From c865e86b8e8cb214d576e6c760b8c62efdf09bad Mon Sep 17 00:00:00 2001 From: Danyil Bohdan Date: Sat, 21 Dec 2013 22:43:47 +0200 Subject: [PATCH] Fixed assignment to 'a'. Added tests and VARIABLE_TYPE. The VARIABLE_TYPE defines what type uBASIC's variables are. --- Makefile | 1 + tests.c | 87 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ubasic.c | 59 +++++++++++++++++++------------------- ubasic.h | 2 ++ 4 files changed, 119 insertions(+), 30 deletions(-) create mode 100644 tests.c diff --git a/Makefile b/Makefile index 3b69d7f..8434adf 100644 --- a/Makefile +++ b/Makefile @@ -1 +1,2 @@ use-ubasic: use-ubasic.o ubasic.o tokenizer.o +tests: tests.o ubasic.o tokenizer.o diff --git a/tests.c b/tests.c new file mode 100644 index 0000000..0ce7a1e --- /dev/null +++ b/tests.c @@ -0,0 +1,87 @@ +/* + * Copyright (c) 2006, Adam Dunkels + * Copyright (c) 2013, Danyil Bohdan + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the author nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + */ + +#include +#include +#include +#include "ubasic.h" + +static const char program_loop[] = +"10 for i = 0 to 126\n\ +20 for j = 0 to 126\n\ +30 for k = 0 to 10\n\ +37 let a = i * j * k\n\ +40 next k\n\ +50 next j\n\ +60 next i\n\ +70 end\n"; + +static const char program_let[] = +"10 let a = 42\n\ +20 end\n"; + + +/*---------------------------------------------------------------------------*/ +void run(const char program[]) { + static int test_num = 0; + test_num++; + printf("Running test #%u... ", test_num); + fflush(stdout); + + clock_t start_t, end_t; + double delta_t; + + start_t = clock(); + + ubasic_init(program); + + do { + ubasic_run(); + } while(!ubasic_finished()); + + end_t = clock(); + delta_t = (double)(end_t - start_t) / CLOCKS_PER_SEC; + + printf("done. Run time: %.3f\n", delta_t); +} + +/*---------------------------------------------------------------------------*/ +int +main(void) +{ + run(program_let); + assert(ubasic_get_variable(0) == 42); + run(program_loop); + assert(ubasic_get_variable(0) == (VARIABLE_TYPE)(126 * 126 * 10)); + + return 0; +} +/*---------------------------------------------------------------------------*/ diff --git a/ubasic.c b/ubasic.c index a6e65c4..3f5b8b1 100644 --- a/ubasic.c +++ b/ubasic.c @@ -36,7 +36,6 @@ #define DEBUG_PRINTF(...) #endif - #include "ubasic.h" #include "tokenizer.h" @@ -61,7 +60,7 @@ static struct for_state for_stack[MAX_FOR_STACK_DEPTH]; static int for_stack_ptr; #define MAX_VARNUM 26 -static char variables[MAX_VARNUM]; +static VARIABLE_TYPE variables[MAX_VARNUM]; static int ended; @@ -83,7 +82,7 @@ accept(int token) { if(token != tokenizer_token()) { DEBUG_PRINTF("Token not what was expected (expected %d, got %d)\n", - token, tokenizer_token()); + token, tokenizer_token()); tokenizer_error_print(); exit(1); } @@ -135,8 +134,8 @@ term(void) op = tokenizer_token(); DEBUG_PRINTF("term: token %d\n", op); while(op == TOKENIZER_ASTR || - op == TOKENIZER_SLASH || - op == TOKENIZER_MOD) { + op == TOKENIZER_SLASH || + op == TOKENIZER_MOD) { tokenizer_next(); f2 = factor(); DEBUG_PRINTF("term: %d %d %d\n", f1, op, f2); @@ -162,14 +161,14 @@ expr(void) { int t1, t2; int op; - + t1 = term(); op = tokenizer_token(); DEBUG_PRINTF("expr: token %d\n", op); while(op == TOKENIZER_PLUS || - op == TOKENIZER_MINUS || - op == TOKENIZER_AND || - op == TOKENIZER_OR) { + op == TOKENIZER_MINUS || + op == TOKENIZER_AND || + op == TOKENIZER_OR) { tokenizer_next(); t2 = term(); DEBUG_PRINTF("expr: %d %d %d\n", t1, op, t2); @@ -198,13 +197,13 @@ relation(void) { int r1, r2; int op; - + r1 = expr(); op = tokenizer_token(); DEBUG_PRINTF("relation: token %d\n", op); while(op == TOKENIZER_LT || - op == TOKENIZER_GT || - op == TOKENIZER_EQ) { + op == TOKENIZER_GT || + op == TOKENIZER_EQ) { tokenizer_next(); r2 = expr(); DEBUG_PRINTF("relation: %d %d %d\n", r1, op, r2); @@ -231,11 +230,11 @@ jump_linenum(int linenum) while(tokenizer_num() != linenum) { do { do { - tokenizer_next(); + tokenizer_next(); } while(tokenizer_token() != TOKENIZER_CR && - tokenizer_token() != TOKENIZER_ENDOFINPUT); + tokenizer_token() != TOKENIZER_ENDOFINPUT); if(tokenizer_token() == TOKENIZER_CR) { - tokenizer_next(); + tokenizer_next(); } } while(tokenizer_token() != TOKENIZER_NUMBER); DEBUG_PRINTF("jump_linenum: Found line %d\n", tokenizer_num()); @@ -265,13 +264,13 @@ print_statement(void) } else if(tokenizer_token() == TOKENIZER_SEMICOLON) { tokenizer_next(); } else if(tokenizer_token() == TOKENIZER_VARIABLE || - tokenizer_token() == TOKENIZER_NUMBER) { + tokenizer_token() == TOKENIZER_NUMBER) { printf("%d", expr()); } else { break; } } while(tokenizer_token() != TOKENIZER_CR && - tokenizer_token() != TOKENIZER_ENDOFINPUT); + tokenizer_token() != TOKENIZER_ENDOFINPUT); printf("\n"); DEBUG_PRINTF("End of print\n"); tokenizer_next(); @@ -281,7 +280,7 @@ static void if_statement(void) { int r; - + accept(TOKENIZER_IF); r = relation(); @@ -293,8 +292,8 @@ if_statement(void) do { tokenizer_next(); } while(tokenizer_token() != TOKENIZER_ELSE && - tokenizer_token() != TOKENIZER_CR && - tokenizer_token() != TOKENIZER_ENDOFINPUT); + tokenizer_token() != TOKENIZER_CR && + tokenizer_token() != TOKENIZER_ENDOFINPUT); if(tokenizer_token() == TOKENIZER_ELSE) { tokenizer_next(); statement(); @@ -352,14 +351,14 @@ static void next_statement(void) { int var; - + accept(TOKENIZER_NEXT); var = tokenizer_variable_num(); accept(TOKENIZER_VARIABLE); if(for_stack_ptr > 0 && var == for_stack[for_stack_ptr - 1].for_variable) { ubasic_set_variable(var, - ubasic_get_variable(var) + 1); + ubasic_get_variable(var) + 1); if(ubasic_get_variable(var) <= for_stack[for_stack_ptr - 1].to) { jump_linenum(for_stack[for_stack_ptr - 1].line_after_for); } else { @@ -377,7 +376,7 @@ static void for_statement(void) { int for_variable, to; - + accept(TOKENIZER_FOR); for_variable = tokenizer_variable_num(); accept(TOKENIZER_VARIABLE); @@ -392,9 +391,9 @@ for_statement(void) 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", - for_stack[for_stack_ptr].for_variable, - for_stack[for_stack_ptr].to); - + 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"); @@ -412,9 +411,9 @@ static void statement(void) { int token; - + token = tokenizer_token(); - + switch(token) { case TOKENIZER_PRINT: print_statement(); @@ -482,7 +481,7 @@ ubasic_finished(void) void ubasic_set_variable(int varnum, int value) { - if(varnum > 0 && varnum <= MAX_VARNUM) { + if(varnum >= 0 && varnum <= MAX_VARNUM) { variables[varnum] = value; } } @@ -490,7 +489,7 @@ ubasic_set_variable(int varnum, int value) int ubasic_get_variable(int varnum) { - if(varnum > 0 && varnum <= MAX_VARNUM) { + if(varnum >= 0 && varnum <= MAX_VARNUM) { return variables[varnum]; } return 0; diff --git a/ubasic.h b/ubasic.h index 4ee4e78..eee6ea9 100644 --- a/ubasic.h +++ b/ubasic.h @@ -30,6 +30,8 @@ #ifndef __UBASIC_H__ #define __UBASIC_H__ +#define VARIABLE_TYPE char + void ubasic_init(const char *program); void ubasic_run(void); int ubasic_finished(void);