//static void let_statement(void) void let_statement(void) { long var; long ix; ix = 0; var = tokenizer_variable_num(); if((var >= MAX_VARNUM)&&(var <(MAX_VARNUM+MAX_ARRYNUM))){ accept(TOKENIZER_VARIABLE); ix = tokenizer_num(); accept(TOKENIZER_ARRAY); }else{ accept(TOKENIZER_VARIABLE); } if(ptr[0] == '='){ accept(TOKENIZER_EQ); if(var < MAX_VARNUM){ ubasic_set_variable(var, expr()); }else if(var < (MAX_VARNUM+MAX_ARRYNUM)){ if(ix<MAX_ARRYLEN){ ubasic_set_array(var,ix, expr()); } }else if(var < (MAX_VARNUM+MAX_ARRYNUM+MAX_STRINGNUM)){ ubasic_set_variable(var, expr()); }else if(var < (MAX_VARNUM+MAX_ARRYNUM+MAX_STRINGNUM+MAX_BIGVARNUM)){ ubasic_set_variable(var, expr()); } } accept(TOKENIZER_CR); }
/*---------------------------------------------------------------------------*/ static void next_statement(void) { int var; struct for_state *fs; struct typevalue t; /* FIXME: support 'NEXT' on its own, also loop down the stack so if you GOTO out of a layer of NEXT the right thing occurs */ var = tokenizer_variable_num(); accept_tok(TOKENIZER_INTVAR); /* FIXME: make the for stack just use pointers so it compiles better */ fs = &for_stack[for_stack_ptr - 1]; if(for_stack_ptr > 0 && var == fs->for_variable) { ubasic_get_variable(var, &t, 0, NULL); t.d.i += fs->step; ubasic_set_variable(var, &t, 0,NULL); /* NEXT end depends upon sign of STEP */ if ((fs->step >= 0 && t.d.i <= fs->to) || (fs->step < 0 && t.d.i >= fs->to)) tokenizer_goto(fs->resume_token); else for_stack_ptr--; } else ubasic_error("Mismatched NEXT"); }
/*---------------------------------------------------------------------------*/ static void for_statement(void) { int for_variable, to; accept(TOKENIZER_FOR); for_variable = tokenizer_variable_num(); accept(TOKENIZER_VARIABLE); accept(TOKENIZER_EQ); ubasic_set_variable(for_variable, expr()); accept(TOKENIZER_TO); to = expr(); accept(TOKENIZER_CR); 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", 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"); } }
static void input_statement(void) { struct typevalue r; var_t v; char buf[129]; uint8_t t; uint8_t first = 1; int l; t = current_token; if (t == TOKENIZER_STRING) { tokenizer_string_func(charout, NULL); tokenizer_next(); t = current_token; accept_either(TOKENIZER_COMMA, TOKENIZER_SEMICOLON); } else { charout('?', NULL); charout(' ', NULL); } begin_input(); /* Consider the single var allowed version of INPUT - it's saner for strings by far ? */ do { int n = 0; struct typevalue s[MAX_SUBSCRIPT]; if (!first) accept_either(TOKENIZER_COMMA, TOKENIZER_SEMICOLON); first = 0; t = current_token; v = tokenizer_variable_num(); accept_either(TOKENIZER_INTVAR, TOKENIZER_STRINGVAR); if (current_token == TOKENIZER_LEFTPAREN) n = parse_subscripts(s); /* FIXME: this works for stdin but not files .. */ if ((l = read(0, buf + 1, 128)) <= 0) { write(2, "EOF\n", 4); exit(1); } charreset(); /* Newline input so move to left */ if (t == TOKENIZER_INTVAR) { r.type = TYPE_INTEGER; /* For now */ r.d.i = atoi(buf + 1); /* FIXME: error checking */ } else { /* Turn a C string into a BASIC one */ r.type = TYPE_STRING; if (buf[l-1] == '\n') l--; *((uint8_t *)buf) = l; r.d.p = (uint8_t *)buf; } ubasic_set_variable(v, &r, n, s); } while(!statement_end()); end_input(); }
//static void inr_statement(void) void inr_statement(void) { long var; accept(TOKENIZER_INR); var = tokenizer_variable_num(); accept(TOKENIZER_VARIABLE); ubasic_set_variable(var, kgetc()); accept(TOKENIZER_CR); }
void script_start( int autostart ) { int i; shot_histogram_set(0); if (autostart) auto_started = 1; else auto_started = 0; delay_target_ticks = 0; kbd_int_stack_ptr = 0; kbd_last_clicked = 0; /*if (!autostart)*/ kbd_key_release_all(); script_console_clear(); script_print_screen_init(); if (conf.script_param_save) { save_params_values(0); } if( autostart ) script_console_add_line("***Autostart***"); else script_console_add_line(lang_str(LANG_CONSOLE_TEXT_STARTED)); if( is_lua() ) { if( !lua_script_start(state_ubasic_script) ) { script_print_screen_end(); wait_and_end(); return; } for (i=0; i<SCRIPT_NUM_PARAMS; ++i) { if( script_params[i][0] ) { char var = 'a'+i; lua_pushlstring( L, &var, 1 ); lua_pushnumber( L, conf.ubasic_vars[i] ); lua_settable( L, LUA_GLOBALSINDEX ); } } state_lua_kbd_first_call_to_resume = 1; } else { ubasic_init(state_ubasic_script); for (i=0; i<SCRIPT_NUM_PARAMS; ++i) { ubasic_set_variable(i, conf.ubasic_vars[i]); } } state_kbd_script_run = 1; if (conf.alt_prevent_shutdown != ALT_PREVENT_SHUTDOWN_ALT_SCRIPT) { enable_shutdown(); } }
//static void ina_statement(void) void ina_statement(void) { long var; int ch; var = tokenizer_variable_num(); accept(TOKENIZER_VARIABLE); accept(TOKENIZER_EQ); accept(TOKENIZER_INA); ch = tokenizer_num_or_variable_num(); accept(TOKENIZER_VARIABLE); ubasic_set_variable(var, ubasic_get_adc(ch)); accept(TOKENIZER_CR); }
/*---------------------------------------------------------------------------*/ static void let_statement(void) { int var; var = tokenizer_variable_num(); 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); }
/*---------------------------------------------------------------------------*/ static void peek_statement(void) { VARIABLE_TYPE peek_addr; int var; accept(TOKENIZER_PEEK); peek_addr = expr(); accept(TOKENIZER_COMMA); var = tokenizer_variable_num(); accept(TOKENIZER_VARIABLE); accept(TOKENIZER_CR); ubasic_set_variable(var, peek_function(peek_addr)); }
//static void inp_statement(void) void inp_statement(void) { long var; char c; int flg = 0; accept(TOKENIZER_INP); var = tokenizer_variable_num(); accept(TOKENIZER_VARIABLE); while(flg == 0){ if((c = kgetc()) != 0){ ubasic_set_variable(var, c); flg = 1; } } accept(TOKENIZER_CR); }
/*---------------------------------------------------------------------------*/ static void let_statement(void) { var_t var; struct typevalue v; struct typevalue s[MAX_SUBSCRIPT]; int n = 0; var = tokenizer_variable_num(); accept_either(TOKENIZER_INTVAR, TOKENIZER_STRINGVAR); if (current_token == TOKENIZER_LEFTPAREN) n = parse_subscripts(s); accept_tok(TOKENIZER_EQ); expr(&v); DEBUG_PRINTF("let_statement: assign %d to %d\n", var, v.d.i); ubasic_set_variable(var, &v, n, s); }
//static void next_statement(void) void next_statement(void) { long 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); if(ubasic_get_variable(var) <= for_stack[for_stack_ptr - 1].to) { jump_linenum(for_stack[for_stack_ptr - 1].line_after_for); }else{ for_stack_ptr--; accept(TOKENIZER_CR); } }else{ accept(TOKENIZER_CR); } }
//static void for_statement(void) void for_statement(void) { long for_variable, to; accept(TOKENIZER_FOR); for_variable = tokenizer_variable_num(); accept(TOKENIZER_VARIABLE); accept(TOKENIZER_EQ); ubasic_set_variable(for_variable, expr()); accept(TOKENIZER_TO); to = expr(); accept(TOKENIZER_CR); 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; for_stack_ptr++; }else{ } }
/*---------------------------------------------------------------------------*/ static void for_statement(void) { var_t for_variable; value_t to, step = 1; struct typevalue t; for_variable = tokenizer_variable_num(); accept_tok(TOKENIZER_INTVAR); accept_tok(TOKENIZER_EQ); expr(&t); typecheck_int(&t); /* The set also typechecks the variable */ ubasic_set_variable(for_variable, &t, 0, NULL); accept_tok(TOKENIZER_TO); to = intexpr(); if (current_token == TOKENIZER_STEP) { accept_tok(TOKENIZER_STEP); step = intexpr(); } if (!statement_end()) syntax_error(); /* Save a pointer to the : or CR, when we return to statements it will do the right thing */ if(for_stack_ptr < MAX_FOR_STACK_DEPTH) { struct for_state *fs = &for_stack[for_stack_ptr]; fs->resume_token = tokenizer_pos(); fs->for_variable = for_variable; fs->to = to; fs->step = step; DEBUG_PRINTF("for_statement: new for, var %d to %d step %d\n", fs->for_variable, fs->to, fs->step); for_stack_ptr++; } else { DEBUG_PRINTF("for_statement: for stack depth exceeded\n"); } }
/*---------------------------------------------------------------------------*/ 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); if(ubasic_get_variable(var) <= for_stack[for_stack_ptr - 1].to) { jump_linenum(for_stack[for_stack_ptr - 1].line_after_for); } else { for_stack_ptr--; accept(TOKENIZER_CR); } } 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); } }