ctags.rb 1.0.19 → 1.1.3

data/ext/vendor/exuberant-ctags/sort.c

@@ -1,230 +0,0 @@
-/*
-*   $Id: sort.c 498 2007-02-17 22:43:15Z dhiebert $
-*
-*   Copyright (c) 1996-2002, Darren Hiebert
-*
-*   This source code is released for free distribution under the terms of the
-*   GNU General Public License.
-*
-*   This module contains functions to sort the tag entries.
-*/
-
-/*
-*   INCLUDE FILES
-*/
-#include "general.h"  /* must always come first */
-
-#if defined (HAVE_STDLIB_H)
-# include <stdlib.h>  /* to declare malloc () */
-#endif
-#include <string.h>
-#include <stdio.h>
-
-#include "debug.h"
-#include "entry.h"
-#include "options.h"
-#include "read.h"
-#include "routines.h"
-#include "sort.h"
-
-/*
-*   FUNCTION DEFINITIONS
-*/
-
-extern void catFile (const char *const name)
-{
-	FILE *const fp = fopen (name, "r");
-
-	if (fp != NULL)
-	{
-		int c;
-		while ((c = getc (fp)) != EOF)
-			putchar (c);
-		fflush (stdout);
-		fclose (fp);
-	}
-}
-
-#ifdef EXTERNAL_SORT
-
-#ifdef NON_CONST_PUTENV_PROTOTYPE
-# define PE_CONST
-#else
-# define PE_CONST const
-#endif
-
-extern void externalSortTags (const boolean toStdout)
-{
-	const char *const sortNormalCommand = "sort -u -o";
-	const char *const sortFoldedCommand = "sort -u -f -o";
-	const char *sortCommand =
-		Option.sorted == SO_FOLDSORTED ? sortFoldedCommand : sortNormalCommand;
-	PE_CONST char *const sortOrder1 = "LC_COLLATE=C";
-	PE_CONST char *const sortOrder2 = "LC_ALL=C";
-	const size_t length = 4 + strlen (sortOrder1) + strlen (sortOrder2) +
-			strlen (sortCommand) + (2 * strlen (tagFileName ()));
-	char *const cmd = (char *) malloc (length + 1);
-	int ret = -1;
-
-	if (cmd != NULL)
-	{
-		/*  Ensure ASCII value sort order.
-		 */
-#ifdef HAVE_SETENV
-		setenv ("LC_COLLATE", "C", 1);
-		setenv ("LC_ALL", "C", 1);
-		sprintf (cmd, "%s %s %s", sortCommand, tagFileName (), tagFileName ());
-#else
-# ifdef HAVE_PUTENV
-		putenv (sortOrder1);
-		putenv (sortOrder2);
-		sprintf (cmd, "%s %s %s", sortCommand, tagFileName (), tagFileName ());
-# else
-		sprintf (cmd, "%s %s %s %s %s", sortOrder1, sortOrder2, sortCommand,
-				tagFileName (), tagFileName ());
-# endif
-#endif
-		verbose ("system (\"%s\")\n", cmd);
-		ret = system (cmd);
-		free (cmd);
-
-	}
-	if (ret != 0)
-		error (FATAL | PERROR, "cannot sort tag file");
-	else if (toStdout)
-		catFile (tagFileName ());
-}
-
-#else
-
-/*
- *  These functions provide a basic internal sort. No great memory
- *  optimization is performed (e.g. recursive subdivided sorts),
- *  so have lots of memory if you have large tag files.
- */
-
-static void failedSort (FILE *const fp, const char* msg)
-{
-	const char* const cannotSort = "cannot sort tag file";
-	if (fp != NULL)
-		fclose (fp);
-	if (msg == NULL)
-		error (FATAL | PERROR, cannotSort);
-	else
-		error (FATAL, "%s: %s", msg, cannotSort);
-}
-
-static int compareTagsFolded(const void *const one, const void *const two)
-{
-	const char *const line1 = *(const char* const*) one;
-	const char *const line2 = *(const char* const*) two;
-
-	return struppercmp (line1, line2);
-}
-
-static int compareTags (const void *const one, const void *const two)
-{
-	const char *const line1 = *(const char* const*) one;
-	const char *const line2 = *(const char* const*) two;
-
-	return strcmp (line1, line2);
-}
-
-static void writeSortedTags (
-		char **const table, const size_t numTags, const boolean toStdout)
-{
-	FILE *fp;
-	size_t i;
-
-	/*  Write the sorted lines back into the tag file.
-	 */
-	if (toStdout)
-		fp = stdout;
-	else
-	{
-		fp = fopen (tagFileName (), "w");
-		if (fp == NULL)
-			failedSort (fp, NULL);
-	}
-	for (i = 0 ; i < numTags ; ++i)
-	{
-		/*  Here we filter out identical tag *lines* (including search
-		 *  pattern) if this is not an xref file.
-		 */
-		if (i == 0  ||  Option.xref  ||  strcmp (table [i], table [i-1]) != 0)
-			if (fputs (table [i], fp) == EOF)
-				failedSort (fp, NULL);
-	}
-	if (toStdout)
-		fflush (fp);
-	else
-		fclose (fp);
-}
-
-extern void internalSortTags (const boolean toStdout)
-{
-	vString *vLine = vStringNew ();
-	FILE *fp = NULL;
-	const char *line;
-	size_t i;
-	int (*cmpFunc)(const void *, const void *);
-
-	/*  Allocate a table of line pointers to be sorted.
-	 */
-	size_t numTags = TagFile.numTags.added + TagFile.numTags.prev;
-	const size_t tableSize = numTags * sizeof (char *);
-	char **const table = (char **) malloc (tableSize);  /* line pointers */
-	DebugStatement ( size_t mallocSize = tableSize; )  /* cumulative total */
-
-
-	cmpFunc = Option.sorted == SO_FOLDSORTED ? compareTagsFolded : compareTags;
-	if (table == NULL)
-		failedSort (fp, "out of memory");
-
-	/*  Open the tag file and place its lines into allocated buffers.
-	 */
-	fp = fopen (tagFileName (), "r");
-	if (fp == NULL)
-		failedSort (fp, NULL);
-	for (i = 0  ;  i < numTags  &&  ! feof (fp)  ;  )
-	{
-		line = readLine (vLine, fp);
-		if (line == NULL)
-		{
-			if (! feof (fp))
-				failedSort (fp, NULL);
-			break;
-		}
-		else if (*line == '\0'  ||  strcmp (line, "\n") == 0)
-			;  /* ignore blank lines */
-		else
-		{
-			const size_t stringSize = strlen (line) + 1;
-
-			table [i] = (char *) malloc (stringSize);
-			if (table [i] == NULL)
-				failedSort (fp, "out of memory");
-			DebugStatement ( mallocSize += stringSize; )
-			strcpy (table [i], line);
-			++i;
-		}
-	}
-	numTags = i;
-	fclose (fp);
-	vStringDelete (vLine);
-
-	/*  Sort the lines.
-	 */
-	qsort (table, numTags, sizeof (*table), cmpFunc);
-
-	writeSortedTags (table, numTags, toStdout);
-
-	PrintStatus (("sort memory: %ld bytes\n", (long) mallocSize));
-	for (i = 0 ; i < numTags ; ++i)
-		free (table [i]);
-	free (table);
-}
-
-#endif
-
-/* vi:set tabstop=4 shiftwidth=4: */

