Return to machdep.h CVS log

Up to [CSRG BSD Unix] / 43BSDReno / pgrm / pascal / px

Annotation of 43BSDReno/pgrm/pascal/px/machdep.h, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Copyright (c) 1980 Regents of the University of California.
                      3:  * All rights reserved.  The Berkeley software License Agreement
                      4:  * specifies the terms and conditions for redistribution.
                      5:  *
                      6:  *     @(#)machdep.h   5.3 (Berkeley) 1/9/89
                      7:  */
                      8: 
                      9: #ifdef ADDR32
                     10: #define pushaddr(x)    push4((long)(x))
                     11: #define popaddr()      (char *)pop4()
                     12: #endif ADDR32
                     13: #ifdef ADDR16
                     14: #define pushaddr(x)    push2((short)(x))
                     15: #define popaddr()      (char *)pop2()
                     16: #endif ADDR16
                     17: 
                     18: #define popfile()      (FILE *)(popaddr())
                     19: 
                     20: #if defined(pdp11)
                     21: #define        popint  pop2
                     22: #define        pushint push2
                     23: #else
                     24: #define popint pop4
                     25: #define pushint        push4
                     26: #endif
                     27: 
                     28: /*
                     29:  * Machine specific macros for reading quantities from the
                     30:  * interpreter instruction stream. Operands in the instruction
                     31:  * stream are aligned to short, but not long boundries. Blockmarks
                     32:  * are always long aligned. Stack alignment indicates whether the
                     33:  * stack is short or long aligned. Stack alignment is assumed to
                     34:  * be no more than long aligned for ADDR32 machines, short aligned
                     35:  * for ADDR16 machines.
                     36:  */
                     37: #if defined(vax) || defined(mc68000) || defined(pdp11)
                     38: #define PCLONGVAL(target) target = *pc.lp++
                     39: #define GETLONGVAL(target, srcptr) target = *(long *)(srcptr)
                     40: #define STACKALIGN(target, value) target = ((value) + 1) &~ 1
                     41: #endif vax || mc68000 || pdp11
                     42: 
                     43: #ifdef tahoe
                     44: #define PCLONGVAL(target) target = *pc.sp++ << 16, target += *pc.usp++
                     45: #define GETLONGVAL(target, srcptr) \
                     46:        tsp = (short *)(srcptr), \
                     47:        target = *tsp++ << 16, target += *(unsigned short *)tsp
                     48: #define STACKALIGN(target, value) target = ((value) + 3) &~ 3
                     49: #endif tahoe
                     50: 
                     51: /*
                     52:  * The following macros implement all accesses to the interpreter stack.
                     53:  *
                     54:  * They used to be hard-coded assembler stuff massaged into the compiler
                     55:  * output by sed scripts, but things are cleaner now.
                     56:  *
                     57:  * The STACKSIZE is an arbitrary value.  I picked 100K since it was unlikely
                     58:  * that anybody's program would run out of stack.  Automatic allocation
                     59:  * would be nice, maybe procedure call should check for enough space + slop
                     60:  * and expand it if necessary.  Expanding the stack will require
                     61:  * pointer relocation if it moves, though.  Probably better would be a
                     62:  * command line option to set the stack size.
                     63:  */
                     64: #define        STACKSIZE       100000
                     65: #define        setup()         { \
                     66:        extern char *malloc(); \
                     67:        stack.cp = STACKSIZE + malloc((unsigned)STACKSIZE); \
                     68:        }
                     69: #ifndef tahoe
                     70: #define        push2(x)        (*--stack.sp) = (x)
                     71: #else
                     72: #define        push2(x)        (*--stack.lp) = (x) << 16
                     73: #endif
                     74: #define push4(x)       (*--stack.lp)  = (x)
                     75: #define push8(x)       (*--stack.dbp) = (x)
                     76: #define pushsze8(x)    (*--stack.s8p) = (x)
                     77: #define pushsp(x)      (stack.cp -= (x))
                     78: #ifndef tahoe
                     79: #define pop2()         (*stack.sp++)
                     80: #else
                     81: #define pop2()         (*stack.lp++) >> 16
                     82: #endif
                     83: #define pop4()         (*stack.lp++)
                     84: #define pop8()         (*stack.dbp++)
                     85: #define popsze8()      (*stack.s8p++)
                     86: #define popsp(x)       (void)(stack.cp += (x))
                     87: #define        enableovrflo()  /*nop*/
                     88: #define        disableovrflo() /*nop*/

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