home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume20 / perl3.0 / part14 < prev    next >
Internet Message Format  |  1989-11-03  |  50KB
  1. Path: bbn.com!rsalz
  2. From: rsalz@uunet.uu.net (Rich Salz)
  3. Newsgroups: comp.sources.unix
  4. Subject: v20i097:  Perl, a language with features of C/sed/awk/shell/etc, Part14/24
  5. Message-ID: <2117@papaya.bbn.com>
  6. Date: 31 Oct 89 20:13:37 GMT
  7. Lines: 1853
  8. Approved: rsalz@uunet.UU.NET
  9.  
  10. Submitted-by: Larry Wall <lwall@jpl-devvax.jpl.nasa.gov>
  11. Posting-number: Volume 20, Issue 97
  12. Archive-name: perl3.0/part14
  13.  
  14. #! /bin/sh
  15.  
  16. # Make a new directory for the perl sources, cd to it, and run kits 1
  17. # thru 24 through sh.  When all 24 kits have been run, read README.
  18.  
  19. echo "This is perl 3.0 kit 14 (of 24).  If kit 14 is complete, the line"
  20. echo '"'"End of kit 14 (of 24)"'" will echo at the end.'
  21. echo ""
  22. export PATH || (echo "You didn't use sh, you clunch." ; kill $$)
  23. mkdir  2>/dev/null
  24. echo Extracting consarg.c
  25. sed >consarg.c <<'!STUFFY!FUNK!' -e 's/X//'
  26. X/* $Header: consarg.c,v 3.0 89/10/18 15:10:30 lwall Locked $
  27. X *
  28. X *    Copyright (c) 1989, Larry Wall
  29. X *
  30. X *    You may distribute under the terms of the GNU General Public License
  31. X *    as specified in the README file that comes with the perl 3.0 kit.
  32. X *
  33. X * $Log:    consarg.c,v $
  34. X * Revision 3.0  89/10/18  15:10:30  lwall
  35. X * 3.0 baseline
  36. X * 
  37. X */
  38. X
  39. X#include "EXTERN.h"
  40. X#include "perl.h"
  41. Xstatic int nothing_in_common();
  42. Xstatic int arg_common();
  43. Xstatic int spat_common();
  44. X
  45. XARG *
  46. Xmake_split(stab,arg,limarg)
  47. Xregister STAB *stab;
  48. Xregister ARG *arg;
  49. XARG *limarg;
  50. X{
  51. X    register SPAT *spat;
  52. X
  53. X    if (arg->arg_type != O_MATCH) {
  54. X    Newz(201,spat,1,SPAT);
  55. X    spat->spat_next = curstash->tbl_spatroot; /* link into spat list */
  56. X    curstash->tbl_spatroot = spat;
  57. X
  58. X    spat->spat_runtime = arg;
  59. X    arg = make_match(O_MATCH,stab2arg(A_STAB,defstab),spat);
  60. X    }
  61. X    Renew(arg,4,ARG);
  62. X    arg->arg_len = 3;
  63. X    if (limarg) {
  64. X    if (limarg->arg_type == O_ITEM) {
  65. X        Copy(limarg+1,arg+3,1,ARG);
  66. X        limarg[1].arg_type = A_NULL;
  67. X        arg_free(limarg);
  68. X    }
  69. X    else {
  70. X        arg[3].arg_type = A_EXPR;
  71. X        arg[3].arg_ptr.arg_arg = limarg;
  72. X    }
  73. X    }
  74. X    else
  75. X    arg[3].arg_type = A_NULL;
  76. X    arg->arg_type = O_SPLIT;
  77. X    spat = arg[2].arg_ptr.arg_spat;
  78. X    spat->spat_repl = stab2arg(A_STAB,aadd(stab));
  79. X    if (spat->spat_short) {    /* exact match can bypass regexec() */
  80. X    if (!((spat->spat_flags & SPAT_SCANFIRST) &&
  81. X        (spat->spat_flags & SPAT_ALL) )) {
  82. X        str_free(spat->spat_short);
  83. X        spat->spat_short = Nullstr;
  84. X    }
  85. X    }
  86. X    return arg;
  87. X}
  88. X
  89. XARG *
  90. Xmod_match(type,left,pat)
  91. Xregister ARG *left;
  92. Xregister ARG *pat;
  93. X{
  94. X
  95. X    register SPAT *spat;
  96. X    register ARG *newarg;
  97. X
  98. X    if ((pat->arg_type == O_MATCH ||
  99. X     pat->arg_type == O_SUBST ||
  100. X     pat->arg_type == O_TRANS ||
  101. X     pat->arg_type == O_SPLIT
  102. X    ) &&
  103. X    pat[1].arg_ptr.arg_stab == defstab ) {
  104. X    switch (pat->arg_type) {
  105. X    case O_MATCH:
  106. X        newarg = make_op(type == O_MATCH ? O_MATCH : O_NMATCH,
  107. X        pat->arg_len,
  108. X        left,Nullarg,Nullarg);
  109. X        break;
  110. X    case O_SUBST:
  111. X        newarg = l(make_op(type == O_MATCH ? O_SUBST : O_NSUBST,
  112. X        pat->arg_len,
  113. X        left,Nullarg,Nullarg));
  114. X        break;
  115. X    case O_TRANS:
  116. X        newarg = l(make_op(type == O_MATCH ? O_TRANS : O_NTRANS,
  117. X        pat->arg_len,
  118. X        left,Nullarg,Nullarg));
  119. X        break;
  120. X    case O_SPLIT:
  121. X        newarg = make_op(type == O_MATCH ? O_SPLIT : O_SPLIT,
  122. X        pat->arg_len,
  123. X        left,Nullarg,Nullarg);
  124. X        break;
  125. X    }
  126. X    if (pat->arg_len >= 2) {
  127. X        newarg[2].arg_type = pat[2].arg_type;
  128. X        newarg[2].arg_ptr = pat[2].arg_ptr;
  129. X        newarg[2].arg_flags = pat[2].arg_flags;
  130. X        if (pat->arg_len >= 3) {
  131. X        newarg[3].arg_type = pat[3].arg_type;
  132. X        newarg[3].arg_ptr = pat[3].arg_ptr;
  133. X        newarg[3].arg_flags = pat[3].arg_flags;
  134. X        }
  135. X    }
  136. X    Safefree(pat);
  137. X    }
  138. X    else {
  139. X    Newz(202,spat,1,SPAT);
  140. X    spat->spat_next = curstash->tbl_spatroot; /* link into spat list */
  141. X    curstash->tbl_spatroot = spat;
  142. X
  143. X    spat->spat_runtime = pat;
  144. X    newarg = make_op(type,2,left,Nullarg,Nullarg);
  145. X    newarg[2].arg_type = A_SPAT | A_DONT;
  146. X    newarg[2].arg_ptr.arg_spat = spat;
  147. X    }
  148. X
  149. X    return newarg;
  150. X}
  151. X
  152. XARG *
  153. Xmake_op(type,newlen,arg1,arg2,arg3)
  154. Xint type;
  155. Xint newlen;
  156. XARG *arg1;
  157. XARG *arg2;
  158. XARG *arg3;
  159. X{
  160. X    register ARG *arg;
  161. X    register ARG *chld;
  162. X    register int doarg;
  163. X    extern ARG *arg4;    /* should be normal arguments, really */
  164. X    extern ARG *arg5;
  165. X
  166. X    arg = op_new(newlen);
  167. X    arg->arg_type = type;
  168. X    doarg = opargs[type];
  169. X    if (chld = arg1) {
  170. X    if (chld->arg_type == O_ITEM &&
  171. X        (hoistable[chld[1].arg_type] || chld[1].arg_type == A_LVAL ||
  172. X         (chld[1].arg_type == A_LEXPR &&
  173. X          (chld[1].arg_ptr.arg_arg->arg_type == O_LIST ||
  174. X           chld[1].arg_ptr.arg_arg->arg_type == O_ARRAY ||
  175. X           chld[1].arg_ptr.arg_arg->arg_type == O_HASH ))))
  176. X    {
  177. X        arg[1].arg_type = chld[1].arg_type;
  178. X        arg[1].arg_ptr = chld[1].arg_ptr;
  179. X        arg[1].arg_flags |= chld[1].arg_flags;
  180. X        arg[1].arg_len = chld[1].arg_len;
  181. X        free_arg(chld);
  182. X    }
  183. X    else {
  184. X        arg[1].arg_type = A_EXPR;
  185. X        arg[1].arg_ptr.arg_arg = chld;
  186. X    }
  187. X    if (!(doarg & 1))
  188. X        arg[1].arg_type |= A_DONT;
  189. X    if (doarg & 2)
  190. X        arg[1].arg_flags |= AF_ARYOK;
  191. X    }
  192. X    doarg >>= 2;
  193. X    if (chld = arg2) {
  194. X    if (chld->arg_type == O_ITEM && 
  195. X        (hoistable[chld[1].arg_type] || 
  196. X         (type == O_ASSIGN && 
  197. X          ((chld[1].arg_type == A_READ && !(arg[1].arg_type & A_DONT))
  198. X        ||
  199. X           (chld[1].arg_type == A_INDREAD && !(arg[1].arg_type & A_DONT))
  200. X        ||
  201. X           (chld[1].arg_type == A_GLOB && !(arg[1].arg_type & A_DONT))
  202. X          ) ) ) ) {
  203. X        arg[2].arg_type = chld[1].arg_type;
  204. X        arg[2].arg_ptr = chld[1].arg_ptr;
  205. X        arg[2].arg_len = chld[1].arg_len;
  206. X        free_arg(chld);
  207. X    }
  208. X    else {
  209. X        arg[2].arg_type = A_EXPR;
  210. X        arg[2].arg_ptr.arg_arg = chld;
  211. X    }
  212. X    if (!(doarg & 1))
  213. X        arg[2].arg_type |= A_DONT;
  214. X    if (doarg & 2)
  215. X        arg[2].arg_flags |= AF_ARYOK;
  216. X    }
  217. X    doarg >>= 2;
  218. X    if (chld = arg3) {
  219. X    if (chld->arg_type == O_ITEM && hoistable[chld[1].arg_type]) {
  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    if (!(doarg & 1))
  230. X        arg[3].arg_type |= A_DONT;
  231. X    if (doarg & 2)
  232. X        arg[3].arg_flags |= AF_ARYOK;
  233. X    }
  234. X    if (newlen >= 4 && (chld = arg4)) {
  235. X    if (chld->arg_type == O_ITEM && hoistable[chld[1].arg_type]) {
  236. X        arg[4].arg_type = chld[1].arg_type;
  237. X        arg[4].arg_ptr = chld[1].arg_ptr;
  238. X        arg[4].arg_len = chld[1].arg_len;
  239. X        free_arg(chld);
  240. X    }
  241. X    else {
  242. X        arg[4].arg_type = A_EXPR;
  243. X        arg[4].arg_ptr.arg_arg = chld;
  244. X    }
  245. X    }
  246. X    if (newlen >= 5 && (chld = arg5)) {
  247. X    if (chld->arg_type == O_ITEM && hoistable[chld[1].arg_type]) {
  248. X        arg[5].arg_type = chld[1].arg_type;
  249. X        arg[5].arg_ptr = chld[1].arg_ptr;
  250. X        arg[5].arg_len = chld[1].arg_len;
  251. X        free_arg(chld);
  252. X    }
  253. X    else {
  254. X        arg[5].arg_type = A_EXPR;
  255. X        arg[5].arg_ptr.arg_arg = chld;
  256. X    }
  257. X    }
  258. X#ifdef DEBUGGING
  259. X    if (debug & 16) {
  260. X    fprintf(stderr,"%lx <= make_op(%s",arg,opname[arg->arg_type]);
  261. X    if (arg1)
  262. X        fprintf(stderr,",%s=%lx",
  263. X        argname[arg[1].arg_type&A_MASK],arg[1].arg_ptr.arg_arg);
  264. X    if (arg2)
  265. X        fprintf(stderr,",%s=%lx",
  266. X        argname[arg[2].arg_type&A_MASK],arg[2].arg_ptr.arg_arg);
  267. X    if (arg3)
  268. X        fprintf(stderr,",%s=%lx",
  269. X        argname[arg[3].arg_type&A_MASK],arg[3].arg_ptr.arg_arg);
  270. X    if (newlen >= 4)
  271. X        fprintf(stderr,",%s=%lx",
  272. X        argname[arg[4].arg_type&A_MASK],arg[4].arg_ptr.arg_arg);
  273. X    if (newlen >= 5)
  274. X        fprintf(stderr,",%s=%lx",
  275. X        argname[arg[5].arg_type&A_MASK],arg[5].arg_ptr.arg_arg);
  276. X    fprintf(stderr,")\n");
  277. X    }
  278. X#endif
  279. X    evalstatic(arg);        /* see if we can consolidate anything */
  280. X    return arg;
  281. X}
  282. X
  283. Xvoid
  284. Xevalstatic(arg)
  285. Xregister ARG *arg;
  286. X{
  287. X    register STR *str;
  288. X    register STR *s1;
  289. X    register STR *s2;
  290. X    double value;        /* must not be register */
  291. X    register char *tmps;
  292. X    int i;
  293. X    unsigned long tmplong;
  294. X    long tmp2;
  295. X    double exp(), log(), sqrt(), modf();
  296. X    char *crypt();
  297. X    double sin(), cos(), atan2(), pow();
  298. X
  299. X    if (!arg || !arg->arg_len)
  300. X    return;
  301. X
  302. X    if ((arg[1].arg_type == A_SINGLE || arg->arg_type == O_AELEM) &&
  303. X        (arg->arg_len == 1 || arg[2].arg_type == A_SINGLE) ) {
  304. X    str = Str_new(20,0);
  305. X    s1 = arg[1].arg_ptr.arg_str;
  306. X    if (arg->arg_len > 1)
  307. X        s2 = arg[2].arg_ptr.arg_str;
  308. X    else
  309. X        s2 = Nullstr;
  310. X    switch (arg->arg_type) {
  311. X    case O_AELEM:
  312. X        i = (int)str_gnum(s2);
  313. X        if (i < 32767 && i >= 0) {
  314. X        arg->arg_type = O_ITEM;
  315. X        arg->arg_len = 1;
  316. X        arg[1].arg_type = A_ARYSTAB;    /* $abc[123] is hoistable now */
  317. X        arg[1].arg_len = i;
  318. X        arg[1].arg_ptr = arg[1].arg_ptr;    /* get stab pointer */
  319. X        str_free(s2);
  320. X        }
  321. X        /* FALL THROUGH */
  322. X    default:
  323. X        str_free(str);
  324. X        str = Nullstr;        /* can't be evaluated yet */
  325. X        break;
  326. X    case O_CONCAT:
  327. X        str_sset(str,s1);
  328. X        str_scat(str,s2);
  329. X        break;
  330. X    case O_REPEAT:
  331. X        i = (int)str_gnum(s2);
  332. X        while (i-- > 0)
  333. X        str_scat(str,s1);
  334. X        break;
  335. X    case O_MULTIPLY:
  336. X        value = str_gnum(s1);
  337. X        str_numset(str,value * str_gnum(s2));
  338. X        break;
  339. X    case O_DIVIDE:
  340. X        value = str_gnum(s2);
  341. X        if (value == 0.0)
  342. X        yyerror("Illegal division by constant zero");
  343. X        else
  344. X        str_numset(str,str_gnum(s1) / value);
  345. X        break;
  346. X    case O_MODULO:
  347. X        tmplong = (long)str_gnum(s2);
  348. X        if (tmplong == 0L) {
  349. X        yyerror("Illegal modulus of constant zero");
  350. X        break;
  351. X        }
  352. X        tmp2 = (long)str_gnum(s1);
  353. X#ifndef lint
  354. X        if (tmp2 >= 0)
  355. X        str_numset(str,(double)(tmp2 % tmplong));
  356. X        else
  357. X        str_numset(str,(double)(tmplong - (-tmp2 % tmplong)));
  358. X#else
  359. X        tmp2 = tmp2;
  360. X#endif
  361. X        break;
  362. X    case O_ADD:
  363. X        value = str_gnum(s1);
  364. X        str_numset(str,value + str_gnum(s2));
  365. X        break;
  366. X    case O_SUBTRACT:
  367. X        value = str_gnum(s1);
  368. X        str_numset(str,value - str_gnum(s2));
  369. X        break;
  370. X    case O_LEFT_SHIFT:
  371. X        value = str_gnum(s1);
  372. X        i = (int)str_gnum(s2);
  373. X#ifndef lint
  374. X        str_numset(str,(double)(((long)value) << i));
  375. X#endif
  376. X        break;
  377. X    case O_RIGHT_SHIFT:
  378. X        value = str_gnum(s1);
  379. X        i = (int)str_gnum(s2);
  380. X#ifndef lint
  381. X        str_numset(str,(double)(((long)value) >> i));
  382. X#endif
  383. X        break;
  384. X    case O_LT:
  385. X        value = str_gnum(s1);
  386. X        str_numset(str,(value < str_gnum(s2)) ? 1.0 : 0.0);
  387. X        break;
  388. X    case O_GT:
  389. X        value = str_gnum(s1);
  390. X        str_numset(str,(value > str_gnum(s2)) ? 1.0 : 0.0);
  391. X        break;
  392. X    case O_LE:
  393. X        value = str_gnum(s1);
  394. X        str_numset(str,(value <= str_gnum(s2)) ? 1.0 : 0.0);
  395. X        break;
  396. X    case O_GE:
  397. X        value = str_gnum(s1);
  398. X        str_numset(str,(value >= str_gnum(s2)) ? 1.0 : 0.0);
  399. X        break;
  400. X    case O_EQ:
  401. X        if (dowarn) {
  402. X        if ((!s1->str_nok && !looks_like_number(s1)) ||
  403. X            (!s2->str_nok && !looks_like_number(s2)) )
  404. X            warn("Possible use of == on string value");
  405. X        }
  406. X        value = str_gnum(s1);
  407. X        str_numset(str,(value == str_gnum(s2)) ? 1.0 : 0.0);
  408. X        break;
  409. X    case O_NE:
  410. X        value = str_gnum(s1);
  411. X        str_numset(str,(value != str_gnum(s2)) ? 1.0 : 0.0);
  412. X        break;
  413. X    case O_BIT_AND:
  414. X        value = str_gnum(s1);
  415. X#ifndef lint
  416. X        str_numset(str,(double)(((long)value) & ((long)str_gnum(s2))));
  417. X#endif
  418. X        break;
  419. X    case O_XOR:
  420. X        value = str_gnum(s1);
  421. X#ifndef lint
  422. X        str_numset(str,(double)(((long)value) ^ ((long)str_gnum(s2))));
  423. X#endif
  424. X        break;
  425. X    case O_BIT_OR:
  426. X        value = str_gnum(s1);
  427. X#ifndef lint
  428. X        str_numset(str,(double)(((long)value) | ((long)str_gnum(s2))));
  429. X#endif
  430. X        break;
  431. X    case O_AND:
  432. X        if (str_true(s1))
  433. X        str_sset(str,s2);
  434. X        else
  435. X        str_sset(str,s1);
  436. X        break;
  437. X    case O_OR:
  438. X        if (str_true(s1))
  439. X        str_sset(str,s1);
  440. X        else
  441. X        str_sset(str,s2);
  442. X        break;
  443. X    case O_COND_EXPR:
  444. X        if ((arg[3].arg_type & A_MASK) != A_SINGLE) {
  445. X        str_free(str);
  446. X        str = Nullstr;
  447. X        }
  448. X        else {
  449. X        if (str_true(s1))
  450. X            str_sset(str,s2);
  451. X        else
  452. X            str_sset(str,arg[3].arg_ptr.arg_str);
  453. X        str_free(arg[3].arg_ptr.arg_str);
  454. X        }
  455. X        break;
  456. X    case O_NEGATE:
  457. X        str_numset(str,(double)(-str_gnum(s1)));
  458. X        break;
  459. X    case O_NOT:
  460. X        str_numset(str,(double)(!str_true(s1)));
  461. X        break;
  462. X    case O_COMPLEMENT:
  463. X#ifndef lint
  464. X        str_numset(str,(double)(~(long)str_gnum(s1)));
  465. X#endif
  466. X        break;
  467. X    case O_SIN:
  468. X        str_numset(str,sin(str_gnum(s1)));
  469. X        break;
  470. X    case O_COS:
  471. X        str_numset(str,cos(str_gnum(s1)));
  472. X        break;
  473. X    case O_ATAN2:
  474. X        value = str_gnum(s1);
  475. X        str_numset(str,atan2(value, str_gnum(s2)));
  476. X        break;
  477. X    case O_POW:
  478. X        value = str_gnum(s1);
  479. X        str_numset(str,pow(value, str_gnum(s2)));
  480. X        break;
  481. X    case O_LENGTH:
  482. X        str_numset(str, (double)str_len(s1));
  483. X        break;
  484. X    case O_SLT:
  485. X        str_numset(str,(double)(str_cmp(s1,s2) < 0));
  486. X        break;
  487. X    case O_SGT:
  488. X        str_numset(str,(double)(str_cmp(s1,s2) > 0));
  489. X        break;
  490. X    case O_SLE:
  491. X        str_numset(str,(double)(str_cmp(s1,s2) <= 0));
  492. X        break;
  493. X    case O_SGE:
  494. X        str_numset(str,(double)(str_cmp(s1,s2) >= 0));
  495. X        break;
  496. X    case O_SEQ:
  497. X        str_numset(str,(double)(str_eq(s1,s2)));
  498. X        break;
  499. X    case O_SNE:
  500. X        str_numset(str,(double)(!str_eq(s1,s2)));
  501. X        break;
  502. X    case O_CRYPT:
  503. X#ifdef CRYPT
  504. X        tmps = str_get(s1);
  505. X        str_set(str,crypt(tmps,str_get(s2)));
  506. X#else
  507. X        yyerror(
  508. X        "The crypt() function is unimplemented due to excessive paranoia.");
  509. X#endif
  510. X        break;
  511. X    case O_EXP:
  512. X        str_numset(str,exp(str_gnum(s1)));
  513. X        break;
  514. X    case O_LOG:
  515. X        str_numset(str,log(str_gnum(s1)));
  516. X        break;
  517. X    case O_SQRT:
  518. X        str_numset(str,sqrt(str_gnum(s1)));
  519. X        break;
  520. X    case O_INT:
  521. X        value = str_gnum(s1);
  522. X        if (value >= 0.0)
  523. X        (void)modf(value,&value);
  524. X        else {
  525. X        (void)modf(-value,&value);
  526. X        value = -value;
  527. X        }
  528. X        str_numset(str,value);
  529. X        break;
  530. X    case O_ORD:
  531. X#ifndef I286
  532. X        str_numset(str,(double)(*str_get(s1)));
  533. X#else
  534. X        {
  535. X        int  zapc;
  536. X        char *zaps;
  537. X
  538. X        zaps = str_get(s1);
  539. X        zapc = (int) *zaps;
  540. X        str_numset(str,(double)(zapc));
  541. X        }
  542. X#endif
  543. X        break;
  544. X    }
  545. X    if (str) {
  546. X        arg->arg_type = O_ITEM;    /* note arg1 type is already SINGLE */
  547. X        str_free(s1);
  548. X        str_free(s2);
  549. X        arg[1].arg_ptr.arg_str = str;
  550. X    }
  551. X    }
  552. X}
  553. X
  554. XARG *
  555. Xl(arg)
  556. Xregister ARG *arg;
  557. X{
  558. X    register int i;
  559. X    register ARG *arg1;
  560. X    register ARG *arg2;
  561. X    SPAT *spat;
  562. X    int arghog = 0;
  563. X
  564. X    i = arg[1].arg_type & A_MASK;
  565. X
  566. X    arg->arg_flags |= AF_COMMON;    /* assume something in common */
  567. X                    /* which forces us to copy things */
  568. X
  569. X    if (i == A_ARYLEN) {
  570. X    arg[1].arg_type = A_LARYLEN;
  571. X    return arg;
  572. X    }
  573. X    if (i == A_ARYSTAB) {
  574. X    arg[1].arg_type = A_LARYSTAB;
  575. X    return arg;
  576. X    }
  577. X
  578. X    /* see if it's an array reference */
  579. X
  580. X    if (i == A_EXPR || i == A_LEXPR) {
  581. X    arg1 = arg[1].arg_ptr.arg_arg;
  582. X
  583. X    if (arg1->arg_type == O_LIST || arg1->arg_type == O_ITEM) {
  584. X                        /* assign to list */
  585. X        if (arg->arg_len > 1) {
  586. X        dehoist(arg,2);
  587. X        arg2 = arg[2].arg_ptr.arg_arg;
  588. X        if (nothing_in_common(arg1,arg2))
  589. X            arg->arg_flags &= ~AF_COMMON;
  590. X        if (arg->arg_type == O_ASSIGN) {
  591. X            if (arg1->arg_flags & AF_LOCAL)
  592. X            arg->arg_flags |= AF_LOCAL;
  593. X            arg[1].arg_flags |= AF_ARYOK;
  594. X            arg[2].arg_flags |= AF_ARYOK;
  595. X        }
  596. X        }
  597. X        else if (arg->arg_type != O_CHOP)
  598. X        arg->arg_type = O_ASSIGN;    /* possible local(); */
  599. X        for (i = arg1->arg_len; i >= 1; i--) {
  600. X        switch (arg1[i].arg_type) {
  601. X        case A_STAR: case A_LSTAR:
  602. X            arg1[i].arg_type = A_LSTAR;
  603. X            break;
  604. X        case A_STAB: case A_LVAL:
  605. X            arg1[i].arg_type = A_LVAL;
  606. X            break;
  607. X        case A_ARYLEN: case A_LARYLEN:
  608. X            arg1[i].arg_type = A_LARYLEN;
  609. X            break;
  610. X        case A_ARYSTAB: case A_LARYSTAB:
  611. X            arg1[i].arg_type = A_LARYSTAB;
  612. X            break;
  613. X        case A_EXPR: case A_LEXPR:
  614. X            arg1[i].arg_type = A_LEXPR;
  615. X            switch(arg1[i].arg_ptr.arg_arg->arg_type) {
  616. X            case O_ARRAY: case O_LARRAY:
  617. X            arg1[i].arg_ptr.arg_arg->arg_type = O_LARRAY;
  618. X            arghog = 1;
  619. X            break;
  620. X            case O_AELEM: case O_LAELEM:
  621. X            arg1[i].arg_ptr.arg_arg->arg_type = O_LAELEM;
  622. X            break;
  623. X            case O_HASH: case O_LHASH:
  624. X            arg1[i].arg_ptr.arg_arg->arg_type = O_LHASH;
  625. X            arghog = 1;
  626. X            break;
  627. X            case O_HELEM: case O_LHELEM:
  628. X            arg1[i].arg_ptr.arg_arg->arg_type = O_LHELEM;
  629. X            break;
  630. X            case O_ASLICE: case O_LASLICE:
  631. X            arg1[i].arg_ptr.arg_arg->arg_type = O_LASLICE;
  632. X            break;
  633. X            case O_HSLICE: case O_LHSLICE:
  634. X            arg1[i].arg_ptr.arg_arg->arg_type = O_LHSLICE;
  635. X            break;
  636. X            default:
  637. X            goto ill_item;
  638. X            }
  639. X            break;
  640. X        default:
  641. X          ill_item:
  642. X            (void)sprintf(tokenbuf, "Illegal item (%s) as lvalue",
  643. X              argname[arg1[i].arg_type&A_MASK]);
  644. X            yyerror(tokenbuf);
  645. X        }
  646. X        }
  647. X        if (arg->arg_len > 1) {
  648. X        if (arg2->arg_type == O_SPLIT && !arg2[3].arg_type && !arghog) {
  649. X            arg2[3].arg_type = A_SINGLE;
  650. X            arg2[3].arg_ptr.arg_str =
  651. X              str_nmake((double)arg1->arg_len + 1); /* limit split len*/
  652. X        }
  653. X        }
  654. X    }
  655. X    else if (arg1->arg_type == O_AELEM || arg1->arg_type == O_LAELEM)
  656. X        arg1->arg_type = O_LAELEM;
  657. X    else if (arg1->arg_type == O_ARRAY || arg1->arg_type == O_LARRAY) {
  658. X        arg1->arg_type = O_LARRAY;
  659. X        if (arg->arg_len > 1) {
  660. X        dehoist(arg,2);
  661. X        arg2 = arg[2].arg_ptr.arg_arg;
  662. X        if (arg2->arg_type == O_SPLIT) { /* use split's builtin =?*/
  663. X            spat = arg2[2].arg_ptr.arg_spat;
  664. X            if (spat->spat_repl[1].arg_ptr.arg_stab == defstab &&
  665. X              nothing_in_common(arg1,spat->spat_repl)) {
  666. X            spat->spat_repl[1].arg_ptr.arg_stab =
  667. X                arg1[1].arg_ptr.arg_stab;
  668. X            arg_free(arg1);    /* recursive */
  669. X            free_arg(arg);    /* non-recursive */
  670. X            return arg2;    /* split has builtin assign */
  671. X            }
  672. X        }
  673. X        else if (nothing_in_common(arg1,arg2))
  674. X            arg->arg_flags &= ~AF_COMMON;
  675. X        if (arg->arg_type == O_ASSIGN) {
  676. X            arg[1].arg_flags |= AF_ARYOK;
  677. X            arg[2].arg_flags |= AF_ARYOK;
  678. X        }
  679. X        }
  680. X    }
  681. X    else if (arg1->arg_type == O_HELEM || arg1->arg_type == O_LHELEM)
  682. X        arg1->arg_type = O_LHELEM;
  683. X    else if (arg1->arg_type == O_HASH || arg1->arg_type == O_LHASH) {
  684. X        arg1->arg_type = O_LHASH;
  685. X        if (arg->arg_len > 1) {
  686. X        dehoist(arg,2);
  687. X        arg2 = arg[2].arg_ptr.arg_arg;
  688. X        if (nothing_in_common(arg1,arg2))
  689. X            arg->arg_flags &= ~AF_COMMON;
  690. X        if (arg->arg_type == O_ASSIGN) {
  691. X            arg[1].arg_flags |= AF_ARYOK;
  692. X            arg[2].arg_flags |= AF_ARYOK;
  693. X        }
  694. X        }
  695. X    }
  696. X    else if (arg1->arg_type == O_ASLICE) {
  697. X        arg1->arg_type = O_LASLICE;
  698. X        if (arg->arg_type == O_ASSIGN) {
  699. X        arg[1].arg_flags |= AF_ARYOK;
  700. X        arg[2].arg_flags |= AF_ARYOK;
  701. X        }
  702. X    }
  703. X    else if (arg1->arg_type == O_HSLICE) {
  704. X        arg1->arg_type = O_LHSLICE;
  705. X        if (arg->arg_type == O_ASSIGN) {
  706. X        arg[1].arg_flags |= AF_ARYOK;
  707. X        arg[2].arg_flags |= AF_ARYOK;
  708. X        }
  709. X    }
  710. X    else if ((arg->arg_type == O_DEFINED || arg->arg_type == O_UNDEF) &&
  711. X      (arg1->arg_type == (perldb ? O_DBSUBR : O_SUBR)) ) {
  712. X        arg[1].arg_type |= A_DONT;
  713. X    }
  714. X    else if (arg1->arg_type == O_SUBSTR || arg1->arg_type == O_VEC) {
  715. X        (void)l(arg1);
  716. X        Renewc(arg1->arg_ptr.arg_str, 1, struct lstring, STR);
  717. X            /* grow string struct to hold an lstring struct */
  718. X    }
  719. X    else if (arg1->arg_type == O_ASSIGN) {
  720. X        if (arg->arg_type == O_CHOP)
  721. X        arg[1].arg_flags &= ~AF_ARYOK;    /* grandfather chop idiom */
  722. X    }
  723. X    else {
  724. X        (void)sprintf(tokenbuf,
  725. X          "Illegal expression (%s) as lvalue",opname[arg1->arg_type]);
  726. X        yyerror(tokenbuf);
  727. X    }
  728. X    arg[1].arg_type = A_LEXPR | (arg[1].arg_type & A_DONT);
  729. X    if (arg->arg_type == O_ASSIGN && (arg1[1].arg_flags & AF_ARYOK)) {
  730. X        arg[1].arg_flags |= AF_ARYOK;
  731. X        if (arg->arg_len > 1)
  732. X        arg[2].arg_flags |= AF_ARYOK;
  733. X    }
  734. X#ifdef DEBUGGING
  735. X    if (debug & 16)
  736. X        fprintf(stderr,"lval LEXPR\n");
  737. X#endif
  738. X    return arg;
  739. X    }
  740. X    if (i == A_STAR || i == A_LSTAR) {
  741. X    arg[1].arg_type = A_LSTAR | (arg[1].arg_type & A_DONT);
  742. X    return arg;
  743. X    }
  744. X
  745. X    /* not an array reference, should be a register name */
  746. X
  747. X    if (i != A_STAB && i != A_LVAL) {
  748. X    (void)sprintf(tokenbuf,
  749. X      "Illegal item (%s) as lvalue",argname[arg[1].arg_type&A_MASK]);
  750. X    yyerror(tokenbuf);
  751. X    }
  752. X    arg[1].arg_type = A_LVAL | (arg[1].arg_type & A_DONT);
  753. X#ifdef DEBUGGING
  754. X    if (debug & 16)
  755. X    fprintf(stderr,"lval LVAL\n");
  756. X#endif
  757. X    return arg;
  758. X}
  759. X
  760. XARG *
  761. Xfixl(type,arg)
  762. Xint type;
  763. XARG *arg;
  764. X{
  765. X    if (type == O_DEFINED || type == O_UNDEF) {
  766. X    if (arg->arg_type != O_ITEM)
  767. X        arg = hide_ary(arg);
  768. X    if (arg->arg_type == O_ITEM) {
  769. X        type = arg[1].arg_type & A_MASK;
  770. X        if (type == A_EXPR || type == A_LEXPR)
  771. X        arg[1].arg_type = A_LEXPR|A_DONT;
  772. X    }
  773. X    }
  774. X    return arg;
  775. X}
  776. X
  777. Xdehoist(arg,i)
  778. XARG *arg;
  779. X{
  780. X    ARG *tmparg;
  781. X
  782. X    if (arg[i].arg_type != A_EXPR) {    /* dehoist */
  783. X    tmparg = make_op(O_ITEM,1,Nullarg,Nullarg,Nullarg);
  784. X    tmparg[1] = arg[i];
  785. X    arg[i].arg_ptr.arg_arg = tmparg;
  786. X    arg[i].arg_type = A_EXPR;
  787. X    }
  788. X}
  789. X
  790. XARG *
  791. Xaddflags(i,flags,arg)
  792. Xregister ARG *arg;
  793. X{
  794. X    arg[i].arg_flags |= flags;
  795. X    return arg;
  796. X}
  797. X
  798. XARG *
  799. Xhide_ary(arg)
  800. XARG *arg;
  801. X{
  802. X    if (arg->arg_type == O_ARRAY || arg->arg_type == O_HASH)
  803. X    return make_op(O_ITEM,1,arg,Nullarg,Nullarg);
  804. X    return arg;
  805. X}
  806. X
  807. X/* maybe do a join on multiple array dimensions */
  808. X
  809. XARG *
  810. Xjmaybe(arg)
  811. Xregister ARG *arg;
  812. X{
  813. X    if (arg && arg->arg_type == O_COMMA) {
  814. X    arg = listish(arg);
  815. X    arg = make_op(O_JOIN, 2,
  816. X        stab2arg(A_STAB,stabent(";",TRUE)),
  817. X        make_list(arg),
  818. X        Nullarg);
  819. X    }
  820. X    return arg;
  821. X}
  822. X
  823. XARG *
  824. Xmake_list(arg)
  825. Xregister ARG *arg;
  826. X{
  827. X    register int i;
  828. X    register ARG *node;
  829. X    register ARG *nxtnode;
  830. X    register int j;
  831. X    STR *tmpstr;
  832. X
  833. X    if (!arg) {
  834. X    arg = op_new(0);
  835. X    arg->arg_type = O_LIST;
  836. X    }
  837. X    if (arg->arg_type != O_COMMA) {
  838. X    if (arg->arg_type != O_ARRAY)
  839. X        arg->arg_flags |= AF_LISTISH;    /* see listish() below */
  840. X    return arg;
  841. X    }
  842. X    for (i = 2, node = arg; ; i++) {
  843. X    if (node->arg_len < 2)
  844. X        break;
  845. X        if (node[1].arg_type != A_EXPR)
  846. X        break;
  847. X    node = node[1].arg_ptr.arg_arg;
  848. X    if (node->arg_type != O_COMMA)
  849. X        break;
  850. X    }
  851. X    if (i > 2) {
  852. X    node = arg;
  853. X    arg = op_new(i);
  854. X    tmpstr = arg->arg_ptr.arg_str;
  855. X#ifdef STRUCTCOPY
  856. X    *arg = *node;        /* copy everything except the STR */
  857. X#else
  858. X    (void)bcopy((char *)node, (char *)arg, sizeof(ARG));
  859. X#endif
  860. X    arg->arg_ptr.arg_str = tmpstr;
  861. X    for (j = i; ; ) {
  862. X#ifdef STRUCTCOPY
  863. X        arg[j] = node[2];
  864. X#else
  865. X        (void)bcopy((char *)(node+2), (char *)(arg+j), sizeof(ARG));
  866. X#endif
  867. X        arg[j].arg_flags |= AF_ARYOK;
  868. X        --j;        /* Bug in Xenix compiler */
  869. X        if (j < 2) {
  870. X#ifdef STRUCTCOPY
  871. X        arg[1] = node[1];
  872. X#else
  873. X        (void)bcopy((char *)(node+1), (char *)(arg+1), sizeof(ARG));
  874. X#endif
  875. X        free_arg(node);
  876. X        break;
  877. X        }
  878. X        nxtnode = node[1].arg_ptr.arg_arg;
  879. X        free_arg(node);
  880. X        node = nxtnode;
  881. X    }
  882. X    }
  883. X    arg[1].arg_flags |= AF_ARYOK;
  884. X    arg[2].arg_flags |= AF_ARYOK;
  885. X    arg->arg_type = O_LIST;
  886. X    arg->arg_len = i;
  887. X    return arg;
  888. X}
  889. X
  890. X/* turn a single item into a list */
  891. X
  892. XARG *
  893. Xlistish(arg)
  894. XARG *arg;
  895. X{
  896. X    if (arg->arg_flags & AF_LISTISH)
  897. X    arg = make_op(O_LIST,1,arg,Nullarg,Nullarg);
  898. X    return arg;
  899. X}
  900. X
  901. XARG *
  902. Xmaybelistish(optype, arg)
  903. Xint optype;
  904. XARG *arg;
  905. X{
  906. X    if (optype == O_PRTF ||
  907. X      (arg->arg_type == O_ASLICE || arg->arg_type == O_HSLICE ||
  908. X       arg->arg_type == O_F_OR_R) )
  909. X    arg = listish(arg);
  910. X    return arg;
  911. X}
  912. X
  913. X/* mark list of local variables */
  914. X
  915. XARG *
  916. Xlocalize(arg)
  917. XARG *arg;
  918. X{
  919. X    arg->arg_flags |= AF_LOCAL;
  920. X    return arg;
  921. X}
  922. X
  923. XARG *
  924. Xfixeval(arg)
  925. XARG *arg;
  926. X{
  927. X    Renew(arg, 3, ARG);
  928. X    arg->arg_len = 2;
  929. X    arg[2].arg_ptr.arg_hash = curstash;
  930. X    arg[2].arg_type = A_NULL;
  931. X    return arg;
  932. X}
  933. X
  934. XARG *
  935. Xrcatmaybe(arg)
  936. XARG *arg;
  937. X{
  938. X    if (arg->arg_type == O_CONCAT && arg[2].arg_type == A_READ) {
  939. X    arg->arg_type = O_RCAT;    
  940. X    arg[2].arg_type = arg[2].arg_ptr.arg_arg[1].arg_type;
  941. X    arg[2].arg_ptr = arg[2].arg_ptr.arg_arg[1].arg_ptr;
  942. X    free_arg(arg[2].arg_ptr.arg_arg);
  943. X    }
  944. X    return arg;
  945. X}
  946. X
  947. XARG *
  948. Xstab2arg(atype,stab)
  949. Xint atype;
  950. Xregister STAB *stab;
  951. X{
  952. X    register ARG *arg;
  953. X
  954. X    arg = op_new(1);
  955. X    arg->arg_type = O_ITEM;
  956. X    arg[1].arg_type = atype;
  957. X    arg[1].arg_ptr.arg_stab = stab;
  958. X    return arg;
  959. X}
  960. X
  961. XARG *
  962. Xcval_to_arg(cval)
  963. Xregister char *cval;
  964. X{
  965. X    register ARG *arg;
  966. X
  967. X    arg = op_new(1);
  968. X    arg->arg_type = O_ITEM;
  969. X    arg[1].arg_type = A_SINGLE;
  970. X    arg[1].arg_ptr.arg_str = str_make(cval,0);
  971. X    Safefree(cval);
  972. X    return arg;
  973. X}
  974. X
  975. XARG *
  976. Xop_new(numargs)
  977. Xint numargs;
  978. X{
  979. X    register ARG *arg;
  980. X
  981. X    Newz(203,arg, numargs + 1, ARG);
  982. X    arg->arg_ptr.arg_str = Str_new(21,0);
  983. X    arg->arg_len = numargs;
  984. X    return arg;
  985. X}
  986. X
  987. Xvoid
  988. Xfree_arg(arg)
  989. XARG *arg;
  990. X{
  991. X    str_free(arg->arg_ptr.arg_str);
  992. X    Safefree(arg);
  993. X}
  994. X
  995. XARG *
  996. Xmake_match(type,expr,spat)
  997. Xint type;
  998. XARG *expr;
  999. XSPAT *spat;
  1000. X{
  1001. X    register ARG *arg;
  1002. X
  1003. X    arg = make_op(type,2,expr,Nullarg,Nullarg);
  1004. X
  1005. X    arg[2].arg_type = A_SPAT|A_DONT;
  1006. X    arg[2].arg_ptr.arg_spat = spat;
  1007. X#ifdef DEBUGGING
  1008. X    if (debug & 16)
  1009. X    fprintf(stderr,"make_match SPAT=%lx\n",(long)spat);
  1010. X#endif
  1011. X
  1012. X    if (type == O_SUBST || type == O_NSUBST) {
  1013. X    if (arg[1].arg_type != A_STAB) {
  1014. X        yyerror("Illegal lvalue");
  1015. X    }
  1016. X    arg[1].arg_type = A_LVAL;
  1017. X    }
  1018. X    return arg;
  1019. X}
  1020. X
  1021. XARG *
  1022. Xcmd_to_arg(cmd)
  1023. XCMD *cmd;
  1024. X{
  1025. X    register ARG *arg;
  1026. X
  1027. X    arg = op_new(1);
  1028. X    arg->arg_type = O_ITEM;
  1029. X    arg[1].arg_type = A_CMD;
  1030. X    arg[1].arg_ptr.arg_cmd = cmd;
  1031. X    return arg;
  1032. X}
  1033. X
  1034. X/* Check two expressions to see if there is any identifier in common */
  1035. X
  1036. Xstatic int
  1037. Xnothing_in_common(arg1,arg2)
  1038. XARG *arg1;
  1039. XARG *arg2;
  1040. X{
  1041. X    static int thisexpr = 0;    /* I don't care if this wraps */
  1042. X
  1043. X    thisexpr++;
  1044. X    if (arg_common(arg1,thisexpr,1))
  1045. X    return 0;    /* hit eval or do {} */
  1046. X    if (arg_common(arg2,thisexpr,0))
  1047. X    return 0;    /* hit identifier again */
  1048. X    return 1;
  1049. X}
  1050. X
  1051. X/* Recursively descend an expression and mark any identifier or check
  1052. X * it to see if it was marked already.
  1053. X */
  1054. X
  1055. Xstatic int
  1056. Xarg_common(arg,exprnum,marking)
  1057. Xregister ARG *arg;
  1058. Xint exprnum;
  1059. Xint marking;
  1060. X{
  1061. X    register int i;
  1062. X
  1063. X    if (!arg)
  1064. X    return 0;
  1065. X    for (i = arg->arg_len; i >= 1; i--) {
  1066. X    switch (arg[i].arg_type & A_MASK) {
  1067. X    case A_NULL:
  1068. X        break;
  1069. X    case A_LEXPR:
  1070. X    case A_EXPR:
  1071. X        if (arg_common(arg[i].arg_ptr.arg_arg,exprnum,marking))
  1072. X        return 1;
  1073. X        break;
  1074. X    case A_CMD:
  1075. X        return 1;        /* assume hanky panky */
  1076. X    case A_STAR:
  1077. X    case A_LSTAR:
  1078. X    case A_STAB:
  1079. X    case A_LVAL:
  1080. X    case A_ARYLEN:
  1081. X    case A_LARYLEN:
  1082. X        if (marking)
  1083. X        stab_lastexpr(arg[i].arg_ptr.arg_stab) = exprnum;
  1084. X        else if (stab_lastexpr(arg[i].arg_ptr.arg_stab) == exprnum)
  1085. X        return 1;
  1086. X        break;
  1087. X    case A_DOUBLE:
  1088. X    case A_BACKTICK:
  1089. X        {
  1090. X        register char *s = arg[i].arg_ptr.arg_str->str_ptr;
  1091. X        register char *send = s + arg[i].arg_ptr.arg_str->str_cur;
  1092. X        register STAB *stab;
  1093. X
  1094. X        while (*s) {
  1095. X            if (*s == '$' && s[1]) {
  1096. X            s = scanreg(s,send,tokenbuf);
  1097. X            stab = stabent(tokenbuf,TRUE);
  1098. X            if (marking)
  1099. X                stab_lastexpr(stab) = exprnum;
  1100. X            else if (stab_lastexpr(stab) == exprnum)
  1101. X                return 1;
  1102. X            continue;
  1103. X            }
  1104. X            else if (*s == '\\' && s[1])
  1105. X            s++;
  1106. X            s++;
  1107. X        }
  1108. X        }
  1109. X        break;
  1110. X    case A_SPAT:
  1111. X        if (spat_common(arg[i].arg_ptr.arg_spat,exprnum,marking))
  1112. X        return 1;
  1113. X        break;
  1114. X    case A_READ:
  1115. X    case A_INDREAD:
  1116. X    case A_GLOB:
  1117. X    case A_WORD:
  1118. X    case A_SINGLE:
  1119. X        break;
  1120. X    }
  1121. X    }
  1122. X    switch (arg->arg_type) {
  1123. X    case O_ARRAY:
  1124. X    case O_LARRAY:
  1125. X    if ((arg[1].arg_type & A_MASK) == A_STAB)
  1126. X        (void)aadd(arg[1].arg_ptr.arg_stab);
  1127. X    break;
  1128. X    case O_HASH:
  1129. X    case O_LHASH:
  1130. X    if ((arg[1].arg_type & A_MASK) == A_STAB)
  1131. X        (void)hadd(arg[1].arg_ptr.arg_stab);
  1132. X    break;
  1133. X    case O_EVAL:
  1134. X    case O_SUBR:
  1135. X    case O_DBSUBR:
  1136. X    return 1;
  1137. X    }
  1138. X    return 0;
  1139. X}
  1140. X
  1141. Xstatic int
  1142. Xspat_common(spat,exprnum,marking)
  1143. Xregister SPAT *spat;
  1144. Xint exprnum;
  1145. Xint marking;
  1146. X{
  1147. X    if (spat->spat_runtime)
  1148. X    if (arg_common(spat->spat_runtime,exprnum,marking))
  1149. X        return 1;
  1150. X    if (spat->spat_repl) {
  1151. X    if (arg_common(spat->spat_repl,exprnum,marking))
  1152. X        return 1;
  1153. X    }
  1154. X    return 0;
  1155. X}
  1156. !STUFFY!FUNK!
  1157. echo Extracting config.h.SH
  1158. sed >config.h.SH <<'!STUFFY!FUNK!' -e 's/X//'
  1159. Xcase $CONFIG in
  1160. X'')
  1161. X    if test ! -f config.sh; then
  1162. X    ln ../config.sh . || \
  1163. X    ln ../../config.sh . || \
  1164. X    ln ../../../config.sh . || \
  1165. X    (echo "Can't find config.sh."; exit 1)
  1166. X    echo "Using config.sh from above..."
  1167. X    fi
  1168. X    . ./config.sh
  1169. X    ;;
  1170. Xesac
  1171. Xecho "Extracting config.h (with variable substitutions)"
  1172. Xsed <<!GROK!THIS! >config.h -e 's!^#undef!/\*#undef!'
  1173. X/* config.h
  1174. X * This file was produced by running the config.h.SH script, which
  1175. X * gets its values from config.sh, which is generally produced by
  1176. X * running Configure.
  1177. X *
  1178. X * Feel free to modify any of this as the need arises.  Note, however,
  1179. X * that running config.h.SH again will wipe out any changes you've made.
  1180. X * For a more permanent change edit config.sh and rerun config.h.SH.
  1181. X */
  1182. X
  1183. X
  1184. X/* EUNICE:
  1185. X *    This symbol, if defined, indicates that the program is being compiled
  1186. X *    under the EUNICE package under VMS.  The program will need to handle
  1187. X *    things like files that don't go away the first time you unlink them,
  1188. X *    due to version numbering.  It will also need to compensate for lack
  1189. X *    of a respectable link() command.
  1190. X */
  1191. X/* VMS:
  1192. X *    This symbol, if defined, indicates that the program is running under
  1193. X *    VMS.  It is currently only set in conjunction with the EUNICE symbol.
  1194. X */
  1195. X#$d_eunice    EUNICE        /**/
  1196. X#$d_eunice    VMS        /**/
  1197. X
  1198. X/* BIN:
  1199. X *    This symbol holds the name of the directory in which the user wants
  1200. X *    to put publicly executable images for the package in question.  It
  1201. X *    is most often a local directory such as /usr/local/bin.
  1202. X */
  1203. X#define BIN "$bin"             /**/
  1204. X
  1205. X/* BYTEORDER:
  1206. X *    This symbol contains an encoding of the order of bytes in a long.
  1207. X *    Usual values (in octal) are 01234, 04321, 02143, 03412...
  1208. X */
  1209. X#define BYTEORDER 0$byteorder        /**/
  1210. X
  1211. X/* CPPSTDIN:
  1212. X *    This symbol contains the first part of the string which will invoke
  1213. X *    the C preprocessor on the standard input and produce to standard
  1214. X *    output.     Typical value of "cc -E" or "/lib/cpp".
  1215. X */
  1216. X/* CPPMINUS:
  1217. X *    This symbol contains the second part of the string which will invoke
  1218. X *    the C preprocessor on the standard input and produce to standard
  1219. X *    output.  This symbol will have the value "-" if CPPSTDIN needs a minus
  1220. X *    to specify standard input, otherwise the value is "".
  1221. X */
  1222. X#define CPPSTDIN "$cppstdin"
  1223. X#define CPPMINUS "$cppminus"
  1224. X
  1225. X/* BCMP:
  1226. X *    This symbol, if defined, indicates that the bcmp routine is available
  1227. X *    to compare blocks of memory.  If undefined, use memcmp.  If that's
  1228. X *    not available, roll your own.
  1229. X */
  1230. X#$d_bcmp    BCMP        /**/
  1231. X
  1232. X/* BCOPY:
  1233. X *    This symbol, if defined, indicates that the bcopy routine is available
  1234. X *    to copy blocks of memory.  Otherwise you should probably use memcpy().
  1235. X */
  1236. X#$d_bcopy    BCOPY        /**/
  1237. X
  1238. X/* CHARSPRINTF:
  1239. X *    This symbol is defined if this system declares "char *sprintf()" in
  1240. X *    stdio.h.  The trend seems to be to declare it as "int sprintf()".  It
  1241. X *    is up to the package author to declare sprintf correctly based on the
  1242. X *    symbol.
  1243. X */
  1244. X#$d_charsprf    CHARSPRINTF     /**/
  1245. X
  1246. X/* CRYPT:
  1247. X *    This symbol, if defined, indicates that the crypt routine is available
  1248. X *    to encrypt passwords and the like.
  1249. X */
  1250. X#$d_crypt    CRYPT        /**/
  1251. X
  1252. X/* DOSUID:
  1253. X *    This symbol, if defined, indicates that the C program should
  1254. X *    check the script that it is executing for setuid/setgid bits, and
  1255. X *    attempt to emulate setuid/setgid on systems that have disabled
  1256. X *    setuid #! scripts because the kernel can't do it securely.
  1257. X *    It is up to the package designer to make sure that this emulation
  1258. X *    is done securely.  Among other things, it should do an fstat on
  1259. X *    the script it just opened to make sure it really is a setuid/setgid
  1260. X *    script, it should make sure the arguments passed correspond exactly
  1261. X *    to the argument on the #! line, and it should not trust any
  1262. X *    subprocesses to which it must pass the filename rather than the
  1263. X *    file descriptor of the script to be executed.
  1264. X */
  1265. X#$d_dosuid DOSUID        /**/
  1266. X
  1267. X/* DUP2:
  1268. X *    This symbol, if defined, indicates that the dup2 routine is available
  1269. X *    to dup file descriptors.  Otherwise you should use dup().
  1270. X */
  1271. X#$d_dup2    DUP2        /**/
  1272. X
  1273. X/* FCHMOD:
  1274. X *    This symbol, if defined, indicates that the fchmod routine is available
  1275. X *    to change mode of opened files.  If unavailable, use chmod().
  1276. X */
  1277. X#$d_fchmod    FCHMOD        /**/
  1278. X
  1279. X/* FCHOWN:
  1280. X *    This symbol, if defined, indicates that the fchown routine is available
  1281. X *    to change ownership of opened files.  If unavailable, use chown().
  1282. X */
  1283. X#$d_fchown    FCHOWN        /**/
  1284. X
  1285. X/* FCNTL:
  1286. X *    This symbol, if defined, indicates to the C program that it should
  1287. X *    include fcntl.h.
  1288. X */
  1289. X#$d_fcntl    FCNTL        /**/
  1290. X
  1291. X/* FLOCK:
  1292. X *    This symbol, if defined, indicates that the flock() routine is
  1293. X *    available to do file locking.
  1294. X */
  1295. X#$d_flock    FLOCK        /**/
  1296. X
  1297. X/* GETGROUPS:
  1298. X *    This symbol, if defined, indicates that the getgroups() routine is
  1299. X *    available to get the list of process groups.  If unavailable, multiple
  1300. X *    groups are probably not supported.
  1301. X */
  1302. X#$d_getgrps    GETGROUPS        /**/
  1303. X
  1304. X/* GETHOSTENT:
  1305. X *    This symbol, if defined, indicates that the gethostent() routine is
  1306. X *    available to lookup host names in some data base or other.
  1307. X */
  1308. X#$d_gethent    GETHOSTENT        /**/
  1309. X
  1310. X/* GETPGRP:
  1311. X *    This symbol, if defined, indicates that the getpgrp() routine is
  1312. X *    available to get the current process group.
  1313. X */
  1314. X#$d_getpgrp    GETPGRP        /**/
  1315. X
  1316. X/* GETPRIORITY:
  1317. X *    This symbol, if defined, indicates that the getpriority() routine is
  1318. X *    available to get a process's priority.
  1319. X */
  1320. X#$d_getprior    GETPRIORITY        /**/
  1321. X
  1322. X/* HTONS:
  1323. X *    This symbol, if defined, indicates that the htons routine (and friends)
  1324. X *    are available to do network order byte swapping.
  1325. X */
  1326. X/* HTONL:
  1327. X *    This symbol, if defined, indicates that the htonl routine (and friends)
  1328. X *    are available to do network order byte swapping.
  1329. X */
  1330. X/* NTOHS:
  1331. X *    This symbol, if defined, indicates that the ntohs routine (and friends)
  1332. X *    are available to do network order byte swapping.
  1333. X */
  1334. X/* NTOHL:
  1335. X *    This symbol, if defined, indicates that the ntohl routine (and friends)
  1336. X *    are available to do network order byte swapping.
  1337. X */
  1338. X#$d_htonl    HTONS        /**/
  1339. X#$d_htonl    HTONL        /**/
  1340. X#$d_htonl    NTOHS        /**/
  1341. X#$d_htonl    NTOHL        /**/
  1342. X
  1343. X/* index:
  1344. X *    This preprocessor symbol is defined, along with rindex, if the system
  1345. X *    uses the strchr and strrchr routines instead.
  1346. X */
  1347. X/* rindex:
  1348. X *    This preprocessor symbol is defined, along with index, if the system
  1349. X *    uses the strchr and strrchr routines instead.
  1350. X */
  1351. X#$d_index    index strchr    /* cultural */
  1352. X#$d_index    rindex strrchr    /*  differences? */
  1353. X
  1354. X/* IOCTL:
  1355. X *    This symbol, if defined, indicates that sys/ioctl.h exists and should
  1356. X *    be included.
  1357. X */
  1358. X#$d_ioctl    IOCTL        /**/
  1359. X
  1360. X/* KILLPG:
  1361. X *    This symbol, if defined, indicates that the killpg routine is available
  1362. X *    to kill process groups.  If unavailable, you probably should use kill
  1363. X *    with a negative process number.
  1364. X */
  1365. X#$d_killpg    KILLPG        /**/
  1366. X
  1367. X/* MEMCMP:
  1368. X *    This symbol, if defined, indicates that the memcmp routine is available
  1369. X *    to compare blocks of memory.  If undefined, roll your own.
  1370. X */
  1371. X#$d_memcmp    MEMCMP        /**/
  1372. X
  1373. X/* MEMCPY:
  1374. X *    This symbol, if defined, indicates that the memcpy routine is available
  1375. X *    to copy blocks of memory.  Otherwise you should probably use bcopy().
  1376. X *    If neither is defined, roll your own.
  1377. X */
  1378. X#$d_memcpy    MEMCPY        /**/
  1379. X
  1380. X/* MKDIR:
  1381. X *    This symbol, if defined, indicates that the mkdir routine is available
  1382. X *    to create directories.  Otherwise you should fork off a new process to
  1383. X *    exec /bin/mkdir.
  1384. X */
  1385. X#$d_mkdir    MKDIR        /**/
  1386. X
  1387. X/* NDBM:
  1388. X *    This symbol, if defined, indicates that ndbm.h exists and should
  1389. X *    be included.
  1390. X */
  1391. X#$d_ndbm    NDBM        /**/
  1392. X
  1393. X/* ODBM:
  1394. X *    This symbol, if defined, indicates that dbm.h exists and should
  1395. X *    be included.
  1396. X */
  1397. X#$d_odbm    ODBM        /**/
  1398. X
  1399. X/* READDIR:
  1400. X *    This symbol, if defined, indicates that the readdir routine is available
  1401. X *    from the C library to create directories.
  1402. X */
  1403. X#$d_readdir    READDIR        /**/
  1404. X
  1405. X/* RENAME:
  1406. X *    This symbol, if defined, indicates that the rename routine is available
  1407. X *    to rename files.  Otherwise you should do the unlink(), link(), unlink()
  1408. X *    trick.
  1409. X */
  1410. X#$d_rename    RENAME        /**/
  1411. X
  1412. X/* RMDIR:
  1413. X *    This symbol, if defined, indicates that the rmdir routine is available
  1414. X *    to remove directories.  Otherwise you should fork off a new process to
  1415. X *    exec /bin/rmdir.
  1416. X */
  1417. X#$d_rmdir    RMDIR        /**/
  1418. X
  1419. X/* SETEGID:
  1420. X *    This symbol, if defined, indicates that the setegid routine is available
  1421. X *    to change the effective gid of the current program.
  1422. X */
  1423. X#$d_setegid    SETEGID        /**/
  1424. X
  1425. X/* SETEUID:
  1426. X *    This symbol, if defined, indicates that the seteuid routine is available
  1427. X *    to change the effective uid of the current program.
  1428. X */
  1429. X#$d_seteuid    SETEUID        /**/
  1430. X
  1431. X/* SETPGRP:
  1432. X *    This symbol, if defined, indicates that the setpgrp() routine is
  1433. X *    available to set the current process group.
  1434. X */
  1435. X#$d_setpgrp    SETPGRP        /**/
  1436. X
  1437. X/* SETPRIORITY:
  1438. X *    This symbol, if defined, indicates that the setpriority() routine is
  1439. X *    available to set a process's priority.
  1440. X */
  1441. X#$d_setprior    SETPRIORITY        /**/
  1442. X
  1443. X/* SETREGID:
  1444. X *    This symbol, if defined, indicates that the setregid routine is
  1445. X *    available to change the real and effective gid of the current program.
  1446. X */
  1447. X/* SETRESGID:
  1448. X *    This symbol, if defined, indicates that the setresgid routine is
  1449. X *    available to change the real, effective and saved gid of the current
  1450. X *    program.
  1451. X */
  1452. X#$d_setregid    SETREGID        /**/
  1453. X#$d_setresgid    SETRESGID        /**/
  1454. X
  1455. X/* SETREUID:
  1456. X *    This symbol, if defined, indicates that the setreuid routine is
  1457. X *    available to change the real and effective uid of the current program.
  1458. X */
  1459. X/* SETRESUID:
  1460. X *    This symbol, if defined, indicates that the setresuid routine is
  1461. X *    available to change the real, effective and saved uid of the current
  1462. X *    program.
  1463. X */
  1464. X#$d_setreuid    SETREUID        /**/
  1465. X#$d_setresuid    SETRESUID        /**/
  1466. X
  1467. X/* SETRGID:
  1468. X *    This symbol, if defined, indicates that the setrgid routine is available
  1469. X *    to change the real gid of the current program.
  1470. X */
  1471. X#$d_setrgid    SETRGID        /**/
  1472. X
  1473. X/* SETRUID:
  1474. X *    This symbol, if defined, indicates that the setruid routine is available
  1475. X *    to change the real uid of the current program.
  1476. X */
  1477. X#$d_setruid    SETRUID        /**/
  1478. X
  1479. X/* SOCKET:
  1480. X *    This symbol, if defined, indicates that the BSD socket interface is
  1481. X *    supported.
  1482. X */
  1483. X/* SOCKETPAIR:
  1484. X *    This symbol, if defined, indicates that the BSD socketpair call is
  1485. X *    supported.
  1486. X */
  1487. X/* OLDSOCKET:
  1488. X *    This symbol, if defined, indicates that the 4.1c BSD socket interface
  1489. X *    is supported instead of the 4.2/4.3 BSD socket interface.
  1490. X */
  1491. X#$d_socket    SOCKET        /**/
  1492. X
  1493. X#$d_sockpair    SOCKETPAIR    /**/
  1494. X
  1495. X#$d_oldsock    OLDSOCKET    /**/
  1496. X
  1497. X/* STATBLOCKS:
  1498. X *    This symbol is defined if this system has a stat structure declaring
  1499. X *    st_blksize and st_blocks.
  1500. X */
  1501. X#$d_statblks    STATBLOCKS     /**/
  1502. X
  1503. X/* STDSTDIO:
  1504. X *    This symbol is defined if this system has a FILE structure declaring
  1505. X *    _ptr and _cnt in stdio.h.
  1506. X */
  1507. X#$d_stdstdio    STDSTDIO     /**/
  1508. X
  1509. X/* STRUCTCOPY:
  1510. X *    This symbol, if defined, indicates that this C compiler knows how
  1511. X *    to copy structures.  If undefined, you'll need to use a block copy
  1512. X *    routine of some sort instead.
  1513. X */
  1514. X#$d_strctcpy    STRUCTCOPY    /**/
  1515. X
  1516. X/* SYMLINK:
  1517. X *    This symbol, if defined, indicates that the symlink routine is available
  1518. X *    to create symbolic links.
  1519. X */
  1520. X#$d_symlink    SYMLINK        /**/
  1521. X
  1522. X/* SYSCALL:
  1523. X *    This symbol, if defined, indicates that the syscall routine is available
  1524. X *    to call arbitrary system calls.  If undefined, that's tough.
  1525. X */
  1526. X#$d_syscall    SYSCALL        /**/
  1527. X
  1528. X/* TMINSYS:
  1529. X *    This symbol is defined if this system declares "struct tm" in
  1530. X *    in <sys/time.h> rather than <time.h>.  We can't just say
  1531. X *    -I/usr/include/sys because some systems have both time files, and
  1532. X *    the -I trick gets the wrong one.
  1533. X */
  1534. X/* I_SYSTIME:
  1535. X *    This symbol is defined if this system has the file <sys/time.h>.
  1536. X */
  1537. X#$d_tminsys    TMINSYS     /**/
  1538. X#$i_systime    I_SYSTIME     /**/
  1539. X
  1540. X/* VARARGS:
  1541. X *    This symbol, if defined, indicates to the C program that it should
  1542. X *    include varargs.h.
  1543. X */
  1544. X#$d_varargs    VARARGS        /**/
  1545. X
  1546. X/* vfork:
  1547. X *    This symbol, if defined, remaps the vfork routine to fork if the
  1548. X *    vfork() routine isn't supported here.
  1549. X */
  1550. X#$d_vfork    vfork fork    /**/
  1551. X
  1552. X/* VOIDSIG:
  1553. X *    This symbol is defined if this system declares "void (*signal())()" in
  1554. X *    signal.h.  The old way was to declare it as "int (*signal())()".  It
  1555. X *    is up to the package author to declare things correctly based on the
  1556. X *    symbol.
  1557. X */
  1558. X#$d_voidsig    VOIDSIG     /**/
  1559. X
  1560. X/* VPRINTF:
  1561. X *    This symbol, if defined, indicates that the vprintf routine is available
  1562. X *    to printf with a pointer to an argument list.  If unavailable, you
  1563. X *    may need to write your own, probably in terms of _doprnt().
  1564. X */
  1565. X/* CHARVSPRINTF:
  1566. X *    This symbol is defined if this system has vsprintf() returning type
  1567. X *    (char*).  The trend seems to be to declare it as "int vsprintf()".  It
  1568. X *    is up to the package author to declare vsprintf correctly based on the
  1569. X *    symbol.
  1570. X */
  1571. X#$d_vprintf    VPRINTF        /**/
  1572. X#$d_charvspr    CHARVSPRINTF     /**/
  1573. X
  1574. X/* GIDTYPE:
  1575. X *    This symbol has a value like gid_t, int, ushort, or whatever type is
  1576. X *    used to declare group ids in the kernel.
  1577. X */
  1578. X#define GIDTYPE $gidtype        /**/
  1579. X
  1580. X/* I_DIRENT:
  1581. X *    This symbol, if defined, indicates to the C program that it should
  1582. X *    include dirent.h.
  1583. X */
  1584. X/* DIRNAMLEN:
  1585. X *    This symbol, if defined, indicates to the C program that the length
  1586. X *    of directory entry names is provided by a d_namlen field.  Otherwise
  1587. X *    you need to do strlen() on the d_name field.
  1588. X */
  1589. X#$i_dirent    I_DIRENT        /**/
  1590. X#$d_dirnamlen    DIRNAMLEN        /**/
  1591. X
  1592. X/* I_FCNTL:
  1593. X *    This symbol, if defined, indicates to the C program that it should
  1594. X *    include fcntl.h.
  1595. X */
  1596. X#$i_fcntl    I_FCNTL        /**/
  1597. X
  1598. X/* I_GRP:
  1599. X *    This symbol, if defined, indicates to the C program that it should
  1600. X *    include grp.h.
  1601. X */
  1602. X#$i_grp    I_GRP        /**/
  1603. X
  1604. X/* I_PWD:
  1605. X *    This symbol, if defined, indicates to the C program that it should
  1606. X *    include pwd.h.
  1607. X */
  1608. X/* PWQUOTA:
  1609. X *    This symbol, if defined, indicates to the C program that struct passwd
  1610. X *    contains pw_quota.
  1611. X */
  1612. X/* PWAGE:
  1613. X *    This symbol, if defined, indicates to the C program that struct passwd
  1614. X *    contains pw_age.
  1615. X */
  1616. X#$i_pwd    I_PWD        /**/
  1617. X#$d_pwquota    PWQUOTA        /**/
  1618. X#$d_pwage    PWAGE        /**/
  1619. X
  1620. X/* I_SYSDIR:
  1621. X *    This symbol, if defined, indicates to the C program that it should
  1622. X *    include sys/dir.h.
  1623. X */
  1624. X#$i_sysdir    I_SYSDIR        /**/
  1625. X
  1626. X/* I_SYSIOCTL:
  1627. X *    This symbol, if defined, indicates that sys/ioctl.h exists and should
  1628. X *    be included.
  1629. X */
  1630. X#$i_sysioctl    I_SYSIOCTL        /**/
  1631. X
  1632. X/* I_VARARGS:
  1633. X *    This symbol, if defined, indicates to the C program that it should
  1634. X *    include varargs.h.
  1635. X */
  1636. X#$i_varargs    I_VARARGS        /**/
  1637. X
  1638. X/* I_VFORK:
  1639. X *    This symbol, if defined, indicates to the C program that it should
  1640. X *    include vfork.h.
  1641. X */
  1642. X#$i_vfork    I_VFORK        /**/
  1643. X
  1644. X/* INTSIZE:
  1645. X *    This symbol contains the size of an int, so that the C preprocessor
  1646. X *    can make decisions based on it.
  1647. X */
  1648. X#define INTSIZE $intsize        /**/
  1649. X
  1650. X/* RANDBITS:
  1651. X *    This symbol contains the number of bits of random number the rand()
  1652. X *    function produces.  Usual values are 15, 16, and 31.
  1653. X */
  1654. X#define RANDBITS $randbits        /**/
  1655. X
  1656. X/* SIG_NAME:
  1657. X *    This symbol contains an list of signal names in order.
  1658. X */
  1659. X#define SIG_NAME "`echo $sig_name | sed 's/ /","/g'`"        /**/
  1660. X
  1661. X/* STDCHAR:
  1662. X *    This symbol is defined to be the type of char used in stdio.h.
  1663. X *    It has the values "unsigned char" or "char".
  1664. X */
  1665. X#define STDCHAR $stdchar    /**/
  1666. X
  1667. X/* UIDTYPE:
  1668. X *    This symbol has a value like uid_t, int, ushort, or whatever type is
  1669. X *    used to declare user ids in the kernel.
  1670. X */
  1671. X#define UIDTYPE $uidtype        /**/
  1672. X
  1673. X/* VOIDFLAGS:
  1674. X *    This symbol indicates how much support of the void type is given by this
  1675. X *    compiler.  What various bits mean:
  1676. X *
  1677. X *        1 = supports declaration of void
  1678. X *        2 = supports arrays of pointers to functions returning void
  1679. X *        4 = supports comparisons between pointers to void functions and
  1680. X *            addresses of void functions
  1681. X *
  1682. X *    The package designer should define VOIDUSED to indicate the requirements
  1683. X *    of the package.  This can be done either by #defining VOIDUSED before
  1684. X *    including config.h, or by defining defvoidused in Myinit.U.  If the
  1685. X *    latter approach is taken, only those flags will be tested.  If the
  1686. X *    level of void support necessary is not present, defines void to int.
  1687. X */
  1688. X#ifndef VOIDUSED
  1689. X#define VOIDUSED $defvoidused
  1690. X#endif
  1691. X#define VOIDFLAGS $voidflags
  1692. X#if (VOIDFLAGS & VOIDUSED) != VOIDUSED
  1693. X#$define void int        /* is void to be avoided? */
  1694. X#$define M_VOID        /* Xenix strikes again */
  1695. X#endif
  1696. X
  1697. X/* PRIVLIB:
  1698. X *    This symbol contains the name of the private library for this package.
  1699. X *    The library is private in the sense that it needn't be in anyone's
  1700. X *    execution path, but it should be accessible by the world.  The program
  1701. X *    should be prepared to do ~ expansion.
  1702. X */
  1703. X#define PRIVLIB "$privlib"        /**/
  1704. X
  1705. X!GROK!THIS!
  1706. !STUFFY!FUNK!
  1707. echo Extracting str.h
  1708. sed >str.h <<'!STUFFY!FUNK!' -e 's/X//'
  1709. X/* $Header: str.h,v 3.0 89/10/18 15:23:49 lwall Locked $
  1710. X *
  1711. X *    Copyright (c) 1989, Larry Wall
  1712. X *
  1713. X *    You may distribute under the terms of the GNU General Public License
  1714. X *    as specified in the README file that comes with the perl 3.0 kit.
  1715. X *
  1716. X * $Log:    str.h,v $
  1717. X * Revision 3.0  89/10/18  15:23:49  lwall
  1718. X * 3.0 baseline
  1719. X * 
  1720. X */
  1721. X
  1722. Xstruct string {
  1723. X    char *    str_ptr;    /* pointer to malloced string */
  1724. X    union {
  1725. X    double    str_nval;    /* numeric value, if any */
  1726. X    STAB    *str_stab;    /* magic stab for magic "key" string */
  1727. X    long    str_useful;    /* is this search optimization effective? */
  1728. X    ARG    *str_args;    /* list of args for interpreted string */
  1729. X    HASH    *str_hash;    /* string represents an assoc array (stab?) */
  1730. X    ARRAY    *str_array;    /* string represents an array */
  1731. X    } str_u;
  1732. X    int        str_len;    /* allocated size */
  1733. X    int        str_cur;    /* length of str_ptr as a C string */
  1734. X    STR *str_magic;        /* while free, link to next free str */
  1735. X                /* while in use, ptr to "key" for magic items */
  1736. X    char    str_pok;    /* state of str_ptr */
  1737. X    char    str_nok;    /* state of str_nval */
  1738. X    unsigned char str_rare;    /* used by search strings */
  1739. X    unsigned char str_state;    /* one of SS_* below */
  1740. X                /* also used by search strings for backoff */
  1741. X#ifdef TAINT
  1742. X    bool    str_tainted;    /* 1 if possibly under control of $< */
  1743. X#endif
  1744. X};
  1745. X
  1746. Xstruct stab {    /* should be identical, except for str_ptr */
  1747. X    STBP *    str_ptr;    /* pointer to malloced string */
  1748. X    union {
  1749. X    double    str_nval;    /* numeric value, if any */
  1750. X    STAB    *str_stab;    /* magic stab for magic "key" string */
  1751. X    long    str_useful;    /* is this search optimization effective? */
  1752. X    ARG    *str_args;    /* list of args for interpreted string */
  1753. X    HASH    *str_hash;    /* string represents an assoc array (stab?) */
  1754. X    ARRAY    *str_array;    /* string represents an array */
  1755. X    } str_u;
  1756. X    int        str_len;    /* allocated size */
  1757. X    int        str_cur;    /* length of str_ptr as a C string */
  1758. X    STR *str_magic;        /* while free, link to next free str */
  1759. X                /* while in use, ptr to "key" for magic items */
  1760. X    char    str_pok;    /* state of str_ptr */
  1761. X    char    str_nok;    /* state of str_nval */
  1762. X    unsigned char str_rare;    /* used by search strings */
  1763. X    unsigned char str_state;    /* one of SS_* below */
  1764. X                /* also used by search strings for backoff */
  1765. X#ifdef TAINT
  1766. X    bool    str_tainted;    /* 1 if possibly under control of $< */
  1767. X#endif
  1768. X};
  1769. X
  1770. X/* some extra info tacked to some lvalue strings */
  1771. X
  1772. Xstruct lstring {
  1773. X    struct string lstr;
  1774. X    int    lstr_offset;
  1775. X    int    lstr_len;
  1776. X};
  1777. X
  1778. X/* These are the values of str_pok:        */
  1779. X#define SP_VALID    1    /* str_ptr is valid */
  1780. X#define SP_FBM        2    /* string was compiled for fbm search */
  1781. X#define SP_STUDIED    4    /* string was studied */
  1782. X#define SP_CASEFOLD    8    /* case insensitive fbm search */
  1783. X#define SP_INTRP    16    /* string was compiled for interping */
  1784. X#define SP_TAIL        32    /* fbm string is tail anchored: /foo$/  */
  1785. X#define SP_MULTI    64    /* symbol table entry probably isn't a typo */
  1786. X
  1787. X#define Nullstr Null(STR*)
  1788. X
  1789. X/* These are the values of str_state:        */
  1790. X#define SS_NORM        0    /* normal string */
  1791. X#define SS_INCR        1    /* normal string, incremented ptr */
  1792. X#define SS_SARY        2    /* array on save stack */
  1793. X#define SS_SHASH    3    /* associative array on save stack */
  1794. X#define SS_SINT        4    /* integer on save stack */
  1795. X#define SS_SLONG    5    /* long on save stack */
  1796. X#define SS_SSTRP    6    /* STR* on save stack */
  1797. X#define SS_SHPTR    7    /* HASH* on save stack */
  1798. X#define SS_SNSTAB    8    /* non-stab on save stack */
  1799. X#define SS_HASH        253    /* carrying an hash */
  1800. X#define SS_ARY        254    /* carrying an array */
  1801. X#define SS_FREE        255    /* in free list */
  1802. X/* str_state may have any value 0-255 when used to hold fbm pattern, in which */
  1803. X/* case it indicates offset to rarest character in screaminstr key */
  1804. X
  1805. X/* the following macro updates any magic values this str is associated with */
  1806. X
  1807. X#ifdef TAINT
  1808. X#define STABSET(x) \
  1809. X    (x)->str_tainted |= tainted; \
  1810. X    if ((x)->str_magic) \
  1811. X    stabset((x)->str_magic,(x))
  1812. X#else
  1813. X#define STABSET(x) \
  1814. X    if ((x)->str_magic) \
  1815. X    stabset((x)->str_magic,(x))
  1816. X#endif
  1817. X
  1818. X#define STR_SSET(dst,src) if (dst != src) str_sset(dst,src)
  1819. X
  1820. XEXT STR **tmps_list;
  1821. XEXT int tmps_max INIT(-1);
  1822. XEXT int tmps_base INIT(-1);
  1823. X
  1824. Xchar *str_2ptr();
  1825. Xdouble str_2num();
  1826. XSTR *str_static();
  1827. XSTR *str_2static();
  1828. XSTR *str_make();
  1829. XSTR *str_nmake();
  1830. XSTR *str_smake();
  1831. Xint str_cmp();
  1832. Xint str_eq();
  1833. Xvoid str_magic();
  1834. Xvoid str_insert();
  1835. !STUFFY!FUNK!
  1836. echo ""
  1837. echo "End of kit 14 (of 24)"
  1838. cat /dev/null >kit14isdone
  1839. run=''
  1840. config=''
  1841. 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; do
  1842.     if test -f kit${iskit}isdone; then
  1843.     run="$run $iskit"
  1844.     else
  1845.     todo="$todo $iskit"
  1846.     fi
  1847. done
  1848. case $todo in
  1849.     '')
  1850.     echo "You have run all your kits.  Please read README and then type Configure."
  1851.     chmod 755 Configure
  1852.     ;;
  1853.     *)  echo "You have run$run."
  1854.     echo "You still need to run$todo."
  1855.     ;;
  1856. esac
  1857. : Someone might mail this, so...
  1858. exit
  1859.  
  1860. -- 
  1861. Please send comp.sources.unix-related mail to rsalz@uunet.uu.net.
  1862. Use a domain-based address or give alternate paths, or you may lose out.
  1863.