# 2.11BSD#431 - /usr/src/new/PORT/perl.1.0.0/stab.c

##### Functions

    aadd              X
    hadd              X
    reg_get           X
    reg_set           X
    sighandler        X
    stab_str          X
    stabset           X
    whichsig          X

       1: /* $Header: stab.c,v 1.0 87/12/18 13:06:14 root Exp $
       2:  *
       3:  * $Log:	stab.c,v $
       4:  * Revision 1.0  87/12/18  13:06:14  root
       5:  * Initial revision
       6:  *
       7:  */
       8:
       9: #include <signal.h>
      10: #include "handy.h"
      11: #include "EXTERN.h"
      12: #include "search.h"
      13: #include "util.h"
      14: #include "perl.h"
      15:
      16: static char *sig_name[] = {
      17:     "",
      18:     "HUP",
      19:     "INT",
      20:     "QUIT",
      21:     "ILL",
      22:     "TRAP",
      23:     "IOT",
      24:     "EMT",
      25:     "FPE",
      26:     "KILL",
      27:     "BUS",
      28:     "SEGV",
      29:     "SYS",
      30:     "PIPE",
      31:     "ALRM",
      32:     "TERM",
      33:     "???"
      34: #ifdef SIGTSTP
      35:     ,"STOP",
      36:     "TSTP",
      37:     "CONT",
      38:     "CHLD",
      39:     "TTIN",
      40:     "TTOU",
      41:     "TINT",
      42:     "XCPU",
      43:     "XFSZ"
      44: #ifdef SIGPROF
      45:     ,"VTALARM",
      46:     "PROF"
      47: #ifdef SIGWINCH
      48:     ,"WINCH"
      49: #ifdef SIGLOST
      50:     ,"LOST"
      51: #ifdef SIGUSR1
      52:     ,"USR1"
      53: #endif
      54: #ifdef SIGUSR2
      55:     ,"USR2"
      56: #endif /* SIGUSR2 */
      57: #endif /* SIGLOST */
      58: #endif /* SIGWINCH */
      59: #endif /* SIGPROF */
      60: #endif /* SIGTSTP */
      61:     ,0
      62:     };
      63:
      64: STR *
      65: stab_str(stab)
      66: STAB *stab;
      67: {
      68:     register int paren;
      69:     register char *s;
      70:     extern int errno;
      71:
      72:     switch (*stab->stab_name) {
      73:     case '0': case '1': case '2': case '3': case '4':
      74:     case '5': case '6': case '7': case '8': case '9': case '&':
      75:     if (curspat) {
      76:         paren = atoi(stab->stab_name);
      77:         if (curspat->spat_compex.subend[paren] &&
      78:           (s = getparen(&curspat->spat_compex,paren))) {
      79:         curspat->spat_compex.subend[paren] = Nullch;
      80:         str_set(stab->stab_val,s);
      81:         }
      82:     }
      83:     break;
      84:     case '+':
      85:     if (curspat) {
      86:         paren = curspat->spat_compex.lastparen;
      87:         if (curspat->spat_compex.subend[paren] &&
      88:           (s = getparen(&curspat->spat_compex,paren))) {
      89:         curspat->spat_compex.subend[paren] = Nullch;
      90:         str_set(stab->stab_val,s);
      91:         }
      92:     }
      93:     break;
      94:     case '.':
      95:     if (last_in_stab) {
      96:         str_numset(stab->stab_val,(double)last_in_stab->stab_io->lines);
      97:     }
      98:     break;
      99:     case '?':
     100:     str_numset(stab->stab_val,(double)statusvalue);
     101:     break;
     102:     case '^':
     103:     s = curoutstab->stab_io->top_name;
     104:     str_set(stab->stab_val,s);
     105:     break;
     106:     case '~':
     107:     s = curoutstab->stab_io->fmt_name;
     108:     str_set(stab->stab_val,s);
     109:     break;
     110:     case '=':
     111:     str_numset(stab->stab_val,(double)curoutstab->stab_io->lines);
     112:     break;
     113:     case '-':
     114:     str_numset(stab->stab_val,(double)curoutstab->stab_io->lines_left);
     115:     break;
     116:     case '%':
     117:     str_numset(stab->stab_val,(double)curoutstab->stab_io->page);
     118:     break;
     119:     case '(':
     120:     if (curspat) {
     121:         str_numset(stab->stab_val,(double)(curspat->spat_compex.subbeg[0] -
     122:         curspat->spat_compex.subbase));
     123:     }
     124:     break;
     125:     case ')':
     126:     if (curspat) {
     127:         str_numset(stab->stab_val,(double)(curspat->spat_compex.subend[0] -
     128:         curspat->spat_compex.subbeg[0]));
     129:     }
     130:     break;
     131:     case '/':
     132:     *tokenbuf = record_separator;
     133:     tokenbuf[1] = '\0';
     134:     str_set(stab->stab_val,tokenbuf);
     135:     break;
     136:     case '[':
     137:     str_numset(stab->stab_val,(double)arybase);
     138:     break;
     139:     case '|':
     140:     str_numset(stab->stab_val,
     141:        (double)((curoutstab->stab_io->flags & IOF_FLUSH) != 0) );
     142:     break;
     143:     case ',':
     144:     str_set(stab->stab_val,ofs);
     145:     break;
     146:     case '\\':
     147:     str_set(stab->stab_val,ors);
     148:     break;
     149:     case '#':
     150:     str_set(stab->stab_val,ofmt);
     151:     break;
     152:     case '!':
     153:     str_numset(stab->stab_val,(double)errno);
     154:     break;
     155:     }
     156:     return stab->stab_val;
     157: }
     158:
     159: stabset(stab,str)
     160: register STAB *stab;
     161: STR *str;
     162: {
     163:     char *s;
     164:     int i;
     165:     int sighandler();
     166:
     167:     if (stab->stab_flags & SF_VMAGIC) {
     168:     switch (stab->stab_name[0]) {
     169:     case '^':
     170:         safefree(curoutstab->stab_io->top_name);
     171:         curoutstab->stab_io->top_name = str_get(str);
     172:         curoutstab->stab_io->top_stab = stabent(str_get(str),FALSE);
     173:         break;
     174:     case '~':
     175:         safefree(curoutstab->stab_io->fmt_name);
     176:         curoutstab->stab_io->fmt_name = str_get(str);
     177:         curoutstab->stab_io->fmt_stab = stabent(str_get(str),FALSE);
     178:         break;
     179:     case '=':
     180:         curoutstab->stab_io->page_len = (long)str_gnum(str);
     181:         break;
     182:     case '-':
     183:         curoutstab->stab_io->lines_left = (long)str_gnum(str);
     184:         break;
     185:     case '%':
     186:         curoutstab->stab_io->page = (long)str_gnum(str);
     187:         break;
     188:     case '|':
     189:         curoutstab->stab_io->flags &= ~IOF_FLUSH;
     190:         if (str_gnum(str) != 0.0) {
     191:         curoutstab->stab_io->flags |= IOF_FLUSH;
     192:         }
     193:         break;
     194:     case '*':
     195:         multiline = (int)str_gnum(str) != 0;
     196:         break;
     197:     case '/':
     198:         record_separator = *str_get(str);
     199:         break;
     200:     case '\\':
     201:         if (ors)
     202:         safefree(ors);
     203:         ors = savestr(str_get(str));
     204:         break;
     205:     case ',':
     206:         if (ofs)
     207:         safefree(ofs);
     208:         ofs = savestr(str_get(str));
     209:         break;
     210:     case '#':
     211:         if (ofmt)
     212:         safefree(ofmt);
     213:         ofmt = savestr(str_get(str));
     214:         break;
     215:     case '[':
     216:         arybase = (int)str_gnum(str);
     217:         break;
     218:     case '!':
     219:         errno = (int)str_gnum(str);     /* will anyone ever use this? */
     220:         break;
     221:     case '.':
     222:     case '+':
     223:     case '&':
     224:     case '0':
     225:     case '1':
     226:     case '2':
     227:     case '3':
     228:     case '4':
     229:     case '5':
     230:     case '6':
     231:     case '7':
     232:     case '8':
     233:     case '9':
     234:     case '(':
     235:     case ')':
     236:         break;      /* "read-only" registers */
     237:     }
     238:     }
     239:     else if (stab == envstab && envname) {
     240:     setenv(envname,str_get(str));
     241:                 /* And you'll never guess what the dog had */
     242:     safefree(envname);  /*   in its mouth... */
     243:     envname = Nullch;
     244:     }
     245:     else if (stab == sigstab && signame) {
     246:     s = str_get(str);
     247:     i = whichsig(signame);  /* ...no, a brick */
     248:     if (strEQ(s,"IGNORE"))
     249:         signal(i,SIG_IGN);
     250:     else if (strEQ(s,"DEFAULT") || !*s)
     251:         signal(i,SIG_DFL);
     252:     else
     253:         signal(i,sighandler);
     254:     safefree(signame);
     255:     signame = Nullch;
     256:     }
     257: }
     258:
     259: whichsig(signame)
     260: char *signame;
     261: {
     262:     register char **sigv;
     263:
     264:     for (sigv = sig_name+1; *sigv; sigv++)
     265:     if (strEQ(signame,*sigv))
     266:         return sigv - sig_name;
     267:     return 0;
     268: }
     269:
     270: sighandler(sig)
     271: int sig;
     272: {
     273:     STAB *stab;
     274:     ARRAY *savearray;
     275:     STR *str;
     276:
     277:     stab = stabent(str_get(hfetch(sigstab->stab_hash,sig_name[sig])),FALSE);
     278:     savearray = defstab->stab_array;
     279:     defstab->stab_array = anew();
     280:     str = str_new(0);
     281:     str_set(str,sig_name[sig]);
     282:     apush(defstab->stab_array,str);
     283:     str = cmd_exec(stab->stab_sub);
     284:     afree(defstab->stab_array);  /* put back old $_[] */
     285:     defstab->stab_array = savearray;
     286: }
     287:
     288: char *
     289: reg_get(name)
     290: char *name;
     291: {
     292:     return STAB_GET(stabent(name,TRUE));
     293: }
     294:
     295: #ifdef NOTUSED
     296: reg_set(name,value)
     297: char *name;
     298: char *value;
     299: {
     300:     str_set(STAB_STR(stabent(name,TRUE)),value);
     301: }
     302: #endif
     303:
     304: STAB *
     305: aadd(stab)
     306: register STAB *stab;
     307: {
     308:     if (!stab->stab_array)
     309:     stab->stab_array = anew();
     310:     return stab;
     311: }
     312:
     313: STAB *
     314: hadd(stab)
     315: register STAB *stab;
     316: {
     317:     if (!stab->stab_hash)
     318:     stab->stab_hash = hnew();
     319:     return stab;
     320: }

