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

Diff of /stack/stack.c

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

revision 1.60 by teddy, Fri Feb 8 05:12:37 2002 UTC revision 1.68 by masse, Mon Feb 11 00:27:18 2002 UTC
# Line 496  extern void eval(environment *env) Line 496  extern void eval(environment *env)
496      return;      return;
497    }    }
498    
499     eval_start:
500    
501    switch(env->head->item->type) {    switch(env->head->item->type) {
502      /* if it's a symbol */      /* if it's a symbol */
503    case symb:    case symb:
504      rcl(env);                   /* get its contents */      rcl(env);                   /* get its contents */
505      if(env->err) return;      if(env->err) return;
506      if(env->head->item->type!=symb){ /* don't recurse symbols */      if(env->head->item->type!=symb){ /* don't recurse symbols */
507        return eval(env);         /* evaluate the value */        goto eval_start;
508      }      }
509      return;      return;
510    
# Line 528  extern void eval(environment *env) Line 530  extern void eval(environment *env)
530          if(env->err) return;          if(env->err) return;
531          if(iterator->next == NULL){          if(iterator->next == NULL){
532            free_val(temp_val);            free_val(temp_val);
533            return eval(env);            goto eval_start;
534          }          }
535          eval(env);          eval(env);
536          if(env->err) return;          if(env->err) return;
# Line 551  extern void eval(environment *env) Line 553  extern void eval(environment *env)
553      strcat(temp_string, " ]");      strcat(temp_string, " ]");
554      stack_read(env, temp_string);      stack_read(env, temp_string);
555      free(temp_string);      free(temp_string);
556      return eval(env);      goto eval_start;
557    
558    case integer:    case integer:
559      return;      return;
# Line 955  extern void sx_2b(environment *env) { Line 957  extern void sx_2b(environment *env) {
957    a=env->head->item->content.val;    a=env->head->item->content.val;
958    toss(env);    toss(env);
959    if(env->err) return;    if(env->err) return;
960    b=env->head->item->content.val;    if(env->head->item->refcount == 1)
961    toss(env);      env->head->item->content.val += a;
962    if(env->err) return;    else {
963    push_int(&(env->head), a+b);      b=env->head->item->content.val;
964        toss(env);
965        if(env->err) return;
966        push_int(&(env->head), a+b);
967      }
968  }  }
969    
970  /* - */  /* - */
971  extern void sx_2d(environment *env) {  extern void sx_2d(environment *env) {
972    int a;    int a, b;
973    
974      if((env->head)==NULL || env->head->next==NULL) {
975        printerr("Too Few Arguments");
976        env->err=1;
977        return;
978      }
979      
980      if(env->head->item->type!=integer
981         || env->head->next->item->type!=integer) {
982        printerr("Bad Argument Type");
983        env->err=2;
984        return;
985      }
986      a=env->head->item->content.val;
987      toss(env);
988      if(env->err) return;
989      if(env->head->item->refcount == 1)
990        env->head->item->content.val -= a;
991      else {
992        b=env->head->item->content.val;
993        toss(env);
994        if(env->err) return;
995        push_int(&(env->head), b-a);
996      }
997    }
998    
999    /* > */
1000    extern void sx_3e(environment *env) {
1001      int a, b;
1002    
1003    if((env->head)==NULL || env->head->next==NULL) {    if((env->head)==NULL || env->head->next==NULL) {
1004      printerr("Too Few Arguments");      printerr("Too Few Arguments");
# Line 980  extern void sx_2d(environment *env) { Line 1015  extern void sx_2d(environment *env) {
1015    a=env->head->item->content.val;    a=env->head->item->content.val;
1016    toss(env);    toss(env);
1017    if(env->err) return;    if(env->err) return;
1018    env->head->item->content.val -= a;    if(env->head->item->refcount == 1)
1019        env->head->item->content.val = (env->head->item->content.val > a);
1020      else {
1021        b=env->head->item->content.val;
1022        toss(env);
1023        if(env->err) return;
1024        push_int(&(env->head), b>a);
1025      }
1026  }  }
1027    
1028  /* Return copy of a value */  /* Return copy of a value */
# Line 1109  extern void ifelse(environment *env) { Line 1151  extern void ifelse(environment *env) {
1151  extern void sx_7768696c65(environment *env) {  extern void sx_7768696c65(environment *env) {
1152    
1153    int truth;    int truth;
1154      value *loop, *test;
1155    
1156    if((env->head)==NULL || env->head->next==NULL) {    if((env->head)==NULL || env->head->next==NULL) {
1157      printerr("Too Few Arguments");      printerr("Too Few Arguments");
# Line 1116  extern void sx_7768696c65(environment *e Line 1159  extern void sx_7768696c65(environment *e
1159      return;      return;
1160    }    }
1161    
1162      loop= env->head->item;
1163      loop->refcount++;
1164      toss(env); if(env->err) return;
1165    
1166      test= env->head->item;
1167      test->refcount++;
1168      toss(env); if(env->err) return;
1169    
1170    do {    do {
1171      swap(env); if(env->err) return;      push_val(&(env->head), test);
1172      dup(env); if(env->err) return;      eval(env);
     eval(env); if(env->err) return;  
1173            
1174      if(env->head->item->type != integer) {      if(env->head->item->type != integer) {
1175        printerr("Bad Argument Type");        printerr("Bad Argument Type");
# Line 1128  extern void sx_7768696c65(environment *e Line 1178  extern void sx_7768696c65(environment *e
1178      }      }
1179            
1180      truth= env->head->item->content.val;      truth= env->head->item->content.val;
       
1181      toss(env); if(env->err) return;      toss(env); if(env->err) return;
     swap(env); if(env->err) return;  
1182            
1183      if(truth) {      if(truth) {
1184        dup(env);        push_val(&(env->head), loop);
1185        eval(env);        eval(env);
1186      } else {      } else {
1187        toss(env);        toss(env);
       toss(env);  
1188      }      }
1189        
1190    } while(truth);    } while(truth);
1191    
1192      free_val(test);
1193      free_val(loop);
1194    }
1195    
1196    /* For-loop */
1197    extern void sx_666f72(environment *env) {
1198      
1199      value *loop, *foo;
1200      stackitem *iterator;
1201      
1202      if((env->head)==NULL || env->head->next==NULL) {
1203        printerr("Too Few Arguments");
1204        env->err=1;
1205        return;
1206      }
1207    
1208      if(env->head->next->item->type != list) {
1209        printerr("Bad Argument Type");
1210        env->err=2;
1211        return;
1212      }
1213    
1214      loop= env->head->item;
1215      loop->refcount++;
1216      toss(env); if(env->err) return;
1217    
1218      foo= env->head->item;
1219      foo->refcount++;
1220      toss(env); if(env->err) return;
1221    
1222      iterator= foo->content.ptr;
1223    
1224      while(iterator!=NULL) {
1225        push_val(&(env->head), iterator->item);
1226        push_val(&(env->head), loop);
1227        eval(env); if(env->err) return;
1228        iterator= iterator->next;
1229      }
1230    
1231      free_val(loop);
1232      free_val(foo);
1233    }
1234    
1235    /* 'to' */
1236    extern void to(environment *env) {
1237      int i, start, ending;
1238      
1239      if((env->head)==NULL || env->head->next==NULL) {
1240        printerr("Too Few Arguments");
1241        env->err=1;
1242        return;
1243      }
1244    
1245      if(env->head->item->type!=integer
1246         || env->head->next->item->type!=integer) {
1247        printerr("Bad Argument Type");
1248        env->err=2;
1249        return;
1250      }
1251    
1252      ending= env->head->item->content.val;
1253      toss(env); if(env->err) return;
1254      start= env->head->item->content.val;
1255      toss(env); if(env->err) return;
1256    
1257      push_sym(env, "[");
1258    
1259      if(ending>=start) {
1260        for(i= start; i<=ending; i++)
1261          push_int(&(env->head), i);
1262      } else {
1263        for(i= start; i>=ending; i--)
1264          push_int(&(env->head), i);
1265      }
1266    
1267      push_sym(env, "[");
1268      pack(env); if(env->err) return;
1269    }
1270    
1271    /* Read a string */
1272    extern void readline(environment *env) {
1273      char in_string[101];
1274    
1275      fgets(in_string, 100, stdin);
1276      push_cstring(&(env->head), in_string);
1277    }
1278    
1279    /* Read a value and place on stack */
1280    extern void read(environment *env) {
1281      const char symbform[]= "%[a-zA-Z0-9!$%*+./:<=>?@^_~-]%100c";
1282      const char strform[]= "\"%[^\"]\"%100c";
1283      const char intform[]= "%i%100c";
1284      const char blankform[]= "%*[ \t]%100c";
1285      const char ebrackform[]= "%*1[]]%100c";
1286      const char semicform[]= "%*1[;]%100c";
1287      const char bbrackform[]= "%*1[[]%100c";
1288    
1289      int itemp, rerun= 0;
1290      static int depth= 0;
1291      char *rest, *match;
1292      static char *in_string= NULL;
1293      size_t inlength;
1294    
1295      if(in_string==NULL) {
1296        readline(env); if(env->err) return;
1297        
1298        in_string= malloc(strlen(env->head->item->content.ptr)+1);
1299        strcpy(in_string, env->head->item->content.ptr);
1300        toss(env); if(env->err) return;
1301      }
1302      
1303      inlength= strlen(in_string)+1;
1304      match= malloc(inlength);
1305      rest= malloc(inlength);
1306    
1307      if(sscanf(in_string, blankform, rest)) {
1308        rerun= 1;    
1309      } else if(sscanf(in_string, intform, &itemp, rest) > 0) {
1310        push_int(&(env->head), itemp);
1311      } else if(sscanf(in_string, strform, match, rest) > 0) {
1312        push_cstring(&(env->head), match);
1313      } else if(sscanf(in_string, symbform, match, rest) > 0) {
1314        push_sym(env, match);
1315      } else if(sscanf(in_string, ebrackform, rest) > 0) {
1316        push_sym(env, "[");
1317        pack(env); if(env->err) return;
1318        if(depth!=0) depth--;
1319      } else if(sscanf(in_string, semicform, rest) > 0) {
1320        push_sym(env, ";");
1321      } else if(sscanf(in_string, bbrackform, rest) > 0) {
1322        push_sym(env, "[");
1323        depth++;
1324      } else {
1325        free(rest);
1326        rest= NULL;
1327        rerun= 1;
1328      }
1329          
1330      free(in_string);
1331      free(match);
1332    
1333      in_string= rest;
1334    
1335      if(rerun || depth)
1336        return read(env);
1337  }  }
Legend:
Removed from v.1.60  
changed lines
  Added in v.1.68
root@recompile.se
 ViewVC Help
Powered by ViewVC 1.1.26