data/ext/vendor/exuberant-ctags/sort.h

@@ -1,32 +0,0 @@
-/*
-*   $Id: sort.h 443 2006-05-30 04:37:13Z darren $
-*
-*   Copyright (c) 1998-2002, Darren Hiebert
-*
-*   This source code is released for free distribution under the terms of the
-*   GNU General Public License.
-*
-*   External interface to sort.c
-*/
-#ifndef _SORT_H
-#define _SORT_H
-
-/*
-*   INCLUDE FILES
-*/
-#include "general.h"  /* must always come first */
-
-/*
-*   FUNCTION PROTOTYPES
-*/
-extern void catFile (const char *const name);
-
-#ifdef EXTERNAL_SORT
-extern void externalSortTags (const boolean toStdout);
-#else
-extern void internalSortTags (const boolean toStdout);
-#endif
-
-#endif  /* _SORT_H */
-
-/* vi:set tabstop=4 shiftwidth=4: */

data/ext/vendor/exuberant-ctags/source.mak

@@ -1,122 +0,0 @@
-# $Id: source.mak 720 2009-07-07 03:55:23Z dhiebert $
-#
-# Shared macros
-
-HEADERS = \
-	args.h ctags.h debug.h entry.h general.h get.h keyword.h \
-	main.h options.h parse.h parsers.h read.h routines.h sort.h \
-	strlist.h vstring.h
-
-SOURCES = \
-	args.c \
-	ant.c \
-	asm.c \
-	asp.c \
-	awk.c \
-	basic.c \
-	beta.c \
-	c.c \
-	cobol.c \
-	dosbatch.c \
-	eiffel.c \
-	entry.c \
-	erlang.c \
-	flex.c \
-	fortran.c \
-	get.c \
-	html.c \
-	jscript.c \
-	keyword.c \
-	lisp.c \
-	lregex.c \
-	lua.c \
-	main.c \
-	make.c \
-	matlab.c \
-	ocaml.c \
-	options.c \
-	parse.c \
-	pascal.c \
-	perl.c \
-	php.c \
-	python.c \
-	read.c \
-	rexx.c \
-	routines.c \
-	ruby.c \
-	scheme.c \
-	sh.c \
-	slang.c \
-	sml.c \
-	sort.c \
-	sql.c \
-	strlist.c \
-	tcl.c \
-	tex.c \
-	verilog.c \
-	vhdl.c \
-	vim.c \
-	yacc.c \
-	vstring.c
-
-ENVIRONMENT_HEADERS = \
-    e_amiga.h e_djgpp.h e_mac.h e_msoft.h e_os2.h e_qdos.h e_riscos.h e_vms.h
-
-ENVIRONMENT_SOURCES = \
-    argproc.c mac.c qdos.c
-
-REGEX_SOURCES = gnu_regex/regex.c
-
-REGEX_HEADERS = gnu_regex/regex.h
-
-OBJECTS = \
-	args.$(OBJEXT) \
-	ant.$(OBJEXT) \
-	asm.$(OBJEXT) \
-	asp.$(OBJEXT) \
-	awk.$(OBJEXT) \
-	basic.$(OBJEXT) \
-	beta.$(OBJEXT) \
-	c.$(OBJEXT) \
-	cobol.$(OBJEXT) \
-	dosbatch.$(OBJEXT) \
-	eiffel.$(OBJEXT) \
-	entry.$(OBJEXT) \
-	erlang.$(OBJEXT) \
-	flex.$(OBJEXT) \
-	fortran.$(OBJEXT) \
-	get.$(OBJEXT) \
-	html.$(OBJEXT) \
-	jscript.$(OBJEXT) \
-	keyword.$(OBJEXT) \
-	lisp.$(OBJEXT) \
-	lregex.$(OBJEXT) \
-	lua.$(OBJEXT) \
-	main.$(OBJEXT) \
-	make.$(OBJEXT) \
-	matlab.$(OBJEXT) \
-	ocaml.$(OBJEXT) \
-	options.$(OBJEXT) \
-	parse.$(OBJEXT) \
-	pascal.$(OBJEXT) \
-	perl.$(OBJEXT) \
-	php.$(OBJEXT) \
-	python.$(OBJEXT) \
-	read.$(OBJEXT) \
-	rexx.$(OBJEXT) \
-	routines.$(OBJEXT) \
-	ruby.$(OBJEXT) \
-	scheme.$(OBJEXT) \
-	sh.$(OBJEXT) \
-	slang.$(OBJEXT) \
-	sml.$(OBJEXT) \
-	sort.$(OBJEXT) \
-	sql.$(OBJEXT) \
-	strlist.$(OBJEXT) \
-	tcl.$(OBJEXT) \
-	tex.$(OBJEXT) \
-	verilog.$(OBJEXT) \
-	vhdl.$(OBJEXT) \
-	vim.$(OBJEXT) \
-	yacc.$(OBJEXT) \
-	vstring.$(OBJEXT)

data/ext/vendor/exuberant-ctags/sql.c

@@ -1,2112 +0,0 @@
-/*
- *	$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: */