home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 2 / crawlyvol2.bin / program / c / itf_src / options.c < prev    next >
C/C++ Source or Header  |  1993-05-22  |  12KB  |  488 lines
  1. /*
  2. **    File:    options.c
  3. **
  4. **    (C)opyright 1987-1992 InfoTaskforce.
  5. */
  6.  
  7. #include    "infocom.h"
  8.  
  9. #define        MAX_CHARS_PER_WORD    (PLUS_CHARS_PER_WORD)
  10. /*
  11. #define        VOCAB_BUFFER_SIZE    (MAX_CHARS_PER_WORD+3)
  12. */
  13. #define        VOCAB_BUFFER_SIZE    ((word)(0x09+3))
  14. #define        VOCAB1_BUFFER_SIZE    ((word)(0x09+4))
  15. #define        BYTE_DISPLAY(x)        hex_digit((x),2)
  16.  
  17. char        vocab_buffer[VOCAB1_BUFFER_SIZE] ;
  18. char        *vocab_ptr ;
  19.  
  20. Void
  21. options ( opt )
  22. word    opt ;
  23. {
  24.     extern header    data_head ;
  25.  
  26.     init_print () ;
  27.     if ( opt & HEAD_INFO )
  28.         show_header () ;
  29.     if ( opt & ( VOCABULARY | EXTENDED_VOCAB ) )
  30.         show_vocab ( opt ) ;
  31.     if ( opt & OBJECTS )
  32.         show_objects ( data_head.z_code_version,opt ) ;
  33.     if ( opt & TREE )
  34.         show_tree ( data_head.z_code_version ) ;
  35. }
  36.  
  37. Void
  38. print_item ( s,n )
  39. char    *s ;
  40. word    n ;
  41. {
  42.     display ( s ) ;
  43.     hex_display ( n ) ;
  44.     new_line () ;
  45. }
  46.  
  47. Void
  48. show_header ()
  49. {
  50.     extern header    data_head ;
  51.     extern proc_ptr    PrintChar ;
  52.  
  53.     word            i ;
  54.  
  55.     /*
  56.     **    We use 'new_line()' to get a new line so that
  57.     **    the "**MORE**" facility will be used.
  58.     */
  59.  
  60.     display ( "INFOCOM Data File Header." ) ;
  61.     new_line () ;
  62.     new_line () ;
  63.     print_item ( "Z-Code Version: $",(word)data_head.z_code_version ) ;
  64.     new_line () ;
  65.     if ( data_head.mode_bits & USE_TIME )
  66.         display ( "Score/Time    : Time" ) ;
  67.     else
  68.         display ( "Score/Time    : Score" ) ;
  69.     new_line () ;
  70.     print_item ( "Mode Bits     : $",(word)data_head.mode_bits ) ;
  71.     print_item ( "Release Number: $",data_head.release ) ;
  72.     print_item ( "Resident Bytes: $",data_head.resident_bytes ) ;
  73.     print_item ( "Start Address : $",data_head.start ) ;
  74.     print_item ( "Vocab Address : $",data_head.vocab ) ;
  75.     print_item ( "Object List   : $",data_head.object_list ) ;
  76.     print_item ( "Global Vars.  : $",data_head.globals ) ;
  77.     print_item ( "Save Bytes    : $",data_head.save_bytes ) ;
  78.     print_item ( "Script Status : $",data_head.script_status ) ;
  79.     if ( data_head.script_status == 0 )
  80.         display ( "Script Status : Off" ) ;
  81.     else
  82.         display ( "Script Status : On" ) ;
  83.     new_line () ;
  84.     display ( "Serial Number : " ) ;
  85.     for ( i = 0 ; i < 6 ; i++ )
  86.         (*PrintChar) ( (word)data_head.serial_no[i] ) ;
  87.     new_line () ;
  88.     print_item ( "Common Words  : $",data_head.common_word ) ;
  89.     print_item ( "Verify Length : $",data_head.verify_length ) ;
  90.     print_item ( "Verify Check  : $",data_head.verify_checksum ) ;
  91.     new_line () ;
  92.     new_line () ;
  93. }
  94.  
  95. Void
  96. print_word ( ch )
  97. word    ch ;
  98. {
  99.     extern char        *vocab_ptr ;
  100.  
  101.     *vocab_ptr++ = (char)ch ;
  102. }
  103.  
  104. Void
  105. show_vocab ( opt )
  106. word    opt ;
  107. {
  108.     extern header        data_head ;
  109.     extern word            num_vocab_words ;
  110.     extern word            vocab_entry_size ;
  111.     extern word            strt_vocab_table ;
  112.     extern byte_ptr        base_ptr ;
  113.     extern proc_ptr        PrintChar ;
  114.     extern char            vocab_buffer[] ;
  115.     extern char            *vocab_ptr ;
  116.     extern int            screen_width ;
  117.     extern int            print_mode ;
  118.     extern int            single_mode ;
  119.     extern Void            print_word () ;
  120.  
  121.     proc_ptr            old_printchar ;
  122.     byte_ptr            ptr ;
  123.     word                page ;
  124.     word                offset ;
  125.     word                count ;
  126.     int                    words_per_line ;
  127.     int                    i ;
  128.  
  129.     display ( "INFOCOM Adventure - Vocab List." ) ;
  130.     new_line () ;
  131.     new_line () ;
  132.     print_item ( "Number of Words: $",num_vocab_words ) ;
  133.     new_line () ;
  134.  
  135.     old_printchar = PrintChar ;
  136.     PrintChar = print_word ;
  137.     vocab_ptr = vocab_buffer ;
  138.     for ( i = 0 ; i < (int)VOCAB_BUFFER_SIZE ; i++ )
  139.         *vocab_ptr++ = ' ' ;
  140.     *vocab_ptr = '\0' ;
  141.  
  142.     words_per_line = screen_width / (int)VOCAB_BUFFER_SIZE ;
  143.     count = 0 ;
  144.     ptr = base_ptr + strt_vocab_table ;
  145.     while ( count < num_vocab_words )
  146.     {
  147.         page = ( ptr - base_ptr ) / (int)BLOCK_SIZE ;
  148.         offset = ( ptr - base_ptr ) % (int)BLOCK_SIZE ;
  149.  
  150.         print_mode = single_mode = 0 ;
  151.         vocab_ptr = vocab_buffer ;
  152.         if ( data_head.z_code_version <= VERSION_3 )
  153.         {
  154.             for ( i = 0 ; i < (int)STD_ENCODED_SIZE ; i++ )
  155.                 decode ( get_word ( &page,&offset ) ) ;
  156.         }
  157.         else
  158.         {
  159.             for ( i = 0 ; i < (int)PLUS_ENCODED_SIZE ; i++ )
  160.                 decode ( get_word ( &page,&offset ) ) ;
  161.         }
  162.         while ( *vocab_ptr != '\0' )
  163.             *vocab_ptr++ = ' ' ;
  164.         display ( vocab_buffer ) ;
  165.  
  166.         if ( opt & EXTENDED_VOCAB )
  167.         {
  168.             if ( data_head.z_code_version <= VERSION_3 )
  169.             {
  170.                 for (i = 0; i < (int)(vocab_entry_size - (STD_ENCODED_SIZE * 2)); i++)
  171.                 {
  172.                     display ( "\t$" ) ;
  173.                     BYTE_DISPLAY ( get_byte ( &page,&offset ) ) ;
  174.                 }
  175.             }
  176.             else
  177.             {
  178.                 for (i = 0; i < (int)(vocab_entry_size - (PLUS_ENCODED_SIZE * 2)); i++)
  179.                 {
  180.                     display ( "\t$" ) ;
  181.                     BYTE_DISPLAY ( get_byte ( &page,&offset ) ) ;
  182.                 }
  183.             }
  184.             ++count ;
  185.             new_line () ;
  186.         }
  187.         else
  188.         {
  189.             if ( ((int)++count % words_per_line) == 0 )
  190.                 new_line () ;
  191.         }
  192.  
  193.         ptr += vocab_entry_size ;
  194.     }
  195.     new_line () ;
  196.     new_line () ;
  197.     PrintChar = old_printchar ;
  198. }
  199.  
  200. boolean
  201. prop_name ( obj_num )
  202. word    obj_num ;
  203. {
  204.     extern header            data_head ;
  205.     extern byte_ptr            base_ptr ;
  206.     extern std_object_ptr    std_obj_list ;
  207.     extern plus_object_ptr    plus_obj_list ;
  208.  
  209.     std_object_ptr            std_obj ;
  210.     plus_object_ptr            plus_obj ;
  211.     byte_ptr                p ;
  212.  
  213.     if ( data_head.z_code_version <= VERSION_3 )
  214.     {
  215.         std_obj = STD_OBJ_ADDR ( obj_num ) ;
  216.         p = base_ptr + ((word)(std_obj -> prop_ptr[0]) << 8) + (std_obj -> prop_ptr[1]) ;
  217.         if ( *p )
  218.             return ( TRUE ) ;
  219.     }
  220.     else
  221.     {
  222.         plus_obj = PLUS_OBJ_ADDR ( obj_num ) ;
  223.         p = base_ptr + ((word)(plus_obj -> prop_ptr[0]) << 8) + (plus_obj -> prop_ptr[1]) ;
  224.         if ( *p )
  225.             return ( TRUE ) ;
  226.     }
  227.     return ( FALSE ) ;
  228. }
  229.  
  230. Void
  231. show_std_props ( obj_num )
  232. word    obj_num ;
  233. {
  234.     extern std_object_ptr    std_obj_list ;
  235.     extern property            std_prop_addr () ;
  236.  
  237.     property                p ;
  238.     byte                    p_num ;
  239.     byte                    p_len ;
  240.  
  241.     new_line () ;
  242.     p = std_prop_addr ( STD_OBJ_ADDR ( obj_num ) ) ;
  243.     while ( ( p_num = STD_PROPERTY_NUMBER ( p ) ) != 0 )
  244.     {
  245.         p_len = STD_PROPERTY_LENGTH ( p ) ;
  246.         ++p ;
  247.         display ( "\t -> property   : $" ) ;
  248.         BYTE_DISPLAY ( p_num ) ;
  249.         display ( " [" ) ;
  250.         while ( p_len-- )
  251.         {
  252.             display ( " $" ) ;
  253.             BYTE_DISPLAY ( *p++ ) ;
  254.         }
  255.         display ( " ]" ) ;
  256.         new_line () ;
  257.     }
  258. }
  259.  
  260. Void
  261. show_plus_props ( obj_num )
  262. word    obj_num ;
  263. {
  264.     extern plus_object_ptr    plus_obj_list ;
  265.     extern property            plus_prop_addr () ;
  266.  
  267.     property                p ;
  268.     byte                    p_num ;
  269.     byte                    p_len ;
  270.     byte                    mode ;
  271.  
  272.     new_line () ;
  273.     p = plus_prop_addr ( PLUS_OBJ_ADDR ( obj_num ) ) ;
  274.     while ( ( p_num = PLUS_PROPERTY_NUMBER ( p ) ) != 0 )
  275.     {
  276.         mode = *p++ ;
  277.         if ( mode & NEXT_BYTE_IS_LENGTH )
  278.             p_len = PLUS_PROPERTY_LENGTH ( p++ ) ;
  279.         else
  280.         {
  281.             if ( mode & PLUS_WORD_MASK )
  282.                 p_len = 2 ;
  283.             else
  284.                 p_len = 1 ;
  285.         }
  286.         display ( "\t -> property   : $" ) ;
  287.         BYTE_DISPLAY ( p_num ) ;
  288.         display ( " [" ) ;
  289.         while ( p_len-- )
  290.         {
  291.             display ( " $" ) ;
  292.             BYTE_DISPLAY ( *p++ ) ;
  293.         }
  294.         display ( " ]" ) ;
  295.         new_line () ;
  296.     }
  297. }
  298.  
  299. Void
  300. show_objects ( version,opt )
  301. byte    version ;
  302. word    opt ;
  303. {
  304.     extern header                data_head ;
  305.     extern std_object_ptr        std_obj_list ;
  306.     extern plus_object_ptr        plus_obj_list ;
  307.     extern byte_ptr                base_ptr ;
  308.  
  309.     register std_object_ptr        std_obj ;
  310.     register plus_object_ptr    plus_obj ;
  311.     word                        i,j ;
  312.     int                            n_objs ;
  313.  
  314.     display ( "INFOCOM Adventure - Object List." ) ;
  315.     new_line () ;
  316.     new_line () ;
  317.     if ( data_head.z_code_version <= VERSION_3 )
  318.     {
  319.         std_obj = STD_OBJ_ADDR ( 1 ) ;
  320.         n_objs = (( std_obj -> prop_ptr[0] << BITS_PER_BYTE ) + std_obj -> prop_ptr[1] - ( (byte_ptr)std_obj - base_ptr )) / (unsigned int)STD_OBJ_SIZE ;
  321.     }
  322.     else
  323.     {
  324.         plus_obj = PLUS_OBJ_ADDR ( 1 ) ;
  325.         n_objs = (( plus_obj -> prop_ptr[0] << BITS_PER_BYTE ) + plus_obj -> prop_ptr[1] - ( (byte_ptr)plus_obj - base_ptr )) / (unsigned int)PLUS_OBJ_SIZE ;
  326.     }
  327.     print_item ( "Number of Objects: $",(word)n_objs ) ;
  328.     new_line () ;
  329.     for ( i = 1 ; i <= (word)n_objs ; i++ )
  330.     {
  331.         display ( "Object $" ) ;
  332.         hex_display ( i ) ;
  333.         display ( " : " ) ;
  334.  
  335.         if ( version <= VERSION_3 )
  336.         {
  337.             if ( prop_name ( i ) )
  338.                 std_p_obj ( i ) ;
  339.             else
  340.                 display ( "<No Name>" ) ;
  341.             new_line () ;
  342.             display ( "\t -> attributes : " ) ;
  343.             std_obj = STD_OBJ_ADDR ( i ) ;
  344.             for ( j = 0 ; j < 4 ; j++ )
  345.                 bit_byte ( std_obj -> attributes[j] ) ;
  346.             new_line () ;
  347.             print_item ( "\t -> location   : $",(word)std_obj -> location[0] ) ;
  348.             print_item ( "\t -> link       : $",(word)std_obj -> link[0] ) ;
  349.             print_item ( "\t -> holds      : $",(word)std_obj -> holds[0] ) ;
  350.             print_item ( "\t -> prop_ptr   : $",(word)((std_obj -> prop_ptr[0] << BITS_PER_BYTE) | (std_obj -> prop_ptr[1])) ) ;
  351.             if ( opt & SHOW_PROPS )
  352.                 show_std_props ( i ) ;
  353.         }
  354.         else
  355.         {
  356.             if ( prop_name ( i ) )
  357.                 plus_p_obj ( i ) ;
  358.             else
  359.                 display ( "<No Name>" ) ;
  360.             new_line () ;
  361.             display ( "\t -> attributes : " ) ;
  362.             plus_obj = PLUS_OBJ_ADDR ( i ) ;
  363.             for ( j = 0 ; j < 6 ; j++ )
  364.                 bit_byte ( plus_obj -> attributes[j] ) ;
  365.             new_line () ;
  366.             print_item ( "\t -> location   : $",(word)((plus_obj -> location[0] << BITS_PER_BYTE) | (plus_obj -> location[1])) ) ;
  367.             print_item ( "\t -> link       : $",(word)((plus_obj -> link[0] << BITS_PER_BYTE) | (plus_obj -> link[1])) ) ;
  368.             print_item ( "\t -> holds      : $",(word)((plus_obj -> holds[0] << BITS_PER_BYTE) | (plus_obj -> holds[1])) ) ;
  369.             print_item ( "\t -> prop_ptr   : $",(word)((plus_obj -> prop_ptr[0] << BITS_PER_BYTE) | (plus_obj -> prop_ptr[1])) ) ;
  370.             if ( opt & SHOW_PROPS )
  371.                 show_plus_props ( i ) ;
  372.         }
  373.         new_line () ;
  374.     }
  375. }
  376.  
  377. Void
  378. bit_byte ( bits )
  379. byte    bits ;
  380. {
  381.     register byte    i ;
  382.  
  383.     for ( i = FIRST_ATTRIBUTE ; i ; i >>= 1 )
  384.         out_char( bits & i ? '1' : '0' ) ;
  385.     out_char( ' ' ) ;
  386. }
  387.  
  388. Void
  389. show_tree ( version )
  390. byte    version ;
  391. {
  392.     extern header                data_head ;
  393.     extern std_object_ptr        std_obj_list ;
  394.     extern plus_object_ptr        plus_obj_list ;
  395.     extern byte_ptr                base_ptr ;
  396.  
  397.     register std_object_ptr        std_obj ;
  398.     register plus_object_ptr    plus_obj ;
  399.     word                        location ;
  400.     word                        i ;
  401.     int                            n_objs ;
  402.  
  403.     display ( "INFOCOM Adventure - Object Tree." ) ;
  404.     new_line () ;
  405.     new_line () ;
  406.     if ( data_head.z_code_version <= VERSION_3 )
  407.     {
  408.         std_obj = STD_OBJ_ADDR ( 1 ) ;
  409.         n_objs = (( std_obj -> prop_ptr[0] << BITS_PER_BYTE ) + std_obj -> prop_ptr[1] - ( (byte_ptr)std_obj - base_ptr )) / (unsigned int)STD_OBJ_SIZE ;
  410.     }
  411.     else
  412.     {
  413.         plus_obj = PLUS_OBJ_ADDR ( 1 ) ;
  414.         n_objs = (( plus_obj -> prop_ptr[0] << BITS_PER_BYTE ) + plus_obj -> prop_ptr[1] - ( (byte_ptr)plus_obj - base_ptr )) / (unsigned int)PLUS_OBJ_SIZE ;
  415.     }
  416.     print_item ( "Number of Objects: $",(word)n_objs ) ;
  417.     new_line () ;
  418.     new_line () ;
  419.     for ( i = 1 ; i <= (word)n_objs ; i++ )
  420.     {
  421.         if ( version <= VERSION_3 )
  422.         {
  423.             std_obj = STD_OBJ_ADDR ( i ) ;
  424.             location = (word)( std_obj -> location[0] ) ;
  425.         }
  426.         else
  427.         {
  428.             plus_obj = PLUS_OBJ_ADDR ( i ) ;
  429.             location = ( plus_obj -> location[0] << BITS_PER_BYTE ) | ( plus_obj -> location[1] ) ;
  430.         }
  431.         if ( location == 0 )
  432.         {
  433.             obtree ( version,i,0 ) ;
  434.             new_line () ;
  435.         }
  436.     }
  437. }
  438.  
  439. Void
  440. obtree ( version,o1,level )
  441. byte    version ;
  442. word    o1 ;
  443. int        level ;
  444. {
  445.     extern std_object_ptr        std_obj_list ;
  446.     extern plus_object_ptr        plus_obj_list ;
  447.  
  448.     register std_object_ptr        std_obj ;
  449.     register plus_object_ptr    plus_obj ;
  450.     register word                temp ;
  451.     int                            i ;
  452.  
  453.     for ( i = level ; i ; i-- )
  454.         out_char( '\t' ) ;
  455.     display ( "$" ) ;
  456.     hex_display ( o1 ) ;
  457.     display ( " : " ) ;
  458.  
  459.     if ( version <= VERSION_3 )
  460.     {
  461.         if ( prop_name ( o1 ) )
  462.             std_p_obj ( o1 ) ;
  463.         else
  464.             display ( "<No Name>" ) ;
  465.         new_line () ;
  466.         std_obj = STD_OBJ_ADDR ( o1 ) ;
  467.         if ( std_obj -> holds[0] )
  468.             obtree ( version,(word)( std_obj -> holds[0] ),level + 1 ) ;
  469.         if ( std_obj -> link[0] )
  470.             obtree ( version,(word)( std_obj -> link[0] ),level ) ;
  471.     }
  472.     else
  473.     {
  474.         if ( prop_name ( o1 ) )
  475.             plus_p_obj ( o1 ) ;
  476.         else
  477.             display ( "<No Name>" ) ;
  478.         new_line () ;
  479.         plus_obj = PLUS_OBJ_ADDR ( o1 ) ;
  480.         temp = ( plus_obj -> holds[0] << BITS_PER_BYTE ) | ( plus_obj -> holds[1] ) ;
  481.         if ( temp )
  482.             obtree ( version,temp,level+1 ) ;
  483.         temp = ( plus_obj -> link[0] << BITS_PER_BYTE ) | ( plus_obj -> link[1] ) ;
  484.         if ( temp )
  485.             obtree ( version,temp,level ) ;
  486.     }
  487. }
  488.