| abstract
| - Below is the full text to lev_comp.c from the source code of NetHack 3.0.0. To link to a particular line, write [[NetHack 3.0.0/lev_comp.c#line123]], for example. Warning! This is the source code from an old release. For the latest release, see Source code 1. 2. # line 1 "lev_comp.y" 3. 4. /* SCCS Id: @(#)lev_comp.c 3.0 89/07/02 5. /* Copyright (c) 1989 by Jean-Christophe Collet */ 6. /* NetHack may be freely redistributed. See license for details. */ 7. 8. /* 9. * This file contains the Level Compiler code 10. * It may handle special mazes & special room-levels 11. */ 12. 13. /* block some unused #defines to avoid overloading some cpp's */ 14. #define MONDATA_H 15. #include "hack.h" 16. #include "sp_lev.h" 17. #include 18. 19. #ifdef AMIGA 20. char *fgets(); 21. # define alloc malloc 22. # undef fopen 23. # undef printf 24. # undef Printf 25. # define Printf printf 26. # define memset(addr,val,len) setmem(addr,len,val) 27. #endif 28. 29. #ifdef MSDOS 30. # undef exit 31. #endif 32. 33. #define MAX_REGISTERS 10 34. #define ERR (-1) 35. 36. struct reg { 37. int x1, y1; 38. int x2, y2; 39. } current_region; 40. 41. struct coord { 42. int x; 43. int y; 44. } current_coord; 45. 46. struct { 47. char *name; 48. short type; 49. } trap_types[TRAPNUM-1] = { 50. "monster", MONST_TRAP, 51. "statue", STATUE_TRAP, 52. "bear", BEAR_TRAP, 53. "arrow", ARROW_TRAP, 54. "dart", DART_TRAP, 55. "trapdoor", TRAPDOOR, 56. "teleport", TELEP_TRAP, 57. "pit", PIT, 58. "sleeping gas", SLP_GAS_TRAP, 59. "magic", MGTRP, 60. "board", SQBRD, 61. "web", WEB, 62. "spiked pit", SPIKED_PIT, 63. "level teleport",LEVEL_TELEP, 64. #ifdef SPELLS 65. "anti magic", ANTI_MAGIC, 66. #endif 67. "rust", RUST_TRAP 68. #ifdef POLYSELF 69. , "polymorph", POLY_TRAP 70. #endif 71. #ifdef ARMY 72. , "land mine", LANDMINE 73. #endif 74. }; 75. 76. struct { 77. char *name; 78. int type; 79. } room_types[SHOPBASE-1] = { 80. /* for historical reasons, room types are not contiguous numbers */ 81. /* (type 1 is skipped) */ 82. "ordinary", OROOM, 83. #ifdef THRONES 84. "throne", COURT, 85. #endif 86. "swamp", SWAMP, 87. "vault", VAULT, 88. "beehive", BEEHIVE, 89. "morgue", MORGUE, 90. #ifdef ARMY 91. "barracks", BARRACKS, 92. #endif 93. "zoo", ZOO, 94. "temple", TEMPLE, 95. "shop", SHOPBASE, 96. }; 97. 98. short db_dirs[4] = { 99. DB_NORTH, 100. DB_EAST, 101. DB_SOUTH, 102. DB_WEST 103. }; 104. 105. #ifdef ALTARS 106. static altar *tmpaltar[256]; 107. #endif /* ALTARS /**/ 108. static lad *tmplad[256]; 109. static dig *tmpdig[256]; 110. static char *tmpmap[ROWNO]; 111. static region *tmpreg[16]; 112. static door *tmpdoor[256]; 113. static trap *tmptrap[256]; 114. static monster *tmpmonst[256]; 115. static object *tmpobj[256]; 116. static drawbridge *tmpdb[256]; 117. static walk *tmpwalk[256]; 118. static mazepart *tmppart[10]; 119. static room *tmproom[MAXNROFROOMS]; 120. static specialmaze maze; 121. 122. static char olist[MAX_REGISTERS], mlist[MAX_REGISTERS]; 123. static struct coord plist[MAX_REGISTERS]; 124. static int n_olist = 0, n_mlist = 0, n_plist = 0; 125. 126. unsigned int nreg = 0, ndoor = 0, ntrap = 0, nmons = 0, nobj = 0; 127. unsigned int ndb = 0, nwalk = 0, npart = 0, ndig = 0, nlad = 0; 128. #ifdef ALTARS 129. unsigned int naltar = 0; 130. #endif /* ALTARS /*/ 131. 132. unsigned int max_x_map, max_y_map; 133. 134. extern int fatal_error; 135. extern char* fname; 136. 137. boolean check_monster_char(), check_object_char(); 138. void scan_map(), store_part(), write_maze(); 139. 140. 141. # line 140 "lev_comp.y" 142. typedef union 143. { 144. int i; 145. char* map; 146. } YYSTYPE; 147. # define CHAR 257 148. # define INTEGER 258 149. # define MAZE_ID 259 150. # define LEVEL_ID 260 151. # define GEOMETRY_ID 261 152. # define OBJECT_ID 262 153. # define MONSTER_ID 263 154. # define TRAP_ID 264 155. # define DOOR_ID 265 156. # define DRAWBRIDGE_ID 266 157. # define MAZEWALK_ID 267 158. # define REGION_ID 268 159. # define RANDOM_OBJECTS_ID 269 160. # define RANDOM_MONSTERS_ID 270 161. # define RANDOM_PLACES_ID 271 162. # define ALTAR_ID 272 163. # define LADDER_ID 273 164. # define NON_DIGGABLE_ID 274 165. # define ROOM_ID 275 166. # define DOOR_STATE 276 167. # define LIGHT_STATE 277 168. # define DIRECTION 278 169. # define RANDOM_TYPE 279 170. # define O_REGISTER 280 171. # define M_REGISTER 281 172. # define P_REGISTER 282 173. # define A_REGISTER 283 174. # define ALIGNMENT 284 175. # define LEFT_OR_RIGHT 285 176. # define CENTER 286 177. # define TOP_OR_BOT 287 178. # define ALTAR_TYPE 288 179. # define UP_OR_DOWN 289 180. # define STRING 290 181. # define MAP_ID 291 182. #define yyclearin yychar = -1 183. #define yyerrok yyerrflag = 0 184. extern int yychar; 185. extern short yyerrflag; 186. #ifndef YYMAXDEPTH 187. #define YYMAXDEPTH 150 188. #endif 189. YYSTYPE yylval, yyval; 190. # define YYERRCODE 256 191. 192. # line 617 "lev_comp.y" 193. 194. 195. /* 196. * Find the type of a room in the table, knowing its name. 197. */ 198. 199. int 200. get_room_type(s) 201. char *s; 202. { 203. register int i; 204. 205. for(i=0; i < SHOPBASE -1; i++) 206. if (!strcmp(s, room_types[i].name)) 207. return room_types[i].type; 208. return ERR; 209. } 210. 211. /* 212. * Find the type of a trap in the table, knowing its name. 213. */ 214. 215. int 216. get_trap_type(s) 217. char *s; 218. { 219. register int i; 220. 221. for(i=0; i < TRAPNUM - 1; i++) 222. if(!strcmp(s,trap_types[i].name)) 223. return(trap_types[i].type); 224. return ERR; 225. } 226. 227. /* 228. * Find the index of a monster in the table, knowing its name. 229. */ 230. 231. int 232. get_monster_id(s, c) 233. char *s; 234. char c; 235. { 236. register int i; 237. 238. for(i=0; mons[i].mname[0]; i++) 239. if(!strncmp(s, mons[i].mname, strlen(mons[i].mname)) 240. && c == mons[i].mlet) 241. return i; 242. return ERR; 243. } 244. 245. /* 246. * Find the index of an object in the table, knowing its name. 247. */ 248. 249. int 250. get_object_id(s, c) 251. char *s; 252. char c; 253. { 254. register int i; 255. 256. for(i=0; i<=NROFOBJECTS;i++) 257. if(objects[i].oc_name && 258. !strncmp(s, objects[i].oc_name, strlen(objects[i].oc_name)) 259. && c == objects[i].oc_olet) 260. return i; 261. return ERR; 262. } 263. 264. /* 265. * Is the character 'c' a valid monster class ? 266. */ 267. 268. boolean 269. check_monster_char(c) 270. char c; 271. { 272. register int i; 273. 274. for(i=0; mons[i].mname[0]; i++) 275. if( c == mons[i].mlet) 276. return 1; 277. return(0); 278. } 279. 280. /* 281. * Is the character 'c' a valid object class ? 282. */ 283. 284. boolean 285. check_object_char(c) 286. char c; 287. { 288. register int i; 289. 290. for(i=0; i<=NROFOBJECTS;i++) 291. if( c == objects[i].oc_olet) 292. return 1; 293. return 0; 294. } 295. 296. /* 297. * Yep! LEX gives us the map in a raw mode. 298. * Just analyze it here. 299. */ 300. 301. void scan_map(map) 302. char *map; 303. { 304. register int i, len; 305. register char *s1, *s2; 306. int max_len = 0; 307. int max_hig = 0; 308. 309. /* First : find the max width of the map */ 310. 311. s1 = map; 312. while (s1 && *s1) { 313. s2 = index(s1, '
'); 314. if (s2) { 315. if (s2-s1 > max_len) 316. max_len = s2-s1; 317. s1 = s2 + 1; 318. } else { 319. if (strlen(s1) > max_len) 320. max_len = strlen(s1); 321. s1 = (char *) 0; 322. } 323. } 324. 325. /* Then parse it now */ 326. 327. while (map && *map) { 328. tmpmap[max_hig] = (char *) alloc(max_len); 329. s1 = index(map, '
'); 330. if (s1) { 331. len = s1 - map; 332. s1++; 333. } else { 334. len = strlen(map); 335. s1 = map + len; 336. } 337. for(i=0; i 338. switch(map[i]) { 339. case '-' : tmpmap[max_hig][i] = HWALL; break; 340. case '|' : tmpmap[max_hig][i] = VWALL; break; 341. case '+' : tmpmap[max_hig][i] = DOOR; break; 342. case 'S' : tmpmap[max_hig][i] = SDOOR; break; 343. case '{' : 344. #ifdef FOUNTAINS 345. tmpmap[max_hig][i] = FOUNTAIN; 346. #else 347. tmpmap[max_hig][i] = ROOM; 348. yywarning("Fountains are not allowed in this version! Ignoring..."); 349. #endif 350. break; 351. case '\\' : 352. #ifdef THRONES 353. tmpmap[max_hig][i] = THRONE; 354. #else 355. tmpmap[max_hig][i] = ROOM; 356. yywarning("Thrones are not allowed in this version! Ignoring..."); 357. #endif 358. break; 359. case 'K' : 360. #ifdef SINKS 361. tmpmap[max_hig][i] = SINK; 362. #else 363. tmpmap[max_hig][i] = ROOM; 364. yywarning("Sinks are not allowed in this version! Ignoring..."); 365. #endif 366. break; 367. case '}' : tmpmap[max_hig][i] = MOAT; break; 368. case '#' : tmpmap[max_hig][i] = CORR; break; 369. default : tmpmap[max_hig][i] = ROOM; break; 370. } 371. while(i < max_len) 372. tmpmap[max_hig][i++] = ROOM; 373. map = s1; 374. max_hig++; 375. } 376. 377. /* Memorize boundaries */ 378. 379. max_x_map = max_len - 1; 380. max_y_map = max_hig - 1; 381. 382. /* Store the map into the mazepart structure */ 383. 384. tmppart[npart]->xsize = max_len; 385. tmppart[npart]->ysize = max_hig; 386. tmppart[npart]->map = (char **) alloc(max_hig*sizeof(char *)); 387. for(i = 0; i< max_hig; i++) 388. tmppart[npart]->map[i] = tmpmap[i]; 389. } 390. 391. /* 392. * Here we want to store the maze part we just got. 393. */ 394. 395. void 396. store_part() 397. { 398. register int i; 399. 400. /* Ok, We got the whole part, now we store it. */ 401. 402. /* The Regions */ 403. 404. if(tmppart[npart]->nreg = nreg) { 405. tmppart[npart]->regions = (region**)alloc(sizeof(region*) * nreg); 406. for(i=0;i 407. tmppart[npart]->regions[i] = tmpreg[i]; 408. } 409. nreg = 0; 410. 411. /* the doors */ 412. 413. if(tmppart[npart]->ndoor = ndoor) { 414. tmppart[npart]->doors = (door **)alloc(sizeof(door *) * ndoor); 415. for(i=0;i 416. tmppart[npart]->doors[i] = tmpdoor[i]; 417. } 418. ndoor = 0; 419. 420. /* the traps */ 421. 422. if(tmppart[npart]->ntraps = ntrap) { 423. tmppart[npart]->traps = (trap **)alloc(sizeof(trap*) * ntrap); 424. for(i=0;i 425. tmppart[npart]->traps[i] = tmptrap[i]; 426. } 427. ntrap = 0; 428. 429. /* the monsters */ 430. 431. if(tmppart[npart]->nmonster = nmons) { 432. tmppart[npart]->monsters = (monster**)alloc(sizeof(monster*)*nmons); 433. for(i=0;i 434. tmppart[npart]->monsters[i] = tmpmonst[i]; 435. } 436. nmons = 0; 437. 438. /* the objects */ 439. 440. if(tmppart[npart]->nobjects = nobj) { 441. tmppart[npart]->objects = (object**)alloc(sizeof(object*)*nobj); 442. for(i=0;i 443. tmppart[npart]->objects[i] = tmpobj[i]; 444. } 445. nobj = 0; 446. 447. /* the drawbridges */ 448. 449. if(tmppart[npart]->ndrawbridge = ndb) { 450. tmppart[npart]->drawbridges = (drawbridge**)alloc(sizeof(drawbridge*)*ndb); 451. for(i=0;i 452. tmppart[npart]->drawbridges[i] = tmpdb[i]; 453. } 454. ndb = 0; 455. 456. /* The walkmaze directives */ 457. 458. if(tmppart[npart]->nwalk = nwalk) { 459. tmppart[npart]->walks = (walk**)alloc(sizeof(walk*)*nwalk); 460. for(i=0;i 461. tmppart[npart]->walks[i] = tmpwalk[i]; 462. } 463. nwalk = 0; 464. 465. /* The non_diggable directives */ 466. 467. if(tmppart[npart]->ndig = ndig) { 468. tmppart[npart]->digs = (dig **) alloc(sizeof(dig*) * ndig); 469. for(i=0;i 470. tmppart[npart]->digs[i] = tmpdig[i]; 471. } 472. ndig = 0; 473. 474. /* The ladders */ 475. 476. if(tmppart[npart]->nlad = nlad) { 477. tmppart[npart]->lads = (lad **) alloc(sizeof(lad*) * nlad); 478. for(i=0;i 479. tmppart[npart]->lads[i] = tmplad[i]; 480. } 481. nlad = 0; 482. #ifdef ALTARS 483. /* The altars */ 484. 485. if(tmppart[npart]->naltar = naltar) { 486. tmppart[npart]->altars = (altar**)alloc(sizeof(altar*) * naltar); 487. for(i=0;i 488. tmppart[npart]->altars[i] = tmpaltar[i]; 489. } 490. naltar = 0; 491. #endif /* ALTARS /**/ 492. npart++; 493. n_plist = n_mlist = n_olist = 0; 494. } 495. 496. /* 497. * Here we write the structure of the maze in the specified file (fd). 498. * Also, we have to free the memory allocated via alloc() 499. */ 500. 501. void 502. write_maze(fd, maze) 503. int fd; 504. specialmaze *maze; 505. { 506. char c; 507. short i,j; 508. mazepart *pt; 509. 510. c = 2; 511. (void) write(fd, &c, 1); /* Header for special mazes */ 512. (void) write(fd, &(maze->numpart), 1); /* Number of parts */ 513. for(i=0;inumpart;i++) { 514. pt = maze->parts[i]; 515. 516. /* First, write the map */ 517. 518. (void) write(fd, &(pt->halign), 1); 519. (void) write(fd, &(pt->valign), 1); 520. (void) write(fd, &(pt->xsize), 1); 521. (void) write(fd, &(pt->ysize), 1); 523. (void) write(fd, pt->map[j], pt->xsize); 524. free(pt->map[j]); 525. } 526. free(pt->map); 527. 528. /* The random registers */ 529. (void) write(fd, &(pt->nrobjects), 1); 530. if(pt->nrobjects) { 531. (void) write(fd, pt->robjects, pt->nrobjects); 532. free(pt->robjects); 533. } 534. (void) write(fd, &(pt->nloc), 1); 535. if(pt->nloc) { 536. (void) write(fd,pt->rloc_x, pt->nloc); 537. (void) write(fd,pt->rloc_y, pt->nloc); 538. free(pt->rloc_x); 539. free(pt->rloc_y); 540. } 541. (void) write(fd,&(pt->nrmonst), 1); 542. if(pt->nrmonst) { 543. (void) write(fd, pt->rmonst, pt->nrmonst); 544. free(pt->rmonst); 545. } 546. 547. /* subrooms */ 548. (void) write(fd, &(pt->nreg), 1); 550. (void) write(fd,(genericptr_t) pt->regions[j], sizeof(region)); 551. free(pt->regions[j]); 552. } 553. if(pt->nreg > 0) 554. free(pt->regions); 555. 556. /* the doors */ 557. (void) write(fd,&(pt->ndoor),1); 559. (void) write(fd,(genericptr_t) pt->doors[j], sizeof(door)); 560. free(pt->doors[j]); 561. } 562. if (pt->ndoor > 0) 563. free(pt->doors); 564. 565. /* The traps */ 566. (void) write(fd,&(pt->ntraps), 1); 568. (void) write(fd,(genericptr_t) pt->traps[j], sizeof(trap)); 569. free(pt->traps[j]); 570. } 571. if (pt->ntraps) 572. free(pt->traps); 573. 574. /* The monsters */ 575. (void) write(fd, &(pt->nmonster), 1); 577. (void) write(fd,(genericptr_t) pt->monsters[j], sizeof(monster)); 578. free(pt->monsters[j]); 579. } 580. if (pt->nmonster > 0) 581. free(pt->monsters); 582. 583. /* The objects */ 584. (void) write(fd, &(pt->nobjects), 1); 586. (void) write(fd,(genericptr_t) pt->objects[j], sizeof(object)); 587. free(pt->objects[j]); 588. } 589. if(pt->nobjects > 0) 590. free(pt->objects); 591. 592. /* The drawbridges */ 593. (void) write(fd, &(pt->ndrawbridge),1); 595. (void) write(fd,(genericptr_t) pt->drawbridges[j], sizeof(drawbridge)); 596. free(pt->drawbridges[j]); 597. } 598. if(pt->ndrawbridge > 0) 599. free(pt->drawbridges); 600. 601. /* The mazewalk directives */ 602. (void) write(fd, &(pt->nwalk), 1); 604. (void) write(fd,(genericptr_t) pt->walks[j], sizeof(walk)); 605. free(pt->walks[j]); 606. } 607. if (pt->nwalk > 0) 608. free(pt->walks); 609. 610. /* The non_diggable directives */ 611. (void) write(fd, &(pt->ndig), 1); 613. (void) write(fd,(genericptr_t) pt->digs[j], sizeof(dig)); 614. free(pt->digs[j]); 615. } 616. if (pt->ndig > 0) 617. free(pt->digs); 618. 619. /* The ladders */ 620. (void) write(fd, &(pt->nlad), 1); 622. (void) write(fd,(genericptr_t) pt->lads[j], sizeof(lad)); 623. free(pt->lads[j]); 624. } 625. if (pt->nlad > 0) 626. free(pt->lads); 627. #ifdef ALTARS 628. /* The altars */ 629. (void) write(fd, &(pt->naltar), 1); 631. (void) write(fd,(genericptr_t) pt->altars[j], sizeof(altar)); 632. free(pt->altars[j]); 633. } 634. if (pt->naltar > 0) 635. free(pt->altars); 636. #endif /* ALTARS /**/ 637. free(pt); 638. } 639. } 640. short yyexca[] ={ 641. -1, 1, 642. 0, -1, 643. -2, 0, 644. }; 645. # define YYNPROD 86 646. # define YYLAST 251 647. short yyact[]={ 648. 649. 164, 130, 126, 91, 16, 19, 168, 146, 69, 72, 650. 145, 19, 19, 19, 19, 167, 75, 74, 26, 27, 651. 143, 137, 12, 138, 144, 141, 65, 87, 134, 6, 652. 88, 78, 173, 80, 40, 39, 42, 41, 43, 46, 653. 44, 170, 169, 155, 45, 47, 48, 147, 83, 85, 654. 22, 24, 23, 135, 131, 127, 116, 105, 72, 65, 655. 18, 92, 71, 86, 171, 153, 67, 93, 151, 149, 656. 157, 64, 114, 110, 108, 97, 62, 61, 60, 59, 657. 58, 57, 56, 55, 54, 53, 51, 50, 49, 17, 658. 13, 172, 165, 156, 154, 152, 150, 148, 139, 122, 659. 119, 118, 117, 115, 113, 112, 111, 109, 107, 106, 660. 104, 103, 52, 174, 158, 69, 77, 90, 68, 98, 661. 9, 99, 100, 101, 3, 142, 82, 7, 94, 14, 662. 84, 79, 166, 140, 162, 136, 89, 81, 102, 76, 663. 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 664. 28, 70, 66, 63, 21, 73, 25, 11, 20, 15, 665. 10, 8, 4, 2, 1, 128, 124, 5, 125, 123, 666. 129, 121, 68, 132, 133, 120, 0, 0, 0, 0, 667. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 668. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 669. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 670. 159, 0, 160, 0, 0, 163, 161, 0, 0, 0, 671. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 672. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 673. 0, 0, 0, 0, 0, 0, 0, 95, 0, 0, 674. 96 }; 675. short yypact[]={ 676. 677. -230,-1000,-230,-1000,-1000,-239, 32,-1000,-239,-1000, 678. -1000,-287, 31,-285,-1000,-219,-1000,-267,-1000,-1000, 679. -228,-1000, 30, 29, 28, 68,-1000,-1000,-1000,-1000, 680. -1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000, 27, 681. 26, 25, 24, 23, 22, 21, 20, 19, 18,-198, 682. 75,-199,-270,-248,-231,-249,-276, -32, 79, -32, 683. -32, -32, 79, 67,-1000,-1000, 66,-1000,-1000,-201, 684. 65,-1000,-1000,-1000,-1000,-1000, 64,-1000,-1000,-1000, 685. -17, 63,-1000,-1000,-1000, -18, 62,-1000,-1000, 61, 686. -1000,-1000, 60,-1000,-1000,-1000, -19, 59,-202, 58, 687. 57, 56,-1000,-198, 75, 55,-199,-277,-203,-278, 688. -204, -32, -32,-250,-205,-256, 54,-259,-268,-282, 689. -1000,-1000,-211,-1000, 53,-1000,-1000, -24, 52,-1000, 690. -1000, -25,-1000,-1000, 51, -28, 50,-1000,-1000,-215, 691. 49,-1000,-1000,-1000, -21,-1000,-1000, 73, -32,-1000, 692. -32,-1000,-249,-1000,-279, 48,-273,-216,-1000,-1000, 693. -1000,-1000,-1000,-1000,-1000,-217,-1000,-1000,-1000, -29, 694. 47,-1000,-226, 72,-1000 }; 695. short yypgo[]={ 696. 697. 0, 60, 167, 166, 165, 164, 163, 124, 162, 161, 698. 120, 160, 159, 158, 157, 156, 155, 154, 153, 152, 699. 151, 71, 62, 66, 150, 149, 148, 147, 146, 145, 700. 144, 143, 142, 141, 140, 139, 61, 137, 63, 136, 701. 75, 135, 134, 133, 132, 131, 130, 67, 128, 125 }; 702. short yyr1[]={ 703. 704. 0, 5, 5, 6, 6, 7, 8, 2, 9, 9, 705. 10, 11, 14, 15, 15, 16, 16, 12, 12, 17, 706. 17, 17, 18, 18, 20, 20, 19, 19, 13, 13, 707. 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 708. 25, 26, 27, 28, 29, 32, 33, 34, 30, 31, 709. 35, 35, 35, 37, 37, 37, 3, 3, 4, 4, 710. 39, 39, 42, 42, 36, 36, 36, 38, 38, 41, 711. 41, 43, 43, 43, 44, 44, 48, 46, 45, 49, 712. 23, 22, 21, 1, 47, 40 }; 713. short yyr2[]={ 714. 715. 0, 0, 1, 1, 2, 1, 2, 3, 1, 2, 716. 3, 2, 5, 1, 1, 1, 1, 0, 2, 3, 717. 3, 3, 1, 3, 1, 3, 1, 3, 0, 2, 718. 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 719. 7, 7, 5, 5, 7, 5, 5, 3, 7, 7, 720. 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 721. 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 722. 1, 1, 1, 1, 1, 1, 4, 4, 4, 4, 723. 1, 1, 1, 1, 5, 9 }; 724. short yychk[]={ 725. 726. -1000, -5, -6, -7, -8, -2, 259, -7, -9, -10, 727. -11, -14, 261, 58, -10, -12, 291, 58, -1, 290, 728. -13, -17, 269, 271, 270, -15, 285, 286, -24, -25, 729. -26, -27, -28, -29, -30, -31, -32, -33, -34, 263, 730. 262, 265, 264, 266, 268, 272, 267, 273, 274, 58, 731. 58, 58, 44, 58, 58, 58, 58, 58, 58, 58, 732. 58, 58, 58, -18, -21, 257, -19, -23, -47, 40, 733. -20, -22, 257, -16, 287, 286, -35, -22, 279, -45, 734. 281, -37, -21, 279, -46, 280, -38, 276, 279, -39, 735. -1, 279, -36, -47, -48, 279, 282, -40, 40, -36, 736. -36, -36, -40, 44, 44, 258, 44, 44, 91, 44, 737. 91, 44, 44, 44, 91, 44, 258, 44, 44, 44, 738. -21, -23, 44, -22, -3, -1, 279, 258, -4, -1, 739. 279, 258, -36, -36, 278, 258, -41, 277, 279, 44, 740. -43, 284, -49, 279, 283, 278, 289, 258, 44, 93, 741. 44, 93, 44, 93, 44, 258, 44, 91, 41, -36, 742. -36, -38, -42, -1, 279, 44, -44, 288, 279, 258, 743. 258, 93, 44, 258, 41 }; 744. short yydef[]={ 745. 746. 1, -2, 2, 3, 5, 0, 0, 4, 6, 8, 747. 17, 0, 0, 0, 9, 28, 11, 0, 7, 83, 748. 10, 18, 0, 0, 0, 0, 13, 14, 29, 30, 749. 31, 32, 33, 34, 35, 36, 37, 38, 39, 0, 750. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 751. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 752. 0, 0, 0, 19, 22, 82, 20, 26, 80, 0, 753. 21, 24, 81, 12, 15, 16, 0, 50, 51, 52, 754. 0, 0, 53, 54, 55, 0, 0, 67, 68, 0, 755. 60, 61, 0, 64, 65, 66, 0, 0, 0, 0, 756. 0, 0, 47, 0, 0, 0, 0, 0, 0, 0, 757. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 758. 23, 27, 0, 25, 0, 56, 57, 0, 0, 58, 759. 59, 0, 42, 43, 0, 0, 0, 69, 70, 0, 760. 0, 71, 72, 73, 0, 45, 46, 0, 0, 78, 761. 0, 77, 0, 76, 0, 0, 0, 0, 84, 40, 762. 41, 44, 48, 62, 63, 0, 49, 74, 75, 0, 763. 0, 79, 0, 0, 85 }; 764. #ifndef lint 765. static char yaccpar_sccsid[] = "@(#)yaccpar 4.1 (Berkeley) 2/11/83"; 766. #endif not lint 767. 768. # 769. # define YYFLAG -1000 770. # define YYERROR goto yyerrlab 771. # define YYACCEPT return(0) 772. # define YYABORT return(1) 773. 774. /* parser for yacc output */ 775. 776. #ifdef YYDEBUG 777. int yydebug = 0; /* 1 for debugging */ 778. #endif 779. YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */ 780. int yychar = -1; /* current input token number */ 781. int yynerrs = 0; /* number of errors */ 782. short yyerrflag = 0; /* error recovery flag */ 783. 784. yyparse() { 785. 786. short yys[YYMAXDEPTH]; 787. short yyj, yym; 788. register YYSTYPE *yypvt; 789. register short yystate, *yyps, yyn; 790. register YYSTYPE *yypv; 791. register short *yyxi; 792. 793. yystate = 0; 794. yychar = -1; 795. yynerrs = 0; 796. yyerrflag = 0; 797. yyps= &yys[-1]; 798. yypv= &yyv[-1]; 799. 800. yystack: /* put a state and value onto the stack */ 801. 802. #ifdef YYDEBUG 803. if( yydebug ) printf( "state %d, char 0%o
", yystate, yychar ); 804. #endif 805. if( ++yyps> &yys[YYMAXDEPTH] ) { yyerror( "yacc stack overflow" ); return(1); } 806. *yyps = yystate; 807. ++yypv; 808. *yypv = yyval; 809. 810. yynewstate: 811. 812. yyn = yypact[yystate]; 813. 814. if( yyn<= YYFLAG ) goto yydefault; /* simple state */ 815. 816. if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0; 817. if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault; 818. 819. if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */ 820. yychar = -1; 821. yyval = yylval; 822. yystate = yyn; 823. if( yyerrflag > 0 ) --yyerrflag; 824. goto yystack; 825. } 826. 827. yydefault: 828. /* default state action */ 829. 830. if( (yyn=yydef[yystate]) == -2 ) { 831. if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0; 832. /* look through exception table */ 833. 834. for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */ 835. 836. while( *(yyxi+=2) >= 0 ){ 837. if( *yyxi == yychar ) break; 838. } 839. if( (yyn = yyxi[1]) < 0 ) return(0); /* accept */ 840. } 841. 842. if( yyn == 0 ){ /* error */ 843. /* error ... attempt to resume parsing */ 844. 845. switch( yyerrflag ){ 846. 847. case 0: /* brand new error */ 848. 849. yyerror( "syntax error" ); 850. yyerrlab: 851. ++yynerrs; 852. 853. case 1: 854. case 2: /* incompletely recovered error ... try again */ 855. 856. yyerrflag = 3; 857. 858. /* find a state where "error" is a legal shift action */ 859. 860. while ( yyps >= yys ) { 861. yyn = yypact[*yyps] + YYERRCODE; 862. if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){ 863. yystate = yyact[yyn]; /* simulate a shift of "error" */ 864. goto yystack; 865. } 866. yyn = yypact[*yyps]; 867. 868. /* the current yyps has no shift onn "error", pop stack */ 869. 870. #ifdef YYDEBUG 871. if( yydebug ) printf( "error recovery pops state %d, uncovers %d
", *yyps, yyps[-1] ); 872. #endif 873. --yyps; 874. --yypv; 875. } 876. 877. /* there is no state on the stack with an error shift ... abort */ 878. 879. yyabort: 880. return(1); 881. 882. 883. case 3: /* no shift yet; clobber input char */ 884. 885. #ifdef YYDEBUG 886. if( yydebug ) printf( "error recovery discards char %d
", yychar ); 887. #endif 888. 889. if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */ 890. yychar = -1; 891. goto yynewstate; /* try again in the same state */ 892. 893. } 894. 895. } 896. 897. /* reduction by production yyn */ 898. 899. #ifdef YYDEBUG 900. if( yydebug ) printf("reduce %d
",yyn); 901. #endif 902. yyps -= yyr2[yyn]; 903. yypvt = yypv; 904. yypv -= yyr2[yyn]; 905. yyval = yypv[1]; 906. yym=yyn; 907. /* consult goto table to find next state */ 908. yyn = yyr1[yyn]; 909. yyj = yypgo[yyn] + *yyps + 1; 910. if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]]; 911. switch(yym){ 912. 913. case 6: 914. # line 170 "lev_comp.y" 915. { 916. int fout, i; 917. 918. if (fatal_error > 0) 919. fprintf(stderr,"%s : %d errors detected. No output created!
", fname, fatal_error); 920. else { 921. fout = open(yypvt[-1].map, O_WRONLY | O_CREAT 922. #ifdef MSDOS 923. | O_BINARY 924. #endif /* MSDOS */ 925. , 0644); 926. if (fout < 0) { 927. yyerror("Can't open output file!!"); 928. exit(1); 929. } 930. maze.numpart = npart; 931. maze.parts = (mazepart**) alloc(sizeof(mazepart*)*npart); 932. for(i=0;i 933. maze.parts[i] = tmppart[i]; 934. write_maze(fout, &maze); 935. (void) close(fout); 936. npart = 0; 937. } 938. } break; 939. case 7: 940. # line 196 "lev_comp.y" 941. { 942. yyval.map = yypvt[-0].map; 943. } break; 944. case 10: 945. # line 204 "lev_comp.y" 946. { 947. store_part(); 948. } break; 949. case 11: 950. # line 209 "lev_comp.y" 951. { 952. tmppart[npart] = (mazepart *) alloc(sizeof(mazepart)); 953. tmppart[npart]->halign = yypvt[-1].i % 10; 954. tmppart[npart]->valign = yypvt[-1].i / 10; 955. tmppart[npart]->nrobjects = 0; 956. tmppart[npart]->nloc = 0; 957. tmppart[npart]->nrmonst = 0; 958. scan_map(yypvt[-0].map); 959. } break; 960. case 12: 961. # line 220 "lev_comp.y" 962. { 963. yyval.i = yypvt[-2].i + ( yypvt[-0].i * 10 ); 964. } break; 965. case 19: 966. # line 234 "lev_comp.y" 967. { 968. if (tmppart[npart]->nrobjects) 969. yyerror("Object registers already initialized!"); 970. else { 971. tmppart[npart]->robjects = (char *) alloc(n_olist); 972. memcpy(tmppart[npart]->robjects, olist, n_olist); 973. tmppart[npart]->nrobjects = n_olist; 974. } 975. } break; 976. case 20: 977. # line 244 "lev_comp.y" 978. { 979. if (tmppart[npart]->nloc) 980. yyerror("Location registers already initialized!"); 981. else { 982. register int i; 983. tmppart[npart]->rloc_x = (char *) alloc(n_plist); 984. tmppart[npart]->rloc_y = (char *) alloc(n_plist); 985. for(i=0;i 986. tmppart[npart]->rloc_x[i] = plist[i].x; 987. tmppart[npart]->rloc_y[i] = plist[i].y; 988. } 989. tmppart[npart]->nloc = n_plist; 990. } 991. } break; 992. case 21: 993. # line 259 "lev_comp.y" 994. { 995. if (tmppart[npart]->nrmonst) 996. yyerror("Monster registers already initialized!"); 997. else { 998. tmppart[npart]->rmonst = (char *) alloc(n_mlist); 999. memcpy(tmppart[npart]->rmonst, mlist, n_mlist); 1000. tmppart[npart]->nrmonst = n_mlist; 1001. } 1002. } break; 1003. case 22: 1004. # line 270 "lev_comp.y" 1005. { 1006. if (n_olist < MAX_REGISTERS) 1007. olist[n_olist++] = yypvt[-0].i; 1008. else 1009. yyerror("Object list too long!"); 1010. } break; 1011. case 23: 1012. # line 277 "lev_comp.y" 1013. { 1014. if (n_olist < MAX_REGISTERS) 1015. olist[n_olist++] = yypvt[-0].i; 1016. else 1017. yyerror("Object list too long!"); 1018. } break; 1019. case 24: 1020. # line 285 "lev_comp.y" 1021. { 1022. if (n_mlist < MAX_REGISTERS) 1023. mlist[n_mlist++] = yypvt[-0].i; 1024. else 1025. yyerror("Monster list too long!"); 1026. } break; 1027. case 25: 1028. # line 292 "lev_comp.y" 1029. { 1030. if (n_mlist < MAX_REGISTERS) 1031. mlist[n_mlist++] = yypvt[-0].i; 1032. else 1033. yyerror("Monster list too long!"); 1034. } break; 1035. case 26: 1036. # line 300 "lev_comp.y" 1037. { 1038. if (n_plist < MAX_REGISTERS) 1039. plist[n_plist++] = current_coord; 1040. else 1041. yyerror("Location list too long!"); 1042. } break; 1043. case 27: 1044. # line 307 "lev_comp.y" 1045. { 1046. if (n_plist < MAX_REGISTERS) 1047. plist[n_plist++] = current_coord; 1048. else 1049. yyerror("Location list too long!"); 1050. } break; 1051. case 40: 1052. # line 329 "lev_comp.y" 1053. { 1054. int token; 1055. 1056. tmpmonst[nmons] = (monster *) alloc(sizeof(monster)); 1057. tmpmonst[nmons]->x = current_coord.x; 1058. tmpmonst[nmons]->y = current_coord.y; 1059. tmpmonst[nmons]->class = yypvt[-4].i; 1060. if (!yypvt[-2].map) 1061. tmpmonst[nmons]->id = -1; 1062. else { 1063. token = get_monster_id(yypvt[-2].map, (char) yypvt[-4].i); 1064. if (token == ERR) { 1065. yywarning("Illegal monster name! Making random monster."); 1066. tmpmonst[nmons]->id = -1; 1067. } else 1068. tmpmonst[nmons]->id = token; 1069. } 1070. nmons++; 1071. } break; 1072. case 41: 1073. # line 350 "lev_comp.y" 1074. { 1075. int token; 1076. 1077. tmpobj[nobj] = (object *) alloc(sizeof(object)); 1078. tmpobj[nobj]->x = current_coord.x; 1079. tmpobj[nobj]->y = current_coord.y; 1080. tmpobj[nobj]->class = yypvt[-4].i; 1081. if (!yypvt[-2].map) 1082. tmpobj[nobj]->id = -1; 1083. else { 1084. token = get_object_id(yypvt[-2].map, (char) yypvt[-4].i); 1085. if (token == ERR) { 1086. yywarning("Illegal object name! Making random object."); 1087. tmpobj[nobj]->id = -1; 1088. } else 1089. tmpobj[nobj]->id = token; 1090. } 1091. nobj++; 1092. } break; 1093. case 42: 1094. # line 371 "lev_comp.y" 1095. { 1096. tmpdoor[ndoor] = (door *) alloc(sizeof(door)); 1097. tmpdoor[ndoor]->x = current_coord.x; 1098. tmpdoor[ndoor]->y = current_coord.y; 1099. tmpdoor[ndoor]->mask = yypvt[-2].i; 1100. ndoor++; 1101. } break; 1102. case 43: 1103. # line 380 "lev_comp.y" 1104. { 1105. tmptrap[ntrap] = (trap *) alloc(sizeof(trap)); 1106. tmptrap[ntrap]->x = current_coord.x; 1107. tmptrap[ntrap]->y = current_coord.y; 1108. tmptrap[ntrap]->type = yypvt[-2].i; 1109. ntrap++; 1110. } break; 1111. case 44: 1112. # line 389 "lev_comp.y" 1113. { 1114. tmpdb[ndb] = (drawbridge *) alloc(sizeof(drawbridge)); 1115. tmpdb[ndb]->x = current_coord.x; 1116. tmpdb[ndb]->y = current_coord.y; 1117. tmpdb[ndb]->dir = db_dirs[yypvt[-2].i]; 1118. if ( yypvt[-0].i == D_ISOPEN ) 1119. tmpdb[ndb]->open = 1; 1120. else if ( yypvt[-0].i == D_CLOSED ) 1121. tmpdb[ndb]->open = 0; 1122. else 1123. yyerror("A drawbridge can only be open or closed!"); 1124. ndb++; 1125. } break; 1126. case 45: 1127. # line 404 "lev_comp.y" 1128. { 1129. tmpwalk[nwalk] = (walk *) alloc(sizeof(walk)); 1130. tmpwalk[nwalk]->x = current_coord.x; 1131. tmpwalk[nwalk]->y = current_coord.y; 1132. tmpwalk[nwalk]->dir = yypvt[-0].i; 1133. nwalk++; 1134. } break; 1135. case 46: 1136. # line 413 "lev_comp.y" 1137. { 1138. tmplad[nlad] = (lad *) alloc(sizeof(lad)); 1139. tmplad[nlad]->x = current_coord.x; 1140. tmplad[nlad]->y = current_coord.y; 1141. tmplad[nlad]->up = yypvt[-0].i; 1142. nlad++; 1143. } break; 1144. case 47: 1145. # line 422 "lev_comp.y" 1146. { 1147. tmpdig[ndig] = (dig *) alloc(sizeof(dig)); 1148. tmpdig[ndig]->x1 = current_region.x1; 1149. tmpdig[ndig]->y1 = current_region.y1; 1150. tmpdig[ndig]->x2 = current_region.x2; 1151. tmpdig[ndig]->y2 = current_region.y2; 1152. ndig++; 1153. } break; 1154. case 48: 1155. # line 432 "lev_comp.y" 1156. { 1157. tmpreg[nreg] = (region *) alloc(sizeof(region)); 1158. tmpreg[nreg]->x1 = current_region.x1; 1159. tmpreg[nreg]->y1 = current_region.y1; 1160. tmpreg[nreg]->x2 = current_region.x2; 1161. tmpreg[nreg]->y2 = current_region.y2; 1162. tmpreg[nreg]->rlit = yypvt[-2].i; 1163. tmpreg[nreg]->rtype = yypvt[-0].i; 1164. nreg++; 1165. } break; 1166. case 49: 1167. # line 444 "lev_comp.y" 1168. { 1169. #ifndef ALTARS 1170. yywarning("Altars are not allowed in this version! Ignoring..."); 1171. #else 1172. tmpaltar[naltar] = (altar *) alloc(sizeof(altar)); 1173. tmpaltar[naltar]->x = current_coord.x; 1174. tmpaltar[naltar]->y = current_coord.y; 1175. tmpaltar[naltar]->align = yypvt[-2].i; 1176. tmpaltar[naltar]->shrine = yypvt[-0].i; 1177. naltar++; 1178. #endif /* ALTARS */ 1179. } break; 1180. case 51: 1181. # line 459 "lev_comp.y" 1182. { 1183. yyval.i = - MAX_REGISTERS - 1; 1184. } break; 1185. case 54: 1186. # line 466 "lev_comp.y" 1187. { 1188. yyval.i = - MAX_REGISTERS - 1; 1189. } break; 1190. case 57: 1191. # line 473 "lev_comp.y" 1192. { 1193. yyval.map = (char *) 0; 1194. } break; 1195. case 59: 1196. # line 479 "lev_comp.y" 1197. { 1198. yyval.map = (char *) 0; 1199. } break; 1200. case 60: 1201. # line 484 "lev_comp.y" 1202. { 1203. int token = get_trap_type(yypvt[-0].map); 1204. if (token == ERR) 1205. yyerror("unknown trap type!"); 1206. yyval.i = token; 1207. } break; 1208. case 62: 1209. # line 493 "lev_comp.y" 1210. { 1211. int token = get_room_type(yypvt[-0].map); 1212. if (token == ERR) { 1213. yywarning("Unknown room type! Making ordinary room..."); 1214. yyval.i = OROOM; 1215. } else 1216. yyval.i = token; 1217. } break; 1218. case 66: 1219. # line 506 "lev_comp.y" 1220. { 1221. current_coord.x = current_coord.y = -MAX_REGISTERS-1; 1222. } break; 1223. case 73: 1224. # line 519 "lev_comp.y" 1225. { 1226. yyval.i = - MAX_REGISTERS - 1; 1227. } break; 1228. case 76: 1229. # line 527 "lev_comp.y" 1230. { 1231. if ( yypvt[-1].i >= MAX_REGISTERS ) { 1232. yyerror("Register Index overflow!"); 1233. } else { 1234. current_coord.x = current_coord.y = - yypvt[-1].i - 1; 1235. } 1236. } break; 1237. case 77: 1238. # line 536 "lev_comp.y" 1239. { 1240. if ( yypvt[-1].i >= MAX_REGISTERS ) { 1241. yyerror("Register Index overflow!"); 1242. } else { 1243. yyval.i = - yypvt[-1].i - 1; 1244. } 1245. } break; 1246. case 78: 1247. # line 545 "lev_comp.y" 1248. { 1249. if ( yypvt[-1].i >= MAX_REGISTERS ) { 1250. yyerror("Register Index overflow!"); 1251. } else { 1252. yyval.i = - yypvt[-1].i - 1; 1253. } 1254. } break; 1255. case 79: 1256. # line 554 "lev_comp.y" 1257. { 1258. if ( yypvt[-1].i >= 3 ) { 1259. yyerror("Register Index overflow!"); 1260. } else { 1261. yyval.i = - yypvt[-1].i - 1; 1262. } 1263. } break; 1264. case 81: 1265. # line 565 "lev_comp.y" 1266. { 1267. if (check_monster_char(yypvt[-0].i)) 1268. yyval.i = yypvt[-0].i ; 1269. else { 1270. yyerror("unknown monster class!"); 1271. yyval.i = ERR; 1272. } 1273. } break; 1274. case 82: 1275. # line 575 "lev_comp.y" 1276. { 1277. char c; 1278. 1279. c = yypvt[-0].i; 1280. #ifndef SPELLS 1281. if ( c == '+') { 1282. c = '?'; 1283. yywarning("Spellbooks are not allowed in this version! (converted into scroll)"); 1284. } 1285. #endif 1286. if (check_object_char(c)) 1287. yyval.i = c; 1288. else { 1289. yyerror("Unknown char class!"); 1290. yyval.i = ERR; 1291. } 1292. } break; 1293. case 84: 1294. # line 595 "lev_comp.y" 1295. { 1296. if (yypvt[-3].i < 0 || yypvt[-3].i > max_x_map || 1297. yypvt[-1].i < 0 || yypvt[-1].i > max_y_map) 1298. yyerror("Coordinates out of map range!"); 1299. current_coord.x = yypvt[-3].i; 1300. current_coord.y = yypvt[-1].i; 1301. } break; 1302. case 85: 1303. # line 604 "lev_comp.y" 1304. { 1305. if (yypvt[-7].i < 0 || yypvt[-7].i > max_x_map || 1306. yypvt[-5].i < 0 || yypvt[-5].i > max_y_map || 1307. yypvt[-3].i < 0 || yypvt[-3].i > max_x_map || 1308. yypvt[-1].i < 0 || yypvt[-1].i > max_y_map) 1309. yyerror("Region out of map range!"); 1310. current_region.x1 = yypvt[-7].i; 1311. current_region.y1 = yypvt[-5].i; 1312. current_region.x2 = yypvt[-3].i; 1313. current_region.y2 = yypvt[-1].i; 1314. } break; 1315. } 1316. goto yystack; /* stack new state and value */ 1317. 1318. }
|
![[RDF Data]](/fct/images/sw-rdf-blue.png)