2012-02-05 11:35:58 -05:00
|
|
|
/****************************************************************
|
|
|
|
|
* *
|
|
|
|
|
* Copyright 2010 Fidelity Information Services, Inc *
|
|
|
|
|
* *
|
|
|
|
|
* This source code contains the intellectual property *
|
|
|
|
|
* of its copyright holder(s), and is made available *
|
|
|
|
|
* under a license. If you do not know the terms of *
|
|
|
|
|
* the license, please stop and do not read further. *
|
|
|
|
|
* *
|
|
|
|
|
****************************************************************/
|
|
|
|
|
|
|
|
|
|
#include "mdef.h"
|
|
|
|
|
|
|
|
|
|
#include "gtm_ctype.h"
|
|
|
|
|
#include "gtm_string.h"
|
|
|
|
|
#include "cli.h"
|
|
|
|
|
#include "gdsroot.h"
|
|
|
|
|
#include "gdsbt.h"
|
|
|
|
|
#include "gdsfhead.h"
|
2012-06-14 08:55:06 -04:00
|
|
|
#include <rtnhdr.h>
|
2012-02-05 11:35:58 -05:00
|
|
|
#include "gv_trigger.h"
|
|
|
|
|
#include "gtm_trigger.h"
|
|
|
|
|
#include "trigger.h"
|
|
|
|
|
#include "trigger_parse_protos.h"
|
|
|
|
|
#include "trigger_scan_string.h"
|
|
|
|
|
#include "zshow.h" /* for zwr2format() prototype */
|
|
|
|
|
#include "min_max.h"
|
|
|
|
|
#include "util.h"
|
|
|
|
|
#include "subscript.h"
|
|
|
|
|
#include "cli_parse.h"
|
|
|
|
|
#include "compiler.h"
|
|
|
|
|
#include "gtm_utf8.h"
|
|
|
|
|
#include "gtmctype.h"
|
|
|
|
|
|
|
|
|
|
GBLREF CLI_ENTRY *cmd_ary;
|
|
|
|
|
GBLREF gd_region *gv_cur_region;
|
|
|
|
|
GBLREF CLI_ENTRY trigger_cmd_ary[];
|
|
|
|
|
|
|
|
|
|
#define BITS_PER_INT (SIZEOF(uint4) * 8) /* Number of bits in an integer */
|
|
|
|
|
#define MAX_PIECE_VALUE (BITS_PER_INT * 1024) /* Largest value allowed in -pieces string */
|
|
|
|
|
#define MAX_PIECE_INT (MAX_PIECE_VALUE / 32) /* Number of integers it takes to hold MAX_PIECE_VALUE bits */
|
|
|
|
|
#define MAX_PIECE_CHARS (MAX_PIECE_INT * 4) /* Number of 8-bit bytes in MAX_PIECE_INT integers */
|
|
|
|
|
#define MAX_LVN_COUNT MAX_GVSUBSCRIPTS /* Maximum number of "lvn=" in trigger subscript */
|
|
|
|
|
#define MAX_OPTIONS_LEN 1024 /* Maximum size of the "options" string */
|
|
|
|
|
#define MAX_DCHAR_LEN 1024 /* Maximum size of $C or $ZCH string */
|
|
|
|
|
#define MAX_DELIM_LEN 1024 /* Maximum size of the string for a delimiter - $C, $ZCH, "x", ... */
|
|
|
|
|
#define MAX_ERROR_MSG_LEN 72
|
|
|
|
|
#define TRIGR_PRECOMP_RTNNAME "trigcomptest#"
|
|
|
|
|
|
|
|
|
|
#define CONV_CH(PTR, STR, LEN) \
|
|
|
|
|
{ \
|
|
|
|
|
if (PRINTABLE(*PTR)) \
|
|
|
|
|
{ \
|
|
|
|
|
STR[0] = '"'; \
|
|
|
|
|
STR[1] = *PTR; \
|
|
|
|
|
STR[2] = '"'; \
|
|
|
|
|
LEN = 3; \
|
|
|
|
|
} else \
|
|
|
|
|
format2zwr((sm_uc_ptr_t)PTR, 1, STR, &LEN); \
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define ERROR_MSG_RETURN(STR, LEN, PTR) \
|
|
|
|
|
{ \
|
|
|
|
|
CONV_STR_AND_PRINT(STR, LEN, PTR); \
|
|
|
|
|
return FALSE; \
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define ERROR_STR_RETURN(STR) \
|
|
|
|
|
{ \
|
|
|
|
|
util_out_print_gtmio(STR, FLUSH); \
|
|
|
|
|
return FALSE; \
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define CONV_CH_AND_PRINT(STR, PTR) \
|
|
|
|
|
{ \
|
|
|
|
|
int out_len; \
|
|
|
|
|
unsigned char out_str[64]; /* Plenty of room for $ZCH(xxx) */ \
|
|
|
|
|
\
|
|
|
|
|
CONV_CH(PTR, out_str, out_len); \
|
|
|
|
|
util_out_print_gtmio(STR, FLUSH, out_len, out_str); \
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define CONV_CH_AND_STR_AND_PRINT(STR, PTR1, LEN, PTR2) \
|
|
|
|
|
{ \
|
|
|
|
|
int out_len1, out_len2; \
|
|
|
|
|
unsigned char out_str1[64]; /* Plenty of room for $ZCH(xxx) */ \
|
|
|
|
|
unsigned char out_str2[MAX_ZWR_EXP_RATIO * OUT_BUFF_SIZE]; \
|
|
|
|
|
\
|
|
|
|
|
CONV_CH(PTR1, out_str1, out_len1); \
|
|
|
|
|
CONV_TO_ZWR(LEN, PTR2, out_len2, out_str2); \
|
|
|
|
|
util_out_print_gtmio(STR, FLUSH, out_len1, out_str1, out_len2, out_str2); \
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define CONV_NUM_AND_STR_AND_PRINT(STR, NUM, LEN, PTR) \
|
|
|
|
|
{ \
|
|
|
|
|
int out_len; \
|
|
|
|
|
unsigned char out_str[MAX_ZWR_EXP_RATIO * OUT_BUFF_SIZE]; \
|
|
|
|
|
\
|
|
|
|
|
CONV_TO_ZWR(LEN, PTR, out_len, out_str); \
|
|
|
|
|
util_out_print_gtmio(STR, FLUSH, NUM, out_len, out_str); \
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define UPDATE_DST(PTR, LEN, HAVE_STAR, DST_PTR, DST_LEN, MAX_LEN) \
|
|
|
|
|
{ \
|
|
|
|
|
if (!HAVE_STAR) \
|
|
|
|
|
{ \
|
|
|
|
|
if (MAX_LEN < ++DST_LEN) \
|
|
|
|
|
{ \
|
|
|
|
|
util_out_print_gtmio("Trigger definition too long", FLUSH); \
|
|
|
|
|
return FALSE; \
|
|
|
|
|
} \
|
|
|
|
|
*DST_PTR++ = *PTR++; \
|
|
|
|
|
} \
|
|
|
|
|
else PTR++; \
|
|
|
|
|
LEN--; \
|
|
|
|
|
}
|
|
|
|
|
#define UPDATE_TRIG_PTRS(VAL, NEXT_VAL, LEN, MAX_OUTPUT_LEN) \
|
|
|
|
|
{ \
|
|
|
|
|
NEXT_VAL = VAL + LEN; \
|
|
|
|
|
if (0 > --MAX_OUTPUT_LEN) \
|
|
|
|
|
{ \
|
|
|
|
|
util_out_print_gtmio("Trigger definition too long", FLUSH); \
|
|
|
|
|
return FALSE; \
|
|
|
|
|
} \
|
|
|
|
|
*NEXT_VAL++ = '\0'; \
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define PROCESS_NUMERIC(PTR, LEN, HAVE_STAR, DST_PTR, DST_LEN, MAX_LEN) \
|
|
|
|
|
{ \
|
|
|
|
|
UPDATE_DST(PTR, LEN, HAVE_STAR, DST_PTR, DST_LEN, MAX_LEN); \
|
|
|
|
|
while (ISDIGIT_ASCII(*PTR)) \
|
|
|
|
|
{ \
|
|
|
|
|
if (!HAVE_STAR) \
|
|
|
|
|
{ \
|
|
|
|
|
if (MAX_LEN < ++DST_LEN) \
|
|
|
|
|
{ \
|
|
|
|
|
util_out_print_gtmio("Subscript too long", FLUSH); \
|
|
|
|
|
return FALSE; \
|
|
|
|
|
} \
|
|
|
|
|
*DST_PTR++ = *PTR++; \
|
|
|
|
|
} else \
|
|
|
|
|
PTR++; \
|
|
|
|
|
LEN--; \
|
|
|
|
|
} \
|
|
|
|
|
}
|
|
|
|
|
#define PROCESS_STRING(PTR, LEN, HAVE_STAR, DST_PTR, DST_LEN, MAX_LEN) \
|
|
|
|
|
{ \
|
|
|
|
|
char *ptr1; \
|
|
|
|
|
int add_len; \
|
|
|
|
|
\
|
|
|
|
|
ptr1 = scan_to_end_quote(PTR, LEN, MAX_LEN); \
|
|
|
|
|
if (NULL == ptr1) \
|
|
|
|
|
{ \
|
|
|
|
|
util_out_print_gtmio("Invalid string", FLUSH); \
|
|
|
|
|
return FALSE; \
|
|
|
|
|
} \
|
|
|
|
|
add_len = (int)(ptr1 - PTR); \
|
|
|
|
|
LEN -= add_len; \
|
|
|
|
|
if (!HAVE_STAR) \
|
|
|
|
|
{ \
|
|
|
|
|
if (MAX_LEN < (DST_LEN + add_len)) \
|
|
|
|
|
{ \
|
|
|
|
|
util_out_print_gtmio("Trigger definition too long", FLUSH); \
|
|
|
|
|
return FALSE; \
|
|
|
|
|
} \
|
|
|
|
|
memcpy(DST_PTR, PTR, add_len); \
|
|
|
|
|
DST_PTR += add_len; \
|
|
|
|
|
DST_LEN += add_len; \
|
|
|
|
|
} \
|
|
|
|
|
PTR = ptr1; \
|
|
|
|
|
}
|
|
|
|
|
#define PROCESS_AND_GET_NUMERIC(PTR, LEN, HAVE_STAR, DST_PTR, DST_LEN, NUM, MAX_LEN) \
|
|
|
|
|
{ \
|
|
|
|
|
char *ptr1; \
|
|
|
|
|
int add_len; \
|
|
|
|
|
\
|
|
|
|
|
ptr1 = PTR; \
|
|
|
|
|
A2I(ptr1, PTR + LEN, NUM); \
|
|
|
|
|
add_len = (int)(ptr1 - PTR); \
|
|
|
|
|
LEN -= add_len; \
|
|
|
|
|
if (!HAVE_STAR) \
|
|
|
|
|
{ \
|
|
|
|
|
if (MAX_LEN < (DST_LEN + add_len)) \
|
|
|
|
|
{ \
|
|
|
|
|
util_out_print_gtmio("Subscript too long", FLUSH); \
|
|
|
|
|
return FALSE; \
|
|
|
|
|
} \
|
|
|
|
|
memcpy(DST_PTR, PTR, add_len); \
|
|
|
|
|
DST_PTR += add_len; \
|
|
|
|
|
DST_LEN += add_len; \
|
|
|
|
|
} \
|
|
|
|
|
PTR = ptr1; \
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define GET_CLI_STR(QUAL, MAX_OUTPUT_LEN, VALUE, RES) \
|
|
|
|
|
{ \
|
|
|
|
|
unsigned short qual_len; \
|
|
|
|
|
\
|
|
|
|
|
qual_len = (unsigned short)MAX_OUTPUT_LEN; \
|
|
|
|
|
assert(MAX_OUTPUT_LEN == qual_len); /* make sure it fits in short */ \
|
|
|
|
|
if (FALSE == cli_get_str(QUAL, VALUE, &qual_len)) \
|
|
|
|
|
return FALSE; \
|
|
|
|
|
RES = qual_len; \
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define GET_CLI_STR_AND_CHECK(QUAL, QUAL_PRESENT, MAX_OUTPUT_LEN, CHECK_FN, VAL, VAL_LEN, NEXT_VAL, ERR_MSG) \
|
|
|
|
|
{ \
|
|
|
|
|
unsigned short qual_str_len; \
|
|
|
|
|
\
|
|
|
|
|
if (CLI_PRESENT == (QUAL_PRESENT = cli_present(QUAL))) \
|
|
|
|
|
{ \
|
|
|
|
|
GET_CLI_STR(QUAL, MAX_OUTPUT_LEN, VAL, qual_str_len); \
|
|
|
|
|
VAL_LEN = qual_str_len; \
|
|
|
|
|
if (!CHECK_FN(VAL, &VAL_LEN)) \
|
|
|
|
|
{ \
|
|
|
|
|
if (0 == STR_LIT_LEN(ERR_MSG)) \
|
|
|
|
|
return FALSE; \
|
|
|
|
|
else \
|
|
|
|
|
{ \
|
|
|
|
|
ERROR_MSG_RETURN(ERR_MSG, VAL_LEN, VAL); \
|
|
|
|
|
} \
|
|
|
|
|
} \
|
|
|
|
|
} else \
|
|
|
|
|
VAL_LEN = 0; \
|
|
|
|
|
/* cli_get_str() will put the string in the buffer (based on max_output_len) \
|
|
|
|
|
* but the check_*() function might take another pass over the string in the \
|
|
|
|
|
* output buffer and consolidate it -- for example piece can reduce 2;3;4;5 \
|
|
|
|
|
* to 2:5. So don't adjust max_output_len until we know the actual length. \
|
|
|
|
|
*/ \
|
|
|
|
|
MAX_OUTPUT_LEN -= VAL_LEN; \
|
|
|
|
|
UPDATE_TRIG_PTRS(VAL, NEXT_VAL, VAL_LEN, MAX_OUTPUT_LEN); \
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
GBLREF char cli_err_str[];
|
|
|
|
|
GBLREF boolean_t gtm_cli_interpret_string;
|
|
|
|
|
|
|
|
|
|
LITREF unsigned char lower_to_upper_table[];
|
|
|
|
|
LITREF mval gvtr_cmd_mval[GVTR_CMDTYPES];
|
|
|
|
|
|
|
|
|
|
STATICFNDEF char *scan_to_end_quote(char *ptr, int len, int max_len)
|
|
|
|
|
{
|
|
|
|
|
int str_len = 0;
|
|
|
|
|
|
|
|
|
|
if ((1 >= len) || ('"' != *ptr))
|
|
|
|
|
return NULL; /* Invalid string - it needs at least "" */
|
|
|
|
|
if (max_len < ++str_len)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("String too long", FLUSH);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
ptr++;
|
|
|
|
|
len--;
|
|
|
|
|
for ( ; 0 < len; len--, ptr++)
|
|
|
|
|
{ /* Scan until the closing quote */
|
|
|
|
|
if ('"' == *ptr)
|
|
|
|
|
{
|
|
|
|
|
if (1 == len)
|
|
|
|
|
break;
|
|
|
|
|
if ('"' == *(ptr + 1))
|
|
|
|
|
{
|
|
|
|
|
if (max_len < ++str_len)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("String too long", FLUSH);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
ptr++;
|
|
|
|
|
len--;
|
|
|
|
|
} else
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (max_len < ++str_len)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("String too long", FLUSH);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return (('"' == *ptr) ? ptr + 1 : NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
STATICFNDEF boolean_t process_dollar_char(char **src_ptr, int *src_len, boolean_t have_star, char **d_ptr, int *dst_len)
|
|
|
|
|
{
|
|
|
|
|
int char_count;
|
|
|
|
|
char *char_ptr;
|
|
|
|
|
int len;
|
|
|
|
|
char *dst_ptr;
|
|
|
|
|
char dst_string[MAX_DCHAR_LEN];
|
|
|
|
|
int lcl_dst_len;
|
|
|
|
|
mstr m_dst;
|
|
|
|
|
mstr m_src;
|
|
|
|
|
char *ptr;
|
|
|
|
|
int q_len;
|
|
|
|
|
char *tmp_dst_ptr;
|
|
|
|
|
|
|
|
|
|
tmp_dst_ptr = dst_ptr = *d_ptr;
|
|
|
|
|
ptr = *src_ptr;
|
|
|
|
|
len = *src_len;
|
|
|
|
|
lcl_dst_len = *dst_len;
|
|
|
|
|
assert('$' == *ptr);
|
|
|
|
|
UPDATE_DST(ptr, len, have_star, dst_ptr, lcl_dst_len, MAX_GVSUBS_LEN);
|
|
|
|
|
if (0 == len)
|
|
|
|
|
return FALSE;
|
|
|
|
|
switch (*ptr)
|
|
|
|
|
{
|
|
|
|
|
case 'c':
|
|
|
|
|
case 'C':
|
|
|
|
|
UPDATE_DST(ptr, len, have_star, dst_ptr, lcl_dst_len, MAX_GVSUBS_LEN);
|
|
|
|
|
if ((0 < len) && ('(' == *ptr))
|
|
|
|
|
break;
|
|
|
|
|
else if ((3 < len) && ('H' == lower_to_upper_table[*ptr])
|
|
|
|
|
&& ('A' == lower_to_upper_table[*(ptr + 1)])
|
|
|
|
|
&& ('R' == lower_to_upper_table[*(ptr + 2)]) && ('(' == *(ptr + 3)))
|
|
|
|
|
{
|
|
|
|
|
ptr += 3;
|
|
|
|
|
len -= 3;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return FALSE;
|
|
|
|
|
break;
|
|
|
|
|
case 'z':
|
|
|
|
|
case 'Z':
|
|
|
|
|
UPDATE_DST(ptr, len, have_star, dst_ptr, lcl_dst_len, MAX_GVSUBS_LEN);
|
|
|
|
|
if ((2 < len) && ('C' == lower_to_upper_table[*ptr])
|
|
|
|
|
&& ('H' == lower_to_upper_table[*(ptr + 1)]) && ('(' == *(ptr + 2)))
|
|
|
|
|
{
|
|
|
|
|
ptr += 2;
|
|
|
|
|
len -= 2;
|
|
|
|
|
}
|
|
|
|
|
else if ((4 < len) && ('C' == lower_to_upper_table[*ptr])
|
|
|
|
|
&& ('H' == lower_to_upper_table[*(ptr + 1)])
|
|
|
|
|
&& ('A' == lower_to_upper_table[*(ptr + 2)])
|
|
|
|
|
&& ('R' == lower_to_upper_table[*(ptr + 3)]) && ('(' == *(ptr + 4)))
|
|
|
|
|
{
|
|
|
|
|
ptr += 4;
|
|
|
|
|
len -= 4;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return FALSE;
|
|
|
|
|
if (MAX_GVSUBS_LEN < lcl_dst_len + 2)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Subscript too long", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
MEMCPY_LIT(dst_ptr, "CH");
|
|
|
|
|
dst_ptr += 2;
|
|
|
|
|
lcl_dst_len += 2;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
assert('(' == *ptr);
|
|
|
|
|
UPDATE_DST(ptr, len, have_star, dst_ptr, lcl_dst_len, MAX_GVSUBS_LEN);
|
|
|
|
|
while ((0 < len) && (')' != *ptr))
|
|
|
|
|
{
|
|
|
|
|
UPDATE_DST(ptr, len, have_star, dst_ptr, lcl_dst_len, MAX_GVSUBS_LEN);
|
|
|
|
|
}
|
|
|
|
|
q_len = 0;
|
|
|
|
|
if (!have_star)
|
|
|
|
|
{
|
|
|
|
|
if (MAX_GVSUBS_LEN < ++lcl_dst_len)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("$[Z]CHAR expression too long", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
*dst_ptr++ = *ptr++;
|
|
|
|
|
*dst_ptr = '\0';
|
|
|
|
|
m_src.addr = tmp_dst_ptr;
|
|
|
|
|
m_src.len = (mstr_len_t)(dst_ptr - tmp_dst_ptr);
|
|
|
|
|
m_dst.addr = dst_string;
|
|
|
|
|
m_dst.len = 0;
|
|
|
|
|
if (!zwr2format(&m_src, &m_dst))
|
|
|
|
|
return FALSE;
|
|
|
|
|
lcl_dst_len = *dst_len; /* Reset length because we're creating the final version now */
|
|
|
|
|
if (MAX_GVSUBS_LEN < ++lcl_dst_len)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Subscript too long", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
*tmp_dst_ptr++ = '"';
|
|
|
|
|
char_ptr = m_dst.addr;
|
|
|
|
|
if (MAX_GVSUBS_LEN < (lcl_dst_len + m_dst.len))
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Subscript too long", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
for (char_count = 0; m_dst.len > char_count; char_count++)
|
|
|
|
|
{
|
|
|
|
|
if ('"' == *char_ptr)
|
|
|
|
|
{
|
|
|
|
|
if (MAX_GVSUBS_LEN < ++lcl_dst_len)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Subscript too long", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
*tmp_dst_ptr++ = '"';
|
|
|
|
|
q_len++;
|
|
|
|
|
}
|
|
|
|
|
*tmp_dst_ptr++ = *char_ptr++;
|
|
|
|
|
lcl_dst_len++;
|
|
|
|
|
}
|
|
|
|
|
if (MAX_GVSUBS_LEN < ++lcl_dst_len)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Subscript too long", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
*tmp_dst_ptr++ = '"';
|
|
|
|
|
dst_ptr = tmp_dst_ptr;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
ptr++;
|
|
|
|
|
assert(!have_star || ((dst_ptr == *d_ptr) && (lcl_dst_len == *dst_len)));
|
|
|
|
|
*src_ptr = ptr;
|
|
|
|
|
*src_len = len + 2 + q_len; /* Allow for the open and close quotes and any internal quotes */
|
|
|
|
|
*d_ptr = dst_ptr;
|
|
|
|
|
*dst_len = lcl_dst_len;
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
STATICFNDEF boolean_t process_delim(char *delim_str, uint4 *delim_len)
|
|
|
|
|
{
|
|
|
|
|
int char_count;
|
|
|
|
|
mstr dst;
|
|
|
|
|
int dst_len;
|
|
|
|
|
char *dst_ptr;
|
|
|
|
|
char dst_string[MAX_DELIM_LEN + 1];
|
|
|
|
|
uint4 len;
|
|
|
|
|
char *ptr;
|
|
|
|
|
char *ptr1;
|
|
|
|
|
int q_len;
|
|
|
|
|
char src_string[MAX_DELIM_LEN + 1];
|
|
|
|
|
mstr src;
|
|
|
|
|
char *src_ptr;
|
|
|
|
|
|
|
|
|
|
if (MAX_DELIM_LEN < *delim_len)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Delimiter too long", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
ptr = delim_str;
|
|
|
|
|
len = *delim_len;
|
|
|
|
|
src_ptr = src_string;
|
|
|
|
|
dst_len = 0;
|
|
|
|
|
/* If ", scan to end quote
|
|
|
|
|
* If $, look for char --> c or zchar --> zch
|
|
|
|
|
* If _, leave it
|
|
|
|
|
*/
|
|
|
|
|
while (0 < len)
|
|
|
|
|
{
|
|
|
|
|
switch (*ptr)
|
|
|
|
|
{
|
|
|
|
|
case '"':
|
|
|
|
|
PROCESS_STRING(ptr, len, FALSE, src_ptr, dst_len, MAX_DELIM_LEN);
|
|
|
|
|
break;
|
|
|
|
|
case '$':
|
|
|
|
|
UPDATE_DST(ptr, len, FALSE, src_ptr, dst_len, MAX_DELIM_LEN);
|
|
|
|
|
if (0 == len)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Invalid entry in delimiter", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
if ((3 < len) && ('C' == lower_to_upper_table[*ptr])
|
|
|
|
|
&& ('H' == lower_to_upper_table[*(ptr + 1)])
|
|
|
|
|
&& ('A' == lower_to_upper_table[*(ptr + 2)])
|
|
|
|
|
&& ('R' == lower_to_upper_table[*(ptr + 3)]))
|
|
|
|
|
{
|
|
|
|
|
if (MAX_DELIM_LEN < ++dst_len)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Trigger definition too long", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
*src_ptr++ = 'C';
|
|
|
|
|
ptr += 4;
|
|
|
|
|
len -= 4;
|
|
|
|
|
} else if ((4 < len) && ('Z' == lower_to_upper_table[*ptr])
|
|
|
|
|
&& ('C' == lower_to_upper_table[*(ptr + 1)])
|
|
|
|
|
&& ('H' == lower_to_upper_table[*(ptr + 2)])
|
|
|
|
|
&& ('A' == lower_to_upper_table[*(ptr + 3)])
|
|
|
|
|
&& ('R' == lower_to_upper_table[*(ptr + 4)]))
|
|
|
|
|
{
|
|
|
|
|
if (MAX_DELIM_LEN < (dst_len + 3))
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Trigger definition too long", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
MEMCPY_LIT(src_ptr, "ZCH");
|
|
|
|
|
src_ptr += 3;
|
|
|
|
|
dst_len += 3;
|
|
|
|
|
ptr += 5;
|
|
|
|
|
len -= 5;
|
|
|
|
|
} else
|
|
|
|
|
{
|
|
|
|
|
UPDATE_DST(ptr, len, FALSE, src_ptr, dst_len, MAX_DELIM_LEN);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
UPDATE_DST(ptr, len, FALSE, src_ptr, dst_len, MAX_DELIM_LEN);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
*src_ptr = '\0';
|
|
|
|
|
src.addr = src_string;
|
|
|
|
|
src.len = (mstr_len_t)(src_ptr - src_string);
|
|
|
|
|
dst.addr = dst_string;
|
|
|
|
|
dst.len = 0;
|
|
|
|
|
if (!zwr2format(&src, &dst))
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Invalid delimiter", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
if (MAX_DELIM_LEN < dst.len)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Delimiter too long", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
memcpy(delim_str, dst_string, dst.len);
|
|
|
|
|
*delim_len = dst.len;
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
boolean_t check_trigger_name(char *name_str, uint4 *name_len)
|
|
|
|
|
{
|
|
|
|
|
uint4 len, lcl_name_len;
|
|
|
|
|
unsigned char *ptr;
|
|
|
|
|
|
|
|
|
|
/* To conform to the other uses of the check_* functions and their use in the GET_CLI_STR_AND_CHECK macro
|
|
|
|
|
* name_len is passed in as a uint4 *, but in this case a uint4 would suffice. To mitigate the dereferencing
|
|
|
|
|
* issues, a local copy is used.
|
|
|
|
|
*/
|
|
|
|
|
lcl_name_len = *name_len;
|
|
|
|
|
if (MAX_USER_TRIGNAME_LEN < lcl_name_len)
|
|
|
|
|
return FALSE;
|
|
|
|
|
ptr = (unsigned char *)name_str;
|
|
|
|
|
if (('%' != *ptr) && !ISALPHA_ASCII(*ptr))
|
|
|
|
|
return FALSE;
|
|
|
|
|
for (len = lcl_name_len - 1, ptr++; (0 < len) && ISALNUM_ASCII(*ptr); ptr++, len--)
|
|
|
|
|
;
|
|
|
|
|
return (0 == len);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
STATICFNDEF boolean_t process_options(char *option_str, uint4 option_len, boolean_t *isolation, boolean_t *noisolation,
|
|
|
|
|
boolean_t *consistency, boolean_t *noconsistency)
|
|
|
|
|
{
|
|
|
|
|
char local_options[MAX_OPTIONS_LEN];
|
|
|
|
|
char *ptr;
|
|
|
|
|
|
|
|
|
|
if (MAX_OPTIONS_LEN < option_len)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Too many options", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
memcpy(local_options, option_str, option_len);
|
|
|
|
|
*isolation = *noisolation = *consistency = *noconsistency = FALSE;
|
|
|
|
|
ptr = local_options;
|
|
|
|
|
for ( ; 0 < option_len; ptr++, option_len--)
|
|
|
|
|
*ptr = TOUPPER(*ptr);
|
|
|
|
|
ptr = strtok(local_options, ",");
|
|
|
|
|
do
|
|
|
|
|
{
|
|
|
|
|
switch (*ptr)
|
|
|
|
|
{
|
|
|
|
|
case 'C':
|
|
|
|
|
if (1 == STRLEN(ptr))
|
|
|
|
|
*consistency = TRUE;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
assert(0 == MEMCMP_LIT(ptr, HASHT_OPT_CONSISTENCY));
|
|
|
|
|
*consistency = TRUE;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case 'I':
|
|
|
|
|
if (1 == STRLEN(ptr))
|
|
|
|
|
*isolation = TRUE;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
assert(0 == MEMCMP_LIT(ptr, HASHT_OPT_ISOLATION));
|
|
|
|
|
*isolation = TRUE;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case 'N':
|
|
|
|
|
assert('O' == *(ptr + 1));
|
|
|
|
|
if ('C' == *(ptr + 2))
|
|
|
|
|
{
|
|
|
|
|
assert(0 == MEMCMP_LIT(ptr, HASHT_OPT_NOCONSISTENCY));
|
|
|
|
|
*noconsistency = TRUE;
|
|
|
|
|
} else
|
|
|
|
|
{
|
|
|
|
|
assert('I' == *(ptr + 2));
|
|
|
|
|
assert(0 == MEMCMP_LIT(ptr, HASHT_OPT_NOISOLATION));
|
|
|
|
|
*noisolation = TRUE;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
GTMASSERT; /* Parsing should have found invalid command */
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
} while (ptr = strtok(NULL, ","));
|
|
|
|
|
return !((*isolation && *noisolation) || (*consistency && *noconsistency));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
STATICFNDEF boolean_t process_subscripts(char *subscr_str, uint4 *subscr_len, char **next_str)
|
|
|
|
|
{
|
|
|
|
|
boolean_t alternation;
|
|
|
|
|
char dst[MAX_GVSUBS_LEN];
|
|
|
|
|
int dst_len;
|
|
|
|
|
char *dst_ptr;
|
|
|
|
|
int len;
|
|
|
|
|
boolean_t have_pattern;
|
|
|
|
|
boolean_t have_range;
|
|
|
|
|
boolean_t have_star;
|
|
|
|
|
boolean_t have_dot;
|
|
|
|
|
int i;
|
|
|
|
|
int lvn_count;
|
|
|
|
|
uint4 lvn_len[MAX_LVN_COUNT];
|
|
|
|
|
char *lvn_start;
|
|
|
|
|
char *lvn_str[MAX_LVN_COUNT];
|
|
|
|
|
int multiplier;
|
|
|
|
|
boolean_t newsub;
|
|
|
|
|
int num1;
|
|
|
|
|
int num2;
|
|
|
|
|
char *ptr;
|
|
|
|
|
char *ptr1;
|
|
|
|
|
char *save_dst_ptr;
|
|
|
|
|
int save_len;
|
|
|
|
|
char *start_dst_ptr;
|
|
|
|
|
uint4 start_len;
|
|
|
|
|
uint4 subsc_count;
|
|
|
|
|
uint4 tmp_len;
|
|
|
|
|
boolean_t valid_sub;
|
|
|
|
|
|
|
|
|
|
error_def(ERR_INVSTRLEN);
|
|
|
|
|
|
|
|
|
|
have_pattern = have_range = valid_sub = have_star = FALSE;
|
|
|
|
|
ptr = subscr_str;
|
|
|
|
|
start_len = len = *subscr_len;
|
|
|
|
|
dst_len = 0;
|
|
|
|
|
newsub = TRUE;
|
|
|
|
|
subsc_count = lvn_count = 0;
|
|
|
|
|
start_dst_ptr = dst_ptr = dst;
|
|
|
|
|
while ((0 < len) && (')' != *ptr))
|
|
|
|
|
{
|
|
|
|
|
if (ISDIGIT_ASCII(*ptr) || ('-' == *ptr))
|
|
|
|
|
{
|
|
|
|
|
PROCESS_NUMERIC(ptr, len, have_star, dst_ptr, dst_len, MAX_GVSUBS_LEN);
|
|
|
|
|
newsub = FALSE;
|
|
|
|
|
valid_sub = TRUE;
|
|
|
|
|
}
|
|
|
|
|
else if (ISALPHA_ASCII(*ptr) || ('%' == *ptr))
|
|
|
|
|
{
|
|
|
|
|
if (!newsub)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Invalid subscript", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
lvn_start = ptr;
|
|
|
|
|
tmp_len = 0;
|
|
|
|
|
do
|
|
|
|
|
{
|
|
|
|
|
if (MAX_MIDENT_LEN < ++tmp_len)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Variable name too long", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
if (MAX_GVSUBS_LEN < ++dst_len)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Subscript too long", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
*dst_ptr++ = *ptr++;
|
|
|
|
|
len--;
|
|
|
|
|
} while (ISALNUM_ASCII(*ptr));
|
|
|
|
|
if ('=' != *ptr)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Invalid variable name in subscript", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
for (i = 0; i < lvn_count; i++)
|
|
|
|
|
{
|
|
|
|
|
if ((lvn_len[i] == tmp_len) && (0 == strncmp(lvn_str[i], lvn_start, tmp_len)))
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Duplicate variable name in subscript", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
lvn_str[lvn_count] = lvn_start;
|
|
|
|
|
lvn_len[lvn_count] = tmp_len;
|
|
|
|
|
lvn_count++;
|
|
|
|
|
if (MAX_GVSUBS_LEN < ++dst_len)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Subscript too long", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
*dst_ptr++ = *ptr++; /* move past = */
|
|
|
|
|
start_dst_ptr = dst_ptr;
|
|
|
|
|
len--;
|
|
|
|
|
if ((0 < len) && ((',' == *ptr) || (')' == *ptr)))
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Variable name not followed by valid subscript", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
continue;
|
|
|
|
|
} else
|
|
|
|
|
{
|
|
|
|
|
switch (*ptr)
|
|
|
|
|
{
|
|
|
|
|
case '"':
|
|
|
|
|
PROCESS_STRING(ptr, len, have_star, dst_ptr, dst_len, MAX_GVSUBS_LEN);
|
|
|
|
|
valid_sub = TRUE;
|
|
|
|
|
newsub = FALSE;
|
|
|
|
|
break;
|
|
|
|
|
case '$':
|
|
|
|
|
if (!process_dollar_char(&ptr, &len, have_star, &dst_ptr, &dst_len))
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Invalid subscript", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
newsub = FALSE;
|
|
|
|
|
valid_sub = TRUE;
|
|
|
|
|
break;
|
|
|
|
|
case '?':
|
|
|
|
|
if (have_range)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Range and pattern match not valid in same subscript", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
UPDATE_DST(ptr, len, have_star, dst_ptr, dst_len, MAX_GVSUBS_LEN);
|
|
|
|
|
ptr1 = ptr;
|
|
|
|
|
alternation = FALSE;
|
|
|
|
|
while ((0 < len) && ((',' != *ptr) || alternation) && ((')' != *ptr) || alternation)
|
|
|
|
|
&& (';' != *ptr))
|
|
|
|
|
{
|
|
|
|
|
num1 = num2 = -1;
|
|
|
|
|
have_dot = FALSE;
|
|
|
|
|
if (ISDIGIT_ASCII(*ptr))
|
|
|
|
|
{
|
|
|
|
|
PROCESS_AND_GET_NUMERIC(ptr, len, have_star, dst_ptr, dst_len, num1,
|
|
|
|
|
MAX_GVSUBS_LEN);
|
|
|
|
|
}
|
|
|
|
|
if ('.' == *ptr)
|
|
|
|
|
{
|
|
|
|
|
have_dot = TRUE;
|
|
|
|
|
if (MAX_GVSUBS_LEN < ++dst_len)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Subscript too long", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
*dst_ptr++ = *ptr++;
|
|
|
|
|
len--;
|
|
|
|
|
if (ISDIGIT_ASCII(*ptr))
|
|
|
|
|
{
|
|
|
|
|
PROCESS_AND_GET_NUMERIC(ptr, len, have_star, dst_ptr, dst_len, num2,
|
|
|
|
|
MAX_GVSUBS_LEN);
|
|
|
|
|
}
|
|
|
|
|
if (-1 == num1)
|
|
|
|
|
num1 = 0;
|
|
|
|
|
}
|
|
|
|
|
switch (*ptr)
|
|
|
|
|
{
|
|
|
|
|
case '(':
|
|
|
|
|
if (!alternation && (0 <= num1))
|
|
|
|
|
{
|
|
|
|
|
UPDATE_DST(ptr, len, have_star, dst_ptr, dst_len,
|
|
|
|
|
MAX_GVSUBS_LEN);
|
|
|
|
|
alternation = TRUE;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case ',':
|
|
|
|
|
if (alternation && (-1 == num1) && (-1 == num2))
|
|
|
|
|
{
|
|
|
|
|
UPDATE_DST(ptr, len, have_star, dst_ptr, dst_len,
|
|
|
|
|
MAX_GVSUBS_LEN);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case ')':
|
|
|
|
|
if (alternation && (-1 == num1) && (-1 == num2))
|
|
|
|
|
{
|
|
|
|
|
UPDATE_DST(ptr, len, have_star, dst_ptr, dst_len,
|
|
|
|
|
MAX_GVSUBS_LEN);
|
|
|
|
|
alternation = FALSE;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if ((0 <= num1) && (0 <= num2) && (num2 < num1))
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Invalid pattern match range", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
switch (toupper(*ptr))
|
|
|
|
|
{
|
|
|
|
|
case 'E':
|
|
|
|
|
if (have_dot && (0 >= num1) && (-1 == num2))
|
|
|
|
|
{ /* Treat ?.E the same as * */
|
|
|
|
|
have_star = TRUE;
|
|
|
|
|
dst_ptr = start_dst_ptr;
|
|
|
|
|
if (MAX_GVSUBS_LEN < ++dst_len)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Subscript too long", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
*dst_ptr++ = '*';
|
|
|
|
|
}
|
|
|
|
|
/* Note: we're dropping into the following case */
|
|
|
|
|
case 'A':
|
|
|
|
|
case 'C':
|
|
|
|
|
case 'K':
|
|
|
|
|
case 'L':
|
|
|
|
|
case 'N':
|
|
|
|
|
case 'P':
|
|
|
|
|
case 'U':
|
|
|
|
|
case 'V':
|
|
|
|
|
|
|
|
|
|
UPDATE_DST(ptr, len, have_star, dst_ptr, dst_len, MAX_GVSUBS_LEN);
|
|
|
|
|
break;
|
|
|
|
|
case '"':
|
|
|
|
|
PROCESS_STRING(ptr, len, have_star, dst_ptr, dst_len,
|
|
|
|
|
MAX_GVSUBS_LEN);
|
|
|
|
|
break;
|
|
|
|
|
/* Note: we're dropping into the default/error case */
|
|
|
|
|
default:
|
|
|
|
|
CONV_CH_AND_PRINT("Unexpected character !AD in pattern code", ptr);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
have_pattern = TRUE;
|
|
|
|
|
valid_sub = TRUE;
|
|
|
|
|
newsub = FALSE;
|
|
|
|
|
break;
|
|
|
|
|
case ':':
|
|
|
|
|
if (have_range)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Range within a range not allowed", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
if (have_pattern)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Pattern not allowed as a range", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
UPDATE_DST(ptr, len, have_star, dst_ptr, dst_len, MAX_GVSUBS_LEN);
|
|
|
|
|
if (ISDIGIT_ASCII(*ptr) || ('-' == *ptr))
|
|
|
|
|
{
|
|
|
|
|
PROCESS_NUMERIC(ptr, len, have_star, dst_ptr, dst_len, MAX_GVSUBS_LEN);
|
|
|
|
|
}
|
|
|
|
|
else if ('"' == *ptr)
|
|
|
|
|
{
|
|
|
|
|
PROCESS_STRING(ptr, len, have_star, dst_ptr, dst_len, MAX_GVSUBS_LEN);
|
|
|
|
|
} else if ('$' == *ptr)
|
|
|
|
|
{
|
|
|
|
|
if (!process_dollar_char(&ptr, &len, have_star, &dst_ptr, &dst_len))
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Invalid range value", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
} else if ((0 < len) && (',' != *ptr) && (';' != *ptr) && (')' != *ptr))
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Invalid string range", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
} else
|
|
|
|
|
{ /* A range with no lower end - just scan the numeric or string */
|
|
|
|
|
ptr1 = ptr;
|
|
|
|
|
if (ISDIGIT_ASCII(*ptr) || ('-' == *ptr))
|
|
|
|
|
{
|
|
|
|
|
PROCESS_NUMERIC(ptr, len, have_star, dst_ptr, dst_len, MAX_GVSUBS_LEN);
|
|
|
|
|
} else if ('"' == *ptr1)
|
|
|
|
|
{
|
|
|
|
|
PROCESS_STRING(ptr, len, have_star, dst_ptr, dst_len, MAX_GVSUBS_LEN);
|
|
|
|
|
} else if ((0 < len) && ((',' != *ptr) && (';' != *ptr) && (')' != *ptr)))
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Range value must be integer or string", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
} else if (!valid_sub)
|
|
|
|
|
{ /* this is a single ":" - treat it just like a * */
|
|
|
|
|
have_star = TRUE;
|
|
|
|
|
dst_ptr = start_dst_ptr;
|
|
|
|
|
if (MAX_GVSUBS_LEN < ++dst_len)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Subscript too long", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
*dst_ptr++ = '*';
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
valid_sub = TRUE;
|
|
|
|
|
newsub = FALSE;
|
|
|
|
|
have_range = TRUE;
|
|
|
|
|
break;
|
|
|
|
|
case '*':
|
|
|
|
|
if (!have_star)
|
|
|
|
|
{
|
|
|
|
|
have_star = TRUE;
|
|
|
|
|
dst_ptr = start_dst_ptr;
|
|
|
|
|
if (MAX_GVSUBS_LEN < ++dst_len)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Subscript too long", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
*dst_ptr++ = '*';
|
|
|
|
|
}
|
|
|
|
|
ptr++;
|
|
|
|
|
len--;
|
|
|
|
|
if ((0 < len) && (',' != *ptr) && (';' != *ptr) && (')' != *ptr))
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Invalid use of *", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
} else
|
|
|
|
|
valid_sub = TRUE;
|
|
|
|
|
newsub = FALSE;
|
|
|
|
|
break;
|
|
|
|
|
case ';':
|
|
|
|
|
UPDATE_DST(ptr, len, have_star, dst_ptr, dst_len, MAX_GVSUBS_LEN);
|
|
|
|
|
/* Delete extraneous ; in the subscript */
|
|
|
|
|
if ((!have_star) && (newsub || ((0 < len)
|
|
|
|
|
&& ((',' == *ptr) || (';' == *ptr) || ISALPHA_ASCII(*ptr)
|
|
|
|
|
|| ('%' == *ptr) || (')' == *ptr)))))
|
|
|
|
|
dst_ptr--;
|
|
|
|
|
valid_sub = FALSE;
|
|
|
|
|
have_pattern = have_range = FALSE;
|
|
|
|
|
break;
|
|
|
|
|
case ',':
|
|
|
|
|
if (newsub)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Empty subscript not allowed", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
if (MAX_GVSUBSCRIPTS <= ++subsc_count)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Too many subscripts", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
if (MAX_GVSUBS_LEN < ++dst_len)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Subscript too long", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
*dst_ptr++ = *ptr++;
|
|
|
|
|
len--;
|
|
|
|
|
start_dst_ptr = dst_ptr;
|
|
|
|
|
newsub = TRUE;
|
|
|
|
|
have_range = have_pattern = valid_sub = have_star = FALSE;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
CONV_CH_AND_PRINT("Invalid character !AD in subscript", ptr);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if ((0 == len) && (')' != *ptr))
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Missing \")\" after global subscript", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
if ((start_len == len) || newsub)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Empty subscript not allowed", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
if ((')' == *ptr) && (MAX_GVSUBSCRIPTS <= ++subsc_count))
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Too many subscripts", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
memcpy(subscr_str, dst, (int)(dst_ptr - dst));
|
|
|
|
|
*subscr_len = (uint4)(dst_ptr - dst);
|
|
|
|
|
*next_str = ptr + 1;
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
STATICFNDEF boolean_t process_pieces(char *piece_str, uint4 *piece_len)
|
|
|
|
|
{
|
|
|
|
|
uint bit;
|
|
|
|
|
uint4 bitmap[MAX_PIECE_INT];
|
|
|
|
|
uint bitval;
|
|
|
|
|
uint bitword;
|
|
|
|
|
boolean_t have_low_num;
|
|
|
|
|
boolean_t have_num;
|
|
|
|
|
boolean_t have_num_in_str;
|
|
|
|
|
uint i;
|
|
|
|
|
uint4 len;
|
|
|
|
|
int low;
|
|
|
|
|
int num;
|
|
|
|
|
char *ptr;
|
|
|
|
|
char *ptr1;
|
|
|
|
|
boolean_t have_error = FALSE;
|
|
|
|
|
int num_len;
|
|
|
|
|
|
|
|
|
|
memset((void *)bitmap, 0, MAX_PIECE_CHARS);
|
|
|
|
|
ptr = piece_str;
|
|
|
|
|
len = *piece_len;
|
|
|
|
|
have_num = have_low_num = FALSE;
|
|
|
|
|
if ('"' == *ptr)
|
|
|
|
|
{
|
|
|
|
|
ptr++;
|
|
|
|
|
len--;
|
|
|
|
|
}
|
|
|
|
|
while ((0 < len) && !have_error)
|
|
|
|
|
{
|
|
|
|
|
switch (*ptr)
|
|
|
|
|
{
|
|
|
|
|
case '0':
|
|
|
|
|
case '1':
|
|
|
|
|
case '2':
|
|
|
|
|
case '3':
|
|
|
|
|
case '4':
|
|
|
|
|
case '5':
|
|
|
|
|
case '6':
|
|
|
|
|
case '7':
|
|
|
|
|
case '8':
|
|
|
|
|
case '9':
|
|
|
|
|
ptr1 = ptr;
|
|
|
|
|
A2I(ptr1, ptr + len, num);
|
|
|
|
|
if ((0 == num) || (MAX_PIECE_VALUE < num))
|
|
|
|
|
{
|
|
|
|
|
CONV_NUM_AND_STR_AND_PRINT("Invalid value !UL in PIECES - !AD", num, *piece_len, piece_str);
|
|
|
|
|
have_error = TRUE;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
len -= (int)(ptr1 - ptr);
|
|
|
|
|
ptr = ptr1;
|
|
|
|
|
bitmap[num / BITS_PER_INT] |= 1 << (num % BITS_PER_INT);
|
|
|
|
|
have_num = TRUE;
|
|
|
|
|
have_low_num = TRUE;
|
|
|
|
|
break;
|
|
|
|
|
case ';':
|
|
|
|
|
if (!have_num)
|
|
|
|
|
{
|
|
|
|
|
CONV_STR_AND_PRINT("Expected an integer in PIECES - ", *piece_len, piece_str);
|
|
|
|
|
have_error = TRUE;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
have_num = FALSE;
|
|
|
|
|
ptr++;
|
|
|
|
|
len--;
|
|
|
|
|
break;
|
|
|
|
|
case ':':
|
|
|
|
|
if (!have_low_num)
|
|
|
|
|
{
|
|
|
|
|
CONV_STR_AND_PRINT("Expected an integer for lower value in range in PIECES - ",
|
|
|
|
|
*piece_len, piece_str);
|
|
|
|
|
have_error = TRUE;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
ptr++;
|
|
|
|
|
len--;
|
|
|
|
|
low = num;
|
|
|
|
|
if (!ISDIGIT_ASCII(*ptr))
|
|
|
|
|
{
|
|
|
|
|
CONV_STR_AND_PRINT("Expected an integer for upper value in range in PIECES - ",
|
|
|
|
|
*piece_len, piece_str);
|
|
|
|
|
have_error = TRUE;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
ptr1 = ptr;
|
|
|
|
|
A2I(ptr1, ptr + len, num);
|
|
|
|
|
if (MAX_PIECE_VALUE < num)
|
|
|
|
|
{
|
|
|
|
|
CONV_NUM_AND_STR_AND_PRINT("Invalid value \"!UL\" in PIECES - !AD", num,
|
|
|
|
|
*piece_len, piece_str);
|
|
|
|
|
have_error = TRUE;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (num <= low)
|
|
|
|
|
{
|
|
|
|
|
CONV_STR_AND_PRINT("Low value of range not less than high value in PIECES - ",
|
|
|
|
|
*piece_len, piece_str);
|
|
|
|
|
have_error = TRUE;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
len -= (int)(ptr1 - ptr);
|
|
|
|
|
ptr = ptr1;
|
|
|
|
|
for (i = low + 1; i <= num; i++)
|
|
|
|
|
bitmap[i / BITS_PER_INT] |= 1 << (i % BITS_PER_INT);
|
|
|
|
|
have_num = TRUE;
|
|
|
|
|
have_low_num = FALSE;
|
|
|
|
|
break;
|
|
|
|
|
case '"':
|
|
|
|
|
if (1 == len)
|
|
|
|
|
{
|
|
|
|
|
len--;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
default:
|
|
|
|
|
CONV_CH_AND_STR_AND_PRINT("Invalid character !AD in PIECES - !AD", ptr, *piece_len, piece_str);
|
|
|
|
|
have_error = TRUE;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if ((0 != len) || !have_num || have_error)
|
|
|
|
|
{
|
|
|
|
|
if (!have_error)
|
|
|
|
|
CONV_STR_AND_PRINT("Invalid PIECE entry - ", *piece_len, piece_str);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
have_num = have_low_num = have_num_in_str = FALSE;
|
|
|
|
|
ptr = piece_str;
|
|
|
|
|
len = 0;
|
|
|
|
|
for (i = 0; i < MAX_PIECE_INT; i++)
|
|
|
|
|
{
|
|
|
|
|
if ((0 == bitmap[i] && !have_low_num))
|
|
|
|
|
continue;
|
|
|
|
|
bitword = bitmap[i];
|
|
|
|
|
bit = 0;
|
|
|
|
|
while ((0 != bitword) || have_low_num)
|
|
|
|
|
{
|
|
|
|
|
bitval = bitword & 1;
|
|
|
|
|
if (!have_low_num)
|
|
|
|
|
{
|
|
|
|
|
if (0 == bitval)
|
|
|
|
|
{
|
|
|
|
|
bitword = bitword >> 1;
|
|
|
|
|
bit++;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
have_num = TRUE;
|
|
|
|
|
have_low_num = TRUE;
|
|
|
|
|
low = i * BITS_PER_INT + bit;
|
|
|
|
|
if (have_num_in_str)
|
|
|
|
|
{
|
|
|
|
|
*ptr++ = ';';
|
|
|
|
|
len++;
|
|
|
|
|
}
|
|
|
|
|
num_len = 0;
|
|
|
|
|
I2A(ptr, num_len, low);
|
|
|
|
|
len += num_len;
|
|
|
|
|
ptr += num_len;
|
|
|
|
|
have_num_in_str = TRUE;
|
|
|
|
|
}
|
|
|
|
|
while ((1 == bitval) && (BITS_PER_INT > bit))
|
|
|
|
|
{
|
|
|
|
|
bitword = bitword >> 1;
|
|
|
|
|
bitval = bitword & 1;
|
|
|
|
|
bit++;
|
|
|
|
|
}
|
|
|
|
|
if (BITS_PER_INT == bit)
|
|
|
|
|
break;
|
|
|
|
|
num = (0 == bit) ? i * BITS_PER_INT - 1 : i * BITS_PER_INT + bit - 1;
|
|
|
|
|
have_low_num = FALSE;
|
|
|
|
|
if (num == low)
|
|
|
|
|
continue;
|
|
|
|
|
*ptr++ = ':';
|
|
|
|
|
len++;
|
|
|
|
|
num_len = 0;
|
|
|
|
|
I2A(ptr, num_len, num);
|
|
|
|
|
len += num_len;
|
|
|
|
|
ptr += num_len;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
*ptr = '\0';
|
|
|
|
|
*piece_len = len;
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
STATICFNDEF boolean_t process_xecute(char *xecute_str, uint4 *xecute_len, boolean_t multi_line)
|
|
|
|
|
{
|
|
|
|
|
uint4 dst_len;
|
|
|
|
|
char dst_string[MAX_SRCLINE];
|
|
|
|
|
uint4 src_len;
|
|
|
|
|
gv_trigger_t trigdsc;
|
|
|
|
|
|
|
|
|
|
src_len = *xecute_len;
|
|
|
|
|
if ((src_len == XTENDED_START_LEN) && (0 == memcmp(XTENDED_START, xecute_str, XTENDED_START_LEN)))
|
|
|
|
|
return TRUE;
|
|
|
|
|
if (!multi_line && (NULL != memchr(xecute_str, '\n', src_len)))
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Newline not allowed in XECUTE string", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
if (!multi_line && MAX_SRCLINE < src_len + 1) /* allow room for leading blank */
|
|
|
|
|
{
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
if (0 == src_len)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Empty XECUTE string is invalid", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
if (!multi_line)
|
|
|
|
|
{
|
|
|
|
|
dst_string[0] = ' ';
|
|
|
|
|
if (!trigger_scan_string(xecute_str, &src_len, dst_string + 1, &dst_len) || (1 != src_len))
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Invalid XECUTE string", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
memcpy(xecute_str, dst_string, ++dst_len);
|
|
|
|
|
*xecute_len = dst_len;
|
|
|
|
|
trigdsc.xecute_str.str.addr = dst_string;
|
|
|
|
|
trigdsc.xecute_str.str.len = dst_len;
|
|
|
|
|
} else
|
|
|
|
|
{
|
|
|
|
|
trigdsc.xecute_str.str.addr = xecute_str;
|
|
|
|
|
trigdsc.xecute_str.str.len = src_len;
|
|
|
|
|
}
|
|
|
|
|
/* Test compile the string - first build up the parm list to trigger compile routine */
|
|
|
|
|
trigdsc.rtn_desc.rt_name.addr = TRIGR_PRECOMP_RTNNAME;
|
|
|
|
|
trigdsc.rtn_desc.rt_name.len = SIZEOF(TRIGR_PRECOMP_RTNNAME) - 1;
|
|
|
|
|
trigdsc.rtn_desc.rt_adr = NULL;
|
|
|
|
|
return (0 == gtm_trigger_complink(&trigdsc, FALSE));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
boolean_t trigger_parse(char *input, uint4 input_len, char *trigvn, char **values, uint4 *value_len, int4 *max_len,
|
|
|
|
|
boolean_t *multi_line_xecute)
|
|
|
|
|
{
|
|
|
|
|
boolean_t cli_status;
|
|
|
|
|
int cmd_ind;
|
|
|
|
|
int count;
|
|
|
|
|
int eof;
|
|
|
|
|
int extra;
|
|
|
|
|
boolean_t found_zkill;
|
|
|
|
|
boolean_t found_kill;
|
|
|
|
|
uint4 len;
|
|
|
|
|
int4 max_output_len;
|
|
|
|
|
int parse_ret;
|
|
|
|
|
boolean_t delim_present, name_present, pieces_present, xecute_present, zdelim_present;
|
|
|
|
|
char *ptr;
|
|
|
|
|
char *ptr1;
|
|
|
|
|
char *ptr2;
|
|
|
|
|
int4 rec_num;
|
|
|
|
|
CLI_ENTRY *save_cmd_ary;
|
|
|
|
|
boolean_t set_present;
|
|
|
|
|
int trigvn_len;
|
|
|
|
|
boolean_t in_multi_line_xecute, out_multi_line_xecute;
|
|
|
|
|
|
|
|
|
|
max_output_len = *max_len;
|
|
|
|
|
in_multi_line_xecute = out_multi_line_xecute = *multi_line_xecute;
|
|
|
|
|
if (in_multi_line_xecute)
|
|
|
|
|
{
|
|
|
|
|
if ((XTENDED_STOP_LEN != input_len) || (0 != memcmp(XTENDED_STOP, input, XTENDED_STOP_LEN)))
|
|
|
|
|
{
|
|
|
|
|
ptr1 = values[XECUTE_SUB] + value_len[XECUTE_SUB];
|
|
|
|
|
if (0 < (max_output_len - input_len - 1))
|
|
|
|
|
{
|
|
|
|
|
memcpy(ptr1, input, input_len);
|
|
|
|
|
ptr1 += input_len;
|
|
|
|
|
*ptr1 = '\n';
|
|
|
|
|
max_output_len -= (input_len + 1);
|
|
|
|
|
value_len[XECUTE_SUB] += input_len + 1;
|
|
|
|
|
*max_len = max_output_len;
|
|
|
|
|
return TRIG_SUCCESS;
|
|
|
|
|
} else
|
|
|
|
|
{
|
|
|
|
|
*multi_line_xecute = FALSE;
|
|
|
|
|
util_out_print_gtmio("Trigger definition too long", FLUSH);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
out_multi_line_xecute = FALSE;
|
|
|
|
|
if (!process_xecute(values[XECUTE_SUB], &value_len[XECUTE_SUB], TRUE))
|
|
|
|
|
{
|
|
|
|
|
*multi_line_xecute = FALSE;
|
|
|
|
|
ERROR_MSG_RETURN("Error parsing XECUTE string: ", value_len[XECUTE_SUB], values[XECUTE_SUB]);
|
|
|
|
|
}
|
|
|
|
|
*multi_line_xecute = out_multi_line_xecute;
|
|
|
|
|
*max_len = max_output_len;
|
|
|
|
|
return TRIG_SUCCESS;
|
|
|
|
|
}
|
|
|
|
|
ptr1 = input;
|
|
|
|
|
len = (uint4)input_len;
|
|
|
|
|
if ('^' != *ptr1++)
|
|
|
|
|
{
|
|
|
|
|
ERROR_MSG_RETURN("Missing global name:\n", input_len, input);
|
|
|
|
|
}
|
|
|
|
|
ptr = ptr1;
|
|
|
|
|
len--;
|
|
|
|
|
if (('%' != *ptr1) && !ISALPHA_ASCII(*ptr1))
|
|
|
|
|
{
|
|
|
|
|
ERROR_MSG_RETURN("Invalid global name:\n", input_len, input);
|
|
|
|
|
}
|
|
|
|
|
ptr1++;
|
|
|
|
|
while (ISALNUM_ASCII(*ptr1))
|
|
|
|
|
ptr1++;
|
|
|
|
|
if (('(' != *ptr1) && !ISSPACE_ASCII(*ptr1))
|
|
|
|
|
{
|
|
|
|
|
ERROR_MSG_RETURN("Invalid global name:\n", input_len, input);
|
|
|
|
|
}
|
|
|
|
|
trigvn_len = (int)(ptr1 - ptr);
|
|
|
|
|
if (MAX_MIDENT_LEN < trigvn_len)
|
|
|
|
|
{
|
|
|
|
|
trigvn_len = MAX_MIDENT_LEN;
|
|
|
|
|
util_out_print_gtmio("Warning: global name truncated to ^!AD", FLUSH, trigvn_len, ptr);
|
|
|
|
|
}
|
|
|
|
|
memcpy(trigvn, ptr, trigvn_len);
|
|
|
|
|
trigvn[trigvn_len] = '\0';
|
|
|
|
|
/* lookup global to get collation info */
|
|
|
|
|
len -= (uint4)trigvn_len;
|
|
|
|
|
ptr2 = ptr1;
|
|
|
|
|
if ('(' == *ptr1)
|
|
|
|
|
{
|
|
|
|
|
ptr1++;
|
|
|
|
|
len--;
|
|
|
|
|
if (!process_subscripts(ptr1, &len, &ptr2))
|
|
|
|
|
{
|
|
|
|
|
ERROR_MSG_RETURN("", input_len, input);
|
|
|
|
|
}
|
|
|
|
|
CHECK_FOR_ROOM_IN_OUTPUT_AND_COPY(ptr1, values[GVSUBS_SUB], len, max_output_len);
|
|
|
|
|
} else
|
|
|
|
|
len = 0;
|
|
|
|
|
if (0 > --max_output_len)
|
|
|
|
|
{
|
|
|
|
|
util_out_print_gtmio("Trigger definition too long", FLUSH);
|
|
|
|
|
return TRIG_FAILURE;
|
|
|
|
|
}
|
|
|
|
|
values[GVSUBS_SUB][len] = '\0';
|
|
|
|
|
value_len[GVSUBS_SUB] = (uint4)len;
|
|
|
|
|
save_cmd_ary = cmd_ary;
|
|
|
|
|
cmd_ary = &trigger_cmd_ary[0];
|
|
|
|
|
gtm_cli_interpret_string = FALSE;
|
|
|
|
|
cli_str_setup(input_len - (uint4)(ptr2 - input), ptr2);
|
|
|
|
|
parse_ret = parse_triggerfile_cmd();
|
|
|
|
|
gtm_cli_interpret_string = TRUE;
|
|
|
|
|
cmd_ary = save_cmd_ary;
|
|
|
|
|
if (parse_ret)
|
|
|
|
|
{
|
|
|
|
|
ERROR_MSG_RETURN("Parse error in input:\n", input_len, input);
|
|
|
|
|
}
|
|
|
|
|
values[CMD_SUB] = values[GVSUBS_SUB] + value_len[GVSUBS_SUB] + 1;
|
|
|
|
|
if (CLI_PRESENT == cli_present("COMMANDS"))
|
|
|
|
|
{
|
|
|
|
|
GET_CLI_STR("COMMANDS", max_output_len, values[CMD_SUB], value_len[CMD_SUB]);
|
|
|
|
|
ptr = values[CMD_SUB];
|
|
|
|
|
count = 0;
|
|
|
|
|
found_zkill = found_kill = FALSE;
|
|
|
|
|
/* The following order (set, kill, zkill, ztkill) needs to be maintained to match
|
|
|
|
|
* the corresponding bit value orders in gv_trig_cmd_table.h
|
|
|
|
|
*/
|
|
|
|
|
if (CLI_PRESENT == (set_present = cli_present("COMMANDS.SET")))
|
|
|
|
|
{
|
|
|
|
|
ADD_STRING(count, ptr, gvtr_cmd_mval[GVTR_CMDTYPE_SET].str.len, gvtr_cmd_mval[GVTR_CMDTYPE_SET].str.addr,
|
|
|
|
|
max_output_len);
|
|
|
|
|
}
|
|
|
|
|
if (CLI_PRESENT == cli_present("COMMANDS.KILL"))
|
|
|
|
|
{
|
|
|
|
|
found_kill = TRUE;
|
|
|
|
|
ADD_COMMA_IF_NEEDED(count, ptr, max_output_len);
|
|
|
|
|
ADD_STRING(count, ptr, gvtr_cmd_mval[GVTR_CMDTYPE_KILL].str.len, gvtr_cmd_mval[GVTR_CMDTYPE_KILL].str.addr,
|
|
|
|
|
max_output_len);
|
|
|
|
|
}
|
|
|
|
|
if (CLI_PRESENT == cli_present("COMMANDS.ZKILL"))
|
|
|
|
|
{
|
|
|
|
|
found_zkill = TRUE;
|
|
|
|
|
ADD_COMMA_IF_NEEDED(count, ptr, max_output_len);
|
|
|
|
|
ADD_STRING(count, ptr, gvtr_cmd_mval[GVTR_CMDTYPE_ZKILL].str.len,
|
|
|
|
|
gvtr_cmd_mval[GVTR_CMDTYPE_ZKILL].str.addr, max_output_len);
|
|
|
|
|
}
|
|
|
|
|
if (CLI_PRESENT == cli_present("COMMANDS.ZWITHDRAW") && !found_zkill)
|
|
|
|
|
{
|
|
|
|
|
ADD_COMMA_IF_NEEDED(count, ptr, max_output_len);
|
|
|
|
|
ADD_STRING(count, ptr, gvtr_cmd_mval[GVTR_CMDTYPE_ZKILL].str.len,
|
|
|
|
|
gvtr_cmd_mval[GVTR_CMDTYPE_ZKILL].str.addr, max_output_len);
|
|
|
|
|
}
|
|
|
|
|
if (CLI_PRESENT == cli_present("COMMANDS.ZTKILL"))
|
|
|
|
|
{
|
|
|
|
|
if (found_kill)
|
|
|
|
|
ERROR_MSG_RETURN("KILL and ZTKILL incompatible: ", value_len[CMD_SUB], values[CMD_SUB]);
|
|
|
|
|
ADD_COMMA_IF_NEEDED(count, ptr, max_output_len);
|
|
|
|
|
ADD_STRING(count, ptr, gvtr_cmd_mval[GVTR_CMDTYPE_ZTKILL].str.len,
|
|
|
|
|
gvtr_cmd_mval[GVTR_CMDTYPE_ZTKILL].str.addr, max_output_len);
|
|
|
|
|
}
|
|
|
|
|
if (CLI_PRESENT == cli_present("COMMANDS.ZTRIGGER"))
|
|
|
|
|
{
|
|
|
|
|
ADD_COMMA_IF_NEEDED(count, ptr, max_output_len);
|
|
|
|
|
ADD_STRING(count, ptr, gvtr_cmd_mval[GVTR_CMDTYPE_ZTRIGGER].str.len,
|
|
|
|
|
gvtr_cmd_mval[GVTR_CMDTYPE_ZTRIGGER].str.addr, max_output_len);
|
|
|
|
|
}
|
|
|
|
|
*ptr = '\0';
|
|
|
|
|
value_len[CMD_SUB] = STRLEN(values[CMD_SUB]);
|
|
|
|
|
} else
|
|
|
|
|
value_len[CMD_SUB] = 0;
|
|
|
|
|
UPDATE_TRIG_PTRS(values[CMD_SUB], values[DELIM_SUB], value_len[CMD_SUB], max_output_len);
|
|
|
|
|
GET_CLI_STR_AND_CHECK("DELIM", delim_present, max_output_len, process_delim, values[DELIM_SUB], value_len[DELIM_SUB],
|
|
|
|
|
values[TRIGNAME_SUB], "Error parsing DELIM string: ");
|
|
|
|
|
GET_CLI_STR_AND_CHECK("NAME", name_present, max_output_len, check_trigger_name, values[TRIGNAME_SUB],
|
|
|
|
|
value_len[TRIGNAME_SUB], values[OPTIONS_SUB], "Error parsing NAME string: ");
|
|
|
|
|
if (CLI_PRESENT == cli_present("OPTIONS"))
|
|
|
|
|
{
|
|
|
|
|
boolean_t isolation, noisolation, consistency, noconsistency;
|
|
|
|
|
|
|
|
|
|
GET_CLI_STR("OPTIONS", max_output_len, values[OPTIONS_SUB], value_len[OPTIONS_SUB]);
|
|
|
|
|
if (!process_options(values[OPTIONS_SUB], value_len[OPTIONS_SUB], &isolation, &noisolation, &consistency,
|
|
|
|
|
&noconsistency))
|
|
|
|
|
{
|
|
|
|
|
ERROR_MSG_RETURN("Inconsistent values in OPTIONS string: ", value_len[OPTIONS_SUB], values[OPTIONS_SUB]);
|
|
|
|
|
}
|
|
|
|
|
count = 0;
|
|
|
|
|
ptr = values[OPTIONS_SUB];
|
|
|
|
|
if (isolation)
|
|
|
|
|
{
|
|
|
|
|
ADD_STRING(count, ptr, STRLEN(HASHT_OPT_ISOLATION), HASHT_OPT_ISOLATION, max_output_len);
|
|
|
|
|
}
|
|
|
|
|
else if (noisolation)
|
|
|
|
|
{
|
|
|
|
|
ADD_STRING(count, ptr, STRLEN(HASHT_OPT_NOISOLATION), HASHT_OPT_NOISOLATION, max_output_len);
|
|
|
|
|
}
|
|
|
|
|
if (consistency)
|
|
|
|
|
{
|
|
|
|
|
ADD_COMMA_IF_NEEDED(count, ptr, max_output_len);
|
|
|
|
|
ADD_STRING(count, ptr, STRLEN(HASHT_OPT_CONSISTENCY), HASHT_OPT_CONSISTENCY, max_output_len);
|
|
|
|
|
}
|
|
|
|
|
else if (noconsistency)
|
|
|
|
|
{
|
|
|
|
|
ADD_COMMA_IF_NEEDED(count, ptr, max_output_len);
|
|
|
|
|
ADD_STRING(count, ptr, STRLEN(HASHT_OPT_NOCONSISTENCY), HASHT_OPT_NOCONSISTENCY, max_output_len);
|
|
|
|
|
}
|
|
|
|
|
*ptr = '\0';
|
|
|
|
|
value_len[OPTIONS_SUB] = STRLEN(values[OPTIONS_SUB]);
|
|
|
|
|
} else
|
|
|
|
|
value_len[OPTIONS_SUB] = 0;
|
|
|
|
|
UPDATE_TRIG_PTRS(values[OPTIONS_SUB], values[PIECES_SUB], value_len[OPTIONS_SUB], max_output_len);
|
|
|
|
|
GET_CLI_STR_AND_CHECK("PIECES", pieces_present, max_output_len, process_pieces, values[PIECES_SUB], value_len[PIECES_SUB],
|
|
|
|
|
values[ZDELIM_SUB], "");
|
|
|
|
|
GET_CLI_STR_AND_CHECK("ZDELIM", zdelim_present, max_output_len, process_delim, values[ZDELIM_SUB], value_len[ZDELIM_SUB],
|
|
|
|
|
values[XECUTE_SUB], "Error parsing ZDELIM string: ");
|
|
|
|
|
/* Since process_xecute() does a test compile of the xecute string, it changes the parsing table from MUPIP TRIGGER
|
|
|
|
|
* to GT.M. To avoid problems with saving and restoring the parse state (which would have to be done with globals
|
|
|
|
|
* that are static in cli_parse.c), it is much easier to put process_xecute() last in the list of qualifiers to check -
|
|
|
|
|
* solving the problem. In other words, don't try to neaten things up by making the qualifiers alphabetical!
|
|
|
|
|
*/
|
|
|
|
|
if (CLI_PRESENT == (xecute_present = cli_present("XECUTE")))
|
|
|
|
|
{
|
|
|
|
|
GET_CLI_STR("XECUTE", max_output_len, values[XECUTE_SUB], value_len[XECUTE_SUB]);
|
|
|
|
|
out_multi_line_xecute |= (value_len[XECUTE_SUB] == XTENDED_START_LEN)
|
|
|
|
|
&& (0 == memcmp(XTENDED_START, values[XECUTE_SUB], XTENDED_START_LEN));
|
|
|
|
|
if (!process_xecute(values[XECUTE_SUB], &value_len[XECUTE_SUB], out_multi_line_xecute))
|
|
|
|
|
{
|
|
|
|
|
ptr = values[XECUTE_SUB];
|
|
|
|
|
len = value_len[XECUTE_SUB];
|
|
|
|
|
ERROR_MSG_RETURN("Error parsing XECUTE string: ", len, ptr);
|
|
|
|
|
}
|
|
|
|
|
} else
|
|
|
|
|
value_len[XECUTE_SUB] = 0;
|
|
|
|
|
if (!in_multi_line_xecute)
|
|
|
|
|
{
|
|
|
|
|
max_output_len -= value_len[XECUTE_SUB];
|
|
|
|
|
UPDATE_TRIG_PTRS(values[XECUTE_SUB], values[CHSET_SUB], value_len[XECUTE_SUB], max_output_len);
|
|
|
|
|
ptr = values[XECUTE_SUB] + value_len[XECUTE_SUB];
|
|
|
|
|
*ptr = '\0';
|
|
|
|
|
if (!xecute_present && !out_multi_line_xecute)
|
|
|
|
|
{
|
|
|
|
|
ERROR_STR_RETURN("XECUTE value missing");
|
|
|
|
|
}
|
|
|
|
|
if (0 == value_len[CMD_SUB])
|
|
|
|
|
{
|
|
|
|
|
ERROR_STR_RETURN("COMMANDS value missing");
|
|
|
|
|
}
|
|
|
|
|
if (delim_present && zdelim_present)
|
|
|
|
|
{
|
|
|
|
|
ERROR_STR_RETURN("Can't have both DELIM and ZDELIM in same entry");
|
|
|
|
|
}
|
|
|
|
|
if ((delim_present || zdelim_present) && !set_present)
|
|
|
|
|
{
|
|
|
|
|
ERROR_STR_RETURN("DELIM and ZDELIM need a commands=SET");
|
|
|
|
|
}
|
|
|
|
|
if (pieces_present && (!delim_present && !zdelim_present))
|
|
|
|
|
{
|
|
|
|
|
ERROR_STR_RETURN("PIECES need either DELIM or ZDELIM");
|
|
|
|
|
}
|
|
|
|
|
if (MAX_HASH_INDEX_LEN < (trigvn_len + 1 + value_len[GVSUBS_SUB] + 1 + value_len[DELIM_SUB] + 1
|
|
|
|
|
+ value_len[ZDELIM_SUB] + 1 + value_len[XECUTE_SUB] + 1))
|
|
|
|
|
{
|
|
|
|
|
ERROR_STR_RETURN("Entry too large to properly index");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
*multi_line_xecute = out_multi_line_xecute;
|
|
|
|
|
*max_len = max_output_len;
|
|
|
|
|
return TRIG_SUCCESS;
|
|
|
|
|
}
|
