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

Diff of /stack/stack.c

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

revision 1.59 by teddy, Fri Feb 8 04:58:23 2002 UTC revision 1.69 by masse, Mon Feb 11 00:54:04 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 894  extern void errn(environment *env){ Line 896  extern void errn(environment *env){
896    push_int(&(env->head), env->err);    push_int(&(env->head), env->err);
897  }  }
898    
899    extern void read(environment*);
900    
901  int main()  int main()
902  {  {
903    environment myenv;    environment myenv;
   char in_string[100];  
904    
905    init_env(&myenv);    init_env(&myenv);
906    
907    printf("okidok\n ");    while(1) {
908        fprintf(stderr, "okidok\n ");
909    while(fgets(in_string, 100, stdin) != NULL) {      read(&myenv);
     stack_read(&myenv, in_string);  
910      if(myenv.err) {      if(myenv.err) {
911        printf("(error %d) ", myenv.err);        printf("(error %d) ", myenv.err);
912        myenv.err=0;        myenv.err=0;
913        } else if(myenv.head->item->type==symb
914                  && ((symbol*)(myenv.head->item->content.ptr))->id[0]==';') {
915          toss(&myenv);             /* No error check in main */
916          eval(&myenv);
917      }      }
     printf("okidok\n ");  
918    }    }
919    quit(&myenv);    quit(&myenv);
920    return EXIT_FAILURE;    return EXIT_FAILURE;
# Line 955  extern void sx_2b(environment *env) { Line 960  extern void sx_2b(environment *env) {
960    a=env->head->item->content.val;    a=env->head->item->content.val;
961    toss(env);    toss(env);
962    if(env->err) return;    if(env->err) return;
963    b=env->head->item->content.val;    if(env->head->item->refcount == 1)
964        env->head->item->content.val += a;
965      else {
966        b=env->head->item->content.val;
967        toss(env);
968        if(env->err) return;
969        push_int(&(env->head), a+b);
970      }
971    }
972    
973    /* - */
974    extern void sx_2d(environment *env) {
975      int a, b;
976    
977      if((env->head)==NULL || env->head->next==NULL) {
978        printerr("Too Few Arguments");
979        env->err=1;
980        return;
981      }
982      
983      if(env->head->item->type!=integer
984         || env->head->next->item->type!=integer) {
985        printerr("Bad Argument Type");
986        env->err=2;
987        return;
988      }
989      a=env->head->item->content.val;
990      toss(env);
991      if(env->err) return;
992      if(env->head->item->refcount == 1)
993        env->head->item->content.val -= a;
994      else {
995        b=env->head->item->content.val;
996        toss(env);
997        if(env->err) return;
998        push_int(&(env->head), b-a);
999      }
1000    }
1001    
1002    /* > */
1003    extern void sx_3e(environment *env) {
1004      int a, b;
1005    
1006      if((env->head)==NULL || env->head->next==NULL) {
1007        printerr("Too Few Arguments");
1008        env->err=1;
1009        return;
1010      }
1011      
1012      if(env->head->item->type!=integer
1013         || env->head->next->item->type!=integer) {
1014        printerr("Bad Argument Type");
1015        env->err=2;
1016        return;
1017      }
1018      a=env->head->item->content.val;
1019    toss(env);    toss(env);
1020    if(env->err) return;    if(env->err) return;
1021    push_int(&(env->head), a+b);    if(env->head->item->refcount == 1)
1022        env->head->item->content.val = (env->head->item->content.val > a);
1023      else {
1024        b=env->head->item->content.val;
1025        toss(env);
1026        if(env->err) return;
1027        push_int(&(env->head), b>a);
1028      }
1029  }  }
1030    
1031  /* Return copy of a value */  /* Return copy of a value */
# Line 1087  extern void ifelse(environment *env) { Line 1154  extern void ifelse(environment *env) {
1154  extern void sx_7768696c65(environment *env) {  extern void sx_7768696c65(environment *env) {
1155    
1156    int truth;    int truth;
1157      value *loop, *test;
1158    
1159    if((env->head)==NULL || env->head->next==NULL) {    if((env->head)==NULL || env->head->next==NULL) {
1160      printerr("Too Few Arguments");      printerr("Too Few Arguments");
# Line 1094  extern void sx_7768696c65(environment *e Line 1162  extern void sx_7768696c65(environment *e
1162      return;      return;
1163    }    }
1164    
1165      loop= env->head->item;
1166      loop->refcount++;
1167      toss(env); if(env->err) return;
1168    
1169      test= env->head->item;
1170      test->refcount++;
1171      toss(env); if(env->err) return;
1172    
1173    do {    do {
1174      swap(env); if(env->err) return;      push_val(&(env->head), test);
1175      dup(env); if(env->err) return;      eval(env);
     eval(env); if(env->err) return;  
1176            
1177      if(env->head->item->type != integer) {      if(env->head->item->type != integer) {
1178        printerr("Bad Argument Type");        printerr("Bad Argument Type");
# Line 1106  extern void sx_7768696c65(environment *e Line 1181  extern void sx_7768696c65(environment *e
1181      }      }
1182            
1183      truth= env->head->item->content.val;      truth= env->head->item->content.val;
       
1184      toss(env); if(env->err) return;      toss(env); if(env->err) return;
     swap(env); if(env->err) return;  
1185            
1186      if(truth) {      if(truth) {
1187        dup(env);        push_val(&(env->head), loop);
1188        eval(env);        eval(env);
1189      } else {      } else {
1190        toss(env);        toss(env);
       toss(env);  
1191      }      }
1192        
1193    } while(truth);    } while(truth);
1194    
1195      free_val(test);
1196      free_val(loop);
1197    }
1198    
1199    /* For-loop */
1200    extern void sx_666f72(environment *env) {
1201      
1202      value *loop, *foo;
1203      stackitem *iterator;
1204      
1205      if((env->head)==NULL || env->head->next==NULL) {
1206        printerr("Too Few Arguments");
1207        env->err=1;
1208        return;
1209      }
1210    
1211      if(env->head->next->item->type != list) {
1212        printerr("Bad Argument Type");
1213        env->err=2;
1214        return;
1215      }
1216    
1217      loop= env->head->item;
1218      loop->refcount++;
1219      toss(env); if(env->err) return;
1220    
1221      foo= env->head->item;
1222      foo->refcount++;
1223      toss(env); if(env->err) return;
1224    
1225      iterator= foo->content.ptr;
1226    
1227      while(iterator!=NULL) {
1228        push_val(&(env->head), iterator->item);
1229        push_val(&(env->head), loop);
1230        eval(env); if(env->err) return;
1231        iterator= iterator->next;
1232      }
1233    
1234      free_val(loop);
1235      free_val(foo);
1236    }
1237    
1238    /* 'to' */
1239    extern void to(environment *env) {
1240      int i, start, ending;
1241      
1242      if((env->head)==NULL || env->head->next==NULL) {
1243        printerr("Too Few Arguments");
1244        env->err=1;
1245        return;
1246      }
1247    
1248      if(env->head->item->type!=integer
1249         || env->head->next->item->type!=integer) {
1250        printerr("Bad Argument Type");
1251        env->err=2;
1252        return;
1253      }
1254    
1255      ending= env->head->item->content.val;
1256      toss(env); if(env->err) return;
1257      start= env->head->item->content.val;
1258      toss(env); if(env->err) return;
1259    
1260      push_sym(env, "[");
1261    
1262      if(ending>=start) {
1263        for(i= start; i<=ending; i++)
1264          push_int(&(env->head), i);
1265      } else {
1266        for(i= start; i>=ending; i--)
1267          push_int(&(env->head), i);
1268      }
1269    
1270      push_sym(env, "[");
1271      pack(env); if(env->err) return;
1272    }
1273    
1274    /* Read a string */
1275    extern void readline(environment *env) {
1276      char in_string[101];
1277    
1278      fgets(in_string, 100, stdin);
1279      push_cstring(&(env->head), in_string);
1280    }
1281    
1282    /* Read a value and place on stack */
1283    extern void read(environment *env) {
1284      const char symbform[]= "%[a-zA-Z0-9!$%*+./:<=>?@^_~-]%100c";
1285      const char strform[]= "\"%[^\"]\"%100c";
1286      const char intform[]= "%i%100c";
1287      const char blankform[]= "%*[ \t]%100c";
1288      const char ebrackform[]= "%*1[]]%100c";
1289      const char semicform[]= "%*1[;]%100c";
1290      const char bbrackform[]= "%*1[[]%100c";
1291    
1292      int itemp, rerun= 0;
1293      static int depth= 0;
1294      char *rest, *match;
1295      static char *in_string= NULL;
1296      size_t inlength;
1297    
1298      if(in_string==NULL) {
1299        readline(env); if(env->err) return;
1300        
1301        in_string= malloc(strlen(env->head->item->content.ptr)+1);
1302        strcpy(in_string, env->head->item->content.ptr);
1303        toss(env); if(env->err) return;
1304      }
1305      
1306      inlength= strlen(in_string)+1;
1307      match= malloc(inlength);
1308      rest= malloc(inlength);
1309    
1310      if(sscanf(in_string, blankform, rest)) {
1311        rerun= 1;    
1312      } else if(sscanf(in_string, intform, &itemp, rest) > 0) {
1313        push_int(&(env->head), itemp);
1314      } else if(sscanf(in_string, strform, match, rest) > 0) {
1315        push_cstring(&(env->head), match);
1316      } else if(sscanf(in_string, symbform, match, rest) > 0) {
1317        push_sym(env, match);
1318      } else if(sscanf(in_string, ebrackform, rest) > 0) {
1319        push_sym(env, "[");
1320        pack(env); if(env->err) return;
1321        if(depth!=0) depth--;
1322      } else if(sscanf(in_string, semicform, rest) > 0) {
1323        push_sym(env, ";");
1324      } else if(sscanf(in_string, bbrackform, rest) > 0) {
1325        push_sym(env, "[");
1326        depth++;
1327      } else {
1328        free(rest);
1329        rest= NULL;
1330        rerun= 1;
1331      }
1332          
1333      free(in_string);
1334      free(match);
1335    
1336      in_string= rest;
1337    
1338      if(rerun || depth)
1339        return read(env);
1340  }  }
Legend:
Removed from v.1.59  
changed lines
  Added in v.1.69
root@recompile.se
 ViewVC Help
Powered by ViewVC 1.1.26