Return to makedefs.c CVS log

Up to [CSRG BSD Unix] / 42BSD / ucb / dbx

Annotation of 42BSD/ucb/dbx/makedefs.c, revision 1.1.1.1

1.1       root        1: /* Copyright (c) 1982 Regents of the University of California */
                      2: 
                      3: static char sccsid[] = "@(#)makedefs.c 1.2 12/15/82";
                      4: 
                      5: /*
                      6:  * Create a definitions file (e.g. .h) from an implementation file (e.g. .c).
                      7:  *
                      8:  * Usage is "makedefs source.c source.h" where source.h is to be created.
                      9:  *
                     10:  * Lines beginning with "public" or within a "#ifndef public ... #endif"
                     11:  * block are copied to the new file.  Initializations (e.g. "int x = 3") are
                     12:  * omitted ("int x;" is output).
                     13:  *
                     14:  * Normally a temporary definitions file is created and compared to
                     15:  * the given destination.  If they are different, the temporary file
                     16:  * is copied on top of the destination.  This is so that dependencies
                     17:  * when using "make" are not triggered.
                     18:  *
                     19:  * The "-f" option overrides this and forces the destination file to be created.
                     20:  */
                     21: 
                     22: #include "defs.h"
                     23: #include <signal.h>
                     24: 
                     25: #define procedure void
                     26: 
                     27: Boolean force;
                     28: Boolean copytext;
                     29: 
                     30: String tmpname;
                     31: String modulename();
                     32: procedure abnorm();
                     33: 
                     34: main(argc, argv)
                     35: int argc;
                     36: String argv[];
                     37: {
                     38:     extern String mktemp();
                     39:     String name;
                     40:     File tmp;
                     41:     Integer r;
                     42:     Integer index;
                     43: 
                     44:     if (streq(argv[1], "-f")) {
                     45:        force = true;
                     46:        index = 2;
                     47:     } else {
                     48:        force = false;
                     49:        index = 1;
                     50:     }
                     51:     if (argc - index > 2) {
                     52:        fatal("usage: makedefs [ -f ] file.c [ file.h ]\n");
                     53:     }
                     54:     tmp = nil;
                     55:     if (freopen(argv[index], "r", stdin) == NULL) {
                     56:        fatal("can't read %s", argv[index]);
                     57:     }
                     58:     signal(SIGINT, abnorm);
                     59:     signal(SIGQUIT, abnorm);
                     60:     if (index + 1 < argc) {
                     61:        if (force) {
                     62:            tmpname = argv[index + 1];
                     63:        } else {
                     64:            tmpname = mktemp("/tmp/makedefsXXXXXX");
                     65:        }
                     66:        tmp = freopen(tmpname, "w", stdout);
                     67:        if (tmp == nil) {
                     68:            fatal("can't write %s", tmpname);
                     69:        }
                     70:     }
                     71:     copytext = false;
                     72:     name = modulename(argv[index]);
                     73:     printf("#ifndef %s\n", name);
                     74:     printf("#define %s\n", name);
                     75:     copy();
                     76:     printf("#endif\n");
                     77:     if (tmp != NULL and not force) {
                     78:        fclose(tmp);
                     79:        r = call("cmp", stdin, stderr, "-s", tmpname, argv[2], nil);
                     80:        if (r != 0) {
                     81:            r = call("cp", stdin, stderr, tmpname, argv[2], nil);
                     82:            if (r != 0) {
                     83:                fprintf(stderr, "can't create %s\n", argv[2]);
                     84:            }
                     85:        }
                     86:        unlink(tmpname);
                     87:     }
                     88:     quit(0);
                     89: }
                     90: 
                     91: String modulename(s)
                     92: String s;
                     93: {
                     94:     String r, i, j;
                     95:     static char buf[256];
                     96: 
                     97:     strcpy(buf, s);
                     98:     i = rindex(buf, '/');
                     99:     if (i == nil) {
                    100:        i = buf;
                    101:     }
                    102:     for (j = i; *j != '.'; j++);
                    103:     *j++ = '_';
                    104:     *j++ = 'h';
                    105:     *j = '\0';
                    106:     return buf;
                    107: }
                    108: 
                    109: copy()
                    110: {
                    111:     register char *p;
                    112:     char line[1024];
                    113: 
                    114:     while (gets(line) != NULL) {
                    115:        if (strncmp(line, "#ifndef public", 14) == 0) {
                    116:            copytext = true;
                    117:        } else if (strncmp(line, "#endif", 6) == 0) {
                    118:            copytext = false;
                    119:        } else if (strncmp(line, "public", 6) == 0) {
                    120:            copydef(line);
                    121:        } else if (copytext) {
                    122:            printf("%s\n", line);
                    123:        }
                    124:     }
                    125: }
                    126: 
                    127: copydef(s)
                    128: String s;
                    129: {
                    130:     register char *p;
                    131:     register Boolean isproc;
                    132: 
                    133:     isproc = false;
                    134:     for (p = &s[7]; *p != '\0' and *p != '='; p++) {
                    135:        if (*p == '(') {
                    136:            isproc = true;
                    137:            printf("(/* ");
                    138:        } else if (*p == ')' and isproc and *(p+1) == '\0') {
                    139:            printf(" */)");
                    140:        } else {
                    141:            putchar(*p);
                    142:        }
                    143:     }
                    144:     if (isproc or *p == '=') {
                    145:        putchar(';');
                    146:     }
                    147:     putchar('\n');
                    148: }
                    149: 
                    150: /*
                    151:  * Terminate program.
                    152:  */
                    153: 
                    154: procedure abnorm(signo)
                    155: int signo;
                    156: {
                    157:     unlink(tmpname);
                    158:     quit(signo);
                    159: }
                    160: 
                    161: quit(r)
                    162: int r;
                    163: {
                    164:     exit(r);
                    165: }
                    166: 
                    167: /*
                    168:  * No special error recovery strategy.
                    169:  */
                    170: 
                    171: erecover()
                    172: {
                    173: }

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