home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume18 / perl / part20 < prev    next >
Encoding:
Internet Message Format  |  1991-04-16  |  49.7 KB
  1. From: lwall@netlabs.com (Larry Wall)
  2. Newsgroups: comp.sources.misc
  3. Subject: v18i038:  perl - The perl programming language, Part20/36
  4. Message-ID: <1991Apr16.185528.1104@sparky.IMD.Sterling.COM>
  5. Date: 16 Apr 91 18:55:28 GMT
  6. Approved: kent@sparky.imd.sterling.com
  7. X-Checksum-Snefru: dd918dc6 3d15982a 4adef959 11f0a7c1
  8.  
  9. Submitted-by: Larry Wall <lwall@netlabs.com>
  10. Posting-number: Volume 18, Issue 38
  11. Archive-name: perl/part20
  12.  
  13. [There are 36 kits for perl version 4.0.]
  14.  
  15. #! /bin/sh
  16.  
  17. # Make a new directory for the perl sources, cd to it, and run kits 1
  18. # thru 36 through sh.  When all 36 kits have been run, read README.
  19.  
  20. echo "This is perl 4.0 kit 20 (of 36).  If kit 20 is complete, the line"
  21. echo '"'"End of kit 20 (of 36)"'" will echo at the end.'
  22. echo ""
  23. export PATH || (echo "You didn't use sh, you clunch." ; kill $$)
  24. mkdir  2>/dev/null
  25. echo Extracting consarg.c
  26. sed >consarg.c <<'!STUFFY!FUNK!' -e 's/X//'
  27. X/* $RCSfile: consarg.c,v $$Revision: 4.0.1.1 $$Date: 91/04/11 17:38:34 $
  28. X *
  29. X *    Copyright (c) 1989, Larry Wall
  30. X *
  31. X *    You may distribute under the terms of the GNU General Public License
  32. X *    as specified in the README file that comes with the perl 3.0 kit.
  33. X *
  34. X * $Log:    consarg.c,v $
  35. X * Revision 4.0.1.1  91/04/11  17:38:34  lwall
  36. X * patch1: fixed "Bad free" error
  37. X * 
  38. X * Revision 4.0  91/03/20  01:06:15  lwall
  39. X * 4.0 baseline.
  40. X * 
  41. X */
  42. X
  43. X#include "EXTERN.h"
  44. X#include "perl.h"
  45. Xstatic int nothing_in_common();
  46. Xstatic int arg_common();
  47. Xstatic int spat_common();
  48. X
  49. XARG *
  50. Xmake_split(stab,arg,limarg)
  51. Xregister STAB *stab;
  52. Xregister ARG *arg;
  53. XARG *limarg;
  54. X{
  55. X    register SPAT *spat;
  56. X
  57. X    if (arg->arg_type != O_MATCH) {
  58. X    Newz(201,spat,1,SPAT);
  59. X    spat->spat_next = curstash->tbl_spatroot; /* link into spat list */
  60. X    curstash->tbl_spatroot = spat;
  61. X
  62. X    spat->spat_runtime = arg;
  63. X    arg = make_match(O_MATCH,stab2arg(A_STAB,defstab),spat);
  64. X    }
  65. X    Renew(arg,4,ARG);
  66. X    arg->arg_len = 3;
  67. X    if (limarg) {
  68. X    if (limarg->arg_type == O_ITEM) {
  69. X        Copy(limarg+1,arg+3,1,ARG);
  70. X        limarg[1].arg_type = A_NULL;
  71. X        arg_free(limarg);
  72. X    }
  73. X    else {
  74. X        arg[3].arg_flags = 0;
  75. X        arg[3].arg_type = A_EXPR;
  76. X        arg[3].arg_ptr.arg_arg = limarg;
  77. X    }
  78. X    }
  79. X    else
  80. X    arg[3].arg_type = A_NULL;
  81. X    arg->arg_type = O_SPLIT;
  82. X    spat = arg[2].arg_ptr.arg_spat;
  83. X    spat->spat_repl = stab2arg(A_STAB,aadd(stab));
  84. X    if (spat->spat_short) {    /* exact match can bypass regexec() */
  85. X    if (!((spat->spat_flags & SPAT_SCANFIRST) &&
  86. X        (spat->spat_flags & SPAT_ALL) )) {
  87. X        str_free(spat->spat_short);
  88. X        spat->spat_short = Nullstr;
  89. X    }
  90. X    }
  91. X    return arg;
  92. X}
  93. X
  94. XARG *
  95. Xmod_match(type,left,pat)
  96. Xregister ARG *left;
  97. Xregister ARG *pat;
  98. X{
  99. X
  100. X    register SPAT *spat;
  101. X    register ARG *newarg;
  102. X
  103. X    if (!pat)
  104. X    return Nullarg;
  105. X
  106. X    if ((pat->arg_type == O_MATCH ||
  107. X     pat->arg_type == O_SUBST ||
  108. X     pat->arg_type == O_TRANS ||
  109. X     pat->arg_type == O_SPLIT
  110. X    ) &&
  111. X    pat[1].arg_ptr.arg_stab == defstab ) {
  112. X    switch (pat->arg_type) {
  113. X    case O_MATCH:
  114. X        newarg = make_op(type == O_MATCH ? O_MATCH : O_NMATCH,
  115. X        pat->arg_len,
  116. X        left,Nullarg,Nullarg);
  117. X        break;
  118. X    case O_SUBST:
  119. X        newarg = l(make_op(type == O_MATCH ? O_SUBST : O_NSUBST,
  120. X        pat->arg_len,
  121. X        left,Nullarg,Nullarg));
  122. X        break;
  123. X    case O_TRANS:
  124. X        newarg = l(make_op(type == O_MATCH ? O_TRANS : O_NTRANS,
  125. X        pat->arg_len,
  126. X        left,Nullarg,Nullarg));
  127. X        break;
  128. X    case O_SPLIT:
  129. X        newarg = make_op(type == O_MATCH ? O_SPLIT : O_SPLIT,
  130. X        pat->arg_len,
  131. X        left,Nullarg,Nullarg);
  132. X        break;
  133. X    }
  134. X    if (pat->arg_len >= 2) {
  135. X        newarg[2].arg_type = pat[2].arg_type;
  136. X        newarg[2].arg_ptr = pat[2].arg_ptr;
  137. X        newarg[2].arg_len = pat[2].arg_len;
  138. X        newarg[2].arg_flags = pat[2].arg_flags;
  139. X        if (pat->arg_len >= 3) {
  140. X        newarg[3].arg_type = pat[3].arg_type;
  141. X        newarg[3].arg_ptr = pat[3].arg_ptr;
  142. X        newarg[3].arg_len = pat[3].arg_len;
  143. X        newarg[3].arg_flags = pat[3].arg_flags;
  144. X        }
  145. X    }
  146. X    free_arg(pat);
  147. X    }
  148. X    else {
  149. X    Newz(202,spat,1,SPAT);
  150. X    spat->spat_next = curstash->tbl_spatroot; /* link into spat list */
  151. X    curstash->tbl_spatroot = spat;
  152. X
  153. X    spat->spat_runtime = pat;
  154. X    newarg = make_op(type,2,left,Nullarg,Nullarg);
  155. X    newarg[2].arg_type = A_SPAT | A_DONT;
  156. X    newarg[2].arg_ptr.arg_spat = spat;
  157. X    }
  158. X
  159. X    return newarg;
  160. X}
  161. X
  162. XARG *
  163. Xmake_op(type,newlen,arg1,arg2,arg3)
  164. Xint type;
  165. Xint newlen;
  166. XARG *arg1;
  167. XARG *arg2;
  168. XARG *arg3;
  169. X{
  170. X    register ARG *arg;
  171. X    register ARG *chld;
  172. X    register unsigned doarg;
  173. X    register int i;
  174. X    extern ARG *arg4;    /* should be normal arguments, really */
  175. X    extern ARG *arg5;
  176. X
  177. X    arg = op_new(newlen);
  178. X    arg->arg_type = type;
  179. X    if (chld = arg1) {
  180. X    if (chld->arg_type == O_ITEM &&
  181. X        (hoistable[ i = (chld[1].arg_type&A_MASK)] || i == A_LVAL ||
  182. X         (i == A_LEXPR &&
  183. X          (chld[1].arg_ptr.arg_arg->arg_type == O_LIST ||
  184. X           chld[1].arg_ptr.arg_arg->arg_type == O_ARRAY ||
  185. X           chld[1].arg_ptr.arg_arg->arg_type == O_HASH ))))
  186. X    {
  187. X        arg[1].arg_type = chld[1].arg_type;
  188. X        arg[1].arg_ptr = chld[1].arg_ptr;
  189. X        arg[1].arg_flags |= chld[1].arg_flags;
  190. X        arg[1].arg_len = chld[1].arg_len;
  191. X        free_arg(chld);
  192. X    }
  193. X    else {
  194. X        arg[1].arg_type = A_EXPR;
  195. X        arg[1].arg_ptr.arg_arg = chld;
  196. X    }
  197. X    }
  198. X    if (chld = arg2) {
  199. X    if (chld->arg_type == O_ITEM && 
  200. X        (hoistable[chld[1].arg_type&A_MASK] || 
  201. X         (type == O_ASSIGN && 
  202. X          ((chld[1].arg_type == A_READ && !(arg[1].arg_type & A_DONT))
  203. X        ||
  204. X           (chld[1].arg_type == A_INDREAD && !(arg[1].arg_type & A_DONT))
  205. X        ||
  206. X           (chld[1].arg_type == A_GLOB && !(arg[1].arg_type & A_DONT))
  207. X          ) ) ) ) {
  208. X        arg[2].arg_type = chld[1].arg_type;
  209. X        arg[2].arg_ptr = chld[1].arg_ptr;
  210. X        arg[2].arg_len = chld[1].arg_len;
  211. X        free_arg(chld);
  212. X    }
  213. X    else {
  214. X        arg[2].arg_type = A_EXPR;
  215. X        arg[2].arg_ptr.arg_arg = chld;
  216. X    }
  217. X    }
  218. X    if (chld = arg3) {
  219. X    if (chld->arg_type == O_ITEM && hoistable[chld[1].arg_type&A_MASK]) {
  220. X        arg[3].arg_type = chld[1].arg_type;
  221. X        arg[3].arg_ptr = chld[1].arg_ptr;
  222. X        arg[3].arg_len = chld[1].arg_len;
  223. X        free_arg(chld);
  224. X    }
  225. X    else {
  226. X        arg[3].arg_type = A_EXPR;
  227. X        arg[3].arg_ptr.arg_arg = chld;
  228. X    }
  229. X    }
  230. X    if (newlen >= 4 && (chld = arg4)) {
  231. X    if (chld->arg_type == O_ITEM && hoistable[chld[1].arg_type&A_MASK]) {
  232. X        arg[4].arg_type = chld[1].arg_type;
  233. X        arg[4].arg_ptr = chld[1].arg_ptr;
  234. X        arg[4].arg_len = chld[1].arg_len;
  235. X        free_arg(chld);
  236. X    }
  237. X    else {
  238. X        arg[4].arg_type = A_EXPR;
  239. X        arg[4].arg_ptr.arg_arg = chld;
  240. X    }
  241. X    }
  242. X    if (newlen >= 5 && (chld = arg5)) {
  243. X    if (chld->arg_type == O_ITEM && hoistable[chld[1].arg_type&A_MASK]) {
  244. X        arg[5].arg_type = chld[1].arg_type;
  245. X        arg[5].arg_ptr = chld[1].arg_ptr;
  246. X        arg[5].arg_len = chld[1].arg_len;
  247. X        free_arg(chld);
  248. X    }
  249. X    else {
  250. X        arg[5].arg_type = A_EXPR;
  251. X        arg[5].arg_ptr.arg_arg = chld;
  252. X    }
  253. X    }
  254. X    doarg = opargs[type];
  255. X    for (i = 1; i <= newlen; ++i) {
  256. X    if (!(doarg & 1))
  257. X        arg[i].arg_type |= A_DONT;
  258. X    if (doarg & 2)
  259. X        arg[i].arg_flags |= AF_ARYOK;
  260. X    doarg >>= 2;
  261. X    }
  262. X#ifdef DEBUGGING
  263. X    if (debug & 16) {
  264. X    fprintf(stderr,"%lx <= make_op(%s",arg,opname[arg->arg_type]);
  265. X    if (arg1)
  266. X        fprintf(stderr,",%s=%lx",
  267. X        argname[arg[1].arg_type&A_MASK],arg[1].arg_ptr.arg_arg);
  268. X    if (arg2)
  269. X        fprintf(stderr,",%s=%lx",
  270. X        argname[arg[2].arg_type&A_MASK],arg[2].arg_ptr.arg_arg);
  271. X    if (arg3)
  272. X        fprintf(stderr,",%s=%lx",
  273. X        argname[arg[3].arg_type&A_MASK],arg[3].arg_ptr.arg_arg);
  274. X    if (newlen >= 4)
  275. X        fprintf(stderr,",%s=%lx",
  276. X        argname[arg[4].arg_type&A_MASK],arg[4].arg_ptr.arg_arg);
  277. X    if (newlen >= 5)
  278. X        fprintf(stderr,",%s=%lx",
  279. X        argname[arg[5].arg_type&A_MASK],arg[5].arg_ptr.arg_arg);
  280. X    fprintf(stderr,")\n");
  281. X    }
  282. X#endif
  283. X    evalstatic(arg);        /* see if we can consolidate anything */
  284. X    return arg;
  285. X}
  286. X
  287. Xvoid
  288. Xevalstatic(arg)
  289. Xregister ARG *arg;
  290. X{
  291. X    register STR *str;
  292. X    register STR *s1;
  293. X    register STR *s2;
  294. X    double value;        /* must not be register */
  295. X    register char *tmps;
  296. X    int i;
  297. X    unsigned long tmplong;
  298. X    long tmp2;
  299. X    double exp(), log(), sqrt(), modf();
  300. X    char *crypt();
  301. X    double sin(), cos(), atan2(), pow();
  302. X
  303. X    if (!arg || !arg->arg_len)
  304. X    return;
  305. X
  306. X    if ((arg[1].arg_type == A_SINGLE || arg->arg_type == O_AELEM) &&
  307. X    (arg->arg_len == 1 || arg[2].arg_type == A_SINGLE) ) {
  308. X    str = Str_new(20,0);
  309. X    s1 = arg[1].arg_ptr.arg_str;
  310. X    if (arg->arg_len > 1)
  311. X        s2 = arg[2].arg_ptr.arg_str;
  312. X    else
  313. X        s2 = Nullstr;
  314. X    switch (arg->arg_type) {
  315. X    case O_AELEM:
  316. X        i = (int)str_gnum(s2);
  317. X        if (i < 32767 && i >= 0) {
  318. X        arg->arg_type = O_ITEM;
  319. X        arg->arg_len = 1;
  320. X        arg[1].arg_type = A_ARYSTAB;    /* $abc[123] is hoistable now */
  321. X        arg[1].arg_len = i;
  322. X        str_free(s2);
  323. X        arg[2].arg_type = A_NULL;
  324. X        arg[2].arg_ptr.arg_str = Nullstr;
  325. X        }
  326. X        /* FALL THROUGH */
  327. X    default:
  328. X        str_free(str);
  329. X        str = Nullstr;        /* can't be evaluated yet */
  330. X        break;
  331. X    case O_CONCAT:
  332. X        str_sset(str,s1);
  333. X        str_scat(str,s2);
  334. X        break;
  335. X    case O_REPEAT:
  336. X        i = (int)str_gnum(s2);
  337. X        tmps = str_get(s1);
  338. X        str_nset(str,"",0);
  339. X        STR_GROW(str, i * s1->str_cur + 1);
  340. X        repeatcpy(str->str_ptr, tmps, s1->str_cur, i);
  341. X        str->str_cur = i * s1->str_cur;
  342. X        str->str_ptr[str->str_cur] = '\0';
  343. X        break;
  344. X    case O_MULTIPLY:
  345. X        value = str_gnum(s1);
  346. X        str_numset(str,value * str_gnum(s2));
  347. X        break;
  348. X    case O_DIVIDE:
  349. X        value = str_gnum(s2);
  350. X        if (value == 0.0)
  351. X        yyerror("Illegal division by constant zero");
  352. X        else
  353. X#ifdef cray
  354. X        /* insure that 20./5. == 4. */
  355. X        {
  356. X        double x;
  357. X        int    k;
  358. X        x =  str_gnum(s1);
  359. X        if ((double)(int)x     == x &&
  360. X            (double)(int)value == value &&
  361. X            (k = (int)x/(int)value)*(int)value == (int)x) {
  362. X            value = k;
  363. X        } else {
  364. X            value = x/value;
  365. X        }
  366. X        str_numset(str,value);
  367. X        }
  368. X#else
  369. X        str_numset(str,str_gnum(s1) / value);
  370. X#endif
  371. X        break;
  372. X    case O_MODULO:
  373. X        tmplong = (unsigned long)str_gnum(s2);
  374. X        if (tmplong == 0L) {
  375. X        yyerror("Illegal modulus of constant zero");
  376. X        break;
  377. X        }
  378. X        tmp2 = (long)str_gnum(s1);
  379. X#ifndef lint
  380. X        if (tmp2 >= 0)
  381. X        str_numset(str,(double)(tmp2 % tmplong));
  382. X        else
  383. X        str_numset(str,(double)((tmplong-((-tmp2 - 1) % tmplong)) - 1));
  384. X#else
  385. X        tmp2 = tmp2;
  386. X#endif
  387. X        break;
  388. X    case O_ADD:
  389. X        value = str_gnum(s1);
  390. X        str_numset(str,value + str_gnum(s2));
  391. X        break;
  392. X    case O_SUBTRACT:
  393. X        value = str_gnum(s1);
  394. X        str_numset(str,value - str_gnum(s2));
  395. X        break;
  396. X    case O_LEFT_SHIFT:
  397. X        value = str_gnum(s1);
  398. X        i = (int)str_gnum(s2);
  399. X#ifndef lint
  400. X        str_numset(str,(double)(((long)value) << i));
  401. X#endif
  402. X        break;
  403. X    case O_RIGHT_SHIFT:
  404. X        value = str_gnum(s1);
  405. X        i = (int)str_gnum(s2);
  406. X#ifndef lint
  407. X        str_numset(str,(double)(((long)value) >> i));
  408. X#endif
  409. X        break;
  410. X    case O_LT:
  411. X        value = str_gnum(s1);
  412. X        str_numset(str,(value < str_gnum(s2)) ? 1.0 : 0.0);
  413. X        break;
  414. X    case O_GT:
  415. X        value = str_gnum(s1);
  416. X        str_numset(str,(value > str_gnum(s2)) ? 1.0 : 0.0);
  417. X        break;
  418. X    case O_LE:
  419. X        value = str_gnum(s1);
  420. X        str_numset(str,(value <= str_gnum(s2)) ? 1.0 : 0.0);
  421. X        break;
  422. X    case O_GE:
  423. X        value = str_gnum(s1);
  424. X        str_numset(str,(value >= str_gnum(s2)) ? 1.0 : 0.0);
  425. X        break;
  426. X    case O_EQ:
  427. X        if (dowarn) {
  428. X        if ((!s1->str_nok && !looks_like_number(s1)) ||
  429. X            (!s2->str_nok && !looks_like_number(s2)) )
  430. X            warn("Possible use of == on string value");
  431. X        }
  432. X        value = str_gnum(s1);
  433. X        str_numset(str,(value == str_gnum(s2)) ? 1.0 : 0.0);
  434. X        break;
  435. X    case O_NE:
  436. X        value = str_gnum(s1);
  437. X        str_numset(str,(value != str_gnum(s2)) ? 1.0 : 0.0);
  438. X        break;
  439. X    case O_NCMP:
  440. X        value = str_gnum(s1);
  441. X        value -= str_gnum(s2);
  442. X        if (value > 0.0)
  443. X        value = 1.0;
  444. X        else if (value < 0.0)
  445. X        value = -1.0;
  446. X        str_numset(str,value);
  447. X        break;
  448. X    case O_BIT_AND:
  449. X        value = str_gnum(s1);
  450. X#ifndef lint
  451. X        str_numset(str,(double)(U_L(value) & U_L(str_gnum(s2))));
  452. X#endif
  453. X        break;
  454. X    case O_XOR:
  455. X        value = str_gnum(s1);
  456. X#ifndef lint
  457. X        str_numset(str,(double)(U_L(value) ^ U_L(str_gnum(s2))));
  458. X#endif
  459. X        break;
  460. X    case O_BIT_OR:
  461. X        value = str_gnum(s1);
  462. X#ifndef lint
  463. X        str_numset(str,(double)(U_L(value) | U_L(str_gnum(s2))));
  464. X#endif
  465. X        break;
  466. X    case O_AND:
  467. X        if (str_true(s1))
  468. X        str_sset(str,s2);
  469. X        else
  470. X        str_sset(str,s1);
  471. X        break;
  472. X    case O_OR:
  473. X        if (str_true(s1))
  474. X        str_sset(str,s1);
  475. X        else
  476. X        str_sset(str,s2);
  477. X        break;
  478. X    case O_COND_EXPR:
  479. X        if ((arg[3].arg_type & A_MASK) != A_SINGLE) {
  480. X        str_free(str);
  481. X        str = Nullstr;
  482. X        }
  483. X        else {
  484. X        if (str_true(s1))
  485. X            str_sset(str,s2);
  486. X        else
  487. X            str_sset(str,arg[3].arg_ptr.arg_str);
  488. X        str_free(arg[3].arg_ptr.arg_str);
  489. X        arg[3].arg_ptr.arg_str = Nullstr;
  490. X        }
  491. X        break;
  492. X    case O_NEGATE:
  493. X        str_numset(str,(double)(-str_gnum(s1)));
  494. X        break;
  495. X    case O_NOT:
  496. X        str_numset(str,(double)(!str_true(s1)));
  497. X        break;
  498. X    case O_COMPLEMENT:
  499. X#ifndef lint
  500. X        str_numset(str,(double)(~U_L(str_gnum(s1))));
  501. X#endif
  502. X        break;
  503. X    case O_SIN:
  504. X        str_numset(str,sin(str_gnum(s1)));
  505. X        break;
  506. X    case O_COS:
  507. X        str_numset(str,cos(str_gnum(s1)));
  508. X        break;
  509. X    case O_ATAN2:
  510. X        value = str_gnum(s1);
  511. X        str_numset(str,atan2(value, str_gnum(s2)));
  512. X        break;
  513. X    case O_POW:
  514. X        value = str_gnum(s1);
  515. X        str_numset(str,pow(value, str_gnum(s2)));
  516. X        break;
  517. X    case O_LENGTH:
  518. X        str_numset(str, (double)str_len(s1));
  519. X        break;
  520. X    case O_SLT:
  521. X        str_numset(str,(double)(str_cmp(s1,s2) < 0));
  522. X        break;
  523. X    case O_SGT:
  524. X        str_numset(str,(double)(str_cmp(s1,s2) > 0));
  525. X        break;
  526. X    case O_SLE:
  527. X        str_numset(str,(double)(str_cmp(s1,s2) <= 0));
  528. X        break;
  529. X    case O_SGE:
  530. X        str_numset(str,(double)(str_cmp(s1,s2) >= 0));
  531. X        break;
  532. X    case O_SEQ:
  533. X        str_numset(str,(double)(str_eq(s1,s2)));
  534. X        break;
  535. X    case O_SNE:
  536. X        str_numset(str,(double)(!str_eq(s1,s2)));
  537. X        break;
  538. X    case O_SCMP:
  539. X        str_numset(str,(double)(str_cmp(s1,s2)));
  540. X        break;
  541. X    case O_CRYPT:
  542. X#ifdef HAS_CRYPT
  543. X        tmps = str_get(s1);
  544. X        str_set(str,crypt(tmps,str_get(s2)));
  545. X#else
  546. X        yyerror(
  547. X        "The crypt() function is unimplemented due to excessive paranoia.");
  548. X#endif
  549. X        break;
  550. X    case O_EXP:
  551. X        str_numset(str,exp(str_gnum(s1)));
  552. X        break;
  553. X    case O_LOG:
  554. X        str_numset(str,log(str_gnum(s1)));
  555. X        break;
  556. X    case O_SQRT:
  557. X        str_numset(str,sqrt(str_gnum(s1)));
  558. X        break;
  559. X    case O_INT:
  560. X        value = str_gnum(s1);
  561. X        if (value >= 0.0)
  562. X        (void)modf(value,&value);
  563. X        else {
  564. X        (void)modf(-value,&value);
  565. X        value = -value;
  566. X        }
  567. X        str_numset(str,value);
  568. X        break;
  569. X    case O_ORD:
  570. X#ifndef I286
  571. X        str_numset(str,(double)(*str_get(s1)));
  572. X#else
  573. X        {
  574. X        int  zapc;
  575. X        char *zaps;
  576. X
  577. X        zaps = str_get(s1);
  578. X        zapc = (int) *zaps;
  579. X        str_numset(str,(double)(zapc));
  580. X        }
  581. X#endif
  582. X        break;
  583. X    }
  584. X    if (str) {
  585. X        arg->arg_type = O_ITEM;    /* note arg1 type is already SINGLE */
  586. X        str_free(s1);
  587. X        arg[1].arg_ptr.arg_str = str;
  588. X        if (s2) {
  589. X        str_free(s2);
  590. X        arg[2].arg_ptr.arg_str = Nullstr;
  591. X        arg[2].arg_type = A_NULL;
  592. X        }
  593. X    }
  594. X    }
  595. X}
  596. X
  597. XARG *
  598. Xl(arg)
  599. Xregister ARG *arg;
  600. X{
  601. X    register int i;
  602. X    register ARG *arg1;
  603. X    register ARG *arg2;
  604. X    SPAT *spat;
  605. X    int arghog = 0;
  606. X
  607. X    i = arg[1].arg_type & A_MASK;
  608. X
  609. X    arg->arg_flags |= AF_COMMON;    /* assume something in common */
  610. X                    /* which forces us to copy things */
  611. X
  612. X    if (i == A_ARYLEN) {
  613. X    arg[1].arg_type = A_LARYLEN;
  614. X    return arg;
  615. X    }
  616. X    if (i == A_ARYSTAB) {
  617. X    arg[1].arg_type = A_LARYSTAB;
  618. X    return arg;
  619. X    }
  620. X
  621. X    /* see if it's an array reference */
  622. X
  623. X    if (i == A_EXPR || i == A_LEXPR) {
  624. X    arg1 = arg[1].arg_ptr.arg_arg;
  625. X
  626. X    if (arg1->arg_type == O_LIST || arg1->arg_type == O_ITEM) {
  627. X                        /* assign to list */
  628. X        if (arg->arg_len > 1) {
  629. X        dehoist(arg,2);
  630. X        arg2 = arg[2].arg_ptr.arg_arg;
  631. X        if (nothing_in_common(arg1,arg2))
  632. X            arg->arg_flags &= ~AF_COMMON;
  633. X        if (arg->arg_type == O_ASSIGN) {
  634. X            if (arg1->arg_flags & AF_LOCAL)
  635. X            arg->arg_flags |= AF_LOCAL;
  636. X            arg[1].arg_flags |= AF_ARYOK;
  637. X            arg[2].arg_flags |= AF_ARYOK;
  638. X        }
  639. X        }
  640. X        else if (arg->arg_type != O_CHOP)
  641. X        arg->arg_type = O_ASSIGN;    /* possible local(); */
  642. X        for (i = arg1->arg_len; i >= 1; i--) {
  643. X        switch (arg1[i].arg_type) {
  644. X        case A_STAR: case A_LSTAR:
  645. X            arg1[i].arg_type = A_LSTAR;
  646. X            break;
  647. X        case A_STAB: case A_LVAL:
  648. X            arg1[i].arg_type = A_LVAL;
  649. X            break;
  650. X        case A_ARYLEN: case A_LARYLEN:
  651. X            arg1[i].arg_type = A_LARYLEN;
  652. X            break;
  653. X        case A_ARYSTAB: case A_LARYSTAB:
  654. X            arg1[i].arg_type = A_LARYSTAB;
  655. X            break;
  656. X        case A_EXPR: case A_LEXPR:
  657. X            arg1[i].arg_type = A_LEXPR;
  658. X            switch(arg1[i].arg_ptr.arg_arg->arg_type) {
  659. X            case O_ARRAY: case O_LARRAY:
  660. X            arg1[i].arg_ptr.arg_arg->arg_type = O_LARRAY;
  661. X            arghog = 1;
  662. X            break;
  663. X            case O_AELEM: case O_LAELEM:
  664. X            arg1[i].arg_ptr.arg_arg->arg_type = O_LAELEM;
  665. X            break;
  666. X            case O_HASH: case O_LHASH:
  667. X            arg1[i].arg_ptr.arg_arg->arg_type = O_LHASH;
  668. X            arghog = 1;
  669. X            break;
  670. X            case O_HELEM: case O_LHELEM:
  671. X            arg1[i].arg_ptr.arg_arg->arg_type = O_LHELEM;
  672. X            break;
  673. X            case O_ASLICE: case O_LASLICE:
  674. X            arg1[i].arg_ptr.arg_arg->arg_type = O_LASLICE;
  675. X            break;
  676. X            case O_HSLICE: case O_LHSLICE:
  677. X            arg1[i].arg_ptr.arg_arg->arg_type = O_LHSLICE;
  678. X            break;
  679. X            default:
  680. X            goto ill_item;
  681. X            }
  682. X            break;
  683. X        default:
  684. X          ill_item:
  685. X            (void)sprintf(tokenbuf, "Illegal item (%s) as lvalue",
  686. X              argname[arg1[i].arg_type&A_MASK]);
  687. X            yyerror(tokenbuf);
  688. X        }
  689. X        }
  690. X        if (arg->arg_len > 1) {
  691. X        if (arg2->arg_type == O_SPLIT && !arg2[3].arg_type && !arghog) {
  692. X            arg2[3].arg_type = A_SINGLE;
  693. X            arg2[3].arg_ptr.arg_str =
  694. X              str_nmake((double)arg1->arg_len + 1); /* limit split len*/
  695. X        }
  696. X        }
  697. X    }
  698. X    else if (arg1->arg_type == O_AELEM || arg1->arg_type == O_LAELEM)
  699. X        if (arg->arg_type == O_DEFINED)
  700. X        arg1->arg_type = O_AELEM;
  701. X        else
  702. X        arg1->arg_type = O_LAELEM;
  703. X    else if (arg1->arg_type == O_ARRAY || arg1->arg_type == O_LARRAY) {
  704. X        arg1->arg_type = O_LARRAY;
  705. X        if (arg->arg_len > 1) {
  706. X        dehoist(arg,2);
  707. X        arg2 = arg[2].arg_ptr.arg_arg;
  708. X        if (arg2->arg_type == O_SPLIT) { /* use split's builtin =?*/
  709. X            spat = arg2[2].arg_ptr.arg_spat;
  710. X            if (!(spat->spat_flags & SPAT_ONCE) &&
  711. X              nothing_in_common(arg1,spat->spat_repl)) {
  712. X            spat->spat_repl[1].arg_ptr.arg_stab =
  713. X                arg1[1].arg_ptr.arg_stab;
  714. X            arg1[1].arg_ptr.arg_stab = Nullstab;
  715. X            spat->spat_flags |= SPAT_ONCE;
  716. X            arg_free(arg1);    /* recursive */
  717. X            arg[1].arg_ptr.arg_arg = Nullarg;
  718. X            free_arg(arg);    /* non-recursive */
  719. X            return arg2;    /* split has builtin assign */
  720. X            }
  721. X        }
  722. X        else if (nothing_in_common(arg1,arg2))
  723. X            arg->arg_flags &= ~AF_COMMON;
  724. X        if (arg->arg_type == O_ASSIGN) {
  725. X            arg[1].arg_flags |= AF_ARYOK;
  726. X            arg[2].arg_flags |= AF_ARYOK;
  727. X        }
  728. X        }
  729. X        else if (arg->arg_type == O_ASSIGN)
  730. X        arg[1].arg_flags |= AF_ARYOK;
  731. X    }
  732. X    else if (arg1->arg_type == O_HELEM || arg1->arg_type == O_LHELEM)
  733. X        if (arg->arg_type == O_DEFINED)
  734. X        arg1->arg_type = O_HELEM;    /* avoid creating one */
  735. X        else
  736. X        arg1->arg_type = O_LHELEM;
  737. X    else if (arg1->arg_type == O_HASH || arg1->arg_type == O_LHASH) {
  738. X        arg1->arg_type = O_LHASH;
  739. X        if (arg->arg_len > 1) {
  740. X        dehoist(arg,2);
  741. X        arg2 = arg[2].arg_ptr.arg_arg;
  742. X        if (nothing_in_common(arg1,arg2))
  743. X            arg->arg_flags &= ~AF_COMMON;
  744. X        if (arg->arg_type == O_ASSIGN) {
  745. X            arg[1].arg_flags |= AF_ARYOK;
  746. X            arg[2].arg_flags |= AF_ARYOK;
  747. X        }
  748. X        }
  749. X        else if (arg->arg_type == O_ASSIGN)
  750. X        arg[1].arg_flags |= AF_ARYOK;
  751. X    }
  752. X    else if (arg1->arg_type == O_ASLICE) {
  753. X        arg1->arg_type = O_LASLICE;
  754. X        if (arg->arg_type == O_ASSIGN) {
  755. X        dehoist(arg,2);
  756. X        arg[1].arg_flags |= AF_ARYOK;
  757. X        arg[2].arg_flags |= AF_ARYOK;
  758. X        }
  759. X    }
  760. X    else if (arg1->arg_type == O_HSLICE) {
  761. X        arg1->arg_type = O_LHSLICE;
  762. X        if (arg->arg_type == O_ASSIGN) {
  763. X        dehoist(arg,2);
  764. X        arg[1].arg_flags |= AF_ARYOK;
  765. X        arg[2].arg_flags |= AF_ARYOK;
  766. X        }
  767. X    }
  768. X    else if ((arg->arg_type == O_DEFINED || arg->arg_type == O_UNDEF) &&
  769. X      (arg1->arg_type == (perldb ? O_DBSUBR : O_SUBR)) ) {
  770. X        arg[1].arg_type |= A_DONT;
  771. X    }
  772. X    else if (arg1->arg_type == O_SUBSTR || arg1->arg_type == O_VEC) {
  773. X        (void)l(arg1);
  774. X        Renewc(arg1->arg_ptr.arg_str, 1, struct lstring, STR);
  775. X            /* grow string struct to hold an lstring struct */
  776. X    }
  777. X    else if (arg1->arg_type == O_ASSIGN) {
  778. X/*        if (arg->arg_type == O_CHOP)
  779. X        arg[1].arg_flags &= ~AF_ARYOK;    /* grandfather chop idiom */
  780. X    }
  781. X    else {
  782. X        (void)sprintf(tokenbuf,
  783. X          "Illegal expression (%s) as lvalue",opname[arg1->arg_type]);
  784. X        yyerror(tokenbuf);
  785. X    }
  786. X    arg[1].arg_type = A_LEXPR | (arg[1].arg_type & A_DONT);
  787. X    if (arg->arg_type == O_ASSIGN && (arg1[1].arg_flags & AF_ARYOK)) {
  788. X        arg[1].arg_flags |= AF_ARYOK;
  789. X        if (arg->arg_len > 1)
  790. X        arg[2].arg_flags |= AF_ARYOK;
  791. X    }
  792. X#ifdef DEBUGGING
  793. X    if (debug & 16)
  794. X        fprintf(stderr,"lval LEXPR\n");
  795. X#endif
  796. X    return arg;
  797. X    }
  798. X    if (i == A_STAR || i == A_LSTAR) {
  799. X    arg[1].arg_type = A_LSTAR | (arg[1].arg_type & A_DONT);
  800. X    return arg;
  801. X    }
  802. X
  803. X    /* not an array reference, should be a register name */
  804. X
  805. X    if (i != A_STAB && i != A_LVAL) {
  806. X    (void)sprintf(tokenbuf,
  807. X      "Illegal item (%s) as lvalue",argname[arg[1].arg_type&A_MASK]);
  808. X    yyerror(tokenbuf);
  809. X    }
  810. X    arg[1].arg_type = A_LVAL | (arg[1].arg_type & A_DONT);
  811. X#ifdef DEBUGGING
  812. X    if (debug & 16)
  813. X    fprintf(stderr,"lval LVAL\n");
  814. X#endif
  815. X    return arg;
  816. X}
  817. X
  818. XARG *
  819. Xfixl(type,arg)
  820. Xint type;
  821. XARG *arg;
  822. X{
  823. X    if (type == O_DEFINED || type == O_UNDEF) {
  824. X    if (arg->arg_type != O_ITEM)
  825. X        arg = hide_ary(arg);
  826. X    if (arg->arg_type == O_ITEM) {
  827. X        type = arg[1].arg_type & A_MASK;
  828. X        if (type == A_EXPR || type == A_LEXPR)
  829. X        arg[1].arg_type = A_LEXPR|A_DONT;
  830. X    }
  831. X    }
  832. X    return arg;
  833. X}
  834. X
  835. Xdehoist(arg,i)
  836. XARG *arg;
  837. X{
  838. X    ARG *tmparg;
  839. X
  840. X    if (arg[i].arg_type != A_EXPR) {    /* dehoist */
  841. X    tmparg = make_op(O_ITEM,1,Nullarg,Nullarg,Nullarg);
  842. X    tmparg[1] = arg[i];
  843. X    arg[i].arg_ptr.arg_arg = tmparg;
  844. X    arg[i].arg_type = A_EXPR;
  845. X    }
  846. X}
  847. X
  848. XARG *
  849. Xaddflags(i,flags,arg)
  850. Xregister ARG *arg;
  851. X{
  852. X    arg[i].arg_flags |= flags;
  853. X    return arg;
  854. X}
  855. X
  856. XARG *
  857. Xhide_ary(arg)
  858. XARG *arg;
  859. X{
  860. X    if (arg->arg_type == O_ARRAY || arg->arg_type == O_HASH)
  861. X    return make_op(O_ITEM,1,arg,Nullarg,Nullarg);
  862. X    return arg;
  863. X}
  864. X
  865. X/* maybe do a join on multiple array dimensions */
  866. X
  867. XARG *
  868. Xjmaybe(arg)
  869. Xregister ARG *arg;
  870. X{
  871. X    if (arg && arg->arg_type == O_COMMA) {
  872. X    arg = listish(arg);
  873. X    arg = make_op(O_JOIN, 2,
  874. X        stab2arg(A_STAB,stabent(";",TRUE)),
  875. X        make_list(arg),
  876. X        Nullarg);
  877. X    }
  878. X    return arg;
  879. X}
  880. X
  881. XARG *
  882. Xmake_list(arg)
  883. Xregister ARG *arg;
  884. X{
  885. X    register int i;
  886. X    register ARG *node;
  887. X    register ARG *nxtnode;
  888. X    register int j;
  889. X    STR *tmpstr;
  890. X
  891. X    if (!arg) {
  892. X    arg = op_new(0);
  893. X    arg->arg_type = O_LIST;
  894. X    }
  895. X    if (arg->arg_type != O_COMMA) {
  896. X    if (arg->arg_type != O_ARRAY)
  897. X        arg->arg_flags |= AF_LISTISH;    /* see listish() below */
  898. X        arg->arg_flags |= AF_LISTISH;    /* see listish() below */
  899. X    return arg;
  900. X    }
  901. X    for (i = 2, node = arg; ; i++) {
  902. X    if (node->arg_len < 2)
  903. X        break;
  904. X        if (node[1].arg_type != A_EXPR)
  905. X        break;
  906. X    node = node[1].arg_ptr.arg_arg;
  907. X    if (node->arg_type != O_COMMA)
  908. X        break;
  909. X    }
  910. X    if (i > 2) {
  911. X    node = arg;
  912. X    arg = op_new(i);
  913. X    tmpstr = arg->arg_ptr.arg_str;
  914. X#ifdef STRUCTCOPY
  915. X    *arg = *node;        /* copy everything except the STR */
  916. X#else
  917. X    (void)bcopy((char *)node, (char *)arg, sizeof(ARG));
  918. X#endif
  919. X    arg->arg_ptr.arg_str = tmpstr;
  920. X    for (j = i; ; ) {
  921. X#ifdef STRUCTCOPY
  922. X        arg[j] = node[2];
  923. X#else
  924. X        (void)bcopy((char *)(node+2), (char *)(arg+j), sizeof(ARG));
  925. X#endif
  926. X        arg[j].arg_flags |= AF_ARYOK;
  927. X        --j;        /* Bug in Xenix compiler */
  928. X        if (j < 2) {
  929. X#ifdef STRUCTCOPY
  930. X        arg[1] = node[1];
  931. X#else
  932. X        (void)bcopy((char *)(node+1), (char *)(arg+1), sizeof(ARG));
  933. X#endif
  934. X        free_arg(node);
  935. X        break;
  936. X        }
  937. X        nxtnode = node[1].arg_ptr.arg_arg;
  938. X        free_arg(node);
  939. X        node = nxtnode;
  940. X    }
  941. X    }
  942. X    arg[1].arg_flags |= AF_ARYOK;
  943. X    arg[2].arg_flags |= AF_ARYOK;
  944. X    arg->arg_type = O_LIST;
  945. X    arg->arg_len = i;
  946. X    return arg;
  947. X}
  948. X
  949. X/* turn a single item into a list */
  950. X
  951. XARG *
  952. Xlistish(arg)
  953. XARG *arg;
  954. X{
  955. X    if (arg->arg_flags & AF_LISTISH)
  956. X    arg = make_op(O_LIST,1,arg,Nullarg,Nullarg);
  957. X    return arg;
  958. X}
  959. X
  960. XARG *
  961. Xmaybelistish(optype, arg)
  962. Xint optype;
  963. XARG *arg;
  964. X{
  965. X    ARG *tmparg = arg;
  966. X
  967. X    if (optype == O_RETURN && arg->arg_type == O_ITEM &&
  968. X      arg[1].arg_type == A_EXPR && (tmparg = arg[1].arg_ptr.arg_arg) &&
  969. X      ((tmparg->arg_flags & AF_LISTISH) || (tmparg->arg_type == O_ARRAY) )) {
  970. X    tmparg = listish(tmparg);
  971. X    free_arg(arg);
  972. X    arg = tmparg;
  973. X    }
  974. X    else if (optype == O_PRTF ||
  975. X      (arg->arg_type == O_ASLICE || arg->arg_type == O_HSLICE ||
  976. X       arg->arg_type == O_F_OR_R) )
  977. X    arg = listish(arg);
  978. X    return arg;
  979. X}
  980. X
  981. X/* mark list of local variables */
  982. X
  983. XARG *
  984. Xlocalize(arg)
  985. XARG *arg;
  986. X{
  987. X    arg->arg_flags |= AF_LOCAL;
  988. X    return arg;
  989. X}
  990. X
  991. XARG *
  992. Xrcatmaybe(arg)
  993. XARG *arg;
  994. X{
  995. X    ARG *arg2;
  996. X
  997. X    if (arg->arg_type == O_CONCAT && arg[2].arg_type == A_EXPR) {
  998. X    arg2 = arg[2].arg_ptr.arg_arg;
  999. X    if (arg2->arg_type == O_ITEM && arg2[1].arg_type == A_READ) {
  1000. X        arg->arg_type = O_RCAT;    
  1001. X        arg[2].arg_type = arg2[1].arg_type;
  1002. X        arg[2].arg_ptr = arg2[1].arg_ptr;
  1003. X        free_arg(arg2);
  1004. X    }
  1005. X    }
  1006. X    return arg;
  1007. X}
  1008. X
  1009. XARG *
  1010. Xstab2arg(atype,stab)
  1011. Xint atype;
  1012. Xregister STAB *stab;
  1013. X{
  1014. X    register ARG *arg;
  1015. X
  1016. X    arg = op_new(1);
  1017. X    arg->arg_type = O_ITEM;
  1018. X    arg[1].arg_type = atype;
  1019. X    arg[1].arg_ptr.arg_stab = stab;
  1020. X    return arg;
  1021. X}
  1022. X
  1023. XARG *
  1024. Xcval_to_arg(cval)
  1025. Xregister char *cval;
  1026. X{
  1027. X    register ARG *arg;
  1028. X
  1029. X    arg = op_new(1);
  1030. X    arg->arg_type = O_ITEM;
  1031. X    arg[1].arg_type = A_SINGLE;
  1032. X    arg[1].arg_ptr.arg_str = str_make(cval,0);
  1033. X    Safefree(cval);
  1034. X    return arg;
  1035. X}
  1036. X
  1037. XARG *
  1038. Xop_new(numargs)
  1039. Xint numargs;
  1040. X{
  1041. X    register ARG *arg;
  1042. X
  1043. X    Newz(203,arg, numargs + 1, ARG);
  1044. X    arg->arg_ptr.arg_str = Str_new(21,0);
  1045. X    arg->arg_len = numargs;
  1046. X    return arg;
  1047. X}
  1048. X
  1049. Xvoid
  1050. Xfree_arg(arg)
  1051. XARG *arg;
  1052. X{
  1053. X    str_free(arg->arg_ptr.arg_str);
  1054. X    Safefree(arg);
  1055. X}
  1056. X
  1057. XARG *
  1058. Xmake_match(type,expr,spat)
  1059. Xint type;
  1060. XARG *expr;
  1061. XSPAT *spat;
  1062. X{
  1063. X    register ARG *arg;
  1064. X
  1065. X    arg = make_op(type,2,expr,Nullarg,Nullarg);
  1066. X
  1067. X    arg[2].arg_type = A_SPAT|A_DONT;
  1068. X    arg[2].arg_ptr.arg_spat = spat;
  1069. X#ifdef DEBUGGING
  1070. X    if (debug & 16)
  1071. X    fprintf(stderr,"make_match SPAT=%lx\n",(long)spat);
  1072. X#endif
  1073. X
  1074. X    if (type == O_SUBST || type == O_NSUBST) {
  1075. X    if (arg[1].arg_type != A_STAB) {
  1076. X        yyerror("Illegal lvalue");
  1077. X    }
  1078. X    arg[1].arg_type = A_LVAL;
  1079. X    }
  1080. X    return arg;
  1081. X}
  1082. X
  1083. XARG *
  1084. Xcmd_to_arg(cmd)
  1085. XCMD *cmd;
  1086. X{
  1087. X    register ARG *arg;
  1088. X
  1089. X    arg = op_new(1);
  1090. X    arg->arg_type = O_ITEM;
  1091. X    arg[1].arg_type = A_CMD;
  1092. X    arg[1].arg_ptr.arg_cmd = cmd;
  1093. X    return arg;
  1094. X}
  1095. X
  1096. X/* Check two expressions to see if there is any identifier in common */
  1097. X
  1098. Xstatic int
  1099. Xnothing_in_common(arg1,arg2)
  1100. XARG *arg1;
  1101. XARG *arg2;
  1102. X{
  1103. X    static int thisexpr = 0;    /* I don't care if this wraps */
  1104. X
  1105. X    thisexpr++;
  1106. X    if (arg_common(arg1,thisexpr,1))
  1107. X    return 0;    /* hit eval or do {} */
  1108. X    stab_lastexpr(defstab) = thisexpr;        /* pretend to hit @_ */
  1109. X    if (arg_common(arg2,thisexpr,0))
  1110. X    return 0;    /* hit identifier again */
  1111. X    return 1;
  1112. X}
  1113. X
  1114. X/* Recursively descend an expression and mark any identifier or check
  1115. X * it to see if it was marked already.
  1116. X */
  1117. X
  1118. Xstatic int
  1119. Xarg_common(arg,exprnum,marking)
  1120. Xregister ARG *arg;
  1121. Xint exprnum;
  1122. Xint marking;
  1123. X{
  1124. X    register int i;
  1125. X
  1126. X    if (!arg)
  1127. X    return 0;
  1128. X    for (i = arg->arg_len; i >= 1; i--) {
  1129. X    switch (arg[i].arg_type & A_MASK) {
  1130. X    case A_NULL:
  1131. X        break;
  1132. X    case A_LEXPR:
  1133. X    case A_EXPR:
  1134. X        if (arg_common(arg[i].arg_ptr.arg_arg,exprnum,marking))
  1135. X        return 1;
  1136. X        break;
  1137. X    case A_CMD:
  1138. X        return 1;        /* assume hanky panky */
  1139. X    case A_STAR:
  1140. X    case A_LSTAR:
  1141. X    case A_STAB:
  1142. X    case A_LVAL:
  1143. X    case A_ARYLEN:
  1144. X    case A_LARYLEN:
  1145. X        if (marking)
  1146. X        stab_lastexpr(arg[i].arg_ptr.arg_stab) = exprnum;
  1147. X        else if (stab_lastexpr(arg[i].arg_ptr.arg_stab) == exprnum)
  1148. X        return 1;
  1149. X        break;
  1150. X    case A_DOUBLE:
  1151. X    case A_BACKTICK:
  1152. X        {
  1153. X        register char *s = arg[i].arg_ptr.arg_str->str_ptr;
  1154. X        register char *send = s + arg[i].arg_ptr.arg_str->str_cur;
  1155. X        register STAB *stab;
  1156. X
  1157. X        while (*s) {
  1158. X            if (*s == '$' && s[1]) {
  1159. X            s = scanident(s,send,tokenbuf);
  1160. X            stab = stabent(tokenbuf,TRUE);
  1161. X            if (marking)
  1162. X                stab_lastexpr(stab) = exprnum;
  1163. X            else if (stab_lastexpr(stab) == exprnum)
  1164. X                return 1;
  1165. X            continue;
  1166. X            }
  1167. X            else if (*s == '\\' && s[1])
  1168. X            s++;
  1169. X            s++;
  1170. X        }
  1171. X        }
  1172. X        break;
  1173. X    case A_SPAT:
  1174. X        if (spat_common(arg[i].arg_ptr.arg_spat,exprnum,marking))
  1175. X        return 1;
  1176. X        break;
  1177. X    case A_READ:
  1178. X    case A_INDREAD:
  1179. X    case A_GLOB:
  1180. X    case A_WORD:
  1181. X    case A_SINGLE:
  1182. X        break;
  1183. X    }
  1184. X    }
  1185. X    switch (arg->arg_type) {
  1186. X    case O_ARRAY:
  1187. X    case O_LARRAY:
  1188. X    if ((arg[1].arg_type & A_MASK) == A_STAB)
  1189. X        (void)aadd(arg[1].arg_ptr.arg_stab);
  1190. X    break;
  1191. X    case O_HASH:
  1192. X    case O_LHASH:
  1193. X    if ((arg[1].arg_type & A_MASK) == A_STAB)
  1194. X        (void)hadd(arg[1].arg_ptr.arg_stab);
  1195. X    break;
  1196. X    case O_EVAL:
  1197. X    case O_SUBR:
  1198. X    case O_DBSUBR:
  1199. X    return 1;
  1200. X    }
  1201. X    return 0;
  1202. X}
  1203. X
  1204. Xstatic int
  1205. Xspat_common(spat,exprnum,marking)
  1206. Xregister SPAT *spat;
  1207. Xint exprnum;
  1208. Xint marking;
  1209. X{
  1210. X    if (spat->spat_runtime)
  1211. X    if (arg_common(spat->spat_runtime,exprnum,marking))
  1212. X        return 1;
  1213. X    if (spat->spat_repl) {
  1214. X    if (arg_common(spat->spat_repl,exprnum,marking))
  1215. X        return 1;
  1216. X    }
  1217. X    return 0;
  1218. X}
  1219. !STUFFY!FUNK!
  1220. echo Extracting arg.h
  1221. sed >arg.h <<'!STUFFY!FUNK!' -e 's/X//'
  1222. X/* $Header: arg.h,v 4.0 91/03/20 01:03:09 lwall Locked $
  1223. X *
  1224. X *    Copyright (c) 1989, Larry Wall
  1225. X *
  1226. X *    You may distribute under the terms of the GNU General Public License
  1227. X *    as specified in the README file that comes with the perl 3.0 kit.
  1228. X *
  1229. X * $Log:    arg.h,v $
  1230. X * Revision 4.0  91/03/20  01:03:09  lwall
  1231. X * 4.0 baseline.
  1232. X * 
  1233. X */
  1234. X
  1235. X#define O_NULL 0
  1236. X#define O_RCAT 1
  1237. X#define O_ITEM 2
  1238. X#define O_SCALAR 3
  1239. X#define O_ITEM2 4
  1240. X#define O_ITEM3 5
  1241. X#define O_CONCAT 6
  1242. X#define O_REPEAT 7
  1243. X#define O_MATCH 8
  1244. X#define O_NMATCH 9
  1245. X#define O_SUBST 10
  1246. X#define O_NSUBST 11
  1247. X#define O_ASSIGN 12
  1248. X#define O_LOCAL 13
  1249. X#define O_AASSIGN 14
  1250. X#define O_SASSIGN 15
  1251. X#define O_CHOP 16
  1252. X#define O_DEFINED 17
  1253. X#define O_UNDEF 18
  1254. X#define O_STUDY 19
  1255. X#define O_POW 20
  1256. X#define O_MULTIPLY 21
  1257. X#define O_DIVIDE 22
  1258. X#define O_MODULO 23
  1259. X#define O_ADD 24
  1260. X#define O_SUBTRACT 25
  1261. X#define O_LEFT_SHIFT 26
  1262. X#define O_RIGHT_SHIFT 27
  1263. X#define O_LT 28
  1264. X#define O_GT 29
  1265. X#define O_LE 30
  1266. X#define O_GE 31
  1267. X#define O_EQ 32
  1268. X#define O_NE 33
  1269. X#define O_NCMP 34
  1270. X#define O_BIT_AND 35
  1271. X#define O_XOR 36
  1272. X#define O_BIT_OR 37
  1273. X#define O_AND 38
  1274. X#define O_OR 39
  1275. X#define O_COND_EXPR 40
  1276. X#define O_COMMA 41
  1277. X#define O_NEGATE 42
  1278. X#define O_NOT 43
  1279. X#define O_COMPLEMENT 44
  1280. X#define O_SELECT 45
  1281. X#define O_WRITE 46
  1282. X#define O_DBMOPEN 47
  1283. X#define O_DBMCLOSE 48
  1284. X#define O_OPEN 49
  1285. X#define O_TRANS 50
  1286. X#define O_NTRANS 51
  1287. X#define O_CLOSE 52
  1288. X#define O_EACH 53
  1289. X#define O_VALUES 54
  1290. X#define O_KEYS 55
  1291. X#define O_LARRAY 56
  1292. X#define O_ARRAY 57
  1293. X#define O_AELEM 58
  1294. X#define O_DELETE 59
  1295. X#define O_LHASH 60
  1296. X#define O_HASH 61
  1297. X#define O_HELEM 62
  1298. X#define O_LAELEM 63
  1299. X#define O_LHELEM 64
  1300. X#define O_LSLICE 65
  1301. X#define O_ASLICE 66
  1302. X#define O_HSLICE 67
  1303. X#define O_LASLICE 68
  1304. X#define O_LHSLICE 69
  1305. X#define O_SPLICE 70
  1306. X#define O_PUSH 71
  1307. X#define O_POP 72
  1308. X#define O_SHIFT 73
  1309. X#define O_UNPACK 74
  1310. X#define O_SPLIT 75
  1311. X#define O_LENGTH 76
  1312. X#define O_SPRINTF 77
  1313. X#define O_SUBSTR 78
  1314. X#define O_PACK 79
  1315. X#define O_GREP 80
  1316. X#define O_JOIN 81
  1317. X#define O_SLT 82
  1318. X#define O_SGT 83
  1319. X#define O_SLE 84
  1320. X#define O_SGE 85
  1321. X#define O_SEQ 86
  1322. X#define O_SNE 87
  1323. X#define O_SCMP 88
  1324. X#define O_SUBR 89
  1325. X#define O_DBSUBR 90
  1326. X#define O_CALLER 91
  1327. X#define O_SORT 92
  1328. X#define O_REVERSE 93
  1329. X#define O_WARN 94
  1330. X#define O_DIE 95
  1331. X#define O_PRTF 96
  1332. X#define O_PRINT 97
  1333. X#define O_CHDIR 98
  1334. X#define O_EXIT 99
  1335. X#define O_RESET 100
  1336. X#define O_LIST 101
  1337. X#define O_EOF 102
  1338. X#define O_GETC 103
  1339. X#define O_TELL 104
  1340. X#define O_RECV 105
  1341. X#define O_READ 106
  1342. X#define O_SYSREAD 107
  1343. X#define O_SYSWRITE 108
  1344. X#define O_SEND 109
  1345. X#define O_SEEK 110
  1346. X#define O_RETURN 111
  1347. X#define O_REDO 112
  1348. X#define O_NEXT 113
  1349. X#define O_LAST 114
  1350. X#define O_DUMP 115
  1351. X#define O_GOTO 116
  1352. X#define O_INDEX 117
  1353. X#define O_RINDEX 118
  1354. X#define O_TIME 119
  1355. X#define O_TMS 120
  1356. X#define O_LOCALTIME 121
  1357. X#define O_GMTIME 122
  1358. X#define O_TRUNCATE 123
  1359. X#define O_LSTAT 124
  1360. X#define O_STAT 125
  1361. X#define O_CRYPT 126
  1362. X#define O_ATAN2 127
  1363. X#define O_SIN 128
  1364. X#define O_COS 129
  1365. X#define O_RAND 130
  1366. X#define O_SRAND 131
  1367. X#define O_EXP 132
  1368. X#define O_LOG 133
  1369. X#define O_SQRT 134
  1370. X#define O_INT 135
  1371. X#define O_ORD 136
  1372. X#define O_ALARM 137
  1373. X#define O_SLEEP 138
  1374. X#define O_RANGE 139
  1375. X#define O_F_OR_R 140
  1376. X#define O_FLIP 141
  1377. X#define O_FLOP 142
  1378. X#define O_FORK 143
  1379. X#define O_WAIT 144
  1380. X#define O_WAITPID 145
  1381. X#define O_SYSTEM 146
  1382. X#define O_EXEC_OP 147
  1383. X#define O_HEX 148
  1384. X#define O_OCT 149
  1385. X#define O_CHOWN 150
  1386. X#define O_KILL 151
  1387. X#define O_UNLINK 152
  1388. X#define O_CHMOD 153
  1389. X#define O_UTIME 154
  1390. X#define O_UMASK 155
  1391. X#define O_MSGGET 156
  1392. X#define O_SHMGET 157
  1393. X#define O_SEMGET 158
  1394. X#define O_MSGCTL 159
  1395. X#define O_SHMCTL 160
  1396. X#define O_SEMCTL 161
  1397. X#define O_MSGSND 162
  1398. X#define O_MSGRCV 163
  1399. X#define O_SEMOP 164
  1400. X#define O_SHMREAD 165
  1401. X#define O_SHMWRITE 166
  1402. X#define O_RENAME 167
  1403. X#define O_LINK 168
  1404. X#define O_MKDIR 169
  1405. X#define O_RMDIR 170
  1406. X#define O_GETPPID 171
  1407. X#define O_GETPGRP 172
  1408. X#define O_SETPGRP 173
  1409. X#define O_GETPRIORITY 174
  1410. X#define O_SETPRIORITY 175
  1411. X#define O_CHROOT 176
  1412. X#define O_FCNTL 177
  1413. X#define O_IOCTL 178
  1414. X#define O_FLOCK 179
  1415. X#define O_UNSHIFT 180
  1416. X#define O_REQUIRE 181
  1417. X#define O_DOFILE 182
  1418. X#define O_EVAL 183
  1419. X#define O_FTRREAD 184
  1420. X#define O_FTRWRITE 185
  1421. X#define O_FTREXEC 186
  1422. X#define O_FTEREAD 187
  1423. X#define O_FTEWRITE 188
  1424. X#define O_FTEEXEC 189
  1425. X#define O_FTIS 190
  1426. X#define O_FTEOWNED 191
  1427. X#define O_FTROWNED 192
  1428. X#define O_FTZERO 193
  1429. X#define O_FTSIZE 194
  1430. X#define O_FTMTIME 195
  1431. X#define O_FTATIME 196
  1432. X#define O_FTCTIME 197
  1433. X#define O_FTSOCK 198
  1434. X#define O_FTCHR 199
  1435. X#define O_FTBLK 200
  1436. X#define O_FTFILE 201
  1437. X#define O_FTDIR 202
  1438. X#define O_FTPIPE 203
  1439. X#define O_FTLINK 204
  1440. X#define O_SYMLINK 205
  1441. X#define O_READLINK 206
  1442. X#define O_FTSUID 207
  1443. X#define O_FTSGID 208
  1444. X#define O_FTSVTX 209
  1445. X#define O_FTTTY 210
  1446. X#define O_FTTEXT 211
  1447. X#define O_FTBINARY 212
  1448. X#define O_SOCKET 213
  1449. X#define O_BIND 214
  1450. X#define O_CONNECT 215
  1451. X#define O_LISTEN 216
  1452. X#define O_ACCEPT 217
  1453. X#define O_GHBYNAME 218
  1454. X#define O_GHBYADDR 219
  1455. X#define O_GHOSTENT 220
  1456. X#define O_GNBYNAME 221
  1457. X#define O_GNBYADDR 222
  1458. X#define O_GNETENT 223
  1459. X#define O_GPBYNAME 224
  1460. X#define O_GPBYNUMBER 225
  1461. X#define O_GPROTOENT 226
  1462. X#define O_GSBYNAME 227
  1463. X#define O_GSBYPORT 228
  1464. X#define O_GSERVENT 229
  1465. X#define O_SHOSTENT 230
  1466. X#define O_SNETENT 231
  1467. X#define O_SPROTOENT 232
  1468. X#define O_SSERVENT 233
  1469. X#define O_EHOSTENT 234
  1470. X#define O_ENETENT 235
  1471. X#define O_EPROTOENT 236
  1472. X#define O_ESERVENT 237
  1473. X#define O_SOCKPAIR 238
  1474. X#define O_SHUTDOWN 239
  1475. X#define O_GSOCKOPT 240
  1476. X#define O_SSOCKOPT 241
  1477. X#define O_GETSOCKNAME 242
  1478. X#define O_GETPEERNAME 243
  1479. X#define O_SSELECT 244
  1480. X#define O_FILENO 245
  1481. X#define O_BINMODE 246
  1482. X#define O_VEC 247
  1483. X#define O_GPWNAM 248
  1484. X#define O_GPWUID 249
  1485. X#define O_GPWENT 250
  1486. X#define O_SPWENT 251
  1487. X#define O_EPWENT 252
  1488. X#define O_GGRNAM 253
  1489. X#define O_GGRGID 254
  1490. X#define O_GGRENT 255
  1491. X#define O_SGRENT 256
  1492. X#define O_EGRENT 257
  1493. X#define O_GETLOGIN 258
  1494. X#define O_OPENDIR 259
  1495. X#define O_READDIR 260
  1496. X#define O_TELLDIR 261
  1497. X#define O_SEEKDIR 262
  1498. X#define O_REWINDDIR 263
  1499. X#define O_CLOSEDIR 264
  1500. X#define O_SYSCALL 265
  1501. X#define O_PIPE 266
  1502. X#define MAXO 267
  1503. X
  1504. X#ifndef DOINIT
  1505. Xextern char *opname[];
  1506. X#else
  1507. Xchar *opname[] = {
  1508. X    "NULL",
  1509. X    "RCAT",
  1510. X    "ITEM",
  1511. X    "SCALAR",
  1512. X    "ITEM2",
  1513. X    "ITEM3",
  1514. X    "CONCAT",
  1515. X    "REPEAT",
  1516. X    "MATCH",
  1517. X    "NMATCH",
  1518. X    "SUBST",
  1519. X    "NSUBST",
  1520. X    "ASSIGN",
  1521. X    "LOCAL",
  1522. X    "AASSIGN",
  1523. X    "SASSIGN",
  1524. X    "CHOP",
  1525. X    "DEFINED",
  1526. X    "UNDEF",
  1527. X    "STUDY",
  1528. X    "POW",
  1529. X    "MULTIPLY",
  1530. X    "DIVIDE",
  1531. X    "MODULO",
  1532. X    "ADD",
  1533. X    "SUBTRACT",
  1534. X    "LEFT_SHIFT",
  1535. X    "RIGHT_SHIFT",
  1536. X    "LT",
  1537. X    "GT",
  1538. X    "LE",
  1539. X    "GE",
  1540. X    "EQ",
  1541. X    "NE",
  1542. X    "NCMP",
  1543. X    "BIT_AND",
  1544. X    "XOR",
  1545. X    "BIT_OR",
  1546. X    "AND",
  1547. X    "OR",
  1548. X    "COND_EXPR",
  1549. X    "COMMA",
  1550. X    "NEGATE",
  1551. X    "NOT",
  1552. X    "COMPLEMENT",
  1553. X    "SELECT",
  1554. X    "WRITE",
  1555. X    "DBMOPEN",
  1556. X    "DBMCLOSE",
  1557. X    "OPEN",
  1558. X    "TRANS",
  1559. X    "NTRANS",
  1560. X    "CLOSE",
  1561. X    "EACH",
  1562. X    "VALUES",
  1563. X    "KEYS",
  1564. X    "LARRAY",
  1565. X    "ARRAY",
  1566. X    "AELEM",
  1567. X    "DELETE",
  1568. X    "LHASH",
  1569. X    "HASH",
  1570. X    "HELEM",
  1571. X    "LAELEM",
  1572. X    "LHELEM",
  1573. X    "LSLICE",
  1574. X    "ASLICE",
  1575. X    "HSLICE",
  1576. X    "LASLICE",
  1577. X    "LHSLICE",
  1578. X    "SPLICE",
  1579. X    "PUSH",
  1580. X    "POP",
  1581. X    "SHIFT",
  1582. X    "UNPACK",
  1583. X    "SPLIT",
  1584. X    "LENGTH",
  1585. X    "SPRINTF",
  1586. X    "SUBSTR",
  1587. X    "PACK",
  1588. X    "GREP",
  1589. X    "JOIN",
  1590. X    "SLT",
  1591. X    "SGT",
  1592. X    "SLE",
  1593. X    "SGE",
  1594. X    "SEQ",
  1595. X    "SNE",
  1596. X    "SCMP",
  1597. X    "SUBR",
  1598. X    "DBSUBR",
  1599. X    "CALLER",
  1600. X    "SORT",
  1601. X    "REVERSE",
  1602. X    "WARN",
  1603. X    "DIE",
  1604. X    "PRINTF",
  1605. X    "PRINT",
  1606. X    "CHDIR",
  1607. X    "EXIT",
  1608. X    "RESET",
  1609. X    "LIST",
  1610. X    "EOF",
  1611. X    "GETC",
  1612. X    "TELL",
  1613. X    "RECV",
  1614. X    "READ",
  1615. X    "SYSREAD",
  1616. X    "SYSWRITE",
  1617. X    "SEND",
  1618. X    "SEEK",
  1619. X    "RETURN",
  1620. X    "REDO",
  1621. X    "NEXT",
  1622. X    "LAST",
  1623. X    "DUMP",
  1624. X    "GOTO",/* shudder */
  1625. X    "INDEX",
  1626. X    "RINDEX",
  1627. X    "TIME",
  1628. X    "TIMES",
  1629. X    "LOCALTIME",
  1630. X    "GMTIME",
  1631. X    "TRUNCATE",
  1632. X    "LSTAT",
  1633. X    "STAT",
  1634. X    "CRYPT",
  1635. X    "ATAN2",
  1636. X    "SIN",
  1637. X    "COS",
  1638. X    "RAND",
  1639. X    "SRAND",
  1640. X    "EXP",
  1641. X    "LOG",
  1642. X    "SQRT",
  1643. X    "INT",
  1644. X    "ORD",
  1645. X    "ALARM",
  1646. X    "SLEEP",
  1647. X    "RANGE",
  1648. X    "FLIP_OR_RANGE",
  1649. X    "FLIP",
  1650. X    "FLOP",
  1651. X    "FORK",
  1652. X    "WAIT",
  1653. X    "WAITPID",
  1654. X    "SYSTEM",
  1655. X    "EXEC",
  1656. X    "HEX",
  1657. X    "OCT",
  1658. X    "CHOWN",
  1659. X    "KILL",
  1660. X    "UNLINK",
  1661. X    "CHMOD",
  1662. X    "UTIME",
  1663. X    "UMASK",
  1664. X    "MSGGET",
  1665. X    "SHMGET",
  1666. X    "SEMGET",
  1667. X    "MSGCTL",
  1668. X    "SHMCTL",
  1669. X    "SEMCTL",
  1670. X    "MSGSND",
  1671. X    "MSGRCV",
  1672. X    "SEMOP",
  1673. X    "SHMREAD",
  1674. X    "SHMWRITE",
  1675. X    "RENAME",
  1676. X    "LINK",
  1677. X    "MKDIR",
  1678. X    "RMDIR",
  1679. X    "GETPPID",
  1680. X    "GETPGRP",
  1681. X    "SETPGRP",
  1682. X    "GETPRIORITY",
  1683. X    "SETPRIORITY",
  1684. X    "CHROOT",
  1685. X    "FCNTL",
  1686. X    "SYSIOCTL",
  1687. X    "FLOCK",
  1688. X    "UNSHIFT",
  1689. X    "REQUIRE",
  1690. X    "DOFILE",
  1691. X    "EVAL",
  1692. X    "FTRREAD",
  1693. X    "FTRWRITE",
  1694. X    "FTREXEC",
  1695. X    "FTEREAD",
  1696. X    "FTEWRITE",
  1697. X    "FTEEXEC",
  1698. X    "FTIS",
  1699. X    "FTEOWNED",
  1700. X    "FTROWNED",
  1701. X    "FTZERO",
  1702. X    "FTSIZE",
  1703. X    "FTMTIME",
  1704. X    "FTATIME",
  1705. X    "FTCTIME",
  1706. X    "FTSOCK",
  1707. X    "FTCHR",
  1708. X    "FTBLK",
  1709. X    "FTFILE",
  1710. X    "FTDIR",
  1711. X    "FTPIPE",
  1712. X    "FTLINK",
  1713. X    "SYMLINK",
  1714. X    "READLINK",
  1715. X    "FTSUID",
  1716. X    "FTSGID",
  1717. X    "FTSVTX",
  1718. X    "FTTTY",
  1719. X    "FTTEXT",
  1720. X    "FTBINARY",
  1721. X    "SOCKET",
  1722. X    "BIND",
  1723. X    "CONNECT",
  1724. X    "LISTEN",
  1725. X    "ACCEPT",
  1726. X    "GHBYNAME",
  1727. X    "GHBYADDR",
  1728. X    "GHOSTENT",
  1729. X    "GNBYNAME",
  1730. X    "GNBYADDR",
  1731. X    "GNETENT",
  1732. X    "GPBYNAME",
  1733. X    "GPBYNUMBER",
  1734. X    "GPROTOENT",
  1735. X    "GSBYNAME",
  1736. X    "GSBYPORT",
  1737. X    "GSERVENT",
  1738. X    "SHOSTENT",
  1739. X    "SNETENT",
  1740. X    "SPROTOENT",
  1741. X    "SSERVENT",
  1742. X    "EHOSTENT",
  1743. X    "ENETENT",
  1744. X    "EPROTOENT",
  1745. X    "ESERVENT",
  1746. X    "SOCKPAIR",
  1747. X    "SHUTDOWN",
  1748. X    "GSOCKOPT",
  1749. X    "SSOCKOPT",
  1750. X    "GETSOCKNAME",
  1751. X    "GETPEERNAME",
  1752. X    "SSELECT",
  1753. X    "FILENO",
  1754. X    "BINMODE",
  1755. X    "VEC",
  1756. X    "GPWNAM",
  1757. X    "GPWUID",
  1758. X    "GPWENT",
  1759. X    "SPWENT",
  1760. X    "EPWENT",
  1761. X    "GGRNAM",
  1762. X    "GGRGID",
  1763. X    "GGRENT",
  1764. X    "SGRENT",
  1765. X    "EGRENT",
  1766. X    "GETLOGIN",
  1767. X    "OPENDIR",
  1768. X    "READDIR",
  1769. X    "TELLDIR",
  1770. X    "SEEKDIR",
  1771. X    "REWINDDIR",
  1772. X    "CLOSEDIR",
  1773. X    "SYSCALL",
  1774. X    "PIPE",
  1775. X    "267"
  1776. X};
  1777. X#endif
  1778. X
  1779. X#define A_NULL 0
  1780. X#define A_EXPR 1
  1781. X#define A_CMD 2
  1782. X#define A_STAB 3
  1783. X#define A_LVAL 4
  1784. X#define A_SINGLE 5
  1785. X#define A_DOUBLE 6
  1786. X#define A_BACKTICK 7
  1787. X#define A_READ 8
  1788. X#define A_SPAT 9
  1789. X#define A_LEXPR 10
  1790. X#define A_ARYLEN 11
  1791. X#define A_ARYSTAB 12
  1792. X#define A_LARYLEN 13
  1793. X#define A_GLOB 14
  1794. X#define A_WORD 15
  1795. X#define A_INDREAD 16
  1796. X#define A_LARYSTAB 17
  1797. X#define A_STAR 18
  1798. X#define A_LSTAR 19
  1799. X#define A_WANTARRAY 20
  1800. X
  1801. X#define A_MASK 31
  1802. X#define A_DONT 32        /* or this into type to suppress evaluation */
  1803. X
  1804. X#ifndef DOINIT
  1805. Xextern char *argname[];
  1806. X#else
  1807. Xchar *argname[] = {
  1808. X    "A_NULL",
  1809. X    "EXPR",
  1810. X    "CMD",
  1811. X    "STAB",
  1812. X    "LVAL",
  1813. X    "SINGLE",
  1814. X    "DOUBLE",
  1815. X    "BACKTICK",
  1816. X    "READ",
  1817. X    "SPAT",
  1818. X    "LEXPR",
  1819. X    "ARYLEN",
  1820. X    "ARYSTAB",
  1821. X    "LARYLEN",
  1822. X    "GLOB",
  1823. X    "WORD",
  1824. X    "INDREAD",
  1825. X    "LARYSTAB",
  1826. X    "STAR",
  1827. X    "LSTAR",
  1828. X    "WANTARRAY",
  1829. X    "21"
  1830. X};
  1831. X#endif
  1832. X
  1833. X#ifndef DOINIT
  1834. Xextern bool hoistable[];
  1835. X#else
  1836. Xbool hoistable[] =
  1837. X  {0,    /* A_NULL */
  1838. X   0,    /* EXPR */
  1839. X   1,    /* CMD */
  1840. X   1,    /* STAB */
  1841. X   0,    /* LVAL */
  1842. X   1,    /* SINGLE */
  1843. X   0,    /* DOUBLE */
  1844. X   0,    /* BACKTICK */
  1845. X   0,    /* READ */
  1846. X   0,    /* SPAT */
  1847. X   0,    /* LEXPR */
  1848. X   1,    /* ARYLEN */
  1849. X   1,    /* ARYSTAB */
  1850. X   0,    /* LARYLEN */
  1851. X   0,    /* GLOB */
  1852. X   1,    /* WORD */
  1853. X   0,    /* INDREAD */
  1854. X   0,    /* LARYSTAB */
  1855. X   1,    /* STAR */
  1856. X   1,    /* LSTAR */
  1857. X   1,    /* WANTARRAY */
  1858. X   0,    /* 21 */
  1859. X};
  1860. X#endif
  1861. X
  1862. Xunion argptr {
  1863. X    ARG        *arg_arg;
  1864. X    char    *arg_cval;
  1865. X    STAB    *arg_stab;
  1866. X    SPAT    *arg_spat;
  1867. X    CMD        *arg_cmd;
  1868. X    STR        *arg_str;
  1869. X    HASH    *arg_hash;
  1870. X};
  1871. X
  1872. Xstruct arg {
  1873. X    union argptr arg_ptr;
  1874. X    short    arg_len;
  1875. X    unsigned short arg_type;
  1876. X    unsigned short arg_flags;
  1877. X};
  1878. X
  1879. X#define AF_ARYOK 1        /* op can handle multiple values here */
  1880. X#define AF_POST 2        /* post *crement this item */
  1881. X#define AF_PRE 4        /* pre *crement this item */
  1882. X#define AF_UP 8            /* increment rather than decrement */
  1883. X#define AF_COMMON 16        /* left and right have symbols in common */
  1884. X#define AF_DEPR 32        /* an older form of the construct */
  1885. X#define AF_LISTISH 64        /* turn into list if important */
  1886. X#define AF_LOCAL 128        /* list of local variables */
  1887. X
  1888. X/*
  1889. X * Most of the ARG pointers are used as pointers to arrays of ARG.  When
  1890. X * so used, the 0th element is special, and represents the operator to
  1891. X * use on the list of arguments following.  The arg_len in the 0th element
  1892. X * gives the maximum argument number, and the arg_str is used to store
  1893. X * the return value in a more-or-less static location.  Sorry it's not
  1894. X * re-entrant (yet), but it sure makes it efficient.  The arg_type of the
  1895. X * 0th element is an operator (O_*) rather than an argument type (A_*).
  1896. X */
  1897. X
  1898. X#define Nullarg Null(ARG*)
  1899. X
  1900. X#ifndef DOINIT
  1901. XEXT unsigned short opargs[MAXO+1];
  1902. X#else
  1903. X#define A(e1,e2,e3)        (e1+(e2<<2)+(e3<<4))
  1904. X#define A5(e1,e2,e3,e4,e5) (e1+(e2<<2)+(e3<<4)+(e4<<6)+(e5<<8))
  1905. Xunsigned short opargs[MAXO+1] = {
  1906. X    A(0,0,0),    /* NULL */
  1907. X    A(1,1,0),    /* RCAT */
  1908. X    A(1,0,0),    /* ITEM */
  1909. X    A(1,0,0),    /* SCALAR */
  1910. X    A(0,0,0),    /* ITEM2 */
  1911. X    A(0,0,0),    /* ITEM3 */
  1912. X    A(1,1,0),    /* CONCAT */
  1913. X    A(3,1,0),    /* REPEAT */
  1914. X    A(1,0,0),    /* MATCH */
  1915. X    A(1,0,0),    /* NMATCH */
  1916. X    A(1,0,0),    /* SUBST */
  1917. X    A(1,0,0),    /* NSUBST */
  1918. X    A(1,1,0),    /* ASSIGN */
  1919. X    A(1,0,0),    /* LOCAL */
  1920. X    A(3,3,0),    /* AASSIGN */
  1921. X    A(0,0,0),    /* SASSIGN */
  1922. X    A(3,0,0),    /* CHOP */
  1923. X    A(1,0,0),    /* DEFINED */
  1924. X    A(1,0,0),    /* UNDEF */
  1925. X    A(1,0,0),    /* STUDY */
  1926. X    A(1,1,0),    /* POW */
  1927. X    A(1,1,0),    /* MULTIPLY */
  1928. X    A(1,1,0),    /* DIVIDE */
  1929. X    A(1,1,0),    /* MODULO */
  1930. X    A(1,1,0),    /* ADD */
  1931. X    A(1,1,0),    /* SUBTRACT */
  1932. X    A(1,1,0),    /* LEFT_SHIFT */
  1933. X    A(1,1,0),    /* RIGHT_SHIFT */
  1934. X    A(1,1,0),    /* LT */
  1935. X    A(1,1,0),    /* GT */
  1936. X    A(1,1,0),    /* LE */
  1937. X    A(1,1,0),    /* GE */
  1938. X    A(1,1,0),    /* EQ */
  1939. X    A(1,1,0),    /* NE */
  1940. X    A(1,1,0),    /* NCMP */
  1941. X    A(1,1,0),    /* BIT_AND */
  1942. X    A(1,1,0),    /* XOR */
  1943. X    A(1,1,0),    /* BIT_OR */
  1944. X    A(1,0,0),    /* AND */
  1945. X    A(1,0,0),    /* OR */
  1946. X    A(1,0,0),    /* COND_EXPR */
  1947. X    A(1,1,0),    /* COMMA */
  1948. X    A(1,0,0),    /* NEGATE */
  1949. X    A(1,0,0),    /* NOT */
  1950. X    A(1,0,0),    /* COMPLEMENT */
  1951. X    A(1,0,0),    /* SELECT */
  1952. X    A(1,0,0),    /* WRITE */
  1953. X    A(1,1,1),    /* DBMOPEN */
  1954. X    A(1,0,0),    /* DBMCLOSE */
  1955. X    A(1,1,0),    /* OPEN */
  1956. X    A(1,0,0),    /* TRANS */
  1957. X    A(1,0,0),    /* NTRANS */
  1958. X    A(1,0,0),    /* CLOSE */
  1959. X    A(0,0,0),    /* EACH */
  1960. X    A(0,0,0),    /* VALUES */
  1961. X    A(0,0,0),    /* KEYS */
  1962. X    A(0,0,0),    /* LARRAY */
  1963. X    A(0,0,0),    /* ARRAY */
  1964. X    A(0,1,0),    /* AELEM */
  1965. X    A(0,1,0),    /* DELETE */
  1966. X    A(0,0,0),    /* LHASH */
  1967. X    A(0,0,0),    /* HASH */
  1968. X    A(0,1,0),    /* HELEM */
  1969. X    A(0,1,0),    /* LAELEM */
  1970. X    A(0,1,0),    /* LHELEM */
  1971. X    A(0,3,3),    /* LSLICE */
  1972. X    A(0,3,0),    /* ASLICE */
  1973. X    A(0,3,0),    /* HSLICE */
  1974. X    A(0,3,0),    /* LASLICE */
  1975. X    A(0,3,0),    /* LHSLICE */
  1976. X    A(0,3,1),    /* SPLICE */
  1977. X    A(0,3,0),    /* PUSH */
  1978. X    A(0,0,0),    /* POP */
  1979. X    A(0,0,0),    /* SHIFT */
  1980. X    A(1,1,0),    /* UNPACK */
  1981. X    A(1,0,1),    /* SPLIT */
  1982. X    A(1,0,0),    /* LENGTH */
  1983. X    A(3,0,0),    /* SPRINTF */
  1984. X    A(1,1,1),    /* SUBSTR */
  1985. X    A(1,3,0),    /* PACK */
  1986. X    A(0,3,0),    /* GREP */
  1987. X    A(1,3,0),    /* JOIN */
  1988. X    A(1,1,0),    /* SLT */
  1989. X    A(1,1,0),    /* SGT */
  1990. X    A(1,1,0),    /* SLE */
  1991. X    A(1,1,0),    /* SGE */
  1992. X    A(1,1,0),    /* SEQ */
  1993. X    A(1,1,0),    /* SNE */
  1994. X    A(1,1,0),    /* SCMP */
  1995. X    A(0,3,0),    /* SUBR */
  1996. X    A(0,3,0),    /* DBSUBR */
  1997. X    A(1,0,0),    /* CALLER */
  1998. X    A(1,3,0),    /* SORT */
  1999. X    A(0,3,0),    /* REVERSE */
  2000. X    A(0,3,0),    /* WARN */
  2001. X    A(0,3,0),    /* DIE */
  2002. X    A(1,3,0),    /* PRINTF */
  2003. X    A(1,3,0),    /* PRINT */
  2004. X    A(1,0,0),    /* CHDIR */
  2005. X    A(1,0,0),    /* EXIT */
  2006. X    A(1,0,0),    /* RESET */
  2007. X    A(3,0,0),    /* LIST */
  2008. X    A(1,0,0),    /* EOF */
  2009. X    A(1,0,0),    /* GETC */
  2010. X    A(1,0,0),    /* TELL */
  2011. X    A5(1,1,1,1,0),    /* RECV */
  2012. X    A(1,1,3),    /* READ */
  2013. X    A(1,1,3),    /* SYSREAD */
  2014. X    A(1,1,3),    /* SYSWRITE */
  2015. X    A(1,1,3),    /* SEND */
  2016. X    A(1,1,1),    /* SEEK */
  2017. X    A(0,3,0),    /* RETURN */
  2018. X    A(0,0,0),    /* REDO */
  2019. X    A(0,0,0),    /* NEXT */
  2020. X    A(0,0,0),    /* LAST */
  2021. X    A(0,0,0),    /* DUMP */
  2022. X    A(0,0,0),    /* GOTO */
  2023. X    A(1,1,1),    /* INDEX */
  2024. X    A(1,1,1),    /* RINDEX */
  2025. X    A(0,0,0),    /* TIME */
  2026. X    A(0,0,0),    /* TIMES */
  2027. X    A(1,0,0),    /* LOCALTIME */
  2028. X    A(1,0,0),    /* GMTIME */
  2029. X    A(1,1,0),    /* TRUNCATE */
  2030. X    A(1,0,0),    /* LSTAT */
  2031. X    A(1,0,0),    /* STAT */
  2032. X    A(1,1,0),    /* CRYPT */
  2033. X    A(1,1,0),    /* ATAN2 */
  2034. X    A(1,0,0),    /* SIN */
  2035. X    A(1,0,0),    /* COS */
  2036. X    A(1,0,0),    /* RAND */
  2037. X    A(1,0,0),    /* SRAND */
  2038. X    A(1,0,0),    /* EXP */
  2039. X    A(1,0,0),    /* LOG */
  2040. X    A(1,0,0),    /* SQRT */
  2041. X    A(1,0,0),    /* INT */
  2042. X    A(1,0,0),    /* ORD */
  2043. X    A(1,0,0),    /* ALARM */
  2044. X    A(1,0,0),    /* SLEEP */
  2045. X    A(1,1,0),    /* RANGE */
  2046. X    A(1,0,0),    /* F_OR_R */
  2047. X    A(1,0,0),    /* FLIP */
  2048. X    A(0,1,0),    /* FLOP */
  2049. X    A(0,0,0),    /* FORK */
  2050. X    A(0,0,0),    /* WAIT */
  2051. X    A(1,1,0),    /* WAITPID */
  2052. X    A(1,3,0),    /* SYSTEM */
  2053. X    A(1,3,0),    /* EXEC */
  2054. X    A(1,0,0),    /* HEX */
  2055. X    A(1,0,0),    /* OCT */
  2056. X    A(0,3,0),    /* CHOWN */
  2057. X    A(0,3,0),    /* KILL */
  2058. X    A(0,3,0),    /* UNLINK */
  2059. X    A(0,3,0),    /* CHMOD */
  2060. X    A(0,3,0),    /* UTIME */
  2061. X    A(1,0,0),    /* UMASK */
  2062. X    A(1,1,0),    /* MSGGET */
  2063. X    A(1,1,1),    /* SHMGET */
  2064. X    A(1,1,1),    /* SEMGET */
  2065. X    A(1,1,1),    /* MSGCTL */
  2066. X    A(1,1,1),    /* SHMCTL */
  2067. X    A5(1,1,1,1,0),    /* SEMCTL */
  2068. X    A(1,1,1),    /* MSGSND */
  2069. X    A5(1,1,1,1,1),    /* MSGRCV */
  2070. X    A(1,1,1),    /* SEMOP */
  2071. X    A5(1,1,1,1,0),    /* SHMREAD */
  2072. X    A5(1,1,1,1,0),    /* SHMWRITE */
  2073. X    A(1,1,0),    /* RENAME */
  2074. X    A(1,1,0),    /* LINK */
  2075. X    A(1,1,0),    /* MKDIR */
  2076. X    A(1,0,0),    /* RMDIR */
  2077. X    A(0,0,0),    /* GETPPID */
  2078. X    A(1,0,0),    /* GETPGRP */
  2079. X    A(1,1,0),    /* SETPGRP */
  2080. X    A(1,1,0),    /* GETPRIORITY */
  2081. X    A(1,1,1),    /* SETPRIORITY */
  2082. X    A(1,0,0),    /* CHROOT */
  2083. X    A(1,1,1),    /* FCNTL */
  2084. X    A(1,1,1),    /* SYSIOCTL */
  2085. X    A(1,1,0),    /* FLOCK */
  2086. X    A(0,3,0),    /* UNSHIFT */
  2087. X    A(1,0,0),    /* REQUIRE */
  2088. X    A(1,0,0),    /* DOFILE */
  2089. X    A(1,0,0),    /* EVAL */
  2090. X    A(1,0,0),    /* FTRREAD */
  2091. X    A(1,0,0),    /* FTRWRITE */
  2092. X    A(1,0,0),    /* FTREXEC */
  2093. X    A(1,0,0),    /* FTEREAD */
  2094. X    A(1,0,0),    /* FTEWRITE */
  2095. X    A(1,0,0),    /* FTEEXEC */
  2096. X    A(1,0,0),    /* FTIS */
  2097. X    A(1,0,0),    /* FTEOWNED */
  2098. X    A(1,0,0),    /* FTROWNED */
  2099. X    A(1,0,0),    /* FTZERO */
  2100. X    A(1,0,0),    /* FTSIZE */
  2101. X    A(1,0,0),    /* FTMTIME */
  2102. X    A(1,0,0),    /* FTATIME */
  2103. X    A(1,0,0),    /* FTCTIME */
  2104. X    A(1,0,0),    /* FTSOCK */
  2105. X    A(1,0,0),    /* FTCHR */
  2106. X    A(1,0,0),    /* FTBLK */
  2107. X    A(1,0,0),    /* FTFILE */
  2108. X    A(1,0,0),    /* FTDIR */
  2109. X    A(1,0,0),    /* FTPIPE */
  2110. X    A(1,0,0),    /* FTLINK */
  2111. X    A(1,1,0),    /* SYMLINK */
  2112. X    A(1,0,0),    /* READLINK */
  2113. X    A(1,0,0),    /* FTSUID */
  2114. X    A(1,0,0),    /* FTSGID */
  2115. X    A(1,0,0),    /* FTSVTX */
  2116. X    A(1,0,0),    /* FTTTY */
  2117. X    A(1,0,0),    /* FTTEXT */
  2118. X    A(1,0,0),    /* FTBINARY */
  2119. X    A5(1,1,1,1,0),    /* SOCKET */
  2120. X    A(1,1,0),    /* BIND */
  2121. X    A(1,1,0),    /* CONNECT */
  2122. X    A(1,1,0),    /* LISTEN */
  2123. X    A(1,1,0),    /* ACCEPT */
  2124. X    A(1,0,0),    /* GHBYNAME */
  2125. X    A(1,1,0),    /* GHBYADDR */
  2126. X    A(0,0,0),    /* GHOSTENT */
  2127. X    A(1,0,0),    /* GNBYNAME */
  2128. X    A(1,1,0),    /* GNBYADDR */
  2129. X    A(0,0,0),    /* GNETENT */
  2130. X    A(1,0,0),    /* GPBYNAME */
  2131. X    A(1,0,0),    /* GPBYNUMBER */
  2132. X    A(0,0,0),    /* GPROTOENT */
  2133. X    A(1,1,0),    /* GSBYNAME */
  2134. X    A(1,1,0),    /* GSBYPORT */
  2135. X    A(0,0,0),    /* GSERVENT */
  2136. X    A(1,0,0),    /* SHOSTENT */
  2137. X    A(1,0,0),    /* SNETENT */
  2138. X    A(1,0,0),    /* SPROTOENT */
  2139. X    A(1,0,0),    /* SSERVENT */
  2140. X    A(0,0,0),    /* EHOSTENT */
  2141. X    A(0,0,0),    /* ENETENT */
  2142. X    A(0,0,0),    /* EPROTOENT */
  2143. X    A(0,0,0),    /* ESERVENT */
  2144. X    A5(1,1,1,1,1),    /* SOCKPAIR */
  2145. X    A(1,1,0),    /* SHUTDOWN */
  2146. X    A(1,1,1),    /* GSOCKOPT */
  2147. X    A5(1,1,1,1,0),    /* SSOCKOPT */
  2148. X    A(1,0,0),    /* GETSOCKNAME */
  2149. X    A(1,0,0),    /* GETPEERNAME */
  2150. X    A5(1,1,1,1,0),    /* SSELECT */
  2151. X    A(1,0,0),    /* FILENO */
  2152. X    A(1,0,0),    /* BINMODE */
  2153. X    A(1,1,1),    /* VEC */
  2154. X    A(1,0,0),    /* GPWNAM */
  2155. X    A(1,0,0),    /* GPWUID */
  2156. X    A(0,0,0),    /* GPWENT */
  2157. X    A(0,0,0),    /* SPWENT */
  2158. X    A(0,0,0),    /* EPWENT */
  2159. X    A(1,0,0),    /* GGRNAM */
  2160. X    A(1,0,0),    /* GGRGID */
  2161. X    A(0,0,0),    /* GGRENT */
  2162. X    A(0,0,0),    /* SGRENT */
  2163. X    A(0,0,0),    /* EGRENT */
  2164. X    A(0,0,0),    /* GETLOGIN */
  2165. X    A(1,1,0),    /* OPENDIR */
  2166. X    A(1,0,0),    /* READDIR */
  2167. X    A(1,0,0),    /* TELLDIR */
  2168. X    A(1,1,0),    /* SEEKDIR */
  2169. X    A(1,0,0),    /* REWINDDIR */
  2170. X    A(1,0,0),    /* CLOSEDIR */
  2171. X    A(1,3,0),    /* SYSCALL */
  2172. X    A(1,1,0),    /* PIPE */
  2173. X    0
  2174. X};
  2175. X#undef A
  2176. X#undef A5
  2177. X#endif
  2178. X
  2179. Xint do_trans();
  2180. Xint do_split();
  2181. Xbool do_eof();
  2182. Xlong do_tell();
  2183. Xbool do_seek();
  2184. Xint do_tms();
  2185. Xint do_time();
  2186. Xint do_stat();
  2187. XSTR *do_push();
  2188. XFILE *nextargv();
  2189. XSTR *do_fttext();
  2190. Xint do_slice();
  2191. !STUFFY!FUNK!
  2192. echo " "
  2193. echo "End of kit 20 (of 36)"
  2194. cat /dev/null >kit20isdone
  2195. run=''
  2196. config=''
  2197. for iskit in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36; do
  2198.     if test -f kit${iskit}isdone; then
  2199.     run="$run $iskit"
  2200.     else
  2201.     todo="$todo $iskit"
  2202.     fi
  2203. done
  2204. case $todo in
  2205.     '')
  2206.     echo "You have run all your kits.  Please read README and then type Configure."
  2207.     for combo in *:AA; do
  2208.         if test -f "$combo"; then
  2209.         realfile=`basename $combo :AA`
  2210.         cat $realfile:[A-Z][A-Z] >$realfile
  2211.         rm -rf $realfile:[A-Z][A-Z]
  2212.         fi
  2213.     done
  2214.     rm -rf kit*isdone
  2215.     chmod 755 Configure
  2216.     ;;
  2217.     *)  echo "You have run$run."
  2218.     echo "You still need to run$todo."
  2219.     ;;
  2220. esac
  2221. : Someone might mail this, so...
  2222. exit
  2223.  
  2224. exit 0 # Just in case...
  2225. -- 
  2226. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  2227. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  2228. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  2229. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  2230.