date and time created 83/08/05 13:34:37 by sam

[unix-history] / usr / src / old / as.vax / ascode.c

diff --git a/usr/src/old/as.vax/ascode.c b/usr/src/old/as.vax/ascode.c
index ba0001f..e67a400 100644 (file)
--- a/usr/src/old/as.vax/ascode.c
+++ b/usr/src/old/as.vax/ascode.c
@@ -1,95 +1,121 @@
-/* Copyright (c) 1980 Regents of the University of California */
-static char sccsid[] = "@(#)ascode.c 4.2 %G%";
+/*
+ *     Copyright (c) 1982 Regents of the University of California
+ */
+#ifndef lint
+static char sccsid[] = "@(#)ascode.c 4.11 %G%";
+#endif not lint
+

 #include <stdio.h>
 #include "as.h"
 #include "assyms.h"
 
 #include <stdio.h>
 #include "as.h"
 #include "assyms.h"
 

-insout(op, ap, nact)
-       struct arg *ap;
+insout(opcode, ap, nact)
+       struct  Opcode  opcode;
+       struct  arg     *ap;
+       int     nact;

 {
 {

-       int jxxflg;
+       int     jxxflg;
+       reg     struct  instab  *ip;            /* the instruction */
+       reg     struct  arg     *ap_walk;       /* actual param walk */
+       reg     int     i;
+       reg     int     ap_type;                /* actual param type */
+       reg     int     ap_type_mask;           /* masked actual param */

 
 

-       op &= 0xFF;

        jxxflg = nact;
        if (nact < 0)
                nact = -nact;
        if (passno == 1) {
        jxxflg = nact;
        if (nact < 0)
                nact = -nact;
        if (passno == 1) {

-               register struct arg     *ap2;
-               register struct instab  *ip;
-               int                     i,nexp;
-               ip = itab[op];
-               nexp = ip->i_nargs;
-               if (nact < nexp)
+               if (!(ITABCHECK(opcode)))
+                       panic("Botched reference into itab");
+               ip = ITABFETCH(opcode);
+               if (nact < ip->i_nargs)

                        yyerror("Too few arguments");
                        yyerror("Too few arguments");

-               if (nact > nexp) {
+               if (nact > ip->i_nargs) {

                        yyerror("Too many arguments");
                        yyerror("Too many arguments");

-                       nact = nexp;
+                       nact = ip->i_nargs;

                }
                }

+           /*
+            *  Check argument compatability with instruction template
+            */
+           for (ap_walk = ap, i = 1; i <= nact; ap_walk++, i++){
+               ap_type = ap_walk->a_atype;
+               ap_type_mask = ap_type & AMASK;

                /*
                /*

-                *      Check argument compatability with instruction template
+                *      The switch value is >> by TYPLG so that the switch
+                *      code is dense, not implemented as a sequence
+                *      of branches but implemented as a casel.
+                *      In addition, cases ACCI and ACCR are added to force
+                *      dense switch code.
+                *      switch on the type of fp

                 */
                 */

-               for (ap2 = ap+nact, i = nact; --i >= 0;)
-                       argcompat(--ap2, fetcharg(ip, i), i+1);
-       }
+               switch( ((fetcharg(ip, i-1)) & ACCESSMASK) >> TYPLG){
+               case ACCI >> TYPLG:
+               case ACCR >> TYPLG:
+                       break;
+               case ACCB >> TYPLG:
+                       if ( !((ap_type_mask == AEXP) || (ap_type_mask == AIMM)) ){
+                               yyerror("arg %d, branch displacement must be an expression",i);
+                               return;
+                       }
+                       break;
+               case ACCA >> TYPLG:
+                       switch(ap_type_mask){
+                       case AREG:      yyerror("arg %d, addressing a register",i);
+                                       return;
+                       case AIMM:      if ( !(ap_type & ASTAR) ){
+                                        yyerror("arg %d, addressing an immediate operand",i);
+                                        return;
+                                       }
+                       }
+                       break;
+               case ACCM >> TYPLG:
+               case ACCW >> TYPLG:
+                       switch(ap_type_mask){
+                       case AIMM:      if (!(ap_type&ASTAR)) {
+                                        yyerror("arg %d, modifying a constant",i);
+                                        return;
+                                       }
+                       }
+                       break;
+               }       /* end of the switch on fp_type */
+               if (ap_type & AINDX) {
+                       if (ap_walk->a_areg2==0xF) {
+                               yyerror("arg %d, PC used as index",i);
+                               return;
+                       }
+                       switch(ap_type_mask){
+                       case AREG:      yyerror("arg %d, indexing the register file",i);
+                                       return;
+                       case AIMM:      yyerror("arg %d, indexing a constant",i);
+                                       return;
+                       case ADECR:
+                       case AINCR:     if (ap_walk->a_areg1==ap_walk->a_areg2) {
+                                               yyerror("arg %d, indexing with modified register",i);
+                                               return;
+                                       }
+                                       break;
+                       }       /* end of switch on ap_type_mask */
+               } /* end of AINDX */
+          }
+       } /* both passes here */

        if (jxxflg < 0)
        if (jxxflg < 0)

-               ijxout(op, ap, nact);
-       else putins(op, ap, nact);
-}
-
-argcompat(act, exp, i)
-       struct arg *act;
-       int exp,i;
-{
-       register        at,atm;
-
-       at = act->a_atype;
-       atm = at & AMASK;
-
-       if ( (exp & ACCB) && (!((atm == AEXP) || (atm == AIMM))) ){
-               yyerror("arg %d, branch displacement must be an expression",i);
-               return;
-       }
-       if ((exp & ACCA) && (atm == AREG)) {
-               yyerror("arg %d, addressing a register",i);
-               return;
-       }
-       if ((exp&ACCW) && (atm==AIMM) && !(at&ASTAR)) {
-               yyerror("arg %d, modifying a constant",i);
-               return;
-       }
-       if (at & AINDX) {
-               if (act->a_areg2==017) {
-                       yyerror("arg %d, PC used as index",i);
-                       return;
-               }
-               if (atm==AREG) {
-                       yyerror("arg %d, indexing the register file",i);
-                       return;
-               }
-               if (atm==AIMM) {
-                       yyerror("arg %d, indexing a constant",i);
-                       return;
-               }
-               if (((atm==ADECR) || (atm==AINCR)) && (act->a_areg1==act->a_areg2)) {
-                       yyerror("arg %d, indexing with modified register",i);
-                       return;
-               }
-       }
+               ijxout(opcode, ap, nact);
+       else
+               putins(opcode, ap, nact);

 }
 
 extern int d124;
 }
 
 extern int d124;

