diff --git a/test-string.bas b/test-string.bas index c27018e..00e54e6 100644 --- a/test-string.bas +++ b/test-string.bas @@ -1 +1,26 @@ -1 print "start of test" 2 a$= "abcdefghi" 3 b$="123456789" 5 print "Length of a$+", len(a$) 6 print "Length of b$=", len(b$) 7 if len(a$) = len(b$) then print "same length" 8 if (a$ = b$) then print "same string" 9 c$=left$(a$+ b$,12) 10 print c$ 11 c$=right$(a$+b$, 12) 12 print c$ 13 c$=mid$(a$+b$, 8,8) 14 print c$ 15 c$=str$(13+42) 16 print c$ 17 print len(c$) 18 print len("this" + "that") 19 c$ = chr$(34) 20 print c$ 21 j = asc(c$) 22 print j 23 print val("12345") 24 i=instr(3, "123456789", "67") 24 print "position of '67' in '123456789' is", i 25 print mid$(a$,2,2)+"xyx" 30 print "end of test" \ No newline at end of file +1 print "start of test" +2 a$= "abcdefghi" +3 b$="123456789" +5 print "Length of a$+", len(a$) +6 print "Length of b$=", len(b$) +7 if len(a$) = len(b$) then print "same length" +8 if (a$ = b$) then print "same string" +9 c$=left$(a$+ b$,12) +10 print c$ +11 c$=right$(a$+b$, 12) +12 print c$ +13 c$=mid$(a$+b$, 8,8) +14 print c$ +15 c$=str$(13+42) +16 print c$ +17 print len(c$) +18 print len("this" + "that") +19 c$ = chr$(34) +20 print c$ +21 j = asc(c$) +22 print j +23 print val("12345") +24 i=instr(3, "123456789", "67") +24 print "position of '67' in '123456789' is", i +25 print mid$(a$,2,2)+"xyx" +30 print "end of test" diff --git a/tokenizer.c b/tokenizer.c index 02fbe29..5ccceb7 100644 --- a/tokenizer.c +++ b/tokenizer.c @@ -28,7 +28,9 @@ * */ -#define DEBUG 0 +#define DEBUG 1 +#define VERBOSE 1 + #if DEBUG #define DEBUG_PRINTF(...) printf(__VA_ARGS__) @@ -41,7 +43,7 @@ #include #include -static char const *ptr, *nextptr; +static char const *ptr, *nextptr, *startptr; static char const *prog; @@ -74,13 +76,50 @@ static const struct keyword_token keywords[] = { {NULL, TOKENIZER_ERROR} }; +static const struct keyword_token tokens[] = { + {"TOKENIZER_ERROR",TOKENIZER_ERROR}, + {"TOKENIZER_ENDOFINPUT",TOKENIZER_ENDOFINPUT}, + {"TOKENIZER_NUMBER",TOKENIZER_NUMBER}, + {"TOKENIZER_STRING",TOKENIZER_STRING}, + {"TOKENIZER_VARIABLE",TOKENIZER_VARIABLE}, + {"TOKENIZER_LET",TOKENIZER_LET}, + {"TOKENIZER_PRINT",TOKENIZER_PRINT}, + {"TOKENIZER_IF",TOKENIZER_IF}, + {"TOKENIZER_THEN",TOKENIZER_THEN}, + {"TOKENIZER_ELSE",TOKENIZER_ELSE}, + {"TOKENIZER_FOR",TOKENIZER_FOR}, + {"TOKENIZER_TO",TOKENIZER_TO}, + {"TOKENIZER_NEXT",TOKENIZER_NEXT}, + {"TOKENIZER_GOTO",TOKENIZER_GOTO}, + {"TOKENIZER_GOSUB",TOKENIZER_GOSUB}, + {"TOKENIZER_RETURN",TOKENIZER_RETURN}, + {"TOKENIZER_CALL",TOKENIZER_CALL}, + {"TOKENIZER_REM",TOKENIZER_REM}, + {"TOKENIZER_PEEK",TOKENIZER_PEEK}, + {"TOKENIZER_POKE",TOKENIZER_POKE}, + {"TOKENIZER_END",TOKENIZER_END}, + {"TOKENIZER_COMMA",TOKENIZER_COMMA}, + {"TOKENIZER_SEMICOLON",TOKENIZER_SEMICOLON}, + {"TOKENIZER_PLUS",TOKENIZER_PLUS}, + {"TOKENIZER_MINUS",TOKENIZER_MINUS}, + {"TOKENIZER_AND",TOKENIZER_AND}, + {"TOKENIZER_OR",TOKENIZER_OR}, + {"TOKENIZER_ASTR",TOKENIZER_ASTR}, + {"TOKENIZER_SLASH",TOKENIZER_SLASH}, + {"TOKENIZER_MOD",TOKENIZER_MOD}, + {"TOKENIZER_HASH",TOKENIZER_HASH}, + {"TOKENIZER_LEFTPAREN",TOKENIZER_LEFTPAREN}, + {"TOKENIZER_RIGHTPAREN",TOKENIZER_RIGHTPAREN}, + {"TOKENIZER_LT",TOKENIZER_LT}, + {"TOKENIZER_GT",TOKENIZER_GT}, + {"TOKENIZER_EQ",TOKENIZER_EQ}, + {"TOKENIZER_LF",TOKENIZER_LF}, + {"TOKENIZER_CR",TOKENIZER_CR} +}; + /*---------------------------------------------------------------------------*/ -static int -singlechar(void) -{ +static int singlechar(void){ if(*ptr == '\n') { - return TOKENIZER_CR; - } else if(*ptr == '\r'){ return TOKENIZER_LF; } else if(*ptr == ',') { return TOKENIZER_COMMA; @@ -116,13 +155,11 @@ singlechar(void) return 0; } /*---------------------------------------------------------------------------*/ -static int -get_next_token(void) -{ +static int get_next_token(void){ struct keyword_token const *kt; int i; - DEBUG_PRINTF("get_next_token(): '%s'\n", ptr); + DEBUG_PRINTF("get_next_token: %p.\n", ptr-startptr); // eat all whitespace while(*ptr == ' ' || *ptr == '\t' || *ptr == '\r') ptr++; @@ -138,16 +175,16 @@ get_next_token(void) nextptr = ptr + i; return TOKENIZER_NUMBER; } else { - DEBUG_PRINTF("get_next_token: error due to too short number\n"); + DEBUG_PRINTF("get_next_token: error due to too short number.\n"); return TOKENIZER_ERROR; } } if(!isdigit(ptr[i])) { - DEBUG_PRINTF("get_next_token: error due to malformed number\n"); + DEBUG_PRINTF("get_next_token: error due to malformed number.\n"); return TOKENIZER_ERROR; } } - DEBUG_PRINTF("get_next_token: error due to too long number\n"); + DEBUG_PRINTF("get_next_token: error due to too long number.\n"); return TOKENIZER_ERROR; } else if(singlechar()) { nextptr = ptr + 1; @@ -173,21 +210,18 @@ get_next_token(void) return TOKENIZER_VARIABLE; } - return TOKENIZER_ERROR; } /*---------------------------------------------------------------------------*/ -void tokenizer_goto(const char *program) -{ +void tokenizer_goto(const char *program){ ptr = program; current_token = get_next_token(); } /*---------------------------------------------------------------------------*/ -void -tokenizer_init(const char *program) -{ +void tokenizer_init(const char *program){ ptr = program; prog = program; + startptr = program; current_token = get_next_token(); } /*---------------------------------------------------------------------------*/ @@ -197,15 +231,13 @@ tokenizer_token(void) return current_token; } /*---------------------------------------------------------------------------*/ -void -tokenizer_next(void) -{ +void tokenizer_next(void){ if(tokenizer_finished()) { return; } - DEBUG_PRINTF("tokenizer_next: %p\n", nextptr); + DEBUG_PRINTF("tokenizer_next: %p.\n", nextptr - startptr); ptr = nextptr; while(*ptr == ' ') { @@ -223,7 +255,7 @@ tokenizer_next(void) tokenizer_next(); } - DEBUG_PRINTF("tokenizer_next: '%s' %d\n", ptr, current_token); + DEBUG_PRINTF("tokenizer_next: %p %s.\n", ptr-startptr, tokenizer_token_name(current_token)); return; } /*---------------------------------------------------------------------------*/ @@ -233,9 +265,7 @@ tokenizer_num(void) return atoi(ptr); } /*---------------------------------------------------------------------------*/ -void -tokenizer_string(char *dest, int len) -{ +void tokenizer_string(char *dest, int len){ char *string_end; int string_len; @@ -257,7 +287,7 @@ tokenizer_string(char *dest, int len) void tokenizer_error_print(void) { - DEBUG_PRINTF("tokenizer_error_print: '%s'\n", ptr); + DEBUG_PRINTF("tokenizer_error_print: %p.\n", ptr-startptr); } /*---------------------------------------------------------------------------*/ int @@ -272,8 +302,26 @@ tokenizer_variable_num(void) return *ptr - 'a'; } /*---------------------------------------------------------------------------*/ -char const * -tokenizer_pos(void) -{ +char const *tokenizer_pos(void){ return ptr; } + +char const *tokenizer_start(void) { + return startptr; +} + +//char* tokenizer_token_name(int token){ +// struct keyword_token kt; +// kt = keywords[token]; +// char* name = kt.keyword; +// return(name); +//} + +char *tokenizer_token_name(int token) { + for (int i = 0; tokens[i].keyword != NULL; i++) { + if (tokens[i].token == token) { + return tokens[i].keyword; // return string + } + } + return NULL; // not found +} \ No newline at end of file diff --git a/tokenizer.h b/tokenizer.h index f6b494d..32cfa9b 100644 --- a/tokenizer.h +++ b/tokenizer.h @@ -33,12 +33,12 @@ #include "vartype.h" enum { - TOKENIZER_ERROR, - TOKENIZER_ENDOFINPUT, - TOKENIZER_NUMBER, - TOKENIZER_STRING, - TOKENIZER_VARIABLE, - TOKENIZER_LET, + TOKENIZER_ERROR, // 0 + TOKENIZER_ENDOFINPUT, // 1 + TOKENIZER_NUMBER, // 2 + TOKENIZER_STRING, // 3 + TOKENIZER_VARIABLE, // 4 + TOKENIZER_LET, // 5 TOKENIZER_PRINT, TOKENIZER_IF, TOKENIZER_THEN, @@ -69,8 +69,8 @@ enum { TOKENIZER_LT, TOKENIZER_GT, TOKENIZER_EQ, - TOKENIZER_CR, - TOKENIZER_LF + TOKENIZER_LF, + TOKENIZER_CR }; void tokenizer_goto(const char *program); @@ -85,5 +85,8 @@ int tokenizer_finished(void); void tokenizer_error_print(void); char const *tokenizer_pos(void); +char const *tokenizer_start(void); + +char *tokenizer_token_name(int token); #endif /* __TOKENIZER_H__ */ diff --git a/ubasic.c b/ubasic.c index 36eade4..ef07e29 100644 --- a/ubasic.c +++ b/ubasic.c @@ -28,7 +28,8 @@ * */ -#define DEBUG 0 +#define DEBUG 1 +#define VERBOSE 0 #if DEBUG #define DEBUG_PRINTF(...) printf(__VA_ARGS__) @@ -82,8 +83,7 @@ poke_func poke_function = NULL; /*---------------------------------------------------------------------------*/ void -ubasic_init(const char *program) -{ +ubasic_init(const char *program){ program_ptr = program; for_stack_ptr = gosub_stack_ptr = 0; index_free(); @@ -91,9 +91,7 @@ ubasic_init(const char *program) ended = 0; } /*---------------------------------------------------------------------------*/ -void -ubasic_init_peek_poke(const char *program, peek_func peek, poke_func poke) -{ +void ubasic_init_peek_poke(const char *program, peek_func peek, poke_func poke){ program_ptr = program; for_stack_ptr = gosub_stack_ptr = 0; index_free(); @@ -103,39 +101,34 @@ ubasic_init_peek_poke(const char *program, peek_func peek, poke_func poke) ended = 0; } /*---------------------------------------------------------------------------*/ -static void -accept(int token) -{ +static void accept(int token){ if(token != tokenizer_token()) { - DEBUG_PRINTF("Token not what was expected (expected %d, got %d)\n", - token, tokenizer_token()); + DEBUG_PRINTF("accept: Token not what was expected (expected '%s', got %d).\n", + tokenizer_token_name(token), + tokenizer_token()); tokenizer_error_print(); exit(1); } - DEBUG_PRINTF("Expected %d, got it\n", token); + DEBUG_PRINTF("accept: Expected '%s', got it.\n", tokenizer_token_name(token)); tokenizer_next(); } /*---------------------------------------------------------------------------*/ -static int -varfactor(void) -{ +static int varfactor(void){ int r; - DEBUG_PRINTF("varfactor: obtaining %d from variable %d\n", variables[tokenizer_variable_num()], tokenizer_variable_num()); + DEBUG_PRINTF("varfactor: obtaining %d from variable %d.\n", variables[tokenizer_variable_num()], tokenizer_variable_num()); r = ubasic_get_variable(tokenizer_variable_num()); accept(TOKENIZER_VARIABLE); return r; } /*---------------------------------------------------------------------------*/ -static int -factor(void) -{ +static int factor(void){ int r; - DEBUG_PRINTF("factor: token %d\n", tokenizer_token()); + DEBUG_PRINTF("factor: token '%s'.\n", tokenizer_token_name(tokenizer_token())); switch(tokenizer_token()) { case TOKENIZER_NUMBER: r = tokenizer_num(); - DEBUG_PRINTF("factor: number %d\n", r); + DEBUG_PRINTF("factor: number %d.\n", r); accept(TOKENIZER_NUMBER); break; case TOKENIZER_LEFTPAREN: @@ -147,24 +140,23 @@ factor(void) r = varfactor(); break; } + DEBUG_PRINTF("term: %d.\n", r); return r; } /*---------------------------------------------------------------------------*/ -static int -term(void) -{ +static int term(void){ int f1, f2; int op; f1 = factor(); op = tokenizer_token(); - DEBUG_PRINTF("term: token %d\n", op); + DEBUG_PRINTF("term: token '%s'.\n", tokenizer_token_name(op)); while(op == TOKENIZER_ASTR || op == TOKENIZER_SLASH || op == TOKENIZER_MOD) { tokenizer_next(); f2 = factor(); - DEBUG_PRINTF("term: %d %d %d\n", f1, op, f2); + DEBUG_PRINTF("term: %d %d %d.\n", f1, op, f2); switch(op) { case TOKENIZER_ASTR: f1 = f1 * f2; @@ -178,26 +170,25 @@ term(void) } op = tokenizer_token(); } - DEBUG_PRINTF("term: %d\n", f1); + DEBUG_PRINTF("term: factor=%d.\n", f1); return f1; } /*---------------------------------------------------------------------------*/ -static VARIABLE_TYPE -expr(void) +static VARIABLE_TYPE expr(void) { int t1, t2; int op; t1 = term(); op = tokenizer_token(); - DEBUG_PRINTF("expr: token %d\n", op); + DEBUG_PRINTF("expr: token %s.\n", tokenizer_token_name(op)); while(op == TOKENIZER_PLUS || op == TOKENIZER_MINUS || op == TOKENIZER_AND || op == TOKENIZER_OR) { tokenizer_next(); t2 = term(); - DEBUG_PRINTF("expr: %d %d %d\n", t1, op, t2); + DEBUG_PRINTF("expr: %d %d %d.\n", t1, op, t2); switch(op) { case TOKENIZER_PLUS: t1 = t1 + t2; @@ -214,25 +205,23 @@ expr(void) } op = tokenizer_token(); } - DEBUG_PRINTF("expr: %d\n", t1); + DEBUG_PRINTF("expr: term=%d.\n", t1); return t1; } /*---------------------------------------------------------------------------*/ -static int -relation(void) -{ +static int relation(void){ int r1, r2; int op; r1 = expr(); op = tokenizer_token(); - DEBUG_PRINTF("relation: token %d\n", op); + DEBUG_PRINTF("relation: token %d.\n", op); while(op == TOKENIZER_LT || op == TOKENIZER_GT || op == TOKENIZER_EQ) { tokenizer_next(); r2 = expr(); - DEBUG_PRINTF("relation: %d %d %d\n", r1, op, r2); + DEBUG_PRINTF("relation: %d %d %d.\n", r1, op, r2); switch(op) { case TOKENIZER_LT: r1 = r1 < r2; @@ -246,15 +235,15 @@ relation(void) } op = tokenizer_token(); } + DEBUG_PRINTF("relation: expr=%d.\n", r1); return r1; } /*---------------------------------------------------------------------------*/ -static void -index_free(void) { +static void index_free(void) { if(line_index_head != NULL) { line_index_current = line_index_head; do { - DEBUG_PRINTF("Freeing index for line %d.\n", line_index_current); + DEBUG_PRINTF("Freeing index for line %d.\n", line_index_current->line_number); line_index_head = line_index_current; line_index_current = line_index_current->next; free(line_index_head); @@ -263,8 +252,7 @@ index_free(void) { } } /*---------------------------------------------------------------------------*/ -static char const* -index_find(int linenum) { +static char const* index_find(int linenum) { struct line_index *lidx; lidx = line_index_head; @@ -276,24 +264,30 @@ index_find(int linenum) { lidx = lidx->next; #if DEBUG + #if VERBOSE if(lidx != NULL) { - DEBUG_PRINTF("index_find: Step %3d. Found index for line %d: %d.\n", - step, lidx->line_number, - lidx->program_text_position); + DEBUG_PRINTF("index_find: Step %3d. Found index for line %d: %p.\n", + step, + lidx->line_number, + lidx->program_text_position - tokenizer_start()); } step++; + #endif #endif } if(lidx != NULL && lidx->line_number == linenum) { + #if DEBUG + #if VERBOSE DEBUG_PRINTF("index_find: Returning index for line %d.\n", linenum); + #endif + #endif return lidx->program_text_position; } DEBUG_PRINTF("index_find: Returning NULL.\n", linenum); return NULL; } /*---------------------------------------------------------------------------*/ -static void -index_add(int linenum, char const* sourcepos) { +static void index_add(int linenum, char const* sourcepos) { if(line_index_head != NULL && index_find(linenum)) { return; } @@ -312,30 +306,32 @@ index_add(int linenum, char const* sourcepos) { line_index_current = new_lidx; line_index_head = line_index_current; } - DEBUG_PRINTF("index_add: Adding index for line %d: %d.\n", linenum, - sourcepos); + //DEBUG_PRINTF("index_add: Adding index for line %d: %p.\n", linenum, + // sourcepos - tokenizer_start()); } /*---------------------------------------------------------------------------*/ -static void -jump_linenum_slow(int linenum) +static void jump_linenum_slow(int linenum) { tokenizer_init(program_ptr); while(tokenizer_num() != linenum) { do { do { tokenizer_next(); - } while(tokenizer_token() != TOKENIZER_CR && + } while(tokenizer_token() != TOKENIZER_LF && tokenizer_token() != TOKENIZER_ENDOFINPUT); - if(tokenizer_token() == TOKENIZER_CR) { + if(tokenizer_token() == TOKENIZER_LF) { tokenizer_next(); } } while(tokenizer_token() != TOKENIZER_NUMBER); - DEBUG_PRINTF("jump_linenum_slow: Found line %d\n", tokenizer_num()); + #if DEBUG + #if VERBOSE + DEBUG_PRINTF("jump_linenum_slow: Found line %d.\n", tokenizer_num()); + #endif + #endif } } /*---------------------------------------------------------------------------*/ -static void -jump_linenum(int linenum) +static void jump_linenum(int linenum) { char const* pos = index_find(linenum); if(pos != NULL) { @@ -343,24 +339,22 @@ jump_linenum(int linenum) tokenizer_goto(pos); } else { /* We'll try to find a yet-unindexed line to jump to. */ - DEBUG_PRINTF("jump_linenum: Calling jump_linenum_slow.\n", linenum); + DEBUG_PRINTF("jump_linenum: Calling jump_linenum_slow for line %d.\n", linenum); jump_linenum_slow(linenum); } } /*---------------------------------------------------------------------------*/ -static void -goto_statement(void) +static void goto_statement(void) { accept(TOKENIZER_GOTO); jump_linenum(tokenizer_num()); } /*---------------------------------------------------------------------------*/ -static void -print_statement(void) +static void print_statement(void) { accept(TOKENIZER_PRINT); + DEBUG_PRINTF("print_statement: Loop.\n"); do { - DEBUG_PRINTF("Print loop\n"); if(tokenizer_token() == TOKENIZER_STRING) { tokenizer_string(string, sizeof(string)); printf("%s", string); @@ -373,25 +367,24 @@ print_statement(void) } else if(tokenizer_token() == TOKENIZER_VARIABLE || tokenizer_token() == TOKENIZER_NUMBER) { printf("%d", expr()); + } else if (tokenizer_token() == TOKENIZER_CR){ + tokenizer_next(); } else { break; } - } while(tokenizer_token() != TOKENIZER_CR && + } while(tokenizer_token() != TOKENIZER_LF && tokenizer_token() != TOKENIZER_ENDOFINPUT); - printf("\n"); - DEBUG_PRINTF("End of print\n"); + DEBUG_PRINTF("print_statement: End of print.\n"); tokenizer_next(); } /*---------------------------------------------------------------------------*/ -static void -if_statement(void) -{ +static void if_statement(void){ int r; accept(TOKENIZER_IF); r = relation(); - DEBUG_PRINTF("if_statement: relation %d\n", r); + DEBUG_PRINTF("if_statement: relation %d.\n", r); accept(TOKENIZER_THEN); if(r) { statement(); @@ -399,20 +392,18 @@ if_statement(void) do { tokenizer_next(); } while(tokenizer_token() != TOKENIZER_ELSE && - tokenizer_token() != TOKENIZER_CR && + tokenizer_token() != TOKENIZER_LF && tokenizer_token() != TOKENIZER_ENDOFINPUT); if(tokenizer_token() == TOKENIZER_ELSE) { tokenizer_next(); statement(); - } else if(tokenizer_token() == TOKENIZER_CR) { + } else if(tokenizer_token() == TOKENIZER_LF) { tokenizer_next(); } } } /*---------------------------------------------------------------------------*/ -static void -let_statement(void) -{ +static void let_statement(void){ int var; var = tokenizer_variable_num(); @@ -420,43 +411,37 @@ let_statement(void) accept(TOKENIZER_VARIABLE); accept(TOKENIZER_EQ); ubasic_set_variable(var, expr()); - DEBUG_PRINTF("let_statement: assign %d to %d\n", variables[var], var); - accept(TOKENIZER_CR); + DEBUG_PRINTF("let_statement: assign %d to %d.\n", variables[var], var); + accept(TOKENIZER_LF); } /*---------------------------------------------------------------------------*/ -static void -gosub_statement(void) -{ +static void gosub_statement(void){ int linenum; accept(TOKENIZER_GOSUB); linenum = tokenizer_num(); accept(TOKENIZER_NUMBER); - accept(TOKENIZER_CR); + accept(TOKENIZER_LF); if(gosub_stack_ptr < MAX_GOSUB_STACK_DEPTH) { gosub_stack[gosub_stack_ptr] = tokenizer_num(); gosub_stack_ptr++; jump_linenum(linenum); } else { - DEBUG_PRINTF("gosub_statement: gosub stack exhausted\n"); + DEBUG_PRINTF("gosub_statement: gosub stack exhausted.\n"); } } /*---------------------------------------------------------------------------*/ -static void -return_statement(void) -{ +static void return_statement(void){ accept(TOKENIZER_RETURN); if(gosub_stack_ptr > 0) { gosub_stack_ptr--; jump_linenum(gosub_stack[gosub_stack_ptr]); } else { - DEBUG_PRINTF("return_statement: non-matching return\n"); + DEBUG_PRINTF("return_statement: non-matching return.\n"); } } /*---------------------------------------------------------------------------*/ -static void -next_statement(void) -{ +static void next_statement(void){ int var; accept(TOKENIZER_NEXT); @@ -470,18 +455,16 @@ next_statement(void) jump_linenum(for_stack[for_stack_ptr - 1].line_after_for); } else { for_stack_ptr--; - accept(TOKENIZER_CR); + accept(TOKENIZER_LF); } } else { - DEBUG_PRINTF("next_statement: non-matching next (expected %d, found %d)\n", for_stack[for_stack_ptr - 1].for_variable, var); - accept(TOKENIZER_CR); + DEBUG_PRINTF("next_statement: non-matching next (expected %d, found %d).\n", for_stack[for_stack_ptr - 1].for_variable, var); + accept(TOKENIZER_LF); } } /*---------------------------------------------------------------------------*/ -static void -for_statement(void) -{ +static void for_statement(void) { int for_variable, to; accept(TOKENIZER_FOR); @@ -491,25 +474,23 @@ for_statement(void) ubasic_set_variable(for_variable, expr()); accept(TOKENIZER_TO); to = expr(); - accept(TOKENIZER_CR); + accept(TOKENIZER_LF); if(for_stack_ptr < MAX_FOR_STACK_DEPTH) { for_stack[for_stack_ptr].line_after_for = tokenizer_num(); for_stack[for_stack_ptr].for_variable = for_variable; for_stack[for_stack_ptr].to = to; - DEBUG_PRINTF("for_statement: new for, var %d to %d\n", + DEBUG_PRINTF("for_statement: new for, var %d to %d.\n", for_stack[for_stack_ptr].for_variable, for_stack[for_stack_ptr].to); for_stack_ptr++; } else { - DEBUG_PRINTF("for_statement: for stack depth exceeded\n"); + DEBUG_PRINTF("for_statement: for stack depth exceeded.\n"); } } /*---------------------------------------------------------------------------*/ -static void -peek_statement(void) -{ +static void peek_statement(void){ VARIABLE_TYPE peek_addr; int var; @@ -518,13 +499,12 @@ peek_statement(void) accept(TOKENIZER_COMMA); var = tokenizer_variable_num(); accept(TOKENIZER_VARIABLE); - accept(TOKENIZER_CR); + accept(TOKENIZER_LF); ubasic_set_variable(var, peek_function(peek_addr)); } /*---------------------------------------------------------------------------*/ -static void -poke_statement(void) +static void poke_statement(void) { VARIABLE_TYPE poke_addr; VARIABLE_TYPE value; @@ -533,21 +513,18 @@ poke_statement(void) poke_addr = expr(); accept(TOKENIZER_COMMA); value = expr(); - accept(TOKENIZER_CR); + accept(TOKENIZER_LF); poke_function(poke_addr, value); } /*---------------------------------------------------------------------------*/ -static void -end_statement(void) +static void end_statement(void) { accept(TOKENIZER_END); ended = 1; } /*---------------------------------------------------------------------------*/ -static void -statement(void) -{ +static void statement(void){ int token; token = tokenizer_token(); @@ -590,14 +567,12 @@ statement(void) let_statement(); break; default: - DEBUG_PRINTF("ubasic.c: statement(): not implemented %d\n", token); + DEBUG_PRINTF("statement: not implemented %d.\n", token); exit(1); } } /*---------------------------------------------------------------------------*/ -static void -line_statement(void) -{ +static void line_statement(void){ DEBUG_PRINTF("----------- Line number %d ---------\n", tokenizer_num()); index_add(tokenizer_num(), tokenizer_pos()); accept(TOKENIZER_NUMBER); @@ -605,11 +580,9 @@ line_statement(void) return; } /*---------------------------------------------------------------------------*/ -void -ubasic_run(void) -{ +void ubasic_run(void){ if(tokenizer_finished()) { - DEBUG_PRINTF("uBASIC program finished\n"); + DEBUG_PRINTF("ubasic_run: Program finished.\n"); return; } @@ -617,22 +590,17 @@ ubasic_run(void) } /*---------------------------------------------------------------------------*/ int -ubasic_finished(void) -{ +ubasic_finished(void){ return ended || tokenizer_finished(); } /*---------------------------------------------------------------------------*/ -void -ubasic_set_variable(int varnum, VARIABLE_TYPE value) -{ +void ubasic_set_variable(int varnum, VARIABLE_TYPE value){ if(varnum >= 0 && varnum <= MAX_VARNUM) { variables[varnum] = value; } } /*---------------------------------------------------------------------------*/ -VARIABLE_TYPE -ubasic_get_variable(int varnum) -{ +VARIABLE_TYPE ubasic_get_variable(int varnum){ if(varnum >= 0 && varnum <= MAX_VARNUM) { return variables[varnum]; }