firebird/firebird-mirror
firebird/firebird-mirror
8
0
Fork 1
mirror of https://github.com/FirebirdSQL/firebird.git synced 2025-01-24 12:03:02 +01:00
Code Issues
46ebed9a87
firebird-mirror/src/dudley/parse.cpp
robocop d6535351a2 Misc: style.
2004-11-24 09:22:07 +00:00

4144 lines
107 KiB
C++
Raw Blame History

/*
* PROGRAM: JRD data definition language parser
* MODULE: parse.cpp
* DESCRIPTION: Statement parser
*
* The contents of this file are subject to the Interbase Public
* License Version 1.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy
* of the License at http://www.Inprise.com/IPL.html
*
* Software distributed under the License is distributed on an
* "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express
* or implied. See the License for the specific language governing
* rights and limitations under the License.
*
* The Original Code was created by Inprise Corporation
* and its predecessors. Portions created by Inprise Corporation are
* Copyright (C) Inprise Corporation.
*
* All Rights Reserved.
* Contributor(s): ______________________________________.
*
* 2002.10.30 Sean Leyne - Removed support for obsolete "PC_PLATFORM" define
*
*/
#include "firebird.h"
#include <stdlib.h>
#include <stdio.h> // a single call to sprintf()
#include <string.h>
#include "../jrd/ibase.h"
#include "../jrd/flags.h"
#include "../dudley/ddl.h"
#include "../jrd/acl.h"
#include "../dudley/ddl_proto.h"
#include "../dudley/exe_proto.h"
#include "../dudley/expr_proto.h"
#include "../dudley/hsh_proto.h"
#include "../dudley/lex_proto.h"
#include "../dudley/parse_proto.h"
#include "../jrd/gds_proto.h"
#include "../jrd/isc_f_proto.h"
const char* const PROMPT = "GDEF> ";
const char* const CONTINUATION = "CON> ";
const int GDS_NAME_LEN = 31;
const int MAX_DIMENSION = 16;
#ifdef FLINT_CACHE
const int MIN_CACHE_BUFFERS = 250;
const int DEF_CACHE_BUFFERS = 1000;
#endif
typedef enum {
obj_database,
obj_relation,
obj_view,
obj_field,
obj_index,
obj_security_class,
obj_trigger,
obj_file,
obj_none,
obj_function,
obj_type,
obj_filter,
obj_shadow,
obj_generator
} OBJ_T;
/* this table translates between the two types of types */
static TRG_T trig_table[] = {
trg_type_none,
trg_type_none,
trg_store,
trg_post_store,
trg_modify,
trg_post_modify,
trg_type_none,
trg_type_none,
trg_pre_erase,
trg_erase
};
static bool check_filename(SYM, bool);
static SYM copy_symbol(SYM);
static DUDLEY_FLD create_global_field(DUDLEY_FLD);
#ifdef FLINT_CACHE
static FIL define_cache(void);
#endif
static void define_database(enum act_t);
static void define_field(void);
static FIL define_file(void);
static void define_filter(void);
static void define_function(void);
static void define_generator(void);
static void define_index(void);
//static FIL define_log_file(USHORT);
static void define_old_trigger(void);
static void define_relation(void);
static void define_security_class(void);
static void define_shadow(void);
static void define_trigger(void);
static void define_type(void);
static void define_view(void);
static void drop_filter(void);
static void drop_function(void);
static void drop_gfield(void);
static void drop_index(void);
static void drop_relation(void);
static void drop_security_class(void);
static void drop_shadow(void);
static void drop_trigger(void);
static void drop_type(void);
static void end_text(TXT);
static SYM gen_trigger_name(TRG_T, DUDLEY_REL);
static int get_system_flag(void);
static void get_trigger_attributes(int *, int *, int *);
static void grant_user_privilege(void);
static DUDLEY_CTX lookup_context(SYM, dudley_lls*);
static DUDLEY_FLD lookup_global_field(DUDLEY_FLD);
static ACT make_action(enum act_t, DBB);
static ACT make_computed_field(DUDLEY_FLD);
static DUDLEY_CTX make_context(TEXT *, DUDLEY_REL);
static ACT make_global_field(DUDLEY_FLD);
static void mod_old_trigger(void);
static void modify_field(void);
static void modify_index(void);
static void modify_relation(void);
static void modify_security_class(void);
static void modify_trigger(void);
static void modify_trigger_action(DUDLEY_TRG, DUDLEY_REL);
static void modify_type(void);
static void modify_view(void);
static bool parse_action(void);
static void parse_array(DUDLEY_FLD);
static TXT parse_description(void);
static void parse_end(void);
static DUDLEY_FLD parse_field(DUDLEY_FLD);
static void parse_field_clauses(DUDLEY_FLD);
static void parse_field_dtype(DUDLEY_FLD);
static void parse_field_subtype(DUDLEY_FLD);
static FUNCARG parse_function_arg(FUNC, USHORT *);
static SCE parse_identifier(void);
static OBJ_T parse_object(void);
static int parse_page_size(void);
static SLONG parse_privileges(void);
static void revoke_user_privilege(void);
static SLONG score_entry(SCE);
static DUDLEY_NOD set_generator(void);
static void sort_out_attributes(DUDLEY_TRG, SLONG, SLONG, SLONG);
static TXT start_text(void);
static void validate_field(DUDLEY_FLD);
static dudley_lls* local_context;
void PARSE_actions(void)
{
/**************************************
*
* P A R S E_ a c t i o n s
*
**************************************
*
* Functional description
* Parse actions in a loop until end of file.
*
**************************************/
parse_action();
while (!dudleyGlob.DDL_eof && dudleyGlob.DDL_errors < 20) {
if ((!dudleyGlob.database || !dudleyGlob.database->dbb_handle) && (!dudleyGlob.DDL_drop_database)) {
DDL_err(111, NULL, NULL, NULL, NULL, NULL); /* msg 111: no database declared */
if (dudleyGlob.database) {
gds__free(dudleyGlob.database);
dudleyGlob.database = NULL;
}
if (dudleyGlob.DDL_interactive)
parse_action();
else {
DDL_err(112, NULL, NULL, NULL, NULL, NULL); /* msg 112: ceasing processing */
break;
}
}
else {
dudleyGlob.DDL_drop_database = false;
parse_action();
}
}
}
void PARSE_error( USHORT number, const TEXT* arg1, const TEXT* arg2)
{
/**************************************
*
* P A R S E _ e r r o r
*
**************************************
*
* Functional description
* Generate a syntax error.
*
**************************************/
DDL_err(number, arg1, arg2, NULL, NULL, NULL);
Firebird::status_exception::raise();
}
FUNC PARSE_function(int existingFunction)
{
/**************************************
*
* P A R S E _ f u n c t i o n
*
**************************************
*
* Functional description
* Get the function block associated with the current token. Also
* advance the token. Create a new function requested.
*
**************************************/
if (dudleyGlob.DDL_token.tok_type != tok_ident)
PARSE_error(113, dudleyGlob.DDL_token.tok_string, 0); /* msg 113: expected function, encountered \"%s\" */
SYM symbol = HSH_typed_lookup(dudleyGlob.DDL_token.tok_string, dudleyGlob.DDL_token.tok_length,
SYM_function);
FUNC function;
if (symbol && (function = (FUNC) symbol->sym_object) &&
function->func_database == dudleyGlob.database)
{
LEX_token();
return function;
}
if (existingFunction) {
PARSE_error(114, dudleyGlob.DDL_token.tok_string, 0); /* msg 114: expected function, encountered \"%s\" */
return NULL; // silence uninitialized warning
}
function = (FUNC) DDL_alloc(sizeof(func));
function->func_name = symbol = PARSE_symbol(tok_ident);
symbol->sym_type = SYM_function;
symbol->sym_object = (DUDLEY_CTX) function;
HSH_insert(symbol);
if (!(function->func_database = dudleyGlob.database))
PARSE_error(111, 0, 0); /* msg 111: no database declared */
return function;
}
enum kwwords PARSE_keyword(void)
{
/**************************************
*
* P A R S E _ k e y w o r d
*
**************************************
*
* Functional description
* Get a real token and return the keyword number.
*
**************************************/
LEX_real();
for (SYM symbol = dudleyGlob.DDL_token.tok_symbol; symbol; symbol = symbol->sym_homonym)
if (symbol->sym_type == SYM_keyword)
return (enum kwwords) symbol->sym_keyword;
return KW_none;
}
DUDLEY_NOD PARSE_make_list(dudley_lls* stack)
{
/**************************************
*
* P A R S E _ m a k e _ l i s t
*
**************************************
*
* Functional description
* Dump a stack of junk into a list node. Best count
* them first.
*
**************************************/
dudley_lls* temp = stack;
USHORT count = 0;
while (temp) {
count++;
temp = temp->lls_next;
}
DUDLEY_NOD node = PARSE_make_node(nod_list, count);
while (stack)
node->nod_arg[--count] = LLS_POP(&stack);
return node;
}
DUDLEY_NOD PARSE_make_node(enum nod_t type, USHORT count)
{
/**************************************
*
* P A R S E _ m a k e _ n o d e
*
**************************************
*
* Functional description
* Allocate and initialize a syntax node of given type.
*
**************************************/
DUDLEY_NOD node = (DUDLEY_NOD) DDL_alloc(NOD_LEN(count));
node->nod_type = type;
node->nod_count = count;
return node;
}
bool PARSE_match( enum kwwords keyword)
{
/**************************************
*
* P A R S E _ m a t c h
*
**************************************
*
* Functional description
* Test the current token for a particular keyword. If so, advanced
* the token stream.
*
**************************************/
if (dudleyGlob.DDL_token.tok_keyword == keyword) {
LEX_token();
return true;
}
for (SYM symbol = dudleyGlob.DDL_token.tok_symbol; symbol; symbol = symbol->sym_homonym)
if (symbol->sym_type == SYM_keyword &&
symbol->sym_keyword == (int) keyword)
{
LEX_token();
return true;
}
return false;
}
int PARSE_number(void)
{
/**************************************
*
* P A R S E _ n u m b e r
*
**************************************
*
* Functional description
* Parse the next token as a number and return its value.
*
**************************************/
const bool negate = PARSE_match(KW_MINUS);
if (dudleyGlob.DDL_token.tok_type != tok_number)
PARSE_error(115, dudleyGlob.DDL_token.tok_string, 0); /* msg 115: expected number, encountered \"%s\" */
const int number = atoi(dudleyGlob.DDL_token.tok_string);
LEX_token();
if (negate)
return -number;
return number;
}
DUDLEY_REL PARSE_relation(void)
{
/**************************************
*
* P A R S E _ r e l a t i o n
*
**************************************
*
* Functional description
* Get the relation block associated with the current token.
* If the relatio was defined before, use the old definition.
* If not, create a new one. Somebody else will decide whether
* this one is worth keeping.
*
**************************************/
if (dudleyGlob.DDL_token.tok_type != tok_ident)
PARSE_error(116, dudleyGlob.DDL_token.tok_string, 0); /* msg 116: expected relation name, encountered \"%s\" */
SYM symbol = HSH_typed_lookup(dudleyGlob.DDL_token.tok_string, dudleyGlob.DDL_token.tok_length,
SYM_relation);
DUDLEY_REL relation;
if (symbol && (relation = (DUDLEY_REL) symbol->sym_object) &&
relation->rel_database == dudleyGlob.database)
{
LEX_token();
return relation;
}
relation = (DUDLEY_REL) DDL_alloc(sizeof(dudley_rel));
relation->rel_name = symbol = PARSE_symbol(tok_ident);
symbol->sym_type = SYM_relation;
symbol->sym_object = (DUDLEY_CTX) relation;
if (!(relation->rel_database = dudleyGlob.database))
PARSE_error(111, 0, 0); /* msg 111: no database declared */
relation->rel_next = dudleyGlob.database->dbb_relations;
dudleyGlob.database->dbb_relations = relation;
return relation;
}
SYM PARSE_symbol(enum tok_t type)
{
/**************************************
*
* P A R S E _ s y m b o l
*
**************************************
*
* Functional description
* Swallow the current token as a symbol.
*
**************************************/
if (dudleyGlob.DDL_token.tok_type != type)
switch (type) {
case tok_ident:
PARSE_error(117, dudleyGlob.DDL_token.tok_string, 0); /* msg 117: expected identifier, encountered \"%s\" */
case tok_quoted:
PARSE_error(118, dudleyGlob.DDL_token.tok_string, 0); /* msg 118: expected quoted string, encountered \"%s\" */
default:
PARSE_error(119, dudleyGlob.DDL_token.tok_string, 0); /* msg 119: expected symbol, encountered \"%s\" */
}
USHORT l = dudleyGlob.DDL_token.tok_length;
const TEXT* q = dudleyGlob.DDL_token.tok_string;
if (type == tok_quoted) {
if (l < 2)
PARSE_error(118, dudleyGlob.DDL_token.tok_string, 0); /* msg 118: expected quoted string, encountered \"%s\" */
q++;
l -= 2;
}
SYM symbol = (SYM) DDL_alloc(SYM_LEN + l);
symbol->sym_length = l;
symbol->sym_string = symbol->sym_name;
TEXT* p = symbol->sym_name;
if (l)
if (type == tok_ident)
do {
const TEXT c = *q++;
*p++ = UPPER(c);
} while (--l);
else
do {
*p++ = *q++;
} while (--l);
LEX_token();
return symbol;
}
static bool check_filename(SYM name,
bool decnet_flag)
{
/**************************************
*
* c h e c k _ f i l e n a m e
*
**************************************
*
* Functional description
* Make sure that a file path doesn't contain an
* inet node name.
*
**************************************/
TEXT file_name[256];
USHORT l = name->sym_length;
if (!l)
return true;
l = MIN(l, sizeof(file_name) - 1);
TEXT* pp = file_name;
for (const TEXT* q = name->sym_string; l--; *pp++ = *q++);
*pp = 0;
for (const TEXT* p = file_name; *p; p++)
if (p[0] == ':' && p[1] == ':')
if (!decnet_flag)
return false;
else {
for (p = file_name; *p;)
if (*p++ == '^')
return false;
return true;
}
return (!ISC_check_if_remote(file_name, false));
}
static SYM copy_symbol( SYM old_name)
{
/**************************************
*
* c o p y _ s y m b o l
*
**************************************
*
* Functional description
* Create a new symbol block for
* the same symbol as an existing block.
* This seems dumber than it is, because
* the implicit creation of global fields
* from local definitions depends on it as
* does the implicit invocation of same-named
* global fields.
*
* We'll just leave the type blank for now.
*
**************************************/
SYM new_name = (SYM) DDL_alloc(SYM_LEN + old_name->sym_length);
new_name->sym_length = old_name->sym_length;
new_name->sym_string = new_name->sym_name;
strcpy(new_name->sym_name, old_name->sym_name);
return new_name;
}
static DUDLEY_FLD create_global_field( DUDLEY_FLD local_field)
{
/**************************************
*
* c r e a t e _ g l o b a l _ f i e l d
*
**************************************
*
* Functional description
* Copy a field block so we can
* have separate blocks for global
* and local fields, even when the
* global field is defined implicitly.
*
* This creates a new field and symbol
* block.
*
**************************************/
DUDLEY_FLD global_field = (DUDLEY_FLD) DDL_alloc(sizeof(dudley_fld));
global_field->fld_dtype = local_field->fld_dtype;
global_field->fld_length = local_field->fld_length;
global_field->fld_scale = local_field->fld_scale;
global_field->fld_segment_length = local_field->fld_segment_length;
global_field->fld_sub_type = local_field->fld_sub_type;
global_field->fld_has_sub_type = local_field->fld_has_sub_type;
global_field->fld_dimension = local_field->fld_dimension;
global_field->fld_system = local_field->fld_system;
global_field->fld_database = local_field->fld_database;
global_field->fld_query_name = local_field->fld_query_name;
global_field->fld_query_header = local_field->fld_query_header;
global_field->fld_edit_string = local_field->fld_edit_string;
global_field->fld_computed = local_field->fld_computed;
global_field->fld_missing = local_field->fld_missing;
global_field->fld_default = local_field->fld_default;
global_field->fld_validation = local_field->fld_validation;
global_field->fld_description = local_field->fld_description;
global_field->fld_compute_src = local_field->fld_compute_src;
global_field->fld_valid_src = local_field->fld_valid_src;
global_field->fld_ranges = local_field->fld_ranges;
if (local_field->fld_source)
global_field->fld_name = local_field->fld_source;
else {
SYM old_name = local_field->fld_name;
SYM new_name = copy_symbol(old_name);
global_field->fld_name = new_name;
new_name->sym_type = SYM_global;
new_name->sym_object = (DUDLEY_CTX) global_field;
local_field->fld_source = new_name;
}
global_field->fld_flags = local_field->fld_flags & ~fld_local;
local_field->fld_source_field = global_field;
local_field->fld_flags |= fld_local;
return global_field;
}
#ifdef FLINT_CACHE
static FIL define_cache(void)
{
/**************************************
*
* d e f i n e _ c a c h e
*
**************************************
*
* Functional description
* Add a shared cache to an existing database.
*
**************************************/
FIL file = (FIL) DDL_alloc(sizeof(fil));
file->fil_name = PARSE_symbol(tok_quoted);
if (!check_filename(file->fil_name, false))
PARSE_error(322, 0, 0); /* msg 322: a node name is not permitted in a shared cache file name */
if (PARSE_match(KW_LENGTH)) {
if ((file->fil_length = PARSE_number()) < MIN_CACHE_BUFFERS)
PARSE_error(339, (TEXT *) MIN_CACHE_BUFFERS, 0); /* msg 339: minimum of %d cache pages required */
PARSE_match(KW_PAGES);
}
else
file->fil_length = DEF_CACHE_BUFFERS; /* default cache buffers */
return file;
}
#endif
static void define_database( enum act_t action_type)
{
/**************************************
*
* d e f i n e _ d a t a b a s e
*
**************************************
*
* Functional description
* Parse the tail of a DEFINE, MODIFY, or DELETE DATABASE statement.
*
**************************************/
if (dudleyGlob.database)
DDL_error_abort(0, 120, NULL, NULL, NULL, NULL, NULL);
// msg 120: GDEF processes only one database at a time
dudleyGlob.database = (DBB) DDL_alloc(sizeof(dbb));
dudleyGlob.database->dbb_name = PARSE_symbol(tok_quoted);
dudleyGlob.DB_file_name = dudleyGlob.database->dbb_name->sym_name;
dudleyGlob.database->dbb_grp_cmt_wait = -1; /* Initialized for default value */
/* parse options for the database parameter block */
while (true) {
if (PARSE_match(KW_LENGTH)) {
dudleyGlob.database->dbb_length = PARSE_number();
PARSE_match(KW_PAGES);
}
else if (PARSE_match(KW_USER)) {
SYM symbol = PARSE_symbol(tok_quoted);
dudleyGlob.DDL_default_user = symbol->sym_name;
}
else if (PARSE_match(KW_PASSWORD)) {
SYM symbol = PARSE_symbol(tok_quoted);
dudleyGlob.DDL_default_password = symbol->sym_name;
}
else
break;
}
if (action_type == act_d_database) {
// if (PARSE_match(KW_CASCADE))
// dudleyGlob.database->dbb_flags |= DBB_cascade;
EXE_drop_database(dudleyGlob.database);
dudleyGlob.DDL_drop_database = true;
return;
}
/* parse add/drop items */
while (true) {
PARSE_match(KW_ADD);
if (dudleyGlob.DDL_token.tok_keyword == KW_DESCRIPTION)
dudleyGlob.database->dbb_description = parse_description();
else if (PARSE_match(KW_SECURITY_CLASS))
dudleyGlob.database->dbb_security_class = PARSE_symbol(tok_ident);
else if (PARSE_match(KW_DROP)) {
if (PARSE_match(KW_DESCRIP))
dudleyGlob.database->dbb_flags |= DBB_null_description;
else if (PARSE_match(KW_SECURITY_CLASS))
dudleyGlob.database->dbb_flags |= DBB_null_security_class;
/*
else if (PARSE_match(KW_LOG_FILE)) {
if ((dudleyGlob.database->dbb_flags & DBB_log_default)
|| (dudleyGlob.database->dbb_logfiles))
{
PARSE_error(337, 0, 0);
}
dudleyGlob.database->dbb_flags |= DBB_drop_log;
}
else if (PARSE_match(KW_CASCADE))
dudleyGlob.database->dbb_flags |= DBB_cascade;
#ifdef FLINT_CACHE
else if (PARSE_match(KW_CACHE))
dudleyGlob.database->dbb_flags |= DBB_drop_cache;
#endif // FLINT_CACHE
*/
else
PARSE_error(121, 0, 0);
// msg 121 only SECURITY_CLASS, DESCRIPTION and CACHE can be dropped
}
else if (PARSE_match(KW_FILE)) {
FIL file = define_file();
file->fil_next = dudleyGlob.database->dbb_files;
dudleyGlob.database->dbb_files = file;
}
else if (PARSE_match(KW_PAGE_SIZE)) {
if (action_type == act_m_database)
PARSE_error(122, 0, 0); /* msg 122: PAGE_SIZE can not be modified */
dudleyGlob.database->dbb_page_size = parse_page_size();
}
/*
else if (PARSE_match(KW_CHECK_POINT_LEN)) {
PARSE_match(KW_EQUALS);
dudleyGlob.database->dbb_chkptlen = PARSE_number();
}
else if (PARSE_match(KW_NUM_LOG_BUFS)) {
PARSE_match(KW_EQUALS);
dudleyGlob.database->dbb_numbufs = PARSE_number();
}
else if (PARSE_match(KW_LOG_BUF_SIZE)) {
PARSE_match(KW_EQUALS);
dudleyGlob.database->dbb_bufsize = PARSE_number();
}
else if (PARSE_match(KW_GROUP_COMMIT_WAIT)) {
PARSE_match(KW_EQUALS);
dudleyGlob.database->dbb_grp_cmt_wait = PARSE_number();
}
else if (PARSE_match(KW_LOG_FILE)) {
if ((dudleyGlob.database->dbb_flags & DBB_log_default)
|| (dudleyGlob.database->dbb_logfiles))
{
PARSE_error(338, 0, 0);
}
if (dudleyGlob.database->dbb_flags & DBB_drop_log)
PARSE_error(337, 0, 0);
if (PARSE_match(KW_LEFT_PAREN)) {
dudleyGlob.database->dbb_flags |= DBB_log_preallocated;
while (true) {
FIL file = define_log_file(DBB_log_preallocated);
file->fil_next = dudleyGlob.database->dbb_logfiles;
dudleyGlob.database->dbb_logfiles = file;
if (!PARSE_match(KW_COMMA))
break;
}
if (!PARSE_match(KW_RIGHT_PAREN))
{
PARSE_error(341, dudleyGlob.DDL_token.tok_string, 0);
// msg 341: expected comma or ')', encountered \"%s\"
}
if (PARSE_match(KW_OVERFLOW))
dudleyGlob.database->dbb_overflow = define_log_file(DBB_log_serial);
else
PARSE_error(340, 0, 0);
}
else if (PARSE_match(KW_BASE_NAME)) {
dudleyGlob.database->dbb_flags |= DBB_log_serial;
dudleyGlob.database->dbb_logfiles = define_log_file(DBB_log_serial);
}
else
dudleyGlob.database->dbb_flags |= DBB_log_default;
}
#ifdef FLINT_CACHE
else if (PARSE_match(KW_CACHE))
dudleyGlob.database->dbb_cache_file = define_cache();
#endif // FLINT_CACHE
*/
else
break;
}
parse_end();
if (action_type == act_c_database) {
dudleyGlob.database->dbb_flags |= DBB_create_database;
EXE_create_database(dudleyGlob.database);
}
else {
EXE_modify_database(dudleyGlob.database);
}
make_action(action_type, dudleyGlob.database);
}
static void define_field(void)
{
/**************************************
*
* d e f i n e _ f i e l d
*
**************************************
*
* Functional description
* Parse a DEFINE FIELD statement.
*
**************************************/
DUDLEY_FLD field = (DUDLEY_FLD) DDL_alloc(sizeof(dudley_fld));
parse_field(field);
field->fld_database = dudleyGlob.database;
if (!field->fld_dtype)
PARSE_error(123, 0, 0); /* msg 123: data type required for global field */
if (field->fld_security_class)
PARSE_error(124, 0, 0); /* msg 124: Security class can appear only on local field references */
parse_end();
make_global_field(field);
}
static FIL define_file(void)
{
/**************************************
*
* d e f i n e _ f i l e
*
**************************************
*
* Functional description
* Add a new file to an existing database.
*
**************************************/
FIL file = (FIL) DDL_alloc(sizeof(fil));
file->fil_name = PARSE_symbol(tok_quoted);
if (!check_filename(file->fil_name, false))
PARSE_error(297, 0, 0); /* msg 297: A node name is not permitted in a shadow or secondary file name */
while (true) {
if (PARSE_match(KW_LENGTH)) {
file->fil_length = PARSE_number();
PARSE_match(KW_PAGES);
}
else if (PARSE_match(KW_STARTS)) {
PARSE_match(KW_AT);
PARSE_match(KW_PAGE);
file->fil_start = PARSE_number();
}
else
break;
}
return file;
}
static void define_filter(void)
{
/**************************************
*
* d e f i n e _ f i l t e r
*
**************************************
*
* Functional description
* Parse a DEFINE FILTER statement.
*
**************************************/
if (dudleyGlob.DDL_token.tok_type != tok_ident)
PARSE_error(126, dudleyGlob.DDL_token.tok_string, 0); /* msg 126: expected filter name, encountered \"%s\" */
FILTER new_filter = (FILTER) DDL_alloc(sizeof(filter));
new_filter->filter_name = PARSE_symbol(tok_ident);
while (true) {
if (dudleyGlob.DDL_token.tok_keyword == KW_DESCRIPTION)
new_filter->filter_description = parse_description();
else if (PARSE_match(KW_INPUT_TYPE))
new_filter->filter_input_sub_type = PARSE_number();
else if (PARSE_match(KW_OUTPUT_TYPE))
new_filter->filter_output_sub_type = PARSE_number();
else if (PARSE_match(KW_FUNCTION_MODULE_NAME))
new_filter->filter_module_name = PARSE_symbol(tok_quoted);
else if (PARSE_match(KW_FUNCTION_ENTRY_POINT))
new_filter->filter_entry_point = PARSE_symbol(tok_quoted);
else
break;
}
if (!new_filter->filter_entry_point)
PARSE_error(127, 0, 0); /* msg 127: Filter entry point must be specified */
#if (defined WIN_NT)
if (!new_filter->filter_module_name)
PARSE_error(128, 0, 0); /* msg 128: Filter module name must be specified */
#endif
parse_end();
make_action(act_a_filter, (DBB) new_filter);
}
static void define_function(void)
{
/**************************************
*
* d e f i n e _ f u n c t i o n
*
**************************************
*
* Functional description
* Parse a DEFINE FUNCTION statement.
*
**************************************/
FUNC function = PARSE_function(FALSE);
while (true) {
if (dudleyGlob.DDL_token.tok_keyword == KW_DESCRIPTION)
function->func_description = parse_description();
else if (PARSE_match(KW_FUNCTION_MODULE_NAME))
function->func_module_name = PARSE_symbol(tok_quoted);
else if (PARSE_match(KW_FUNCTION_ENTRY_POINT))
function->func_entry_point = PARSE_symbol(tok_quoted);
else if (PARSE_match(KW_QUERY_NAME))
function->func_query_name = PARSE_symbol(tok_ident);
else
break;
}
if (!function->func_entry_point)
PARSE_error(130, 0, 0); /* msg 130: Function entry point must be specified */
#if (defined WIN_NT)
if (!function->func_module_name)
PARSE_error(131, 0, 0); /* msg 131: Function module name must be specified */
#endif
/* Gobble function arguments */
SSHORT position = 1;
while (true) {
if (dudleyGlob.DDL_token.tok_keyword == KW_SEMI)
break;
FUNCARG function_arg = parse_function_arg(function, (USHORT*) &position);
function_arg->funcarg_funcname = function->func_name;
make_action(act_a_function_arg, (DBB) function_arg);
if (!PARSE_match(KW_COMMA))
break;
}
if (!(dudleyGlob.DDL_token.tok_keyword == KW_SEMI))
PARSE_error(132, dudleyGlob.DDL_token.tok_string, 0); /* msg 132: expected comma or semi-colon, encountered \"%s\" */
make_action(act_a_function, (DBB) function);
}
static void define_generator(void)
{
/**************************************
*
* d e f i n e _ g e n e r a t o r
*
**************************************
*
* Functional description
* Parse a DEFINE GENERATOR statement.
*
**************************************/
if (dudleyGlob.DDL_token.tok_type != tok_ident)
PARSE_error(274, dudleyGlob.DDL_token.tok_string, 0); /* msg 274: expected generator name, encountered \"%s\" */
SYM symbol = PARSE_symbol(tok_ident);
parse_end();
make_action(act_a_generator, (DBB) symbol);
}
static void define_index(void)
{
/**************************************
*
* d e f i n e _ i n d e x
*
**************************************
*
* Functional description
* Define a new index.
*
**************************************/
TXT description = NULL;
bool unique = false;
bool inactive = false;
idx_direction descending = IDX_type_none;
SYM index_name = PARSE_symbol(tok_ident);
PARSE_match(KW_FOR);
SYM rel_name = PARSE_symbol(tok_ident);
while (true) {
if (PARSE_match(KW_DUPLICATES))
unique = false;
else if (PARSE_match(KW_UNIQUE))
unique = true;
else if (dudleyGlob.DDL_token.tok_keyword == KW_DESCRIPTION)
description = parse_description();
else if (PARSE_match(KW_ACTIVE))
inactive = false;
else if (PARSE_match(KW_INACTIVE))
inactive = true;
else if (PARSE_match(KW_ASCENDING))
descending = IDX_type_none;
else if (PARSE_match(KW_DESCENDING))
descending = IDX_type_descend;
else
break;
}
SSHORT count = 0;
dudley_lls* stack = NULL;
while (true) {
LLS_PUSH((DUDLEY_NOD) PARSE_symbol(tok_ident), &stack);
count++;
if (!PARSE_match(KW_COMMA))
break;
}
if (!(dudleyGlob.DDL_token.tok_keyword == KW_SEMI))
PARSE_error(135, dudleyGlob.DDL_token.tok_string, 0);
// msg 135: expected comma or semi-colon, encountered \"%s\"
DUDLEY_IDX index = (DUDLEY_IDX) DDL_alloc(IDX_LEN(count == 0 ? 1 : count));
index->idx_count = count;
index->idx_name = index_name;
index->idx_relation = rel_name;
index->idx_unique = unique;
index->idx_description = description;
index->idx_inactive = inactive;
index->idx_type = descending;
while (stack)
index->idx_field[--count] = (SYM) LLS_POP(&stack);
make_action(act_a_index, (DBB) index);
}
/*
static FIL define_log_file( USHORT log_type)
{
// **************************************
// *
// * d e f i n e _ l o g _ f i l e
// *
// **************************************
// *
// * Functional description
// * define a log file
// *
// **************************************
FIL file = (FIL) DDL_alloc(sizeof(fil));
file->fil_name = PARSE_symbol(tok_quoted);
if (!check_filename(file->fil_name, false))
PARSE_error(297, 0, 0);
// msg 297: A node name is not permitted in a shadow or secondary file name
while (true) {
if (PARSE_match(KW_SIZE)) {
PARSE_match(KW_EQUALS);
file->fil_length = PARSE_number();
}
else if (PARSE_match(KW_RAW_PARTITIONS)) {
if (log_type != DBB_log_preallocated)
PARSE_error(332, 0, 0);
// msg 332: Partitions not supported in series of log file specification
PARSE_match(KW_EQUALS);
file->fil_partitions = PARSE_number();
file->fil_raw = LOG_raw;
}
else
break;
}
// Check for the specified length of the log file
if (file->fil_partitions) {
if (!file->fil_length)
PARSE_error(335, file->fil_name->sym_string, 0);
// msg 335: Total length of the partitioned log <logname> must be specified
}
return file;
}
*/
static void define_old_trigger(void)
{
/**************************************
*
* d e f i n e _ o l d _ t r i g g e r
*
**************************************
*
* Functional description
* Parse old style trigger definition
*
**************************************/
SYM name = NULL;
DUDLEY_TRG trigger = NULL;
DUDLEY_REL relation = PARSE_relation();
while (!PARSE_match(KW_END_TRIGGER)) {
trigger = (DUDLEY_TRG) DDL_alloc(sizeof(dudley_trg));
trigger->trg_relation = relation;
if (PARSE_match(KW_STORE))
trigger->trg_type = trg_store;
else if (PARSE_match(KW_MODIFY))
trigger->trg_type = trg_modify;
else if (PARSE_match(KW_ERASE))
trigger->trg_type = trg_erase;
else
PARSE_error(136, dudleyGlob.DDL_token.tok_string, 0);
// msg 136: expected STORE, MODIFY, ERASE, END_TRIGGER, encountered \"%s\"
PARSE_match(KW_COLON);
name = gen_trigger_name(trigger->trg_type, relation);
trigger->trg_name = name;
trigger->trg_source = start_text();
trigger->trg_statement = EXPR_statement();
end_text(trigger->trg_source);
make_action(act_a_trigger, (DBB) trigger);
}
parse_end();
if (trigger) {
name->sym_type = SYM_trigger;
name->sym_object = (DUDLEY_CTX) trigger;
HSH_insert(name);
}
}
static void define_relation(void)
{
/**************************************
*
* d e f i n e _ r e l a t i o n
*
**************************************
*
* Functional description
* Parse a DEFINE RELATION statement.
*
**************************************/
DUDLEY_REL relation = PARSE_relation();
if (!(relation->rel_flags & rel_marked_for_delete) &&
((relation->rel_flags & rel_marked_for_creation)
|| EXE_relation(relation)))
{
PARSE_error(137, relation->rel_name->sym_string, 0);
// msg 137: relation %s already exists
}
if (PARSE_match(KW_EXTERNAL_FILE)) {
relation->rel_filename = PARSE_symbol(tok_quoted);
if (!check_filename(relation->rel_filename, true))
PARSE_error(298, 0, 0);
// msg 298: A non-Decnet node name is not permitted in an external file name
}
ACT action = make_action(act_a_relation, (DBB) relation);
ACT rel_actions = action;
action->act_flags |= ACT_ignore;
SSHORT position = 1;
while (true)
if (dudleyGlob.DDL_token.tok_keyword == KW_DESCRIPTION)
relation->rel_description = parse_description();
else if (PARSE_match(KW_SECURITY_CLASS))
relation->rel_security_class = PARSE_symbol(tok_ident);
else if (PARSE_match(KW_SYSTEM_FLAG)) {
relation->rel_system = get_system_flag();
relation->rel_flags |= rel_explicit_system;
}
else
break;
/* Gobble fields */
DUDLEY_FLD global;
while (true) {
PARSE_match(KW_ADD);
PARSE_match(KW_FIELD);
DUDLEY_FLD field = (DUDLEY_FLD) DDL_alloc(sizeof(dudley_fld));
parse_field(field);
field->fld_relation = relation;
field->fld_database = dudleyGlob.database;
if (field->fld_computed)
make_computed_field(field);
else if (!(field->fld_flags & fld_local))
make_global_field(create_global_field(field));
else if (global = lookup_global_field(field)) {
field->fld_dtype = global->fld_dtype;
field->fld_length = global->fld_length;
field->fld_scale = global->fld_scale;
field->fld_segment_length = global->fld_segment_length;
field->fld_sub_type = global->fld_sub_type;
field->fld_has_sub_type = global->fld_has_sub_type;
}
if (field->fld_flags & fld_explicit_position)
position = field->fld_position + 1;
else
field->fld_position = position++;
field->fld_flags |= fld_explicit_position;
field->fld_name->sym_type = SYM_field;
HSH_insert(field->fld_name);
action = make_action(act_a_field, (DBB) field);
action->act_flags |= ACT_ignore;
if (!PARSE_match(KW_COMMA))
break;
}
if (!(dudleyGlob.DDL_token.tok_keyword == KW_SEMI))
PARSE_error(138, dudleyGlob.DDL_token.tok_string, 0);
// msg 138: expected comma or semi-colon, encountered \"%s\"
// We started off by assuming that the relation and field actions that
// have been defined would have to be ignored. Everything has gone well so
// turn them on.
while (true) {
action->act_flags &= ~ACT_ignore;
if (action == rel_actions)
break;
action = action->act_next;
}
HSH_insert(relation->rel_name);
relation->rel_flags &= ~rel_marked_for_delete;
relation->rel_flags |= rel_marked_for_creation;
}
static void define_security_class(void)
{
/**************************************
*
* d e f i n e _ s e c u r i t y _ c l a s s
*
**************************************
*
* Functional description
* Parse an access control list.
*
**************************************/
SCL sec_class = (SCL) DDL_alloc(sizeof(scl));
sec_class->scl_name = PARSE_symbol(tok_ident);
if (dudleyGlob.DDL_token.tok_keyword == KW_DESCRIPTION)
sec_class->scl_description = parse_description();
/* Pick up entries. Use the users's order */
while (true) {
SCE element = parse_identifier();
if (!element)
return;
SCE* next;
for (next = &sec_class->scl_entries; *next; next = &(*next)->sce_next);
*next = element;
element->sce_privileges = parse_privileges();
if (!PARSE_match(KW_COMMA))
break;
}
parse_end();
make_action(act_a_security, (DBB) sec_class);
}
static void define_shadow(void)
{
/**************************************
*
* d e f i n e _ s h a d o w
*
**************************************
*
* Functional description
* Define a shadow file to the database.
* Parse it as a set of normal file additions,
* setting the shadow number on all files.
*
**************************************/
FIL shadow = (FIL) DDL_alloc(sizeof(fil));
/* get the shadow number, defaulting to 1 */
int number;
if (dudleyGlob.DDL_token.tok_type != tok_number)
number = 1;
else {
number = PARSE_number();
if (number < 1)
PARSE_error(139, 0, 0); /* msg 139: shadow number must be a positive integer */
}
/* match the keywords MANUAL or AUTO to imply whether the shadow
should be automatically deleted when something goes awry */
if (PARSE_match(KW_MANUAL))
shadow->fil_manual = 1;
else
PARSE_match(KW_AUTO);
if (PARSE_match(KW_CONDITIONAL))
shadow->fil_conditional = 1;
shadow->fil_name = PARSE_symbol(tok_quoted);
if (!check_filename(shadow->fil_name, false))
PARSE_error(297, 0, 0);
// msg 297: A node name is not permitted in a shadow or secondary file name
if (PARSE_match(KW_LENGTH)) {
shadow->fil_length = PARSE_number();
PARSE_match(KW_PAGES);
}
while (true) {
if (PARSE_match(KW_FILE)) {
FIL file = define_file();
file->fil_next = shadow;
shadow = file;
}
else
break;
}
parse_end();
for (FIL file = shadow; file; file = file->fil_next)
file->fil_shadow_number = number;
make_action(act_a_shadow, (DBB) shadow);
}
static void define_trigger(void)
{
/**************************************
*
* d e f i n e _ t r i g g e r
*
**************************************
*
* Functional description
* Parse new trigger definition
* syntax, being a little loose about
* what comes when.
*
**************************************/
if (PARSE_match(KW_FOR)) {
define_old_trigger();
return;
}
DUDLEY_TRG trigger = (DUDLEY_TRG) DDL_alloc(sizeof(dudley_trg));
trigger->trg_name = PARSE_symbol(tok_ident);
PARSE_match(KW_FOR);
trigger->trg_relation = PARSE_relation();
int flags = 0, trg_state = 0, trg_sequence = 0;
get_trigger_attributes(&flags, &trg_state, &trg_sequence);
trigger->trg_type = trig_table[trg_state & ~trig_inact];
trigger->trg_inactive = (trg_state & trig_inact);
trigger->trg_sequence = trg_sequence;
if (!(int) trigger->trg_type) /* still none */
PARSE_error(141, dudleyGlob.DDL_token.tok_string, 0);
/* msg 141: expected STORE, MODIFY, ERASE, encountered \"%s\" */
bool action = false;
bool end = false;
while (!(dudleyGlob.DDL_token.tok_keyword == KW_SEMI)) {
if (dudleyGlob.DDL_token.tok_keyword == KW_DESCRIPTION)
trigger->trg_description = parse_description();
else if (PARSE_match(KW_END_TRIGGER))
action = end = true;
else if (!action) {
trigger->trg_source = start_text();
trigger->trg_statement = EXPR_statement();
end_text(trigger->trg_source);
action = true;
}
else if (PARSE_match(KW_MESSAGE)) {
TRGMSG trigmsg = (TRGMSG) DDL_alloc(sizeof(trgmsg));
trigmsg->trgmsg_trg_name = trigger->trg_name;
trigmsg->trgmsg_number = PARSE_number();
if (trigmsg->trgmsg_number > 255)
PARSE_error(142, (TEXT *)(IPTR)(trigmsg->trgmsg_number), 0);
/* msg 142: message number %d exceeds 255 */
PARSE_match(KW_COLON);
trigmsg->trgmsg_text = PARSE_symbol(tok_quoted);
make_action(act_a_trigger_msg, (DBB) trigmsg);
PARSE_match(KW_COMMA);
}
else {
/* if none of the other cases were true, we must be stuck on a bum token */
if (end)
PARSE_error(304, dudleyGlob.DDL_token.tok_string, 0);
/* msg 304: expected message keyword, encountered \"%s\" */
else if (!action)
PARSE_error(305, dudleyGlob.DDL_token.tok_string, 0);
/* msg 305: expected trigger action, encountered \"%s\" */
else
PARSE_error(306, dudleyGlob.DDL_token.tok_string, 0);
/* msg 306: expected end_trigger or description keyword, encountered \"%s\" */
break;
}
}
parse_end();
make_action(act_a_trigger, (DBB) trigger);
trigger->trg_name->sym_type = SYM_trigger;
trigger->trg_name->sym_object = (DUDLEY_CTX) trigger;
HSH_insert(trigger->trg_name);
}
static void define_type(void)
{
/**************************************
*
* d e f i n e _ t y p e
*
**************************************
*
* Functional description
* Parse a type for a field.
*
**************************************/
PARSE_match(KW_FOR);
SYM fldname = PARSE_symbol(tok_ident);
while (true) {
TYP fldtype = (TYP) DDL_alloc(sizeof(typ));
fldtype->typ_field_name = fldname;
fldtype->typ_name = PARSE_symbol(tok_ident);
PARSE_match(KW_COLON);
fldtype->typ_type = PARSE_number();
if (dudleyGlob.DDL_token.tok_keyword == KW_DESCRIPTION)
fldtype->typ_description = parse_description();
make_action(act_a_type, (DBB) fldtype);
if (!PARSE_match(KW_COMMA))
break;
}
parse_end();
}
static void define_view(void)
{
/**************************************
*
* d e f i n e _ v i e w
*
**************************************
*
* Functional description
* Parse a DEFINE VIEW statement.
*
**************************************/
/* Pick up relation name */
DUDLEY_REL relation = PARSE_relation();
if (!(relation->rel_flags & rel_marked_for_delete) &&
((relation->rel_flags & rel_marked_for_creation)
|| EXE_relation(relation)))
{
PARSE_error(300, relation->rel_name->sym_string, 0);
// msg 300: relation %s already exists
}
PARSE_match(KW_OF);
/* Parse record selection expression */
dudley_lls* contexts = NULL;
relation->rel_view_source = start_text();
relation->rel_rse = EXPR_rse(true);
end_text(relation->rel_view_source);
/* add my context to the context stack */
contexts = (dudley_lls*) relation->rel_rse->nod_arg[s_rse_contexts];
DUDLEY_CTX my_context = make_context(0, relation);
LLS_PUSH((DUDLEY_NOD) my_context, &contexts);
relation->rel_rse->nod_arg[s_rse_contexts] = (DUDLEY_NOD) contexts;
ACT action = make_action(act_a_relation, (DBB) relation);
ACT rel_actions = action;
action->act_flags |= ACT_ignore;
/* Pick up various fields and clauses */
while (true) {
if (dudleyGlob.DDL_token.tok_keyword == KW_DESCRIPTION)
relation->rel_description = parse_description();
else if (PARSE_match(KW_SECURITY_CLASS))
relation->rel_security_class = PARSE_symbol(tok_ident);
else if (PARSE_match(KW_SYSTEM_FLAG)) {
relation->rel_system = get_system_flag();
relation->rel_flags |= rel_explicit_system;
}
else
break;
}
/* Gobble fields */
SSHORT position = 1;
DUDLEY_FLD* ptr = &relation->rel_fields;
while (true) {
PARSE_match(KW_ADD);
PARSE_match(KW_FIELD);
DUDLEY_FLD field = (DUDLEY_FLD) DDL_alloc(sizeof(dudley_fld));
field->fld_flags |= fld_local;
field->fld_relation = relation;
*ptr = field;
ptr = &field->fld_next;
SYM symbol = PARSE_symbol(tok_ident);
field->fld_name = symbol;
DUDLEY_CTX context = lookup_context(symbol, contexts);
if (context) {
if (!PARSE_match(KW_DOT))
PARSE_error(144, dudleyGlob.DDL_token.tok_string, 0); /* msg 144: expected period, encountered \"%s\" */
field->fld_name = field->fld_base = PARSE_symbol(tok_ident);
}
else {
if (PARSE_match(KW_FROM)) {
symbol = PARSE_symbol(tok_ident);
if (!(context = lookup_context(symbol, contexts)))
PARSE_error(145, dudleyGlob.DDL_token.tok_string, 0);
/* msg 145: expected qualified field name, encountered \"%s\" */
if (!PARSE_match(KW_DOT))
PARSE_error(146, dudleyGlob.DDL_token.tok_string, 0);
/* msg 146: expected period, encountered \"%s\" */
field->fld_base = PARSE_symbol(tok_ident);
}
else {
parse_field_dtype(field);
if (field->fld_dtype == blr_cstring)
PARSE_error(147, 0, 0); /* msg 147: datatype cstring not supported for fields */
if (PARSE_match(KW_COMPUTED)) {
PARSE_match(KW_BY);
if (!(PARSE_match(KW_LEFT_PAREN)))
PARSE_error(148, 0, 0); /* msg 148: computed by expression must be parenthesized */
field->fld_compute_src = start_text();
field->fld_computed = EXPR_value(0, NULL);
end_text(field->fld_compute_src);
if (!(PARSE_match(KW_RIGHT_PAREN)))
PARSE_error(149, 0, 0); /* msg 149: unmatched parenthesis */
context = my_context;
}
else
PARSE_error(150, dudleyGlob.DDL_token.tok_string, 0);
/* msg 150: expected FROM, COMPUTED, or qualified field, encountered \"%s\" */
}
}
field->fld_context = context;
parse_field_clauses(field);
if (field->fld_computed)
make_computed_field(field);
if (field->fld_flags & fld_explicit_position)
position = field->fld_position + 1;
else
field->fld_position = position++;
field->fld_flags |= fld_explicit_position;
field->fld_name->sym_type = SYM_field;
field->fld_name->sym_object = (DUDLEY_CTX) field;
HSH_insert(field->fld_name);
if (!PARSE_match(KW_COMMA))
break;
}
parse_end();
/* We started off by assuming that the relation and field actions that
have been defined would have to be ignored. Everything has gone well so
turn them on. */
while (true) {
action->act_flags &= ~ACT_ignore;
if (action == rel_actions)
break;
action = action->act_next;
}
HSH_insert(relation->rel_name);
relation->rel_flags &= ~rel_marked_for_delete;
relation->rel_flags |= rel_marked_for_creation;
}
static void drop_filter(void)
{
/**************************************
*
* d r o p _ f i l t e r
*
**************************************
*
* Functional description
* Parse the DROP (DELETE) filter statement.
*
**************************************/
FILTER filter_to_drop = (FILTER) DDL_alloc(sizeof(filter));
filter_to_drop->filter_name = PARSE_symbol(tok_ident);
parse_end();
make_action(act_d_filter, (DBB) filter_to_drop);
}
static void drop_function(void)
{
/**************************************
*
* d r o p _ f u n c t i o n
*
**************************************
*
* Functional description
* Parse the DROP (DELETE) function statement.
*
**************************************/
FUNC function = (FUNC) DDL_alloc(sizeof(func));
function->func_name = PARSE_symbol(tok_ident);
parse_end();
make_action(act_d_function, (DBB) function);
}
static void drop_gfield(void)
{
/**************************************
*
* d r o p _ g f i e l d
*
**************************************
*
* Functional description
* Parse the DROP (DELETE) field statement.
*
**************************************/
DUDLEY_FLD field = (DUDLEY_FLD) DDL_alloc(sizeof(dudley_fld));
field->fld_name = PARSE_symbol(tok_ident);
parse_end();
make_action(act_d_gfield, (DBB) field);
}
static void drop_index(void)
{
/**************************************
*
* d r o p _ i n d e x
*
**************************************
*
* Functional description
* Parse DROP INDEX statement.
*
**************************************/
DUDLEY_IDX index = (DUDLEY_IDX) DDL_alloc(IDX_LEN(1)); // 0 is invalid
index->idx_name = PARSE_symbol(tok_ident);
parse_end();
make_action(act_d_index, (DBB) index);
}
static void drop_relation(void)
{
/**************************************
*
* d r o p _ r e l a t i o n
*
**************************************
*
* Functional description
* Parse DROP RELATION statement.
*
**************************************/
DUDLEY_REL relation = PARSE_relation();
parse_end();
if (relation->rel_flags & rel_marked_for_creation)
PARSE_error(303, 0, 0); /* msg 303: A relation or view may not be defined and then deleted in a single execution of GDEF */
relation->rel_flags |= rel_marked_for_delete;
make_action(act_d_relation, (DBB) relation);
}
static void drop_security_class(void)
{
/**************************************
*
* d r o p _ s e c u r i t y _ c l a s s
*
**************************************
*
* Functional description
* Parse DROP SECURITY_CLASS statement.
*
**************************************/
SCL sec_class = (SCL) DDL_alloc(sizeof(scl));
sec_class->scl_name = PARSE_symbol(tok_ident);
parse_end();
make_action(act_d_security, (DBB) sec_class);
}
static void drop_shadow(void)
{
/**************************************
*
* d r o p _ s h a d o w
*
**************************************
*
* Functional description
* Parse DROP SHADOW statement.
*
**************************************/
const int number = PARSE_number();
parse_end();
make_action(act_d_shadow, (DBB)(IPTR) number);
}
static void drop_trigger(void)
{
/**************************************
*
* d r o p _ t r i g g e r
*
**************************************
*
* Functional description
* Parse trigger deletion
* (old and new trigger syntax).
*
**************************************/
if (PARSE_match(KW_FOR)) {
DUDLEY_REL relation = PARSE_relation();
while (!PARSE_match(KW_END_TRIGGER)) {
DUDLEY_TRG trigger = (DUDLEY_TRG) DDL_alloc(sizeof(dudley_trg));
if (PARSE_match(KW_STORE))
trigger->trg_type = trg_store;
else if (PARSE_match(KW_MODIFY))
trigger->trg_type = trg_modify;
else if (PARSE_match(KW_ERASE))
trigger->trg_type = trg_erase;
else
PARSE_error(153, dudleyGlob.DDL_token.tok_string, 0);
/* msg 153: "expected STORE, MODIFY, ERASE, or END_TRIGGER, encountered \"%s\" */
trigger->trg_name = gen_trigger_name(trigger->trg_type, relation);
trigger->trg_relation = relation;
make_action(act_d_trigger, (DBB) trigger);
}
}
else {
DUDLEY_TRG trigger = (DUDLEY_TRG) DDL_alloc(sizeof(dudley_trg));
trigger->trg_name = PARSE_symbol(tok_ident);
make_action(act_d_trigger, (DBB) trigger);
}
parse_end();
}
static void drop_type(void)
{
/**************************************
*
* d r o p _ t y p e
*
**************************************
*
* Functional description
* Parse the DROP (DELETE) type statement.
*
**************************************/
PARSE_match(KW_FOR);
if (PARSE_match(KW_ALL)) {
TYP fldtype = (TYP) DDL_alloc(sizeof(typ));
fldtype->typ_field_name = PARSE_symbol(tok_ident);
fldtype->typ_name->sym_length = 3;
//strncpy(fldtype->typ_name->sym_string, "ALL", 3);
// Bug: writing in null pointer?
fldtype->typ_name->sym_string = "ALL";
make_action(act_d_type, (DBB) fldtype);
}
else {
SYM fldname = PARSE_symbol(tok_ident);
while (true) {
TYP fldtype = (TYP) DDL_alloc(sizeof(typ));
fldtype->typ_field_name = fldname;
fldtype->typ_name = PARSE_symbol(tok_ident);
make_action(act_d_type, (DBB) fldtype);
if (!PARSE_match(KW_COMMA))
break;
}
}
parse_end();
}
static void end_text( TXT text)
{
/**************************************
*
* e n d _ t e x t
*
**************************************
*
* Functional description
* Mark end of a text description.
*
**************************************/
text->txt_length =
dudleyGlob.DDL_token.tok_position - dudleyGlob.DDL_token.tok_length - text->txt_position;
#if (defined WIN_NT)
/* the length of the text field should subtract out the
line feeds, since they are automatically filtered out
when reading from a file */
text->txt_length -= (dudleyGlob.DDL_line - text->txt_start_line);
#endif
}
static SYM gen_trigger_name( TRG_T type, DUDLEY_REL relation)
{
/**************************************
*
* g e n _ t r i g g e r _ n a m e
*
**************************************
*
* Functional description
* Generate a trigger name for an old style trigger.
*
**************************************/
SYM symbol = (SYM) DDL_alloc(SYM_LEN + GDS_NAME_LEN);
symbol->sym_string = symbol->sym_name;
TEXT* p = symbol->sym_name;
const TEXT* const end = p + GDS_NAME_LEN;
/* Start by copying relation name */
const TEXT* q = relation->rel_name->sym_string;
while (*q && p < end)
*p++ = *q++;
switch (type) {
case trg_store:
q = "$STORE";
break;
case trg_modify:
q = "$MODIFY";
break;
case trg_erase:
q = "$ERASE";
break;
default:
DDL_err(156, NULL, NULL, NULL, NULL, NULL); /* msg 156: gen_trigger_name: invalid trigger type */
}
while (*q && p < end)
*p++ = *q++;
*p = 0;
symbol->sym_length = p - symbol->sym_string;
return symbol;
}
static int get_system_flag(void)
{
/**************************************
*
* g e t _ s y s t e m _ f l a g
*
**************************************
*
* Functional description
* Return the (signed) numeric system flag value.
*
**************************************/
const SSHORT number = PARSE_number();
if (number == 1)
PARSE_error(157, 0, 0); /* msg 157: System flag value of 1 is reserved for system relations */
return number;
}
static void get_trigger_attributes( int *flags, int *type, int *sequence)
{
/**************************************
*
* g e t _ t r i g g e r _ a t t r i b u t e s
*
**************************************
*
* Functional description
*
* trigger attributes include [[PRE | POST]
* {STORE | MODIFY | ERASE } [SEQUENCE]].
* All are optional on a new style modify,
* PRE and POST are optional in new style definitions.
* For STORE & MODIFY PRE is the default.
* For ERASE, POST is the default.
*
**************************************/
if (PARSE_match(KW_INACTIVE)) {
*flags |= trg_mflag_onoff;
*type |= trig_inact;
}
else if (PARSE_match(KW_ACTIVE))
*flags |= trg_mflag_onoff;
*flags |= trg_mflag_order;
if (PARSE_match(KW_PRE_STORE))
*type |= trig_sto;
else if (PARSE_match(KW_PRE_MODIFY))
*type |= trig_mod;
else if (PARSE_match(KW_PRE_ERASE))
*type |= trig_era;
else if (!(PARSE_match(KW_PRE))) {
*type |= trig_post;
if (PARSE_match(KW_POST_STORE))
*type |= trig_sto;
else if (PARSE_match(KW_POST_MODIFY))
*type |= trig_mod;
else if (PARSE_match(KW_POST_ERASE))
*type |= trig_era;
else if (!(PARSE_match(KW_POST))) {
*type &= ~trig_post;
*flags &= ~trg_mflag_order;
}
}
if (!(*type & ~(trig_inact | trig_post))) {
if (PARSE_match(KW_STORE))
*type |= trig_sto;
else if (PARSE_match(KW_MODIFY))
*type |= trig_mod;
else if (PARSE_match(KW_ERASE)) {
*type |= trig_era;
if (!(*flags & trg_mflag_order))
*type |= trig_post;
}
}
if ((!PARSE_match(KW_COLON)) && ((*flags & trg_mflag_order) ||
(*type & (trig_sto | trig_mod | trig_era))))
{
*sequence = PARSE_number();
*flags |= trg_mflag_seqnum;
PARSE_match(KW_COLON);
}
if ((*type & ~trig_inact) || (*flags & trg_mflag_order))
*flags |= trg_mflag_type;
}
static void grant_user_privilege(void)
{
/**************************************
*
* g r a n t _ u s e r _ p r i v i l e g e
*
**************************************
*
* Functional description
* Parse a SQL grant statement.
*
**************************************/
USERPRIV upriv = (USERPRIV) DDL_alloc(sizeof(userpriv));
upriv->userpriv_flags = 0;
while (true) {
/* ALL is translated to mean four individual privileges */
if (PARSE_match(KW_ALL)) {
/* optional keyword following ALL */
PARSE_match(KW_PRIVILEGES);
upriv->userpriv_flags |= USERPRIV_select;
upriv->userpriv_flags |= USERPRIV_delete;
upriv->userpriv_flags |= USERPRIV_insert;
upriv->userpriv_flags |= USERPRIV_update;
if (!PARSE_match(KW_ON))
PARSE_error(159, dudleyGlob.DDL_token.tok_string, 0); /* msg 159: expected ON, encountered \"%s\" */
break;
}
else if (PARSE_match(KW_SELECT))
upriv->userpriv_flags |= USERPRIV_select;
else if (PARSE_match(KW_DELETE))
upriv->userpriv_flags |= USERPRIV_delete;
else if (PARSE_match(KW_INSERT))
upriv->userpriv_flags |= USERPRIV_insert;
else if (PARSE_match(KW_UPDATE)) {
/* look for a field list for the update privilege */
upriv->userpriv_flags |= USERPRIV_update;
if (PARSE_match(KW_ON))
break;
if (PARSE_match(KW_COMMA))
continue;
if (!PARSE_match(KW_LEFT_PAREN))
PARSE_error(313, dudleyGlob.DDL_token.tok_string, 0); /* msg 313: expected ON or '(', encountered "%s" */
do {
if (dudleyGlob.DDL_token.tok_keyword == KW_SELECT
|| dudleyGlob.DDL_token.tok_keyword == KW_INSERT
|| dudleyGlob.DDL_token.tok_keyword == KW_DELETE
|| dudleyGlob.DDL_token.tok_keyword == KW_UPDATE)
{
break;
}
UPFE upf = (UPFE) DDL_alloc(sizeof(upfe));
upf->upfe_fldname = PARSE_symbol(tok_ident);
upf->upfe_next = upriv->userpriv_upflist;
upriv->userpriv_upflist = upf;
} while (PARSE_match(KW_COMMA));
if (!PARSE_match(KW_RIGHT_PAREN))
PARSE_error(314, dudleyGlob.DDL_token.tok_string, 0); /* msg 314: expected ')', encountered "%s" */
continue;
}
if (!PARSE_match(KW_COMMA)) {
if (!PARSE_match(KW_ON))
PARSE_error(159, dudleyGlob.DDL_token.tok_string, 0); /* msg 159: expected ON, encountered \"%s\" */
break;
}
}
if (!upriv->userpriv_flags)
PARSE_error(160, 0, 0); /* msg 160: GRANT privilege was not specified */
upriv->userpriv_relation = PARSE_symbol(tok_ident);
if (!PARSE_match(KW_TO))
PARSE_error(161, dudleyGlob.DDL_token.tok_string, 0); /* msg 161: expected TO, encountered "%s" */
/* get the userlist */
while (true) {
USRE usr = (USRE) DDL_alloc(sizeof(usre));
usr->usre_name = PARSE_symbol(tok_ident);
usr->usre_next = upriv->userpriv_userlist;
upriv->userpriv_userlist = usr;
if (!PARSE_match(KW_COMMA))
break;
}
/* check for the optional WITH GRANT OPTION specification */
if (PARSE_match(KW_WITH)) {
if (!PARSE_match(KW_GRANT))
PARSE_error(162, dudleyGlob.DDL_token.tok_string, 0); /* msg 162:expected GRANT, encountered \"%s\" */
if (!PARSE_match(KW_OPTION))
PARSE_error(163, dudleyGlob.DDL_token.tok_string, 0); /* msg 163: expected OPTION, encountered \"%s\" */
upriv->userpriv_flags |= USERPRIV_grant;
}
parse_end();
make_action(act_grant, (DBB) upriv);
}
static DUDLEY_CTX lookup_context( SYM symbol, dudley_lls* contexts)
{
/**************************************
*
* l o o k u p _ c o n t e x t
*
**************************************
*
* Functional description
* Search the context stack. If a context name is given, consider
* only named contexts; otherwise return the first unnamed context.
* In either case, if nothing matches, return NULL.
*
**************************************/
/* If no name is given, look for a nameless one. */
if (!symbol) {
for (; contexts; contexts = contexts->lls_next) {
DUDLEY_CTX context = (DUDLEY_CTX) contexts->lls_object;
if (!context->ctx_name && !context->ctx_view_rse)
return context;
}
return NULL;
}
/* Other search by name */
for (; contexts; contexts = contexts->lls_next) {
DUDLEY_CTX context = (DUDLEY_CTX) contexts->lls_object;
SYM name = context->ctx_name;
if (name && !strcmp(name->sym_string, symbol->sym_string))
return context;
}
return NULL;
}
static DUDLEY_FLD lookup_global_field( DUDLEY_FLD field)
{
/**************************************
*
* l o o k u p _ g l o b a l _ f i e l d
*
**************************************
*
* Functional description
*
**************************************/
/* Find symbol */
SYM name = (field->fld_source) ? field->fld_source : field->fld_name;
SYM symbol = HSH_typed_lookup(name->sym_string, name->sym_length,
SYM_global);
if (symbol)
return (DUDLEY_FLD) symbol->sym_object;
PARSE_error(230, name->sym_string, 0); /* msg 230: global field %s isn't defined */
return NULL;
}
static ACT make_action( enum act_t type, DBB object)
{
/**************************************
*
* m a k e _ a c t i o n
*
**************************************
*
* Functional description
* Allocate and link an action block.
*
**************************************/
ACT action = (ACT) DDL_alloc(sizeof(act));
action->act_type = type;
action->act_next = dudleyGlob.DDL_actions;
action->act_object = object;
action->act_line = dudleyGlob.DDL_line;
dudleyGlob.DDL_actions = action;
return action;
}
static ACT make_computed_field( DUDLEY_FLD field)
{
/**************************************
*
* m a k e _ c o m p u t e d _ f i e l d
*
**************************************
*
* Functional description
*
**************************************/
TEXT s[64];
/* Start by generating a unique name */
USHORT l;
for (USHORT i = 1;; i++) {
sprintf(s, "RDB$%d", i);
l = strlen(s);
if (!HSH_lookup(s, l))
break;
}
/* Make up new symbol block */
SYM symbol = (SYM) DDL_alloc(SYM_LEN + l);
field->fld_source = symbol;
symbol->sym_type = SYM_global;
symbol->sym_length = l;
symbol->sym_string = symbol->sym_name;
strcpy(symbol->sym_name, s);
DUDLEY_FLD computed = create_global_field(field);
field->fld_source_field = computed;
symbol->sym_object = (DUDLEY_CTX) computed;
return make_global_field(computed);
}
static DUDLEY_CTX make_context( TEXT * string, DUDLEY_REL relation)
{
/**************************************
*
* m a k e _ c o n t e x t
*
**************************************
*
* Functional description
* Make context for trigger.
*
**************************************/
DUDLEY_CTX context = (DUDLEY_CTX) DDL_alloc(sizeof(dudley_ctx));
context->ctx_relation = relation;
if (string) {
SYM symbol = (SYM) DDL_alloc(SYM_LEN);
context->ctx_name = symbol;
symbol->sym_object = context;
symbol->sym_string = string;
symbol->sym_length = strlen(string);
symbol->sym_type = SYM_context;
}
return context;
}
static ACT make_global_field( DUDLEY_FLD field)
{
/**************************************
*
* m a k e _ g l o b a l _ f i e l d
*
**************************************
*
* Functional description
*
**************************************/
/* Make sure symbol is unique */
SYM symbol = field->fld_name;
symbol->sym_object = (DUDLEY_CTX) field;
symbol->sym_type = SYM_global;
if (symbol = HSH_typed_lookup(symbol->sym_string,
symbol->sym_length,
SYM_global))
PARSE_error(164, symbol->sym_string, 0); /* msg 164: global field %s already exists */
HSH_insert(field->fld_name);
return make_action(act_a_gfield, (DBB) field);
}
static void mod_old_trigger(void)
{
/**************************************
*
* m o d _ o l d _ t r i g g e r
*
**************************************
*
* Functional description
* Parse and old style modify trigger.
* (first part was done earlier)
*
**************************************/
DUDLEY_REL relation = PARSE_relation();
while (!PARSE_match(KW_END_TRIGGER)) {
int flags = 0, type = 0, sequence = 0;
get_trigger_attributes(&flags, &type, &sequence);
if (!type)
PARSE_error(165, dudleyGlob.DDL_token.tok_string, 0); /* msg 165: expected STORE, MODIFY, ERASE, END_TRIGGER, encountered \"%s\" */
DUDLEY_TRG trigger = (DUDLEY_TRG) DDL_alloc(sizeof(dudley_trg));
trigger->trg_relation = relation;
trigger->trg_mflag = flags & ~trg_mflag_order;
if (trigger->trg_mflag & trg_mflag_type)
trigger->trg_type = trig_table[type & ~trig_inact];
SYM name = gen_trigger_name(trigger->trg_type, relation);
trigger->trg_name = name;
SYM symbol = HSH_typed_lookup(name->sym_string, name->sym_length,
SYM_trigger);
if (!symbol)
PARSE_error(166, name->sym_string, 0); /* msg 166: Trigger %s does not exist */
modify_trigger_action(trigger, relation);
make_action(act_m_trigger, (DBB) trigger);
}
parse_end();
}
static void modify_field(void)
{
/**************************************
*
* m o d i f y _ f i e l d
*
**************************************
*
* Functional description
* Parse a MODIFY FIELD statement.
*
**************************************/
if (!local_context)
LLS_PUSH((DUDLEY_NOD) DDL_alloc(sizeof(dudley_ctx)), &local_context);
/* Lookup global field */
SYM symbol;
for (symbol = dudleyGlob.DDL_token.tok_symbol; symbol; symbol = symbol->sym_homonym)
if (symbol->sym_type == SYM_global)
break;
if (!symbol)
PARSE_error(167, dudleyGlob.DDL_token.tok_string, 0); /*msg 167: expected global field name, encountered \"%s\" */
DUDLEY_FLD field = (DUDLEY_FLD) symbol->sym_object;
LEX_token();
field->fld_flags |= fld_modify;
parse_field_dtype(field);
if (field->fld_dtype == blr_cstring)
PARSE_error(168, 0, 0); /*msg 168: datatype cstring not supported for fields */
parse_field_clauses(field);
if (field->fld_computed)
PARSE_error(169, 0, 0); /* msg 169: A computed expression can not be changed or added */
if (field->fld_security_class)
PARSE_error(170, 0, 0); /* msg 170: Security class can appear only on local field references */
parse_end();
make_action(act_m_gfield, (DBB) field);
}
static void modify_index(void)
{
/**************************************
*
* m o d i f y _ i n d e x
*
**************************************
*
* Functional description
* Alter an index. Does not currently
* allow adding or dropping fields from
* an index
*
**************************************/
DUDLEY_IDX index = (DUDLEY_IDX) DDL_alloc(IDX_LEN(1)); // 0 is invalid
index->idx_name = PARSE_symbol(tok_ident);
while (true) {
if (PARSE_match(KW_DUPLICATES)) {
index->idx_unique = false;
index->idx_flags |= IDX_unique_flag;
}
else if (PARSE_match(KW_UNIQUE)) {
index->idx_unique = true;
index->idx_flags |= IDX_unique_flag;
}
else if (PARSE_match(KW_ACTIVE)) {
index->idx_inactive = false;
index->idx_flags |= IDX_active_flag;
}
else if (PARSE_match(KW_INACTIVE)) {
index->idx_inactive = true;
index->idx_flags |= IDX_active_flag;
}
else if (PARSE_match(KW_ASCENDING)) {
index->idx_type = IDX_type_none;
index->idx_flags |= IDX_type_flag;
}
else if (PARSE_match(KW_DESCENDING)) {
index->idx_type = IDX_type_descend;
index->idx_flags |= IDX_type_flag;
}
else if (dudleyGlob.DDL_token.tok_keyword == KW_DESCRIPTION) {
index->idx_description = parse_description();
}
else if (PARSE_match(KW_DROP)) {
if (PARSE_match(KW_DESCRIP))
index->idx_flags |= IDX_null_description;
else
PARSE_error(172, dudleyGlob.DDL_token.tok_string, 0); /*msg 172: expected DESCRIPTION, encountered \"%s\" */
}
else if (PARSE_match(KW_STATISTICS))
index->idx_flags |= IDX_statistics_flag;
else
break;
}
make_action(act_m_index, (DBB) index);
}
static void modify_relation(void)
{
/**************************************
*
* m o d i f y _ r e l a t i o n
*
**************************************
*
* Functional description
* Parse a MODIFY RELATION statement.
*
**************************************/
DUDLEY_REL relation = PARSE_relation();
make_action(act_m_relation, (DBB) relation);
if (PARSE_match(KW_EXTERNAL_FILE)) {
relation->rel_filename = PARSE_symbol(tok_quoted);
if (!check_filename(relation->rel_filename, true))
PARSE_error(298, 0, 0); /* msg 298: A non-Decnet node name is not permitted in an external file name */
}
bool modify_relation = false;
while (true) {
if (dudleyGlob.DDL_token.tok_keyword == KW_DESCRIPTION) {
relation->rel_description = parse_description();
modify_relation = true;
}
else if (PARSE_match(KW_SECURITY_CLASS))
{
modify_relation = true;
relation->rel_security_class = PARSE_symbol(tok_ident);
}
else if (PARSE_match(KW_SYSTEM_FLAG)) {
relation->rel_system = get_system_flag();
relation->rel_flags |= rel_explicit_system;
modify_relation = true;
}
else
break;
}
/* Act on field actions */
if (!(dudleyGlob.DDL_token.tok_keyword == KW_SEMI))
while (true) {
if (PARSE_match(KW_ADD)) {
PARSE_match(KW_FIELD);
{
DUDLEY_FLD field = (DUDLEY_FLD) DDL_alloc(sizeof(dudley_fld));
parse_field(field);
field->fld_relation = relation;
field->fld_database = dudleyGlob.database;
DUDLEY_FLD global;
if (field->fld_computed)
make_computed_field(field);
else if (!(field->fld_flags & fld_local))
make_global_field(create_global_field(field));
else if (global = lookup_global_field(field)) {
field->fld_dtype = global->fld_dtype;
field->fld_length = global->fld_length;
field->fld_scale = global->fld_scale;
field->fld_segment_length =
global->fld_segment_length;
field->fld_sub_type = global->fld_sub_type;
field->fld_has_sub_type = global->fld_has_sub_type;
}
if (!(field->fld_flags & fld_explicit_position))
field->fld_position = ++relation->rel_field_position;
field->fld_name->sym_type = SYM_field;
HSH_insert(field->fld_name);
make_action(act_a_field, (DBB) field);
}
}
else if (PARSE_match(KW_MODIFY)) {
PARSE_match(KW_FIELD);
DUDLEY_FLD field = (DUDLEY_FLD) DDL_alloc(sizeof(dudley_fld));
field->fld_flags |= (fld_modify | fld_local);
parse_field(field);
field->fld_relation = relation;
field->fld_database = dudleyGlob.database;
if (field->fld_computed)
PARSE_error(173, 0, 0); /* msg 173: A computed expression can not be changed or added */
make_action(act_m_field, (DBB) field);
}
else if (PARSE_match(KW_DROP)) {
if (PARSE_match(KW_SECURITY_CLASS)) {
relation->rel_flags |= rel_null_security_class;
modify_relation = true;
PARSE_match(KW_COMMA);
if (dudleyGlob.DDL_token.tok_keyword == KW_SEMI)
break;
else
continue;
}
else if (PARSE_match(KW_DESCRIP)) {
modify_relation = true;
relation->rel_flags |= rel_null_description;
PARSE_match(KW_COMMA);
if (dudleyGlob.DDL_token.tok_keyword == KW_SEMI)
break;
else
continue;
}
else {
PARSE_match(KW_FIELD);
DUDLEY_FLD field = (DUDLEY_FLD) DDL_alloc(sizeof(dudley_fld));
field->fld_flags |= fld_local;
field->fld_relation = relation;
field->fld_database = dudleyGlob.database;
field->fld_name = PARSE_symbol(tok_ident);
make_action(act_d_field, (DBB) field);
}
}
else
PARSE_error(174, dudleyGlob.DDL_token.tok_string, 0); /* msg 174: expected field action, encountered \"%s\" */
if (!PARSE_match(KW_COMMA))
break;
}
parse_end();
if (modify_relation)
relation->rel_flags |= rel_marked_for_modify;
}
static void modify_security_class(void)
{
/**************************************
*
* m o d i f y _ s e c u r i t y _ c l a s s
*
**************************************
*
* Functional description
* Modify an existing security class.
*
**************************************/
/* return error msg for now until fully coded */
PARSE_error(247, 0, 0); /* msg 247: action not implemented yet */
SCL sec_class = (SCL) DDL_alloc(sizeof(scl));
sec_class->scl_name = PARSE_symbol(tok_ident);
if (dudleyGlob.DDL_token.tok_keyword == KW_DESCRIPTION)
sec_class->scl_description = parse_description();
while (true) {
SCE element = parse_identifier();
if (!element)
return;
const USHORT score = score_entry(element);
for (SCE* next = &sec_class->scl_entries;; next = &(*next)->sce_next)
if (!*next || score > score_entry(*next)) {
element->sce_next = *next;
*next = element;
break;
}
element->sce_privileges = parse_privileges();
if (!PARSE_match(KW_COMMA))
break;
}
parse_end();
make_action(act_m_security, (DBB) sec_class);
}
static void modify_trigger(void)
{
/**************************************
*
* m o d i f y _ t r i g g e r
*
**************************************
*
* Functional description
* Parse new trigger modification
* (go elsewhere if this is an old trigger).
*
**************************************/
TRGMSG_T msg_type = trgmsg_none;
if (PARSE_match(KW_FOR)) { /* modify trigger for ... is the old syntax */
mod_old_trigger();
return;
}
/* lookup the trigger name, complain and quit if it's unknown */
SYM name;
for (name = dudleyGlob.DDL_token.tok_symbol;
name && (name->sym_type != SYM_trigger); name = name->sym_homonym);
{
if (!name)
PARSE_error(176, dudleyGlob.DDL_token.tok_string, 0);
// msg 176: expected trigger name, encountered \"%s\"
}
DUDLEY_TRG trigger = (DUDLEY_TRG) name->sym_object;
LEX_token();
/* in case somebody compulsive specifies the relation name */
DUDLEY_REL relation;
if (PARSE_match(KW_FOR)) {
relation = PARSE_relation();
if (relation != trigger->trg_relation)
PARSE_error(177, 0, 0);
/* msg 177: Unsuccesful attempt to modify trigger relation */
}
else
relation = trigger->trg_relation;
SLONG flags = 0;
SLONG type = 0;
SLONG sequence = 0;
get_trigger_attributes((int*) &flags, (int*) &type, (int*) &sequence);
bool action = false;
bool end = false;
while (!(dudleyGlob.DDL_token.tok_keyword == KW_SEMI)) {
if ((PARSE_match(KW_MESSAGE)) || (PARSE_match(KW_MSGADD)) ||
(PARSE_match(KW_MSGMODIFY)))
{
msg_type = trgmsg_modify;
}
else if ((PARSE_match(KW_MSGDROP)) || (PARSE_match(KW_DROP)))
{
PARSE_match(KW_MESSAGE);
msg_type = trgmsg_drop;
}
if (msg_type) {
TRGMSG trigmsg = (TRGMSG) DDL_alloc(sizeof(trgmsg));
trigmsg->trgmsg_trg_name = trigger->trg_name;
trigmsg->trgmsg_number = PARSE_number();
if (trigmsg->trgmsg_number > 255)
PARSE_error(178, (TEXT *)(IPTR) trigmsg->trgmsg_number, 0);
/* msg 178: message number %d exceeds 255 */
if (msg_type == trgmsg_drop)
make_action(act_d_trigger_msg, (DBB) trigmsg);
else if (msg_type == trgmsg_modify) {
PARSE_match(KW_COLON);
trigmsg->trgmsg_text = PARSE_symbol(tok_quoted);
make_action(act_m_trigger_msg, (DBB) trigmsg);
}
PARSE_match(KW_COMMA);
msg_type = trgmsg_none;
}
else if (PARSE_match(KW_END_TRIGGER))
end = true;
else if (dudleyGlob.DDL_token.tok_keyword == KW_DESCRIPTION)
trigger->trg_description = parse_description();
else if (!action && !end) {
modify_trigger_action(trigger, relation);
action = true;
}
else
PARSE_error(179, dudleyGlob.DDL_token.tok_string, 0);
/* msg 179: expected message modification keyword, encountered \"%s\" */
}
if (flags || type || sequence)
sort_out_attributes(trigger, flags, type, sequence);
make_action(act_m_trigger, (DBB) trigger);
}
static void modify_trigger_action( DUDLEY_TRG trigger, DUDLEY_REL relation)
{
/**************************************
*
* m o d i f y _ t r i g g e r _ a c t i o n
*
**************************************
*
* Functional description
* Parse a trigger statement.
*
**************************************/
trigger->trg_source = start_text();
trigger->trg_statement = EXPR_statement();
end_text(trigger->trg_source);
}
static void modify_type(void)
{
/**************************************
*
* m o d i f y _ t y p e
*
**************************************
*
* Functional description
* Parse a modify of an existing type value for a field.
*
**************************************/
PARSE_match(KW_FOR);
SYM fldname = PARSE_symbol(tok_ident);
while (true) {
TYP fldtype = (TYP) DDL_alloc(sizeof(typ));
fldtype->typ_field_name = fldname;
fldtype->typ_name = PARSE_symbol(tok_ident);
PARSE_match(KW_COLON);
fldtype->typ_type = PARSE_number();
if (dudleyGlob.DDL_token.tok_keyword == KW_DESCRIPTION)
fldtype->typ_description = parse_description();
make_action(act_m_type, (DBB) fldtype);
if (!PARSE_match(KW_COMMA))
break;
}
parse_end();
}
static void modify_view(void)
{
/**************************************
*
* m o d i f y _ v i e w
*
**************************************
*
* Functional description
* Parse a MODIFY VIEW statement.
*
**************************************/
bool view_modify = false;
DUDLEY_REL relation = PARSE_relation();
make_action(act_m_relation, (DBB) relation);
while (true) {
if (dudleyGlob.DDL_token.tok_keyword == KW_DESCRIPTION) {
relation->rel_description = parse_description();
view_modify = true;
}
else if (PARSE_match(KW_SECURITY_CLASS)) {
relation->rel_security_class = PARSE_symbol(tok_ident);
view_modify = true;
}
else if (PARSE_match(KW_SYSTEM_FLAG)) {
relation->rel_system = get_system_flag();
relation->rel_flags |= rel_explicit_system;
view_modify = true;
}
else
break;
}
/* Act on field actions */
if (!(dudleyGlob.DDL_token.tok_keyword == KW_SEMI))
while (true) {
if (PARSE_match(KW_MODIFY)) {
PARSE_match(KW_FIELD);
DUDLEY_FLD field = (DUDLEY_FLD) DDL_alloc(sizeof(dudley_fld));
field->fld_flags |= (fld_modify | fld_local);
parse_field(field);
field->fld_relation = relation;
field->fld_database = dudleyGlob.database;
if (field->fld_computed)
PARSE_error(181, 0, 0); /* msg 181: A computed expression can not be changed or added */
make_action(act_m_field, (DBB) field);
}
else if (PARSE_match(KW_DROP)) {
if (PARSE_match(KW_DESCRIP)) {
view_modify = true;
relation->rel_flags |= rel_null_description;
if (dudleyGlob.DDL_token.tok_keyword == KW_SEMI)
break;
else
continue;
}
else if (PARSE_match(KW_SECURITY_CLASS)) {
view_modify = true;
relation->rel_flags |= rel_null_security_class;
if (dudleyGlob.DDL_token.tok_keyword == KW_SEMI)
break;
else
continue;
}
else {
PARSE_match(KW_FIELD);
DUDLEY_FLD field = (DUDLEY_FLD) DDL_alloc(sizeof(dudley_fld));
field->fld_flags |= fld_local;
field->fld_relation = relation;
field->fld_database = dudleyGlob.database;
field->fld_name = PARSE_symbol(tok_ident);
make_action(act_d_field, (DBB) field);
}
}
else
PARSE_error(182, dudleyGlob.DDL_token.tok_string, 0);
/* msg 182: expected drop/modify of field or security class, encountered \"%s\" */
if (!PARSE_match(KW_COMMA))
break;
}
if (view_modify)
relation->rel_flags |= rel_marked_for_modify;
parse_end();
}
static bool parse_action(void)
{
/**************************************
*
* p a r s e _ a c t i o n
*
**************************************
*
* Functional description
* Parse a single action. If an token flush is required, return true.
*
**************************************/
/* Set up an environment to catch syntax errors. If one occurs, scan looking
for semi-colon to continue processing. */
try {
dudleyGlob.DDL_prompt = PROMPT;
LEX_token();
dudleyGlob.DDL_prompt = CONTINUATION;
if (dudleyGlob.DDL_eof)
return true;
if (PARSE_match(KW_DEFINE))
switch (parse_object()) {
case obj_database:
define_database(act_c_database);
return true;
case obj_relation:
define_relation();
return true;
case obj_view:
define_view();
return true;
case obj_field:
define_field();
return true;
case obj_index:
define_index();
return true;
case obj_security_class:
define_security_class();
return true;
case obj_trigger:
define_trigger();
return true;
case obj_file:
define_file();
return true;
case obj_function:
define_function();
return true;
case obj_type:
define_type();
return true;
case obj_filter:
define_filter();
return true;
case obj_shadow:
define_shadow();
return true;
case obj_generator:
define_generator();
return true;
default:
if (dudleyGlob.database) {
define_relation();
return true;
}
PARSE_error(183, dudleyGlob.DDL_token.tok_string, 0); /* msg 183: expected object for DEFINE, encountered \"%s\" */
}
else if (PARSE_match(KW_MODIFY))
switch (parse_object()) {
case obj_database:
define_database(act_m_database);
return true;
case obj_relation:
modify_relation();
return true;
case obj_view:
modify_view();
return true;
case obj_field:
modify_field();
return true;
case obj_index:
modify_index();
return true;
case obj_security_class:
modify_security_class();
return true;
case obj_trigger:
modify_trigger();
return true;
case obj_function:
PARSE_error(233, 0, 0); /* msg 233: action not implemented yet */
case obj_type:
modify_type();
return true;
case obj_filter:
PARSE_error(231, 0, 0); /* msg 231: action not implemented yet */
case obj_shadow:
PARSE_error(232, 0, 0); /* msg 232: action not implemented yet */
default:
PARSE_error(184, dudleyGlob.DDL_token.tok_string, 0);
/* msg 184: expected object for MODIFY, encountered \"%s\" */
}
else if (PARSE_match(KW_DROP))
switch (parse_object()) {
case obj_database:
define_database(act_d_database);
return true;
case obj_relation:
case obj_view:
drop_relation();
return true;
case obj_field:
drop_gfield();
return true;
case obj_index:
drop_index();
return true;
case obj_security_class:
drop_security_class();
return true;
case obj_trigger:
drop_trigger();
return true;
case obj_function:
drop_function();
return true;
case obj_type:
drop_type();
return true;
case obj_filter:
drop_filter();
return true;
case obj_shadow:
drop_shadow();
return true;
default:
PARSE_error(185, dudleyGlob.DDL_token.tok_string, 0);
/* msg 185: expected object for DROP, encountered \"%s\" */
}
else if (PARSE_match(KW_GRANT)) {
grant_user_privilege();
return true;
}
else if (PARSE_match(KW_REVOKE)) {
revoke_user_privilege();
return true;
}
else if (PARSE_match(KW_SET_GENERATOR)) {
set_generator();
return true;
}
else if (PARSE_match(KW_SET)) {
if (!PARSE_match(KW_GENERATOR))
PARSE_error(318, dudleyGlob.DDL_token.tok_string, 0); /* msg 318: expected GENERATOR, encountered \"%s\" */
set_generator();
return true;
}
else if (dudleyGlob.DDL_interactive && dudleyGlob.DDL_token.tok_keyword == KW_EXIT) {
dudleyGlob.DDL_eof = true;
return false;
}
else if (dudleyGlob.DDL_interactive && dudleyGlob.DDL_token.tok_keyword == KW_QUIT) {
dudleyGlob.DDL_quit = dudleyGlob.DDL_eof = true;
return false;
}
PARSE_error(186, dudleyGlob.DDL_token.tok_string, 0); /* msg 186: expected command, encountered \"%s\" */
return false;
} // try
catch (const std::exception&) {
if (dudleyGlob.DDL_interactive)
LEX_flush();
else
while (!dudleyGlob.DDL_eof && !(dudleyGlob.DDL_token.tok_keyword == KW_SEMI))
LEX_token();
return true;
}
}
static void parse_array( DUDLEY_FLD field)
{
/**************************************
*
* p a r s e _ a r r a y
*
**************************************
*
* Functional description
* Parse the multi-dimensional array specification.
*
**************************************/
if (!PARSE_match(KW_LEFT_PAREN))
return;
/* Pick up ranges */
SLONG ranges[2 * MAX_DIMENSION];
SLONG* range = ranges;
for (;;) {
++field->fld_dimension;
range[0] = 1;
range[1] = PARSE_number();
if (PARSE_match(KW_COLON)) {
range[0] = range[1];
range[1] = PARSE_number();
}
if ((range[1] - range[0]) <= 0)
PARSE_error(188, 0, 0); /* msg 188: array size must be positive */
range += 2;
if (PARSE_match(KW_RIGHT_PAREN))
break;
if (!PARSE_match(KW_COMMA))
PARSE_error(189, dudleyGlob.DDL_token.tok_string, 0); /* msg 189: expected comma, encountered \"%s\" */
}
/* Allocate and copy block to hold ranges */
const SLONG n = field->fld_dimension * sizeof(SLONG) * 2;
SLONG* ptr = (SLONG*) DDL_alloc(n);
field->fld_ranges = ptr;
const SLONG* const end = range;
for (const SLONG* range2 = ranges; range2 < end;)
*ptr++ = *range2++;
}
static TXT parse_description(void)
{
/**************************************
*
* p a r s e _ d e s c r i p t i o n
*
**************************************
*
* Functional description
* Create a text block to hold the pointer and length
* of the description of a metadata item.
*
**************************************/
dudleyGlob.DDL_description = true;
TXT description = start_text();
description->txt_position = dudleyGlob.DDL_token.tok_position;
while (!dudleyGlob.DDL_eof && (!(dudleyGlob.DDL_token.tok_keyword == KW_END_DESCRIPTION)))
LEX_token();
if (dudleyGlob.DDL_eof)
return NULL;
end_text(description);
PARSE_match(KW_END_DESCRIPTION);
dudleyGlob.DDL_description = false;
return description;
}
static void parse_end(void)
{
/**************************************
*
* p a r s e _ e n d
*
**************************************
*
* Functional description
* Parse the end of command. Better be a semi-colon.
*
**************************************/
if (!(dudleyGlob.DDL_token.tok_keyword == KW_SEMI))
PARSE_error(190, dudleyGlob.DDL_token.tok_string, 0); /* msg 190: expected semi-colon, encountered \"%s\" */
}
static DUDLEY_FLD parse_field( DUDLEY_FLD field)
{
/**************************************
*
* p a r s e _ f i e l d
*
**************************************
*
* Functional description
* Parse a field definition, complete with data type and clauses.
*
**************************************/
field->fld_name = PARSE_symbol(tok_ident);
field->fld_name->sym_object = (DUDLEY_CTX) field;
if (PARSE_match(KW_BASED)) {
PARSE_match(KW_ON);
field->fld_source = PARSE_symbol(tok_ident);
field->fld_flags |= fld_local;
}
else {
parse_field_dtype(field);
if (field->fld_dtype == blr_cstring)
PARSE_error(191, 0, 0); /* msg 191: datatype cstring not supported for fields */
}
if (!field->fld_dtype)
field->fld_flags |= fld_local;
parse_field_clauses(field);
if (!(dudleyGlob.DDL_token.tok_keyword == KW_COMMA) && !(dudleyGlob.DDL_token.tok_keyword == KW_SEMI))
PARSE_error(192, dudleyGlob.DDL_token.tok_string, 0); /* msg 192: expected field clause, encountered \"%s\" */
validate_field(field);
return field;
}
static void parse_field_clauses( DUDLEY_FLD field)
{
/**************************************
*
* p a r s e _ f i e l d _ c l a u s e s
*
**************************************
*
* Functional description
* Parse a field definition, complete with data type and clauses.
*
**************************************/
/* Pick up purely optional clauses */
while (true)
switch (PARSE_keyword()) {
case KW_POSITION:
LEX_token();
field->fld_position = PARSE_number();
field->fld_flags |= fld_explicit_position;
break;
case KW_SECURITY_CLASS:
LEX_token();
field->fld_security_class = PARSE_symbol(tok_ident);
break;
case KW_DROP:
LEX_token();
if (PARSE_match(KW_SECURITY_CLASS))
field->fld_flags |= fld_null_security_class;
else if (PARSE_match(KW_VALID_IF))
field->fld_flags |= fld_null_validation;
else if (PARSE_match(KW_DESCRIP))
field->fld_flags |= fld_null_description;
else if (PARSE_match(KW_QUERY_NAME))
field->fld_flags |= fld_null_query_name;
else if (PARSE_match(KW_QUERY_HEADER))
field->fld_flags |= fld_null_query_header;
else if (PARSE_match(KW_EDIT_STRING))
field->fld_flags |= fld_null_edit_string;
else if (PARSE_match(KW_MISSING)) {
PARSE_match(KW_VALUE);
field->fld_flags |= fld_null_missing_value;
}
else
PARSE_error(193, dudleyGlob.DDL_token.tok_string, 0);
/* msg 193: expected DESCRIPTION, EDIT_STRING, MISSING VALUE, SECURITY_CLASS or VALID_IF", encountered \"%s\" */
break;
case KW_QUERY_NAME:
LEX_token();
PARSE_match(KW_IS);
field->fld_query_name = PARSE_symbol(tok_ident);
break;
case KW_EDIT_STRING:
LEX_token();
field->fld_edit_string = PARSE_symbol(tok_quoted);
break;
case KW_QUERY_HEADER:
{
LEX_token();
PARSE_match(KW_IS);
dudley_lls* stack = NULL;
for (;;) {
LLS_PUSH((DUDLEY_NOD) PARSE_symbol(tok_quoted), &stack);
if (!PARSE_match(KW_SLASH))
break;
}
field->fld_query_header = PARSE_make_list(stack);
break;
}
case KW_COMPUTED:
LEX_token();
PARSE_match(KW_BY);
if (!(PARSE_match(KW_LEFT_PAREN)))
PARSE_error(194, 0, 0); /* msg 194: computed by expression must be parenthesized */
field->fld_compute_src = start_text();
field->fld_computed = EXPR_value(0, NULL);
end_text(field->fld_compute_src);
if (!(PARSE_match(KW_RIGHT_PAREN)))
PARSE_error(195, 0, 0); /* msg 195: unmatched parenthesis */
break;
case KW_MISSING:
LEX_token();
PARSE_match(KW_VALUE);
PARSE_match(KW_IS);
field->fld_missing = EXPR_value(0, NULL);
break;
case KW_VALID_IF:
LEX_token();
PARSE_match(KW_IF);
if (!(PARSE_match(KW_LEFT_PAREN)))
PARSE_error(196, 0, 0); /* msg 196: validation expression must be parenthesized */
field->fld_valid_src = start_text();
field->fld_validation = EXPR_boolean(0);
end_text(field->fld_valid_src);
if (!(PARSE_match(KW_RIGHT_PAREN)))
PARSE_error(195, 0, 0); /* msg 195: unmatched parenthesis */
break;
case KW_SEGMENT_LENGTH:
{
LEX_token();
PARSE_match(KW_IS);
const int n = PARSE_number();
field->fld_segment_length = n;
if (n <= 0)
PARSE_error(197, 0, 0); /* msg 197: segment length must be positive */
break;
}
case KW_SUB_TYPE:
LEX_token();
parse_field_subtype(field);
break;
case KW_DEFAULT:
LEX_token();
PARSE_match(KW_VALUE);
PARSE_match(KW_IS);
field->fld_default = EXPR_value(0, NULL);
break;
case KW_DESCRIPTION:
field->fld_description = parse_description();
break;
case KW_SYSTEM_FLAG:
LEX_token();
field->fld_system = get_system_flag();
field->fld_flags |= fld_explicit_system;
break;
default:
return;
}
}
static void parse_field_dtype( DUDLEY_FLD field)
{
/**************************************
*
* p a r s e _ f i e l d _ d t y p e
*
**************************************
*
* Functional description
* Parse a field definition, complete with data type and clauses.
*
**************************************/
switch (PARSE_keyword()) {
case KW_CHAR:
field->fld_dtype = blr_text;
break;
case KW_VARYING:
field->fld_dtype = blr_varying;
break;
case KW_CSTRING:
field->fld_dtype = blr_cstring;
break;
case KW_SHORT:
field->fld_dtype = blr_short;
field->fld_length = sizeof(SSHORT);
break;
case KW_LONG:
field->fld_dtype = blr_long;
field->fld_length = sizeof(SLONG);
break;
case KW_QUAD:
field->fld_dtype = blr_quad;
field->fld_length = sizeof(ISC_QUAD);
break;
case KW_FLOAT:
field->fld_dtype = blr_float;
field->fld_length = sizeof(float);
break;
case KW_DOUBLE:
field->fld_dtype = blr_double;
field->fld_length = sizeof(double);
break;
case KW_DATE:
field->fld_dtype = blr_timestamp;
field->fld_length = sizeof(ISC_QUAD);
break;
case KW_BLOB:
field->fld_dtype = blr_blob;
field->fld_length = sizeof(ISC_QUAD);
break;
default:
return;
}
LEX_token();
if (field->fld_dtype == blr_text ||
field->fld_dtype == blr_varying || field->fld_dtype == blr_cstring)
{
if (!PARSE_match(KW_L_BRCKET) && !PARSE_match(KW_LT))
PARSE_error(200, dudleyGlob.DDL_token.tok_string, 0); /* msg 200: expected \"[\", encountered \"%s\" */
const int n = PARSE_number();
field->fld_length = n;
if (n <= 0)
PARSE_error(201, 0, 0); /* msg 201: character field length must be positive */
if (!PARSE_match(KW_R_BRCKET) && !PARSE_match(KW_GT))
PARSE_error(202, dudleyGlob.DDL_token.tok_string, 0); /* msg 202: expected \"]\", encountered \"%s\" */
if (PARSE_match(KW_SUB_TYPE))
parse_field_subtype(field);
}
if (field->fld_dtype != blr_blob)
parse_array(field);
field->fld_scale = 0;
if ((field->fld_dtype == blr_short ||
field->fld_dtype == blr_long || field->fld_dtype == blr_quad))
{
if (PARSE_match(KW_SCALE))
field->fld_scale = PARSE_number();
}
}
static void parse_field_subtype( DUDLEY_FLD field)
{
/**************************************
*
* p a r s e _ f i e l d _ s u b t y p e
*
**************************************
*
* Functional description
* Match a datatype sub_type clause. Set the (fld_has_sub_type) flag
* so we know this type is a type set by the user.
*
**************************************/
PARSE_match(KW_IS);
if (PARSE_match(KW_TEXT) || PARSE_match(KW_FIXED))
field->fld_sub_type = 1;
else if (PARSE_match(KW_BLR))
field->fld_sub_type = 2;
else if (PARSE_match(KW_ACL))
field->fld_sub_type = 3;
else if (PARSE_keyword() == KW_MINUS)
field->fld_sub_type = PARSE_number();
else if (dudleyGlob.DDL_token.tok_type != tok_number)
PARSE_error(198, dudleyGlob.DDL_token.tok_string, 0); /* msg 198: expected field sub_type, encountered \"%s\" */
else
field->fld_sub_type = PARSE_number();
field->fld_has_sub_type = TRUE;
}
static FUNCARG parse_function_arg( FUNC function, USHORT * position)
{
/**************************************
*
* p a r s e _ f u n c t i o n _ a r g
*
**************************************
*
* Functional description
* Parse a function argument definition, complete with data type.
*
**************************************/
FUNCARG func_arg = (FUNCARG) DDL_alloc(sizeof(funcarg));
DUDLEY_FLD field = (DUDLEY_FLD) DDL_alloc(sizeof(dudley_fld));
parse_field_dtype(field);
func_arg->funcarg_dtype = field->fld_dtype;
func_arg->funcarg_scale = field->fld_scale;
func_arg->funcarg_length = field->fld_length;
func_arg->funcarg_sub_type = field->fld_sub_type;
func_arg->funcarg_has_sub_type = field->fld_has_sub_type;
func_arg->funcarg_position = (*position)++;
PARSE_match(KW_BY);
LEX_token();
switch (PARSE_keyword()) {
case KW_VALUE:
LEX_token();
func_arg->funcarg_mechanism = FUNCARG_mechanism_value;
if (field->fld_dtype == blr_text ||
field->fld_dtype == blr_varying ||
field->fld_dtype == blr_cstring ||
field->fld_dtype == blr_blob || field->fld_dtype == blr_timestamp)
{
PARSE_error(203, 0, 0); /* msg 203: argument mode by value not allowed for this data type */
}
break;
case KW_REFERENCE:
LEX_token();
if (field->fld_dtype == blr_blob)
func_arg->funcarg_mechanism = FUNCARG_mechanism_blob_struc;
else
func_arg->funcarg_mechanism = FUNCARG_mechanism_reference;
break;
case KW_SCALAR_ARRAY_DESCRIPTOR:
LEX_token();
func_arg->funcarg_mechanism = FUNCARG_mechanism_sc_array_desc;
break;
default:
PARSE_error(204, 0, 0); /* msg 204: argument mode is by value, or by reference */
}
/* (kw_comma or kw_semi) here means this argument is not a
return_value or a return_argument in which case it had
better not be passed by value */
if (dudleyGlob.DDL_token.tok_keyword == KW_COMMA || dudleyGlob.DDL_token.tok_keyword == KW_SEMI) {
if (func_arg->funcarg_mechanism == FUNCARG_mechanism_value)
PARSE_error(293, 0, 0); /* msg 293: argument mode 'by value' requires a return mode */
}
else {
if (func_arg->funcarg_mechanism == FUNCARG_mechanism_sc_array_desc)
PARSE_error(295, 0, 0); /* msg 295: "Functions can't return arrays." */
switch (PARSE_keyword()) {
case KW_RETURN_VALUE:
--(*position);
LEX_token();
function->func_return_arg = func_arg->funcarg_position = 0;
function->func_return = func_arg;
break;
case KW_RETURN_ARGUMENT:
LEX_token();
if (func_arg->funcarg_mechanism == FUNCARG_mechanism_value)
PARSE_error(292, 0, 0); /* msg 292: argument mode of a return_argument must be 'by reference' */
function->func_return_arg = func_arg->funcarg_position;
function->func_return = func_arg;
break;
default:
PARSE_error(205, 0, 0); /* msg 205: return mode must be return_value or return_argument */
}
}
if (*position > 11)
PARSE_error(310, 0, 0); /* msg 310: UDF is limited to 10 parameters */
return func_arg;
}
static SCE parse_identifier(void)
{
/**************************************
*
* p a r s e _ i d e n t i f i e r
*
**************************************
*
* Functional description
* Parse the hard part of an access control element.
*
**************************************/
TEXT* idents[10];
TEXT** s;
const TEXT* const* end;
TEXT strings[256];
const TEXT* q;
TEXT* p = strings;
for (s = idents, end = s + 10; s < end; s++)
*s = NULL;
/* Get explicit identifiers, if any */
switch (dudleyGlob.DDL_token.tok_keyword) {
case (KW_VIEW):
LEX_token();
if (dudleyGlob.DDL_token.tok_type != tok_ident)
PARSE_error(117, dudleyGlob.DDL_token.tok_string, 0); /* msg 117: expected identifier, encountered \"%s\" */
idents[id_view] = p;
q = dudleyGlob.DDL_token.tok_string;
while (*p++ = *q++);
LEX_token();
break;
case (KW_USER):
LEX_token();
if (dudleyGlob.DDL_token.tok_type != tok_ident)
PARSE_error(117, dudleyGlob.DDL_token.tok_string, 0); /* msg 117: expected identifier, encountered \"%s\" */
idents[id_user] = p;
q = dudleyGlob.DDL_token.tok_string;
while (*p++ = *q++);
LEX_token();
if (PARSE_match(KW_GROUP)) {
if (dudleyGlob.DDL_token.tok_type != tok_ident)
PARSE_error(117, dudleyGlob.DDL_token.tok_string, 0); /* msg 117: expected identifier, encountered \"%s\" */
idents[id_group] = p;
q = dudleyGlob.DDL_token.tok_string;
while (*p++ = *q++);
LEX_token();
}
break;
case (KW_GROUP):
LEX_token();
if (dudleyGlob.DDL_token.tok_type != tok_ident)
PARSE_error(117, dudleyGlob.DDL_token.tok_string, 0); /* msg 117: expected identifier, encountered \"%s\" */
idents[id_group] = p;
q = dudleyGlob.DDL_token.tok_string;
while (*p++ = *q++);
LEX_token();
if (PARSE_match(KW_USER)) {
if (dudleyGlob.DDL_token.tok_type != tok_ident)
PARSE_error(117, dudleyGlob.DDL_token.tok_string, 0); /* msg 117: expected identifier, encountered \"%s\" */
idents[id_user] = p;
q = dudleyGlob.DDL_token.tok_string;
while (*p++ = *q++);
LEX_token();
}
break;
case (KW_L_BRCKET):
case (KW_LT):
LEX_token();
if (!PARSE_match(KW_ASTERISK)) {
if (dudleyGlob.DDL_token.tok_type != tok_number)
PARSE_error(206, dudleyGlob.DDL_token.tok_string, 0); /* msg 206: expected number, encountered \"%s\" */
idents[id_group] = p;
q = dudleyGlob.DDL_token.tok_string;
while (*p++ = *q++);
LEX_token();
}
if (!PARSE_match(KW_COMMA))
PARSE_error(207, dudleyGlob.DDL_token.tok_string, 0); /* msg 207: expected comma between group and user ids, encountered \"%s\" */
if (!PARSE_match(KW_ASTERISK)) {
if (dudleyGlob.DDL_token.tok_type != tok_number)
PARSE_error(206, dudleyGlob.DDL_token.tok_string, 0); /* msg 206: expected number, encountered \"%s\" */
idents[id_user] = p;
q = dudleyGlob.DDL_token.tok_string;
while (*p++ = *q++);
LEX_token();
}
if (!(PARSE_match(KW_R_BRCKET) || PARSE_match(KW_GT)))
PARSE_error(208, dudleyGlob.DDL_token.tok_string, 0); /* msg 208: expected trailing bracket, encountered \"%s\" */
break;
}
/* Build access control element */
SCE element = (SCE) DDL_alloc(sizeof(sce) + (p - strings));
p = (TEXT *) element->sce_strings;
TEXT** s1 = (TEXT **) element->sce_idents;
for (s = idents, end = s + 10; s < end; s++, s1++)
{
if (q = *s) {
*s1 = p;
while (*p++ = *q++);
}
}
return element;
}
static OBJ_T parse_object(void)
{
/**************************************
*
* p a r s e _ o b j e c t
*
**************************************
*
* Functional description
* Parse on object name returning what we found.
*
**************************************/
if (PARSE_match(KW_DATABASE))
return obj_database;
else if (!dudleyGlob.database || !dudleyGlob.database->dbb_handle)
PARSE_error(209, 0, 0); /* msg 209: no database declared */
if (PARSE_match(KW_RELATION))
return obj_relation;
if (PARSE_match(KW_FIELD))
return obj_field;
if (PARSE_match(KW_INDEX))
return obj_index;
if (PARSE_match(KW_VIEW))
return obj_view;
if (PARSE_match(KW_SECURITY_CLASS))
return obj_security_class;
if (PARSE_match(KW_TRIGGER))
return obj_trigger;
if (PARSE_match(KW_FILE))
return obj_file;
if (PARSE_match(KW_FUNCTION))
return obj_function;
if (PARSE_match(KW_TYPES))
return obj_type;
if (PARSE_match(KW_FILTER))
return obj_filter;
if (PARSE_match(KW_SHADOW))
return obj_shadow;
if (PARSE_match(KW_GENERATOR))
return obj_generator;
return obj_none;
}
static int parse_page_size(void)
{
/**************************************
*
* p a r s e _ p a g e _ s i z e
*
**************************************
*
* Functional description
* parse the page_size clause of a
* define database statement
*
*
**************************************/
PARSE_match(KW_EQUALS);
int n1, n2;
n2 = n1 = PARSE_number();
if (n1 <= 1024)
n2 = 1024;
else if (n1 <= 2048)
n2 = 2048;
else if (n1 <= 4096)
n2 = 4096;
else if (n1 <= 8192)
n2 = 8192;
else
PARSE_error(210, (TEXT *)(IPTR) n1, (TEXT *)(IPTR) MAX_PAGE_LEN);
/* msg 210: PAGE_SIZE specified (%d) longer than limit of %d bytes */
if (n1 != n2)
DDL_msg_put(211, (TEXT *)(IPTR) n1, (TEXT *)(IPTR) n2, NULL, NULL, NULL);
/* msg 211: PAGE_SIZE specified (%d) was rounded up to %d bytes\n */
return n2;
}
static SLONG parse_privileges(void)
{
/**************************************
*
* p a r s e _ p r i v i l e g e s
*
**************************************
*
* Functional description
* Parse an access control list.
*
**************************************/
SLONG privileges = 0;
if (!PARSE_match(KW_MINUS)) {
if (dudleyGlob.DDL_token.tok_type != tok_ident)
PARSE_error(117, dudleyGlob.DDL_token.tok_string, 0); /* msg 117: expected identifier, encountered \"%s\" */
const TEXT* p = dudleyGlob.DDL_token.tok_string;
TEXT c;
while (c = *p++)
switch (UPPER(c)) {
case 'P':
privileges |= 1 << priv_protect;
break;
case 'G':
privileges |= 1 << priv_grant;
break;
case 'D':
privileges |= 1 << priv_delete;
break;
case 'R':
privileges |= 1 << priv_read;
break;
case 'W':
privileges |= 1 << priv_write;
break;
case 'C':
privileges |= 1 << priv_control;
break;
default:
PARSE_error(212, (TEXT *)(IPTR) p[-1], 0);
/* msg 212: Unrecognized privilege \"%c\" or unrecognized identifier */
}
LEX_token();
}
return privileges;
}
static void revoke_user_privilege(void)
{
/**************************************
*
* r e v o k e _ u s e r _ p r i v i l e g e
*
**************************************
*
* Functional description
* Parse a SQL grant statement.
*
**************************************/
USERPRIV upriv = (USERPRIV) DDL_alloc(sizeof(userpriv));
while (true) {
if (PARSE_match(KW_ALL)) {
/* optional keyword following ALL */
PARSE_match(KW_PRIVILEGES);
upriv->userpriv_flags |= USERPRIV_select;
upriv->userpriv_flags |= USERPRIV_delete;
upriv->userpriv_flags |= USERPRIV_insert;
upriv->userpriv_flags |= USERPRIV_update;
}
else if (PARSE_match(KW_SELECT))
upriv->userpriv_flags |= USERPRIV_select;
else if (PARSE_match(KW_DELETE))
upriv->userpriv_flags |= USERPRIV_delete;
else if (PARSE_match(KW_INSERT))
upriv->userpriv_flags |= USERPRIV_insert;
else if (PARSE_match(KW_UPDATE)) {
/* revoke update privilege applies to all fields in the grant
update list */
upriv->userpriv_flags |= USERPRIV_update;
if (PARSE_match(KW_ON))
break;
if (PARSE_match(KW_COMMA))
continue;
if (!PARSE_match(KW_LEFT_PAREN))
PARSE_error(315, dudleyGlob.DDL_token.tok_string, 0); /* msg 315: expected ON or '(', encountered "%s" */
do {
if (dudleyGlob.DDL_token.tok_keyword == KW_SELECT
|| dudleyGlob.DDL_token.tok_keyword == KW_INSERT
|| dudleyGlob.DDL_token.tok_keyword == KW_DELETE
|| dudleyGlob.DDL_token.tok_keyword == KW_UPDATE)
{
break;
}
UPFE upf = (UPFE) DDL_alloc(sizeof(upfe));
upf->upfe_fldname = PARSE_symbol(tok_ident);
upf->upfe_next = upriv->userpriv_upflist;
upriv->userpriv_upflist = upf;
} while (PARSE_match(KW_COMMA));
if (!PARSE_match(KW_RIGHT_PAREN))
PARSE_error(316, dudleyGlob.DDL_token.tok_string, 0); /* msg 316: expected ')', encountered "%s" */
continue;
}
if (!PARSE_match(KW_COMMA)) {
if (!PARSE_match(KW_ON))
PARSE_error(214, dudleyGlob.DDL_token.tok_string, 0); /* msg 214: expected ON, encountered \"%s\" */
break;
}
} // while (true)
if (!upriv->userpriv_flags)
PARSE_error(215, 0, 0); /* msg 215: REVOKE privilege was not specified */
upriv->userpriv_relation = PARSE_symbol(tok_ident);
if (!PARSE_match(KW_FROM))
PARSE_error(216, dudleyGlob.DDL_token.tok_string, 0); /* msg 216: expected FROM, encountered \"%s\" */
/* get the userlist */
while (true) {
USRE usr = (USRE) DDL_alloc(sizeof(usre));
usr->usre_name = PARSE_symbol(tok_ident);
usr->usre_next = upriv->userpriv_userlist;
upriv->userpriv_userlist = usr;
if (!PARSE_match(KW_COMMA))
break;
}
parse_end();
make_action(act_revoke, (DBB) upriv);
}
static SLONG score_entry( SCE element)
{
/**************************************
*
* s c o r e _ e n t r y
*
**************************************
*
* Functional description
* Compute a value to determine placement of an
* access control element in an Apollo access
* control list.
*
**************************************/
SLONG score = 0;
if (element->sce_idents[id_view])
score++;
const TEXT* const* ptr = (TEXT**) element->sce_idents;
for (const TEXT* const* const end = ptr + id_max; ptr < end;
ptr++)
{
score <<= 1;
if (*ptr)
score |= 1;
}
return score;
}
static DUDLEY_NOD set_generator(void)
{
/**************************************
*
* s e t _ g e n e r a t o r
*
**************************************
*
* Functional description
* get the name and new value for generator
**************************************/
if (dudleyGlob.DDL_token.tok_type != tok_ident)
PARSE_error(274, dudleyGlob.DDL_token.tok_string, 0); /* msg 274: expected generator name, encountered \"%s\" */
DUDLEY_NOD node = PARSE_make_node(nod_set_generator, 2);
node->nod_count = 1;
node->nod_arg[1] = (DUDLEY_NOD) PARSE_symbol(tok_ident);
PARSE_match(KW_TO);
node->nod_arg[0] = EXPR_value(0, NULL);
parse_end();
make_action(act_s_generator, (DBB) node);
return 0;
}
static void sort_out_attributes(
DUDLEY_TRG trigger,
SLONG flags, SLONG type, SLONG sequence)
{
/**************************************
*
* s o r t _ o u t _ a t t r i b u t e s
*
**************************************
*
* Functional description
* Somebody is being very cute and changing
* attributes of a trigger. We're going to do
* it, but we'd better remember the other, unchanged
* attributes so we don't make a big mess.
*
**************************************/
trigger->trg_mflag = flags & ~trg_mflag_order;
if (flags & trg_mflag_type)
switch (trigger->trg_type) {
case trg_store:
case trg_post_store:
if (!(type & (trig_mod | trig_era)))
type |= trig_sto;
else if (!trigger->trg_statement && (type & trig_era))
PARSE_error(217, 0, 0); /* msg 217: Attempt change trigger type from STORE to ERASE */
break;
case trg_modify:
case trg_post_modify:
if (!(type & (trig_sto | trig_era)))
type |= trig_mod;
else if (!trigger->trg_statement)
if (type & trig_sto)
PARSE_error(218, 0, 0); /* msg 218: Attempt change trigger type from MODIFY to STORE */
else
PARSE_error(219, 0, 0); /* msg 219: Attempt change trigger type from MODIFY to ERASE */
break;
case trg_pre_erase:
case trg_erase:
if (!(type & (trig_sto | trig_mod)))
type |= trig_era;
else if (!trigger->trg_statement && (type & trig_sto))
PARSE_error(220, 0, 0); /* msg 220: Attempt to change trigger type from ERASE to STORE */
}
if ((!(flags & trg_mflag_order)) && (flags & trg_mflag_type))
switch (trigger->trg_type) {
case trg_erase:
case trg_post_modify:
case trg_post_store:
type |= trig_post;
break;
case trg_store:
case trg_modify:
case trg_pre_erase:
type &= ~trig_post;
}
if (trigger->trg_mflag & trg_mflag_type)
trigger->trg_type = trig_table[type & ~trig_inact];
if (trigger->trg_mflag & trg_mflag_seqnum)
trigger->trg_sequence = sequence;
if (trigger->trg_mflag & trg_mflag_onoff)
trigger->trg_inactive = type & trig_inact;
}
static TXT start_text(void)
{
/**************************************
*
* s t a r t _ t e x t
*
**************************************
*
* Functional description
* Make the current position to save description text.
*
**************************************/
TXT text = (TXT) DDL_alloc(sizeof(txt));
text->txt_position = dudleyGlob.DDL_token.tok_position - dudleyGlob.DDL_token.tok_length;
text->txt_start_line = dudleyGlob.DDL_line;
return text;
}
static void validate_field( DUDLEY_FLD field)
{
/**************************************
*
* v a l i d a t e _ f i e l d
*
**************************************
*
* Functional description
* Validate that the field clauses make sense
* together.
*
**************************************/
TEXT option[128];
*option = 0;
if (field->fld_flags & fld_local) {
if (field->fld_validation)
gds__msg_format(0, DDL_MSG_FAC, 221, sizeof(option), option, NULL,
NULL, NULL, NULL, NULL);
/* msg 221 /'valid if/' */
if (field->fld_missing)
gds__msg_format(0, DDL_MSG_FAC, 222, sizeof(option), option, NULL,
NULL, NULL, NULL, NULL);
/* msg 222: missing value */
if ((field->fld_dtype) && !(field->fld_computed))
gds__msg_format(0, DDL_MSG_FAC, 223, sizeof(option), option, NULL,
NULL, NULL, NULL, NULL);
/* msg 223: data type */
if ((field->fld_has_sub_type) && !(field->fld_computed))
gds__msg_format(0, DDL_MSG_FAC, 224, sizeof(option), option, NULL,
NULL, NULL, NULL, NULL);
/* msg 224: sub type */
if ((field->fld_segment_length) && !(field->fld_computed))
gds__msg_format(0, DDL_MSG_FAC, 225, sizeof(option), option, NULL,
NULL, NULL, NULL, NULL);
/* msg 225: segment_length */
if (*option)
PARSE_error(226, option, 0); /* msg 226: %s is a global, not local, attribute */
return;
}
if (field->fld_computed && !(field->fld_dtype))
PARSE_error(227, 0, 0); /* msg 227: computed fields need datatypes */
if (field->fld_flags & fld_modify)
return;
if ((field->fld_has_sub_type) &&
(field->fld_dtype != blr_blob) &&
(field->fld_dtype != blr_text) && (field->fld_dtype != blr_varying))
PARSE_error(228, 0, 0); /* msg 228: subtypes are valid only for blobs and text */
if (field->fld_segment_length && (field->fld_dtype != blr_blob))
PARSE_error(229, 0, 0); /* msg 229: segment length is valid only for blobs */
if ((field->fld_dtype == blr_blob) && !(field->fld_segment_length))
field->fld_segment_length = 80;
}
View Git Blame Copy Permalink