int i_execute_for (SOURCE_FILE * sf,const int todo)
{
int this_todo,r,pos = sf->pos;
real begin,end,step;
VAR * v;
l_get_token();v = get_var(token);
l_get_token();// skip '='
begin = calc_check(FALSE,pline);
l_get_token();// skip 'to'
end = calc_check(FALSE,pline);
l_get_token();
if (token_type!=TT_LINE_END) step= calc_check(FALSE,pline);
else step = 1.0;
v->value = begin;
if (!todo)
{
this_todo = FALSE;
}
else
{
this_todo = v->value<=end;
}
while (TRUE)
{
r = i_execute_line(sf,this_todo);
if (r==EXE_END)
{
if (this_todo)
{
v->value+=step;
this_todo = v->value<=end;
sf->pos = pos;
}
else
break;
}
else if (r==EXE_RETURN) return EXE_RETURN;
else if (r==EXE_BREAK)
{
this_todo = FALSE;
}
}
return EXE_DO;
}
int i_execute_if (SOURCE_FILE * sf,const int todo)
{
int this_todo,r,done = FALSE;
if (!todo)
{
this_todo = FALSE;
}
else
{
this_todo = (calc_check(FALSE,pline) != 0.0);
if (this_todo) done = TRUE;
}
while (TRUE)
{
r = i_execute_line(sf,this_todo);
if (r==EXE_END) break;
else if (r==EXE_ELSEIF)
{
if (todo)
{
if (done) this_todo = FALSE;
else
{
this_todo = (calc_check(FALSE,pline) != 0.0);
if (this_todo) done = TRUE;
}
}
}
else if (r==EXE_ELSE)
{
if(todo)this_todo = !done;
}
else if (r==EXE_RETURN) return EXE_RETURN;
else if (r==EXE_BREAK) return EXE_BREAK;
}
return EXE_DO;
}
int i_execute_while (SOURCE_FILE * sf,const int todo)
{
int this_todo,r,pos = sf->pos;
char cond_buf[LINE_MAX];
strcpy(cond_buf,pline);
if (!todo)
{
this_todo = FALSE;
}
else
{
this_todo = (calc_check(FALSE,cond_buf) != 0.0);
}
while (TRUE)
{
r = i_execute_line(sf,this_todo);
if (r==EXE_END)
{
if (this_todo)
{
this_todo = (calc_check(FALSE,cond_buf) != 0.0);
sf->pos = pos;
}
else
break;
}
else if (r==EXE_RETURN) return EXE_RETURN;
else if (r==EXE_BREAK)
{
this_todo = FALSE;
}
}
return EXE_DO;
}
int i_execute_case (SOURCE_FILE * sf,const int todo)
{
int this_todo,r,done = FALSE;
VAR * v;
l_get_token();
v = find_var(token);
if (!todo)
{
this_todo = FALSE;
}
while (TRUE)
{
r = i_execute_line(sf,this_todo);
if (r==EXE_END) break;
else if (r==EXE_WHEN)
{
if (todo)
{
if (done) this_todo = FALSE;
else
{
this_todo = (calc_check(FALSE,pline) == v->value);
if (this_todo) done = TRUE;
}
}
}
else if (r==EXE_ELSE)
{
if(todo)this_todo = !done;
}
else if (r==EXE_RETURN) return EXE_RETURN;
else if (r==EXE_BREAK) return EXE_BREAK;
}
return EXE_DO;
}
int i_execute_repeat (SOURCE_FILE * sf,const int todo)
{
int this_todo,r,pos = sf->pos;
if (!todo)
{
this_todo = FALSE;
}
else
{
this_todo = TRUE;
}
while (TRUE)
{
r = i_execute_line(sf,this_todo);
if (r==EXE_UNTIL)
{
if (todo)
{
this_todo = (calc_check(FALSE,pline) == 0.0);
if (!this_todo)
break;
else
sf->pos = pos;
}
else
break;
}
else if (r==EXE_RETURN) return EXE_RETURN;
else if (r==EXE_BREAK)
{
this_todo = FALSE;
}
}
return EXE_DO;
}
int cvsdelta::copy_buffer(const Byte *from, unsigned start, unsigned len, ByteArray& data_buffer)
{
Byte *p;
size_t count,n;
size_t s = data_buffer.size();
data_buffer.resize(s+len);
memcpy((Byte*)&data_buffer[s],from+start,len);
/* Merge the buffer into the calculated checksum data */
count=len/block_size;
for(n=0, p=(Byte*)&data_buffer[s]+(count-1)*block_size; n<count; n++, p-=block_size)
{
checksum_t *c = check2+n+check2_count;
unsigned h;
calc_check(p,c);
h=calc_hash(c)%prime;
c->next=hash[h];
c->new_data=true;
hash[h]=c;
}
check2_count+=n;
return s;
}
int main(int argc, char *argv[])
{
register uint i,j;
uint ant,n1,n2,n3;
uint write_count,update,opt_delete,check2,dupp_keys,found_key;
int error;
ulong pos;
unsigned long key_check;
uchar record[128],record2[128],record3[128],key[10];
const char *filename,*filename2;
HP_INFO *file,*file2;
HP_SHARE *tmp_share;
HP_KEYDEF keyinfo[MAX_KEYS];
HA_KEYSEG keyseg[MAX_KEYS*5];
HEAP_PTR UNINIT_VAR(position);
HP_CREATE_INFO hp_create_info;
CHARSET_INFO *cs= &my_charset_latin1;
my_bool unused;
MY_INIT(argv[0]); /* init my_sys library & pthreads */
filename= "test2";
filename2= "test2_2";
file=file2=0;
get_options(argc,argv);
bzero(&hp_create_info, sizeof(hp_create_info));
hp_create_info.max_table_size= 2*1024L*1024L;
hp_create_info.keys= keys;
hp_create_info.keydef= keyinfo;
hp_create_info.reclength= reclength;
hp_create_info.max_records= (ulong) flag*100000L;
hp_create_info.min_records= (ulong) recant/2;
write_count=update=opt_delete=0;
key_check=0;
keyinfo[0].seg=keyseg;
keyinfo[0].keysegs=1;
keyinfo[0].flag= 0;
keyinfo[0].algorithm= HA_KEY_ALG_HASH;
keyinfo[0].seg[0].type=HA_KEYTYPE_BINARY;
keyinfo[0].seg[0].start=0;
keyinfo[0].seg[0].length=6;
keyinfo[0].seg[0].null_bit=0;
keyinfo[0].seg[0].charset=cs;
keyinfo[1].seg=keyseg+1;
keyinfo[1].keysegs=2;
keyinfo[1].flag=0;
keyinfo[1].algorithm= HA_KEY_ALG_HASH;
keyinfo[1].seg[0].type=HA_KEYTYPE_BINARY;
keyinfo[1].seg[0].start=7;
keyinfo[1].seg[0].length=6;
keyinfo[1].seg[0].null_bit=0;
keyinfo[1].seg[0].charset=cs;
keyinfo[1].seg[1].type=HA_KEYTYPE_TEXT;
keyinfo[1].seg[1].start=0; /* key in two parts */
keyinfo[1].seg[1].length=6;
keyinfo[1].seg[1].null_bit=0;
keyinfo[1].seg[1].charset=cs;
keyinfo[2].seg=keyseg+3;
keyinfo[2].keysegs=1;
keyinfo[2].flag=HA_NOSAME;
keyinfo[2].algorithm= HA_KEY_ALG_HASH;
keyinfo[2].seg[0].type=HA_KEYTYPE_BINARY;
keyinfo[2].seg[0].start=12;
keyinfo[2].seg[0].length=8;
keyinfo[2].seg[0].null_bit=0;
keyinfo[2].seg[0].charset=cs;
keyinfo[3].seg=keyseg+4;
keyinfo[3].keysegs=1;
keyinfo[3].flag=HA_NOSAME;
keyinfo[3].algorithm= HA_KEY_ALG_HASH;
keyinfo[3].seg[0].type=HA_KEYTYPE_BINARY;
keyinfo[3].seg[0].start=37;
keyinfo[3].seg[0].length=1;
keyinfo[3].seg[0].null_bit=1;
keyinfo[3].seg[0].null_pos=38;
keyinfo[3].seg[0].charset=cs;
bzero((char*) key1,sizeof(key1));
bzero((char*) key3,sizeof(key3));
printf("- Creating heap-file\n");
if (heap_create(filename, &hp_create_info, &tmp_share, &unused) ||
!(file= heap_open(filename, 2)))
goto err;
signal(SIGINT,endprog);
printf("- Writing records:s\n");
strmov((char*) record," ..... key");
for (i=0 ; i < recant ; i++)
{
n1=rnd(1000); n2=rnd(100); n3=rnd(MY_MIN(recant*5,MAX_RECORDS));
make_record(record,n1,n2,n3,"Pos",write_count);
if (heap_write(file,record))
{
if (my_errno != HA_ERR_FOUND_DUPP_KEY || key3[n3] == 0)
{
printf("Error: %d in write at record: %d\n",my_errno,i);
goto err;
}
if (verbose) printf(" Double key: %d\n",n3);
}
else
{
if (key3[n3] == 1)
{
printf("Error: Didn't get error when writing second key: '%8d'\n",n3);
goto err;
}
write_count++; key1[n1]++; key3[n3]=1;
key_check+=n1;
}
if (testflag == 1 && heap_check_heap(file,0))
{
puts("Heap keys crashed");
goto err;
}
}
if (testflag == 1)
goto end;
if (heap_check_heap(file,0))
{
puts("Heap keys crashed");
goto err;
}
printf("- Delete\n");
for (i=0 ; i < write_count/10 ; i++)
{
for (j=rnd(1000)+1 ; j>0 && key1[j] == 0 ; j--) ;
if (j != 0)
{
sprintf((char*) key,"%6d",j);
if (heap_rkey(file,record,0,key,6, HA_READ_KEY_EXACT))
{
printf("can't find key1: \"%s\"\n",(char*) key);
goto err;
}
if (heap_delete(file,record))
{
printf("error: %d; can't delete record: \"%s\"\n", my_errno,(char*) record);
goto err;
}
opt_delete++;
key1[atoi((char*) record+keyinfo[0].seg[0].start)]--;
key3[atoi((char*) record+keyinfo[2].seg[0].start)]=0;
key_check-=atoi((char*) record);
if (testflag == 2 && heap_check_heap(file,0))
{
puts("Heap keys crashed");
goto err;
}
}
else
puts("Warning: Skipping delete test because no dupplicate keys");
}
if (testflag==2) goto end;
if (heap_check_heap(file,0))
{
puts("Heap keys crashed");
goto err;
}
printf("- Update\n");
for (i=0 ; i < write_count/10 ; i++)
{
n1=rnd(1000); n2=rnd(100); n3=rnd(MY_MIN(recant*2,MAX_RECORDS));
make_record(record2, n1, n2, n3, "XXX", update);
if (rnd(2) == 1)
{
if (heap_scan_init(file))
goto err;
j=rnd(write_count-opt_delete);
while ((error=heap_scan(file,record) == HA_ERR_RECORD_DELETED) ||
(!error && j))
{
if (!error)
j--;
}
if (error)
goto err;
}
else
{
for (j=rnd(1000)+1 ; j>0 && key1[j] == 0 ; j--) ;
if (!key1[j])
continue;
sprintf((char*) key,"%6d",j);
if (heap_rkey(file,record,0,key,6, HA_READ_KEY_EXACT))
{
printf("can't find key1: \"%s\"\n",(char*) key);
goto err;
}
}
if (heap_update(file,record,record2))
{
if (my_errno != HA_ERR_FOUND_DUPP_KEY || key3[n3] == 0)
{
printf("error: %d; can't update:\nFrom: \"%s\"\nTo: \"%s\"\n",
my_errno,(char*) record, (char*) record2);
goto err;
}
if (verbose)
printf("Double key when tried to update:\nFrom: \"%s\"\nTo: \"%s\"\n",
(char*) record, (char*) record2);
}
else
{
key1[atoi((char*) record+keyinfo[0].seg[0].start)]--;
key3[atoi((char*) record+keyinfo[2].seg[0].start)]=0;
key1[n1]++; key3[n3]=1;
update++;
key_check=key_check-atoi((char*) record)+n1;
}
if (testflag == 3 && heap_check_heap(file,0))
{
puts("Heap keys crashed");
goto err;
}
}
if (testflag == 3) goto end;
if (heap_check_heap(file,0))
{
puts("Heap keys crashed");
goto err;
}
for (i=999, dupp_keys=found_key=0 ; i>0 ; i--)
{
if (key1[i] > dupp_keys) { dupp_keys=key1[i]; found_key=i; }
sprintf((char*) key,"%6d",found_key);
}
if (dupp_keys > 3)
{
if (!silent)
printf("- Read first key - next - delete - next -> last\n");
DBUG_PRINT("progpos",("first - next - delete - next -> last"));
if (heap_rkey(file,record,0,key,6, HA_READ_KEY_EXACT))
goto err;
if (heap_rnext(file,record3)) goto err;
if (heap_delete(file,record3)) goto err;
key_check-=atoi((char*) record3);
key1[atoi((char*) record+keyinfo[0].seg[0].start)]--;
key3[atoi((char*) record+keyinfo[2].seg[0].start)]=0;
opt_delete++;
ant=2;
while ((error=heap_rnext(file,record3)) == 0 ||
error == HA_ERR_RECORD_DELETED)
if (! error)
ant++;
if (ant != dupp_keys)
{
printf("next: I can only find: %d records of %d\n",
ant,dupp_keys);
goto end;
}
dupp_keys--;
if (heap_check_heap(file,0))
{
puts("Heap keys crashed");
goto err;
}
if (!silent)
printf("- Read last key - delete - prev - prev - opt_delete - prev -> first\n");
if (heap_rprev(file,record))
goto err;
if (heap_delete(file,record3)) goto err;
key_check-=atoi((char*) record3);
key1[atoi((char*) record+keyinfo[0].seg[0].start)]--;
key3[atoi((char*) record+keyinfo[2].seg[0].start)]=0;
opt_delete++;
if (heap_rprev(file,record3) || heap_rprev(file,record3))
goto err;
if (heap_delete(file,record3)) goto err;
key_check-=atoi((char*) record3);
key1[atoi((char*) record+keyinfo[0].seg[0].start)]--;
key3[atoi((char*) record+keyinfo[2].seg[0].start)]=0;
opt_delete++;
ant=3;
while ((error=heap_rprev(file,record3)) == 0 ||
error == HA_ERR_RECORD_DELETED)
{
if (! error)
ant++;
}
if (ant != dupp_keys)
{
printf("next: I can only find: %d records of %d\n",
ant,dupp_keys);
goto end;
}
dupp_keys-=2;
if (heap_check_heap(file,0))
{
puts("Heap keys crashed");
goto err;
}
}
else
puts("Warning: Not enough duplicated keys: Skipping delete key check");
if (!silent)
printf("- Read (first) - next - delete - next -> last\n");
DBUG_PRINT("progpos",("first - next - delete - next -> last"));
if (heap_scan_init(file))
goto err;
while ((error=heap_scan(file,record3) == HA_ERR_RECORD_DELETED)) ;
if (error)
goto err;
if (heap_delete(file,record3)) goto err;
key_check-=atoi((char*) record3);
opt_delete++;
key1[atoi((char*) record+keyinfo[0].seg[0].start)]--;
key3[atoi((char*) record+keyinfo[2].seg[0].start)]=0;
ant=0;
while ((error=heap_scan(file,record3)) == 0 ||
error == HA_ERR_RECORD_DELETED)
if (! error)
ant++;
if (ant != write_count-opt_delete)
{
printf("next: Found: %d records of %d\n",ant,write_count-opt_delete);
goto end;
}
if (heap_check_heap(file,0))
{
puts("Heap keys crashed");
goto err;
}
puts("- Test if: Read rrnd - same - rkey - same");
DBUG_PRINT("progpos",("Read rrnd - same"));
pos=rnd(write_count-opt_delete-5)+5;
heap_scan_init(file);
i=5;
while ((error=heap_scan(file,record)) == HA_ERR_RECORD_DELETED ||
(error == 0 && pos))
{
if (!error)
pos--;
if (i-- == 0)
{
bmove(record3,record,reclength);
position=heap_position(file);
}
}
if (error)
goto err;
bmove(record2,record,reclength);
if (heap_rsame(file,record,-1) || heap_rsame(file,record2,2))
goto err;
if (memcmp(record2,record,reclength))
{
puts("heap_rsame didn't find right record");
goto end;
}
puts("- Test of read through position");
if (heap_rrnd(file,record,position))
goto err;
if (memcmp(record3,record,reclength))
{
puts("heap_frnd didn't find right record");
goto end;
}
printf("- heap_info\n");
{
HEAPINFO info;
heap_info(file,&info,0);
/* We have to test with opt_delete +1 as this may be the case if the last
inserted row was a duplicate key */
if (info.records != write_count-opt_delete ||
(info.deleted != opt_delete && info.deleted != opt_delete+1))
{
puts("Wrong info from heap_info");
printf("Got: records: %ld(%d) deleted: %ld(%d)\n",
info.records,write_count-opt_delete,info.deleted,opt_delete);
}
}
#ifdef OLD_HEAP_VERSION
{
uint check;
printf("- Read through all records with rnd\n");
if (heap_extra(file,HA_EXTRA_RESET) || heap_extra(file,HA_EXTRA_CACHE))
{
puts("got error from heap_extra");
goto end;
}
ant=check=0;
while ((error=heap_rrnd(file,record,(ulong) -1)) != HA_ERR_END_OF_FILE &&
ant < write_count + 10)
{
if (!error)
{
ant++;
check+=calc_check(record,reclength);
}
}
if (ant != write_count-opt_delete)
{
printf("rrnd: I can only find: %d records of %d\n", ant,
write_count-opt_delete);
goto end;
}
if (heap_extra(file,HA_EXTRA_NO_CACHE))
{
puts("got error from heap_extra(HA_EXTRA_NO_CACHE)");
goto end;
}
}
#endif
printf("- Read through all records with scan\n");
if (heap_reset(file) || heap_extra(file,HA_EXTRA_CACHE))
{
puts("got error from heap_extra");
goto end;
}
ant=check2=0;
heap_scan_init(file);
while ((error=heap_scan(file,record)) != HA_ERR_END_OF_FILE &&
ant < write_count + 10)
{
if (!error)
{
ant++;
check2+=calc_check(record,reclength);
}
}
if (ant != write_count-opt_delete)
{
printf("scan: I can only find: %d records of %d\n", ant,
write_count-opt_delete);
goto end;
}
#ifdef OLD_HEAP_VERSION
if (check != check2)
{
puts("scan: Checksum didn't match reading with rrnd");
goto end;
}
#endif
if (heap_extra(file,HA_EXTRA_NO_CACHE))
{
puts("got error from heap_extra(HA_EXTRA_NO_CACHE)");
goto end;
}
for (i=999, dupp_keys=found_key=0 ; i>0 ; i--)
{
if (key1[i] > dupp_keys) { dupp_keys=key1[i]; found_key=i; }
sprintf((char*) key,"%6d",found_key);
}
printf("- Read through all keys with first-next-last-prev\n");
ant=0;
for (error=heap_rkey(file,record,0,key,6, HA_READ_KEY_EXACT);
! error ;
error=heap_rnext(file,record))
ant++;
if (ant != dupp_keys)
{
printf("first-next: I can only find: %d records of %d\n", ant,
dupp_keys);
goto end;
}
ant=0;
for (error=heap_rprev(file,record) ;
! error ;
error=heap_rprev(file,record))
{
ant++;
check2+=calc_check(record,reclength);
}
if (ant != dupp_keys)
{
printf("last-prev: I can only find: %d records of %d\n", ant,
dupp_keys);
goto end;
}
if (testflag == 4) goto end;
printf("- Reading through all rows through keys\n");
if (!(file2=heap_open(filename, 2)))
goto err;
if (heap_scan_init(file))
goto err;
while ((error=heap_scan(file,record)) != HA_ERR_END_OF_FILE)
{
if (error == 0)
{
if (heap_rkey(file2,record2,2,record+keyinfo[2].seg[0].start,8,
HA_READ_KEY_EXACT))
{
printf("can't find key3: \"%.8s\"\n",
record+keyinfo[2].seg[0].start);
goto err;
}
}
}
heap_close(file2);
printf("- Creating output heap-file 2\n");
hp_create_info.keys= 1;
hp_create_info.max_records= 0;
hp_create_info.min_records= 0;
if (heap_create(filename2, &hp_create_info, &tmp_share, &unused) ||
!(file2= heap_open_from_share_and_register(tmp_share, 2)))
goto err;
printf("- Copying and removing records\n");
if (heap_scan_init(file))
goto err;
while ((error=heap_scan(file,record)) != HA_ERR_END_OF_FILE)
{
if (error == 0)
{
if (heap_write(file2,record))
goto err;
key_check-=atoi((char*) record);
write_count++;
if (heap_delete(file,record))
goto err;
opt_delete++;
}
pos++;
}
printf("- Checking heap tables\n");
if (heap_check_heap(file,1) || heap_check_heap(file2,1))
{
puts("Heap keys crashed");
goto err;
}
if (my_errno != HA_ERR_END_OF_FILE)
printf("error: %d from heap_rrnd\n",my_errno);
if (key_check)
printf("error: Some read got wrong: check is %ld\n",(long) key_check);
end:
printf("\nFollowing test have been made:\n");
printf("Write records: %d\nUpdate records: %d\nDelete records: %d\n", write_count,update,opt_delete);
heap_clear(file);
if (heap_close(file) || (file2 && heap_close(file2)))
goto err;
heap_delete_table(filename2);
hp_panic(HA_PANIC_CLOSE);
my_end(MY_GIVE_INFO);
return(0);
err:
printf("Got error: %d when using heap-database\n",my_errno);
(void) heap_close(file);
return(1);
} /* main */
real calc (const char * exp)
{
return calc_check(TRUE,exp);
}
real calc_check(int check,const char * exp)
{
real opd_stack[STACK_SIZE];
int opr_stack[STACK_SIZE];
int opd_size = 0,opr_size = 0;
int state = 1/*,i*/;
extern VAR * find_var (const char *);
if (check)
{
match_exp(exp);
l_get_token();
if (token_type!=TT_LINE_END)
{
merror_msg("illegal expr");
}
}
pline = exp;
while(1)
{
l_get_token();//puts(token);SHOW_STACK;
// exit
if (token_type==TT_LINE_END)
{
break;
}
else if (token_type==TT_ID)
{
VAR * v;ARRAY * a;
if (state!=1 && !check)
{
l_put_back();
break;
}
v = find_var(token);
if (v!=NULL)
{
push_opd(v->value);
move2(2);
continue;
}
a = find_array (token);
if (a!=NULL)
{
int index;
l_get_token();//skip (
index = (int)calc_check(FALSE,pline);
// delete this line,calc_check call skip ( automatically
//l_get_token();//skip )
push_opd(get_element(a,index));
move2(2);
continue;
}
merror_msg("Unrecognized identifier '%s'",token);
}
// constant
else if (token_type==TT_INT || token_type==TT_FLOAT)
{
push_opd((real)atof(token));
move2(2);
}
// operator
else if (IS_OPR(token_type))
{
// neg "-" judgement
if (token_type==OPR_SUB && state==1)
{
token_type = OPR_NEG;
}
//
if (opr_size>0 &&
opr_stack[opr_size-1]!=TT_LBK &&
priority(token_type) <= priority(opr_stack[opr_size-1]))
{
real result;
result = calc_pop(opd_stack,opr_stack,&opd_size,&opr_size);
push_opd(result);
}
push_opr(token_type);
move2(1);
}
// process '(' and ')'
else if (token_type==TT_LBK)
{
push_opr(token_type);
}
else if (token_type==TT_RBK)
{
while(opr_stack[opr_size-1] /* top */ != TT_LBK && opr_size > 0)
{
real result;
result = calc_pop(opd_stack,opr_stack,&opd_size,&opr_size);
push_opd(result);
}
if (opr_stack[opr_size-1] /* top */ == TT_LBK)
{
opr_size--; // pop '('
}
else // funcition call end
{
break;
}
}
// built-in function call
else if (IS_RESWORD(token_type))
{
int argc = token_ext,i;
real result;
FUNCTION func = get_func(token_type);
//printf("call <%s>\n",token);
// skip '('
l_get_token ();
// get all arg and push them in stack
for (i=0;i<argc;++i)
{
result = calc_check(FALSE,pline);
push_opd(result);
//printf("[%d] |%.4lf|\n",i,result);
}
// call func
result = func(opd_stack + opd_size - argc);
// pop args
opd_size -= argc;
// push result
push_opd(result);
//printf("call end\n");
}
else
{
if (check)
merror_illegal_token();
else
{
l_put_back();
break;
}
}
}
// pop up all
while(opr_size > 0)
{
real result;
result = calc_pop(opd_stack,opr_stack,&opd_size,&opr_size);
push_opd(result);
}
if (opd_size != 1)
{
merror_msg("calc:unknown error!");
}
return opd_stack[0];
}
int i_execute_line (SOURCE_FILE * sf,const int todo)
{
l_get_line(sf);pline = line;
l_get_token();
if (token_type==TT_LINE_END)
{
return EXE_DO;// skip empty line
}
else if (IS_KEYWORD(token_type))
{
if (token_type==KEY_END)
{
return EXE_END;
}
else if (token_type==KEY_IF)
{
return i_execute_if (sf,todo);
}
else if (token_type==KEY_WHILE)
{
return i_execute_while(sf,todo);
}
else if (token_type==KEY_REPEAT)
{
return i_execute_repeat(sf,todo);
}
if (token_type==KEY_UNTIL)
{
return EXE_UNTIL;
}
else if (token_type==KEY_FOR)
{
return i_execute_for(sf,todo);
}
else if (token_type==KEY_CASE)
{
return i_execute_case(sf,todo);
}
else if (token_type==KEY_ELSEIF)
{
return EXE_ELSEIF;
}
else if (token_type==KEY_WHEN)
{
return EXE_WHEN;
}
else if (token_type==KEY_ELSE)
{
return EXE_ELSE;
}
if (!todo) return EXE_DO;
if (token_type==KEY_BREAK)
{
return EXE_BREAK;
}
else if (token_type==KEY_RETURN)
{
return EXE_RETURN;
}
else if (token_type==KEY_GOSUB)
{
extern int i_call_sub (SOURCE_FILE *,const char *);
l_get_token();
return i_call_sub(sf,token);
}
else if (token_type==KEY_DIM)
{
ARRAY * array;
long size;
while(1)
{
l_get_token();
// new array
array = (ARRAY*)calloc(sizeof(ARRAY),1);
array->name = s_strdup(token);
list_push(&list_array,array);
//
l_get_token();// skip '('
size = (long)calc_check(FALSE,pline);
if (size<=0)
{
merror_msg("illegal array size %d!",size);
}
array->size = size;
array->array = calloc(sizeof(real),size);
{
int i;
for (i=0;i<size;++i) array->array[i] = 0.0;
}
l_get_token();// skip ')'
l_get_token();
if (token_type==TT_COM) continue;
else if (token_type==TT_LINE_END) break;
}
}
else if (token_type==KEY_EXIT)
{
d_exit();
}
}
else if(token_type==TT_ID)
{
if (str_eq(token,"print"))
{
while(1)
{
l_get_token();
if (token_type==TT_STRING)
{
printf("%s",token);
}
else
{
real result;
char buf[128];
l_put_back();
result = calc_check(FALSE,pline);
d_ftoa(result,buf);
printf(buf);
}
l_get_token();
if (token_type==TT_LINE_END)break;
}//while
}//print
else if (str_eq(token,"input"))
{
VAR * v;char buf[64];
while(1)
{
l_get_token();
v = get_var(token);
gets(64,buf);puts(buf);
v->value = atof(buf);
l_get_token();
if (token_type==TT_LINE_END)break;
}//while
}//input
else
{
ARRAY * a;
VAR * var;
var = find_var(token);
if (var!=NULL)
{
l_get_token(); //skip '='
var->value = calc_check(FALSE,pline);
return EXE_DO;
}
a = find_array(token);
if(a!=NULL)
{
int index;
l_get_token();//skip (
index = (int)calc_check(FALSE,pline);
// delete this line,calc_check call skip ( automatically
//l_get_token();//skip )
l_get_token();// skip =
assign_element(a,index,calc_check(FALSE,pline));
return EXE_DO;
}
var = create_var(token);
l_get_token(); //skip '='
var->value = calc_check(FALSE,pline);
return EXE_DO;
}//assign
}// TT_ID
else
{
merror_illegal_token();
}
return EXE_DO;
}
