[BACK]Return to scanner2.c CVS log [TXT][DIR] Up to [local] / OpenXM / src / kan96xx / Kan

Annotation of OpenXM/src/kan96xx/Kan/scanner2.c, Revision 1.4

1.4     ! takayama    1: /* $OpenXM: OpenXM/src/kan96xx/Kan/scanner2.c,v 1.3 2001/05/04 01:06:25 takayama Exp $ */
1.1       maekawa     2: /*  scanner2.c (SM StackMachine) */
                      3: /* export: struct tokens decompostToTokens(char *str,int *sizep);
                      4:    scanner2.c is for getting tokens from a string.
                      5: */
                      6: #include <stdio.h>
                      7: #include "datatype.h"
                      8: #include "stackm.h"
                      9: struct tokens lookupTokens(struct tokens t);
                     10: int isLiteral(char *s);
                     11: struct object lookupLiteralString(char *s);
                     12: /****************  defined in stackm.h ****************************
1.3       takayama   13:                    typedef enum {INIT,GET,PUT,OPEN} actionType;
1.1       maekawa    14:
1.3       takayama   15:                    struct tokens{
                     16:                    char *token;
                     17:                    int kind;
                     18:                    };
1.1       maekawa    19:
                     20:
1.3       takayama   21:                    #define ID   2
                     22:                    #define DOLLAR 3    strings enclosed by dollar sign
                     23:                    #define EXECUTABLE_STRING 4  strings enclosed by {}
                     24:                    #define EXECUTABLE_ARRAY  8  Don't set it in this file.
1.1       maekawa    25: ******************************************************************/
                     26:
                     27:
                     28: /*******   declaration-part of lexical analizer ********************/
                     29: #define mygetchar()  getSM()
                     30: /* to use getSM()  ( input from StringSM ),
                     31:    setup  StringSM;
                     32:    getokenSM(INIT);
                     33: */
                     34:
                     35:
                     36:
                     37:
                     38: #define BUF0LIMIT 40000
                     39: static char *StringSM;
                     40: static int StrpSM = 0;
                     41: static char BufSMorg[BUF0LIMIT];
                     42: static char *BufSM = BufSMorg;
                     43: static int Buf0limit = BUF0LIMIT ;
                     44: static int ExistSM = 0;
                     45: static int TypeSM = ID;
                     46:
                     47: /****************  end of declaration part of lexical analizer ******/
                     48:
                     49: static int getSM();
                     50: static putSM();
                     51: static struct tokens flushSM();
                     52: static isSpaceSM();
                     53: static isDollarSM();
                     54: static isBraceSM();
                     55: static isKakkoSM();
                     56: static isSymbolSM();
                     57: static struct tokens getokenSM2();
                     58:
                     59: /****************  code part of lexical analizer ********************/
                     60:
                     61: struct tokens *decomposeToTokens(str,sizep)
1.3       takayama   62:      char *str;
                     63:      int *sizep;
1.1       maekawa    64: {
                     65:   struct tokens *tArray;
                     66:   struct tokens token;
                     67:   int k;
                     68:   int size;
                     69:
                     70:   StringSM = (char *) sGC_malloc((strlen(str)+3)*sizeof(char));
                     71:   if (StringSM == (char *)NULL) {
                     72:     errorScanner2("I have no memormy.");
                     73:   }
                     74:   strcpy(StringSM,str);
                     75:   getokenSM2(INIT);
                     76:   size = 0;
                     77:   token = getokenSM2(GET);
                     78:   while (token.kind != -1) {
                     79:     size++;
                     80:     token = getokenSM2(GET);
                     81:   }
                     82:
                     83:   tArray = (struct tokens *)sGC_malloc((size+1)*sizeof(struct tokens));
                     84:   strcpy(StringSM,str);
                     85:   getokenSM2(INIT);
                     86:   for (k=0; k<size; k++) {
                     87:     tArray[k] = getokenSM2(GET);
                     88:   }
                     89:
                     90:   *sizep = size;
                     91:   return(tArray);
                     92: }
                     93:
                     94:
                     95:
                     96: static int getSM()
