Return to unixstart.c CVS log

Up to [CSRG BSD Unix] / 42BSD / games / compat

Annotation of 42BSD/games/compat/unixstart.c, revision 1.1.1.1

1.1       root        1: #
                      2: static char sccsid[] = "       unixstart.c     4.1     82/05/12        ";
                      3: /*     Start up a version 6 or version 7 pdp-11 UNIX compatability mode
                      4:  *     program. Must set up the memory layout with args etc.
                      5:  *     Art Wetzel      August 1979
                      6:  */
                      7: #include <stdio.h>
                      8: #include "defs.h"
                      9: #define        MAXARGS 100
                     10: start(argv, envp) unsigned char **argv, **envp; {
                     11:        register unsigned char *sp, *ap;
                     12:        register unsigned short *ssp;
                     13:        register int i, argc, envc;
                     14:        unsigned char *envps[MAXARGS], *argps[MAXARGS], **av, *p1, *p2;
                     15:        extern unsigned char *progname, *nameend;
                     16:        /* set up initial memory layout for unix */
                     17:        /* set stack pointer to top of memory */
                     18:        sp = memsiz;
                     19: #ifdef V7UNIX
                     20:        /* zero top 2 bytes */
                     21:        *(--sp) = 0;
                     22:        *(--sp) = 0;
                     23:        /* point to environment pointer list */
                     24:        av = envp;
                     25:        envc = 0;
                     26:        /* count up number of env elements */
                     27:        while(*(av++)) envc++;
                     28:        /* last UNIX V7 env ptr is 0 */
                     29:        envps[envc] = (unsigned char *)0;
                     30:        /* copy actual environment (assume byte text) - last first */
                     31:        for(i=envc-1; i>=0; i--) {
                     32:                ap = envp[i];
                     33:                while(*(ap++)) ;
                     34:                while(ap != envp[i]) *(--sp) = *(--ap);
                     35:                /* force stack word alignment - required per arg in v7 */
                     36:                if((int)sp & 1) {
                     37:                        ap = sp--;
                     38:                        while((*(ap-1) = *ap)) ap++;
                     39:                }
                     40:                envps[i] = sp;
                     41:        }
                     42: #endif
                     43:        /* point to argument pointer list */
                     44:        av = argv;
                     45:        argc = 0;
                     46:        /* count up number of args */
                     47:        while(*(av++)) argc++;
                     48: #ifdef V7UNIX
                     49:        /* last UNIX V7 arg ptr is 0 */
                     50:        argps[argc] = (unsigned char *)0;
                     51: #endif
                     52: #ifdef V6UNIX
                     53:        /* last UNIX V6 arg ptr is -1 */
                     54:        argps[argc] = (unsigned char *)-1;
                     55: #endif
                     56:        /* copy actual arguments (assume byte text) - last first */
                     57:        for(i=argc-1; i>=0; i--) {
                     58:                ap = argv[i];
                     59:                while(*(ap++)) ;
                     60:                while(ap != argv[i]) *(--sp) = *(--ap);
                     61:                /* force stack word alignment - required per arg in v7 */
                     62:                if((int)sp & 1) {
                     63:                        ap = sp--;
                     64:                        while((*(ap-1) = *ap)) ap++;
                     65:                }
                     66:                argps[i] = sp;
                     67:        }
                     68:        ssp = (unsigned short *)sp;
                     69: #ifdef V7UNIX
                     70:        /* clear a word */
                     71:        *(--ssp) = 0;
                     72:        /* set up environment pointers */
                     73:        for(i=envc; i>=0; i--) {
                     74:                *(--ssp) = (short)(long)envps[i];
                     75:        }
                     76:        /* clear another word */
                     77:        *(--ssp) = 0;
                     78: #endif
                     79:        /* set up argument pointers */
                     80:        for(i=argc; i>=0; i--) {
                     81:                *(--ssp) = (short)(long)argps[i];
                     82:        }
                     83:        /* then argument count */
                     84:        *(--ssp) = argc;
                     85:        /* set up stack pointer */
                     86:        regs[6] = (int)ssp;
                     87:        /* set up a psl with cleared condition codes */
                     88:        psl = 0x83c00000;
                     89:        /* copy out part of the program name and args where ps can get them */
                     90:        /* flag it with a * so it shows up as a compatability mode process */
                     91:        /* check for case with no env and reset nameend */
                     92:        if(nameend < progname) nameend = (unsigned char *)2147483647;
                     93:        for(p1=progname, *p1++ = '*', i=1, p2=argv[0]; p1<nameend; p1++) {
                     94:                if((*p1 = *p2))
                     95:                        p2++;
                     96:                else if(argv[i])
                     97:                        p2 = argv[i++];
                     98:                else break;
                     99:        }
                    100:        while(p1 < nameend) *p1++ = ' ';
                    101:        *p1 = 0;
                    102:        /* clear out registers other than sp */
                    103:        regs[0] = 0;
                    104:        regs[1] = 0;
                    105:        regs[2] = 0;
                    106:        regs[3] = 0;
                    107:        regs[4] = 0;
                    108:        regs[5] = 0;
                    109:        /* finally get around to actually starting up in compatability mode */
                    110:        incompat++;
                    111:        compat();
                    112: }

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