From 96393257a43ac52f2b911594d106741245dec5f0 Mon Sep 17 00:00:00 2001 From: mrb0nk500 Date: Fri, 4 Dec 2020 15:20:28 -0500 Subject: - Started work on writing the new version of the assembler. - Did alot of stuff in the emulator. - Did alot of stuff in the SuB Suite. --- lexer/backup/lexer.c | 937 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 937 insertions(+) create mode 100644 lexer/backup/lexer.c (limited to 'lexer/backup/lexer.c') diff --git a/lexer/backup/lexer.c b/lexer/backup/lexer.c new file mode 100644 index 0000000..1654f44 --- /dev/null +++ b/lexer/backup/lexer.c @@ -0,0 +1,937 @@ +#include "asmmon.h" +#include "lexer.h" + +uint8_t lex_type; +uint16_t sym_count = 0; +token *tokens = NULL; +token *last_tok = NULL; +symbol *locals = NULL; +symbol *last_loc = NULL; +symbol *cur_sym = NULL; +symbol *struct_sym = NULL; + +line *tmp_line = NULL; + +symbol *mksymbol(const char *name, uint64_t val, uint8_t def, uint8_t islocal, uint8_t useid, uint16_t id, uint8_t dbg) { + uint16_t i = 0; + symbol *s = (!islocal) ? symbols : locals; + uint8_t flag = 0; + for (; s; s = s->next, i++) { + if (!useid && name[0] != s->name[0]) { + continue; + } + flag = (useid) ? (id == s->id) : !strcmp(name, s->name); + if (flag) { + if (def) { + if (s->def) { + if (dbg) { + printf("mksymbol(): oof, you cannot redefine the symbol: %s\n", name); + } + defined = 1; + } else { + defined = 0; + } + s->def = def; + s->val = val; + s->id = i; + if (dbg) { + printf("mksymbol(): def: %u, val: $%016"PRIX64", name: %s\n", def, val, name); + printf("mksymbol(): i: $%X, id: $%04X\n", i, s->id); + } + } + return s; + } + } + size_t str_size = strlen(name)+1; + s = malloc(sizeof(symbol)); + s->down = NULL; + if (!islocal) { + (last_sym) ? (last_sym->next = s) : (symbols = s); + if (last_sym) { + last_sym->next->prev = last_sym; + last_sym->next->up = last_sym->up; + last_sym->next->down = NULL; + } else { + symbols->prev = NULL; + symbols->up = NULL; + symbols->down = NULL; + } + } else { + (last_loc) ? (last_loc->next = s) : (locals = s); + if (last_loc) { + last_loc->next->prev = last_loc; + last_loc->next->up = last_loc->up; + last_loc->next->down = NULL; + } else { + locals->prev = NULL; + locals->down = NULL; + } + } + s->name = malloc(str_size); + s->def = def; + s->val = val; + s->count = 0; + s->isstruct = 0; + memcpy(s->name, name, str_size); + s->next = NULL; + s->id = sym_count++; + (!islocal) ? (last_sym = s) : (last_loc = s); + if (!islocal) { + s->down = NULL; + /*if (def) { + locals = NULL; + last_loc = NULL; + }*/ + } else { + cur_sym->count++; + } + defined = 0; + if (dbg) { + printf("mksymbol(): def: %u, val: $%016"PRIX64", name: %s, id: $%04X\n", def, val, name, sym_count-1); + } + return s; +} + +uint16_t fixup_cnt = 0; +symbol *get_sym(const char *name, uint64_t val, token *t, uint8_t islocal, uint8_t dbg) { + symbol *s = mksymbol(name, 0, 0, islocal, 0, 0, dbg); + if (dbg) { + printf("get_sym(): Symbol ID: $%X.\n", s->id); + } + if (s->def) { + return s; + } else { + if (dbg) { + printf("get_sym(): oof, symbol %s, does not exist, yet.\n", name); + } + fixup *f = malloc(sizeof(fixup)); + (last_fix) ? (last_fix->next = f) : (fixups = f); + f->adr = val; + f->t = t; + f->s = s; + f->next = NULL; + last_fix = f; + fixup_cnt++; + return NULL; + } +} + +symbol *find_member(char *name, symbol* root, uint8_t dbg) { + /*for (; root->up; root = root->up);*/ + symbol *s = root; + if (s->down == NULL && s->up != NULL) { + s = s->up; + } + do { + s = s->down; + for (symbol *m = s; m; m = m->next) { + size_t len1 = strlen(name); + size_t len2 = strlen(m->name); + if (len1 == len2 && name[0] == m->name[0] && !strcmp(name, m->name)) { + return m; + } + } + for (; s->next && !s->down; s = s->next); + } while (s->down); + return NULL; +} + +uint16_t reslv_fixups(uint8_t dbg) { + fixup *f = fixups; + symbol *ls; + uint16_t i = 0, j = 0; + for (; f; f = f->next) { + if (f->s->def) { + if (dbg) { + printf("reslv_fixups(): Symbol ID: $%X, Symbol Name: %s, Symbol Value: $%"PRIX64".\n", f->s->id, f->s->name, f->s->val); + } + f->t->sym = f->s; + } else { + if (dbg) { + printf("reslv_fixups(): oof, undefined reference to '%s', at $%016"PRIX64".\n", f->s->name, f->adr); + } + i++; + } + } + return i; + +} + +uint16_t get_comment(const char *com, uint8_t dbg) { + uint16_t i = 0; + for (; comment[i] && i < comidx; i++) { + if (com[0] == comment[i][0] && !strcmp(com, comment[i])) { + break; + } + } + if (comment[i] == NULL) { + if (dbg) { + printf("get_comment(): oof, the index $%04X is NULL.\n", i); + printf("get_comment(): oof, the comment \"%s\", was not found in the comment table.\n", com); + } + size_t size = strlen(com)+1; + comment[comidx] = malloc(size); + memcpy(comment[comidx], com, size); + return comidx++; + + } + if (dbg) { + if (strcmp(com, comment[i])) { + printf("get_comment(): oof, the comment \"%s\" is somehow not in the comment table, even though it should be at index $%04X.\n", com, i); + } + printf("get_comment(): The return value of strcmp(com, comment[$%04X]) is %i.\n", i, strcmp(com, comment[i])); + printf("get_comment(): Found comment \"%s\", in the table, at index $%04X.\n", com, i); + } + return i; +} + +uint16_t get_string(const char *str, uint8_t dbg) { + uint16_t i = 0; + uint8_t isstr = 0; + for (; i < stridx; i++) { + if (isstr || string[i] == NULL) { + break; + } else if (str[0] == string[i][0]) { + isstr = !strcmp(str, string[i]); + } + } + if (string[i] == NULL || i == stridx) { + if (dbg) { + printf("get_string(): oof, the index $%04X is NULL.\n", i); + printf("get_string(): oof, the string \"%s\", was not found in the string table.\n", str); + } + return 0xFFFF; + } + if (dbg) { + printf("get_string(): Found string \"%s\", in the table, at index $%04X.\n", str, i); + } + return i; +} + +line *find_line(uint32_t ln, uint8_t dbg) { + uint32_t i = 0; + line *l = lines; + for (; l && l->linenum != ln; l = l->next); + if (l != NULL) { + if (l->linenum == ln) { + if (dbg) { + printf("find_line(): Found line number %u.\n", ln); + } + return l; + } + } else { + if (dbg) { + printf("find_line(): oof, could not find line number %u.\n", ln); + } + return NULL; + } + return l; +} + +int is_struct = 0; +int is_anon = 0; + +void create_struct(symbol *c_sym, line *l, token *t, token *lt, char *name, uint8_t dbg) { + uint8_t ismember = !(is_struct == 1 && lt && lt->id == TOK_DIR); + mksymbol(name, 0, 1, ismember, 0, 0, dbg); + if (isfixup) { + isfixup = reslv_fixups(dbg); + } + t->sym = get_sym(name, 0, t, ismember, dbg); + if (lt && lt->id == TOK_DIR) { + t->sym->isstruct = 1; + t->id = (lt->type == DIR_STRUCT) ? TOK_STRUCT : TOK_UNION; + tmp_line = l; + } else { + t->id = TOK_MEMBER; + t->sym->isanon = (is_anon > 0); + } + isfixup += (t->sym == NULL); + int is_top = (c_sym == NULL); + c_sym = (!ismember && !c_sym) ? last_sym : c_sym; + if (!ismember) { + if (!is_top) { + c_sym = t->sym; + locals = NULL; + last_loc = NULL; + } else { + c_sym->down = locals; + } + } else { + if (lt && lt->id == TOK_DIR) { + if (lt->type == DIR_UNION || lt->type == DIR_STRUCT) { + c_sym->down = locals; + c_sym->down->up = c_sym; + last_loc->up = c_sym; + c_sym = last_loc; + locals = NULL; + last_loc = NULL; + } + } + } + cur_sym = c_sym; +} + +void end_struct(symbol *c_sym, symbol *s_sym, uint8_t dbg) { + int skip = 0; + if (is_anon > 0) { + if ((c_sym && c_sym->isanon) || (c_sym->up && !c_sym->up->isanon) || (c_sym && s_sym->isanon)) { + is_anon--; + } else if (is_struct <= 0) { + is_anon = 0; + } + skip = (!is_anon); + } + if (((is_struct-is_anon) > 0 && !skip) || (is_anon <= 0 && is_struct <= 0)) { + symbol *s; + for (s = locals; s; s = s->next) { + if (s->up == NULL) { + s->up = c_sym; + } + if (dbg) { + printf("s: %p, s->up: %p, c_sym: %p, last_loc: %p\n", s, s->up, c_sym, last_loc); + } + } + if (c_sym->down == NULL) { + c_sym->down = locals; + } + } + if ((is_anon <= 0 || is_struct <= 0)) { + for (s_sym = c_sym; s_sym->prev && !s_sym->isanon; s_sym = s_sym->prev); + struct_sym = s_sym; + } + if ((is_struct-is_anon) > 0 && !skip) { + symbol *s = c_sym; + for (; s->prev; s = s->prev) { + if (s->up == NULL && c_sym->up) { + s->up = c_sym->up; + } + if (dbg) { + printf("s: %p, s->up: %p, c_sym->up: %p, last_loc: %p\n", s, s->up, c_sym->up, last_loc); + } + } + if (c_sym->up) { + cur_sym = c_sym->up; + } + for (locals = locals->up; locals->prev; locals = locals->prev); + for (last_loc = locals; last_loc->next; last_loc = last_loc->next); + } +} + +uint64_t lex(char *str, uint64_t address, uint16_t bline, uint8_t dbg) { + char sym[0x100]; + uint16_t i = 0; + uint16_t j = 0; + uint16_t comid = 0; + uint16_t strid = 0; + uint16_t symid = 0; + uint64_t value = 0; + lex_type = 0xFF; + + uint8_t k = 0; + uint8_t k2 = 0; + union reg ch; + ch.u64 = 0; + uint8_t rs = 0; + uint8_t of = 0; + uint8_t base = 0; + + uint8_t islocal = 0; + + uint8_t isop = 0; + int num = 0; + int isch = 0; + uint8_t isesc = 0; + uint8_t islinenum; + + int16_t ln = -1; + + char lnum[6]; + + uint8_t space = 0; + uint8_t tab = 0; + uint8_t fall = 0; + uint8_t done = 0; + + + /*uint8_t is_newcom = 0;*/ + line *l = NULL; + token *st = NULL; + token *t = NULL; + token *lt = NULL; + symbol *tmp_sym = NULL; + symbol *tsym = NULL; + + while (isdigit(str[i]) && isdelm(str[i], dbg) != 16) { + lnum[j++] = str[i++]; + } + islinenum = i; + if (i) { + lnum[j] = '\0'; + ln = strtol(lnum, NULL, 10); + j = 0; + l = find_line(ln, dbg); + } else { + ln = linenum; + l = NULL; + } + if (l) { + address = l->addr; + } else { + l = malloc(sizeof(line)); + (last_line) ? (last_line->next = l) : (lines = l); + l->tok = NULL; + l->next = NULL; + l->count = 0; + l->bline = bline; + last_line = l; + + } + l->addr = address; + while (isdelm(str[i], dbg) != 1) { + uint8_t offset = 0; + base = 0; + space = 0; + tab = 0; + while (isdelm(str[i+j], dbg) == 16) { + tab += str[i+j] == '\t'; + space += str[i+j] == ' '; + j++; + } + j = 0; + if (dbg) { + printf("lex(): tab: %u, space: %u\n", tab, space); + } + if (isdelm(str[i], dbg) == 16) { + for (; isdelm(str[i], dbg) == 16; i++); + } + uint8_t ptok = get_ptok(str[i], dbg); + if (is_altok(ptok, dbg)) { + offset++; + if (((ptok == PTOK_S || ptok == PTOK_B) && toupper(str[i+1]) == 'P') || (ptok == PTOK_P && toupper(str[i+1]) == 'C')) { + offset++; + } + switch (get_ptok(str[i+offset], dbg)) { + case PTOK_B : + case PTOK_E : + case PTOK_X : + case PTOK_Y : + case PTOK_S : + case PTOK_P : + case PTOK_A : + case PTOK_C : + case PTOK_D : + case PTOK_F : + case PTOK_R : + case PTOK_ALPHA : ptok = PTOK_ALPHA; break; + case PTOK_NUMBER: + if (ptok == PTOK_R) { + char reg_num[3]; + for (int isnum = 0; isdigit(str[i+offset]) && !(isdelm(str[i+offset], dbg) & 0x03) && isnum < 2; offset++, isnum++) { + reg_num[isnum] = str[i+offset]; + } + reg_num[isnum] = '\0'; + if (isnum == 2) { + int regnum = strtoul(reg_num, NULL, 10); + ptok = (regnum < 11 || regnum > 15) ? PTOK_ALPHA : ptok; + } else { + ptok = PTOK_ALPHA; + } + } else { + ptok = PTOK_ALPHA; + } + break; + } + if ((ptok == PTOK_S && str[i+1] && toupper(str[i+1]) != 'P') || (ptok == PTOK_P && toupper(str[i+1]) != 'C')) { + ptok = PTOK_ALPHA; + } + } + /*i = ptok_handler[ptok](str, i, lex_type, l, t, dbg);*/ + switch (ptok) { + case PTOK_DOT: + i++; + for (; !(isdelm(str[i+j], dbg) & 17); j++); + memcpy(lexeme, str+i, j); + lexeme[j] = '\0'; + i += j; + if (!isop) { + for (k = 0; k < 11; k++) { + if (tolower(lexeme[0]) == dir_t[k][0] && !strcasecmp(lexeme, dir_t[k])) { + lex_type = TOK_DIR; + uint16_t tmp = j; + for (j = 0; isdelm(str[i+j], dbg) & 16; j++); + uint8_t ret = get_ptok(str[i+j], dbg); + j = tmp; + + if ((k == DIR_STRUCT || k == DIR_UNION) && (ret != PTOK_ALPHA || (is_anon && ret == PTOK_ALPHA))) { + is_anon++; + } + is_struct += (k == DIR_STRUCT || k == DIR_UNION); + is_struct -= (k == DIR_ENDSTRUCT || k == DIR_ENDUNION); + if ((k == DIR_ENDSTRUCT || k == DIR_ENDUNION)) { + end_struct(cur_sym, struct_sym, dbg); + } + break; + } + } + if (lex_type != TOK_DIR && lt && lt->id == TOK_SYM) { + lex_type = TOK_MEMBER; + i -= j; + } else { + l->count++; + t = make_token(lex_type, k, space, tab, 0, "", NULL); + } + } else { + lex_type = TOK_RS; + switch (tolower(lexeme[j-1])) { + case '2': + case 'w': + rs = 1; + break; + case '4': + case 'd': + rs = 2; + break; + case '8': + case 'q': + rs = 3; + break; + } + l->count++; + t = make_token(lex_type, rs, space, tab, 0, "", NULL); + isop = 0; + } + break; + case PTOK_DQUOTE: + i++; + for (; isdelm(str[i+j], dbg) != 4 || isesc; j++) { + isesc = (str[i+j] == '\\' && str[i+(j-1)] != '\\'); + } + memcpy(lexeme, str+i, j); + lexeme[j] = '\0'; + i += j; + strid = get_string(lexeme, dbg); + if (strid == 0xFFFF) { + strid = stridx; + string[strid] = malloc(j+1); + memcpy(string[strid], lexeme, j+1); + stridx++; + } else { + } + if (dbg) { + printf("lex(): str[0x%04X]: %s\n", strid, string[strid]); + } + if (lt->id == TOK_DIR && lt->type == DIR_INCLUDE) { + incl[inc_count+inc_file] = strid; + inc_file++; + } + lex_type = TOK_STRING; + l->count++; + t = make_token(lex_type, 0, space, tab, 0, string[strid], NULL); + break; + case PTOK_DOLLAR: + case PTOK_PERCENT: + case PTOK_NUMBER: + value = 0; + switch (ptok) { + case PTOK_DOLLAR : base = 16; lex_type = TOK_HEX; i++; break; + case PTOK_PERCENT: base = 2; lex_type = TOK_BIN; i++; break; + case PTOK_NUMBER : base = 10; lex_type = TOK_DEC; /**/ break; + } + for (; isxdigit(str[i+j]) && !(isdelm(str[i+j], dbg) & 0x03); j++); + memcpy(lexeme, str+i, j); + lexeme[j] = '\0'; + i += j; + value = strtoull(lexeme, NULL, base); + if (lt->id == TOK_SYM) { + tsym = mksymbol(sym, value, 1, islocal, 0, 0, dbg); + if (lt) { + lt->sym = get_sym(sym, address, lt, islocal, dbg); + } + if (!islocal) { + cur_sym = last_sym; + } + tsym = NULL; + islocal = 0; + isfixup += (lt->sym == NULL); + if (dbg) { + printf("lex(): isfixup: %u\n", isfixup); + } + } + l->count++; + t = make_token(lex_type, 0, space, tab, value, "", NULL); + t->digits = (lt->id != TOK_SYM) ? j : 0; + break; + case PTOK_SQUOTE: + i++; + k = 0; + j = 0; + while (isdelm(str[i], dbg) != 8 || isesc) { + isesc = (str[i] == '\\' && str[i-1] != '\\'); + lexeme[j++] = str[i++]; + } + isesc = 0; + lexeme[j] = '\0'; + for (j = 0; lexeme[k] != '\0' && j < 7; k++) { + switch (lexeme[k]) { + case '\\': + switch (lexeme[++k]) { + case 'n' : ch.u8[j++] = '\n'; break; + case 'r' : ch.u8[j++] = '\r'; break; + case 't' : ch.u8[j++] = '\t'; break; + case 'b' : ch.u8[j++] = '\b'; break; + case '\'': ch.u8[j++] = '\''; break; + case '\"': ch.u8[j++] = '\"'; break; + case '\\': ch.u8[j++] = '\\'; break; + } + break; + default: ch.u8[j++] = lexeme[k]; + } + } + lex_type = TOK_CHAR; + l->count++; + t = make_token(lex_type, 0, space, tab, ch.u64, "", NULL); + break; + case PTOK_LBRACK: + case PTOK_HASH : + /*l->tok->type = (ptok == PTOK_LBRACK) ? IND : IMM; + lex_type = (ptok == PTOK_LBRACK) ? TOK_IND : TOK_IMM;*/ + lex_type = TOK_MEM; + value = (ptok == PTOK_LBRACK) ? MEM_IND : MEM_IMM; + l->count++; + t = make_token(lex_type, value, space, tab, 0, "", NULL); + lex_type = (ptok == PTOK_LBRACK) ? TOK_IND : TOK_IMM; + memset(lexeme, 0, strlen(lexeme)+1); + lexeme[j++] = str[i]; + /*(t) ? (t->subspace = space) : (lt->subspace = space); + (t) ? (t->subtab = tab) : (lt->subtab = tab);*/ + break; + case PTOK_PLUS: + case PTOK_MINUS: + case PTOK_GT: + case PTOK_LT: + case PTOK_PIPE: + lex_type = TOK_EXPR; + switch (ptok) { + case PTOK_PLUS : value = EXPR_PLUS ; break; + case PTOK_MINUS: value = EXPR_MINUS; break; + case PTOK_PIPE : value = EXPR_OR ; break; + case PTOK_GT : value = (get_ptok(str[i+1], dbg) == PTOK_GT) ? (EXPR_RSHFT) : (EXPR_LOW) ; break; + case PTOK_LT : value = (get_ptok(str[i+1], dbg) == PTOK_LT) ? (EXPR_LSHFT) : (EXPR_HIGH); break; + } + l->count++; + t = make_token(lex_type, value, space, tab, 0, "", NULL); + memset(lexeme, 0, strlen(lexeme)+1); + lexeme[j++] = str[i]; + if (value == EXPR_LSHFT || value == EXPR_RSHFT) { + lexeme[j++] = str[++i]; + } + break; + case PTOK_EQU: + i++; + lex_type = TOK_SYM; + memset(lexeme, 0, strlen(lexeme)+1); + lexeme[j] = str[i]; + (t) ? (t->subspace = space) : (lt->subspace = space); + (t) ? (t->subtab = tab) : (lt->subtab = tab); + break; + case PTOK_RBRACK: + i++; + lex_type = TOK_IND; + lexeme[j] = ')'; + lexeme[j+1] = '\0'; + lexeme[j+2] = '\0'; + (t) ? (t->subspace = space) : (lt->subspace = space); + (t) ? (t->subtab = tab) : (lt->subtab = tab); + break; + case PTOK_COMMA: + i++; + if (lex_type != TOK_IND && lex_type != TOK_OF) { + lex_type = TOK_CSV; + } + lexeme[j] = ','; + lexeme[j+1] = '\0'; + lexeme[j+2] = '\0'; + break; + case PTOK_B: + case PTOK_E: + case PTOK_X: + case PTOK_Y: + case PTOK_S: + case PTOK_A: + case PTOK_C: + case PTOK_D: + case PTOK_F: + case PTOK_R: + lexeme[j+0] = str[i++]; + lexeme[j+1] = (ptok == PTOK_R || ((ptok == PTOK_S || ptok == PTOK_B) && get_ptok(str[i], dbg) == PTOK_P)) ? str[i++] : '\0'; + lexeme[j+2] = (ptok == PTOK_R) ? str[i++] : '\0'; + lexeme[j+3] = '\0'; + lex_type = TOK_REG; + switch (ptok) { + case PTOK_A: value = REG_A; break; + case PTOK_X: value = REG_X; break; + case PTOK_Y: value = REG_Y; break; + case PTOK_E: value = REG_E; break; + case PTOK_C: value = REG_C; break; + case PTOK_D: value = REG_D; break; + case PTOK_S: + case PTOK_B: + if (get_ptok(lexeme[j+1], dbg) == PTOK_P) { + value = (ptok == PTOK_S) ? REG_SP : REG_BP; + } else { + value = (ptok == PTOK_S) ? REG_S : REG_B; + } + break; + case PTOK_F: value = REG_F; break; + case PTOK_R: value = strtoull(lexeme+j+1, NULL, 10); break; + } + l->count++; + t = make_token(lex_type, value, space, tab, 0, "", NULL); + /*(t) ? (t->subspace = space) : (lt->subspace = space); + (t) ? (t->subtab = tab) : (lt->subtab = tab);*/ + break; + case PTOK_P: + lexeme[j] = str[i++]; + lexeme[j+1] = (str[i] != ',') ? str[i++] : '\0'; + lexeme[j+2] = '\0'; + /*switch (ptok) { + case PTOK_S: of = 1; break; + case PTOK_P: of = 2; break; + }*/ + of = 2; + lex_type = TOK_OF; + l->count++; + t = make_token(lex_type, of, space, tab, 0, "", NULL); + break; + case PTOK_AT: + memset(lexeme, 0, strlen(lexeme)+1); + lexeme[j] = '@'; + islocal = 1; + lex_type = TOK_LOCAL; + if (lt || t) { + (t) ? (t->subspace = space) : (lt->subspace = space); + (t) ? (t->subtab = tab) : (lt->subtab = tab); + } + break; + case PTOK_COLON: + i++; + lexeme[j] = ':'; + lexeme[j+1] = '\0'; + lex_type = TOK_LABEL; + tsym = mksymbol(sym, address, 1, islocal, 0, 0, dbg); + if (isfixup) { + isfixup = reslv_fixups(dbg); + } + if (lt) { + lt->id = lex_type; + lt->type = islocal; + lt->sym = get_sym(sym, address, t, islocal, dbg); + isfixup += (lt->sym == NULL); + } + if (!islocal) { + cur_sym = last_sym; + locals = NULL; + last_loc = NULL; + } else if (cur_sym->down == NULL && cur_sym == last_sym) { + cur_sym->down = locals; + cur_sym->down->up = cur_sym; + } + tsym = NULL; + islocal = 0; + if (dbg) { + printf("lex(): isfixup: %u\n", isfixup); + } + break; + case PTOK_SCOLON: + i++; + for (; isdelm(str[i+j], dbg) != 1; j++); + if (!j) { + lexeme[j] = ' '; + lexeme[j+1] = '\0'; + + } else { + memcpy(lexeme, str+i, j); + lexeme[j] = '\0'; + i += j; + comid = get_comment(lexeme, dbg); + /*is_newcom = (comid == 0xFFFF); + if (comid == 0xFFFF) { + if (line != lineidx && l[line].com != 0xFFFF) { + comid = l[line].com; + } else { + comid = comidx; + } + comid = comidx; + comment[comid] = malloc(j+1); + memcpy(comment[comid], lexeme, j+1); + comidx++; + }*/ + if (dbg) { + printf("lex(): com[0x%04X]: %s\n", comid, comment[comid]); + } + } + lex_type = TOK_COMMENT; + l->count++; + if (j) { + t = make_token(lex_type, 0, space, tab, 0, comment[comid], NULL); + } else { + t = make_token(lex_type, 0, space, tab, 0, "" , NULL); + } + + break; + case PTOK_ALPHA: + for (; !isdelm2(str[i+j], dbg); j++); + memcpy(lexeme, str+i, j); + lexeme[j] = '\0'; + i += j; + isch = 0; + isop = 0; + if (j == 3 && str[i] != ':' && !is_struct) { + for (k = 0; k < OPNUM; k++) { + int find_ext = (k < EXT_OPNUM); + int find_ortho = (k < ORTHO_OPNUM); + int upper = toupper(lexeme[0]); + int isbase = (upper == mne[k][0]); + int isext = (find_ext && upper == ext_mne[k][0]); + int isortho = (find_ortho && upper == ortho_mne[k][0]); + + if (isbase || isext || isortho) { + int is_base = !strcasecmp(lexeme, mne[k]); + int is_ext = (find_ext && !strcasecmp(lexeme, ext_mne[k])); + int is_ortho = (find_ortho && !strcasecmp(lexeme, ortho_mne[k])); + if (is_base || is_ext || is_ortho) { + lex_type = (is_base) ? TOK_OPCODE : lex_type; + lex_type = (is_ext) ? TOK_EXTOP : lex_type; + lex_type = (is_ortho) ? TOK_ORTHO : lex_type; + isop = 1; + l->count++; + t = make_token(lex_type, 0xFF, space, tab, k, "", NULL); + break; + } + } + } + } + if (!isop) { + uint8_t spaces = 0; + if (l->tok->type == TOK_ORTHO && l->tok->byte == SET) { + for (k = 0; k < 8; k++) { + int upper = toupper(lexeme[0]); + if (upper == set_cc[k][0]) { + if (!strcasecmp(lexeme, set_cc[k])) { + lex_type = TOK_CC; + l->count++; + t = make_token(lex_type, 0xFF, space, tab, k, "", NULL); + } + } + } + } + for (; isdelm(str[i+spaces], dbg) == 16; spaces++); + uint8_t ret = get_ptok(str[i+spaces], dbg); + if (ret == PTOK_COLON || ret == PTOK_EQU) { + islocal = (lex_type == TOK_LOCAL); + } + lex_type = TOK_SYM; + l->count++; + t = make_token(lex_type, islocal, space, tab, 0, "", NULL); + memcpy(sym, lexeme, j+1); + if (dbg) { + printf("lex(): spaces: %u\n", spaces); + } + if (is_struct) { + create_struct(cur_sym, l, t, lt, sym, dbg); + islocal = 0; + } else if ((str[i+spaces] != ':' && str[i+spaces] != '=')) { + uint8_t sym_struct = 0; + symbol *s; + /*tmp_sym = (s && s->isstruct) ? NULL : tmp_sym;*/ + if (tmp_sym) { + t->sym = find_member(lexeme, tmp_sym, dbg); + tmp_sym = NULL; + } else { + t->sym = get_sym(lexeme, address, t, islocal, dbg); + } + isfixup += (t && t->sym == NULL); + islocal = 0; + if (dbg) { + printf("lex(): isfixup: %u\n", isfixup); + } + } + if (!is_struct && t && t->sym && t->sym->isstruct) { + tmp_sym = t->sym; + } + } + break; + } + if (!l->tok && t) { + l->tok = tokens; + } + if (dbg) { + printf("lex(): lexeme: %s, lex_type: %s\n", lexeme, (lex_type != 0xFF) ? lex_tok[lex_type] : "TOK_NONE"); + } + j = 0; + if ((lex_type == TOK_OPCODE || lex_type == TOK_EXTOP) && !isop) { + j = 0; + } else if (lex_type == TOK_EXPR || (lex_type != TOK_MEMBER && !isdelm2(str[i], dbg))) { + i++; + } + switch (lex_type) { + default: + lex_type = 0xFF; + case TOK_CSV: + case TOK_IND: + case TOK_LOCAL: + memset(lexeme, 0, strlen(lexeme)+1); + case TOK_SYM: + break; + } + if (t) { + lt = t; + t = t->next; + } + } + if (i) { + l->tok = tokens; + token *tok = tokens; + if (tok->id == TOK_SYM && tok->next) { + symbol *s = tok->sym; + for (; tok; tok = tok->next) { + switch (tok->id) { + case TOK_HEX : + case TOK_BIN : + case TOK_DEC : + case TOK_CHAR: + case TOK_EXPR: + s->val = get_val(tok, address, 3, dbg); + if (tok->next) { + tok = skip_expr(tok, dbg); + } + break; + } + } + } + tokens = NULL; + last_tok = NULL; + bytecount dummy; + if (!is_struct) { + l = (tmp_line) ? tmp_line : l; + address = parse_tokens(l->tok, &l, &dummy, 0, address, dbg); + if (tmp_line) { + tmp_line = NULL; + } + } + if (dbg) { + printf("lex(): Next address: $%"PRIX64"\n", address); + } + if (ln > linenum || islinenum) { + l->linenum = ln; + if (ln > linenum) { + linenum+=(10+(ln & 10)); + } + } else if (!islinenum) { + l->linenum = linenum; + linenum += 10; + } + } + return address; +} -- cgit v1.2.3-13-gbd6f