home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / ssvpar.zip / SSCALC.C < prev    next >
Text File  |  1994-11-25  |  12KB  |  400 lines
  1. #if !defined( SSCALCSSH)
  2. #  define SSCALCSSH
  3. #  include<string.h>
  4. #  include<sslexc.h>
  5. #  include<ssyaccc.h>
  6.  
  7. #  define ALexExpressionListMain       0
  8. #  define ALexExpressionListMLCom      1
  9. #  define ALexExpressionListSLCom      2
  10.  
  11. #  define ALexEnd                      4
  12. #  define ALexPlus                     5
  13. #  define ALexMinus                    6
  14. #  define ALexDiv                      7
  15. #  define ALexMult                     8
  16. #  define ALexMod                      9
  17. #  define ALexPow                      10
  18. #  define ALexOr                       11
  19. #  define ALexAnd                      12
  20. #  define ALexNot                      13
  21. #  define ALexOParen                   14
  22. #  define ALexCParen                   15
  23. #  define ALexDec                      16
  24. #  define ALexOct                      17
  25. #  define ALexHex                      18
  26.  
  27. #  define AYaccStart                   1
  28. #  define AYaccStartList               2
  29. #  define AYaccExprSingle              3
  30. #  define AYaccExprError               4
  31. #  define AYaccExprPlus                5
  32. #  define AYaccExprMinus               6
  33. #  define AYaccExprMult                7
  34. #  define AYaccExprDiv                 8
  35. #  define AYaccExprMod                 9
  36. #  define AYaccExprNot                 10
  37. #  define AYaccExprAnd                 11
  38. #  define AYaccExprOr                  12
  39. #  define AYaccExprNested              13
  40. #  define AYaccExprNumber              14
  41. #  define AYaccNumberDec               15
  42. #  define AYaccNumberOct               16
  43. #  define AYaccNumberHex               17
  44.  
  45.    struct _AYaccStackElement
  46.       {
  47.       SSSigned32       olVal;
  48.       };
  49.  
  50.    typedef struct _AYaccStackElement AYaccStackElement;
  51.  
  52.    SSRetConstChar ALexClassTokenToConstChar( SSUnsigned32 qulToken)
  53.       {
  54.       const char* zpchToken;
  55.       switch ( qulToken)
  56.          {
  57.          case ALexEnd:
  58.             zpchToken = ";";
  59.             break;
  60.  
  61.          case ALexPlus:
  62.             zpchToken = "+";
  63.             break;
  64.  
  65.          case ALexMinus:
  66.             zpchToken = "-";
  67.             break;
  68.  
  69.          case ALexDiv:
  70.             zpchToken = "/";
  71.             break;
  72.  
  73.          case ALexMult:
  74.             zpchToken = "*";
  75.             break;
  76.  
  77.          case ALexMod:
  78.             zpchToken = "%";
  79.             break;
  80.  
  81.          case ALexPow:
  82.             zpchToken = "**";
  83.             break;
  84.  
  85.          case ALexOr:
  86.             zpchToken = "or";
  87.             break;
  88.  
  89.          case ALexAnd:
  90.             zpchToken = "and";
  91.             break;
  92.  
  93.          case ALexNot:
  94.             zpchToken = "not";
  95.             break;
  96.  
  97.          case ALexOParen:
  98.             zpchToken = "(";
  99.             break;
  100.  
  101.          case ALexCParen:
  102.             zpchToken = ")";
  103.             break;
  104.  
  105.          case ALexDec:
  106.             zpchToken = "dec";
  107.             break;
  108.  
  109.          case ALexOct:
  110.             zpchToken = "oct";
  111.             break;
  112.  
  113.          case ALexHex:
  114.             zpchToken = "hex";
  115.             break;
  116.  
  117.          case SSYaccErrorToken:
  118.             zpchToken = "%error";
  119.             break;
  120.  
  121.          case SSYaccEofToken:
  122.             zpchToken = "eof";
  123.             break;
  124.  
  125.          default:
  126.             zpchToken = SSLexTokenNotFound;
  127.          }
  128.       return zpchToken;
  129.       }
  130.  
  131.    AYaccStackElement* AYaccElementFromProduction( void* qpYacc,
  132.       SSUnsigned32 qulIndex)
  133.       {
  134.       void* zpEle = SSYaccGetElementFromProduction( qpYacc, qulIndex);
  135.       return ( AYaccStackElement*) SSYaccStackElementGetExtra( zpEle);
  136.       }
  137.  
  138.    SSRetVoidP AYaccClassReduce( void* qpYacc, SSUnsigned32 qulProd, 
  139.       SSUnsigned32 qulSize, void* qpParm)
  140.       {
  141.       void* zpEle;
  142.       SSSigned32 zlVal;
  143.       AYaccStackElement* zpStack;
  144.  
  145.       switch ( qulProd)
  146.          {
  147.          case AYaccStart:
  148.          /* start -> exprStatement */
  149.             break;
  150.  
  151.          case AYaccStartList:
  152.          /* start -> start exprStatement */
  153.             break;
  154.  
  155.          case AYaccExprSingle:
  156.          /* exprStatement -> expr ; */
  157.             {
  158.             AYaccStackElement* zpEle = AYaccElementFromProduction( qpYacc, 0);
  159.             printf( "%d,%x\n", zpEle->olVal, zpEle->olVal);
  160.             break;
  161.             }
  162.  
  163.          case AYaccExprError:
  164.          /* exprStatement -> %error ; */
  165.             break;
  166.  
  167.          case AYaccExprPlus:
  168.          /* expr -> expr + expr */
  169.             {
  170.             AYaccStackElement* zpEle0 = AYaccElementFromProduction( qpYacc, 0);
  171.             AYaccStackElement* zpEle2 = AYaccElementFromProduction( qpYacc, 2);
  172.             zlVal = zpEle0->olVal + zpEle2->olVal;
  173.             break;
  174.             }
  175.  
  176.          case AYaccExprMinus:
  177.          /* expr -> expr - expr */
  178.             {
  179.             AYaccStackElement* zpEle0 = AYaccElementFromProduction( qpYacc, 0);
  180.             AYaccStackElement* zpEle2 = AYaccElementFromProduction( qpYacc, 2);
  181.             zlVal = zpEle0->olVal - zpEle2->olVal;
  182.             break;
  183.             }
  184.  
  185.          case AYaccExprMult:
  186.          /* expr -> expr * expr */
  187.             {
  188.             AYaccStackElement* zpEle0 = AYaccElementFromProduction( qpYacc, 0);
  189.             AYaccStackElement* zpEle2 = AYaccElementFromProduction( qpYacc, 2);
  190.             zlVal = zpEle0->olVal * zpEle2->olVal;
  191.             break;
  192.             }
  193.  
  194.          case AYaccExprDiv:
  195.          /* expr -> expr / expr */
  196.             {
  197.             AYaccStackElement* zpEle0 = AYaccElementFromProduction( qpYacc, 0);
  198.             AYaccStackElement* zpEle2 = AYaccElementFromProduction( qpYacc, 2);
  199.             if ( zpEle2->olVal == 0)
  200.                {
  201.                printf( "0 divisor detected, terminating\n");
  202.                SSYaccSetAbort( qpYacc);
  203.                break;
  204.                }
  205.             zlVal = zpEle0->olVal / zpEle2->olVal;
  206.             break;
  207.             }
  208.  
  209.          case AYaccExprMod:
  210.          /* expr -> expr % expr */
  211.             {
  212.             AYaccStackElement* zpEle0 = AYaccElementFromProduction( qpYacc, 0);
  213.             AYaccStackElement* zpEle2 = AYaccElementFromProduction( qpYacc, 2);
  214.             if ( zpEle2->olVal == 0)
  215.                {
  216.                printf( "0 divisor detected, terminating\n");
  217.                SSYaccSetAbort( qpYacc);
  218.                break;
  219.                }
  220.             zlVal = zpEle0->olVal % zpEle2->olVal;
  221.             break;
  222.             }
  223.  
  224.          case AYaccExprNot:
  225.          /* expr -> not expr */
  226.             {
  227.             AYaccStackElement* zpEle = AYaccElementFromProduction( qpYacc, 0);
  228.             zlVal = ~zpEle->olVal;
  229.             break;
  230.             }
  231.  
  232.          case AYaccExprAnd:
  233.          /* expr -> expr and expr */
  234.             {
  235.             AYaccStackElement* zpEle0 = AYaccElementFromProduction( qpYacc, 0);
  236.             AYaccStackElement* zpEle2 = AYaccElementFromProduction( qpYacc, 2);
  237.             zlVal = zpEle0->olVal & zpEle2->olVal;
  238.             break;
  239.             }
  240.  
  241.          case AYaccExprOr:
  242.          /* expr -> expr or expr */
  243.             {
  244.             AYaccStackElement* zpEle0 = AYaccElementFromProduction( qpYacc, 0);
  245.             AYaccStackElement* zpEle2 = AYaccElementFromProduction( qpYacc, 2);
  246.             zlVal = zpEle0->olVal | zpEle2->olVal;
  247.             break;
  248.             }
  249.  
  250.          case AYaccExprNested:
  251.          /* expr -> ( expr ) */
  252.             {
  253.             AYaccStackElement* zpEle = AYaccElementFromProduction( qpYacc, 1);
  254.             zlVal = zpEle->olVal;
  255.             break;
  256.             }
  257.  
  258.          case AYaccExprNumber:
  259.          /* expr -> number */
  260.             {
  261.             AYaccStackElement* zpEle = AYaccElementFromProduction( qpYacc, 0);
  262.             zlVal = zpEle->olVal;
  263.             break;
  264.             }
  265.  
  266.          case AYaccNumberDec:
  267.          /* number -> dec */
  268.             {
  269.             void* zpEle = SSYaccGetElementFromProduction( qpYacc, 0);
  270.             void* zpLexeme = SSYaccStackElementGetLexeme( zpEle);
  271.             char* zpchLexeme = ( char*) SSLexLexemeGetBuffer( zpLexeme);
  272.             zlVal = strtol( zpchLexeme, 0, 0);
  273.             break;
  274.             }
  275.  
  276.          case AYaccNumberOct:
  277.          /* number -> oct */
  278.             {
  279.             void* zpEle = SSYaccGetElementFromProduction( qpYacc, 0);
  280.             void* zpLexeme = SSYaccStackElementGetLexeme( zpEle);
  281.             char* zpchLexeme = ( char*) SSLexLexemeGetBuffer( zpLexeme);
  282.             zlVal = strtol( zpchLexeme, 0, 0);
  283.             break;
  284.             }
  285.  
  286.          case AYaccNumberHex:
  287.          /* number -> hex */
  288.             {
  289.             void* zpEle = SSYaccGetElementFromProduction( qpYacc, 0);
  290.             void* zpLexeme = SSYaccStackElementGetLexeme( zpEle);
  291.             char* zpchLexeme = ( char*) SSLexLexemeGetBuffer( zpLexeme);
  292.             zlVal = strtol( zpchLexeme, 0, 0);
  293.             break;
  294.             }
  295.  
  296.          }
  297.  
  298.       zpEle = SSYaccStackElementCreate( sizeof( AYaccStackElement), 0);
  299.       zpStack = ( AYaccStackElement*) SSYaccStackElementGetExtra( zpEle);
  300.       zpStack->olVal = zlVal;
  301.       return zpEle;
  302.       }
  303.  
  304.    SSRetVoid ABadCorrelatorCallback( void* qpCorr, const char* qpchVer,
  305.       void* qpParm)
  306.       {
  307.       printf( "Bad correlator detected, %p, %.4s\n", qpCorr, qpchVer);
  308.       abort();
  309.       }
  310.  
  311.    SSBooleanValue AYaccErrorCallback( void* qpYacc, void* qpLexeme,
  312.       SSUnsigned32 qulState, void* qpParm)
  313.       {
  314.       char* zpchLexeme = "eof";
  315.       SSUnsigned32 zulLine = 0;
  316.       SSUnsigned32 zulOffset = 0;
  317.  
  318.       if ( qpLexeme)
  319.          {
  320.          zpchLexeme = ( char*) SSLexLexemeGetBuffer( qpLexeme);
  321.          zulLine = SSLexLexemeGetLine( qpLexeme);
  322.          zulOffset = SSLexLexemeGetOffset( qpLexeme);
  323.          }
  324.       printf( "Syntax error at %d,%d: %s\n", zulLine, zulOffset, zpchLexeme);
  325.       if ( !qpLexeme)
  326.          printf( "   Probable missing semicolon\n");
  327.       return SSYaccProcessError( qpYacc);
  328.       }
  329.  
  330.    int main( int qiArg, char** qapszArg)
  331.       {
  332.       void* zpLex;
  333.       void* zpYacc;
  334.       void* zpExcept;
  335.       void* zpConsumer;
  336.       void* zpLexTable;
  337.       void* zpYaccTable;
  338.  
  339.       if ( qiArg < 2)
  340.          {
  341.          printf( "Missing argument\n");
  342.          return 1;
  343.          }
  344.  
  345.       SSExceptionSetBadCorrelatorCallback( ABadCorrelatorCallback, 0);
  346.  
  347.       zpConsumer = SSLexConsumerCreate( qapszArg[ 1], strlen( qapszArg[ 1]),
  348.          SSLexConsumerTypeCharacter, 0, &zpExcept);
  349.       if ( !zpConsumer)
  350.          {
  351.          printf( "Create consumer failed: %s\n", SSExceptionGetMessage( zpExcept));
  352.          SSExceptionDestroy( zpExcept);
  353.          return 1;
  354.          }
  355.  
  356.       zpLexTable = SSLexTableCreate( "sscalc.dfa", &zpExcept);
  357.       if ( !zpLexTable)
  358.          {
  359.          printf( "Create lex table failed: %s\n", SSExceptionGetMessage( zpExcept));
  360.          SSExceptionDestroy( zpExcept);
  361.          return 1;
  362.          }
  363.  
  364.       zpLex = SSLexCreate( zpLexTable, zpConsumer, &zpExcept);
  365.       if ( !zpLex)
  366.          {
  367.          printf( "Create lex failed: %s\n", SSExceptionGetMessage( zpExcept));
  368.          SSExceptionDestroy( zpExcept);
  369.          return 1;
  370.          }
  371.  
  372.       zpYaccTable = SSYaccTableCreate( "sscalc.llr", &zpExcept);
  373.       if ( !zpYaccTable)
  374.          {
  375.          printf( "Create yacc table failed: %s\n", SSExceptionGetMessage( zpExcept));
  376.          SSExceptionDestroy( zpExcept);
  377.          return 1;
  378.          }
  379.  
  380.       zpYacc = SSYaccCreate( zpLex, zpYaccTable, AYaccClassReduce, 0,
  381.          sizeof( AYaccStackElement), &zpExcept);
  382.       if ( !zpYacc)
  383.          {
  384.          printf( "Create yacc failed: %s\n", SSExceptionGetMessage( zpExcept));
  385.          SSExceptionDestroy( zpExcept);
  386.          return 1;
  387.          }
  388.  
  389.       SSYaccSetErrorCallback( zpYacc, AYaccErrorCallback, 0);
  390.  
  391.       SSYaccParse( zpYacc);
  392.       zpExcept = SSYaccGetLastException( zpYacc);
  393.       if ( zpExcept)
  394.          printf( "Parse: %s\n", SSExceptionGetMessage( zpExcept));
  395.  
  396.       return 0;
  397.       }
  398.  
  399. #endif
  400.