18 |
enum { |
enum { |
19 |
integer, |
integer, |
20 |
string, |
string, |
|
ref, /* Reference (to an element in the |
|
|
hash table) */ |
|
21 |
func, /* Function pointer */ |
func, /* Function pointer */ |
22 |
symb, |
symb, |
23 |
list |
list |
68 |
{ |
{ |
69 |
long i; |
long i; |
70 |
|
|
71 |
|
env->err=0; |
72 |
for(i= 0; i<HASHTBLSIZE; i++) |
for(i= 0; i<HASHTBLSIZE; i++) |
73 |
env->symbols[i]= NULL; |
env->symbols[i]= NULL; |
74 |
} |
} |
103 |
} |
} |
104 |
|
|
105 |
/* Generic push function. */ |
/* Generic push function. */ |
106 |
int push(stackitem** stack_head, stackitem* in_item) |
void push(stackitem** stack_head, stackitem* in_item) |
107 |
{ |
{ |
108 |
in_item->next= *stack_head; |
in_item->next= *stack_head; |
109 |
*stack_head= in_item; |
*stack_head= in_item; |
|
return 1; |
|
110 |
} |
} |
111 |
|
|
112 |
/* Push a value onto the stack */ |
/* Push a value onto the stack */ |
119 |
} |
} |
120 |
|
|
121 |
/* Push an integer onto the stack. */ |
/* Push an integer onto the stack. */ |
122 |
int push_int(stackitem **stack_head, int in_val) |
void push_int(stackitem **stack_head, int in_val) |
123 |
{ |
{ |
124 |
value *new_value= malloc(sizeof(value)); |
value *new_value= malloc(sizeof(value)); |
125 |
stackitem *new_item= malloc(sizeof(stackitem)); |
stackitem *new_item= malloc(sizeof(stackitem)); |
130 |
new_value->refcount=1; |
new_value->refcount=1; |
131 |
|
|
132 |
push(stack_head, new_item); |
push(stack_head, new_item); |
|
return 1; |
|
133 |
} |
} |
134 |
|
|
135 |
/* Copy a string onto the stack. */ |
/* Copy a string onto the stack. */ |
136 |
int push_cstring(stackitem **stack_head, const char *in_string) |
void push_cstring(stackitem **stack_head, const char *in_string) |
137 |
{ |
{ |
138 |
value *new_value= malloc(sizeof(value)); |
value *new_value= malloc(sizeof(value)); |
139 |
stackitem *new_item= malloc(sizeof(stackitem)); |
stackitem *new_item= malloc(sizeof(stackitem)); |
145 |
new_value->refcount=1; |
new_value->refcount=1; |
146 |
|
|
147 |
push(stack_head, new_item); |
push(stack_head, new_item); |
|
return 1; |
|
148 |
} |
} |
149 |
|
|
150 |
/* Push a symbol onto the stack. */ |
/* Push a symbol onto the stack. */ |
151 |
int push_sym(environment *env, const char *in_string) |
void push_sym(environment *env, const char *in_string) |
152 |
{ |
{ |
153 |
stackitem *new_item; /* The new stack item */ |
stackitem *new_item; /* The new stack item */ |
154 |
/* ...which will contain... */ |
/* ...which will contain... */ |
203 |
} |
} |
204 |
} |
} |
205 |
push(&(env->head), new_item); |
push(&(env->head), new_item); |
|
return 1; |
|
206 |
} |
} |
207 |
|
|
208 |
void printerr(const char* in_string) { |
void printerr(const char* in_string) { |
218 |
switch (val->type){ /* and free the contents if necessary */ |
switch (val->type){ /* and free the contents if necessary */ |
219 |
case string: |
case string: |
220 |
free(val->content.ptr); |
free(val->content.ptr); |
221 |
|
break; |
222 |
case list: /* lists needs to be freed recursively */ |
case list: /* lists needs to be freed recursively */ |
223 |
item=val->content.ptr; |
item=val->content.ptr; |
224 |
while(item != NULL) { /* for all stack items */ |
while(item != NULL) { /* for all stack items */ |
241 |
stackitem *temp= env->head; |
stackitem *temp= env->head; |
242 |
|
|
243 |
if((env->head)==NULL) { |
if((env->head)==NULL) { |
244 |
printerr("Stack empty"); |
printerr("Too Few Arguments"); |
245 |
|
env->err=1; |
246 |
return; |
return; |
247 |
} |
} |
248 |
|
|
252 |
} |
} |
253 |
|
|
254 |
/* Print newline. */ |
/* Print newline. */ |
255 |
extern void nl(environment *env) |
extern void nl() |
256 |
{ |
{ |
257 |
printf("\n"); |
printf("\n"); |
258 |
} |
} |
259 |
|
|
260 |
/* Prints the top element of the stack. */ |
/* Gets the type of a value */ |
261 |
void print_h(stackitem *stack_head) |
extern void type(environment *env){ |
262 |
{ |
int typenum; |
263 |
|
|
264 |
if(stack_head==NULL) { |
if((env->head)==NULL) { |
265 |
printerr("Stack empty"); |
printerr("Too Few Arguments"); |
266 |
|
env->err=1; |
267 |
return; |
return; |
268 |
} |
} |
269 |
|
typenum=env->head->item->type; |
270 |
|
toss(env); |
271 |
|
switch(typenum){ |
272 |
|
case integer: |
273 |
|
push_sym(env, "integer"); |
274 |
|
break; |
275 |
|
case string: |
276 |
|
push_sym(env, "string"); |
277 |
|
break; |
278 |
|
case symb: |
279 |
|
push_sym(env, "symbol"); |
280 |
|
break; |
281 |
|
case func: |
282 |
|
push_sym(env, "function"); |
283 |
|
break; |
284 |
|
case list: |
285 |
|
push_sym(env, "list"); |
286 |
|
break; |
287 |
|
default: |
288 |
|
push_sym(env, "unknown"); |
289 |
|
break; |
290 |
|
} |
291 |
|
} |
292 |
|
|
293 |
|
/* Prints the top element of the stack. */ |
294 |
|
void print_h(stackitem *stack_head) |
295 |
|
{ |
296 |
switch(stack_head->item->type) { |
switch(stack_head->item->type) { |
297 |
case integer: |
case integer: |
298 |
printf("%d", stack_head->item->content.val); |
printf("%d", stack_head->item->content.val); |
303 |
case symb: |
case symb: |
304 |
printf("'%s'", ((symbol *)(stack_head->item->content.ptr))->id); |
printf("'%s'", ((symbol *)(stack_head->item->content.ptr))->id); |
305 |
break; |
break; |
306 |
|
case func: |
307 |
|
printf("#<function %p>", (funcp)(stack_head->item->content.ptr)); |
308 |
|
break; |
309 |
|
case list: |
310 |
|
/* A list is just a stack, so make stack_head point to it */ |
311 |
|
stack_head=(stackitem *)(stack_head->item->content.ptr); |
312 |
|
printf("[ "); |
313 |
|
while(stack_head != NULL) { |
314 |
|
print_h(stack_head); |
315 |
|
printf(" "); |
316 |
|
stack_head=stack_head->next; |
317 |
|
} |
318 |
|
printf("]"); |
319 |
|
break; |
320 |
default: |
default: |
321 |
printf("%p", (funcp)(stack_head->item->content.ptr)); |
printf("#<unknown %p>", (stack_head->item->content.ptr)); |
322 |
break; |
break; |
323 |
} |
} |
324 |
} |
} |
325 |
|
|
326 |
extern void print_(environment *env) { |
extern void print_(environment *env) { |
327 |
|
if(env->head==NULL) { |
328 |
|
printerr("Too Few Arguments"); |
329 |
|
env->err=1; |
330 |
|
return; |
331 |
|
} |
332 |
print_h(env->head); |
print_h(env->head); |
333 |
} |
} |
334 |
|
|
336 |
extern void print(environment *env) |
extern void print(environment *env) |
337 |
{ |
{ |
338 |
print_(env); |
print_(env); |
339 |
|
if(env->err) return; |
340 |
toss(env); |
toss(env); |
341 |
} |
} |
342 |
|
|
355 |
/* Prints the stack. */ |
/* Prints the stack. */ |
356 |
extern void printstack(environment *env) |
extern void printstack(environment *env) |
357 |
{ |
{ |
358 |
if(env->head != NULL) { |
if(env->head == NULL) { |
359 |
print_st(env->head, 1); |
return; |
|
nl(); |
|
|
} else { |
|
|
printerr("Stack empty"); |
|
360 |
} |
} |
361 |
|
print_st(env->head, 1); |
362 |
|
nl(); |
363 |
} |
} |
364 |
|
|
365 |
/* Swap the two top elements on the stack. */ |
/* Swap the two top elements on the stack. */ |
368 |
stackitem *temp= env->head; |
stackitem *temp= env->head; |
369 |
|
|
370 |
if((env->head)==NULL) { |
if((env->head)==NULL) { |
371 |
printerr("Stack empty"); |
printerr("Too Few Arguments"); |
372 |
|
env->err=1; |
373 |
return; |
return; |
374 |
} |
} |
375 |
|
|
376 |
if(env->head->next==NULL) { |
if(env->head->next==NULL) { |
377 |
printerr("Not enough arguments"); |
printerr("Too Few Arguments"); |
378 |
|
env->err=1; |
379 |
return; |
return; |
380 |
} |
} |
381 |
|
|
400 |
value *val; |
value *val; |
401 |
|
|
402 |
if(env->head == NULL) { |
if(env->head == NULL) { |
403 |
printerr("Stack empty"); |
printerr("Too Few Arguments"); |
404 |
|
env->err=1; |
405 |
return; |
return; |
406 |
} |
} |
407 |
|
|
408 |
if(env->head->item->type!=symb) { |
if(env->head->item->type!=symb) { |
409 |
printerr("Not a symbol"); |
printerr("Bad Argument Type"); |
410 |
|
env->err=2; |
411 |
return; |
return; |
412 |
} |
} |
413 |
|
|
414 |
val=((symbol *)(env->head->item->content.ptr))->val; |
val=((symbol *)(env->head->item->content.ptr))->val; |
415 |
if(val == NULL){ |
if(val == NULL){ |
416 |
printerr("Unbound variable"); |
printerr("Unbound Variable"); |
417 |
|
env->err=3; |
418 |
return; |
return; |
419 |
} |
} |
420 |
toss(env); /* toss the symbol */ |
toss(env); /* toss the symbol */ |
421 |
|
if(env->err) return; |
422 |
push_val(&(env->head), val); /* Return its bound value */ |
push_val(&(env->head), val); /* Return its bound value */ |
423 |
} |
} |
424 |
|
|
428 |
extern void eval(environment *env) |
extern void eval(environment *env) |
429 |
{ |
{ |
430 |
funcp in_func; |
funcp in_func; |
|
value* val; |
|
431 |
if(env->head==NULL) { |
if(env->head==NULL) { |
432 |
printerr("Stack empty"); |
printerr("Too Few Arguments"); |
433 |
|
env->err=1; |
434 |
return; |
return; |
435 |
} |
} |
436 |
|
|
437 |
/* if it's a symbol */ |
/* if it's a symbol */ |
438 |
if(env->head->item->type==symb) { |
if(env->head->item->type==symb) { |
439 |
|
|
440 |
/* If it's not bound to anything */ |
rcl(env); /* get its contents */ |
441 |
if (((symbol *)(env->head->item->content.ptr))->val == NULL) { |
if(env->err) return; |
442 |
printerr("Unbound variable"); |
if(env->head->item->type!=symb){ /* don't recurse symbols */ |
443 |
|
eval(env); /* evaluate the value */ |
444 |
return; |
return; |
445 |
} |
} |
|
|
|
|
/* If it contains a function */ |
|
|
if (((symbol *)(env->head->item->content.ptr))->val->type == func) { |
|
|
in_func= |
|
|
(funcp)(((symbol *)(env->head->item->content.ptr))->val->content.ptr); |
|
|
toss(env); |
|
|
(*in_func)(env); /* Run the function */ |
|
|
return; |
|
|
} else { /* If it's not a function */ |
|
|
val=((symbol *)(env->head->item->content.ptr))->val; |
|
|
toss(env); /* toss the symbol */ |
|
|
push_val(&(env->head), val); /* Return its bound value */ |
|
|
} |
|
446 |
} |
} |
447 |
|
|
448 |
/* If it's a lone function value, run it */ |
/* If it's a lone function value, run it */ |
449 |
if(env->head->item->type==func) { |
if(env->head->item->type==func) { |
450 |
in_func= (funcp)(env->head->item->content.ptr); |
in_func= (funcp)(env->head->item->content.ptr); |
451 |
toss(env); |
toss(env); |
452 |
|
if(env->err) return; |
453 |
(*in_func)(env); |
(*in_func)(env); |
454 |
|
} |
455 |
|
} |
456 |
|
|
457 |
|
/* Reverse a list */ |
458 |
|
extern void rev(environment *env){ |
459 |
|
stackitem *old_head, *new_head, *item; |
460 |
|
|
461 |
|
if((env->head)==NULL) { |
462 |
|
printerr("Too Few Arguments"); |
463 |
|
env->err=1; |
464 |
return; |
return; |
465 |
} |
} |
466 |
|
|
467 |
|
if(env->head->item->type!=list) { |
468 |
|
printerr("Bad Argument Type"); |
469 |
|
env->err=2; |
470 |
|
return; |
471 |
|
} |
472 |
|
|
473 |
|
old_head=(stackitem *)(env->head->item->content.ptr); |
474 |
|
new_head=NULL; |
475 |
|
while(old_head != NULL){ |
476 |
|
item=old_head; |
477 |
|
old_head=old_head->next; |
478 |
|
item->next=new_head; |
479 |
|
new_head=item; |
480 |
|
} |
481 |
|
env->head->item->content.ptr=new_head; |
482 |
} |
} |
483 |
|
|
484 |
/* Make a list. */ |
/* Make a list. */ |
521 |
temp->item= pack; |
temp->item= pack; |
522 |
|
|
523 |
push(&(env->head), temp); |
push(&(env->head), temp); |
524 |
|
rev(env); |
525 |
} |
} |
526 |
|
|
527 |
/* Parse input. */ |
/* Parse input. */ |
528 |
int stack_read(environment *env, char *in_line) |
void stack_read(environment *env, char *in_line) |
529 |
{ |
{ |
530 |
char *temp, *rest; |
char *temp, *rest; |
531 |
int itemp; |
int itemp; |
537 |
rest= malloc(inlength); |
rest= malloc(inlength); |
538 |
|
|
539 |
do { |
do { |
540 |
|
/* If comment */ |
541 |
|
if((convert= sscanf(in_line, "#%[^\n\r]", rest))) { |
542 |
|
free(temp); free(rest); |
543 |
|
return; |
544 |
|
} |
545 |
|
|
546 |
/* If string */ |
/* If string */ |
547 |
if((convert= sscanf(in_line, "\"%[^\"\n\r]\" %[^\n\r]", temp, rest))) { |
if((convert= sscanf(in_line, "\"%[^\"\n\r]\" %[^\n\r]", temp, rest))) { |
548 |
push_cstring(&(env->head), temp); |
push_cstring(&(env->head), temp); |
560 |
break; |
break; |
561 |
} |
} |
562 |
/* If symbol */ |
/* If symbol */ |
563 |
if((convert= sscanf(in_line, "%[^][ ;\n\r_]%[^\n\r]", temp, rest))) { |
if((convert= sscanf(in_line, "%[^][ ;\n\r]%[^\n\r]", temp, rest))) { |
564 |
push_sym(env, temp); |
push_sym(env, temp); |
565 |
break; |
break; |
566 |
} |
} |
592 |
} |
} |
593 |
} while(0); |
} while(0); |
594 |
|
|
|
|
|
595 |
free(temp); |
free(temp); |
596 |
|
|
597 |
if(convert<2) { |
if(convert<2) { |
598 |
free(rest); |
free(rest); |
599 |
return 0; |
return; |
600 |
} |
} |
601 |
|
|
602 |
stack_read(env, rest); |
stack_read(env, rest); |
603 |
|
|
604 |
free(rest); |
free(rest); |
|
return 1; |
|
605 |
} |
} |
606 |
|
|
607 |
/* Relocate elements of the list on the stack. */ |
/* Relocate elements of the list on the stack. */ |
610 |
stackitem *temp, *new_head; |
stackitem *temp, *new_head; |
611 |
|
|
612 |
/* Is top element a list? */ |
/* Is top element a list? */ |
613 |
if(env->head==NULL || env->head->item->type!=list) { |
if(env->head==NULL) { |
614 |
printerr("Stack empty or not a list"); |
printerr("Too Few Arguments"); |
615 |
|
env->err=1; |
616 |
return; |
return; |
617 |
} |
} |
618 |
|
if(env->head->item->type!=list) { |
619 |
|
printerr("Bad Argument Type"); |
620 |
|
env->err=2; |
621 |
|
return; |
622 |
|
} |
623 |
|
|
624 |
|
rev(env); |
625 |
|
|
626 |
|
if(env->err) |
627 |
|
return; |
628 |
|
|
629 |
/* The first list element is the new stack head */ |
/* The first list element is the new stack head */ |
630 |
new_head= temp= env->head->item->content.ptr; |
new_head= temp= env->head->item->content.ptr; |
649 |
int result; |
int result; |
650 |
|
|
651 |
if((env->head)==NULL || env->head->next==NULL) { |
if((env->head)==NULL || env->head->next==NULL) { |
652 |
printerr("Not enough elements to compare"); |
printerr("Too Few Arguments"); |
653 |
|
env->err=1; |
654 |
return; |
return; |
655 |
} |
} |
656 |
|
|
668 |
{ |
{ |
669 |
int val; |
int val; |
670 |
|
|
671 |
if((env->head)==NULL || env->head->item->type!=integer) { |
if((env->head)==NULL) { |
672 |
printerr("Stack empty or element is not a integer"); |
printerr("Too Few Arguments"); |
673 |
|
env->err=1; |
674 |
|
return; |
675 |
|
} |
676 |
|
|
677 |
|
if(env->head->item->type!=integer) { |
678 |
|
printerr("Bad Argument Type"); |
679 |
|
env->err=2; |
680 |
return; |
return; |
681 |
} |
} |
682 |
|
|
699 |
symbol *sym; |
symbol *sym; |
700 |
|
|
701 |
/* 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 */ |
702 |
if(env->head==NULL || env->head->next==NULL |
if(env->head==NULL || env->head->next==NULL) { |
703 |
|| env->head->item->type!=symb) { |
printerr("Too Few Arguments"); |
704 |
printerr("Define what?"); |
env->err=1; |
705 |
|
return; |
706 |
|
} |
707 |
|
|
708 |
|
if(env->head->item->type!=symb) { |
709 |
|
printerr("Bad Argument Type"); |
710 |
|
env->err=2; |
711 |
return; |
return; |
712 |
} |
} |
713 |
|
|
753 |
} |
} |
754 |
} |
} |
755 |
|
|
756 |
|
/* Forgets a symbol (remove it from the hash table) */ |
757 |
|
extern void forget(environment *env) |
758 |
|
{ |
759 |
|
char* sym_id; |
760 |
|
stackitem *stack_head= env->head; |
761 |
|
symbol **hash_entry, *temp; |
762 |
|
|
763 |
|
if(stack_head==NULL) { |
764 |
|
printerr("Too Few Arguments"); |
765 |
|
env->err=1; |
766 |
|
return; |
767 |
|
} |
768 |
|
|
769 |
|
if(stack_head->item->type!=symb) { |
770 |
|
printerr("Bad Argument Type"); |
771 |
|
env->err=2; |
772 |
|
return; |
773 |
|
} |
774 |
|
|
775 |
|
sym_id= ((symbol*)(stack_head->item->content.ptr))->id; |
776 |
|
toss(env); |
777 |
|
|
778 |
|
hash_entry= hash(env->symbols, sym_id); |
779 |
|
temp= *hash_entry; |
780 |
|
*hash_entry= (*hash_entry)->next; |
781 |
|
|
782 |
|
if(temp->val!=NULL) { |
783 |
|
free_val(temp->val); |
784 |
|
} |
785 |
|
free(temp->id); |
786 |
|
free(temp); |
787 |
|
} |
788 |
|
|
789 |
|
/* Returns the current error number to the stack */ |
790 |
|
extern void errn(environment *env){ |
791 |
|
push_int(&(env->head), env->err); |
792 |
|
} |
793 |
|
|
794 |
int main() |
int main() |
795 |
{ |
{ |
796 |
environment myenv; |
environment myenv; |
802 |
|
|
803 |
while(fgets(in_string, 100, stdin) != NULL) { |
while(fgets(in_string, 100, stdin) != NULL) { |
804 |
stack_read(&myenv, in_string); |
stack_read(&myenv, in_string); |
805 |
|
if(myenv.err) { |
806 |
|
printf("(error %d) ", myenv.err); |
807 |
|
myenv.err=0; |
808 |
|
} |
809 |
printf("okidok\n "); |
printf("okidok\n "); |
810 |
} |
} |
811 |
|
quit(&myenv); |
812 |
exit(EXIT_SUCCESS); |
return EXIT_FAILURE; |
813 |
} |
} |