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

Diff of /stack/stack.c

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

revision 1.91 by teddy, Thu Mar 7 03:28:29 2002 UTC revision 1.94 by masse, Sat Mar 9 09:58:31 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 1782  YOU OR THIRD PARTIES OR A FAILURE OF THE Line 1945  YOU OR THIRD PARTIES OR A FAILURE OF THE
1945  PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE\n\  PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE\n\
1946  POSSIBILITY OF SUCH DAMAGES.\n");  POSSIBILITY OF SUCH DAMAGES.\n");
1947  }  }
1948    
1949    /* "*" */
1950    extern void sx_2a(environment *env)
1951    {
1952      int a, b;
1953      float fa, fb;
1954    
1955      if((env->head)==NULL || env->head->next==NULL) {
1956        printerr("Too Few Arguments");
1957        env->err=1;
1958        return;
1959      }
1960      
1961      if(env->head->item->type==integer
1962         && env->head->next->item->type==integer) {
1963        a=env->head->item->content.i;
1964        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;
1970      }
1971    
1972      if(env->head->item->type==tfloat
1973         && env->head->next->item->type==tfloat) {
1974        fa= env->head->item->content.f;
1975        toss(env); if(env->err) return;
1976        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)
2011    {
2012      int a, b;
2013      float fa, fb;
2014    
2015      if((env->head)==NULL || env->head->next==NULL) {
2016        printerr("Too Few Arguments");
2017        env->err=1;
2018        return;
2019      }
2020      
2021      if(env->head->item->type==integer
2022         && env->head->next->item->type==integer) {
2023        a=env->head->item->content.i;
2024        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;
2030      }
2031    
2032      if(env->head->item->type==tfloat
2033         && env->head->next->item->type==tfloat) {
2034        fa= env->head->item->content.f;
2035        toss(env); if(env->err) return;
2036        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" */
2070    extern void mod(environment *env)
2071    {
2072      int a, b;
2073    
2074      if((env->head)==NULL || env->head->next==NULL) {
2075        printerr("Too Few Arguments");
2076        env->err= 1;
2077        return;
2078      }
2079      
2080      if(env->head->item->type==integer
2081         && env->head->next->item->type==integer) {
2082        a= env->head->item->content.i;
2083        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;
2089      }
2090    
2091      printerr("Bad Argument Type");
2092      env->err=2;
2093    }
2094    
2095    /* "div" */
2096    extern void sx_646976(environment *env)
2097    {
2098      int a, b;
2099      
2100      if((env->head)==NULL || env->head->next==NULL) {
2101        printerr("Too Few Arguments");
2102        env->err= 1;
2103        return;
2104      }
2105    
2106      if(env->head->item->type==integer
2107         && env->head->next->item->type==integer) {
2108        a= env->head->item->content.i;
2109        toss(env); if(env->err) return;
2110        b= env->head->item->content.i;
2111        toss(env); if(env->err) return;
2112        push_int(env, (int)b/a);
2113    
2114        return;
2115      }
2116    
2117      printerr("Bad Argument Type");
2118      env->err= 2;
2119    }
Legend:
Removed from v.1.91  
changed lines
  Added in v.1.94
root@recompile.se
 ViewVC Help
Powered by ViewVC 1.1.26