ANSI; const -> constant, inline -> inlne

SCCS-vsn: usr.bin/f77/pass1.tahoe/bb.c 5.2
SCCS-vsn: usr.bin/f77/pass1.tahoe/conv.c 5.2
SCCS-vsn: usr.bin/f77/pass1.tahoe/data.c 5.2
SCCS-vsn: usr.bin/f77/pass1.tahoe/defs.h 5.2
SCCS-vsn: usr.bin/f77/pass1.tahoe/equiv.c 5.2
SCCS-vsn: usr.bin/f77/pass1.tahoe/exec.c 5.2
SCCS-vsn: usr.bin/f77/pass1.tahoe/expr.c 1.3
SCCS-vsn: usr.bin/f77/pass1.tahoe/intr.c 5.2
SCCS-vsn: usr.bin/f77/pass1.tahoe/io.c 5.2
SCCS-vsn: usr.bin/f77/pass1.tahoe/optcse.c 5.2
SCCS-vsn: usr.bin/f77/pass1.tahoe/optim.c 5.2
SCCS-vsn: usr.bin/f77/pass1.tahoe/optloop.c 5.2
SCCS-vsn: usr.bin/f77/pass1.tahoe/paramset.c 5.2
SCCS-vsn: usr.bin/f77/pass1.tahoe/proc.c 5.2
SCCS-vsn: usr.bin/f77/pass1.tahoe/put.c 5.2
SCCS-vsn: usr.bin/f77/pass1.tahoe/putpcc.c 5.2
SCCS-vsn: usr.bin/f77/pass1.tahoe/regalloc.c 5.2
SCCS-vsn: usr.bin/f77/pass1.tahoe/stab.c 5.2
SCCS-vsn: usr.bin/f77/pass1.tahoe/tahoe.c 5.2

diff --git a/usr/src/usr.bin/f77/pass1.tahoe/bb.c b/usr/src/usr.bin/f77/pass1.tahoe/bb.c
index 6f75b1c..328e761 100644 (file)
--- a/usr/src/usr.bin/f77/pass1.tahoe/bb.c
+++ b/usr/src/usr.bin/f77/pass1.tahoe/bb.c
@@ -690,16 +690,17 @@ switch(p->tag)
               if (ISCHAR(p))
                  {
                       fprintf(diagfile," ISCHAR ccp= %d\n",
               if (ISCHAR(p))
                  {
                       fprintf(diagfile," ISCHAR ccp= %d\n",

-                                                   p->constblock.const.ccp);
+                                                   p->constblock.constant.ccp);

                       SHOWEXPR(p->constblock.vleng);
                  }
               else  if( ISINT(type) )
                       SHOWEXPR(p->constblock.vleng);
                  }
               else  if( ISINT(type) )

-                   fprintf(diagfile," ci= %d\n",p->constblock.const.ci); 
+                   fprintf(diagfile," ci= %d\n",p->constblock.constant.ci); 

               else if( ISREAL(type) )
               else if( ISREAL(type) )

-                   fprintf(diagfile," cd[0]= %e\n",p->constblock.const.cd[0]);
+                   fprintf(diagfile,
+                       " cd[0]= %e\n",p->constblock.constant.cd[0]);

               else fprintf(diagfile," cd[0]= %e  cd[1]= %e\n",
               else fprintf(diagfile," cd[0]= %e  cd[1]= %e\n",

-                            p->constblock.const.cd[0],
-                            p->constblock.const.cd[1] ); 
+                            p->constblock.constant.cd[0],
+                            p->constblock.constant.cd[1] ); 

               break;
 
          case TADDR:
               break;
 
          case TADDR:

diff --git a/usr/src/usr.bin/f77/pass1.tahoe/conv.c b/usr/src/usr.bin/f77/pass1.tahoe/conv.c
index 4a17631..26b9a3b 100644 (file)
--- a/usr/src/usr.bin/f77/pass1.tahoe/conv.c
+++ b/usr/src/usr.bin/f77/pass1.tahoe/conv.c
@@ -42,8 +42,8 @@ Constp cp;
   register int k;
   register int lenb;
 
   register int k;
   register int lenb;
 

-  bits = cp->const.ccp;
-  lenb = cp->vleng->constblock.const.ci;
+  bits = cp->constant.ccp;
+  lenb = cp->vleng->constblock.constant.ci;

 
   p = (char *) ckalloc(len);
 
 
   p = (char *) ckalloc(len);
 


@@ -101,8 +101,8 @@ Constp cp;
   register int k;
   register int lenb;
 
   register int k;
   register int lenb;
 

-  bytes = cp->const.ccp;
-  lenb = cp->vleng->constblock.const.ci;
+  bytes = cp->constant.ccp;
+  lenb = cp->vleng->constblock.constant.ci;

 
   p = (char *) ckalloc(len);
 
 
   p = (char *) ckalloc(len);
 


@@ -148,7 +148,7 @@ Constp cp;
     case TYBITSTR:
       shortp = (short *) grabbits(2, cp);
       p = (expptr) mkconst(TYSHORT);
     case TYBITSTR:
       shortp = (short *) grabbits(2, cp);
       p = (expptr) mkconst(TYSHORT);

-      p->constblock.const.ci = *shortp;
+      p->constblock.constant.ci = *shortp;

       free((char *) shortp);
       break;
 
       free((char *) shortp);
       break;
 


@@ -157,11 +157,11 @@ Constp cp;
       break;
 
     case TYLONG:
       break;
 
     case TYLONG:

