Return to macvert.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / jove

Annotation of 43BSDReno/contrib/jove/macvert.c, revision 1.1

1.1     ! root        1: /***************************************************************************
        !             2:  * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne.  JOVE *
        !             3:  * is provided to you without charge, and with no warranty.  You may give  *
        !             4:  * away copies of JOVE, including sources, provided that this notice is    *
        !             5:  * included in all the files.                                              *
        !             6:  ***************************************************************************/
        !             7: 
        !             8: /* Macvert converts old style macro files to the new style.  The old
        !             9:    style macros were binary files, the new ones are text files suitable
        !            10:    for loading with the "source" command of JOVE. */
        !            11: 
        !            12: #include <stdio.h>
        !            13: 
        !            14: extern int
        !            15:        read(),
        !            16:        write();
        !            17: 
        !            18: static void
        !            19:        output_new_definition();
        !            20: 
        !            21: static int     mac_fd;
        !            22: 
        !            23: static void
        !            24: mac_io(fcn, ptr, nbytes)
        !            25: int    (*fcn)();
        !            26: char   *ptr;
        !            27: int    nbytes;
        !            28: {
        !            29:        int     nio;
        !            30: 
        !            31:        if ((nio = (*fcn)(mac_fd, ptr, nbytes)) != nbytes)
        !            32:                fprintf(stderr, "[Macro %s error: %d got %d]",
        !            33:                         (fcn == read) ? "read" : "write",
        !            34:                         nbytes,
        !            35:                         nio);
        !            36: }
        !            37: 
        !            38: #define NEWWAY 1
        !            39: #define OLDWAY 0
        !            40: 
        !            41: static int     int_how = NEWWAY;
        !            42: 
        !            43: /* Formatting int's the old way or the new "improved" way? */
        !            44: 
        !            45: #if defined(vax) || defined(pdp11)
        !            46: 
        !            47: static long
        !            48: ntohl(x)
        !            49: register long x;
        !            50: {
        !            51:        return( (((x >>  0) & 0377) << 24) |
        !            52:                (((x >>  8) & 0377) << 16) |
        !            53:                (((x >> 16) & 0377) <<  8) |
        !            54:                (((x >> 24) & 0377) <<  0) );
        !            55: }
        !            56: 
        !            57: #else
        !            58: 
        !            59: static long
        !            60: ntohl(x)
        !            61: register long x;
        !            62: {
        !            63:        return(x);
        !            64: }
        !            65: 
        !            66: #endif
        !            67: 
        !            68: static int
        !            69: int_fmt(i)
        !            70: int    i;
        !            71: {
        !            72:        if (int_how == NEWWAY) {
        !            73:                /* Note: using ntohl() for an int is not portable! */
        !            74:                return (int) ntohl((long) i);
        !            75:        }
        !            76:        return i;
        !            77: }
        !            78: 
        !            79: static void
        !            80: read_and_write_macros(filein)
        !            81: char   *filein;
        !            82: {
        !            83:        int     namelen,
        !            84:                bodylen,
        !            85:                tmp;
        !            86:        char    macname[256],
        !            87:                macbuf[1024];
        !            88: 
        !            89:        if ((mac_fd = open(filein, 0)) == -1)
        !            90:                fprintf(stderr, "Cannot open %s\n", filein);
        !            91: 
        !            92:        while (read(mac_fd, (char *) &tmp, sizeof tmp) == (sizeof tmp)) {
        !            93: retry:         bodylen = int_fmt(tmp);
        !            94:                if (bodylen <= 0 || bodylen > 10000) {
        !            95:                        if (int_how == NEWWAY) {
        !            96:                                int_how = OLDWAY;
        !            97:                                goto retry;
        !            98:                        } else {
        !            99:                                fprintf(stderr, "I don't think \"%s\" is an old style JOVE macro file\n", filein);
        !           100:                                exit(1);
        !           101:                        }
        !           102:                }
        !           103:                mac_io(read, (char *) &namelen, (int) (sizeof namelen));
        !           104:                namelen = int_fmt(namelen);
        !           105:                mac_io(read, macname, namelen);
        !           106:                mac_io(read, macbuf, bodylen);
        !           107:                output_new_definition(macname, macbuf, bodylen);
        !           108:        }
        !           109: }
        !           110: 
        !           111: static void
        !           112: pr_putc(c)
        !           113: int    c;
        !           114: {
        !           115:        if (c == '\\' || c == '^')
        !           116:                putchar('\\');
        !           117:         else if (c < ' ' || c == '\177') {
        !           118:                putchar('^');
        !           119:                c = (c == '\177') ? '?' : (c + '@');
        !           120:        }
        !           121:        putchar(c);
        !           122: }
        !           123: 
        !           124: static void
        !           125: output_new_definition(name, body, bodylen)
        !           126: char   *name,
        !           127:        *body;
        !           128: int    bodylen;
        !           129: {
        !           130:        int     i;
        !           131: 
        !           132:        fprintf(stdout, "define-macro %s ", name);
        !           133:        for (i = 0; i < bodylen; i++)
        !           134:                pr_putc(body[i]);
        !           135:        putchar('\n');
        !           136: }
        !           137: 
        !           138: int
        !           139: main(argc, argv)
        !           140: int    argc;
        !           141: char   *argv[];
        !           142: {
        !           143:        if (argc != 2) {
        !           144:                fprintf(stderr, "usage: macvert <old-style-macro-file>\n");
        !           145:                exit(1);
        !           146:        }
        !           147: 
        !           148:        read_and_write_macros(argv[1]);
        !           149:        return 0;
        !           150: }

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