home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / GAMES / infocom_src.lha / plus_fns.c < prev    next >
Text File  |  1993-03-03  |  16KB  |  836 lines
  1. /*
  2. **    File:    plus_fns.c
  3. **
  4. **    (C)opyright 1987-1992 InfoTaskforce.
  5. */
  6.  
  7. #include    <stdio.h>
  8. #include    "infocom.h"
  9.  
  10. /*
  11. **    PLUS Interpreter Function Definitions.
  12. */
  13.  
  14. Void
  15. parameter_copy ( src,dst )
  16. word    *src ;
  17. word    *dst ;
  18. {
  19.     word    src_size ;
  20.     word    dst_size ;
  21.  
  22.     src_size = *src++ ;
  23.     dst_size = *dst++ ;
  24.     if ( src_size > dst_size )
  25.     {
  26.         src += dst_size ;
  27.         dst += dst_size ;
  28.         src_size -= dst_size ;
  29.         while ( src_size-- )
  30.             *dst++ = *src++ ;
  31.     }
  32. }
  33.  
  34. Void
  35. plus_compare2 ()
  36. {
  37.     extern word        param_stack[] ;
  38.  
  39.     register word    *ptr    = ¶m_stack[1] ;
  40.     register word    data ;            /* Parameter 1 */
  41.     register word    address ;        /* Parameter 2 */
  42.     register word    num_words ;        /* Parameter 3 */
  43.     word            addr_page ;
  44.     word            addr_offset ;
  45.  
  46.     data = *ptr++ ;
  47.     address = *ptr++ ;
  48.     num_words = *ptr++ ;
  49.     addr_page = address / BLOCK_SIZE ;
  50.     addr_offset = address % BLOCK_SIZE ;
  51.     while ( num_words-- != 0 )
  52.     {
  53.         if ( data == get_word ( &addr_page,&addr_offset ) )
  54.         {
  55.             address = ( addr_page * BLOCK_SIZE ) + addr_offset - 2 ;
  56.             store ( address ) ;
  57.             ret_value ( TRUE ) ;
  58.             return ;
  59.         }
  60.     }
  61.     store ( (word)0 ) ;
  62.     ret_value ( FALSE ) ;
  63. }
  64.  
  65. Void
  66. adv_compare2 ()
  67. {
  68.     extern word        param_stack[] ;
  69.     extern word        default_param_stack[] ;
  70.  
  71.     register word    *ptr    = ¶m_stack[1] ;
  72.     register word    data ;            /* Parameter 1 */
  73.     register word    address ;        /* Parameter 2 */
  74.     register word    num_words ;        /* Parameter 3 */
  75.     register word    inc ;            /* Parameter 4 */
  76.     register word    data_size ;        /* Parameter 4 */
  77.     word            addr_page ;
  78.     word            addr_offset ;
  79.  
  80.     default_param_stack[0] = 4 ;
  81.     default_param_stack[4] = 0x82 ;
  82.     parameter_copy ( default_param_stack,param_stack ) ;
  83.     data = *ptr++ ;
  84.     address = *ptr++ ;
  85.     num_words = *ptr++ ;
  86.     inc = *ptr & 0x7F ;
  87.     data_size = *ptr & 0x80 ;
  88.     while ( num_words-- )
  89.     {
  90.         addr_page = address / BLOCK_SIZE ;
  91.         addr_offset = address % BLOCK_SIZE ;
  92.         if ( data_size != 0 )
  93.         {
  94.             if ( data == get_word ( &addr_page,&addr_offset ) )
  95.             {
  96.                 store ( address ) ;
  97.                 ret_value ( TRUE ) ;
  98.                 return ;
  99.             }
  100.         }
  101.         else
  102.         {
  103.             if ( (byte)data == get_byte ( &addr_page,&addr_offset ) )
  104.             {
  105.                 store ( address ) ;
  106.                 ret_value ( TRUE ) ;
  107.                 return ;
  108.             }
  109.         }
  110.         address += inc ;
  111.     }
  112.     store ( (word)0 ) ;
  113.     ret_value ( FALSE ) ;
  114. }
  115.  
  116. Void
  117. gosub2 ( address )
  118. word    address ;
  119. {
  120.     extern proc_ptr    jmp_op2[] ;
  121.     extern word        param_stack[] ;
  122.  
  123.     param_stack[0] = 1 ;
  124.     param_stack[1] = address ;
  125.  
  126.     /*
  127.     **    Call the current "gosub" opcode ...
  128.     */
  129.  
  130.     (*jmp_op2[0x20])() ;
  131. }
  132.  
  133. Void
  134. do_beep ( sound )
  135. word    sound ;
  136. {
  137.     /*
  138.     **    Note: The only legal values for sound are 1 and 2.
  139.     */
  140.  
  141.     while ( sound-- )
  142.         putchar ( BELL ) ;
  143. }
  144.  
  145. Void
  146. erase_line ( mode )
  147. word    mode ;
  148. {
  149.     /*
  150.     **    "mode" must be 1.
  151.     **    The characters at the cursor and to the right are erased.
  152.     **    The cursor itself is not moved.
  153.     */
  154.  
  155.     if ( mode == 1 )
  156.         ERASE_TO_EOLN () ;
  157. }
  158.  
  159. Void
  160. do_clear_screen ( param )
  161. word    param ;
  162. {
  163.     extern header    data_head ;
  164.     extern word        window_height ;
  165.     extern int        screen_height ;
  166.     extern word        top_screen_line ;
  167.  
  168.     signed_word        window ;
  169.  
  170.     window = (signed_word)param ;
  171.     switch ( window )
  172.     {
  173.         case -1:
  174.                 split_screen ( (word)0 ) ;
  175.                 ERASE_WINDOW ( top_screen_line,(word)screen_height ) ;
  176.                 if ( data_head.z_code_version == VERSION_4 )
  177.                 {
  178.                     /*
  179.                     **    cursor to bottom l.h.s
  180.                     */
  181.  
  182.                     GOTO_XY ( 0,screen_height - 1 ) ;
  183.                 }
  184.                 break ;
  185.         case 0:
  186.                 ERASE_WINDOW ( window_height,(word)screen_height ) ;
  187.                 break ;
  188.         case 1:
  189.                 ERASE_WINDOW ( top_screen_line,window_height ) ;
  190.                 break ;
  191.     }
  192. }
  193.  
  194. Void
  195. set_cursor_posn ()
  196. {
  197.     /*
  198.     **    Here is some code from either a MAC or an AMIGA.
  199.     **    It is different to that used by the IBM PC (see below).
  200.     **    Which is better ?
  201.     **
  202.     **        if ( current_window != 1 )
  203.     **            error ( PLUS_ERROR_2 ) ;
  204.     **        GOTO_XY ( param_stack[2],param_stack[1] ) ;
  205.     */
  206.  
  207.     extern header    data_head ;
  208.     extern word        param_stack[] ;
  209.     extern word        current_window ;
  210.     extern boolean    use_buffered_io ;
  211.  
  212.     if ( data_head.z_code_version >= VERSION_5 )
  213.     {
  214.         flush_prt_buff () ;
  215.         GOTO_XY ( --param_stack[2],--param_stack[1] ) ;
  216.     }
  217.     else
  218.     {
  219.         if ( use_buffered_io == FALSE )
  220.         {
  221.             if ( current_window != 0 )
  222.                 GOTO_XY ( --param_stack[2],--param_stack[1] ) ;
  223.         }
  224.     }
  225. }
  226.  
  227. Void
  228. set_text_mode ( mode )
  229. word    mode ;
  230. {
  231.     /*
  232.     **    Mode:
  233.     **            0 = NORMAL_MODE ;
  234.     **            1 = INVERSE_MODE ;
  235.     **            2 = BOLD_MODE ;
  236.     */
  237.  
  238.     /*
  239.     **    In interpreters prior to VERSION_5, the "mode" parameter is not
  240.     **    checked before being incremented and passed to "print_char ()".
  241.     **    In VERSION_5 and subsequent interpreters, the "mode" parameter
  242.     **    is checked first.
  243.     **
  244.     **    However, there is no reason for us not to adopt the VERSION_5
  245.     **    method for all versions of the interpreter.
  246.     **
  247.     **    Interpreters prior to VERSION_5 did not include the statement:
  248.     **
  249.     **                if ( mode < 5 )
  250.     */
  251.  
  252.     if ( mode < 5 )
  253.         print_char ( ++mode ) ;
  254. }
  255.  
  256. Void
  257. io_buffer_mode ( param )
  258. word    param ;
  259. {
  260.     extern boolean    use_buffered_io ;
  261.  
  262.     if ( param == 0 )
  263.     {
  264.         use_buffered_io = FALSE ;
  265.         flush_prt_buff () ;
  266.     }
  267.     else
  268.         use_buffered_io = TRUE ;
  269. }
  270.  
  271. Void
  272. io_mode ()
  273. {
  274.     extern header        data_head ;
  275.     extern word            param_stack[] ;
  276.     extern byte_ptr        base_ptr ;
  277.     extern byte_ptr        internal_io_buffer ;
  278.     extern byte_ptr        internal_io_ptr ;
  279.     extern word            int_io_buff_length ;
  280.     extern boolean        enable_screen ;
  281.     extern boolean        script_on ;
  282.     extern boolean        use_internal_buffer ;
  283.  
  284.     byte_ptr            ptr ;
  285.     signed_word            mode ;
  286.  
  287.     mode = (signed_word)param_stack[1] ;
  288.     switch ( mode )
  289.     {
  290.         case 1:
  291.                 enable_screen = TRUE ;
  292.                 break ;
  293.         case 2:
  294.                 if ( script_on == FALSE )
  295.                 {
  296.                     data_head.script_status |= SCRIPT_MODE_ON ;
  297.                     if (( script_on = open_script () ) == FALSE )
  298.                         data_head.script_status = SCRIPT_ERROR ;
  299.                     ptr = (byte_ptr) &(((header_ptr)base_ptr) -> script_status) ;
  300.                     *ptr++ = MOST_SIGNIFICANT_BYTE ( data_head.script_status ) ;
  301.                     *ptr = LEAST_SIGNIFICANT_BYTE ( data_head.script_status ) ;
  302.                 }
  303.                 break ;
  304.         case 3:
  305.                 use_internal_buffer = TRUE ;
  306.                 internal_io_buffer = base_ptr + param_stack[2] ;
  307.                 int_io_buff_length = 0 ;
  308.                 internal_io_ptr = internal_io_buffer + 2 ;
  309.                 break ;
  310.         case -1:
  311.                 enable_screen = FALSE ;
  312.                 break ;
  313.         case -2:
  314.                 script_on = FALSE ;
  315.                 data_head.script_status &= SCRIPT_MODE_OFF ;
  316.                 close_script () ;
  317.                 ptr = (byte_ptr) &(((header_ptr)base_ptr) -> script_status) ;
  318.                 *ptr++ = MOST_SIGNIFICANT_BYTE ( data_head.script_status ) ;
  319.                 *ptr = LEAST_SIGNIFICANT_BYTE ( data_head.script_status ) ;
  320.                 break ;
  321.         case -3:
  322.                 use_internal_buffer = FALSE ;
  323.                 *internal_io_buffer++ = MOST_SIGNIFICANT_BYTE ( int_io_buff_length ) ;
  324.                 *internal_io_buffer = LEAST_SIGNIFICANT_BYTE ( int_io_buff_length ) ;
  325.                 *internal_io_ptr = 0 ;
  326.                 break ;
  327.     }
  328. }
  329.  
  330. Void
  331. get_key ()
  332. {
  333.     extern header    data_head ;
  334.     extern word        param_stack[] ;
  335.     extern int        linecount ;
  336.  
  337.     if ( data_head.z_code_version >= VERSION_5 )
  338.         flush_prt_buff () ;
  339.  
  340.     linecount = 0 ;
  341.     if ( param_stack[1] == 1 )
  342.     {
  343.         if ( param_stack[0] < 3 )
  344.         {
  345.             store ( read_the_key () ) ;
  346.             return ;
  347.         }
  348.         else
  349.         {
  350.             if ( wait_for_key ( param_stack[2]/10,param_stack[3] ) == TRUE )
  351.             {
  352.                 store ( read_the_key () ) ;
  353.                 return ;
  354.             }
  355.         }
  356.     }
  357.     store ( (word)0 ) ;
  358. }
  359.  
  360. word
  361. read_the_key ()
  362. {
  363.     /*
  364.     **    This routine assumes that special keys such as the cursor
  365.     **    movement and backspace/delete keys have been translated by
  366.     **    the "GET_CH" routine.
  367.     **
  368.     **    The following translations are suggested:
  369.     **
  370.     **        DELETE        -> BACK_SPACE character ('\b')
  371.     **        LEFT_ARROW    -> BACK_SPACE character ('\b')
  372.     **        RIGHT_ARROW    -> BELL character (0x07)
  373.     **        UP_ARROW    -> VERTICAL_TAB character (0x0B)
  374.     **        DOWN_ARROW    -> CARRIAGE_RETURN character ('\r')
  375.     **
  376.     **    This routine translates '\n' to '\r'.
  377.     */
  378.  
  379.     register int    ch ;
  380.     register int    done    = FALSE ;
  381.  
  382.     while ( ! done )
  383.     {
  384.         switch ( ch = GET_CH () )
  385.         {
  386.             case BELL:
  387.             case VERTICAL_TAB:
  388.             case '\b':
  389.             case '\n':
  390.                         done = TRUE ;
  391.                         break ;
  392.             case '\l':
  393.                         ch = '\r' ;
  394.                         done = TRUE ;
  395.                         break ;
  396.             default:
  397.                         if ( ch >= ' ' )
  398.                             done = TRUE ;
  399.                         break ;
  400.         }
  401.     }
  402.     return ( (word)ch ) ;
  403. }
  404.  
  405. boolean
  406. wait_for_key ( time_out,address )
  407. word    time_out ;
  408. word    address ;
  409. {
  410.     register word    delay ;
  411.     register long    now ;
  412.     register long    next ;
  413.  
  414.     do
  415.     {
  416.         delay = time_out ;
  417.         do
  418.         {
  419.             now = TIME_FUNCTION ;
  420.             do
  421.             {
  422.                 if ( KBD_HIT () )
  423.                     return ( TRUE ) ;
  424.                 next = TIME_FUNCTION ;
  425.             } while ( next - now < ONE_SECOND ) ;
  426.             now = next ;
  427.         } while ( --delay != 0 ) ;
  428.     } while ( special_gosub ( address ) == 0 ) ;
  429.     return ( FALSE ) ;
  430. }
  431.  
  432. word
  433. special_gosub ( address )
  434. word    address ;
  435. {
  436.     extern proc_ptr    jmp_op2[] ;
  437.     extern word        param_stack[] ;
  438.     extern word        pc_page ;
  439.     extern word        *stack ;
  440.     extern boolean    stop ;
  441.  
  442.     word            value ;
  443.     boolean            old_stop ;
  444.  
  445.     old_stop = stop ;
  446.     *(--stack) = pc_page ;
  447.     pc_page = EMPTY_PAGE ;
  448.     param_stack[0] = 1 ;
  449.     param_stack[1] = address ;
  450.  
  451.     /*
  452.     **    Call the current "gosub" opcode ...
  453.     */
  454.  
  455.     (*jmp_op2[0x20])() ;
  456.  
  457.     execute_opcode () ;
  458.     value = *stack++ ;
  459.     pc_page = *stack++ ;
  460.     fix_pc () ;
  461.     stop = old_stop ;
  462.     return ( value ) ;
  463. }
  464.  
  465. /*
  466. **    ADVANCED Interpreter Function Definitions.
  467. */
  468.  
  469. Void
  470. gosub4 ()
  471. {
  472.     call ( PROCEDURE ) ;
  473. }
  474.  
  475. Void
  476. gosub5 ( address )
  477. word    address ;
  478. {
  479.     extern word        param_stack[] ;
  480.  
  481.     param_stack[0] = 1 ;
  482.     param_stack[1] = address ;
  483.     gosub4 () ;
  484. }
  485.  
  486. Void
  487. call ( type )
  488. word    type ;
  489. {
  490.     extern word        pc_offset ;
  491.     extern word        pc_page ;
  492.     extern word        *stack_base ;
  493.     extern word        *stack_var_ptr ;
  494.     extern word        *stack ;
  495.     extern word        param_stack[] ;
  496.     extern byte        local_params ;
  497.  
  498.     register word    *param_ptr = ¶m_stack[0] ;
  499.     register word    address ;
  500.     register word    parameter ;
  501.     register int    num_params ;
  502.     int                vars ;
  503.  
  504.     num_params = (int) *param_ptr++ ;
  505.     if (( address = *param_ptr++ ) == 0 )
  506.     {
  507.         if ( type != PROCEDURE )
  508.             store ( address ) ;
  509.     }
  510.     else
  511.     {
  512.         --num_params ;
  513.         *(--stack) = pc_page ;
  514.         *(--stack) = pc_offset ;
  515.         *(--stack) = type | local_params ;
  516.  
  517.         /*
  518.         **    Push offset of old stack_var_ptr from stack_base onto stack
  519.         */
  520.  
  521.         *(--stack) = (word)(stack_var_ptr - stack_base) ;
  522.  
  523.         pc_page = PLUS_PAGE ( address ) ;
  524.         pc_offset = PLUS_OFFSET ( address ) ;
  525.         fix_pc () ;
  526.  
  527.         /*
  528.         **    The value of the current stack pointer is the
  529.         **    new value of stack_var_ptr.
  530.         */
  531.  
  532.         stack_var_ptr = stack ;
  533.         local_params = num_params ;
  534.  
  535.         /*
  536.         **    Global variables 1 to 15 are Local variables, which
  537.         **    reside on the stack (and so are local to each procedure).
  538.         */
  539.  
  540.         vars = (int) next_byte () ;
  541.         if ( vars > ( (int)LOCAL_VARS - 1 ) )
  542.         {
  543.             display ( "Bad loc num" ) ;
  544.             vars = LOCAL_VARS - 1 ;
  545.         }
  546.         if ( num_params > vars )
  547.         {
  548.             display ( "Bad optional num" ) ;
  549.             num_params = vars ;
  550.         }
  551.         vars -= num_params ;
  552.         while ( num_params-- )
  553.             *(--stack) = *param_ptr++ ;
  554.         while ( vars-- )
  555.             *(--stack) = 0 ;
  556.     }
  557. }
  558.  
  559. Void
  560. branch_true ()
  561. {
  562.     ret_value ( TRUE ) ;
  563. }
  564.  
  565. Void
  566. throw_away_stack_frame ( value,stack_offset )
  567. word    value ;
  568. word    stack_offset ;
  569. {
  570.     extern word        *stack_base ;
  571.     extern word        *stack_var_ptr ;
  572.  
  573.     register word    *new_svp ;
  574.  
  575.     new_svp = stack_base + (signed_word)stack_offset ;
  576.     if ( new_svp < stack_var_ptr )
  577.         display ( "Bad Throw" ) ;
  578.     else
  579.     {
  580.         stack_var_ptr = new_svp ;
  581.         adv_rtn ( value ) ;
  582.     }
  583. }
  584.  
  585. Void
  586. parse ()
  587. {
  588.     extern word            default_param_stack[] ;
  589.     extern word            param_stack[] ;
  590.     extern byte_ptr        base_ptr ;
  591.     extern byte_ptr        main_vocab_list ;
  592.  
  593.     byte_ptr            in_buf_strt ;
  594.     byte_ptr            word_buff_strt ;
  595.     byte_ptr            vocab_strt ;
  596.  
  597.     default_param_stack[0] = 4 ;
  598.     default_param_stack[3] = 0 ;
  599.     default_param_stack[4] = 0 ;
  600.     parameter_copy ( default_param_stack,param_stack ) ;
  601.  
  602.     in_buf_strt = base_ptr + param_stack[1] ;
  603.     word_buff_strt = base_ptr + param_stack[2] ;
  604.     if ( param_stack[3] == 0 )
  605.         vocab_strt = main_vocab_list ;
  606.     else
  607.         vocab_strt = base_ptr + param_stack[3] ;
  608.     advanced_parse_buffer ( in_buf_strt,word_buff_strt,vocab_strt,param_stack[4] ) ;
  609. }
  610.  
  611. Void
  612. encrypt ( param1,param2,param3,param4 )
  613. word    param1 ;
  614. word    param2 ;
  615. word    param3 ;
  616. word    param4 ;
  617. {
  618.     extern byte_ptr        base_ptr ;
  619.  
  620.     word                coded[PLUS_ENCODED_SIZE] ;
  621.     byte_ptr            ptr ;
  622.     register word        i ;
  623.  
  624.     ptr = base_ptr + param1 + param3 ;
  625.     i = get_code ( &ptr,PLUS_CHARS_PER_WORD,coded ) ;
  626.     ptr = base_ptr + param4 ;
  627.     for ( i = 0 ; i < PLUS_ENCODED_SIZE ; i++ )
  628.     {
  629.         *ptr++ = MOST_SIGNIFICANT_BYTE ( coded[i] ) ;
  630.         *ptr++ = LEAST_SIGNIFICANT_BYTE ( coded[i] ) ;
  631.     }
  632. }
  633.  
  634. Void
  635. block_copy ()
  636. {
  637.     extern word                param_stack[] ;
  638.     extern byte_ptr            base_ptr ;
  639.  
  640.     register word            *ptr        = ¶m_stack[1] ;
  641.     register boolean        negative    = FALSE ;
  642.     register byte_ptr        dst ;
  643.     register word            src_offset ;    /* Parameter 1 */
  644.     register word            dst_offset ;    /* Parameter 2 */
  645.     register signed_word    num_words ;        /* Parameter 3 */
  646.     word                    addr_page ;
  647.     word                    addr_offset ;
  648.  
  649.     src_offset = *ptr++ ;
  650.     dst_offset = *ptr++ ;
  651.     if ( src_offset != dst_offset )
  652.     {
  653.         num_words = (signed_word)*ptr ;
  654.         if ( num_words != 0 )
  655.         {
  656.             if ( num_words < 0 )
  657.             {
  658.                 negative = TRUE ;
  659.                 num_words = -num_words ;
  660.             }
  661.             if ( dst_offset == 0 )
  662.             {
  663.                 dst = base_ptr + src_offset ;
  664.                 while ( num_words-- )
  665.                     *dst++ = 0 ;
  666.             }
  667.             else
  668.             {
  669.                 if    (
  670.                         ( negative )
  671.                         ||
  672.                         ( src_offset > dst_offset )
  673.                         ||
  674.                         ( (word)( (signed_word)src_offset + num_words ) < dst_offset )
  675.                     )
  676.                 {
  677.                     dst = base_ptr + dst_offset ;
  678.                     addr_page = src_offset / BLOCK_SIZE ;
  679.                     addr_offset = src_offset % BLOCK_SIZE ;
  680.                     while ( num_words-- )
  681.                         *dst++ = get_byte ( &addr_page,&addr_offset ) ;
  682.                 }
  683.                 else
  684.                 {
  685.                     dst = base_ptr + ( dst_offset + num_words ) ;
  686.                     src_offset += num_words ;
  687.                     while ( num_words-- )
  688.                     {
  689.                         --src_offset ;
  690.                         addr_page = src_offset / BLOCK_SIZE ;
  691.                         addr_offset = src_offset % BLOCK_SIZE ;
  692.                         *(--dst) = get_byte ( &addr_page,&addr_offset ) ;
  693.                     }
  694.                 }
  695.             }
  696.         }
  697.     }
  698. }
  699.  
  700. Void
  701. print_text ()
  702. {
  703.     extern word        default_param_stack[] ;
  704.     extern word        param_stack[] ;
  705.  
  706.     register word    *ptr    = ¶m_stack[1] ;
  707.     register word    address ;        /* Parameter 1 */
  708.     register word    line_width ;    /* Parameter 2 */
  709.     register word    num_lines ;        /* Parameter 3 */
  710.     register word    count ;
  711.     word            addr_page ;
  712.     word            addr_offset ;
  713.     int                cursor_x ;
  714.     int                cursor_y ;
  715.  
  716.     default_param_stack[0] = 3 ;
  717.     default_param_stack[3] = 1 ;
  718.     parameter_copy ( default_param_stack,param_stack ) ;
  719.  
  720.     cursor_x = GET_X () ;
  721.     cursor_y = GET_Y () ;
  722.     address = *ptr++ ;
  723.     line_width = *ptr++ ;
  724.     num_lines = *ptr++ ;
  725.     if ( line_width > 0 )
  726.     {
  727.         while ( num_lines )
  728.         {
  729.             count = line_width ;
  730.             addr_page = address / BLOCK_SIZE ;
  731.             addr_offset = address % BLOCK_SIZE ;
  732.             while ( count-- )
  733.                 print_char ( (word) get_byte ( &addr_page,&addr_offset ) ) ;
  734.             if ( --num_lines )
  735.             {
  736.                 /*
  737.                 **    New Line.
  738.                 */
  739.  
  740.                 GOTO_XY ( cursor_x,++cursor_y ) ;
  741.                 address += line_width ;
  742.             }
  743.         }
  744.     }
  745. }
  746.  
  747. Void
  748. num_local_params ( num_params )
  749. word    num_params ;
  750. {
  751.     extern byte        local_params ;
  752.  
  753.     if ( num_params <= (word)local_params )
  754.         ret_value ( TRUE ) ;
  755.     else
  756.         ret_value ( FALSE ) ;
  757. }
  758.  
  759. Void
  760. logical_shift ( param1,param2 )
  761. word    param1 ;
  762. word    param2 ;
  763. {
  764.     register signed_word    bits_to_shift ;
  765.  
  766.     bits_to_shift = (signed_word) param2 ;
  767.     if ( bits_to_shift < 0 )
  768.         store ( (word)( param1 >> ( -bits_to_shift ) ) ) ;
  769.     else
  770.         store ( (word)( param1 << bits_to_shift ) ) ;
  771. }
  772.  
  773. Void
  774. arithmetic_shift ( param1,param2 )
  775. word    param1 ;
  776. word    param2 ;
  777. {
  778.     register signed_word    bits_to_shift ;
  779.  
  780.     bits_to_shift = (signed_word) param2 ;
  781.     if ( bits_to_shift < 0 )
  782.     {
  783.         if ( ( (signed_word)param1 ) < 0 )
  784.             store ( (word)( ~((signed_word)( ~param1 ) >> ( -bits_to_shift )) ) ) ;
  785.         else
  786.             store ( (word)( (signed_word)param1 >> ( -bits_to_shift ) ) ) ;
  787.     }
  788.     else
  789.         store ( (word)( param1 << bits_to_shift ) ) ;
  790. }
  791.  
  792. Void
  793. clear_flag ()
  794. {
  795.     /*
  796.     **    Load a register with 0 but don't do anything with it.
  797.     */
  798. }
  799.  
  800. Void
  801. set_flag ()
  802. {
  803.     /*
  804.     **    Load a register with 1 but don't do anything with it.
  805.     */
  806. }
  807.  
  808. int
  809. array_test ( ptr,value )
  810. byte_ptr    ptr ;
  811. word        value ;
  812. {
  813.     /*
  814.     **    This function is only used by "test_byte_array ()".
  815.     **    On a MAC, it always returns -1.
  816.     */
  817.  
  818.     return ( -1 ) ;
  819. }
  820.  
  821. Void
  822. test_byte_array ( value,offset )
  823. word    value ;
  824. word    offset ;
  825. {
  826.     extern byte_ptr        base_ptr ;
  827.  
  828.     register byte_ptr    ptr ;
  829.  
  830.     ptr = base_ptr + offset ;
  831.     if ( array_test ( ptr,value ) >= 0 )
  832.         ret_value ( TRUE ) ;
  833.     else
  834.         ret_value ( FALSE ) ;
  835. }
  836.