/[cvs]/stack/stack.c
ViewVC logotype

Diff of /stack/stack.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.48 by teddy, Thu Feb 7 04:34:42 2002 UTC revision 1.62 by teddy, Fri Feb 8 06:23:19 2002 UTC
# Line 1  Line 1 
1  /* printf */  /* printf, sscanf, fgets, fprintf */
2  #include <stdio.h>  #include <stdio.h>
3  /* EXIT_SUCCESS */  /* exit, EXIT_SUCCESS, malloc, free */
4  #include <stdlib.h>  #include <stdlib.h>
5  /* NULL */  /* NULL */
6  #include <stddef.h>  #include <stddef.h>
7  /* dlopen, dlsym, dlerror */  /* dlopen, dlsym, dlerror */
8  #include <dlfcn.h>  #include <dlfcn.h>
9  /* assert */  /* strcmp, strcpy, strlen, strcat, strdup */
 #include <assert.h>  
 /* strcat */  
10  #include <string.h>  #include <string.h>
11    
12  #define HASHTBLSIZE 65536  #define HASHTBLSIZE 65536
# Line 50  typedef symbol *hashtbl[HASHTBLSIZE]; /* Line 48  typedef symbol *hashtbl[HASHTBLSIZE]; /*
48  typedef struct stackitem_struct  typedef struct stackitem_struct
49  {  {
50    value *item;                  /* The value on the stack */    value *item;                  /* The value on the stack */
51                                    /* (This is never NULL) */
52    struct stackitem_struct *next; /* Next item */    struct stackitem_struct *next; /* Next item */
53  } stackitem;  } stackitem;
54    
# Line 101  void free_val(value *val){ Line 100  void free_val(value *val){
100        }        }
101        free(val);                /* Free the actual list value */        free(val);                /* Free the actual list value */
102        break;        break;
103      default:      case integer:
104        case func:
105        case symb:
106        break;        break;
107      }      }
108    }    }
# Line 198  void push_cstring(stackitem **stack_head Line 199  void push_cstring(stackitem **stack_head
199  }  }
200    
201  /* Mangle a symbol name to a valid C identifier name */  /* Mangle a symbol name to a valid C identifier name */
202  char *mangle_(const char *old_string){  char *mangle_str(const char *old_string){
203    char validchars[]    char validchars[]
204      ="0123456789abcdef";      ="0123456789abcdef";
205    char *new_string, *current;    char *new_string, *current;
206    
207    new_string=malloc(strlen(old_string)+4);    new_string=malloc((strlen(old_string)*2)+4);
208    strcpy(new_string, "sx_");    /* Stack eXternal */    strcpy(new_string, "sx_");    /* Stack eXternal */
209    current=new_string+3;    current=new_string+3;
210    while(old_string[0] != '\0'){    while(old_string[0] != '\0'){
211      current[0]=validchars[old_string[0]/16];      current[0]=validchars[(unsigned char)(old_string[0])/16];
212      current[1]=validchars[old_string[0]%16];      current[1]=validchars[(unsigned char)(old_string[0])%16];
213      current+=2;      current+=2;
214      old_string++;      old_string++;
215    }    }
# Line 233  extern void mangle(environment *env){ Line 234  extern void mangle(environment *env){
234      return;      return;
235    }    }
236    
237    new_string= mangle_((const char *)(env->head->item->content.ptr));    new_string= mangle_str((const char *)(env->head->item->content.ptr));
238    
239    toss(env);    toss(env);
240    if(env->err) return;    if(env->err) return;
# Line 296  void push_sym(environment *env, const ch Line 297  void push_sym(environment *env, const ch
297      funcptr= dlsym(handle, in_string); /* Get function pointer */      funcptr= dlsym(handle, in_string); /* Get function pointer */
298      dlerr=dlerror();      dlerr=dlerror();
299      if(dlerr != NULL) {         /* If no function was found */      if(dlerr != NULL) {         /* If no function was found */
300        mangled=mangle_(in_string);        mangled=mangle_str(in_string);
301        funcptr= dlsym(handle, mangled); /* try mangling it */        funcptr= dlsym(handle, mangled); /* try mangling it */
302        free(mangled);        free(mangled);
303        dlerr=dlerror();        dlerr=dlerror();
# Line 346  extern void type(environment *env){ Line 347  extern void type(environment *env){
347    case list:    case list:
348      push_sym(env, "list");      push_sym(env, "list");
349      break;      break;
   default:  
     push_sym(env, "unknown");  
     break;  
350    }    }
351  }      }    
352    
# Line 360  void print_h(stackitem *stack_head) Line 358  void print_h(stackitem *stack_head)
358      printf("%d", stack_head->item->content.val);      printf("%d", stack_head->item->content.val);
359      break;      break;
360    case string:    case string:
361      printf("\"%s\"", (char*)stack_head->item->content.ptr);      printf("%s", (char*)stack_head->item->content.ptr);
362      break;      break;
363    case symb:    case symb:
364      printf("%s", ((symbol *)(stack_head->item->content.ptr))->id);      printf("%s", ((symbol *)(stack_head->item->content.ptr))->id);
# Line 379  void print_h(stackitem *stack_head) Line 377  void print_h(stackitem *stack_head)
377      }      }
378      printf("]");      printf("]");
379      break;      break;
   default:  
     printf("#<unknown %p>", (stack_head->item->content.ptr));  
     break;  
