# 2.11BSD#431 - /usr/src/ucb/pascal/pxp/fdec.c

##### Functions

    funcbody          X
    funcend           X
    funcfwd           X
    funchdr           X
    ppsname           X

       1: #
       2: /*
       3:  * pxp - Pascal execution profiler
       4:  *
       5:  * Bill Joy UCB
       6:  * Version 1.2.1 January 1994
       7:  */
       8:
       9: #include "0.h"
      10: #include "tree.h"
      11:
      12: /*
      13:  * Program, procedure or function "header", i.e.:
      14:  *
      15:  *	function sin: real;
      16:  */
      17: funchdr(r)
      18:     int *r;
      19: {
      20:     register **rl, *il;
      21:
      22:     if (inpflist(r[2])) {
      23:         optstk['z'-'a'] <<= 1;
      24:         optstk['z'-'a'] |= opts['z'-'a'];
      25:         opts['z'-'a'] = 1;
      26:     }
      27:     cbn++;
      28:     lastbn = cbn;
      29:     getcnt();
      30:     if (nojunk && !inpflist(r[2]))
      31:         setprint();
      32:     else
      33:         printon();
      34:     if (r[0] == T_PROG && noinclude && bracket)
      35:         printoff();
      36:     if (cbn > 1 && !justify)
      37:         ppgoin(PRFN);
      38:     puthedr();
      39:     if (noblank(setline(r[1])))
      40:         ppnl();
      41:     cnttab(r[2], pfcnt++);
      42:     ppnl();
      43:     indent();
      44:     switch (r[0]) {
      45:         case T_PROG:
      46:             ppkw("program");
      47:             break;
      48:         case T_PDEC:
      49:             ppkw("procedure");
      50:             break;
      51:         case T_FDEC:
      52:             ppkw("function");
      53:             break;
      54:         default:
      55:             panic("funchdr");
      56:     }
      57:     ppspac();
      58:     ppid(r[2]);
      59:     if (r[0] != T_PROG) {
      60:         rl = r[3];
      61:         if (rl != NIL) {
      62:             ppbra("(");
      63:             for (;;) {
      64:                 if (rl[1] == NIL) {
      65:                     rl = rl[2];
      66:                     continue;
      67:                 }
      68:                 switch (rl[1][0]) {
      69:                     case T_PVAR:
      70:                         ppkw("var");
      71:                         ppspac();
      72:                         break;
      73:                     case T_PPROC:
      74:                         ppkw("procedure");
      75:                         ppspac();
      76:                         break;
      77:                     case T_PFUNC:
      78:                         ppkw("function");
      79:                         ppspac();
      80:                         break;
      81:                 }
      82:                 il = rl[1][1];
      83:                 if (il != NIL)
      84:                     for (;;) {
      85:                         ppid(il[1]);
      86:                         il = il[2];
      87:                         if (il == NIL)
      88:                             break;
      89:                         ppsep(", ");
      90:                     }
      91:                 else
      92:                     ppid("{identifier list}");
      93:                 if (rl[1][0] != T_PPROC) {
      94:                     ppsep(":");
      95:                     gtype(rl[1][2]);
      96:                 }
      97:                 rl = rl[2];
      98:                 if (rl == NIL)
      99:                     break;
     100:                 ppsep(";");
     101:                 ppspac();
     102:             }
     103:             ppket(")");
     104:         }
     105:         if (r[0] == T_FDEC && r[4] != NIL) {
     106:             ppsep(":");
     107:             gtype(r[4]);
     108:         }
     109:         ppsep(";");
     110:     } else {
     111:         rl = r[3];
     112:         if (rl != NIL) {
     113:             ppbra("(");
     114:             for (;;) {
     115:                 ppid(rl[1]);
     116:                 rl = rl[2];
     117:                 if (rl == NIL)
     118:                     break;
     119:                 ppsep(", ");
     120:             }
     121:             ppket(")");
     122:         }
     123:         ppsep(";");
     124:     }
     125: fhout:
     126:     setline(r[1]);
     127:     putcml();
     128:     savecnt(&pfcnts[cbn]);
     129:     setprint();
     130:     --cbn;
     131:     if (cbn && !justify)
     132:         ppgoout(PRFN);
     133:     return (r[2]);
     134: }
     135:
     136: /*
     137:  * Forward declaration i.e. the second line of
     138:  *
     139:  *	procedure fum(var i: integer);
     140:  *	    forward;
     141:  */
     142: funcfwd(fp)
     143:     char *fp;
     144: {
     145:
     146:     baroff();
     147:     ppgoin(DECL);
     148:     ppnl();
     149:     indent();
     150:     ppkw("forward");
     151:     ppsep(";");
     152:     ppgoout(DECL);
     153:     baron();
     154:     return (fp);
     155: }
     156:
     157: /*
     158:  * The "body" of a procedure, function, or program declaration,
     159:  * i.e. a non-forward definition encounter.
     160:  */
     161: funcbody(fp)
     162:     char *fp;
     163: {
     164:
     165:     if (cbn && !justify)
     166:         ppgoin(PRFN);
     167:     cbn++;
     168:     lastbn = cbn;
     169:     return (fp);
     170: }
     171:
     172: /*
     173:  * The guts of the procedure, function or program, i.e.
     174:  * the part between the begin and the end.
     175:  */
     176: funcend(fp, bundle, binfo)
     177:     char *fp;
     178:     int *bundle, *binfo;
     179: {
     180:     int *blk;
     181:     extern int cntstat;
     182:
     183:     cntstat = 0;
     184:     blk = bundle[2];
     185:     rescnt(&pfcnts[cbn]);
     186:     setprint();
     187:     if (cbn == 1 && noinclude && bracket)
     188:         printoff();
     189:     if (lastbn > cbn)
     190:         unprint();
     191:     if (cbn == 1)
     192:         puthedr();
     193:     if (noblank(setline(bundle[1])) && lastbn > cbn)
     194:         ppnl();
     195:     ppnl();
     196:     indent();
     197:     ppkw("begin");
     198:     setline(bundle[1]);
     199:     if (putcml() == 0 && lastbn > cbn)
     200:         ppsname(fp);
     201:     ppgoin(DECL);
     202:     statlist(blk);
     203:     setinfo(bundle[1]);
     204:     putcmp();
     205:     ppgoout(DECL);
     206:     ppnl();
     207:     indent();
     208:     ppkw("end");
     209:     ppsep(cbn == 1 ? "." : ";");
     210:     setinfo(binfo);
     211:     if (putcml() == 0)
     212:         ppsname(fp);
     213:     cbn--;
     214:     if (cbn && !justify)
     215:         ppgoout(PRFN);
     216:     if (inpflist(fp)) {
     217:         opts['z'-'a'] = optstk['z'-'a'] & 1;
     218:         optstk['z'-'a'] >>= 1;
     219:     }
     220:     if (cbn == 0) {
     221:         flushcm();
     222:         printon();
     223:         ppnl();
     224:     }
     225: }
     226:
     227: ppsname(fp)
     228:     char *fp;
     229: {
     230:     if (fp == NIL)
     231:         return;
     232:     ppsep(" { ");
     233:     ppid(fp);
     234:     ppsep(" }");
     235: }

#### Defined functions

funcbody defined in line 161; used 3 times

- in /usr/src/ucb/pascal/pxp/pas.y line 131, 140, 285

funcend defined in line 176; used 2 times

- in /usr/src/ucb/pascal/pxp/pas.y line 126, 281

funcfwd defined in line 142; used 1 times

- in /usr/src/ucb/pascal/pxp/pas.y line 278

funchdr defined in line 17; used 3 times

- in /usr/src/ucb/pascal/pxp/pas.y line 131, 140, 289

ppsname defined in line 227; used 2 times

- in line 200, 212

Last modified: 1994-01-07 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 829 |