Token Class Reference

Token type to store token information. More...

#include <token_t.h>

Public Member Functions
void	token_print (Token *token)
	Pretty-print one token, with its source and length. More...
int	token_recognize (Token *t)
	Parse token - test if it's an opcode, a label or a directive. More...
int	token_analyze_instruction (State *s, Token *t)
	analyze instruction token (instruction, addressmode & operand) More...
int	token_compile (State *s, Token *t, char **dataptr)
	compile token into binary data More...
int	token_get_operand (State *s, Token *t)
	parse the operand of the instruction as a number More...

Data Fields
int	binSize
	number of bytes this token will generate More...
enum tokenType	type
	type of this token More...
struct {
enum AddressMode	addressmode
	Address mode of the instruction. More...
int	number
	operand of the instruction More...
Instruction *	inst
	pointer to instruction data More...
int	address
	address of instruction in resulting bytecode More...
}	instr
	instruction data. Not used if token type is not TT_INSTR More...
char	stripped [TOKEN_BUFFER_SIZE]
	stripped text from source file More...
int	len
	length of stripped text More...
struct {
char	fname [TOKEN_SOURCE_FILE_SIZE]
	file name of source file More...
int	lineno
	line in source file More...
}	source
	source of this token More...

Private Member Functions
int	token_link_instruction (State *s, Token *token)
	find and link the instruction entry for a token More...
int	token_get_addressmode (Token *t)
	Determine the address mode of a token. More...

Detailed Description

Token type to store token information.

Definition at line 37 of file token_t.h.

Member Function Documentation

token_analyze_instruction()

int token_analyze_instruction	(	State *	s,
		Token *	t
	)

analyze instruction token (instruction, addressmode & operand)

Returns

0 on success, -1 on error

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;
}

Referenced by pass_one().

token_compile()

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

compile token into binary data

Parameters

dataptr	char** to return data to
s	assembler state
t	token to compile

Returns

the number of bytes in 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;
}

Referenced by concat_bin().

token_get_addressmode()

int token_get_addressmode ( Token *  t )

private

Determine the address mode of a token.

Returns

0 on success and -1 on error

(modifies the token in-place)

Definition at line 109 of file tokenFunc.c.

                                    {
 
    // step 1 - implied
    if (t->len == 3) {
        t->instr.addressmode = ADRM_IMP;
        return 0;
    }
 
 
    // step 2 - acc
    if (t->len == 5 && util_match_char(t->stripped[4], 'a')) {
        t->instr.addressmode = ADRM_ACC;
        return 0;
    }
 
 
    // step 3 - imm
    if (t->stripped[4] == '#') {
        t->instr.addressmode = ADRM_IMM;
        return 0;
    }
 
 
    // step 4 - relative
    if (t->instr.inst->opcs[ADRM_REL] != OPC_INVALID) {
        // this can ONLY be a relative
        t->instr.addressmode = ADRM_REL;
        return 0;
    }
 
 
 
    // step 5,6,7 have a few checks in common
    // so we can avoid code duplication by fatoring that out
 
    int s_x = 0, s_y = 0, s_close = 0, s_sep = 0; // seen x, y, close or coma
 
    for (int i = 0; i < t->len; i++) {
        if (util_match_char(t->stripped[i], 'x') && s_sep)
            s_x = 1;
        if (util_match_char(t->stripped[i], 'y') && s_sep)
            s_y = 1;
        if (t->stripped[i] == ',')
            s_sep = 1;
        if (t->stripped[i] == ')')
            s_close = 1;
    }
 
    // must have a separator if it has an index
    if ((s_x || s_y) && !s_sep)
        return -1;
 
    // can not have both indexes
    if (s_x && s_y)
        return -1;
 
    // end of common chekcs
 
 
    // step 5 - zeropage
    if (t->stripped[4] == '*') {
        // must NOT have a close
        if (s_close)
            return -1;
 
        // no index - normal zpg
        if (!(s_x || s_y)) {
            t->instr.addressmode = ADRM_ZPG;
            return 0;
        }
 
        // Set according to index
        t->instr.addressmode = s_x ? ADRM_ZPG_X : ADRM_ZPG_Y;
        return 0;
    }
 
    // step 6 - indirect
    if (t->stripped[4] == '(') {
        // must have a close )
        if (!s_close)
            return -1;
 
        // no index - normal inderect
        if (!(s_x || s_y)) {
            t->instr.addressmode = ADRM_IND;
            return 0;
        }
 
        // Set according to index
        t->instr.addressmode = s_x ? ADRM_IND_X : ADRM_IND_Y;
        return 0;
    }
 
 
    // step 7 - absolute
    {
        // must not have a close )
        if (s_close)
            return -1;
 
        // no index - normal absolute
        if (!(s_x || s_y)) {
            t->instr.addressmode = ADRM_ABS;
            return 0;
        }
 
        // Set according to index
        t->instr.addressmode = s_x ? ADRM_ABS_X : ADRM_ABS_Y;
        return 0;
    }
 
    return -1;
}