#### Defined functions

aadd defined in line 304; used 13 times

- in /usr/src/new/PORT/perl.1.0.0/perl.y line 362, 464, 473-477(2), 493-497(2), 507, 530
- in /usr/src/new/PORT/perl.1.0.0/perly.c line 416, 425, 996, 1583
- in /usr/src/new/PORT/perl.1.0.0/stab.h line 57

hadd defined in line 313; used 3 times

- in /usr/src/new/PORT/perl.1.0.0/perl.y line 369, 564
- in /usr/src/new/PORT/perl.1.0.0/stab.h line 58

reg_get defined in line 288; used 2 times

- in /usr/src/new/PORT/perl.1.0.0/perl.h line 95
- in /usr/src/new/PORT/perl.1.0.0/str.c line 414

reg_set defined in line 296; never used
sighandler defined in line 270; used 2 times

- in line 165, 253

stab_str defined in line 64; used 4 times

- in /usr/src/new/PORT/perl.1.0.0/perl.h line 85
- in /usr/src/new/PORT/perl.1.0.0/stab.h line 43-45(3)

stabset defined in line 159; used 1 times

- in /usr/src/new/PORT/perl.1.0.0/str.h line 26

whichsig defined in line 259; used 1 times

- in line 247

#### Defined variables

sig_name defined in line 16; used 4 times

- in line 264-266(2), 277-281(2)

Last modified: 1988-01-31 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 986 |