[BACK]Return to oxlistusage.c CVS log [TXT][DIR] Up to [local] / OpenXM / src / util

Annotation of OpenXM/src/util/oxlistusage.c, Revision 1.2

1.2     ! takayama    1: /* $OpenXM: OpenXM/src/util/oxlistusage.c,v 1.1 2017/03/10 01:32:50 takayama Exp $ */
1.1       takayama    2: #include <stdio.h>
                      3: #include <ctype.h>
                      4: #include <stdlib.h>
                      5: #include <sys/types.h>
                      6: #include <sys/stat.h>
                      7: #include <string.h>
                      8: #include "oxlistlocalf.h"
                      9:
1.2     ! takayama   10: void putchar0(int c);
        !            11: int fsgetc(FILE *fp);
        !            12: int readchar(void);
        !            13: int isReserved(char *name);
        !            14: void printf0(char *s);
        !            15: int shouldReplace(char *name);
        !            16: void printf1(char *name);
        !            17: int readcomment(void);
        !            18: int readcomment2(void);
        !            19:
        !            20: #define MAX_ITEM 1024*10
1.1       takayama   21: int Mydebug=0;
                     22:
                     23: objectp KClval;
                     24: int Replace = 0;
                     25: int Linenumber = 0;
                     26: int Saki = 0;
                     27: int Debug2 = 0;
                     28: FILE *Inop = NULL;
1.2     ! takayama   29: char *Functions[MAX_ITEM];
        !            30: char *Args[MAX_ITEM];
        !            31: char *Usages[MAX_ITEM];
        !            32: int Entries=0;
