//static void gosub_statement(void)
void gosub_statement(void)
{
int linenum,nextnum;
char *tmpptr, *tmpnextptr;
accept(TOKENIZER_GOSUB);
linenum = tokenizer_num();
accept(TOKENIZER_NUMBER);
tmpptr = ptr;
tmpnextptr = nextptr;
while(tokenizer_token() != TOKENIZER_CR &&
tokenizer_token() != TOKENIZER_ENDOFINPUT){
tokenizer_next();
}
accept(TOKENIZER_CR);
nextnum = tokenizer_num();
ptr = tmpptr;
nextptr = tmpnextptr;
if(gosub_stack_ptr < MAX_GOSUB_STACK_DEPTH) {
gosub_stack[gosub_stack_ptr] = nextnum;
gosub_stack_ptr++;
jump_linenum(linenum);
}else{
}
}
/*---------------------------------------------------------------------------*/
static void
line_statement(void)
{
DEBUG_PRINTF("----------- Line number %d ---------\n", tokenizer_num());
index_add(tokenizer_num(), tokenizer_pos());
accept(TOKENIZER_NUMBER);
statement();
return;
}
//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 find_linenum (int linenum)
{
/* Skip irrelevant new-lines and comments. */
while (tokenizer_token() != T_NUMBER)
tokenizer_next();
while (tokenizer_num() != linenum &&
tokenizer_token() != T_EOF)
{
/* Check line number, then skip the rest of line statement. */
do {
do {
tokenizer_next();
} while (tokenizer_token() != T_EOL &&
tokenizer_token() != T_EOF);
if (tokenizer_token() == T_EOL)
{
/* Skip irrelevant new-lines and comments. */
while (tokenizer_token() != T_NUMBER &&
tokenizer_token() != T_EOF)
tokenizer_next();
}
} while (tokenizer_token() != T_NUMBER &&
tokenizer_token() != T_EOF);
}
}
/*---------------------------------------------------------------------------*/
static void
gosub_statement(void)
{
int linenum;
accept(TOKENIZER_GOSUB);
linenum = tokenizer_num();
accept(TOKENIZER_NUMBER);
accept(TOKENIZER_CR);
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");
}
}
/*---------------------------------------------------------------------------*/
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 line_statement(void)
void line_statement(void)
{
ErrLine = tokenizer_num();
/* current_linenum = tokenizer_num();*/
accept(TOKENIZER_NUMBER);
statement();
return;
}
/*---------------------------------------------------------------------------*/
static void
jump_linenum_slow(int linenum)
{
tokenizer_init(program_ptr);
while(tokenizer_num() != linenum) {
do {
do {
tokenizer_next();
} while(current_token != TOKENIZER_CR &&
current_token != TOKENIZER_ENDOFINPUT);
if(current_token == TOKENIZER_CR) {
tokenizer_next();
}
} while(current_token != TOKENIZER_NUMBER);
DEBUG_PRINTF("jump_linenum_slow: Found line %d\n", tokenizer_num());
}
}
/*---------------------------------------------------------------------------*/
static void line_statements(void)
{
line_num = tokenizer_num();
DEBUG_PRINTF("----------- Line number %d ---------\n", line_num);
index_add(line_num, tokenizer_pos());
accept_tok(TOKENIZER_NUMBER);
statements();
return;
}
static void goto_statement (void)
{
int to;
accept(T_GOTO);
to = tokenizer_num();
accept(T_NUMBER);
accept(T_EOL);
jump_linenum(to);
}
static void if_statement (void)
{
int r, to;
accept(T_IF);
r = relation();
accept(T_THEN);
to = tokenizer_num();
accept(T_NUMBER);
accept(T_EOL);
if (r)
jump_linenum(to);
}
//static int factor(void)
int factor(void)
{
int r;
switch(tokenizer_token()) {
case TOKENIZER_NUMBER:
r = tokenizer_num();
accept(TOKENIZER_NUMBER);
break;
case TOKENIZER_LEFTPAREN:
accept(TOKENIZER_LEFTPAREN);
r = expr();
accept(TOKENIZER_RIGHTPAREN);
break;
default:
r = varfactor();
break;
}
return r;
}
//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 jump_linenum(int linenum)
void jump_linenum(int linenum)
{
ptr = BASICBUF;
nextptr = ptr;
tokenizer_init(ptr);
while(tokenizer_num() != linenum) {
do {
do {
tokenizer_next();
} while(tokenizer_token() != TOKENIZER_CR &&
tokenizer_token() != TOKENIZER_ENDOFINPUT);
if(tokenizer_token() == TOKENIZER_CR) {
tokenizer_next();
}
if(tokenizer_token() == TOKENIZER_ENDOFINPUT){
ended = 1;
return;
}
} while(tokenizer_token() != TOKENIZER_NUMBER);
}
}
static int factor (void)
{
int r;
switch (tokenizer_token())
{
case T_NUMBER:
r = tokenizer_num();
accept(T_NUMBER);
break;
case T_LEFT_PAREN:
accept(T_LEFT_PAREN);
r = expression();
accept(T_RIGHT_PAREN);
break;
default:
r = get_variable(
tokenizer_variable_num());
accept(T_LETTER);
break;
}
return r;
}
/*---------------------------------------------------------------------------*/
static int
factor(void)
{
int r;
DEBUG_PRINTF("factor: token %d\n", tokenizer_token());
switch(tokenizer_token()) {
case TOKENIZER_NUMBER:
r = tokenizer_num();
DEBUG_PRINTF("factor: number %d\n", r);
accept(TOKENIZER_NUMBER);
break;
case TOKENIZER_LEFTPAREN:
accept(TOKENIZER_LEFTPAREN);
r = expr();
accept(TOKENIZER_RIGHTPAREN);
break;
default:
r = varfactor();
break;
}
return r;
}
/*---------------------------------------------------------------------------*/
static void factor(struct typevalue *v)
{
uint8_t t = current_token;
int len;
struct typevalue arg[3];
DEBUG_PRINTF("factor: token %d\n", current_token);
switch(t) {
case TOKENIZER_STRING:
v->type = TYPE_STRING;
len = tokenizer_string_len();
v->d.p = string_temp(len);
memcpy(v->d.p + 1, tokenizer_string(), len);
DEBUG_PRINTF("factor: string %p\n", v->d.p);
accept_tok(TOKENIZER_STRING);
break;
case TOKENIZER_NUMBER:
v->d.i = tokenizer_num();
v->type = TYPE_INTEGER;
DEBUG_PRINTF("factor: number %d\n", v->d.i);
accept_tok(TOKENIZER_NUMBER);
break;
case TOKENIZER_LEFTPAREN:
accept_tok(TOKENIZER_LEFTPAREN);
expr(v);
accept_tok(TOKENIZER_RIGHTPAREN);
break;
case TOKENIZER_INTVAR:
case TOKENIZER_STRINGVAR:
varfactor(v);
break;
default:
if (TOKENIZER_NUMEXP(t)) {
accept_tok(t);
switch(t) {
case TOKENIZER_PEEK:
funcexpr(arg,"I");
v->d.i = peek_function(arg[0].d.i);
break;
case TOKENIZER_ABS:
funcexpr(arg,"I");
v->d.i = arg[0].d.i;
if (v->d.i < 0)
v->d.i = -v->d.i;
break;
case TOKENIZER_INT:
funcexpr(arg,"I");
v->d.i = arg[0].d.i;
break;
case TOKENIZER_SGN:
funcexpr(arg,"I");
v->d.i = arg[0].d.i;
if (v->d.i > 1 ) v->d.i = 1;
if (v->d.i < 0) v->d.i = -1;
break;
case TOKENIZER_LEN:
funcexpr(arg,"S");
v->d.i = *arg[0].d.p;
break;
case TOKENIZER_CODE:
funcexpr(arg,"S");
if (*arg[0].d.p)
v->d.i = arg[0].d.p[1];
else
v->d.i = 0;
break;
case TOKENIZER_VAL:
funcexpr(arg,"S");
v->d.i = string_val(&arg[0]);
break;
default:
syntax_error();
}
v->type = TYPE_INTEGER;
}
else if (TOKENIZER_STRINGEXP(t)) {
accept_tok(t);
switch(t) {
case TOKENIZER_LEFTSTR:
funcexpr(arg, "SI");
string_cut(v, &arg[0], 1, arg[1].d.i);
break;
case TOKENIZER_RIGHTSTR:
funcexpr(arg, "SI");
string_cut_r(v, &arg[0], arg[1].d.i);
break;
case TOKENIZER_MIDSTR:
funcexpr(arg, "SII");
string_cut(v, &arg[0], arg[1].d.i, arg[2].d.i);
break;
case TOKENIZER_CHRSTR:
funcexpr(arg, "I");
v->d.p = string_temp(2);
v->d.p[1] = arg[0].d.i;
v->type = TYPE_STRING;
break;
default:
syntax_error();
}
}
else
syntax_error();
}
}
//static void goto_statement(void)
void goto_statement(void)
{
accept(TOKENIZER_GOTO);
jump_linenum(tokenizer_num());
}