380    }    }
381  }  }
382    
# Line 438  extern void swap(environment *env) Line 433  extern void swap(environment *env)
433    env->head->next= temp;    env->head->next= temp;
434  }  }
435    
436    /* Rotate the first three elements on the stack. */
437    extern void rot(environment *env)
438    {
439      stackitem *temp= env->head;
440      
441      if(env->head==NULL || env->head->next==NULL
442          || env->head->next->next==NULL) {
443        printerr("Too Few Arguments");
444        env->err=1;
445        return;
446      }
447    
448      env->head= env->head->next->next;
449      temp->next->next= env->head->next;
450      env->head->next= temp;
451    }
452    
453  /* Recall a value from a symbol, if bound */  /* Recall a value from a symbol, if bound */
454  extern void rcl(environment *env)  extern void rcl(environment *env)
455  {  {
# Line 490  extern void eval(environment *env) Line 502  extern void eval(environment *env)
502      rcl(env);                   /* get its contents */      rcl(env);                   /* get its contents */
503      if(env->err) return;      if(env->err) return;
504      if(env->head->item->type!=symb){ /* don't recurse symbols */      if(env->head->item->type!=symb){ /* don't recurse symbols */
505        eval(env);                        /* evaluate the value */        return eval(env);         /* evaluate the value */
       return;  
506      }      }
507      break;      return;
508    
509      /* If it's a lone function value, run it */      /* If it's a lone function value, run it */
510    case func:    case func:
511      in_func= (funcp)(env->head->item->content.ptr);      in_func= (funcp)(env->head->item->content.ptr);
512      toss(env);      toss(env);
513      if(env->err) return;      if(env->err) return;
514      (*in_func)(env);      return (*in_func)(env);
     break;  
515    
516      /* If it's a list */      /* If it's a list */
517    case list:    case list:
# Line 510  extern void eval(environment *env) Line 520  extern void eval(environment *env)
520      toss(env);      toss(env);
521      if(env->err) return;      if(env->err) return;
522      iterator= (stackitem*)temp_val->content.ptr;      iterator= (stackitem*)temp_val->content.ptr;
523      while(iterator!=NULL && iterator->item!=NULL) {      while(iterator!=NULL) {
524        push_val(&(env->head), iterator->item);        push_val(&(env->head), iterator->item);
525        if(env->head->item->type==symb        if(env->head->item->type==symb
526          && strcmp(";", ((symbol*)(env->head->item->content.ptr))->id)==0) {          && strcmp(";", ((symbol*)(env->head->item->content.ptr))->id)==0) {
527          toss(env);          toss(env);
528          if(env->err) return;          if(env->err) return;
529            if(iterator->next == NULL){
530              free_val(temp_val);
531              return eval(env);
532            }
533          eval(env);          eval(env);
534          if(env->err) return;          if(env->err) return;
535        }        }
536        iterator= iterator->next;        iterator= iterator->next;
537      }      }
538      free_val(temp_val);      free_val(temp_val);
539      break;      return;
540    
541      /* If it's a string */      /* If it's a string */
542    case string:    case string:
# Line 531  extern void eval(environment *env) Line 545  extern void eval(environment *env)
545      toss(env);      toss(env);
546      if(env->err) return;      if(env->err) return;
547      temp_string= malloc(strlen((char*)temp_val->content.ptr)+5);      temp_string= malloc(strlen((char*)temp_val->content.ptr)+5);
548      strcat(temp_string, "[ ");      strcpy(temp_string, "[ ");
549      strcat(temp_string, (char*)temp_val->content.ptr);      strcpy(temp_string+2, (char*)temp_val->content.ptr);
550        free_val(temp_val);
551      strcat(temp_string, " ]");      strcat(temp_string, " ]");
552      stack_read(env, temp_string);      stack_read(env, temp_string);
     eval(env);  
     if(env->err) return;  
     free_val(temp_val);  
553      free(temp_string);      free(temp_string);
554      break;      return eval(env);
555    
556    default:    case integer:
557        return;
558    }    }
559  }  }
560    
# Line 905  int main() Line 918  int main()
918  /* + */  /* + */
919  extern void sx_2b(environment *env) {  extern void sx_2b(environment *env) {
920    int a, b;    int a, b;
921      size_t len;
922      char* new_string;
923      value *a_val, *b_val;
924    
925      if((env->head)==NULL || env->head->next==NULL) {
926        printerr("Too Few Arguments");
927        env->err=1;
928        return;
929      }
930    
931      if(env->head->item->type==string
932         && env->head->next->item->type==string) {
933        a_val= env->head->item;
934        b_val= env->head->next->item;
935        a_val->refcount++;
936        b_val->refcount++;
937        toss(env); if(env->err) return;
938        toss(env); if(env->err) return;
939        len= strlen(a_val->content.ptr)+strlen(b_val->content.ptr)+1;
940        new_string= malloc(len);
941        strcpy(new_string, b_val->content.ptr);
942        strcat(new_string, a_val->content.ptr);
943        free_val(a_val); free_val(b_val);
944        push_cstring(&(env->head), new_string);
945        free(new_string);
946        return;
947      }
948      
949      if(env->head->item->type!=integer
950         || env->head->next->item->type!=integer) {
951        printerr("Bad Argument Type");
952        env->err=2;
953        return;
954      }
955      a=env->head->item->content.val;
956      toss(env);
957      if(env->err) return;
958      if(env->head->item->refcount == 1)
959        env->head->item->content.val += a;
960      else {
961        b=env->head->item->content.val;
962        toss(env);
963        if(env->err) return;
964        push_int(&(env->head), a+b);
965      }
966    }
967    
968    /* - */
969    extern void sx_2d(environment *env) {
970      int a, b;
971    
972      if((env->head)==NULL || env->head->next==NULL) {
973        printerr("Too Few Arguments");
974        env->err=1;
975        return;
976      }
977      
978      if(env->head->item->type!=integer
979         || env->head->next->item->type!=integer) {
980        printerr("Bad Argument Type");
981        env->err=2;
982        return;
983      }
984      a=env->head->item->content.val;
985      toss(env);
986      if(env->err) return;
987      if(env->head->item->refcount == 1)
988        env->head->item->content.val -= a;
989      else {
990        b=env->head->item->content.val;
991        toss(env);
992        if(env->err) return;
993        push_int(&(env->head), b-a);
994      }
995    }
996    
997    /* > */
998    extern void sx_3e(environment *env) {
999      int a, b;
1000    
1001    if((env->head)==NULL || env->head->next==NULL) {    if((env->head)==NULL || env->head->next==NULL) {
1002      printerr("Too Few Arguments");      printerr("Too Few Arguments");
# Line 921  extern void sx_2b(environment *env) { Line 1013  extern void sx_2b(environment *env) {
1013    a=env->head->item->content.val;    a=env->head->item->content.val;
1014    toss(env);    toss(env);
1015    if(env->err) return;    if(env->err) return;
1016    b=env->head->item->content.val;    if(env->head->item->refcount == 1)
1017        env->head->item->content.val = (env->head->item->content.val > a);
1018      else {
1019        b=env->head->item->content.val;
1020        toss(env);
1021        if(env->err) return;
1022        push_int(&(env->head), b>a);
1023      }
1024    }
1025    
1026    /* Return copy of a value */
1027    value *copy_val(value *old_value){
1028      stackitem *old_item, *new_item, *prev_item;
1029    
1030      value *new_value=malloc(sizeof(value));
1031    
1032      new_value->type=old_value->type;
1033      new_value->refcount=0;        /* This is increased if/when this
1034                                       value is referenced somewhere, like
1035                                       in a stack item or a variable */
1036      switch(old_value->type){
1037      case integer:
1038        new_value->content.val=old_value->content.val;
1039        break;
1040      case string:
1041        (char *)(new_value->content.ptr)
1042          = strdup((char *)(old_value->content.ptr));
1043        break;
1044      case func:
1045      case symb:
1046        new_value->content.ptr=old_value->content.ptr;
1047        break;
1048      case list:
1049        new_value->content.ptr=NULL;
1050    
1051        prev_item=NULL;
1052        old_item=(stackitem *)(old_value->content.ptr);
1053    
1054        while(old_item != NULL) {   /* While list is not empty */
1055          new_item= malloc(sizeof(stackitem));
1056          new_item->item=copy_val(old_item->item); /* recurse */
1057          new_item->next=NULL;
1058          if(prev_item != NULL)     /* If this wasn't the first item */
1059            prev_item->next=new_item; /* point the previous item to the
1060                                         new item */
1061          else
1062            new_value->content.ptr=new_item;
1063          old_item=old_item->next;
1064          prev_item=new_item;
1065        }    
1066        break;
1067      }
1068      return new_value;
1069    }
1070    
1071    /* duplicates an item on the stack */
1072    extern void dup(environment *env) {
1073      if((env->head)==NULL) {
1074        printerr("Too Few Arguments");
1075        env->err=1;
1076        return;
1077      }
1078      push_val(&(env->head), copy_val(env->head->item));
1079    }
1080    
1081    /* "if", If-Then */
1082    extern void sx_6966(environment *env) {
1083    
1084      int truth;
1085    
1086      if((env->head)==NULL || env->head->next==NULL) {
1087        printerr("Too Few Arguments");
1088        env->err=1;
1089        return;
1090      }
1091    
1092      if(env->head->next->item->type != integer) {
1093        printerr("Bad Argument Type");
1094        env->err=2;
1095        return;
1096      }
1097      
1098      swap(env);
1099      if(env->err) return;
1100      
1101      truth=env->head->item->content.val;
1102    
1103      toss(env);
1104      if(env->err) return;
1105    
1106      if(truth)
1107        eval(env);
1108      else
1109        toss(env);
1110    }
1111    
1112    /* If-Then-Else */
1113    extern void ifelse(environment *env) {
1114    
1115      int truth;
1116    
1117      if((env->head)==NULL || env->head->next==NULL
1118         || env->head->next->next==NULL) {
1119        printerr("Too Few Arguments");
1120        env->err=1;
1121        return;
1122      }
1123    
1124      if(env->head->next->next->item->type != integer) {
1125        printerr("Bad Argument Type");
1126        env->err=2;
1127        return;
1128      }
1129      
1130      rot(env);
1131      if(env->err) return;
1132      
1133      truth=env->head->item->content.val;
1134    
1135      toss(env);
1136      if(env->err) return;
1137    
1138      if(!truth)
1139        swap(env);
1140      if(env->err) return;
1141    
1142    toss(env);    toss(env);
1143    if(env->err) return;    if(env->err) return;
1144    push_int(&(env->head), a+b);  
1145      eval(env);
1146    }
1147    
1148    /* while */
1149    extern void sx_7768696c65(environment *env) {
1150    
1151      int truth;
1152    
1153      if((env->head)==NULL || env->head->next==NULL) {
1154        printerr("Too Few Arguments");
1155        env->err=1;
1156        return;
1157      }
1158    
1159      do {
1160        swap(env); if(env->err) return;
1161        dup(env); if(env->err) return;
1162        eval(env); if(env->err) return;
1163        
1164        if(env->head->item->type != integer) {
1165          printerr("Bad Argument Type");
1166          env->err=2;
1167          return;
1168        }
1169        
1170        truth= env->head->item->content.val;
1171        
1172        toss(env); if(env->err) return;
1173        swap(env); if(env->err) return;
1174        
1175        if(truth) {
1176          dup(env);
1177          eval(env);
1178        } else {
1179          toss(env);
1180          toss(env);
1181        }
1182      
1183      } while(truth);
1184  }  }
Legend:
Removed from v.1.48  
changed lines
  Added in v.1.62
root@recompile.se
 ViewVC Help
Powered by ViewVC 1.1.26