home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 2 / crawlyvol2.bin / program / c / itf_src / variable.c < prev    next >
C/C++ Source or Header  |  1992-12-22  |  4KB  |  201 lines
  1. /*
  2. **    File:    variable.c
  3. **
  4. **    (C)opyright 1987-1992 InfoTaskforce.
  5. */
  6.  
  7. #include    "infocom.h"
  8.  
  9. Void
  10. get_var ( var )
  11. word    var ;
  12. {
  13.     store ( load_var ( var ) ) ;
  14. }
  15.  
  16. word
  17. load_var ( var )
  18. word    var ;
  19. {
  20.     extern byte_ptr        global_ptr ;
  21.     extern word            *stack_var_ptr ;
  22.     extern word            *stack ;
  23.  
  24.     register word        value ;
  25.     register word        *svp ;
  26.     register byte_ptr    ptr ;
  27.  
  28.     if ( var == 0 )
  29.         return ( *stack ) ;
  30.     else
  31.     {
  32.         if ( var < LOCAL_VARS )
  33.         {
  34.             /*
  35.             **    In interpreters prior to VERSION_5, the "stack_var_ptr"
  36.             **    pointed to the first local variable on the z_code stack.
  37.             **    In VERSION_5 and subsequent interpreters, the "stack_var_ptr"
  38.             **    points to the stack entry above the first local variable on
  39.             **    the z_code stack.
  40.             **
  41.             **    However, there is no reason for us not to adopt the VERSION_5
  42.             **    method for all versions of the interpreter. This decision
  43.             **    affects the following opcodes:
  44.             **                                gosub, std_rtn, load_var & put_var.
  45.             **
  46.             **    Interpreters prior to VERSION_5 used the statement:
  47.             **
  48.             **                svp = stack_var_ptr - ( var - 1 ) ;
  49.             **
  50.             **    instead of:
  51.             **
  52.             **                svp = stack_var_ptr - var ;
  53.             */
  54.  
  55.             svp = stack_var_ptr - var ;
  56.             return ( *svp ) ;
  57.         }
  58.         else
  59.         {
  60.             ptr = global_ptr + (( var - LOCAL_VARS ) << 1 ) ;
  61.             value = *(ptr++) << BITS_PER_BYTE ;
  62.             return ( (word)(value | *ptr) ) ;
  63.         }
  64.     }
  65. }
  66.  
  67. Void
  68. put_var ( var,value )
  69. word    var,value ;
  70. {
  71.     extern byte_ptr        global_ptr ;
  72.     extern word            *stack_var_ptr ;
  73.     extern word            *stack ;
  74.  
  75.     register word        *svp ;
  76.     register byte_ptr    ptr ;
  77.  
  78.     if ( var == 0 )
  79.         *stack = value ;
  80.     else
  81.     {
  82.         if ( var < LOCAL_VARS )
  83.         {
  84.             /*
  85.             **    In interpreters prior to VERSION_5, the "stack_var_ptr"
  86.             **    pointed to the first local variable on the z_code stack.
  87.             **    In VERSION_5 and subsequent interpreters, the "stack_var_ptr"
  88.             **    points to the stack entry above the first local variable on
  89.             **    the z_code stack.
  90.             **
  91.             **    However, there is no reason for us not to adopt the VERSION_5
  92.             **    method for all versions of the interpreter. This decision
  93.             **    affects the following opcodes:
  94.             **                                gosub, std_rtn, load_var & put_var.
  95.             **
  96.             **    Interpreters prior to VERSION_5 used the statement:
  97.             **
  98.             **                svp = stack_var_ptr - ( var - 1 ) ;
  99.             **
  100.             **    instead of:
  101.             **
  102.             **                svp = stack_var_ptr - var ;
  103.             */
  104.  
  105.             svp = stack_var_ptr - var ;
  106.             *svp = value ;
  107.         }
  108.         else
  109.         {
  110.             ptr = global_ptr + (( var - LOCAL_VARS ) << 1 ) ;
  111.             *ptr++ = MOST_SIGNIFICANT_BYTE ( value ) ;
  112.             *ptr = LEAST_SIGNIFICANT_BYTE ( value ) ;
  113.         }
  114.     }
  115. }
  116.  
  117. Void
  118. push ( value )
  119. word    value ;
  120. {
  121.     extern word        *stack ;
  122.  
  123.     *(--stack) = value ;
  124. }
  125.  
  126. Void
  127. pop ( var )
  128. word    var ;
  129. {
  130.     extern word        *stack ;
  131.  
  132.     put_var ( var,*stack++ ) ;
  133. }
  134.  
  135. Void
  136. inc_var ( var )
  137. word    var ;
  138. {
  139.     put_var ( var,load_var ( var ) + 1 ) ;
  140. }
  141.  
  142. Void
  143. dec_var ( var )
  144. word    var ;
  145. {
  146.     put_var ( var,load_var ( var ) - 1 ) ;
  147. }
  148.  
  149. Void
  150. inc_chk ( var,threshold )
  151. word    var,threshold ;
  152. {
  153.     register word    value ;
  154.  
  155.     value = load_var ( var ) + 1 ;
  156.     put_var ( var,value ) ;
  157.     if ( (signed_word)value > (signed_word)threshold )
  158.         ret_value ( TRUE ) ;
  159.     else
  160.         ret_value ( FALSE ) ;
  161. }
  162.  
  163. Void
  164. dec_chk ( var,threshold )
  165. word    var,threshold ;
  166. {
  167.     register word    value ;
  168.  
  169.     value = load_var ( var ) - 1 ;
  170.     put_var ( var,value ) ;
  171.     if ( (signed_word)value < (signed_word)threshold )
  172.         ret_value ( TRUE ) ;
  173.     else
  174.         ret_value ( FALSE ) ;
  175. }
  176.  
  177. word
  178. load ( mode )
  179. int        mode ;
  180. {
  181.     /*
  182.     **    Mode 0 = Immediate Word ;
  183.     **    Mode 1 = Immediate Byte ;
  184.     **    Mode 2 = Variable ;
  185.     */
  186.  
  187.     extern word        *stack ;
  188.  
  189.     register word    var ;
  190.  
  191.     if ( --mode < 0 )
  192.         return ( next_word () ) ;
  193.     if ( mode == 0 )
  194.         return ( (word)next_byte () ) ;
  195.     var = next_byte () ;
  196.     if ( var == 0 )
  197.         return ( *stack++ ) ;
  198.     else
  199.         return ( load_var ( var ) ) ;
  200. }
  201.