References ADRM_ABS, ADRM_ABS_X, ADRM_ABS_Y, ADRM_ACC, ADRM_IMM, ADRM_IMP, ADRM_IND, ADRM_IND_X, ADRM_IND_Y, ADRM_REL, ADRM_ZPG, ADRM_ZPG_X, ADRM_ZPG_Y, instr, len, OPC_INVALID, stripped, and util_match_char().

Referenced by token_analyze_instruction().

token_get_operand()

int token_get_operand	(	State *	s,
		Token *	t
	)

parse the operand of the instruction as a number

Modifies the token in-places. Does NOT fail if operand is an undefined label!

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;
}

Referenced by pass_one(), and pass_two().

token_link_instruction()

int token_link_instruction ( State *  s, Token *  token  )

private

find and link the instruction entry for a token

Returns

0 on success, -1 on error

Definition at line 30 of file tokenFunc.c.

                                                   {
    token->instr.inst = instruction_find(s->instr, token->stripped);
    if (token->instr.inst == NULL) return -1;
    return 0;
}

References State::instr, instr, Instruction::instruction_find(), and stripped.

Referenced by token_analyze_instruction().

token_print()

void token_print

(

Token *

token

)

Pretty-print one token, with its source and length.

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);
}

Referenced by compile_data(), compile_pad(), pass_one(), pass_two(), read_file(), read_token(), token_analyze_instruction(), token_compile(), token_get_operand(), token_recognize(), and tokenslist_debug_print().

token_recognize()

int token_recognize

(

Token *

t

)

Parse token - test if it's an opcode, a label or a directive.

Parameters

t	token to recognize - will be modified in-place

Returns

0 on success, -1 on error

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;
}

Referenced by tokenslist_recognize().

Field Documentation

binSize

int Token::binSize

number of bytes this token will generate

Definition at line 39 of file token_t.h.

Referenced by compile_data(), compile_pad(), pass_one(), read_token(), token_analyze_instruction(), token_compile(), and token_get_operand().

instr

struct { ... } Token::instr

instruction data. Not used if token type is not TT_INSTR

Referenced by pass_one(), read_token(), token_analyze_instruction(), token_compile(), token_get_addressmode(), token_get_operand(), token_link_instruction(), and token_recognize().

len

int Token::len

length of stripped text

Definition at line 57 of file token_t.h.

Referenced by pass_one(), read_file(), read_token(), token_get_addressmode(), token_print(), and token_recognize().

source

struct { ... } Token::source

source of this token

Referenced by read_file(), and token_print().

stripped

char Token::stripped[TOKEN_BUFFER_SIZE]

stripped text from source file

Definition at line 55 of file token_t.h.

Referenced by compile_data(), compile_pad(), directive_compile(), pass_one(), read_token(), token_get_addressmode(), token_get_operand(), token_link_instruction(), token_print(), and token_recognize().

type

enum tokenType Token::type

type of this token

Definition at line 39 of file token_t.h.

Referenced by pass_one(), token_compile(), token_get_operand(), and token_recognize().

---

The documentation for this class was generated from the following files:

• src/token_t.h
• src/tokenFunc.c
• src/tokenFunc.h