home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / GAMES / infocom_src.lha / support.c < prev    next >
Text File  |  1993-03-03  |  3KB  |  232 lines
  1. /*
  2. **    File:    support.c
  3. **
  4. **    (C)opyright 1987-1992 InfoTaskforce.
  5. */
  6.  
  7. #include    "infocom.h"
  8.  
  9. Void
  10. null ()
  11. {
  12.     /*
  13.     **    The NULL function
  14.     */
  15. }
  16.  
  17. Void
  18. restart ()
  19. {
  20.     extern word            save_blocks ;
  21.     extern byte_ptr        base_ptr ;
  22.  
  23.     new_line () ;
  24.     load_page ( 0,save_blocks,base_ptr ) ;
  25.     init_interpreter ( TRUE ) ;
  26. }
  27.  
  28. Void
  29. quit ()
  30. {
  31.     extern boolean    stop ;
  32.  
  33.     stop = TRUE ;
  34. }
  35.  
  36. Void
  37. verify ()
  38. {
  39.     extern word        resident_blocks ;
  40.     extern header    data_head ;
  41.  
  42.     register word    sum ;
  43.     register word    addr_hi ;
  44.     register word    addr_lo ;
  45.     word            page ;
  46.     word            offset ;
  47.     word            save ;
  48.  
  49.     if ( data_head.z_code_version <= VERSION_3 )
  50.     {
  51.         addr_lo = STD_OFFSET ( data_head.verify_length ) ;
  52.         addr_hi = STD_PAGE ( data_head.verify_length ) ;
  53.     }
  54.     else
  55.     {
  56.         addr_lo = PLUS_OFFSET ( data_head.verify_length ) ;
  57.         addr_hi = PLUS_PAGE ( data_head.verify_length ) ;
  58.     }
  59.     save = resident_blocks ;
  60.     resident_blocks = 0 ;
  61.     page = 0 ;
  62.     offset = sizeof ( header ) ;
  63.     sum = 0 ;
  64.     while (( page != addr_hi ) || ( offset != addr_lo ))
  65.         sum += get_byte ( &page,&offset ) ;
  66.  
  67.     resident_blocks = save ;
  68.     if ( sum == data_head.verify_checksum )
  69.         ret_value ( TRUE ) ;
  70.     else
  71.         ret_value ( FALSE ) ;
  72. }
  73.  
  74. Void
  75. store ( value )
  76. word    value ;
  77. {
  78.     extern word        *stack ;
  79.  
  80.     word            var ;
  81.  
  82.     var = next_byte () ;
  83.     if ( var == 0 )
  84.         *(--stack) = value ;
  85.     else
  86.         put_var ( var,value ) ;
  87. }
  88.  
  89. Void
  90. ret_value ( result )
  91. word    result ;
  92. {
  93.     extern word        pc_offset ;
  94.  
  95.     word    branch ;
  96.  
  97.     branch = next_byte () ;
  98.  
  99.     /*
  100.     **    Test bit 7
  101.     */
  102.  
  103.     if (( branch & 0x80 ) != 0 )
  104.     {
  105.         /*
  106.         **    Clear bit 7
  107.         */
  108.  
  109.         branch &= 0x7F ;
  110.         ++result ;
  111.     }
  112.  
  113.     /*
  114.     **    Test bit 6
  115.     */
  116.  
  117.     if (( branch & 0x40 ) == 0 )
  118.     {
  119.         branch = ( branch << BITS_PER_BYTE ) | next_byte () ;
  120.  
  121.         /*
  122.         **    Test bit D. If set, make branch negative.
  123.         */
  124.  
  125.         if ( branch & 0x2000 )
  126.             branch |= 0xC000 ;
  127.     }
  128.     else
  129.     {
  130.         /*
  131.         **    Clear bit 6
  132.         */
  133.  
  134.         branch &= 0xBF ;
  135.     }
  136.  
  137.     if (( --result ) != 0 )
  138.     {
  139.         switch ( branch )
  140.         {
  141.             case 0 :    ret_false () ;
  142.                         break ;
  143.             case 1 :    ret_true () ;
  144.                         break ;
  145.             default :    pc_offset += ( branch - 2 ) ;
  146.                         fix_pc () ;
  147.         }
  148.     }
  149. }
  150.  
  151. byte
  152. get_byte ( page,offset )
  153. word    *page ;
  154. word    *offset ;
  155. {
  156.     extern word            resident_blocks ;
  157.     extern byte_ptr        base_ptr ;
  158.  
  159.     byte_ptr            ptr ;
  160.  
  161.     if ( *page < resident_blocks )
  162.         ptr = base_ptr + ((signed_long)*page * BLOCK_SIZE) + *offset ;
  163.     else
  164.         ptr = fetch_page ( *page ) + *offset ;
  165.     ++(*offset) ;
  166.     if ( *offset == BLOCK_SIZE )
  167.     {
  168.         *offset = 0 ;
  169.         ++(*page) ;
  170.     }
  171.     return ( *ptr ) ;
  172. }
  173.  
  174. word
  175. get_word ( page,offset )
  176. word    *page ;
  177. word    *offset ;
  178. {
  179.     word    temp ;
  180.  
  181.     temp = get_byte ( page,offset ) << BITS_PER_BYTE ;
  182.     return ( temp | get_byte ( page,offset ) ) ;
  183. }
  184.  
  185. byte
  186. next_byte ()
  187. {
  188.     extern word            pc_offset ;
  189.     extern byte_ptr        prog_block_ptr ;
  190.  
  191.     register byte_ptr    ptr ;
  192.  
  193.     ptr = prog_block_ptr + pc_offset++ ;
  194.     if ( pc_offset == BLOCK_SIZE )
  195.         fix_pc () ;
  196.     return ( *ptr ) ;
  197. }
  198.  
  199. word
  200. next_word ()
  201. {
  202.     word    temp ;
  203.  
  204.     temp = next_byte () << BITS_PER_BYTE ;
  205.     return ( temp | next_byte () ) ;
  206. }
  207.  
  208. Void
  209. error ( err_num )
  210. word    err_num ;
  211. {
  212.     char    ch[4] ;
  213.  
  214.     /*
  215.     **    'err_num' must be between 00 and 99 inclusive.
  216.     **    We can't use print_char or print_num because the print
  217.     **    buffer may not yet have been created or initialised.
  218.     */
  219.  
  220.     display ( "\nInternal Error " ) ;
  221.     if ( err_num != ERR_MEMORY )
  222.     {
  223.         ch[0] = '#' ;
  224.         ch[1] = '0' + ( err_num / 10 ) ;
  225.         ch[2] = '0' + ( err_num % 10 ) ;
  226.         ch[3] = 0 ;
  227.         display ( ch ) ;
  228.     }
  229.     display ( "\n" ) ;
  230.     quit () ;
  231. }
  232.