home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 8 / FreshFishVol8-CD2.bin / bbs / gnu / f2c-1993.04.28-src.lha / f2c-1993.04.28 / src / exec.c < prev    next >
C/C++ Source or Header  |  1993-04-28  |  18KB  |  830 lines
  1. /****************************************************************
  2. Copyright 1990, 1993 by AT&T Bell Laboratories and Bellcore.
  3.  
  4. Permission to use, copy, modify, and distribute this software
  5. and its documentation for any purpose and without fee is hereby
  6. granted, provided that the above copyright notice appear in all
  7. copies and that both that the copyright notice and this
  8. permission notice and warranty disclaimer appear in supporting
  9. documentation, and that the names of AT&T Bell Laboratories or
  10. Bellcore or any of their entities not be used in advertising or
  11. publicity pertaining to distribution of the software without
  12. specific, written prior permission.
  13.  
  14. AT&T and Bellcore disclaim all warranties with regard to this
  15. software, including all implied warranties of merchantability
  16. and fitness.  In no event shall AT&T or Bellcore be liable for
  17. any special, indirect or consequential damages or any damages
  18. whatsoever resulting from loss of use, data or profits, whether
  19. in an action of contract, negligence or other tortious action,
  20. arising out of or in connection with the use or performance of
  21. this software.
  22. ****************************************************************/
  23.  
  24. #include "defs.h"
  25. #include "p1defs.h"
  26. #include "names.h"
  27.  
  28. LOCAL void exar2(), popctl(), pushctl();
  29.  
  30. /*   Logical IF codes
  31. */
  32.  
  33.  
  34. exif(p)
  35. expptr p;
  36. {
  37.     pushctl(CTLIF);
  38.     putif(p, 0);    /* 0 => if, not elseif */
  39. }
  40.  
  41.  
  42.  
  43. exelif(p)
  44. expptr p;
  45. {
  46.     if (ctlstack->ctltype == CTLIF || ctlstack->ctltype == CTLIFX)
  47.     putif(p, 1);    /* 1 ==> elseif */
  48.     else
  49.     execerr("elseif out of place", CNULL);
  50. }
  51.  
  52.  
  53.  
  54.  
  55.  
  56. exelse()
  57. {
  58.     register struct Ctlframe *c;
  59.  
  60.     for(c = ctlstack; c->ctltype == CTLIFX; --c);
  61.     if(c->ctltype == CTLIF) {
  62.         p1_else ();
  63.         c->ctltype = CTLELSE;
  64.         }
  65.     else
  66.         execerr("else out of place", CNULL);
  67.     }
  68.  
  69.  
  70. exendif()
  71. {
  72.     while(ctlstack->ctltype == CTLIFX) {
  73.         popctl();
  74.         p1else_end();
  75.         }
  76.     if(ctlstack->ctltype == CTLIF) {
  77.         popctl();
  78.         p1_endif ();
  79.         }
  80.     else if(ctlstack->ctltype == CTLELSE) {
  81.         popctl();
  82.         p1else_end ();
  83.         }
  84.     else
  85.         execerr("endif out of place", CNULL);
  86.     }
  87.  
  88.  
  89. new_endif()
  90. {
  91.     if (ctlstack->ctltype == CTLIF || ctlstack->ctltype == CTLIFX)
  92.         pushctl(CTLIFX);
  93.     else
  94.         err("new_endif bug");
  95.     }
  96.  
  97. /* pushctl -- Start a new control construct, initialize the labels (to
  98.    zero) */
  99.  
  100.  LOCAL void
  101. pushctl(code)
  102.  int code;
  103. {
  104.     register int i;
  105.  
  106.     if(++ctlstack >= lastctl)
  107.         many("loops or if-then-elses", 'c', maxctl);
  108.     ctlstack->ctltype = code;
  109.     for(i = 0 ; i < 4 ; ++i)
  110.         ctlstack->ctlabels[i] = 0;
  111.     ctlstack->dowhile = 0;
  112.     ++blklevel;
  113. }
  114.  
  115.  
  116.  LOCAL void
  117. popctl()
  118. {
  119.     if( ctlstack-- < ctls )
  120.         Fatal("control stack empty");
  121.     --blklevel;
  122. }
  123.  
  124.  
  125.  
  126. /* poplab -- update the flags in   labeltab   */
  127.  
  128. LOCAL poplab()
  129. {
  130.     register struct Labelblock  *lp;
  131.  
  132.     for(lp = labeltab ; lp < highlabtab ; ++lp)
  133.         if(lp->labdefined)
  134.         {
  135.             /* mark all labels in inner blocks unreachable */
  136.             if(lp->blklevel > blklevel)
  137.                 lp->labinacc = YES;
  138.         }
  139.         else if(lp->blklevel > blklevel)
  140.         {
  141.             /* move all labels referred to in inner blocks out a level */
  142.             lp->blklevel = blklevel;
  143.         }
  144. }
  145.  
  146.  
  147. /*  BRANCHING CODE
  148. */
  149.  
  150. exgoto(lab)
  151. struct Labelblock *lab;
  152. {
  153.     lab->labused = 1;
  154.     p1_goto (lab -> stateno);
  155. }
  156.  
  157.  
  158.  
  159.  
  160.  
  161.  
  162.  
  163. exequals(lp, rp)
  164. register struct Primblock *lp;
  165. register expptr rp;
  166. {
  167.     if(lp->tag != TPRIM)
  168.     {
  169.         err("assignment to a non-variable");
  170.         frexpr((expptr)lp);
  171.         frexpr(rp);
  172.     }
  173.     else if(lp->namep->vclass!=CLVAR && lp->argsp)
  174.     {
  175.         if(parstate >= INEXEC)
  176.             err("statement function amid executables");
  177.         mkstfunct(lp, rp);
  178.     }
  179.     else
  180.     {
  181.         expptr new_lp, new_rp;
  182.  
  183.         if(parstate < INDATA)
  184.             enddcl();
  185.         new_lp = mklhs (lp, keepsubs);
  186.         new_rp = fixtype (rp);
  187.         puteq(new_lp, new_rp);
  188.     }
  189. }
  190.  
  191.  
  192.  
  193. /* Make Statement Function */
  194.  
  195. long laststfcn = -1, thisstno;
  196. int doing_stmtfcn;
  197.  
  198. mkstfunct(lp, rp)
  199. struct Primblock *lp;
  200. expptr rp;
  201. {
  202.     register struct Primblock *p;
  203.     register Namep np;
  204.     chainp args;
  205.  
  206.     laststfcn = thisstno;
  207.     np = lp->namep;
  208.     if(np->vclass == CLUNKNOWN)
  209.         np->vclass = CLPROC;
  210.     else
  211.     {
  212.         dclerr("redeclaration of statement function", np);
  213.         return;
  214.     }
  215.     np->vprocclass = PSTFUNCT;
  216.     np->vstg = STGSTFUNCT;
  217.  
  218. /* Set the type of the function */
  219.  
  220.     impldcl(np);
  221.     if (np->vtype == TYCHAR && !np->vleng)
  222.         err("character statement function with length (*)");
  223.     args = (lp->argsp ? lp->argsp->listp : CHNULL);
  224.     np->varxptr.vstfdesc = mkchain((char *)args, (chainp)rp);
  225.  
  226.     for(doing_stmtfcn = 1 ; args ; args = args->nextp)
  227.  
  228. /* It is an error for the formal parameters to have arguments or
  229.    subscripts */
  230.  
  231.         if( ((tagptr)(args->datap))->tag!=TPRIM ||
  232.             (p = (struct Primblock *)(args->datap) )->argsp ||
  233.             p->fcharp || p->lcharp )
  234.             err("non-variable argument in statement function definition");
  235.         else
  236.         {
  237.  
  238. /* Replace the name on the left-hand side */
  239.  
  240.             args->datap = (char *)p->namep;
  241.             vardcl(p -> namep);
  242.             free((char *)p);
  243.         }
  244.     doing_stmtfcn = 0;
  245. }
  246.  
  247.  static void
  248. mixed_type(np)
  249.  Namep np;
  250. {
  251.     char buf[128];
  252.     sprintf(buf, "%s function %.90s invoked as subroutine",
  253.         ftn_types[np->vtype], np->fvarname);
  254.     warn(buf);
  255.     }
  256.  
  257.  
  258. excall(name, args, nstars, labels)
  259. Namep name;
  260. struct Listblock *args;
  261. int nstars;
  262. struct Labelblock *labels[ ];
  263. {
  264.     register expptr p;
  265.  
  266.     if (name->vtype != TYSUBR) {
  267.         if (name->vinfproc && !name->vcalled) {
  268.             name->vtype = TYSUBR;
  269.             frexpr(name->vleng);
  270.             name->vleng = 0;
  271.             }
  272.         else if (!name->vimpltype && name->vtype != TYUNKNOWN)
  273.             mixed_type(name);
  274.         else
  275.             settype(name, TYSUBR, (ftnint)0);
  276.         }
  277.     p = mkfunct( mkprim(name, args, CHNULL) );
  278.  
  279. /* Subroutines and their identifiers acquire the type INT */
  280.  
  281.     p->exprblock.vtype = p->exprblock.leftp->headblock.vtype = TYINT;
  282.  
  283. /* Handle the alternate return mechanism */
  284.  
  285.     if(nstars > 0)
  286.         putcmgo(putx(fixtype(p)), nstars, labels);
  287.     else
  288.         putexpr(p);
  289. }
  290.  
  291.  
  292.  
  293. exstop(stop, p)
  294. int stop;
  295. register expptr p;
  296. {
  297.     char *str;
  298.     int n;
  299.     expptr mkstrcon();
  300.  
  301.     if(p)
  302.     {
  303.         if( ! ISCONST(p) )
  304.         {
  305.             execerr("pause/stop argument must be constant", CNULL);
  306.             frexpr(p);
  307.             p = mkstrcon(0, CNULL);
  308.         }
  309.         else if( ISINT(p->constblock.vtype) )
  310.         {
  311.             str = convic(p->constblock.Const.ci);
  312.             n = strlen(str);
  313.             if(n > 0)
  314.             {
  315.                 p->constblock.Const.ccp = copyn(n, str);
  316.                 p->constblock.Const.ccp1.blanks = 0;
  317.                 p->constblock.vtype = TYCHAR;
  318.                 p->constblock.vleng = (expptr) ICON(n);
  319.             }
  320.             else
  321.                 p = (expptr) mkstrcon(0, CNULL);
  322.         }
  323.         else if(p->constblock.vtype != TYCHAR)
  324.         {
  325.             execerr("pause/stop argument must be integer or string", CNULL);
  326.             p = (expptr) mkstrcon(0, CNULL);
  327.         }
  328.     }
  329.     else    p = (expptr) mkstrcon(0, CNULL);
  330.  
  331.     {
  332.     expptr subr_call;
  333.  
  334.     subr_call = call1(TYSUBR, (stop ? "s_stop" : "s_paus"), p);
  335.     putexpr( subr_call );
  336.     }
  337. }
  338.  
  339. /* DO LOOP CODE */
  340.  
  341. #define DOINIT    par[0]
  342. #define DOLIMIT    par[1]
  343. #define DOINCR    par[2]
  344.  
  345.  
  346. /* Macros for   ctlstack -> dostepsign   */
  347.  
  348. #define VARSTEP    0
  349. #define POSSTEP    1
  350. #define NEGSTEP    2
  351.  
  352.  
  353. /* exdo -- generate DO loop code.  In the case of a variable increment,
  354.    positive increment tests are placed above the body, negative increment
  355.    tests are placed below (see   enddo()   ) */
  356.  
  357. exdo(range, loopname, spec)
  358. int range;            /* end label */
  359. Namep loopname;
  360. chainp spec;            /* input spec must have at least 2 exprs */
  361. {
  362.     register expptr p;
  363.     register Namep np;
  364.     chainp cp;        /* loops over the fields in   spec */
  365.     register int i;
  366.     int dotype;        /* type of the index variable */
  367.     int incsign;        /* sign of the increment, if it's constant
  368.                    */
  369.     Addrp dovarp;        /* loop index variable */
  370.     expptr doinit;        /* constant or register for init param */
  371.     expptr par[3];        /* local specification parameters */
  372.  
  373.     expptr init, test, inc;    /* Expressions in the resulting FOR loop */
  374.  
  375.  
  376.     test = ENULL;
  377.  
  378.     pushctl(CTLDO);
  379.     dorange = ctlstack->dolabel = range;
  380.     ctlstack->loopname = loopname;
  381.  
  382. /* Declare the loop index */
  383.  
  384.     np = (Namep)spec->datap;
  385.     ctlstack->donamep = NULL;
  386.     if (!np) { /* do while */
  387.         ctlstack->dowhile = 1;
  388. #if 0
  389.         if (loopname) {
  390.             if (loopname->vtype == TYUNKNOWN) {
  391.                 loopname->vdcldone = 1;
  392.                 loopname->vclass = CLLABEL;
  393.                 loopname->vprocclass = PLABEL;
  394.                 loopname->vtype = TYLABEL;
  395.                 }
  396.             if (loopname->vtype == TYLABEL)
  397.                 if (loopname->vdovar)
  398.                     dclerr("already in use as a loop name",
  399.                         loopname);
  400.                 else
  401.                     loopname->vdovar = 1;
  402.             else
  403.                 dclerr("already declared; cannot