home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / ssvpar.zip / SSLEX.HPP < prev    next >
Text File  |  1994-11-28  |  12KB  |  299 lines
  1. /*---------------------------------------------------------------------------
  2.  
  3.                Copyright (c) 1994 SandStone Software Inc.
  4.                           All rights reserved
  5.  
  6. ----------------------------------------------------------------------------*/
  7. #if !defined( SSLEX)
  8. #  define SSLEX
  9. #  include<stdio.h>
  10. #  include<malloc.h>
  11. #  include<sssto.hpp>
  12. #  include<ssref.hpp>
  13. #  include<ssglobal.h>
  14. #  include<ssdbcs.hpp>
  15. #  include<ssexcept.hpp>
  16.  
  17. #  define SSLexConsumerDefaultInc   0
  18. #  define SSLexConsumerAll          0xffffffff
  19. #  define SSLexConsumerDefaultSize  SSLexConsumerAll
  20.  
  21. #  define SSLexFileModeCharacter    "r"
  22. #  define SSLexFileModeBinary       "rb"
  23. #  define SSLexFileModeUnicode      "rb"
  24.  
  25. #  define SSLexMinimumCharacterSize 2
  26. #  define SSLexTokenBof             0xffffffff
  27. #  define SSLexStateInvalid         0xffffffff
  28. #  define SSLexTokenNotFound        "SSLexTokenNotFound"
  29.  
  30. #  define SSLexMsgFileOpen          "SSLex0101e: Error opening file, %s, %ld"
  31. #  define SSLexMsgFileLength        "SSLex0102e: Invalid file length or read error, %s"
  32. #  define SSLexMsgLexemeLength      "SSLex0103e: Lexeme too long, %ld"
  33. #  define SSLexMsgTable             "SSLex0104e: Invalid table, %s"
  34. #  define SSLexMsgError             "SSLex0105e: Invalid token, Line %ld, Offset %ld, %s"
  35. #  define SSLexMsgIterator          "SSLex0106e: Invalid expression list index, %ld"
  36. #  define SSLexMsgMissingParm       "SSLex0107e: Table or consumer missing, required"
  37.  
  38.    class SSLex;
  39.    class SSLexMark;
  40.    class SSLexTable;
  41.    class SSLexLexeme;
  42.    class SSLexConsumer;
  43.    class SSLexIterator;
  44.    class SSLexFileConsumer;
  45.    class SSLexStringConsumer;
  46.    class SSLexExpressionList;
  47.  
  48.    typedef SSRef< SSLexLexeme>  SSLexLexemeRef;
  49.    typedef SSLexExpressionList* SSLexExpressionListPtr;
  50.  
  51.    class SSLexMark
  52.       {
  53.       friend class SSLexConsumer;
  54.  
  55.       public:
  56.          SSConstr          SSLexMark( void);
  57.  
  58.       private:
  59.          SSUnsigned32      oulMark;
  60.          SSUnsigned32      oulLine;
  61.          SSUnsigned32      oulOffset;
  62.       };
  63.  
  64.    class SSLexExpressionList : public SSExceptionPresent
  65.       {
  66.       public:
  67.          SSConstr         SSLexExpressionList( void*);
  68.          SSDestr          SSLexExpressionList( void);
  69.  
  70.       protected:
  71.          void*            opTable;
  72.       };
  73.  
  74.    class SSLexTable : public SSExceptionPresent
  75.       {
  76.       public:
  77.          SSConstr               SSLexTable( const char*);
  78.  
  79.          void*                  table( void);
  80.          SSLexExpressionList*   expressionList( SSUnsigned32 = 0);
  81.  
  82.          SSDestr                SSLexTable( void);
  83.  
  84.       private:
  85.          void*                  opTable;
  86.          SSLexExpressionList**  oapExpressionList;
  87.          SSUnsigned32           oulExpressionList;
  88.       };
  89.  
  90.    class SSLexLexeme : public SSRefCount, public SSExceptionPresent
  91.       {
  92.       public:
  93.  
  94.          enum SSLexLexemeType
  95.             {
  96.             unicode,
  97.             character
  98.             };
  99.  
  100.          SSConstr            SSLexLexeme( void);
  101.          SSConstr            SSLexLexeme( SSUnsigned32);
  102.          SSConstr            SSLexLexeme( SSUnsigned32, SSUnsigned32);
  103.          SSConstr            SSLexLexeme( SSLexConsumer&, SSUnsigned32,
  104.                                 SSLexMark&, SSBooleanValue = SSFalse);
  105.          SSConstr            SSLexLexeme( SSUnsigned32, SSUnsigned32,
  106.                                 SSUnsigned32, SSUnsigned32, 
  107.                                 SSBooleanValue = SSFalse);
  108.          SSConstr            SSLexLexeme( SSUnsigned32, SSUnsigned32,
  109.                                 const char*, SSUnsigned32, SSUnsigned32,
  110.                                 SSBooleanValue = SSFalse);
  111.          SSConstr            SSLexLexeme( SSUnsigned32, SSUnsigned32,
  112.                                 const SSUnicode*, SSUnsigned32, SSUnsigned32,
  113.                                 SSBooleanValue = SSFalse);
  114.  
  115.          void*               operator new( size_t);
  116.          void                operator delete( void*);
  117.          void*               operator new( size_t, SSUnsigned32);
  118.  
  119.          SSLexLexemeType     type( void) const;
  120.          SSUnsigned32        line( void) const;
  121.          SSUnsigned32        token( void) const;
  122.          SSUnsigned32        offset( void) const;
  123.          SSUnsigned32        length( void) const;
  124.  
  125.          void                setBuffer( char*);
  126.          void                setLine( SSUnsigned32);
  127.          void                setToken( SSUnsigned32);
  128.          void                setOffset( SSUnsigned32);
  129.          void                setLength( SSUnsigned32);
  130.          void                setType( SSLexLexemeType);
  131.  
  132.          char*               asChar( void) const;
  133.          const char*         asConstChar( void) const;
  134.          const SSUnicode*    asConstUnicode( void) const;
  135.                              operator const char*( void);
  136.                              operator const SSUnicode*( void);
  137.          SSBooleanValue      isEqualLexeme( SSLexLexeme&) const;
  138.          SSUnsigned32        asUnsigned32( SSBooleanValue&) const;
  139.  
  140.          void                refFree( void);
  141.          virtual SSDestr     SSLexLexeme( void);
  142.  
  143.       protected:
  144.          SSBooleanValue      oOwn;
  145.          SSLexLexemeType     oType;
  146.          SSUnsigned32        oulLine;
  147.          SSUnsigned32        oulToken;
  148.          char*               opchBuff;
  149.          SSUnsigned32        oulLength;
  150.          SSUnsigned32        oulOffset;
  151.       };
  152.  
  153.    class SSLexConsumer : public SSExceptionPresent
  154.       {
  155.       public:
  156.  
  157.          enum SSLexConsumerType
  158.             {
  159.             binary,
  160.             unicode,
  161.             character
  162.             };
  163.  
  164.          SSConstr               SSLexConsumer( SSLexConsumerType = character);
  165.  
  166.          SSLexMark              mark( void);
  167.          SSBooleanValue         operator++( int);
  168.          SSLexConsumerType      type( void) const;
  169.          SSDbcsInfo&            dbcs( void) const;
  170.          void                   singleByte( void);
  171.          void                   doubleByte( void);
  172.          void                   flushLexeme( void);
  173.          void                   unicodeByte( void);
  174.          SSUnsigned32           current( void) const;
  175.          SSUnsigned32           consumed( void) const;
  176.          virtual SSUnsigned32   nextBuffer( void) = 0;
  177.          SSLexLexeme*           lexemeToCurrent( void);
  178.          SSBooleanValue         endOfData( void) const;
  179.          void                   flushLexeme( SSLexMark&);
  180.          void                   flushStartOfLine( SSLexMark&);
  181.          void                   addBuffer( char*, SSUnsigned32);
  182.          SSLexLexeme*           lexemeToMark( SSLexMark&, SSUnsigned32);
  183.          SSBooleanValue         shiftBuffer( SSUnsigned32&, SSUnsigned32&);
  184.          SSBooleanValue         expandBuffer( SSUnsigned32&, SSUnsigned32&);
  185.          void                   adjustMark( SSLexMark&, SSBooleanValue = SSFalse);
  186.  
  187.          char*                  buffer( void);
  188.          SSUnsigned32           bufferInc( void);
  189.          SSUnsigned32           line( void) const;
  190.          void                   setBuffer( char*);
  191.          SSUnsigned32           offset( void) const;
  192.          SSUnsigned32           bufferLength( void);
  193.          void                   setEndOfData( void);
  194.          SSUnsigned32           lexemeLength( void) const;
  195.          char*                  lexemeBuffer( void) const;
  196.          void                   setBufferInc( SSUnsigned32);
  197.          void                   setDataLength( SSUnsigned32);
  198.          SSUnsigned32           lexemeLength( SSLexMark&) const;
  199.          void                   setBufferLength( SSUnsigned32);
  200.  
  201.          virtual SSDestr        SSLexConsumer( void);
  202.  
  203.       protected:
  204.          SSDbcsInfo&            oDbcs;
  205.          SSLexConsumerType      oType;
  206.          SSUnsigned32           oulBof;
  207.          SSUnsigned32           oulInc;
  208.          SSUnsigned32           oulLine;
  209.          SSUnsigned32           oulBuff;
  210.          SSUnsigned32           oulMark;
  211.          char*                  opchBuff;
  212.          SSUnsigned32           oulStart;
  213.          SSUnsigned32           oulIndex;
  214.          SSUnsigned32           oulLength;
  215.          SSUnsigned32           oulOffset;
  216.          SSUnsigned32           oulCurrent;
  217.          SSBooleanValue         oEndOfData;
  218.          SSUnsigned32           oulConsumed;
  219.          SSUnsigned32           oulScanLine;
  220.          SSUnsigned32           oulMarkLine;
  221.          SSUnsigned32           oulScanOffset;
  222.          SSUnsigned32           oulMarkOffset;
  223.       };
  224.  
  225.    class SSLexFileConsumer : public SSLexConsumer
  226.       {
  227.       public:
  228.          SSConstr               SSLexFileConsumer( const char*,
  229.                                    SSLexConsumerType = character,
  230.                                    SSUnsigned32 = SSLexConsumerDefaultSize,
  231.                                    SSUnsigned32 = SSLexConsumerDefaultInc);
  232.  
  233.          void                   close( void);
  234.          FILE*                  file( void) const;
  235.          SSUnsigned32           nextBuffer( void);
  236.  
  237.          virtual SSDestr        SSLexFileConsumer( void);
  238.  
  239.       protected:
  240.          FILE*                  opFile;
  241.       };
  242.  
  243.    class SSLexStringConsumer : public SSLexConsumer
  244.       {
  245.       public:
  246.          SSConstr              SSLexStringConsumer( const char*,
  247.                                   SSLexConsumerType = character);
  248.  
  249.          SSUnsigned32          nextBuffer( void);
  250.       };
  251.  
  252.    class SSLex : public SSExceptionPresent
  253.       {
  254.       public:
  255.          SSConstr               SSLex( const char* = 0);
  256.          SSConstr               SSLex( const char*, const char*);
  257.          SSConstr               SSLex( SSLexConsumer&, SSLexTable&);
  258.  
  259.          void                   setTable( SSLexTable&);
  260.          void                   setTable( const char*);
  261.          void                   setConsumer( const char*);
  262.          void                   setConsumer( SSLexConsumer&);
  263.  
  264.          void                   reset( void);
  265.          SSLexLexeme*           operator++( int);
  266.          SSLexTable*            table( void) const;
  267.          SSUnsigned32           lexemesValid( void);
  268.          SSLexConsumer*         consumer( void) const;
  269.          virtual SSLexLexeme*   error( SSLexConsumer&);
  270.          SSBooleanValue         popExpressionList( void);
  271.          virtual const char*    tokenToConstChar( SSUnsigned32);
  272.          SSBooleanValue         isCurrentExpressionList( SSUnsigned32);
  273.          SSBooleanValue         pushExpressionList( SSLexExpressionList&);
  274.          SSBooleanValue         gotoExpressionList( SSLexExpressionList&);
  275.          virtual SSLexLexeme*   complete( SSLexConsumer&, SSUnsigned32,
  276.                                    SSLexMark&);
  277.  
  278.          SSDestr                SSLex( void);
  279.  
  280.       protected:
  281.          SSLexTable*            opTable;
  282.          SSUnsigned32           oulState;
  283.          SSBooleanValue         oOwnTable;
  284.          SSLexConsumer*         opConsumer;
  285.          SSBooleanValue         oOwnConsumer;
  286.          SSUnsigned32           oulLexemesValid;
  287.  
  288.       protected:
  289.          void                   open( void);
  290.          SSLexIterator&         iterator( void) const;
  291.  
  292.          SSLexIterator*         opIterator;
  293.          void*                  opExpressionListStack;
  294.       };
  295.  
  296. #  include<sslex.inl>
  297.  
  298. #endif
  299.