| /* ----------------------------------------------------------------------------- |
| * sql.yy |
| * |
| * A simple context-free grammar to parse SQL files and translating |
| * CREATE FUNCTION statements into C++ function declarations. |
| * This allows .sql files to be documented by documentation tools like Doxygen. |
| * |
| * Revision History: |
| * 0.3: Florian Schoppmann, 29 Jan 2011, CREATE AGGREGATE supported, return |
| * types inferred from final function, |
| * line numbers are preserved |
| * 0.2: " , 16 Jan 2011, Converted to C++ |
| * 0.1: " , 10 Jan 2011, Initial version, support for CREATE |
| * FUNCTION. |
| * ----------------------------------------------------------------------------- |
| */ |
| |
| /* The %code directive needs bison >= 2.4 */ |
| %require "2.4" |
| |
| %code requires { |
| #include <map> |
| #include <fstream> |
| #include <cstring> |
| |
| /* |
| * FIXME: We should not disable warnings. Without this option, we would |
| * get the following warnings: |
| * 1) deprecated conversion from string constant to 'char*' |
| * 2) ignoring return value of '...', declared with attribute |
| * warn_unused_result |
| */ |
| #if defined(__GNUC__) |
| #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) |
| #pragma GCC diagnostic ignored "-Wwrite-strings" |
| #endif |
| #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) |
| #pragma GCC diagnostic ignored "-Wunused-result" |
| #endif |
| |
| #pragma GCC diagnostic ignored "-Wconversion" |
| #endif |
| |
| #ifdef COMPILING_SCANNER |
| /* Flex expects the signature of yylex to be defined in the macro |
| * YY_DECL. */ |
| #define YY_DECL \ |
| int \ |
| bison::SQLScanner::lex( \ |
| bison::SQLParser::semantic_type *yylval, \ |
| bison::SQLParser::location_type *yylloc, \ |
| bison::SQLDriver *driver \ |
| ) |
| #else |
| /* In the parser, we need to call the lexer and therefore need the |
| * lexer class declaration. */ |
| #define yyFlexLexer SQLFlexLexer |
| #undef yylex |
| #include "FlexLexer.h" |
| #undef yyFlexLexer |
| #endif |
| |
| namespace bison { |
| |
| /* Forward declaration because referenced by generated class declaration |
| * SQLParser */ |
| class SQLDriver; |
| |
| } |
| } |
| |
| %code provides { |
| namespace bison { |
| |
| class SQLScanner; |
| |
| class SQLDriver |
| { |
| public: |
| class CountingOStream { |
| public: |
| CountingOStream(); |
| CountingOStream &advance(int line); |
| CountingOStream &operator<<(const char *str); |
| CountingOStream &operator<<(char c); |
| |
| int currentLine; |
| }; |
| |
| SQLDriver(const std::string &inExeName, const std::string &inFilename); |
| virtual ~SQLDriver(); |
| void error(const SQLParser::location_type &l, const std::string &m); |
| void error(const std::string &m); |
| |
| CountingOStream cout; |
| std::map<std::string, char *> fnToReturnType; |
| SQLScanner *scanner; |
| std::string exeName; |
| std::string filename; |
| }; |
| |
| /* We need to subclass because SQLFlexLexer's yylex function does not have |
| * the proper signature */ |
| class SQLScanner : public SQLFlexLexer |
| { |
| public: |
| SQLScanner(std::istream *arg_yyin = 0, std::ostream* arg_yyout = 0); |
| virtual ~SQLScanner(); |
| static inline char *strlowerdup(const char *inString); |
| int lex(SQLParser::semantic_type *yylval, |
| SQLParser::location_type *yylloc, SQLDriver *driver); |
| void preScannerAction(SQLParser::semantic_type *yylval, |
| SQLParser::location_type *yylloc, SQLDriver *driver); |
| void more(); |
| |
| char *stringLiteralQuotation; |
| unsigned long oldLength; |
| }; |
| |
| class TaggedStr |
| { |
| public: |
| TaggedStr(int inTag, char *inStr) : tag(inTag), str(inStr) { }; |
| virtual ~TaggedStr() { }; |
| |
| int tag; |
| char *str; |
| }; |
| |
| } // namespace bison |
| |
| /* "Connect" the bison parser in the driver to the flex scanner class |
| * object. The C++ scanner generated by flex is a bit ugly, therefore |
| * this sort of hack here. |
| */ |
| #undef yylex |
| #define yylex driver->scanner->lex |
| } |
| |
| /* write out a header file containing the token defines */ |
| %defines |
| |
| /* use C++ and its skeleton file */ |
| %skeleton "lalr1.cc" |
| |
| /* keep track of the current position within the input */ |
| %locations |
| %initial-action { |
| // Initialize the initial location. |
| @$.begin.filename = @$.end.filename = &driver->filename; |
| }; |
| |
| /* The name of the parser class. */ |
| %define parser_class_name "SQLParser" |
| |
| /* Declare that an argument declared by the braced-code `argument-declaration' |
| * is an additional yyparse argument. The `argument-declaration' is used when |
| * declaring functions or prototypes. The last identifier in |
| * `argument-declaration' must be the argument name. */ |
| %parse-param { SQLDriver *driver } |
| |
| /* Declare that the braced-code argument-declaration is an additional yylex |
| * argument declaration. */ |
| %lex-param { SQLDriver *driver } |
| |
| /* namespace to enclose parser in */ |
| %name-prefix="bison" |
| |
| %union |
| { |
| char *str; |
| class TaggedStr *tStr; |
| int i; |
| } |
| |
| %token END 0 "end of file" |
| %token <str> IDENTIFIER "identifier" |
| |
| %token <str> COMMENT |
| |
| %token CREATE_FUNCTION |
| %token CREATE_AGGREGATE |
| |
| /* Function tokens */ |
| %token IN |
| %token OUT |
| %token INOUT |
| |
| %token RETURNS |
| %token SETOF |
| |
| %token AS |
| %token LANGUAGE |
| %token IMMUTABLE |
| %token STABLE |
| %token VOLATILE |
| %token CALLED_ON_NULL_INPUT |
| %token RETURNS_NULL_ON_NULL_INPUT |
| %token SECURITY_INVOKER |
| %token SECURITY_DEFINER |
| |
| %token DEFAULT |
| |
| /* Aggregate tokens */ |
| %token <i> SFUNC |
| %token <i> PREFUNC |
| %token <i> FINALFUNC |
| %token SORTOP |
| %token STYPE |
| %token INITCOND |
| |
| /* types with more than 1 word */ |
| %token BIT |
| %token CHARACTER |
| %token DOUBLE |
| %token PRECISION |
| %token TIME |
| %token VARYING |
| %token VOID |
| %token WITH |
| %token WITHOUT |
| %token ZONE |
| |
| %token <str> INTEGER_LITERAL |
| %token <str> FLOAT_LITERAL |
| %token <str> STRING_LITERAL |
| %token <str> NULL_KEYWORD |
| |
| /* Special tokens, for extending SQL syntax in C commands */ |
| %token BEGIN_SPECIAL |
| %token END_SPECIAL |
| |
| %type <str> expr |
| %type <str> prefixExpr |
| %type <str> qualifiedIdent |
| %type <str> optFnArgList fnArgList fnArgument |
| %type <str> optDefaultArgument defaultArgument |
| %type <str> optAggArgList aggArgList aggArgument |
| %type <str> argname type baseType optLength optArray array |
| %type <str> returnDecl retType |
| %type <tStr> aggOptionList aggOption |
| %type <i> aggFunc |
| |
| |
| %% /* Grammar rules and actions follow. */ |
| |
| input: |
| | input stmt |
| | input COMMENT { driver->cout.advance(@2.begin.line) << $2; } |
| | input '\n' { driver->cout << '\n'; } |
| ; |
| |
| stmt: |
| ';' |
| | createFnStmt ';' |
| | createAggStmt ';' |
| ; |
| |
| createFnStmt: |
| CREATE_FUNCTION qualifiedIdent '(' optFnArgList ')' returnDecl fnOptions { |
| driver->cout.advance(@1.begin.line) << $6 << ' ' << $2 << '(' << $4 << ") { };"; |
| driver->fnToReturnType.insert(std::pair<std::string,char *>($2, $6)); |
| } |
| ; |
| |
| createAggStmt: |
| CREATE_AGGREGATE qualifiedIdent '(' optAggArgList ')' '(' aggOptionList ')' { |
| driver->cout.advance(@1.begin.line) << "@aggregate " |
| << ($7 == NULL ? "" : $7->str) << ' ' << $2 << '(' << $4 << ") { };"; |
| } |
| ; |
| |
| qualifiedIdent: |
| IDENTIFIER |
| | IDENTIFIER '.' IDENTIFIER { |
| $$ = $3; |
| } |
| ; |
| |
| optFnArgList: { $$ = ""; } |
| | fnArgList |
| ; |
| |
| optAggArgList: |
| '*' { $$ = ""; } |
| | aggArgList |
| ; |
| |
| fnArgList: |
| fnArgList ',' fnArgument { |
| /* Yes, we'll leak memory. And we'll fail if there is not enough. |
| * We ignore all that here and below. */ |
| asprintf(&($$), "%s, %s", $1, $3); |
| } |
| | fnArgument |
| ; |
| |
| aggArgList: |
| aggArgList ',' aggArgument { |
| asprintf(&($$), "%s, %s", $1, $3); |
| } |
| | aggArgument |
| |
| fnArgument: |
| type optDefaultArgument { |
| asprintf(&($$), "%s%s", $1, $2); |
| } |
| | argname type optDefaultArgument { |
| asprintf(&($$), "%s %s%s", $2, $1, $3); |
| } |
| | argmode argname type optDefaultArgument { |
| asprintf(&($$), "%s %s%s", $3, $2, $4); |
| } |
| ; |
| |
| optDefaultArgument: { $$ = ""; } |
| | defaultArgument |
| | BEGIN_SPECIAL defaultArgument END_SPECIAL { $$ = $2; } |
| ; |
| |
| defaultArgument: |
| DEFAULT expr { |
| asprintf(&($$), " = %s", $2); |
| } |
| | '=' expr { |
| asprintf(&($$), " = %s", $2); |
| } |
| ; |
| |
| aggArgument: |
| type optDefaultArgument |
| | argname type optDefaultArgument { |
| asprintf(&($$), "%s %s%s", $2, $1, $3); |
| } |
| ; |
| |
| argmode: |
| IN |
| | OUT |
| | INOUT |
| ; |
| |
| argname: |
| IDENTIFIER |
| | BEGIN_SPECIAL IDENTIFIER END_SPECIAL { $$ = $2; } |
| ; |
| |
| type: |
| baseType optArray { |
| asprintf(&($$), "%s%s", $1, $2); |
| } |
| ; |
| |
| baseType: |
| qualifiedIdent |
| | BIT VARYING optLength { |
| asprintf(&($$), "varbit%s", $3); |
| } |
| | CHARACTER VARYING optLength { |
| asprintf(&($$), "varchar%s", $3); |
| } |
| | DOUBLE PRECISION { $$ = "float8"; } |
| | VOID { $$ = "void"; } |
| ; |
| |
| optArray: { $$ = ""; } |
| | array; |
| |
| optLength: { $$ = ""; } |
| | '(' INTEGER_LITERAL ')' { |
| asprintf(&($$), "(%s)", $2); |
| } |
| ; |
| |
| array: |
| '[' ']' { $$ = "[]"; } |
| | '[' INTEGER_LITERAL ']' { |
| asprintf(&($$), "[%s]", $2); |
| } |
| | array '[' ']' { |
| asprintf(&($$), "%s[]", $1); |
| } |
| | array '[' INTEGER_LITERAL ']' { |
| asprintf(&($$), "%s[%s]", $1, $3); |
| } |
| ; |
| |
| returnDecl: { $$ = "void"; } |
| | RETURNS retType { $$ = $2; } |
| ; |
| |
| retType: |
| type |
| | SETOF type { |
| asprintf(&($$), "set<%s>", $2); |
| } |
| ; |
| |
| fnOptions: |
| | fnOptions fnOption; |
| |
| fnOption: |
| AS STRING_LITERAL |
| | AS STRING_LITERAL ',' STRING_LITERAL |
| | LANGUAGE STRING_LITERAL |
| | LANGUAGE IDENTIFIER |
| | IMMUTABLE |
| | STABLE |
| | VOLATILE |
| | CALLED_ON_NULL_INPUT |
| | RETURNS_NULL_ON_NULL_INPUT |
| | SECURITY_INVOKER |
| | SECURITY_DEFINER |
| ; |
| |
| aggOptionList: |
| aggOptionList ',' aggOption { |
| if ($1 == NULL) |
| $$ = $3; |
| else if ($3 == NULL) |
| $$ = $1; |
| else if ($1->tag == token::FINALFUNC) |
| $$ = $1; |
| else |
| $$ = $3; |
| } |
| | aggOption |
| ; |
| |
| aggOption: |
| aggFunc '=' qualifiedIdent { |
| $$ = new TaggedStr($1, driver->fnToReturnType[$3]); |
| } |
| | STYPE '=' type { $$ = new TaggedStr(token::STYPE, $3); } |
| | INITCOND '=' expr { $$ = NULL; } |
| /* FIXME: SORTOP not yet supported at this point */ |
| ; |
| |
| aggFunc: |
| SFUNC |
| | PREFUNC |
| | FINALFUNC |
| ; |
| |
| expr: |
| INTEGER_LITERAL |
| | FLOAT_LITERAL |
| | STRING_LITERAL |
| | IDENTIFIER |
| | NULL_KEYWORD |
| | prefixExpr |
| /* FIXME: Support more or ignore completely */ |
| ; |
| |
| prefixExpr: |
| '+' expr { |
| asprintf(&($$), "+%s", $2); |
| } |
| | '-' expr { |
| asprintf(&($$), "-%s", $2); |
| } |
| ; |
| |
| %% |
| |
| namespace bison{ |
| |
| SQLDriver::SQLDriver(const std::string &inExeName, |
| const std::string &inFilename) |
| : exeName(inExeName), filename(inFilename) { } |
| |
| SQLDriver::~SQLDriver() { } |
| |
| void SQLDriver::error(const SQLParser::location_type &l, const std::string &m) { |
| std::cerr << exeName << ":" << l << ": " << m << std::endl; |
| } |
| |
| void SQLDriver::error(const std::string &m) { |
| std::cerr << m << std::endl; |
| } |
| |
| SQLDriver::CountingOStream::CountingOStream() : currentLine(1) { |
| } |
| |
| SQLDriver::CountingOStream &SQLDriver::CountingOStream::advance(int line) { |
| while (currentLine < line) { |
| std::cout.put('\n'); |
| currentLine++; |
| } |
| return *this; |
| } |
| |
| SQLDriver::CountingOStream &SQLDriver::CountingOStream::operator<<( |
| const char *str) { |
| |
| for (int i = 0; str[i] != 0; i++) |
| if (str[i] == '\n') |
| currentLine++; |
| |
| std::cout << str; |
| return *this; |
| } |
| |
| SQLDriver::CountingOStream &SQLDriver::CountingOStream::operator<<(char c) { |
| if (c == '\n') currentLine++; |
| std::cout.put(c); |
| return *this; |
| } |
| |
| |
| void SQLParser::error(const SQLParser::location_type &l, |
| const std::string &m) { |
| |
| driver->error(l, m); |
| } |
| |
| } // namespace bison |
| |
| /* This implementation of SQLFlexLexer::yylex() is required because it is |
| * declared in FlexLexer.h. The scanner's "real" yylex function is generated by |
| * flex and "connected" via YY_DECL. */ |
| #ifdef yylex |
| #undef yylex |
| #endif |
| int SQLFlexLexer::yylex() |
| { |
| std::cerr << |
| "Error: SQLFlexLexer::yylex() was called. Use SQLScanner::lex() instead" |
| << std::endl; |
| return 0; |
| } |
| |
| int main(int argc, char **argv) |
| { |
| std::istream *inStream = NULL; |
| std::string filename = "<stdin>"; |
| bool error = false; |
| bool customFileName = false; |
| |
| for (int i = 1; i < argc; i++) { |
| if (std::strcmp(argv[1], "-f") == 0) { |
| if (i < argc - 1) { |
| filename = argv[++i]; |
| customFileName = true; |
| } else { |
| error = true; |
| break; |
| } |
| } else if (inStream == NULL) { |
| inStream = new std::ifstream(argv[i]); |
| if (!customFileName) |
| filename = argv[i]; |
| } |
| } |
| if (error) { |
| std::cerr << "Usage: " << argv[0] << " [-f customFileName] [inputFile]" |
| << std::endl; |
| return 1; |
| } |
| |
| bison::SQLDriver driver(argv[0], filename); |
| bison::SQLScanner scanner(inStream); driver.scanner = &scanner; |
| bison::SQLParser parser(&driver); |
| |
| int result = parser.parse(); |
| |
| if (inStream != NULL) |
| delete inStream; |
| |
| if (result != 0) |
| return result; |
| |
| std::cout << '\n'; |
| |
| /* |
| std::cout << "// List of functions:\n"; |
| for (std::map<std::string,char *>::iterator it = driver.fnToReturnType.begin(); |
| it != driver.fnToReturnType.end(); it++) |
| std::cout << "// " << (*it).first << ": return type " << (*it).second << std::endl; |
| */ |
| return 0; |
| } |
