From c097164993327b91efc5b77d5dd6bbe692685c56 Mon Sep 17 00:00:00 2001 From: Emilien Lemaire Date: Thu, 20 Nov 2025 17:50:43 +0100 Subject: [PATCH 01/11] Hack is hacking --- cobc/config.def | 3 +++ cobc/field.c | 14 +++++++++++--- config/default.conf | 3 +++ 3 files changed, 17 insertions(+), 3 deletions(-) diff --git a/cobc/config.def b/cobc/config.def index ce587c5a4..cb179f900 100644 --- a/cobc/config.def +++ b/cobc/config.def @@ -117,6 +117,9 @@ CB_CONFIG_BOOLEAN (cb_complex_odo, "complex-odo", CB_CONFIG_BOOLEAN (cb_odoslide, "odoslide", _("adjust items following OCCURS DEPENDING (implies complex-odo)")) +CB_CONFIG_BOOLEAN (cb_odo_redefines, "odo-in-redefines", + _("allow ODO in REDEFINES fields")) + CB_CONFIG_BOOLEAN (cb_initial_justify, "init-justify", _("applies JUSTIFY with VALUE clause")) diff --git a/cobc/field.c b/cobc/field.c index bc1f458cf..fd83b8bd0 100644 --- a/cobc/field.c +++ b/cobc/field.c @@ -1417,14 +1417,22 @@ validate_redefines (const struct cb_field * const f) } /* Check variable occurrence */ - if (f->depending - || (!f->flag_picture_l && cb_field_variable_size (f))) { - cb_error_x (x, _("'%s' cannot be variable length"), f->name); + if (cb_odo_redefines) { + if (cb_field_variable_size(f->redefines) || f->depending) { + return; + } } + if (!f->redefines->flag_picture_l && cb_field_variable_size (f->redefines)) { cb_error_x (x, _("the original definition '%s' cannot be variable length"), f->redefines->name); } + + if (f->depending + || (!f->flag_picture_l && cb_field_variable_size (f))) { + cb_error_x (x, _("'%s' cannot be variable length"), f->name); + } + } /* Perform group-specific validation of f. */ diff --git a/config/default.conf b/config/default.conf index c4510e71c..c84b987bf 100644 --- a/config/default.conf +++ b/config/default.conf @@ -85,6 +85,9 @@ complex-odo: no # Adjust position of items following OCCURS DEPENDING odoslide: no +# Allow OCCURS DEPENDING ON in REDEFINES field +odo-in-redefines: no + # Allow REDEFINES to other than last equal level number indirect-redefines: no From 66eb0c4e3878658e83a1e8aeae9506d6c3bd7b03 Mon Sep 17 00:00:00 2001 From: Nicolas Berthier Date: Tue, 25 Nov 2025 09:59:40 +0100 Subject: [PATCH 02/11] Check for terminating periods at the end of `SET` directives --- cobc/ChangeLog | 5 +++++ cobc/ppparse.y | 13 +++++++++++-- tests/testsuite.src/run_misc.at | 12 ++++++++++++ tests/testsuite.src/syn_misc.at | 19 ++++++++++++++++++- 4 files changed, 46 insertions(+), 3 deletions(-) diff --git a/cobc/ChangeLog b/cobc/ChangeLog index 75d9c7a4a..a65c248b9 100644 --- a/cobc/ChangeLog +++ b/cobc/ChangeLog @@ -1,4 +1,9 @@ +2025-11-25 Nicolas Berthier + + * ppparse.y: error on extraneous periods at the end of SET + directives; turn to a warning in relaxed syntax mode. + 2025-11-01 Simon Sobisch * codegen.c (output_xml_parse): fixed xml state to be static-local diff --git a/cobc/ppparse.y b/cobc/ppparse.y index 06ee8c238..27bdfa1f4 100644 --- a/cobc/ppparse.y +++ b/cobc/ppparse.y @@ -894,8 +894,8 @@ if_directive_elif: ; set_directive: - set_choice -| set_directive set_choice + set_choice _unexpected_dot +| set_directive set_choice _unexpected_dot ; /* FIXME: *all* of the choices below should be #PASSED to the scanner @@ -1377,6 +1377,15 @@ _dot: | DOT ; +_unexpected_dot: +| DOT + { + if (cb_syntax_check (_("unexpected period")) == 0) { + YYERROR; + } + } +; + leap_second_directive: /* empty (OFF implied) */ | ON diff --git a/tests/testsuite.src/run_misc.at b/tests/testsuite.src/run_misc.at index e30c658e4..666c2f8b2 100644 --- a/tests/testsuite.src/run_misc.at +++ b/tests/testsuite.src/run_misc.at @@ -911,6 +911,18 @@ AT_CHECK([$COMPILE prog.cob], [0], [], []) AT_CHECK([$COBCRUN_DIRECT ./prog], [0], [OKOKOKOK]) +AT_DATA([prog2.cob], [ + $SET SOURCEFORMAT "FREE". +IDENTIFICATION DIVISION. +PROGRAM-ID. prog. +$SET SOURCEFORMAT "FIXED". + STOP RUN. +]) + +# Note: error with strict syntax is checked in syn_misc.at +AT_CHECK([$COMPILE -frelax-syntax-checks -w prog2.cob], [0], [], []) +AT_CHECK([$COBCRUN_DIRECT ./prog2], [0], []) + AT_CLEANUP diff --git a/tests/testsuite.src/syn_misc.at b/tests/testsuite.src/syn_misc.at index 72468db91..7914617a5 100644 --- a/tests/testsuite.src/syn_misc.at +++ b/tests/testsuite.src/syn_misc.at @@ -5855,11 +5855,28 @@ prog.cob:8: error: PROGRAM-ID header missing prog.cob:8: error: PROCEDURE DIVISION header missing prog.cob:8: error: syntax error, unexpected Literal ]) -AT_CLEANUP # Let's add a double quote here " to match the one in the error and # please emacs coloring... +AT_DATA([prog2.cob], [ + $SET SOURCEFORMAT"FREE". +IDENTIFICATION DIVISION. +PROGRAM-ID. prog. +$SET SOURCEFORMAT "FIXED". + PROCEDURE DIVISION. + STOP RUN. +]) +AT_CHECK([$COMPILE_ONLY prog2.cob], [1], [], +[prog2.cob:2: error: unexpected period +prog2.cob:2: error: PROGRAM-ID header missing +]) +AT_CHECK([$COMPILE_ONLY -frelax-syntax-checks prog2.cob], [0], [], +[prog2.cob:2: warning: unexpected period +prog2.cob:5: warning: unexpected period +]) +AT_CLEANUP + # normal register extension, # active for lax and standard configurations AT_SETUP([WHEN-COMPILED register in dialect]) From 10318dc544977a8d7cf6d821a1e44dd8892c81a0 Mon Sep 17 00:00:00 2001 From: Fabrice Le Fessant Date: Tue, 25 Nov 2025 22:07:03 +0100 Subject: [PATCH 03/11] Fix Nicolas's patch while waiting for remerge --- cobc/ppparse.y | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/cobc/ppparse.y b/cobc/ppparse.y index 27bdfa1f4..1bcb3eb5e 100644 --- a/cobc/ppparse.y +++ b/cobc/ppparse.y @@ -1380,9 +1380,7 @@ _dot: _unexpected_dot: | DOT { - if (cb_syntax_check (_("unexpected period")) == 0) { - YYERROR; - } + cb_syntax_check (_("unexpected period")); } ; From 76ffab92240450a66f48bd8a41a9f9dccc0e8f00 Mon Sep 17 00:00:00 2001 From: Fabrice Le Fessant Date: Tue, 25 Nov 2025 22:20:57 +0100 Subject: [PATCH 04/11] improve optional dot heuristics in DATA SECTION --- cobc/parser.y | 6 +-- cobc/scanner.l | 142 +++++++++++++++++++++++++++++++++++++++++++++---- 2 files changed, 135 insertions(+), 13 deletions(-) diff --git a/cobc/parser.y b/cobc/parser.y index 281473051..e6e401301 100644 --- a/cobc/parser.y +++ b/cobc/parser.y @@ -20430,7 +20430,6 @@ level_number_in_area_a: dot_or_else_end_of_file_description: TOK_DOT -| level_number_in_area_a /* repeats last token */ | file_description_end_delimiter { if (!cb_verify (cb_missing_period, _("optional period"))) { @@ -20451,7 +20450,6 @@ dot_or_else_end_of_record_description; dot_or_else_end_of_record_description: TOK_DOT -| level_number_in_area_a /* repeats last token */ | record_description_end_delimiter { if (!cb_verify (cb_missing_period, _("optional period"))) { @@ -20462,13 +20460,13 @@ dot_or_else_end_of_record_description: ; file_control_end_delimiter: - SELECT | I_O_CONTROL | DATA | PROCEDURE; + SELECT | I_O_CONTROL | DATA | PROCEDURE | LEVEL_NUMBER | LEVEL_NUMBER_IN_AREA_A; file_description_end_delimiter: TOK_FILE | PROCEDURE; record_description_end_delimiter: - PROCEDURE | COMMUNICATION | LOCAL_STORAGE | LINKAGE | REPORT | SCREEN; + PROCEDURE | COMMUNICATION | LOCAL_STORAGE | LINKAGE | REPORT | SCREEN | LEVEL_NUMBER_IN_AREA_A | LEVEL_NUMBER ; _dot_or_else_area_a: /* in PROCEDURE DIVISION */ TOK_DOT diff --git a/cobc/scanner.l b/cobc/scanner.l index bbd485a2e..93dbe9418 100644 --- a/cobc/scanner.l +++ b/cobc/scanner.l @@ -107,6 +107,7 @@ #define YYSTYPE cb_tree #define _PARSER_H /* work around bad Windows SDK header */ #include "parser.h" +#include "eprintf_token.def" #define RETURN_TOK(expr) \ do { \ @@ -509,7 +510,9 @@ H#[0-9A-Za-z]+ { } [0-9][0-9]? { - int value; + int value; + int return_token1; + int return_token2; /* We treat integer literals immediately after '.' as labels; that is, they must be level numbers or section names. */ @@ -520,28 +523,30 @@ H#[0-9A-Za-z]+ { value = atoi (yytext); if (value == 66) { /* level number 66 */ - RETURN_TOK (SIXTY_SIX); + return_token1 = SIXTY_SIX; goto return_token1; } else if (value == 78) { /* level number 78 */ - RETURN_TOK (SEVENTY_EIGHT); + return_token1 = SEVENTY_EIGHT; goto return_token1; } else if (value == 88) { /* level number 88 */ - RETURN_TOK (EIGHTY_EIGHT); + return_token1 = EIGHTY_EIGHT; goto return_token1; } else if ((value >= 1 && value <= 49) || value == 77) { /* level number (1 through 49, 77) */ if (cobc_in_area_a) { - RETURN_TOK (LEVEL_NUMBER_IN_AREA_A); + return_token1 = LEVEL_NUMBER_IN_AREA_A; + goto return_token1 ; } else { - RETURN_TOK (LEVEL_NUMBER); + return_token1 = LEVEL_NUMBER; + goto return_token1 ; } } } /* Integer label */ if (cobc_in_area_a) { - RETURN_TOK (WORD_IN_AREA_A); + return_token1 = WORD_IN_AREA_A; goto return_token1; } else { - RETURN_TOK (WORD); + return_token1 = WORD; goto return_token1; } } /* Numeric literal or referenced integer label @@ -550,7 +555,126 @@ H#[0-9A-Za-z]+ { integer label to typeck.c (cb_build_section_name) */ yylval = cb_build_numeric_literal (0, yytext, 0); - RETURN_TOK (LITERAL); + return_token1 = LITERAL; goto return_token1; + + return_token1: + + + /* We treat integer literals immediately after '.' as labels; + that is, they must be level numbers or section names. */ + if (last_token == TOK_DOT || cobc_in_area_a) { + yylval = cb_build_reference (yytext); + + if (!cobc_in_procedure) { + value = atoi (yytext); + if (value == 66) { + /* level number 66 */ + return_token2 = SIXTY_SIX; goto return_token2; + } else if (value == 78) { + /* level number 78 */ + return_token2 = SEVENTY_EIGHT; goto return_token2; + } else if (value == 88) { + /* level number 88 */ + return_token2 = EIGHTY_EIGHT; goto return_token2; + } else if ((value >= 1 && value <= 49) || value == 77) { + /* level number (1 through 49, 77) */ + if (cobc_in_area_a) { + return_token2 = LEVEL_NUMBER_IN_AREA_A; + goto return_token2 ; + } else { + return_token2 = LEVEL_NUMBER; + goto return_token2 ; + } + } + } + + /* Integer label */ + if (cobc_in_area_a) { + return_token2 = WORD_IN_AREA_A; goto return_token2; + } else { + return_token2 = WORD; goto return_token2; + } + } + + if (!cobc_in_procedure) { + // fprintf(stderr, "not in procedure\n"); + switch(last_token){ + case TOK_OPEN_PAREN: + case BLOCK: + case CONTAINS: + case IS: + case OCCURS: + case TO: + case THRU: + case VALUE: + case VARYING: + case WORD: + { + // fprintf(stderr, "literal '%s' after token:", yytext); + // eprintf_token(last_token); + // fprintf(stderr, "\n"); + yylval = cb_build_numeric_literal (0, yytext, 0); + return_token2 = LITERAL; + goto return_token2; + } + case LITERAL: { + switch (cb_tree_category (last_yylval)){ + case CB_CATEGORY_NUMERIC: { + // fprintf(stderr, "literal after numeric LITERAL\n"); + yylval = cb_build_numeric_literal (0, yytext, 0); + return_token2 = LITERAL; + goto return_token2; + } + default: + } + } + default: + } + // fprintf(stderr, "probably a level number\n"); + yylval = cb_build_reference (yytext); + value = atoi (yytext); + if (value == 66) { + /* level number 66 */ + return_token2 = SIXTY_SIX; goto return_token2; + } else if (value == 78) { + /* level number 78 */ + return_token2 = SEVENTY_EIGHT; goto return_token2; + } else if (value == 88) { + /* level number 88 */ + return_token2 = EIGHTY_EIGHT; goto return_token2; + } else if ((value >= 1 && value <= 49) || value == 77) { + /* level number (1 through 49, 77) */ + if (cobc_in_area_a) { + return_token2 = LEVEL_NUMBER_IN_AREA_A; + goto return_token2 ; + } else { + return_token2 = LEVEL_NUMBER; + goto return_token2 ; + } + } + return_token2 = WORD; goto return_token2; + } + /* Numeric literal or referenced integer label + remark: all transformations/checks are postponed: + literals to tree.c, + integer label to typeck.c (cb_build_section_name) + */ + yylval = cb_build_numeric_literal (0, yytext, 0); + return_token2 = LITERAL; goto return_token2; + +return_token2: + + if (return_token1 != return_token2){ + fprintf(stderr, "%s:%d: Number %s translated differently ", + cb_source_file, cb_source_line, yytext); + eprintf_token(return_token1); + fprintf(stderr, " vs "); + eprintf_token(return_token2); + fprintf(stderr, " (last token was "); + eprintf_token(last_token); + fprintf(stderr, " )\n"); + } + RETURN_TOK(return_token2); } [0-9]+ { From be73f0d34fb9597899ef94e7c46683aa798c33f4 Mon Sep 17 00:00:00 2001 From: Fabrice Le Fessant Date: Tue, 25 Nov 2025 22:21:41 +0100 Subject: [PATCH 05/11] =?UTF-8?q?Allow=20spaces=20between=20parens=20in=20?= =?UTF-8?q?PICTURE=20=C3=A0=20la=20MF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- cobc/scanner.l | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/cobc/scanner.l b/cobc/scanner.l index 93dbe9418..f59b057d7 100644 --- a/cobc/scanner.l +++ b/cobc/scanner.l @@ -1418,7 +1418,7 @@ return_token2: "IS" { /* Ignore */ } - [^ \n;]+ { + ([^ \n;(]|"("[^)]+")")+ { BEGIN INITIAL; scan_picture (yytext); RETURN_TOK (PICTURE); @@ -2411,19 +2411,23 @@ static void scan_picture (const char *text) { unsigned char *p; + unsigned char *dst; /* Scan a PICTURE clause */ /* Normalize the input */ + dst = (unsigned char*) text; for (p = (unsigned char *)text; *p; p++) { /* unput trailing '.' or ',' */ if (p[1] == 0 && (*p == '.' || *p == ',')) { unput (*p); - *p = 0; break; } - *p = cb_toupper (*p); + /* remove spaces à la MF in pictures */ + if (*p != ' '){ + *dst++ = cb_toupper (*p); + } } - + *dst = 0; yylval = CB_TREE (cb_build_picture (text)); } From 57ddc3a6497c9074bd029d7d698710101038192f Mon Sep 17 00:00:00 2001 From: Fabrice Le Fessant Date: Tue, 25 Nov 2025 22:38:36 +0100 Subject: [PATCH 06/11] remove WORD from prev_token for literal --- cobc/scanner.l | 1 - 1 file changed, 1 deletion(-) diff --git a/cobc/scanner.l b/cobc/scanner.l index f59b057d7..50aecece1 100644 --- a/cobc/scanner.l +++ b/cobc/scanner.l @@ -608,7 +608,6 @@ H#[0-9A-Za-z]+ { case THRU: case VALUE: case VARYING: - case WORD: { // fprintf(stderr, "literal '%s' after token:", yytext); // eprintf_token(last_token); From 9a7daa79e12643eeaf2337960a9aef37c65059f5 Mon Sep 17 00:00:00 2001 From: Fabrice Le Fessant Date: Tue, 25 Nov 2025 23:34:37 +0100 Subject: [PATCH 07/11] Allow extra dot between data descriptions --- cobc/parser.y | 23 +++++++++++------------ 1 file changed, 11 insertions(+), 12 deletions(-) diff --git a/cobc/parser.y b/cobc/parser.y index e6e401301..d97004c21 100644 --- a/cobc/parser.y +++ b/cobc/parser.y @@ -7053,8 +7053,7 @@ working_storage: WORKING_STORAGE { check_area_a_of ("WORKING-STORAGE SECTION"); _working_storage_section: /* empty */ -| working_storage SECTION - dot_or_else_end_of_record_description +| working_storage SECTION _dot { check_headers_present (COBC_HD_DATA_DIVISION, 0, 0, 0); header_check |= COBC_HD_WORKING_STORAGE_SECTION; @@ -7088,7 +7087,7 @@ _record_description_list: record_description_list: data_description dot_or_else_end_of_record_description -| record_description_list data_description dot_or_else_end_of_record_description +| record_description_list _extra_dot data_description dot_or_else_end_of_record_description ; data_description: @@ -20408,6 +20407,15 @@ _dot: } ; +_extra_dot: +| TOK_DOT + { + if (!cb_verify (cb_missing_period, _("extra period"))) { + YYERROR; + } + } +; + dot_or_else_end_of_file_control: TOK_DOT | file_control_end_delimiter @@ -20419,15 +20427,6 @@ dot_or_else_end_of_file_control: } ; -level_number_in_area_a: - LEVEL_NUMBER_IN_AREA_A - { - /* No need to raise the error for *_IN_AREA_A tokens */ - (void) cb_verify (cb_missing_period, _("optional period")); - cobc_repeat_last_token = 1; - } -; - dot_or_else_end_of_file_description: TOK_DOT | file_description_end_delimiter From 3ea19dada9e1b095e536de2b18fe3b7d58f7584a Mon Sep 17 00:00:00 2001 From: Fabrice Le Fessant Date: Tue, 25 Nov 2025 23:34:52 +0100 Subject: [PATCH 08/11] Macro MUST_PRINT_TOKENS to display tokens as they are generated --- cobc/scanner.l | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/cobc/scanner.l b/cobc/scanner.l index 50aecece1..5657807b1 100644 --- a/cobc/scanner.l +++ b/cobc/scanner.l @@ -109,11 +109,21 @@ #include "parser.h" #include "eprintf_token.def" +#ifdef MUST_PRINT_TOKENS +#define PRINT_TOK(expr) \ + fprintf(stderr, "%s:%d:token ", cb_source_file, cb_source_line); \ + eprintf_token(expr); \ + fprintf(stderr, "\n") +#else +#define PRINT_TOK(expr) +#endif + #define RETURN_TOK(expr) \ do { \ last_yylval = yylval; \ second_last_token = last_token; \ last_token = (expr); \ + PRINT_TOK(last_token); \ return last_token; \ } ONCE_COB From 493bcc8b6dd30f0faf048349377c54d83d224cf5 Mon Sep 17 00:00:00 2001 From: Fabrice Le Fessant Date: Tue, 25 Nov 2025 23:53:10 +0100 Subject: [PATCH 09/11] Commit missing eprintf_token.def file --- cobc/eprintf_token.def | 985 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 985 insertions(+) create mode 100644 cobc/eprintf_token.def diff --git a/cobc/eprintf_token.def b/cobc/eprintf_token.def new file mode 100644 index 000000000..d46fc1e4d --- /dev/null +++ b/cobc/eprintf_token.def @@ -0,0 +1,985 @@ +/* TODO: we should probably auto-generate this file from parser.h... one day */ + +static void eprintf_token(int token){ + switch(token){ + + case TOKEN_EOF: { fprintf(stderr, "TOKEN_EOF"); return; } + case YYUNDEF: { fprintf(stderr, "YYUNDEF"); return; } + case THREEDIMENSIONAL: { fprintf(stderr, "THREEDIMENSIONAL"); return; } + case ABSENT: { fprintf(stderr, "ABSENT"); return; } + case ACCEPT: { fprintf(stderr, "ACCEPT"); return; } + case ACCESS: { fprintf(stderr, "ACCESS"); return; } + case ACTIVEX: { fprintf(stderr, "ACTIVEX"); return; } + case ACTIVE_CLASS: { fprintf(stderr, "ACTIVE_CLASS"); return; } + case ACTION: { fprintf(stderr, "ACTION"); return; } + case ACTUAL: { fprintf(stderr, "ACTUAL"); return; } + case ADD: { fprintf(stderr, "ADD"); return; } + case ADDRESS: { fprintf(stderr, "ADDRESS"); return; } + case ADJUSTABLE_COLUMNS: { fprintf(stderr, "ADJUSTABLE_COLUMNS"); return; } + case ADVANCING: { fprintf(stderr, "ADVANCING"); return; } + case AFTER: { fprintf(stderr, "AFTER"); return; } + case ALIGNED: { fprintf(stderr, "ALIGNED"); return; } + case ALIGNMENT: { fprintf(stderr, "ALIGNMENT"); return; } + case ALL: { fprintf(stderr, "ALL"); return; } + case ALLOCATE: { fprintf(stderr, "ALLOCATE"); return; } + case ALLOWING: { fprintf(stderr, "ALLOWING"); return; } + case ALPHABET: { fprintf(stderr, "ALPHABET"); return; } + case ALPHABETIC: { fprintf(stderr, "ALPHABETIC"); return; } + case ALPHABETIC_LOWER: { fprintf(stderr, "ALPHABETIC_LOWER"); return; } + case ALPHABETIC_UPPER: { fprintf(stderr, "ALPHABETIC_UPPER"); return; } + case ALPHANUMERIC: { fprintf(stderr, "ALPHANUMERIC"); return; } + case ALPHANUMERIC_EDITED: { fprintf(stderr, "ALPHANUMERIC_EDITED"); return; } + case ALSO: { fprintf(stderr, "ALSO"); return; } + case ALTER: { fprintf(stderr, "ALTER"); return; } + case ALTERNATE: { fprintf(stderr, "ALTERNATE"); return; } + case AND: { fprintf(stderr, "AND"); return; } + case ANY: { fprintf(stderr, "ANY"); return; } + case APPLY: { fprintf(stderr, "APPLY"); return; } + case ARE: { fprintf(stderr, "ARE"); return; } + case AREA: { fprintf(stderr, "AREA"); return; } + case AREAS: { fprintf(stderr, "AREAS"); return; } + case ARGUMENT_NUMBER: { fprintf(stderr, "ARGUMENT_NUMBER"); return; } + case ARGUMENT_VALUE: { fprintf(stderr, "ARGUMENT_VALUE"); return; } + case ARITHMETIC: { fprintf(stderr, "ARITHMETIC"); return; } + case AS: { fprintf(stderr, "AS"); return; } + case ASCENDING: { fprintf(stderr, "ASCENDING"); return; } + case ASCII: { fprintf(stderr, "ASCII"); return; } + case ASSIGN: { fprintf(stderr, "ASSIGN"); return; } + case AT: { fprintf(stderr, "AT"); return; } + case AT_END: { fprintf(stderr, "AT_END"); return; } + case ATTRIBUTE: { fprintf(stderr, "ATTRIBUTE"); return; } + case ATTRIBUTES: { fprintf(stderr, "ATTRIBUTES"); return; } + case AUTHOR: { fprintf(stderr, "AUTHOR"); return; } + case AUTO: { fprintf(stderr, "AUTO"); return; } + case AUTO_DECIMAL: { fprintf(stderr, "AUTO_DECIMAL"); return; } + case AUTO_SPIN: { fprintf(stderr, "AUTO_SPIN"); return; } + case AUTOMATIC: { fprintf(stderr, "AUTOMATIC"); return; } + case AWAY_FROM_ZERO: { fprintf(stderr, "AWAY_FROM_ZERO"); return; } + case B_AND: { fprintf(stderr, "B_AND"); return; } + case B_NOT: { fprintf(stderr, "B_NOT"); return; } + case B_OR: { fprintf(stderr, "B_OR"); return; } + case B_XOR: { fprintf(stderr, "B_XOR"); return; } + case B_SHIFT_L: { fprintf(stderr, "B_SHIFT_L"); return; } + case B_SHIFT_R: { fprintf(stderr, "B_SHIFT_R"); return; } + case B_SHIFT_LC: { fprintf(stderr, "B_SHIFT_LC"); return; } + case B_SHIFT_RC: { fprintf(stderr, "B_SHIFT_RC"); return; } + case BACKGROUND_COLOR: { fprintf(stderr, "BACKGROUND_COLOR"); return; } + case BACKGROUND_HIGH: { fprintf(stderr, "BACKGROUND_HIGH"); return; } + case BACKGROUND_LOW: { fprintf(stderr, "BACKGROUND_LOW"); return; } + case BACKGROUND_STANDARD: { fprintf(stderr, "BACKGROUND_STANDARD"); return; } + case BACKWARD: { fprintf(stderr, "BACKWARD"); return; } + case BAR: { fprintf(stderr, "BAR"); return; } + case BASED: { fprintf(stderr, "BASED"); return; } + case BEFORE: { fprintf(stderr, "BEFORE"); return; } + case BELL: { fprintf(stderr, "BELL"); return; } + case BINARY: { fprintf(stderr, "BINARY"); return; } + case BINARY_C_LONG: { fprintf(stderr, "BINARY_C_LONG"); return; } + case BINARY_CHAR: { fprintf(stderr, "BINARY_CHAR"); return; } + case BINARY_DOUBLE: { fprintf(stderr, "BINARY_DOUBLE"); return; } + case BINARY_LONG: { fprintf(stderr, "BINARY_LONG"); return; } + case BINARY_SEQUENTIAL: { fprintf(stderr, "BINARY_SEQUENTIAL"); return; } + case BINARY_SHORT: { fprintf(stderr, "BINARY_SHORT"); return; } + case BIT: { fprintf(stderr, "BIT"); return; } + case BITMAP: { fprintf(stderr, "BITMAP"); return; } + case BITMAP_END: { fprintf(stderr, "BITMAP_END"); return; } + case BITMAP_HANDLE: { fprintf(stderr, "BITMAP_HANDLE"); return; } + case BITMAP_NUMBER: { fprintf(stderr, "BITMAP_NUMBER"); return; } + case BITMAP_START: { fprintf(stderr, "BITMAP_START"); return; } + case BITMAP_TIMER: { fprintf(stderr, "BITMAP_TIMER"); return; } + case BITMAP_TRAILING: { fprintf(stderr, "BITMAP_TRAILING"); return; } + case BITMAP_TRANSPARENT_COLOR: { fprintf(stderr, "BITMAP_TRANSPARENT_COLOR"); return; } + case BITMAP_WIDTH: { fprintf(stderr, "BITMAP_WIDTH"); return; } + case BLANK: { fprintf(stderr, "BLANK"); return; } + case BLINK: { fprintf(stderr, "BLINK"); return; } + case BLOCK: { fprintf(stderr, "BLOCK"); return; } + case BOOLEAN: { fprintf(stderr, "BOOLEAN"); return; } + case BOTTOM: { fprintf(stderr, "BOTTOM"); return; } + case BOX: { fprintf(stderr, "BOX"); return; } + case BOXED: { fprintf(stderr, "BOXED"); return; } + case BULK_ADDITION: { fprintf(stderr, "BULK_ADDITION"); return; } + case BUSY: { fprintf(stderr, "BUSY"); return; } + case BUTTONS: { fprintf(stderr, "BUTTONS"); return; } + case BY: { fprintf(stderr, "BY"); return; } + case BYTE_LENGTH: { fprintf(stderr, "BYTE_LENGTH"); return; } + case C: { fprintf(stderr, "C"); return; } + case CALENDAR_FONT: { fprintf(stderr, "CALENDAR_FONT"); return; } + case CALL: { fprintf(stderr, "CALL"); return; } + case CANCEL: { fprintf(stderr, "CANCEL"); return; } + case CANCEL_BUTTON: { fprintf(stderr, "CANCEL_BUTTON"); return; } + case CAPACITY: { fprintf(stderr, "CAPACITY"); return; } + case CARD_PUNCH: { fprintf(stderr, "CARD_PUNCH"); return; } + case CARD_READER: { fprintf(stderr, "CARD_READER"); return; } + case CASSETTE: { fprintf(stderr, "CASSETTE"); return; } + case CCOL: { fprintf(stderr, "CCOL"); return; } + case CD: { fprintf(stderr, "CD"); return; } + case CELL: { fprintf(stderr, "CELL"); return; } + case CELL_COLOR: { fprintf(stderr, "CELL_COLOR"); return; } + case CELL_DATA: { fprintf(stderr, "CELL_DATA"); return; } + case CELL_FONT: { fprintf(stderr, "CELL_FONT"); return; } + case CELL_PROTECTION: { fprintf(stderr, "CELL_PROTECTION"); return; } + case CENTER: { fprintf(stderr, "CENTER"); return; } + case CENTERED: { fprintf(stderr, "CENTERED"); return; } + case CENTERED_HEADINGS: { fprintf(stderr, "CENTERED_HEADINGS"); return; } + case CENTURY_DATE: { fprintf(stderr, "CENTURY_DATE"); return; } + case CF: { fprintf(stderr, "CF"); return; } + case CH: { fprintf(stderr, "CH"); return; } + case CHAINING: { fprintf(stderr, "CHAINING"); return; } + case CHANGED: { fprintf(stderr, "CHANGED"); return; } + case CHARACTER: { fprintf(stderr, "CHARACTER"); return; } + case CHARACTERS: { fprintf(stderr, "CHARACTERS"); return; } + case CHECK_BOX: { fprintf(stderr, "CHECK_BOX"); return; } + case CLASS: { fprintf(stderr, "CLASS"); return; } + case CLASSIFICATION: { fprintf(stderr, "CLASSIFICATION"); return; } + case CLASS_NAME: { fprintf(stderr, "CLASS_NAME"); return; } + case CLEAR_SELECTION: { fprintf(stderr, "CLEAR_SELECTION"); return; } + case CLINE: { fprintf(stderr, "CLINE"); return; } + case CLINES: { fprintf(stderr, "CLINES"); return; } + case CLOSE: { fprintf(stderr, "CLOSE"); return; } + case COBOL: { fprintf(stderr, "COBOL"); return; } + case CODE: { fprintf(stderr, "CODE"); return; } + case CODE_SET: { fprintf(stderr, "CODE_SET"); return; } + case COLLATING: { fprintf(stderr, "COLLATING"); return; } + case COL: { fprintf(stderr, "COL"); return; } + case COLOR: { fprintf(stderr, "COLOR"); return; } + case COLORS: { fprintf(stderr, "COLORS"); return; } + case COLS: { fprintf(stderr, "COLS"); return; } + case COLUMN: { fprintf(stderr, "COLUMN"); return; } + case COLUMN_COLOR: { fprintf(stderr, "COLUMN_COLOR"); return; } + case COLUMN_DIVIDERS: { fprintf(stderr, "COLUMN_DIVIDERS"); return; } + case COLUMN_FONT: { fprintf(stderr, "COLUMN_FONT"); return; } + case COLUMN_HEADINGS: { fprintf(stderr, "COLUMN_HEADINGS"); return; } + case COLUMN_PROTECTION: { fprintf(stderr, "COLUMN_PROTECTION"); return; } + case COLUMNS: { fprintf(stderr, "COLUMNS"); return; } + case COMBO_BOX: { fprintf(stderr, "COMBO_BOX"); return; } + case COMMA: { fprintf(stderr, "COMMA"); return; } + case COMMAND_LINE: { fprintf(stderr, "COMMAND_LINE"); return; } + case COMMA_DELIM: { fprintf(stderr, "COMMA_DELIM"); return; } + case COMMIT: { fprintf(stderr, "COMMIT"); return; } + case COMMON: { fprintf(stderr, "COMMON"); return; } + case COMMUNICATION: { fprintf(stderr, "COMMUNICATION"); return; } + case COMP: { fprintf(stderr, "COMP"); return; } + case COMPUTE: { fprintf(stderr, "COMPUTE"); return; } + case COMP_0: { fprintf(stderr, "COMP_0"); return; } + case COMP_1: { fprintf(stderr, "COMP_1"); return; } + case COMP_2: { fprintf(stderr, "COMP_2"); return; } + case COMP_3: { fprintf(stderr, "COMP_3"); return; } + case COMP_4: { fprintf(stderr, "COMP_4"); return; } + case COMP_5: { fprintf(stderr, "COMP_5"); return; } + case COMP_6: { fprintf(stderr, "COMP_6"); return; } + case COMP_N: { fprintf(stderr, "COMP_N"); return; } + case COMP_X: { fprintf(stderr, "COMP_X"); return; } + case CONCATENATE_FUNC: { fprintf(stderr, "CONCATENATE_FUNC"); return; } + case CONDITION: { fprintf(stderr, "CONDITION"); return; } + case CONFIGURATION: { fprintf(stderr, "CONFIGURATION"); return; } + case CONSTANT: { fprintf(stderr, "CONSTANT"); return; } + case CONTAINS: { fprintf(stderr, "CONTAINS"); return; } + case CONTENT: { fprintf(stderr, "CONTENT"); return; } + case CONTENT_LENGTH_FUNC: { fprintf(stderr, "CONTENT_LENGTH_FUNC"); return; } + case CONTENT_OF_FUNC: { fprintf(stderr, "CONTENT_OF_FUNC"); return; } + case CONTINUE: { fprintf(stderr, "CONTINUE"); return; } + case CONTROL: { fprintf(stderr, "CONTROL"); return; } + case CONTROLS: { fprintf(stderr, "CONTROLS"); return; } + case CONVERSION: { fprintf(stderr, "CONVERSION"); return; } + case CONVERTING: { fprintf(stderr, "CONVERTING"); return; } + case COPY: { fprintf(stderr, "COPY"); return; } + case COPY_SELECTION: { fprintf(stderr, "COPY_SELECTION"); return; } + case CORE_INDEX: { fprintf(stderr, "CORE_INDEX"); return; } + case CORRESPONDING: { fprintf(stderr, "CORRESPONDING"); return; } + case COUNT: { fprintf(stderr, "COUNT"); return; } + case CRT: { fprintf(stderr, "CRT"); return; } + case CRT_UNDER: { fprintf(stderr, "CRT_UNDER"); return; } + case CSIZE: { fprintf(stderr, "CSIZE"); return; } + case CURRENCY: { fprintf(stderr, "CURRENCY"); return; } + case CURRENT_DATE_FUNC: { fprintf(stderr, "CURRENT_DATE_FUNC"); return; } + case CURSOR: { fprintf(stderr, "CURSOR"); return; } + case CURSOR_COL: { fprintf(stderr, "CURSOR_COL"); return; } + case CURSOR_COLOR: { fprintf(stderr, "CURSOR_COLOR"); return; } + case CURSOR_FRAME_WIDTH: { fprintf(stderr, "CURSOR_FRAME_WIDTH"); return; } + case CURSOR_ROW: { fprintf(stderr, "CURSOR_ROW"); return; } + case CURSOR_X: { fprintf(stderr, "CURSOR_X"); return; } + case CURSOR_Y: { fprintf(stderr, "CURSOR_Y"); return; } + case CUSTOM_PRINT_TEMPLATE: { fprintf(stderr, "CUSTOM_PRINT_TEMPLATE"); return; } + case CYCLE: { fprintf(stderr, "CYCLE"); return; } + case CYL_INDEX: { fprintf(stderr, "CYL_INDEX"); return; } + case CYL_OVERFLOW: { fprintf(stderr, "CYL_OVERFLOW"); return; } + case DASHED: { fprintf(stderr, "DASHED"); return; } + case DATA: { fprintf(stderr, "DATA"); return; } + case DATA_COLUMNS: { fprintf(stderr, "DATA_COLUMNS"); return; } + case DATA_POINTER: { fprintf(stderr, "DATA_POINTER"); return; } + case DATA_TYPES: { fprintf(stderr, "DATA_TYPES"); return; } + case DATE: { fprintf(stderr, "DATE"); return; } + case DATE_COMPILED: { fprintf(stderr, "DATE_COMPILED"); return; } + case DATE_ENTRY: { fprintf(stderr, "DATE_ENTRY"); return; } + case DATE_MODIFIED: { fprintf(stderr, "DATE_MODIFIED"); return; } + case DATE_WRITTEN: { fprintf(stderr, "DATE_WRITTEN"); return; } + case DAY: { fprintf(stderr, "DAY"); return; } + case DAY_OF_WEEK: { fprintf(stderr, "DAY_OF_WEEK"); return; } + case DE: { fprintf(stderr, "DE"); return; } + case DEBUGGING: { fprintf(stderr, "DEBUGGING"); return; } + case DECIMAL_POINT: { fprintf(stderr, "DECIMAL_POINT"); return; } + case DECLARATIVES: { fprintf(stderr, "DECLARATIVES"); return; } + case DEFAULT: { fprintf(stderr, "DEFAULT"); return; } + case DEFAULT_BUTTON: { fprintf(stderr, "DEFAULT_BUTTON"); return; } + case DEFAULT_FONT: { fprintf(stderr, "DEFAULT_FONT"); return; } + case DELETE: { fprintf(stderr, "DELETE"); return; } + case DELIMITED: { fprintf(stderr, "DELIMITED"); return; } + case DELIMITER: { fprintf(stderr, "DELIMITER"); return; } + case DEPENDING: { fprintf(stderr, "DEPENDING"); return; } + case DESCENDING: { fprintf(stderr, "DESCENDING"); return; } + case DESTINATION: { fprintf(stderr, "DESTINATION"); return; } + case DESTROY: { fprintf(stderr, "DESTROY"); return; } + case DETAIL: { fprintf(stderr, "DETAIL"); return; } + case DISABLE: { fprintf(stderr, "DISABLE"); return; } + case DISC: { fprintf(stderr, "DISC"); return; } + case DISK: { fprintf(stderr, "DISK"); return; } + case DISP: { fprintf(stderr, "DISP"); return; } + case DISPLAY: { fprintf(stderr, "DISPLAY"); return; } + case DISPLAY_1: { fprintf(stderr, "DISPLAY_1"); return; } + case DISPLAY_COLUMNS: { fprintf(stderr, "DISPLAY_COLUMNS"); return; } + case DISPLAY_FORMAT: { fprintf(stderr, "DISPLAY_FORMAT"); return; } + case DISPLAY_OF_FUNC: { fprintf(stderr, "DISPLAY_OF_FUNC"); return; } + case DIVIDE: { fprintf(stderr, "DIVIDE"); return; } + case DIVIDERS: { fprintf(stderr, "DIVIDERS"); return; } + case DIVIDER_COLOR: { fprintf(stderr, "DIVIDER_COLOR"); return; } + case DIVISION: { fprintf(stderr, "DIVISION"); return; } + case DOTDASH: { fprintf(stderr, "DOTDASH"); return; } + case DOTTED: { fprintf(stderr, "DOTTED"); return; } + case DRAG_COLOR: { fprintf(stderr, "DRAG_COLOR"); return; } + case DROP_DOWN: { fprintf(stderr, "DROP_DOWN"); return; } + case DROP_LIST: { fprintf(stderr, "DROP_LIST"); return; } + case DOWN: { fprintf(stderr, "DOWN"); return; } + case DUPLICATES: { fprintf(stderr, "DUPLICATES"); return; } + case DYNAMIC: { fprintf(stderr, "DYNAMIC"); return; } + case EBCDIC: { fprintf(stderr, "EBCDIC"); return; } + case EC: { fprintf(stderr, "EC"); return; } + case ECHO: { fprintf(stderr, "ECHO"); return; } + case EGI: { fprintf(stderr, "EGI"); return; } + case EIGHTY_EIGHT: { fprintf(stderr, "EIGHTY_EIGHT"); return; } + case ENABLE: { fprintf(stderr, "ENABLE"); return; } + case ELEMENT: { fprintf(stderr, "ELEMENT"); return; } + case ELSE: { fprintf(stderr, "ELSE"); return; } + case EMI: { fprintf(stderr, "EMI"); return; } + case ENCRYPTION: { fprintf(stderr, "ENCRYPTION"); return; } + case ENCODING: { fprintf(stderr, "ENCODING"); return; } + case END: { fprintf(stderr, "END"); return; } + case END_ACCEPT: { fprintf(stderr, "END_ACCEPT"); return; } + case END_ADD: { fprintf(stderr, "END_ADD"); return; } + case END_CALL: { fprintf(stderr, "END_CALL"); return; } + case END_COMPUTE: { fprintf(stderr, "END_COMPUTE"); return; } + case END_COLOR: { fprintf(stderr, "END_COLOR"); return; } + case END_DELETE: { fprintf(stderr, "END_DELETE"); return; } + case END_DISPLAY: { fprintf(stderr, "END_DISPLAY"); return; } + case END_DIVIDE: { fprintf(stderr, "END_DIVIDE"); return; } + case END_EVALUATE: { fprintf(stderr, "END_EVALUATE"); return; } + case END_FUNCTION: { fprintf(stderr, "END_FUNCTION"); return; } + case END_IF: { fprintf(stderr, "END_IF"); return; } + case END_JSON: { fprintf(stderr, "END_JSON"); return; } + case END_MODIFY: { fprintf(stderr, "END_MODIFY"); return; } + case END_MULTIPLY: { fprintf(stderr, "END_MULTIPLY"); return; } + case END_PERFORM: { fprintf(stderr, "END_PERFORM"); return; } + case END_PROGRAM: { fprintf(stderr, "END_PROGRAM"); return; } + case END_READ: { fprintf(stderr, "END_READ"); return; } + case END_RECEIVE: { fprintf(stderr, "END_RECEIVE"); return; } + case END_RETURN: { fprintf(stderr, "END_RETURN"); return; } + case END_REWRITE: { fprintf(stderr, "END_REWRITE"); return; } + case END_SEARCH: { fprintf(stderr, "END_SEARCH"); return; } + case END_SEND: { fprintf(stderr, "END_SEND"); return; } + case END_START: { fprintf(stderr, "END_START"); return; } + case END_STRING: { fprintf(stderr, "END_STRING"); return; } + case END_SUBTRACT: { fprintf(stderr, "END_SUBTRACT"); return; } + case END_UNSTRING: { fprintf(stderr, "END_UNSTRING"); return; } + case END_WRITE: { fprintf(stderr, "END_WRITE"); return; } + case END_XML: { fprintf(stderr, "END_XML"); return; } + case ENGRAVED: { fprintf(stderr, "ENGRAVED"); return; } + case ENSURE_VISIBLE: { fprintf(stderr, "ENSURE_VISIBLE"); return; } + case ENTRY: { fprintf(stderr, "ENTRY"); return; } + case ENTRY_CONVENTION: { fprintf(stderr, "ENTRY_CONVENTION"); return; } + case ENTRY_FIELD: { fprintf(stderr, "ENTRY_FIELD"); return; } + case ENTRY_REASON: { fprintf(stderr, "ENTRY_REASON"); return; } + case ENVIRONMENT: { fprintf(stderr, "ENVIRONMENT"); return; } + case ENVIRONMENT_NAME: { fprintf(stderr, "ENVIRONMENT_NAME"); return; } + case ENVIRONMENT_VALUE: { fprintf(stderr, "ENVIRONMENT_VALUE"); return; } + case EOL: { fprintf(stderr, "EOL"); return; } + case EOP: { fprintf(stderr, "EOP"); return; } + case EOS: { fprintf(stderr, "EOS"); return; } + case EQUAL: { fprintf(stderr, "EQUAL"); return; } + case ERASE: { fprintf(stderr, "ERASE"); return; } + case ERROR: { fprintf(stderr, "ERROR"); return; } + case ESCAPE: { fprintf(stderr, "ESCAPE"); return; } + case ESCAPE_BUTTON: { fprintf(stderr, "ESCAPE_BUTTON"); return; } + case ESI: { fprintf(stderr, "ESI"); return; } + case EVALUATE: { fprintf(stderr, "EVALUATE"); return; } + case EVENT: { fprintf(stderr, "EVENT"); return; } + case EVENT_LIST: { fprintf(stderr, "EVENT_LIST"); return; } + case EVENT_STATUS: { fprintf(stderr, "EVENT_STATUS"); return; } + case EVERY: { fprintf(stderr, "EVERY"); return; } + case EXAMINE: { fprintf(stderr, "EXAMINE"); return; } + case EXCEPTION: { fprintf(stderr, "EXCEPTION"); return; } + case EXCEPTION_CONDITION: { fprintf(stderr, "EXCEPTION_CONDITION"); return; } + case EXCEPTION_VALUE: { fprintf(stderr, "EXCEPTION_VALUE"); return; } + case EXPAND: { fprintf(stderr, "EXPAND"); return; } + case EXCLUSIVE: { fprintf(stderr, "EXCLUSIVE"); return; } + case EXHIBIT: { fprintf(stderr, "EXHIBIT"); return; } + case EXIT: { fprintf(stderr, "EXIT"); return; } + case EXPONENTIATION: { fprintf(stderr, "EXPONENTIATION"); return; } + case EXTEND: { fprintf(stderr, "EXTEND"); return; } + case EXTENDED_SEARCH: { fprintf(stderr, "EXTENDED_SEARCH"); return; } + case EXTERNAL: { fprintf(stderr, "EXTERNAL"); return; } + case EXTERNAL_FORM: { fprintf(stderr, "EXTERNAL_FORM"); return; } + case F: { fprintf(stderr, "F"); return; } + case FACTORY: { fprintf(stderr, "FACTORY"); return; } + case FD: { fprintf(stderr, "FD"); return; } + case FH__FCD: { fprintf(stderr, "FH__FCD"); return; } + case FH__KEYDEF: { fprintf(stderr, "FH__KEYDEF"); return; } + case FILE_CONTROL: { fprintf(stderr, "FILE_CONTROL"); return; } + case FILE_ID: { fprintf(stderr, "FILE_ID"); return; } + case FILE_LIMIT: { fprintf(stderr, "FILE_LIMIT"); return; } + case FILE_LIMITS: { fprintf(stderr, "FILE_LIMITS"); return; } + case FILE_NAME: { fprintf(stderr, "FILE_NAME"); return; } + case FILE_POS: { fprintf(stderr, "FILE_POS"); return; } + case FILL_COLOR: { fprintf(stderr, "FILL_COLOR"); return; } + case FILL_COLOR2: { fprintf(stderr, "FILL_COLOR2"); return; } + case FILL_PERCENT: { fprintf(stderr, "FILL_PERCENT"); return; } + case FILLER: { fprintf(stderr, "FILLER"); return; } + case FINAL: { fprintf(stderr, "FINAL"); return; } + case FINISH_REASON: { fprintf(stderr, "FINISH_REASON"); return; } + case FIRST: { fprintf(stderr, "FIRST"); return; } + case FIXED: { fprintf(stderr, "FIXED"); return; } + case FIXED_FONT: { fprintf(stderr, "FIXED_FONT"); return; } + case FIXED_WIDTH: { fprintf(stderr, "FIXED_WIDTH"); return; } + case FLAT: { fprintf(stderr, "FLAT"); return; } + case FLAT_BUTTONS: { fprintf(stderr, "FLAT_BUTTONS"); return; } + case FLOAT_BINARY_128: { fprintf(stderr, "FLOAT_BINARY_128"); return; } + case FLOAT_BINARY_32: { fprintf(stderr, "FLOAT_BINARY_32"); return; } + case FLOAT_BINARY_64: { fprintf(stderr, "FLOAT_BINARY_64"); return; } + case FLOAT_DECIMAL_16: { fprintf(stderr, "FLOAT_DECIMAL_16"); return; } + case FLOAT_DECIMAL_34: { fprintf(stderr, "FLOAT_DECIMAL_34"); return; } + case FLOAT_DECIMAL_7: { fprintf(stderr, "FLOAT_DECIMAL_7"); return; } + case FLOAT_EXTENDED: { fprintf(stderr, "FLOAT_EXTENDED"); return; } + case FLOAT_LONG: { fprintf(stderr, "FLOAT_LONG"); return; } + case FLOAT_SHORT: { fprintf(stderr, "FLOAT_SHORT"); return; } + case FLOATING: { fprintf(stderr, "FLOATING"); return; } + case FONT: { fprintf(stderr, "FONT"); return; } + case FOOTING: { fprintf(stderr, "FOOTING"); return; } + case FOR: { fprintf(stderr, "FOR"); return; } + case FOREGROUND_COLOR: { fprintf(stderr, "FOREGROUND_COLOR"); return; } + case FOREVER: { fprintf(stderr, "FOREVER"); return; } + case FORMAT: { fprintf(stderr, "FORMAT"); return; } + case FORMATTED_DATE_FUNC: { fprintf(stderr, "FORMATTED_DATE_FUNC"); return; } + case FORMATTED_DATETIME_FUNC: { fprintf(stderr, "FORMATTED_DATETIME_FUNC"); return; } + case FORMATTED_TIME_FUNC: { fprintf(stderr, "FORMATTED_TIME_FUNC"); return; } + case FRAME: { fprintf(stderr, "FRAME"); return; } + case FRAMED: { fprintf(stderr, "FRAMED"); return; } + case FREE: { fprintf(stderr, "FREE"); return; } + case FROM: { fprintf(stderr, "FROM"); return; } + case FROM_CRT: { fprintf(stderr, "FROM_CRT"); return; } + case FULL: { fprintf(stderr, "FULL"); return; } + case FULL_HEIGHT: { fprintf(stderr, "FULL_HEIGHT"); return; } + case FUNCTION: { fprintf(stderr, "FUNCTION"); return; } + case FUNCTION_ID: { fprintf(stderr, "FUNCTION_ID"); return; } + case FUNCTION_NAME: { fprintf(stderr, "FUNCTION_NAME"); return; } + case FUNCTION_POINTER: { fprintf(stderr, "FUNCTION_POINTER"); return; } + case GENERATE: { fprintf(stderr, "GENERATE"); return; } + case GIVING: { fprintf(stderr, "GIVING"); return; } + case GLOBAL: { fprintf(stderr, "GLOBAL"); return; } + case GO: { fprintf(stderr, "GO"); return; } + case GO_BACK: { fprintf(stderr, "GO_BACK"); return; } + case GO_FORWARD: { fprintf(stderr, "GO_FORWARD"); return; } + case GO_HOME: { fprintf(stderr, "GO_HOME"); return; } + case GO_SEARCH: { fprintf(stderr, "GO_SEARCH"); return; } + case GOBACK: { fprintf(stderr, "GOBACK"); return; } + case GRAPHICAL: { fprintf(stderr, "GRAPHICAL"); return; } + case GREATER: { fprintf(stderr, "GREATER"); return; } + case GREATER_OR_EQUAL: { fprintf(stderr, "GREATER_OR_EQUAL"); return; } + case GRID: { fprintf(stderr, "GRID"); return; } + case GROUP: { fprintf(stderr, "GROUP"); return; } + case GROUP_VALUE: { fprintf(stderr, "GROUP_VALUE"); return; } + case HANDLE: { fprintf(stderr, "HANDLE"); return; } + case HAS_CHILDREN: { fprintf(stderr, "HAS_CHILDREN"); return; } + case HEADING: { fprintf(stderr, "HEADING"); return; } + case HEADING_COLOR: { fprintf(stderr, "HEADING_COLOR"); return; } + case HEADING_DIVIDER_COLOR: { fprintf(stderr, "HEADING_DIVIDER_COLOR"); return; } + case HEADING_FONT: { fprintf(stderr, "HEADING_FONT"); return; } + case HEAVY: { fprintf(stderr, "HEAVY"); return; } + case HEIGHT_IN_CELLS: { fprintf(stderr, "HEIGHT_IN_CELLS"); return; } + case HIDDEN_DATA: { fprintf(stderr, "HIDDEN_DATA"); return; } + case HIGHLIGHT: { fprintf(stderr, "HIGHLIGHT"); return; } + case HIGH_COLOR: { fprintf(stderr, "HIGH_COLOR"); return; } + case HIGH_VALUE: { fprintf(stderr, "HIGH_VALUE"); return; } + case HOT_TRACK: { fprintf(stderr, "HOT_TRACK"); return; } + case HSCROLL: { fprintf(stderr, "HSCROLL"); return; } + case HSCROLL_POS: { fprintf(stderr, "HSCROLL_POS"); return; } + case ICON: { fprintf(stderr, "ICON"); return; } + case ID: { fprintf(stderr, "ID"); return; } + case IDENTIFIED: { fprintf(stderr, "IDENTIFIED"); return; } + case IDENTIFICATION: { fprintf(stderr, "IDENTIFICATION"); return; } + case IF: { fprintf(stderr, "IF"); return; } + case IGNORE: { fprintf(stderr, "IGNORE"); return; } + case IGNORING: { fprintf(stderr, "IGNORING"); return; } + case IN: { fprintf(stderr, "IN"); return; } + case INDEPENDENT: { fprintf(stderr, "INDEPENDENT"); return; } + case INDEX: { fprintf(stderr, "INDEX"); return; } + case INDEXED: { fprintf(stderr, "INDEXED"); return; } + case INDICATE: { fprintf(stderr, "INDICATE"); return; } + case INITIALIZE: { fprintf(stderr, "INITIALIZE"); return; } + case INITIALIZED: { fprintf(stderr, "INITIALIZED"); return; } + case INITIATE: { fprintf(stderr, "INITIATE"); return; } + case INPUT: { fprintf(stderr, "INPUT"); return; } + case INPUT_OUTPUT: { fprintf(stderr, "INPUT_OUTPUT"); return; } + case INQUIRE: { fprintf(stderr, "INQUIRE"); return; } + case INSERTION_INDEX: { fprintf(stderr, "INSERTION_INDEX"); return; } + case INSERT_ROWS: { fprintf(stderr, "INSERT_ROWS"); return; } + case INSPECT: { fprintf(stderr, "INSPECT"); return; } + case INSTALLATION: { fprintf(stderr, "INSTALLATION"); return; } + case INTERMEDIATE: { fprintf(stderr, "INTERMEDIATE"); return; } + case INTO: { fprintf(stderr, "INTO"); return; } + case INTRINSIC: { fprintf(stderr, "INTRINSIC"); return; } + case INVALID: { fprintf(stderr, "INVALID"); return; } + case INVALID_KEY: { fprintf(stderr, "INVALID_KEY"); return; } + case IS: { fprintf(stderr, "IS"); return; } + case ITEM: { fprintf(stderr, "ITEM"); return; } + case ITEM_TEXT: { fprintf(stderr, "ITEM_TEXT"); return; } + case ITEM_TO_ADD: { fprintf(stderr, "ITEM_TO_ADD"); return; } + case ITEM_TO_DELETE: { fprintf(stderr, "ITEM_TO_DELETE"); return; } + case ITEM_TO_EMPTY: { fprintf(stderr, "ITEM_TO_EMPTY"); return; } + case ITEM_VALUE: { fprintf(stderr, "ITEM_VALUE"); return; } + case I_O: { fprintf(stderr, "I_O"); return; } + case I_O_CONTROL: { fprintf(stderr, "I_O_CONTROL"); return; } + case JSON: { fprintf(stderr, "JSON"); return; } + case JUSTIFIED: { fprintf(stderr, "JUSTIFIED"); return; } + case KEPT: { fprintf(stderr, "KEPT"); return; } + case KEY: { fprintf(stderr, "KEY"); return; } + case KEYBOARD: { fprintf(stderr, "KEYBOARD"); return; } + case LABEL: { fprintf(stderr, "LABEL"); return; } + case LABEL_OFFSET: { fprintf(stderr, "LABEL_OFFSET"); return; } + case LARGE_FONT: { fprintf(stderr, "LARGE_FONT"); return; } + case LARGE_OFFSET: { fprintf(stderr, "LARGE_OFFSET"); return; } + case LAST: { fprintf(stderr, "LAST"); return; } + case LAST_ROW: { fprintf(stderr, "LAST_ROW"); return; } + case LAYOUT_DATA: { fprintf(stderr, "LAYOUT_DATA"); return; } + case LAYOUT_MANAGER: { fprintf(stderr, "LAYOUT_MANAGER"); return; } + case LEADING: { fprintf(stderr, "LEADING"); return; } + case LEADING_SHIFT: { fprintf(stderr, "LEADING_SHIFT"); return; } + case LEAVE: { fprintf(stderr, "LEAVE"); return; } + case LEFT: { fprintf(stderr, "LEFT"); return; } + case LEFTLINE: { fprintf(stderr, "LEFTLINE"); return; } + case LEFT_TEXT: { fprintf(stderr, "LEFT_TEXT"); return; } + case LENGTH: { fprintf(stderr, "LENGTH"); return; } + case LENGTH_OF: { fprintf(stderr, "LENGTH_OF"); return; } + case LENGTH_FUNC: { fprintf(stderr, "LENGTH_FUNC"); return; } + case LESS: { fprintf(stderr, "LESS"); return; } + case LESS_OR_EQUAL: { fprintf(stderr, "LESS_OR_EQUAL"); return; } + case LEVEL_NUMBER: { fprintf(stderr, "LEVEL_NUMBER"); return; } + case LIKE: { fprintf(stderr, "LIKE"); return; } + case LIMIT: { fprintf(stderr, "LIMIT"); return; } + case LIMITS: { fprintf(stderr, "LIMITS"); return; } + case LINAGE: { fprintf(stderr, "LINAGE"); return; } + case LINAGE_COUNTER: { fprintf(stderr, "LINAGE_COUNTER"); return; } + case LINE: { fprintf(stderr, "LINE"); return; } + case LINE_COUNTER: { fprintf(stderr, "LINE_COUNTER"); return; } + case LINE_LIMIT: { fprintf(stderr, "LINE_LIMIT"); return; } + case LINE_SEQUENTIAL: { fprintf(stderr, "LINE_SEQUENTIAL"); return; } + case LINES: { fprintf(stderr, "LINES"); return; } + case LINES_AT_ROOT: { fprintf(stderr, "LINES_AT_ROOT"); return; } + case LINKAGE: { fprintf(stderr, "LINKAGE"); return; } + case LIST_BOX: { fprintf(stderr, "LIST_BOX"); return; } + case LITERAL: { fprintf(stderr, "LITERAL"); return; } + case LM_RESIZE: { fprintf(stderr, "LM_RESIZE"); return; } + case LOC: { fprintf(stderr, "LOC"); return; } + case LOCALE: { fprintf(stderr, "LOCALE"); return; } + case LOCALE_DATE_FUNC: { fprintf(stderr, "LOCALE_DATE_FUNC"); return; } + case LOCALE_TIME_FUNC: { fprintf(stderr, "LOCALE_TIME_FUNC"); return; } + case LOCALE_TIME_FROM_FUNC: { fprintf(stderr, "LOCALE_TIME_FROM_FUNC"); return; } + case LOCAL_STORAGE: { fprintf(stderr, "LOCAL_STORAGE"); return; } + case LOCK: { fprintf(stderr, "LOCK"); return; } + case LOCK_HOLDING: { fprintf(stderr, "LOCK_HOLDING"); return; } + case LONG_DATE: { fprintf(stderr, "LONG_DATE"); return; } + case LOWER: { fprintf(stderr, "LOWER"); return; } + case LOWERED: { fprintf(stderr, "LOWERED"); return; } + case LOWER_CASE_FUNC: { fprintf(stderr, "LOWER_CASE_FUNC"); return; } + case LOWLIGHT: { fprintf(stderr, "LOWLIGHT"); return; } + case LOW_COLOR: { fprintf(stderr, "LOW_COLOR"); return; } + case LOW_VALUE: { fprintf(stderr, "LOW_VALUE"); return; } + case MAGNETIC_TAPE: { fprintf(stderr, "MAGNETIC_TAPE"); return; } + case MANUAL: { fprintf(stderr, "MANUAL"); return; } + case MASS_UPDATE: { fprintf(stderr, "MASS_UPDATE"); return; } + case MASTER_INDEX: { fprintf(stderr, "MASTER_INDEX"); return; } + case MAX_LINES: { fprintf(stderr, "MAX_LINES"); return; } + case MAX_PROGRESS: { fprintf(stderr, "MAX_PROGRESS"); return; } + case MAX_TEXT: { fprintf(stderr, "MAX_TEXT"); return; } + case MAX_VAL: { fprintf(stderr, "MAX_VAL"); return; } + case MEMORY: { fprintf(stderr, "MEMORY"); return; } + case MEDIUM_FONT: { fprintf(stderr, "MEDIUM_FONT"); return; } + case MENU: { fprintf(stderr, "MENU"); return; } + case MERGE: { fprintf(stderr, "MERGE"); return; } + case MESSAGE: { fprintf(stderr, "MESSAGE"); return; } + case MICROSECOND_TIME: { fprintf(stderr, "MICROSECOND_TIME"); return; } + case MINUS: { fprintf(stderr, "MINUS"); return; } + case MIN_VAL: { fprintf(stderr, "MIN_VAL"); return; } + case MNEMONIC_NAME: { fprintf(stderr, "MNEMONIC_NAME"); return; } + case MODAL: { fprintf(stderr, "MODAL"); return; } + case MODE: { fprintf(stderr, "MODE"); return; } + case MODELESS: { fprintf(stderr, "MODELESS"); return; } + case MODIFY: { fprintf(stderr, "MODIFY"); return; } + case MODULES: { fprintf(stderr, "MODULES"); return; } + case MOVE: { fprintf(stderr, "MOVE"); return; } + case MULTILINE: { fprintf(stderr, "MULTILINE"); return; } + case MULTIPLE: { fprintf(stderr, "MULTIPLE"); return; } + case MULTIPLY: { fprintf(stderr, "MULTIPLY"); return; } + case NAME: { fprintf(stderr, "NAME"); return; } + case NAMED: { fprintf(stderr, "NAMED"); return; } + case NAMESPACE: { fprintf(stderr, "NAMESPACE"); return; } + case NAMESPACE_PREFIX: { fprintf(stderr, "NAMESPACE_PREFIX"); return; } + case NATIONAL: { fprintf(stderr, "NATIONAL"); return; } + case NATIONAL_EDITED: { fprintf(stderr, "NATIONAL_EDITED"); return; } + case NATIONAL_OF_FUNC: { fprintf(stderr, "NATIONAL_OF_FUNC"); return; } + case NATIVE: { fprintf(stderr, "NATIVE"); return; } + case NAVIGATE_URL: { fprintf(stderr, "NAVIGATE_URL"); return; } + case NEAREST_AWAY_FROM_ZERO: { fprintf(stderr, "NEAREST_AWAY_FROM_ZERO"); return; } + case NEAREST_EVEN: { fprintf(stderr, "NEAREST_EVEN"); return; } + case NEAREST_TOWARD_ZERO: { fprintf(stderr, "NEAREST_TOWARD_ZERO"); return; } + case NEGATIVE: { fprintf(stderr, "NEGATIVE"); return; } + case NESTED: { fprintf(stderr, "NESTED"); return; } + case NEW: { fprintf(stderr, "NEW"); return; } + case NEXT: { fprintf(stderr, "NEXT"); return; } + case NEXT_ITEM: { fprintf(stderr, "NEXT_ITEM"); return; } + case NEXT_GROUP: { fprintf(stderr, "NEXT_GROUP"); return; } + case NEXT_PAGE: { fprintf(stderr, "NEXT_PAGE"); return; } + case NO: { fprintf(stderr, "NO"); return; } + case NO_ADVANCING: { fprintf(stderr, "NO_ADVANCING"); return; } + case NO_AUTOSEL: { fprintf(stderr, "NO_AUTOSEL"); return; } + case NO_AUTO_DEFAULT: { fprintf(stderr, "NO_AUTO_DEFAULT"); return; } + case NO_BOX: { fprintf(stderr, "NO_BOX"); return; } + case NO_DATA: { fprintf(stderr, "NO_DATA"); return; } + case NO_DIVIDERS: { fprintf(stderr, "NO_DIVIDERS"); return; } + case NO_ECHO: { fprintf(stderr, "NO_ECHO"); return; } + case NO_F4: { fprintf(stderr, "NO_F4"); return; } + case NO_FOCUS: { fprintf(stderr, "NO_FOCUS"); return; } + case NO_GROUP_TAB: { fprintf(stderr, "NO_GROUP_TAB"); return; } + case NO_KEY_LETTER: { fprintf(stderr, "NO_KEY_LETTER"); return; } + case NO_SEARCH: { fprintf(stderr, "NO_SEARCH"); return; } + case NO_UPDOWN: { fprintf(stderr, "NO_UPDOWN"); return; } + case NOMINAL: { fprintf(stderr, "NOMINAL"); return; } + case NONE: { fprintf(stderr, "NONE"); return; } + case NONNUMERIC: { fprintf(stderr, "NONNUMERIC"); return; } + case NORMAL: { fprintf(stderr, "NORMAL"); return; } + case NOT: { fprintf(stderr, "NOT"); return; } + case NOTAB: { fprintf(stderr, "NOTAB"); return; } + case NOTHING: { fprintf(stderr, "NOTHING"); return; } + case NOTIFY: { fprintf(stderr, "NOTIFY"); return; } + case NOTIFY_CHANGE: { fprintf(stderr, "NOTIFY_CHANGE"); return; } + case NOTIFY_DBLCLICK: { fprintf(stderr, "NOTIFY_DBLCLICK"); return; } + case NOTIFY_SELCHANGE: { fprintf(stderr, "NOTIFY_SELCHANGE"); return; } + case NOT_AT_END: { fprintf(stderr, "NOT_AT_END"); return; } + case NOT_EOP: { fprintf(stderr, "NOT_EOP"); return; } + case NOT_ON_ESCAPE: { fprintf(stderr, "NOT_ON_ESCAPE"); return; } + case NOT_EQUAL: { fprintf(stderr, "NOT_EQUAL"); return; } + case NOT_ON_EXCEPTION: { fprintf(stderr, "NOT_ON_EXCEPTION"); return; } + case NOT_INVALID_KEY: { fprintf(stderr, "NOT_INVALID_KEY"); return; } + case NOT_ON_OVERFLOW: { fprintf(stderr, "NOT_ON_OVERFLOW"); return; } + case NOT_SIZE_ERROR: { fprintf(stderr, "NOT_SIZE_ERROR"); return; } + case NUM_COL_HEADINGS: { fprintf(stderr, "NUM_COL_HEADINGS"); return; } + case NUM_ROWS: { fprintf(stderr, "NUM_ROWS"); return; } + case NUMBER: { fprintf(stderr, "NUMBER"); return; } + case NUMBERS: { fprintf(stderr, "NUMBERS"); return; } + case NUMERIC: { fprintf(stderr, "NUMERIC"); return; } + case NUMERIC_EDITED: { fprintf(stderr, "NUMERIC_EDITED"); return; } + case NUMVALC_FUNC: { fprintf(stderr, "NUMVALC_FUNC"); return; } + case OBJECT: { fprintf(stderr, "OBJECT"); return; } + case OBJECT_COMPUTER: { fprintf(stderr, "OBJECT_COMPUTER"); return; } + case OCCURS: { fprintf(stderr, "OCCURS"); return; } + case OF: { fprintf(stderr, "OF"); return; } + case OFF: { fprintf(stderr, "OFF"); return; } + case OK_BUTTON: { fprintf(stderr, "OK_BUTTON"); return; } + case OMITTED: { fprintf(stderr, "OMITTED"); return; } + case ON: { fprintf(stderr, "ON"); return; } + case ONLY: { fprintf(stderr, "ONLY"); return; } + case ON_ESCAPE: { fprintf(stderr, "ON_ESCAPE"); return; } + case ON_EXCEPTION: { fprintf(stderr, "ON_EXCEPTION"); return; } + case OPEN: { fprintf(stderr, "OPEN"); return; } + case OPTIONAL: { fprintf(stderr, "OPTIONAL"); return; } + case OPTIONS: { fprintf(stderr, "OPTIONS"); return; } + case OR: { fprintf(stderr, "OR"); return; } + case ORDER: { fprintf(stderr, "ORDER"); return; } + case ORGANIZATION: { fprintf(stderr, "ORGANIZATION"); return; } + case OTHER: { fprintf(stderr, "OTHER"); return; } + case OTHERS: { fprintf(stderr, "OTHERS"); return; } + case OUTPUT: { fprintf(stderr, "OUTPUT"); return; } + case OVERLAP_LEFT: { fprintf(stderr, "OVERLAP_LEFT"); return; } + case OVERLAP_TOP: { fprintf(stderr, "OVERLAP_TOP"); return; } + case OVERLINE: { fprintf(stderr, "OVERLINE"); return; } + case PACKED_DECIMAL: { fprintf(stderr, "PACKED_DECIMAL"); return; } + case PADDING: { fprintf(stderr, "PADDING"); return; } + case PASCAL: { fprintf(stderr, "PASCAL"); return; } + case PAGE: { fprintf(stderr, "PAGE"); return; } + case PAGE_COUNTER: { fprintf(stderr, "PAGE_COUNTER"); return; } + case PAGE_SETUP: { fprintf(stderr, "PAGE_SETUP"); return; } + case PAGED: { fprintf(stderr, "PAGED"); return; } + case PARAGRAPH: { fprintf(stderr, "PARAGRAPH"); return; } + case PARENT: { fprintf(stderr, "PARENT"); return; } + case PARSE: { fprintf(stderr, "PARSE"); return; } + case PASSWORD: { fprintf(stderr, "PASSWORD"); return; } + case PERFORM: { fprintf(stderr, "PERFORM"); return; } + case PERMANENT: { fprintf(stderr, "PERMANENT"); return; } + case PH: { fprintf(stderr, "PH"); return; } + case PF: { fprintf(stderr, "PF"); return; } + case PHYSICAL: { fprintf(stderr, "PHYSICAL"); return; } + case PICTURE: { fprintf(stderr, "PICTURE"); return; } + case PICTURE_SYMBOL: { fprintf(stderr, "PICTURE_SYMBOL"); return; } + case PIXEL: { fprintf(stderr, "PIXEL"); return; } + case PLACEMENT: { fprintf(stderr, "PLACEMENT"); return; } + case PLUS: { fprintf(stderr, "PLUS"); return; } + case POINTER: { fprintf(stderr, "POINTER"); return; } + case POP_UP: { fprintf(stderr, "POP_UP"); return; } + case POS: { fprintf(stderr, "POS"); return; } + case POSITION: { fprintf(stderr, "POSITION"); return; } + case POSITION_SHIFT: { fprintf(stderr, "POSITION_SHIFT"); return; } + case POSITIVE: { fprintf(stderr, "POSITIVE"); return; } + case PRESENT: { fprintf(stderr, "PRESENT"); return; } + case PREVIOUS: { fprintf(stderr, "PREVIOUS"); return; } + case PRINT: { fprintf(stderr, "PRINT"); return; } + case PRINT_CONTROL: { fprintf(stderr, "PRINT_CONTROL"); return; } + case PRINT_NO_PROMPT: { fprintf(stderr, "PRINT_NO_PROMPT"); return; } + case PRINT_PREVIEW: { fprintf(stderr, "PRINT_PREVIEW"); return; } + case PRINTER: { fprintf(stderr, "PRINTER"); return; } + case PRINTER_1: { fprintf(stderr, "PRINTER_1"); return; } + case PRINTING: { fprintf(stderr, "PRINTING"); return; } + case PRIORITY: { fprintf(stderr, "PRIORITY"); return; } + case PROCEDURE: { fprintf(stderr, "PROCEDURE"); return; } + case PROCEDURES: { fprintf(stderr, "PROCEDURES"); return; } + case PROCEED: { fprintf(stderr, "PROCEED"); return; } + case PROCESSING: { fprintf(stderr, "PROCESSING"); return; } + case PROGRAM: { fprintf(stderr, "PROGRAM"); return; } + case PROGRAM_ID: { fprintf(stderr, "PROGRAM_ID"); return; } + case PROGRAM_NAME: { fprintf(stderr, "PROGRAM_NAME"); return; } + case PROGRAM_POINTER: { fprintf(stderr, "PROGRAM_POINTER"); return; } + case PROGRESS: { fprintf(stderr, "PROGRESS"); return; } + case PROHIBITED: { fprintf(stderr, "PROHIBITED"); return; } + case PROMPT: { fprintf(stderr, "PROMPT"); return; } + case PROPERTIES: { fprintf(stderr, "PROPERTIES"); return; } + case PROPERTY: { fprintf(stderr, "PROPERTY"); return; } + case PROTECTED: { fprintf(stderr, "PROTECTED"); return; } + case PROTOTYPE: { fprintf(stderr, "PROTOTYPE"); return; } + case PURGE: { fprintf(stderr, "PURGE"); return; } + case PUSH_BUTTON: { fprintf(stderr, "PUSH_BUTTON"); return; } + case QUERY_INDEX: { fprintf(stderr, "QUERY_INDEX"); return; } + case QUEUE: { fprintf(stderr, "QUEUE"); return; } + case QUOTE: { fprintf(stderr, "QUOTE"); return; } + case RADIO_BUTTON: { fprintf(stderr, "RADIO_BUTTON"); return; } + case RAISE: { fprintf(stderr, "RAISE"); return; } + case RAISED: { fprintf(stderr, "RAISED"); return; } + case RAISING: { fprintf(stderr, "RAISING"); return; } + case RANDOM: { fprintf(stderr, "RANDOM"); return; } + case RD: { fprintf(stderr, "RD"); return; } + case READ: { fprintf(stderr, "READ"); return; } + case READERS: { fprintf(stderr, "READERS"); return; } + case READ_ONLY: { fprintf(stderr, "READ_ONLY"); return; } + case READY: { fprintf(stderr, "READY"); return; } + case RECEIVE: { fprintf(stderr, "RECEIVE"); return; } + case RECEIVED: { fprintf(stderr, "RECEIVED"); return; } + case RECORD: { fprintf(stderr, "RECORD"); return; } + case RECORD_DATA: { fprintf(stderr, "RECORD_DATA"); return; } + case RECORD_OVERFLOW: { fprintf(stderr, "RECORD_OVERFLOW"); return; } + case RECORD_TO_ADD: { fprintf(stderr, "RECORD_TO_ADD"); return; } + case RECORD_TO_DELETE: { fprintf(stderr, "RECORD_TO_DELETE"); return; } + case RECORDING: { fprintf(stderr, "RECORDING"); return; } + case RECORDS: { fprintf(stderr, "RECORDS"); return; } + case RECURSIVE: { fprintf(stderr, "RECURSIVE"); return; } + case REDEFINES: { fprintf(stderr, "REDEFINES"); return; } + case REEL: { fprintf(stderr, "REEL"); return; } + case REFERENCE: { fprintf(stderr, "REFERENCE"); return; } + case REFERENCES: { fprintf(stderr, "REFERENCES"); return; } + case REFRESH: { fprintf(stderr, "REFRESH"); return; } + case REGION_COLOR: { fprintf(stderr, "REGION_COLOR"); return; } + case RELATION: { fprintf(stderr, "RELATION"); return; } + case RELATIVE: { fprintf(stderr, "RELATIVE"); return; } + case RELEASE: { fprintf(stderr, "RELEASE"); return; } + case REMAINDER: { fprintf(stderr, "REMAINDER"); return; } + case REMARKS: { fprintf(stderr, "REMARKS"); return; } + case REMOVAL: { fprintf(stderr, "REMOVAL"); return; } + case RENAMES: { fprintf(stderr, "RENAMES"); return; } + case REORG_CRITERIA: { fprintf(stderr, "REORG_CRITERIA"); return; } + case REPEATED: { fprintf(stderr, "REPEATED"); return; } + case REPLACE: { fprintf(stderr, "REPLACE"); return; } + case REPLACING: { fprintf(stderr, "REPLACING"); return; } + case REPORT: { fprintf(stderr, "REPORT"); return; } + case REPORTING: { fprintf(stderr, "REPORTING"); return; } + case REPORTS: { fprintf(stderr, "REPORTS"); return; } + case REPOSITORY: { fprintf(stderr, "REPOSITORY"); return; } + case REQUIRED: { fprintf(stderr, "REQUIRED"); return; } + case REREAD: { fprintf(stderr, "REREAD"); return; } + case RERUN: { fprintf(stderr, "RERUN"); return; } + case RESERVE: { fprintf(stderr, "RESERVE"); return; } + case RESET: { fprintf(stderr, "RESET"); return; } + case RESET_GRID: { fprintf(stderr, "RESET_GRID"); return; } + case RESET_LIST: { fprintf(stderr, "RESET_LIST"); return; } + case RESET_TABS: { fprintf(stderr, "RESET_TABS"); return; } + case RETRY: { fprintf(stderr, "RETRY"); return; } + case RETURN: { fprintf(stderr, "RETURN"); return; } + case RETURNING: { fprintf(stderr, "RETURNING"); return; } + case REVERSE: { fprintf(stderr, "REVERSE"); return; } + case REVERSE_FUNC: { fprintf(stderr, "REVERSE_FUNC"); return; } + case REVERSE_VIDEO: { fprintf(stderr, "REVERSE_VIDEO"); return; } + case REVERSED: { fprintf(stderr, "REVERSED"); return; } + case REWIND: { fprintf(stderr, "REWIND"); return; } + case REWRITE: { fprintf(stderr, "REWRITE"); return; } + case RF: { fprintf(stderr, "RF"); return; } + case RH: { fprintf(stderr, "RH"); return; } + case RIGHT: { fprintf(stderr, "RIGHT"); return; } + case RIGHT_ALIGN: { fprintf(stderr, "RIGHT_ALIGN"); return; } + case RIGHTLINE: { fprintf(stderr, "RIGHTLINE"); return; } + case RIMMED: { fprintf(stderr, "RIMMED"); return; } + case ROLLBACK: { fprintf(stderr, "ROLLBACK"); return; } + case ROUNDED: { fprintf(stderr, "ROUNDED"); return; } + case ROUNDING: { fprintf(stderr, "ROUNDING"); return; } + case ROW_COLOR: { fprintf(stderr, "ROW_COLOR"); return; } + case ROW_COLOR_PATTERN: { fprintf(stderr, "ROW_COLOR_PATTERN"); return; } + case ROW_DIVIDERS: { fprintf(stderr, "ROW_DIVIDERS"); return; } + case ROW_FONT: { fprintf(stderr, "ROW_FONT"); return; } + case ROW_HEADINGS: { fprintf(stderr, "ROW_HEADINGS"); return; } + case ROW_PROTECTION: { fprintf(stderr, "ROW_PROTECTION"); return; } + case RUN: { fprintf(stderr, "RUN"); return; } + case S: { fprintf(stderr, "S"); return; } + case SAME: { fprintf(stderr, "SAME"); return; } + case SAVE_AS: { fprintf(stderr, "SAVE_AS"); return; } + case SAVE_AS_NO_PROMPT: { fprintf(stderr, "SAVE_AS_NO_PROMPT"); return; } + case SCREEN: { fprintf(stderr, "SCREEN"); return; } + case SCREEN_CONTROL: { fprintf(stderr, "SCREEN_CONTROL"); return; } + case SCROLL: { fprintf(stderr, "SCROLL"); return; } + case SCROLL_BAR: { fprintf(stderr, "SCROLL_BAR"); return; } + case SD: { fprintf(stderr, "SD"); return; } + case SEARCH: { fprintf(stderr, "SEARCH"); return; } + case SEARCH_OPTIONS: { fprintf(stderr, "SEARCH_OPTIONS"); return; } + case SEARCH_TEXT: { fprintf(stderr, "SEARCH_TEXT"); return; } + case SECONDS: { fprintf(stderr, "SECONDS"); return; } + case SECTION: { fprintf(stderr, "SECTION"); return; } + case SECURE: { fprintf(stderr, "SECURE"); return; } + case SECURITY: { fprintf(stderr, "SECURITY"); return; } + case SEGMENT: { fprintf(stderr, "SEGMENT"); return; } + case SEGMENT_LIMIT: { fprintf(stderr, "SEGMENT_LIMIT"); return; } + case SELECT: { fprintf(stderr, "SELECT"); return; } + case SELECTION_INDEX: { fprintf(stderr, "SELECTION_INDEX"); return; } + case SELECTION_TEXT: { fprintf(stderr, "SELECTION_TEXT"); return; } + case SELECT_ALL: { fprintf(stderr, "SELECT_ALL"); return; } + case SELF_ACT: { fprintf(stderr, "SELF_ACT"); return; } + case SEMI_COLON: { fprintf(stderr, "SEMI_COLON"); return; } + case SEND: { fprintf(stderr, "SEND"); return; } + case SENTENCE: { fprintf(stderr, "SENTENCE"); return; } + case SEPARATE: { fprintf(stderr, "SEPARATE"); return; } + case SEPARATION: { fprintf(stderr, "SEPARATION"); return; } + case SEQUENCE: { fprintf(stderr, "SEQUENCE"); return; } + case SEQUENTIAL: { fprintf(stderr, "SEQUENTIAL"); return; } + case SET: { fprintf(stderr, "SET"); return; } + case SEVENTY_EIGHT: { fprintf(stderr, "SEVENTY_EIGHT"); return; } + case SHADING: { fprintf(stderr, "SHADING"); return; } + case SHADOW: { fprintf(stderr, "SHADOW"); return; } + case SHARING: { fprintf(stderr, "SHARING"); return; } + case SHORT_DATE: { fprintf(stderr, "SHORT_DATE"); return; } + case SHOW_LINES: { fprintf(stderr, "SHOW_LINES"); return; } + case SHOW_NONE: { fprintf(stderr, "SHOW_NONE"); return; } + case SHOW_SEL_ALWAYS: { fprintf(stderr, "SHOW_SEL_ALWAYS"); return; } + case SIGN: { fprintf(stderr, "SIGN"); return; } + case SIGNED: { fprintf(stderr, "SIGNED"); return; } + case SIGNED_INT: { fprintf(stderr, "SIGNED_INT"); return; } + case SIGNED_LONG: { fprintf(stderr, "SIGNED_LONG"); return; } + case SIGNED_SHORT: { fprintf(stderr, "SIGNED_SHORT"); return; } + case SIXTY_SIX: { fprintf(stderr, "SIXTY_SIX"); return; } + case SIZE: { fprintf(stderr, "SIZE"); return; } + case SIZE_ERROR: { fprintf(stderr, "SIZE_ERROR"); return; } + case SMALL_FONT: { fprintf(stderr, "SMALL_FONT"); return; } + case SORT: { fprintf(stderr, "SORT"); return; } + case SORT_MERGE: { fprintf(stderr, "SORT_MERGE"); return; } + case SORT_ORDER: { fprintf(stderr, "SORT_ORDER"); return; } + case SOURCE: { fprintf(stderr, "SOURCE"); return; } + case SOURCE_COMPUTER: { fprintf(stderr, "SOURCE_COMPUTER"); return; } + case SPACE: { fprintf(stderr, "SPACE"); return; } + case SPECIAL_NAMES: { fprintf(stderr, "SPECIAL_NAMES"); return; } + case SPINNER: { fprintf(stderr, "SPINNER"); return; } + case SQUARE: { fprintf(stderr, "SQUARE"); return; } + case STANDARD: { fprintf(stderr, "STANDARD"); return; } + case STANDARD_1: { fprintf(stderr, "STANDARD_1"); return; } + case STANDARD_2: { fprintf(stderr, "STANDARD_2"); return; } + case STANDARD_BINARY: { fprintf(stderr, "STANDARD_BINARY"); return; } + case STANDARD_DECIMAL: { fprintf(stderr, "STANDARD_DECIMAL"); return; } + case START: { fprintf(stderr, "START"); return; } + case START_X: { fprintf(stderr, "START_X"); return; } + case START_Y: { fprintf(stderr, "START_Y"); return; } + case STATIC: { fprintf(stderr, "STATIC"); return; } + case STATIC_LIST: { fprintf(stderr, "STATIC_LIST"); return; } + case STATUS: { fprintf(stderr, "STATUS"); return; } + case STATUS_BAR: { fprintf(stderr, "STATUS_BAR"); return; } + case STATUS_TEXT: { fprintf(stderr, "STATUS_TEXT"); return; } + case STDCALL: { fprintf(stderr, "STDCALL"); return; } + case STEP: { fprintf(stderr, "STEP"); return; } + case STOP: { fprintf(stderr, "STOP"); return; } + case STRING: { fprintf(stderr, "STRING"); return; } + case STRONG: { fprintf(stderr, "STRONG"); return; } + case STYLE: { fprintf(stderr, "STYLE"); return; } + case SUB_QUEUE_1: { fprintf(stderr, "SUB_QUEUE_1"); return; } + case SUB_QUEUE_2: { fprintf(stderr, "SUB_QUEUE_2"); return; } + case SUB_QUEUE_3: { fprintf(stderr, "SUB_QUEUE_3"); return; } + case SUBSTITUTE_FUNC: { fprintf(stderr, "SUBSTITUTE_FUNC"); return; } + case SUBSTITUTE_CASE_FUNC: { fprintf(stderr, "SUBSTITUTE_CASE_FUNC"); return; } + case SUBTRACT: { fprintf(stderr, "SUBTRACT"); return; } + case SUBWINDOW: { fprintf(stderr, "SUBWINDOW"); return; } + case SUM: { fprintf(stderr, "SUM"); return; } + case SUPPRESS: { fprintf(stderr, "SUPPRESS"); return; } + case SUPPRESS_XML: { fprintf(stderr, "SUPPRESS_XML"); return; } + case SYMBOL: { fprintf(stderr, "SYMBOL"); return; } + case SYMBOLIC: { fprintf(stderr, "SYMBOLIC"); return; } + case SYNCHRONIZED: { fprintf(stderr, "SYNCHRONIZED"); return; } + case SYSTEM_DEFAULT: { fprintf(stderr, "SYSTEM_DEFAULT"); return; } + case SYSTEM_INFO: { fprintf(stderr, "SYSTEM_INFO"); return; } + case SYSTEM_OFFSET: { fprintf(stderr, "SYSTEM_OFFSET"); return; } + case TAB: { fprintf(stderr, "TAB"); return; } + case TAB_TO_ADD: { fprintf(stderr, "TAB_TO_ADD"); return; } + case TAB_TO_DELETE: { fprintf(stderr, "TAB_TO_DELETE"); return; } + case TABLE: { fprintf(stderr, "TABLE"); return; } + case TALLYING: { fprintf(stderr, "TALLYING"); return; } + case TEMPORARY: { fprintf(stderr, "TEMPORARY"); return; } + case TAPE: { fprintf(stderr, "TAPE"); return; } + case TERMINAL: { fprintf(stderr, "TERMINAL"); return; } + case TERMINATE: { fprintf(stderr, "TERMINATE"); return; } + case TERMINAL_INFO: { fprintf(stderr, "TERMINAL_INFO"); return; } + case TERMINATION_VALUE: { fprintf(stderr, "TERMINATION_VALUE"); return; } + case TEST: { fprintf(stderr, "TEST"); return; } + case TEXT: { fprintf(stderr, "TEXT"); return; } + case THAN: { fprintf(stderr, "THAN"); return; } + case THEN: { fprintf(stderr, "THEN"); return; } + case THREAD: { fprintf(stderr, "THREAD"); return; } + case THREADS: { fprintf(stderr, "THREADS"); return; } + case THRU: { fprintf(stderr, "THRU"); return; } + case THUMB_POSITION: { fprintf(stderr, "THUMB_POSITION"); return; } + case TILED_HEADINGS: { fprintf(stderr, "TILED_HEADINGS"); return; } + case TIME: { fprintf(stderr, "TIME"); return; } + case TIME_OUT: { fprintf(stderr, "TIME_OUT"); return; } + case TIMES: { fprintf(stderr, "TIMES"); return; } + case TITLE: { fprintf(stderr, "TITLE"); return; } + case TITLE_POSITION: { fprintf(stderr, "TITLE_POSITION"); return; } + case TO: { fprintf(stderr, "TO"); return; } + case TOK_AMPER: { fprintf(stderr, "TOK_AMPER"); return; } + case TOK_CLOSE_PAREN: { fprintf(stderr, "TOK_CLOSE_PAREN"); return; } + case TOK_COLON: { fprintf(stderr, "TOK_COLON"); return; } + case TOK_DIV: { fprintf(stderr, "TOK_DIV"); return; } + case TOK_DOT: { fprintf(stderr, "TOK_DOT"); return; } + case TOK_EQUAL: { fprintf(stderr, "TOK_EQUAL"); return; } + case TOK_EXTERN: { fprintf(stderr, "TOK_EXTERN"); return; } + case TOK_FALSE: { fprintf(stderr, "TOK_FALSE"); return; } + case TOK_FILE: { fprintf(stderr, "TOK_FILE"); return; } + case TOK_GREATER: { fprintf(stderr, "TOK_GREATER"); return; } + case TOK_INITIAL: { fprintf(stderr, "TOK_INITIAL"); return; } + case TOK_LESS: { fprintf(stderr, "TOK_LESS"); return; } + case TOK_MINUS: { fprintf(stderr, "TOK_MINUS"); return; } + case TOK_MUL: { fprintf(stderr, "TOK_MUL"); return; } + case TOK_NULL: { fprintf(stderr, "TOK_NULL"); return; } + case TOK_OVERFLOW: { fprintf(stderr, "TOK_OVERFLOW"); return; } + case TOK_OPEN_PAREN: { fprintf(stderr, "TOK_OPEN_PAREN"); return; } + case TOK_PLUS: { fprintf(stderr, "TOK_PLUS"); return; } + case TOK_TRUE: { fprintf(stderr, "TOK_TRUE"); return; } + case TOP: { fprintf(stderr, "TOP"); return; } + case TOWARD_GREATER: { fprintf(stderr, "TOWARD_GREATER"); return; } + case TOWARD_LESSER: { fprintf(stderr, "TOWARD_LESSER"); return; } + case TRACE: { fprintf(stderr, "TRACE"); return; } + case TRACK: { fprintf(stderr, "TRACK"); return; } + case TRACKS: { fprintf(stderr, "TRACKS"); return; } + case TRACK_AREA: { fprintf(stderr, "TRACK_AREA"); return; } + case TRACK_LIMIT: { fprintf(stderr, "TRACK_LIMIT"); return; } + case TRADITIONAL_FONT: { fprintf(stderr, "TRADITIONAL_FONT"); return; } + case TRAILING: { fprintf(stderr, "TRAILING"); return; } + case TRAILING_SHIFT: { fprintf(stderr, "TRAILING_SHIFT"); return; } + case TRANSFORM: { fprintf(stderr, "TRANSFORM"); return; } + case TRANSPARENT: { fprintf(stderr, "TRANSPARENT"); return; } + case TREE_VIEW: { fprintf(stderr, "TREE_VIEW"); return; } + case TRIM_FUNC: { fprintf(stderr, "TRIM_FUNC"); return; } + case TRUNCATION: { fprintf(stderr, "TRUNCATION"); return; } + case TYPE: { fprintf(stderr, "TYPE"); return; } + case TYPEDEF: { fprintf(stderr, "TYPEDEF"); return; } + case U: { fprintf(stderr, "U"); return; } + case UCS_4: { fprintf(stderr, "UCS_4"); return; } + case UNBOUNDED: { fprintf(stderr, "UNBOUNDED"); return; } + case UNDERLINE: { fprintf(stderr, "UNDERLINE"); return; } + case UNFRAMED: { fprintf(stderr, "UNFRAMED"); return; } + case UNIT: { fprintf(stderr, "UNIT"); return; } + case UNLOCK: { fprintf(stderr, "UNLOCK"); return; } + case UNSIGNED: { fprintf(stderr, "UNSIGNED"); return; } + case UNSIGNED_INT: { fprintf(stderr, "UNSIGNED_INT"); return; } + case UNSIGNED_LONG: { fprintf(stderr, "UNSIGNED_LONG"); return; } + case UNSIGNED_SHORT: { fprintf(stderr, "UNSIGNED_SHORT"); return; } + case UNSORTED: { fprintf(stderr, "UNSORTED"); return; } + case UNSTRING: { fprintf(stderr, "UNSTRING"); return; } + case UNTIL: { fprintf(stderr, "UNTIL"); return; } + case UP: { fprintf(stderr, "UP"); return; } + case UPDATE: { fprintf(stderr, "UPDATE"); return; } + case UPDATERS: { fprintf(stderr, "UPDATERS"); return; } + case UPON: { fprintf(stderr, "UPON"); return; } + case UPON_ARGUMENT_NUMBER: { fprintf(stderr, "UPON_ARGUMENT_NUMBER"); return; } + case UPON_COMMAND_LINE: { fprintf(stderr, "UPON_COMMAND_LINE"); return; } + case UPON_ENVIRONMENT_NAME: { fprintf(stderr, "UPON_ENVIRONMENT_NAME"); return; } + case UPON_ENVIRONMENT_VALUE: { fprintf(stderr, "UPON_ENVIRONMENT_VALUE"); return; } + case UPPER: { fprintf(stderr, "UPPER"); return; } + case UPPER_CASE_FUNC: { fprintf(stderr, "UPPER_CASE_FUNC"); return; } + case USAGE: { fprintf(stderr, "USAGE"); return; } + case USE: { fprintf(stderr, "USE"); return; } + case USE_ALT: { fprintf(stderr, "USE_ALT"); return; } + case USE_RETURN: { fprintf(stderr, "USE_RETURN"); return; } + case USE_TAB: { fprintf(stderr, "USE_TAB"); return; } + case USER: { fprintf(stderr, "USER"); return; } + case USER_DEFAULT: { fprintf(stderr, "USER_DEFAULT"); return; } + case USER_FUNCTION_NAME: { fprintf(stderr, "USER_FUNCTION_NAME"); return; } + case USING: { fprintf(stderr, "USING"); return; } + case UTF_8: { fprintf(stderr, "UTF_8"); return; } + case UTF_16: { fprintf(stderr, "UTF_16"); return; } + case V: { fprintf(stderr, "V"); return; } + case VALID: { fprintf(stderr, "VALID"); return; } + case VALIDATE: { fprintf(stderr, "VALIDATE"); return; } + case VALIDATE_STATUS: { fprintf(stderr, "VALIDATE_STATUS"); return; } + case VALIDATING: { fprintf(stderr, "VALIDATING"); return; } + case VALUE: { fprintf(stderr, "VALUE"); return; } + case VALUE_FORMAT: { fprintf(stderr, "VALUE_FORMAT"); return; } + case VALUES: { fprintf(stderr, "VALUES"); return; } + case VARIABLE: { fprintf(stderr, "VARIABLE"); return; } + case VARIANT: { fprintf(stderr, "VARIANT"); return; } + case VARYING: { fprintf(stderr, "VARYING"); return; } + case VERTICAL: { fprintf(stderr, "VERTICAL"); return; } + case VERY_HEAVY: { fprintf(stderr, "VERY_HEAVY"); return; } + case VIRTUAL_WIDTH: { fprintf(stderr, "VIRTUAL_WIDTH"); return; } + case VOLATILE: { fprintf(stderr, "VOLATILE"); return; } + case VPADDING: { fprintf(stderr, "VPADDING"); return; } + case VSCROLL: { fprintf(stderr, "VSCROLL"); return; } + case VSCROLL_BAR: { fprintf(stderr, "VSCROLL_BAR"); return; } + case VSCROLL_POS: { fprintf(stderr, "VSCROLL_POS"); return; } + case VTOP: { fprintf(stderr, "VTOP"); return; } + case WAIT: { fprintf(stderr, "WAIT"); return; } + case WEB_BROWSER: { fprintf(stderr, "WEB_BROWSER"); return; } + case WHEN: { fprintf(stderr, "WHEN"); return; } + case WHEN_COMPILED_FUNC: { fprintf(stderr, "WHEN_COMPILED_FUNC"); return; } + case WHEN_XML: { fprintf(stderr, "WHEN_XML"); return; } + case WIDTH: { fprintf(stderr, "WIDTH"); return; } + case WIDTH_IN_CELLS: { fprintf(stderr, "WIDTH_IN_CELLS"); return; } + case WINAPI: { fprintf(stderr, "WINAPI"); return; } + case WINDOW: { fprintf(stderr, "WINDOW"); return; } + case WITH: { fprintf(stderr, "WITH"); return; } + case WORD: { fprintf(stderr, "WORD"); return; } + case WORDS: { fprintf(stderr, "WORDS"); return; } + case WORKING_STORAGE: { fprintf(stderr, "WORKING_STORAGE"); return; } + case WRAP: { fprintf(stderr, "WRAP"); return; } + case WRITE: { fprintf(stderr, "WRITE"); return; } + case WRITE_ONLY: { fprintf(stderr, "WRITE_ONLY"); return; } + case WRITE_VERIFY: { fprintf(stderr, "WRITE_VERIFY"); return; } + case WRITERS: { fprintf(stderr, "WRITERS"); return; } + case X: { fprintf(stderr, "X"); return; } + case XML: { fprintf(stderr, "XML"); return; } + case XML_DECLARATION: { fprintf(stderr, "XML_DECLARATION"); return; } + case XML_SCHEMA: { fprintf(stderr, "XML_SCHEMA"); return; } + case Y: { fprintf(stderr, "Y"); return; } + case YYYYDDD: { fprintf(stderr, "YYYYDDD"); return; } + case YYYYMMDD: { fprintf(stderr, "YYYYMMDD"); return; } + case ZERO: { fprintf(stderr, "ZERO"); return; } + case LEVEL_NUMBER_IN_AREA_A: { fprintf(stderr, "LEVEL_NUMBER_IN_AREA_A"); return; } + case WORD_IN_AREA_A: { fprintf(stderr, "WORD_IN_AREA_A"); return; } + case SHIFT_PREFER: { fprintf(stderr, "SHIFT_PREFER"); return; } + + default: + fprintf(stderr, ""); + } +} From a3fd9820c5f8293818de2ee272cc0bf757878cf4 Mon Sep 17 00:00:00 2001 From: Fabrice Le Fessant Date: Wed, 26 Nov 2025 17:41:43 +0100 Subject: [PATCH 10/11] Allow no dot before FD --- cobc/parser.y | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cobc/parser.y b/cobc/parser.y index d97004c21..ce0fe1867 100644 --- a/cobc/parser.y +++ b/cobc/parser.y @@ -20462,7 +20462,7 @@ file_control_end_delimiter: SELECT | I_O_CONTROL | DATA | PROCEDURE | LEVEL_NUMBER | LEVEL_NUMBER_IN_AREA_A; file_description_end_delimiter: - TOK_FILE | PROCEDURE; + TOK_FILE | PROCEDURE | FD; record_description_end_delimiter: PROCEDURE | COMMUNICATION | LOCAL_STORAGE | LINKAGE | REPORT | SCREEN | LEVEL_NUMBER_IN_AREA_A | LEVEL_NUMBER ; From 180bbcb5bb97d8aeba35c7366274ee2eda8e98e4 Mon Sep 17 00:00:00 2001 From: Fabrice Le Fessant Date: Wed, 26 Nov 2025 17:42:11 +0100 Subject: [PATCH 11/11] Improve debug of tokens --- cobc/scanner.l | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/cobc/scanner.l b/cobc/scanner.l index 5657807b1..c0c031ddb 100644 --- a/cobc/scanner.l +++ b/cobc/scanner.l @@ -109,11 +109,12 @@ #include "parser.h" #include "eprintf_token.def" +//#define MUST_PRINT_TOKENS #ifdef MUST_PRINT_TOKENS #define PRINT_TOK(expr) \ fprintf(stderr, "%s:%d:token ", cb_source_file, cb_source_line); \ eprintf_token(expr); \ - fprintf(stderr, "\n") + fprintf(stderr, " for '%s'\n", yytext) #else #define PRINT_TOK(expr) #endif