| /********************************************************************** |
| // @@@ START COPYRIGHT @@@ |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| // @@@ END COPYRIGHT @@@ |
| **********************************************************************/ |
| #ifndef PARKEYWORDS_H |
| #define PARKEYWORDS_H |
| /* -*-C++-*- |
| ******************************************************************************* |
| * |
| * File: ParKeyWords.h |
| * Description: All keywords including those defined in ANSI 5.2, |
| * Used by ulexer |
| ******************************************************************************* |
| */ |
| |
| #include "NABasicObject.h" |
| #define SQLPARSERGLOBALS_FLAGS |
| #include "SqlParserGlobals.h" // Parser Flags |
| #include "NAWinNT.h" // for NAWchar, WIDE_(), etc. |
| #include "NABoolean.h" |
| |
| #ifndef SQLPARSER_H |
| #include <sqlparser.h> // Angled brackets are intentional here |
| #define SQLPARSER_H |
| #endif |
| |
| // ----------------------------------------------------------------------- |
| // contents of this file |
| // ----------------------------------------------------------------------- |
| class ParKeyWord; |
| class ParKeyWords; |
| |
| enum { |
| FLAGSNONE_ = 0x000, // No FLAGS |
| |
| FIRST_ = 0x001, // can appear as first word of compound token |
| // eg. BROWSE in BROWSE ACCESS -> |
| // TOK_BROWSE_ACCESS |
| |
| SECOND_ = 0x002, // can appear as second word of compound token |
| // eg. ACCESS in BROWSE ACCESS -> |
| // TOK_BROWSE_ACCESS |
| |
| THIRD_ = 0x004, // can appear as third word of compound token |
| // eg. ONLY in FOR READ ONLY -> |
| // TOK_FOR_READ_ONLY |
| |
| RESWORD_ = 0x008, // a reserved word (ANSI, Pot. ANSI or COMPAQ) |
| |
| NONRESWORD_ = 0x010, // a non-reserved word. These are words that |
| // should be reserved (ANSI or Pot. ANSI) but |
| // are not for various reason. See ABSOLUTE, |
| // DATA, and OPERATION in ComResWords.cpp. |
| |
| NONRESTOKEN_ = 0x020, // a non-reserved token. These are words that |
| // can be used as a token or an identifier |
| // depending on the context. This flag is |
| // used only for notation. The Parser also |
| // maintains this list. |
| |
| MPWORD_ = 0x040, // a SQL/MP Reserved word. |
| |
| ALLOWOLDNEW_ = 0x080, // Indicates that the word is allowed if the |
| // ALLOWOLDNEW parser flag is set. In certain |
| // contexts the words OLD and NEW are allowed |
| // as identifiers. This flag identifies the |
| // extra words which are allowed in this |
| // context. |
| |
| ANS_ = 0x100, // Indicates that the word is reserved by ANSI |
| // This flag is used only for notation. |
| |
| POTANS_ = 0x200, // Indicates that the word is potentially |
| // reserved by ANSI. This flag is used only |
| // for notation. |
| |
| COMPAQ_ = 0x400, // Indicates that the word is reserved by |
| // COMPAQ. This flag is used only for notation. |
| |
| CONDITIONAL_RES_ = 0x800 // Indicates that the word is reserved |
| // conditionally. |
| }; |
| |
| // *********************************************************************** |
| // |
| // ParKeyWord : A description of a key word. |
| // |
| // *********************************************************************** |
| class ParKeyWord : public NABasicObject |
| { |
| public: |
| |
| // Constructors. |
| // |
| ParKeyWord(const ParKeyWord &other, NAMemory * h=0); |
| ParKeyWord(NAMemory * h=0) {}; |
| ParKeyWord(const char *kwd, Int32 code, UInt32 flags, NAMemory * h=0); |
| |
| // Destructor |
| // |
| virtual ~ParKeyWord() {}; |
| |
| // Is this key word allowed in the first, second or third position |
| // of a compound token. |
| // |
| inline NABoolean canBeFirst () const { return flags_ & FIRST_; }; |
| inline NABoolean canBeSecond() const { return flags_ & SECOND_; }; |
| inline NABoolean canBeThird () const { return flags_ & THIRD_; }; |
| |
| // Accessor methods. |
| // |
| inline const char *getKeyWord() const { return keyword_; }; |
| inline Int32 getTokenCode() const { return tokenCode_; }; |
| |
| // Is the word an identifier. |
| // |
| inline NABoolean isIdentifier() const { |
| return ((tokenCode_ == IDENTIFIER) || |
| (inMPContext() && !isMPReserved() && !(flags_ & NONRESTOKEN_))); |
| }; |
| |
| // Is the word reserved, depends on isMPContext. |
| // |
| inline NABoolean isReserved() const { |
| if (inMPContext()) { |
| return isMPReserved(); |
| } else { |
| return ((flags_ & RESWORD_) && |
| !(allowOldAndNew() && (flags_ & ALLOWOLDNEW_))); |
| } |
| }; |
| |
| inline NABoolean isConditionallyReserved() const { |
| return ( flags_ & (CONDITIONAL_RES_ | RESWORD_ ) ); |
| }; |
| |
| NABoolean useAsIdentifierInNonSpecialMode() const; |
| |
| private: |
| |
| // Are the keywords OLD and NEW allowed as identifiers. |
| // |
| inline static NABoolean allowOldAndNew(void) { |
| return Get_SqlParser_Flags(ALLOW_OLD_AND_NEW_KEYWORD) ? TRUE : FALSE; |
| } |
| |
| // Are we parsing/lexing MP Stored text. |
| // This affect which words are reserved, identifiers, or tokens. |
| // |
| inline static NABoolean inMPContext(void) { |
| return FALSE; |
| } |
| |
| // Is the word reserved by SQL/MP. |
| // |
| inline NABoolean isMPReserved() const { return flags_ & MPWORD_; }; |
| |
| |
| // The keyword. |
| // |
| const char *keyword_; |
| |
| // The token representing the keyword. |
| // |
| Int32 tokenCode_; |
| |
| // Attributes of the key word. |
| // |
| UInt32 flags_; |
| }; |
| |
| // *********************************************************************** |
| // |
| // ParKeyWords : A table of keywords (ParKeyWord). |
| // |
| // This class has no non-static data associated with it. It simple |
| // provides an interface to static data of the keyword table. |
| // |
| // *********************************************************************** |
| class ParKeyWords : public NABasicObject |
| { |
| public: |
| |
| // Constructor. |
| // |
| ParKeyWords(const ParKeyWords &other, NAMemory * h=0); |
| ParKeyWords(NAMemory * h=0); |
| |
| // Initialize the key word table. This will load in any changes to |
| // the table and sort it if these things have not already been done. |
| // |
| static void initKeyWordTable(void); |
| |
| // Find the given keyword in the key word table. If it is not |
| // found, return a pointer to the identifier keyword (see identWord_ |
| // below). |
| // |
| static const ParKeyWord *lookupKeyWord(NAWchar *id); |
| |
| // Check if key word table had been sorted |
| // |
| static const NABoolean keyWordTableSorted(void) { |
| return keyWordTableSorted_; |
| } |
| |
| private: |
| |
| // Comparision method for searching keyword table. |
| // |
| static Int32 keyCompare(const void *keyval, const void *datum); |
| |
| // Encapulates the searching of the keyword table. |
| // |
| static inline ParKeyWord *searchKeyWordTbl(ParKeyWord *key) { |
| return (ParKeyWord *)bsearch(key, |
| keyWords_, |
| numEntries_, |
| sizeof(ParKeyWord), |
| keyCompare); |
| } |
| |
| // Static data associated with all instances of this class. |
| // |
| |
| // The array of keywords. |
| // |
| static ParKeyWord keyWords_[]; |
| |
| // The default IDENTIFIER keyword. Used by lookupKeyWord() if the |
| // given word is not found in the keyword table. |
| // |
| static ParKeyWord identWord_; |
| |
| // The number of entries in the keyword table. |
| // |
| static size_t numEntries_; |
| |
| // The max length of all the keywords. |
| // |
| static size_t maxKeyWordLength_; |
| |
| // Indicates if the keyword table has been sorted. |
| // |
| static NABoolean keyWordTableSorted_; |
| }; |
| |
| #endif // PARKEYWORDS_H |