1.1       takayama   33:
1.2     ! takayama   34: char *readstring(int endquote);
1.1       takayama   35:
                     36: void *mymalloc(int n) { return malloc(n); }
                     37:
                     38: void myerror(char *s) {
                     39:   fprintf(stderr,"Error: %s\n",s);
                     40:   exit(-1);
                     41: }
                     42:
                     43: objectp newObject_d() {
                     44:   objectp obj;
                     45:   obj = (objectp) mymalloc(sizeof(struct Object));
                     46:   if (obj == (objectp) NULL) {
                     47:     fprintf(stderr,"Error: No more memory in newObject_d().\n");
                     48:     exit(10);
                     49:   }
                     50:   obj->tag = Snull;  obj->attr = NULL;
                     51:   return(obj);
                     52: }
                     53:
                     54: char *newString(int size) {
                     55:   char *str;
                     56:   if (size <= 0) size=1;
                     57:   str = (char *)mymalloc(sizeof(char)*size);
                     58:   if (str == (char *)NULL) {
                     59:     fprintf(stderr,"Error: No more memory in newObject_d().\n");
                     60:     exit(10);
                     61:   }
                     62:   return(str);
                     63: }
                     64:
                     65: void printObject_d(FILE *fp,objectp op)
                     66: {
                     67:   if (op == (objectp) NULL) {
                     68:     fprintf(fp," <null objectp> ");
                     69:     return;
                     70:   }
                     71:   switch(op->tag) {
                     72:   case Sinteger:
                     73:     fprintf(fp,"%d",op->lc.ival);
                     74:     return;
                     75:     break;
                     76:   case Sstring:
                     77:     fprintf(fp,"%s",op->lc.str);
                     78:     return;
                     79:     break;
                     80:   default:
                     81:     fprintf(stderr,"printObject_d(): Sorry. Not implemented.");
                     82:     break;
                     83:   }
                     84: }
                     85:
                     86: void printObjectSymbol(objectp op)
                     87: {
                     88:   static char tmp[1024];
                     89:   if (op == (objectp) NULL) {
                     90:     printf(" <null objectp> ");
                     91:     return;
                     92:   }
                     93:   switch(op->tag) {
                     94:   case Sinteger:
                     95:     printf("%d",op->lc.ival);
                     96:     return; break;
                     97:   case Sstring:
                     98:     printf("%s",op->lc.str);
                     99:     return; break;
                    100:   default:
                    101:     fprintf(stderr,"(printObjectSymbol(): Sorry. Not implemented.)");
                    102:     break;
                    103:   }
                    104: }
                    105:
                    106: int KClex() {
                    107:   extern int Saki; /* Saki-yomi */
                    108:   int d;
                    109:   int state = 0;
                    110:   int i;
                    111:   static char nametmp[1024];
                    112:   char *name = nametmp;
                    113:   char *str;
                    114:   KClval = (objectp) NULL;
                    115:   while (1) {
                    116:     switch( state ) {
                    117:     case 0:
                    118:       /* printf(" <%x> ",Saki); */
                    119:       if (Saki == EOF) {
                    120:         return(Saki);
                    121:       }
                    122:       if (Saki <= ' ') {
                    123:         if (Saki == '\n') ++Linenumber;
                    124:         if (Replace) putchar0(Saki);
                    125:         Saki = fsgetc(Inop); break;
                    126:       }
                    127:       if ( Saki == '\"' ) {
1.2     ! takayama  128:         str = readstring('\"');
1.1       takayama  129:         if (Mydebug) printf("[string: %s]",str);
                    130:
                    131:         KClval = newObject_d();
                    132:         KClval->tag = Sstring;
                    133:         KClval->lc.str = newString(strlen(str)+1);
                    134:         strcpy(KClval->lc.str,str);
                    135:
                    136:         Saki = fsgetc(Inop);
                    137:         return(QUOTE);
                    138:         break;
                    139:       }
                    140:       if (Saki == '\'' ) {
1.2     ! takayama  141:         str = readstring('\'');
        !           142:         if (strlen(str)==1) d=str[0];
        !           143:         else d='E';
1.1       takayama  144:         Saki = fsgetc(Inop);
                    145:
                    146:         KClval = newObject_d();
                    147:         KClval->tag = Sinteger;
                    148:         KClval->lc.ival = d;
                    149:
                    150:         return(SINGLEQUOTE);
                    151:       }
                    152:       /* single */
                    153:       if ( Saki == '(' || Saki == ')' || Saki == ';' ||
                    154:            Saki == '{' || Saki == '}' || Saki == ',' ||
                    155:            Saki == '[' || Saki == ']' || Saki == '~' ||
                    156:             Saki == '?' || Saki == '.' || Saki == '$') {
                    157:         d = Saki; Saki = fsgetc(Inop);
                    158:         if (Replace) putchar0(d);
                    159:         return(d);
                    160:       }
                    161:
                    162:       /* single or combination =, == */
                    163:       if ( Saki == '=') {
                    164:         state = 51; Saki = fsgetc(Inop); break;
                    165:       } else if ( Saki == '<' ) {
                    166:         state = 52; Saki = fsgetc(Inop); break;
                    167:       } else if ( Saki == '>' ) {
                    168:         state = 53; Saki = fsgetc(Inop); break;
                    169:       } else if ( Saki == '/' ) {
                    170:         state = 54; Saki = fsgetc(Inop); break;
                    171:       } else if ( Saki == '&' ) {
                    172:         state = 55; Saki = fsgetc(Inop); break;
                    173:       } else if ( Saki == '|' ) {
                    174:         state = 56; Saki = fsgetc(Inop); break;
                    175:       } else if ( Saki == '!' ) {
                    176:         state = 57; Saki = fsgetc(Inop); break;
                    177:       } else if ( Saki == ':' ) {
                    178:         state = 58; Saki = fsgetc(Inop); break;
                    179:       } else if ( Saki == '+' ) {
                    180:         state = 59; Saki = fsgetc(Inop); break;
                    181:       } else if ( Saki == '-' ) {
                    182:         state = 60; Saki = fsgetc(Inop); break;
                    183:       } else if ( Saki == '%' ) {
                    184:         state = 61; Saki = fsgetc(Inop); break;
                    185:       } else if ( Saki == '^' ) {
                    186:         state = 62; Saki = fsgetc(Inop); break;
                    187:       } else if ( Saki == '*' ) {
                    188:         state = 63; Saki = fsgetc(Inop); break;
                    189:       } else ;
                    190:
                    191:
                    192:       /* else : Identifier or function names. */
                    193:       name[0] = Saki; i=1; name[i] = '\0';
                    194:       Saki = fsgetc(Inop);
                    195:       if (isdigit(name[0])) {
                    196:         /*while (isdigit(Saki) || isalpha(Saki) || Saki=='.') */
                    197:         while (isdigit(Saki) || isalpha(Saki)) {
                    198:           name[i++] = Saki; name[i] = '\0';
                    199:           Saki = fsgetc(Inop);
                    200:         }
                    201:       }else{
                    202:         while (isdigit(Saki) || isalpha(Saki) || (Saki=='_') ||
                    203:                ( Saki>= 256)) {
                    204:           name[i++] = Saki; name[i] = '\0';
                    205:           Saki = fsgetc(Inop);
                    206:         }
                    207:       }
                    208:       if (Mydebug) printf("identifier string=[%s]",name);
                    209:       if (isdigit(name[0])) {
                    210:         /****************************
1.2     ! takayama  211:       case : machine integer.
1.1       takayama  212:     KClval = newObject_d();
                    213:     KClval->tag = Sinteger;
                    214:     sscanf(name,"%d",&(KClval->lc.ival));*************/
                    215:         /* Other cases.  */
                    216:         KClval = newObject_d();
                    217:         KClval->tag = Sstring;
                    218:         KClval->lc.str = newString(strlen(name)+1);
                    219:         strcpy(KClval->lc.str,name);
                    220:         return(NUMBER);
                    221:         break;
                    222:       } /* else : Identifier case.*/
                    223:
1.2     ! takayama  224:       if ((d = isReserved(name))) {
1.1       takayama  225:         if (Replace) printf0(name);
                    226:         return(d);
                    227:       } else {
                    228:         if (Replace) {
                    229:           if (shouldReplace(name))
                    230:             printf1(name); /* do your own replacement in printf1*/
                    231:           else
                    232:             printf0(name);
                    233:         }
                    234:         KClval = newObject_d();
                    235:         KClval->tag = Sstring;
                    236:         KClval->lc.str = newString(strlen(name)+1);
                    237:         strcpy(KClval->lc.str,name);
                    238:         return(ID);
                    239:       }
                    240:       break;
                    241:
                    242:     case 51:
                    243:       if (Replace) putchar0('=');
                    244:       if ( Saki == '=') {
                    245:         if (Replace) putchar0('=');
                    246:         Saki = fsgetc(Inop);state = 0;return(EQUAL); /* == */
                    247:       }else{
                    248:         state = 0;return('=');
                    249:       }
                    250:       break;
                    251:     case 52: /* 52 --- 60 tmporary return values */
                    252:       if (Replace) putchar0('<');
                    253:       if ( Saki == '=') {
                    254:         if (Replace) putchar0('=');
                    255:         Saki = fsgetc(Inop);state = 0;return(LESSEQUAL); /* <= */
                    256:       } else if ( Saki == '<') {
                    257:         if (Replace) putchar0('<');
                    258:         Saki = fsgetc(Inop);state = 0;return(LEFTSHIFT); /* << */
                    259:       }else{
                    260:         state = 0;return('<');
                    261:       }
                    262:       break;
                    263:     case 53:
                    264:       if (Replace) putchar0('>');
                    265:       if ( Saki == '=') {
                    266:         if (Replace) putchar0('=');
                    267:         Saki = fsgetc(Inop);state = 0;return(GREATEREQUAL); /* >= */
                    268:       } else if ( Saki == '>') {
                    269:         if (Replace) putchar0('>');
                    270:         Saki = fsgetc(Inop);state = 0;return(RIGHTSHIFT); /* >> */
                    271:       }else{
                    272:         state = 0;return('>');
                    273:       }
                    274:       break;
                    275:     case 54:
                    276:       if ( Saki == '*') {
                    277:         readcomment();
                    278:         Saki = fsgetc(Inop);state = 0;break; /* clike-comment */
                    279:       }else if (Saki == '/') {
                    280:         readcomment2();
                    281:         Saki = fsgetc(Inop);state = 0;break; /* comment by // */
                    282:       }else {
                    283:         if (Replace) putchar0('/');
                    284:         state = 0;return('/');
                    285:       }
                    286:       break;
                    287:     case 55:
                    288:       if (Replace) putchar0('&');
                    289:       if ( Saki == '&') {
                    290:         if (Replace) putchar0('&');
                    291:         Saki = fsgetc(Inop);state = 0;return(AND); /* && */
                    292:       }else{
                    293:         state = 0;return('&');
                    294:       }
                    295:       break;
                    296:     case 56:
                    297:       if (Replace) putchar0('|');
                    298:       if ( Saki == '|') {
                    299:         if (Replace) putchar0('|');
                    300:         Saki = fsgetc(Inop);state = 0;return(OR); /* || */
                    301:       }else{
                    302:         state = 0;return('|');
                    303:       }
                    304:       break;
                    305:     case 57:
                    306:       if (Replace) putchar0('!');
                    307:       if ( Saki == '=') {
                    308:         if (Replace) putchar0('=');
                    309:         Saki = fsgetc(Inop);state = 0;return(NOTEQUAL); /* != */
                    310:       }else{
                    311:         state = 0;return('!');
                    312:       }
                    313:       break;
                    314:     case 58:
                    315:       if (Replace) putchar0(':');
                    316:       if ( Saki == '=') {
                    317:         if (Replace) putchar0('=');
                    318:         Saki = fsgetc(Inop);state = 0;return(PUT); /* := */
                    319:       }else{
                    320:         state = 0;return(':');
                    321:       }
                    322:       break;
                    323:     case 59:
                    324:       if (Replace) putchar0('+');
                    325:       if ( Saki == '+') {
                    326:         if (Replace) putchar0('+');
                    327:         Saki = fsgetc(Inop);state = 0;return(INCREMENT); /* ++ */
                    328:       }else{
                    329:         state = 0;return('+');
                    330:       }
                    331:       break;
                    332:     case 60:
                    333:       if (Replace) putchar0('-');
                    334:       if ( Saki == '-') {
                    335:         if (Replace) putchar0('-');
                    336:         Saki = fsgetc(Inop);state = 0;return(DECREMENT); /* -- */
                    337:       }else if (Saki == '>') {
                    338:         if (Replace) putchar0('>');
                    339:         Saki = fsgetc(Inop);state = 0;return(MEMBER); /* -> */
                    340:       }else{
                    341:         state = 0;return('-');
                    342:       }
                    343:       break;
                    344:     case 61:
                    345:       if (Replace) putchar0('%');
                    346:       if ( Saki == '=') {
                    347:         if (Replace) putchar0('=');
                    348:         Saki = fsgetc(Inop);state = 0;return(RESIDUEPUT); /* %= */
                    349:       }else{
                    350:         state = 0;return('%');
                    351:       }
                    352:       break;
                    353:     case 62:
                    354:       if (Replace) putchar0('^');
                    355:       if ( Saki == '=') {
                    356:         if (Replace) putchar0('=');
                    357:         Saki = fsgetc(Inop);state = 0;return(NEGATEPUT); /* ^= */
                    358:       }else{
                    359:         state = 0;return('^');
                    360:       }
                    361:       break;
                    362:     case 63:
                    363:       if (Replace) putchar0('*');
                    364:       if ( Saki == '=') {
                    365:         if (Replace) putchar0('=');
                    366:         Saki = fsgetc(Inop);state = 0;return(MULTPUT); /* *= */
                    367:       }else{
                    368:         state = 0;return('*');
                    369:       }
                    370:       break;
                    371:
                    372:
                    373:     default:
                    374:       fprintf(stderr,"%d: Error in KClex().\n",Linenumber);
                    375:     }
                    376:   }
                    377:
                    378: }
                    379:
                    380:
1.2     ! takayama  381: int readcomment() {
1.1       takayama  382:   int c;
                    383:   while (1) {
                    384:     c = fsgetc(Inop);
                    385:     if (c == EOF) {
                    386:       fprintf(stderr,"%d: Unexpected end of file in a comment.\n",Linenumber);
                    387:       return 0;
                    388:     }
                    389:     if (c == '*') {
                    390:       c = fsgetc(Inop);
                    391:       if (c == '/') return 0;
                    392:     }
                    393:   }
                    394: }
                    395:
1.2     ! takayama  396: int readcomment2() {
1.1       takayama  397:   int c;
                    398:   while (1) {
                    399:     c = fsgetc(Inop);
                    400:     if (c == EOF) {
                    401:       fprintf(stderr,"%d: Unexpected end of file in a comment.\n",Linenumber);
                    402:       return 0;
                    403:     }
                    404:     if (c == '\n') {
                    405:       return 0;
                    406:     }
                    407:   }
                    408: }
                    409:
                    410:
1.2     ! takayama  411: char *readstring(int endquote) {
1.1       takayama  412:   static char strtmp[1024]; /* temporary */
                    413:   static int size = 1024;
                    414:   static char *str = strtmp;
                    415:   int i=0;
                    416:   int c;
                    417:   static char *strwork;
                    418:
                    419:
                    420:   if (Replace) putchar0('\"'); /* output " */
                    421:   while (1) {
                    422:     c = fsgetc(Inop);
                    423:     if (Replace) putchar0(c);
1.2     ! takayama  424:     if (c == endquote) {
1.1       takayama  425:       str[i] = '\0';
                    426:       return(str);
                    427:     }
                    428:     if (c == EOF) {
                    429:       fprintf(stderr,"%d: Unexpected end of file in the string.\n",Linenumber);
                    430:       str[i]= '\0';
                    431:       return(str);
                    432:     }
                    433:     if (c == '\\') {
                    434:       c = fsgetc(Inop);
                    435:       if (Replace) {
1.2     ! takayama  436:        putchar0(c);
        !           437:       }
        !           438:       switch(c) {  /* interprete as escape sequence. */
        !           439:       case 'n': c='\n'; break;
        !           440:       case 't': c='\t'; break;
        !           441:       default: break;
1.1       takayama  442:       }
                    443:       if (c == EOF) {
                    444:         fprintf(stderr,"%d: Unexpected end of file in the escape sequence.\n",Linenumber);
                    445:         str[i]= '\0';
                    446:         return(str);
                    447:       }
                    448:     }
                    449:
                    450:     str[i++] = c;
                    451:     if (i >= size-10) {
                    452:       size = size*2;
                    453:       strwork = newString(size);
                    454:       strcpy(strwork,str);
                    455:       str = strwork;
                    456:     }
                    457:   }
                    458: }
                    459:
                    460:
