BSD 3 development

[unix-history] / usr / src / cmd / f77 / proc.c

diff --git a/usr/src/cmd/f77/proc.c b/usr/src/cmd/f77/proc.c
index 007aaa2..bca826e 100644 (file)
--- a/usr/src/cmd/f77/proc.c
+++ b/usr/src/cmd/f77/proc.c
@@ -1,5 +1,10 @@
 #include "defs"
 
 #include "defs"
 

+#ifdef SDB
+#      include <a.out.h>
+char *stabline();
+#endif
+

 /* start a new procedure */
 
 newproc()
 /* start a new procedure */
 
 newproc()


@@ -20,7 +25,7 @@ procclass = CLMAIN;   /* default */
 
 endproc()
 {
 
 endproc()
 {

-struct labelblock *lp;
+struct Labelblock *lp;

 
 if(parstate < INDATA)
        enddcl();
 
 if(parstate < INDATA)
        enddcl();


@@ -28,14 +33,14 @@ if(ctlstack >= ctls)
        err("DO loop or BLOCK IF not closed");
 for(lp = labeltab ; lp < labtabend ; ++lp)
        if(lp->stateno!=0 && lp->labdefined==NO)
        err("DO loop or BLOCK IF not closed");
 for(lp = labeltab ; lp < labtabend ; ++lp)
        if(lp->stateno!=0 && lp->labdefined==NO)

-               err1("missing statement number %s", convic(lp->stateno) );
+               errstr("missing statement number %s", convic(lp->stateno) );

 
 epicode();
 procode();
 dobss();
 prdbginfo();
 
 
 epicode();
 procode();
 dobss();
 prdbginfo();
 

-#if FAMILY == SCJ
+#if FAMILY == PCC

        putbracket();
 #endif
 
        putbracket();
 #endif
 


@@ -48,17 +53,12 @@ procinit(); /* clean up for next procedure */
 
 enddcl()
 {
 
 enddcl()
 {

-register struct entrypoint *p;
+register struct Entrypoint *p;

 
 parstate = INEXEC;
 docommon();
 doequiv();
 docomleng();
 
 parstate = INEXEC;
 docommon();
 doequiv();
 docomleng();

-#if TARGET == PDP11
-/* fake jump to start the optimizer */
-if(procclass != CLBLOCK)
-       putgoto( fudgelabel = newlabel() );
-#endif

 for(p = entries ; p ; p = p->nextp)
        doentry(p);
 }
 for(p = entries ; p ; p = p->nextp)
        doentry(p);
 }


@@ -68,16 +68,17 @@ for(p = entries ; p ; p = p->nextp)
 /* Main program or Block data */
 
 startproc(progname, class)
 /* Main program or Block data */
 
 startproc(progname, class)

-struct extsym * progname;
+struct Extsym * progname;

 int class;
 {
 int class;
 {

-register struct entrypoint *p;
+register struct Entrypoint *p;
+char buff[10];

 
 

-p = ALLOC(entrypoint);
+p = ALLOC(Entrypoint);

 if(class == CLMAIN)
 if(class == CLMAIN)

-       puthead("MAIN__");
+       puthead("MAIN__", CLMAIN);

 else
 else

-       puthead(NULL);
+       puthead(NULL, CLBLOCK);

 if(class == CLMAIN)
        newentry( mkname(5, "MAIN_") );
 p->entryname = progname;
 if(class == CLMAIN)
        newentry( mkname(5, "MAIN_") );
 p->entryname = progname;


@@ -90,15 +91,27 @@ fprintf(diagfile, "   %s", (class==CLMAIN ? "MAIN" : "BLOCK DATA") );
 if(progname)
        fprintf(diagfile, " %s", nounder(XL, procname = progname->extname) );
 fprintf(diagfile, ":\n");
 if(progname)
        fprintf(diagfile, " %s", nounder(XL, procname = progname->extname) );
 fprintf(diagfile, ":\n");

+#ifdef SDB
+if(sdbflag && class==CLMAIN)
+       {
+       sprintf(buff, "L%d", p->entrylabel);
+       prstab("MAIN_", N_FUN, lineno, buff);
+       p2pass( stabline("MAIN_", N_FNAME, 0, 0) );
+       if(progname)
+               {
+               prstab(nounder(XL,progname->extname), N_ENTRY, lineno,buff);
+/*             p2pass(stabline(nounder(XL,progname->extname),N_FNAME,0,0));    */
+               }
+       }
+#endif

 }
 
 /* subroutine or function statement */
 
 }
 
 /* subroutine or function statement */
 

-struct extsym *newentry(v)
-register struct nameblock *v;
+struct Extsym *newentry(v)
+register struct Nameblock *v;

 {
 {

-register struct extsym *p;
-struct extsym *mkext();
+register struct Extsym *p;

 
 p = mkext( varunder(VL, v->varname) );
 
 
 p = mkext( varunder(VL, v->varname) );
 


@@ -121,14 +134,15 @@ return(p);
 entrypt(class, type, length, entry, args)
 int class, type;
 ftnint length;
 entrypt(class, type, length, entry, args)
 int class, type;
 ftnint length;

-struct extsym *entry;
+struct Extsym *entry;

 chainp args;
 {
 chainp args;
 {

-register struct nameblock *q;
-register struct entrypoint *p;
+register struct Nameblock *q;
+register struct Entrypoint *p;
+char buff[10];

 
 if(class != CLENTRY)
 
 if(class != CLENTRY)

-       puthead( varstr(XL, procname = entry->extname) );
+       puthead( varstr(XL, procname = entry->extname), class);

 if(class == CLENTRY)
        fprintf(diagfile, "       entry ");
 fprintf(diagfile, "   %s:\n", nounder(XL, entry->extname));
 if(class == CLENTRY)
        fprintf(diagfile, "       entry ");
 fprintf(diagfile, "   %s:\n", nounder(XL, entry->extname));


@@ -147,13 +161,25 @@ if(class == CLPROC)
                ret0label = newlabel();
        }
 
                ret0label = newlabel();
        }
 

-p = ALLOC(entrypoint);
+p = ALLOC(Entrypoint);

 entries = hookup(entries, p);
 p->entryname = entry;
 p->arglist = args;
 p->entrylabel = newlabel();
 p->enamep = q;
 
 entries = hookup(entries, p);
 p->entryname = entry;
 p->arglist = args;
 p->entrylabel = newlabel();
 p->enamep = q;
 

+#ifdef SDB
+if(sdbflag)
+       {
+       sprintf(buff, "L%d", p->entrylabel);
+       prstab(nounder(XL, entry->extname),
+               (class==CLENTRY ? N_ENTRY : N_FUN),
+               lineno, buff);
+       if(class != CLENTRY)
+       p2pass( stabline( nounder(XL,entry->extname), N_FNAME, 0, 0) );
+       }
+#endif
+

 if(class == CLENTRY)
        {
        class = CLPROC;
 if(class == CLENTRY)
        {
        class = CLPROC;


@@ -216,7 +242,7 @@ else if(procclass != CLBLOCK)
 LOCAL retval(t)
 register int t;
 {
 LOCAL retval(t)
 register int t;
 {

-register struct addrblock *p;
+register struct Addrblock *p;

 
 switch(t)
        {
 
 switch(t)
        {


@@ -243,7 +269,7 @@ switch(t)
                break;
 
        default:
                break;
 
        default:

-               fatal1("retval: impossible type %d", t);
+               fatali("retval: impossible type %d", t);

        }
 goret(t);
 }
        }
 goret(t);
 }


@@ -253,14 +279,18 @@ goret(t);
 
 LOCAL procode()
 {
 
 LOCAL procode()
 {

-register struct entrypoint *p;
-struct addrblock *argvec;
+register struct Entrypoint *p;
+struct Addrblock *argvec;

 
 #if TARGET==GCOS
        argvec = autovar(lastargslot/SZADDR, TYADDR, NULL);
 #else
        if(lastargslot>0 && nentry>1)
 
 #if TARGET==GCOS
        argvec = autovar(lastargslot/SZADDR, TYADDR, NULL);
 #else
        if(lastargslot>0 && nentry>1)

+#if TARGET == VAX
+               argvec = autovar(1 + lastargslot/SZADDR, TYADDR, NULL);
+#else

                argvec = autovar(lastargslot/SZADDR, TYADDR, NULL);
                argvec = autovar(lastargslot/SZADDR, TYADDR, NULL);

+#endif

        else
                argvec = NULL;
 #endif
        else
                argvec = NULL;
 #endif


@@ -275,7 +305,7 @@ struct addrblock *argvec;
 for(p = entries ; p ; p = p->nextp)
        prolog(p, argvec);
 
 for(p = entries ; p ; p = p->nextp)
        prolog(p, argvec);
 

-#if FAMILY == SCJ
+#if FAMILY == PCC

        putrbrack(procno);
 #endif
 
        putrbrack(procno);
 #endif
 


@@ -288,12 +318,12 @@ prendproc();
  */
 
 LOCAL doentry(ep)
  */
 
 LOCAL doentry(ep)

-struct entrypoint *ep;
+struct Entrypoint *ep;

 {
 register int type;
 {
 register int type;

-register struct nameblock *np;
+register struct Nameblock *np;

 chainp p;
 chainp p;

-register struct nameblock *q;
+register struct Nameblock *q;

 
 ++nentry;
 if(procclass == CLMAIN)
 
 ++nentry;
 if(procclass == CLMAIN)


@@ -308,13 +338,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->const.ci : (ftnint) 0);
+               procleng = (np->vleng ? np->vleng->constblock.const.ci : (ftnint) 0);

 
 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->const.ci : (ftnint) 0) != procleng)
+       else if( (np->vleng ? np->vleng->constblock.const.ci : (ftnint) 0) != procleng)

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


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

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

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


@@ -361,6 +391,12 @@ for(p = ep->arglist ; p ; p = p->nextp)
                {
                impldcl(q);
                q->vdcldone = YES;
                {
                impldcl(q);
                q->vdcldone = YES;

+#ifdef SDB
+               if(sdbflag)
+                       prstab(varstr(VL,q->varname), N_PSYM,
+                               stabtype(q),
+                               convic(q->vardesc.varno + ARGOFFSET) );
+#endif

                if(q->vtype == TYCHAR)
                        {
                        if(q->vleng == NULL)    /* character*(*) */
                if(q->vtype == TYCHAR)
                        {
                        if(q->vleng == NULL)    /* character*(*) */


@@ -390,41 +426,54 @@ return(k);
 
 LOCAL dobss()
 {
 
 LOCAL dobss()
 {

-register struct hashentry *p;
-register struct nameblock *q;
+register struct Hashentry *p;
+register struct Nameblock *q;

 register int i;
 int align;
 register int i;
 int align;

-ftnint leng, iarrl, iarrlen();
-struct extsym *mkext();
+ftnint leng, iarrl;

 char *memname();
 char *memname();

+int qstg, qclass, qtype;

 
 pruse(asmfile, USEBSS);
 
 for(p = hashtab ; p<lasthash ; ++p)
     if(q = p->varp)
        {
 
 pruse(asmfile, USEBSS);
 
 for(p = hashtab ; p<lasthash ; ++p)
     if(q = p->varp)
        {

-       if( (q->vclass==CLUNKNOWN && q->vstg!=STGARG) ||
-           (q->vclass==CLVAR && q->vstg==STGUNKNOWN) )
+       qstg = q->vstg;
+       qtype = q->vtype;
+       qclass = q->vclass;
+
+#ifdef SDB
+               if(sdbflag&&qclass==CLVAR&&(qstg==STGBSS||qstg==STGINIT))
+                       {
+                       prstab(varstr(VL,q->varname), N_LCSYM,
+                               stabtype(q), memname(qstg,q->vardesc.varno) );
+                       prstleng(q, iarrlen(q));
+                       }
+#endif
+
+       if( (qclass==CLUNKNOWN && qstg!=STGARG) ||
+           (qclass==CLVAR && qstg==STGUNKNOWN) )

                warn1("local variable %s never used", varstr(VL,q->varname) );
                warn1("local variable %s never used", varstr(VL,q->varname) );

-       else if(q->vclass==CLVAR && q->vstg==STGBSS)
+       else if(qclass==CLVAR && qstg==STGBSS)

                {
                {

-               align = (q->vtype==TYCHAR ? ALILONG : typealign[q->vtype]);
+               align = (qtype==TYCHAR ? ALILONG : typealign[qtype]);

                if(bssleng % align != 0)
                        {
                        bssleng = roundup(bssleng, align);
                        preven(align);
                        }
                if(bssleng % align != 0)
                        {
                        bssleng = roundup(bssleng, align);
                        preven(align);
                        }

-               prlocvar( memname(STGBSS, q->vardesc.varno), iarrl = iarrlen(q) );
+               prlocvar(memname(STGBSS,q->vardesc.varno), iarrl = iarrlen(q) );

                bssleng += iarrl;
                }
                bssleng += iarrl;
                }

-       else if(q->vclass==CLPROC && q->vprocclass==PEXTERNAL && q->vstg!=STGARG)
+       else if(qclass==CLPROC && q->vprocclass==PEXTERNAL && qstg!=STGARG)

                mkext(varunder(VL, q->varname)) ->extstg = STGEXT;
 
                mkext(varunder(VL, q->varname)) ->extstg = STGEXT;
 

-       if(q->vclass==CLVAR && q->vstg!=STGARG)
+       if(qclass==CLVAR && qstg!=STGARG)

                {
                if(q->vdim && !ISICON(q->vdim->nelt) )
                        dclerr("adjustable dimension on non-argument", q);
                {
                if(q->vdim && !ISICON(q->vdim->nelt) )
                        dclerr("adjustable dimension on non-argument", q);

-               if(q->vtype==TYCHAR && (q->vleng==NULL || !ISICON(q->vleng)))
+               if(qtype==TYCHAR && (q->vleng==NULL || !ISICON(q->vleng)))

                        dclerr("adjustable leng on nonargument", q);
                }
        }
                        dclerr("adjustable leng on nonargument", q);
                }
        }


@@ -444,7 +493,7 @@ for(i = 0 ; i < nequiv ; ++i)
 
 doext()
 {
 
 doext()
 {

-struct extsym *p;
+struct Extsym *p;

 
 for(p = extsymtab ; p<nextext ; ++p)
        prext( varstr(XL, p->extname), p->maxleng, p->extinit);
 
 for(p = extsymtab ; p<nextext ; ++p)
        prext( varstr(XL, p->extname), p->maxleng, p->extinit);


@@ -454,7 +503,7 @@ for(p = extsymtab ; p<nextext ; ++p)
 
 
 ftnint iarrlen(q)
 
 
 ftnint iarrlen(q)

-register struct nameblock *q;
+register struct Nameblock *q;

 {
 ftnint leng;
 
 {
 ftnint leng;
 


@@ -463,28 +512,32 @@ 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->const.ci;
+               leng *= q->vdim->nelt->constblock.const.ci;

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

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

        else    return(-1);
 return(leng);
 }
 \f
 LOCAL docommon()
 {
        else    return(-1);
 return(leng);
 }
 \f
 LOCAL docommon()
 {

-register struct extsym *p;
+register struct Extsym *p;

 register chainp q;
 register chainp q;

-struct dimblock *t;
+struct Dimblock *t;

 expptr neltp;
 expptr neltp;

-register struct nameblock *v;
+register struct Nameblock *v;

 ftnint size;
 int type;
 
 for(p = extsymtab ; p<nextext ; ++p)
        if(p->extstg==STGCOMMON)
                {
 ftnint size;
 int type;
 
 for(p = extsymtab ; p<nextext ; ++p)
        if(p->extstg==STGCOMMON)
                {

+#ifdef SDB
+               if(sdbflag)
+                       prstab(NULL, N_BCOMM, 0, 0);
+#endif

                for(q = p->extp ; q ; q = q->nextp)
                        {
                        v = q->datap;
                for(q = p->extp ; q ; q = q->nextp)
                        {
                        v = q->datap;


@@ -499,17 +552,28 @@ 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->const.ci;
+                               size = v->vleng->constblock.const.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->const.ci;
+                                       size *= neltp->constblock.const.ci;

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

+#ifdef SDB
+                       if(sdbflag)
+                               {
+                               prstssym(v);
+                               prstleng(v, size);
+                               }
+#endif

                        }
 
                frchain( &(p->extp) );
                        }
 
                frchain( &(p->extp) );

+#ifdef SDB
+               if(sdbflag)
+                       prstab(varstr(XL,p->extname), N_ECOMM, 0, 0);
+#endif

                }
 }
 
                }
 }
 


@@ -519,13 +583,13 @@ for(p = extsymtab ; p<nextext ; ++p)
 
 LOCAL docomleng()
 {
 
 LOCAL docomleng()
 {

-register struct extsym *p;
+register struct Extsym *p;

 
 for(p = extsymtab ; p < nextext ; ++p)
        if(p->extstg == STGCOMMON)
                {
 
 for(p = extsymtab ; p < nextext ; ++p)
        if(p->extstg == STGCOMMON)
                {

-               if(p->maxleng!=0 && p->extleng!=0 && p->maxleng!=p->extleng &&
-                   !eqn(XL,"_BLNK__ ",p->extname) )
+               if(p->maxleng!=0 && p->extleng!=0 && p->maxleng!=p->extleng
+                   && !eqn(XL,"_BLNK__ ",p->extname) )

                        warn1("incompatible lengths for common block %s",
                                nounder(XL, p->extname) );
                if(p->maxleng < p->extleng)
                        warn1("incompatible lengths for common block %s",
                                nounder(XL, p->extname) );
                if(p->maxleng < p->extleng)


@@ -540,7 +604,7 @@ for(p = extsymtab ; p < nextext ; ++p)
 /* ROUTINES DEALING WITH AUTOMATIC AND TEMPORARY STORAGE */
 
 frtemp(p)
 /* ROUTINES DEALING WITH AUTOMATIC AND TEMPORARY STORAGE */
 
 frtemp(p)

-struct addrblock *p;
+struct Addrblock *p;

 {
 holdtemps = mkchain(p, holdtemps);
 }
 {
 holdtemps = mkchain(p, holdtemps);
 }


@@ -550,16 +614,16 @@ holdtemps = mkchain(p, holdtemps);
 
 /* allocate an automatic variable slot */
 
 
 /* allocate an automatic variable slot */
 

-struct addrblock *autovar(nelt, t, lengp)
+struct Addrblock *autovar(nelt, t, lengp)

 register int nelt, t;
 expptr lengp;
 {
 ftnint leng;
 register int nelt, t;
 expptr lengp;
 {
 ftnint leng;

-register struct addrblock *q;
+register struct Addrblock *q;

 
 if(t == TYCHAR)
        if( ISICON(lengp) )
 
 if(t == TYCHAR)
        if( ISICON(lengp) )

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

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


@@ -567,7 +631,7 @@ else
        leng = typesize[t];
 autoleng = roundup( autoleng, typealign[t]);
 
        leng = typesize[t];
 autoleng = roundup( autoleng, typealign[t]);
 

-q = ALLOC(addrblock);
+q = ALLOC(Addrblock);

 q->tag = TADDR;
 q->vtype = t;
 if(t == TYCHAR)
 q->tag = TADDR;
 q->vtype = t;
 if(t == TYCHAR)


@@ -587,21 +651,21 @@ return(q);
 }
 
 
 }
 
 

-struct addrblock *mktmpn(nelt, type, lengp)
+struct Addrblock *mktmpn(nelt, type, lengp)

 int nelt;
 register int type;
 expptr lengp;
 {
 ftnint leng;
 chainp p, oldp;
 int nelt;
 register int type;
 expptr lengp;
 {
 ftnint leng;
 chainp p, oldp;

-register struct addrblock *q;
+register struct Addrblock *q;

 
 if(type==TYUNKNOWN || type==TYERROR)
 
 if(type==TYUNKNOWN || type==TYERROR)

-       fatal1("mktmpn: invalid type %d", type);
+       fatali("mktmpn: invalid type %d", type);

 
 if(type==TYCHAR)
        if( ISICON(lengp) )
 
 if(type==TYCHAR)
        if( ISICON(lengp) )

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

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


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

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

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


@@ -625,7 +689,7 @@ return(q);
 
 
 
 
 
 

-struct addrblock *mktemp(type, lengp)
+struct Addrblock *mktemp(type, lengp)

 int type;
 expptr lengp;
 {
 int type;
 expptr lengp;
 {


@@ -634,11 +698,11 @@ return( mktmpn(1,type,lengp) );
 \f
 /* VARIOUS ROUTINES FOR PROCESSING DECLARATIONS */
 
 \f
 /* VARIOUS ROUTINES FOR PROCESSING DECLARATIONS */
 

-struct extsym *comblock(len, s)
+struct Extsym *comblock(len, s)

 register int len;
 register char *s;
 {
 register int len;
 register char *s;
 {

-struct extsym *mkext(), *p;
+struct Extsym *p;

 
 if(len == 0)
        {
 
 if(len == 0)
        {


@@ -650,7 +714,7 @@ if(p->extstg == STGUNKNOWN)
        p->extstg = STGCOMMON;
 else if(p->extstg != STGCOMMON)
        {
        p->extstg = STGCOMMON;
 else if(p->extstg != STGCOMMON)
        {

-       err1("%s cannot be a common block name", s);
+       errstr("%s cannot be a common block name", s);

        return(0);
        }
 
        return(0);
        }
 


@@ -659,8 +723,8 @@ return( p );
 
 
 incomm(c, v)
 
 
 incomm(c, v)

-struct extsym *c;
-struct nameblock *v;
+struct Extsym *c;
+struct Nameblock *v;

 {
 if(v->vstg != STGUNKNOWN)
        dclerr("incompatible common declaration", v);
 {
 if(v->vstg != STGUNKNOWN)
        dclerr("incompatible common declaration", v);


@@ -675,7 +739,7 @@ else
 
 
 settype(v, type, length)
 
 
 settype(v, type, length)

-register struct nameblock * v;
+register struct Nameblock * v;

 register int type;
 register int length;
 {
 register int type;
 register int length;
 {


@@ -699,7 +763,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->const.ci!=length) )
+else if(v->vtype!=type || (type==TYCHAR && v->vleng->constblock.const.ci!=length) )

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


@@ -737,7 +801,7 @@ switch(type)
                goto ret;
 
        case TYLOGICAL:
                goto ret;
 
        case TYLOGICAL:

-               if(length == 4)
+               if(length == typesize[TYLOGICAL])

                        goto ret;
                break;
 
                        goto ret;
                break;
 


@@ -750,7 +814,7 @@ switch(type)
                        goto ret;
                break;
        default:
                        goto ret;
                break;
        default:

-               fatal1("lengtype: invalid type %d", type);
+               fatali("lengtype: invalid type %d", type);

        }
 
 if(length != 0)
        }
 
 if(length != 0)


@@ -765,7 +829,7 @@ ret:
 
 
 setintr(v)
 
 
 setintr(v)

-register struct nameblock * v;
+register struct Nameblock * v;

 {
 register int k;
 
 {
 register int k;
 


@@ -788,7 +852,7 @@ else
 
 
 setext(v)
 
 
 setext(v)

-register struct nameblock * v;
+register struct Nameblock * v;

 {
 if(v->vclass == CLUNKNOWN)
        v->vclass = CLPROC;
 {
 if(v->vclass == CLUNKNOWN)
        v->vclass = CLPROC;


@@ -807,12 +871,12 @@ else if(v->vprocclass != PEXTERNAL)
 /* create dimensions block for array variable */
 
 setbound(v, nd, dims)
 /* create dimensions block for array variable */
 
 setbound(v, nd, dims)

-register struct nameblock * v;
+register struct Nameblock * v;

 int nd;
 struct { expptr lb, ub; } dims[ ];
 {
 register expptr q, t;
 int nd;
 struct { expptr lb, ub; } dims[ ];
 {
 register expptr q, t;

-register struct dimblock *p;
+register struct Dimblock *p;

 int i;
 
 if(v->vclass == CLUNKNOWN)
 int i;
 
 if(v->vclass == CLUNKNOWN)


@@ -823,7 +887,7 @@ else if(v->vclass != CLVAR)
        return;
        }
 
        return;
        }
 

-v->vdim = p = (struct dimblock *) ckalloc( sizeof(int) + (3+2*nd)*sizeof(expptr) );
+v->vdim = p = (struct Dimblock *) ckalloc(sizeof(int) + (3+2*nd)*sizeof(expptr) );

 p->ndim = nd;
 p->nelt = ICON(1);
 
 p->ndim = nd;
 p->nelt = ICON(1);
 


@@ -858,7 +922,8 @@ for(i=0 ; i<nd ; ++i)
                        p->dims[i].dimexpr = q;
                        }
                if(p->nelt)
                        p->dims[i].dimexpr = q;
                        }
                if(p->nelt)

-                       p->nelt = mkexpr(OPSTAR, p->nelt, cpexpr(p->dims[i].dimsize));
+                       p->nelt = mkexpr(OPSTAR, p->nelt,
+                                       cpexpr(p->dims[i].dimsize) );

                }
        }
 
                }
        }