Return to vms-pp.c CVS log

Up to [Apple XNU] / GNUtools / emacs / src

Annotation of GNUtools/emacs/src/vms-pp.c, revision 1.1

1.1     ! root        1: /* vms_pp - preprocess emacs files in such a way that they can be
        !             2:  *          compiled on VMS without warnings.
        !             3:  * Copyright (C) 1986 Free Software Foundation, Inc.
        !             4:    
        !             5: This file is part of GNU Emacs.
        !             6: 
        !             7: GNU Emacs is free software; you can redistribute it and/or modify
        !             8: it under the terms of the GNU General Public License as published by
        !             9: the Free Software Foundation; either version 1, or (at your option)
        !            10: any later version.
        !            11: 
        !            12: GNU Emacs is distributed in the hope that it will be useful,
        !            13: but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            15: GNU General Public License for more details.
        !            16: 
        !            17: You should have received a copy of the GNU General Public License
        !            18: along with GNU Emacs; see the file COPYING.  If not, write to
        !            19: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
        !            20: 
        !            21:  *
        !            22:  * Usage:
        !            23:  *     vms_pp infile outfile
        !            24:  * implicit inputs:
        !            25:  *     The file "vms_pp.trans" has the names and their translations.
        !            26:  * description:
        !            27:  *     Vms_pp takes the input file and scans it, replacing the long
        !            28:  *     names with shorter names according to the table read in from
        !            29:  *     vms_pp.trans. The line is then written to the output file.
        !            30:  *
        !            31:  *     Additionally, the "#undef foo" construct is replaced with:
        !            32:  *             #ifdef foo
        !            33:  *             #undef foo
        !            34:  *             #endif
        !            35:  *
        !            36:  *     The construct #if defined(foo) is replaced with
        !            37:  *             #ifdef foo
        !            38:  *             #define foo_VAL 1
        !            39:  *             #else
        !            40:  *             #define foo_VAL 0
        !            41:  *             #endif
        !            42:  *             #define defined(XX) XX_val
        !            43:  *             #if defined(foo)
        !            44:  *
        !            45:  *     This last contruction only works on single line #if's and takes
        !            46:  *     advantage of a questionable C pre-processor trick. If there are
        !            47:  *     comments within the #if, that contain "defined", then this will
        !            48:  *     bomb.
        !            49:  */
        !            50: #include <stdio.h>
        !            51: 
        !            52: #define Max_table 100
        !            53: #define Table_name "vms_pp.trans"
        !            54: #define Word_member \
        !            55: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$"
        !            56: 
        !            57: static   FILE *in,*out;                        /* read from, write to */
        !            58: struct item {                          /* symbol table entries */
        !            59:   char *name;
        !            60:   char *value;
        !            61: };
        !            62: static struct item name_table[Max_table]; /* symbol table */
        !            63: static int defined_defined = 0;                /* small optimization */
        !            64: 
        !            65: main(argc,argv) int argc; char **argv; {
        !            66:   char buffer[1024];
        !            67: 
        !            68:   if(argc != 3) {                      /* check argument count */
        !            69:     fprintf(stderr,"usage: vms_pp infile outfile");
        !            70:     exit();
        !            71:   }
        !            72:   init_table();                                /* read in translation table */
        !            73: 
        !            74: /* open input and output files
        !            75:  */
        !            76:   if((in = fopen(argv[1],"r")) == NULL) {
        !            77:     fprintf(stderr,"vms_pp: unable to open file '%s'",argv[1]);
        !            78:     exit();
        !            79:   }
        !            80:   if((out = fopen(argv[2],"w")) == NULL) {
        !            81:     fprintf(stderr,"vms_pp: unable to create file '%s'",argv[2]);
        !            82:     exit();
        !            83:   }
        !            84: 
        !            85:   while(fgets(buffer,1023,in) != NULL) { /* loop through buffer until end */
        !            86:     process_line(buffer);              /* process the line */
        !            87:     fputs(buffer,out);                 /* write out the line */
        !            88:   }
        !            89: }
        !            90: 
        !            91: /* buy - allocate and copy a string
        !            92:  */
        !            93: static char *buy(str) char *str; {
        !            94:   char *temp;
        !            95: 
        !            96:   if(!(temp = malloc(strlen(str)+1))) {
        !            97:     fprintf(stderr,"vms_pp: can't allocate memory");
        !            98:     exit();
        !            99:   }
        !           100:   strcpy(temp,str);
        !           101:   return temp;
        !           102: }
        !           103: 
        !           104: /* gather_word - return a buffer full of the next word
        !           105:  */
        !           106: static char *gather_word(ptr,word) char *ptr, *word;{
        !           107:   for(; strchr(Word_member,*ptr); ptr++,word++)
        !           108:     *word = *ptr;
        !           109:   *word = 0;
        !           110:   return ptr;
        !           111: }
        !           112: 
        !           113: /* skip_white - skip white space
        !           114:  */
        !           115: static char *skip_white(ptr) char *ptr; {
        !           116:   while(*ptr == ' ' || *ptr == '\t')
        !           117:     ptr++;
        !           118:   return ptr;
        !           119: }
        !           120: 
        !           121: /* init_table - initialize translation table.
        !           122:  */
        !           123: init_table() {
        !           124:   char buf[256],*ptr,word[128];
        !           125:   FILE *in;
        !           126:   int i;
        !           127: 
        !           128:   if((in = fopen(Table_name,"r")) == NULL) { /* open file */
        !           129:     fprintf(stderr,"vms_pp: can't open '%s'",Table_name);
        !           130:     exit();
        !           131:   }
        !           132:   for(i = 0; fgets(buf,255,in) != NULL;) { /* loop through lines */
        !           133:     ptr = skip_white(buf);
        !           134:     if(*ptr == '!')                    /* skip comments */
        !           135:       continue;
        !           136:     ptr = gather_word(ptr,word);       /* get long word */
        !           137:     if(*word == 0) {                   /* bad entry */
        !           138:       fprintf(stderr,"vms_pp: bad input line '%s'\n",buf);
        !           139:       continue;
        !           140:     }
        !           141:     name_table[i].name = buy(word);    /* set up the name */
        !           142:     ptr = skip_white(ptr);             /* skip white space */
        !           143:     ptr = gather_word(ptr,word);       /* get equivalent name */
        !           144:     if(*word == 0) {                   /* bad entry */
        !           145:       fprintf(stderr,"vms_pp: bad input line '%s'\n",buf);
        !           146:       continue;
        !           147:     }
        !           148:     name_table[i].value = buy(word);   /* and the equivalent name */
        !           149:     i++;                               /* increment to next position */
        !           150:   }
        !           151:   for(; i < Max_table; i++)            /* mark rest as unused */
        !           152:     name_table[i].name = 0;
        !           153: }
        !           154: 
        !           155: /* process_line - do actual line processing
        !           156:  */
        !           157: process_line(buf) char *buf; {
        !           158:   char *in_ptr,*out_ptr;
        !           159:   char word[128],*ptr;
        !           160:   int len;
        !           161: 
        !           162:   check_pp(buf);                       /* check for preprocessor lines */
        !           163: 
        !           164:   for(in_ptr = out_ptr = buf; *in_ptr;) {
        !           165:     if(!strchr(Word_member,*in_ptr))   /* non alpha-numeric? just copy */
        !           166:       *out_ptr++ = *in_ptr++;
        !           167:     else {
        !           168:       in_ptr = gather_word(in_ptr,word); /* get the 'word' */
        !           169:       if(strlen(word) > 31)            /* length is too long */
        !           170:        replace_word(word);             /* replace the word */
        !           171:       for(ptr = word; *ptr; ptr++,out_ptr++) /* copy out the word */
        !           172:          *out_ptr = *ptr;
        !           173:     }
        !           174:   }
        !           175:   *out_ptr = 0;
        !           176: }
        !           177: 
        !           178: /* check_pp - check for preprocessor lines
        !           179:  */
        !           180: check_pp(buf) char *buf; {
        !           181:   char *ptr,*p;
        !           182:   char word[128];
        !           183: 
        !           184:   ptr = skip_white(buf);               /* skip white space */
        !           185:   if(*ptr != '#')                      /* is this a preprocessor line? */
        !           186:     return;                            /* no, just return */
        !           187: 
        !           188:   ptr = skip_white(++ptr);             /* skip white */
        !           189:   ptr = gather_word(ptr,word);         /* get command word */
        !           190:   if(!strcmp("undef",word)) {          /* undef? */
        !           191:     ptr = skip_white(ptr);
        !           192:     ptr = gather_word(ptr,word);       /* get the symbol to undef */
        !           193:     fprintf(out,"#ifdef %s\n",word);
        !           194:     fputs(buf,out);
        !           195:     strcpy(buf,"#endif");
        !           196:     return;
        !           197:   }
        !           198:   if(!strcmp("if",word)) {             /* check for if */
        !           199:     for(;;) {
        !           200:       ptr = strchr(ptr,'d');           /* look for d in defined */
        !           201:       if(!ptr)                         /* are we done? */
        !           202:        return;
        !           203:       if(strchr(Word_member,*(ptr-1))){        /* at beginning of word? */
        !           204:        ptr++; continue;                /* no, continue looking */
        !           205:       }
        !           206:       ptr = gather_word(ptr,word);     /* get the word */
        !           207:       if(strcmp(word,"defined"))       /* skip if not defined */
        !           208:        continue;
        !           209:       ptr = skip_white(ptr);           /* skip white */
        !           210:       if(*ptr != '(')                  /* look for open paren */
        !           211:        continue;                       /* error, continue */
        !           212:       ptr++;                           /* skip paren */
        !           213:       ptr = skip_white(ptr);           /* more white skipping */
        !           214:       ptr = gather_word(ptr,word);     /* get the thing to test */
        !           215:       if(!*word)                       /* null word is bad */
        !           216:        continue;
        !           217:       fprintf(out,"#ifdef %s\n",word); /* generate the code */
        !           218:       fprintf(out,"#define %s_VAL 1\n",word);
        !           219:       fprintf(out,"#else\n");
        !           220:       fprintf(out,"#define %s_VAL 0\n",word);
        !           221:       fprintf(out,"#endif\n");
        !           222:       if(!defined_defined) {
        !           223:        fprintf(out,"#define defined(XXX) XXX/**/_VAL\n");
        !           224:        defined_defined = 1;
        !           225:       }
        !           226:     }
        !           227:   }
        !           228: }
        !           229: 
        !           230: /* replace_word - look the word up in the table, and replace it
        !           231:  *               if a match is found.
        !           232:  */
        !           233: replace_word(word) char *word; {
        !           234:   int i;
        !           235: 
        !           236:   for(i = 0; i < Max_table && name_table[i].name; i++)
        !           237:     if(!strcmp(word,name_table[i].name)) {
        !           238:       strcpy(word,name_table[i].value);
        !           239:       return;
        !           240:     }
        !           241:   fprintf(stderr,"couldn't find '%s'\n",word);
        !           242: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.