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

Diff of /stack/stack.c

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

revision 1.92 by masse, Fri Mar 8 06:44:15 2002 UTC revision 1.93 by masse, Fri Mar 8 16:09:30 2002 UTC
# Line 118  value* new_val(environment *env) { Line 118  value* new_val(environment *env) {
118    stackitem *nitem= malloc(sizeof(stackitem));    stackitem *nitem= malloc(sizeof(stackitem));
119    
120    nval->content.ptr= NULL;    nval->content.ptr= NULL;
   protect(env, nval);  
   
   gc_init(env);  
121    
122    nitem->item= nval;    nitem->item= nval;
123    nitem->next= env->gc_ref;    nitem->next= env->gc_ref;
124    env->gc_ref= nitem;    env->gc_ref= nitem;
125    
126    env->gc_count++;    env->gc_count++;
127    
128      protect(env, nval);
129      gc_init(env);
130    unprotect(env);    unprotect(env);
131    
132    return nval;    return nval;
# Line 151  void gc_mark(value *val) { Line 151  void gc_mark(value *val) {
151  }  }
152    
153  extern void gc_init(environment *env) {  extern void gc_init(environment *env) {
154    stackitem *new_head= NULL, *titem, *iterator= env->gc_ref;    stackitem *new_head= NULL, *titem, *iterator;
155    symbol *tsymb;    symbol *tsymb;
156    int i;    int i;
157    
158    if(env->gc_count < env->gc_limit)    if(env->gc_count < env->gc_limit)
159      return;      return;
160    
161      /* Garb by default */
162      iterator= env->gc_ref;
163    while(iterator!=NULL) {    while(iterator!=NULL) {
164      iterator->item->gc_garb= 1;      iterator->item->gc_garb= 1;
165      iterator= iterator->next;      iterator= iterator->next;
166    }    }
167    
168    /* Mark */    /* Mark protected values */
169    iterator= env->gc_protect;    iterator= env->gc_protect;
170    while(iterator!=NULL) {    while(iterator!=NULL) {
171      gc_mark(iterator->item);      gc_mark(iterator->item);
172      iterator= iterator->next;      iterator= iterator->next;
173    }    }
174    
175      /* Mark values in stack */
176    iterator= env->head;    iterator= env->head;
177    while(iterator!=NULL) {    while(iterator!=NULL) {
178      gc_mark(iterator->item);      gc_mark(iterator->item);
179      iterator= iterator->next;      iterator= iterator->next;
180    }    }
181    
182      /* Mark values in hashtable */
183    for(i= 0; i<HASHTBLSIZE; i++) {    for(i= 0; i<HASHTBLSIZE; i++) {
184      tsymb= env->symbols[i];      tsymb= env->symbols[i];
185      while(tsymb!=NULL) {      while(tsymb!=NULL) {
# Line 190  extern void gc_init(environment *env) { Line 194  extern void gc_init(environment *env) {
194    while(env->gc_ref!=NULL) {    while(env->gc_ref!=NULL) {
195    
196      if(env->gc_ref->item->gc_garb) {      if(env->gc_ref->item->gc_garb) {
197        switch(env->gc_ref->item->type) {  
198          /* Remove content */
199          switch(env->gc_ref->item->type) {
200        case string:        case string:
201          free(env->gc_ref->item->content.ptr);          free(env->gc_ref->item->content.ptr);
202          break;          break;
       case integer:  
         break;  
203        case list:        case list:
204          while(env->gc_ref->item->content.ptr!=NULL) {          while(env->gc_ref->item->content.ptr!=NULL) {
205            titem= env->gc_ref->item->content.ptr;            titem= env->gc_ref->item->content.ptr;
# Line 206  extern void gc_init(environment *env) { Line 210  extern void gc_init(environment *env) {
210        default:        default:
211          break;          break;
212        }        }
213        free(env->gc_ref->item);        free(env->gc_ref->item);  /* Remove from gc_ref */
214        titem= env->gc_ref->next;        titem= env->gc_ref->next;
215        free(env->gc_ref);        free(env->gc_ref);        /* Remove value */
216        env->gc_ref= titem;        env->gc_ref= titem;
217      } else {      } else {                    /* Save */
218        titem= env->gc_ref->next;        titem= env->gc_ref->next;
219        env->gc_ref->next= new_head;        env->gc_ref->next= new_head;
220        new_head= env->gc_ref;        new_head= env->gc_ref;
# Line 252  void push_int(environment *env, int in_v Line 256  void push_int(environment *env, int in_v
256  {  {
257    value *new_value= new_val(env);    value *new_value= new_val(env);
258        
259    new_value->content.val= in_val;    new_value->content.i= in_val;
260    new_value->type= integer;    new_value->type= integer;
261    
262    push_val(env, new_value);    push_val(env, new_value);
263  }  }
264    
265    void push_float(environment *env, float in_val)
266    {
267      value *new_value= new_val(env);
268    
269      new_value->content.f= in_val;
270      new_value->type= tfloat;
271    
272      push_val(env, new_value);
273    }
274    
275  /* Copy a string onto the stack. */  /* Copy a string onto the stack. */
276  void push_cstring(environment *env, const char *in_string)  void push_cstring(environment *env, const char *in_string)
277  {  {
# Line 328  void push_sym(environment *env, const ch Line 342  void push_sym(environment *env, const ch
342    char *mangled;                /* Mangled function name */    char *mangled;                /* Mangled function name */
343    
344    new_value= new_val(env);    new_value= new_val(env);
345      protect(env, new_value);
346      new_fvalue= new_val(env);
347      protect(env, new_fvalue);
348    
349    /* The new value is a symbol */    /* The new value is a symbol */
350    new_value->type= symb;    new_value->type= symb;
# Line 362  void push_sym(environment *env, const ch Line 379  void push_sym(environment *env, const ch
379        dlerr= dlerror();        dlerr= dlerror();
380      }      }
381      if(dlerr==NULL) {           /* If a function was found */      if(dlerr==NULL) {           /* If a function was found */
       new_fvalue= new_val(env); /* Create a new value */  
382        new_fvalue->type= func;   /* The new value is a function pointer */        new_fvalue->type= func;   /* The new value is a function pointer */
383        new_fvalue->content.ptr= funcptr; /* Store function pointer */        new_fvalue->content.ptr= funcptr; /* Store function pointer */
384        (*new_symbol)->val= new_fvalue; /* Bind the symbol to the new        (*new_symbol)->val= new_fvalue; /* Bind the symbol to the new
# Line 370  void push_sym(environment *env, const ch Line 386  void push_sym(environment *env, const ch
386      }      }
387    }    }
388    push_val(env, new_value);    push_val(env, new_value);
389      unprotect(env); unprotect(env);
390  }  }
391    
392  /* Print newline. */  /* Print newline. */
# Line 393  extern void type(environment *env){ Line 410  extern void type(environment *env){
410    case integer:    case integer:
411      push_sym(env, "integer");      push_sym(env, "integer");
412      break;      break;
413      case tfloat:
414        push_sym(env, "float");
415        break;
416    case string:    case string:
417      push_sym(env, "string");      push_sym(env, "string");
418      break;      break;
# Line 413  void print_h(stackitem *stack_head, int Line 433  void print_h(stackitem *stack_head, int
433  {  {
434    switch(stack_head->item->type) {    switch(stack_head->item->type) {
435    case integer:    case integer:
436      printf("%d", stack_head->item->content.val);      printf("%d", stack_head->item->content.i);
437        break;
438      case tfloat:
439        printf("%f", stack_head->item->content.f);
440      break;      break;
441    case string:    case string:
442      if(noquote)      if(noquote)
# Line 597  extern void eval(environment *env) Line 620  extern void eval(environment *env)
620    case list:    case list:
621      temp_val= env->head->item;      temp_val= env->head->item;
622      protect(env, temp_val);      protect(env, temp_val);
623      toss(env);  
624      if(env->err) return;      toss(env); if(env->err) return;
625      iterator= (stackitem*)temp_val->content.ptr;      iterator= (stackitem*)temp_val->content.ptr;
     unprotect(env);  
626            
627      while(iterator!=NULL) {      while(iterator!=NULL) {
628        push_val(env, iterator->item);        push_val(env, iterator->item);
# Line 618  extern void eval(environment *env) Line 640  extern void eval(environment *env)
640        }        }
641        iterator= iterator->next;        iterator= iterator->next;
642      }      }
643        unprotect(env);
644      return;      return;
645    
646    default:    default:
# Line 659  extern void pack(environment *env) Line 682  extern void pack(environment *env)
682    value *pack;    value *pack;
683    
684    iterator= env->head;    iterator= env->head;
685      pack= new_val(env);
686      protect(env, pack);
687    
688    if(iterator==NULL    if(iterator==NULL
689       || (iterator->item->type==symb       || (iterator->item->type==symb
# Line 676  extern void pack(environment *env) Line 701  extern void pack(environment *env)
701      temp= env->head;      temp= env->head;
702      env->head= iterator->next;      env->head= iterator->next;
703      iterator->next= NULL;      iterator->next= NULL;
704    
705        pack->type= list;
706        pack->content.ptr= temp;
707            
708      if(env->head!=NULL)      if(env->head!=NULL)
709        toss(env);        toss(env);
710    }    }
711    
712    /* Push list */    /* Push list */
   pack= new_val(env);  
   pack->type= list;  
   pack->content.ptr= temp;  
713    
714    push_val(env, pack);    push_val(env, pack);
715    rev(env);    rev(env);
716    
717      unprotect(env);
718  }  }
719    
720  /* Relocate elements of the list on the stack. */  /* Relocate elements of the list on the stack. */
# Line 765  extern void not(environment *env) Line 792  extern void not(environment *env)
792      return;      return;
793    }    }
794    
795    val= env->head->item->content.val;    val= env->head->item->content.i;
796    toss(env);    toss(env);
797    push_int(env, !val);    push_int(env, !val);
798  }  }
# Line 967  under certain conditions; type `copying; Line 994  under certain conditions; type `copying;
994  /* "+" */  /* "+" */
995  extern void sx_2b(environment *env) {  extern void sx_2b(environment *env) {
996    int a, b;    int a, b;
997      float fa, fb;
998    size_t len;    size_t len;
999    char* new_string;    char* new_string;
1000    value *a_val, *b_val;    value *a_val, *b_val;
# Line 991  extern void sx_2b(environment *env) { Line 1019  extern void sx_2b(environment *env) {
1019      push_cstring(env, new_string);      push_cstring(env, new_string);
1020      unprotect(env); unprotect(env);      unprotect(env); unprotect(env);
1021      free(new_string);      free(new_string);
1022        
1023      return;      return;
1024    }    }
1025        
1026    if(env->head->item->type!=integer    if(env->head->item->type==integer
1027       || env->head->next->item->type!=integer) {       && env->head->next->item->type==integer) {
1028      printerr("Bad Argument Type");      a=env->head->item->content.i;
1029      env->err=2;      toss(env); if(env->err) return;
1030        b=env->head->item->content.i;
1031        toss(env); if(env->err) return;
1032        push_int(env, b+a);
1033    
1034      return;      return;
1035    }    }
1036    a= env->head->item->content.val;  
1037    toss(env); if(env->err) return;    if(env->head->item->type==tfloat
1038           && env->head->next->item->type==tfloat) {
1039    b= env->head->item->content.val;      fa= env->head->item->content.f;
1040    toss(env); if(env->err) return;      toss(env); if(env->err) return;
1041    push_int(env, a+b);      fb= env->head->item->content.f;
1042        toss(env); if(env->err) return;
1043        push_float(env, fb+fa);
1044        
1045        return;
1046      }
1047    
1048      if(env->head->item->type==tfloat
1049         && env->head->next->item->type==integer) {
1050        fa= env->head->item->content.f;
1051        toss(env); if(env->err) return;
1052        b= env->head->item->content.i;
1053        toss(env); if(env->err) return;
1054        push_float(env, b+fa);
1055        
1056        return;
1057      }
1058    
1059      if(env->head->item->type==integer
1060         && env->head->next->item->type==tfloat) {
1061        a= env->head->item->content.i;
1062        toss(env); if(env->err) return;
1063        fb= env->head->item->content.f;
1064        toss(env); if(env->err) return;
1065        push_float(env, fb+a);
1066    
1067        return;
1068      }
1069    
1070      printerr("Bad Argument Type");
1071      env->err=2;
1072  }  }
1073    
1074  /* "-" */  /* "-" */
1075  extern void sx_2d(environment *env) {  extern void sx_2d(environment *env) {
1076    int a, b;    int a, b;
1077      float fa, fb;
1078    
1079    if((env->head)==NULL || env->head->next==NULL) {    if((env->head)==NULL || env->head->next==NULL) {
1080      printerr("Too Few Arguments");      printerr("Too Few Arguments");
# Line 1018  extern void sx_2d(environment *env) { Line 1082  extern void sx_2d(environment *env) {
1082      return;      return;
1083    }    }
1084        
1085    if(env->head->item->type!=integer    if(env->head->item->type==integer
1086       || env->head->next->item->type!=integer) {       && env->head->next->item->type==integer) {
1087      printerr("Bad Argument Type");      a=env->head->item->content.i;
1088      env->err=2;      toss(env); if(env->err) return;
1089        b=env->head->item->content.i;
1090        toss(env); if(env->err) return;
1091        push_int(env, b-a);
1092    
1093      return;      return;
1094    }    }
1095    
1096    a=env->head->item->content.val;    if(env->head->item->type==tfloat
1097    toss(env); if(env->err) return;       && env->head->next->item->type==tfloat) {
1098    b=env->head->item->content.val;      fa= env->head->item->content.f;
1099    toss(env); if(env->err) return;      toss(env); if(env->err) return;
1100    push_int(env, b-a);      fb= env->head->item->content.f;
1101        toss(env); if(env->err) return;
1102        push_float(env, fb-fa);
1103        
1104        return;
1105      }
1106    
1107      if(env->head->item->type==tfloat
1108         && env->head->next->item->type==integer) {
1109        fa= env->head->item->content.f;
1110        toss(env); if(env->err) return;
1111        b= env->head->item->content.i;
1112        toss(env); if(env->err) return;
1113        push_float(env, b-fa);
1114        
1115        return;
1116      }
1117    
1118      if(env->head->item->type==integer
1119         && env->head->next->item->type==tfloat) {
1120        a= env->head->item->content.i;
1121        toss(env); if(env->err) return;
1122        fb= env->head->item->content.f;
1123        toss(env); if(env->err) return;
1124        push_float(env, fb-a);
1125    
1126        return;
1127      }
1128    
1129      printerr("Bad Argument Type");
1130      env->err=2;
1131  }  }
1132    
1133  /* ">" */  /* ">" */
1134  extern void sx_3e(environment *env) {  extern void sx_3e(environment *env) {
1135    int a, b;    int a, b;
1136      float fa, fb;
1137    
1138    if((env->head)==NULL || env->head->next==NULL) {    if((env->head)==NULL || env->head->next==NULL) {
1139      printerr("Too Few Arguments");      printerr("Too Few Arguments");
# Line 1042  extern void sx_3e(environment *env) { Line 1141  extern void sx_3e(environment *env) {
1141      return;      return;
1142    }    }
1143        
1144    if(env->head->item->type!=integer    if(env->head->item->type==integer
1145       || env->head->next->item->type!=integer) {       && env->head->next->item->type==integer) {
1146      printerr("Bad Argument Type");      a=env->head->item->content.i;
1147      env->err=2;      toss(env); if(env->err) return;
1148        b=env->head->item->content.i;
1149        toss(env); if(env->err) return;
1150        push_int(env, b>a);
1151    
1152      return;      return;
1153    }    }
1154    
1155    a=env->head->item->content.val;    if(env->head->item->type==tfloat
1156    toss(env); if(env->err) return;       && env->head->next->item->type==tfloat) {
1157    b=env->head->item->content.val;      fa= env->head->item->content.f;
1158    toss(env); if(env->err) return;      toss(env); if(env->err) return;
1159    push_int(env, b>a);      fb= env->head->item->content.f;
1160        toss(env); if(env->err) return;
1161        push_int(env, fb>fa);
1162        
1163        return;
1164      }
1165    
1166      if(env->head->item->type==tfloat
1167         && env->head->next->item->type==integer) {
1168        fa= env->head->item->content.f;
1169        toss(env); if(env->err) return;
1170        b= env->head->item->content.i;
1171        toss(env); if(env->err) return;
1172        push_int(env, b>fa);
1173        
1174        return;
1175      }
1176    
1177      if(env->head->item->type==integer
1178         && env->head->next->item->type==tfloat) {
1179        a= env->head->item->content.i;
1180        toss(env); if(env->err) return;
1181        fb= env->head->item->content.f;
1182        toss(env); if(env->err) return;
1183        push_int(env, fb>a);
1184    
1185        return;
1186      }
1187    
1188      printerr("Bad Argument Type");
1189      env->err=2;
1190    }
1191    
1192    /* "<" */
1193    extern void sx_3c(environment *env) {
1194      swap(env); if(env->err) return;
1195      sx_3e(env);
1196    }
1197    
1198    /* "<=" */
1199    extern void sx_3c3d(environment *env) {
1200      sx_3e(env); if(env->err) return;
1201      not(env);
1202    }
1203    
1204    /* ">=" */
1205    extern void sx_3e3d(environment *env) {
1206      sx_3c(env); if(env->err) return;
1207      not(env);
1208  }  }
1209    
1210  /* Return copy of a value */  /* Return copy of a value */
1211  value *copy_val(environment *env, value *old_value){  value *copy_val(environment *env, value *old_value){
1212    stackitem *old_item, *new_item, *prev_item;    stackitem *old_item, *new_item, *prev_item;
1213      value *new_value;
   value *new_value= new_val(env);  
1214    
1215    protect(env, old_value);    protect(env, old_value);
1216      new_value= new_val(env);
1217      protect(env, new_value);
1218    new_value->type= old_value->type;    new_value->type= old_value->type;
1219    
1220    switch(old_value->type){    switch(old_value->type){
1221      case tfloat:
1222    case integer:    case integer:
1223      new_value->content.val= old_value->content.val;    case func:
1224      case symb:
1225        new_value->content= old_value->content;
1226      break;      break;
1227    case string:    case string:
1228      (char *)(new_value->content.ptr)=      (char *)(new_value->content.ptr)=
1229        strdup((char *)(old_value->content.ptr));        strdup((char *)(old_value->content.ptr));
1230      break;      break;
   case func:  
   case symb:  
     new_value->content.ptr= old_value->content.ptr;  
     break;  
1231    case list:    case list:
1232      new_value->content.ptr= NULL;      new_value->content.ptr= NULL;
1233    
# Line 1098  value *copy_val(environment *env, value Line 1249  value *copy_val(environment *env, value
1249      break;      break;
1250    }    }
1251    
1252    unprotect(env);    unprotect(env); unprotect(env);
1253    
1254    return new_value;    return new_value;
1255  }  }
# Line 1133  extern void sx_6966(environment *env) { Line 1284  extern void sx_6966(environment *env) {
1284    swap(env);    swap(env);
1285    if(env->err) return;    if(env->err) return;
1286        
1287    truth=env->head->item->content.val;    truth=env->head->item->content.i;
1288    
1289    toss(env);    toss(env);
1290    if(env->err) return;    if(env->err) return;
# Line 1165  extern void ifelse(environment *env) { Line 1316  extern void ifelse(environment *env) {
1316    rot(env);    rot(env);
1317    if(env->err) return;    if(env->err) return;
1318        
1319    truth=env->head->item->content.val;    truth=env->head->item->content.i;
1320    
1321    toss(env);    toss(env);
1322    if(env->err) return;    if(env->err) return;
# Line 1210  extern void sx_7768696c65(environment *e Line 1361  extern void sx_7768696c65(environment *e
1361        return;        return;
1362      }      }
1363            
1364      truth= env->head->item->content.val;      truth= env->head->item->content.i;
1365      toss(env); if(env->err) return;      toss(env); if(env->err) return;
1366            
1367      if(truth) {      if(truth) {
# Line 1249  extern void sx_666f72(environment *env) Line 1400  extern void sx_666f72(environment *env)
1400    protect(env, loop);    protect(env, loop);
1401    toss(env); if(env->err) return;    toss(env); if(env->err) return;
1402    
1403    foo2= env->head->item->content.val;    foo2= env->head->item->content.i;
1404    toss(env); if(env->err) return;    toss(env); if(env->err) return;
1405    
1406    foo1= env->head->item->content.val;    foo1= env->head->item->content.i;
1407    toss(env); if(env->err) return;    toss(env); if(env->err) return;
1408    
1409    if(foo1<=foo2) {    if(foo1<=foo2) {
# Line 1329  extern void to(environment *env) { Line 1480  extern void to(environment *env) {
1480      return;      return;
1481    }    }
1482    
1483    ending= env->head->item->content.val;    ending= env->head->item->content.i;
1484    toss(env); if(env->err) return;    toss(env); if(env->err) return;
1485    start= env->head->item->content.val;    start= env->head->item->content.i;
1486    toss(env); if(env->err) return;    toss(env); if(env->err) return;
1487    
1488    temp_head= env->head;    temp_head= env->head;
# Line 1346  extern void to(environment *env) { Line 1497  extern void to(environment *env) {
1497    }    }
1498    
1499    temp_val= new_val(env);    temp_val= new_val(env);
1500      protect(env, temp_val);
1501    
1502    temp_val->content.ptr= env->head;    temp_val->content.ptr= env->head;
1503    temp_val->type= list;    temp_val->type= list;
1504    env->head= temp_head;    env->head= temp_head;
1505    push_val(env, temp_val);    push_val(env, temp_val);
1506    
1507      unprotect(env);
1508  }  }
1509    
1510  /* Read a string */  /* Read a string */
# Line 1367  extern void sx_72656164(environment *env Line 1522  extern void sx_72656164(environment *env
1522    const char symbform[]= "%[a-zA-Z0-9!$%*+./:<=>?@^_~-]%n";    const char symbform[]= "%[a-zA-Z0-9!$%*+./:<=>?@^_~-]%n";
1523    const char strform[]= "\"%[^\"]\"%n";    const char strform[]= "\"%[^\"]\"%n";
1524    const char intform[]= "%i%n";    const char intform[]= "%i%n";
1525      const char fltform[]= "%f%n";
1526    const char blankform[]= "%*[ \t]%n";    const char blankform[]= "%*[ \t]%n";
1527    const char ebrackform[]= "]%n";    const char ebrackform[]= "]%n";
1528    const char semicform[]= ";%n";    const char semicform[]= ";%n";
1529    const char bbrackform[]= "[%n";    const char bbrackform[]= "[%n";
1530    
1531    int itemp, readlength= -1;    int itemp, readlength= -1;
1532      int count= -1;
1533      float ftemp;
1534    static int depth= 0;    static int depth= 0;
1535    char *match;    char *match, *ctemp;
1536    size_t inlength;    size_t inlength;
1537    
1538    if(env->in_string==NULL) {    if(env->in_string==NULL) {
# Line 1397  extern void sx_72656164(environment *env Line 1555  extern void sx_72656164(environment *env
1555    inlength= strlen(env->in_string)+1;    inlength= strlen(env->in_string)+1;
1556    match= malloc(inlength);    match= malloc(inlength);
1557    
1558    if(sscanf(env->in_string, blankform, &readlength)!=EOF    if(sscanf(env->in_string, blankform, &readlength) != EOF
1559       && readlength != -1) {       && readlength != -1) {
1560      ;      ;
1561    } else if(sscanf(env->in_string, intform, &itemp, &readlength) != EOF    } else if(sscanf(env->in_string, fltform, &ftemp, &readlength) != EOF
1562              && readlength != -1) {              && readlength != -1) {
1563      push_int(env, itemp);      if(sscanf(env->in_string, intform, &itemp, &count) != EOF
1564           && count==readlength) {
1565          push_int(env, itemp);
1566        } else {
1567          push_float(env, ftemp);
1568        }
1569    } else if(sscanf(env->in_string, strform, match, &readlength) != EOF    } else if(sscanf(env->in_string, strform, match, &readlength) != EOF
1570              && readlength != -1) {              && readlength != -1) {
1571      push_cstring(env, match);      push_cstring(env, match);
# Line 1424  extern void sx_72656164(environment *env Line 1587  extern void sx_72656164(environment *env
1587      free(env->free_string);      free(env->free_string);
1588      env->in_string = env->free_string = NULL;      env->in_string = env->free_string = NULL;
1589    }    }
1590    if ( env->in_string != NULL) {    if (env->in_string != NULL) {
1591      env->in_string += readlength;      env->in_string += readlength;
1592    }    }
1593    
# Line 1451  extern void beep(environment *env) { Line 1614  extern void beep(environment *env) {
1614      return;      return;
1615    }    }
1616    
1617    dur=env->head->item->content.val;    dur=env->head->item->content.i;
1618    toss(env);    toss(env);
1619    freq=env->head->item->content.val;    freq=env->head->item->content.i;
1620    toss(env);    toss(env);
1621    
1622    period=1193180/freq;          /* convert freq from Hz to period    period=1193180/freq;          /* convert freq from Hz to period
# Line 1494  extern void sx_77616974(environment *env Line 1657  extern void sx_77616974(environment *env
1657      return;      return;
1658    }    }
1659    
1660    dur=env->head->item->content.val;    dur=env->head->item->content.i;
1661    toss(env);    toss(env);
1662    
1663    usleep(dur);    usleep(dur);
# Line 1787  POSSIBILITY OF SUCH DAMAGES.\n"); Line 1950  POSSIBILITY OF SUCH DAMAGES.\n");
1950  extern void sx_2a(environment *env)  extern void sx_2a(environment *env)
1951  {  {
1952    int a, b;    int a, b;
1953      float fa, fb;
1954    
1955    if((env->head)==NULL || env->head->next==NULL) {    if((env->head)==NULL || env->head->next==NULL) {
1956      printerr("Too Few Arguments");      printerr("Too Few Arguments");
# Line 1794  extern void sx_2a(environment *env) Line 1958  extern void sx_2a(environment *env)
1958      return;      return;
1959    }    }
1960        
1961    if(env->head->item->type!=integer    if(env->head->item->type==integer
1962       || env->head->next->item->type!=integer) {       && env->head->next->item->type==integer) {
1963      printerr("Bad Argument Type");      a=env->head->item->content.i;
1964      env->err=2;      toss(env); if(env->err) return;
1965        b=env->head->item->content.i;
1966        toss(env); if(env->err) return;
1967        push_int(env, b*a);
1968    
1969      return;      return;
1970    }    }
1971    
1972    a=env->head->item->content.val;    if(env->head->item->type==tfloat
1973    toss(env); if(env->err) return;       && env->head->next->item->type==tfloat) {
1974    b=env->head->item->content.val;      fa= env->head->item->content.f;
1975    toss(env); if(env->err) return;      toss(env); if(env->err) return;
1976    push_int(env, b*a);      fb= env->head->item->content.f;
1977        toss(env); if(env->err) return;
1978        push_float(env, fb*fa);
1979        
1980        return;
1981      }
1982    
1983      if(env->head->item->type==tfloat
1984         && env->head->next->item->type==integer) {
1985        fa= env->head->item->content.f;
1986        toss(env); if(env->err) return;
1987        b= env->head->item->content.i;
1988        toss(env); if(env->err) return;
1989        push_float(env, b*fa);
1990        
1991        return;
1992      }
1993    
1994      if(env->head->item->type==integer
1995         && env->head->next->item->type==tfloat) {
1996        a= env->head->item->content.i;
1997        toss(env); if(env->err) return;
1998        fb= env->head->item->content.f;
1999        toss(env); if(env->err) return;
2000        push_float(env, fb*a);
2001    
2002        return;
2003      }
2004    
2005      printerr("Bad Argument Type");
2006      env->err=2;
2007  }  }
2008    
2009  /* "/" */  /* "/" */
2010  extern void sx_2f(environment *env)  extern void sx_2f(environment *env)
2011  {  {
2012    int a, b;    int a, b;
2013      float fa, fb;
2014    
2015    if((env->head)==NULL || env->head->next==NULL) {    if((env->head)==NULL || env->head->next==NULL) {
2016      printerr("Too Few Arguments");      printerr("Too Few Arguments");
# Line 1819  extern void sx_2f(environment *env) Line 2018  extern void sx_2f(environment *env)
2018      return;      return;
2019    }    }
2020        
2021    if(env->head->item->type!=integer    if(env->head->item->type==integer
2022       || env->head->next->item->type!=integer) {       && env->head->next->item->type==integer) {
2023      printerr("Bad Argument Type");      a=env->head->item->content.i;
2024      env->err=2;      toss(env); if(env->err) return;
2025        b=env->head->item->content.i;
2026        toss(env); if(env->err) return;
2027        push_float(env, b/a);
2028    
2029      return;      return;
2030    }    }
2031    
2032    a=env->head->item->content.val;    if(env->head->item->type==tfloat
2033    toss(env); if(env->err) return;       && env->head->next->item->type==tfloat) {
2034    b=env->head->item->content.val;      fa= env->head->item->content.f;
2035    toss(env); if(env->err) return;      toss(env); if(env->err) return;
2036    push_int(env, b/a);      fb= env->head->item->content.f;
2037        toss(env); if(env->err) return;
2038        push_float(env, fb/fa);
2039        
2040        return;
2041      }
2042    
2043      if(env->head->item->type==tfloat
2044         && env->head->next->item->type==integer) {
2045        fa= env->head->item->content.f;
2046        toss(env); if(env->err) return;
2047        b= env->head->item->content.i;
2048        toss(env); if(env->err) return;
2049        push_float(env, b/fa);
2050        
2051        return;
2052      }
2053    
2054      if(env->head->item->type==integer
2055         && env->head->next->item->type==tfloat) {
2056        a= env->head->item->content.i;
2057        toss(env); if(env->err) return;
2058        fb= env->head->item->content.f;
2059        toss(env); if(env->err) return;
2060        push_float(env, fb/a);
2061    
2062        return;
2063      }
2064    
2065      printerr("Bad Argument Type");
2066      env->err=2;
2067  }  }
2068    
2069  /* "mod" */  /* "mod" */
# Line 1844  extern void mod(environment *env) Line 2077  extern void mod(environment *env)
2077      return;      return;
2078    }    }
2079        
2080    if(env->head->item->type!=integer    if(env->head->item->type==integer
2081       || env->head->next->item->type!=integer) {       && env->head->next->item->type==integer) {
2082      printerr("Bad Argument Type");      a= env->head->item->content.i;
2083      env->err=2;      toss(env); if(env->err) return;
2084        b= env->head->item->content.i;
2085        toss(env); if(env->err) return;
2086        push_int(env, b%a);
2087    
2088      return;      return;
2089    }    }
2090    
2091    a=env->head->item->content.val;    printerr("Bad Argument Type");
2092    toss(env); if(env->err) return;    env->err=2;
   b=env->head->item->content.val;  
   toss(env); if(env->err) return;  
   push_int(env, b%a);  
2093  }  }
Legend:
Removed from v.1.92  
changed lines
  Added in v.1.93
root@recompile.se
 ViewVC Help
Powered by ViewVC 1.1.26