home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / GAMES / infocom_src.lha / property.c < prev    next >
Text File  |  1993-03-03  |  7KB  |  428 lines
  1. /*
  2. **    File:    property.c
  3. **
  4. **    (C)opyright 1987-1992 InfoTaskforce.
  5. */
  6.  
  7. #include    "infocom.h"
  8.  
  9. property
  10. std_prop_addr ( obj )
  11. std_object_ptr        obj ;
  12. {
  13.     extern byte_ptr        base_ptr ;
  14.  
  15.     register property    p ;
  16.  
  17.     p = base_ptr + ((word)(obj -> prop_ptr[0]) << 8) + (obj -> prop_ptr[1]) ;
  18.     return ( p + (*p << 1) + 1 ) ;
  19. }
  20.  
  21. property
  22. plus_prop_addr ( obj )
  23. plus_object_ptr        obj ;
  24. {
  25.     extern byte_ptr        base_ptr ;
  26.  
  27.     register property    p ;
  28.  
  29.     p = base_ptr + ((word)(obj -> prop_ptr[0]) << 8) + (obj -> prop_ptr[1]) ;
  30.     return ( p + (*p << 1) + 1 ) ;
  31. }
  32.  
  33. property
  34. std_next_addr ( p )
  35. register property    p ;
  36. {
  37.     return ( p + STD_PROPERTY_LENGTH ( p ) + 1 ) ;
  38. }
  39.  
  40. property
  41. plus_next_addr ( p )
  42. register property    p ;
  43. {
  44.     register byte    mode ;
  45.  
  46.     mode = *p++ ;
  47.     if ( ( mode & NEXT_BYTE_IS_LENGTH ) == 0 )
  48.     {
  49.         if ( mode & PLUS_WORD_MASK )
  50.             ++p ;
  51.         return ( ++p ) ;
  52.     }
  53.     return ( p + PLUS_PROPERTY_LENGTH ( p ) + 1 ) ;
  54. }
  55.  
  56. Void
  57. std_getprop ( obj_num,prop_num )
  58. word    obj_num ;
  59. word    prop_num ;
  60. {
  61.     extern std_object_ptr    std_obj_list ;
  62.  
  63.     register property        p ;
  64.     register word            p_num ;
  65.     register word            prop ;
  66.  
  67.     p = std_prop_addr ( STD_OBJ_ADDR ( obj_num )) ;
  68.     p_num = STD_PROPERTY_NUMBER ( p ) ;
  69.  
  70.     /*
  71.     **    Properties are kept in descending order
  72.     */
  73.  
  74.     while ( p_num > prop_num )
  75.     {
  76.         p = std_next_addr ( p ) ;
  77.         p_num = STD_PROPERTY_NUMBER ( p ) ;
  78.     }
  79.     if ( p_num < prop_num )
  80.     {
  81.         p = (property) std_obj_list + (( --prop_num ) << 1 ) ;
  82.         prop = (*p++) << 8 ;
  83.         prop += *p ;
  84.     }
  85.     else
  86.     {
  87.         if ( (*p++) & STD_WORD_MASK )
  88.         {
  89.             prop = (*p++) << 8 ;
  90.             prop += *p ;
  91.         }
  92.         else
  93.             prop = *p ;
  94.     }
  95.     store ( prop ) ;
  96. }
  97.  
  98. Void
  99. plus_getprop ( obj_num,prop_num )
  100. word    obj_num ;
  101. word    prop_num ;
  102. {
  103.     extern plus_object_ptr    plus_obj_list ;
  104.  
  105.     register property        p ;
  106.     register word            p_num ;
  107.     register word            prop ;
  108.  
  109.     p = plus_prop_addr ( PLUS_OBJ_ADDR ( obj_num )) ;
  110.     p_num = PLUS_PROPERTY_NUMBER ( p ) ;
  111.  
  112.     /*
  113.     **    Properties are kept in descending order
  114.     */
  115.  
  116.     while ( p_num > prop_num )
  117.     {
  118.         p = plus_next_addr ( p ) ;
  119.         p_num = PLUS_PROPERTY_NUMBER ( p ) ;
  120.     }
  121.     if ( p_num < prop_num )
  122.     {
  123.         p = (property) plus_obj_list + (( --prop_num ) << 1 ) ;
  124.         prop = (*p++) << 8 ;
  125.         prop += *p ;
  126.     }
  127.     else
  128.     {
  129.         if ( (*p++) & PLUS_WORD_MASK )
  130.         {
  131.             prop = (*p++) << 8 ;
  132.             prop += *p ;
  133.         }
  134.         else
  135.             prop = *p ;
  136.     }
  137.     store ( prop ) ;
  138. }
  139.  
  140. Void
  141. std_put_prop ( obj_num,prop_num,value )
  142. word    obj_num ;
  143. word    prop_num ;
  144. word    value ;
  145. {
  146.     extern std_object_ptr    std_obj_list ;
  147.  
  148.     register property        p ;
  149.     register word            p_num ;
  150.  
  151.     p = std_prop_addr ( STD_OBJ_ADDR ( obj_num )) ;
  152.     p_num = STD_PROPERTY_NUMBER ( p ) ;
  153.  
  154.     /*
  155.     **    Properties are kept in descending order
  156.     */
  157.  
  158.     while ( p_num > prop_num )
  159.     {
  160.         p = std_next_addr ( p ) ;
  161.         p_num = STD_PROPERTY_NUMBER ( p ) ;
  162.     }
  163.     if ( p_num < prop_num )
  164.         error ( ERR_PUT_PROP ) ;
  165.     else
  166.     {
  167.         if ( (*p++) & STD_WORD_MASK )
  168.         {
  169.             *p++ = value >> 8 ;
  170.             *p = value ;
  171.         }
  172.         else
  173.             *p = value ;
  174.     }
  175. }
  176.  
  177. Void
  178. plus_put_prop ( obj_num,prop_num,value )
  179. word    obj_num ;
  180. word    prop_num ;
  181. word    value ;
  182. {
  183.     extern plus_object_ptr    plus_obj_list ;
  184.  
  185.     register property        p ;
  186.     register word            p_num ;
  187.  
  188.     p = plus_prop_addr ( PLUS_OBJ_ADDR ( obj_num )) ;
  189.     p_num = PLUS_PROPERTY_NUMBER ( p ) ;
  190.  
  191.     /*
  192.     **    Properties are kept in descending order
  193.     */
  194.  
  195.     while ( p_num > prop_num )
  196.     {
  197.         p = plus_next_addr ( p ) ;
  198.         p_num = PLUS_PROPERTY_NUMBER ( p ) ;
  199.     }
  200.     if ( p_num < prop_num )
  201.         error ( ERR_PUT_PROP ) ;
  202.     else
  203.     {
  204.         if ( (*p++) & PLUS_WORD_MASK )
  205.         {
  206.             *p++ = value >> 8 ;
  207.             *p = value ;
  208.         }
  209.         else
  210.             *p = value ;
  211.     }
  212. }
  213.  
  214. Void
  215. std_get_next_prop ( obj_num,prop_num )
  216. word    obj_num ;
  217. word    prop_num ;
  218. {
  219.     extern std_object_ptr    std_obj_list ;
  220.  
  221.     register property        p ;
  222.     register word            p_num ;
  223.  
  224.     p = std_prop_addr ( STD_OBJ_ADDR ( obj_num )) ;
  225.     if ( prop_num != 0 )
  226.     {
  227.         p_num = STD_PROPERTY_NUMBER ( p ) ;
  228.  
  229.         /*
  230.         **    Properties are kept in descending order
  231.         */
  232.  
  233.         while ( p_num > prop_num )
  234.         {
  235.             p = std_next_addr ( p ) ;
  236.             p_num = STD_PROPERTY_NUMBER ( p ) ;
  237.         }
  238.         if ( p_num < prop_num )
  239.             error ( ERR_NEXT_PROP ) ;
  240.         else
  241.             p = std_next_addr ( p ) ;
  242.     }
  243.     store ( (word) STD_PROPERTY_NUMBER ( p ) ) ;
  244. }
  245.  
  246. Void
  247. plus_get_next_prop ( obj_num,prop_num )
  248. word    obj_num ;
  249. word    prop_num ;
  250. {
  251.     extern plus_object_ptr    plus_obj_list ;
  252.  
  253.     register property        p ;
  254.     register word            p_num ;
  255.  
  256.     p = plus_prop_addr ( PLUS_OBJ_ADDR ( obj_num )) ;
  257.     if ( prop_num != 0 )
  258.     {
  259.         p_num = PLUS_PROPERTY_NUMBER ( p ) ;
  260.  
  261.         /*
  262.         **    Properties are kept in descending order
  263.         */
  264.  
  265.         while ( p_num > prop_num )
  266.         {
  267.             p = plus_next_addr ( p ) ;
  268.             p_num = PLUS_PROPERTY_NUMBER ( p ) ;
  269.         }
  270.         if ( p_num < prop_num )
  271.             error ( ERR_NEXT_PROP ) ;
  272.         else
  273.             p = plus_next_addr ( p ) ;
  274.     }
  275.     store ( (word) PLUS_PROPERTY_NUMBER ( p ) ) ;
  276. }
  277.  
  278. Void
  279. load_word_array ( base,offset )
  280. register word    base ;
  281. register word    offset ;
  282. {
  283.     word    page ;
  284.     word    page_offset ;
  285.  
  286.     base += (word)( offset << 1 ) ;
  287.     page = base / BLOCK_SIZE ;
  288.     page_offset = base % BLOCK_SIZE ;
  289.     store ( get_word ( &page,&page_offset ) ) ;
  290. }
  291.  
  292. Void
  293. load_byte_array ( base,offset )
  294. register word    base ;
  295. register word    offset ;
  296. {
  297.     word    page ;
  298.     word    page_offset ;
  299.  
  300.     base += offset ;
  301.     page = base / BLOCK_SIZE ;
  302.     page_offset = base % BLOCK_SIZE ;
  303.     store ( (word)get_byte ( &page,&page_offset ) ) ;
  304. }
  305.  
  306. Void
  307. save_word_array ( base,offset,value )
  308. word    base ;
  309. word    offset ;
  310. word    value ;
  311. {
  312.     extern byte_ptr        base_ptr ;
  313.  
  314.     register byte_ptr    ptr ;
  315.  
  316.     ptr = base_ptr + (word)( base + (word)( offset << 1 ) ) ;
  317.     *ptr++ = value >> 8 ;
  318.     *ptr = value ;
  319. }
  320.  
  321. Void
  322. save_byte_array ( base,offset,value )
  323. word    base ;
  324. word    offset ;
  325. word    value ;
  326. {
  327.     extern byte_ptr        base_ptr ;
  328.  
  329.     register byte_ptr    ptr ;
  330.  
  331.     ptr = base_ptr + (word)( base + offset ) ;
  332.     *ptr = value ;
  333. }
  334.  
  335. Void
  336. std_get_prop_addr ( obj_num,prop_num )
  337. word    obj_num ;
  338. word    prop_num ;
  339. {
  340.     extern byte_ptr            base_ptr ;
  341.     extern std_object_ptr    std_obj_list ;
  342.  
  343.     register property        p ;
  344.     register word            p_num ;
  345.  
  346.     p = std_prop_addr ( STD_OBJ_ADDR ( obj_num )) ;
  347.     p_num = STD_PROPERTY_NUMBER ( p ) ;
  348.  
  349.     /*
  350.     **    Properties are kept in descending order
  351.     */
  352.  
  353.     while ( p_num > prop_num )
  354.     {
  355.         p = std_next_addr ( p ) ;
  356.         p_num = STD_PROPERTY_NUMBER ( p ) ;
  357.     }
  358.     if ( p_num < prop_num )
  359.         store ( (word)0 ) ;
  360.     else
  361.         store ( (word)(p + 1 - base_ptr) ) ;
  362. }
  363.  
  364. Void
  365. plus_get_prop_addr ( obj_num,prop_num )
  366. word    obj_num ;
  367. word    prop_num ;
  368. {
  369.     extern byte_ptr            base_ptr ;
  370.     extern plus_object_ptr    plus_obj_list ;
  371.  
  372.     register property        p ;
  373.     register word            p_num ;
  374.  
  375.     p = plus_prop_addr ( PLUS_OBJ_ADDR ( obj_num )) ;
  376.     p_num = PLUS_PROPERTY_NUMBER ( p ) ;
  377.  
  378.     /*
  379.     **    Properties are kept in descending order
  380.     */
  381.  
  382.     while ( p_num > prop_num )
  383.     {
  384.         p = plus_next_addr ( p ) ;
  385.         p_num = PLUS_PROPERTY_NUMBER ( p ) ;
  386.     }
  387.     if ( p_num < prop_num )
  388.         store ( (word)0 ) ;
  389.     else
  390.     {
  391.         if ( ( *p & NEXT_BYTE_IS_LENGTH ) != 0 )
  392.             ++p ;
  393.         store ( (word)(p + 1 - base_ptr) ) ;
  394.     }
  395. }
  396.  
  397. Void
  398. std_get_p_len ( prop_num )
  399. word    prop_num;
  400. {
  401.     extern byte_ptr        base_ptr ;
  402.  
  403.     register property    p ;
  404.  
  405.     p = base_ptr + prop_num - 1 ;
  406.     store ( (word) STD_PROPERTY_LENGTH ( p ) ) ;
  407. }
  408.  
  409. Void
  410. plus_get_p_len ( prop_num )
  411. word    prop_num;
  412. {
  413.     extern byte_ptr        base_ptr ;
  414.  
  415.     register property    p ;
  416.  
  417.     p = base_ptr + prop_num - 1 ;
  418.     if ( ( *p & NEXT_BYTE_IS_LENGTH ) == 0 )
  419.     {
  420.         if ( *p & PLUS_WORD_MASK )
  421.             store ( (word)2 ) ;
  422.         else
  423.             store ( (word)1 ) ;
  424.         return ;
  425.     }
  426.     store ( (word) PLUS_PROPERTY_LENGTH ( p ) ) ;
  427. }
  428.