240 |
stackitem *temp= env->head; |
stackitem *temp= env->head; |
241 |
|
|
242 |
if((env->head)==NULL) { |
if((env->head)==NULL) { |
243 |
printerr("Stack empty"); |
printerr("Too Few Arguments"); |
244 |
env->err=1; |
env->err=1; |
245 |
return; |
return; |
246 |
} |
} |
283 |
|
|
284 |
extern void print_(environment *env) { |
extern void print_(environment *env) { |
285 |
if(env->head==NULL) { |
if(env->head==NULL) { |
286 |
printerr("Stack empty"); |
printerr("Too Few Arguments"); |
287 |
env->err=1; |
env->err=1; |
288 |
return; |
return; |
289 |
} |
} |
314 |
extern void printstack(environment *env) |
extern void printstack(environment *env) |
315 |
{ |
{ |
316 |
if(env->head == NULL) { |
if(env->head == NULL) { |
317 |
printerr("Stack empty"); |
printerr("Too Few Arguments"); |
318 |
env->err=1; |
env->err=1; |
319 |
return; |
return; |
320 |
} |
} |
328 |
stackitem *temp= env->head; |
stackitem *temp= env->head; |
329 |
|
|
330 |
if((env->head)==NULL) { |
if((env->head)==NULL) { |
331 |
printerr("Stack empty"); |
printerr("Too Few Arguments"); |
332 |
env->err=1; |
env->err=1; |
333 |
return; |
return; |
334 |
} |
} |
335 |
|
|
336 |
if(env->head->next==NULL) { |
if(env->head->next==NULL) { |
337 |
printerr("Not enough arguments"); |
printerr("Too Few Arguments"); |
338 |
env->err=1; |
env->err=1; |
339 |
return; |
return; |
340 |
} |
} |
360 |
value *val; |
value *val; |
361 |
|
|
362 |
if(env->head == NULL) { |
if(env->head == NULL) { |
363 |
printerr("Stack empty"); |
printerr("Too Few Arguments"); |
364 |
env->err=1; |
env->err=1; |
365 |
return; |
return; |
366 |
} |
} |
367 |
|
|
368 |
if(env->head->item->type!=symb) { |
if(env->head->item->type!=symb) { |
369 |
printerr("Not a symbol"); |
printerr("Bad Argument Type"); |
370 |
env->err=1; |
env->err=2; |
371 |
return; |
return; |
372 |
} |
} |
373 |
|
|
374 |
val=((symbol *)(env->head->item->content.ptr))->val; |
val=((symbol *)(env->head->item->content.ptr))->val; |
375 |
if(val == NULL){ |
if(val == NULL){ |
376 |
printerr("Unbound variable"); |
printerr("Unbound Variable"); |
377 |
env->err=1; |
env->err=3; |
378 |
return; |
return; |
379 |
} |
} |
380 |
toss(env); /* toss the symbol */ |
toss(env); /* toss the symbol */ |
389 |
{ |
{ |
390 |
funcp in_func; |
funcp in_func; |
391 |
if(env->head==NULL) { |
if(env->head==NULL) { |
392 |
printerr("Stack empty"); |
printerr("Too Few Arguments"); |
393 |
env->err=1; |
env->err=1; |
394 |
return; |
return; |
395 |
} |
} |
538 |
stackitem *temp, *new_head; |
stackitem *temp, *new_head; |
539 |
|
|
540 |
/* Is top element a list? */ |
/* Is top element a list? */ |
541 |
if(env->head==NULL || env->head->item->type!=list) { |
if(env->head==NULL) { |
542 |
printerr("Stack empty or not a list"); |
printerr("Too Few Arguments"); |
543 |
env->err=1; |
env->err=1; |
544 |
return; |
return; |
545 |
} |
} |
546 |
|
if(env->head->item->type!=list) { |
547 |
|
printerr("Bad Argument Type"); |
548 |
|
env->err=2; |
549 |
|
return; |
550 |
|
} |
551 |
|
|
552 |
/* The first list element is the new stack head */ |
/* The first list element is the new stack head */ |
553 |
new_head= temp= env->head->item->content.ptr; |
new_head= temp= env->head->item->content.ptr; |
572 |
int result; |
int result; |
573 |
|
|
574 |
if((env->head)==NULL || env->head->next==NULL) { |
if((env->head)==NULL || env->head->next==NULL) { |
575 |
printerr("Not enough elements to compare"); |
printerr("Too Few Arguments"); |
576 |
env->err=1; |
env->err=1; |
577 |
return; |
return; |
578 |
} |
} |
591 |
{ |
{ |
592 |
int val; |
int val; |
593 |
|
|
594 |
if((env->head)==NULL || env->head->item->type!=integer) { |
if((env->head)==NULL) { |
595 |
printerr("Stack empty or element is not a integer"); |
printerr("Too Few Arguments"); |
596 |
env->err=1; |
env->err=1; |
597 |
return; |
return; |
598 |
} |
} |
599 |
|
|
600 |
|
if(env->head->item->type!=integer) { |
601 |
|
printerr("Bad Argument Type"); |
602 |
|
env->err=2; |
603 |
|
return; |
604 |
|
} |
605 |
|
|
606 |
val= env->head->item->content.val; |
val= env->head->item->content.val; |
607 |
toss(env); |
toss(env); |
608 |
push_int(&(env->head), !val); |
push_int(&(env->head), !val); |
622 |
symbol *sym; |
symbol *sym; |
623 |
|
|
624 |
/* Needs two values on the stack, the top one must be a symbol */ |
/* Needs two values on the stack, the top one must be a symbol */ |
625 |
if(env->head==NULL || env->head->next==NULL |
if(env->head==NULL || env->head->next==NULL) { |
626 |
|| env->head->item->type!=symb) { |
printerr("Too Few Arguments"); |
|
printerr("Define what?"); |
|
627 |
env->err=1; |
env->err=1; |
628 |
return; |
return; |
629 |
} |
} |
630 |
|
|
631 |
|
if(env->head->item->type!=symb) { |
632 |
|
printerr("Bad Argument Type"); |
633 |
|
env->err=2; |
634 |
|
return; |
635 |
|
} |
636 |
|
|
637 |
/* long names are a pain */ |
/* long names are a pain */ |
638 |
sym=env->head->item->content.ptr; |
sym=env->head->item->content.ptr; |
639 |
|
|
683 |
stackitem *stack_head= env->head; |
stackitem *stack_head= env->head; |
684 |
symbol **hash_entry, *temp; |
symbol **hash_entry, *temp; |
685 |
|
|
686 |
if(stack_head==NULL || stack_head->item->type!=symb) { |
if(stack_head==NULL) { |
687 |
printerr("Stack empty or not a symbol"); |
printerr("Too Few Arguments"); |
688 |
|
env->err=1; |
689 |
|
return; |
690 |
|
} |
691 |
|
|
692 |
|
if(stack_head->item->type!=symb) { |
693 |
|
printerr("Bad Argument Type"); |
694 |
|
env->err=2; |
695 |
return; |
return; |
696 |
} |
} |
697 |
|
|
707 |
} |
} |
708 |
free(temp->id); |
free(temp->id); |
709 |
free(temp); |
free(temp); |
710 |
} |
} |
711 |
|
|
712 |
|
/* Returns the current error number to the stack */ |
713 |
|
extern void errn(environment *env){ |
714 |
|
push_int(&(env->head), env->err); |
715 |
|
} |
716 |
|
|
717 |
int main() |
int main() |
718 |
{ |
{ |