-       int len124[] =  {0,LEN1,LEN2,0,LEN4};
-       char mod124[] = {0,0x00,0x20,0,0x40};

 
 

-putins(op, ap, n)
-       /*
-        *      n had better be positive
-        */
+putins(opcode, ap, n)
+       struct  Opcode  opcode;

        register struct arg *ap;
        register struct arg *ap;

+       int     n;                      /* Must be positive */

 {
 {

-       register struct exp     *xp;
-       register int            a;
-       int                     i,xtrab;
+       reg     struct exp      *xp;
+       reg     int     argtype;
+               int     i;
+               int     reloc_how;
+               int     value;

 
 #ifdef DEBUG
        fflush(stdout);
 
 #ifdef DEBUG
        fflush(stdout);


@@ -97,17 +123,40 @@ putins(op, ap, n)
        if (passno == 2)
                goto PASS2;
 
        if (passno == 2)
                goto PASS2;
 

-       dotp->e_xvalue += n+1;          /* 1 for the opcode, at least 1 per arg */
+       dotp->e_xvalue += n;            /* at least one byte per arg */
+       switch(opcode.Op_eopcode){
+       case NEW:
+       case CORE:
+               dotp->e_xvalue += 1;    /* 1 byte opcode */
+               break;
+       case ESCD:
+       case ESCF:
+               dotp->e_xvalue += 2;    /* 2 byte opcode */
+               break;
+       default:
+               panic("Bad escape opcode");
+       }
+

        for (i=0; i<n; i++,ap++) {      /* some args take more than 1 byte */
        for (i=0; i<n; i++,ap++) {      /* some args take more than 1 byte */

-           a = ap->a_atype;
-           if (a & AINDX)
+           argtype = ap->a_atype;
+           if (argtype & AINDX)

                dotp->e_xvalue++;
                dotp->e_xvalue++;

-           switch (a&~(AINDX|ASTAR)) {
+           /*
+            *  This switch has been fixed by enumerating the no action
+            *  alternatives (those that have 1 one byte of code)
+            *  so that a casel instruction is emitted.
+            */
+           switch (argtype&~(AINDX|ASTAR)) {
+               case AREG:
+               case ABASE:
+               case ADECR:
+               case AINCR:
+                       break;

                case AEXP: 
                case AEXP: 

-                       a = fetcharg(itab[op], i);
-                       if (a == ACCB+TYPB)
+                       argtype = fetcharg(ITABFETCH(opcode), i);
+                       if (argtype == A_BB)

                                break;
                                break;

-                       if (a==ACCB+TYPW){
+                       if (argtype == A_BW){

                                dotp->e_xvalue++;
                                break;
                        }
                                dotp->e_xvalue++;
                                break;
                        }


@@ -123,89 +172,68 @@ putins(op, ap, n)
                                dotp->e_xvalue += ap->a_dispsize;
                                break;
                        }
                                dotp->e_xvalue += ap->a_dispsize;
                                break;
                        }

-                       if (xp->e_xvalue==0 && !(a&ASTAR))
+                       if (xp->e_xvalue==0 && !(argtype&ASTAR))

                                break;
                                break;

-                       dotp->e_xvalue++;
-                       if ((xp->e_xvalue<MINBYTE) || (xp->e_xvalue>MAXBYTE))
-                               dotp->e_xvalue++;
-                       if ((xp->e_xvalue<MINWORD) || (xp->e_xvalue>MAXWORD))
-                               dotp->e_xvalue += 2;
+                       dotp->e_xvalue += 1;
+                       if (ISBYTE(xp->e_xvalue))
+                               break;
+                       dotp->e_xvalue += 1;
+                       if (ISWORD(xp->e_xvalue))
+                               break;
+                       dotp->e_xvalue += 2;

                        break;
 
                case AIMM: 
                        break;
 
                case AIMM: 

-                       if (ap->a_atype&ASTAR) a=TYPL;
-                       else {
-                               a = fetcharg(itab[op], i);
-                               if (a&ACCA)
-                                       a = TYPL;
+                       if (ap->a_atype&ASTAR) {
+                               argtype=TYPL;
+                       } else {
+                               argtype = fetcharg(ITABFETCH(opcode), i);
+                               if (argtype&ACCA)
+                                       argtype = TYPL;

                                else
                                else

-                                       a &= TYPMASK;
+                                       argtype &= TYPMASK;

                                xp = ap->a_xp;
                                xp = ap->a_xp;

-                               if (   ((xp->e_xtype&XTYPE)==XABS)
-                                   && (!(xp->e_xtype&XFORW))
-                                   && (xp->e_xvalue>=0)
-                                   && (xp->e_xvalue<=63) 
-                                   && (xp->e_yvalue == 0)
-                                   && (a != TYPD)
-                                   && (a != TYPF)
-                               )
-                                               break;
+                               if (immconstant(ap->a_xp, argtype, &value))
+                                       break;

                        }
                        }

-                       switch (a) {
-                       case TYPD:
-                       case TYPF:
-                               if (   !(((xp->e_xtype&XTYPE)==XABS)
-                                   && (!(xp->e_xtype&XFORW))
-                                   && (slitflt(xp)))
-                               ){
-                               /* it is NOT short */
-                                       dotp->e_xvalue += ((a==TYPF)?
-                                               4 : 8);
-                               }
-                               break;
-                       case TYPQ: 
-                               dotp->e_xvalue += 8;break;
-                       case TYPL:
-                               dotp->e_xvalue += 4;break;
-                       case TYPW: 
-                               dotp->e_xvalue += 2;break;
-                       case TYPB: 
-                               dotp->e_xvalue += 1;break;
-                       }       /*end of the switch on a*/
+                       dotp->e_xvalue += ty_nbyte[argtype];

            }   /*end of the switch on the type*/
        }       /*end of looping for all arguments*/
        return;
 
 PASS2:
            }   /*end of the switch on the type*/
        }       /*end of looping for all arguments*/
        return;
 
 PASS2:

-
-#ifdef UNIX
-       outb(op); /* the opcode */
-#endif UNIX
-#ifdef VMS
-       *vms_obj_ptr++ = -1; *vms_obj_ptr++ = (char)op;
-       dotp->e_xvalue += 1;
-#endif VMS
+       /*
+        *      Output the opcode
+        */
+       switch(opcode.Op_eopcode){
+       case NEW:
+               nnewopcodes++;
+               break;
+       case ESCD:
+       case ESCF:
+               nGHopcodes++;
+               Outb(opcode.Op_eopcode);
+               break;
+       case CORE:
+               break;
+       default:
+               panic("Bad escape opcode");
+       }
+       Outb(opcode.Op_popcode);

 
        for (i=0; i<n; i++,ap++) {/* now for the arguments */
 
        for (i=0; i<n; i++,ap++) {/* now for the arguments */

-               a=ap->a_atype;
+               argtype=ap->a_atype;

                xp=ap->a_xp;
                xp=ap->a_xp;

-               xtrab=0;
-               if (a&AINDX) {
-#ifdef UNIX
-                       { outb(0x40 | ap->a_areg2); }
-#endif UNIX
-#ifdef VMS
-                       { *vms_obj_ptr++ = -1;
-                         *vms_obj_ptr++ = (0x40 | ap->a_areg2);
-                         dotp->e_xvalue += 1; }
-#endif VMS
-                       a &= ~AINDX;
+               reloc_how = TYPNONE;
+               if (argtype&AINDX) {
+                       { Outb(0x40 | ap->a_areg2); }
+                       argtype &= ~AINDX;

                }
                }

-               if (a&ASTAR) {
+               if (argtype&ASTAR) {

                        ap->a_areg1 |= 0x10;
                        ap->a_areg1 |= 0x10;

-                       a &= ~ASTAR;
+                       argtype &= ~ASTAR;

                }
                }

-               switch (a) {
+               switch (argtype) {

                case AREG:              /* %r */
                        ap->a_areg1 |= 0x50;
                        break; 
                case AREG:              /* %r */
                        ap->a_areg1 |= 0x50;
                        break; 


@@ -215,117 +243,192 @@ PASS2:
                case ADECR:             /* -(%r) */
                        ap->a_areg1 |= 0x70;
                        break; 
                case ADECR:             /* -(%r) */
                        ap->a_areg1 |= 0x70;
                        break; 

-               case AINCR:             /* (%r) */
+               case AINCR:             /* (%r)+ */

                        ap->a_areg1 |= 0x80;
                        break;
                case AEXP: /* expr */
                        ap->a_areg1 |= 0x80;
                        break;
                case AEXP: /* expr */

-                       a = fetcharg(itab[op], i);
-                       if (a == ACCB+TYPB) {
-                               ap->a_areg1 = a = 
+                       argtype = fetcharg(ITABFETCH(opcode), i);
+                       if (argtype == A_BB) {
+                               ap->a_areg1 = argtype = 

                                        xp->e_xvalue - (dotp->e_xvalue + 1);
                                        xp->e_xvalue - (dotp->e_xvalue + 1);

-                               if (a<MINBYTE || a>MAXBYTE)
-                                       yyerror("Branch too far"); break;
+                               if (xp->e_xtype & XXTRN)
+                                       yywarning("%s: destination label is external",
+                                               FETCHNAME(ITABFETCH(opcode)));
+                               if (!ISBYTE(argtype))
+                                       yyerror("%s: Branch too far(%db): try -J flag",
+                                               FETCHNAME(ITABFETCH(opcode)),
+                                               argtype);
+                               break;

                        }
                        }

-                       if (a == ACCB+TYPW) {
-                               ap->a_areg1 = a = xp->e_xvalue
+                       if (argtype == A_BW) {
+                               ap->a_areg1 = argtype = xp->e_xvalue

                                        -= dotp->e_xvalue + 2;
                                        -= dotp->e_xvalue + 2;

+                               if (xp->e_xtype & XXTRN)
+                                       yywarning("%s: destination label is external",
+                                               FETCHNAME(ITABFETCH(opcode)));

                                xp->e_xtype = XABS;
                                xp->e_xtype = XABS;

-                               if (a<MINWORD || a>MAXWORD) 
-                                       yyerror("Branch too far");
-                               xp->e_xvalue = a>>8;
-                               xtrab = LEN1;
+                               if (!ISWORD(argtype))
+                                       yyerror("%s: Branch too far(%db): try -J flag",
+                                               FETCHNAME(ITABFETCH(opcode)),
+                                               argtype);
+                               xp->e_xvalue = argtype>>8;
+                               reloc_how = TYPB;

                                break;
                        }
                        /* reduces to expr(pc) mode */
                        ap->a_areg1 |= (0xAF + mod124[ap->a_dispsize]);
                                break;
                        }
                        /* reduces to expr(pc) mode */
                        ap->a_areg1 |= (0xAF + mod124[ap->a_dispsize]);

-                       xtrab = len124[ap->a_dispsize]+PCREL;
+                       reloc_how = type_124[ap->a_dispsize] + RELOC_PCREL;

                        break;
                
                case ADISP: /* expr(%r) */
                        ap->a_areg1 |= 0xA0;
                        if ((xp->e_xtype&XTYPE)!=XABS || xp->e_xtype&XFORW){
                                ap->a_areg1 += mod124[ap->a_dispsize];
                        break;
                
                case ADISP: /* expr(%r) */
                        ap->a_areg1 |= 0xA0;
                        if ((xp->e_xtype&XTYPE)!=XABS || xp->e_xtype&XFORW){
                                ap->a_areg1 += mod124[ap->a_dispsize];

-                               xtrab=len124[ap->a_dispsize];
+                               reloc_how = type_124[ap->a_dispsize];

                                break;
                        }
                        if (xp->e_xvalue==0 && !(ap->a_areg1&0x10)) {
                                ap->a_areg1 ^= 0xC0;
                                break;
                        }
                                break;
                        }
                        if (xp->e_xvalue==0 && !(ap->a_areg1&0x10)) {
                                ap->a_areg1 ^= 0xC0;
                                break;
                        }

-                       xtrab=LEN1;
-                       if ((xp->e_xvalue<MINBYTE) || (xp->e_xvalue>MAXBYTE)){
-                               ap->a_areg1 += 0x20;
-                               xtrab=LEN2;
-                       }
-                       if ((xp->e_xvalue<MINWORD) || (xp->e_xvalue>MAXWORD)){
-                               ap->a_areg1 += 0x20;
-                               xtrab=LEN4;
-                       }
+                       reloc_how = TYPB;
+                       if (ISBYTE(xp->e_xvalue))
+                               break;
+                       ap->a_areg1 += 0x20;
+                       reloc_how = TYPW;
+                       if (ISWORD(xp->e_xvalue))
+                               break;
+                       ap->a_areg1 += 0x20;
+                       reloc_how = TYPL;

                        break;
                
                case AIMM:  /* $expr */
                        break;
                
                case AIMM:  /* $expr */

-                       if (ap->a_atype&ASTAR)
-                               a=TYPL;
-                       else {
-                               a = fetcharg(itab[op], i);
-                               if (a&ACCA)
-                                       a=TYPL;
+                       if (ap->a_atype&ASTAR) {
+                               argtype=TYPL;
+                       } else {
+                               argtype = fetcharg(ITABFETCH(opcode), i);
+                               if (argtype&ACCA)
+                                       argtype = TYPL;

                                else
                                else

-                                       a &= TYPMASK;
-                               if (    ( (xp->e_xtype&XTYPE) == XABS) 
-                                   && !(xp->e_xtype&XFORW)
-                                   &&  (xp->e_xvalue >= 0)
-                                   &&  (xp->e_xvalue <= 63)
-                                   &&  (xp->e_yvalue == 0)
-                                   &&  (a != TYPF)
-                                   &&  (a != TYPD) ) {
-                                       ap->a_areg1 = xp->e_xvalue;
+                                       argtype &= TYPMASK;
+                               if (immconstant(xp, argtype, &value)){
+                                       reloc_how = TYPNONE;
+                                       ap->a_areg1 = value;

                                        break;
                                }
                        }
                        ap->a_areg1 |= 0x8F;
                                        break;
                                }
                        }
                        ap->a_areg1 |= 0x8F;

-                       switch (a) {
-                       case TYPD:
-                       case TYPF:
-                               if (   ((xp->e_xtype&XTYPE)==XABS)
-                                   && (!(xp->e_xtype&XFORW))
-                                   && (slitflt(xp))
-                               ){
-                                       ap->a_areg1=extlitflt(xp);
-                               } else {
-                                       xtrab = (a==TYPF) ? LEN4: LEN8;
-                               }
-                               break;
-                       case TYPQ: xtrab = LEN8; break;
-                       case TYPL: xtrab = LEN4; break;
-                       case TYPW: xtrab = LEN2; break;
-                       case TYPB: xtrab = LEN1; break;
-                       }       
+                       reloc_how = argtype;

                        break;
                
                        break;
                

-               }       /*end of the switch on a*/
+               }       /*end of the switch on argtype*/

                /*
                 *      use the first byte to describe the argument
                 */
                /*
                 *      use the first byte to describe the argument
                 */

-#ifdef UNIX
-               outb(ap->a_areg1);
-#endif UNIX
-#ifdef VMS
-               *vms_obj_ptr++ = -1; *vms_obj_ptr++ = (char)(ap->a_areg1);
-               dotp->e_xvalue += 1;
-               if ((vms_obj_ptr-sobuf) > 400) {
-                       write(objfil,sobuf,vms_obj_ptr-sobuf);
-                       vms_obj_ptr=sobuf+1;
-               }
-#endif VMS
-               if (xtrab) 
-                       /*
-                        *      Floating point numbers are written to a.out
-                        *      by outrel; they require that the least significant
-                        *      4 bytes of an 8 byte double precision number
-                        *      immediately follow the field xvalue, which
-                        *      they do.
-                        */
-                       outrel(&xp->e_xvalue, xtrab, xp->e_xtype, xp->e_xname);
+               Outb(ap->a_areg1);
+               if (reloc_how != TYPNONE) 
+                       outrel(xp, reloc_how);

        }       /*end of the for to pick up all arguments*/
 }
        }       /*end of the for to pick up all arguments*/
 }

