home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / games / volume16 / nethck31 / part51 < prev    next >
Encoding:
Internet Message Format  |  1993-02-03  |  57.6 KB
  1. Path: uunet!news.tek.com!master!saab!billr
  2. From: billr@saab.CNA.TEK.COM (Bill Randle)
  3. Newsgroups: comp.sources.games
  4. Subject: v16i059:  nethack31 - display oriented dungeons & dragons (Ver. 3.1), Part51/108
  5. Message-ID: <4362@master.CNA.TEK.COM>
  6. Date: 1 Feb 93 19:42:49 GMT
  7. Sender: news@master.CNA.TEK.COM
  8. Lines: 2770
  9. Approved: billr@saab.CNA.TEK.COM
  10. Xref: uunet comp.sources.games:1609
  11.  
  12. Submitted-by: izchak@linc.cis.upenn.edu (Izchak Miller)
  13. Posting-number: Volume 16, Issue 59
  14. Archive-name: nethack31/Part51
  15. Supersedes: nethack3p9: Volume 10, Issue 46-102
  16. Environment: Amiga, Atari, Mac, MS-DOS, OS2, Unix, VMS, X11
  17.  
  18.  
  19.  
  20. #! /bin/sh
  21. # This is a shell archive.  Remove anything before this line, then unpack
  22. # it by saving it into a file and typing "sh file".  To overwrite existing
  23. # files, type "sh file -c".  You can also feed this as standard input via
  24. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  25. # will see the following message at the end:
  26. #        "End of archive 51 (of 108)."
  27. # Contents:  src/attrib.c sys/share/lev_lex.c
  28. # Wrapped by billr@saab on Wed Jan 27 16:09:06 1993
  29. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  30. if test -f 'src/attrib.c' -a "${1}" != "-c" ; then 
  31.   echo shar: Will not clobber existing file \"'src/attrib.c'\"
  32. else
  33. echo shar: Extracting \"'src/attrib.c'\" \(17826 characters\)
  34. sed "s/^X//" >'src/attrib.c' <<'END_OF_FILE'
  35. X/*    SCCS Id: @(#)attrib.c    3.1    92/10/26    */
  36. X/*    Copyright 1988, 1989, 1990, 1992, M. Stephenson          */
  37. X/* NetHack may be freely redistributed.  See license for details. */
  38. X
  39. X/*  attribute modification routines. */
  40. X
  41. X#include "hack.h"
  42. X#include "artifact.h"
  43. X
  44. X/* #define    DEBUG    /* uncomment for debugging info */
  45. X
  46. X#ifdef OVLB
  47. X
  48. X    /* part of the output on gain or loss of attribute */
  49. Xstatic
  50. Xconst char    *plusattr[] = {
  51. X    "strong", "smart", "wise", "agile", "tough", "charismatic"
  52. X},
  53. X        *minusattr[] = {
  54. X    "weak", "stupid", "foolish", "clumsy", "vulnerable", "ugly"
  55. X};
  56. X
  57. X    /* maximum and minimum values for the attributes */
  58. Xstruct attribs    attrmax = {
  59. X    118, 18, 18, 18, 18, 18
  60. X},
  61. X        attrmin = {
  62. X    3, 3, 3, 3, 3, 3
  63. X};
  64. X
  65. Xstatic
  66. Xconst struct innate {
  67. X    schar    ulevel;
  68. X    long    *ability;
  69. X    const char *gainstr, *losestr;
  70. X}    a_abil[] = { {     1, &(Stealth), "", "" },
  71. X             {   1, &(Fast), "", "" },
  72. X             {  10, &(Searching), "perceptive", "" },
  73. X             {     0, 0, 0, 0 } },
  74. X
  75. X    b_abil[] = { {     1, &(HPoison_resistance), "", "" },
  76. X             {   7, &(Fast), "quick", "slow" },
  77. X             {  15, &(Stealth), "stealthy", "" },
  78. X             {     0, 0, 0, 0 } },
  79. X
  80. X    c_abil[] = { {     7, &(Fast), "quick", "slow" },
  81. X             {    15, &(Warning), "sensitive", "" },
  82. X             {     0, 0, 0, 0 } },
  83. X
  84. X    e_abil[] = { {   1, &(Fast), "", "" },
  85. X             {     1, &(HSee_invisible), "", "" },
  86. X             {     1, &(Searching), "", "" },
  87. X             {     1, &(HSleep_resistance), "", "" },
  88. X             {     0, 0, 0, 0 } },
  89. X
  90. X    h_abil[] = { {     1, &(HPoison_resistance), "", "" },
  91. X             {    15, &(Warning), "sensitive", "" },
  92. X             {     0, 0, 0, 0 } },
  93. X
  94. X    k_abil[] = { {     7, &(Fast), "quick", "slow" },
  95. X             {     0, 0, 0, 0 } },
  96. X
  97. X    p_abil[] = { {    15, &(Warning), "sensitive", "" },
  98. X             {  20, &(HFire_resistance), "cool", "warmer" },
  99. X             {     0, 0, 0, 0 } },
  100. X
  101. X    r_abil[] = { {     1, &(Stealth), "", ""  },
  102. X             {  10, &(Searching), "perceptive", "" },
  103. X             {     0, 0, 0, 0 } },
  104. X
  105. X    s_abil[] = { {     1, &(Fast), "", "" },
  106. X             {  15, &(Stealth), "stealthy", "" },
  107. X             {     0, 0, 0, 0 } },
  108. X
  109. X    t_abil[] = { {    10, &(Searching), "perceptive", "" },
  110. X             {    20, &(HPoison_resistance), "hardy", "" },
  111. X             {     0, 0, 0, 0 } },
  112. X
  113. X    v_abil[] = { {     1, &(HCold_resistance), "", "" },
  114. X             {     1, &(Stealth), "", "" },
  115. X             {   7, &(Fast), "quick", "slow" },
  116. X             {     0, 0, 0, 0 } },
  117. X
  118. X    w_abil[] = { {    15, &(Warning), "sensitive", "" },
  119. X             {  17, &(HTeleport_control), "controlled","uncontrolled" },
  120. X             {     0, 0, 0, 0 } };
  121. X
  122. Xstatic
  123. Xconst struct clattr {
  124. X    struct    attribs    base, cldist;
  125. X     align    align;
  126. X    schar    shp, hd, xlev, ndx;
  127. X/* According to AD&D, HD for some classes (ex. Wizard) should be smaller
  128. X * (4-sided for wizards).  But this is not AD&D, and using the AD&D
  129. X * rule here produces an unplayable character.  This I have used a minimum
  130. X * of an 10-sided hit die for everything.  Another AD&D change: wizards get
  131. X * a minimum strength of 6 since without one you can't teleport or cast
  132. X * spells. --KAA
  133. X */
  134. X    const struct    innate *abil;
  135. X}    a_attr = { {     7, 10, 10,  7,  7,  7 },  /* Archeologist */
  136. X           {    20, 20, 20, 10, 20, 10 },
  137. X            { A_LAWFUL, 10 },  13, 10, 14,  2, a_abil },
  138. X
  139. X    b_attr = { {    16,  7,  7, 15, 16,  6 },  /* Barbarian */
  140. X           {    30,  6,  7, 20, 30,  7 },
  141. X            { A_NEUTRAL, 10 }, 16, 12, 10,  3, b_abil },
  142. X
  143. X    c_attr = { {    10,  7,  7,  7,  8,  6 },  /* Caveman (fighter) */
  144. X           {    30,  6,  7, 20, 30,  7 },
  145. X             { A_LAWFUL, 0 },  16, 10, 10,  3, c_abil },
  146. X
  147. X/*
  148. X    e_attr = { {    13, 13, 14,  6, 14,  6 },
  149. X */
  150. X    e_attr = { {    13, 13, 13,  9, 13,  7 },  /* Elf (ranger) */
  151. X           {    30, 10, 10, 20, 20, 10 },
  152. X            { A_CHAOTIC, 10 },  15, 10, 11,  2, e_abil },
  153. X
  154. X    h_attr = { {     7,  7, 13,  7, 11, 16 },  /* Healer (druid) */
  155. X           {    15, 20, 20, 15, 25, 10 },
  156. X            { A_NEUTRAL, 10 },  13, 10, 20,  2, h_abil },
  157. X
  158. X    k_attr = { {    13,  7, 14,  8, 10, 17 },  /* Knight (paladin) */
  159. X           {    20, 15, 15, 10, 20, 10 },
  160. X            { A_LAWFUL, 10 },  16, 10, 10,  3, k_abil },
  161. X
  162. X    p_attr = { {     7,  7, 10,  7,  7,  7 },  /* Priest (cleric) */
  163. X           {    15, 10, 30, 15, 20, 10 },
  164. X            { A_NEUTRAL, 0 },  14, 10, 10,  2, p_abil },
  165. X
  166. X    r_attr = { {     7,  7,  7, 10,  7,  6 },  /* Rogue (thief) */
  167. X           {    20, 10, 10, 30, 20, 10 },
  168. X            { A_CHAOTIC, 10 }, 12, 10, 11,  2, r_abil },
  169. X
  170. X    s_attr = { {    10,  8,  7, 10, 17,  6 },  /* Samurai (fighter/thief) */
  171. X           {    30, 10, 10, 30, 14, 10 },
  172. X            { A_LAWFUL, 10 },  15, 10, 11,  2, s_abil },
  173. X
  174. X#ifdef TOURIST
  175. X    t_attr = { {     7, 10,  6,  7,  7, 10 },  /* Tourist */
  176. X           {    15, 10, 10, 15, 30, 20 },
  177. X            { A_NEUTRAL, 0 },  10, 10, 14,  1, t_abil },
  178. X#endif
  179. X
  180. X    v_attr = { {    10,  7,  7,  7, 10,  7 },  /* Valkyrie (fighter) */
  181. X           {    30,  6,  7, 20, 30,  7 },
  182. X            { A_NEUTRAL, 0 },  16, 10, 10,  3, v_abil },
  183. X
  184. X    w_attr = { {     7, 10,  7,  7,  7,  7 },  /* Wizard (magic-user) */
  185. X           {    10, 30, 10, 20, 20, 10 },
  186. X            { A_NEUTRAL, 0 },  12, 10, 12,  1, w_abil },
  187. X
  188. X    X_attr = { {     3,  3,  3,  3,  3,  3 },
  189. X           {    20, 15, 15, 15, 20, 15 },
  190. X            { A_NEUTRAL, 0 },  12, 10, 14,  1,  0 };
  191. X
  192. Xstatic long next_check = 600L;    /* arbitrary first setting */
  193. Xstatic const struct clattr NEARDATA *NDECL(clx);
  194. Xstatic void NDECL(init_align);
  195. Xstatic void NDECL(exerper);
  196. X
  197. X/* adjust an attribute; return TRUE if change is made, FALSE otherwise */
  198. Xboolean
  199. Xadjattrib(ndx, incr, msgflg)
  200. X    int    ndx, incr;
  201. X    int    msgflg;        /* positive => no message, zero => message, and */
  202. X{                /* negative => conditional (msg if change made) */
  203. X    if (!incr) return FALSE;
  204. X
  205. X    if (incr > 0) {
  206. X        if ((AMAX(ndx) >= ATTRMAX(ndx)) && (ACURR(ndx) >= AMAX(ndx))) {
  207. X        if (msgflg == 0 && flags.verbose)
  208. X            pline("You're already as %s as you can get.",
  209. X              plusattr[ndx]);
  210. X        ABASE(ndx) = AMAX(ndx) = ATTRMAX(ndx); /* just in case */
  211. X        return FALSE;
  212. X        }
  213. X
  214. X        ABASE(ndx) += incr;
  215. X        if(ABASE(ndx) > AMAX(ndx)) {
  216. X        incr = ABASE(ndx) - AMAX(ndx);
  217. X        AMAX(ndx) += incr;
  218. X        if(AMAX(ndx) > ATTRMAX(ndx))
  219. X            AMAX(ndx) = ATTRMAX(ndx);
  220. X        ABASE(ndx) = AMAX(ndx);
  221. X        }
  222. X    } else {
  223. X        if (ABASE(ndx) <= ATTRMIN(ndx)) {
  224. X        if (msgflg == 0 && flags.verbose)
  225. X            pline("You're already as %s as you can get.",
  226. X              minusattr[ndx]);
  227. X        ABASE(ndx) = ATTRMIN(ndx); /* just in case */
  228. X        return FALSE;
  229. X        }
  230. X
  231. X        ABASE(ndx) += incr;
  232. X        if(ABASE(ndx) < ATTRMIN(ndx)) {
  233. X        incr = ABASE(ndx) - ATTRMIN(ndx);
  234. X        ABASE(ndx) = ATTRMIN(ndx);
  235. X        AMAX(ndx) += incr;
  236. X        if(AMAX(ndx) < ATTRMIN(ndx))
  237. X            AMAX(ndx) = ATTRMIN(ndx);
  238. X        }
  239. X    }
  240. X    if (msgflg <= 0)
  241. X        You("feel %s%s!",
  242. X          (incr > 1 || incr < -1) ? "very ": "",
  243. X          (incr > 0) ? plusattr[ndx] : minusattr[ndx]);
  244. X    flags.botl = 1;
  245. X    return TRUE;
  246. X}
  247. X
  248. Xvoid
  249. Xgainstr(otmp, incr)
  250. X    register struct obj *otmp;
  251. X    register int incr;
  252. X{
  253. X    int num = 1;
  254. X
  255. X    if(incr) num = incr;
  256. X    else {
  257. X        if(ABASE(A_STR) < 18) num = (rn2(4) ? 1 : rnd(6) );
  258. X        else if (ABASE(A_STR) < 103) num = rnd(10);
  259. X    }
  260. X    (void) adjattrib(A_STR, (otmp && otmp->cursed) ? -num : num, TRUE);
  261. X}
  262. X
  263. Xvoid
  264. Xlosestr(num)    /* may kill you; cause may be poison or monster like 'a' */
  265. X    register int num;
  266. X{
  267. X    int ustr = ABASE(A_STR) - num;
  268. X
  269. X    while(ustr < 3) {
  270. X        ustr++;
  271. X        num--;
  272. X        u.uhp -= 6;
  273. X        u.uhpmax -= 6;
  274. X    }
  275. X    (void) adjattrib(A_STR, -num, TRUE);
  276. X}
  277. X
  278. Xvoid
  279. Xchange_luck(n)
  280. X    register schar n;
  281. X{
  282. X    u.uluck += n;
  283. X    if (u.uluck < 0 && u.uluck < LUCKMIN)    u.uluck = LUCKMIN;
  284. X    if (u.uluck > 0 && u.uluck > LUCKMAX)    u.uluck = LUCKMAX;
  285. X}
  286. X
  287. Xint
  288. Xstone_luck(parameter)
  289. Xboolean parameter; /* So I can't think up of a good name.  So sue me. --KAA */
  290. X{
  291. X    register struct obj *otmp;
  292. X    register long bonchance = 0;
  293. X
  294. X    for(otmp = invent; otmp; otmp=otmp->nobj)
  295. X        if (otmp->otyp == LUCKSTONE
  296. X        || (otmp->oartifact && spec_ability(otmp, SPFX_LUCK))) {
  297. X        if (otmp->cursed) bonchance -= otmp->quan;
  298. X        else if (otmp->blessed) bonchance += otmp->quan;
  299. X        else if (parameter) bonchance += otmp->quan;
  300. X        }
  301. X
  302. X    return sgn((int)bonchance);
  303. X}
  304. X
  305. X#endif /* OVLB */
  306. X#ifdef OVL1
  307. X
  308. Xvoid
  309. Xrestore_attrib() {
  310. X
  311. X    int    i;
  312. X
  313. X    for(i = 0; i < A_MAX; i++) {    /* all temporary losses/gains */
  314. X
  315. X       if(ATEMP(i) && ATIME(i)) {
  316. X        if(!(--(ATIME(i)))) { /* countdown for change */
  317. X            ATEMP(i) += ATEMP(i) > 0 ? -1 : 1;
  318. X
  319. X            if(ATEMP(i)) /* reset timer */
  320. X            ATIME(i) = 100 / ACURR(A_CON);
  321. X        }
  322. X        }
  323. X    }
  324. X}
  325. X
  326. X#endif /* OVL1 */
  327. X#ifdef OVLB
  328. X
  329. X#define AVAL    50        /* tune value for exercise gains */
  330. X
  331. Xvoid
  332. Xexercise(i, inc_or_dec)
  333. Xint    i;
  334. Xboolean    inc_or_dec;
  335. X{
  336. X#ifdef DEBUG
  337. X    pline("Exercise:");
  338. X#endif
  339. X    if (i == A_INT || i == A_CHA) return;    /* can't exercise these */
  340. X
  341. X#ifdef POLYSELF
  342. X    /* no physical exercise while polymorphed; the body's temporary */
  343. X    if (u.umonnum >= 0 && i != A_WIS) return;
  344. X#endif
  345. X    if(abs(AEXE(i)) < AVAL) {
  346. X        /*
  347. X         *    Law of diminishing returns (Part I):
  348. X         *
  349. X         *    Gain is harder at higher attribute values.
  350. X         *    79% at "3" --> 0% at "18"
  351. X         *    Loss is even at all levels (50%).
  352. X         *
  353. X         *    Note: *YES* ACURR is the right one to use.
  354. X         */
  355. X        AEXE(i) += (inc_or_dec) ? (rn2(19) > ACURR(i)) : -rn2(2);
  356. X#ifdef DEBUG
  357. X        pline("%s, %s AEXE = %d",
  358. X            (i == A_STR) ? "Str" : (i == A_WIS) ? "Wis" :
  359. X            (i == A_DEX) ? "Dex" : "Con",
  360. X            (inc_or_dec) ? "inc" : "dec", AEXE(i));
  361. X#endif
  362. X    }
  363. X}
  364. X
  365. X/* hunger values - from eat.c */
  366. X#define SATIATED    0
  367. X#define NOT_HUNGRY    1
  368. X#define HUNGRY        2
  369. X#define WEAK        3
  370. X#define FAINTING    4
  371. X#define FAINTED        5
  372. X#define STARVED        6
  373. X
  374. Xstatic void
  375. Xexerper()
  376. X{
  377. X    if(!(moves % 10)) {
  378. X        /* Hunger Checks */
  379. X
  380. X        int hs = (u.uhunger > 1000) ? SATIATED :
  381. X             (u.uhunger > 150) ? NOT_HUNGRY :
  382. X             (u.uhunger > 50) ? HUNGRY :
  383. X             (u.uhunger > 0) ? WEAK : FAINTING;
  384. X
  385. X#ifdef DEBUG
  386. X        pline("exerper: Hunger checks");
  387. X#endif
  388. X        switch (hs) {
  389. X            case SATIATED:    exercise(A_DEX, FALSE); break;
  390. X            case NOT_HUNGRY:    exercise(A_CON, TRUE); break;
  391. X            case WEAK:        exercise(A_STR, FALSE); break;
  392. X            case FAINTING:
  393. X            case FAINTED:    exercise(A_CON, FALSE); break;
  394. X        }
  395. X
  396. X        /* Encumberance Checks */
  397. X#ifdef DEBUG
  398. X        pline("exerper: Encumber checks");
  399. X#endif
  400. X        switch (near_capacity()) {
  401. X            case MOD_ENCUMBER:    exercise(A_STR, TRUE); break;
  402. X            case HVY_ENCUMBER:    exercise(A_STR, TRUE);
  403. X                    exercise(A_DEX, FALSE); break;
  404. X            case EXT_ENCUMBER:    exercise(A_DEX, FALSE);
  405. X                    exercise(A_CON, FALSE); break;
  406. X        }
  407. X
  408. X    }
  409. X
  410. X    /* status checks */
  411. X    if(!(moves % 5)) {
  412. X#ifdef DEBUG
  413. X        pline("exerper: Status checks");
  414. X#endif
  415. X        if(Clairvoyant)        exercise(A_WIS, TRUE);
  416. X        if(HRegeneration)    exercise(A_STR, TRUE);
  417. X
  418. X        if(Sick || Vomiting)            exercise(A_CON, FALSE);
  419. X        if(Confusion || Hallucination)        exercise(A_WIS, FALSE);
  420. X        if(Wounded_legs || Fumbling || HStun)    exercise(A_DEX, FALSE);
  421. X    }
  422. X}
  423. X
  424. Xvoid
  425. Xexerchk()
  426. X{
  427. X    int    i, mod_val;
  428. X
  429. X    /*    Check out the periodic accumulations */
  430. X    exerper();
  431. X
  432. X#ifdef DEBUG
  433. X    if(moves >= next_check)
  434. X        pline("exerchk: ready to test. multi = %d.", multi);
  435. X#endif
  436. X    /*    Are we ready for a test?    */
  437. X    if(moves >= next_check && !multi) {
  438. X#ifdef DEBUG
  439. X        pline("exerchk: testing.");
  440. X#endif
  441. X        /*
  442. X         *    Law of diminishing returns (Part II):
  443. X         *
  444. X         *    The effects of "exercise" and "abuse" wear
  445. X         *    off over time.  Even if you *don't* get an
  446. X         *    increase/decrease, you lose some of the
  447. X         *    accumulated effects.
  448. X         */
  449. X        for(i = 0; i < A_MAX; AEXE(i++) /= 2) {
  450. X
  451. X        if(ABASE(i) >= 18 || !AEXE(i)) continue;
  452. X        if(i == A_INT || i == A_CHA) continue;/* can't exercise these */
  453. X
  454. X#ifdef DEBUG
  455. X        pline("exerchk: testing %s (%d).",
  456. X            (i == A_STR) ? "Str" : (i == A_WIS) ? "Wis" :
  457. X            (i == A_DEX) ? "Dex" : "Con", AEXE(i));
  458. X#endif
  459. X        /*
  460. X         *    Law of diminishing returns (Part III):
  461. X         *
  462. X         *    You don't *always* gain by exercising.
  463. X         *    [MRS 92/10/28 - Treat Wisdom specially for balance.]
  464. X         */
  465. X        if(rn2(AVAL) > ((i != A_WIS) ? abs(AEXE(i)*2/3) : abs(AEXE(i))))
  466. X            continue;
  467. X        mod_val = sgn(AEXE(i));
  468. X
  469. X#ifdef DEBUG
  470. X        pline("exerchk: changing %d.", i);
  471. X#endif
  472. X        if(adjattrib(i, mod_val, -1)) {
  473. X#ifdef DEBUG
  474. X            pline("exerchk: changed %d.", i);
  475. X#endif
  476. X            /* if you actually changed an attrib - zero accumulation */
  477. X            AEXE(i) = 0;
  478. X            /* then print an explanation */
  479. X            switch(i) {
  480. X            case A_STR: You((mod_val >0) ?
  481. X                    "must have been exercising." :
  482. X                    "must have been abusing your body.");
  483. X                break;
  484. X            case A_WIS: You((mod_val >0) ?
  485. X                    "must have been very observant." :
  486. X                    "must not have been paying attention.");
  487. X                break;
  488. X            case A_DEX: You((mod_val >0) ?
  489. X                    "must have been working on your reflexes." :
  490. X                    "haven't been working on reflexes lately.");
  491. X                break;
  492. X            case A_CON: You((mod_val >0) ?
  493. X                    "must be leading a healthy life-style." :
  494. X                    "must not have been watching your health.");
  495. X                break;
  496. X            }
  497. X        }
  498. X        }
  499. X        next_check += rn1(200,800);
  500. X#ifdef DEBUG
  501. X        pline("exerchk: next check at %ld.", next_check);
  502. X#endif
  503. X    }
  504. X}
  505. X
  506. Xstatic const struct    clattr *
  507. Xclx()  {
  508. X
  509. X    register const struct    clattr    *attr;
  510. X
  511. X    switch    (pl_character[0]) {
  512. X
  513. X        case 'A':    attr = &a_attr;
  514. X            break;
  515. X        case 'B':    attr = &b_attr;
  516. X            break;
  517. X        case 'C':    attr = &c_attr;
  518. X            break;
  519. X        case 'E':    attr = &e_attr;
  520. X            break;
  521. X        case 'H':    attr = &h_attr;
  522. X            break;
  523. X        case 'K':    attr = &k_attr;
  524. X            break;
  525. X        case 'P':    attr = &p_attr;
  526. X            break;
  527. X        case 'R':    attr = &r_attr;
  528. X            break;
  529. X        case 'S':    attr = &s_attr;
  530. X            break;
  531. X#ifdef TOURIST
  532. X        case 'T':    attr = &t_attr;
  533. X            break;
  534. X#endif
  535. X        case 'V':    attr = &v_attr;
  536. X            break;
  537. X        case 'W':    attr = &w_attr;
  538. X            break;
  539. X        default:    /* unknown type */
  540. X            attr = &X_attr;
  541. X            break;
  542. X    }
  543. X    return(attr);
  544. X}
  545. X
  546. Xstatic void
  547. Xinit_align() {    /* called from newhp if u.ulevel is 0 */
  548. X
  549. X    register const struct    clattr    *attr = clx();
  550. X
  551. X    u.ualign = attr->align;
  552. X    /* there should be priests of every stripe */
  553. X    if(pl_character[0] == 'P')
  554. X         u.ualign.type = (rn2(2)) ? attr->align.type : (rn2(2)) ? 1 : -1;
  555. X    else u.ualign.type = attr->align.type;
  556. X}
  557. X
  558. Xvoid
  559. Xinit_attr(np)
  560. X    register int    np;
  561. X{
  562. X    register int    i, x, tryct;
  563. X    register const struct    clattr    *attr = clx();
  564. X
  565. X    for(i = 0; i < A_MAX; i++) {
  566. X
  567. X        ABASE(i) = AMAX(i) = attr->base.a[i];
  568. X        ATEMP(i) = ATIME(i) = 0;
  569. X        np -= attr->base.a[i];
  570. X    }
  571. X
  572. X    tryct = 0;
  573. X    while(np > 0 && tryct < 100) {
  574. X
  575. X        x = rn2(100);
  576. X        for (i = 0; (i < A_MAX) && ((x -= attr->cldist.a[i]) > 0); i++) ;
  577. X        if(i >= A_MAX) continue; /* impossible */
  578. X
  579. X        if(ABASE(i) >= ATTRMAX(i)) {
  580. X
  581. X        tryct++;
  582. X        continue;
  583. X        }
  584. X        tryct = 0;
  585. X        ABASE(i)++;
  586. X        AMAX(i)++;
  587. X        np--;
  588. X    }
  589. X
  590. X    tryct = 0;
  591. X    while(np < 0 && tryct < 100) {        /* for redistribution */
  592. X
  593. X        x = rn2(100);
  594. X        for (i = 0; (i < A_MAX) && ((x -= attr->cldist.a[i]) > 0); i++) ;
  595. X        if(i >= A_MAX) continue; /* impossible */
  596. X
  597. X        if(ABASE(i) <= ATTRMIN(i)) {
  598. X
  599. X        tryct++;
  600. X        continue;
  601. X        }
  602. X        tryct = 0;
  603. X        ABASE(i)--;
  604. X        AMAX(i)--;
  605. X        np++;
  606. X    }
  607. X}
  608. X
  609. Xvoid
  610. Xredist_attr() {
  611. X
  612. X    register int i, tmp;
  613. X
  614. X    for(i = 0; i < A_MAX; i++) {
  615. X        if (i==A_INT || i==A_WIS) continue;
  616. X        /* Polymorphing doesn't change your mind */
  617. X        tmp = AMAX(i);
  618. X        AMAX(i) += (rn2(5)-2);
  619. X        if (AMAX(i) > ATTRMAX(i)) AMAX(i) = ATTRMAX(i);
  620. X        if (AMAX(i) < ATTRMIN(i)) AMAX(i) = ATTRMIN(i);
  621. X        ABASE(i) = ABASE(i) * AMAX(i) / tmp;
  622. X        /* ABASE(i) > ATTRMAX(i) is impossible */
  623. X        if (ABASE(i) < ATTRMIN(i)) ABASE(i) = ATTRMIN(i);
  624. X    }
  625. X}
  626. X
  627. Xvoid
  628. Xadjabil(oldlevel,newlevel)
  629. Xint oldlevel, newlevel;
  630. X{
  631. X    register const struct clattr    *attr = clx();
  632. X#ifdef GCC_WARN
  633. X    /* this is the "right" definition */
  634. X    register const struct innate    *abil = attr->abil;
  635. X#else
  636. X    /* this one satisfies more compilers */
  637. X    register struct innate    *abil = (struct innate *)attr->abil;
  638. X#endif
  639. X
  640. X    if(abil) {
  641. X        for(; abil->ability; abil++) {
  642. X        if(oldlevel < abil->ulevel && newlevel >= abil->ulevel) {
  643. X            /* Abilities gained at level 1 can never be lost
  644. X             * via level loss, only via means that remove _any_
  645. X             * sort of ability.  A "gain" of such an ability from
  646. X             * an outside source is devoid of meaning, so we set
  647. X             * FROMOUTSIDE to avoid such gains.
  648. X             */
  649. X            if (abil->ulevel == 1)
  650. X                *(abil->ability) |= (FROMEXPER|FROMOUTSIDE);
  651. X            else
  652. X                *(abil->ability) |= FROMEXPER;
  653. X            if(!(*(abil->ability) & FROMOUTSIDE)) {
  654. X                if(*(abil->gainstr))
  655. X                You("feel %s!", abil->gainstr);
  656. X            }
  657. X        } else if (oldlevel >= abil->ulevel && newlevel < abil->ulevel) {
  658. X            *(abil->ability) &= ~FROMEXPER;
  659. X            if((*(abil->ability) & INTRINSIC)) {
  660. X                if(*(abil->losestr))
  661. X                You("feel %s!", abil->losestr);
  662. X                else if(*(abil->gainstr))
  663. X                You("feel less %s!", abil->gainstr);
  664. X            }
  665. X        }
  666. X        }
  667. X    }
  668. X}
  669. X
  670. Xint
  671. Xnewhp() {
  672. X    register const struct clattr    *attr = clx();
  673. X    int    hp, conplus;
  674. X
  675. X    if(u.ulevel == 0) {
  676. X
  677. X        hp = attr->shp;
  678. X        init_align();    /* initialize alignment stuff */
  679. X        return hp;
  680. X    } else {
  681. X
  682. X        if(u.ulevel < attr->xlev)
  683. X        hp = rnd(attr->hd);
  684. X        else
  685. X        hp = attr->ndx;
  686. X    }
  687. X
  688. X    switch(ACURR(A_CON)) {
  689. X        case    3:    conplus = -2; break;
  690. X        case    4:
  691. X        case    5:
  692. X        case    6:    conplus = -1; break;
  693. X        case    15:
  694. X        case    16:    conplus = 1; break;
  695. X        case    17:    conplus = 2; break;
  696. X        case    18:    conplus = 3; break;
  697. X        default:    conplus = 0;
  698. X    }
  699. X    hp += conplus;
  700. X    return((hp <= 0) ? 1 : hp);
  701. X}
  702. X
  703. X#endif /* OVLB */
  704. X#ifdef OVL0
  705. X
  706. Xschar
  707. Xacurr(x)
  708. Xint x;
  709. X{ 
  710. X    register int tmp = (u.abon.a[x] + u.atemp.a[x] + u.acurr.a[x]);
  711. X
  712. X    if (x == A_STR) {
  713. X        if (uarmg && uarmg->otyp == GAUNTLETS_OF_POWER) return(125);
  714. X        else return((tmp >= 125) ? 125 : (tmp <= 3) ? 3 : tmp);
  715. X    } 
  716. X#ifdef POLYSELF
  717. X    else if(x == A_CHA) {
  718. X        if (tmp < 18 && (u.usym == S_NYMPH ||
  719. X            u.umonnum==PM_SUCCUBUS || u.umonnum == PM_INCUBUS))
  720. X            return 18;
  721. X    }
  722. X#endif
  723. X    return((tmp >= 25) ? 25 : (tmp <= 3) ? 3 : tmp);
  724. X}
  725. X
  726. Xschar
  727. Xacurrstr()
  728. X/* condense clumsy ACURR(A_STR) value into value that fits into game formulas
  729. X */
  730. X{
  731. X    register int str = ACURR(A_STR);
  732. X
  733. X    if (str <= 18) return str;
  734. X    if (str <= 121) return (19 + str / 50); /* map to 19-21 */
  735. X    else return str - 100;
  736. X}
  737. X
  738. X#endif /* OVL0 */
  739. X#ifdef OVL2
  740. X
  741. X/* avoid possible problems with alignment overflow, and provide a centralized
  742. X * location for any future alignment limits
  743. X */
  744. Xvoid
  745. Xadjalign(n)
  746. Xregister int n;
  747. X{
  748. X    register int newalign = u.ualign.record + n;
  749. X
  750. X    if(n < 0) {
  751. X        if(newalign < u.ualign.record)
  752. X            u.ualign.record = newalign;
  753. X    } else
  754. X        if(newalign > u.ualign.record) {
  755. X            u.ualign.record = newalign;
  756. X            if(u.ualign.record > ALIGNLIM)
  757. X                u.ualign.record = ALIGNLIM;
  758. X        }
  759. X}
  760. X
  761. X#endif /* OVL2 */
  762. X
  763. X/*attrib.c*/
  764. END_OF_FILE
  765. if test 17826 -ne `wc -c <'src/attrib.c'`; then
  766.     echo shar: \"'src/attrib.c'\" unpacked with wrong size!
  767. fi
  768. # end of 'src/attrib.c'
  769. fi
  770. if test -f 'sys/share/lev_lex.c' -a "${1}" != "-c" ; then 
  771.   echo shar: Will not clobber existing file \"'sys/share/lev_lex.c'\"
  772. else
  773. echo shar: Extracting \"'sys/share/lev_lex.c'\" \(35705 characters\)
  774. sed "s/^X//" >'sys/share/lev_lex.c' <<'END_OF_FILE'
  775. X# include "stdio.h"
  776. X# define U(x) x
  777. X# define NLSTATE yyprevious=YYNEWLINE
  778. X# define BEGIN yybgin = yysvec + 1 +
  779. X# define INITIAL 0
  780. X# define YYLERR yysvec
  781. X# define YYSTATE (yyestate-yysvec-1)
  782. X# define YYOPTIM 1
  783. X# define YYLMAX BUFSIZ
  784. X# define output(c) putc(c,yyout)
  785. X# define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
  786. X# define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;}
  787. X# define yymore() (yymorfg=1)
  788. X# define ECHO fprintf(yyout, "%s",yytext)
  789. X# define REJECT { nstr = yyreject(); goto yyfussy;}
  790. Xint yyleng; extern char yytext[];
  791. Xint yymorfg;
  792. Xextern char *yysptr, yysbuf[];
  793. Xint yytchar;
  794. XFILE *yyin = {stdin}, *yyout = {stdout};
  795. Xextern int yylineno;
  796. Xstruct yysvf { 
  797. X    struct yywork *yystoff;
  798. X    struct yysvf *yyother;
  799. X    int *yystops;};
  800. Xstruct yysvf *yyestate;
  801. Xextern struct yysvf yysvec[], *yybgin;
  802. X/*    SCCS Id: @(#)lev_lex.c    3.1    92/07/12    */
  803. X/*    Copyright (c) 1989 by Jean-Christophe Collet */
  804. X/* NetHack may be freely redistributed.  See license for details. */
  805. X
  806. X#define LEV_LEX_C
  807. X
  808. X#include "hack.h"
  809. X#include "lev_comp.h"
  810. X#include "sp_lev.h"
  811. X
  812. X/* Most of these don't exist in flex, yywrap is macro and
  813. X * yyunput is properly declared in flex.skel.
  814. X */
  815. X#ifndef FLEX_SCANNER
  816. Xint FDECL (yyback, (int *, int));
  817. Xint NDECL (yylook);
  818. Xint NDECL (yyinput);
  819. Xint NDECL (yywrap);
  820. Xint NDECL (yylex);
  821. X    /* Traditional lexes let yyunput() and yyoutput() default to int;
  822. X     * newer ones may declare them as void since they don't return
  823. X     * values.  For even more fun, the lex supplied as part of the
  824. X     * newer unbundled compiler for SunOS 4.x adds the void declarations
  825. X     * (under __STDC__ or _cplusplus ifdefs -- otherwise they remain
  826. X     * int) while the bundled lex and the one with the older unbundled
  827. X     * compiler do not.  To detect this, we need help from outside --
  828. X     * sys/unix/Makefile.utl.
  829. X     */
  830. X# if defined(NeXT) || defined(SVR4)
  831. X#  define VOIDYYPUT
  832. X# endif
  833. X# if !defined(VOIDYYPUT)
  834. X#  if defined(POSIX_TYPES) && !defined(BOS) && !defined(HISX)
  835. X#   define VOIDYYPUT
  836. X#  endif
  837. X# endif
  838. X# if !defined(VOIDYYPUT) && defined(WEIRD_LEX)
  839. X#  if defined(SUNOS4) && defined(__STDC__) && (WEIRD_LEX != 0) 
  840. X#   define VOIDYYPUT
  841. X#  endif
  842. X# endif
  843. X# ifdef VOIDYYPUT
  844. Xvoid FDECL (yyunput, (int));
  845. Xvoid FDECL (yyoutput, (int));
  846. X# else
  847. Xint FDECL (yyunput, (int));
  848. Xint FDECL (yyoutput, (int));
  849. X# endif
  850. X#endif    /* FLEX_SCANNER */
  851. X
  852. Xvoid FDECL (init_yyin, (FILE *));
  853. Xvoid FDECL (init_yyout, (FILE *));
  854. X
  855. X#ifdef MICRO
  856. X#undef exit
  857. Xextern void FDECL(exit, (int));
  858. X#endif
  859. X
  860. X/* this doesn't always get put in lev_comp.h
  861. X * (esp. when using older versions of bison)
  862. X */
  863. X
  864. Xextern YYSTYPE yylval;
  865. X
  866. Xint line_number = 1, colon_line_number = 1;
  867. X
  868. X/* This is *** UGLY *** but I can't think a better way to do it
  869. X * I really need a huge buffer to scan maps...
  870. X */
  871. X
  872. X#undef YYLMAX
  873. X#define YYLMAX    2048
  874. X
  875. X/*
  876. X *    This is a hack required by Michael Hamel to get things
  877. X *    working on the Mac.
  878. X */
  879. X#if defined(applec) && !defined(FLEX_SCANNER)
  880. X#undef input
  881. X#undef unput
  882. X#define unput(c) { yytchar = (c); if (yytchar == 10) yylineno--; *yysptr++ = yytchar; }
  883. X# ifndef YYNEWLINE
  884. X# define YYNEWLINE 10
  885. X# endif
  886. X
  887. Xchar
  888. Xinput() {    /* Under MPW \n is chr(13)! Compensate for this. */
  889. X
  890. X    if (yysptr > yysbuf) return(*--yysptr);
  891. X    else {
  892. X        yytchar = getc(yyin);
  893. X        if (yytchar == '\n') {
  894. X            yylineno++;
  895. X            return(YYNEWLINE);
  896. X        }
  897. X        if (yytchar == EOF) return(0);
  898. X        else            return(yytchar);
  899. X    }
  900. X}
  901. X#endif    /* applec && !FLEX_SCANNER */
  902. X
  903. X# define MAPC 2
  904. X# define YYNEWLINE 10
  905. Xyylex(){
  906. Xint nstr; extern int yyprevious;
  907. Xwhile((nstr = yylook()) >= 0)
  908. Xyyfussy: switch(nstr){
  909. Xcase 0:
  910. Xif(yywrap()) return(0); break;
  911. Xcase 1:
  912. X{
  913. X#ifdef FLEX_SCANNER
  914. X          /*
  915. X           * There is a bug in Flex 2.3 patch level < 6
  916. X           * (absent in previous versions)
  917. X           * that results in the following behaviour :
  918. X           * Once you enter an yymore(), you never exit from it.
  919. X           * This should do the trick!
  920. X           */
  921. X          extern int yy_more_len;
  922. X
  923. X          yy_more_len = 0;
  924. X#endif
  925. X          BEGIN(INITIAL);
  926. X          yylval.map = (char *) alloc(yyleng-5);
  927. X          strncpy(yylval.map, yytext,yyleng-6);
  928. X          yylval.map[yyleng-6] = 0;
  929. X          return MAP_ID;
  930. X        }
  931. Xbreak;
  932. Xcase 2:
  933. X{ line_number++; yymore(); }
  934. Xbreak;
  935. Xcase 3:
  936. X    { line_number++; }
  937. Xbreak;
  938. Xcase 4:
  939. X    { colon_line_number = line_number; return ':'; }
  940. Xbreak;
  941. Xcase 5:
  942. X    return MESSAGE_ID;
  943. Xbreak;
  944. Xcase 6:
  945. X    return MAZE_ID;
  946. Xbreak;
  947. Xcase 7:
  948. X    return NOMAP_ID;
  949. Xbreak;
  950. Xcase 8:
  951. X    return LEVEL_ID;
  952. Xbreak;
  953. Xcase 9:
  954. Xreturn LEV_INIT_ID;
  955. Xbreak;
  956. Xcase 10:
  957. X    return FLAGS_ID;
  958. Xbreak;
  959. Xcase 11:
  960. Xreturn GEOMETRY_ID;
  961. Xbreak;
  962. Xcase 12:
  963. X    { BEGIN(MAPC); line_number++; }
  964. Xbreak;
  965. Xcase 13:
  966. X    return OBJECT_ID;
  967. Xbreak;
  968. Xcase 14:
  969. X    return MONSTER_ID;
  970. Xbreak;
  971. Xcase 15:
  972. X    return TRAP_ID;
  973. Xbreak;
  974. Xcase 16:
  975. X    return DOOR_ID;
  976. Xbreak;
  977. Xcase 17:
  978. Xreturn DRAWBRIDGE_ID;
  979. Xbreak;
  980. Xcase 18:
  981. Xreturn MAZEWALK_ID;
  982. Xbreak;
  983. Xcase 19:
  984. X    return WALLIFY_ID;
  985. Xbreak;
  986. Xcase 20:
  987. X    return REGION_ID;
  988. Xbreak;
  989. Xcase 21:
  990. Xreturn RANDOM_OBJECTS_ID;
  991. Xbreak;
  992. Xcase 22:
  993. Xreturn RANDOM_MONSTERS_ID;
  994. Xbreak;
  995. Xcase 23:
  996. Xreturn RANDOM_PLACES_ID;
  997. Xbreak;
  998. Xcase 24:
  999. X    return ALTAR_ID;
  1000. Xbreak;
  1001. Xcase 25:
  1002. X    return LADDER_ID;
  1003. Xbreak;
  1004. Xcase 26:
  1005. X    return STAIR_ID;
  1006. Xbreak;
  1007. Xcase 27:
  1008. X    return PORTAL_ID;
  1009. Xbreak;
  1010. Xcase 28:
  1011. Xreturn TELEPRT_ID;
  1012. Xbreak;
  1013. Xcase 29:
  1014. X    return BRANCH_ID;
  1015. Xbreak;
  1016. Xcase 30:
  1017. Xreturn FOUNTAIN_ID;
  1018. Xbreak;
  1019. Xcase 31:
  1020. X    return SINK_ID;
  1021. Xbreak;
  1022. Xcase 32:
  1023. X    return POOL_ID;
  1024. Xbreak;
  1025. Xcase 33:
  1026. Xreturn NON_DIGGABLE_ID;
  1027. Xbreak;
  1028. Xcase 34:
  1029. X    return ROOM_ID;
  1030. Xbreak;
  1031. Xcase 35:
  1032. X    return SUBROOM_ID;
  1033. Xbreak;
  1034. Xcase 36:
  1035. Xreturn RAND_CORRIDOR_ID;
  1036. Xbreak;
  1037. Xcase 37:
  1038. Xreturn CORRIDOR_ID;
  1039. Xbreak;
  1040. Xcase 38:
  1041. X    return GOLD_ID;
  1042. Xbreak;
  1043. Xcase 39:
  1044. Xreturn ENGRAVING_ID;
  1045. Xbreak;
  1046. Xcase 40:
  1047. X    return NAME_ID;
  1048. Xbreak;
  1049. Xcase 41:
  1050. X    return CHANCE_ID;
  1051. Xbreak;
  1052. Xcase 42:
  1053. Xreturn LEV;
  1054. Xbreak;
  1055. Xcase 43:
  1056. X    { yylval.i=D_ISOPEN; return DOOR_STATE; }
  1057. Xbreak;
  1058. Xcase 44:
  1059. X    { yylval.i=D_CLOSED; return DOOR_STATE; }
  1060. Xbreak;
  1061. Xcase 45:
  1062. X    { yylval.i=D_LOCKED; return DOOR_STATE; }
  1063. Xbreak;
  1064. Xcase 46:
  1065. X    { yylval.i=D_NODOOR; return DOOR_STATE; }
  1066. Xbreak;
  1067. Xcase 47:
  1068. X    { yylval.i=D_BROKEN; return DOOR_STATE; }
  1069. Xbreak;
  1070. Xcase 48:
  1071. X    { yylval.i=W_NORTH; return DIRECTION; }
  1072. Xbreak;
  1073. Xcase 49:
  1074. X    { yylval.i=W_EAST; return DIRECTION; }
  1075. Xbreak;
  1076. Xcase 50:
  1077. X    { yylval.i=W_SOUTH; return DIRECTION; }
  1078. Xbreak;
  1079. Xcase 51:
  1080. X    { yylval.i=W_WEST; return DIRECTION; }
  1081. Xbreak;
  1082. Xcase 52:
  1083. X    { yylval.i = -1; return RANDOM_TYPE; }
  1084. Xbreak;
  1085. Xcase 53:
  1086. X    { yylval.i = -2; return NONE; }
  1087. Xbreak;
  1088. Xcase 54:
  1089. X    return O_REGISTER;
  1090. Xbreak;
  1091. Xcase 55:
  1092. X    return M_REGISTER;
  1093. Xbreak;
  1094. Xcase 56:
  1095. X    return P_REGISTER;
  1096. Xbreak;
  1097. Xcase 57:
  1098. X    return A_REGISTER;
  1099. Xbreak;
  1100. Xcase 58:
  1101. X    { yylval.i=1; return LEFT_OR_RIGHT; }
  1102. Xbreak;
  1103. Xcase 59:
  1104. X{ yylval.i=2; return LEFT_OR_RIGHT; }
  1105. Xbreak;
  1106. Xcase 60:
  1107. X    { yylval.i=3; return CENTER; }
  1108. Xbreak;
  1109. Xcase 61:
  1110. X{ yylval.i=4; return LEFT_OR_RIGHT; }
  1111. Xbreak;
  1112. Xcase 62:
  1113. X    { yylval.i=5; return LEFT_OR_RIGHT; }
  1114. Xbreak;
  1115. Xcase 63:
  1116. X    { yylval.i=1; return TOP_OR_BOT; }
  1117. Xbreak;
  1118. Xcase 64:
  1119. X    { yylval.i=5; return TOP_OR_BOT; }
  1120. Xbreak;
  1121. Xcase 65:
  1122. X    { yylval.i=1; return LIGHT_STATE; }
  1123. Xbreak;
  1124. Xcase 66:
  1125. X    { yylval.i=0; return LIGHT_STATE; }
  1126. Xbreak;
  1127. Xcase 67:
  1128. X    { yylval.i=0; return FILLING; }
  1129. Xbreak;
  1130. Xcase 68:
  1131. X{ yylval.i=1; return FILLING; }
  1132. Xbreak;
  1133. Xcase 69:
  1134. X    { yylval.i= AM_NONE; return ALIGNMENT; }
  1135. Xbreak;
  1136. Xcase 70:
  1137. X    { yylval.i= AM_LAWFUL; return ALIGNMENT; }
  1138. Xbreak;
  1139. Xcase 71:
  1140. X    { yylval.i= AM_NEUTRAL; return ALIGNMENT; }
  1141. Xbreak;
  1142. Xcase 72:
  1143. X    { yylval.i= AM_CHAOTIC; return ALIGNMENT; }
  1144. Xbreak;
  1145. Xcase 73:
  1146. X{ yylval.i=1; return MON_ATTITUDE; }
  1147. Xbreak;
  1148. Xcase 74:
  1149. X    { yylval.i=0; return MON_ATTITUDE; }
  1150. Xbreak;
  1151. Xcase 75:
  1152. X    { yylval.i=1; return MON_ALERTNESS; }
  1153. Xbreak;
  1154. Xcase 76:
  1155. X    { yylval.i=0; return MON_ALERTNESS; }
  1156. Xbreak;
  1157. Xcase 77:
  1158. X{ yylval.i= M_AP_FURNITURE; return MON_APPEARANCE; }
  1159. Xbreak;
  1160. Xcase 78:
  1161. X{ yylval.i= M_AP_MONSTER;   return MON_APPEARANCE; }
  1162. Xbreak;
  1163. Xcase 79:
  1164. X{ yylval.i= M_AP_OBJECT;    return MON_APPEARANCE; }
  1165. Xbreak;
  1166. Xcase 80:
  1167. X    { yylval.i=2; return ALTAR_TYPE; }
  1168. Xbreak;
  1169. Xcase 81:
  1170. X    { yylval.i=1; return ALTAR_TYPE; }
  1171. Xbreak;
  1172. Xcase 82:
  1173. X    { yylval.i=0; return ALTAR_TYPE; }
  1174. Xbreak;
  1175. Xcase 83:
  1176. X    { yylval.i=1; return UP_OR_DOWN; }
  1177. Xbreak;
  1178. Xcase 84:
  1179. X    { yylval.i=0; return UP_OR_DOWN; }
  1180. Xbreak;
  1181. Xcase 85:
  1182. X    { yylval.i=0; return BOOLEAN; }
  1183. Xbreak;
  1184. Xcase 86:
  1185. X    { yylval.i=1; return BOOLEAN; }
  1186. Xbreak;
  1187. Xcase 87:
  1188. X    { yylval.i=DUST; return ENGRAVING_TYPE; }
  1189. Xbreak;
  1190. Xcase 88:
  1191. X    { yylval.i=ENGRAVE; return ENGRAVING_TYPE; }
  1192. Xbreak;
  1193. Xcase 89:
  1194. X    { yylval.i=BURN; return ENGRAVING_TYPE; }
  1195. Xbreak;
  1196. Xcase 90:
  1197. X    { yylval.i=MARK; return ENGRAVING_TYPE; }
  1198. Xbreak;
  1199. Xcase 91:
  1200. X    { yylval.i=1; return CURSE_TYPE; }
  1201. Xbreak;
  1202. Xcase 92:
  1203. X{ yylval.i=2; return CURSE_TYPE; }
  1204. Xbreak;
  1205. Xcase 93:
  1206. X    { yylval.i=3; return CURSE_TYPE; }
  1207. Xbreak;
  1208. Xcase 94:
  1209. X{ yylval.i=NOTELEPORT; return FLAG_TYPE; }
  1210. Xbreak;
  1211. Xcase 95:
  1212. X{ yylval.i=HARDFLOOR; return FLAG_TYPE; }
  1213. Xbreak;
  1214. Xcase 96:
  1215. X    { yylval.i=NOMMAP; return FLAG_TYPE; }
  1216. Xbreak;
  1217. Xcase 97:
  1218. X{ yylval.i=SHORTSIGHTED; return FLAG_TYPE; }
  1219. Xbreak;
  1220. Xcase 98:
  1221. X{ yylval.i=atoi(yytext); return INTEGER; }
  1222. Xbreak;
  1223. Xcase 99:
  1224. X{ yytext[yyleng-1] = 0; /* Discard the trailing \" */
  1225. X          yylval.map = (char *) alloc(strlen(yytext+1)+1);
  1226. X          strcpy(yylval.map, yytext+1); /* Discard the first \" */
  1227. X          return STRING; }
  1228. Xbreak;
  1229. Xcase 100:
  1230. X    { line_number++; }
  1231. Xbreak;
  1232. Xcase 101:
  1233. X    ;
  1234. Xbreak;
  1235. Xcase 102:
  1236. X    { yylval.i = yytext[1]; return CHAR; }
  1237. Xbreak;
  1238. Xcase 103:
  1239. X    { return yytext[0]; }
  1240. Xbreak;
  1241. Xcase -1:
  1242. Xbreak;
  1243. Xdefault:
  1244. Xfprintf(yyout,"bad switch yylook %d",nstr);
  1245. X} return(0); }
  1246. X/* end of yylex */
  1247. X#ifdef    AMIGA
  1248. Xlong *alloc(n)
  1249. X    unsigned n;
  1250. X{
  1251. X    return ((long *)malloc (n));
  1252. X}
  1253. X#endif
  1254. X
  1255. X/* routine to switch to another input file; needed for flex */
  1256. Xvoid init_yyin( input_f )
  1257. XFILE *input_f;
  1258. X{
  1259. X#ifdef FLEX_SCANNER
  1260. X    if (yyin)
  1261. X        yyrestart(input_f);
  1262. X    else
  1263. X#endif
  1264. X        yyin = input_f;
  1265. X}
  1266. X/* analogous routine (for completeness) */
  1267. Xvoid init_yyout( output_f )
  1268. XFILE *output_f;
  1269. X{
  1270. X    yyout = output_f;
  1271. X}
  1272. X
  1273. Xint yyvstop[] = {
  1274. X0,
  1275. X
  1276. X103,
  1277. X0,
  1278. X
  1279. X101,
  1280. X103,
  1281. X0,
  1282. X
  1283. X100,
  1284. X0,
  1285. X
  1286. X103,
  1287. X0,
  1288. X
  1289. X103,
  1290. X0,
  1291. X
  1292. X103,
  1293. X0,
  1294. X
  1295. X98,
  1296. X103,
  1297. X0,
  1298. X
  1299. X4,
  1300. X103,
  1301. X0,
  1302. X
  1303. X103,
  1304. X0,
  1305. X
  1306. X103,
  1307. X0,
  1308. X
  1309. X103,
  1310. X0,
  1311. X
  1312. X103,
  1313. X0,
  1314. X
  1315. X103,
  1316. X0,
  1317. X
  1318. X103,
  1319. X0,
  1320. X
  1321. X103,
  1322. X0,
  1323. X
  1324. X103,
  1325. X0,
  1326. X
  1327. X103,
  1328. X0,
  1329. X
  1330. X103,
  1331. X0,
  1332. X
  1333. X103,
  1334. X0,
  1335. X
  1336. X103,
  1337. X0,
  1338. X
  1339. X103,
  1340. X0,
  1341. X
  1342. X103,
  1343. X0,
  1344. X
  1345. X103,
  1346. X0,
  1347. X
  1348. X103,
  1349. X0,
  1350. X
  1351. X103,
  1352. X0,
  1353. X
  1354. X103,
  1355. X0,
  1356. X
  1357. X103,
  1358. X0,
  1359. X
  1360. X103,
  1361. X0,
  1362. X
  1363. X103,
  1364. X0,
  1365. X
  1366. X103,
  1367. X0,
  1368. X
  1369. X103,
  1370. X0,
  1371. X
  1372. X103,
  1373. X0,
  1374. X
  1375. X103,
  1376. X0,
  1377. X
  1378. X103,
  1379. X0,
  1380. X
  1381. X103,
  1382. X0,
  1383. X
  1384. X103,
  1385. X0,
  1386. X
  1387. X103,
  1388. X0,
  1389. X
  1390. X103,
  1391. X0,
  1392. X
  1393. X103,
  1394. X0,
  1395. X
  1396. X103,
  1397. X0,
  1398. X
  1399. X103,
  1400. X0,
  1401. X
  1402. X103,
  1403. X0,
  1404. X
  1405. X103,
  1406. X0,
  1407. X
  1408. X103,
  1409. X0,
  1410. X
  1411. X2,
  1412. X100,
  1413. X0,
  1414. X
  1415. X101,
  1416. X103,
  1417. X0,
  1418. X
  1419. X103,
  1420. X0,
  1421. X
  1422. X103,
  1423. X0,
  1424. X
  1425. X103,
  1426. X0,
  1427. X
  1428. X103,
  1429. X0,
  1430. X
  1431. X103,
  1432. X0,
  1433. X
  1434. X103,
  1435. X0,
  1436. X
  1437. X103,
  1438. X0,
  1439. X
  1440. X103,
  1441. X0,
  1442. X
  1443. X103,
  1444. X0,
  1445. X
  1446. X103,
  1447. X0,
  1448. X
  1449. X103,
  1450. X0,
  1451. X
  1452. X103,
  1453. X0,
  1454. X
  1455. X101,
  1456. X0,
  1457. X
  1458. X99,
  1459. X0,
  1460. X
  1461. X98,
  1462. X0,
  1463. X
  1464. X83,
  1465. X0,
  1466. X
  1467. X3,
  1468. X0,
  1469. X
  1470. X2,
  1471. X0,
  1472. X
  1473. X101,
  1474. X0,
  1475. X
  1476. X2,
  1477. X3,
  1478. X0,
  1479. X
  1480. X102,
  1481. X0,
  1482. X
  1483. X70,
  1484. X0,
  1485. X
  1486. X65,
  1487. X0,
  1488. X
  1489. X63,
  1490. X0,
  1491. X
  1492. X16,
  1493. X0,
  1494. X
  1495. X38,
  1496. X0,
  1497. X
  1498. X6,
  1499. X0,
  1500. X
  1501. X40,
  1502. X0,
  1503. X
  1504. X32,
  1505. X0,
  1506. X
  1507. X34,
  1508. X0,
  1509. X
  1510. X31,
  1511. X0,
  1512. X
  1513. X15,
  1514. X0,
  1515. X
  1516. X89,
  1517. X0,
  1518. X
  1519. X84,
  1520. X0,
  1521. X
  1522. X87,
  1523. X0,
  1524. X
  1525. X49,
  1526. X0,
  1527. X
  1528. X58,
  1529. X0,
  1530. X
  1531. X90,
  1532. X0,
  1533. X
  1534. X53,
  1535. X0,
  1536. X
  1537. X43,
  1538. X0,
  1539. X
  1540. X86,
  1541. X0,
  1542. X
  1543. X51,
  1544. X0,
  1545. X
  1546. X12,
  1547. X0,
  1548. X
  1549. X24,
  1550. X0,
  1551. X
  1552. X10,
  1553. X0,
  1554. X
  1555. X8,
  1556. X0,
  1557. X
  1558. X7,
  1559. X0,
  1560. X
  1561. X26,
  1562. X0,
  1563. X
  1564. X57,
  1565. X0,
  1566. X
  1567. X82,
  1568. X0,
  1569. X
  1570. X76,
  1571. X0,
  1572. X
  1573. X72,
  1574. X0,
  1575. X
  1576. X85,
  1577. X0,
  1578. X
  1579. X48,
  1580. X0,
  1581. X
  1582. X56,
  1583. X0,
  1584. X
  1585. X62,
  1586. X0,
  1587. X
  1588. X50,
  1589. X0,
  1590. X
  1591. X66,
  1592. X0,
  1593. X
  1594. X29,
  1595. X0,
  1596. X
  1597. X41,
  1598. X0,
  1599. X
  1600. X25,
  1601. X0,
  1602. X
  1603. X13,
  1604. X0,
  1605. X
  1606. X27,
  1607. X0,
  1608. X
  1609. X20,
  1610. X0,
  1611. X
  1612. X75,
  1613. X0,
  1614. X
  1615. X64,
  1616. X0,
  1617. X
  1618. X47,
  1619. X0,
  1620. X
  1621. X60,
  1622. X0,
  1623. X
  1624. X44,
  1625. X0,
  1626. X
  1627. X93,
  1628. X0,
  1629. X
  1630. X67,
  1631. X0,
  1632. X
  1633. X45,
  1634. X0,
  1635. X
  1636. X46,
  1637. X0,
  1638. X
  1639. X96,
  1640. X0,
  1641. X
  1642. X54,
  1643. X0,
  1644. X
  1645. X52,
  1646. X0,
  1647. X
  1648. X81,
  1649. X0,
  1650. X
  1651. X1,
  1652. X0,
  1653. X
  1654. X5,
  1655. X0,
  1656. X
  1657. X14,
  1658. X0,
  1659. X
  1660. X35,
  1661. X0,
  1662. X
  1663. X19,
  1664. X0,
  1665. X
  1666. X91,
  1667. X0,
  1668. X
  1669. X88,
  1670. X0,
  1671. X
  1672. X74,
  1673. X0,
  1674. X
  1675. X55,
  1676. X0,
  1677. X
  1678. X71,
  1679. X0,
  1680. X
  1681. X69,
  1682. X0,
  1683. X
  1684. X80,
  1685. X0,
  1686. X
  1687. X37,
  1688. X0,
  1689. X
  1690. X30,
  1691. X0,
  1692. X
  1693. X11,
  1694. X0,
  1695. X
  1696. X9,
  1697. X0,
  1698. X
  1699. X18,
  1700. X0,
  1701. X
  1702. X79,
  1703. X0,
  1704. X
  1705. X73,
  1706. X0,
  1707. X
  1708. X92,
  1709. X0,
  1710. X
  1711. X68,
  1712. X0,
  1713. X
  1714. X39,
  1715. X0,
  1716. X
  1717. X59,
  1718. X0,
  1719. X
  1720. X95,
  1721. X0,
  1722. X
  1723. X42,
  1724. X0,
  1725. X
  1726. X77,
  1727. X0,
  1728. X
  1729. X78,
  1730. X0,
  1731. X
  1732. X17,
  1733. X0,
  1734. X
  1735. X61,
  1736. X0,
  1737. X
  1738. X94,
  1739. X0,
  1740. X
  1741. X33,
  1742. X0,
  1743. X
  1744. X97,
  1745. X0,
  1746. X
  1747. X23,
  1748. X0,
  1749. X
  1750. X21,
  1751. X0,
  1752. X
  1753. X22,
  1754. X0,
  1755. X
  1756. X28,
  1757. X0,
  1758. X
  1759. X36,
  1760. X0,
  1761. X0};
  1762. X# define YYTYPE int
  1763. Xstruct yywork { YYTYPE verify, advance; } yycrank[] = {
  1764. X0,0,    0,0,    1,5,    0,0,    
  1765. X0,0,    0,0,    0,0,    0,0,    
  1766. X8,64,    0,0,    1,6,    1,7,    
  1767. X0,0,    0,0,    6,63,    0,0,    
  1768. X8,64,    8,64,    0,0,    0,0,    
  1769. X0,0,    0,0,    0,0,    0,0,    
  1770. X0,0,    0,0,    0,0,    0,0,    
  1771. X0,0,    0,0,    0,0,    0,0,    
  1772. X0,0,    1,6,    0,0,    1,8,    
  1773. X1,5,    6,63,    0,0,    8,64,    
  1774. X1,9,    8,65,    8,64,    0,0,    
  1775. X1,10,    0,0,    0,0,    0,0,    
  1776. X0,0,    1,11,    8,64,    0,0,    
  1777. X0,0,    0,0,    0,0,    8,64,    
  1778. X0,0,    0,0,    0,0,    1,12,    
  1779. X0,0,    0,0,    0,0,    0,0,    
  1780. X0,0,    0,0,    1,13,    1,14,    
  1781. X1,15,    1,16,    1,17,    1,18,    
  1782. X1,19,    24,87,    1,20,    29,97,    
  1783. X0,0,    1,21,    1,22,    1,23,    
  1784. X1,24,    1,25,    13,68,    1,26,    
  1785. X1,27,    1,28,    14,69,    15,70,    
  1786. X1,29,    16,72,    17,74,    20,79,    
  1787. X16,73,    18,75,    15,71,    25,88,    
  1788. X18,76,    19,77,    1,30,    1,31,    
  1789. X1,32,    1,33,    1,34,    1,35,    
  1790. X21,80,    1,36,    48,142,    19,78,    
  1791. X21,81,    1,37,    1,38,    1,39,    
  1792. X1,40,    1,41,    23,85,    1,42,    
  1793. X1,43,    1,44,    1,45,    2,47,    
  1794. X1,46,    33,109,    41,128,    2,9,    
  1795. X45,137,    46,139,    45,138,    33,110,    
  1796. X23,86,    41,129,    2,5,    10,67,    
  1797. X10,67,    10,67,    10,67,    10,67,    
  1798. X10,67,    10,67,    10,67,    10,67,    
  1799. X10,67,    53,146,    2,12,    28,95,    
  1800. X22,82,    54,69,    56,147,    57,79,    
  1801. X22,83,    2,13,    2,14,    2,15,    
  1802. X2,16,    2,17,    2,18,    2,19,    
  1803. X28,96,    2,20,    22,84,    2,5,    
  1804. X2,21,    2,48,    2,23,    2,24,    
  1805. X2,25,    26,89,    2,26,    2,27,    
  1806. X2,28,    26,90,    35,113,    2,29,    
  1807. X44,135,    59,88,    61,150,    44,136,    
  1808. X2,5,    34,111,    35,114,    26,91,    
  1809. X30,98,    2,30,    2,31,    2,32,    
  1810. X2,33,    2,34,    2,35,    30,99,    
  1811. X2,36,    3,49,    34,112,    30,100,    
  1812. X2,37,    2,38,    2,39,    2,40,    
  1813. X2,41,    66,153,    2,42,    2,43,    
  1814. X2,44,    2,45,    39,124,    2,46,    
  1815. X27,92,    36,115,    55,70,    2,5,    
  1816. X2,5,    2,5,    68,154,    3,50,    
  1817. X39,125,    55,71,    3,51,    27,93,    
  1818. X27,94,    31,101,    3,9,    36,116,    
  1819. X31,102,    37,117,    3,52,    31,103,    
  1820. X32,105,    37,118,    31,104,    32,106,    
  1821. X40,126,    37,119,    42,130,    32,107,    
  1822. X58,148,    69,155,    70,156,    37,120,    
  1823. X58,81,    3,12,    42,131,    71,157,    
  1824. X32,108,    72,158,    40,127,    73,159,    
  1825. X3,53,    3,54,    3,55,    3,16,    
  1826. X3,56,    3,18,    3,19,    38,121,    
  1827. X3,57,    38,122,    74,160,    3,58,    
  1828. X3,22,    3,23,    3,24,    3,59,    
  1829. X60,149,    3,26,    3,60,    3,28,    
  1830. X75,161,    76,162,    3,61,    38,123,    
  1831. X43,132,    77,163,    78,164,    60,93,    
  1832. X60,94,    79,165,    80,166,    43,133,    
  1833. X3,30,    3,31,    3,32,    3,33,    
  1834. X3,34,    3,35,    43,134,    3,36,    
  1835. X81,167,    82,168,    83,169,    3,37,    
  1836. X3,38,    3,39,    3,40,    3,41,    
  1837. X4,5,    3,42,    3,43,    3,44,    
  1838. X3,45,    84,170,    3,46,    62,151,    
  1839. X4,6,    4,49,    52,67,    52,67,    
  1840. X52,67,    52,67,    52,67,    52,67,    
  1841. X52,67,    52,67,    52,67,    52,67,    
  1842. X85,171,    86,172,    86,173,    87,174,    
  1843. X88,175,    89,177,    90,178,    88,176,    
  1844. X91,179,    62,152,    92,180,    4,50,    
  1845. X62,152,    4,8,    4,62,    93,181,    
  1846. X94,182,    95,183,    4,9,    96,184,    
  1847. X62,152,    97,185,    4,52,    98,186,    
  1848. X99,188,    4,51,    100,189,    4,11,    
  1849. X101,190,    102,191,    103,192,    104,193,    
  1850. X105,194,    106,195,    98,187,    107,196,    
  1851. X108,197,    4,12,    109,198,    110,199,    
  1852. X111,200,    112,201,    113,202,    114,203,    
  1853. X4,53,    4,54,    4,55,    4,16,    
  1854. X4,56,    4,18,    4,19,    116,206,    
  1855. X4,57,    117,207,    4,51,    4,58,    
  1856. X4,48,    4,23,    4,24,    4,59,    
  1857. X119,210,    4,26,    4,60,    4,28,    
  1858. X115,204,    120,211,    4,61,    122,215,    
  1859. X118,208,    123,216,    115,205,    4,51,    
  1860. X124,217,    126,224,    127,225,    128,226,    
  1861. X4,30,    4,31,    4,32,    4,33,    
  1862. X4,34,    4,35,    129,227,    4,36,    
  1863. X118,209,    130,228,    131,229,    4,37,    
  1864. X4,38,    4,39,    4,40,    4,41,    
  1865. X9,66,    4,42,    4,43,    4,44,    
  1866. X4,45,    132,230,    4,46,    47,140,    
  1867. X9,66,    9,0,    4,51,    4,51,    
  1868. X4,51,    134,233,    135,234,    47,140,    
  1869. X47,141,    121,212,    133,231,    136,235,    
  1870. X139,239,    133,232,    50,63,    50,143,    
  1871. X121,213,    142,240,    121,214,    137,236,    
  1872. X146,154,    147,241,    137,237,    9,66,    
  1873. X147,160,    9,66,    9,66,    142,168,    
  1874. X137,238,    148,166,    47,140,    149,180,    
  1875. X47,140,    47,140,    9,66,    150,242,    
  1876. X154,243,    50,144,    155,244,    9,66,    
  1877. X50,145,    47,140,    152,151,    156,245,    
  1878. X125,218,    157,246,    47,140,    125,219,    
  1879. X50,145,    158,247,    50,145,    50,145,    
  1880. X159,248,    160,249,    51,143,    161,250,    
  1881. X125,220,    125,221,    162,251,    163,252,    
  1882. X164,253,    125,222,    165,254,    125,223,    
  1883. X152,152,    166,255,    167,256,    152,152,    
  1884. X168,257,    169,258,    50,145,    50,145,    
  1885. X50,145,    170,259,    171,260,    152,152,    
  1886. X51,145,    172,261,    50,145,    51,145,    
  1887. X50,145,    50,145,    173,262,    174,263,    
  1888. X175,264,    50,145,    176,265,    51,145,    
  1889. X50,145,    51,145,    51,145,    177,266,    
  1890. X50,145,    178,267,    179,268,    180,269,    
  1891. X181,270,    50,145,    182,271,    183,272,    
  1892. X184,273,    185,274,    186,275,    187,276,    
  1893. X188,277,    189,278,    190,279,    191,280,    
  1894. X192,281,    51,145,    51,145,    51,145,    
  1895. X193,282,    194,283,    195,284,    196,285,    
  1896. X197,286,    51,145,    198,287,    51,145,    
  1897. X51,145,    199,288,    200,289,    201,290,    
  1898. X51,145,    202,291,    203,292,    51,145,    
  1899. X50,145,    50,145,    50,145,    51,145,    
  1900. X204,293,    205,294,    206,295,    208,296,    
  1901. X51,145,    209,297,    211,298,    212,299,    
  1902. X213,300,    214,301,    215,302,    216,303,    
  1903. X217,304,    218,305,    219,306,    220,307,    
  1904. X221,308,    222,309,    223,310,    224,311,    
  1905. X225,312,    226,313,    227,314,    228,315,    
  1906. X229,316,    230,317,    231,318,    232,319,    
  1907. X233,320,    235,321,    236,322,    237,323,    
  1908. X238,324,    239,325,    240,326,    51,145,    
  1909. X51,145,    51,145,    241,327,    242,328,    
  1910. X243,329,    244,330,    245,331,    246,332,    
  1911. X248,333,    249,334,    250,335,    251,336,    
  1912. X252,337,    254,338,    255,339,    256,340,    
  1913. X257,341,    258,342,    259,343,    261,344,    
  1914. X262,345,    263,346,    265,347,    266,348,    
  1915. X267,349,    270,350,    271,351,    272,352,    
  1916. X274,353,    275,354,    276,355,    277,356,    
  1917. X278,357,    279,358,    280,359,    281,360,    
  1918. X283,361,    284,362,    285,363,    286,364,    
  1919. X290,365,    291,366,    292,367,    293,368,    
  1920. X294,369,    295,370,    297,371,    298,372,    
  1921. X299,373,    300,374,    301,375,    303,376,    
  1922. X304,377,    305,378,    306,379,    307,380,    
  1923. X309,381,    310,382,    311,383,    313,384,    
  1924. X314,385,    315,386,    316,387,    317,388,    
  1925. X318,389,    319,390,    320,391,    322,392,    
  1926. X323,393,    324,394,    327,395,    328,396,    
  1927. X330,397,    331,398,    332,399,    333,400,    
  1928. X334,401,    336,402,    337,403,    338,404,    
  1929. X339,405,    341,406,    342,407,    343,408,    
  1930. X345,409,    346,410,    347,411,    348,412,    
  1931. X349,413,    351,414,    352,415,    353,416,    
  1932. X356,417,    358,418,    359,419,    360,420,    
  1933. X361,421,    363,422,    364,423,    365,424,    
  1934. X367,425,    368,426,    369,428,    370,429,    
  1935. X371,430,    372,431,    373,432,    368,427,    
  1936. X374,433,    375,434,    376,435,    377,436,    
  1937. X378,437,    379,438,    380,439,    382,440,    
  1938. X383,441,    384,442,    386,443,    388,444,    
  1939. X389,445,    390,446,    392,447,    393,448,    
  1940. X395,449,    396,416,    399,450,    400,451,    
  1941. X401,452,    402,453,    403,454,    404,455,    
  1942. X406,456,    407,457,    408,458,    409,459,    
  1943. X412,460,    414,461,    415,462,    416,463,    
  1944. X418,464,    424,465,    426,466,    427,467,    
  1945. X428,468,    429,469,    430,470,    432,471,    
  1946. X433,472,    434,473,    435,474,    436,475,    
  1947. X437,476,    440,477,    442,478,    444,479,    
  1948. X445,480,    447,481,    448,482,    450,483,    
  1949. X451,484,    452,485,    453,486,    454,487,    
  1950. X455,488,    456,489,    459,490,    460,491,    
  1951. X462,495,    466,496,    467,497,    468,498,    
  1952. X470,499,    471,500,    472,501,    473,502,    
  1953. X477,503,    460,492,    478,504,    460,493,    
  1954. X460,494,    480,505,    481,506,    482,507,    
  1955. X484,508,    485,509,    490,510,    491,511,    
  1956. X492,512,    493,513,    494,514,    495,515,    
  1957. X496,516,    497,517,    498,518,    499,519,    
  1958. X500,520,    501,521,    503,522,    505,523,    
  1959. X508,524,    510,525,    511,526,    512,527,    
  1960. X513,528,    514,529,    515,530,    517,531,    
  1961. X522,532,    523,533,    525,534,    526,535,    
  1962. X527,536,    528,537,    529,538,    530,539,    
  1963. X533,540,    534,541,    535,542,    536,543,    
  1964. X537,544,    538,545,    539,546,    540,547,    
  1965. X542,548,    543,549,    544,550,    545,551,    
  1966. X546,552,    548,553,    549,554,    550,555,    
  1967. X552,556,    553,557,    554,558,    556,559,    
  1968. X557,560,    0,0,    0,0,    0,0,    
  1969. X0,0};
  1970. Xstruct yysvf yysvec[] = {
  1971. X0,    0,    0,
  1972. Xyycrank+-1,    0,        0,    
  1973. Xyycrank+-84,    yysvec+1,    0,    
  1974. Xyycrank+-179,    yysvec+1,    0,    
  1975. Xyycrank+-291,    0,        0,    
  1976. Xyycrank+0,    0,        yyvstop+1,
  1977. Xyycrank+5,    0,        yyvstop+3,
  1978. Xyycrank+0,    0,        yyvstop+6,
  1979. Xyycrank+-7,    0,        yyvstop+8,
  1980. Xyycrank+-403,    0,        yyvstop+10,
  1981. Xyycrank+83,    0,        yyvstop+12,
  1982. Xyycrank+0,    yysvec+10,    yyvstop+14,
  1983. Xyycrank+0,    0,        yyvstop+17,
  1984. Xyycrank+6,    0,        yyvstop+20,
  1985. Xyycrank+4,    0,        yyvstop+22,
  1986. Xyycrank+15,    0,        yyvstop+24,
  1987. Xyycrank+10,    0,        yyvstop+26,
  1988. Xyycrank+12,    0,        yyvstop+28,
  1989. Xyycrank+17,    0,        yyvstop+30,
  1990. Xyycrank+28,    0,        yyvstop+32,
  1991. Xyycrank+13,    0,        yyvstop+34,
  1992. Xyycrank+39,    0,        yyvstop+36,
  1993. Xyycrank+79,    0,        yyvstop+38,
  1994. Xyycrank+49,    0,        yyvstop+40,
  1995. Xyycrank+7,    0,        yyvstop+42,
  1996. Xyycrank+16,    0,        yyvstop+44,
  1997. Xyycrank+100,    0,        yyvstop+46,
  1998. Xyycrank+131,    0,        yyvstop+48,
  1999. Xyycrank+74,    0,        yyvstop+50,
  2000. Xyycrank+10,    0,        yyvstop+52,
  2001. Xyycrank+72,    0,        yyvstop+54,
  2002. Xyycrank+109,    0,        yyvstop+56,
  2003. Xyycrank+123,    0,        yyvstop+58,
  2004. Xyycrank+10,    0,        yyvstop+60,
  2005. Xyycrank+80,    0,        yyvstop+62,
  2006. Xyycrank+73,    0,        yyvstop+64,
  2007. Xyycrank+108,    0,        yyvstop+66,
  2008. Xyycrank+124,    0,        yyvstop+68,
  2009. Xyycrank+156,    0,        yyvstop+70,
  2010. Xyycrank+101,    0,        yyvstop+72,
  2011. Xyycrank+130,    0,        yyvstop+74,
  2012. Xyycrank+21,    0,        yyvstop+76,
  2013. Xyycrank+133,    0,        yyvstop+78,
  2014. Xyycrank+171,    0,        yyvstop+80,
  2015. Xyycrank+61,    0,        yyvstop+82,
  2016. Xyycrank+14,    0,        yyvstop+84,
  2017. Xyycrank+24,    0,        yyvstop+86,
  2018. Xyycrank+-410,    0,        yyvstop+88,
  2019. Xyycrank+41,    yysvec+22,    yyvstop+90,
  2020. Xyycrank+0,    0,        yyvstop+92,
  2021. Xyycrank+417,    0,        yyvstop+95,
  2022. Xyycrank+456,    0,        yyvstop+98,
  2023. Xyycrank+254,    yysvec+51,    yyvstop+100,
  2024. Xyycrank+65,    yysvec+51,    yyvstop+102,
  2025. Xyycrank+63,    yysvec+51,    yyvstop+104,
  2026. Xyycrank+134,    yysvec+51,    yyvstop+106,
  2027. Xyycrank+68,    0,        yyvstop+108,
  2028. Xyycrank+69,    yysvec+51,    yyvstop+110,
  2029. Xyycrank+167,    yysvec+51,    yyvstop+112,
  2030. Xyycrank+94,    yysvec+51,    yyvstop+114,
  2031. Xyycrank+187,    yysvec+51,    yyvstop+116,
  2032. Xyycrank+109,    yysvec+51,    yyvstop+118,
  2033. Xyycrank+-289,    yysvec+47,    yyvstop+120,
  2034. Xyycrank+0,    yysvec+6,    yyvstop+122,
  2035. Xyycrank+0,    yysvec+8,    0,    
  2036. Xyycrank+0,    0,        yyvstop+124,
  2037. Xyycrank+158,    0,        0,    
  2038. Xyycrank+0,    yysvec+10,    yyvstop+126,
  2039. Xyycrank+126,    0,        0,    
  2040. Xyycrank+168,    0,        0,    
  2041. Xyycrank+169,    0,        0,    
  2042. Xyycrank+157,    0,        0,    
  2043. Xyycrank+162,    0,        0,    
  2044. Xyycrank+178,    0,        0,    
  2045. Xyycrank+183,    0,        0,    
  2046. Xyycrank+199,    0,        0,    
  2047. Xyycrank+180,    0,        0,    
  2048. Xyycrank+190,    0,        0,    
  2049. Xyycrank+194,    0,        0,    
  2050. Xyycrank+200,    0,        0,    
  2051. Xyycrank+206,    0,        0,    
  2052. Xyycrank+198,    0,        0,    
  2053. Xyycrank+195,    0,        0,    
  2054. Xyycrank+203,    0,        0,    
  2055. Xyycrank+219,    0,        0,    
  2056. Xyycrank+235,    0,        0,    
  2057. Xyycrank+236,    0,        0,    
  2058. Xyycrank+241,    0,        0,    
  2059. Xyycrank+237,    0,        0,    
  2060. Xyycrank+239,    0,        0,    
  2061. Xyycrank+247,    0,        0,    
  2062. Xyycrank+241,    0,        0,    
  2063. Xyycrank+244,    0,        0,    
  2064. Xyycrank+262,    0,        0,    
  2065. Xyycrank+262,    0,        0,    
  2066. Xyycrank+253,    0,        0,    
  2067. Xyycrank+266,    0,        0,    
  2068. Xyycrank+257,    0,        0,    
  2069. Xyycrank+230,    0,        0,    
  2070. Xyycrank+228,    0,        0,    
  2071. Xyycrank+241,    0,        0,    
  2072. Xyycrank+239,    0,        0,    
  2073. Xyycrank+225,    0,        0,    
  2074. Xyycrank+231,    0,        0,    
  2075. Xyycrank+229,    0,        0,    
  2076. Xyycrank+234,    0,        0,    
  2077. Xyycrank+248,    0,        0,    
  2078. Xyycrank+236,    0,        0,    
  2079. Xyycrank+234,    0,        0,    
  2080. Xyycrank+231,    0,        0,    
  2081. Xyycrank+236,    0,        0,    
  2082. Xyycrank+237,    0,        0,    
  2083. Xyycrank+250,    0,        0,    
  2084. Xyycrank+246,    0,        0,    
  2085. Xyycrank+247,    0,        0,    
  2086. Xyycrank+268,    0,        0,    
  2087. Xyycrank+248,    0,        0,    
  2088. Xyycrank+246,    0,        0,    
  2089. Xyycrank+278,    0,        0,    
  2090. Xyycrank+256,    0,        0,    
  2091. Xyycrank+278,    0,        0,    
  2092. Xyycrank+319,    0,        0,    
  2093. Xyycrank+265,    0,        0,    
  2094. Xyycrank+271,    0,        0,    
  2095. Xyycrank+267,    0,        0,    
  2096. Xyycrank+359,    0,        0,    
  2097. Xyycrank+279,    0,        0,    
  2098. Xyycrank+285,    0,        0,    
  2099. Xyycrank+290,    0,        0,    
  2100. Xyycrank+297,    0,        0,    
  2101. Xyycrank+287,    0,        0,    
  2102. Xyycrank+295,    0,        0,    
  2103. Xyycrank+299,    0,        0,    
  2104. Xyycrank+311,    0,        0,    
  2105. Xyycrank+300,    0,        0,    
  2106. Xyycrank+306,    0,        0,    
  2107. Xyycrank+306,    0,        0,    
  2108. Xyycrank+332,    0,        0,    
  2109. Xyycrank+0,    0,        yyvstop+128,
  2110. Xyycrank+309,    0,        0,    
  2111. Xyycrank+0,    yysvec+47,    0,    
  2112. Xyycrank+0,    0,        yyvstop+130,
  2113. Xyycrank+349,    0,        0,    
  2114. Xyycrank+0,    0,        yyvstop+132,
  2115. Xyycrank+0,    yysvec+50,    yyvstop+134,
  2116. Xyycrank+0,    yysvec+51,    0,    
  2117. Xyycrank+348,    yysvec+51,    0,    
  2118. Xyycrank+365,    0,        0,    
  2119. Xyycrank+373,    yysvec+51,    0,    
  2120. Xyycrank+365,    yysvec+51,    0,    
  2121. Xyycrank+371,    yysvec+51,    0,    
  2122. Xyycrank+0,    0,        yyvstop+136,
  2123. Xyycrank+-444,    yysvec+47,    0,    
  2124. Xyycrank+0,    0,        yyvstop+139,
  2125. Xyycrank+383,    0,        0,    
  2126. Xyycrank+372,    0,        0,    
  2127. Xyycrank+377,    0,        0,    
  2128. Xyycrank+375,    0,        0,    
  2129. Xyycrank+379,    0,        0,    
  2130. Xyycrank+377,    0,        0,    
  2131. Xyycrank+383,    0,        0,    
  2132. Xyycrank+396,    0,        0,    
  2133. Xyycrank+392,    0,        0,    
  2134. Xyycrank+394,    0,        0,    
  2135. Xyycrank+404,    0,        0,    
  2136. Xyycrank+390,    0,        0,    
  2137. Xyycrank+409,    0,        0,    
  2138. Xyycrank+409,    0,        0,    
  2139. Xyycrank+411,    0,        0,    
  2140. Xyycrank+398,    0,        0,    
  2141. Xyycrank+402,    0,        0,    
  2142. Xyycrank+417,    0,        0,    
  2143. Xyycrank+424,    0,        0,    
  2144. Xyycrank+399,    0,        0,    
  2145. Xyycrank+426,    0,        0,    
  2146. Xyycrank+420,    0,        0,    
  2147. Xyycrank+414,    0,        0,    
  2148. Xyycrank+435,    0,        0,    
  2149. Xyycrank+432,    0,        0,    
  2150. Xyycrank+429,    0,        0,    
  2151. Xyycrank+432,    0,        0,    
  2152. Xyycrank+435,    0,        0,    
  2153. Xyycrank+428,    0,        0,    
  2154. Xyycrank+442,    0,        0,    
  2155. Xyycrank+432,    0,        0,    
  2156. Xyycrank+437,    0,        0,    
  2157. Xyycrank+411,    0,        0,    
  2158. Xyycrank+418,    0,        0,    
  2159. Xyycrank+415,    0,        0,    
  2160. Xyycrank+410,    0,        0,    
  2161. Xyycrank+403,    0,        0,    
  2162. Xyycrank+403,    0,        0,    
  2163. Xyycrank+413,    0,        0,    
  2164. Xyycrank+414,    0,        0,    
  2165. Xyycrank+409,    0,        0,    
  2166. Xyycrank+415,    0,        0,    
  2167. Xyycrank+412,    0,        0,    
  2168. Xyycrank+413,    0,        0,    
  2169. Xyycrank+420,    0,        0,    
  2170. Xyycrank+417,    0,        0,    
  2171. Xyycrank+418,    0,        0,    
  2172. Xyycrank+421,    0,        0,    
  2173. Xyycrank+422,    0,        0,    
  2174. Xyycrank+430,    0,        0,    
  2175. Xyycrank+442,    0,        0,    
  2176. Xyycrank+445,    0,        0,    
  2177. Xyycrank+430,    0,        0,    
  2178. Xyycrank+0,    0,        yyvstop+141,
  2179. Xyycrank+431,    0,        0,    
  2180. Xyycrank+435,    0,        0,    
  2181. Xyycrank+0,    0,        yyvstop+143,
  2182. Xyycrank+443,    0,        0,    
  2183. Xyycrank+450,    0,        0,    
  2184. Xyycrank+441,    0,        0,    
  2185. Xyycrank+455,    0,        0,    
  2186. Xyycrank+447,    0,        0,    
  2187. Xyycrank+440,    0,        0,    
  2188. Xyycrank+440,    0,        0,    
  2189. Xyycrank+449,    0,        0,    
  2190. Xyycrank+447,    0,        0,    
  2191. Xyycrank+450,    0,        0,    
  2192. Xyycrank+459,    0,        0,    
  2193. Xyycrank+445,    0,        0,    
  2194. Xyycrank+461,    0,        0,    
  2195. Xyycrank+462,    0,        0,    
  2196. Xyycrank+454,    0,        0,    
  2197. Xyycrank+466,    0,        0,    
  2198. Xyycrank+467,    0,        0,    
  2199. Xyycrank+467,    0,        0,    
  2200. Xyycrank+464,    0,        0,    
  2201. Xyycrank+470,    0,        0,    
  2202. Xyycrank+456,    0,        0,    
  2203. Xyycrank+466,    0,        0,    
  2204. Xyycrank+456,    0,        0,    
  2205. Xyycrank+0,    0,        yyvstop+145,
  2206. Xyycrank+472,    0,        0,    
  2207. Xyycrank+457,    0,        0,    
  2208. Xyycrank+470,    0,        0,    
  2209. Xyycrank+471,    0,        0,    
  2210. Xyycrank+461,    0,        0,    
  2211. Xyycrank+568,    0,        0,    
  2212. Xyycrank+505,    0,        0,    
  2213. Xyycrank+507,    yysvec+51,    0,    
  2214. Xyycrank+502,    0,        0,    
  2215. Xyycrank+518,    0,        0,    
  2216. Xyycrank+519,    0,        0,    
  2217. Xyycrank+514,    0,        0,    
  2218. Xyycrank+0,    0,        yyvstop+147,
  2219. Xyycrank+522,    0,        0,    
  2220. Xyycrank+524,    0,        0,    
  2221. Xyycrank+507,    0,        0,    
  2222. Xyycrank+507,    0,        0,    
  2223. Xyycrank+523,    0,        0,    
  2224. Xyycrank+0,    0,        yyvstop+149,
  2225. Xyycrank+498,    0,        0,    
  2226. Xyycrank+525,    0,        0,    
  2227. Xyycrank+519,    0,        0,    
  2228. Xyycrank+509,    0,        yyvstop+151,
  2229. Xyycrank+532,    0,        0,    
  2230. Xyycrank+514,    0,        0,    
  2231. Xyycrank+0,    0,        yyvstop+153,
  2232. Xyycrank+519,    0,        0,    
  2233. Xyycrank+532,    0,        0,    
  2234. Xyycrank+534,    0,        0,    
  2235. Xyycrank+0,    0,        yyvstop+155,
  2236. Xyycrank+537,    0,        0,    
  2237. Xyycrank+524,    0,        0,    
  2238. Xyycrank+525,    0,        0,    
  2239. Xyycrank+0,    0,        yyvstop+157,
  2240. Xyycrank+0,    0,        yyvstop+159,
  2241. Xyycrank+523,    0,        0,    
  2242. Xyycrank+527,    0,        0,    
  2243. Xyycrank+527,    0,        0,    
  2244. Xyycrank+0,    0,        yyvstop+161,
  2245. Xyycrank+535,    0,        0,    
  2246. Xyycrank+499,    0,        0,    
  2247. Xyycrank+496,    0,        0,    
  2248. Xyycrank+510,    0,        0,    
  2249. Xyycrank+511,    0,        0,    
  2250. Xyycrank+498,    0,        0,    
  2251. Xyycrank+503,    0,        0,    
  2252. Xyycrank+514,    0,        0,    
  2253. Xyycrank+0,    0,        yyvstop+163,
  2254. Xyycrank+515,    0,        0,    
  2255. Xyycrank+502,    0,        0,    
  2256. Xyycrank+517,    0,        0,    
  2257. Xyycrank+518,    0,        0,    
  2258. Xyycrank+0,    0,        yyvstop+165,
  2259. Xyycrank+0,    0,        yyvstop+167,
  2260. Xyycrank+0,    0,        yyvstop+169,
  2261. Xyycrank+523,    0,        0,    
  2262. Xyycrank+520,    0,        0,    
  2263. Xyycrank+521,    0,        0,    
  2264. Xyycrank+578,    0,        0,    
  2265. Xyycrank+522,    0,        0,    
  2266. Xyycrank+520,    0,        0,    
  2267. Xyycrank+0,    0,        yyvstop+171,
  2268. Xyycrank+525,    0,        0,    
  2269. Xyycrank+526,    0,        0,    
  2270. Xyycrank+531,    0,        0,    
  2271. Xyycrank+519,    0,        0,    
  2272. Xyycrank+524,    0,        0,    
  2273. Xyycrank+0,    0,        yyvstop+173,
  2274. Xyycrank+515,    0,        0,    
  2275. Xyycrank+518,    0,        0,    
  2276. Xyycrank+528,    0,        0,    
  2277. Xyycrank+523,    0,        0,    
  2278. Xyycrank+538,    0,        0,    
  2279. Xyycrank+0,    0,        yyvstop+175,
  2280. Xyycrank+532,    0,        0,    
  2281. Xyycrank+529,    0,        0,    
  2282. Xyycrank+539,    0,        0,    
  2283. Xyycrank+0,    0,        yyvstop+177,
  2284. Xyycrank+538,    0,        0,    
  2285. Xyycrank+539,    0,        0,    
  2286. Xyycrank+530,    0,        0,    
  2287. Xyycrank+526,    0,        0,    
  2288. Xyycrank+527,    0,        0,    
  2289. Xyycrank+528,    0,        0,    
  2290. Xyycrank+535,    0,        0,    
  2291. Xyycrank+542,    0,        0,    
  2292. Xyycrank+0,    0,        yyvstop+179,
  2293. Xyycrank+533,    0,        0,    
  2294. Xyycrank+540,    0,        0,    
  2295. Xyycrank+533,    0,        0,    
  2296. Xyycrank+0,    0,        yyvstop+181,
  2297. Xyycrank+0,    0,        yyvstop+183,
  2298. Xyycrank+585,    0,        0,    
  2299. Xyycrank+578,    yysvec+51,    0,    
  2300. Xyycrank+0,    0,        yyvstop+185,
  2301. Xyycrank+580,    0,        0,    
  2302. Xyycrank+584,    0,        0,    
  2303. Xyycrank+586,    0,        0,    
  2304. Xyycrank+573,    0,        0,    
  2305. Xyycrank+570,    0,        0,    
  2306. Xyycrank+0,    0,        yyvstop+187,
  2307. Xyycrank+592,    0,        0,    
  2308. Xyycrank+574,    0,        0,    
  2309. Xyycrank+582,    0,        0,    
  2310. Xyycrank+578,    0,        0,    
  2311. Xyycrank+0,    0,        yyvstop+189,
  2312. Xyycrank+596,    0,        0,    
  2313. Xyycrank+591,    0,        0,    
  2314. Xyycrank+594,    0,        0,    
  2315. Xyycrank+0,    0,        yyvstop+191,
  2316. Xyycrank+591,    0,        0,    
  2317. Xyycrank+581,    0,        0,    
  2318. Xyycrank+590,    0,        0,    
  2319. Xyycrank+590,    0,        0,    
  2320. Xyycrank+590,    0,        0,    
  2321. Xyycrank+0,    0,        yyvstop+193,
  2322. Xyycrank+590,    0,        0,    
  2323. Xyycrank+591,    0,        0,    
  2324. Xyycrank+601,    0,        0,    
  2325. Xyycrank+0,    0,        yyvstop+195,
  2326. Xyycrank+0,    0,        yyvstop+197,
  2327. Xyycrank+560,    0,        0,    
  2328. Xyycrank+0,    0,        yyvstop+199,
  2329. Xyycrank+572,    0,        0,    
  2330. Xyycrank+565,    0,        0,    
  2331. Xyycrank+565,    0,        0,    
  2332. Xyycrank+562,    0,        0,    
  2333. Xyycrank+0,    0,        yyvstop+201,
  2334. Xyycrank+577,    0,        0,    
  2335. Xyycrank+578,    0,        0,    
  2336. Xyycrank+561,    0,        0,    
  2337. Xyycrank+0,    0,        yyvstop+203,
  2338. Xyycrank+580,    0,        0,    
  2339. Xyycrank+573,    0,        0,    
  2340. Xyycrank+574,    0,        0,    
  2341. Xyycrank+575,    0,        0,    
  2342. Xyycrank+581,    0,        0,    
  2343. Xyycrank+585,    0,        0,    
  2344. Xyycrank+570,    0,        0,    
  2345. Xyycrank+573,    0,        0,    
  2346. Xyycrank+588,    0,        0,    
  2347. Xyycrank+589,    0,        0,    
  2348. Xyycrank+594,    0,        0,    
  2349. Xyycrank+589,    0,        0,    
  2350. Xyycrank+579,    0,        0,    
  2351. Xyycrank+582,    0,        0,    
  2352. Xyycrank+0,    0,        yyvstop+205,
  2353. Xyycrank+594,    0,        0,    
  2354. Xyycrank+580,    0,        0,    
  2355. Xyycrank+595,    0,        0,    
  2356. Xyycrank+0,    0,        yyvstop+207,
  2357. Xyycrank+589,    0,        0,    
  2358. Xyycrank+0,    0,        yyvstop+209,
  2359. Xyycrank+582,    0,        0,    
  2360. Xyycrank+585,    0,        0,    
  2361. Xyycrank+600,    0,        0,    
  2362. Xyycrank+0,    0,        yyvstop+211,
  2363. Xyycrank+587,    0,        0,    
  2364. Xyycrank+595,    0,        0,    
  2365. Xyycrank+0,    0,        yyvstop+213,
  2366. Xyycrank+624,    0,        0,    
  2367. Xyycrank+635,    yysvec+51,    0,    
  2368. Xyycrank+0,    0,        yyvstop+215,
  2369. Xyycrank+0,    0,        yyvstop+217,
  2370. Xyycrank+627,    0,        0,    
  2371. Xyycrank+634,    0,        0,    
  2372. Xyycrank+635,    0,        0,    
  2373. Xyycrank+636,    0,        0,    
  2374. Xyycrank+628,    0,        0,    
  2375. Xyycrank+646,    0,        0,    
  2376. Xyycrank+0,    0,        yyvstop+219,
  2377. Xyycrank+636,    0,        0,    
  2378. Xyycrank+644,    0,        0,    
  2379. Xyycrank+632,    0,        0,    
  2380. Xyycrank+644,    0,        0,    
  2381. Xyycrank+0,    0,        yyvstop+221,
  2382. Xyycrank+0,    0,        yyvstop+223,
  2383. Xyycrank+621,    0,        0,    
  2384. Xyycrank+0,    0,        yyvstop+225,
  2385. Xyycrank+640,    0,        0,    
  2386. Xyycrank+636,    0,        0,    
  2387. Xyycrank+630,    0,        0,    
  2388. Xyycrank+0,    0,        yyvstop+227,
  2389. Xyycrank+620,    0,        0,    
  2390. Xyycrank+0,    0,        yyvstop+229,
  2391. Xyycrank+0,    0,        yyvstop+231,
  2392. Xyycrank+0,    0,        yyvstop+233,
  2393. Xyycrank+0,    0,        yyvstop+235,
  2394. Xyycrank+0,    0,        yyvstop+237,
  2395. Xyycrank+620,    0,        0,    
  2396. Xyycrank+0,    0,        yyvstop+239,
  2397. Xyycrank+621,    0,        0,    
  2398. Xyycrank+618,    0,        0,    
  2399. Xyycrank+613,    0,        0,    
  2400. Xyycrank+624,    0,        0,    
  2401. Xyycrank+621,    0,        0,    
  2402. Xyycrank+0,    0,        yyvstop+241,
  2403. Xyycrank+610,    0,        0,    
  2404. Xyycrank+612,    0,        0,    
  2405. Xyycrank+630,    0,        0,    
  2406. Xyycrank+616,    0,        0,    
  2407. Xyycrank+623,    0,        0,    
  2408. Xyycrank+622,    0,        0,    
  2409. Xyycrank+0,    0,        yyvstop+243,
  2410. Xyycrank+0,    0,        yyvstop+245,
  2411. Xyycrank+621,    0,        0,    
  2412. Xyycrank+0,    0,        yyvstop+247,
  2413. Xyycrank+617,    0,        0,    
  2414. Xyycrank+0,    0,        yyvstop+249,
  2415. Xyycrank+626,    0,        0,    
  2416. Xyycrank+631,    0,        0,    
  2417. Xyycrank+0,    0,        yyvstop+251,
  2418. Xyycrank+636,    0,        0,    
  2419. Xyycrank+637,    0,        0,    
  2420. Xyycrank+0,    0,        yyvstop+253,
  2421. Xyycrank+657,    0,        0,    
  2422. Xyycrank+672,    0,        0,    
  2423. Xyycrank+663,    0,        0,    
  2424. Xyycrank+664,    0,        0,    
  2425. Xyycrank+654,    0,        0,    
  2426. Xyycrank+664,    0,        0,    
  2427. Xyycrank+670,    0,        0,    
  2428. Xyycrank+0,    0,        yyvstop+255,
  2429. Xyycrank+0,    0,        yyvstop+257,
  2430. Xyycrank+675,    0,        0,    
  2431. Xyycrank+680,    0,        0,    
  2432. Xyycrank+0,    0,        yyvstop+259,
  2433. Xyycrank+664,    0,        0,    
  2434. Xyycrank+0,    0,        yyvstop+261,
  2435. Xyycrank+0,    0,        yyvstop+263,
  2436. Xyycrank+0,    0,        yyvstop+265,
  2437. Xyycrank+647,    0,        0,    
  2438. Xyycrank+647,    0,        0,    
  2439. Xyycrank+640,    0,        0,    
  2440. Xyycrank+0,    0,        yyvstop+267,
  2441. Xyycrank+641,    0,        0,    
  2442. Xyycrank+639,    0,        0,    
  2443. Xyycrank+653,    0,        0,    
  2444. Xyycrank+639,    0,        0,    
  2445. Xyycrank+0,    0,        yyvstop+269,
  2446. Xyycrank+0,    0,        yyvstop+271,
  2447. Xyycrank+0,    0,        yyvstop+273,
  2448. Xyycrank+645,    0,        0,    
  2449. Xyycrank+650,    0,        0,    
  2450. Xyycrank+0,    0,        yyvstop+275,
  2451. Xyycrank+658,    0,        0,    
  2452. Xyycrank+662,    0,        0,    
  2453. Xyycrank+663,    0,        0,    
  2454. Xyycrank+0,    0,        yyvstop+277,
  2455. Xyycrank+693,    0,        0,    
  2456. Xyycrank+694,    0,        0,    
  2457. Xyycrank+0,    0,        yyvstop+279,
  2458. Xyycrank+0,    0,        yyvstop+281,
  2459. Xyycrank+0,    0,        yyvstop+283,
  2460. Xyycrank+0,    0,        yyvstop+285,
  2461. Xyycrank+701,    0,        0,    
  2462. Xyycrank+688,    0,        0,    
  2463. Xyycrank+689,    0,        0,    
  2464. Xyycrank+703,    0,        0,    
  2465. Xyycrank+694,    0,        0,    
  2466. Xyycrank+676,    0,        0,    
  2467. Xyycrank+656,    0,        0,    
  2468. Xyycrank+669,    0,        0,    
  2469. Xyycrank+660,    0,        0,    
  2470. Xyycrank+665,    0,        0,    
  2471. Xyycrank+675,    0,        0,    
  2472. Xyycrank+663,    0,        0,    
  2473. Xyycrank+0,    0,        yyvstop+287,
  2474. Xyycrank+664,    0,        0,    
  2475. Xyycrank+0,    0,        yyvstop+289,
  2476. Xyycrank+675,    0,        0,    
  2477. Xyycrank+0,    0,        yyvstop+291,
  2478. Xyycrank+0,    0,        yyvstop+293,
  2479. Xyycrank+711,    0,        0,    
  2480. Xyycrank+0,    0,        yyvstop+295,
  2481. Xyycrank+715,    0,        0,    
  2482. Xyycrank+700,    0,        0,    
  2483. Xyycrank+705,    0,        0,    
  2484. Xyycrank+710,    0,        0,    
  2485. Xyycrank+720,    0,        0,    
  2486. Xyycrank+704,    0,        0,    
  2487. Xyycrank+0,    0,        yyvstop+297,
  2488. Xyycrank+671,    0,        0,    
  2489. Xyycrank+0,    0,        yyvstop+299,
  2490. Xyycrank+0,    0,        yyvstop+301,
  2491. Xyycrank+0,    0,        yyvstop+303,
  2492. Xyycrank+0,    0,        yyvstop+305,
  2493. Xyycrank+672,    0,        0,    
  2494. Xyycrank+673,    0,        0,    
  2495. Xyycrank+0,    0,        yyvstop+307,
  2496. Xyycrank+714,    0,        0,    
  2497. Xyycrank+709,    0,        0,    
  2498. Xyycrank+709,    0,        0,    
  2499. Xyycrank+724,    0,        0,    
  2500. Xyycrank+727,    0,        0,    
  2501. Xyycrank+726,    0,        0,    
  2502. Xyycrank+0,    0,        yyvstop+309,
  2503. Xyycrank+0,    0,        yyvstop+311,
  2504. Xyycrank+695,    0,        0,    
  2505. Xyycrank+728,    0,        0,    
  2506. Xyycrank+725,    0,        0,    
  2507. Xyycrank+715,    0,        0,    
  2508. Xyycrank+733,    0,        0,    
  2509. Xyycrank+732,    0,        0,    
  2510. Xyycrank+731,    0,        0,    
  2511. Xyycrank+703,    0,        0,    
  2512. Xyycrank+0,    0,        yyvstop+313,
  2513. Xyycrank+736,    0,        0,    
  2514. Xyycrank+736,    0,        0,    
  2515. Xyycrank+722,    0,        0,    
  2516. Xyycrank+724,    0,        0,    
  2517. Xyycrank+735,    0,        0,    
  2518. Xyycrank+0,    0,        yyvstop+315,
  2519. Xyycrank+730,    0,        0,    
  2520. Xyycrank+728,    0,        0,    
  2521. Xyycrank+728,    0,        0,    
  2522. Xyycrank+0,    0,        yyvstop+317,
  2523. Xyycrank+733,    0,        0,    
  2524. Xyycrank+731,    0,        0,    
  2525. Xyycrank+731,    0,        0,    
  2526. Xyycrank+0,    0,        yyvstop+319,
  2527. Xyycrank+737,    0,        0,    
  2528. Xyycrank+733,    0,        0,    
  2529. Xyycrank+0,    0,        yyvstop+321,
  2530. Xyycrank+0,    0,        yyvstop+323,
  2531. Xyycrank+0,    0,        yyvstop+325,
  2532. X0,    0,    0};
  2533. Xstruct yywork *yytop = yycrank+816;
  2534. Xstruct yysvf *yybgin = yysvec+1;
  2535. Xchar yymatch[] = {
  2536. X00  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  2537. X01  ,011 ,012 ,01  ,01  ,01  ,01  ,01  ,
  2538. X01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  2539. X01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  2540. X040 ,01  ,'"' ,'#' ,01  ,01  ,01  ,01  ,
  2541. X01  ,01  ,01  ,'+' ,01  ,'+' ,'#' ,01  ,
  2542. X'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,
  2543. X'0' ,'0' ,01  ,01  ,01  ,01  ,01  ,01  ,
  2544. X01  ,'#' ,'#' ,'#' ,01  ,01  ,01  ,01  ,
  2545. X01  ,'#' ,01  ,'#' ,'#' ,01  ,01  ,01  ,
  2546. X'#' ,01  ,01  ,'#' ,01  ,01  ,01  ,'#' ,
  2547. X01  ,01  ,01  ,01  ,'#' ,01  ,01  ,01  ,
  2548. X01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  2549. X01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  2550. X01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  2551. X01  ,01  ,01  ,'#' ,'#' ,'#' ,01  ,01  ,
  2552. X0};
  2553. Xchar yyextra[] = {
  2554. X0,0,0,0,0,0,0,0,
  2555. X0,0,0,0,0,0,0,0,
  2556. X0,0,0,0,0,0,0,0,
  2557. X0,0,0,0,0,0,0,0,
  2558. X0,0,0,0,0,0,0,0,
  2559. X0,0,0,0,0,0,0,0,
  2560. X0,0,0,0,0,0,0,0,
  2561. X0,0,0,0,0,0,0,0,
  2562. X0,0,0,0,0,0,0,0,
  2563. X0,0,0,0,0,0,0,0,
  2564. X0,0,0,0,0,0,0,0,
  2565. X0,0,0,0,0,0,0,0,
  2566. X0,0,0,0,0,0,0,0,
  2567. X0};
  2568. X#ifndef lint
  2569. Xstatic    char ncform_sccsid[] = "@(#)ncform 1.6 88/02/08 SMI"; /* from S5R2 1.2 */
  2570. X#endif
  2571. X
  2572. Xint yylineno =1;
  2573. X# define YYU(x) x
  2574. X# define NLSTATE yyprevious=YYNEWLINE
  2575. Xchar yytext[YYLMAX];
  2576. Xstruct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
  2577. Xchar yysbuf[YYLMAX];
  2578. Xchar *yysptr = yysbuf;
  2579. Xint *yyfnd;
  2580. Xextern struct yysvf *yyestate;
  2581. Xint yyprevious = YYNEWLINE;
  2582. Xyylook(){
  2583. X    register struct yysvf *yystate, **lsp;
  2584. X    register struct yywork *yyt;
  2585. X    struct yysvf *yyz;
  2586. X    int yych, yyfirst;
  2587. X    struct yywork *yyr;
  2588. X# ifdef LEXDEBUG
  2589. X    int debug;
  2590. X# endif
  2591. X    char *yylastch;
  2592. X    /* start off machines */
  2593. X# ifdef LEXDEBUG
  2594. X    debug = 0;
  2595. X# endif
  2596. X    yyfirst=1;
  2597. X    if (!yymorfg)
  2598. X        yylastch = yytext;
  2599. X    else {
  2600. X        yymorfg=0;
  2601. X        yylastch = yytext+yyleng;
  2602. X        }
  2603. X    for(;;){
  2604. X        lsp = yylstate;
  2605. X        yyestate = yystate = yybgin;
  2606. X        if (yyprevious==YYNEWLINE) yystate++;
  2607. X        for (;;){
  2608. X# ifdef LEXDEBUG
  2609. X            if(debug)fprintf(yyout,"state %d\n",yystate-yysvec-1);
  2610. X# endif
  2611. X            yyt = yystate->yystoff;
  2612. X            if(yyt == yycrank && !yyfirst){  /* may not be any transitions */
  2613. X                yyz = yystate->yyother;
  2614. X                if(yyz == 0)break;
  2615. X                if(yyz->yystoff == yycrank)break;
  2616. X                }
  2617. X            *yylastch++ = yych = input();
  2618. X            yyfirst=0;
  2619. X        tryagain:
  2620. X# ifdef LEXDEBUG
  2621. X            if(debug){
  2622. X                fprintf(yyout,"char ");
  2623. X                allprint(yych);
  2624. X                putchar('\n');
  2625. X                }
  2626. X# endif
  2627. X            yyr = yyt;
  2628. X            if ( (int)yyt > (int)yycrank){
  2629. X                yyt = yyr + yych;
  2630. X                if (yyt <= yytop && yyt->verify+yysvec == yystate){
  2631. X                    if(yyt->advance+yysvec == YYLERR)    /* error transitions */
  2632. X                        {unput(*--yylastch);break;}
  2633. X                    *lsp++ = yystate = yyt->advance+yysvec;
  2634. X                    goto contin;
  2635. X                    }
  2636. X                }
  2637. X# ifdef YYOPTIM
  2638. X            else if((int)yyt < (int)yycrank) {        /* r < yycrank */
  2639. X                yyt = yyr = yycrank+(yycrank-yyt);
  2640. X# ifdef LEXDEBUG
  2641. X                if(debug)fprintf(yyout,"compressed state\n");
  2642. X# endif
  2643. X                yyt = yyt + yych;
  2644. X                if(yyt <= yytop && yyt->verify+yysvec == yystate){
  2645. X                    if(yyt->advance+yysvec == YYLERR)    /* error transitions */
  2646. X                        {unput(*--yylastch);break;}
  2647. X                    *lsp++ = yystate = yyt->advance+yysvec;
  2648. X                    goto contin;
  2649. X                    }
  2650. X                yyt = yyr + YYU(yymatch[yych]);
  2651. X# ifdef LEXDEBUG
  2652. X                if(debug){
  2653. X                    fprintf(yyout,"try fall back character ");
  2654. X                    allprint(YYU(yymatch[yych]));
  2655. X                    putchar('\n');
  2656. X                    }
  2657. X# endif
  2658. X                if(yyt <= yytop && yyt->verify+yysvec == yystate){
  2659. X                    if(yyt->advance+yysvec == YYLERR)    /* error transition */
  2660. X                        {unput(*--yylastch);break;}
  2661. X                    *lsp++ = yystate = yyt->advance+yysvec;
  2662. X                    goto contin;
  2663. X                    }
  2664. X                }
  2665. X            if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank){
  2666. X# ifdef LEXDEBUG
  2667. X                if(debug)fprintf(yyout,"fall back to state %d\n",yystate-yysvec-1);
  2668. X# endif
  2669. X                goto tryagain;
  2670. X                }
  2671. X# endif
  2672. X            else
  2673. X                {unput(*--yylastch);break;}
  2674. X        contin:
  2675. X# ifdef LEXDEBUG
  2676. X            if(debug){
  2677. X                fprintf(yyout,"state %d char ",yystate-yysvec-1);
  2678. X                allprint(yych);
  2679. X                putchar('\n');
  2680. X                }
  2681. X# endif
  2682. X            ;
  2683. X            }
  2684. X# ifdef LEXDEBUG
  2685. X        if(debug){
  2686. X            fprintf(yyout,"stopped at %d with ",*(lsp-1)-yysvec-1);
  2687. X            allprint(yych);
  2688. X            putchar('\n');
  2689. X            }
  2690. X# endif
  2691. X        while (lsp-- > yylstate){
  2692. X            *yylastch-- = 0;
  2693. X            if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0){
  2694. X                yyolsp = lsp;
  2695. X                if(yyextra[*yyfnd]){        /* must backup */
  2696. X                    while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate){
  2697. X                        lsp--;
  2698. X                        unput(*yylastch--);
  2699. X                        }
  2700. X                    }
  2701. X                yyprevious = YYU(*yylastch);
  2702. X                yylsp = lsp;
  2703. X                yyleng = yylastch-yytext+1;
  2704. X                yytext[yyleng] = 0;
  2705. X# ifdef LEXDEBUG
  2706. X                if(debug){
  2707. X                    fprintf(yyout,"\nmatch ");
  2708. X                    sprint(yytext);
  2709. X                    fprintf(yyout," action %d\n",*yyfnd);
  2710. X                    }
  2711. X# endif
  2712. X                return(*yyfnd++);
  2713. X                }
  2714. X            unput(*yylastch);
  2715. X            }
  2716. X        if (yytext[0] == 0  /* && feof(yyin) */)
  2717. X            {
  2718. X            yysptr=yysbuf;
  2719. X            return(0);
  2720. X            }
  2721. X        yyprevious = yytext[0] = input();
  2722. X        if (yyprevious>0)
  2723. X            output(yyprevious);
  2724. X        yylastch=yytext;
  2725. X# ifdef LEXDEBUG
  2726. X        if(debug)putchar('\n');
  2727. X# endif
  2728. X        }
  2729. X    }
  2730. Xyyback(p, m)
  2731. X    int *p;
  2732. X{
  2733. Xif (p==0) return(0);
  2734. Xwhile (*p)
  2735. X    {
  2736. X    if (*p++ == m)
  2737. X        return(1);
  2738. X    }
  2739. Xreturn(0);
  2740. X}
  2741. X    /* the following are only used in the lex library */
  2742. Xyyinput(){
  2743. X    return(input());
  2744. X    }
  2745. Xyyoutput(c)
  2746. X  int c; {
  2747. X    output(c);
  2748. X    }
  2749. Xyyunput(c)
  2750. X   int c; {
  2751. X    unput(c);
  2752. X    }
  2753. END_OF_FILE
  2754. if test 35705 -ne `wc -c <'sys/share/lev_lex.c'`; then
  2755.     echo shar: \"'sys/share/lev_lex.c'\" unpacked with wrong size!
  2756. fi
  2757. # end of 'sys/share/lev_lex.c'
  2758. fi
  2759. echo shar: End of archive 51 \(of 108\).
  2760. cp /dev/null ark51isdone
  2761. MISSING=""
  2762. for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 \
  2763. 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 \
  2764. 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 \
  2765. 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 \
  2766. 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 \
  2767. 101 102 103 104 105 106 107 108 ; do
  2768.     if test ! -f ark${I}isdone ; then
  2769.     MISSING="${MISSING} ${I}"
  2770.     fi
  2771. done
  2772. if test "${MISSING}" = "" ; then
  2773.     echo You have unpacked all 108 archives.
  2774.     echo "Now execute 'rebuild.sh'"
  2775.     rm -f ark10[0-8]isdone ark[1-9]isdone ark[1-9][0-9]isdone
  2776. else
  2777.     echo You still need to unpack the following archives:
  2778.     echo "        " ${MISSING}
  2779. fi
  2780. ##  End of shell archive.
  2781. exit 0
  2782.