Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
tree: 1d39fc1460
Fetching contributors…

Cannot retrieve contributors at this time

2113 lines (1934 sloc) 50.484 kb
/*
* $Id: sql.c 703 2009-03-14 22:06:12Z dfishburn $
*
* Copyright (c) 2002-2003, Darren Hiebert
*
* This source code is released for free distribution under the terms of the
* GNU General Public License.
*
* This module contains functions for generating tags for PL/SQL language
* files.
*/
/*
* INCLUDE FILES
*/
#include "general.h" /* must always come first */
#include <ctype.h> /* to define isalpha () */
#include <setjmp.h>
#ifdef DEBUG
#include <stdio.h>
#endif
#include "debug.h"
#include "entry.h"
#include "keyword.h"
#include "parse.h"
#include "read.h"
#include "routines.h"
#include "vstring.h"
/*
* On-line "Oracle Database PL/SQL Language Reference":
* http://download.oracle.com/docs/cd/B28359_01/appdev.111/b28370/toc.htm
*
* Sample PL/SQL code is available from:
* http://www.orafaq.com/faqscrpt.htm#GENPLSQL
*
* On-line SQL Anywhere Documentation
* http://www.ianywhere.com/developer/product_manuals/sqlanywhere/index.html
*/
/*
* MACROS
*/
#define isType(token,t) (boolean) ((token)->type == (t))
#define isKeyword(token,k) (boolean) ((token)->keyword == (k))
/*
* DATA DECLARATIONS
*/
typedef enum eException { ExceptionNone, ExceptionEOF } exception_t;
/*
* Used to specify type of keyword.
*/
typedef enum eKeywordId {
KEYWORD_NONE = -1,
KEYWORD_is,
KEYWORD_begin,
KEYWORD_body,
KEYWORD_cursor,
KEYWORD_declare,
KEYWORD_end,
KEYWORD_function,
KEYWORD_if,
KEYWORD_loop,
KEYWORD_case,
KEYWORD_for,
KEYWORD_call,
KEYWORD_package,
KEYWORD_pragma,
KEYWORD_procedure,
KEYWORD_record,
KEYWORD_object,
KEYWORD_ref,
KEYWORD_rem,
KEYWORD_return,
KEYWORD_returns,
KEYWORD_subtype,
KEYWORD_table,
KEYWORD_trigger,
KEYWORD_type,
KEYWORD_index,
KEYWORD_event,
KEYWORD_publication,
KEYWORD_service,
KEYWORD_domain,
KEYWORD_datatype,
KEYWORD_result,
KEYWORD_url,
KEYWORD_internal,
KEYWORD_external,
KEYWORD_when,
KEYWORD_then,
KEYWORD_variable,
KEYWORD_exception,
KEYWORD_at,
KEYWORD_on,
KEYWORD_primary,
KEYWORD_references,
KEYWORD_unique,
KEYWORD_check,
KEYWORD_constraint,
KEYWORD_foreign,
KEYWORD_ml_table,
KEYWORD_ml_table_lang,
KEYWORD_ml_table_dnet,
KEYWORD_ml_table_java,
KEYWORD_ml_table_chk,
KEYWORD_ml_conn,
KEYWORD_ml_conn_lang,
KEYWORD_ml_conn_dnet,
KEYWORD_ml_conn_java,
KEYWORD_ml_conn_chk,
KEYWORD_local,
KEYWORD_temporary,
KEYWORD_drop,
KEYWORD_view,
KEYWORD_synonym,
KEYWORD_handler,
KEYWORD_comment,
KEYWORD_create,
KEYWORD_go
} keywordId;
/*
* Used to determine whether keyword is valid for the token language and
* what its ID is.
*/
typedef struct sKeywordDesc {
const char *name;
keywordId id;
} keywordDesc;
typedef enum eTokenType {
TOKEN_UNDEFINED,
TOKEN_BLOCK_LABEL_BEGIN,
TOKEN_BLOCK_LABEL_END,
TOKEN_CHARACTER,
TOKEN_CLOSE_PAREN,
TOKEN_SEMICOLON,
TOKEN_COMMA,
TOKEN_IDENTIFIER,
TOKEN_KEYWORD,
TOKEN_OPEN_PAREN,
TOKEN_OPERATOR,
TOKEN_OTHER,
TOKEN_STRING,
TOKEN_PERIOD,
TOKEN_OPEN_CURLY,
TOKEN_CLOSE_CURLY,
TOKEN_OPEN_SQUARE,
TOKEN_CLOSE_SQUARE,
TOKEN_TILDE,
TOKEN_FORWARD_SLASH
} tokenType;
typedef struct sTokenInfoSQL {
tokenType type;
keywordId keyword;
vString * string;
vString * scope;
int begin_end_nest_lvl;
unsigned long lineNumber;
fpos_t filePosition;
} tokenInfo;
/*
* DATA DEFINITIONS
*/
static langType Lang_sql;
static jmp_buf Exception;
typedef enum {
SQLTAG_CURSOR,
SQLTAG_PROTOTYPE,
SQLTAG_FUNCTION,
SQLTAG_FIELD,
SQLTAG_LOCAL_VARIABLE,
SQLTAG_BLOCK_LABEL,
SQLTAG_PACKAGE,
SQLTAG_PROCEDURE,
SQLTAG_RECORD,
SQLTAG_SUBTYPE,
SQLTAG_TABLE,
SQLTAG_TRIGGER,
SQLTAG_VARIABLE,
SQLTAG_INDEX,
SQLTAG_EVENT,
SQLTAG_PUBLICATION,
SQLTAG_SERVICE,
SQLTAG_DOMAIN,
SQLTAG_VIEW,
SQLTAG_SYNONYM,
SQLTAG_MLTABLE,
SQLTAG_MLCONN,
SQLTAG_COUNT
} sqlKind;
static kindOption SqlKinds [] = {
{ TRUE, 'c', "cursor", "cursors" },
{ FALSE, 'd', "prototype", "prototypes" },
{ TRUE, 'f', "function", "functions" },
{ TRUE, 'F', "field", "record fields" },
{ FALSE, 'l', "local", "local variables" },
{ TRUE, 'L', "label", "block label" },
{ TRUE, 'P', "package", "packages" },
{ TRUE, 'p', "procedure", "procedures" },
{ FALSE, 'r', "record", "records" },
{ TRUE, 's', "subtype", "subtypes" },
{ TRUE, 't', "table", "tables" },
{ TRUE, 'T', "trigger", "triggers" },
{ TRUE, 'v', "variable", "variables" },
{ TRUE, 'i', "index", "indexes" },
{ TRUE, 'e', "event", "events" },
{ TRUE, 'U', "publication", "publications" },
{ TRUE, 'R', "service", "services" },
{ TRUE, 'D', "domain", "domains" },
{ TRUE, 'V', "view", "views" },
{ TRUE, 'n', "synonym", "synonyms" },
{ TRUE, 'x', "mltable", "MobiLink Table Scripts" },
{ TRUE, 'y', "mlconn", "MobiLink Conn Scripts" }
};
static const keywordDesc SqlKeywordTable [] = {
/* keyword keyword ID */
{ "as", KEYWORD_is },
{ "is", KEYWORD_is },
{ "begin", KEYWORD_begin },
{ "body", KEYWORD_body },
{ "cursor", KEYWORD_cursor },
{ "declare", KEYWORD_declare },
{ "end", KEYWORD_end },
{ "function", KEYWORD_function },
{ "if", KEYWORD_if },
{ "loop", KEYWORD_loop },
{ "case", KEYWORD_case },
{ "for", KEYWORD_for },
{ "call", KEYWORD_call },
{ "package", KEYWORD_package },
{ "pragma", KEYWORD_pragma },
{ "procedure", KEYWORD_procedure },
{ "record", KEYWORD_record },
{ "object", KEYWORD_object },
{ "ref", KEYWORD_ref },
{ "rem", KEYWORD_rem },
{ "return", KEYWORD_return },
{ "returns", KEYWORD_returns },
{ "subtype", KEYWORD_subtype },
{ "table", KEYWORD_table },
{ "trigger", KEYWORD_trigger },
{ "type", KEYWORD_type },
{ "index", KEYWORD_index },
{ "event", KEYWORD_event },
{ "publication", KEYWORD_publication },
{ "service", KEYWORD_service },
{ "domain", KEYWORD_domain },
{ "datatype", KEYWORD_datatype },
{ "result", KEYWORD_result },
{ "url", KEYWORD_url },
{ "internal", KEYWORD_internal },
{ "external", KEYWORD_external },
{ "when", KEYWORD_when },
{ "then", KEYWORD_then },
{ "variable", KEYWORD_variable },
{ "exception", KEYWORD_exception },
{ "at", KEYWORD_at },
{ "on", KEYWORD_on },
{ "primary", KEYWORD_primary },
{ "references", KEYWORD_references },
{ "unique", KEYWORD_unique },
{ "check", KEYWORD_check },
{ "constraint", KEYWORD_constraint },
{ "foreign", KEYWORD_foreign },
{ "ml_add_table_script", KEYWORD_ml_table },
{ "ml_add_lang_table_script", KEYWORD_ml_table_lang },
{ "ml_add_dnet_table_script", KEYWORD_ml_table_dnet },
{ "ml_add_java_table_script", KEYWORD_ml_table_java },
{ "ml_add_lang_table_script_chk", KEYWORD_ml_table_chk },
{ "ml_add_connection_script", KEYWORD_ml_conn },
{ "ml_add_lang_connection_script", KEYWORD_ml_conn_lang },
{ "ml_add_dnet_connection_script", KEYWORD_ml_conn_dnet },
{ "ml_add_java_connection_script", KEYWORD_ml_conn_java },
{ "ml_add_lang_conn_script_chk", KEYWORD_ml_conn_chk },
{ "local", KEYWORD_local },
{ "temporary", KEYWORD_temporary },
{ "drop", KEYWORD_drop },
{ "view", KEYWORD_view },
{ "synonym", KEYWORD_synonym },
{ "handler", KEYWORD_handler },
{ "comment", KEYWORD_comment },
{ "create", KEYWORD_create },
{ "go", KEYWORD_go }
};
/*
* FUNCTION DECLARATIONS
*/
/* Recursive calls */
static void parseBlock (tokenInfo *const token, const boolean local);
static void parseKeywords (tokenInfo *const token);
static void parseSqlFile (tokenInfo *const token);
/*
* FUNCTION DEFINITIONS
*/
static boolean isIdentChar1 (const int c)
{
/*
* Other databases are less restrictive on the first character of
* an identifier.
* isIdentChar1 is used to identify the first character of an
* identifier, so we are removing some restrictions.
*/
return (boolean)
(isalpha (c) || c == '@' || c == '_' );
}
static boolean isIdentChar (const int c)
{
return (boolean)
(isalpha (c) || isdigit (c) || c == '$' ||
c == '@' || c == '_' || c == '#');
}
static boolean isCmdTerm (tokenInfo *const token)
{
DebugStatement (
debugPrintf (DEBUG_PARSE
, "\n isCmdTerm: token same tt:%d tk:%d\n"
, token->type
, token->keyword
);
);
/*
* Based on the various customer sites I have been at
* the most common command delimiters are
* ;
* ~
* /
* go
* This routine will check for any of these, more
* can easily be added by modifying readToken and
* either adding the character to:
* enum eTokenType
* enum eTokenType
*/
return ( isType (token, TOKEN_SEMICOLON) ||
isType (token, TOKEN_TILDE) ||
isType (token, TOKEN_FORWARD_SLASH) ||
isKeyword (token, KEYWORD_go)
);
}
static boolean isMatchedEnd(tokenInfo *const token, int nest_lvl)
{
boolean terminated = FALSE;
/*
* Since different forms of SQL allow the use of
* BEGIN
* ...
* END
* blocks, some statements may not be terminated using
* the standard delimiters:
* ;
* ~
* /
* go
* This routine will check to see if we encounter and END
* for the matching nest level of BEGIN ... END statements.
* If we find one, then we can assume, the statement was terminated
* since we have fallen through to the END statement of the BEGIN
* block.
*/
if ( nest_lvl > 0 && isKeyword (token, KEYWORD_end) )
{
if ( token->begin_end_nest_lvl == nest_lvl )
terminated = TRUE;
}
return terminated;
}
static void buildSqlKeywordHash (void)
{
const size_t count = sizeof (SqlKeywordTable) /
sizeof (SqlKeywordTable [0]);
size_t i;
for (i = 0 ; i < count ; ++i)
{
const keywordDesc* const p = &SqlKeywordTable [i];
addKeyword (p->name, Lang_sql, (int) p->id);
}
}
static tokenInfo *newToken (void)
{
tokenInfo *const token = xMalloc (1, tokenInfo);
token->type = TOKEN_UNDEFINED;
token->keyword = KEYWORD_NONE;
token->string = vStringNew ();
token->scope = vStringNew ();
token->begin_end_nest_lvl = 0;
token->lineNumber = getSourceLineNumber ();
token->filePosition = getInputFilePosition ();
return token;
}
static void deleteToken (tokenInfo *const token)
{
vStringDelete (token->string);
vStringDelete (token->scope);
eFree (token);
}
/*
* Tag generation functions
*/
static void makeConstTag (tokenInfo *const token, const sqlKind kind)
{
if (SqlKinds [kind].enabled)
{
const char *const name = vStringValue (token->string);
tagEntryInfo e;
initTagEntry (&e, name);
e.lineNumber = token->lineNumber;
e.filePosition = token->filePosition;
e.kindName = SqlKinds [kind].name;
e.kind = SqlKinds [kind].letter;
makeTagEntry (&e);
}
}
static void makeSqlTag (tokenInfo *const token, const sqlKind kind)
{
vString * fulltag;
if (SqlKinds [kind].enabled)
{
/*
* If a scope has been added to the token, change the token
* string to include the scope when making the tag.
*/
if ( vStringLength(token->scope) > 0 )
{
fulltag = vStringNew ();
vStringCopy(fulltag, token->scope);
vStringCatS (fulltag, ".");
vStringCatS (fulltag, vStringValue(token->string));
vStringTerminate(fulltag);
vStringCopy(token->string, fulltag);
vStringDelete (fulltag);
}
makeConstTag (token, kind);
}
}
/*
* Parsing functions
*/
static void parseString (vString *const string, const int delimiter)
{
boolean end = FALSE;
while (! end)
{
int c = fileGetc ();
if (c == EOF)
end = TRUE;
/*
else if (c == '\\')
{
c = fileGetc(); // This maybe a ' or ". //
vStringPut(string, c);
}
*/
else if (c == delimiter)
end = TRUE;
else
vStringPut (string, c);
}
vStringTerminate (string);
}
/* Read a C identifier beginning with "firstChar" and places it into "name".
*/
static void parseIdentifier (vString *const string, const int firstChar)
{
int c = firstChar;
Assert (isIdentChar1 (c));
do
{
vStringPut (string, c);
c = fileGetc ();
} while (isIdentChar (c));
vStringTerminate (string);
if (!isspace (c))
fileUngetc (c); /* unget non-identifier character */
}
static void readToken (tokenInfo *const token)
{
int c;
token->type = TOKEN_UNDEFINED;
token->keyword = KEYWORD_NONE;
vStringClear (token->string);
getNextChar:
do
{
c = fileGetc ();
token->lineNumber = getSourceLineNumber ();
token->filePosition = getInputFilePosition ();
/*
* Added " to the list of ignores, not sure what this
* might break but it gets by this issue:
* create table "t1" (...)
*
* Darren, the code passes all my tests for both
* Oracle and SQL Anywhere, but maybe you can tell me
* what this may effect.
*/
}
while (c == '\t' || c == ' ' || c == '\n');
switch (c)
{
case EOF: longjmp (Exception, (int)ExceptionEOF); break;
case '(': token->type = TOKEN_OPEN_PAREN; break;
case ')': token->type = TOKEN_CLOSE_PAREN; break;
case ';': token->type = TOKEN_SEMICOLON; break;
case '.': token->type = TOKEN_PERIOD; break;
case ',': token->type = TOKEN_COMMA; break;
case '{': token->type = TOKEN_OPEN_CURLY; break;
case '}': token->type = TOKEN_CLOSE_CURLY; break;
case '~': token->type = TOKEN_TILDE; break;
case '[': token->type = TOKEN_OPEN_SQUARE; break;
case ']': token->type = TOKEN_CLOSE_SQUARE; break;
case '\'':
case '"':
token->type = TOKEN_STRING;
parseString (token->string, c);
token->lineNumber = getSourceLineNumber ();
token->filePosition = getInputFilePosition ();
break;
case '-':
c = fileGetc ();
if (c == '-') /* -- is this the start of a comment? */
{
fileSkipToCharacter ('\n');
goto getNextChar;
}
else
{
if (!isspace (c))
fileUngetc (c);
token->type = TOKEN_OPERATOR;
}
break;
case '<':
case '>':
{
const int initial = c;
int d = fileGetc ();
if (d == initial)
{
if (initial == '<')
token->type = TOKEN_BLOCK_LABEL_BEGIN;
else
token->type = TOKEN_BLOCK_LABEL_END;
}
else
{
fileUngetc (d);
token->type = TOKEN_UNDEFINED;
}
break;
}
case '\\':
c = fileGetc ();
if (c != '\\' && c != '"' && c != '\'' && !isspace (c))
fileUngetc (c);
token->type = TOKEN_CHARACTER;
token->lineNumber = getSourceLineNumber ();
token->filePosition = getInputFilePosition ();
break;
case '/':
{
int d = fileGetc ();
if ( (d != '*') && /* is this the start of a comment? */
(d != '/') ) /* is a one line comment? */
{
token->type = TOKEN_FORWARD_SLASH;
fileUngetc (d);
}
else
{
if (d == '*')
{
do
{
fileSkipToCharacter ('*');
c = fileGetc ();
if (c == '/')
break;
else
fileUngetc (c);
} while (c != EOF && c != '\0');
goto getNextChar;
}
else if (d == '/') /* is this the start of a comment? */
{
fileSkipToCharacter ('\n');
goto getNextChar;
}
}
break;
}
default:
if (! isIdentChar1 (c))
token->type = TOKEN_UNDEFINED;
else
{
parseIdentifier (token->string, c);
token->lineNumber = getSourceLineNumber ();
token->filePosition = getInputFilePosition ();
token->keyword = analyzeToken (token->string, Lang_sql);
if (isKeyword (token, KEYWORD_rem))
{
vStringClear (token->string);
fileSkipToCharacter ('\n');
goto getNextChar;
}
else if (isKeyword (token, KEYWORD_NONE))
token->type = TOKEN_IDENTIFIER;
else
token->type = TOKEN_KEYWORD;
}
break;
}
}
/*
* Token parsing functions
*/
/*
* static void addContext (tokenInfo* const parent, const tokenInfo* const child)
* {
* if (vStringLength (parent->string) > 0)
* {
* vStringCatS (parent->string, ".");
* }
* vStringCatS (parent->string, vStringValue(child->string));
* vStringTerminate(parent->string);
* }
*/
static void addToScope (tokenInfo* const token, vString* const extra)
{
if (vStringLength (token->scope) > 0)
{
vStringCatS (token->scope, ".");
}
vStringCatS (token->scope, vStringValue(extra));
vStringTerminate(token->scope);
}
/*
* Scanning functions
*/
static void findToken (tokenInfo *const token, const tokenType type)
{
while (! isType (token, type))
{
readToken (token);
}
}
static void findCmdTerm (tokenInfo *const token, const boolean check_first)
{
int begin_end_nest_lvl = token->begin_end_nest_lvl;
if ( check_first )
{
if ( isCmdTerm(token) )
return;
}
do
{
readToken (token);
} while ( !isCmdTerm(token) && !isMatchedEnd(token, begin_end_nest_lvl) );
}
static void skipToMatched(tokenInfo *const token)
{
int nest_level = 0;
tokenType open_token;
tokenType close_token;
switch (token->type)
{
case TOKEN_OPEN_PAREN:
open_token = TOKEN_OPEN_PAREN;
close_token = TOKEN_CLOSE_PAREN;
break;
case TOKEN_OPEN_CURLY:
open_token = TOKEN_OPEN_CURLY;
close_token = TOKEN_CLOSE_CURLY;
break;
case TOKEN_OPEN_SQUARE:
open_token = TOKEN_OPEN_SQUARE;
close_token = TOKEN_CLOSE_SQUARE;
break;
default:
return;
}
/*
* This routine will skip to a matching closing token.
* It will also handle nested tokens like the (, ) below.
* ( name varchar(30), text binary(10) )
*/
if (isType (token, open_token))
{
nest_level++;
while (! (isType (token, close_token) && (nest_level == 0)))
{
readToken (token);
if (isType (token, open_token))
{
nest_level++;
}
if (isType (token, close_token))
{
if (nest_level > 0)
{
nest_level--;
}
}
}
readToken (token);
}
}
static void skipArgumentList (tokenInfo *const token)
{
/*
* Other databases can have arguments with fully declared
* datatypes:
* ( name varchar(30), text binary(10) )
* So we must check for nested open and closing parantheses
*/
if (isType (token, TOKEN_OPEN_PAREN)) /* arguments? */
{
skipToMatched (token);
}
}
static void parseSubProgram (tokenInfo *const token)
{
tokenInfo *const name = newToken ();
/*
* This must handle both prototypes and the body of
* the procedures.
*
* Prototype:
* FUNCTION func_name RETURN integer;
* PROCEDURE proc_name( parameters );
* Procedure
* FUNCTION GET_ML_USERNAME RETURN VARCHAR2
* IS
* BEGIN
* RETURN v_sync_user_id;
* END GET_ML_USERNAME;
*
* PROCEDURE proc_name( parameters )
* IS
* BEGIN
* END;
* CREATE PROCEDURE proc_name( parameters )
* EXTERNAL NAME ... ;
* CREATE PROCEDURE proc_name( parameters )
* BEGIN
* END;
*
* CREATE FUNCTION f_GetClassName(
* IN @object VARCHAR(128)
* ,IN @code VARCHAR(128)
* )
* RETURNS VARCHAR(200)
* DETERMINISTIC
* BEGIN
*
* IF( @object = 'user_state' ) THEN
* SET something = something;
* END IF;
*
* RETURN @name;
* END;
*/
const sqlKind kind = isKeyword (token, KEYWORD_function) ?
SQLTAG_FUNCTION : SQLTAG_PROCEDURE;
Assert (isKeyword (token, KEYWORD_function) ||
isKeyword (token, KEYWORD_procedure));
readToken (name);
readToken (token);
if (isType (token, TOKEN_PERIOD))
{
readToken (name);
readToken (token);
}
if (isType (token, TOKEN_OPEN_PAREN))
{
/* Reads to the next token after the TOKEN_CLOSE_PAREN */
skipArgumentList(token);
}
if (kind == SQLTAG_FUNCTION)
{
if (isKeyword (token, KEYWORD_return) || isKeyword (token, KEYWORD_returns))
{
/* Read datatype */
readToken (token);
/*
* Read token after which could be the
* command terminator if a prototype
* or an open parantheses
*/
readToken (token);
if (isType (token, TOKEN_OPEN_PAREN))
{
/* Reads to the next token after the TOKEN_CLOSE_PAREN */
skipArgumentList(token);
}
}
}
if( isCmdTerm (token) )
{
makeSqlTag (name, SQLTAG_PROTOTYPE);
}
else
{
while (!(isKeyword (token, KEYWORD_is) ||
isKeyword (token, KEYWORD_begin) ||
isKeyword (token, KEYWORD_at) ||
isKeyword (token, KEYWORD_internal) ||
isKeyword (token, KEYWORD_external) ||
isKeyword (token, KEYWORD_url) ||
isCmdTerm (token)
)
)
{
if ( isKeyword (token, KEYWORD_result) )
{
readToken (token);
if (isType (token, TOKEN_OPEN_PAREN))
{
/* Reads to the next token after the TOKEN_CLOSE_PAREN */
skipArgumentList(token);
}
} else {
readToken (token);
}
}
if (isKeyword (token, KEYWORD_at) ||
isKeyword (token, KEYWORD_url) ||
isKeyword (token, KEYWORD_internal) ||
isKeyword (token, KEYWORD_external) )
{
addToScope(token, name->string);
if (isType (name, TOKEN_IDENTIFIER) ||
isType (name, TOKEN_STRING) ||
!isKeyword (token, KEYWORD_NONE)
)
makeSqlTag (name, kind);
vStringClear (token->scope);
}
if (isKeyword (token, KEYWORD_is) ||
isKeyword (token, KEYWORD_begin) )
{
addToScope(token, name->string);
if (isType (name, TOKEN_IDENTIFIER) ||
isType (name, TOKEN_STRING) ||
!isKeyword (token, KEYWORD_NONE)
)
makeSqlTag (name, kind);
parseBlock (token, TRUE);
vStringClear (token->scope);
}
}
deleteToken (name);
}
static void parseRecord (tokenInfo *const token)
{
/*
* Make it a bit forgiving, this is called from
* multiple functions, parseTable, parseType
*/
if (!isType (token, TOKEN_OPEN_PAREN))
readToken (token);
Assert (isType (token, TOKEN_OPEN_PAREN));
do
{
if ( isType (token, TOKEN_COMMA) || isType (token, TOKEN_OPEN_PAREN) )
readToken (token);
/*
* Create table statements can end with various constraints
* which must be excluded from the SQLTAG_FIELD.
* create table t1 (
* c1 integer,
* c2 char(30),
* c3 numeric(10,5),
* c4 integer,
* constraint whatever,
* primary key(c1),
* foreign key (),
* check ()
* )
*/
if (! (isKeyword(token, KEYWORD_primary) ||
isKeyword(token, KEYWORD_references) ||
isKeyword(token, KEYWORD_unique) ||
isKeyword(token, KEYWORD_check) ||
isKeyword(token, KEYWORD_constraint) ||
isKeyword(token, KEYWORD_foreign) ) )
{
if (isType (token, TOKEN_IDENTIFIER) ||
isType (token, TOKEN_STRING))
makeSqlTag (token, SQLTAG_FIELD);
}
while (!(isType (token, TOKEN_COMMA) ||
isType (token, TOKEN_CLOSE_PAREN) ||
isType (token, TOKEN_OPEN_PAREN)
))
{
readToken (token);
/*
* A table structure can look like this:
* create table t1 (
* c1 integer,
* c2 char(30),
* c3 numeric(10,5),
* c4 integer
* )
* We can't just look for a COMMA or CLOSE_PAREN
* since that will not deal with the numeric(10,5)
* case. So we need to skip the argument list
* when we find an open paren.
*/
if (isType (token, TOKEN_OPEN_PAREN))
{
/* Reads to the next token after the TOKEN_CLOSE_PAREN */
skipArgumentList(token);
}
}
} while (! isType (token, TOKEN_CLOSE_PAREN));
}
static void parseType (tokenInfo *const token)
{
tokenInfo *const name = newToken ();
vString * saveScope = vStringNew ();
vStringCopy(saveScope, token->scope);
/* If a scope has been set, add it to the name */
addToScope (name, token->scope);
readToken (name);
if (isType (name, TOKEN_IDENTIFIER))
{
readToken (token);
if (isKeyword (token, KEYWORD_is))
{
readToken (token);
addToScope (token, name->string);
switch (token->keyword)
{
case KEYWORD_record:
case KEYWORD_object:
makeSqlTag (name, SQLTAG_RECORD);
parseRecord (token);
break;
case KEYWORD_table:
makeSqlTag (name, SQLTAG_TABLE);
break;
case KEYWORD_ref:
readToken (token);
if (isKeyword (token, KEYWORD_cursor))
makeSqlTag (name, SQLTAG_CURSOR);
break;
default: break;
}
vStringClear (token->scope);
}
}
vStringCopy(token->scope, saveScope);
deleteToken (name);
vStringDelete(saveScope);
}
static void parseSimple (tokenInfo *const token, const sqlKind kind)
{
/* This will simply make the tagname from the first word found */
readToken (token);
if (isType (token, TOKEN_IDENTIFIER) ||
isType (token, TOKEN_STRING))
makeSqlTag (token, kind);
}
static void parseDeclare (tokenInfo *const token, const boolean local)
{
/*
* PL/SQL declares are of this format:
* IS|AS
* [declare]
* CURSOR curname ...
* varname1 datatype;
* varname2 datatype;
* varname3 datatype;
* begin
*/
if (isKeyword (token, KEYWORD_declare))
readToken (token);
while (! isKeyword (token, KEYWORD_begin) && ! isKeyword (token, KEYWORD_end))
{
switch (token->keyword)
{
case KEYWORD_cursor: parseSimple (token, SQLTAG_CURSOR); break;
case KEYWORD_function: parseSubProgram (token); break;
case KEYWORD_procedure: parseSubProgram (token); break;
case KEYWORD_subtype: parseSimple (token, SQLTAG_SUBTYPE); break;
case KEYWORD_trigger: parseSimple (token, SQLTAG_TRIGGER); break;
case KEYWORD_type: parseType (token); break;
default:
if (isType (token, TOKEN_IDENTIFIER))
{
if (local)
{
makeSqlTag (token, SQLTAG_LOCAL_VARIABLE);
}
else
{
makeSqlTag (token, SQLTAG_VARIABLE);
}
}
break;
}
findToken (token, TOKEN_SEMICOLON);
readToken (token);
}
}
static void parseDeclareANSI (tokenInfo *const token, const boolean local)
{
tokenInfo *const type = newToken ();
/*
* ANSI declares are of this format:
* BEGIN
* DECLARE varname1 datatype;
* DECLARE varname2 datatype;
* ...
*
* This differ from PL/SQL where DECLARE preceeds the BEGIN block
* and the DECLARE keyword is not repeated.
*/
while (isKeyword (token, KEYWORD_declare))
{
readToken (token);
readToken (type);
if (isKeyword (type, KEYWORD_cursor))
makeSqlTag (token, SQLTAG_CURSOR);
else if (isKeyword (token, KEYWORD_local) &&
isKeyword (type, KEYWORD_temporary))
{
/*
* DECLARE LOCAL TEMPORARY TABLE table_name (
* c1 int,
* c2 int
* );
*/
readToken (token);
if (isKeyword (token, KEYWORD_table))
{
readToken (token);
if (isType(token, TOKEN_IDENTIFIER) ||
isType(token, TOKEN_STRING) )
{
makeSqlTag (token, SQLTAG_TABLE);
}
}
}
else if (isType (token, TOKEN_IDENTIFIER) ||
isType (token, TOKEN_STRING))
{
if (local)
makeSqlTag (token, SQLTAG_LOCAL_VARIABLE);
else
makeSqlTag (token, SQLTAG_VARIABLE);
}
findToken (token, TOKEN_SEMICOLON);
readToken (token);
}
deleteToken (type);
}
static void parseLabel (tokenInfo *const token)
{
/*
* A label has this format:
* <<tobacco_dependency>>
* DECLARE
* v_senator VARCHAR2(100) := 'THURMOND, JESSE';
* BEGIN
* IF total_contributions (v_senator, 'TOBACCO') > 25000
* THEN
* <<alochol_dependency>>
* DECLARE
* v_senator VARCHAR2(100) := 'WHATEVERIT, TAKES';
* BEGIN
* ...
*/
Assert (isType (token, TOKEN_BLOCK_LABEL_BEGIN));
readToken (token);
if (isType (token, TOKEN_IDENTIFIER))
{
makeSqlTag (token, SQLTAG_BLOCK_LABEL);
readToken (token); /* read end of label */
}
}
static void parseStatements (tokenInfo *const token)
{
boolean isAnsi = TRUE;
boolean stmtTerm = FALSE;
do
{
if (isType (token, TOKEN_BLOCK_LABEL_BEGIN))
parseLabel (token);
else
{
switch (token->keyword)
{
case KEYWORD_exception:
/*
* EXCEPTION
* <exception handler>;
*
* Where an exception handler could be:
* BEGIN
* WHEN OTHERS THEN
* x := x + 3;
* END;
* In this case we need to skip this keyword and
* move on to the next token without reading until
* TOKEN_SEMICOLON;
*/
readToken (token);
continue;
case KEYWORD_when:
/*
* WHEN statements can be used in exception clauses
* and CASE statements. The CASE statement should skip
* these given below we skip over to an END statement.
* But for an exception clause, we can have:
* EXCEPTION
* WHEN OTHERS THEN
* BEGIN
* x := x + 3;
* END;
* If we skip to the TOKEN_SEMICOLON, we miss the begin
* of a nested BEGIN END block. So read the next token
* after the THEN and restart the LOOP.
*/
while (! isKeyword (token, KEYWORD_then))
readToken (token);
readToken (token);
continue;
case KEYWORD_if:
/*
* We do not want to look for a ; since for an empty
* IF block, it would skip over the END.
* IF...THEN
* END IF;
*
* or non-ANSI
* IF ...
* BEGIN
* END
*/
while ( ! isKeyword (token, KEYWORD_then) &&
! isKeyword (token, KEYWORD_begin) )
{
readToken (token);
}
if( isKeyword (token, KEYWORD_begin ) )
{
isAnsi = FALSE;
parseBlock(token, FALSE);
/*
* Handle the non-Ansi IF blocks.
* parseBlock consumes the END, so if the next
* token in a command terminator (like GO)
* we know we are done with this statement.
*/
if ( isCmdTerm (token) )
stmtTerm = TRUE;
}
else
{
readToken (token);
parseStatements (token);
/*
* parseStatements returns when it finds an END, an IF
* should follow the END for ANSI anyway.
* IF...THEN
* END IF;
*/
if( isKeyword (token, KEYWORD_end ) )
readToken (token);
if( ! isKeyword (token, KEYWORD_if ) )
{
/*
* Well we need to do something here.
* There are lots of different END statements
* END;
* END CASE;
* ENDIF;
* ENDCASE;
*/
}
}
break;
case KEYWORD_loop:
case KEYWORD_case:
case KEYWORD_for:
/*
* LOOP...
* END LOOP;
*
* CASE
* WHEN '1' THEN
* END CASE;
*
* FOR loop_name AS cursor_name CURSOR FOR ...
* END FOR;
*/
readToken (token);
parseStatements (token);
if( isKeyword (token, KEYWORD_end ) )
readToken (token);
break;
case KEYWORD_create:
readToken (token);
parseKeywords(token);
break;
case KEYWORD_declare:
case KEYWORD_begin:
parseBlock (token, TRUE);
break;
case KEYWORD_end:
break;
default:
readToken (token);
break;
}
/*
* Not all statements must end in a semi-colon
* begin
* if current publisher <> 'publish' then
* signal UE_FailStatement
* end if
* end;
* The last statement prior to an end ("signal" above) does
* not need a semi-colon, nor does the end if, since it is
* also the last statement prior to the end of the block.
*
* So we must read to the first semi-colon or an END block
*/
while ( ! stmtTerm &&
! ( isKeyword (token, KEYWORD_end) ||
(isCmdTerm(token)) )
)
{
readToken (token);
if (isType (token, TOKEN_OPEN_PAREN) ||
isType (token, TOKEN_OPEN_CURLY) ||
isType (token, TOKEN_OPEN_SQUARE) )
skipToMatched (token);
}
}
/*
* We assumed earlier all statements ended with a command terminator.
* See comment above, now, only read if the current token
* is not a command terminator.
*/
if ( isCmdTerm(token) )
{
readToken (token);
}
} while (! isKeyword (token, KEYWORD_end) && ! stmtTerm );
}
static void parseBlock (tokenInfo *const token, const boolean local)
{
if (isType (token, TOKEN_BLOCK_LABEL_BEGIN))
{
parseLabel (token);
readToken (token);
}
if (! isKeyword (token, KEYWORD_begin))
{
readToken (token);
/*
* These are Oracle style declares which generally come
* between an IS/AS and BEGIN block.
*/
parseDeclare (token, local);
}
if (isKeyword (token, KEYWORD_begin))
{
readToken (token);
/*
* Check for ANSI declarations which always follow
* a BEGIN statement. This routine will not advance
* the token if none are found.
*/
parseDeclareANSI (token, local);
token->begin_end_nest_lvl++;
while (! isKeyword (token, KEYWORD_end))
{
parseStatements (token);
}
token->begin_end_nest_lvl--;
/*
* Read the next token (we will assume
* it is the command delimiter)
*/
readToken (token);
/*
* Check if the END block is terminated
*/
if ( !isCmdTerm (token) )
{
/*
* Not sure what to do here at the moment.
* I think the routine that calls parseBlock
* must expect the next token has already
* been read since it is possible this
* token is not a command delimiter.
*/
/* findCmdTerm (token, FALSE); */
}
}
}
static void parsePackage (tokenInfo *const token)
{
/*
* Packages can be specified in a number of ways:
* CREATE OR REPLACE PACKAGE pkg_name AS
* or
* CREATE OR REPLACE PACKAGE owner.pkg_name AS
* or by specifying a package body
* CREATE OR REPLACE PACKAGE BODY pkg_name AS
* CREATE OR REPLACE PACKAGE BODY owner.pkg_name AS
*/
tokenInfo *const name = newToken ();
readToken (name);
if (isKeyword (name, KEYWORD_body))
{
/*
* Ignore the BODY tag since we will process
* the body or prototypes in the same manner
*/
readToken (name);
}
/* Check for owner.pkg_name */
while (! isKeyword (token, KEYWORD_is))
{
readToken (token);
if ( isType(token, TOKEN_PERIOD) )
{
readToken (name);
}
}
if (isKeyword (token, KEYWORD_is))
{
if (isType (name, TOKEN_IDENTIFIER) ||
isType (name, TOKEN_STRING))
makeSqlTag (name, SQLTAG_PACKAGE);
parseBlock (token, FALSE);
}
findCmdTerm (token, FALSE);
deleteToken (name);
}
static void parseTable (tokenInfo *const token)
{
tokenInfo *const name = newToken ();
/*
* This deals with these formats:
* create table t1 (c1 int);
* create global tempoary table t2 (c1 int);
* create table "t3" (c1 int);
* create table bob.t4 (c1 int);
* create table bob."t5" (c1 int);
* create table "bob"."t6" (c1 int);
* create table bob."t7" (c1 int);
* Proxy tables use this format:
* create existing table bob."t7" AT '...';
* SQL Server and Sybase formats
* create table OnlyTable (
* create table dbo.HasOwner (
* create table [dbo].[HasOwnerSquare] (
* create table master.dbo.HasDb (
* create table master..HasDbNoOwner (
* create table [master].dbo.[HasDbAndOwnerSquare] (
* create table [master]..[HasDbNoOwnerSquare] (
*/
/* This could be a database, owner or table name */
readToken (name);
if (isType (name, TOKEN_OPEN_SQUARE))
{
readToken (name);
/* Read close square */
readToken (token);
}
readToken (token);
if (isType (token, TOKEN_PERIOD))
{
/*
* This could be a owner or table name.
* But this is also a special case since the table can be
* referenced with a blank owner:
* dbname..tablename
*/
readToken (name);
if (isType (name, TOKEN_OPEN_SQUARE))
{
readToken (name);
/* Read close square */
readToken (token);
}
/* Check if a blank name was provided */
if (isType (name, TOKEN_PERIOD))
{
readToken (name);
if (isType (name, TOKEN_OPEN_SQUARE))
{
readToken (name);
/* Read close square */
readToken (token);
}
}
readToken (token);
if (isType (token, TOKEN_PERIOD))
{
/* This can only be the table name */
readToken (name);
if (isType (name, TOKEN_OPEN_SQUARE))
{
readToken (name);
/* Read close square */
readToken (token);
}
readToken (token);
}
}
if (isType (token, TOKEN_OPEN_PAREN))
{
if (isType (name, TOKEN_IDENTIFIER) ||
isType (name, TOKEN_STRING))
{
makeSqlTag (name, SQLTAG_TABLE);
vStringCopy(token->scope, name->string);
parseRecord (token);
vStringClear (token->scope);
}
}
else if (isKeyword (token, KEYWORD_at))
{
if (isType (name, TOKEN_IDENTIFIER))
{
makeSqlTag (name, SQLTAG_TABLE);
}
}
findCmdTerm (token, FALSE);
deleteToken (name);
}
static void parseIndex (tokenInfo *const token)
{
tokenInfo *const name = newToken ();
tokenInfo *const owner = newToken ();
/*
* This deals with these formats
* create index i1 on t1(c1) create index "i2" on t1(c1)
* create virtual unique clustered index "i3" on t1(c1)
* create unique clustered index "i4" on t1(c1)
* create clustered index "i5" on t1(c1)
* create bitmap index "i6" on t1(c1)
*/
readToken (name);
readToken (token);
if (isType (token, TOKEN_PERIOD))
{
readToken (name);
readToken (token);
}
if ( isKeyword (token, KEYWORD_on) &&
(isType (name, TOKEN_IDENTIFIER) || isType (name, TOKEN_STRING) ) )
{
readToken (owner);
readToken (token);
if (isType (token, TOKEN_PERIOD))
{
readToken (owner);
readToken (token);
}
addToScope(name, owner->string);
makeSqlTag (name, SQLTAG_INDEX);
}
findCmdTerm (token, FALSE);
deleteToken (name);
deleteToken (owner);
}
static void parseEvent (tokenInfo *const token)
{
tokenInfo *const name = newToken ();
/*
* This deals with these formats
* create event e1 handler begin end;
* create event "e2" handler begin end;
* create event dba."e3" handler begin end;
* create event "dba"."e4" handler begin end;
*/
readToken (name);
readToken (token);
if (isType (token, TOKEN_PERIOD))
{
readToken (name);
}
while (! (isKeyword (token, KEYWORD_handler) ||
(isType (token, TOKEN_SEMICOLON))) )
{
readToken (token);
}
if ( isKeyword (token, KEYWORD_handler) ||
isType (token, TOKEN_SEMICOLON) )
{
makeSqlTag (name, SQLTAG_EVENT);
}
if (isKeyword (token, KEYWORD_handler))
{
readToken (token);
if ( isKeyword (token, KEYWORD_begin) )
{
parseBlock (token, TRUE);
}
findCmdTerm (token, TRUE);
}
deleteToken (name);
}
static void parseTrigger (tokenInfo *const token)
{
tokenInfo *const name = newToken ();
tokenInfo *const table = newToken ();
/*
* This deals with these formats
* create or replace trigger tr1 begin end;
* create trigger "tr2" begin end;
* drop trigger "droptr1";
* create trigger "tr3" CALL sp_something();
* create trigger "owner"."tr4" begin end;
* create trigger "tr5" not valid;
* create trigger "tr6" begin end;
*/
readToken (name);
readToken (token);
if (isType (token, TOKEN_PERIOD))
{
readToken (name);
readToken (token);
}
while ( !isKeyword (token, KEYWORD_on) &&
!isCmdTerm (token) )
{
readToken (token);
}
/*if (! isType (token, TOKEN_SEMICOLON) ) */
if (! isCmdTerm (token) )
{
readToken (table);
readToken (token);
if (isType (token, TOKEN_PERIOD))
{
readToken (table);
readToken (token);
}
while (! (isKeyword (token, KEYWORD_begin) ||
(isKeyword (token, KEYWORD_call)) ||
( isCmdTerm (token))) )
{
if ( isKeyword (token, KEYWORD_declare) )
{
addToScope(token, name->string);
parseDeclare(token, TRUE);
vStringClear(token->scope);
}
else
readToken (token);
}
if ( isKeyword (token, KEYWORD_begin) ||
isKeyword (token, KEYWORD_call) )
{
addToScope(name, table->string);
makeSqlTag (name, SQLTAG_TRIGGER);
addToScope(token, table->string);
if ( isKeyword (token, KEYWORD_begin) )
{
parseBlock (token, TRUE);
}
vStringClear(token->scope);
}
}
findCmdTerm (token, TRUE);
deleteToken (name);
deleteToken (table);
}
static void parsePublication (tokenInfo *const token)
{
tokenInfo *const name = newToken ();
/*
* This deals with these formats
* create or replace publication pu1 ()
* create publication "pu2" ()
* create publication dba."pu3" ()
* create publication "dba"."pu4" ()
*/
readToken (name);
readToken (token);
if (isType (token, TOKEN_PERIOD))
{
readToken (name);
readToken (token);
}
if (isType (token, TOKEN_OPEN_PAREN))
{
if (isType (name, TOKEN_IDENTIFIER) ||
isType (name, TOKEN_STRING))
{
makeSqlTag (name, SQLTAG_PUBLICATION);
}
}
findCmdTerm (token, FALSE);
deleteToken (name);
}
static void parseService (tokenInfo *const token)
{
tokenInfo *const name = newToken ();
/*
* This deals with these formats
* CREATE SERVICE s1 TYPE 'HTML'
* AUTHORIZATION OFF USER DBA AS
* SELECT *
* FROM SYS.SYSTABLE;
* CREATE SERVICE "s2" TYPE 'HTML'
* AUTHORIZATION OFF USER DBA AS
* CALL sp_Something();
*/
readToken (name);
readToken (token);
if (isKeyword (token, KEYWORD_type))
{
if (isType (name, TOKEN_IDENTIFIER) ||
isType (name, TOKEN_STRING))
{
makeSqlTag (name, SQLTAG_SERVICE);
}
}
findCmdTerm (token, FALSE);
deleteToken (name);
}
static void parseDomain (tokenInfo *const token)
{
tokenInfo *const name = newToken ();
/*
* This deals with these formats
* CREATE DOMAIN|DATATYPE [AS] your_name ...;
*/
readToken (name);
if (isKeyword (name, KEYWORD_is))
{
readToken (name);
}
readToken (token);
if (isType (name, TOKEN_IDENTIFIER) ||
isType (name, TOKEN_STRING))
{
makeSqlTag (name, SQLTAG_DOMAIN);
}
findCmdTerm (token, FALSE);
deleteToken (name);
}
static void parseDrop (tokenInfo *const token)
{
/*
* This deals with these formats
* DROP TABLE|PROCEDURE|DOMAIN|DATATYPE name;
*
* Just simply skip over these statements.
* They are often confused with PROCEDURE prototypes
* since the syntax is similar, this effectively deals with
* the issue for all types.
*/
findCmdTerm (token, FALSE);
}
static void parseVariable (tokenInfo *const token)
{
tokenInfo *const name = newToken ();
/*
* This deals with these formats
* create variable varname1 integer;
* create variable @varname2 integer;
* create variable "varname3" integer;
* drop variable @varname3;
*/
readToken (name);
readToken (token);
if ( (isType (name, TOKEN_IDENTIFIER) || isType (name, TOKEN_STRING))
&& !isType (token, TOKEN_SEMICOLON) )
{
makeSqlTag (name, SQLTAG_VARIABLE);
}
findCmdTerm (token, TRUE);
deleteToken (name);
}
static void parseSynonym (tokenInfo *const token)
{
tokenInfo *const name = newToken ();
/*
* This deals with these formats
* create variable varname1 integer;
* create variable @varname2 integer;
* create variable "varname3" integer;
* drop variable @varname3;
*/
readToken (name);
readToken (token);
if ( (isType (name, TOKEN_IDENTIFIER) || isType (name, TOKEN_STRING))
&& isKeyword (token, KEYWORD_for) )
{
makeSqlTag (name, SQLTAG_SYNONYM);
}
findCmdTerm (token, TRUE);
deleteToken (name);
}
static void parseView (tokenInfo *const token)
{
tokenInfo *const name = newToken ();
/*
* This deals with these formats
* create variable varname1 integer;
* create variable @varname2 integer;
* create variable "varname3" integer;
* drop variable @varname3;
*/
readToken (name);
readToken (token);
if (isType (token, TOKEN_PERIOD))
{
readToken (name);
readToken (token);
}
if ( isType (token, TOKEN_OPEN_PAREN) )
{
skipArgumentList(token);
}
while (!(isKeyword (token, KEYWORD_is) ||
isType (token, TOKEN_SEMICOLON)
))
{
readToken (token);
}
if ( (isType (name, TOKEN_IDENTIFIER) || isType (name, TOKEN_STRING))
&& isKeyword (token, KEYWORD_is) )
{
makeSqlTag (name, SQLTAG_VIEW);
}
findCmdTerm (token, TRUE);
deleteToken (name);
}
static void parseMLTable (tokenInfo *const token)
{
tokenInfo *const version = newToken ();
tokenInfo *const table = newToken ();
tokenInfo *const event = newToken ();
/*
* This deals with these formats
* call dbo.ml_add_table_script( 'version', 'table_name', 'event',
* 'some SQL statement'
* );
*/
readToken (token);
if ( isType (token, TOKEN_OPEN_PAREN) )
{
readToken (version);
readToken (token);
while (!(isType (token, TOKEN_COMMA) ||
isType (token, TOKEN_CLOSE_PAREN)
))
{
readToken (token);
}
if (isType (token, TOKEN_COMMA))
{
readToken (table);
readToken (token);
while (!(isType (token, TOKEN_COMMA) ||
isType (token, TOKEN_CLOSE_PAREN)
))
{
readToken (token);
}
if (isType (token, TOKEN_COMMA))
{
readToken (event);
if (isType (version, TOKEN_STRING) &&
isType (table, TOKEN_STRING) &&
isType (event, TOKEN_STRING) )
{
addToScope(version, table->string);
addToScope(version, event->string);
makeSqlTag (version, SQLTAG_MLTABLE);
}
}
if( !isType (token, TOKEN_CLOSE_PAREN) )
findToken (token, TOKEN_CLOSE_PAREN);
}
}
findCmdTerm (token, TRUE);
deleteToken (version);
deleteToken (table);
deleteToken (event);
}
static void parseMLConn (tokenInfo *const token)
{
tokenInfo *const version = newToken ();
tokenInfo *const event = newToken ();
/*
* This deals with these formats
* call ml_add_connection_script( 'version', 'event',
* 'some SQL statement'
* );
*/
readToken (token);
if ( isType (token, TOKEN_OPEN_PAREN) )
{
readToken (version);
readToken (token);
while (!(isType (token, TOKEN_COMMA) ||
isType (token, TOKEN_CLOSE_PAREN)
))
{
readToken (token);
}
if (isType (token, TOKEN_COMMA))
{
readToken (event);
if (isType (version, TOKEN_STRING) &&
isType (event, TOKEN_STRING) )
{
addToScope(version, event->string);
makeSqlTag (version, SQLTAG_MLCONN);
}
}
if( !isType (token, TOKEN_CLOSE_PAREN) )
findToken (token, TOKEN_CLOSE_PAREN);
}
findCmdTerm (token, TRUE);
deleteToken (version);
deleteToken (event);
}
static void parseComment (tokenInfo *const token)
{
/*
* This deals with this statement:
* COMMENT TO PRESERVE FORMAT ON PROCEDURE "DBA"."test" IS
* {create PROCEDURE DBA."test"()
* BEGIN
* signal dave;
* END
* }
* ;
* The comment can contain anything between the CURLY
* braces
* COMMENT ON USER "admin" IS
* 'Administration Group'
* ;
* Or it could be a simple string with no curly braces
*/
while (! isKeyword (token, KEYWORD_is))
{
readToken (token);
}
readToken (token);
if ( isType(token, TOKEN_OPEN_CURLY) )
{
findToken (token, TOKEN_CLOSE_CURLY);
}
findCmdTerm (token, TRUE);
}
static void parseKeywords (tokenInfo *const token)
{
switch (token->keyword)
{
case KEYWORD_begin: parseBlock (token, FALSE); break;
case KEYWORD_comment: parseComment (token); break;
case KEYWORD_cursor: parseSimple (token, SQLTAG_CURSOR); break;
case KEYWORD_datatype: parseDomain (token); break;
case KEYWORD_declare: parseBlock (token, FALSE); break;
case KEYWORD_domain: parseDomain (token); break;
case KEYWORD_drop: parseDrop (token); break;
case KEYWORD_event: parseEvent (token); break;
case KEYWORD_function: parseSubProgram (token); break;
case KEYWORD_if: parseStatements (token); break;
case KEYWORD_index: parseIndex (token); break;
case KEYWORD_ml_table: parseMLTable (token); break;
case KEYWORD_ml_table_lang: parseMLTable (token); break;
case KEYWORD_ml_table_dnet: parseMLTable (token); break;
case KEYWORD_ml_table_java: parseMLTable (token); break;
case KEYWORD_ml_table_chk: parseMLTable (token); break;
case KEYWORD_ml_conn: parseMLConn (token); break;
case KEYWORD_ml_conn_lang: parseMLConn (token); break;
case KEYWORD_ml_conn_dnet: parseMLConn (token); break;
case KEYWORD_ml_conn_java: parseMLConn (token); break;
case KEYWORD_ml_conn_chk: parseMLConn (token); break;
case KEYWORD_package: parsePackage (token); break;
case KEYWORD_procedure: parseSubProgram (token); break;
case KEYWORD_publication: parsePublication (token); break;
case KEYWORD_service: parseService (token); break;
case KEYWORD_subtype: parseSimple (token, SQLTAG_SUBTYPE); break;
case KEYWORD_synonym: parseSynonym (token); break;
case KEYWORD_table: parseTable (token); break;
case KEYWORD_trigger: parseTrigger (token); break;
case KEYWORD_type: parseType (token); break;
case KEYWORD_variable: parseVariable (token); break;
case KEYWORD_view: parseView (token); break;
default: break;
}
}
static void parseSqlFile (tokenInfo *const token)
{
do
{
readToken (token);
if (isType (token, TOKEN_BLOCK_LABEL_BEGIN))
parseLabel (token);
else
parseKeywords (token);
} while (! isKeyword (token, KEYWORD_end));
}
static void initialize (const langType language)
{
Assert (sizeof (SqlKinds) / sizeof (SqlKinds [0]) == SQLTAG_COUNT);
Lang_sql = language;
buildSqlKeywordHash ();
}
static void findSqlTags (void)
{
tokenInfo *const token = newToken ();
exception_t exception = (exception_t) (setjmp (Exception));
while (exception == ExceptionNone)
parseSqlFile (token);
deleteToken (token);
}
extern parserDefinition* SqlParser (void)
{
static const char *const extensions [] = { "sql", NULL };
parserDefinition* def = parserNew ("SQL");
def->kinds = SqlKinds;
def->kindCount = KIND_COUNT (SqlKinds);
def->extensions = extensions;
def->parser = findSqlTags;
def->initialize = initialize;
return def;
}
/* vi:set tabstop=4 shiftwidth=4 noexpandtab: */
Jump to Line
Something went wrong with that request. Please try again.