+/*
+ *     Is xp an immediate constant?
+ *     argtype: how the instruction will interpret the bytes
+ *     xp->e_number.num_tag ("numtype"): the kind of number given
+ *
+ *     Use the following table:
+ *     float: TYPF, TYPD, TYPG, TYPH
+ *     quad: TYPQ, TYPO
+ *     int: TYPG, TYPW, TYPL
+ *
+ *                             numtype
+ *     argtype         float   quad    int
+ *     
+ *     float           slitflt slitflt slitflt
+ *     quad            0       0       0
+ *     int             0..63   0       0..63
+ *
+ *     Where the table entry implies the predicate to return.
+ */
+#define        IMMFLT  1               /* these flags are not used by anybody (yet) */
+#define        IMMINT  2
+
+int immconstant(xp, argtype, valuep)
+       reg     struct  exp     *xp;
+               int     argtype;
+               int     *valuep;
+{
+       reg     int     back = 0;
+               int     numtype;
+       reg     int     fits;
+
+       if ((xp->e_xtype & XTYPE) != XABS)
+               return(0);
+       if ((xp->e_xtype & XFORW) != 0)
+               return(0);
+       numtype = xp->e_number.num_tag;
+
+       fits = 1;
+       if (passno == 2) switch(argtype){
+       case TYPB:
+               switch(numtype){
+               default:        fits = 0; break;
+               case TYPB:      fits = 1; break;
+               case TYPW:      
+               case TYPL:
+                       fits = ISBYTE(xp->e_xvalue) || ISUBYTE(xp->e_xvalue);
+                       break;
+               }
+               break;
+       case TYPW:
+               switch(numtype){
+               default:        fits = 0; break;
+               case TYPB:
+               case TYPW:      fits = 1; break;
+               case TYPL:
+                       fits = ISWORD(xp->e_xvalue) || ISUWORD(xp->e_xvalue);
+                       break;
+               }
+               break;
+       case TYPF:
+               if (numtype == TYPD){   /* same format for first 32 bits */
+                       fits = 1;
+                       break;
+               }
+               /*FALLTHROUGH*/
+       default:
+               fits = ty_nbyte[argtype] >= ty_nbyte[numtype];
+       }
+       if (!fits){
+         yywarning("Immediate constant type %s mismatches instruction type %s",
+               ty_string[numtype],
+               ty_string[argtype]);
+       }
+
+       switch(argtype){
+       case TYPF:
+       case TYPG:
+       case TYPD:
+       case TYPH:
+               back = slitflt(xp->e_number, argtype, valuep);
+               break;
+       case TYPO:
+       case TYPQ:
+               back = 0;
+               break;
+       case TYPB:
+       case TYPW:
+       case TYPL:
+               switch(numtype){
+               case TYPO:
+               case TYPQ:
+                       back = 0;
+                       break;
+               default:
+                       *valuep = xp->e_xvalue;
+                       back = ISLIT(xp->e_xvalue);
+                       break;
+               }
+               break;
+       }
+       return(back);
+}