1.2     ! takayama  461: int readchar() {
1.1       takayama  462:   int c;
                    463:   if (Replace) putchar0('\'');
                    464:   c = fsgetc(Inop); /* 'c.'   '\.c' */
                    465:   if (Replace) putchar0(c);
                    466:   if ( c == '\\') {
                    467:     c = fsgetc(Inop); /* '\c.' */
                    468:     if (Replace) putchar0(c);
                    469:     if (c == EOF) {
                    470:       fprintf(stderr,"%d: Unexpected end of file in the escape sequence.\n",Linenumber);
                    471:       return(-1);
                    472:     }
                    473:     if (fsgetc(Inop) != '\'') {
                    474:       fprintf(stderr,"%d: Error in single quote string (escape seq)\n",Linenumber);
                    475:       return(c);
                    476:     }
                    477:     if (Replace) putchar0('\'');
                    478:     return(c);
                    479:   }
                    480:
                    481:   if (fsgetc(Inop) != '\'') {
                    482:     fprintf(stderr,"%d: Error in single quote string\n",Linenumber);
                    483:   }
                    484:   if (Replace) putchar0('\'');
                    485:   return(c);
                    486: }
                    487:
1.2     ! takayama  488: void putchar0(c)
1.1       takayama  489:   int c;
                    490: {
                    491:   if (c > 0) putchar(c);
                    492: }
                    493:
1.2     ! takayama  494: void printf0(s)
1.1       takayama  495:   char *s;
                    496: {
                    497:   int i = 0;
                    498:   while (s[i] != '\0') putchar0(s[i++]);
                    499: }
                    500:
1.2     ! takayama  501: void printf1(s)
1.1       takayama  502:   char *s;
                    503: {
                    504:   int i = 0;
                    505:   /* putchar0('K'); */   /* do your own replacement */
                    506:   while (s[i] != '\0') putchar0(s[i++]);
                    507: }
                    508:
1.2     ! takayama  509: int isReserved(s)
1.1       takayama  510:   char *s;
                    511: {
                    512:   char *r[] = {"auto","break","case","char","const","continue",
                    513:                "default","do","double","else","enum","extern",
                    514:                "float","for","goto","if","int","long","register",
                    515:                "return","short","signed","sizeof","static","struct",
                    516:                "switch","typedef","union","unsigned","volatile",
                    517:                "void","while",
                    518:                "print","module","local","def","sm1","load","Test","special",
1.2     ! takayama  519:                "class","super","final","extends",
1.1       takayama  520:                "incetanceVariable","this","new","startOfThisClass",
                    521:                "sizeOfThisClass","PSfor","OutputPrompt"};
                    522:
                    523:   int  val[]= {AUTO, BREAK, CASE, CHAR, CONST, CONTINUE, DEFAULT, DO, DOUBLE,
                    524:                ELSE, ENUM,
                    525:                EXTERN, FLOAT, FOR, GOTO, IF, INT, LONG, REGISTER,
                    526:                RETURN, SHORT, SIGNED, SIZEOF, STATIC, STRUCT, SWITCH,
                    527:                TYPEDEF, UNION,
                    528:                UNSIGNED, VOLATILE, VOID, WHILE,
                    529:                PRINT,MODULE,LOCAL,DEF,SM1,LOAD,TEST,SPECIAL,
1.2     ! takayama  530:                CLASS,SUPER,FINAL,EXTENDS,INCETANCEVARIABLE,
1.1       takayama  531:                THIS, NEW, STARTOFTHISCLASS, SIZEOFTHISCLASS,PSFOR,PROMPT};
1.2     ! takayama  532:   int  n = 51; /* Length of the list above */
1.1       takayama  533:   /* You have to change simple.y, too. */
                    534:
                    535:   int i;
                    536:   for (i=0; i<n; i++) {
                    537:     if (strcmp(r[i],s) == 0) {
                    538:       if (Debug2) printf("\nReserved word: %s ---\n",s);
                    539:       return(val[i]);
                    540:     }
                    541:   }
                    542:   return(0);
                    543:
                    544: }
                    545:
1.2     ! takayama  546: int shouldReplace(s)
1.1       takayama  547:   char *s;
                    548: {
                    549:   char *r[] = {"dummy"};
                    550:   int n = 1;
                    551:   int i;
                    552:   for (i=0; i<n; i++) {
                    553:     if (strcmp(r[i],s) == 0) {
                    554:       /* printf("\n--- %s ---\n",s); */
                    555:       return(1);
                    556:     }
                    557:   }
                    558:   return(1); /* change to 0. */
                    559: }
                    560:
                    561:
                    562:
                    563: int fsgetc(FILE *fp) {
                    564:   int c;
                    565:   return(fgetc(fp));
                    566: }
                    567:
1.2     ! takayama  568: int oxgOut(char *inFname) {
        !           569:   FILE *fp;
        !           570:   int i;
        !           571:   fp = stdout;
        !           572:   for (i=0; i<Entries; i++) {
        !           573:     fprintf(fp,"/*&usage begin:\n");
        !           574:     fprintf(fp,"%s%s\n",Functions[i],Args[i]);
        !           575:     fprintf(fp,"description: %s\n",Usages[i]);
        !           576:     fprintf(fp,"end: */\n\n");
        !           577:   }
        !           578:   return(0);
        !           579: }
1.1       takayama  580:
1.2     ! takayama  581: int outUsage(char *inFname,int oxg) {
1.1       takayama  582:   int c;
1.2     ! takayama  583:   char usage[1024*100];
1.1       takayama  584:   char fname[1024];
                    585:   char *args[1024];
1.2     ! takayama  586:   char outbuf[1024*10];
1.1       takayama  587:   char *tt;
                    588:   int prevtype;
                    589:   int i;
1.2     ! takayama  590:   Entries=0;
1.1       takayama  591:   while ((c=KClex()) != EOF) {
                    592:     if (c == DEF) {
                    593:       c=KClex();
                    594:       if (c != ID) {
1.2     ! takayama  595:         fprintf(stderr,"ID (identifier) is expected, but the token type is %d. See isReserved() in oxlistusage.c\n",c);
1.1       takayama  596:       }else {
                    597:         if (Mydebug) printf("ID=%s",(KClval->lc).str);
                    598:         strcpy(fname,(KClval->lc).str); // def ...
                    599:         if (Mydebug) printf("fname=%s,",fname);
                    600:       }
                    601:       prevtype=0;
                    602:       i=0; args[i]=NULL;
                    603:       while (c != '{') {
                    604:         prevtype=c;
                    605:         c=KClex();
                    606:         if (c == QUOTE) {
                    607:           strcpy(usage,(KClval->lc).str);
                    608:           if (Mydebug) printf("usage=%s,",usage);
                    609:         }else if (c == ID) {
                    610:           if (Mydebug) { printf("tag=%d ",KClval->tag); fflush(NULL);}
                    611:           if (KClval->tag == Sstring) {
                    612:             tt = (char *) mymalloc(strlen((KClval->lc).str)+2);
                    613:             if (tt == NULL) myerror("No memory\n");
                    614:             strcpy(tt,(KClval->lc).str);
                    615:             args[i++] = tt;
                    616:             args[i] = NULL;
                    617:             if (i >1024-2) {fprintf(stderr,"def %s: ",fname); myerror("Too many args.\n");
                    618:             }
                    619:           }
                    620:         }
                    621:         if (prevtype == QUOTE) {
1.2     ! takayama  622:           /**/printf("\nFunction: %s(",fname);
        !           623:           Functions[Entries]=(char *)mymalloc(strlen(fname)+2);
        !           624:           strcpy(Functions[Entries],fname);
        !           625:           sprintf(outbuf,"(");
1.1       takayama  626:           for (i=0; args[i] != NULL; i++) {
1.2     ! takayama  627:             /**/printf("%s",args[i]);
        !           628:             sprintf(&(outbuf[strlen(outbuf)]),"%s",args[i]);
        !           629:             if (args[i+1] != NULL) {
        !           630:               /**/printf(",");
        !           631:              sprintf(&(outbuf[strlen(outbuf)]),",");
        !           632:              }
1.1       takayama  633:           }
1.2     ! takayama  634:           /**/printf(")\n");
        !           635:          sprintf(&(outbuf[strlen(outbuf)]),")");
        !           636:          Args[Entries] = (char *)mymalloc(strlen(outbuf)+2);
        !           637:          strcpy(Args[Entries],outbuf);
        !           638:           /**/printf("Usage: %s\n",usage);
        !           639:          Usages[Entries] = (char *)mymalloc(strlen(usage)+2);
        !           640:          strcpy(Usages[Entries],usage);
        !           641:           Entries++;
1.1       takayama  642:         }
                    643:       }
                    644:     }
                    645:   }
1.2     ! takayama  646:   if (oxg) { oxgOut(inFname); Entries=0;}
1.1       takayama  647:   return(0);
                    648: }
1.2     ! takayama  649:
        !           650: int main(int argc,char *argv[]) {
        !           651:   int i;
        !           652:   int oxg=0;
        !           653:   Inop = stdin;
        !           654:   for (i=1; i<argc; i++) {
        !           655:     if (argv[i][0] == '-') {
        !           656:       if (strcmp(argv[i],"--oxgentexi")==0) oxg=1;
        !           657:     }else {
        !           658:       Inop = fopen(argv[i],"r");
        !           659:       if (Inop == NULL) {
        !           660:        fprintf(stderr,"File %s is not found.\n",argv[1]); return(-1);
        !           661:       }
        !           662:       outUsage(argv[i],oxg);
        !           663:       fclose(Inop);
        !           664:     }
        !           665:   }
        !           666:   if (Inop == stdin) outUsage("stdin",oxg);
        !           667: }

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