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 */ |
257 |
printf("\n"); |
printf("\n"); |
258 |
} |
} |
259 |
|
|
260 |
|
/* Gets the type of a value */ |
261 |
|
extern void type(environment *env){ |
262 |
|
int typenum; |
263 |
|
|
264 |
|
if((env->head)==NULL) { |
265 |
|
printerr("Too Few Arguments"); |
266 |
|
env->err=1; |
267 |
|
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. */ |
/* Prints the top element of the stack. */ |
294 |
void print_h(stackitem *stack_head) |
void print_h(stackitem *stack_head) |
295 |
{ |
{ |
301 |
printf("\"%s\"", (char*)stack_head->item->content.ptr); |
printf("\"%s\"", (char*)stack_head->item->content.ptr); |
302 |
break; |
break; |
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: |
case func: |
307 |
printf("#<function %p>", (funcp)(stack_head->item->content.ptr)); |
printf("#<function %p>", (funcp)(stack_head->item->content.ptr)); |
308 |
break; |
break; |
309 |
case list: |
case list: |
310 |
printf("#<list %p>", (funcp)(stack_head->item->content.ptr)); |
/* 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; |
break; |
320 |
default: |
default: |
321 |
printf("#<unknown %p>", (funcp)(stack_head->item->content.ptr)); |
printf("#<unknown %p>", (stack_head->item->content.ptr)); |
322 |
break; |
break; |
323 |
} |
} |
324 |
} |
} |
356 |
extern void printstack(environment *env) |
extern void printstack(environment *env) |
357 |
{ |
{ |
358 |
if(env->head == NULL) { |
if(env->head == NULL) { |
|
printerr("Too Few Arguments"); |
|
|
env->err=1; |
|
359 |
return; |
return; |
360 |
} |
} |
361 |
print_st(env->head, 1); |
print_st(env->head, 1); |
428 |
extern void eval(environment *env) |
extern void eval(environment *env) |
429 |
{ |
{ |
430 |
funcp in_func; |
funcp in_func; |
431 |
|
value* temp_val; |
432 |
|
stackitem* iterator; |
433 |
|
|
434 |
if(env->head==NULL) { |
if(env->head==NULL) { |
435 |
printerr("Too Few Arguments"); |
printerr("Too Few Arguments"); |
436 |
env->err=1; |
env->err=1; |
454 |
toss(env); |
toss(env); |
455 |
if(env->err) return; |
if(env->err) return; |
456 |
(*in_func)(env); |
(*in_func)(env); |
457 |
|
return; |
458 |
|
} |
459 |
|
|
460 |
|
/* If it's a list */ |
461 |
|
if(env->head->item->type==list) { |
462 |
|
temp_val= env->head->item; |
463 |
|
env->head->item->refcount++; |
464 |
|
toss(env); |
465 |
|
if(env->err) return; |
466 |
|
iterator= (stackitem*)temp_val->content.ptr; |
467 |
|
while(iterator!=NULL && iterator->item!=NULL) { |
468 |
|
push_val(&(env->head), iterator->item); |
469 |
|
if(env->head->item->type==symb |
470 |
|
&& strcmp(";", ((symbol*)(env->head->item->content.ptr))->id)==0) { |
471 |
|
toss(env); |
472 |
|
if(env->err) return; |
473 |
|
eval(env); |
474 |
|
} |
475 |
|
iterator= iterator->next; |
476 |
|
} |
477 |
|
free_val(temp_val); |
478 |
|
} |
479 |
|
} |
480 |
|
|
481 |
|
/* Reverse (flip) a list */ |
482 |
|
extern void rev(environment *env){ |
483 |
|
stackitem *old_head, *new_head, *item; |
484 |
|
|
485 |
|
if((env->head)==NULL) { |
486 |
|
printerr("Too Few Arguments"); |
487 |
|
env->err=1; |
488 |
|
return; |
489 |
|
} |
490 |
|
|
491 |
|
if(env->head->item->type!=list) { |
492 |
|
printerr("Bad Argument Type"); |
493 |
|
env->err=2; |
494 |
|
return; |
495 |
|
} |
496 |
|
|
497 |
|
old_head=(stackitem *)(env->head->item->content.ptr); |
498 |
|
new_head=NULL; |
499 |
|
while(old_head != NULL){ |
500 |
|
item=old_head; |
501 |
|
old_head=old_head->next; |
502 |
|
item->next=new_head; |
503 |
|
new_head=item; |
504 |
} |
} |
505 |
|
env->head->item->content.ptr=new_head; |
506 |
} |
} |
507 |
|
|
508 |
/* Make a list. */ |
/* Make a list. */ |
545 |
temp->item= pack; |
temp->item= pack; |
546 |
|
|
547 |
push(&(env->head), temp); |
push(&(env->head), temp); |
548 |
|
rev(env); |
549 |
} |
} |
550 |
|
|
551 |
/* Parse input. */ |
/* Parse input. */ |
552 |
int stack_read(environment *env, char *in_line) |
void stack_read(environment *env, char *in_line) |
553 |
{ |
{ |
554 |
char *temp, *rest; |
char *temp, *rest; |
555 |
int itemp; |
int itemp; |
561 |
rest= malloc(inlength); |
rest= malloc(inlength); |
562 |
|
|
563 |
do { |
do { |
564 |
|
/* If comment */ |
565 |
|
if((convert= sscanf(in_line, "#%[^\n\r]", rest))) { |
566 |
|
free(temp); free(rest); |
567 |
|
return; |
568 |
|
} |
569 |
|
|
570 |
/* If string */ |
/* If string */ |
571 |
if((convert= sscanf(in_line, "\"%[^\"\n\r]\" %[^\n\r]", temp, rest))) { |
if((convert= sscanf(in_line, "\"%[^\"\n\r]\" %[^\n\r]", temp, rest))) { |
572 |
push_cstring(&(env->head), temp); |
push_cstring(&(env->head), temp); |
616 |
} |
} |
617 |
} while(0); |
} while(0); |
618 |
|
|
|
|
|
619 |
free(temp); |
free(temp); |
620 |
|
|
621 |
if(convert<2) { |
if(convert<2) { |
622 |
free(rest); |
free(rest); |
623 |
return 0; |
return; |
624 |
} |
} |
625 |
|
|
626 |
stack_read(env, rest); |
stack_read(env, rest); |
627 |
|
|
628 |
free(rest); |
free(rest); |
|
return 1; |
|
629 |
} |
} |
630 |
|
|
631 |
/* Relocate elements of the list on the stack. */ |
/* Relocate elements of the list on the stack. */ |
645 |
return; |
return; |
646 |
} |
} |
647 |
|
|
648 |
|
rev(env); |
649 |
|
|
650 |
|
if(env->err) |
651 |
|
return; |
652 |
|
|
653 |
/* The first list element is the new stack head */ |
/* The first list element is the new stack head */ |
654 |
new_head= temp= env->head->item->content.ptr; |
new_head= temp= env->head->item->content.ptr; |
655 |
|
|
832 |
} |
} |
833 |
printf("okidok\n "); |
printf("okidok\n "); |
834 |
} |
} |
835 |
|
quit(&myenv); |
836 |
exit(EXIT_SUCCESS); |
return EXIT_FAILURE; |
837 |
} |
} |