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