From 328d235571616669273979dd1b4c7ace018efc0b Mon Sep 17 00:00:00 2001 From: Alvaro Herrera Date: Sat, 7 Mar 2009 00:13:58 +0000 Subject: [PATCH] Separate the key word list that lived in keywords.c into a new header file kwlist.h, to avoid having to link the backend object file into other programs like pg_dump. We can now simply symlink a single source file from the backend (kwlookup.c, containing the shared routine ScanKeywordLookup) and compile it locally, which is a lot cleaner. --- src/backend/parser/Makefile | 4 +- src/backend/parser/gram.y | 6 +- src/backend/parser/keywords.c | 488 +------------------------ src/backend/parser/kwlookup.c | 87 +++++ src/bin/pg_dump/Makefile | 26 +- src/bin/pg_dump/keywords.c | 31 ++ src/bin/psql/Makefile | 22 +- src/bin/scripts/Makefile | 30 +- src/include/parser/kwlist.h | 419 +++++++++++++++++++++ src/interfaces/ecpg/preproc/Makefile | 9 +- src/interfaces/ecpg/preproc/keywords.c | 30 ++ 11 files changed, 621 insertions(+), 531 deletions(-) create mode 100644 src/backend/parser/kwlookup.c create mode 100644 src/bin/pg_dump/keywords.c create mode 100644 src/include/parser/kwlist.h create mode 100644 src/interfaces/ecpg/preproc/keywords.c diff --git a/src/backend/parser/Makefile b/src/backend/parser/Makefile index 8cefea14ac..3a46e6c4e3 100644 --- a/src/backend/parser/Makefile +++ b/src/backend/parser/Makefile @@ -2,7 +2,7 @@ # # Makefile for parser # -# $PostgreSQL: pgsql/src/backend/parser/Makefile,v 1.48 2008/10/04 21:56:54 tgl Exp $ +# $PostgreSQL: pgsql/src/backend/parser/Makefile,v 1.49 2009/03/07 00:13:57 alvherre Exp $ # #------------------------------------------------------------------------- @@ -14,7 +14,7 @@ override CPPFLAGS := -I$(srcdir) $(CPPFLAGS) OBJS= analyze.o gram.o keywords.o parser.o parse_agg.o parse_cte.o parse_clause.o \ parse_expr.o parse_func.o parse_node.o parse_oper.o parse_relation.o \ - parse_type.o parse_coerce.o parse_target.o parse_utilcmd.o scansup.o + parse_type.o parse_coerce.o parse_target.o parse_utilcmd.o scansup.o kwlookup.o FLEXFLAGS = -CF diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y index 3dadbcffde..7a890091a8 100644 --- a/src/backend/parser/gram.y +++ b/src/backend/parser/gram.y @@ -11,7 +11,7 @@ * * * IDENTIFICATION - * $PostgreSQL: pgsql/src/backend/parser/gram.y,v 2.659 2009/02/24 10:06:33 petere Exp $ + * $PostgreSQL: pgsql/src/backend/parser/gram.y,v 2.660 2009/03/07 00:13:57 alvherre Exp $ * * HISTORY * AUTHOR DATE MAJOR EVENT @@ -423,7 +423,7 @@ static TypeName *TableFuncTypeName(List *columns); /* * If you make any token changes, update the keyword table in - * parser/keywords.c and add new keywords to the appropriate one of + * src/include/parser/kwlist.h and add new keywords to the appropriate one of * the reserved-or-not-so-reserved keyword lists, below; search * this file for "Name classification hierarchy". */ @@ -516,7 +516,7 @@ static TypeName *TableFuncTypeName(List *columns); ZONE -/* The grammar thinks these are keywords, but they are not in the keywords.c +/* The grammar thinks these are keywords, but they are not in the kwlist.h * list and so can never be entered directly. The filter in parser.c * creates these tokens when required. */ diff --git a/src/backend/parser/keywords.c b/src/backend/parser/keywords.c index 48218df9c4..440c63e453 100644 --- a/src/backend/parser/keywords.c +++ b/src/backend/parser/keywords.c @@ -3,501 +3,29 @@ * keywords.c * lexical token lookup for key words in PostgreSQL * - * NB: This file is also used by pg_dump. - * * * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * * * IDENTIFICATION - * $PostgreSQL: pgsql/src/backend/parser/keywords.c,v 1.210 2009/02/24 10:06:33 petere Exp $ + * $PostgreSQL: pgsql/src/backend/parser/keywords.c,v 1.211 2009/03/07 00:13:57 alvherre Exp $ * *------------------------------------------------------------------------- */ +#include "postgres.h" -/* Use c.h so that this file can be built in either frontend or backend */ -#include "c.h" - -#include - -/* - * This macro definition overrides the YYSTYPE union definition in gram.h. - * We don't need that struct in this file, and including the real definition - * would require sucking in some backend-only include files. - */ -#define YYSTYPE int - +#include "nodes/nodes.h" +#include "nodes/parsenodes.h" #include "parser/keywords.h" -#ifndef ECPG_COMPILE #include "parser/gram.h" -#else -#include "preproc.h" -#endif -/* - * List of keyword (name, token-value, category) entries. - * - * !!WARNING!!: This list must be sorted by ASCII name, because binary - * search is used to locate entries. - */ +#define PG_KEYWORD(a,b,c) {a,b,c}, + + const ScanKeyword ScanKeywords[] = { - /* name, value, category */ - {"abort", ABORT_P, UNRESERVED_KEYWORD}, - {"absolute", ABSOLUTE_P, UNRESERVED_KEYWORD}, - {"access", ACCESS, UNRESERVED_KEYWORD}, - {"action", ACTION, UNRESERVED_KEYWORD}, - {"add", ADD_P, UNRESERVED_KEYWORD}, - {"admin", ADMIN, UNRESERVED_KEYWORD}, - {"after", AFTER, UNRESERVED_KEYWORD}, - {"aggregate", AGGREGATE, UNRESERVED_KEYWORD}, - {"all", ALL, RESERVED_KEYWORD}, - {"also", ALSO, UNRESERVED_KEYWORD}, - {"alter", ALTER, UNRESERVED_KEYWORD}, - {"always", ALWAYS, UNRESERVED_KEYWORD}, - {"analyse", ANALYSE, RESERVED_KEYWORD}, /* British spelling */ - {"analyze", ANALYZE, RESERVED_KEYWORD}, - {"and", AND, RESERVED_KEYWORD}, - {"any", ANY, RESERVED_KEYWORD}, - {"array", ARRAY, RESERVED_KEYWORD}, - {"as", AS, RESERVED_KEYWORD}, - {"asc", ASC, RESERVED_KEYWORD}, - {"assertion", ASSERTION, UNRESERVED_KEYWORD}, - {"assignment", ASSIGNMENT, UNRESERVED_KEYWORD}, - {"asymmetric", ASYMMETRIC, RESERVED_KEYWORD}, - {"at", AT, UNRESERVED_KEYWORD}, - {"authorization", AUTHORIZATION, TYPE_FUNC_NAME_KEYWORD}, - {"backward", BACKWARD, UNRESERVED_KEYWORD}, - {"before", BEFORE, UNRESERVED_KEYWORD}, - {"begin", BEGIN_P, UNRESERVED_KEYWORD}, - {"between", BETWEEN, TYPE_FUNC_NAME_KEYWORD}, - {"bigint", BIGINT, COL_NAME_KEYWORD}, - {"binary", BINARY, TYPE_FUNC_NAME_KEYWORD}, - {"bit", BIT, COL_NAME_KEYWORD}, - {"boolean", BOOLEAN_P, COL_NAME_KEYWORD}, - {"both", BOTH, RESERVED_KEYWORD}, - {"by", BY, UNRESERVED_KEYWORD}, - {"cache", CACHE, UNRESERVED_KEYWORD}, - {"called", CALLED, UNRESERVED_KEYWORD}, - {"cascade", CASCADE, UNRESERVED_KEYWORD}, - {"cascaded", CASCADED, UNRESERVED_KEYWORD}, - {"case", CASE, RESERVED_KEYWORD}, - {"cast", CAST, RESERVED_KEYWORD}, - {"catalog", CATALOG_P, UNRESERVED_KEYWORD}, - {"chain", CHAIN, UNRESERVED_KEYWORD}, - {"char", CHAR_P, COL_NAME_KEYWORD}, - {"character", CHARACTER, COL_NAME_KEYWORD}, - {"characteristics", CHARACTERISTICS, UNRESERVED_KEYWORD}, - {"check", CHECK, RESERVED_KEYWORD}, - {"checkpoint", CHECKPOINT, UNRESERVED_KEYWORD}, - {"class", CLASS, UNRESERVED_KEYWORD}, - {"close", CLOSE, UNRESERVED_KEYWORD}, - {"cluster", CLUSTER, UNRESERVED_KEYWORD}, - {"coalesce", COALESCE, COL_NAME_KEYWORD}, - {"collate", COLLATE, RESERVED_KEYWORD}, - {"column", COLUMN, RESERVED_KEYWORD}, - {"comment", COMMENT, UNRESERVED_KEYWORD}, - {"commit", COMMIT, UNRESERVED_KEYWORD}, - {"committed", COMMITTED, UNRESERVED_KEYWORD}, - {"concurrently", CONCURRENTLY, UNRESERVED_KEYWORD}, - {"configuration", CONFIGURATION, UNRESERVED_KEYWORD}, - {"connection", CONNECTION, UNRESERVED_KEYWORD}, - {"constraint", CONSTRAINT, RESERVED_KEYWORD}, - {"constraints", CONSTRAINTS, UNRESERVED_KEYWORD}, - {"content", CONTENT_P, UNRESERVED_KEYWORD}, - {"continue", CONTINUE_P, UNRESERVED_KEYWORD}, - {"conversion", CONVERSION_P, UNRESERVED_KEYWORD}, - {"copy", COPY, UNRESERVED_KEYWORD}, - {"cost", COST, UNRESERVED_KEYWORD}, - {"create", CREATE, RESERVED_KEYWORD}, - {"createdb", CREATEDB, UNRESERVED_KEYWORD}, - {"createrole", CREATEROLE, UNRESERVED_KEYWORD}, - {"createuser", CREATEUSER, UNRESERVED_KEYWORD}, - {"cross", CROSS, TYPE_FUNC_NAME_KEYWORD}, - {"csv", CSV, UNRESERVED_KEYWORD}, - {"ctype", CTYPE, UNRESERVED_KEYWORD}, - {"current", CURRENT_P, UNRESERVED_KEYWORD}, - {"current_catalog", CURRENT_CATALOG, RESERVED_KEYWORD}, - {"current_date", CURRENT_DATE, RESERVED_KEYWORD}, - {"current_role", CURRENT_ROLE, RESERVED_KEYWORD}, - {"current_schema", CURRENT_SCHEMA, TYPE_FUNC_NAME_KEYWORD}, - {"current_time", CURRENT_TIME, RESERVED_KEYWORD}, - {"current_timestamp", CURRENT_TIMESTAMP, RESERVED_KEYWORD}, - {"current_user", CURRENT_USER, RESERVED_KEYWORD}, - {"cursor", CURSOR, UNRESERVED_KEYWORD}, - {"cycle", CYCLE, UNRESERVED_KEYWORD}, - {"data", DATA_P, UNRESERVED_KEYWORD}, - {"database", DATABASE, UNRESERVED_KEYWORD}, - {"day", DAY_P, UNRESERVED_KEYWORD}, - {"deallocate", DEALLOCATE, UNRESERVED_KEYWORD}, - {"dec", DEC, COL_NAME_KEYWORD}, - {"decimal", DECIMAL_P, COL_NAME_KEYWORD}, - {"declare", DECLARE, UNRESERVED_KEYWORD}, - {"default", DEFAULT, RESERVED_KEYWORD}, - {"defaults", DEFAULTS, UNRESERVED_KEYWORD}, - {"deferrable", DEFERRABLE, RESERVED_KEYWORD}, - {"deferred", DEFERRED, UNRESERVED_KEYWORD}, - {"definer", DEFINER, UNRESERVED_KEYWORD}, - {"delete", DELETE_P, UNRESERVED_KEYWORD}, - {"delimiter", DELIMITER, UNRESERVED_KEYWORD}, - {"delimiters", DELIMITERS, UNRESERVED_KEYWORD}, - {"desc", DESC, RESERVED_KEYWORD}, - {"dictionary", DICTIONARY, UNRESERVED_KEYWORD}, - {"disable", DISABLE_P, UNRESERVED_KEYWORD}, - {"discard", DISCARD, UNRESERVED_KEYWORD}, - {"distinct", DISTINCT, RESERVED_KEYWORD}, - {"do", DO, RESERVED_KEYWORD}, - {"document", DOCUMENT_P, UNRESERVED_KEYWORD}, - {"domain", DOMAIN_P, UNRESERVED_KEYWORD}, - {"double", DOUBLE_P, UNRESERVED_KEYWORD}, - {"drop", DROP, UNRESERVED_KEYWORD}, - {"each", EACH, UNRESERVED_KEYWORD}, - {"else", ELSE, RESERVED_KEYWORD}, - {"enable", ENABLE_P, UNRESERVED_KEYWORD}, - {"encoding", ENCODING, UNRESERVED_KEYWORD}, - {"encrypted", ENCRYPTED, UNRESERVED_KEYWORD}, - {"end", END_P, RESERVED_KEYWORD}, - {"enum", ENUM_P, UNRESERVED_KEYWORD}, - {"escape", ESCAPE, UNRESERVED_KEYWORD}, - {"except", EXCEPT, RESERVED_KEYWORD}, - {"excluding", EXCLUDING, UNRESERVED_KEYWORD}, - {"exclusive", EXCLUSIVE, UNRESERVED_KEYWORD}, - {"execute", EXECUTE, UNRESERVED_KEYWORD}, - {"exists", EXISTS, COL_NAME_KEYWORD}, - {"explain", EXPLAIN, UNRESERVED_KEYWORD}, - {"external", EXTERNAL, UNRESERVED_KEYWORD}, - {"extract", EXTRACT, COL_NAME_KEYWORD}, - {"false", FALSE_P, RESERVED_KEYWORD}, - {"family", FAMILY, UNRESERVED_KEYWORD}, - {"fetch", FETCH, RESERVED_KEYWORD}, - {"first", FIRST_P, UNRESERVED_KEYWORD}, - {"float", FLOAT_P, COL_NAME_KEYWORD}, - {"following", FOLLOWING, UNRESERVED_KEYWORD}, - {"for", FOR, RESERVED_KEYWORD}, - {"force", FORCE, UNRESERVED_KEYWORD}, - {"foreign", FOREIGN, RESERVED_KEYWORD}, - {"forward", FORWARD, UNRESERVED_KEYWORD}, - {"freeze", FREEZE, TYPE_FUNC_NAME_KEYWORD}, - {"from", FROM, RESERVED_KEYWORD}, - {"full", FULL, TYPE_FUNC_NAME_KEYWORD}, - {"function", FUNCTION, UNRESERVED_KEYWORD}, - {"global", GLOBAL, UNRESERVED_KEYWORD}, - {"grant", GRANT, RESERVED_KEYWORD}, - {"granted", GRANTED, UNRESERVED_KEYWORD}, - {"greatest", GREATEST, COL_NAME_KEYWORD}, - {"group", GROUP_P, RESERVED_KEYWORD}, - {"handler", HANDLER, UNRESERVED_KEYWORD}, - {"having", HAVING, RESERVED_KEYWORD}, - {"header", HEADER_P, UNRESERVED_KEYWORD}, - {"hold", HOLD, UNRESERVED_KEYWORD}, - {"hour", HOUR_P, UNRESERVED_KEYWORD}, - {"identity", IDENTITY_P, UNRESERVED_KEYWORD}, - {"if", IF_P, UNRESERVED_KEYWORD}, - {"ilike", ILIKE, TYPE_FUNC_NAME_KEYWORD}, - {"immediate", IMMEDIATE, UNRESERVED_KEYWORD}, - {"immutable", IMMUTABLE, UNRESERVED_KEYWORD}, - {"implicit", IMPLICIT_P, UNRESERVED_KEYWORD}, - {"in", IN_P, RESERVED_KEYWORD}, - {"including", INCLUDING, UNRESERVED_KEYWORD}, - {"increment", INCREMENT, UNRESERVED_KEYWORD}, - {"index", INDEX, UNRESERVED_KEYWORD}, - {"indexes", INDEXES, UNRESERVED_KEYWORD}, - {"inherit", INHERIT, UNRESERVED_KEYWORD}, - {"inherits", INHERITS, UNRESERVED_KEYWORD}, - {"initially", INITIALLY, RESERVED_KEYWORD}, - {"inner", INNER_P, TYPE_FUNC_NAME_KEYWORD}, - {"inout", INOUT, COL_NAME_KEYWORD}, - {"input", INPUT_P, UNRESERVED_KEYWORD}, - {"insensitive", INSENSITIVE, UNRESERVED_KEYWORD}, - {"insert", INSERT, UNRESERVED_KEYWORD}, - {"instead", INSTEAD, UNRESERVED_KEYWORD}, - {"int", INT_P, COL_NAME_KEYWORD}, - {"integer", INTEGER, COL_NAME_KEYWORD}, - {"intersect", INTERSECT, RESERVED_KEYWORD}, - {"interval", INTERVAL, COL_NAME_KEYWORD}, - {"into", INTO, RESERVED_KEYWORD}, - {"invoker", INVOKER, UNRESERVED_KEYWORD}, - {"is", IS, TYPE_FUNC_NAME_KEYWORD}, - {"isnull", ISNULL, TYPE_FUNC_NAME_KEYWORD}, - {"isolation", ISOLATION, UNRESERVED_KEYWORD}, - {"join", JOIN, TYPE_FUNC_NAME_KEYWORD}, - {"key", KEY, UNRESERVED_KEYWORD}, - {"lancompiler", LANCOMPILER, UNRESERVED_KEYWORD}, - {"language", LANGUAGE, UNRESERVED_KEYWORD}, - {"large", LARGE_P, UNRESERVED_KEYWORD}, - {"last", LAST_P, UNRESERVED_KEYWORD}, - {"leading", LEADING, RESERVED_KEYWORD}, - {"least", LEAST, COL_NAME_KEYWORD}, - {"left", LEFT, TYPE_FUNC_NAME_KEYWORD}, - {"level", LEVEL, UNRESERVED_KEYWORD}, - {"like", LIKE, TYPE_FUNC_NAME_KEYWORD}, - {"limit", LIMIT, RESERVED_KEYWORD}, - {"listen", LISTEN, UNRESERVED_KEYWORD}, - {"load", LOAD, UNRESERVED_KEYWORD}, - {"local", LOCAL, UNRESERVED_KEYWORD}, - {"localtime", LOCALTIME, RESERVED_KEYWORD}, - {"localtimestamp", LOCALTIMESTAMP, RESERVED_KEYWORD}, - {"location", LOCATION, UNRESERVED_KEYWORD}, - {"lock", LOCK_P, UNRESERVED_KEYWORD}, - {"login", LOGIN_P, UNRESERVED_KEYWORD}, - {"mapping", MAPPING, UNRESERVED_KEYWORD}, - {"match", MATCH, UNRESERVED_KEYWORD}, - {"maxvalue", MAXVALUE, UNRESERVED_KEYWORD}, - {"minute", MINUTE_P, UNRESERVED_KEYWORD}, - {"minvalue", MINVALUE, UNRESERVED_KEYWORD}, - {"mode", MODE, UNRESERVED_KEYWORD}, - {"month", MONTH_P, UNRESERVED_KEYWORD}, - {"move", MOVE, UNRESERVED_KEYWORD}, - {"name", NAME_P, UNRESERVED_KEYWORD}, - {"names", NAMES, UNRESERVED_KEYWORD}, - {"national", NATIONAL, COL_NAME_KEYWORD}, - {"natural", NATURAL, TYPE_FUNC_NAME_KEYWORD}, - {"nchar", NCHAR, COL_NAME_KEYWORD}, - {"new", NEW, RESERVED_KEYWORD}, - {"next", NEXT, UNRESERVED_KEYWORD}, - {"no", NO, UNRESERVED_KEYWORD}, - {"nocreatedb", NOCREATEDB, UNRESERVED_KEYWORD}, - {"nocreaterole", NOCREATEROLE, UNRESERVED_KEYWORD}, - {"nocreateuser", NOCREATEUSER, UNRESERVED_KEYWORD}, - {"noinherit", NOINHERIT, UNRESERVED_KEYWORD}, - {"nologin", NOLOGIN_P, UNRESERVED_KEYWORD}, - {"none", NONE, COL_NAME_KEYWORD}, - {"nosuperuser", NOSUPERUSER, UNRESERVED_KEYWORD}, - {"not", NOT, RESERVED_KEYWORD}, - {"nothing", NOTHING, UNRESERVED_KEYWORD}, - {"notify", NOTIFY, UNRESERVED_KEYWORD}, - {"notnull", NOTNULL, TYPE_FUNC_NAME_KEYWORD}, - {"nowait", NOWAIT, UNRESERVED_KEYWORD}, - {"null", NULL_P, RESERVED_KEYWORD}, - {"nullif", NULLIF, COL_NAME_KEYWORD}, - {"nulls", NULLS_P, UNRESERVED_KEYWORD}, - {"numeric", NUMERIC, COL_NAME_KEYWORD}, - {"object", OBJECT_P, UNRESERVED_KEYWORD}, - {"of", OF, UNRESERVED_KEYWORD}, - {"off", OFF, RESERVED_KEYWORD}, - {"offset", OFFSET, RESERVED_KEYWORD}, - {"oids", OIDS, UNRESERVED_KEYWORD}, - {"old", OLD, RESERVED_KEYWORD}, - {"on", ON, RESERVED_KEYWORD}, - {"only", ONLY, RESERVED_KEYWORD}, - {"operator", OPERATOR, UNRESERVED_KEYWORD}, - {"option", OPTION, UNRESERVED_KEYWORD}, - {"options", OPTIONS, UNRESERVED_KEYWORD}, - {"or", OR, RESERVED_KEYWORD}, - {"order", ORDER, RESERVED_KEYWORD}, - {"out", OUT_P, COL_NAME_KEYWORD}, - {"outer", OUTER_P, TYPE_FUNC_NAME_KEYWORD}, - {"over", OVER, TYPE_FUNC_NAME_KEYWORD}, - {"overlaps", OVERLAPS, TYPE_FUNC_NAME_KEYWORD}, - {"overlay", OVERLAY, COL_NAME_KEYWORD}, - {"owned", OWNED, UNRESERVED_KEYWORD}, - {"owner", OWNER, UNRESERVED_KEYWORD}, - {"parser", PARSER, UNRESERVED_KEYWORD}, - {"partial", PARTIAL, UNRESERVED_KEYWORD}, - {"partition", PARTITION, UNRESERVED_KEYWORD}, - {"password", PASSWORD, UNRESERVED_KEYWORD}, - {"placing", PLACING, RESERVED_KEYWORD}, - {"plans", PLANS, UNRESERVED_KEYWORD}, - {"position", POSITION, COL_NAME_KEYWORD}, - {"preceding", PRECEDING, UNRESERVED_KEYWORD}, - {"precision", PRECISION, COL_NAME_KEYWORD}, - {"prepare", PREPARE, UNRESERVED_KEYWORD}, - {"prepared", PREPARED, UNRESERVED_KEYWORD}, - {"preserve", PRESERVE, UNRESERVED_KEYWORD}, - {"primary", PRIMARY, RESERVED_KEYWORD}, - {"prior", PRIOR, UNRESERVED_KEYWORD}, - {"privileges", PRIVILEGES, UNRESERVED_KEYWORD}, - {"procedural", PROCEDURAL, UNRESERVED_KEYWORD}, - {"procedure", PROCEDURE, UNRESERVED_KEYWORD}, - {"quote", QUOTE, UNRESERVED_KEYWORD}, - {"range", RANGE, UNRESERVED_KEYWORD}, - {"read", READ, UNRESERVED_KEYWORD}, - {"real", REAL, COL_NAME_KEYWORD}, - {"reassign", REASSIGN, UNRESERVED_KEYWORD}, - {"recheck", RECHECK, UNRESERVED_KEYWORD}, - {"recursive", RECURSIVE, UNRESERVED_KEYWORD}, - {"references", REFERENCES, RESERVED_KEYWORD}, - {"reindex", REINDEX, UNRESERVED_KEYWORD}, - {"relative", RELATIVE_P, UNRESERVED_KEYWORD}, - {"release", RELEASE, UNRESERVED_KEYWORD}, - {"rename", RENAME, UNRESERVED_KEYWORD}, - {"repeatable", REPEATABLE, UNRESERVED_KEYWORD}, - {"replace", REPLACE, UNRESERVED_KEYWORD}, - {"replica", REPLICA, UNRESERVED_KEYWORD}, - {"reset", RESET, UNRESERVED_KEYWORD}, - {"restart", RESTART, UNRESERVED_KEYWORD}, - {"restrict", RESTRICT, UNRESERVED_KEYWORD}, - {"returning", RETURNING, RESERVED_KEYWORD}, - {"returns", RETURNS, UNRESERVED_KEYWORD}, - {"revoke", REVOKE, UNRESERVED_KEYWORD}, - {"right", RIGHT, TYPE_FUNC_NAME_KEYWORD}, - {"role", ROLE, UNRESERVED_KEYWORD}, - {"rollback", ROLLBACK, UNRESERVED_KEYWORD}, - {"row", ROW, COL_NAME_KEYWORD}, - {"rows", ROWS, UNRESERVED_KEYWORD}, - {"rule", RULE, UNRESERVED_KEYWORD}, - {"savepoint", SAVEPOINT, UNRESERVED_KEYWORD}, - {"schema", SCHEMA, UNRESERVED_KEYWORD}, - {"scroll", SCROLL, UNRESERVED_KEYWORD}, - {"search", SEARCH, UNRESERVED_KEYWORD}, - {"second", SECOND_P, UNRESERVED_KEYWORD}, - {"security", SECURITY, UNRESERVED_KEYWORD}, - {"select", SELECT, RESERVED_KEYWORD}, - {"sequence", SEQUENCE, UNRESERVED_KEYWORD}, - {"serializable", SERIALIZABLE, UNRESERVED_KEYWORD}, - {"server", SERVER, UNRESERVED_KEYWORD}, - {"session", SESSION, UNRESERVED_KEYWORD}, - {"session_user", SESSION_USER, RESERVED_KEYWORD}, - {"set", SET, UNRESERVED_KEYWORD}, - {"setof", SETOF, COL_NAME_KEYWORD}, - {"share", SHARE, UNRESERVED_KEYWORD}, - {"show", SHOW, UNRESERVED_KEYWORD}, - {"similar", SIMILAR, TYPE_FUNC_NAME_KEYWORD}, - {"simple", SIMPLE, UNRESERVED_KEYWORD}, - {"smallint", SMALLINT, COL_NAME_KEYWORD}, - {"some", SOME, RESERVED_KEYWORD}, - {"stable", STABLE, UNRESERVED_KEYWORD}, - {"standalone", STANDALONE_P, UNRESERVED_KEYWORD}, - {"start", START, UNRESERVED_KEYWORD}, - {"statement", STATEMENT, UNRESERVED_KEYWORD}, - {"statistics", STATISTICS, UNRESERVED_KEYWORD}, - {"stdin", STDIN, UNRESERVED_KEYWORD}, - {"stdout", STDOUT, UNRESERVED_KEYWORD}, - {"storage", STORAGE, UNRESERVED_KEYWORD}, - {"strict", STRICT_P, UNRESERVED_KEYWORD}, - {"strip", STRIP_P, UNRESERVED_KEYWORD}, - {"substring", SUBSTRING, COL_NAME_KEYWORD}, - {"superuser", SUPERUSER_P, UNRESERVED_KEYWORD}, - {"symmetric", SYMMETRIC, RESERVED_KEYWORD}, - {"sysid", SYSID, UNRESERVED_KEYWORD}, - {"system", SYSTEM_P, UNRESERVED_KEYWORD}, - {"table", TABLE, RESERVED_KEYWORD}, - {"tablespace", TABLESPACE, UNRESERVED_KEYWORD}, - {"temp", TEMP, UNRESERVED_KEYWORD}, - {"template", TEMPLATE, UNRESERVED_KEYWORD}, - {"temporary", TEMPORARY, UNRESERVED_KEYWORD}, - {"text", TEXT_P, UNRESERVED_KEYWORD}, - {"then", THEN, RESERVED_KEYWORD}, - {"time", TIME, COL_NAME_KEYWORD}, - {"timestamp", TIMESTAMP, COL_NAME_KEYWORD}, - {"to", TO, RESERVED_KEYWORD}, - {"trailing", TRAILING, RESERVED_KEYWORD}, - {"transaction", TRANSACTION, UNRESERVED_KEYWORD}, - {"treat", TREAT, COL_NAME_KEYWORD}, - {"trigger", TRIGGER, UNRESERVED_KEYWORD}, - {"trim", TRIM, COL_NAME_KEYWORD}, - {"true", TRUE_P, RESERVED_KEYWORD}, - {"truncate", TRUNCATE, UNRESERVED_KEYWORD}, - {"trusted", TRUSTED, UNRESERVED_KEYWORD}, - {"type", TYPE_P, UNRESERVED_KEYWORD}, - {"unbounded", UNBOUNDED, UNRESERVED_KEYWORD}, - {"uncommitted", UNCOMMITTED, UNRESERVED_KEYWORD}, - {"unencrypted", UNENCRYPTED, UNRESERVED_KEYWORD}, - {"union", UNION, RESERVED_KEYWORD}, - {"unique", UNIQUE, RESERVED_KEYWORD}, - {"unknown", UNKNOWN, UNRESERVED_KEYWORD}, - {"unlisten", UNLISTEN, UNRESERVED_KEYWORD}, - {"until", UNTIL, UNRESERVED_KEYWORD}, - {"update", UPDATE, UNRESERVED_KEYWORD}, - {"user", USER, RESERVED_KEYWORD}, - {"using", USING, RESERVED_KEYWORD}, - {"vacuum", VACUUM, UNRESERVED_KEYWORD}, - {"valid", VALID, UNRESERVED_KEYWORD}, - {"validator", VALIDATOR, UNRESERVED_KEYWORD}, - {"value", VALUE_P, UNRESERVED_KEYWORD}, - {"values", VALUES, COL_NAME_KEYWORD}, - {"varchar", VARCHAR, COL_NAME_KEYWORD}, - {"variadic", VARIADIC, RESERVED_KEYWORD}, - {"varying", VARYING, UNRESERVED_KEYWORD}, - {"verbose", VERBOSE, TYPE_FUNC_NAME_KEYWORD}, - {"version", VERSION_P, UNRESERVED_KEYWORD}, - {"view", VIEW, UNRESERVED_KEYWORD}, - {"volatile", VOLATILE, UNRESERVED_KEYWORD}, - {"when", WHEN, RESERVED_KEYWORD}, - {"where", WHERE, RESERVED_KEYWORD}, - {"whitespace", WHITESPACE_P, UNRESERVED_KEYWORD}, - {"window", WINDOW, RESERVED_KEYWORD}, - {"with", WITH, RESERVED_KEYWORD}, - {"without", WITHOUT, UNRESERVED_KEYWORD}, - {"work", WORK, UNRESERVED_KEYWORD}, - {"wrapper", WRAPPER, UNRESERVED_KEYWORD}, - {"write", WRITE, UNRESERVED_KEYWORD}, - {"xml", XML_P, UNRESERVED_KEYWORD}, - {"xmlattributes", XMLATTRIBUTES, COL_NAME_KEYWORD}, - {"xmlconcat", XMLCONCAT, COL_NAME_KEYWORD}, - {"xmlelement", XMLELEMENT, COL_NAME_KEYWORD}, - {"xmlforest", XMLFOREST, COL_NAME_KEYWORD}, - {"xmlparse", XMLPARSE, COL_NAME_KEYWORD}, - {"xmlpi", XMLPI, COL_NAME_KEYWORD}, - {"xmlroot", XMLROOT, COL_NAME_KEYWORD}, - {"xmlserialize", XMLSERIALIZE, COL_NAME_KEYWORD}, - {"year", YEAR_P, UNRESERVED_KEYWORD}, - {"yes", YES_P, UNRESERVED_KEYWORD}, - {"zone", ZONE, UNRESERVED_KEYWORD}, +#include "parser/kwlist.h" }; /* End of ScanKeywords, for use elsewhere */ const ScanKeyword *LastScanKeyword = endof(ScanKeywords); - -/* - * ScanKeywordLookup - see if a given word is a keyword - * - * Returns a pointer to the ScanKeyword table entry, or NULL if no match. - * - * The match is done case-insensitively. Note that we deliberately use a - * dumbed-down case conversion that will only translate 'A'-'Z' into 'a'-'z', - * even if we are in a locale where tolower() would produce more or different - * translations. This is to conform to the SQL99 spec, which says that - * keywords are to be matched in this way even though non-keyword identifiers - * receive a different case-normalization mapping. - */ -const ScanKeyword * -ScanKeywordLookup(const char *text) -{ - int len, - i; - char word[NAMEDATALEN]; - const ScanKeyword *low; - const ScanKeyword *high; - - len = strlen(text); - /* We assume all keywords are shorter than NAMEDATALEN. */ - if (len >= NAMEDATALEN) - return NULL; - - /* - * Apply an ASCII-only downcasing. We must not use tolower() since it may - * produce the wrong translation in some locales (eg, Turkish). - */ - for (i = 0; i < len; i++) - { - char ch = text[i]; - - if (ch >= 'A' && ch <= 'Z') - ch += 'a' - 'A'; - word[i] = ch; - } - word[len] = '\0'; - - /* - * Now do a binary search using plain strcmp() comparison. - */ - low = &ScanKeywords[0]; - high = endof(ScanKeywords) - 1; - while (low <= high) - { - const ScanKeyword *middle; - int difference; - - middle = low + (high - low) / 2; - difference = strcmp(middle->name, word); - if (difference == 0) - return middle; - else if (difference < 0) - low = middle + 1; - else - high = middle - 1; - } - - return NULL; -} diff --git a/src/backend/parser/kwlookup.c b/src/backend/parser/kwlookup.c new file mode 100644 index 0000000000..86c89e68b2 --- /dev/null +++ b/src/backend/parser/kwlookup.c @@ -0,0 +1,87 @@ +/*------------------------------------------------------------------------- + * + * kwlookup.c + * lexical token lookup for key words in PostgreSQL + * + * NB - this file is also used by ECPG and several frontend programs in + * src/bin/ including pg_dump and psql + * + * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * + * IDENTIFICATION + * $PostgreSQL: pgsql/src/backend/parser/kwlookup.c,v 2.1 2009/03/07 00:13:58 alvherre Exp $ + * + *------------------------------------------------------------------------- + */ + +/* use c.h so this can be built as either frontend or backend */ +#include "c.h" + +#include + +#include "parser/keywords.h" + +/* + * ScanKeywordLookup - see if a given word is a keyword + * + * Returns a pointer to the ScanKeyword table entry, or NULL if no match. + * + * The match is done case-insensitively. Note that we deliberately use a + * dumbed-down case conversion that will only translate 'A'-'Z' into 'a'-'z', + * even if we are in a locale where tolower() would produce more or different + * translations. This is to conform to the SQL99 spec, which says that + * keywords are to be matched in this way even though non-keyword identifiers + * receive a different case-normalization mapping. + */ +const ScanKeyword * +ScanKeywordLookup(const char *text) +{ + int len, + i; + char word[NAMEDATALEN]; + const ScanKeyword *low; + const ScanKeyword *high; + + len = strlen(text); + /* We assume all keywords are shorter than NAMEDATALEN. */ + if (len >= NAMEDATALEN) + return NULL; + + /* + * Apply an ASCII-only downcasing. We must not use tolower() since it may + * produce the wrong translation in some locales (eg, Turkish). + */ + for (i = 0; i < len; i++) + { + char ch = text[i]; + + if (ch >= 'A' && ch <= 'Z') + ch += 'a' - 'A'; + word[i] = ch; + } + word[len] = '\0'; + + /* + * Now do a binary search using plain strcmp() comparison. + */ + low = &ScanKeywords[0]; + high = LastScanKeyword - 1; + while (low <= high) + { + const ScanKeyword *middle; + int difference; + + middle = low + (high - low) / 2; + difference = strcmp(middle->name, word); + if (difference == 0) + return middle; + else if (difference < 0) + low = middle + 1; + else + high = middle - 1; + } + + return NULL; +} diff --git a/src/bin/pg_dump/Makefile b/src/bin/pg_dump/Makefile index cc9a355180..4cc49d8f7a 100644 --- a/src/bin/pg_dump/Makefile +++ b/src/bin/pg_dump/Makefile @@ -5,7 +5,7 @@ # Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group # Portions Copyright (c) 1994, Regents of the University of California # -# $PostgreSQL: pgsql/src/bin/pg_dump/Makefile,v 1.66 2009/01/01 17:23:54 momjian Exp $ +# $PostgreSQL: pgsql/src/bin/pg_dump/Makefile,v 1.67 2009/03/07 00:13:58 alvherre Exp $ # #------------------------------------------------------------------------- @@ -20,23 +20,21 @@ OBJS= pg_backup_archiver.o pg_backup_db.o pg_backup_custom.o \ pg_backup_files.o pg_backup_null.o pg_backup_tar.o \ dumputils.o $(WIN32RES) -EXTRA_OBJS = $(top_builddir)/src/backend/parser/keywords.o +KEYWRDOBJS = keywords.o kwlookup.o -all: submake-libpq submake-libpgport submake-backend pg_dump pg_restore pg_dumpall +kwlookup.c: % : $(top_srcdir)/src/backend/parser/% + rm -f $@ && $(LN_S) $< . -pg_dump: pg_dump.o common.o pg_dump_sort.o $(OBJS) $(libpq_builddir)/libpq.a - $(CC) $(CFLAGS) pg_dump.o common.o pg_dump_sort.o $(OBJS) $(EXTRA_OBJS) $(libpq_pgport) $(LDFLAGS) $(LIBS) -o $@$(X) +all: submake-libpq submake-libpgport pg_dump pg_restore pg_dumpall -pg_restore: pg_restore.o $(OBJS) $(libpq_builddir)/libpq.a - $(CC) $(CFLAGS) pg_restore.o $(OBJS) $(EXTRA_OBJS) $(libpq_pgport) $(LDFLAGS) $(LIBS) -o $@$(X) +pg_dump: pg_dump.o common.o pg_dump_sort.o $(OBJS) $(KEYWRDOBJS) $(libpq_builddir)/libpq.a + $(CC) $(CFLAGS) pg_dump.o common.o pg_dump_sort.o $(KEYWRDOBJS) $(OBJS) $(libpq_pgport) $(LDFLAGS) $(LIBS) -o $@$(X) -pg_dumpall: pg_dumpall.o dumputils.o $(libpq_builddir)/libpq.a - $(CC) $(CFLAGS) pg_dumpall.o dumputils.o $(EXTRA_OBJS) $(WIN32RES) $(libpq_pgport) $(LDFLAGS) $(LIBS) -o $@$(X) - -.PHONY: submake-backend -submake-backend: - $(MAKE) -C $(top_builddir)/src/backend/parser keywords.o +pg_restore: pg_restore.o $(OBJS) $(KEYWRDOBJS) $(libpq_builddir)/libpq.a + $(CC) $(CFLAGS) pg_restore.o $(KEYWRDOBJS) $(OBJS) $(libpq_pgport) $(LDFLAGS) $(LIBS) -o $@$(X) +pg_dumpall: pg_dumpall.o dumputils.o $(KEYWRDOBJS) $(libpq_builddir)/libpq.a + $(CC) $(CFLAGS) pg_dumpall.o dumputils.o $(KEYWRDOBJS) $(WIN32RES) $(libpq_pgport) $(LDFLAGS) $(LIBS) -o $@$(X) install: all installdirs $(INSTALL_PROGRAM) pg_dump$(X) '$(DESTDIR)$(bindir)'/pg_dump$(X) @@ -50,4 +48,4 @@ uninstall: rm -f $(addprefix '$(DESTDIR)$(bindir)'/, pg_dump$(X) pg_restore$(X) pg_dumpall$(X)) clean distclean maintainer-clean: - rm -f pg_dump$(X) pg_restore$(X) pg_dumpall$(X) $(OBJS) pg_dump.o common.o pg_dump_sort.o pg_restore.o pg_dumpall.o + rm -f pg_dump$(X) pg_restore$(X) pg_dumpall$(X) $(OBJS) pg_dump.o common.o pg_dump_sort.o pg_restore.o pg_dumpall.o kwlookup.c $(KEYWRDOBJS) diff --git a/src/bin/pg_dump/keywords.c b/src/bin/pg_dump/keywords.c new file mode 100644 index 0000000000..97e9ce53db --- /dev/null +++ b/src/bin/pg_dump/keywords.c @@ -0,0 +1,31 @@ +/*------------------------------------------------------------------------- + * + * keywords.c + * lexical token lookup for key words in PostgreSQL + * + * + * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * + * IDENTIFICATION + * $PostgreSQL: pgsql/src/bin/pg_dump/keywords.c,v 1.1 2009/03/07 00:13:58 alvherre Exp $ + * + *------------------------------------------------------------------------- + */ +#include "postgres_fe.h" + +#include "parser/keywords.h" + +/* + * We don't need the token number, so leave it out to avoid requiring other + * backend headers. + */ +#define PG_KEYWORD(a,b,c) {a,0,c}, + +const ScanKeyword ScanKeywords[] = { +#include "parser/kwlist.h" +}; + +/* End of ScanKeywords, for use elsewhere */ +const ScanKeyword *LastScanKeyword = endof(ScanKeywords); diff --git a/src/bin/psql/Makefile b/src/bin/psql/Makefile index 3eed67495e..d8a1f60c47 100644 --- a/src/bin/psql/Makefile +++ b/src/bin/psql/Makefile @@ -5,7 +5,7 @@ # Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group # Portions Copyright (c) 1994, Regents of the University of California # -# $PostgreSQL: pgsql/src/bin/psql/Makefile,v 1.61 2009/01/01 17:23:54 momjian Exp $ +# $PostgreSQL: pgsql/src/bin/psql/Makefile,v 1.62 2009/03/07 00:13:58 alvherre Exp $ # #------------------------------------------------------------------------- @@ -21,21 +21,23 @@ override CPPFLAGS := -I$(srcdir) -I$(libpq_srcdir) -I$(top_srcdir)/src/bin/pg_du OBJS= command.o common.o help.o input.o stringutils.o mainloop.o copy.o \ startup.o prompt.o variables.o large_obj.o print.o describe.o \ - psqlscan.o tab-complete.o mbprint.o dumputils.o $(WIN32RES) - -EXTRA_OBJS = $(top_builddir)/src/backend/parser/keywords.o + psqlscan.o tab-complete.o mbprint.o dumputils.o keywords.o kwlookup.o \ + $(WIN32RES) FLEXFLAGS = -Cfe -all: submake-libpq submake-libpgport submake-backend psql +all: submake-libpq submake-libpgport psql psql: $(OBJS) $(libpq_builddir)/libpq.a - $(CC) $(CFLAGS) $(OBJS) $(EXTRA_OBJS) $(libpq_pgport) $(LDFLAGS) $(LIBS) -o $@$(X) + $(CC) $(CFLAGS) $(OBJS) $(libpq_pgport) $(LDFLAGS) $(LIBS) -o $@$(X) help.o: $(srcdir)/sql_help.h -dumputils.c: % : $(top_srcdir)/src/bin/pg_dump/% +dumputils.c keywords.c: % : $(top_srcdir)/src/bin/pg_dump/% + rm -f $@ && $(LN_S) $< . + +kwlookup.c: % : $(top_srcdir)/src/backend/parser/% rm -f $@ && $(LN_S) $< . ifdef PERL @@ -53,10 +55,6 @@ else @$(missing) flex $< $@ endif -.PHONY: submake-backend -submake-backend: - $(MAKE) -C $(top_builddir)/src/backend/parser keywords.o - distprep: $(srcdir)/sql_help.h $(srcdir)/psqlscan.c install: all installdirs @@ -71,7 +69,7 @@ uninstall: # psqlscan.c is in the distribution tarball, so is not cleaned here clean distclean: - rm -f psql$(X) $(OBJS) dumputils.c + rm -f psql$(X) $(OBJS) dumputils.c keywords.c kwlookup.c maintainer-clean: distclean rm -f $(srcdir)/sql_help.h $(srcdir)/psqlscan.c diff --git a/src/bin/scripts/Makefile b/src/bin/scripts/Makefile index b39012c2e2..e353d86de8 100644 --- a/src/bin/scripts/Makefile +++ b/src/bin/scripts/Makefile @@ -5,7 +5,7 @@ # Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group # Portions Copyright (c) 1994, Regents of the University of California # -# $PostgreSQL: pgsql/src/bin/scripts/Makefile,v 1.40 2009/01/01 17:23:55 momjian Exp $ +# $PostgreSQL: pgsql/src/bin/scripts/Makefile,v 1.41 2009/03/07 00:13:58 alvherre Exp $ # #------------------------------------------------------------------------- @@ -18,31 +18,31 @@ PROGRAMS = createdb createlang createuser dropdb droplang dropuser clusterdb vac override CPPFLAGS := -I$(top_srcdir)/src/bin/pg_dump -I$(top_srcdir)/src/bin/psql -I$(libpq_srcdir) $(CPPFLAGS) -all: submake-libpq submake-backend $(PROGRAMS) +all: submake-libpq $(PROGRAMS) %: %.o $(WIN32RES) $(CC) $(CFLAGS) $^ $(libpq_pgport) $(LDFLAGS) $(LIBS) -o $@$(X) -createdb: createdb.o common.o dumputils.o $(top_builddir)/src/backend/parser/keywords.o +DUMPUTILSOBJS = dumputils.o kwlookup.o keywords.o + +createdb: createdb.o common.o $(DUMPUTILSOBJS) createlang: createlang.o common.o print.o mbprint.o -createuser: createuser.o common.o dumputils.o $(top_builddir)/src/backend/parser/keywords.o -dropdb: dropdb.o common.o dumputils.o $(top_builddir)/src/backend/parser/keywords.o +createuser: createuser.o common.o $(DUMPUTILSOBJS) +dropdb: dropdb.o common.o $(DUMPUTILSOBJS) droplang: droplang.o common.o print.o mbprint.o -dropuser: dropuser.o common.o dumputils.o $(top_builddir)/src/backend/parser/keywords.o -clusterdb: clusterdb.o common.o dumputils.o $(top_builddir)/src/backend/parser/keywords.o +dropuser: dropuser.o common.o $(DUMPUTILSOBJS) +clusterdb: clusterdb.o common.o $(DUMPUTILSOBJS) vacuumdb: vacuumdb.o common.o -reindexdb: reindexdb.o common.o dumputils.o $(top_builddir)/src/backend/parser/keywords.o +reindexdb: reindexdb.o common.o $(DUMPUTILSOBJS) -dumputils.c: % : $(top_srcdir)/src/bin/pg_dump/% +dumputils.c keywords.c: % : $(top_srcdir)/src/bin/pg_dump/% rm -f $@ && $(LN_S) $< . print.c mbprint.c : % : $(top_srcdir)/src/bin/psql/% rm -f $@ && $(LN_S) $< . -.PHONY: submake-backend -submake-backend: - $(MAKE) -C $(top_builddir)/src/backend/parser keywords.o - +kwlookup.c: % : $(top_srcdir)/src/backend/parser/% + rm -f $@ && $(LN_S) $< . install: all installdirs $(INSTALL_PROGRAM) createdb$(X) '$(DESTDIR)$(bindir)'/createdb$(X) @@ -64,5 +64,5 @@ uninstall: clean distclean maintainer-clean: rm -f $(addsuffix $(X), $(PROGRAMS)) $(addsuffix .o, $(PROGRAMS)) - rm -f common.o dumputils.o print.o mbprint.o $(WIN32RES) - rm -f dumputils.c print.c mbprint.c + rm -f common.o $(DUMPUTILSOBJS) print.o mbprint.o $(WIN32RES) + rm -f dumputils.c print.c mbprint.c kwlookup.c keywords.c diff --git a/src/include/parser/kwlist.h b/src/include/parser/kwlist.h new file mode 100644 index 0000000000..1fb2c7a51a --- /dev/null +++ b/src/include/parser/kwlist.h @@ -0,0 +1,419 @@ +/*------------------------------------------------------------------------- + * + * kwlist.h + * + * The keyword list is kept in its own source file for possible use by + * automatic tools. The exact representation of a keyword is determined + * by the PG_KEYWORD macro, which is not defined in this file; it can + * be defined by the caller for special purposes. + * + * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * IDENTIFICATION + * $PostgreSQL: pgsql/src/include/parser/kwlist.h,v 1.1 2009/03/07 00:13:58 alvherre Exp $ + * + *------------------------------------------------------------------------- + */ + +/* there is deliberately not an #ifndef KWLIST_H here */ + +/* + * List of keyword (name, token-value, category) entries. + * + * !!WARNING!!: This list must be sorted by ASCII name, because binary + * search is used to locate entries. + */ + +/* name, value, category */ +PG_KEYWORD("abort", ABORT_P, UNRESERVED_KEYWORD) +PG_KEYWORD("absolute", ABSOLUTE_P, UNRESERVED_KEYWORD) +PG_KEYWORD("access", ACCESS, UNRESERVED_KEYWORD) +PG_KEYWORD("action", ACTION, UNRESERVED_KEYWORD) +PG_KEYWORD("add", ADD_P, UNRESERVED_KEYWORD) +PG_KEYWORD("admin", ADMIN, UNRESERVED_KEYWORD) +PG_KEYWORD("after", AFTER, UNRESERVED_KEYWORD) +PG_KEYWORD("aggregate", AGGREGATE, UNRESERVED_KEYWORD) +PG_KEYWORD("all", ALL, RESERVED_KEYWORD) +PG_KEYWORD("also", ALSO, UNRESERVED_KEYWORD) +PG_KEYWORD("alter", ALTER, UNRESERVED_KEYWORD) +PG_KEYWORD("always", ALWAYS, UNRESERVED_KEYWORD) +PG_KEYWORD("analyse", ANALYSE, RESERVED_KEYWORD) /* British spelling */ +PG_KEYWORD("analyze", ANALYZE, RESERVED_KEYWORD) +PG_KEYWORD("and", AND, RESERVED_KEYWORD) +PG_KEYWORD("any", ANY, RESERVED_KEYWORD) +PG_KEYWORD("array", ARRAY, RESERVED_KEYWORD) +PG_KEYWORD("as", AS, RESERVED_KEYWORD) +PG_KEYWORD("asc", ASC, RESERVED_KEYWORD) +PG_KEYWORD("assertion", ASSERTION, UNRESERVED_KEYWORD) +PG_KEYWORD("assignment", ASSIGNMENT, UNRESERVED_KEYWORD) +PG_KEYWORD("asymmetric", ASYMMETRIC, RESERVED_KEYWORD) +PG_KEYWORD("at", AT, UNRESERVED_KEYWORD) +PG_KEYWORD("authorization", AUTHORIZATION, TYPE_FUNC_NAME_KEYWORD) +PG_KEYWORD("backward", BACKWARD, UNRESERVED_KEYWORD) +PG_KEYWORD("before", BEFORE, UNRESERVED_KEYWORD) +PG_KEYWORD("begin", BEGIN_P, UNRESERVED_KEYWORD) +PG_KEYWORD("between", BETWEEN, TYPE_FUNC_NAME_KEYWORD) +PG_KEYWORD("bigint", BIGINT, COL_NAME_KEYWORD) +PG_KEYWORD("binary", BINARY, TYPE_FUNC_NAME_KEYWORD) +PG_KEYWORD("bit", BIT, COL_NAME_KEYWORD) +PG_KEYWORD("boolean", BOOLEAN_P, COL_NAME_KEYWORD) +PG_KEYWORD("both", BOTH, RESERVED_KEYWORD) +PG_KEYWORD("by", BY, UNRESERVED_KEYWORD) +PG_KEYWORD("cache", CACHE, UNRESERVED_KEYWORD) +PG_KEYWORD("called", CALLED, UNRESERVED_KEYWORD) +PG_KEYWORD("cascade", CASCADE, UNRESERVED_KEYWORD) +PG_KEYWORD("cascaded", CASCADED, UNRESERVED_KEYWORD) +PG_KEYWORD("case", CASE, RESERVED_KEYWORD) +PG_KEYWORD("cast", CAST, RESERVED_KEYWORD) +PG_KEYWORD("catalog", CATALOG_P, UNRESERVED_KEYWORD) +PG_KEYWORD("chain", CHAIN, UNRESERVED_KEYWORD) +PG_KEYWORD("char", CHAR_P, COL_NAME_KEYWORD) +PG_KEYWORD("character", CHARACTER, COL_NAME_KEYWORD) +PG_KEYWORD("characteristics", CHARACTERISTICS, UNRESERVED_KEYWORD) +PG_KEYWORD("check", CHECK, RESERVED_KEYWORD) +PG_KEYWORD("checkpoint", CHECKPOINT, UNRESERVED_KEYWORD) +PG_KEYWORD("class", CLASS, UNRESERVED_KEYWORD) +PG_KEYWORD("close", CLOSE, UNRESERVED_KEYWORD) +PG_KEYWORD("cluster", CLUSTER, UNRESERVED_KEYWORD) +PG_KEYWORD("coalesce", COALESCE, COL_NAME_KEYWORD) +PG_KEYWORD("collate", COLLATE, RESERVED_KEYWORD) +PG_KEYWORD("column", COLUMN, RESERVED_KEYWORD) +PG_KEYWORD("comment", COMMENT, UNRESERVED_KEYWORD) +PG_KEYWORD("commit", COMMIT, UNRESERVED_KEYWORD) +PG_KEYWORD("committed", COMMITTED, UNRESERVED_KEYWORD) +PG_KEYWORD("concurrently", CONCURRENTLY, UNRESERVED_KEYWORD) +PG_KEYWORD("configuration", CONFIGURATION, UNRESERVED_KEYWORD) +PG_KEYWORD("connection", CONNECTION, UNRESERVED_KEYWORD) +PG_KEYWORD("constraint", CONSTRAINT, RESERVED_KEYWORD) +PG_KEYWORD("constraints", CONSTRAINTS, UNRESERVED_KEYWORD) +PG_KEYWORD("content", CONTENT_P, UNRESERVED_KEYWORD) +PG_KEYWORD("continue", CONTINUE_P, UNRESERVED_KEYWORD) +PG_KEYWORD("conversion", CONVERSION_P, UNRESERVED_KEYWORD) +PG_KEYWORD("copy", COPY, UNRESERVED_KEYWORD) +PG_KEYWORD("cost", COST, UNRESERVED_KEYWORD) +PG_KEYWORD("create", CREATE, RESERVED_KEYWORD) +PG_KEYWORD("createdb", CREATEDB, UNRESERVED_KEYWORD) +PG_KEYWORD("createrole", CREATEROLE, UNRESERVED_KEYWORD) +PG_KEYWORD("createuser", CREATEUSER, UNRESERVED_KEYWORD) +PG_KEYWORD("cross", CROSS, TYPE_FUNC_NAME_KEYWORD) +PG_KEYWORD("csv", CSV, UNRESERVED_KEYWORD) +PG_KEYWORD("ctype", CTYPE, UNRESERVED_KEYWORD) +PG_KEYWORD("current", CURRENT_P, UNRESERVED_KEYWORD) +PG_KEYWORD("current_catalog", CURRENT_CATALOG, RESERVED_KEYWORD) +PG_KEYWORD("current_date", CURRENT_DATE, RESERVED_KEYWORD) +PG_KEYWORD("current_role", CURRENT_ROLE, RESERVED_KEYWORD) +PG_KEYWORD("current_schema", CURRENT_SCHEMA, TYPE_FUNC_NAME_KEYWORD) +PG_KEYWORD("current_time", CURRENT_TIME, RESERVED_KEYWORD) +PG_KEYWORD("current_timestamp", CURRENT_TIMESTAMP, RESERVED_KEYWORD) +PG_KEYWORD("current_user", CURRENT_USER, RESERVED_KEYWORD) +PG_KEYWORD("cursor", CURSOR, UNRESERVED_KEYWORD) +PG_KEYWORD("cycle", CYCLE, UNRESERVED_KEYWORD) +PG_KEYWORD("data", DATA_P, UNRESERVED_KEYWORD) +PG_KEYWORD("database", DATABASE, UNRESERVED_KEYWORD) +PG_KEYWORD("day", DAY_P, UNRESERVED_KEYWORD) +PG_KEYWORD("deallocate", DEALLOCATE, UNRESERVED_KEYWORD) +PG_KEYWORD("dec", DEC, COL_NAME_KEYWORD) +PG_KEYWORD("decimal", DECIMAL_P, COL_NAME_KEYWORD) +PG_KEYWORD("declare", DECLARE, UNRESERVED_KEYWORD) +PG_KEYWORD("default", DEFAULT, RESERVED_KEYWORD) +PG_KEYWORD("defaults", DEFAULTS, UNRESERVED_KEYWORD) +PG_KEYWORD("deferrable", DEFERRABLE, RESERVED_KEYWORD) +PG_KEYWORD("deferred", DEFERRED, UNRESERVED_KEYWORD) +PG_KEYWORD("definer", DEFINER, UNRESERVED_KEYWORD) +PG_KEYWORD("delete", DELETE_P, UNRESERVED_KEYWORD) +PG_KEYWORD("delimiter", DELIMITER, UNRESERVED_KEYWORD) +PG_KEYWORD("delimiters", DELIMITERS, UNRESERVED_KEYWORD) +PG_KEYWORD("desc", DESC, RESERVED_KEYWORD) +PG_KEYWORD("dictionary", DICTIONARY, UNRESERVED_KEYWORD) +PG_KEYWORD("disable", DISABLE_P, UNRESERVED_KEYWORD) +PG_KEYWORD("discard", DISCARD, UNRESERVED_KEYWORD) +PG_KEYWORD("distinct", DISTINCT, RESERVED_KEYWORD) +PG_KEYWORD("do", DO, RESERVED_KEYWORD) +PG_KEYWORD("document", DOCUMENT_P, UNRESERVED_KEYWORD) +PG_KEYWORD("domain", DOMAIN_P, UNRESERVED_KEYWORD) +PG_KEYWORD("double", DOUBLE_P, UNRESERVED_KEYWORD) +PG_KEYWORD("drop", DROP, UNRESERVED_KEYWORD) +PG_KEYWORD("each", EACH, UNRESERVED_KEYWORD) +PG_KEYWORD("else", ELSE, RESERVED_KEYWORD) +PG_KEYWORD("enable", ENABLE_P, UNRESERVED_KEYWORD) +PG_KEYWORD("encoding", ENCODING, UNRESERVED_KEYWORD) +PG_KEYWORD("encrypted", ENCRYPTED, UNRESERVED_KEYWORD) +PG_KEYWORD("end", END_P, RESERVED_KEYWORD) +PG_KEYWORD("enum", ENUM_P, UNRESERVED_KEYWORD) +PG_KEYWORD("escape", ESCAPE, UNRESERVED_KEYWORD) +PG_KEYWORD("except", EXCEPT, RESERVED_KEYWORD) +PG_KEYWORD("excluding", EXCLUDING, UNRESERVED_KEYWORD) +PG_KEYWORD("exclusive", EXCLUSIVE, UNRESERVED_KEYWORD) +PG_KEYWORD("execute", EXECUTE, UNRESERVED_KEYWORD) +PG_KEYWORD("exists", EXISTS, COL_NAME_KEYWORD) +PG_KEYWORD("explain", EXPLAIN, UNRESERVED_KEYWORD) +PG_KEYWORD("external", EXTERNAL, UNRESERVED_KEYWORD) +PG_KEYWORD("extract", EXTRACT, COL_NAME_KEYWORD) +PG_KEYWORD("false", FALSE_P, RESERVED_KEYWORD) +PG_KEYWORD("family", FAMILY, UNRESERVED_KEYWORD) +PG_KEYWORD("fetch", FETCH, RESERVED_KEYWORD) +PG_KEYWORD("first", FIRST_P, UNRESERVED_KEYWORD) +PG_KEYWORD("float", FLOAT_P, COL_NAME_KEYWORD) +PG_KEYWORD("following", FOLLOWING, UNRESERVED_KEYWORD) +PG_KEYWORD("for", FOR, RESERVED_KEYWORD) +PG_KEYWORD("force", FORCE, UNRESERVED_KEYWORD) +PG_KEYWORD("foreign", FOREIGN, RESERVED_KEYWORD) +PG_KEYWORD("forward", FORWARD, UNRESERVED_KEYWORD) +PG_KEYWORD("freeze", FREEZE, TYPE_FUNC_NAME_KEYWORD) +PG_KEYWORD("from", FROM, RESERVED_KEYWORD) +PG_KEYWORD("full", FULL, TYPE_FUNC_NAME_KEYWORD) +PG_KEYWORD("function", FUNCTION, UNRESERVED_KEYWORD) +PG_KEYWORD("global", GLOBAL, UNRESERVED_KEYWORD) +PG_KEYWORD("grant", GRANT, RESERVED_KEYWORD) +PG_KEYWORD("granted", GRANTED, UNRESERVED_KEYWORD) +PG_KEYWORD("greatest", GREATEST, COL_NAME_KEYWORD) +PG_KEYWORD("group", GROUP_P, RESERVED_KEYWORD) +PG_KEYWORD("handler", HANDLER, UNRESERVED_KEYWORD) +PG_KEYWORD("having", HAVING, RESERVED_KEYWORD) +PG_KEYWORD("header", HEADER_P, UNRESERVED_KEYWORD) +PG_KEYWORD("hold", HOLD, UNRESERVED_KEYWORD) +PG_KEYWORD("hour", HOUR_P, UNRESERVED_KEYWORD) +PG_KEYWORD("identity", IDENTITY_P, UNRESERVED_KEYWORD) +PG_KEYWORD("if", IF_P, UNRESERVED_KEYWORD) +PG_KEYWORD("ilike", ILIKE, TYPE_FUNC_NAME_KEYWORD) +PG_KEYWORD("immediate", IMMEDIATE, UNRESERVED_KEYWORD) +PG_KEYWORD("immutable", IMMUTABLE, UNRESERVED_KEYWORD) +PG_KEYWORD("implicit", IMPLICIT_P, UNRESERVED_KEYWORD) +PG_KEYWORD("in", IN_P, RESERVED_KEYWORD) +PG_KEYWORD("including", INCLUDING, UNRESERVED_KEYWORD) +PG_KEYWORD("increment", INCREMENT, UNRESERVED_KEYWORD) +PG_KEYWORD("index", INDEX, UNRESERVED_KEYWORD) +PG_KEYWORD("indexes", INDEXES, UNRESERVED_KEYWORD) +PG_KEYWORD("inherit", INHERIT, UNRESERVED_KEYWORD) +PG_KEYWORD("inherits", INHERITS, UNRESERVED_KEYWORD) +PG_KEYWORD("initially", INITIALLY, RESERVED_KEYWORD) +PG_KEYWORD("inner", INNER_P, TYPE_FUNC_NAME_KEYWORD) +PG_KEYWORD("inout", INOUT, COL_NAME_KEYWORD) +PG_KEYWORD("input", INPUT_P, UNRESERVED_KEYWORD) +PG_KEYWORD("insensitive", INSENSITIVE, UNRESERVED_KEYWORD) +PG_KEYWORD("insert", INSERT, UNRESERVED_KEYWORD) +PG_KEYWORD("instead", INSTEAD, UNRESERVED_KEYWORD) +PG_KEYWORD("int", INT_P, COL_NAME_KEYWORD) +PG_KEYWORD("integer", INTEGER, COL_NAME_KEYWORD) +PG_KEYWORD("intersect", INTERSECT, RESERVED_KEYWORD) +PG_KEYWORD("interval", INTERVAL, COL_NAME_KEYWORD) +PG_KEYWORD("into", INTO, RESERVED_KEYWORD) +PG_KEYWORD("invoker", INVOKER, UNRESERVED_KEYWORD) +PG_KEYWORD("is", IS, TYPE_FUNC_NAME_KEYWORD) +PG_KEYWORD("isnull", ISNULL, TYPE_FUNC_NAME_KEYWORD) +PG_KEYWORD("isolation", ISOLATION, UNRESERVED_KEYWORD) +PG_KEYWORD("join", JOIN, TYPE_FUNC_NAME_KEYWORD) +PG_KEYWORD("key", KEY, UNRESERVED_KEYWORD) +PG_KEYWORD("lancompiler", LANCOMPILER, UNRESERVED_KEYWORD) +PG_KEYWORD("language", LANGUAGE, UNRESERVED_KEYWORD) +PG_KEYWORD("large", LARGE_P, UNRESERVED_KEYWORD) +PG_KEYWORD("last", LAST_P, UNRESERVED_KEYWORD) +PG_KEYWORD("leading", LEADING, RESERVED_KEYWORD) +PG_KEYWORD("least", LEAST, COL_NAME_KEYWORD) +PG_KEYWORD("left", LEFT, TYPE_FUNC_NAME_KEYWORD) +PG_KEYWORD("level", LEVEL, UNRESERVED_KEYWORD) +PG_KEYWORD("like", LIKE, TYPE_FUNC_NAME_KEYWORD) +PG_KEYWORD("limit", LIMIT, RESERVED_KEYWORD) +PG_KEYWORD("listen", LISTEN, UNRESERVED_KEYWORD) +PG_KEYWORD("load", LOAD, UNRESERVED_KEYWORD) +PG_KEYWORD("local", LOCAL, UNRESERVED_KEYWORD) +PG_KEYWORD("localtime", LOCALTIME, RESERVED_KEYWORD) +PG_KEYWORD("localtimestamp", LOCALTIMESTAMP, RESERVED_KEYWORD) +PG_KEYWORD("location", LOCATION, UNRESERVED_KEYWORD) +PG_KEYWORD("lock", LOCK_P, UNRESERVED_KEYWORD) +PG_KEYWORD("login", LOGIN_P, UNRESERVED_KEYWORD) +PG_KEYWORD("mapping", MAPPING, UNRESERVED_KEYWORD) +PG_KEYWORD("match", MATCH, UNRESERVED_KEYWORD) +PG_KEYWORD("maxvalue", MAXVALUE, UNRESERVED_KEYWORD) +PG_KEYWORD("minute", MINUTE_P, UNRESERVED_KEYWORD) +PG_KEYWORD("minvalue", MINVALUE, UNRESERVED_KEYWORD) +PG_KEYWORD("mode", MODE, UNRESERVED_KEYWORD) +PG_KEYWORD("month", MONTH_P, UNRESERVED_KEYWORD) +PG_KEYWORD("move", MOVE, UNRESERVED_KEYWORD) +PG_KEYWORD("name", NAME_P, UNRESERVED_KEYWORD) +PG_KEYWORD("names", NAMES, UNRESERVED_KEYWORD) +PG_KEYWORD("national", NATIONAL, COL_NAME_KEYWORD) +PG_KEYWORD("natural", NATURAL, TYPE_FUNC_NAME_KEYWORD) +PG_KEYWORD("nchar", NCHAR, COL_NAME_KEYWORD) +PG_KEYWORD("new", NEW, RESERVED_KEYWORD) +PG_KEYWORD("next", NEXT, UNRESERVED_KEYWORD) +PG_KEYWORD("no", NO, UNRESERVED_KEYWORD) +PG_KEYWORD("nocreatedb", NOCREATEDB, UNRESERVED_KEYWORD) +PG_KEYWORD("nocreaterole", NOCREATEROLE, UNRESERVED_KEYWORD) +PG_KEYWORD("nocreateuser", NOCREATEUSER, UNRESERVED_KEYWORD) +PG_KEYWORD("noinherit", NOINHERIT, UNRESERVED_KEYWORD) +PG_KEYWORD("nologin", NOLOGIN_P, UNRESERVED_KEYWORD) +PG_KEYWORD("none", NONE, COL_NAME_KEYWORD) +PG_KEYWORD("nosuperuser", NOSUPERUSER, UNRESERVED_KEYWORD) +PG_KEYWORD("not", NOT, RESERVED_KEYWORD) +PG_KEYWORD("nothing", NOTHING, UNRESERVED_KEYWORD) +PG_KEYWORD("notify", NOTIFY, UNRESERVED_KEYWORD) +PG_KEYWORD("notnull", NOTNULL, TYPE_FUNC_NAME_KEYWORD) +PG_KEYWORD("nowait", NOWAIT, UNRESERVED_KEYWORD) +PG_KEYWORD("null", NULL_P, RESERVED_KEYWORD) +PG_KEYWORD("nullif", NULLIF, COL_NAME_KEYWORD) +PG_KEYWORD("nulls", NULLS_P, UNRESERVED_KEYWORD) +PG_KEYWORD("numeric", NUMERIC, COL_NAME_KEYWORD) +PG_KEYWORD("object", OBJECT_P, UNRESERVED_KEYWORD) +PG_KEYWORD("of", OF, UNRESERVED_KEYWORD) +PG_KEYWORD("off", OFF, RESERVED_KEYWORD) +PG_KEYWORD("offset", OFFSET, RESERVED_KEYWORD) +PG_KEYWORD("oids", OIDS, UNRESERVED_KEYWORD) +PG_KEYWORD("old", OLD, RESERVED_KEYWORD) +PG_KEYWORD("on", ON, RESERVED_KEYWORD) +PG_KEYWORD("only", ONLY, RESERVED_KEYWORD) +PG_KEYWORD("operator", OPERATOR, UNRESERVED_KEYWORD) +PG_KEYWORD("option", OPTION, UNRESERVED_KEYWORD) +PG_KEYWORD("options", OPTIONS, UNRESERVED_KEYWORD) +PG_KEYWORD("or", OR, RESERVED_KEYWORD) +PG_KEYWORD("order", ORDER, RESERVED_KEYWORD) +PG_KEYWORD("out", OUT_P, COL_NAME_KEYWORD) +PG_KEYWORD("outer", OUTER_P, TYPE_FUNC_NAME_KEYWORD) +PG_KEYWORD("over", OVER, TYPE_FUNC_NAME_KEYWORD) +PG_KEYWORD("overlaps", OVERLAPS, TYPE_FUNC_NAME_KEYWORD) +PG_KEYWORD("overlay", OVERLAY, COL_NAME_KEYWORD) +PG_KEYWORD("owned", OWNED, UNRESERVED_KEYWORD) +PG_KEYWORD("owner", OWNER, UNRESERVED_KEYWORD) +PG_KEYWORD("parser", PARSER, UNRESERVED_KEYWORD) +PG_KEYWORD("partial", PARTIAL, UNRESERVED_KEYWORD) +PG_KEYWORD("partition", PARTITION, UNRESERVED_KEYWORD) +PG_KEYWORD("password", PASSWORD, UNRESERVED_KEYWORD) +PG_KEYWORD("placing", PLACING, RESERVED_KEYWORD) +PG_KEYWORD("plans", PLANS, UNRESERVED_KEYWORD) +PG_KEYWORD("position", POSITION, COL_NAME_KEYWORD) +PG_KEYWORD("preceding", PRECEDING, UNRESERVED_KEYWORD) +PG_KEYWORD("precision", PRECISION, COL_NAME_KEYWORD) +PG_KEYWORD("prepare", PREPARE, UNRESERVED_KEYWORD) +PG_KEYWORD("prepared", PREPARED, UNRESERVED_KEYWORD) +PG_KEYWORD("preserve", PRESERVE, UNRESERVED_KEYWORD) +PG_KEYWORD("primary", PRIMARY, RESERVED_KEYWORD) +PG_KEYWORD("prior", PRIOR, UNRESERVED_KEYWORD) +PG_KEYWORD("privileges", PRIVILEGES, UNRESERVED_KEYWORD) +PG_KEYWORD("procedural", PROCEDURAL, UNRESERVED_KEYWORD) +PG_KEYWORD("procedure", PROCEDURE, UNRESERVED_KEYWORD) +PG_KEYWORD("quote", QUOTE, UNRESERVED_KEYWORD) +PG_KEYWORD("range", RANGE, UNRESERVED_KEYWORD) +PG_KEYWORD("read", READ, UNRESERVED_KEYWORD) +PG_KEYWORD("real", REAL, COL_NAME_KEYWORD) +PG_KEYWORD("reassign", REASSIGN, UNRESERVED_KEYWORD) +PG_KEYWORD("recheck", RECHECK, UNRESERVED_KEYWORD) +PG_KEYWORD("recursive", RECURSIVE, UNRESERVED_KEYWORD) +PG_KEYWORD("references", REFERENCES, RESERVED_KEYWORD) +PG_KEYWORD("reindex", REINDEX, UNRESERVED_KEYWORD) +PG_KEYWORD("relative", RELATIVE_P, UNRESERVED_KEYWORD) +PG_KEYWORD("release", RELEASE, UNRESERVED_KEYWORD) +PG_KEYWORD("rename", RENAME, UNRESERVED_KEYWORD) +PG_KEYWORD("repeatable", REPEATABLE, UNRESERVED_KEYWORD) +PG_KEYWORD("replace", REPLACE, UNRESERVED_KEYWORD) +PG_KEYWORD("replica", REPLICA, UNRESERVED_KEYWORD) +PG_KEYWORD("reset", RESET, UNRESERVED_KEYWORD) +PG_KEYWORD("restart", RESTART, UNRESERVED_KEYWORD) +PG_KEYWORD("restrict", RESTRICT, UNRESERVED_KEYWORD) +PG_KEYWORD("returning", RETURNING, RESERVED_KEYWORD) +PG_KEYWORD("returns", RETURNS, UNRESERVED_KEYWORD) +PG_KEYWORD("revoke", REVOKE, UNRESERVED_KEYWORD) +PG_KEYWORD("right", RIGHT, TYPE_FUNC_NAME_KEYWORD) +PG_KEYWORD("role", ROLE, UNRESERVED_KEYWORD) +PG_KEYWORD("rollback", ROLLBACK, UNRESERVED_KEYWORD) +PG_KEYWORD("row", ROW, COL_NAME_KEYWORD) +PG_KEYWORD("rows", ROWS, UNRESERVED_KEYWORD) +PG_KEYWORD("rule", RULE, UNRESERVED_KEYWORD) +PG_KEYWORD("savepoint", SAVEPOINT, UNRESERVED_KEYWORD) +PG_KEYWORD("schema", SCHEMA, UNRESERVED_KEYWORD) +PG_KEYWORD("scroll", SCROLL, UNRESERVED_KEYWORD) +PG_KEYWORD("search", SEARCH, UNRESERVED_KEYWORD) +PG_KEYWORD("second", SECOND_P, UNRESERVED_KEYWORD) +PG_KEYWORD("security", SECURITY, UNRESERVED_KEYWORD) +PG_KEYWORD("select", SELECT, RESERVED_KEYWORD) +PG_KEYWORD("sequence", SEQUENCE, UNRESERVED_KEYWORD) +PG_KEYWORD("serializable", SERIALIZABLE, UNRESERVED_KEYWORD) +PG_KEYWORD("server", SERVER, UNRESERVED_KEYWORD) +PG_KEYWORD("session", SESSION, UNRESERVED_KEYWORD) +PG_KEYWORD("session_user", SESSION_USER, RESERVED_KEYWORD) +PG_KEYWORD("set", SET, UNRESERVED_KEYWORD) +PG_KEYWORD("setof", SETOF, COL_NAME_KEYWORD) +PG_KEYWORD("share", SHARE, UNRESERVED_KEYWORD) +PG_KEYWORD("show", SHOW, UNRESERVED_KEYWORD) +PG_KEYWORD("similar", SIMILAR, TYPE_FUNC_NAME_KEYWORD) +PG_KEYWORD("simple", SIMPLE, UNRESERVED_KEYWORD) +PG_KEYWORD("smallint", SMALLINT, COL_NAME_KEYWORD) +PG_KEYWORD("some", SOME, RESERVED_KEYWORD) +PG_KEYWORD("stable", STABLE, UNRESERVED_KEYWORD) +PG_KEYWORD("standalone", STANDALONE_P, UNRESERVED_KEYWORD) +PG_KEYWORD("start", START, UNRESERVED_KEYWORD) +PG_KEYWORD("statement", STATEMENT, UNRESERVED_KEYWORD) +PG_KEYWORD("statistics", STATISTICS, UNRESERVED_KEYWORD) +PG_KEYWORD("stdin", STDIN, UNRESERVED_KEYWORD) +PG_KEYWORD("stdout", STDOUT, UNRESERVED_KEYWORD) +PG_KEYWORD("storage", STORAGE, UNRESERVED_KEYWORD) +PG_KEYWORD("strict", STRICT_P, UNRESERVED_KEYWORD) +PG_KEYWORD("strip", STRIP_P, UNRESERVED_KEYWORD) +PG_KEYWORD("substring", SUBSTRING, COL_NAME_KEYWORD) +PG_KEYWORD("superuser", SUPERUSER_P, UNRESERVED_KEYWORD) +PG_KEYWORD("symmetric", SYMMETRIC, RESERVED_KEYWORD) +PG_KEYWORD("sysid", SYSID, UNRESERVED_KEYWORD) +PG_KEYWORD("system", SYSTEM_P, UNRESERVED_KEYWORD) +PG_KEYWORD("table", TABLE, RESERVED_KEYWORD) +PG_KEYWORD("tablespace", TABLESPACE, UNRESERVED_KEYWORD) +PG_KEYWORD("temp", TEMP, UNRESERVED_KEYWORD) +PG_KEYWORD("template", TEMPLATE, UNRESERVED_KEYWORD) +PG_KEYWORD("temporary", TEMPORARY, UNRESERVED_KEYWORD) +PG_KEYWORD("text", TEXT_P, UNRESERVED_KEYWORD) +PG_KEYWORD("then", THEN, RESERVED_KEYWORD) +PG_KEYWORD("time", TIME, COL_NAME_KEYWORD) +PG_KEYWORD("timestamp", TIMESTAMP, COL_NAME_KEYWORD) +PG_KEYWORD("to", TO, RESERVED_KEYWORD) +PG_KEYWORD("trailing", TRAILING, RESERVED_KEYWORD) +PG_KEYWORD("transaction", TRANSACTION, UNRESERVED_KEYWORD) +PG_KEYWORD("treat", TREAT, COL_NAME_KEYWORD) +PG_KEYWORD("trigger", TRIGGER, UNRESERVED_KEYWORD) +PG_KEYWORD("trim", TRIM, COL_NAME_KEYWORD) +PG_KEYWORD("true", TRUE_P, RESERVED_KEYWORD) +PG_KEYWORD("truncate", TRUNCATE, UNRESERVED_KEYWORD) +PG_KEYWORD("trusted", TRUSTED, UNRESERVED_KEYWORD) +PG_KEYWORD("type", TYPE_P, UNRESERVED_KEYWORD) +PG_KEYWORD("unbounded", UNBOUNDED, UNRESERVED_KEYWORD) +PG_KEYWORD("uncommitted", UNCOMMITTED, UNRESERVED_KEYWORD) +PG_KEYWORD("unencrypted", UNENCRYPTED, UNRESERVED_KEYWORD) +PG_KEYWORD("union", UNION, RESERVED_KEYWORD) +PG_KEYWORD("unique", UNIQUE, RESERVED_KEYWORD) +PG_KEYWORD("unknown", UNKNOWN, UNRESERVED_KEYWORD) +PG_KEYWORD("unlisten", UNLISTEN, UNRESERVED_KEYWORD) +PG_KEYWORD("until", UNTIL, UNRESERVED_KEYWORD) +PG_KEYWORD("update", UPDATE, UNRESERVED_KEYWORD) +PG_KEYWORD("user", USER, RESERVED_KEYWORD) +PG_KEYWORD("using", USING, RESERVED_KEYWORD) +PG_KEYWORD("vacuum", VACUUM, UNRESERVED_KEYWORD) +PG_KEYWORD("valid", VALID, UNRESERVED_KEYWORD) +PG_KEYWORD("validator", VALIDATOR, UNRESERVED_KEYWORD) +PG_KEYWORD("value", VALUE_P, UNRESERVED_KEYWORD) +PG_KEYWORD("values", VALUES, COL_NAME_KEYWORD) +PG_KEYWORD("varchar", VARCHAR, COL_NAME_KEYWORD) +PG_KEYWORD("variadic", VARIADIC, RESERVED_KEYWORD) +PG_KEYWORD("varying", VARYING, UNRESERVED_KEYWORD) +PG_KEYWORD("verbose", VERBOSE, TYPE_FUNC_NAME_KEYWORD) +PG_KEYWORD("version", VERSION_P, UNRESERVED_KEYWORD) +PG_KEYWORD("view", VIEW, UNRESERVED_KEYWORD) +PG_KEYWORD("volatile", VOLATILE, UNRESERVED_KEYWORD) +PG_KEYWORD("when", WHEN, RESERVED_KEYWORD) +PG_KEYWORD("where", WHERE, RESERVED_KEYWORD) +PG_KEYWORD("whitespace", WHITESPACE_P, UNRESERVED_KEYWORD) +PG_KEYWORD("window", WINDOW, RESERVED_KEYWORD) +PG_KEYWORD("with", WITH, RESERVED_KEYWORD) +PG_KEYWORD("without", WITHOUT, UNRESERVED_KEYWORD) +PG_KEYWORD("work", WORK, UNRESERVED_KEYWORD) +PG_KEYWORD("wrapper", WRAPPER, UNRESERVED_KEYWORD) +PG_KEYWORD("write", WRITE, UNRESERVED_KEYWORD) +PG_KEYWORD("xml", XML_P, UNRESERVED_KEYWORD) +PG_KEYWORD("xmlattributes", XMLATTRIBUTES, COL_NAME_KEYWORD) +PG_KEYWORD("xmlconcat", XMLCONCAT, COL_NAME_KEYWORD) +PG_KEYWORD("xmlelement", XMLELEMENT, COL_NAME_KEYWORD) +PG_KEYWORD("xmlforest", XMLFOREST, COL_NAME_KEYWORD) +PG_KEYWORD("xmlparse", XMLPARSE, COL_NAME_KEYWORD) +PG_KEYWORD("xmlpi", XMLPI, COL_NAME_KEYWORD) +PG_KEYWORD("xmlroot", XMLROOT, COL_NAME_KEYWORD) +PG_KEYWORD("xmlserialize", XMLSERIALIZE, COL_NAME_KEYWORD) +PG_KEYWORD("year", YEAR_P, UNRESERVED_KEYWORD) +PG_KEYWORD("yes", YES_P, UNRESERVED_KEYWORD) +PG_KEYWORD("zone", ZONE, UNRESERVED_KEYWORD) diff --git a/src/interfaces/ecpg/preproc/Makefile b/src/interfaces/ecpg/preproc/Makefile index 7983659ed1..3e95606c9d 100644 --- a/src/interfaces/ecpg/preproc/Makefile +++ b/src/interfaces/ecpg/preproc/Makefile @@ -4,7 +4,7 @@ # # Copyright (c) 1998-2009, PostgreSQL Global Development Group # -# $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/Makefile,v 1.141 2009/01/01 17:24:02 momjian Exp $ +# $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/Makefile,v 1.142 2009/03/07 00:13:58 alvherre Exp $ # #------------------------------------------------------------------------- @@ -25,7 +25,7 @@ override CPPFLAGS := -I../include -I$(top_srcdir)/src/interfaces/ecpg/include \ override CFLAGS += $(PTHREAD_CFLAGS) -DECPG_COMPILE OBJS= preproc.o type.o ecpg.o output.o parser.o \ - keywords.o c_keywords.o ecpg_keywords.o ../ecpglib/typename.o descriptor.o variable.o \ + keywords.o c_keywords.o ecpg_keywords.o kwlookup.o ../ecpglib/typename.o descriptor.o variable.o \ $(WIN32RES) all: submake-libpgport ecpg @@ -57,8 +57,7 @@ $(srcdir)/preproc.y: $(top_srcdir)/src/backend/parser/gram.y parse.pl ecpg.addon ecpg_keywords.o c_keywords.o keywords.o preproc.o parser.o: preproc.h -# instead of maintaining our own list, take the one from the backend -keywords.c: % : $(top_srcdir)/src/backend/parser/% +kwlookup.c: % : $(top_srcdir)/src/backend/parser/% rm -f $@ && $(LN_S) $< . distprep: $(srcdir)/preproc.y $(srcdir)/preproc.c $(srcdir)/preproc.h $(srcdir)/pgc.c @@ -73,7 +72,7 @@ uninstall: rm -f '$(DESTDIR)$(bindir)/ecpg$(X)' clean distclean: - rm -f keywords.c *.o ecpg$(X) + rm -f kwlookup.c *.o ecpg$(X) # garbage from development @rm -f core a.out diff --git a/src/interfaces/ecpg/preproc/keywords.c b/src/interfaces/ecpg/preproc/keywords.c new file mode 100644 index 0000000000..62065ba2f2 --- /dev/null +++ b/src/interfaces/ecpg/preproc/keywords.c @@ -0,0 +1,30 @@ +/*------------------------------------------------------------------------- + * + * keywords.c + * lexical token lookup for key words in PostgreSQL + * + * + * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * + * IDENTIFICATION + * $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/keywords.c,v 1.87 2009/03/07 00:13:58 alvherre Exp $ + * + *------------------------------------------------------------------------- + */ +#include "postgres_fe.h" + +#include "parser/keywords.h" +#include "type.h" +#include "preproc.h" + +#define PG_KEYWORD(a,b,c) {a,b,c}, + + +const ScanKeyword ScanKeywords[] = { +#include "parser/kwlist.h" +}; + +/* End of ScanKeywords, for use elsewhere */ +const ScanKeyword *LastScanKeyword = endof(ScanKeywords); -- 2.40.0