2.11BSD#431 - /usr/src/games/hack/hack.zap.c

   1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
   2: /* hack.zap.c - version 1.0.3 */
   3: 
   4: #include "hack.h"
   5: 
   6: extern struct obj *mkobj_at();
   7: extern struct monst *makemon(), *mkmon_at(), youmonst;
   8: struct monst *bhit();
   9: char *exclam();
  10: 
  11: char *fl[]= {
  12:     "magic missile",
  13:     "bolt of fire",
  14:     "sleep ray",
  15:     "bolt of cold",
  16:     "death ray"
  17: };
  18: 
  19: /* Routines for IMMEDIATE wands. */
  20: /* bhitm: monster mtmp was hit by the effect of wand otmp */
  21: bhitm(mtmp, otmp)
  22: register struct monst *mtmp;
  23: register struct obj *otmp;
  24: {
  25:     wakeup(mtmp);
  26:     switch(otmp->otyp) {
  27:     case WAN_STRIKING:
  28:         if(u.uswallow || rnd(20) < 10+mtmp->data->ac) {
  29:             register int tmp = d(2,12);
  30:             hit("wand", mtmp, exclam(tmp));
  31:             mtmp->mhp -= tmp;
  32:             if(mtmp->mhp < 1) killed(mtmp);
  33:         } else miss("wand", mtmp);
  34:         break;
  35:     case WAN_SLOW_MONSTER:
  36:         mtmp->mspeed = MSLOW;
  37:         break;
  38:     case WAN_SPEED_MONSTER:
  39:         mtmp->mspeed = MFAST;
  40:         break;
  41:     case WAN_UNDEAD_TURNING:
  42:         if(index(UNDEAD,mtmp->data->mlet)) {
  43:             mtmp->mhp -= rnd(8);
  44:             if(mtmp->mhp < 1) killed(mtmp);
  45:             else mtmp->mflee = 1;
  46:         }
  47:         break;
  48:     case WAN_POLYMORPH:
  49:         if( newcham(mtmp,&mons[rn2(CMNUM)]) )
  50:             objects[otmp->otyp].oc_name_known = 1;
  51:         break;
  52:     case WAN_CANCELLATION:
  53:         mtmp->mcan = 1;
  54:         break;
  55:     case WAN_TELEPORTATION:
  56:         rloc(mtmp);
  57:         break;
  58:     case WAN_MAKE_INVISIBLE:
  59:         mtmp->minvis = 1;
  60:         break;
  61: #ifdef WAN_PROBING
  62:     case WAN_PROBING:
  63:         mstatusline(mtmp);
  64:         break;
  65: #endif WAN_PROBING
  66:     default:
  67:         impossible("What an interesting wand (%u)", otmp->otyp);
  68:     }
  69: }
  70: 
  71: bhito(obj, otmp)    /* object obj was hit by the effect of wand otmp */
  72: register struct obj *obj, *otmp;    /* returns TRUE if sth was done */
  73: {
  74:     register int res = TRUE;
  75: 
  76:     if(obj == uball || obj == uchain)
  77:         res = FALSE;
  78:     else
  79:     switch(otmp->otyp) {
  80:     case WAN_POLYMORPH:
  81:         /* preserve symbol and quantity, but turn rocks into gems */
  82:         mkobj_at((obj->otyp == ROCK || obj->otyp == ENORMOUS_ROCK)
  83:             ? GEM_SYM : obj->olet,
  84:             obj->ox, obj->oy) -> quan = obj->quan;
  85:         delobj(obj);
  86:         break;
  87:     case WAN_STRIKING:
  88:         if(obj->otyp == ENORMOUS_ROCK)
  89:             fracture_rock(obj);
  90:         else
  91:             res = FALSE;
  92:         break;
  93:     case WAN_CANCELLATION:
  94:         if(obj->spe && obj->olet != AMULET_SYM) {
  95:             obj->known = 0;
  96:             obj->spe = 0;
  97:         }
  98:         break;
  99:     case WAN_TELEPORTATION:
 100:         rloco(obj);
 101:         break;
 102:     case WAN_MAKE_INVISIBLE:
 103:         obj->oinvis = 1;
 104:         break;
 105:     case WAN_UNDEAD_TURNING:
 106:         res = revive(obj);
 107:         break;
 108:     case WAN_SLOW_MONSTER:      /* no effect on objects */
 109:     case WAN_SPEED_MONSTER:
 110: #ifdef WAN_PROBING
 111:     case WAN_PROBING:
 112: #endif WAN_PROBING
 113:         res = FALSE;
 114:         break;
 115:     default:
 116:         impossible("What an interesting wand (%u)", otmp->otyp);
 117:     }
 118:     return(res);
 119: }
 120: 
 121: dozap()
 122: {
 123:     register struct obj *obj;
 124:     xchar zx,zy;
 125: 
 126:     obj = getobj("/", "zap");
 127:     if(!obj) return(0);
 128:     if(obj->spe < 0 || (obj->spe == 0 && rn2(121))) {
 129:         pline("Nothing Happens.");
 130:         return(1);
 131:     }
 132:     if(obj->spe == 0)
 133:         pline("You wrest one more spell from the worn-out wand.");
 134:     if(!(objects[obj->otyp].bits & NODIR) && !getdir(1))
 135:         return(1);  /* make him pay for knowing !NODIR */
 136:     obj->spe--;
 137:     if(objects[obj->otyp].bits & IMMEDIATE) {
 138:         if(u.uswallow)
 139:             bhitm(u.ustuck, obj);
 140:         else if(u.dz) {
 141:             if(u.dz > 0) {
 142:                 register struct obj *otmp = o_at(u.ux, u.uy);
 143:                 if(otmp)
 144:                     (void) bhito(otmp, obj);
 145:             }
 146:         } else
 147:             (void) bhit(u.dx,u.dy,rn1(8,6),0,bhitm,bhito,obj);
 148:     } else {
 149:         switch(obj->otyp){
 150:         case WAN_LIGHT:
 151:             litroom(TRUE);
 152:             break;
 153:         case WAN_SECRET_DOOR_DETECTION:
 154:             if(!findit()) return(1);
 155:             break;
 156:         case WAN_CREATE_MONSTER:
 157:             { register int cnt = 1;
 158:             if(!rn2(23)) cnt += rn2(7) + 1;
 159:             while(cnt--)
 160:                 (void) makemon((struct permonst *) 0, u.ux, u.uy);
 161:             }
 162:             break;
 163:         case WAN_WISHING:
 164:             { char buf[BUFSZ];
 165:               register struct obj *otmp;
 166:               extern struct obj *readobjnam(), *addinv();
 167:               if(u.uluck + rn2(5) < 0) {
 168:             pline("Unfortunately, nothing happens.");
 169:             break;
 170:               }
 171:               pline("You may wish for an object. What do you want? ");
 172:               getlin(buf);
 173:               if(buf[0] == '\033') buf[0] = 0;
 174:               otmp = readobjnam(buf);
 175:               otmp = addinv(otmp);
 176:               prinv(otmp);
 177:               break;
 178:             }
 179:         case WAN_DIGGING:
 180:             /* Original effect (approximately):
 181: 			 * from CORR: dig until we pierce a wall
 182: 			 * from ROOM: piece wall and dig until we reach
 183: 			 * an ACCESSIBLE place.
 184: 			 * Currently: dig for digdepth positions;
 185: 			 * also down on request of Lennart Augustsson.
 186: 			 */
 187:             { register struct rm *room;
 188:               register int digdepth;
 189:             if(u.uswallow) {
 190:                 register struct monst *mtmp = u.ustuck;
 191: 
 192:                 pline("You pierce %s's stomach wall!",
 193:                     monnam(mtmp));
 194:                 mtmp->mhp = 1;  /* almost dead */
 195:                 unstuck(mtmp);
 196:                 mnexto(mtmp);
 197:                 break;
 198:             }
 199:             if(u.dz) {
 200:                 if(u.dz < 0) {
 201:                 pline("You loosen a rock from the ceiling.");
 202:                 pline("It falls on your head!");
 203:                 losehp(1, "falling rock");
 204:                 mksobj_at(ROCK, u.ux, u.uy);
 205:                 fobj->quan = 1;
 206:                 stackobj(fobj);
 207:                 if(Invisible) newsym(u.ux, u.uy);
 208:                 } else {
 209:                 dighole();
 210:                 }
 211:                 break;
 212:             }
 213:             zx = u.ux+u.dx;
 214:             zy = u.uy+u.dy;
 215:             digdepth = 8 + rn2(18);
 216:             Tmp_at(-1, '*');    /* open call */
 217:             while(--digdepth >= 0) {
 218:                 if(!isok(zx,zy)) break;
 219:                 room = &levl[zx][zy];
 220:                 Tmp_at(zx,zy);
 221:                 if(!xdnstair){
 222:                     if(zx < 3 || zx > COLNO-3 ||
 223:                         zy < 3 || zy > ROWNO-3)
 224:                         break;
 225:                     if(room->typ == HWALL ||
 226:                         room->typ == VWALL){
 227:                         room->typ = ROOM;
 228:                         break;
 229:                     }
 230:                 } else
 231:                 if(room->typ == HWALL || room->typ == VWALL ||
 232:                    room->typ == SDOOR || room->typ == LDOOR){
 233:                     room->typ = DOOR;
 234:                     digdepth -= 2;
 235:                 } else
 236:                 if(room->typ == SCORR || !room->typ) {
 237:                     room->typ = CORR;
 238:                     digdepth--;
 239:                 }
 240:                 mnewsym(zx,zy);
 241:                 zx += u.dx;
 242:                 zy += u.dy;
 243:             }
 244:             mnewsym(zx,zy); /* not always necessary */
 245:             Tmp_at(-1,-1);  /* closing call */
 246:             break;
 247:             }
 248:         default:
 249:             buzz((int) obj->otyp - WAN_MAGIC_MISSILE,
 250:                 u.ux, u.uy, u.dx, u.dy);
 251:             break;
 252:         }
 253:         if(!objects[obj->otyp].oc_name_known) {
 254:             objects[obj->otyp].oc_name_known = 1;
 255:             more_experienced(0,10);
 256:         }
 257:     }
 258:     return(1);
 259: }
 260: 
 261: char *
 262: exclam(force)
 263: register int force;
 264: {
 265:     /* force == 0 occurs e.g. with sleep ray */
 266:     /* note that large force is usual with wands so that !! would
 267: 		require information about hand/weapon/wand */
 268:     return( (force < 0) ? "?" : (force <= 4) ? "." : "!" );
 269: }
 270: 
 271: hit(str,mtmp,force)
 272: register char *str;
 273: register struct monst *mtmp;
 274: register char *force;       /* usually either "." or "!" */
 275: {
 276:     if(!cansee(mtmp->mx,mtmp->my)) pline("The %s hits it.", str);
 277:     else pline("The %s hits %s%s", str, monnam(mtmp), force);
 278: }
 279: 
 280: miss(str,mtmp)
 281: register char *str;
 282: register struct monst *mtmp;
 283: {
 284:     if(!cansee(mtmp->mx,mtmp->my)) pline("The %s misses it.",str);
 285:     else pline("The %s misses %s.",str,monnam(mtmp));
 286: }
 287: 
 288: /* bhit: called when a weapon is thrown (sym = obj->olet) or when an
 289:    IMMEDIATE wand is zapped (sym = 0); the weapon falls down at end of
 290:    range or when a monster is hit; the monster is returned, and bhitpos
 291:    is set to the final position of the weapon thrown; the ray of a wand
 292:    may affect several objects and monsters on its path - for each of
 293:    these an argument function is called. */
 294: /* check !u.uswallow before calling bhit() */
 295: 
 296: struct monst *
 297: bhit(ddx,ddy,range,sym,fhitm,fhito,obj)
 298: register int ddx,ddy,range;     /* direction and range */
 299: char sym;               /* symbol displayed on path */
 300: int (*fhitm)(), (*fhito)();     /* fns called when mon/obj hit */
 301: struct obj *obj;            /* 2nd arg to fhitm/fhito */
 302: {
 303:     register struct monst *mtmp;
 304:     register struct obj *otmp;
 305:     register int typ;
 306: 
 307:     bhitpos.x = u.ux;
 308:     bhitpos.y = u.uy;
 309: 
 310:     if(sym) tmp_at(-1, sym);    /* open call */
 311:     while(range-- > 0) {
 312:         bhitpos.x += ddx;
 313:         bhitpos.y += ddy;
 314:         typ = levl[bhitpos.x][bhitpos.y].typ;
 315:         if(mtmp = m_at(bhitpos.x,bhitpos.y)){
 316:             if(sym) {
 317:                 tmp_at(-1, -1); /* close call */
 318:                 return(mtmp);
 319:             }
 320:             (*fhitm)(mtmp, obj);
 321:             range -= 3;
 322:         }
 323:         if(fhito && (otmp = o_at(bhitpos.x,bhitpos.y))){
 324:             if((*fhito)(otmp, obj))
 325:                 range--;
 326:         }
 327:         if(!ZAP_POS(typ)) {
 328:             bhitpos.x -= ddx;
 329:             bhitpos.y -= ddy;
 330:             break;
 331:         }
 332:         if(sym) tmp_at(bhitpos.x, bhitpos.y);
 333:     }
 334: 
 335:     /* leave last symbol unless in a pool */
 336:     if(sym)
 337:        tmp_at(-1, (levl[bhitpos.x][bhitpos.y].typ == POOL) ? -1 : 0);
 338:     return(0);
 339: }
 340: 
 341: struct monst *
 342: boomhit(dx,dy) {
 343:     register int i, ct;
 344:     register struct monst *mtmp;
 345:     char sym = ')';
 346:     extern schar xdir[], ydir[];
 347: 
 348:     bhitpos.x = u.ux;
 349:     bhitpos.y = u.uy;
 350: 
 351:     for(i=0; i<8; i++) if(xdir[i] == dx && ydir[i] == dy) break;
 352:     tmp_at(-1, sym);    /* open call */
 353:     for(ct=0; ct<10; ct++) {
 354:         if(i == 8) i = 0;
 355:         sym = ')' + '(' - sym;
 356:         tmp_at(-2, sym);    /* change let call */
 357:         dx = xdir[i];
 358:         dy = ydir[i];
 359:         bhitpos.x += dx;
 360:         bhitpos.y += dy;
 361:         if(mtmp = m_at(bhitpos.x, bhitpos.y)){
 362:             tmp_at(-1,-1);
 363:             return(mtmp);
 364:         }
 365:         if(!ZAP_POS(levl[bhitpos.x][bhitpos.y].typ)) {
 366:             bhitpos.x -= dx;
 367:             bhitpos.y -= dy;
 368:             break;
 369:         }
 370:         if(bhitpos.x == u.ux && bhitpos.y == u.uy) { /* ct == 9 */
 371:             if(rn2(20) >= 10+u.ulevel){ /* we hit ourselves */
 372:                 (void) thitu(10, rnd(10), "boomerang");
 373:                 break;
 374:             } else {    /* we catch it */
 375:                 tmp_at(-1,-1);
 376:                 pline("Skillfully, you catch the boomerang.");
 377:                 return(&youmonst);
 378:             }
 379:         }
 380:         tmp_at(bhitpos.x, bhitpos.y);
 381:         if(ct % 5 != 0) i++;
 382:     }
 383:     tmp_at(-1, -1); /* do not leave last symbol */
 384:     return(0);
 385: }
 386: 
 387: char
 388: dirlet(dx,dy) register dx,dy; {
 389:     return
 390:         (dx == dy) ? '\\' : (dx && dy) ? '/' : dx ? '-' : '|';
 391: }
 392: 
 393: /* type == -1: monster spitting fire at you */
 394: /* type == -1,-2,-3: bolts sent out by wizard */
 395: /* called with dx = dy = 0 with vertical bolts */
 396: buzz(type,sx,sy,dx,dy)
 397: register int type;
 398: register xchar sx,sy;
 399: register int dx,dy;
 400: {
 401:     int abstype = abs(type);
 402:     register char *fltxt = (type == -1) ? "blaze of fire" : fl[abstype];
 403:     struct rm *lev;
 404:     xchar range;
 405:     struct monst *mon;
 406: 
 407:     if(u.uswallow) {
 408:         register int tmp;
 409: 
 410:         if(type < 0) return;
 411:         tmp = zhit(u.ustuck, type);
 412:         pline("The %s rips into %s%s",
 413:             fltxt, monnam(u.ustuck), exclam(tmp));
 414:         return;
 415:     }
 416:     if(type < 0) pru();
 417:     range = rn1(7,7);
 418:     Tmp_at(-1, dirlet(dx,dy));  /* open call */
 419:     while(range-- > 0) {
 420:         sx += dx;
 421:         sy += dy;
 422:         if((lev = &levl[sx][sy])->typ) Tmp_at(sx,sy);
 423:         else {
 424:             int bounce = 0;
 425:             if(cansee(sx-dx,sy-dy))
 426:                 pline("The %s bounces!", fltxt);
 427:             if(ZAP_POS(levl[sx][sy-dy].typ))
 428:                 bounce = 1;
 429:             if(ZAP_POS(levl[sx-dx][sy].typ)) {
 430:                 if(!bounce || rn2(2)) bounce = 2;
 431:             }
 432:             switch(bounce){
 433:             case 0:
 434:                 dx = -dx;
 435:                 dy = -dy;
 436:                 continue;
 437:             case 1:
 438:                 dy = -dy;
 439:                 sx -= dx;
 440:                 break;
 441:             case 2:
 442:                 dx = -dx;
 443:                 sy -= dy;
 444:                 break;
 445:             }
 446:             Tmp_at(-2,dirlet(dx,dy));
 447:             continue;
 448:         }
 449:         if(lev->typ == POOL && abstype == 1 /* fire */) {
 450:             range -= 3;
 451:             lev->typ = ROOM;
 452:             if(cansee(sx,sy)) {
 453:                 mnewsym(sx,sy);
 454:                 pline("The water evaporates.");
 455:             } else
 456:                 pline("You hear a hissing sound.");
 457:         }
 458:         if((mon = m_at(sx,sy)) &&
 459:            (type != -1 || mon->data->mlet != 'D')) {
 460:             wakeup(mon);
 461:             if(rnd(20) < 18 + mon->data->ac) {
 462:                 register int tmp = zhit(mon,abstype);
 463:                 if(mon->mhp < 1) {
 464:                     if(type < 0) {
 465:                         if(cansee(mon->mx,mon->my))
 466:                           pline("%s is killed by the %s!",
 467:                         Monnam(mon), fltxt);
 468:                         mondied(mon);
 469:                     } else
 470:                         killed(mon);
 471:                 } else
 472:                     hit(fltxt, mon, exclam(tmp));
 473:                 range -= 2;
 474:             } else
 475:                 miss(fltxt,mon);
 476:         } else if(sx == u.ux && sy == u.uy) {
 477:             nomul(0);
 478:             if(rnd(20) < 18+u.uac) {
 479:                 register int dam = 0;
 480:                 range -= 2;
 481:                 pline("The %s hits you!",fltxt);
 482:                 switch(abstype) {
 483:                 case 0:
 484:                     dam = d(2,6);
 485:                     break;
 486:                 case 1:
 487:                     if(Fire_resistance)
 488:                         pline("You don't feel hot!");
 489:                     else dam = d(6,6);
 490:                     if(!rn2(3))
 491:                         burn_scrolls();
 492:                     break;
 493:                 case 2:
 494:                     nomul(-rnd(25)); /* sleep ray */
 495:                     break;
 496:                 case 3:
 497:                     if(Cold_resistance)
 498:                         pline("You don't feel cold!");
 499:                     else dam = d(6,6);
 500:                     break;
 501:                 case 4:
 502:                     u.uhp = -1;
 503:                 }
 504:                 losehp(dam,fltxt);
 505:             } else pline("The %s whizzes by you!",fltxt);
 506:             stop_occupation();
 507:         }
 508:         if(!ZAP_POS(lev->typ)) {
 509:             int bounce = 0, rmn;
 510:             if(cansee(sx,sy)) pline("The %s bounces!",fltxt);
 511:             range--;
 512:             if(!dx || !dy || !rn2(20)){
 513:                 dx = -dx;
 514:                 dy = -dy;
 515:             } else {
 516:               if(ZAP_POS(rmn = levl[sx][sy-dy].typ) &&
 517:                 (IS_ROOM(rmn) || ZAP_POS(levl[sx+dx][sy-dy].typ)))
 518:                 bounce = 1;
 519:               if(ZAP_POS(rmn = levl[sx-dx][sy].typ) &&
 520:                 (IS_ROOM(rmn) || ZAP_POS(levl[sx-dx][sy+dy].typ)))
 521:                 if(!bounce || rn2(2))
 522:                     bounce = 2;
 523: 
 524:               switch(bounce){
 525:               case 0:
 526:                 dy = -dy;
 527:                 dx = -dx;
 528:                 break;
 529:               case 1:
 530:                 dy = -dy;
 531:                 break;
 532:               case 2:
 533:                 dx = -dx;
 534:                 break;
 535:               }
 536:               Tmp_at(-2, dirlet(dx,dy));
 537:             }
 538:         }
 539:     }
 540:     Tmp_at(-1,-1);
 541: }
 542: 
 543: zhit(mon,type)          /* returns damage to mon */
 544: register struct monst *mon;
 545: register type;
 546: {
 547:     register int tmp = 0;
 548: 
 549:     switch(type) {
 550:     case 0:         /* magic missile */
 551:         tmp = d(2,6);
 552:         break;
 553:     case -1:        /* Dragon blazing fire */
 554:     case 1:         /* fire */
 555:         if(index("Dg", mon->data->mlet)) break;
 556:         tmp = d(6,6);
 557:         if(index("YF", mon->data->mlet)) tmp += 7;
 558:         break;
 559:     case 2:         /* sleep*/
 560:         mon->mfroz = 1;
 561:         break;
 562:     case 3:         /* cold */
 563:         if(index("YFgf", mon->data->mlet)) break;
 564:         tmp = d(6,6);
 565:         if(mon->data->mlet == 'D') tmp += 7;
 566:         break;
 567:     case 4:         /* death*/
 568:         if(index(UNDEAD, mon->data->mlet)) break;
 569:         tmp = mon->mhp+1;
 570:         break;
 571:     }
 572:     mon->mhp -= tmp;
 573:     return(tmp);
 574: }
 575: 
 576: #define CORPSE_I_TO_C(otyp) (char) ((otyp >= DEAD_ACID_BLOB)\
 577:              ?  'a' + (otyp - DEAD_ACID_BLOB)\
 578:              :  '@' + (otyp - DEAD_HUMAN))
 579: revive(obj)
 580: register struct obj *obj;
 581: {
 582:     register struct monst *mtmp;
 583: 
 584:     if(obj->olet == FOOD_SYM && obj->otyp > CORPSE) {
 585:         /* do not (yet) revive shopkeepers */
 586:         /* Note: this might conceivably produce two monsters
 587: 			at the same position - strange, but harmless */
 588:         mtmp = mkmon_at(CORPSE_I_TO_C(obj->otyp),obj->ox,obj->oy);
 589:         delobj(obj);
 590:     }
 591:     return(!!mtmp);     /* TRUE if some monster created */
 592: }
 593: 
 594: rloco(obj)
 595: register struct obj *obj;
 596: {
 597:     register tx,ty,otx,oty;
 598: 
 599:     otx = obj->ox;
 600:     oty = obj->oy;
 601:     do {
 602:         tx = rn1(COLNO-3,2);
 603:         ty = rn2(ROWNO);
 604:     } while(!goodpos(tx,ty));
 605:     obj->ox = tx;
 606:     obj->oy = ty;
 607:     if(cansee(otx,oty))
 608:         newsym(otx,oty);
 609: }
 610: 
 611: fracture_rock(obj)  /* fractured by pick-axe or wand of striking */
 612: register struct obj *obj;              /* no texts here! */
 613: {
 614:     /* unpobj(obj); */
 615:     obj->otyp = ROCK;
 616:     obj->quan = 7 + rn2(60);
 617:     obj->owt = weight(obj);
 618:     obj->olet = WEAPON_SYM;
 619:     if(cansee(obj->ox,obj->oy))
 620:         prl(obj->ox,obj->oy);
 621: }
 622: 
 623: burn_scrolls()
 624: {
 625:     register struct obj *obj, *obj2;
 626:     register int cnt = 0;
 627: 
 628:     for(obj = invent; obj; obj = obj2) {
 629:         obj2 = obj->nobj;
 630:         if(obj->olet == SCROLL_SYM) {
 631:             cnt++;
 632:             useup(obj);
 633:         }
 634:     }
 635:     if(cnt > 1) {
 636:         pline("Your scrolls catch fire!");
 637:         losehp(cnt, "burning scrolls");
 638:     } else if(cnt) {
 639:         pline("Your scroll catches fire!");
 640:         losehp(1, "burning scroll");
 641:     }
 642: }

Defined functions

Defined variables

Defined macros