Changeset 854


Ignore:
Timestamp:
12/04/09 01:31:14 (3 years ago)
Author:
reyalp
Message:

WARNING this may break some existing scripts, see ​http://chdk.setepontos.com/index.php/topic,4408.0.html and ​http://chdk.setepontos.com/index.php/topic,4276.0.html

  • add UBASIC_DEBUG option to build the verbose debug version of ubasic_test, fix warning in tokenizer.c test version
Location:
trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/ubasic.h

    r515 r854  
    4141    UBASIC_E_GOSUB_STACK_EXHAUSTED, 
    4242    UBASIC_E_UNMATCHED_RETURN, 
     43    UBASIC_E_IF_STACK_EXHAUSTED, 
     44    UBASIC_E_UNMATCHED_IF, 
     45    UBASIC_E_SELECT_STACK_EXHAUSTED, 
     46    UBASIC_E_UNMATCHED_END_SELECT, 
     47    UBASIC_E_FOR_STACK_EXHAUSTED, 
     48    UBASIC_E_UNMATCHED_NEXT, 
     49    UBASIC_E_DO_STACK_EXHAUSTED, 
     50    UBASIC_E_UNMATCHED_UNTIL, 
     51    UBASIC_E_WHILE_STACK_EXHAUSTED, 
     52    UBASIC_E_UNMATCHED_WEND, 
    4353    UBASIC_E_UNKNOWN_ERROR, 
    4454    UBASIC_E_ENDMARK 

  • trunk/lib/ubasic/Makefile

    r846 r854  
    1111libubasic.a: $(OBJS) 
    1212 
     13UBASIC_TEST_CFLAGS=-g -Wall -DUBASIC_TEST -DCAMERA_$(PLATFORM) -DPLATFORMID=$(PLATFORMID) 
     14ifdef UBASIC_DEBUG 
     15        UBASIC_TEST_CFLAGS+=-DDEBUG=1 
     16endif 
     17 
    1318check: 
    14         gcc -g -Wall -DUBASIC_TEST -DCAMERA_$(PLATFORM) -DPLATFORMID=$(PLATFORMID) -o ubasic_test$(EXE) *.c 
     19        gcc $(UBASIC_TEST_CFLAGS) -o ubasic_test$(EXE) $(OBJS:.o=.c) run-ubasic.c 
    1520 
    1621clean: 

  • trunk/lib/ubasic/tokenizer.c

    r847 r854  
    3838#include <string.h> 
    3939#include <ctype.h> 
     40#include <stdio.h> 
    4041#endif 
    4142 

  • trunk/lib/ubasic/ubasic.c

    r847 r854  
    125125    "Unk key", 
    126126    "Unk label", 
    127     "Stack ful", 
     127    "gosub: Stack ful", 
    128128    "bad return", 
     129    "if: Stack ful", 
     130    "bad endif", 
     131    "select: Stack ful", 
     132    "bad end_select", 
     133    "for: Stack ful", 
     134    "bad next", 
     135    "do: Stack ful", 
     136    "bad until", 
     137    "while: Stack ful", 
     138    "bad wend", 
    129139    "Unk err"  
    130140}; 
    … …  
    142152{ 
    143153  program_ptr = program; 
    144   for_stack_ptr = gosub_stack_ptr = while_stack_ptr = do_stack_ptr = if_stack_ptr = 0; 
     154  for_stack_ptr = gosub_stack_ptr = while_stack_ptr = do_stack_ptr = if_stack_ptr = select_stack_ptr = 0; 
    145155  tokenizer_init(program); 
    146156  ended = 0; 
    … …  
    250260#ifdef UBASIC_TEST 
    251261        r = 0; 
    252 #else 
     262#else    
    253263    r = conf.script_startup; 
    254264#endif 
    … …  
    477487  case TOKENIZER_GET_TIME: { 
    478488    accept(TOKENIZER_GET_TIME); 
    479           unsigned long t2 = time(NULL); 
     489         unsigned long t2 = time(NULL); 
    480490    int tmode = expr(); 
    481           static struct tm *ttm; 
    482           ttm = localtime(&t2); 
     491     static struct tm *ttm; 
     492     ttm = localtime(&t2); 
    483493    if (tmode==0) r = ttm->tm_sec; 
    484494    else if (tmode==1) r = ttm->tm_min; 
    … …  
    493503#ifdef UBASIC_TEST 
    494504        r = 1; 
    495 #else 
    496     r = conf.save_raw;      
    497 #endif 
     505#else    
     506    r = conf.save_raw; 
     507#endif     
    498508    break; 
    499509 // get CHDK capture mode value, or 0 if in playback or unknown (broken modemap) 
    … …  
    764774} 
    765775/*---------------------------------------------------------------------------*/ 
     776/* IF-STATEMENT                                                              */ 
     777 
     778static void 
     779endif_statement(void) 
     780{ 
     781  if(if_stack_ptr > 0) { 
     782    accept(TOKENIZER_ENDIF); 
     783    accept(TOKENIZER_CR); 
     784    if_stack_ptr--; 
     785  } else { 
     786    DEBUG_PRINTF("ubasic.c: endif_statement(): endif without if-statement\n"); 
     787    ended = 1; 
     788    ubasic_error = UBASIC_E_UNMATCHED_IF; 
     789  } 
     790} 
     791/*---------------------------------------------------------------------------*/ 
    766792static void 
    767793if_statement(void) 
    768794{ 
    769   int r, else_cntr,endif_cntr; 
     795  int r, else_cntr,endif_cntr,f_nt,f_sl; 
    770796   
    771797  accept(TOKENIZER_IF); 
    772  
    773   r = relation(); /*relation(); */ 
    774  // printf("if_statement: relation %d\n", r); 
     798  DEBUG_PRINTF("if_statement: get_relation\n"); 
     799  r = relation(); 
     800  DEBUG_PRINTF("if_statement: relation %d\n", r); 
    775801  accept(TOKENIZER_THEN); 
    776   if (tokenizer_token() == TOKENIZER_CR) {   
    777         if(if_stack_ptr < MAX_IF_STACK_DEPTH) { 
    778          if_stack[if_stack_ptr] = r; 
    779          if_stack_ptr++; 
    780         } 
    781           accept(TOKENIZER_CR); 
    782           if(r) { 
    783                 return; 
    784           } 
    785           else { 
    786                 else_cntr=endif_cntr=0; 
    787                   tokenizer_next();         
    788                 while(((tokenizer_token() != TOKENIZER_ELSE &&  tokenizer_token() != TOKENIZER_ENDIF)  
    789                        || else_cntr || endif_cntr) && tokenizer_token() != TOKENIZER_ENDOFINPUT){ 
    790                   if( tokenizer_token() == TOKENIZER_IF) {else_cntr+=1;endif_cntr+=1;}               
    791                   if( tokenizer_token() == TOKENIZER_ELSE) { 
    792                           else_cntr--;             
    793                   } 
    794                   if( tokenizer_token() == TOKENIZER_ENDIF)  { 
    795                     endif_cntr--; 
    796             if (endif_cntr != else_cntr) else_cntr--; 
    797                   }     
    798                   tokenizer_next();                                                          
    799                  } 
    800             if(tokenizer_token() == TOKENIZER_ELSE) { 
    801                 return; 
    802                 } 
    803           }                                                   
    804           accept(TOKENIZER_ENDIF); 
    805           accept(TOKENIZER_CR);                        
    806           if(if_stack_ptr > 0) { 
    807              if_stack_ptr--; 
     802  if (ended) { 
     803    return; 
     804  } 
     805 
     806  if (tokenizer_token() == TOKENIZER_CR) { 
     807    // CR after then -> multiline IF-Statement 
     808    if(if_stack_ptr < MAX_IF_STACK_DEPTH) { 
     809      if_stack[if_stack_ptr] = r; 
     810      if_stack_ptr++; 
     811    } else { 
     812      DEBUG_PRINTF("if_statement: IF-stack depth exceeded\n"); 
     813      ended = 1; 
     814      ubasic_error = UBASIC_E_IF_STACK_EXHAUSTED; 
     815      return; 
     816    } 
     817    DEBUG_PRINTF("if_statement: stack_ptr %d\n", if_stack_ptr); 
     818    accept(TOKENIZER_CR); 
     819    if(r) { 
     820      DEBUG_PRINTF("if_statement: result true\n"); 
     821      return; 
     822    }else { 
     823      DEBUG_PRINTF("if_statement: result false\n"); 
     824       
     825      else_cntr=endif_cntr=0; // number of else/endif possible in current nesting 
     826      f_nt=f_sl=0; // f_nt nested then ?, f_fs flag single line 
     827 
     828      while(((tokenizer_token() != TOKENIZER_ELSE &&  tokenizer_token() != TOKENIZER_ENDIF)  
     829           || else_cntr || endif_cntr) && tokenizer_token() != TOKENIZER_ENDOFINPUT){ 
     830        f_nt=0; 
     831        // nested if 
     832        if( tokenizer_token() == TOKENIZER_IF) { 
     833          else_cntr+=1; 
     834          endif_cntr+=1; 
     835          f_sl=0; 
     836          DEBUG_PRINTF("IF: line %d, token %d, else %d, end %d\n", tokenizer_line_number(),tokenizer_token(),else_cntr,endif_cntr); 
     837        } 
     838        if( tokenizer_token() == TOKENIZER_THEN) { 
     839          f_nt=1; 
     840          tokenizer_next(); 
     841          DEBUG_PRINTF("THEN: line %d, token %d, else %d, end %d\n", tokenizer_line_number(),tokenizer_token(),else_cntr,endif_cntr); 
     842          if (tokenizer_token() != TOKENIZER_CR) { 
     843            f_sl=1; 
    808844          } 
     845          DEBUG_PRINTF("THEN_SL: line %d, token %d, else %d, end %d\n", tokenizer_line_number(),tokenizer_token(),else_cntr,endif_cntr); 
     846        } 
     847        if(tokenizer_token() == TOKENIZER_ELSE) { 
     848          else_cntr--; 
     849          DEBUG_PRINTF("ELSE: line %d, token %d, else %d, end %d\n", tokenizer_line_number(),tokenizer_token(),else_cntr,endif_cntr); 
     850          if (else_cntr<0) {  
     851            DEBUG_PRINTF("ubasic.c: if_statement(): else without if-statement\n"); 
     852            ended = 1; 
     853            ubasic_error = UBASIC_E_UNMATCHED_IF; 
     854            return; 
     855          } 
     856        } 
     857        if(!f_sl && (tokenizer_token() == TOKENIZER_ENDIF)) { 
     858          endif_cntr--; 
     859          if (endif_cntr != else_cntr) 
     860            else_cntr--; 
     861          DEBUG_PRINTF("ENDIF: line %d, token %d, else %d, end %d\n", tokenizer_line_number(),tokenizer_token(),else_cntr,endif_cntr); 
     862        } else { 
     863          if (f_sl && (tokenizer_token() == TOKENIZER_CR))  { 
     864            f_sl=0; 
     865            endif_cntr--; 
     866            if (endif_cntr != else_cntr) 
     867              else_cntr--; 
     868            DEBUG_PRINTF("ENDIF_SL: line %d, token %d, else %d, end %d\n", tokenizer_line_number(),tokenizer_token(),else_cntr,endif_cntr); 
     869          } else { 
     870            if (tokenizer_token()==TOKENIZER_ENDIF){ 
     871              DEBUG_PRINTF("ubasic.c: if_statement(): endif in singleline if-statement\n"); 
     872              ended = 1; 
     873              ubasic_error = UBASIC_E_PARSE; 
     874              return; 
     875            } 
     876          } 
     877        } 
     878        if (!f_nt) { 
     879          tokenizer_next(); 
     880        } 
     881      } 
     882      if(tokenizer_token() == TOKENIZER_ELSE) { 
     883        return; 
     884      } 
     885    }       
     886    endif_statement(); 
    809887  }else { 
    810           if(r) { 
    811             statement(); 
    812           } else { 
    813             do { 
    814               tokenizer_next(); 
    815             } while(tokenizer_token() != TOKENIZER_ELSE && 
    816                     tokenizer_token() != TOKENIZER_CR && 
    817                     tokenizer_token() != TOKENIZER_ENDOFINPUT); 
    818             if(tokenizer_token() == TOKENIZER_ELSE) { 
    819               tokenizer_next(); 
    820               statement(); 
    821             } else if(tokenizer_token() == TOKENIZER_CR) { 
    822               tokenizer_next(); 
    823             } 
    824           } 
     888  // Singleline IF-Statement 
     889    if(r) { 
     890      statement(); 
     891    } else { 
     892      do { 
     893        tokenizer_next(); 
     894      } while(tokenizer_token() != TOKENIZER_ELSE && 
     895        tokenizer_token() != TOKENIZER_CR && 
     896        tokenizer_token() != TOKENIZER_ENDOFINPUT); 
     897      if(tokenizer_token() == TOKENIZER_ELSE) { 
     898        accept(TOKENIZER_ELSE);  
     899        statement(); 
     900      } else { 
     901        accept(TOKENIZER_CR); 
     902      } 
     903    } 
    825904  } 
    826905} 
    … …  
    829908else_statement(void) 
    830909{ 
    831   int r=0, endif_cntr; 
     910  int r=0, endif_cntr, f_nt; 
    832911   
    833912  accept(TOKENIZER_ELSE); 
    834  
    835913  if(if_stack_ptr > 0) { 
    836914    r = if_stack[if_stack_ptr-1]; 
    837915  } 
    838  // printf("if_statement: relation %d\n", r); 
    839   if (tokenizer_token() == TOKENIZER_CR) {   
    840           accept(TOKENIZER_CR); 
    841           if(!r) { 
    842                 return; 
    843           } 
    844           else {                                       
    845                 endif_cntr=0; 
    846                 tokenizer_next();         
    847                 while(((tokenizer_token() != TOKENIZER_ENDIF )  
    848                        || endif_cntr) && tokenizer_token() != TOKENIZER_ENDOFINPUT){ 
    849                   if( tokenizer_token() == TOKENIZER_IF) {endif_cntr+=1;}                    
    850                   if( tokenizer_token() == TOKENIZER_ENDIF)  { 
    851                     endif_cntr--; 
    852                   }     
    853                   tokenizer_next();                                                          
    854                  } 
    855           }                                                   
    856 //        accept(TOKENIZER_ENDIF); 
    857 //        accept(TOKENIZER_CR);                        
    858   } 
    859 } 
    860 /*---------------------------------------------------------------------------*/ 
    861 static void 
    862 endif_statement(void) 
    863 { 
    864         accept(TOKENIZER_ENDIF); 
    865         accept(TOKENIZER_CR);                  
    866     if(if_stack_ptr > 0) { 
    867         if_stack_ptr--; 
    868     } 
     916  else{ 
     917    DEBUG_PRINTF("ubasic.c: else_statement(): else without if-statement\n"); 
     918    ended = 1; 
     919    ubasic_error = UBASIC_E_PARSE; 
     920    return; 
     921  } 
     922  DEBUG_PRINTF("else_statement: relation %d\n", r); 
     923   
     924  if (tokenizer_token() == TOKENIZER_CR) { 
     925    accept(TOKENIZER_CR); 
     926    if(!r) { 
     927      DEBUG_PRINTF("else_statement: result true\n"); 
     928      return; 
     929    } else { 
     930      DEBUG_PRINTF("else_statement: result false\n"); 
     931      endif_cntr=0; 
     932      while(((tokenizer_token() != TOKENIZER_ENDIF )  
     933           || endif_cntr) && tokenizer_token() != TOKENIZER_ENDOFINPUT){ 
     934        f_nt=0; 
     935        if( tokenizer_token() == TOKENIZER_IF) { 
     936          endif_cntr+=1; 
     937        } 
     938        if( tokenizer_token() == TOKENIZER_THEN) { 
     939          tokenizer_next(); 
     940          // then followed by CR -> multi line 
     941          if (tokenizer_token() == TOKENIZER_CR) { 
     942            f_nt=1; 
     943          } else { // single line 
     944            endif_cntr--; 
     945            while(tokenizer_token() != TOKENIZER_ENDIF && tokenizer_token() != TOKENIZER_CR  
     946                 && tokenizer_token() != TOKENIZER_ENDOFINPUT){ 
     947              tokenizer_next(); 
     948            } 
     949            if (tokenizer_token()==TOKENIZER_ENDIF){ 
     950              DEBUG_PRINTF("ubasic.c: else_statement(): endif in singleline if-statement\n"); 
     951              ended = 1; 
     952              ubasic_error = UBASIC_E_PARSE; 
     953              return; 
     954            } 
     955          } 
     956        } 
     957        if( tokenizer_token() == TOKENIZER_ENDIF)  { 
     958          endif_cntr--; 
     959        } 
     960        if (!f_nt) { 
     961          tokenizer_next(); 
     962        } 
     963      } 
     964    } 
     965    endif_statement(); 
     966  }else{ 
     967    DEBUG_PRINTF("ubasic.c: else_statement(): CR after ELSE expected\n"); 
     968    ended = 1; 
     969    ubasic_error = UBASIC_E_PARSE; 
     970  } 
    869971} 
    870972/*---------------------------------------------------------------------------*/ 
    … …  
    881983    DEBUG_PRINTF("select_statement: SELECT-Stack fail\n"); 
    882984    ended = 1; 
    883     ubasic_error = UBASIC_E_UNKNOWN_ERROR;  //besser neuer Fehler UBASIC_E_SELECT_STACK_EXHAUSTED, 
     985    ubasic_error = UBASIC_E_UNMATCHED_END_SELECT; 
    884986  } 
    885987} 
    … …  
    895997    DEBUG_PRINTF("ubasic.c: end_select_statement(): end_select without select-statement\n"); 
    896998    ended = 1; 
    897     ubasic_error = UBASIC_E_PARSE; 
     999    ubasic_error = UBASIC_E_UNMATCHED_END_SELECT; 
    8981000  } 
    8991001} 
    … …  
    9851087    DEBUG_PRINTF("case_statement: SELECT-Stack fail\n"); 
    9861088    ended = 1; 
    987     ubasic_error = UBASIC_E_UNKNOWN_ERROR;  //besser neuer Fehler UBASIC_E_SELECT_STACK_EXHAUSTED, 
     1089    ubasic_error = UBASIC_E_UNMATCHED_END_SELECT; 
    9881090  } 
    9891091} 
    … …  
    10381140    DEBUG_PRINTF("case_else_statement: SELECT-Stack fault\n"); 
    10391141    ended = 1; 
    1040     ubasic_error = UBASIC_E_UNKNOWN_ERROR;  //besser neuer Fehler UBASIC_E_SELECT_STACK_EXHAUSTED, 
     1142    ubasic_error = UBASIC_E_UNMATCHED_END_SELECT; 
    10411143  } 
    10421144} 
    … …  
    10691171    DEBUG_PRINTF("select_statement: SELECT-stack depth exceeded\n"); 
    10701172    ended = 1; 
    1071     ubasic_error = UBASIC_E_UNKNOWN_ERROR;  //besser neuer Fehler UBASIC_E_SELECT_STACK_EXHAUSTED, 
     1173    ubasic_error = UBASIC_E_SELECT_STACK_EXHAUSTED; 
    10721174  } 
    10731175} 
    … …  
    11691271  } else { 
    11701272    DEBUG_PRINTF("next_statement: non-matching next (expected %d, found %d)\n", for_stack[for_stack_ptr - 1].for_variable, var); 
    1171     accept(TOKENIZER_CR); 
     1273    ended = 1; 
     1274    ubasic_error = UBASIC_E_UNMATCHED_NEXT; 
    11721275  } 
    11731276 
    … …  
    12051308  } else { 
    12061309    DEBUG_PRINTF("for_statement: for stack depth exceeded\n"); 
     1310    ended = 1; 
     1311    ubasic_error = UBASIC_E_FOR_STACK_EXHAUSTED; 
    12071312  } 
    12081313} 
    … …  
    12161321     do_stack[do_stack_ptr] = tokenizer_line_number(); 
    12171322     do_stack_ptr++; 
     1323  } else { 
     1324    DEBUG_PRINTF("do_statement: do stack depth exceeded\n"); 
     1325    ended = 1; 
     1326    ubasic_error = UBASIC_E_DO_STACK_EXHAUSTED; 
    12181327  } 
    12191328} 
    … …  
    12261335  accept(TOKENIZER_UNTIL); 
    12271336  r = relation(); 
    1228   if(!r) { 
    1229     if(do_stack_ptr > 0) { 
     1337  if(do_stack_ptr > 0) { 
     1338    if(!r) { 
    12301339      jump_line(do_stack[do_stack_ptr-1]); 
    1231     } 
    1232   } 
    1233   else { 
    1234     do_stack_ptr--; 
    1235         accept_cr(); 
    1236   } 
    1237  
     1340    } else { 
     1341      do_stack_ptr--; 
     1342          accept_cr(); 
     1343    } 
     1344  } else { 
     1345    DEBUG_PRINTF("until_statement: unmatched until\n"); 
     1346    ended = 1; 
     1347    ubasic_error = UBASIC_E_UNMATCHED_UNTIL; 
     1348  } 
    12381349} 
    12391350/*---------------------------------------------------------------------------*/ 
    … …  
    12491360      while_stack_ptr++; 
    12501361    } 
    1251   } 
     1362  } else { 
     1363    DEBUG_PRINTF("while_statement: while stack depth exceeded\n"); 
     1364    ended = 1; 
     1365    ubasic_error = UBASIC_E_WHILE_STACK_EXHAUSTED; 
     1366    return; 
     1367  } 
     1368 
    12521369  r = relation(); 
    1253   if(!r) { 
    1254         while_cntr=0; 
    1255     while((tokenizer_token() != TOKENIZER_WEND  || while_cntr ) &&  
    1256             tokenizer_token() != TOKENIZER_ENDOFINPUT){    
    1257             if (tokenizer_token() == TOKENIZER_WHILE) while_cntr+=1; 
    1258             if (tokenizer_token() == TOKENIZER_WEND) while_cntr-=1;            
    1259           tokenizer_next(); 
    1260         }   
    1261     while_stack_ptr--; 
     1370  if(while_stack_ptr > 0) { 
     1371    if(!r) { 
     1372        while_cntr=0; 
     1373      while((tokenizer_token() != TOKENIZER_WEND  || while_cntr ) &&  
     1374              tokenizer_token() != TOKENIZER_ENDOFINPUT){    
     1375              if (tokenizer_token() == TOKENIZER_WHILE) while_cntr+=1; 
     1376              if (tokenizer_token() == TOKENIZER_WEND) while_cntr-=1;            
     1377              tokenizer_next(); 
     1378            }   
     1379      while_stack_ptr--; 
    12621380     
    1263     accept(TOKENIZER_WEND); 
    1264     accept(TOKENIZER_CR);        
    1265   } 
    1266   else  { 
    1267         accept_cr();         
    1268   }  
     1381      accept(TOKENIZER_WEND); 
     1382      accept(TOKENIZER_CR);      
     1383    } else { 
     1384          accept_cr();         
     1385    } 
     1386  } else { 
     1387    DEBUG_PRINTF("while_statement: unmatched wend\n"); 
     1388    ended = 1; 
     1389    ubasic_error = UBASIC_E_UNMATCHED_WEND; 
     1390  } 
    12691391} 
    12701392/*---------------------------------------------------------------------------*/ 
    … …  
    12751397  if(while_stack_ptr > 0) { 
    12761398    jump_line(while_stack[while_stack_ptr-1]); 
    1277   } 
    1278   else { 
    1279         accept_cr(); 
     1399  } else { 
     1400    DEBUG_PRINTF("wend_statement: unmatched wend\n"); 
     1401    ended = 1; 
     1402    ubasic_error = UBASIC_E_UNMATCHED_WEND; 
    12801403  } 
    12811404} 
    … …  
    25772700} 
    25782701/*---------------------------------------------------------------------------*/ 
    2579  
    2580  
    2581  
    2582  
    2583  
    2584  
    2585  
Note: See TracChangeset for help on using the changeset viewer.