Return to int.c CVS log

Up to [CSRG BSD Unix] / 41BSD / cmd / px

Annotation of 41BSD/cmd/px/int.c, revision 1.1

1.1     ! root        1: /* Copyright (c) 1979 Regents of the University of California */
        !             2: 
        !             3: static char sccsid[] = "@(#)int.c 4.1 10/10/80";
        !             4: 
        !             5: /*
        !             6:  * px - interpreter for Berkeley Pascal
        !             7:  * Version 2.0 Winter 1979
        !             8:  *
        !             9:  * Original version for the PDP 11/70 authored by:
        !            10:  * Bill Joy, Charles Haley, Ken Thompson
        !            11:  *
        !            12:  * Rewritten for VAX 11/780 by Kirk McKusick
        !            13:  */
        !            14: 
        !            15: #include       "stdio.h"
        !            16: #include       "signal.h"
        !            17: #include       "h00vars.h"
        !            18: #include       "objfmt.h"
        !            19: 
        !            20: main(ac,av)
        !            21: 
        !            22: long   ac;
        !            23: char   **av;
        !            24: 
        !            25: {
        !            26: extern  intr();
        !            27: extern  memsize();
        !            28: extern  except();
        !            29: extern  syserr();
        !            30: extern  char *malloc();
        !            31: extern   long createtime;
        !            32: struct  pxhdr pxhd;
        !            33: register long bytesread, block;
        !            34: register char *objprog;
        !            35: register FILE *prog;
        !            36: #define         pipe 3
        !            37: #define         pipesize 4096
        !            38: 
        !            39: /*
        !            40:  * Initialize everything
        !            41:  */
        !            42: argc = ac;
        !            43: argv = av;
        !            44: stcnt = 0;
        !            45: stlim = 500000;
        !            46: llimit = 0x7fffffff;   /* set to unlimited */
        !            47: nodump = 0;
        !            48: 
        !            49: /*
        !            50:  * Determine how PX was invoked, and how to process the program 
        !            51:  */
        !            52: if (argv[0][0] == '-' && argv[0][1] == 'o')
        !            53:        {
        !            54:        file = &argv[0][2];
        !            55:        mode = PIX;
        !            56:        }
        !            57: else if (argc <= 1)
        !            58:        {
        !            59:        file = "obj";
        !            60:        mode = PX;
        !            61:        }
        !            62: else if (argv[1][0] != '-')
        !            63:        {
        !            64:        file = argv[1];
        !            65:        mode = PX;
        !            66:        }
        !            67: else if (argv[1][1] == 0)
        !            68:        {
        !            69:        file = argv[0];
        !            70:        mode = PIPE;
        !            71:        argc -= 1;
        !            72:        argv[1] = argv[0];
        !            73:        argv = &argv[1];
        !            74:        }
        !            75: else
        !            76:        {
        !            77:        fputs("Improper specification of object file to PX\n",stderr);
        !            78:        exit(1);
        !            79:        }
        !            80: 
        !            81: /*
        !            82:  * Process program header information
        !            83:  */
        !            84: if (mode == PIPE)
        !            85:        read(pipe,&pxhd,sizeof(struct pxhdr));
        !            86: else
        !            87:        {
        !            88:        prog = fopen(file,"r");
        !            89:        if (prog == NULL)
        !            90:                {
        !            91:                perror(file);
        !            92:                exit(1);
        !            93:                }
        !            94:        fseek(prog,HEADER_BYTES-sizeof(struct pxhdr),0);
        !            95:        fread(&pxhd,sizeof(struct pxhdr),1,prog);
        !            96:        }
        !            97: if (pxhd.maketime < createtime)
        !            98:        {
        !            99:        fprintf(stderr,"%s is obsolete and must be recompiled\n",file);
        !           100:        exit(1);
        !           101:        }
        !           102: if (pxhd.magicnum != 0403)
        !           103:        {
        !           104:        fprintf(stderr,"%s is not a Pascal program\n",file);
        !           105:        exit(1);
        !           106:        }
        !           107: 
        !           108: /*
        !           109:  * Load program into memory
        !           110:  */
        !           111: objprog = malloc(pxhd.objsize);
        !           112: if (mode == PIPE)
        !           113:        {
        !           114:        bytesread = 0;
        !           115:        do
        !           116:                {
        !           117:                block = read(pipe,objprog+bytesread,pipesize);
        !           118:                bytesread += block;
        !           119:                }
        !           120:                while (block);
        !           121:        }
        !           122: else
        !           123:        {
        !           124:        bytesread = fread(objprog,1,pxhd.objsize,prog);
        !           125:        fclose(prog);
        !           126:        if (mode == PIX)
        !           127:                unlink(file);
        !           128:        }
        !           129: if (bytesread != pxhd.objsize)
        !           130:        {
        !           131:        fprintf(stderr,"Read error occurred while loading %s\n",file);
        !           132:        exit(1);
        !           133:        }
        !           134: if (mode == PIX)
        !           135:        fputs("Execution begins...\n",stderr);
        !           136: /*
        !           137:  * set interpreter to catch expected signals and begin interpretation
        !           138:  */
        !           139: signal(SIGILL,syserr);
        !           140: signal(SIGBUS,syserr);
        !           141: signal(SIGSYS,syserr);
        !           142: if (signal(SIGINT,SIG_IGN) != SIG_IGN)
        !           143:        signal(SIGINT,intr);
        !           144: signal(SIGSEGV,memsize);
        !           145: signal(SIGFPE,except);
        !           146: #ifdef profile
        !           147: interpret(objprog,1);
        !           148: #else
        !           149: interpret(objprog,0);
        !           150: #endif
        !           151: /*
        !           152:  * reset signals, deallocate memory, and exit normally
        !           153:  */
        !           154: signal(SIGINT,SIG_IGN);
        !           155: signal(SIGSEGV,SIG_DFL);
        !           156: signal(SIGFPE,SIG_DFL);
        !           157: pflush();
        !           158: /* pfree(objprog); */
        !           159: psexit(0);
        !           160: }

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