home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1997 March / VPR9703A.ISO / VPR_DATA / DOGA / SOURCES / POLYEDIT.LZH / ML / PARSE3.C < prev    next >
C/C++ Source or Header  |  1996-01-18  |  4KB  |  189 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 "parse.h"
  12. #include "err.h"
  13.  
  14. int        OrSym[] = { SYM_OR, SYM_XOR, 0 };
  15. int        AndSym[] = { SYM_AND, 0 };
  16. int        CompareSym[] = { SYM_NOTEQ, SYM_EQ, SYM_LSS, SYM_GTR, SYM_LSSEQ, SYM_GTREQ, 0 };
  17. int        ShiftSym[] = { SYM_LSFT, SYM_RSFT, 0 };
  18. int        AdderSym[] = { SYM_PLUS, SYM_MINUS, 0 };
  19. int        MultiSym[] = { SYM_MULT, SYM_DIVIDE, SYM_MOD, 0 };
  20. int        RefSym[] = { SYM_DOT, SYM_REFER, 0 };
  21.  
  22. int        *Symbols[] = { OrSym, AndSym, CompareSym, ShiftSym, AdderSym, MultiSym, RefSym, NULL };
  23.  
  24. int        OrOpe[] = { OPE_OR, OPE_XOR, 0 };
  25. int        AndOpe[] = { OPE_AND, 0 };
  26. int        CompareOpe[] = { OPE_NOTEQ, OPE_EQ, OPE_LSS, OPE_GTR, OPE_LSSEQ, OPE_GTREQ, 0 };
  27. int        ShiftOpe[] = { OPE_LSFT, OPE_RSFT, 0 };
  28. int        AdderOpe[] = { OPE_PLUS, OPE_MINUS, 0 };
  29. int        MultiOpe[] = { OPE_MULT, OPE_DIVIDE, OPE_MOD, 0 };
  30. int        RefOpe[] = { OPE_DOT, OPE_REFER, 0 };
  31.  
  32. int        *Operators[] = { OrOpe, AndOpe, CompareOpe, ShiftOpe, AdderOpe, MultiOpe, RefOpe, NULL };
  33.  
  34. #define    SYMBOLS    (sizeof(Symbols)/sizeof(Symbols[0])-1)
  35.  
  36. int        SymbolLevel[SYM_UNKNOWN - SYM_SPL_CHAR+1];
  37. int        OperatorTable[SYM_UNKNOWN - SYM_SPL_CHAR+1];
  38. #define SYM_LEVEL_BEGIN    SYM_SPL_CHAR
  39. #define SYM_LEVEL_END    SYM_UNKNOWN+1        /*ENDは含まない*/
  40.  
  41. static    void    _ParseExpression( int );
  42. static    void    ParseFactor( void );
  43.  
  44. void    Parse3Init(void)
  45. {
  46.     int i, l;
  47.     for (i = 0; i < sizeof(SymbolLevel)/sizeof(SymbolLevel[0]); ++i) {
  48.         SymbolLevel[i]   = -1;
  49.         OperatorTable[i] = -1;
  50.     }
  51.     for (l = 0; Symbols[l] != NULL; l++) {
  52.         for( i = 0 ; Symbols[l][i] != 0 ; i++ )
  53.         {
  54. /*printf("level=%d, i=%d -> Symbol=%08x, Operator=%d\n", l, i, Symbols[l][i], Operators[l][i]);*/
  55.             assert(SYM_LEVEL_BEGIN <= Symbols[l][i] && Symbols[l][i] < SYM_LEVEL_END);
  56.             assert(Operators[l] != NULL);
  57.             assert(Operators[l][i] != 0);
  58.             SymbolLevel[Symbols[l][i] - SYM_LEVEL_BEGIN] = l;
  59.             OperatorTable[Symbols[l][i] - SYM_LEVEL_BEGIN] = Operators[l][i];
  60.         }
  61.     }
  62. }
  63.  
  64. void    ParseExpression()
  65. {
  66.     _ParseExpression( 0 );
  67. }
  68.  
  69. static    void    _ParseExpression( level )
  70. int        level ;
  71. {
  72.     int        i, ope ;
  73. #if 0
  74.     if ( Symbols[level] == NULL )
  75.     {
  76.         ParseFactor();
  77.     }
  78. #else
  79.     if ( level >= SYMBOLS)
  80.     {
  81.         ParseFactor();
  82.     }
  83. #endif
  84.     else
  85.     {
  86.         _ParseExpression( level + 1 );
  87.         for(;;)
  88.         {
  89. #if 0
  90.             for( i = 0 ; Symbols[level][i] != 0 ; i++ )
  91.             {
  92.                 if ( Input.token == Symbols[level][i] )
  93.                 {
  94.                     ope = Operators[level][i] ;
  95.                     break ;
  96.                 }
  97.             }
  98.             if ( Symbols[level][i] == 0 )
  99.                 return ;
  100. #else
  101.             if ((Input.token & SYM_SPL_CHAR) == 0
  102.              || SymbolLevel[Input.token - SYM_LEVEL_BEGIN] != level) {
  103.                 return;
  104.             }
  105.             ope = OperatorTable[Input.token - SYM_LEVEL_BEGIN];
  106. #endif
  107.             GetToken();
  108.             _ParseExpression( level + 1 );
  109.             CodeSetOperator( ope );
  110.         }
  111.     }
  112. }
  113.  
  114. static    void    ParseFactor()
  115. {
  116.     int        ope, size ;
  117.  
  118.     /*    単項演算子    */
  119.     switch( Input.token )
  120.     {
  121.         case SYM_MINUS :
  122.             ope = OPE_MINUS1 ;
  123.             break ;
  124.         case SYM_NOT:
  125.             ope = OPE_NOT ;
  126.             break ;
  127.         default :
  128.             ope = 0 ;
  129.     }
  130.     if ( ope != 0 )
  131.     {
  132.         GetToken();
  133.         ParseFactor();
  134.         CodeSetOperator( ope );
  135.     }
  136.     else if ( Input.token == SYM_CONSTDATA )
  137.     {
  138.         /*    定数    */
  139.         CodeSetConst( &(Input.data) );
  140.         GetToken();
  141.     }
  142.     else if ( Input.token == SYM_OPEN1 )
  143.     {
  144.         /*    かっこ    */
  145.         GetToken();
  146.         ParseExpression();
  147.         if ( Input.token == SYM_CLOSE1 )
  148.             GetToken();
  149.         else
  150.             ParseError( " ) が必要です" );
  151.     }
  152.     else if ( Input.token == SYM_OPEN2 )
  153.     {
  154.         /*    配列    */
  155.         size = 0 ;
  156.         do
  157.         {
  158.             size++ ;
  159.             GetToken();
  160.             ParseExpression();
  161.             if ( Input.token != SYM_COMMA && Input.token != SYM_CLOSE2 )
  162.                 ParseError( ",または}が必要です" );
  163.         }
  164.         while( Input.token != SYM_CLOSE2 );
  165.         GetToken();
  166.         CodeSetArray( size );
  167.     }
  168.     else if ( Input.token == SYM_IDENT )
  169.     {
  170.         /*    変数、関数の処理    */
  171.         int        ident ;
  172.  
  173.         ident = IdentSearch( IdentLocalVar, Input.str );
  174.         if ( ( ident = IdentSearch( IdentLocalVar, Input.str ) ) >= 0 )
  175.             ParseLocalVar( ident );
  176.         else if ( ( ident = IdentSearch( IdentGlobalVar, Input.str ) ) >= 0 )
  177.         {
  178.             ParseGlobalVar( ident );
  179.         }
  180.         else if ( ( ident = IdentSearch( IdentFunction, Input.str ) ) >= 0 )
  181.         {
  182.             ParseFunction( ident );
  183.         }
  184.         else
  185.             ParseError( "識別子 %s は定義されていません", Input.str );
  186.     }
  187. }
  188.  
  189.