tokenFunc.c File Reference

implement token member methods More...

#include "debugmalloc.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "tokenFunc.h"
#include "util.h"
#include "number.h"
#include "state.h"
#include "logging.h"
#include "directive.h"

Go to the source code of this file.

Functions
void	token_print (Token *token)
int	token_analyze_instruction (State *s, Token *t)
int	token_recognize (Token *t)
int	token_get_operand (State *s, Token *t)
int	token_compile (State *s, Token *t, char **dataptr)

Detailed Description

implement token member methods

See also

tokenFunc.h

Definition in file tokenFunc.c.

Function Documentation

token_analyze_instruction()

int token_analyze_instruction	(	State *	s,
		Token *	t
	)

Definition at line 224 of file tokenFunc.c.

                                                  {
    if (token_link_instruction(s, t) < 0) {
        ERROR("Unknown instruction!\n");
        goto ERR;
    }
    if (token_get_addressmode(t) < 0) {
        ERROR("Can not determine instruction address mode!\n");
        goto ERR;
    }
    if (t->instr.inst->opcs[t->instr.addressmode] == OPC_INVALID) {
        ERROR("Invalid instruction-addressmode combination!\n");
        ERROR("A-mode: %s\n", ADRM_NAMES[t->instr.addressmode]);
        goto ERR;
    }
 
    t->binSize = 1 + ADRM_SIZES[t->instr.addressmode];
 
    return 0;
 
 
ERR:
    token_print(t);
    FAIL("Error while analyzing token: \n");
    return -1;
}

References ADRM_NAMES, ADRM_SIZES, Token::binSize, ERROR, FAIL, Token::instr, OPC_INVALID, Token::token_get_addressmode(), Token::token_link_instruction(), and Token::token_print().

token_compile()

int token_compile	(	State *	s,
		Token *	t,
		char **	dataptr
	)

Definition at line 318 of file tokenFunc.c.

                                                      {
    if (t->type != TT_INSTR) {
        if (t->type == TT_DIRECTIVE) {
            return directive_compile(s, t, dataptr);
        }
        // should NEVER reach this:
        ERROR("Something went terribly wrong!\n");
        ERROR("A LABEL in last pass!\n");
        return -1;
    }
    int size = t->binSize;
    char* data = malloc(size);
    *dataptr = data;
    if (t->instr.addressmode == ADRM_REL) {
        int n = t->instr.number - t->instr.address - 2;
 
        if (-128 > n || 127 < n) {
            ERROR("Relative addressing jump too far!\n");
            printf("Target: $%x, from: $%x (diff: $%x)\n", t->instr.number, t->instr.address, n);
            token_print(t);
            free(data);
            *dataptr = NULL;
            return -1;
        }
        t->instr.number = n;
    }
    data[0] = t->instr.inst->opcs[t->instr.addressmode];
    if (size > 1) {
        data[1] = t->instr.number & 0xff;
    }
    if (size > 2) {
        data[2] = (t->instr.number >> 8) & 0xff;
    }
    return 0;
}

References ADRM_REL, Token::binSize, directive_compile(), ERROR, Token::instr, Token::token_print(), TT_DIRECTIVE, TT_INSTR, and Token::type.

token_get_operand()

int token_get_operand	(	State *	s,
		Token *	t
	)

Definition at line 287 of file tokenFunc.c.

                                          {
    if (t->type != TT_INSTR) return 0;
    if (t->binSize == 1) {
        t->instr.number = 0;
        return 0;
    }
 
    char* begin = &t->stripped[4];
    char* end;
    for (; *begin != 0 && (*begin == ' ' || *begin == '*' || *begin == '(' || *begin == '#'); begin++);
    for (end = begin; *end != 0 && *end != ')' && *end != ',' && *end != ' '; end++);
 
    char* buff = malloc(end - begin + 1);
    strncpy(buff, begin, end - begin + 1);
    buff[end - begin] = 0;
 
    int n = number_get_number(s, buff);
    free(buff);
 
    if (n == NUMBER_ERROR) {
        token_print(t);
        FAIL("Opcode operand parsing failed!\n");
        return -1;
    }
    if (n == NUMBER_LABEL_NODEF) {
        return 0;
    }
    t->instr.number = n;
    return 0;
}

References Token::binSize, FAIL, Token::instr, NUMBER_ERROR, number_get_number(), NUMBER_LABEL_NODEF, Token::stripped, Token::token_print(), TT_INSTR, and Token::type.

token_print()

void token_print

(

Token *

token

)

Definition at line 20 of file tokenFunc.c.

                               {
    printf("\t%s:%d:%d\t\t'%.*s'\n", token->source.fname, token->source.lineno, token->len, token->len, token->stripped);
}

References Token::len, Token::source, and Token::stripped.

token_recognize()

int token_recognize

(

Token *

t

)

Definition at line 251 of file tokenFunc.c.

                              {
    // how many token types does it fit
    int found = 0;
 
    // directive - starts with a dot
    if (t->stripped[0] == '.') {
        t->type = TT_DIRECTIVE;
        found++;
    }
 
    // label - ends with a ':'
    if (t->stripped[t->len - 1] == ':') {
        t->type = TT_LABEL;
        found++;
    }
 
    // instruction - 3rd char is a space or len is 3
    if (t->stripped[3] == ' ' || t->stripped[3] == '\0') {
        t->type = TT_INSTR;
        t->instr.number = -1;
        found++;
    }
 
    // 0 or more than one match is a problem
    if (found != 1) {
        ERROR("Can not recognize token:\n");
        token_print(t);
        return -1;
    }
 
    LOG(4, "Recognized token as %d:\n", t->type);
    LOGDO(4, token_print(t));
 
    return 0;
}

References ERROR, Token::instr, Token::len, LOG, LOGDO, Token::stripped, Token::token_print(), TT_DIRECTIVE, TT_INSTR, TT_LABEL, and Token::type.