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