Edited documentation of ChimaraIF::command signal
[projects/chimara/chimara.git] / interpreters / nitfol / objects.c
1 /*  Nitfol - z-machine interpreter using Glk for output.
2     Copyright (C) 1999  Evin Robertson
3
4     This program is free software; you can redistribute it and/or modify
5     it under the terms of the GNU General Public License as published by
6     the Free Software Foundation; either version 2 of the License, or
7     (at your option) any later version.
8
9     This program is distributed in the hope that it will be useful,
10     but WITHOUT ANY WARRANTY; without even the implied warranty of
11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12     GNU General Public License for more details.
13
14     You should have received a copy of the GNU General Public License
15     along with this program; if not, write to the Free Software
16     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
17
18     The author can be reached at nitfol@deja.com
19 */
20 #include "nitfol.h"
21
22 /* attribute/8 will be the byte offset into the object entry for attribute */
23 #define ATTRIBUTE(n, a) z_memory[z_objecttable + n * OBJSIZE + a / 8]
24
25 #define OBJ_ADDR(n)     (z_objecttable + (n) * OBJSIZE)
26
27 #define PARENTP(n)      (OBJ_ADDR(n) + oPARENT)
28 #define SIBLINGP(n)     (OBJ_ADDR(n) + oSIBLING)
29 #define CHILDP(n)       (OBJ_ADDR(n) + oCHILD)
30 #define PROPSP(n)       (OBJ_ADDR(n) + oPROPS)
31
32 #define PARENT(n)  LOWO(PARENTP(n))
33 #define SIBLING(n) LOWO(SIBLINGP(n))
34 #define CHILD(n)   LOWO(CHILDP(n))
35 #define PROPS(n)   LOWORD(PROPSP(n))
36
37
38 static zword OBJSIZE;
39 static zword oPARENT, oSIBLING, oCHILD, oPROPS;
40 static zword PROP_NUM_MASK, ATTR_COUNT;
41
42 static BOOL object_property_loop(zword object, zword *propnum,
43                                  zword *location, zword *len);
44
45
46 zword LOWO(zword p)
47 {
48   if(zversion >= 4)
49     return LOWORD(p);
50   return LOBYTE(p);
51 }
52
53 void LOWOcopy(zword a, zword b)
54 {
55   if(zversion >= 4) {
56     LOWORDcopy(a, b);
57   } else {
58     LOBYTEcopy(a, b);
59   }
60 }
61
62 void LOWOwrite(zword p, zword n)
63 {
64   if(zversion >= 4) {
65     LOWORDwrite(p, n);
66   } else {
67     LOBYTEwrite(p, n);
68   }
69 }
70
71
72 #ifdef FAST
73 #define check_obj_valid(obj) TRUE
74 #define check_attr_valid(attr) TRUE
75 #else
76 static BOOL check_obj_valid(zword object)
77 {
78   if(object > object_count) { /* Object past the first property table entry */
79     if(object > maxobjs) {    /* Object past the end of dynamic memory */
80       n_show_error(E_OBJECT, "object number too large", object);
81       return FALSE;
82     }
83     n_show_warn(E_OBJECT, "object number probably too large", object);
84   }
85   if(object == 0) {
86     n_show_error(E_OBJECT, "vile object 0 error from hell", object);
87     return FALSE;
88   }
89   return TRUE;
90 }
91
92 static BOOL check_attr_valid(zword attr)
93 {
94   if(attr > ATTR_COUNT) {
95     n_show_error(E_OBJECT, "attempt to access illegal attribute", attr);
96     return FALSE;
97   }
98   return TRUE;
99 }
100 #endif
101
102
103
104 void objects_init(void)
105 {
106   zword object;
107
108   if(zversion >= 4) {
109     OBJSIZE = 14;
110     oPARENT = 6;
111     oSIBLING = 8;
112     oCHILD = 10;
113     oPROPS = 12;
114     PROP_NUM_MASK = 0x3f;
115     ATTR_COUNT = 47;
116   } else {
117     OBJSIZE = 9;
118     oPARENT = 4;
119     oSIBLING = 5;
120     oCHILD = 6;
121     oPROPS = 7;
122     PROP_NUM_MASK = 0x1f;
123     ATTR_COUNT = 31;
124   }
125
126   /* Address of objects; we want this to be one before the first object 
127      because there's no object 0 */
128   z_objecttable = z_propdefaults + PROP_NUM_MASK * ZWORD_SIZE - OBJSIZE;
129   maxobjs = (dynamic_size - z_objecttable) / OBJSIZE;
130
131   obj_first_prop_addr = ZWORD_MASK;
132   obj_last_prop_addr = 0;
133
134   prop_table_start = ZWORD_MASK;
135   prop_table_end = 0;
136
137   /* Count objects in tree, assuming objects end where proptables begin */
138   for(object = 1; OBJ_ADDR(object) < prop_table_start; object++) {
139     zword propnum, location, len;
140
141     if(PROPS(object) < prop_table_start)
142       prop_table_start = PROPS(object);
143
144     location = 0;
145     while(object_property_loop(object, &propnum, &location, &len)) {
146       if(location < obj_first_prop_addr)
147         obj_first_prop_addr = location;
148       if(location > obj_last_prop_addr)
149         obj_last_prop_addr = location;
150
151       if(location + len > prop_table_end)
152         prop_table_end = location + len;
153     }
154   }
155
156   object_count = object - 1;
157
158   if(object_count > maxobjs)
159     object_count = maxobjs;
160 }
161
162
163
164
165 void op_get_child(void)
166 {
167   zword child;
168   if(!check_obj_valid(operand[0])) {
169     mop_store_result(0);
170     mop_skip_branch();
171     return;
172   }
173
174   debug_object(operand[0], OBJ_GET_INFO);
175
176   child = CHILD(operand[0]);
177   mop_store_result(child);
178   mop_cond_branch(child != 0);
179 }
180
181
182 void op_get_parent(void)
183 {
184   zword parent;
185   if(!check_obj_valid(operand[0])) {
186     mop_store_result(0);
187     return;
188   }
189
190   debug_object(operand[0], OBJ_GET_INFO);
191
192   parent = PARENT(operand[0]);
193   mop_store_result(parent);
194 }
195
196
197 void op_get_sibling(void)
198 {
199   zword sibling;
200   if(!check_obj_valid(operand[0])) {
201     mop_store_result(0);
202     mop_skip_branch();
203     return;
204   }
205
206   debug_object(operand[0], OBJ_GET_INFO);
207
208   sibling = SIBLING(operand[0]);
209   mop_store_result(sibling);
210   mop_cond_branch(sibling != 0);
211 }
212
213
214
215 void op_insert_obj(void)
216 {
217   zword object = operand[0], dest = operand[1];
218
219   if(!check_obj_valid(object) || !check_obj_valid(dest))
220     return;
221
222 #ifndef FAST
223   {
224     zword child = object;
225     int depth = 0;
226     while(child) {
227       if(child == dest) {
228         n_show_error(E_OBJECT, "attempt to place an object inside itself", object);
229         return;
230       }
231       child = CHILD(child);
232       depth++;
233       if(depth > maxobjs) {
234         n_show_error(E_OBJECT, "found objects inside themselves", child);
235         break;
236       }
237     }
238   }
239 #endif
240
241
242   op_remove_obj(); /* Remove object operand[0] from object tree */
243
244   debug_object(operand[1], OBJ_RECEIVE);
245
246   LOWOwrite(PARENTP(object), dest);
247   LOWOcopy(SIBLINGP(object), CHILDP(dest));
248   LOWOwrite(CHILDP(dest), object);
249 }
250
251
252 void op_jin(void)
253 {
254   if(!check_obj_valid(operand[0])) {
255     mop_skip_branch();
256     return;
257   }
258
259   debug_object(operand[0], OBJ_GET_INFO);
260   debug_object(operand[1], OBJ_GET_INFO);
261
262   mop_cond_branch(PARENT(operand[0]) == operand[1]);
263 }
264
265
266 void op_remove_obj(void)
267 {
268   zword parent, sibling, nextsibling;
269   zword object = operand[0];
270
271   if(!check_obj_valid(object))
272     return;
273   parent = PARENT(object);
274
275   if(!parent)   /* If no parent, do nothing with no error message */
276     return;
277   if(!check_obj_valid(parent))
278     return;
279
280   debug_object(operand[0], OBJ_MOVE);
281
282   nextsibling = CHILD(parent);
283
284   if(nextsibling == object) {  /* if it's the first child */
285     LOWOcopy(CHILDP(parent), SIBLINGP(object));
286   } else {
287     unsigned width = 0;
288     do { /* Loops until the SIBLING(sibling)==object so we can skip over it */
289       sibling = nextsibling;
290       
291       if(!check_obj_valid(sibling))
292         return;
293
294       nextsibling = SIBLING(sibling);
295
296 #ifndef FAST
297       if(width++ > maxobjs) {  /* If we've looped more times than reasonable */
298         n_show_error(E_OBJECT, "looped sibling list", parent);
299         return;
300       }
301 #endif
302     } while(nextsibling != object);
303     
304     LOWOcopy(SIBLINGP(sibling), SIBLINGP(object));/*make the list skip object*/
305   }
306
307   LOWOwrite(PARENTP(object), 0);  
308   LOWOwrite(SIBLINGP(object), 0);
309 }
310
311 offset object_name(zword object)
312 {
313   if(LOBYTE(PROPS(object)))
314     return PROPS(object) + 1;
315   else
316     return 0;
317 }
318
319
320 void op_print_obj(void)
321 {
322   offset short_name_off = object_name(operand[0]);
323   if(short_name_off)
324     decodezscii(short_name_off, output_char);
325   else
326     n_show_error(E_OBJECT, "attempt to print name of nameless object", operand[0]);
327 }
328
329
330 /* attribute opcodes: */
331
332 void op_clear_attr(void)
333 {
334   if(!check_obj_valid(operand[0]) || !check_attr_valid(operand[1]))
335     return;
336   debug_attrib(operand[1], operand[0]);
337
338   ATTRIBUTE(operand[0], operand[1]) &= ~(b10000000 >> (operand[1] & b0111));
339   /* shift top bit right to select the appropriate bit and make
340      a mask from the complement */
341 }
342
343
344 void op_set_attr(void)
345 {
346   if(!check_obj_valid(operand[0]) || !check_attr_valid(operand[1]))
347     return;
348   debug_attrib(operand[1], operand[0]);
349                                       /* select the bit to be set */
350   ATTRIBUTE(operand[0], operand[1]) |= (b10000000 >> (operand[1] & b0111));
351 }
352
353
354 void op_test_attr(void)
355 {
356   if(!check_obj_valid(operand[0]) || !check_attr_valid(operand[1])) {
357     mop_skip_branch();
358     return;
359   }
360   debug_attrib(operand[1], operand[0]);
361                                        /* select the bit to be tested */
362   if(ATTRIBUTE(operand[0], operand[1]) & (b10000000 >> (operand[1] & b0111)))
363     mop_take_branch();
364   else
365     mop_skip_branch();
366 }
367
368
369 /* property table opcodes: */
370
371 /* Helper functions */
372
373 /*
374  * Given the location of the sizebyte, returns the length of the following
375  *  property and sets *size_length to the size of the sizebyte
376  */
377 static zword get_prop_length(zword propoffset, int *size_length)
378 {
379   zword prop_length;
380
381   zbyte size_byte = LOBYTE(propoffset);
382   if(zversion >= 4) {
383     if(size_byte & b10000000) {  /* top bit set means two bytes of size info */
384       *size_length = 2;
385       prop_length = LOBYTE(propoffset + 1) & b00111111;
386       if(prop_length == 0)
387         prop_length = 64;
388     } else {  /* one byte of size info */
389       *size_length = 1;
390       if(size_byte & b01000000)
391         prop_length = 2;
392       else
393         prop_length = 1;
394     }
395   } else {
396     prop_length = (size_byte >> 5) + 1;
397     *size_length = 1;
398   }
399   return prop_length;
400 }
401
402
403 /*
404  * Loops over all properties of an object, returning FALSE if no more
405  * Before first call, set *location = 0;
406  */
407 static BOOL object_property_loop(zword object, zword *propnum,
408                                  zword *location, zword *len)
409 {
410   zword proptable;
411   int size_byte, size_length;
412
413   if(!*location) {
414     *location = proptable = PROPS(object);
415     *len = LOBYTE(proptable) * 2 + 1;   /* skip the header */
416   }
417
418   proptable  = *location;
419   proptable += *len;
420  
421   size_byte  = LOBYTE(proptable);
422   *propnum   = size_byte & PROP_NUM_MASK;
423   if(*propnum) {
424     *len       = get_prop_length(proptable, &size_length);
425     proptable += size_length;
426
427     *location  = proptable;
428     return TRUE;
429   }
430   return FALSE;
431 }
432
433
434
435 static zword get_prop_offset(zword object, zword property, zword *length)
436 {
437   zword propnum, location;
438   location = 0;
439   while(object_property_loop(object, &propnum, &location, length)) {
440     if(propnum == property)
441       return location;
442   }
443   return 0;
444 }
445
446
447 void op_get_next_prop(void)
448 {
449   zword proptable = 0;
450   zword prop_len;
451   zword prop_num;
452
453   if(!check_obj_valid(operand[0])) {
454     mop_store_result(0);
455     return;
456   }
457
458   if(operand[1] == 0) {
459     if(object_property_loop(operand[0], &prop_num, &proptable, &prop_len))
460       mop_store_result(prop_num);
461     else
462       mop_store_result(0);
463     return;
464   }
465   
466   while(object_property_loop(operand[0], &prop_num, &proptable, &prop_len)) {
467     if(prop_num == operand[1]) {
468       if(object_property_loop(operand[0], &prop_num, &proptable, &prop_len))
469         mop_store_result(prop_num);
470       else
471         mop_store_result(0);
472       return;
473     }
474   }
475
476   n_show_error(E_OBJECT, "get_next_prop on nonexistent property", operand[1]);
477   mop_store_result(0);
478   return;
479 }
480
481
482 void op_get_prop_addr(void)
483 {
484   zword proptable;
485   zword prop_len;
486   if(!check_obj_valid(operand[0])) {
487     mop_store_result(0);
488     return;
489   }
490
491   proptable = get_prop_offset(operand[0], operand[1], &prop_len);
492
493   mop_store_result(proptable);
494 }
495
496
497 void op_get_prop_len(void)
498 {
499   int size_length;
500   zword prop_length;
501
502 #ifndef FAST
503   if(operand[0] < obj_first_prop_addr ||
504      operand[0] > obj_last_prop_addr) {
505     if(operand[0] < 64) {
506       n_show_error(E_OBJECT, "get property length in header", operand[0]);
507       mop_store_result(0);
508       return;
509     }
510     n_show_warn(E_OBJECT, "get property length at probably bad address", operand[0]);
511   }
512 #endif
513
514   operand[0]--;                    /* Skip back a byte for the size byte */
515
516   if(zversion >= 4)
517     if(LOBYTE(operand[0]) & 0x80) {  /* test top bit - two bytes of size info */
518       operand[0]--;                  /* Skip back another byte */
519     }
520
521   prop_length = get_prop_length(operand[0], &size_length);
522
523   mop_store_result(prop_length);
524 }
525
526
527 void op_get_prop(void)
528 {
529   zword prop_length;
530   zword proptable;
531   if(!check_obj_valid(operand[0])) {
532     mop_store_result(0);
533     return;
534   }
535
536   proptable = get_prop_offset(operand[0], operand[1], &prop_length);
537
538   if(proptable == 0) {  /* property not provided; use property default */
539     mop_store_result(LOWORD(z_propdefaults + (operand[1]-1) * ZWORD_SIZE));
540     return;
541   }
542
543   switch(prop_length) {
544   case 1:
545     mop_store_result(LOBYTE(proptable)); break;
546 #ifndef FAST
547   default:
548     n_show_port(E_OBJECT, "get_prop on property with bad length", operand[1]);
549 #endif
550   case ZWORD_SIZE:
551     mop_store_result(LOWORD(proptable));
552   }
553 }
554
555
556 void op_put_prop(void)
557 {
558   zword prop_length;
559   zword proptable;
560   if(!check_obj_valid(operand[0])) {
561     mop_store_result(0);
562     return;
563   }
564
565   proptable = get_prop_offset(operand[0], operand[1], &prop_length);
566
567 #ifndef FAST
568   if(proptable == 0) {
569     n_show_error(E_OBJECT, "attempt to write to nonexistent property", operand[1]);
570     return;
571   }
572 #endif
573   
574   switch(prop_length) {
575   case 1:
576     LOBYTEwrite(proptable, operand[2]); break;
577 #ifndef FAST
578   default:
579     n_show_port(E_OBJECT, "put_prop on property with bad length", operand[1]);
580 #endif
581   case ZWORD_SIZE:
582     LOWORDwrite(proptable, operand[2]); break;
583   }
584 }
585
586
587
588 #ifdef DEBUGGING
589
590
591 BOOL infix_property_loop(zword object, zword *propnum, zword *location, zword *len, zword *nonindivloc, zword *nonindivlen)
592 {
593   BOOL status;
594
595   if(*location && *propnum > PROP_NUM_MASK) {
596     *location += *len;
597     *propnum = LOWORD(*location);
598     *location += ZWORD_SIZE;
599     *len = LOBYTE(*location);
600     (*location)++;
601
602     if(*propnum)
603       return TRUE;
604
605     *propnum = 0;
606     *location = *nonindivloc;
607     *len = *nonindivlen;
608     *nonindivloc = 0;
609     *nonindivlen = 0;
610   }
611
612   status = object_property_loop(object, propnum, location, len);
613   if(!status)
614     return FALSE;
615
616   if(*propnum == 3) { /* Individual property table */
617     zword iproptable = LOWORD(*location);
618     zword ilen;
619
620     *propnum = LOWORD(iproptable);
621     iproptable += ZWORD_SIZE;
622     ilen = LOBYTE(iproptable);
623     iproptable++;
624     if(!*propnum)
625       return infix_property_loop(object, propnum, location, len, nonindivloc, nonindivlen);
626
627     *nonindivloc = *location;
628     *nonindivlen = *len;
629     *location = iproptable;
630     *len = ilen;
631   }
632
633   return TRUE;
634 }
635
636
637 void infix_move(zword dest, zword object)
638 {
639   zword to1 = operand[0], to2 = operand[1];
640   operand[0] = object; operand[1] = dest;
641   op_insert_obj();
642   operand[0] = to1; operand[1] = to2;
643 }
644
645 void infix_remove(zword object)
646 {
647   zword to1 = operand[0];
648   operand[0] = object;
649   op_remove_obj();
650   operand[0] = to1;
651 }
652
653 zword infix_parent(zword object)
654 {
655   return PARENT(object);
656 }
657
658 zword infix_child(zword object)
659 {
660   return CHILD(object);
661 }
662
663 zword infix_sibling(zword object)
664 {
665   return SIBLING(object);
666 }
667
668 void infix_set_attrib(zword object, zword attrib)
669 {
670   zword to1 = operand[0], to2 = operand[1];
671   operand[0] = object; operand[1] = attrib;
672   op_set_attr();
673   operand[0] = to1; operand[1] = to2;
674 }
675
676 void infix_clear_attrib(zword object, zword attrib)
677 {
678   zword to1 = operand[0], to2 = operand[1];
679   operand[0] = object; operand[1] = attrib;
680   op_clear_attr();
681   operand[0] = to1; operand[1] = to2;
682 }
683
684
685
686 static void infix_property_display(unsigned prop,
687                                    offset proptable, unsigned prop_length)
688 {
689   BOOL do_number = TRUE;
690   BOOL do_name = TRUE;
691
692   unsigned i;
693
694   /* things we know to be objects/strings/routines */
695   static const char *decode_me_names[] = { 
696     "n_to", "nw_to", "w_to", "sw_to", "s_to", "se_to", "e_to", "ne_to",
697     "in_to", "out_to", "u_to", "d_to",
698     "add_to_scope", "after", "article", "articles", "before", "cant_go",
699     "daemon", "describe", "door_dir", "door_to", "each_turn", "found_in",
700     "grammar", "initial", "inside_description", "invent", "life", "orders",
701     "parse_name", "plural", "react_after", "react_before",
702     "short_name", "short_name_indef", "time_out", "when_closed", "when_open",
703     "when_on", "when_off", "with_key",
704     "obj",
705     "description",
706     "ofclass"
707   };
708
709   /* things we know to be just plain numbers */
710   static const char *dont_decode_names[] = {
711     "capacity", "number", "time_left"
712   };
713
714   z_typed p;
715   const char *propname;
716
717   p.v = prop; p.t = Z_PROP;
718   propname = infix_get_name(p);
719
720   if(prop == 2)
721     propname = "ofclass";
722     
723   infix_print_string(", ");
724   
725   if(propname)
726     infix_print_string(propname);
727   else {
728     infix_print_string("P");
729     infix_print_number(prop);
730   }
731   infix_print_string(" =");
732
733   if(prop == 2) {
734     for(i = 0; i < prop_length; i+=ZWORD_SIZE) {
735       offset short_name_off = object_name(LOWORD(proptable + i));
736       if(short_name_off) {
737         infix_print_char(' ');
738         decodezscii(short_name_off, infix_print_char);
739       } else {
740         infix_print_string(" <badclass>");
741       }
742     }
743     return;
744   }
745
746   if(propname) {
747     if(n_strcmp(propname, "name") == 0) {
748       for(i = 0; i < prop_length; i+=ZWORD_SIZE) {
749         infix_print_string(" '");
750         decodezscii(LOWORD(proptable + i), infix_print_char);
751         infix_print_char('\'');
752       }
753       return;
754     }
755
756     for(i = 0; i < sizeof(decode_me_names) / sizeof(*decode_me_names); i++)
757       if(n_strcmp(decode_me_names[i], propname) == 0)
758         do_number = FALSE;
759       
760     for(i = 0; i < sizeof(dont_decode_names) / sizeof(*dont_decode_names); i++)
761       if(n_strcmp(dont_decode_names[i], propname) == 0)
762         do_name = FALSE;
763   }
764
765   if(prop_length % ZWORD_SIZE || LOWORD(proptable) == 0) {
766     do_number = TRUE;
767     do_name = FALSE;
768   }
769
770   if(do_number) {
771     switch(prop_length) {
772     case 1:
773       infix_print_char(' ');
774       infix_print_znumber(LOBYTE(proptable));
775       break;
776     case ZWORD_SIZE:
777       infix_print_char(' ');
778       infix_print_znumber(LOWORD(proptable));
779       break;
780     default:
781       for(i = 0; i < prop_length; i++) {
782         infix_print_char(' ');
783         infix_print_znumber(LOBYTE(proptable + i));
784       }
785     }
786   }
787
788   if(do_name) {
789     for(i = 0; i < prop_length; i += ZWORD_SIZE) {
790       zword val = LOWORD(proptable + i);
791       const char *name = debug_decode_number(val);
792
793       if(name) {
794         infix_print_char(' ');
795         if(do_number)
796           infix_print_char('(');
797         infix_print_string(name);
798         if(do_number)
799           infix_print_char(')');
800       } else {
801         if(!do_number) {
802           infix_print_char(' ');
803           infix_print_znumber(val);
804         }
805         if(val <= object_count) {
806           offset short_name_off = object_name(val);
807           if(short_name_off) {
808             infix_print_char(' ');
809             infix_print_char('(');
810             decodezscii(short_name_off, infix_print_char);
811             infix_print_char(')');
812           }
813         }
814       }
815     }
816   }
817 }
818
819
820 static void infix_show_object(zword object)
821 {
822   const char *name;
823   if(!object) {
824     infix_print_string("0");
825   } else {
826     offset short_name_off;
827     z_typed o;
828     o.t = Z_OBJECT; o.v = object;
829     name = infix_get_name(o);
830     if(name) {
831       infix_print_string(name);
832     } else {
833       infix_print_number(object);
834     }
835
836     short_name_off = object_name(object);
837     if(short_name_off) {
838       infix_print_string(" \"");
839       decodezscii(short_name_off, infix_print_char);
840       infix_print_char('"');
841     } else if(!name) {
842       infix_print_string(" <nameless>");
843     }
844   }
845 }
846
847 zword infix_get_proptable(zword object, zword prop, zword *length)
848 {
849   zword propnum, location, nloc, nlen;
850
851   location = 0;
852   while(infix_property_loop(object, &propnum, &location, length, &nloc, &nlen)) {
853     if(propnum == prop)
854       return location;
855   }
856
857   return 0;
858 }
859
860
861 zword infix_get_prop(zword object, zword prop)
862 {
863   zword prop_length;
864   zword proptable = infix_get_proptable(object, prop, &prop_length);
865
866   if(!proptable) {
867     if(prop < PROP_NUM_MASK) { /* property defaults */
868       proptable = z_propdefaults + (prop - 1) * ZWORD_SIZE;
869       prop_length = ZWORD_SIZE;
870     } else {
871       return 0;
872     }
873   }
874
875   switch(prop_length) {
876   case 1:
877     return LOBYTE(proptable);
878   default:
879   case ZWORD_SIZE: 
880     return LOWORD(proptable);
881   }
882 }
883
884
885 void infix_put_prop(zword object, zword prop, zword val)
886 {
887   zword prop_length;
888   zword proptable = infix_get_proptable(object, prop, &prop_length);
889
890   if(!proptable)
891     return;
892
893   switch(prop_length) {
894   case 1:
895     LOBYTEwrite(proptable, val);
896   default:
897   case ZWORD_SIZE: 
898     LOWORDwrite(proptable, val);
899   }
900 }
901
902
903 BOOL infix_test_attrib(zword object, zword attrib)
904 {
905   if(!check_obj_valid(object) || !check_attr_valid(attrib)) {
906     return FALSE;
907   }
908
909                                        /* select the bit to be tested */
910   if(ATTRIBUTE(object, attrib) & (b10000000 >> (attrib & b0111)))
911     return TRUE;
912   else
913     return FALSE;
914 }
915
916
917 static char *trunk = NULL;
918 static int trunksize = 128;
919
920 static void infix_draw_trunk(int depth)
921 {
922   int i;
923   for(i = 1; i < depth; i++) {
924     if(trunk[i])
925       infix_print_fixed_string(" |  ");
926     else
927       infix_print_fixed_string("    ");
928   }
929 }
930
931 static void infix_draw_branch(int depth)
932 {
933   infix_draw_trunk(depth);
934   if(depth)
935     infix_print_fixed_string(" +->");
936 }
937
938
939 static void infix_draw_object(zword object, int depth)
940 {
941   zword c;
942   unsigned width;
943
944   if(depth >= trunksize) {
945     trunksize *= 2;
946     trunk = (char *) n_realloc(trunk, trunksize);
947   }
948
949   infix_draw_branch(depth);
950   infix_show_object(object);
951   infix_print_char(10);
952
953   /* Do a sanity check before we print anything to avoid screenfulls of junk */
954   width = 0;
955   for(c = CHILD(object); c; c = SIBLING(c)) {
956     if(width++ > maxobjs) {
957       infix_print_string("looped sibling list.\n");
958       return;
959     }
960   }
961
962   for(c = CHILD(object); c; c = SIBLING(c)) {
963     if(PARENT(c) != object) { /* Section 12.5 (b) */
964       infix_print_string("object ");
965       infix_print_number(c);
966       infix_print_string(" is a child of object ");
967       infix_print_number(object);
968       infix_print_string(" but has ");
969       infix_print_number(PARENT(c));
970       infix_print_string(" listed as its parent.\n");
971       return;
972     }
973
974     trunk[depth+1] = (SIBLING(c) != 0);
975
976     infix_draw_object(c, depth+1);
977   }
978 }
979
980 void infix_object_tree(zword object)
981 {
982   trunk = (char *) n_malloc(trunksize);
983
984   if(object != 0) {
985     infix_draw_object(object, 0);
986     n_free(trunk);
987     return;
988   }
989
990   for(object = 1; object <= object_count; object++) {
991     if(!PARENT(object)) {
992       if(SIBLING(object)) {  /* Section 12.5 (a) */
993         infix_print_string("Object ");
994         infix_print_number(object);
995         infix_print_string(" has no parent, but has sibling ");
996         infix_print_number(SIBLING(object));
997         infix_print_string(".\n");
998         return;
999       }
1000       infix_draw_object(object, 0);
1001     }
1002   }  
1003
1004   n_free(trunk);
1005
1006 }
1007
1008
1009 /* Contrary to the zspec, short names may be arbitrarily long because of
1010    abbreviations, so use realloc */
1011
1012 static char *short_name;
1013 static unsigned short_name_length;
1014 static unsigned short_name_i;
1015
1016 static void infix_copy_short_name(int ch)
1017 {
1018   if(short_name_i + 1 >= short_name_length ) {
1019     char *p;
1020     short_name_length *= 2;
1021     p = (char *) n_realloc(short_name, short_name_length);
1022     short_name = p;
1023   }
1024   short_name[short_name_i++] = ch;
1025 }
1026
1027 void infix_object_find(const char *description)
1028 {
1029   zword object;
1030   char *desc = n_strdup(description);
1031   n_strlower(desc);
1032   for(object = 1; object <= object_count; object++) {
1033     offset short_name_off = object_name(object);
1034     if(short_name_off) {
1035       short_name_length = 512;
1036       short_name = (char *) n_malloc(short_name_length);
1037       short_name_i = 0;
1038       decodezscii(short_name_off, infix_copy_short_name);
1039       short_name[short_name_i] = 0;
1040       n_strlower(short_name);
1041       if(n_strstr(short_name, desc)) {
1042         infix_show_object(object);
1043         if(PARENT(object)) {
1044           infix_print_string(" in ");
1045           infix_show_object(PARENT(object));
1046         }
1047         infix_print_char(10);
1048       }
1049       n_free(short_name);
1050     }
1051   }
1052 }
1053
1054
1055 void infix_object_display(zword object)
1056 {
1057   offset short_name_off;
1058   zword propnum, location, length, nloc, nlen;
1059   unsigned n;
1060   BOOL did;
1061
1062   if(object == 0) {
1063     infix_print_string("nothing");
1064     return;
1065   }
1066
1067   if(!check_obj_valid(object)) {
1068     infix_print_string("invalid object");
1069     return;
1070   }
1071
1072   infix_print_char('{');
1073
1074   short_name_off = object_name(object);
1075   if(short_name_off) {
1076     infix_print_string("short_name = \"");
1077     decodezscii(short_name_off, infix_print_char);
1078     infix_print_string("\", attrib =");
1079   }
1080
1081   did = FALSE;
1082   for(n = 0; n < ATTR_COUNT; n++) {
1083     if(infix_test_attrib(object, n)) {
1084       z_typed a;
1085       const char *attrname;
1086       a.t = Z_ATTR; a.v = n;
1087       attrname = infix_get_name(a);
1088       infix_print_char(' ');
1089       if(attrname)
1090         infix_print_string(attrname);
1091       else
1092         infix_print_number(n);
1093       did = TRUE;
1094     }
1095   }
1096   if(!did)
1097     infix_print_string(" <none>");
1098
1099   infix_print_string(", parent = ");
1100   infix_show_object(PARENT(object));
1101
1102   infix_print_string(", sibling = ");
1103   infix_show_object(SIBLING(object));
1104
1105   infix_print_string(", child = ");
1106   infix_show_object(CHILD(object));
1107
1108
1109   location = 0;
1110   while(infix_property_loop(object, &propnum, &location, &length, &nloc, &nlen)) {
1111     infix_property_display(propnum, location, length);
1112   }
1113
1114   infix_print_char('}');
1115 }
1116
1117 #endif /* DEBUGGING */