Return to liszt.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ucb / lisp / liszt / 68k

Annotation of 43BSD/ucb/lisp/liszt/68k/liszt.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char *rcsid = "$Header: liszt.c 1.6 83/07/25 12:07:31 layer Exp $";
        !             3: #endif
        !             4: 
        !             5: /*
        !             6: **                     -[Wed May  4 18:18:10 1983 by layer]-
        !             7: **
        !             8: **
        !             9: ** liszt :: interface to the lisp compiler
        !            10: **
        !            11: ** There are two reasons for having a C interface to the compiler:
        !            12: **     1) Fseek doesn't work properly from lisp, and there is no
        !            13: **        lseek.
        !            14: **     2) To start up a process from a 1 Mb process, like when liszt forks
        !            15: **        a /usr/lib/lisp/as to assemble the output of the compiler, takes
        !            16: **        too long. (The compiler is 100 times larger than this program.)
        !            17: **
        !            18: **/
        !            19: 
        !            20: #include       <stdio.h>
        !            21: #include       "../../franz/h/aout.h"
        !            22: #include       "../../franz/h/config.h"
        !            23: 
        !            24: #ifndef LISZT
        !            25: #define LISZT  "/usr/ucb/xliszt"
        !            26: #endif
        !            27: 
        !            28: #ifndef AS
        !            29: #define AS     "/usr/lib/lisp/as"
        !            30: #endif
        !            31: 
        !            32: #ifndef OFFSET
        !            33: #define OFFSET         0x0
        !            34: #endif
        !            35: 
        !            36: main(argc,argv,envp)
        !            37:        register char *argv[], **envp;
        !            38: {
        !            39:        struct exec header;
        !            40:        register int autorun = 0;
        !            41:        register int no_assem = 0;
        !            42:        register char *p;
        !            43:        register int oflag = 0, cur;
        !            44:        register int objp;
        !            45:        register int slen;
        !            46:        char temp[20], tempfile[20], srcfile[20], outfile[20];
        !            47:        char *args_to_string();
        !            48:        char *flags_to_string();
        !            49:        char command[1024];
        !            50:     
        !            51:        /*
        !            52:        **  process arguments :: check for -r and -S switches
        !            53:        **
        !            54:        **  -F is a special flag that means just to fix the offset in the
        !            55:        ** object file, and then quit.
        !            56:        **
        !            57:        **/
        !            58:        /* If no args, then give the user an interactive liszt */
        !            59:         if (argc == 1)
        !            60:        {
        !            61:                execle(LISZT, "liszt", 0, envp);
        !            62:                exit(100);
        !            63:        } else
        !            64:        {
        !            65:                for (cur = 1; cur < argc; cur++) {
        !            66:                        if (*argv[cur] == '-')
        !            67:                        {
        !            68:                                p = argv[cur];
        !            69:                                p++;
        !            70:                                if (*p == 'o')
        !            71:                                {
        !            72:                                        strcpy(outfile,argv[++cur]);
        !            73:                                        oflag++;
        !            74:                                }
        !            75:                                else if (*p == 'F')
        !            76:                                {
        !            77:                                        strcpy(outfile,argv[++cur]);
        !            78:                                        autorun = 1;
        !            79:                                        goto fixit;
        !            80:                                }
        !            81:                                else
        !            82:                                {
        !            83:                                        for (; *p; p++) {
        !            84:                                                switch (*p)
        !            85:                                                {
        !            86:                                                case 'S':
        !            87:                                                        no_assem++;
        !            88:                                                        break;
        !            89:                                                case 'r':
        !            90:                                                        autorun++;
        !            91:                                                        break;
        !            92:                                                default:
        !            93:                                                        break;
        !            94:                                                }
        !            95:                                        }
        !            96:                                }
        !            97:                        }
        !            98:                        else
        !            99:                        {       /* must be filename */
        !           100:                                strcpy(srcfile, argv[cur]);
        !           101:                        }
        !           102:                }
        !           103:        }
        !           104: 
        !           105:        if (no_assem)
        !           106:        {
        !           107:                sprintf(command, "%s %s", LISZT, args_to_string(argv));
        !           108: #ifdef debug
        !           109:                printf("%s\n", command);
        !           110: #else
        !           111:                exit(system(command));
        !           112: #endif
        !           113:        }
        !           114: 
        !           115:        sprintf(tempfile, "/tmp/Lzt%d.s", getpid());
        !           116: 
        !           117:        /* If output file not given, then we deduce it... */
        !           118:        if (oflag == 0)
        !           119:        {
        !           120:                strcpy(outfile,srcfile);
        !           121:                slen = strlen(outfile);
        !           122:                if (outfile[slen - 2] == '.')
        !           123:                {
        !           124:                        outfile[slen - 1] = 'o';
        !           125:                }
        !           126:                else
        !           127:                {
        !           128:                        strcpy(temp,outfile);
        !           129:                        sprintf(outfile, "%s.o", temp);
        !           130:                }
        !           131:        }
        !           132: 
        !           133:        sprintf(command, "%s -S%s -o %s %s",
        !           134:                         LISZT, flags_to_string(argc, argv), tempfile, srcfile);
        !           135: #ifdef debug
        !           136:        printf("%s\n", command);
        !           137: #else
        !           138:        if (system(command) != 0)
        !           139:        {
        !           140:                exit(101);
        !           141:        }
        !           142: #endif
        !           143: 
        !           144:        sprintf(command, "%s -o %s %s", AS, outfile, tempfile);
        !           145: #ifdef debug
        !           146:        printf("%s\n", command);
        !           147: #else
        !           148:        if (system(command) != 0)
        !           149:        {
        !           150:                exit(102);
        !           151:        }
        !           152:        unlink(tempfile);
        !           153: 
        !           154: fixit:
        !           155:        if (autorun)
        !           156:        {
        !           157:                if ((objp = open(outfile,2)) == -1)
        !           158:                {
        !           159:                        perror(outfile);
        !           160:                        exit(103);
        !           161:                }
        !           162:                if (read(objp,&header,sizeof header) != sizeof (struct exec))
        !           163:                {
        !           164:                        perror("read failed");
        !           165:                        exit(1);
        !           166:                }
        !           167: 
        !           168:                /* Change the offset to the correct value */
        !           169:                header.a_entry = OFFSET;
        !           170: 
        !           171:                /* seek back to beginning */
        !           172:                if (lseek(objp,0,0) != 0)
        !           173:                {
        !           174:                        perror("seek failed");
        !           175:                        exit(104);
        !           176:                }
        !           177: 
        !           178:                /* write the new a.out header... */
        !           179:                if (write(objp,&header,sizeof header) != sizeof(struct exec))
        !           180:                {
        !           181:                        perror("write failed");
        !           182:                        exit(105);
        !           183:                }
        !           184: 
        !           185:                /* make it executable */
        !           186:                chmod(outfile, 0755);
        !           187:        } else
        !           188:                exit(0);
        !           189: #endif
        !           190: }
        !           191: 
        !           192: char *
        !           193: args_to_string(pp)
        !           194:        char *pp[];
        !           195: {
        !           196:        char result[1024];
        !           197:        register int ii = 0,
        !           198:                     jj = 1;
        !           199: 
        !           200:        for (; pp[jj]; ii++, jj++)
        !           201:        {
        !           202:                xstrcpy(&result[ii],pp[jj]);
        !           203:                ii = ii + strlen(pp[jj]);
        !           204:        }
        !           205:        result[ii++] = '\0';
        !           206:        return(result);
        !           207: }
        !           208: 
        !           209: char *
        !           210: flags_to_string(argc, argv)
        !           211:        int argc;
        !           212:        char *argv[];
        !           213: {
        !           214:        char result[128];
        !           215:        register int chari, word, skipnext = 0, out = 0;
        !           216: 
        !           217:        for (word = 1; word < argc; word++)
        !           218:        {
        !           219:                if (skipnext)
        !           220:                {
        !           221:                        skipnext = 0;
        !           222:                        word++;
        !           223:                        continue;
        !           224:                }
        !           225:                if (*argv[word] == '-')
        !           226:                        for (chari = 1; argv[word][chari]; chari++)
        !           227:                                if (argv[word][chari] == 'o')
        !           228:                                        skipnext = 1;
        !           229:                                else
        !           230:                                        result[out++] = argv[word][chari];
        !           231:        }
        !           232:        result[out] = '\0';
        !           233:        return(result);
        !           234: }
        !           235: 
        !           236: xstrcpy(s, t)
        !           237:        char *s, *t;
        !           238: {
        !           239:        while (*t != '\0')
        !           240:        {
        !           241:                *s++ = *t++;
        !           242:        }
        !           243:        *s = ' ';
        !           244: }

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