1.3       takayama   97:      /* get a letter from StringSM */
1.1       maekawa    98: {
                     99:   int c;
                    100:   c = StringSM[StrpSM++];
                    101:   if (c == '\0') {
                    102:     StrpSM--;return(EOF);
                    103:   } else return(c);
                    104: }
                    105:
                    106: static putSM(c)
1.3       takayama  107:      int c;
                    108:      /* put a letter on BufSM */
1.1       maekawa   109: {
                    110:   char *new; int i;
                    111:   BufSM[ExistSM++] = ((c=='\n')? ' ' : c);
                    112:   if (ExistSM >= Buf0limit-1)  {
                    113:     new = (char *) sGC_malloc(sizeof(char *)*Buf0limit*2) ;
                    114:     if (new == (char *)NULL) {
                    115:       fprintf(stderr,"No more memory in parserpass0.c\n");
                    116:       exit(18);
                    117:     }
                    118:     fprintf(stderr,"\nSystem Message: Increasing BufSM to %d in scanner2.c\n",Buf0limit*2);
                    119:     for (i=0; i<Buf0limit; i++) {
                    120:       new[i] = BufSM[i];
                    121:     }
                    122:     BufSM = new; Buf0limit *= 2;
                    123:   }
                    124: }
                    125:
                    126: static struct tokens flushSM()
                    127: {
                    128:   char *token;
                    129:   struct tokens r;
                    130:   if (ExistSM<=0) {
                    131:     fprintf(stderr,"\n flushSM() is called without data. Don't use the empty string $$. \n");
                    132:     r.token = (char *)NULL; r.kind = -10; /* -1 ==> -10 ***/
                    133:     return(r);
                    134:   }
                    135:   BufSM[ExistSM] = '\0';
                    136:   ExistSM = 0;
                    137:   token = (char *)sGC_malloc((strlen(BufSM)+1)*sizeof(char));
                    138:   strcpy(token,BufSM);
                    139:   r.token = token;
                    140:   r.kind = TypeSM;
                    141:   if (r.kind == ID) {
                    142:     if (isLiteral(r.token)) {
1.3       takayama  143:       r.object = lookupLiteralString(r.token);
1.1       maekawa   144:     }else{
                    145:       r = lookupTokens(r); /* Compute hashing values */
                    146:     }
                    147:   }
                    148:   return(r);
                    149: }
                    150:
                    151: static isSpaceSM(c)
1.3       takayama  152:      int c;
1.1       maekawa   153: {
1.4     ! takayama  154:   static int prev=0;
        !           155:   if ((c == ',') && (prev == ',')) fprintf(stderr,"Warning! ,, is found.\n");
        !           156:   prev = c;
        !           157:
        !           158:   if (((c <= ' ') || c == ',') && (c!= EOF)) return(1);
1.1       maekawa   159:   else return(0);
                    160: }
                    161:
                    162: static isDollarSM(c)
1.3       takayama  163:      int c;
1.1       maekawa   164: {
                    165:   if (c == '$') return(1);
                    166:   else return(0);
                    167: }
                    168:
                    169: static isBraceSM(c)
1.3       takayama  170:      int c;
1.1       maekawa   171: {
                    172:   if (c == '{') return(1);
                    173:   else return(0);
                    174: }
                    175:
                    176: static isKakkoSM(c)
1.3       takayama  177:      int c;
1.1       maekawa   178: {
                    179:   if (c == '(') return(1);
                    180:   else return(0);
                    181: }
                    182:
                    183: static isSymbolSM(c)
1.3       takayama  184:      int c;
1.1       maekawa   185: {
                    186:   if ((c == '{') ||
                    187:       (c == '}') ||
                    188:       (c == '[') ||
                    189:       (c == ']') ||
                    190:       (c == '(') ||
                    191:       (c == ')'))
                    192:     return(1);
                    193:   else return(0);
                    194: }
                    195:
                    196: static struct tokens getokenSM2(kind,str)
1.3       takayama  197:      actionType kind;
                    198:      char *str;
