Return to int.c CVS log

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

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

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

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