-      value = cp->const.ci;
+      value = cp->constant.ci;

       if (value >= MINWORD && value <= MAXWORD)
        {
          p = (expptr) mkconst(TYSHORT);
       if (value >= MINWORD && value <= MAXWORD)
        {
          p = (expptr) mkconst(TYSHORT);

-         p->constblock.const.ci = value;
+         p->constblock.constant.ci = value;

        }
       else
        {
        }
       else
        {


@@ -180,7 +180,7 @@ Constp cp;
     case TYDCOMPLEX:
       minp = (double *) dminword;
       maxp = (double *) dmaxword;
     case TYDCOMPLEX:
       minp = (double *) dminword;
       maxp = (double *) dmaxword;

-      rp = (long *) &(cp->const.cd[0]);
+      rp = (long *) &(cp->constant.cd[0]);

       x.q.word1 = rp[0];
       x.q.word2 = rp[1];
       if (x.f.sign == 1 && x.f.exp == 0)
       x.q.word1 = rp[0];
       x.q.word2 = rp[1];
       if (x.f.sign == 1 && x.f.exp == 0)


@@ -195,7 +195,7 @@ Constp cp;
       else if (x.d >= *minp && x.d <= *maxp)
        {
          p = (expptr) mkconst(TYSHORT);
       else if (x.d >= *minp && x.d <= *maxp)
        {
          p = (expptr) mkconst(TYSHORT);

-         p->constblock.const.ci = x.d;
+         p->constblock.constant.ci = x.d;

        }
       else
        {
        }
       else
        {


@@ -227,7 +227,7 @@ Constp cp;
     case TYHOLLERITH:
       shortp = (short *) grabbytes(2, cp);
       p = (expptr) mkconst(TYSHORT);
     case TYHOLLERITH:
       shortp = (short *) grabbytes(2, cp);
       p = (expptr) mkconst(TYSHORT);

-      p->constblock.const.ci = *shortp;
+      p->constblock.constant.ci = *shortp;

       free((char *) shortp);
       break;
 
       free((char *) shortp);
       break;
 


@@ -262,13 +262,13 @@ Constp cp;
     case TYBITSTR:
       longp = (ftnint *) grabbits(4, cp);
       p = (expptr) mkconst(TYLONG);
     case TYBITSTR:
       longp = (ftnint *) grabbits(4, cp);
       p = (expptr) mkconst(TYLONG);

-      p->constblock.const.ci = *longp;
+      p->constblock.constant.ci = *longp;

       free((char *) longp);
       break;
 
     case TYSHORT:
       p = (expptr) mkconst(TYLONG);
       free((char *) longp);
       break;
 
     case TYSHORT:
       p = (expptr) mkconst(TYLONG);

-      p->constblock.const.ci = cp->const.ci;
+      p->constblock.constant.ci = cp->constant.ci;

       break;
 
     case TYLONG:
       break;
 
     case TYLONG:


@@ -281,7 +281,7 @@ Constp cp;
     case TYDCOMPLEX:
       minp = (double *) dminint;
       maxp = (double *) dmaxint;
     case TYDCOMPLEX:
       minp = (double *) dminint;
       maxp = (double *) dmaxint;

-      rp = (long *) &(cp->const.cd[0]);
+      rp = (long *) &(cp->constant.cd[0]);

       x.q.word1 = rp[0];
       x.q.word2 = rp[1];
       if (x.f.sign == 1 && x.f.exp == 0)
       x.q.word1 = rp[0];
       x.q.word2 = rp[1];
       if (x.f.sign == 1 && x.f.exp == 0)


@@ -296,7 +296,7 @@ Constp cp;
       else if (x.d >= *minp && x.d <= *maxp)
        {
          p = (expptr) mkconst(TYLONG);
       else if (x.d >= *minp && x.d <= *maxp)
        {
          p = (expptr) mkconst(TYLONG);

-         p->constblock.const.ci = x.d;
+         p->constblock.constant.ci = x.d;

        }
       else
        {
        }
       else
        {


@@ -328,7 +328,7 @@ Constp cp;
     case TYHOLLERITH:
       longp = (ftnint *) grabbytes(4, cp);
       p = (expptr) mkconst(TYLONG);
     case TYHOLLERITH:
       longp = (ftnint *) grabbytes(4, cp);
       p = (expptr) mkconst(TYLONG);

-      p->constblock.const.ci = *longp;
+      p->constblock.constant.ci = *longp;

       free((char *) longp);
       break;
 
       free((char *) longp);
       break;
 


@@ -363,7 +363,7 @@ Constp cp;
     case TYBITSTR:
       longp = (long *) grabbits(4, cp);
       p = (expptr) mkconst(TYREAL);
     case TYBITSTR:
       longp = (long *) grabbits(4, cp);
       p = (expptr) mkconst(TYREAL);

-      rp = (long *) &(p->constblock.const.cd[0]);
+      rp = (long *) &(p->constblock.constant.cd[0]);

       rp[0] = *longp;
       free((char *) longp);
       break;
       rp[0] = *longp;
       free((char *) longp);
       break;


@@ -371,7 +371,7 @@ Constp cp;
     case TYSHORT:
     case TYLONG:
       p = (expptr) mkconst(TYREAL);
     case TYSHORT:
     case TYLONG:
       p = (expptr) mkconst(TYREAL);

-      p->constblock.const.cd[0] = cp->const.ci;
+      p->constblock.constant.cd[0] = cp->constant.ci;

       break;
 
     case TYREAL:
       break;
 
     case TYREAL:


@@ -380,20 +380,20 @@ Constp cp;
     case TYDCOMPLEX:
       minp = (double *) dminreal;
       maxp = (double *) dmaxreal;
     case TYDCOMPLEX:
       minp = (double *) dminreal;
       maxp = (double *) dmaxreal;

-      rp = (long *) &(cp->const.cd[0]);
+      rp = (long *) &(cp->constant.cd[0]);

       x.q.word1 = rp[0];
       x.q.word2 = rp[1];
       if (x.f.sign == 1 && x.f.exp == 0)
        {
          p = (expptr) mkconst(TYREAL);
       x.q.word1 = rp[0];
       x.q.word2 = rp[1];
       if (x.f.sign == 1 && x.f.exp == 0)
        {
          p = (expptr) mkconst(TYREAL);

-         rp = (long *) &(p->constblock.const.cd[0]);
+         rp = (long *) &(p->constblock.constant.cd[0]);

          rp[0] = x.q.word1;
        }
       else if (x.d >= *minp && x.d <= *maxp)
        {
          p = (expptr) mkconst(TYREAL);
          y = x.d;
          rp[0] = x.q.word1;
        }
       else if (x.d >= *minp && x.d <= *maxp)
        {
          p = (expptr) mkconst(TYREAL);
          y = x.d;

-         p->constblock.const.cd[0] = y;
+         p->constblock.constant.cd[0] = y;

        }
       else
        {
        }
       else
        {


@@ -425,7 +425,7 @@ Constp cp;
     case TYHOLLERITH:
       longp = (long *) grabbytes(4, cp);
       p = (expptr) mkconst(TYREAL);
     case TYHOLLERITH:
       longp = (long *) grabbytes(4, cp);
       p = (expptr) mkconst(TYREAL);

-      rp = (long *) &(p->constblock.const.cd[0]);
+      rp = (long *) &(p->constblock.constant.cd[0]);

       rp[0] = *longp;
       free((char *) longp);
       break;
       rp[0] = *longp;
       free((char *) longp);
       break;


@@ -458,7 +458,7 @@ Constp cp;
     case TYBITSTR:
       longp = (long *) grabbits(8, cp);
       p = (expptr) mkconst(TYDREAL);
     case TYBITSTR:
       longp = (long *) grabbits(8, cp);
       p = (expptr) mkconst(TYDREAL);

-      rp = (long *) &(p->constblock.const.cd[0]);
+      rp = (long *) &(p->constblock.constant.cd[0]);

       rp[0] = longp[0];
       rp[1] = longp[1];
       free((char *) longp);
       rp[0] = longp[0];
       rp[1] = longp[1];
       free((char *) longp);


@@ -467,7 +467,7 @@ Constp cp;
     case TYSHORT:
     case TYLONG:
       p = (expptr) mkconst(TYDREAL);
     case TYSHORT:
     case TYLONG:
       p = (expptr) mkconst(TYDREAL);

-      p->constblock.const.cd[0] = cp->const.ci;
+      p->constblock.constant.cd[0] = cp->constant.ci;

       break;
 
     case TYREAL:
       break;
 
     case TYREAL:


@@ -475,8 +475,8 @@ Constp cp;
     case TYCOMPLEX:
     case TYDCOMPLEX:
       p = (expptr) mkconst(TYDREAL);
     case TYCOMPLEX:
     case TYDCOMPLEX:
       p = (expptr) mkconst(TYDREAL);

-      longp = (long *) &(cp->const.cd[0]);
-      rp = (long *) &(p->constblock.const.cd[0]);
+      longp = (long *) &(cp->constant.cd[0]);
+      rp = (long *) &(p->constblock.constant.cd[0]);

       rp[0] = longp[0];
       rp[1] = longp[1];
       break;
       rp[0] = longp[0];
       rp[1] = longp[1];
       break;


@@ -500,7 +500,7 @@ Constp cp;
     case TYHOLLERITH:
       longp = (long *) grabbytes(8, cp);
       p = (expptr) mkconst(TYDREAL);
     case TYHOLLERITH:
       longp = (long *) grabbytes(8, cp);
       p = (expptr) mkconst(TYDREAL);

-      rp = (long *) &(p->constblock.const.cd[0]);
+      rp = (long *) &(p->constblock.constant.cd[0]);

       rp[0] = longp[0];
       rp[1] = longp[1];
       free((char *) longp);
       rp[0] = longp[0];
       rp[1] = longp[1];
       free((char *) longp);


@@ -538,7 +538,7 @@ Constp cp;
     case TYBITSTR:
       longp = (long *) grabbits(8, cp);
       p = (expptr) mkconst(TYCOMPLEX);
     case TYBITSTR:
       longp = (long *) grabbits(8, cp);
       p = (expptr) mkconst(TYCOMPLEX);

-      rp = (long *) &(p->constblock.const.cd[0]);
+      rp = (long *) &(p->constblock.constant.cd[0]);

       rp[0] = longp[0];
       rp[2] = longp[1];
       free((char *) longp);
       rp[0] = longp[0];
       rp[2] = longp[1];
       free((char *) longp);


@@ -547,7 +547,7 @@ Constp cp;
     case TYSHORT:
     case TYLONG:
       p = (expptr) mkconst(TYCOMPLEX);
     case TYSHORT:
     case TYLONG:
       p = (expptr) mkconst(TYCOMPLEX);

-      p->constblock.const.cd[0] = cp->const.ci;
+      p->constblock.constant.cd[0] = cp->constant.ci;

       break;
 
     case TYREAL:
       break;
 
     case TYREAL:


@@ -557,7 +557,7 @@ Constp cp;
       overflow = 0;
       minp = (double *) dminreal;
       maxp = (double *) dmaxreal;
       overflow = 0;
       minp = (double *) dminreal;
       maxp = (double *) dmaxreal;

-      rp = (long *) &(cp->const.cd[0]);
+      rp = (long *) &(cp->constant.cd[0]);

       re.q.word1 = rp[0];
       re.q.word2 = rp[1];
       im.q.word1 = rp[2];
       re.q.word1 = rp[0];
       re.q.word2 = rp[1];
       im.q.word1 = rp[2];


@@ -591,7 +591,7 @@ Constp cp;
              x = im.d;
              im.d = x;
            }
              x = im.d;
              im.d = x;
            }

-         rp = (long *) &(p->constblock.const.cd[0]);
+         rp = (long *) &(p->constblock.constant.cd[0]);

          rp[0] = re.q.word1;
          rp[1] = re.q.word2;
          rp[2] = im.q.word1;
          rp[0] = re.q.word1;
          rp[1] = re.q.word2;
          rp[2] = im.q.word1;


@@ -617,7 +617,7 @@ Constp cp;
     case TYHOLLERITH:
       longp = (long *) grabbytes(8, cp);
       p = (expptr) mkconst(TYCOMPLEX);
     case TYHOLLERITH:
       longp = (long *) grabbytes(8, cp);
       p = (expptr) mkconst(TYCOMPLEX);

-      rp = (long *) &(p->constblock.const.cd[0]);
+      rp = (long *) &(p->constblock.constant.cd[0]);

       rp[0] = longp[0];
       rp[2] = longp[1];
       free((char *) longp);
       rp[0] = longp[0];
       rp[2] = longp[1];
       free((char *) longp);


@@ -649,7 +649,7 @@ Constp cp;
     case TYBITSTR:
       longp = (long *) grabbits(16, cp);
       p = (expptr) mkconst(TYDCOMPLEX);
     case TYBITSTR:
       longp = (long *) grabbits(16, cp);
       p = (expptr) mkconst(TYDCOMPLEX);

-      rp = (long *) &(p->constblock.const.cd[0]);
+      rp = (long *) &(p->constblock.constant.cd[0]);

       rp[0] = longp[0];
       rp[1] = longp[1];
       rp[2] = longp[2];
       rp[0] = longp[0];
       rp[1] = longp[1];
       rp[2] = longp[2];


@@ -660,7 +660,7 @@ Constp cp;
     case TYSHORT:
     case TYLONG:
       p = (expptr) mkconst(TYDCOMPLEX);
     case TYSHORT:
     case TYLONG:
       p = (expptr) mkconst(TYDCOMPLEX);

-      p->constblock.const.cd[0] = cp->const.ci;
+      p->constblock.constant.cd[0] = cp->constant.ci;

       break;
 
     case TYREAL:
       break;
 
     case TYREAL:


@@ -668,8 +668,8 @@ Constp cp;
     case TYCOMPLEX:
     case TYDCOMPLEX:
       p = (expptr) mkconst(TYDCOMPLEX);
     case TYCOMPLEX:
     case TYDCOMPLEX:
       p = (expptr) mkconst(TYDCOMPLEX);

-      longp = (long *) &(cp->const.cd[0]);
-      rp = (long *) &(p->constblock.const.cd[0]);
+      longp = (long *) &(cp->constant.cd[0]);
+      rp = (long *) &(p->constblock.constant.cd[0]);

       rp[0] = longp[0];
       rp[1] = longp[1];
       rp[2] = longp[2];
       rp[0] = longp[0];
       rp[1] = longp[1];
       rp[2] = longp[2];


@@ -695,7 +695,7 @@ Constp cp;
     case TYHOLLERITH:
       longp = (long *) grabbytes(16, cp);
       p = (expptr) mkconst(TYDCOMPLEX);
     case TYHOLLERITH:
       longp = (long *) grabbytes(16, cp);
       p = (expptr) mkconst(TYDCOMPLEX);

-      rp = (long *) &(p->constblock.const.cd[0]);
+      rp = (long *) &(p->constblock.constant.cd[0]);

       rp[0] = longp[0];
       rp[1] = longp[1];
       rp[2] = longp[2];
       rp[0] = longp[0];
       rp[1] = longp[1];
       rp[2] = longp[2];


@@ -734,13 +734,13 @@ Constp cp;
       if (tylogical == TYSHORT)
        {
          shortp = (short *) grabbits(size, cp);
       if (tylogical == TYSHORT)
        {
          shortp = (short *) grabbits(size, cp);

-         p->constblock.const.ci = (int) *shortp;
+         p->constblock.constant.ci = (int) *shortp;

          free((char *) shortp);
        }
       else
        {
          longp = (long *) grabbits(size, cp);
          free((char *) shortp);
        }
       else
        {
          longp = (long *) grabbits(size, cp);

-         p->constblock.const.ci = *longp;
+         p->constblock.constant.ci = *longp;

          free((char *) longp);
        }
       break;
          free((char *) longp);
        }
       break;


@@ -776,13 +776,13 @@ Constp cp;
       if (tylogical == TYSHORT)
        {
          shortp = (short *) grabbytes(size, cp);
       if (tylogical == TYSHORT)
        {
          shortp = (short *) grabbytes(size, cp);

-         p->constblock.const.ci = (int) *shortp;
+         p->constblock.constant.ci = (int) *shortp;

          free((char *) shortp);
        }
       else
        {
          longp = (long *) grabbytes(4, cp);
          free((char *) shortp);
        }
       else
        {
          longp = (long *) grabbytes(4, cp);

-         p->constblock.const.ci = *longp;
+         p->constblock.constant.ci = *longp;

          free((char *) longp);
        }
       break;
          free((char *) longp);
        }
       break;


@@ -857,45 +857,45 @@ Constp cp;
 \f
 
 expptr
 \f
 
 expptr

-convconst(type, len, const)
+convconst(type, len, constant)

 int type;
 int len;
 int type;
 int len;

-Constp const;
+Constp constant;

 {
   register expptr p;
 
   switch (type)
     {
     case TYSHORT:
 {
   register expptr p;
 
   switch (type)
     {
     case TYSHORT:

-      p = cshort(const);
+      p = cshort(constant);

       break;
 
     case TYLONG:
       break;
 
     case TYLONG:

-      p = clong(const);
+      p = clong(constant);

       break;
 
     case TYREAL:
       break;
 
     case TYREAL:

-      p = creal(const);
+      p = creal(constant);

       break;
 
     case TYDREAL:
       break;
 
     case TYDREAL:

-      p = cdreal(const);
+      p = cdreal(constant);

       break;
 
     case TYCOMPLEX:
       break;
 
     case TYCOMPLEX:

-      p = ccomplex(const);
+      p = ccomplex(constant);

       break;
 
     case TYDCOMPLEX:
       break;
 
     case TYDCOMPLEX:

-      p = cdcomplex(const);
+      p = cdcomplex(constant);

       break;
 
     case TYLOGICAL:
       break;
 
     case TYLOGICAL:

-      p = clogical(const);
+      p = clogical(constant);

       break;
 
     case TYCHAR:
       break;
 
     case TYCHAR:

-      p = cchar(len, const);
+      p = cchar(len, constant);

       break;
 
     case TYERROR:
       break;
 
     case TYERROR:

diff --git a/usr/src/usr.bin/f77/pass1.tahoe/data.c b/usr/src/usr.bin/f77/pass1.tahoe/data.c
index 6ad682a..ddfc571 100644 (file)
--- a/usr/src/usr.bin/f77/pass1.tahoe/data.c
+++ b/usr/src/usr.bin/f77/pass1.tahoe/data.c
@@ -714,12 +714,12 @@ vexpr *dp;
   else
     {
       if ((MAXINT + MININT == -1)
   else
     {
       if ((MAXINT + MININT == -1)

-         && tp->paramval->constblock.const.ci == MININT)
+         && tp->paramval->constblock.constant.ci == MININT)

        p->status = MINLESS1;
       else
        {
          p->status = NORMAL;
        p->status = MINLESS1;
       else
        {
          p->status = NORMAL;

-          p->value = tp->paramval->constblock.const.ci;
+          p->value = tp->paramval->constblock.constant.ci;

        }
     }
 
        }
     }
 


@@ -1672,7 +1672,7 @@ char *sname;
                  t = ALLOC(Dvalue);
                  t->tag = DVALUE;
                  t->status = NORMAL;
                  t = ALLOC(Dvalue);
                  t->tag = DVALUE;
                  t->status = NORMAL;

-                 t->value = np->vleng->constblock.const.ci;
+                 t->value = np->vleng->constblock.constant.ci;

                  rp->high = (vexpr *) t;
                }
            }
                  rp->high = (vexpr *) t;
                }
            }


@@ -1870,13 +1870,13 @@ aelt *ap;
   index = sub[--i];
   while (i-- > 0)
     {
   index = sub[--i];
   while (i-- > 0)
     {

-      size = dp->dims[i].dimsize->constblock.const.ci;
+      size = dp->dims[i].dimsize->constblock.constant.ci;

       index = sub[i] + index * size;
     }
 
       index = sub[i] + index * size;
     }
 

-  index -= dp->baseoffset->constblock.const.ci;
+  index -= dp->baseoffset->constblock.constant.ci;

 
 

-  if (index < 0 || index >= dp->nelt->constblock.const.ci)
+  if (index < 0 || index >= dp->nelt->constblock.constant.ci)

     {
       err(boundserror);
       return (-1);
     {
       err(boundserror);
       return (-1);


@@ -1952,12 +1952,12 @@ register Namep np;
          np->init = YES;
          np->initoffset = base = vdatahwm;
          if (np->vdim != NULL)
          np->init = YES;
          np->initoffset = base = vdatahwm;
          if (np->vdim != NULL)

-           nelt = np->vdim->nelt->constblock.const.ci;
+           nelt = np->vdim->nelt->constblock.constant.ci;

          else
            nelt = 1;
          type = np->vtype;
          if (type == TYCHAR)
          else
            nelt = 1;
          type = np->vtype;
          if (type == TYCHAR)

-           typelen = np->vleng->constblock.const.ci;
+           typelen = np->vleng->constblock.constant.ci;

          else if (type == TYLOGICAL)
            typelen = typesize[tylogical];
          else
          else if (type == TYLOGICAL)
            typelen = typesize[tylogical];
          else


@@ -2002,11 +2002,11 @@ register Namep np;
 
 \f
 
 
 \f
 

-wrtdata(offset, repl, len, const)
+wrtdata(offset, repl, len, constant)

 long offset;
 ftnint repl;
 ftnint len;
 long offset;
 ftnint repl;
 ftnint len;

-char *const;
+char *constant;

 {
   static char *badoffset = "bad offset in wrtdata";
   static char *toomuch = "too much data";
 {
   static char *badoffset = "bad offset in wrtdata";
   static char *toomuch = "too much data";


@@ -2168,7 +2168,7 @@ char *const;
       k = len;
 
       while (k > 0 && allzero != NO)
       k = len;
 
       while (k > 0 && allzero != NO)

-       if (const[--k] != 0) allzero = NO;
+       if (constant[--k] != 0) allzero = NO;

 
       if (allzero == YES)
        return;
 
       if (allzero == YES)
        return;


@@ -2184,7 +2184,7 @@ char *const;
   k = repl;
   while (k-- > 0)
     {
   k = repl;
   while (k-- > 0)
     {

-      nbytes = write(datafile, const, len);
+      nbytes = write(datafile, constant, len);

       if (nbytes != len)
        {
          err(writeerror);
       if (nbytes != len)
        {
          err(writeerror);


@@ -2268,7 +2268,7 @@ aelt *ap;
   register long soffset;
   register dvalue *lwb;
   register dvalue *upb;
   register long soffset;
   register dvalue *lwb;
   register dvalue *upb;

-  register Constp const;
+  register Constp constant;

   register int k;
   register vallist *t;
   register int type;
   register int k;
   register vallist *t;
   register int type;


@@ -2283,7 +2283,7 @@ aelt *ap;
   type = np->vtype;
 
   if (type == TYCHAR)
   type = np->vtype;
 
   if (type == TYCHAR)

-    typelen = np->vleng->constblock.const.ci;
+    typelen = np->vleng->constblock.constant.ci;

   else if (type == TYLOGICAL)
     typelen = typesize[tylogical];
   else
   else if (type == TYLOGICAL)
     typelen = typesize[tylogical];
   else


@@ -2341,28 +2341,28 @@ aelt *ap;
          frvexpr((vexpr *) upb);
        }
 
          frvexpr((vexpr *) upb);
        }
 

-      const = getdatum();
-      if (const == NULL || !ISCONST(const))
+      constant = getdatum();
+      if (constant == NULL || !ISCONST(constant))

        return;
 
        return;
 

-      const = (Constp) convconst(type, typelen, const);
-      if (const == NULL || !ISCONST(const))
+      constant = (Constp) convconst(type, typelen, constant);
+      if (constant == NULL || !ISCONST(constant))

        {
        {

-         frexpr((tagptr) const);
+         frexpr((tagptr) constant);

          return;
        }
 
       if (type == TYCHAR)
          return;
        }
 
       if (type == TYCHAR)

-       wrtdata(base + soffset, 1, typelen, const->const.ccp);
+       wrtdata(base + soffset, 1, typelen, constant->constant.ccp);

       else
       else

-       wrtdata(base + soffset, 1, typelen, packbytes(const));
+       wrtdata(base + soffset, 1, typelen, packbytes(constant));

 
 

-      frexpr((tagptr) const);
+      frexpr((tagptr) constant);

     }
   else
     {
       soffset = 0;
     }
   else
     {
       soffset = 0;

-      k = np->vdim->nelt->constblock.const.ci;
+      k = np->vdim->nelt->constblock.constant.ci;

       while (k > 0 && dataerror == NO)
        {
          if (grvals == NULL)
       while (k > 0 && dataerror == NO)
        {
          if (grvals == NULL)


@@ -2382,18 +2382,18 @@ aelt *ap;
            }
          else
            {
            }
          else
            {

-             const = grvals->value;
-             if (const == NULL || !ISCONST(const))
+             constant = grvals->value;
+             if (constant == NULL || !ISCONST(constant))

                {
                  dataerror = YES;
                }
              else
                {
                {
                  dataerror = YES;
                }
              else
                {

-                 const = (Constp) convconst(type, typelen, const);
-                 if (const == NULL || !ISCONST(const))
+                 constant = (Constp) convconst(type, typelen, constant);
+                 if (constant == NULL || !ISCONST(constant))

                    {
                      dataerror = YES;
                    {
                      dataerror = YES;

-                     frexpr((tagptr) const);
+                     frexpr((tagptr) constant);

                    }
                  else
                    {
                    }
                  else
                    {


@@ -2406,13 +2406,15 @@ aelt *ap;
                      k -= repl;
 
                      if (type == TYCHAR)
                      k -= repl;
 
                      if (type == TYCHAR)

-                       wrtdata(base+soffset, repl, typelen, const->const.ccp);
+                       wrtdata(base+soffset, repl, typelen,
+                           constant->constant.ccp);

                      else
                      else

-                       wrtdata(base+soffset, repl, typelen, packbytes(const));
+                       wrtdata(base+soffset, repl, typelen,
+                           packbytes(constant));

 
                      soffset = soffset + repl * typelen;
 
 
                      soffset = soffset + repl * typelen;
 

-                     frexpr((tagptr) const);
+                     frexpr((tagptr) constant);

                    }
                }
            }
                    }
                }
            }

diff --git a/usr/src/usr.bin/f77/pass1.tahoe/defs.h b/usr/src/usr.bin/f77/pass1.tahoe/defs.h
index d20f7ea..aca23e9 100644 (file)
--- a/usr/src/usr.bin/f77/pass1.tahoe/defs.h
+++ b/usr/src/usr.bin/f77/pass1.tahoe/defs.h
@@ -359,7 +359,7 @@ struct Constblock
        field vclass;
        field vstg;
        expptr vleng;
        field vclass;
        field vstg;
        expptr vleng;

-       union Constant const;
+       union Constant constant;

        };
 
 
        };
 
 

diff --git a/usr/src/usr.bin/f77/pass1.tahoe/equiv.c b/usr/src/usr.bin/f77/pass1.tahoe/equiv.c
index 93deaa6..751d1ab 100644 (file)
--- a/usr/src/usr.bin/f77/pass1.tahoe/equiv.c
+++ b/usr/src/usr.bin/f77/pass1.tahoe/equiv.c
@@ -83,7 +83,7 @@ for(i = 0 ; i < nequiv ; ++i)
 
                        offp = suboffset(itemp);
                        if(ISICON(offp))
 
                        offp = suboffset(itemp);
                        if(ISICON(offp))

-                               offset = offp->constblock.const.ci;
+                               offset = offp->constblock.constant.ci;

                        else    {
                                dclerr("illegal subscript in equivalence ",
                                        np);
                        else    {
                                dclerr("illegal subscript in equivalence ",
                                        np);

diff --git a/usr/src/usr.bin/f77/pass1.tahoe/exec.c b/usr/src/usr.bin/f77/pass1.tahoe/exec.c
index 66970c6..f866c64 100644 (file)
--- a/usr/src/usr.bin/f77/pass1.tahoe/exec.c
+++ b/usr/src/usr.bin/f77/pass1.tahoe/exec.c
@@ -353,11 +353,11 @@ if(p)
                }
        else if( ISINT(p->constblock.vtype) )
                {
                }
        else if( ISINT(p->constblock.vtype) )
                {

-               q = convic(p->constblock.const.ci);
+               q = convic(p->constblock.constant.ci);

                n = strlen(q);
                if(n > 0)
                        {
                n = strlen(q);
                if(n > 0)
                        {

-                       p->constblock.const.ccp = copyn(n, q);
+                       p->constblock.constant.ccp = copyn(n, q);

                        p->constblock.vtype = TYCHAR;
                        p->constblock.vleng = (expptr) ICON(n);
                        }
                        p->constblock.vtype = TYCHAR;
                        p->constblock.vleng = (expptr) ICON(n);
                        }


@@ -385,9 +385,9 @@ else
 #define DOLIMIT        par[1]
 #define DOINCR par[2]
 
 #define DOLIMIT        par[1]
 #define DOINCR par[2]
 

-#define CONSTINIT  const[0]
-#define CONSTLIMIT const[1]
-#define CONSTINCR  const[2]
+#define CONSTINIT  constant[0]
+#define CONSTLIMIT constant[1]
+#define CONSTINCR  constant[2]

 
 #define VARSTEP        0
 #define POSSTEP        1
 
 #define VARSTEP        0
 #define POSSTEP        1


@@ -407,7 +407,7 @@ chainp spec;
   int dotype, incsign;
   Addrp dovarp, dostgp;
   expptr par[3];
   int dotype, incsign;
   Addrp dovarp, dostgp;
   expptr par[3];

-  expptr const[3];
+  expptr constant[3];

   Slotp doslot;
 
   pushctl(CTLDO);
   Slotp doslot;
 
   pushctl(CTLDO);


@@ -441,11 +441,11 @@ chainp spec;
 
 
       if (ISCONST(q))
 
 
       if (ISCONST(q))

-       const[i] = mkconv(dotype, q);
+       constant[i] = mkconv(dotype, q);

       else
        {
          frexpr(q);
       else
        {
          frexpr(q);

-         const[i] = NULL;
+         constant[i] = NULL;

        }
 
       par[i++] = mkconv(dotype, p);
        }
 
       par[i++] = mkconv(dotype, p);

diff --git a/usr/src/usr.bin/f77/pass1.tahoe/expr.c b/usr/src/usr.bin/f77/pass1.tahoe/expr.c
index fc2be14..232203b 100644 (file)
--- a/usr/src/usr.bin/f77/pass1.tahoe/expr.c
+++ b/usr/src/usr.bin/f77/pass1.tahoe/expr.c
@@ -137,7 +137,7 @@ register int l;
 register Constp  p;
 
 p = mkconst(TYLOGICAL);
 register Constp  p;
 
 p = mkconst(TYLOGICAL);

-p->const.ci = l;
+p->constant.ci = l;

 return( (expptr) p );
 }
 
 return( (expptr) p );
 }
 


@@ -160,7 +160,7 @@ if(tyint == TYSHORT)
 else
   usetype = tyint;
 p = mkconst(usetype);
 else
   usetype = tyint;
 p = mkconst(usetype);

-p->const.ci = l;
+p->constant.ci = l;

 return( (expptr) p );
 }
 
 return( (expptr) p );
 }
 


@@ -172,7 +172,7 @@ register int l;
 register Constp p;
 
 p = mkconst(TYADDR);
 register Constp p;
 
 p = mkconst(TYADDR);

-p->const.ci = l;
+p->constant.ci = l;

 return( (expptr) p );
 }
 
 return( (expptr) p );
 }
 


@@ -185,7 +185,7 @@ double d;
 register Constp p;
 
 p = mkconst(t);
 register Constp p;
 
 p = mkconst(t);

-p->const.cd[0] = d;
+p->constant.cd[0] = d;

 return( (expptr) p );
 }
 
 return( (expptr) p );
 }
 


@@ -237,7 +237,7 @@ register char *s;
 
   p = mkconst(TYBITSTR);
   p->vleng = ICON(size);
 
   p = mkconst(TYBITSTR);
   p->vleng = ICON(size);

-  p->const.ccp = bp;
+  p->constant.ccp = bp;

 
   return ((expptr) p);
 }
 
   return ((expptr) p);
 }


@@ -253,7 +253,7 @@ register char *s;
 
 p = mkconst(TYCHAR);
 p->vleng = ICON(l);
 
 p = mkconst(TYCHAR);
 p->vleng = ICON(l);

-p->const.ccp = s = (char *) ckalloc(l);
+p->constant.ccp = s = (char *) ckalloc(l);

 while(--l >= 0)
        *s++ = *v++;
 return( (expptr) p );
 while(--l >= 0)
        *s++ = *v++;
 return( (expptr) p );


@@ -273,11 +273,11 @@ if( ISCONST(realp) && ISNUMERIC(rtype) && ISCONST(imagp) && ISNUMERIC(itype) )
        {
        p = mkconst( (rtype==TYDREAL||itype==TYDREAL) ? TYDCOMPLEX : TYCOMPLEX);
        if( ISINT(rtype) )
        {
        p = mkconst( (rtype==TYDREAL||itype==TYDREAL) ? TYDCOMPLEX : TYCOMPLEX);
        if( ISINT(rtype) )

-               p->const.cd[0] = realp->constblock.const.ci;
-       else    p->const.cd[0] = realp->constblock.const.cd[0];
+               p->constant.cd[0] = realp->constblock.constant.ci;
+       else    p->constant.cd[0] = realp->constblock.constant.cd[0];

        if( ISINT(itype) )
        if( ISINT(itype) )

-               p->const.cd[1] = imagp->constblock.const.ci;
-       else    p->const.cd[1] = imagp->constblock.const.cd[0];
+               p->constant.cd[1] = imagp->constblock.constant.ci;
+       else    p->constant.cd[1] = imagp->constblock.constant.cd[0];

        }
 else
        {
        }
 else
        {


@@ -349,8 +349,8 @@ if( pt == TYADDR && ISNUMERIC(t) )
 if( ISCONST(p) && pt!=TYADDR)
        {
        q = (expptr) mkconst(t);
 if( ISCONST(p) && pt!=TYADDR)
        {
        q = (expptr) mkconst(t);

-       consconv(t, &(q->constblock.const),
-               p->constblock.vtype, &(p->constblock.const) );
+       consconv(t, &(q->constblock.constant),
+               p->constblock.vtype, &(p->constblock.constant) );

        frexpr(p);
        }
 #if TARGET == PDP11
        frexpr(p);
        }
 #if TARGET == PDP11


@@ -389,8 +389,8 @@ if(t == pt)
 else if( ISCONST(p) && pt!=TYADDR)
        {
        q = (expptr) mkconst(t);
 else if( ISCONST(p) && pt!=TYADDR)
        {
        q = (expptr) mkconst(t);

-       consconv(t, &(q->constblock.const),
-               p->constblock.vtype, &(p->constblock.const) );
+       consconv(t, &(q->constblock.constant),
+               p->constblock.vtype, &(p->constblock.constant) );

        frexpr(p);
        }
 #if TARGET == PDP11
        frexpr(p);
        }
 #if TARGET == PDP11


@@ -465,9 +465,9 @@ switch(tag)
        case TCONST:
                if(e->constblock.vtype == TYCHAR)
                        {
        case TCONST:
                if(e->constblock.vtype == TYCHAR)
                        {

-                       e->constblock.const.ccp =
-                               copyn(1+strlen(e->constblock.const.ccp),
-                                       e->constblock.const.ccp);
+                       e->constblock.constant.ccp =
+                               copyn(1+strlen(e->constblock.constant.ccp),
+                                       e->constblock.constant.ccp);

                        e->constblock.vleng =
                                (expptr) cpexpr(e->constblock.vleng);
                        }
                        e->constblock.vleng =
                                (expptr) cpexpr(e->constblock.vleng);
                        }


@@ -531,7 +531,7 @@ switch(p->tag)
                        case TYBITSTR:
                        case TYCHAR:
                        case TYHOLLERITH:
                        case TYBITSTR:
                        case TYCHAR:
                        case TYHOLLERITH:

-                               free( (charptr) (p->constblock.const.ccp) );
+                               free( (charptr) (p->constblock.constant.ccp) );

                                frexpr(p->constblock.vleng);
                        }
                break;
                                frexpr(p->constblock.vleng);
                        }
                break;


@@ -1494,10 +1494,11 @@ checkvar = NULL;
 checkcond = NULL;
 if( ISICON(p) )
        {
 checkcond = NULL;
 if( ISICON(p) )
        {

-       if(p->constblock.const.ci < 0)
+       if(p->constblock.constant.ci < 0)

                goto badsub;
        if( ISICON(dimp->nelt) )
                goto badsub;
        if( ISICON(dimp->nelt) )

-               if(p->constblock.const.ci < dimp->nelt->constblock.const.ci)
+               if(p->constblock.constant.ci <
+                   dimp->nelt->constblock.constant.ci)

                        return(p);
                else
                        goto badsub;
                        return(p);
                else
                        goto badsub;


@@ -1578,7 +1579,7 @@ switch( p->vstg)
                        {
                        t->vleng = (expptr) cpexpr(p->vleng);
                        if( ISICON(t->vleng) )
                        {
                        t->vleng = (expptr) cpexpr(p->vleng);
                        if( ISICON(t->vleng) )

-                               t->varleng = t->vleng->constblock.const.ci;
+                               t->varleng = t->vleng->constblock.constant.ci;

                        }
                if (p->vstg == STGBSS)
                        t->varsize = p->varsize;
                        }
                if (p->vstg == STGBSS)
                        t->varsize = p->varsize;


@@ -1707,7 +1708,7 @@ switch(v->vstg)
                        {
                        neltp = t->nelt;
                        if (neltp && ISICON(neltp))
                        {
                        neltp = t->nelt;
                        if (neltp && ISICON(neltp))

-                               nelt = neltp->constblock.const.ci;
+                               nelt = neltp->constblock.constant.ci;

                        else
                                dclerr("improperly dimensioned array", v);
                        }
                        else
                                dclerr("improperly dimensioned array", v);
                        }


@@ -1719,7 +1720,7 @@ switch(v->vstg)
                                eltsize = typesize[TYCHAR];
                        else if (ISICON(v->vleng))
                                eltsize = typesize[TYCHAR] *
                                eltsize = typesize[TYCHAR];
                        else if (ISICON(v->vleng))
                                eltsize = typesize[TYCHAR] *

-                                       v->vleng->constblock.const.ci;
+                                       v->vleng->constblock.constant.ci;

                        else if (v->vleng->tag != TERROR)
                                {
                                errstr("nonconstant string length on %s",
                        else if (v->vleng->tag != TERROR)
                                {
                                errstr("nonconstant string length on %s",


@@ -1738,12 +1739,12 @@ switch(v->vstg)
                nelt = 1;
                if(t = v->vdim)
                        if( (neltp = t->nelt) && ISCONST(neltp) )
                nelt = 1;
                if(t = v->vdim)
                        if( (neltp = t->nelt) && ISCONST(neltp) )

-                               nelt = neltp->constblock.const.ci;
+                               nelt = neltp->constblock.constant.ci;

                        else
                                dclerr("adjustable automatic array", v);
                p = autovar(nelt, v->vtype, v->vleng);
                v->vardesc.varno = p->memno;
                        else
                                dclerr("adjustable automatic array", v);
                p = autovar(nelt, v->vtype, v->vleng);
                v->vardesc.varno = p->memno;

-               v->voffset = p->memoffset->constblock.const.ci;
+               v->voffset = p->memoffset->constblock.constant.ci;

                frexpr(p);
                break;
 
                frexpr(p);
                break;
 


@@ -1793,7 +1794,7 @@ if( isupper(c) )
 return(c - 'a');
 }
 \f
 return(c - 'a');
 }
 \f

-#define ICONEQ(z, c)  (ISICON(z) && z->constblock.const.ci==c)
+#define ICONEQ(z, c)  (ISICON(z) && z->constblock.constant.ci==c)

 #define COMMUTE        { e = lp;  lp = rp;  rp = e; }
 
 
 #define COMMUTE        { e = lp;  lp = rp;  rp = e; }
 
 


@@ -1851,7 +1852,7 @@ switch(opcode)
 
                if( ISICON(rp) )
                        {
 
                if( ISICON(rp) )
                        {

-                       if(rp->constblock.const.ci == 0)
+                       if(rp->constblock.constant.ci == 0)

                                {
                                if(etype == TYUNKNOWN)
                                        break;
                                {
                                if(etype == TYUNKNOWN)
                                        break;


@@ -1891,10 +1892,10 @@ switch(opcode)
        mulop:
                if( ISICON(rp) )
                        {
        mulop:
                if( ISICON(rp) )
                        {

-                       if(rp->constblock.const.ci == 1)
+                       if(rp->constblock.constant.ci == 1)

                                goto retleft;
 
                                goto retleft;
 

-                       if(rp->constblock.const.ci == -1)
+                       if(rp->constblock.constant.ci == -1)

                                {
                                frexpr(rp);
                                return( mkexpr(OPNEG, lp, PNULL) );
                                {
                                frexpr(rp);
                                return( mkexpr(OPNEG, lp, PNULL) );


@@ -1906,8 +1907,8 @@ switch(opcode)
                        if(opcode == OPSTAR)
                                e = mkexpr(OPSTAR, lp->exprblock.rightp, rp);
                        else  if(ISICON(rp) &&
                        if(opcode == OPSTAR)
                                e = mkexpr(OPSTAR, lp->exprblock.rightp, rp);
                        else  if(ISICON(rp) &&

-                               (lp->exprblock.rightp->constblock.const.ci %
-                                       rp->constblock.const.ci) == 0)
+                               (lp->exprblock.rightp->constblock.constant.ci %
+                                       rp->constblock.constant.ci) == 0)

                                e = mkexpr(OPSLASH, lp->exprblock.rightp, rp);
                        else    break;
 
                                e = mkexpr(OPSLASH, lp->exprblock.rightp, rp);
                        else    break;
 


@@ -1939,7 +1940,7 @@ switch(opcode)
        addop:
                if( ISICON(rp) )
                        {
        addop:
                if( ISICON(rp) )
                        {

-                       if(rp->constblock.const.ci == 0)
+                       if(rp->constblock.constant.ci == 0)

                                goto retleft;
                        if( ISPLUSOP(lp) && ISICON(lp->exprblock.rightp) )
                                {
                                goto retleft;
                        if( ISPLUSOP(lp) && ISICON(lp->exprblock.rightp) )
                                {


@@ -1990,7 +1991,7 @@ switch(opcode)
 
                if( ISCONST(rp) )
                        {
 
                if( ISCONST(rp) )
                        {

-                       if(rp->constblock.const.ci == 0)
+                       if(rp->constblock.constant.ci == 0)

                                if(opcode == OPOR)
                                        goto retleft;
                                else
                                if(opcode == OPOR)
                                        goto retleft;
                                else


@@ -2003,7 +2004,7 @@ switch(opcode)
        case OPLSHIFT:
                if (ISICON(rp))
                        {
        case OPLSHIFT:
                if (ISICON(rp))
                        {

-                       if (rp->constblock.const.ci == 0)
+                       if (rp->constblock.constant.ci == 0)

                                goto retleft;
                        if ((lp->tag == TEXPR) &&
                            ((lp->exprblock.opcode == OPPLUS) ||
                                goto retleft;
                        if ((lp->tag == TEXPR) &&
                            ((lp->exprblock.opcode == OPPLUS) ||


@@ -2233,11 +2234,13 @@ if(rp == 0)
        switch(opcode)
                {
                case OPNOT:
        switch(opcode)
                {
                case OPNOT:

-                       lp->constblock.const.ci = ! lp->constblock.const.ci;
+                       lp->constblock.constant.ci =
+                           ! lp->constblock.constant.ci;

                        return(lp);
 
                case OPBITNOT:
                        return(lp);
 
                case OPBITNOT:

-                       lp->constblock.const.ci = ~ lp->constblock.const.ci;
+                       lp->constblock.constant.ci =
+                           ~ lp->constblock.constant.ci;

                        return(lp);
 
                case OPNEG:
                        return(lp);
 
                case OPNEG:


@@ -2268,59 +2271,59 @@ switch(opcode)
                return(e);
 
        case OPAND:
                return(e);
 
        case OPAND:

-               p->const.ci = lp->constblock.const.ci &&
-                               rp->constblock.const.ci;
+               p->constant.ci = lp->constblock.constant.ci &&
+                               rp->constblock.constant.ci;

                break;
 
        case OPOR:
                break;
 
        case OPOR:

-               p->const.ci = lp->constblock.const.ci ||
-                               rp->constblock.const.ci;
+               p->constant.ci = lp->constblock.constant.ci ||
+                               rp->constblock.constant.ci;

                break;
 
        case OPEQV:
                break;
 
        case OPEQV:

-               p->const.ci = lp->constblock.const.ci ==
-                               rp->constblock.const.ci;
+               p->constant.ci = lp->constblock.constant.ci ==
+                               rp->constblock.constant.ci;

                break;
 
        case OPNEQV:
                break;
 
        case OPNEQV:

-               p->const.ci = lp->constblock.const.ci !=
-                               rp->constblock.const.ci;
+               p->constant.ci = lp->constblock.constant.ci !=
+                               rp->constblock.constant.ci;

                break;
 
        case OPBITAND:
                break;
 
        case OPBITAND:

-               p->const.ci = lp->constblock.const.ci &
-                               rp->constblock.const.ci;
+               p->constant.ci = lp->constblock.constant.ci &
+                               rp->constblock.constant.ci;

                break;
 
        case OPBITOR:
                break;
 
        case OPBITOR:

-               p->const.ci = lp->constblock.const.ci |
-                               rp->constblock.const.ci;
+               p->constant.ci = lp->constblock.constant.ci |
+                               rp->constblock.constant.ci;

                break;
 
        case OPBITXOR:
                break;
 
        case OPBITXOR:

-               p->const.ci = lp->constblock.const.ci ^
-                               rp->constblock.const.ci;
+               p->constant.ci = lp->constblock.constant.ci ^
+                               rp->constblock.constant.ci;

                break;
 
        case OPLSHIFT:
                break;
 
        case OPLSHIFT:

-               p->const.ci = lp->constblock.const.ci <<
-                               rp->constblock.const.ci;
+               p->constant.ci = lp->constblock.constant.ci <<
+                               rp->constblock.constant.ci;

                break;
 
        case OPRSHIFT:
                break;
 
        case OPRSHIFT:

-               p->const.ci = lp->constblock.const.ci >>
-                               rp->constblock.const.ci;
+               p->constant.ci = lp->constblock.constant.ci >>
+                               rp->constblock.constant.ci;

                break;
 
        case OPCONCAT:
                break;
 
        case OPCONCAT:

-               ll = lp->constblock.vleng->constblock.const.ci;
-               lr = rp->constblock.vleng->constblock.const.ci;
-               p->const.ccp = q = (char *) ckalloc(ll+lr);
+               ll = lp->constblock.vleng->constblock.constant.ci;
+               lr = rp->constblock.vleng->constblock.constant.ci;
+               p->constant.ccp = q = (char *) ckalloc(ll+lr);

                p->vleng = ICON(ll+lr);
                p->vleng = ICON(ll+lr);

-               s = lp->constblock.const.ccp;
+               s = lp->constblock.constant.ccp;

                for(i = 0 ; i < ll ; ++i)
                        *q++ = *s++;
                for(i = 0 ; i < ll ; ++i)
                        *q++ = *s++;

-               s = rp->constblock.const.ccp;
+               s = rp->constblock.constant.ccp;

                for(i = 0; i < lr; ++i)
                        *q++ = *s++;
                break;
                for(i = 0; i < lr; ++i)
                        *q++ = *s++;
                break;


@@ -2329,26 +2332,28 @@ switch(opcode)
        case OPPOWER:
                if( ! ISINT(rtype) )
                        return(e);
        case OPPOWER:
                if( ! ISINT(rtype) )
                        return(e);

-               conspower(&(p->const), lp, rp->constblock.const.ci);
+               conspower(&(p->constant), lp, rp->constblock.constant.ci);

                break;
 
 
        default:
                if(ltype == TYCHAR)
                        {
                break;
 
 
        default:
                if(ltype == TYCHAR)
                        {

-                       lcon.ci = cmpstr(lp->constblock.const.ccp,
-                                       rp->constblock.const.ccp,
-                                       lp->constblock.vleng->constblock.const.ci,
-                                       rp->constblock.vleng->constblock.const.ci);
+                       lcon.ci = cmpstr(lp->constblock.constant.ccp,
+                               rp->constblock.constant.ccp,
+                               lp->constblock.vleng->constblock.constant.ci,
+                               rp->constblock.vleng->constblock.constant.ci);

                        rcon.ci = 0;
                        mtype = tyint;
                        }
                else    {
                        mtype = maxtype(ltype, rtype);
                        rcon.ci = 0;
                        mtype = tyint;
                        }
                else    {
                        mtype = maxtype(ltype, rtype);

-                       consconv(mtype, &lcon, ltype, &(lp->constblock.const) );
-                       consconv(mtype, &rcon, rtype, &(rp->constblock.const) );
+                       consconv(mtype, &lcon, ltype,
+                               &(lp->constblock.constant) );
+                       consconv(mtype, &rcon, rtype,
+                               &(rp->constblock.constant) );

                        }
                        }

-               consbinop(opcode, mtype, &(p->const), &lcon, &rcon);
+               consbinop(opcode, mtype, &(p->constant), &lcon, &rcon);

                break;
        }
 
                break;
        }
 


@@ -2423,16 +2428,16 @@ switch(p->vtype)
        {
        case TYSHORT:
        case TYLONG:
        {
        case TYSHORT:
        case TYLONG:

-               p->const.ci = - p->const.ci;
+               p->constant.ci = - p->constant.ci;

                break;
 
        case TYCOMPLEX:
        case TYDCOMPLEX:
                break;
 
        case TYCOMPLEX:
        case TYDCOMPLEX:

-               p->const.cd[1] = - p->const.cd[1];
+               p->constant.cd[1] = - p->constant.cd[1];

                /* fall through and do the real parts */
        case TYREAL:
        case TYDREAL:
                /* fall through and do the real parts */
        case TYREAL:
        case TYDREAL:

-               p->const.cd[0] = - p->const.cd[0];
+               p->constant.cd[0] = - p->constant.cd[0];

                break;
        default:
                badtype("consnegop", p->vtype);
                break;
        default:
                badtype("consnegop", p->vtype);


@@ -2472,11 +2477,11 @@ if(n < 0)
        {
        if( ISINT(type) )
                {
        {
        if( ISINT(type) )
                {

-               if (ap->const.ci == 0)
+               if (ap->constant.ci == 0)

                        err("zero raised to a negative power");
                        err("zero raised to a negative power");

-               else if (ap->const.ci == 1)
+               else if (ap->constant.ci == 1)

                        return;
                        return;

-               else if (ap->const.ci == -1)
+               else if (ap->constant.ci == -1)

                        {
                        if (n < -2)
                                n = n + 2;
                        {
                        if (n < -2)
                                n = n + 2;


@@ -2489,10 +2494,10 @@ if(n < 0)
                return;
                }
        n = - n;
                return;
                }
        n = - n;

-       consbinop(OPSLASH, type, &x, powp, &(ap->const));
+       consbinop(OPSLASH, type, &x, powp, &(ap->constant));

        }
 else
        }
 else

-       consbinop(OPSTAR, type, &x, powp, &(ap->const));
+       consbinop(OPSTAR, type, &x, powp, &(ap->constant));

 
 for( ; ; )
        {
 
 for( ; ; )
        {


@@ -2669,19 +2674,20 @@ switch(p->headblock.vtype)
        {
        case TYSHORT:
        case TYLONG:
        {
        case TYSHORT:
        case TYLONG:

-               if(p->constblock.const.ci > 0) return(1);
-               if(p->constblock.const.ci < 0) return(-1);
+               if(p->constblock.constant.ci > 0) return(1);
+               if(p->constblock.constant.ci < 0) return(-1);

                return(0);
 
        case TYREAL:
        case TYDREAL:
                return(0);
 
        case TYREAL:
        case TYDREAL:

-               if(p->constblock.const.cd[0] > 0) return(1);
-               if(p->constblock.const.cd[0] < 0) return(-1);
+               if(p->constblock.constant.cd[0] > 0) return(1);
+               if(p->constblock.constant.cd[0] < 0) return(-1);

                return(0);
 
        case TYCOMPLEX:
        case TYDCOMPLEX:
                return(0);
 
        case TYCOMPLEX:
        case TYDCOMPLEX:

-               return(p->constblock.const.cd[0]!=0 || p->constblock.const.cd[1]!=0);
+               return(p->constblock.constant.cd[0]!=0 ||
+                       p->constblock.constant.cd[1]!=0);

 
        default:
                badtype( "conssgn", p->constblock.vtype);
 
        default:
                badtype( "conssgn", p->constblock.vtype);


@@ -2705,7 +2711,7 @@ rtype = rp->headblock.vtype;
 
 if(ISICON(rp))
        {
 
 if(ISICON(rp))
        {

-       if(rp->constblock.const.ci == 0)
+       if(rp->constblock.constant.ci == 0)

                {
                frexpr(p);
                if( ISINT(ltype) )
                {
                frexpr(p);
                if( ISINT(ltype) )


@@ -2717,7 +2723,7 @@ if(ISICON(rp))
                        return( pp );
                        }
                }
                        return( pp );
                        }
                }

-       if(rp->constblock.const.ci < 0)
+       if(rp->constblock.constant.ci < 0)

                {
                if( ISINT(ltype) )
                        {
                {
                if( ISINT(ltype) )
                        {


@@ -2725,10 +2731,10 @@ if(ISICON(rp))
                        err("integer**negative");
                        return( errnode() );
                        }
                        err("integer**negative");
                        return( errnode() );
                        }

-               rp->constblock.const.ci = - rp->constblock.const.ci;
+               rp->constblock.constant.ci = - rp->constblock.constant.ci;

                p->exprblock.leftp = lp = fixexpr(mkexpr(OPSLASH, ICON(1), lp));
                }
                p->exprblock.leftp = lp = fixexpr(mkexpr(OPSLASH, ICON(1), lp));
                }

-       if(rp->constblock.const.ci == 1)
+       if(rp->constblock.constant.ci == 1)

                {
                frexpr(rp);
                free( (charptr) p );
                {
                frexpr(rp);
                free( (charptr) p );


@@ -2812,7 +2818,7 @@ expptr e;
        if (! ISCONST (e))
                return (0);
 
        if (! ISCONST (e))
                return (0);
 

-       val = e->constblock.const.ci;
+       val = e->constblock.constant.ci;

        switch (val)
                {
                case 2:         res = 1; break;
        switch (val)
                {
                case 2:         res = 1; break;

diff --git a/usr/src/usr.bin/f77/pass1.tahoe/intr.c b/usr/src/usr.bin/f77/pass1.tahoe/intr.c
index 31a4a32..4cf69ce 100644 (file)
--- a/usr/src/usr.bin/f77/pass1.tahoe/intr.c
+++ b/usr/src/usr.bin/f77/pass1.tahoe/intr.c
@@ -25,7 +25,7 @@ static char sccsid[] = "@(#)intr.c    5.1 (Berkeley) 6/7/85";
  * Changes to distinguish explicit from implicit conversions with intrconv().
  * 
  * Revision 1.2  84/12/15  01:02:33  donn
  * Changes to distinguish explicit from implicit conversions with intrconv().
  * 
  * Revision 1.2  84/12/15  01:02:33  donn

- * Added a case for an integer*4 result from len() in inline().  Previously
+ * Added a case for an integer*4 result from len() in inlne().  Previously

  * only -i2 provoked len() inline, sigh.
  * 
  */
  * only -i2 provoked len() inline, sigh.
  * 
  */


@@ -450,7 +450,7 @@ int i, rettype;
 Addrp ap;
 register struct Specblock *sp;
 register struct Chain *cp;
 Addrp ap;
 register struct Specblock *sp;
 register struct Chain *cp;

-expptr inline(), mkcxcon(), mkrealcon();
+expptr inlne(), mkcxcon(), mkrealcon();

 register struct Incstblock *cstp;
 expptr q, ep;
 int mtype;
 register struct Incstblock *cstp;
 expptr q, ep;
 int mtype;


@@ -593,7 +593,7 @@ switch(f1field)
                if(mtype != sp->atype)
                        goto badtype;
                fixargs(YES, argsp);
                if(mtype != sp->atype)
                        goto badtype;
                fixargs(YES, argsp);

-               if(q = inline(sp-spectab, mtype, argsp->listp))
+               if(q = inlne(sp-spectab, mtype, argsp->listp))

                        {
                        frchain( &(argsp->listp) );
                        free( (charptr) argsp);
                        {
                        frchain( &(argsp->listp) );
                        free( (charptr) argsp);


@@ -721,7 +721,7 @@ fatali("intraddr: impossible f1=%d\n", (int) packed.bits.f1);
 
 
 
 
 
 

-expptr inline(fno, type, args)
+expptr inlne(fno, type, args)

 int fno;
 int type;
 struct Chain *args;
 int fno;
 int type;
 struct Chain *args;

diff --git a/usr/src/usr.bin/f77/pass1.tahoe/io.c b/usr/src/usr.bin/f77/pass1.tahoe/io.c
index af3bf9e..53d9eb6 100644 (file)
--- a/usr/src/usr.bin/f77/pass1.tahoe/io.c
+++ b/usr/src/usr.bin/f77/pass1.tahoe/io.c
@@ -240,13 +240,13 @@ ioerrlab = ioendlab = skiplab = jumplab = 0;
 
 if(p = V(IOSEND))
        if(ISICON(p))
 
 if(p = V(IOSEND))
        if(ISICON(p))

-               ioendlab = execlab(p->constblock.const.ci) ->labelno;
+               ioendlab = execlab(p->constblock.constant.ci) ->labelno;

        else
                err("bad end= clause");
 
 if(p = V(IOSERR))
        if(ISICON(p))
        else
                err("bad end= clause");
 
 if(p = V(IOSERR))
        if(ISICON(p))

-               ioerrlab = execlab(p->constblock.const.ci) ->labelno;
+               ioerrlab = execlab(p->constblock.constant.ci) ->labelno;

        else
                err("bad err= clause");
 
        else
                err("bad err= clause");
 


@@ -706,7 +706,7 @@ if(p = V(IOSFMT))
                }
        else if( ISICON(p) )
                {
                }
        else if( ISICON(p) )
                {

-               if( (k = fmtstmt( mklabel(p->constblock.const.ci) )) > 0 )
+               if( (k = fmtstmt( mklabel(p->constblock.constant.ci) )) > 0 )

                        {
                        fmtp = (Addrp) mkaddcon(k);
                        varfmt = NO;
                        {
                        fmtp = (Addrp) mkaddcon(k);
                        varfmt = NO;


@@ -929,14 +929,14 @@ register expptr p;
       if (!ISICON(q->memoffset))
        fatal(badoffset);
 
       if (!ISICON(q->memoffset))
        fatal(badoffset);
 

-      op = mkiodata(q->memno, q->memoffset->constblock.const.ci, blklen);
+      op = mkiodata(q->memno, q->memoffset->constblock.constant.ci, blklen);

       if (op->tag != 0)
        fatal(badoffset);
 
       if (type == TYADDR)
        {
          op->tag = NDLABEL;
       if (op->tag != 0)
        fatal(badoffset);
 
       if (type == TYADDR)
        {
          op->tag = NDLABEL;

-         op->val.label = p->constblock.const.ci;
+         op->val.label = p->constblock.constant.ci;

        }
       else
        {
        }
       else
        {


@@ -996,7 +996,7 @@ register Addrp p;
          op->tag = NDADDR;
          op->val.addr.stg = p->vstg;
          op->val.addr.memno = p->memno;
          op->tag = NDADDR;
          op->val.addr.stg = p->vstg;
          op->val.addr.memno = p->memno;

-         op->val.addr.offset = p->memoffset->constblock.const.ci;
+         op->val.addr.offset = p->memoffset->constblock.constant.ci;

        }
       else
        badtag("ioseta", p->tag);
        }
       else
        badtag("ioseta", p->tag);


@@ -1162,7 +1162,7 @@ register int len;
          type = cp->vtype;
          if (type != TYIOINT)
            badtype("outolist", type);
          type = cp->vtype;
          if (type != TYIOINT)
            badtype("outolist", type);

-         prconi(initfile, type, cp->const.ci);
+         prconi(initfile, type, cp->constant.ci);

          clen += typesize[type];
          frexpr((tagptr) cp);
          break;
          clen += typesize[type];
          frexpr((tagptr) cp);
          break;

diff --git a/usr/src/usr.bin/f77/pass1.tahoe/optcse.c b/usr/src/usr.bin/f77/pass1.tahoe/optcse.c
index 40e0c3a..7335c8d 100644 (file)
--- a/usr/src/usr.bin/f77/pass1.tahoe/optcse.c
+++ b/usr/src/usr.bin/f77/pass1.tahoe/optcse.c
@@ -429,8 +429,8 @@ expptr ep1,ep2;
                            if (ep1->addrblock.memno == ep2->addrblock.memno &&
                                ISCONST(ep1->addrblock.memoffset) &&
                                ISCONST(ep2->addrblock.memoffset) &&
                            if (ep1->addrblock.memno == ep2->addrblock.memno &&
                                ISCONST(ep1->addrblock.memoffset) &&
                                ISCONST(ep2->addrblock.memoffset) &&

-                               ep1->addrblock.memoffset->constblock.const.ci ==
-                               ep2->addrblock.memoffset->constblock.const.ci ) {
+                               ep1->addrblock.memoffset->constblock.constant.ci ==
+                               ep2->addrblock.memoffset->constblock.constant.ci ) {

                                    return(TRUE); 
                            }
                            break;
                                    return(TRUE); 
                            }
                            break;


@@ -447,8 +447,8 @@ expptr ep1,ep2;
                    (ep2->constblock.vtype)  ) 
                {
                        union Constant *ap,*bp;
                    (ep2->constblock.vtype)  ) 
                {
                        union Constant *ap,*bp;

-                       ap= &ep1->constblock.const;
-                       bp= &ep2->constblock.const;
+                       ap= &ep1->constblock.constant;
+                       bp= &ep2->constblock.constant;

                        switch(ep1->constblock.vtype)
 
                        {
                        switch(ep1->constblock.vtype)
 
                        {

diff --git a/usr/src/usr.bin/f77/pass1.tahoe/optim.c b/usr/src/usr.bin/f77/pass1.tahoe/optim.c
index cff7ac3..c9d4383 100644 (file)
--- a/usr/src/usr.bin/f77/pass1.tahoe/optim.c
+++ b/usr/src/usr.bin/f77/pass1.tahoe/optim.c
@@ -746,7 +746,7 @@ LOCAL expptr buffpower( p )
                fatal( "buffpower: bad non-integer exponent" );
 
        base = expand(p->exprblock.leftp);
                fatal( "buffpower: bad non-integer exponent" );
 
        base = expand(p->exprblock.leftp);

-       exp = p->exprblock.rightp->constblock.const.ci;
+       exp = p->exprblock.rightp->constblock.constant.ci;

        if ( exp < 2 )
                fatal( "buffpower: bad exponent less than 2" );
 
        if ( exp < 2 )
                fatal( "buffpower: bad exponent less than 2" );
 

diff --git a/usr/src/usr.bin/f77/pass1.tahoe/optloop.c b/usr/src/usr.bin/f77/pass1.tahoe/optloop.c
index c8c8633..be1c88d 100644 (file)
--- a/usr/src/usr.bin/f77/pass1.tahoe/optloop.c
+++ b/usr/src/usr.bin/f77/pass1.tahoe/optloop.c
@@ -635,11 +635,11 @@ expptr p;
     return NO;
 
   if (ISINT(p->constblock.vtype))
     return NO;
 
   if (ISINT(p->constblock.vtype))

-    if (abs(p->constblock.const.ci) <= 1)
+    if (abs(p->constblock.constant.ci) <= 1)

       return YES;
 
   if (ISREAL(p->constblock.vtype))
       return YES;
 
   if (ISREAL(p->constblock.vtype))

-    if (abs(p->constblock.const.cd[0]) <= 1.0)
+    if (abs(p->constblock.constant.cd[0]) <= 1.0)

       return YES;
 
   return NO;
       return YES;
 
   return NO;

diff --git a/usr/src/usr.bin/f77/pass1.tahoe/paramset.c b/usr/src/usr.bin/f77/pass1.tahoe/paramset.c
index 50e33eb..2fed3d1 100644 (file)
--- a/usr/src/usr.bin/f77/pass1.tahoe/paramset.c
+++ b/usr/src/usr.bin/f77/pass1.tahoe/paramset.c
@@ -71,11 +71,11 @@ expptr param_item_vl;
          if (type == TYCHAR)
            {
              if (param_item_nm->vleng != NULL)
          if (type == TYCHAR)
            {
              if (param_item_nm->vleng != NULL)

-               len = param_item_nm->vleng->constblock.const.ci;
+               len = param_item_nm->vleng->constblock.constant.ci;

              else if (ISCONST(param_item_vl) &&
                        param_item_vl->constblock.vtype == TYCHAR)
                len = param_item_vl->constblock.vleng->
              else if (ISCONST(param_item_vl) &&
                        param_item_vl->constblock.vtype == TYCHAR)
                len = param_item_vl->constblock.vleng->

-                       constblock.const.ci;
+                       constblock.constant.ci;

              else
                len = 1;
            }
              else
                len = 1;
            }

diff --git a/usr/src/usr.bin/f77/pass1.tahoe/proc.c b/usr/src/usr.bin/f77/pass1.tahoe/proc.c
index f8bacfb..820537a 100644 (file)
--- a/usr/src/usr.bin/f77/pass1.tahoe/proc.c
+++ b/usr/src/usr.bin/f77/pass1.tahoe/proc.c
@@ -502,13 +502,13 @@ impldcl( np = mkname(VL, nounder(XL, ep->entryname->extname) ) );
 type = np->vtype;
 if(proctype == TYUNKNOWN)
        if( (proctype = type) == TYCHAR)
 type = np->vtype;
 if(proctype == TYUNKNOWN)
        if( (proctype = type) == TYCHAR)

-               procleng = (np->vleng ? np->vleng->constblock.const.ci : (ftnint) (-1));
+               procleng = (np->vleng ? np->vleng->constblock.constant.ci : (ftnint) (-1));

 
 if(proctype == TYCHAR)
        {
        if(type != TYCHAR)
                err("noncharacter entry of character function");
 
 if(proctype == TYCHAR)
        {
        if(type != TYCHAR)
                err("noncharacter entry of character function");

-       else if( (np->vleng ? np->vleng->constblock.const.ci : (ftnint) (-1)) != procleng)
+       else if( (np->vleng ? np->vleng->constblock.constant.ci : (ftnint) (-1)) != procleng)

                err("mismatched character entry lengths");
        }
 else if(type == TYCHAR)
                err("mismatched character entry lengths");
        }
 else if(type == TYCHAR)


@@ -543,7 +543,7 @@ else if(type != TYSUBR)
        if(retslot == NULL)
                retslot = autovar(1, TYDREAL, PNULL);
        np->vstg = STGAUTO;
        if(retslot == NULL)
                retslot = autovar(1, TYDREAL, PNULL);
        np->vstg = STGAUTO;

-       np->voffset = retslot->memoffset->constblock.const.ci;
+       np->voffset = retslot->memoffset->constblock.constant.ci;

        }
 
 for(p = ep->arglist ; p ; p = p->nextp)
        }
 
 for(p = ep->arglist ; p ; p = p->nextp)


@@ -720,11 +720,11 @@ if(leng <= 0)
        return(-1);
 if(q->vdim)
        if( ISICON(q->vdim->nelt) )
        return(-1);
 if(q->vdim)
        if( ISICON(q->vdim->nelt) )

-               leng *= q->vdim->nelt->constblock.const.ci;
+               leng *= q->vdim->nelt->constblock.constant.ci;

        else    return(-1);
 if(q->vleng)
        if( ISICON(q->vleng) )
        else    return(-1);
 if(q->vleng)
        if( ISICON(q->vleng) )

-               leng *= q->vleng->constblock.const.ci;
+               leng *= q->vleng->constblock.constant.ci;

        else    return(-1);
 return(leng);
 }
        else    return(-1);
 return(leng);
 }


@@ -785,7 +785,7 @@ for(q = np->varxptr.namelist ; q ; q = q->nextp)
                praddr(asmfile, v->vstg, v->vardesc.varno, v->voffset);
                prconi(asmfile, TYINT,
                        type==TYCHAR ?
                praddr(asmfile, v->vstg, v->vardesc.varno, v->voffset);
                prconi(asmfile, TYINT,
                        type==TYCHAR ?

-                           -(v->vleng->constblock.const.ci) : (ftnint) type);
+                           -(v->vleng->constblock.constant.ci) : (ftnint) type);

                if(v->vdim)
                        {
                        praddr(asmfile, STGINIT, dimno, (ftnint)dimoffset);
                if(v->vdim)
                        {
                        praddr(asmfile, STGINIT, dimno, (ftnint)dimoffset);


@@ -815,12 +815,12 @@ if(dimoffset > 0)
                        int i;
                        prconi(asmfile, TYINT, (ftnint) (dp->ndim) );
                        prconi(asmfile, TYINT,
                        int i;
                        prconi(asmfile, TYINT, (ftnint) (dp->ndim) );
                        prconi(asmfile, TYINT,

-                               (ftnint) (dp->nelt->constblock.const.ci) );
+                               (ftnint) (dp->nelt->constblock.constant.ci) );

                        prconi(asmfile, TYINT,
                        prconi(asmfile, TYINT,

-                               (ftnint) (dp->baseoffset->constblock.const.ci));
+                               (ftnint) (dp->baseoffset->constblock.constant.ci));

                        for(i=0; i<dp->ndim ; ++i)
                                prconi(asmfile, TYINT,
                        for(i=0; i<dp->ndim ; ++i)
                                prconi(asmfile, TYINT,

-                                       dp->dims[i].dimsize->constblock.const.ci);
+                                       dp->dims[i].dimsize->constblock.constant.ci);

                        }
        }
 
                        }
        }
 


@@ -857,11 +857,11 @@ for(p = extsymtab ; p<nextext ; ++p)
                        v->voffset = p->extleng;
                        v->vardesc.varno = p - extsymtab;
                        if(type == TYCHAR)
                        v->voffset = p->extleng;
                        v->vardesc.varno = p - extsymtab;
                        if(type == TYCHAR)

-                               size = v->vleng->constblock.const.ci;
+                               size = v->vleng->constblock.constant.ci;

                        else    size = typesize[type];
                        if(t = v->vdim)
                                if( (neltp = t->nelt) && ISCONST(neltp) )
                        else    size = typesize[type];
                        if(t = v->vdim)
                                if( (neltp = t->nelt) && ISCONST(neltp) )

-                                       size *= neltp->constblock.const.ci;
+                                       size *= neltp->constblock.constant.ci;

                                else
                                        dclerr("adjustable array in common", v);
                        p->extleng += size;
                                else
                                        dclerr("adjustable array in common", v);
                        p->extleng += size;


@@ -947,7 +947,7 @@ register Addrp q;
 
 if(lengp)
        if( ISICON(lengp) )
 
 if(lengp)
        if( ISICON(lengp) )

-               leng = lengp->constblock.const.ci;
+               leng = lengp->constblock.constant.ci;

        else    {
                fatal("automatic variable of nonconstant length");
                }
        else    {
                fatal("automatic variable of nonconstant length");
                }


@@ -1002,7 +1002,7 @@ if(type==TYUNKNOWN || type==TYERROR)
 
 if(type==TYCHAR)
        if( ISICON(lengp) )
 
 if(type==TYCHAR)
        if( ISICON(lengp) )

-               leng = lengp->constblock.const.ci;
+               leng = lengp->constblock.constant.ci;

        else    {
                err("adjustable length");
                return( (Tempp) errnode() );
        else    {
                err("adjustable length");
                return( (Tempp) errnode() );


@@ -1102,7 +1102,7 @@ if(type==TYUNKNOWN || type==TYERROR)
 
 if(type==TYCHAR)
        if( ISICON(lengp) )
 
 if(type==TYCHAR)
        if( ISICON(lengp) )

-               leng = lengp->constblock.const.ci;
+               leng = lengp->constblock.constant.ci;

        else    {
                err("adjustable length");
                return( (Addrp) errnode() );
        else    {
                err("adjustable length");
                return( (Addrp) errnode() );


@@ -1123,7 +1123,7 @@ for(oldp=CHNULL, p=templist  ;  p  ;  oldp=p, p=p->nextp)
        {
        q = (Addrp) (p->datap);
        if(q->vtype==type && q->ntempelt==nelt &&
        {
        q = (Addrp) (p->datap);
        if(q->vtype==type && q->ntempelt==nelt &&

-           (type!=TYCHAR || q->vleng->constblock.const.ci==leng) )
+           (type!=TYCHAR || q->vleng->constblock.constant.ci==leng) )

                {
                if(oldp)
                        oldp->nextp = p->nextp;
                {
                if(oldp)
                        oldp->nextp = p->nextp;


@@ -1133,7 +1133,7 @@ for(oldp=CHNULL, p=templist  ;  p  ;  oldp=p, p=p->nextp)
 
                if (debugflag[14])
                        fprintf(diagfile,"mkaltmpn reusing offset %d\n",
 
                if (debugflag[14])
                        fprintf(diagfile,"mkaltmpn reusing offset %d\n",

-                               q->memoffset->constblock.const.ci);
+                               q->memoffset->constblock.constant.ci);

                return(q);
                }
        }
                return(q);
                }
        }


@@ -1143,7 +1143,7 @@ q->istemp = YES;
 
 if (debugflag[14])
        fprintf(diagfile,"mkaltmpn new offset %d\n",
 
 if (debugflag[14])
        fprintf(diagfile,"mkaltmpn new offset %d\n",

-               q->memoffset->constblock.const.ci);
+               q->memoffset->constblock.constant.ci);

 return(q);
 }
 
 return(q);
 }
 


@@ -1172,7 +1172,7 @@ expptr lengp;
   if (type == TYCHAR)
     {
       if (ISICON(lengp))
   if (type == TYCHAR)
     {
       if (ISICON(lengp))

-       leng = lengp->constblock.const.ci;
+       leng = lengp->constblock.constant.ci;

       else
        {
          err("adjustable length");
       else
        {
          err("adjustable length");


@@ -1187,7 +1187,7 @@ expptr lengp;
     {
       q = (Addrp) (p->datap);
       if (q->vtype == type
     {
       q = (Addrp) (p->datap);
       if (q->vtype == type

-         && (type != TYCHAR || q->vleng->constblock.const.ci == leng))
+         && (type != TYCHAR || q->vleng->constblock.constant.ci == leng))

        {
          if (oldp)
            oldp->nextp = p->nextp;
        {
          if (oldp)
            oldp->nextp = p->nextp;


@@ -1278,7 +1278,7 @@ else if(v->vtype == TYUNKNOWN)
        if( (v->vtype = lengtype(type, length))==TYCHAR && length>=0)
                v->vleng = ICON(length);
        }
        if( (v->vtype = lengtype(type, length))==TYCHAR && length>=0)
                v->vleng = ICON(length);
        }

-else if(v->vtype!=type || (type==TYCHAR && v->vleng->constblock.const.ci!=length) )
+else if(v->vtype!=type || (type==TYCHAR && v->vleng->constblock.constant.ci!=length) )

        dclerr("incompatible type declarations", v);
 }
 
        dclerr("incompatible type declarations", v);
 }
 


@@ -1455,7 +1455,7 @@ for(i=0 ; i<nd ; ++i)
                           frexpr(q);
                           q = ICON(0);
                           }
                           frexpr(q);
                           q = ICON(0);
                           }

-                       if ( q->constblock.const.ci <= 0)
+                       if ( q->constblock.constant.ci <= 0)

                           {
                           dclerr("array bounds out of sequence", v);
                           frexpr(q);
                           {
                           dclerr("array bounds out of sequence", v);
                           frexpr(q);

diff --git a/usr/src/usr.bin/f77/pass1.tahoe/put.c b/usr/src/usr.bin/f77/pass1.tahoe/put.c
index ded9804..d01864a 100644 (file)
--- a/usr/src/usr.bin/f77/pass1.tahoe/put.c
+++ b/usr/src/usr.bin/f77/pass1.tahoe/put.c
@@ -160,7 +160,7 @@ if (ISCONST(p))
        if (ISCOMPLEX(p->constblock.vtype))
                return(mkrealcon(p->constblock.vtype == TYCOMPLEX ?
                                        TYREAL : TYDREAL,
        if (ISCOMPLEX(p->constblock.vtype))
                return(mkrealcon(p->constblock.vtype == TYCOMPLEX ?
                                        TYREAL : TYDREAL,

-                               p->constblock.const.cd[1]));
+                               p->constblock.constant.cd[1]));

        else if (p->constblock.vtype == TYDREAL)
                return(mkrealcon(TYDREAL, 0.0));
        else
        else if (p->constblock.vtype == TYDREAL)
                return(mkrealcon(TYDREAL, 0.0));
        else


@@ -204,7 +204,7 @@ register expptr p;
 if(p->tag==TEXPR && p->exprblock.opcode==OPCONCAT)
        return( lencat(p->exprblock.leftp) + lencat(p->exprblock.rightp) );
 else if( p->headblock.vleng!=NULL && ISICON(p->headblock.vleng) )
 if(p->tag==TEXPR && p->exprblock.opcode==OPCONCAT)
        return( lencat(p->exprblock.leftp) + lencat(p->exprblock.rightp) );
 else if( p->headblock.vleng!=NULL && ISICON(p->headblock.vleng) )

-       return(p->headblock.vleng->constblock.const.ci);
+       return(p->headblock.vleng->constblock.constant.ci);

 else if(p->tag==TADDR && p->addrblock.varleng!=0)
        return(p->addrblock.varleng);
 else if(p->tag==TTEMP && p->tempblock.varleng!=0)
 else if(p->tag==TADDR && p->addrblock.varleng!=0)
        return(p->addrblock.varleng);
 else if(p->tag==TTEMP && p->tempblock.varleng!=0)


@@ -241,7 +241,7 @@ q->memoffset = ICON(0);
 switch(type = p->vtype)
        {
        case TYCHAR:
 switch(type = p->vtype)
        {
        case TYCHAR:

-               if(p->vleng->constblock.const.ci > XL)
+               if(p->vleng->constblock.constant.ci > XL)

                        break;  /* too long for literal table */
                litflavor = 1;
                goto loop;
                        break;  /* too long for literal table */
                litflavor = 1;
                goto loop;


@@ -263,9 +263,9 @@ switch(type = p->vtype)
                        if(type == litp->littype) switch(litflavor)
                                {
                        case 1:
                        if(type == litp->littype) switch(litflavor)
                                {
                        case 1:

-                               if(p->vleng->constblock.const.ci != litp->litval.litcval.litclen)
+                               if(p->vleng->constblock.constant.ci != litp->litval.litcval.litclen)

                                        break;
                                        break;

-                               if(! eqn( (int) p->vleng->constblock.const.ci, p->const.ccp,
+                               if(! eqn( (int) p->vleng->constblock.constant.ci, p->constant.ccp,

                                        litp->litval.litcval.litcstr) )
                                                break;
 
                                        litp->litval.litcval.litcstr) )
                                                break;
 


@@ -275,12 +275,12 @@ switch(type = p->vtype)
                                return(q);
 
                        case 2:
                                return(q);
 
                        case 2:

-                               if(p->const.cd[0] == litp->litval.litdval)
+                               if(p->constant.cd[0] == litp->litval.litdval)

                                        goto ret;
                                break;
 
                        case 3:
                                        goto ret;
                                break;
 
                        case 3:

-                               if(p->const.ci == litp->litval.litival)
+                               if(p->constant.ci == litp->litval.litival)

                                        goto ret;
                                break;
                                }
                                        goto ret;
                                break;
                                }


@@ -293,18 +293,18 @@ switch(type = p->vtype)
                                {
                                case 1:
                                        litp->litval.litcval.litclen =
                                {
                                case 1:
                                        litp->litval.litcval.litclen =

-                                               p->vleng->constblock.const.ci;
+                                               p->vleng->constblock.constant.ci;

                                        cpn( (int) litp->litval.litcval.litclen,
                                        cpn( (int) litp->litval.litcval.litclen,

-                                               p->const.ccp,
+                                               p->constant.ccp,

                                                litp->litval.litcval.litcstr);
                                        break;
 
                                case 2:
                                                litp->litval.litcval.litcstr);
                                        break;
 
                                case 2:

-                                       litp->litval.litdval = p->const.cd[0];
+                                       litp->litval.litdval = p->constant.cd[0];

                                        break;
 
                                case 3:
                                        break;
 
                                case 3:

-                                       litp->litval.litival = p->const.ci;
+                                       litp->litval.litival = p->constant.ci;

                                        break;
                                }
                        }
                                        break;
                                }
                        }


@@ -321,7 +321,7 @@ switch(type)
        case TYLOGICAL:
        case TYSHORT:
        case TYLONG:
        case TYLOGICAL:
        case TYSHORT:
        case TYLONG:

-               prconi(asmfile, type, p->const.ci);
+               prconi(asmfile, type, p->constant.ci);

                break;
 
        case TYCOMPLEX:
                break;
 
        case TYCOMPLEX:


@@ -337,16 +337,16 @@ switch(type)
 
        flpt:
                for(i = 0 ; i < k ; ++i)
 
        flpt:
                for(i = 0 ; i < k ; ++i)

-                       prconr(asmfile, type, p->const.cd[i]);
+                       prconr(asmfile, type, p->constant.cd[i]);

                break;
 
        case TYCHAR:
                break;
 
        case TYCHAR:

-               putstr(asmfile, p->const.ccp,
-                       (int) (p->vleng->constblock.const.ci) );
+               putstr(asmfile, p->constant.ccp,
+                       (int) (p->vleng->constblock.constant.ci) );

                break;
 
        case TYADDR:
                break;
 
        case TYADDR:

-               prcona(asmfile, p->const.ci);
+               prcona(asmfile, p->constant.ci);

                break;
 
        default:
                break;
 
        default:

diff --git a/usr/src/usr.bin/f77/pass1.tahoe/putpcc.c b/usr/src/usr.bin/f77/pass1.tahoe/putpcc.c
index e3311e8..b2ce08c 100644 (file)
--- a/usr/src/usr.bin/f77/pass1.tahoe/putpcc.c
+++ b/usr/src/usr.bin/f77/pass1.tahoe/putpcc.c
@@ -358,7 +358,7 @@ switch(p->tag)
                                type = tyint;
                        case TYLONG:
                        case TYSHORT:
                                type = tyint;
                        case TYLONG:
                        case TYSHORT:

-                               p2icon(p->constblock.const.ci, types2[type]);
+                               p2icon(p->constblock.constant.ci, types2[type]);

                                free( (charptr) p );
                                break;
 
                                free( (charptr) p );
                                break;
 


@@ -366,7 +366,7 @@ switch(p->tag)
                                p2triple(PCC_ICON, 1, PCCT_INT|PCCTM_PTR);
                                p2word(0L);
                                p2name(memname(STGCONST,
                                p2triple(PCC_ICON, 1, PCCT_INT|PCCTM_PTR);
                                p2word(0L);
                                p2name(memname(STGCONST,

-                                       (int) p->constblock.const.ci) );
+                                       (int) p->constblock.constant.ci) );

                                free( (charptr) p );
                                break;
 
                                free( (charptr) p );
                                break;
 


@@ -430,7 +430,7 @@ switch(p->tag)
                                /*   m * (2**k) -> m<<k   */
                                if(INT(p->exprblock.leftp->headblock.vtype) &&
                                   ISICON(p->exprblock.rightp) &&
                                /*   m * (2**k) -> m<<k   */
                                if(INT(p->exprblock.leftp->headblock.vtype) &&
                                   ISICON(p->exprblock.rightp) &&

-                                  ( (k = log2(p->exprblock.rightp->constblock.const.ci))>0) )
+                                  ( (k = log2(p->exprblock.rightp->constblock.constant.ci))>0) )

                                        {
                                        p->exprblock.opcode = OPLSHIFT;
                                        frexpr(p->exprblock.rightp);
                                        {
                                        p->exprblock.opcode = OPLSHIFT;
                                        frexpr(p->exprblock.rightp);


@@ -627,10 +627,10 @@ switch(p->exprblock.opcode)       /* check for special cases and rewrite */
                if(ISREAL(p->exprblock.leftp->headblock.vtype) &&
                   ISREAL(p->exprblock.rightp->headblock.vtype) &&
                   ISCONST(p->exprblock.rightp) &&
                if(ISREAL(p->exprblock.leftp->headblock.vtype) &&
                   ISREAL(p->exprblock.rightp->headblock.vtype) &&
                   ISCONST(p->exprblock.rightp) &&

-                  p->exprblock.rightp->constblock.const.cd[0]==0)
+                  p->exprblock.rightp->constblock.constant.cd[0]==0)

                        {
                        p->exprblock.rightp->constblock.vtype = TYINT;
                        {
                        p->exprblock.rightp->constblock.vtype = TYINT;

-                       p->exprblock.rightp->constblock.const.ci = 0;
+                       p->exprblock.rightp->constblock.constant.ci = 0;

                        }
 #endif
        }
                        }
 #endif
        }


@@ -674,7 +674,7 @@ int type;
 int ncomma;
 
 if(!ISICON(p->exprblock.rightp) ||
 int ncomma;
 
 if(!ISICON(p->exprblock.rightp) ||

-    (k = p->exprblock.rightp->constblock.const.ci)<2)
+    (k = p->exprblock.rightp->constblock.constant.ci)<2)

        fatal("putpower: bad call");
 base = p->exprblock.leftp;
 type = base->headblock.vtype;
        fatal("putpower: bad call");
 base = p->exprblock.leftp;
 type = base->headblock.vtype;


@@ -1020,7 +1020,7 @@ switch(p->tag)
 
                        case OPCONV:
                                if(!ISICON(p->exprblock.vleng)
 
                        case OPCONV:
                                if(!ISICON(p->exprblock.vleng)

-                                  || p->exprblock.vleng->constblock.const.ci!=1
+                                  || p->exprblock.vleng->constblock.constant.ci!=1

                                   || ! INT(p->exprblock.leftp->headblock.vtype) )
                                        fatal("putch1: bad character conversion");
                                t = mkaltemp(TYCHAR, ICON(1) );
                                   || ! INT(p->exprblock.leftp->headblock.vtype) )
                                        fatal("putch1: bad character conversion");
                                t = mkaltemp(TYCHAR, ICON(1) );


@@ -1607,10 +1607,10 @@ if(p->tag==TEXPR && p->exprblock.opcode==OPSTAR)
                {
                p->exprblock.opcode = OPPLUS;
                lp->exprblock.opcode = OPSTAR;
                {
                p->exprblock.opcode = OPPLUS;
                lp->exprblock.opcode = OPSTAR;

-               prod = rp->constblock.const.ci *
-                       lp->exprblock.rightp->constblock.const.ci;
-               lp->exprblock.rightp->constblock.const.ci = rp->constblock.const.ci;
-               rp->constblock.const.ci = prod;
+               prod = rp->constblock.constant.ci *
+                       lp->exprblock.rightp->constblock.constant.ci;
+               lp->exprblock.rightp->constblock.constant.ci = rp->constblock.constant.ci;
+               rp->constblock.constant.ci = prod;

                }
        }
 
                }
        }
 


@@ -1619,7 +1619,7 @@ if(p->tag==TEXPR && p->exprblock.opcode==OPPLUS &&
        {
        rp = p->exprblock.rightp;
        lp = p->exprblock.leftp;
        {
        rp = p->exprblock.rightp;
        lp = p->exprblock.leftp;

-       offset += rp->constblock.const.ci;
+       offset += rp->constblock.constant.ci;

        frexpr(rp);
        free( (charptr) p );
        *p0 = lp;
        frexpr(rp);
        free( (charptr) p );
        *p0 = lp;


@@ -1627,7 +1627,7 @@ if(p->tag==TEXPR && p->exprblock.opcode==OPPLUS &&
 
 if( ISCONST(p) )
        {
 
 if( ISCONST(p) )
        {

-       offset += p->constblock.const.ci;
+       offset += p->constblock.constant.ci;

        frexpr(p);
        *p0 = NULL;
        }
        frexpr(p);
        *p0 = NULL;
        }

diff --git a/usr/src/usr.bin/f77/pass1.tahoe/regalloc.c b/usr/src/usr.bin/f77/pass1.tahoe/regalloc.c
index 2ef6dfc..4f3e267 100644 (file)
--- a/usr/src/usr.bin/f77/pass1.tahoe/regalloc.c
+++ b/usr/src/usr.bin/f77/pass1.tahoe/regalloc.c
@@ -334,7 +334,7 @@ Addrp ap;
   if (!ISVAR(ap))
     fatal("regalloc:  bad data sent to getvar");
 
   if (!ISVAR(ap))
     fatal("regalloc:  bad data sent to getvar");
 

-  memoffset = ap->memoffset->constblock.const.ci;
+  memoffset = ap->memoffset->constblock.constant.ci;

 
   for (q = ainfo->varlist; q; q = q->link)
     if (q->memoffset == memoffset)
 
   for (q = ainfo->varlist; q; q = q->link)
     if (q->memoffset == memoffset)


@@ -661,7 +661,7 @@ LOCAL alreg()
       rp->vstg = ap->vstg;
       rp->vtype = ap->vtype;
       rp->memno = ap->memno;
       rp->vstg = ap->vstg;
       rp->vtype = ap->vtype;
       rp->memno = ap->memno;

-      rp->memoffset = ap->memoffset->constblock.const.ci;
+      rp->memoffset = ap->memoffset->constblock.constant.ci;

       rp->isarrayarg = NO;
       rp->stgp = ap;
     }
       rp->isarrayarg = NO;
       rp->stgp = ap;
     }


@@ -784,7 +784,7 @@ LOCAL alreg()
                    ap = (Addrp) sp->expr->exprblock.leftp;
                    if ((ap->vstg == rp->vstg) && (ap->memno == rp->memno) &&
                        fixedaddress(ap) &&
                    ap = (Addrp) sp->expr->exprblock.leftp;
                    if ((ap->vstg == rp->vstg) && (ap->memno == rp->memno) &&
                        fixedaddress(ap) &&

-                       (ap->memoffset->constblock.const.ci == rp->memoffset))
+                       (ap->memoffset->constblock.constant.ci == rp->memoffset))

                      {
                        changetoreg(ap, i);
                        goto L1;
                      {
                        changetoreg(ap, i);
                        goto L1;


@@ -1405,7 +1405,7 @@ expptr p;
        {
          if (ISREGTYPE(ap->vtype))
            {
        {
          if (ISREGTYPE(ap->vtype))
            {

-             varinfo = lookupvar(addrinfo, ap->memoffset->constblock.const.ci);
+             varinfo = lookupvar(addrinfo, ap->memoffset->constblock.constant.ci);

              varinfo->refs++;
            }
        }
              varinfo->refs++;
            }
        }


@@ -1560,7 +1560,7 @@ expptr p;
 
          if (fixedaddress(ap))
            {
 
          if (fixedaddress(ap))
            {

-             memoffset = ap->memoffset->constblock.const.ci;
+             memoffset = ap->memoffset->constblock.constant.ci;

              for (i = toplcv + 1; i <= topregvar; i++)
                if ((rp = regtab[i]) &&
                    !rp->isarrayarg &&
              for (i = toplcv + 1; i <= topregvar; i++)
                if ((rp = regtab[i]) &&
                    !rp->isarrayarg &&


@@ -1619,7 +1619,7 @@ expptr p;
 
       if (fixedaddress(ap))
        {
 
       if (fixedaddress(ap))
        {

-          memoffset = ap->memoffset->constblock.const.ci;
+          memoffset = ap->memoffset->constblock.constant.ci;

          for (i = toplcv + 1; i <= topregvar; i++)
            if ((rp = regtab[i]) &&
                !rp->isarrayarg &&
          for (i = toplcv + 1; i <= topregvar; i++)
            if ((rp = regtab[i]) &&
                !rp->isarrayarg &&


@@ -1932,7 +1932,7 @@ Slotp sp;
       (l->addrblock.vstg == regtab[i]->vstg) &&
       (l->addrblock.memno == regtab[i]->memno) &&
       fixedaddress(l) &&
       (l->addrblock.vstg == regtab[i]->vstg) &&
       (l->addrblock.memno == regtab[i]->memno) &&
       fixedaddress(l) &&

-      (l->addrblock.memoffset->constblock.const.ci == regtab[i]->memoffset))
+      (l->addrblock.memoffset->constblock.constant.ci == regtab[i]->memoffset))

     return YES;
 
   return NO;
     return YES;
 
   return NO;

diff --git a/usr/src/usr.bin/f77/pass1.tahoe/stab.c b/usr/src/usr.bin/f77/pass1.tahoe/stab.c
index bd747f6..7464114 100644 (file)
--- a/usr/src/usr.bin/f77/pass1.tahoe/stab.c
+++ b/usr/src/usr.bin/f77/pass1.tahoe/stab.c
@@ -274,16 +274,16 @@ Namep sym;
     
       for (i = p->vdim->ndim-1; i >=0 ; --i) { 
          if(p->vdim->dims[i].lbaddr == ENULL) {
     
       for (i = p->vdim->ndim-1; i >=0 ; --i) { 
          if(p->vdim->dims[i].lbaddr == ENULL) {

-             sprintf(lb,"%d", p->vdim->dims[i].lb->constblock.const.ci);
+             sprintf(lb,"%d", p->vdim->dims[i].lb->constblock.constant.ci);

         }
         else  { 
         }
         else  { 

-             sprintf(lb,"T%d", p->vdim->dims[i].lbaddr->addrblock.memoffset->constblock.const.ci);
+             sprintf(lb,"T%d", p->vdim->dims[i].lbaddr->addrblock.memoffset->constblock.constant.ci);

          }
          if(p->vdim->dims[i].ubaddr == ENULL) {
          }
          if(p->vdim->dims[i].ubaddr == ENULL) {

-             sprintf(ub,"%d",p->vdim->dims[i].ub->constblock.const.ci);
+             sprintf(ub,"%d",p->vdim->dims[i].ub->constblock.constant.ci);

         }
         else  {
         }
         else  {

-             sprintf(ub,"T%d",p->vdim->dims[i].ubaddr->addrblock.memoffset->constblock.const.ci);
+             sprintf(ub,"T%d",p->vdim->dims[i].ubaddr->addrblock.memoffset->constblock.constant.ci);

          }
                 sprintf(asmline+len, "ar%d;%s;%s;", TYINT, lb, ub);
         len += strlen(asmline+len);
          }
                 sprintf(asmline+len, "ar%d;%s;%s;", TYINT, lb, ub);
         len += strlen(asmline+len);


@@ -294,7 +294,7 @@ Namep sym;
         if( ! (p->vleng ) )
            fatalstr("missing length in addtypeinfo for character variable %s", varstr(p->varname));
 
         if( ! (p->vleng ) )
            fatalstr("missing length in addtypeinfo for character variable %s", varstr(p->varname));
 

-        if (ISCONST(p->vleng)) sprintf(ub,"%d",p->vleng->constblock.const.ci);
+        if (ISCONST(p->vleng)) sprintf(ub,"%d",p->vleng->constblock.constant.ci);

          else sprintf(ub,"A%d",p->vleng->addrblock.memno + ARGOFFSET);
 
        sprintf(asmline+len,"ar%d;1;%s;", TYINT, ub);
          else sprintf(ub,"A%d",p->vleng->addrblock.memno + ARGOFFSET);
 
        sprintf(asmline+len,"ar%d;1;%s;", TYINT, ub);

diff --git a/usr/src/usr.bin/f77/pass1.tahoe/tahoe.c b/usr/src/usr.bin/f77/pass1.tahoe/tahoe.c
index 50cab7c..c4c270d 100644 (file)
--- a/usr/src/usr.bin/f77/pass1.tahoe/tahoe.c
+++ b/usr/src/usr.bin/f77/pass1.tahoe/tahoe.c
@@ -352,7 +352,7 @@ register Constp cp;
 #if HERE == TAHOE
     case TYSHORT:
     { static short shrt;
 #if HERE == TAHOE
     case TYSHORT:
     { static short shrt;

-      shrt = cp->const.ci;
+      shrt = cp->constant.ci;

       return ((char *)&shrt);
     }
     case TYLONG:
       return ((char *)&shrt);
     }
     case TYLONG:


@@ -360,11 +360,11 @@ register Constp cp;
     case TYREAL:
     case TYDREAL:
     case TYDCOMPLEX:
     case TYREAL:
     case TYDREAL:
     case TYDCOMPLEX:

-      return ((char *)&cp->const);
+      return ((char *)&cp->constant);

     case TYCOMPLEX:
       { static float quad[2];
     case TYCOMPLEX:
       { static float quad[2];

-      quad[0] = cp->const.cd[0];
-      quad[1] = cp->const.cd[1];
+      quad[0] = cp->constant.cd[0];
+      quad[1] = cp->constant.cd[1];

       return ((char *)quad);
       }
 #endif
       return ((char *)quad);
       }
 #endif


@@ -372,18 +372,18 @@ register Constp cp;
 #if HERE == VAX
     case TYLONG:
     case TYLOGICAL:
 #if HERE == VAX
     case TYLONG:
     case TYLOGICAL:

-      swab4((char *)&cp->const.ci, lng, 4);
+      swab4((char *)&cp->constant.ci, lng, 4);

       return (lng);
 
     case TYSHORT:
     case TYREAL:
     case TYDREAL:
     case TYDCOMPLEX:
       return (lng);
 
     case TYSHORT:
     case TYREAL:
     case TYDREAL:
     case TYDCOMPLEX:

-      swab((char *)cp->const.cd, shrt, typesize[cp->vtype]);
+      swab((char *)cp->constant.cd, shrt, typesize[cp->vtype]);

       return (shrt);
     case TYCOMPLEX:
       return (shrt);
     case TYCOMPLEX:

-      swab((char *)cp->const.cd, shrt, 4);
-      swab((char *)&(cp->const.cd[1]), &shrt[4], 4);
+      swab((char *)cp->constant.cd, shrt, 4);
+      swab((char *)&(cp->constant.cd[1]), &shrt[4], 4);

       return (shrt);
 #endif
 
       return (shrt);
 #endif
 


@@ -877,7 +877,7 @@ if (anylocals == YES)
 if(argvec)
        {
        if (argvec->tag != TADDR) badtag ("prolog",argvec->tag);
 if(argvec)
        {
        if (argvec->tag != TADDR) badtag ("prolog",argvec->tag);

-       argloc = argvec->memoffset->constblock.const.ci + SZINT;
+       argloc = argvec->memoffset->constblock.constant.ci + SZINT;

                        /* first slot holds count */
        if(proctype == TYCHAR)
                {
                        /* first slot holds count */
        if(proctype == TYCHAR)
                {


@@ -943,7 +943,7 @@ for(p = ep->arglist ; p ; p = p->nextp)
                size = typesize[ q->vtype ];
                if(q->vtype == TYCHAR)
                        if( ISICON(q->vleng) )
                size = typesize[ q->vtype ];
                if(q->vtype == TYCHAR)
                        if( ISICON(q->vleng) )

-                               size *= q->vleng->constblock.const.ci;
+                               size *= q->vleng->constblock.constant.ci;

                        else
                                size = -1;
 
                        else
                                size = -1;
 


@@ -973,12 +973,12 @@ for(p = ep->arglist ; p ; p = p->nextp)
                                        p->datap->nameblock.vardesc.varno +
                                                ARGOFFSET);
                                }
                                        p->datap->nameblock.vardesc.varno +
                                                ARGOFFSET);
                                }

-                       else if(dp->baseoffset->constblock.const.ci != 0)
+                       else if(dp->baseoffset->constblock.constant.ci != 0)

                                {
                                if(size > 0)
                                        {
                                        p2pij("\tsubl2\t$%ld,%d(r12)",
                                {
                                if(size > 0)
                                        {
                                        p2pij("\tsubl2\t$%ld,%d(r12)",

-                                               dp->baseoffset->constblock.const.ci * size,
+                                               dp->baseoffset->constblock.constant.ci * size,

                                                p->datap->nameblock.vardesc.varno +
                                                        ARGOFFSET);
                                        }
                                                p->datap->nameblock.vardesc.varno +
                                                        ARGOFFSET);
                                        }