home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1997 March / VPR9703A.ISO / VPR_DATA / DOGA / SOURCES / POLYEDIT.LZH / ML / STACK.C < prev    next >
C/C++ Source or Header  |  1996-01-06  |  5KB  |  314 lines
  1. /*
  2.  *        演算用スタック制御
  3.  *
  4.  *        T.Kobayashi        1993.8.6
  5.  */
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <string.h>
  9. #include <assert.h>
  10.  
  11. #include "data.h"
  12. #include "alloc.h"
  13.  
  14. #include "inlib.h"
  15. #include "err.h"
  16.  
  17. extern    int        ExecDebug ;
  18.  
  19. /*    演算用スタック    */
  20. int            MaxStack ;
  21. DataStruct    *StackBuf ;
  22. int            StackPtr ;
  23. int            StackUsed ;
  24.  
  25. /*    スタックトップを得る    */
  26. DataStruct    *StackTop()
  27. {
  28.     assert( -1 <= StackPtr && StackPtr < MaxStack );
  29.     return (DataStruct*)&StackBuf[StackPtr] ;
  30. }
  31.  
  32. /*    ポップ    */
  33. void    StackPop()
  34. {
  35.     assert( 0 <= StackPtr && StackPtr < MaxStack );
  36.  
  37.     if ( StackBuf[StackPtr].type & TYPE_OBJECT )
  38.     {
  39.         ObjectFree( StackBuf[StackPtr].od.ptr );
  40.     }
  41.     StackPtr -- ;
  42. #if    PDEBUG
  43.     if ( ExecDebug )
  44.     {
  45.         printf( "  " );
  46.         printf( "POP [%d] ", StackPtr );
  47.         DataPrint( &StackBuf[StackPtr+1] );
  48.         printf( "\n" );
  49.     }
  50. #endif
  51. }
  52.  
  53. /*    プッシュ    */
  54. void    StackPush( buf )
  55. DataStruct    *buf ;
  56. {
  57.     StackPtr ++ ;
  58.     assert( 0 <= StackPtr );
  59.     if ( StackUsed < StackPtr )
  60.         StackUsed = StackPtr ;
  61.     if ( StackPtr >= MaxStack )
  62.     {
  63.         ExecError( "スタックオーバーフロー！！" );
  64.     }
  65.     if ( buf == NULL )
  66.     {
  67.         buf->type = TYPE_NOASN ;
  68.     }
  69.     else
  70.     {
  71.         StackBuf[StackPtr] = *buf ;
  72.         if ( buf->type & TYPE_OBJECT )
  73.         {
  74.             StackBuf[StackPtr].od.ptr = ObjectCopy( buf->od.ptr );
  75.         }
  76.     }
  77.  
  78. #if    PDEBUG
  79.     if ( ExecDebug )
  80.     {
  81.         printf( "  " );
  82.         printf( "PUSH[%d] ", StackPtr );
  83.         DataPrint( buf );
  84.         printf( "\n" );
  85.     }
  86. #endif
  87.  
  88. }
  89.  
  90. /*    論理型をプッシュ    */
  91. void    StackPushBoolean( l )
  92. int        l ;
  93. {
  94.     StackPtr ++ ;
  95.     assert( 0 <= StackPtr );
  96.     if ( StackUsed < StackPtr )
  97.         StackUsed = StackPtr ;
  98.     if ( StackPtr >= MaxStack )
  99.     {
  100.         ExecError( "スタックオーバーフロー！！" );
  101.     }
  102.     StackBuf[StackPtr].type = TYPE_BOOLEAN ;
  103.     StackBuf[StackPtr].ld.l = l ;
  104.  
  105. #if    PDEBUG
  106.     if ( ExecDebug )
  107.     {
  108.         printf( "  " );
  109.         printf( "PUSH[%d] int : %d\n", StackPtr, l );
  110.     }
  111. #endif
  112. }
  113.  
  114.  
  115. /*    整数をプッシュ    */
  116. void    StackPushInt( i )
  117. int        i ;
  118. {
  119.     StackPtr ++ ;
  120.     assert( 0 <= StackPtr );
  121.     if ( StackUsed < StackPtr )
  122.         StackUsed = StackPtr ;
  123.     if ( StackPtr >= MaxStack )
  124.     {
  125.         ExecError( "スタックオーバーフロー！！" );
  126.     }
  127.     StackBuf[StackPtr].type = TYPE_INT ;
  128.     StackBuf[StackPtr].id.i = i ;
  129.  
  130. #if    PDEBUG
  131.     if ( ExecDebug )
  132.     {
  133.         printf( "  " );
  134.         printf( "PUSH[%d] int : %d\n", StackPtr, i );
  135.     }
  136. #endif
  137. }
  138.  
  139. /*    実数をプッシュ    */
  140. void    StackPushReal( r )
  141. double    r ;
  142. {
  143.     StackPtr ++ ;
  144.     assert( 0 <= StackPtr );
  145.     if ( StackUsed < StackPtr )
  146.         StackUsed = StackPtr ;
  147.     if ( StackPtr >= MaxStack )
  148.     {
  149.         ExecError( "スタックオーバーフロー！！" );
  150.     }
  151.     StackBuf[StackPtr].type = TYPE_REAL ;
  152.     StackBuf[StackPtr].rd.r = (float)r ;
  153.  
  154. #if    PDEBUG
  155.     if ( ExecDebug )
  156.     {
  157.         printf( "  " );
  158.         printf( "PUSH[%d] int : %d\n", StackPtr, r );
  159.     }
  160. #endif
  161. }
  162.  
  163. /*    スタック上に領域を得る    */
  164. DataStruct    *StackAlloc( size )
  165. int        size ;
  166. {
  167.     int        i ;
  168.     DataStruct    *data, *ret ;
  169.  
  170.     assert( 0 <= size );
  171.  
  172.     data = & StackBuf[StackPtr] + 1;
  173.     ret = data ;
  174.     StackPtr += size ;
  175.  
  176.     assert( 0 <= StackPtr );
  177.     if ( StackUsed < StackPtr )
  178.         StackUsed = StackPtr ;
  179.     if ( StackPtr >= MaxStack )
  180.     {
  181.         ExecError( "スタックオーバーフロー！！" );
  182.     }
  183.  
  184.     for( i = 0 ; i < size ; i++ )
  185.     {
  186.         data->type = TYPE_NOASN ;
  187.         data++ ;
  188.     }
  189.  
  190. #if    PDEBUG
  191.     if ( ExecDebug )
  192.     {
  193.         printf( "  " );
  194.         printf( "Alloc[%d] : %d\n", StackPtr, size );
  195.     }
  196. #endif
  197.  
  198.     return ret ;
  199. }
  200.  
  201. /*    マーク位置まで解放    */
  202. void    StackRelease( ptr )
  203. DataStruct    *ptr ;
  204. {
  205.     DataStruct    *top ;
  206.  
  207.     top = StackTop();
  208.     assert( StackBuf - 1 <= ptr && ptr <= top );
  209.  
  210.     while( ptr < top )
  211.     {
  212.         if ( top->type & TYPE_OBJECT )
  213.         {
  214.             ObjectFree( top->od.ptr );
  215.         }
  216.         top -- ;
  217.     }
  218.     StackPtr = top - StackBuf ;
  219.  
  220. #if    PDEBUG
  221.     if ( ExecDebug )
  222.     {
  223.         printf( "  " );
  224.         printf( "Release[%d]\n", StackPtr );
  225.     }
  226. #endif
  227.  
  228. }
  229.  
  230. /*    スタックの最大使用量を得る    */
  231. int        StackMaxUsed()
  232. {
  233.     return StackUsed ;
  234. }
  235.  
  236. /*    データバッファの内容を表示    */
  237. void    DataPrint( buf )
  238. DataStruct    *buf ;
  239. {
  240.     char    str[256] ;
  241.  
  242.     DataToString( str, buf );
  243.     printf( str );
  244. }
  245.  
  246. /*    文字列に変換    */
  247. int        DataToString( str, buf )
  248. char    *str ;
  249. DataStruct    *buf ;
  250. {
  251.     char    *typename ;
  252.  
  253.     switch( buf->type )
  254.     {
  255.         case TYPE_BOOLEAN:
  256.             if ( buf->ld.l )
  257.                 strcpy( str, "TRUE" );
  258.             else
  259.                 strcpy( str, "FALSE" );
  260.             break ;
  261.         case TYPE_INT:
  262.             sprintf( str, "%d", buf->id.i );
  263.             break ;
  264.         case TYPE_REAL:
  265.             sprintf( str, "%f", buf->rd.r );
  266.             break ;
  267.         case TYPE_FUNC:
  268.             sprintf( str, "%d", buf->funcd.ident );
  269.             break ;
  270.         case TYPE_ARRAY:
  271.             sprintf( str, "%X[%d]", (int)(buf->ad.ary), buf->ad.size );
  272.             break ;
  273.         case TYPE_TYPE:
  274.             switch( buf->td.t )
  275.             {
  276.                 case TYPE_NOASN:
  277.                     typename = "NO_ASSIGN" ;
  278.                     break ;
  279.                 case TYPE_BOOLEAN:
  280.                     typename = "NO_ASSIGN" ;
  281.                 case TYPE_INT:
  282.                     typename = "INT" ;
  283.                     break ;
  284.                 case TYPE_REAL:
  285.                     typename = "REAL" ;
  286.                     break ;
  287.                 case TYPE_TYPE:
  288.                     typename = "TYPE" ;
  289.                     break ;
  290.                 case TYPE_ARRAY:
  291.                     typename = "ARRAY" ;
  292.                     break ;
  293.                 case TYPE_FUNC:
  294.                     typename = "FUNC" ;
  295.                     break ;
  296.                 case TYPE_OBJECT:
  297.                     typename = "OBJECT" ;
  298.                     break ;
  299.                 default:
  300.                     typename = "DATA TYPE ERROR!!!" ;
  301.                     break ;
  302.             }
  303.             strcpy( str, typename );
  304.             break ;
  305.         case TYPE_OBJECT:
  306.             sprintf( str, "Object[%d][%X]", buf->od.ptr->type, buf->od.ptr );
  307.             break ;
  308.         default:
  309.             assert( FALSE );
  310.     }
  311.     return strlen( str );
  312. }
  313.  
  314.