1.1       maekawa   199: {
                    200:   static int c;
                    201:   static struct tokens rnull;
                    202:   int level;
                    203:
                    204:   if (kind == INIT) {
                    205:     StrpSM = 0;
                    206:     ExistSM = 0;
                    207:
                    208:     c = mygetchar();
                    209:     rnull.token = (char *)NULL; rnull.kind = -1;
                    210:     return(rnull);
                    211:   }
                    212:
                    213:
                    214:
                    215:   for (;;) {
                    216:     TypeSM = ID;
                    217:     if (c == EOF) {
                    218:       if (ExistSM) return(flushSM());
                    219:       else return(rnull);
                    220:     } else if (isSpaceSM(c)) {
                    221:       if (ExistSM) {
1.3       takayama  222:         c = mygetchar(); return(flushSM());
1.1       maekawa   223:       }else {
1.3       takayama  224:         while (isSpaceSM(c=mygetchar())) ;
1.1       maekawa   225:       }
                    226:     } else if (isDollarSM(c)) { /* output contents in dollar signs. */
                    227:       if (ExistSM) return(flushSM());
                    228:       else {
1.3       takayama  229:         c = mygetchar();
                    230:         while ((c != EOF) && (c != '$')) {
                    231:           putSM(c);
                    232:           c = mygetchar();
                    233:         }
                    234:         if (c=='$') c=mygetchar();
                    235:         TypeSM = DOLLAR;
                    236:         return(flushSM());
1.1       maekawa   237:       }
                    238:     } else if (isBraceSM(c)) { /* output contents in { }  */
                    239:       /*  { {  } } */
                    240:       level = 0;
                    241:       if (ExistSM) return(flushSM());
                    242:       else {
1.3       takayama  243:         c = mygetchar();
                    244:         while (1) {
                    245:           if (c == '%') { /* skip the comment in the brace. */
                    246:             while (((c=mygetchar()) != '\n') && (c != EOF))  ;
                    247:           }
                    248:           if (c == EOF) break;
                    249:           if ((c == '}') && (level <= 0)) break;
                    250:           if ( c == '{') ++level;
                    251:           if ( c == '}') --level;
                    252:           putSM(c);
                    253:           c = mygetchar();
                    254:         }
                    255:         if (c=='}') c=mygetchar();
                    256:         TypeSM = EXECUTABLE_STRING;
                    257:         return(flushSM());
1.1       maekawa   258:       }
                    259:     } else if (isKakkoSM(c)) { /* output contents in (  )  */
                    260:       level = 0;
                    261:       if (ExistSM) return(flushSM());
                    262:       else {
1.3       takayama  263:         c = mygetchar();
                    264:         while (1) {
                    265:           if (c == EOF) break;
                    266:           if (c == '\\') { /* e.g. \(  */
                    267:             putSM(c);
                    268:             c = mygetchar();
                    269:             if (c == EOF) break;
                    270:           }else{
                    271:             if ((c == ')') && (level <= 0)) break;
                    272:             if ( c == '(') ++level;
                    273:             if ( c == ')') --level;
                    274:           }
                    275:           putSM(c);
                    276:           c = mygetchar();
                    277:         }
                    278:         if (c==')') c=mygetchar();
                    279:         TypeSM = DOLLAR;
                    280:         return(flushSM());
1.1       maekawa   281:       }
                    282:     } else if (c=='%') { /* comment */
                    283:       while (((c=mygetchar()) != '\n') && (c != EOF))  ;
                    284:       if(ExistSM) return(flushSM());
                    285:     } else if (isSymbolSM(c)) { /* symbols. {,} etc */
                    286:       if(ExistSM) return(flushSM());
                    287:       else {
1.3       takayama  288:         putSM(c);
                    289:         c = mygetchar();
                    290:         return(flushSM());
1.1       maekawa   291:       }
                    292:     } else { /* identifier */
                    293:       putSM(c);
                    294:       c =mygetchar();
                    295:       while ((!isDollarSM(c)) &&
1.3       takayama  296:              (!isSpaceSM(c))  &&
                    297:              (!isSymbolSM(c)) &&
                    298:              (c != EOF)) {
                    299:         putSM(c);
                    300:         c = mygetchar();
1.1       maekawa   301:       }
                    302:       return(flushSM());
                    303:     }
                    304:   }
                    305: }
                    306:
                    307: /*********** end of code part of lexical analizer ********************/
                    308:
                    309:
                    310: errorScanner2(str)
1.3       takayama  311:      char *str;
1.1       maekawa   312: {
                    313:   fprintf(stderr,"Error (scanner2.c): %s\n",str);
                    314:   exit(10);
                    315: }
                    316:

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>