Return to macvert.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove

Annotation of 43BSDTahoe/new/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     read(),
        !            15:                write();
        !            16: 
        !            17: int    mac_fd;
        !            18: 
        !            19: mac_io(fcn, ptr, nbytes)
        !            20: int    (*fcn)();
        !            21: char   *ptr;
        !            22: {
        !            23:        int     nio;
        !            24: 
        !            25:        if ((nio = (*fcn)(mac_fd, ptr, nbytes)) != nbytes)
        !            26:                fprintf(stderr, "[Macro %s error: %d got %d]",
        !            27:                         (fcn == read) ? "read" : "write",
        !            28:                         nbytes,
        !            29:                         nio);
        !            30: }
        !            31: 
        !            32: #define NEWWAY 1
        !            33: #define OLDWAY 0
        !            34: 
        !            35: int    int_how = NEWWAY;
        !            36: 
        !            37: /* Formatting int's the old way or the new "improved" way? */
        !            38: 
        !            39: #if vax || pdp11
        !            40: long htonl(x)
        !            41: register long x;
        !            42: {
        !            43:        return( (((x >>  0) & 0377) << 24) |
        !            44:                (((x >>  8) & 0377) << 16) |
        !            45:                (((x >> 16) & 0377) <<  8) |
        !            46:                (((x >> 24) & 0377) <<  0) );
        !            47: }
        !            48: 
        !            49: short htons(x)
        !            50: register short x;
        !            51: {
        !            52:        return( (((x >>  0) & 0377) << 8) |
        !            53:                (((x >>  8) & 0377) << 0) );
        !            54: }
        !            55: 
        !            56: long ntohl(x)
        !            57: register long x;
        !            58: {
        !            59:        return( (((x >>  0) & 0377) << 24) |
        !            60:                (((x >>  8) & 0377) << 16) |
        !            61:                (((x >> 16) & 0377) <<  8) |
        !            62:                (((x >> 24) & 0377) <<  0) );
        !            63: }
        !            64: 
        !            65: short ntohs(x)
        !            66: register short x;
        !            67: {
        !            68:        return( (((x >>  0) & 0377) << 8) |
        !            69:                (((x >>  8) & 0377) << 0) );
        !            70: }
        !            71: #else
        !            72: long htonl(x)
        !            73: register long x;
        !            74: {
        !            75:        return(x);
        !            76: }
        !            77: 
        !            78: short htons(x)
        !            79: register short x;
        !            80: {
        !            81:        return(x);
        !            82: }
        !            83: 
        !            84: long ntohl(x)
        !            85: register long x;
        !            86: {
        !            87:        return(x);
        !            88: }
        !            89: 
        !            90: short ntohs(x)
        !            91: register short x;
        !            92: {
        !            93:        return(x);
        !            94: }
        !            95: #endif
        !            96: 
        !            97: int_fmt(i)
        !            98: {
        !            99:        if (int_how == NEWWAY)
        !           100:                return ntohl(i);
        !           101:        return i;
        !           102: }
        !           103: 
        !           104: read_and_write_macros(filein)
        !           105: char   *filein;
        !           106: {
        !           107:        int     namelen,
        !           108:                bodylen,
        !           109:                tmp;
        !           110:        char    macname[256],
        !           111:                macbuf[1024];
        !           112: 
        !           113:        if ((mac_fd = open(filein, 0)) == -1)
        !           114:                fprintf(stderr, "Cannot open %s\n", filein);
        !           115: 
        !           116:        while (read(mac_fd, (char *) &tmp, sizeof tmp) == (sizeof tmp)) {
        !           117: retry:         bodylen = int_fmt(tmp);
        !           118:                if (bodylen <= 0 || bodylen > 10000) {
        !           119:                        if (int_how == NEWWAY) {
        !           120:                                int_how = OLDWAY;
        !           121:                                goto retry;
        !           122:                        } else {
        !           123:                                fprintf(stderr, "I don't think \"%s\" is an old style JOVE macro file\n", filein);
        !           124:                                exit(1);
        !           125:                        }
        !           126:                }
        !           127:                mac_io(read, (char *) &namelen, sizeof namelen);
        !           128:                namelen = int_fmt(namelen);
        !           129:                mac_io(read, macname, namelen);
        !           130:                mac_io(read, macbuf, bodylen);
        !           131:                output_new_definition(macname, macbuf, bodylen);
        !           132:        }               
        !           133: }
        !           134: 
        !           135: pr_putc(c)
        !           136: {
        !           137:        if (c == '\\' || c == '^')
        !           138:                putchar('\\');
        !           139:         else if (c < ' ' || c == '\177') {
        !           140:                putchar('^');
        !           141:                c = (c == '\177') ? '?' : (c + '@');
        !           142:        }
        !           143:        putchar(c);
        !           144: }
        !           145: 
        !           146: output_new_definition(name, body, bodylen)
        !           147: char   *name,
        !           148:        *body;
        !           149: {
        !           150:        int     i;
        !           151: 
        !           152:        fprintf(stdout, "define-macro %s ", name);
        !           153:        for (i = 0; i < bodylen; i++)
        !           154:                pr_putc(body[i]);
        !           155:        putchar('\n');
        !           156: }
        !           157: 
        !           158: main(argc, argv)
        !           159: char   *argv[];
        !           160: {
        !           161:        if (argc != 2) {
        !           162:                fprintf(stderr, "usage: macvert <old-style-macro-file>\n");
        !           163:                exit(1);
        !           164:        }
        !           165: 
        !           166:        read_and_write_macros(argv[1]);
        !           167: }

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