| 0,0 → 1,535 |
|---|
| /* |
| * Tiny BASIC Interpreter and Compiler Project |
| * Interpreter module |
| * |
| * Released as Public Domain by Damian Gareth Walker 2019 |
| * Created: 23-Aug-2019 |
| */ |
| |
| |
| /* included headers */ |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include "interpret.h" |
| #include "errors.h" |
| #include "options.h" |
| #include "statement.h" |
| |
| |
| /* forward declarations */ |
| static int interpret_expression (ExpressionNode *expression); |
| static void interpret_statement (StatementNode *statement); |
| |
| |
| /* |
| * Data Definitions |
| */ |
| |
| /* The GOSUB Stack */ |
| typedef struct gosub_stack_node GosubStackNode; |
| typedef struct gosub_stack_node { |
| ProgramLineNode *program_line; /* the line following the GOSUB */ |
| GosubStackNode *next; /* stack node for the previous GOSUB */ |
| } GosubStackNode; |
| |
| /* private data */ |
| typedef struct interpreter_data { |
| ProgramNode *program; /* the program to interpret */ |
| ProgramLineNode *line; /* current line we're executing */ |
| GosubStackNode *gosub_stack; /* the top of the GOSUB stack */ |
| int gosub_stack_size; /* number of entries on the GOSUB stack */ |
| int variables [26]; /* the numeric variables */ |
| int stopped; /* set to 1 when an END is encountered */ |
| ErrorHandler *errors; /* the error handler */ |
| LanguageOptions *options; /* the language options */ |
| } InterpreterData; |
| |
| /* convenience variables */ |
| static Interpreter *this; /* the object we are working with */ |
| |
| |
| /* |
| * Private Methods |
| */ |
| |
| |
| /* |
| * Evaluate a factor for the interpreter |
| * params: |
| * FactorNode* factor the factor to evaluate |
| */ |
| static int interpret_factor (FactorNode *factor) { |
| |
| /* local variables */ |
| int result_store = 0; /* result of factor evaluation */ |
| |
| /* check factor class */ |
| switch (factor->class) { |
| |
| /* a regular variable */ |
| case FACTOR_VARIABLE: |
| result_store = this->priv->variables [factor->data.variable - 1] |
| * (factor->sign == SIGN_POSITIVE ? 1 : -1); |
| break; |
| |
| /* an integer constant */ |
| case FACTOR_VALUE: |
| result_store = factor->data.value |
| * (factor->sign == SIGN_POSITIVE ? 1 : -1); |
| break; |
| |
| /* an expression */ |
| case FACTOR_EXPRESSION: |
| result_store = interpret_expression (factor->data.expression) |
| * (factor->sign == SIGN_POSITIVE ? 1 : -1); |
| break; |
| |
| /* this only happens if the parser has failed in its duty */ |
| default: |
| this->priv->errors->set_code |
| (this->priv->errors, E_INVALID_EXPRESSION, 0, this->priv->line->label); |
| } |
| |
| /* check the result and return it*/ |
| if (result_store < -32768 || result_store > 32767) |
| this->priv->errors->set_code |
| (this->priv->errors, E_OVERFLOW, 0, this->priv->line->label); |
| return result_store; |
| } |
| |
| /* |
| * Evaluate a term for the interpreter |
| * params: |
| * TermNode* term the term to evaluate |
| */ |
| static int interpret_term (TermNode *term) { |
| |
| /* local variables */ |
| int result_store; /* the partial evaluation */ |
| RightHandFactor *rhfactor; /* pointer to successive rh factor nodes */ |
| int divisor; /* used to check for division by 0 before attempting */ |
| |
| /* calculate the first factor result */ |
| result_store = interpret_factor (term->factor); |
| rhfactor = term->next; |
| |
| /* adjust store according to successive rh factors */ |
| while (rhfactor && ! this->priv->errors->get_code (this->priv->errors)) { |
| switch (rhfactor->op) { |
| case TERM_OPERATOR_MULTIPLY: |
| result_store *= interpret_factor (rhfactor->factor); |
| if (result_store < -32768 || result_store > 32767) |
| this->priv->errors->set_code |
| (this->priv->errors, E_OVERFLOW, 0, this->priv->line->label); |
| break; |
| case TERM_OPERATOR_DIVIDE: |
| if ((divisor = interpret_factor (rhfactor->factor))) |
| result_store /= divisor; |
| else |
| this->priv->errors->set_code |
| (this->priv->errors, E_DIVIDE_BY_ZERO, 0, this->priv->line->label); |
| break; |
| default: |
| break; |
| } |
| rhfactor = rhfactor->next; |
| } |
| |
| /* return the result */ |
| return result_store; |
| } |
| |
| /* |
| * Evaluate an expression for the interpreter |
| * params: |
| * ExpressionNode* expression the expression to evaluate |
| */ |
| static int interpret_expression (ExpressionNode *expression) { |
| |
| /* local variables */ |
| int result_store; /* the partial evaluation */ |
| RightHandTerm *rhterm; /* pointer to successive rh term nodes */ |
| |
| /* calculate the first term result */ |
| result_store = interpret_term (expression->term); |
| rhterm = expression->next; |
| |
| /* adjust store according to successive rh terms */ |
| while (rhterm && ! this->priv->errors->get_code (this->priv->errors)) { |
| switch (rhterm->op) { |
| case EXPRESSION_OPERATOR_PLUS: |
| result_store += interpret_term (rhterm->term); |
| if (result_store < -32768 || result_store > 32767) |
| this->priv->errors->set_code |
| (this->priv->errors, E_OVERFLOW, 0, this->priv->line->label); |
| break; |
| case EXPRESSION_OPERATOR_MINUS: |
| result_store -= interpret_term (rhterm->term); |
| if (result_store < -32768 || result_store > 32767) |
| this->priv->errors->set_code |
| (this->priv->errors, E_OVERFLOW, 0, this->priv->line->label); |
| break; |
| default: |
| break; |
| } |
| rhterm = rhterm->next; |
| } |
| |
| /* return the result */ |
| return result_store; |
| } |
| |
| /* |
| * Find a program line given its label |
| * returns: |
| * ProgramLineNode* the program line found |
| */ |
| static ProgramLineNode *find_label (int jump_label) { |
| |
| /* local variables */ |
| ProgramLineNode |
| *ptr, /* a line we're currently looking at */ |
| *found = NULL; /* the line if found */ |
| |
| /* do the search */ |
| for (ptr = this->priv->program->first; ptr && ! found; ptr = ptr->next) |
| if (ptr->label == jump_label) |
| found = ptr; |
| else if (ptr->label >= jump_label |
| && this->priv->options->get_line_numbers (this->priv->options) |
| != LINE_NUMBERS_OPTIONAL) |
| found = ptr; |
| |
| /* check for errors and return what was found */ |
| if (! found) |
| this->priv->errors->set_code |
| (this->priv->errors, E_INVALID_LINE_NUMBER, 0, this->priv->line->label); |
| return found; |
| } |
| |
| |
| /* |
| * Level 1 Routines |
| */ |
| |
| |
| /* |
| * Initialise the variables |
| */ |
| static void initialise_variables (void) { |
| int count; /* counter for this->priv->variables */ |
| for (count = 0; count < 26; ++count) { |
| this->priv->variables [count] = 0; |
| } |
| } |
| |
| /* |
| * Interpret a LET statement |
| * params: |
| * LetStatementNode* letn the LET statement details |
| */ |
| void interpret_let_statement (LetStatementNode *letn) { |
| this->priv->variables [letn->variable - 1] |
| = interpret_expression (letn->expression); |
| this->priv->line = this->priv->line->next; |
| } |
| |
| /* |
| * Interpret an IF statement |
| * params: |
| * IfStatementNode* ifn the IF statement details |
| */ |
| void interpret_if_statement (IfStatementNode *ifn) { |
| |
| /* local variables */ |
| int |
| left, /* result of the left-hand expression */ |
| right, /* result of the right-hand expression */ |
| comparison; /* result of the comparison between the two */ |
| |
| /* get the expressions */ |
| left = interpret_expression (ifn->left); |
| right = interpret_expression (ifn->right); |
| |
| /* make the comparison */ |
| switch (ifn->op) { |
| case RELOP_EQUAL: comparison = (left == right); break; |
| case RELOP_UNEQUAL: comparison = (left != right); break; |
| case RELOP_LESSTHAN: comparison = (left < right); break; |
| case RELOP_LESSOREQUAL: comparison = (left <= right); break; |
| case RELOP_GREATERTHAN: comparison = (left > right); break; |
| case RELOP_GREATEROREQUAL: comparison = (left >= right); break; |
| } |
| |
| /* perform the conditional statement */ |
| if (comparison && ! this->priv->errors->get_code (this->priv->errors)) |
| interpret_statement (ifn->statement); |
| else |
| this->priv->line = this->priv->line->next; |
| } |
| |
| /* |
| * Interpret a GOTO statement |
| * params: |
| * GotoStatementNode* goton the GOTO statement details |
| */ |
| void interpret_goto_statement (GotoStatementNode *goton) { |
| int label; /* the line label to go to */ |
| label = interpret_expression (goton->label); |
| if (! this->priv->errors->get_code (this->priv->errors)) |
| this->priv->line = find_label (label); |
| } |
| |
| /* |
| * Interpret a GOSUB statement |
| * params: |
| * GosubStatementNode* gosubn the GOSUB statement details |
| */ |
| void interpret_gosub_statement (GosubStatementNode *gosubn) { |
| |
| /* local variables */ |
| GosubStackNode *gosub_node; /* indicates the program line to return to */ |
| int label; /* the line label to go to */ |
| |
| /* create the new node on the GOSUB stack */ |
| if (this->priv->gosub_stack_size < this->priv->options->get_gosub_limit |
| (this->priv->options)) { |
| gosub_node = malloc (sizeof (GosubStackNode)); |
| gosub_node->program_line = this->priv->line->next; |
| gosub_node->next = this->priv->gosub_stack; |
| this->priv->gosub_stack = gosub_node; |
| ++this->priv->gosub_stack_size; |
| } else |
| this->priv->errors->set_code (this->priv->errors, |
| E_TOO_MANY_GOSUBS, 0, this->priv->line->label); |
| |
| /* branch to the subroutine requested */ |
| if (! this->priv->errors->get_code (this->priv->errors)) |
| label = interpret_expression (gosubn->label); |
| if (! this->priv->errors->get_code (this->priv->errors)) |
| this->priv->line = find_label (label); |
| } |
| |
| /* |
| * Interpret a RETURN statement |
| */ |
| void interpret_return_statement (void) { |
| |
| /* local variables */ |
| GosubStackNode *gosub_node; /* node popped off the GOSUB stack */ |
| |
| /* return to the statement following the most recent GOSUB */ |
| if (this->priv->gosub_stack) { |
| this->priv->line = this->priv->gosub_stack->program_line; |
| gosub_node = this->priv->gosub_stack; |
| this->priv->gosub_stack = this->priv->gosub_stack->next; |
| free (gosub_node); |
| --this->priv->gosub_stack_size; |
| } |
| |
| /* no GOSUBs led here, so raise an error */ |
| else |
| this->priv->errors->set_code |
| (this->priv->errors, E_RETURN_WITHOUT_GOSUB, 0, this->priv->line->label); |
| } |
| |
| /* |
| * Interpret a PRINT statement |
| * params: |
| * PrintStatementNode* printn the PRINT statement details |
| */ |
| void interpret_print_statement (PrintStatementNode *printn) { |
| |
| /* local variables */ |
| OutputNode *outn; /* current output node */ |
| int |
| items = 0, /* counter ensures runtime errors appear on a new line */ |
| result; /* the result of an expression */ |
| |
| /* print each of the output items */ |
| outn = printn->first; |
| while (outn) { |
| switch (outn->class) { |
| case OUTPUT_STRING: |
| printf ("%s", outn->output.string); |
| ++items; |
| break; |
| case OUTPUT_EXPRESSION: |
| result = interpret_expression (outn->output.expression); |
| if (! this->priv->errors->get_code (this->priv->errors)) { |
| printf ("%d", result); |
| ++items; |
| } |
| break; |
| } |
| outn = outn->next; |
| } |
| |
| /* print the linefeed */ |
| if (items) |
| printf ("\n"); |
| this->priv->line = this->priv->line->next; |
| } |
| |
| /* |
| * Interpret an INPUT statement |
| * params: |
| * InputStatementNode* inputn the INPUT statement details |
| */ |
| void interpret_input_statement (InputStatementNode *inputn) { |
| |
| /* local variables */ |
| VariableListNode *variable; /* current variable to input */ |
| int |
| value, /* value input from the user */ |
| sign = 1, /* the default sign */ |
| ch = 0; /* character from the input stream */ |
| |
| /* input each of the variables */ |
| variable = inputn->first; |
| while (variable) { |
| do { |
| if (ch == '-') sign = -1; else sign = 1; |
| ch = getchar (); |
| } while (ch < '0' || ch > '9'); |
| value = 0; |
| do { |
| value = 10 * value + (ch - '0'); |
| if (value * sign < -32768 || value * sign > 32767) |
| this->priv->errors->set_code |
| (this->priv->errors, E_OVERFLOW, 0, this->priv->line->label); |
| ch = getchar (); |
| } while (ch >= '0' && ch <= '9' |
| && ! this->priv->errors->get_code (this->priv->errors)); |
| this->priv->variables [variable->variable - 1] = sign * value; |
| variable = variable->next; |
| } |
| |
| /* advance to the next statement when done */ |
| this->priv->line = this->priv->line->next; |
| } |
| |
| |
| /* |
| * Interpret an individual statement |
| * params: |
| * StatementNode* statement the statement to interpret |
| */ |
| void interpret_statement (StatementNode *statement) { |
| |
| /* skip comments */ |
| if (! statement) { |
| this->priv->line = this->priv->line->next; |
| return; |
| } |
| |
| /* interpret real statements */ |
| switch (statement->class) { |
| case STATEMENT_NONE: |
| break; |
| case STATEMENT_LET: |
| interpret_let_statement (statement->statement.letn); |
| break; |
| case STATEMENT_IF: |
| interpret_if_statement (statement->statement.ifn); |
| break; |
| case STATEMENT_GOTO: |
| interpret_goto_statement (statement->statement.goton); |
| break; |
| case STATEMENT_GOSUB: |
| interpret_gosub_statement (statement->statement.gosubn); |
| break; |
| case STATEMENT_RETURN: |
| interpret_return_statement (); |
| break; |
| case STATEMENT_END: |
| this->priv->stopped = 1; |
| break; |
| case STATEMENT_PRINT: |
| interpret_print_statement (statement->statement.printn); |
| break; |
| case STATEMENT_INPUT: |
| interpret_input_statement (statement->statement.inputn); |
| break; |
| default: |
| printf ("Statement type %d not implemented.\n", statement->class); |
| } |
| } |
| |
| /* |
| * Interpret program starting from a particular line |
| * params: |
| * ProgramLineNode* program_line the starting line |
| */ |
| static void interpret_program_from (ProgramLineNode *program_line) { |
| this->priv->line = program_line; |
| while (this->priv->line |
| && ! this->priv->stopped |
| && ! this->priv->errors->get_code (this->priv->errors)) |
| interpret_statement (this->priv->line->statement); |
| } |
| |
| |
| /* |
| * Public Methods |
| */ |
| |
| |
| /* |
| * Interpret the program from the beginning |
| * params: |
| * Interpreter* interpreter the interpreter to use |
| * ProgramNode* program the program to interpret |
| */ |
| static void interpret (Interpreter *interpreter, ProgramNode *program) { |
| this = interpreter; |
| this->priv->program = program; |
| initialise_variables (); |
| interpret_program_from (this->priv->program->first); |
| } |
| |
| /* |
| * Destroy the interpreter |
| * params: |
| * Interpreter* interpreter the doomed interpreter |
| */ |
| static void destroy (Interpreter *interpreter) { |
| if (interpreter) { |
| if (interpreter->priv) |
| free (interpreter->priv); |
| free (interpreter); |
| } |
| } |
| |
| |
| /* |
| * Constructors |
| */ |
| |
| |
| /* |
| * Constructor |
| * returns: |
| * Interpreter* the new interpreter |
| */ |
| Interpreter *new_Interpreter (ErrorHandler *errors, LanguageOptions *options) { |
| |
| /* allocate memory */ |
| this = malloc (sizeof (Interpreter)); |
| this->priv = malloc (sizeof (InterpreterData)); |
| |
| /* initialise methods */ |
| this->interpret = interpret; |
| this->destroy = destroy; |
| |
| /* initialise properties */ |
| this->priv->gosub_stack = NULL; |
| this->priv->gosub_stack_size = 0; |
| this->priv->stopped = 0; |
| this->priv->errors = errors; |
| this->priv->options = options; |
| |
| /* return the new object */ |
| return this; |
| } |