From 8b04ba6a295fe0b0ea6d216f7e9c4b862b40e473 Mon Sep 17 00:00:00 2001 From: David Declerck Date: Fri, 31 May 2024 01:06:50 +0200 Subject: [PATCH] Merge SVN 3940 --- cobc/ChangeLog | 6 + cobc/cobc.c | 6 +- cobc/ppparse.output | 3160 +++++++++++++++++++++++++ cobc/ppparse.y | 35 +- tests/testsuite.src/run_extensions.at | 93 - tests/testsuite.src/syn_misc.at | 218 ++ 6 files changed, 3417 insertions(+), 101 deletions(-) create mode 100644 cobc/ppparse.output diff --git a/cobc/ChangeLog b/cobc/ChangeLog index 70d42049e..7d088c09d 100644 --- a/cobc/ChangeLog +++ b/cobc/ChangeLog @@ -1270,6 +1270,12 @@ * config.def: added possible values for assign-clause and screen-section-rules. +2020-07-21 Simon Sobisch + + * ppparse.y: improved error handling for broken IF/ELIF + directives by consuming as much errors as possible and + emitting a "false" + 2020-07-19 Edward Hart * cobc.c, typeck.c: added support for JSON-C as JSON handler. diff --git a/cobc/cobc.c b/cobc/cobc.c index 8530b5457..a57bc1170 100644 --- a/cobc/cobc.c +++ b/cobc/cobc.c @@ -4134,7 +4134,7 @@ process_filename (const char *filename) #if defined(__OS400__) extension[0] == 0 #else - cb_strcasecmp (extension, COB_OBJECT_EXT) == 0 + cb_strcasecmp (extension, COB_OBJECT_EXT) == 0 #if defined(_WIN32) || cb_strcasecmp (extension, "lib") == 0 #endif @@ -4160,8 +4160,8 @@ process_filename (const char *filename) fn->preprocess = cobc_main_strdup (fn->source); } else if (output_name && cb_compile_level == CB_LEVEL_PREPROCESS) { fn->preprocess = cobc_main_strdup (output_name); - } else if (save_all_src || save_temps || - cb_compile_level == CB_LEVEL_PREPROCESS) { + } else if (save_all_src || save_temps + || cb_compile_level == CB_LEVEL_PREPROCESS) { fn->preprocess = cobc_main_stradd_dup (fbasename, ".i"); } else { fn->preprocess = cobc_main_malloc (COB_FILE_MAX); diff --git a/cobc/ppparse.output b/cobc/ppparse.output new file mode 100644 index 000000000..6063f424a --- /dev/null +++ b/cobc/ppparse.output @@ -0,0 +1,3160 @@ +Grammaire + + 0 $accept: statement_list "end of file" + + 1 statement_list: ε + 2 | statement_list statement + + 3 statement: copy_statement "." + 4 | replace_statement "." + 5 | directive "end of line" + 6 | listing_statement + 7 | CONTROL_STATEMENT control_options _dot "end of line" + + 8 directive: SOURCE_DIRECTIVE source_directive + 9 | DEFINE_DIRECTIVE define_directive + 10 | COBOL_WORDS_DIRECTIVE cobol_words_directive + 11 | SET_DIRECTIVE set_directive + 12 | REFMOD_DIRECTIVE refmod_directive + 13 | TURN_DIRECTIVE turn_directive + 14 | LISTING_DIRECTIVE listing_directive + 15 | LEAP_SECOND_DIRECTIVE leap_second_directive + + 16 $@1: ε + + 17 directive: IF_DIRECTIVE $@1 if_directive_if + + 18 $@2: ε + + 19 directive: ELIF_DIRECTIVE $@2 if_directive_elif + 20 | ELSE_DIRECTIVE + 21 | ENDIF_DIRECTIVE + + 22 $@3: ε + + 23 directive: CALL_DIRECTIVE $@3 call_directive + + 24 if_directive_if: if_directive + 25 | error + + 26 if_directive_elif: if_directive + 27 | error + + 28 set_directive: set_choice + 29 | set_directive set_choice + + 30 set_choice: CONSTANT "Variable" "Literal" + 31 | "Variable" set_options + 32 | ADDRSV alnum_list + 33 | ADDSYN alnum_equality + 34 | ASSIGN "Literal" + 35 | BOUND + 36 | CALLFH "Literal" + 37 | CALLFH + 38 | XFD "Literal" + 39 | COMP1 "Literal" + 40 | "DPC-IN-DATA" "Literal" + 41 | FOLDCOPYNAME _as "Literal" + 42 | KEYCOMPRESS "Literal" + 43 | NOKEYCOMPRESS + 44 | MAKESYN alnum_equality + 45 | NOBOUND + 46 | "NODPC-IN-DATA" + 47 | NOFOLDCOPYNAME + 48 | NOSSRANGE + 49 | NOODOSLIDE + 50 | ODOSLIDE + 51 | OVERRIDE alnum_equality_list + 52 | REMOVE alnum_list + 53 | SOURCEFORMAT _as "Literal" + 54 | SOURCEFORMAT _as error + 55 | SPZERO + 56 | SSRANGE _literal + + 57 alnum_list: "Literal" + 58 | alnum_list "Literal" + + 59 alnum_equality_list: alnum_equality + 60 | alnum_equality_list alnum_equality + + 61 alnum_equality: "Literal" "=" "Literal" + + 62 alnum_with_list: alnum_with + 63 | alnum_with_list alnum_with + + 64 alnum_with: "Literal" WITH "Literal" + + 65 alnum_by_list: alnum_by + 66 | alnum_by_list alnum_by + + 67 alnum_by: "Literal" BY "Literal" + + 68 set_options: ε + 69 | _as "Literal" + + 70 refmod_directive: _on + 71 | OFF + + 72 source_directive: _format _is format_type + + 73 format_type: FIXED + 74 | FREE + 75 | VARIABLE + 76 | "word" + + 77 _literal: ε + 78 | "Literal" + + 79 define_directive: "Variable" _as "Literal" _override + 80 | "Variable" _as PARAMETER _override + 81 | "Variable" _as OFF + 82 | CONSTANT "Variable" _as "Literal" _override + 83 | variable_or_literal + + 84 cobol_words_directive: EQUATE alnum_with_list + 85 | UNDEFINE alnum_list + 86 | SUBSTITUTE alnum_by_list + 87 | RESERVE alnum_list + + 88 listing_directive: ε + 89 | ON + 90 | OFF + + 91 listing_statement: LISTING_STATEMENT + 92 | TITLE_STATEMENT "Literal" _dot "end of line" + + 93 control_options: control_option + 94 | control_options control_option + + 95 control_option: SOURCE + 96 | NOSOURCE + 97 | LIST + 98 | NOLIST + 99 | MAP + 100 | NOMAP + + 101 _dot: ε + 102 | "." + + 103 leap_second_directive: ε + 104 | ON + 105 | OFF + + 106 turn_directive: ec_list CHECKING on_or_off + + 107 ec_list: "Variable" + 108 | ec_list "Variable" + + 109 on_or_off: on_with_loc + 110 | ON + 111 | OFF + + 112 on_with_loc: ON with_loc + 113 | with_loc + + 114 with_loc: WITH LOCATION + 115 | LOCATION + + 116 call_directive: call_choice + 117 | call_directive call_choice + + 118 call_choice: COBOL + 119 | "EXTERN" + 120 | STDCALL + 121 | STATIC + + 122 if_directive: "Variable" _is _not DEFINED + 123 | "Variable" _is _not SET + 124 | "Variable" _is _not condition_clause object_id + 125 | "Literal" _is _not condition_clause object_id + 126 | garbage + + 127 garbage: variable_or_literal + 128 | garbage variable_or_literal + 129 | garbage error + + 130 variable_or_literal: "Variable" + 131 | "Literal" + + 132 object_id: "Literal" + 133 | "Variable" + + 134 condition_clause: GREATER _than OR EQUAL _to + 135 | GREATER _than + 136 | LESS _than OR EQUAL _to + 137 | LESS _than + 138 | EQUAL _to + 139 | ">=" + 140 | ">" + 141 | "<=" + 142 | "<" + 143 | "=" + 144 | "<>" + + 145 copy_statement: COPY copy_source copy_in copy_suppress copy_replacing + + 146 copy_source: "Identifier or Literal" + 147 | "Text-Name" + + 148 copy_in: ε + 149 | in_or_of copy_source + + 150 in_or_of: IN + 151 | OF + + 152 copy_suppress: ε + 153 | SUPPRESS _printing + + 154 copy_replacing: ε + 155 | REPLACING replacing_list + + 156 replace_statement: REPLACE _also replacing_list + 157 | REPLACE _last OFF + + 158 replacing_list: text_src BY text_dst + 159 | lead_trail text_partial_src BY text_partial_dst + 160 | replacing_list text_src BY text_dst + 161 | replacing_list lead_trail text_partial_src BY text_partial_dst + + 162 text_src: "==" token_list "==" + 163 | identifier + + 164 text_dst: "==" "==" + 165 | "==" token_list "==" + 166 | identifier + + 167 text_partial_src: "==" "Identifier or Literal" "==" + + 168 text_partial_dst: "==" "==" + 169 | "==" "Identifier or Literal" "==" + + 170 token_list: "Identifier or Literal" + 171 | token_list "Identifier or Literal" + + 172 identifier: "Identifier or Literal" + 173 | identifier IN "Identifier or Literal" + 174 | identifier OF "Identifier or Literal" + 175 | identifier '(' subscripts ')' + + 176 subscripts: "Identifier or Literal" + 177 | subscripts "Identifier or Literal" + + 178 lead_trail: LEADING + 179 | TRAILING + + 180 _override: ε + 181 | OVERRIDE + + 182 _not: ε + 183 | NOT + + 184 _also: ε + 185 | ALSO + + 186 _last: ε + 187 | LAST + + 188 _as: ε + 189 | AS + + 190 _format: ε + 191 | FORMAT + + 192 _is: ε + 193 | IS + + 194 _printing: ε + 195 | PRINTING + + 196 _on: ε + 197 | ON + + 198 _than: ε + 199 | THAN + + 200 _to: ε + 201 | TO + + +Terminaux, suivis des règles où ils apparaissent + + "end of file" (0) 0 + '(' (40) 175 + ')' (41) 175 + error (256) 25 27 54 129 + ALSO (258) 185 + BY (259) 67 158 159 160 161 + COPY (260) 145 + "==" (261) 162 164 165 167 168 169 + IN (262) 150 173 + LAST (263) 187 + LEADING (264) 178 + OF (265) 151 174 + OFF (266) 71 81 90 105 111 157 + PRINTING (267) 195 + REPLACE (268) 156 157 + REPLACING (269) 155 + SUPPRESS (270) 153 + TRAILING (271) 179 + "." (272) 3 4 102 + "word" (273) 76 + LISTING_DIRECTIVE (274) 14 + LISTING_STATEMENT (275) 91 + TITLE_STATEMENT (276) 92 + COBOL_WORDS_DIRECTIVE (277) 10 + EQUATE (278) 84 + UNDEFINE (279) 85 + SUBSTITUTE (280) 86 + RESERVE (281) 87 + CONTROL_STATEMENT (282) 7 + SOURCE (283) 95 + NOSOURCE (284) 96 + LIST (285) 97 + NOLIST (286) 98 + MAP (287) 99 + NOMAP (288) 100 + LEAP_SECOND_DIRECTIVE (289) 15 + SOURCE_DIRECTIVE (290) 8 + FORMAT (291) 191 + IS (292) 193 + FIXED (293) 73 + FREE (294) 74 + VARIABLE (295) 75 + CALL_DIRECTIVE (296) 23 + COBOL (297) 118 + "EXTERN" (298) 119 + STDCALL (299) 120 + STATIC (300) 121 + DEFINE_DIRECTIVE (301) 9 + AS (302) 189 + PARAMETER (303) 80 + OVERRIDE (304) 51 181 + REFMOD_DIRECTIVE (305) 12 + SET_DIRECTIVE (306) 11 + ADDRSV (307) 32 + ADDSYN (308) 33 + ASSIGN (309) 34 + BOUND (310) 35 + CALLFH (311) 36 37 + XFD (312) 38 + COMP1 (313) 39 + CONSTANT (314) 30 82 + "DPC-IN-DATA" (315) 40 + FOLDCOPYNAME (316) 41 + KEYCOMPRESS (317) 42 + NOKEYCOMPRESS (318) 43 + MAKESYN (319) 44 + NOBOUND (320) 45 + "NODPC-IN-DATA" (321) 46 + NOFOLDCOPYNAME (322) 47 + NOODOSLIDE (323) 49 + NOSSRANGE (324) 48 + ODOSLIDE (325) 50 + REMOVE (326) 52 + SOURCEFORMAT (327) 53 54 + SPZERO (328) 55 + SSRANGE (329) 56 + IF_DIRECTIVE (330) 17 + ELSE_DIRECTIVE (331) 20 + ENDIF_DIRECTIVE (332) 21 + ELIF_DIRECTIVE (333) 19 + ">=" (334) 139 + "<=" (335) 141 + "<" (336) 142 + ">" (337) 140 + "=" (338) 61 143 + "<>" (339) 144 + NOT (340) 183 + THAN (341) 199 + TO (342) 201 + OR (343) 134 136 + EQUAL (344) 134 136 138 + GREATER (345) 134 135 + LESS (346) 136 137 + SET (347) 123 + DEFINED (348) 122 + TURN_DIRECTIVE (349) 13 + ON (350) 89 104 110 112 197 + CHECKING (351) 106 + WITH (352) 64 114 + LOCATION (353) 114 115 + "end of line" (354) 5 7 92 + "Identifier or Literal" (355) 146 167 169 170 171 172 173 174 176 177 + "Text-Name" (356) 147 + "Variable" (357) 30 31 79 80 81 82 107 108 122 123 124 130 133 + "Literal" (358) 30 34 36 38 39 40 41 42 53 57 58 61 64 67 69 78 79 82 92 125 131 132 + + +Non-terminaux, suivis des règles où ils apparaissent + + $accept (106) + à gauche: 0 + statement_list (107) + à gauche: 1 2 + à droite: 0 2 + statement (108) + à gauche: 3 4 5 6 7 + à droite: 2 + directive (109) + à gauche: 8 9 10 11 12 13 14 15 17 19 20 21 23 + à droite: 5 + $@1 (110) + à gauche: 16 + à droite: 17 + $@2 (111) + à gauche: 18 + à droite: 19 + $@3 (112) + à gauche: 22 + à droite: 23 + if_directive_if (113) + à gauche: 24 25 + à droite: 17 + if_directive_elif (114) + à gauche: 26 27 + à droite: 19 + set_directive (115) + à gauche: 28 29 + à droite: 11 29 + set_choice (116) + à gauche: 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 + à droite: 28 29 + alnum_list (117) + à gauche: 57 58 + à droite: 32 52 58 85 87 + alnum_equality_list (118) + à gauche: 59 60 + à droite: 51 60 + alnum_equality (119) + à gauche: 61 + à droite: 33 44 59 60 + alnum_with_list (120) + à gauche: 62 63 + à droite: 63 84 + alnum_with (121) + à gauche: 64 + à droite: 62 63 + alnum_by_list (122) + à gauche: 65 66 + à droite: 66 86 + alnum_by (123) + à gauche: 67 + à droite: 65 66 + set_options (124) + à gauche: 68 69 + à droite: 31 + refmod_directive (125) + à gauche: 70 71 + à droite: 12 + source_directive (126) + à gauche: 72 + à droite: 8 + format_type (127) + à gauche: 73 74 75 76 + à droite: 72 + _literal (128) + à gauche: 77 78 + à droite: 56 + define_directive (129) + à gauche: 79 80 81 82 83 + à droite: 9 + cobol_words_directive (130) + à gauche: 84 85 86 87 + à droite: 10 + listing_directive (131) + à gauche: 88 89 90 + à droite: 14 + listing_statement (132) + à gauche: 91 92 + à droite: 6 + control_options (133) + à gauche: 93 94 + à droite: 7 94 + control_option (134) + à gauche: 95 96 97 98 99 100 + à droite: 93 94 + _dot (135) + à gauche: 101 102 + à droite: 7 92 + leap_second_directive (136) + à gauche: 103 104 105 + à droite: 15 + turn_directive (137) + à gauche: 106 + à droite: 13 + ec_list (138) + à gauche: 107 108 + à droite: 106 108 + on_or_off (139) + à gauche: 109 110 111 + à droite: 106 + on_with_loc (140) + à gauche: 112 113 + à droite: 109 + with_loc (141) + à gauche: 114 115 + à droite: 112 113 + call_directive (142) + à gauche: 116 117 + à droite: 23 117 + call_choice (143) + à gauche: 118 119 120 121 + à droite: 116 117 + if_directive (144) + à gauche: 122 123 124 125 126 + à droite: 24 26 + garbage (145) + à gauche: 127 128 129 + à droite: 126 128 129 + variable_or_literal (146) + à gauche: 130 131 + à droite: 83 127 128 + object_id (147) + à gauche: 132 133 + à droite: 124 125 + condition_clause (148) + à gauche: 134 135 136 137 138 139 140 141 142 143 144 + à droite: 124 125 + copy_statement (149) + à gauche: 145 + à droite: 3 + copy_source (150) + à gauche: 146 147 + à droite: 145 149 + copy_in (151) + à gauche: 148 149 + à droite: 145 + in_or_of (152) + à gauche: 150 151 + à droite: 149 + copy_suppress (153) + à gauche: 152 153 + à droite: 145 + copy_replacing (154) + à gauche: 154 155 + à droite: 145 + replace_statement (155) + à gauche: 156 157 + à droite: 4 + replacing_list (156) + à gauche: 158 159 160 161 + à droite: 155 156 160 161 + text_src (157) + à gauche: 162 163 + à droite: 158 160 + text_dst (158) + à gauche: 164 165 166 + à droite: 158 160 + text_partial_src (159) + à gauche: 167 + à droite: 159 161 + text_partial_dst (160) + à gauche: 168 169 + à droite: 159 161 + token_list (161) + à gauche: 170 171 + à droite: 162 165 171 + identifier (162) + à gauche: 172 173 174 175 + à droite: 163 166 173 174 175 + subscripts (163) + à gauche: 176 177 + à droite: 175 177 + lead_trail (164) + à gauche: 178 179 + à droite: 159 161 + _override (165) + à gauche: 180 181 + à droite: 79 80 82 + _not (166) + à gauche: 182 183 + à droite: 122 123 124 125 + _also (167) + à gauche: 184 185 + à droite: 156 + _last (168) + à gauche: 186 187 + à droite: 157 + _as (169) + à gauche: 188 189 + à droite: 41 53 54 69 79 80 81 82 + _format (170) + à gauche: 190 191 + à droite: 72 + _is (171) + à gauche: 192 193 + à droite: 72 122 123 124 125 + _printing (172) + à gauche: 194 195 + à droite: 153 + _on (173) + à gauche: 196 197 + à droite: 70 + _than (174) + à gauche: 198 199 + à droite: 134 135 136 137 + _to (175) + à gauche: 200 201 + à droite: 134 136 138 + + +État 0 + + 0 $accept: • statement_list "end of file" + + $défaut réduction par utilisation de la règle 1 (statement_list) + + statement_list aller à l'état 1 + + +État 1 + + 0 $accept: statement_list • "end of file" + 2 statement_list: statement_list • statement + + "end of file" décalage et aller à l'état 2 + COPY décalage et aller à l'état 3 + REPLACE décalage et aller à l'état 4 + LISTING_DIRECTIVE décalage et aller à l'état 5 + LISTING_STATEMENT décalage et aller à l'état 6 + TITLE_STATEMENT décalage et aller à l'état 7 + COBOL_WORDS_DIRECTIVE décalage et aller à l'état 8 + CONTROL_STATEMENT décalage et aller à l'état 9 + LEAP_SECOND_DIRECTIVE décalage et aller à l'état 10 + SOURCE_DIRECTIVE décalage et aller à l'état 11 + CALL_DIRECTIVE décalage et aller à l'état 12 + DEFINE_DIRECTIVE décalage et aller à l'état 13 + REFMOD_DIRECTIVE décalage et aller à l'état 14 + SET_DIRECTIVE décalage et aller à l'état 15 + IF_DIRECTIVE décalage et aller à l'état 16 + ELSE_DIRECTIVE décalage et aller à l'état 17 + ENDIF_DIRECTIVE décalage et aller à l'état 18 + ELIF_DIRECTIVE décalage et aller à l'état 19 + TURN_DIRECTIVE décalage et aller à l'état 20 + + statement aller à l'état 21 + directive aller à l'état 22 + listing_statement aller à l'état 23 + copy_statement aller à l'état 24 + replace_statement aller à l'état 25 + + +État 2 + + 0 $accept: statement_list "end of file" • + + $défaut accepter + + +État 3 + + 145 copy_statement: COPY • copy_source copy_in copy_suppress copy_replacing + + "Identifier or Literal" décalage et aller à l'état 26 + "Text-Name" décalage et aller à l'état 27 + + copy_source aller à l'état 28 + + +État 4 + + 156 replace_statement: REPLACE • _also replacing_list + 157 | REPLACE • _last OFF + + ALSO décalage et aller à l'état 29 + LAST décalage et aller à l'état 30 + + OFF réduction par utilisation de la règle 186 (_last) + $défaut réduction par utilisation de la règle 184 (_also) + + _also aller à l'état 31 + _last aller à l'état 32 + + +État 5 + + 14 directive: LISTING_DIRECTIVE • listing_directive + + OFF décalage et aller à l'état 33 + ON décalage et aller à l'état 34 + + $défaut réduction par utilisation de la règle 88 (listing_directive) + + listing_directive aller à l'état 35 + + +État 6 + + 91 listing_statement: LISTING_STATEMENT • + + $défaut réduction par utilisation de la règle 91 (listing_statement) + + +État 7 + + 92 listing_statement: TITLE_STATEMENT • "Literal" _dot "end of line" + + "Literal" décalage et aller à l'état 36 + + +État 8 + + 10 directive: COBOL_WORDS_DIRECTIVE • cobol_words_directive + + EQUATE décalage et aller à l'état 37 + UNDEFINE décalage et aller à l'état 38 + SUBSTITUTE décalage et aller à l'état 39 + RESERVE décalage et aller à l'état 40 + + cobol_words_directive aller à l'état 41 + + +État 9 + + 7 statement: CONTROL_STATEMENT • control_options _dot "end of line" + + SOURCE décalage et aller à l'état 42 + NOSOURCE décalage et aller à l'état 43 + LIST décalage et aller à l'état 44 + NOLIST décalage et aller à l'état 45 + MAP décalage et aller à l'état 46 + NOMAP décalage et aller à l'état 47 + + control_options aller à l'état 48 + control_option aller à l'état 49 + + +État 10 + + 15 directive: LEAP_SECOND_DIRECTIVE • leap_second_directive + + OFF décalage et aller à l'état 50 + ON décalage et aller à l'état 51 + + $défaut réduction par utilisation de la règle 103 (leap_second_directive) + + leap_second_directive aller à l'état 52 + + +État 11 + + 8 directive: SOURCE_DIRECTIVE • source_directive + + FORMAT décalage et aller à l'état 53 + + $défaut réduction par utilisation de la règle 190 (_format) + + source_directive aller à l'état 54 + _format aller à l'état 55 + + +État 12 + + 23 directive: CALL_DIRECTIVE • $@3 call_directive + + $défaut réduction par utilisation de la règle 22 ($@3) + + $@3 aller à l'état 56 + + +État 13 + + 9 directive: DEFINE_DIRECTIVE • define_directive + + CONSTANT décalage et aller à l'état 57 + "Variable" décalage et aller à l'état 58 + "Literal" décalage et aller à l'état 59 + + define_directive aller à l'état 60 + variable_or_literal aller à l'état 61 + + +État 14 + + 12 directive: REFMOD_DIRECTIVE • refmod_directive + + OFF décalage et aller à l'état 62 + ON décalage et aller à l'état 63 + + $défaut réduction par utilisation de la règle 196 (_on) + + refmod_directive aller à l'état 64 + _on aller à l'état 65 + + +État 15 + + 11 directive: SET_DIRECTIVE • set_directive + + OVERRIDE décalage et aller à l'état 66 + ADDRSV décalage et aller à l'état 67 + ADDSYN décalage et aller à l'état 68 + ASSIGN décalage et aller à l'état 69 + BOUND décalage et aller à l'état 70 + CALLFH décalage et aller à l'état 71 + XFD décalage et aller à l'état 72 + COMP1 décalage et aller à l'état 73 + CONSTANT décalage et aller à l'état 74 + "DPC-IN-DATA" décalage et aller à l'état 75 + FOLDCOPYNAME décalage et aller à l'état 76 + KEYCOMPRESS décalage et aller à l'état 77 + NOKEYCOMPRESS décalage et aller à l'état 78 + MAKESYN décalage et aller à l'état 79 + NOBOUND décalage et aller à l'état 80 + "NODPC-IN-DATA" décalage et aller à l'état 81 + NOFOLDCOPYNAME décalage et aller à l'état 82 + NOODOSLIDE décalage et aller à l'état 83 + NOSSRANGE décalage et aller à l'état 84 + ODOSLIDE décalage et aller à l'état 85 + REMOVE décalage et aller à l'état 86 + SOURCEFORMAT décalage et aller à l'état 87 + SPZERO décalage et aller à l'état 88 + SSRANGE décalage et aller à l'état 89 + "Variable" décalage et aller à l'état 90 + + set_directive aller à l'état 91 + set_choice aller à l'état 92 + + +État 16 + + 17 directive: IF_DIRECTIVE • $@1 if_directive_if + + $défaut réduction par utilisation de la règle 16 ($@1) + + $@1 aller à l'état 93 + + +État 17 + + 20 directive: ELSE_DIRECTIVE • + + $défaut réduction par utilisation de la règle 20 (directive) + + +État 18 + + 21 directive: ENDIF_DIRECTIVE • + + $défaut réduction par utilisation de la règle 21 (directive) + + +État 19 + + 19 directive: ELIF_DIRECTIVE • $@2 if_directive_elif + + $défaut réduction par utilisation de la règle 18 ($@2) + + $@2 aller à l'état 94 + + +État 20 + + 13 directive: TURN_DIRECTIVE • turn_directive + + "Variable" décalage et aller à l'état 95 + + turn_directive aller à l'état 96 + ec_list aller à l'état 97 + + +État 21 + + 2 statement_list: statement_list statement • + + $défaut réduction par utilisation de la règle 2 (statement_list) + + +État 22 + + 5 statement: directive • "end of line" + + "end of line" décalage et aller à l'état 98 + + +État 23 + + 6 statement: listing_statement • + + $défaut réduction par utilisation de la règle 6 (statement) + + +État 24 + + 3 statement: copy_statement • "." + + "." décalage et aller à l'état 99 + + +État 25 + + 4 statement: replace_statement • "." + + "." décalage et aller à l'état 100 + + +État 26 + + 146 copy_source: "Identifier or Literal" • + + $défaut réduction par utilisation de la règle 146 (copy_source) + + +État 27 + + 147 copy_source: "Text-Name" • + + $défaut réduction par utilisation de la règle 147 (copy_source) + + +État 28 + + 145 copy_statement: COPY copy_source • copy_in copy_suppress copy_replacing + + IN décalage et aller à l'état 101 + OF décalage et aller à l'état 102 + + $défaut réduction par utilisation de la règle 148 (copy_in) + + copy_in aller à l'état 103 + in_or_of aller à l'état 104 + + +État 29 + + 185 _also: ALSO • + + $défaut réduction par utilisation de la règle 185 (_also) + + +État 30 + + 187 _last: LAST • + + $défaut réduction par utilisation de la règle 187 (_last) + + +État 31 + + 156 replace_statement: REPLACE _also • replacing_list + + "==" décalage et aller à l'état 105 + LEADING décalage et aller à l'état 106 + TRAILING décalage et aller à l'état 107 + "Identifier or Literal" décalage et aller à l'état 108 + + replacing_list aller à l'état 109 + text_src aller à l'état 110 + identifier aller à l'état 111 + lead_trail aller à l'état 112 + + +État 32 + + 157 replace_statement: REPLACE _last • OFF + + OFF décalage et aller à l'état 113 + + +État 33 + + 90 listing_directive: OFF • + + $défaut réduction par utilisation de la règle 90 (listing_directive) + + +État 34 + + 89 listing_directive: ON • + + $défaut réduction par utilisation de la règle 89 (listing_directive) + + +État 35 + + 14 directive: LISTING_DIRECTIVE listing_directive • + + $défaut réduction par utilisation de la règle 14 (directive) + + +État 36 + + 92 listing_statement: TITLE_STATEMENT "Literal" • _dot "end of line" + + "." décalage et aller à l'état 114 + + $défaut réduction par utilisation de la règle 101 (_dot) + + _dot aller à l'état 115 + + +État 37 + + 84 cobol_words_directive: EQUATE • alnum_with_list + + "Literal" décalage et aller à l'état 116 + + alnum_with_list aller à l'état 117 + alnum_with aller à l'état 118 + + +État 38 + + 85 cobol_words_directive: UNDEFINE • alnum_list + + "Literal" décalage et aller à l'état 119 + + alnum_list aller à l'état 120 + + +État 39 + + 86 cobol_words_directive: SUBSTITUTE • alnum_by_list + + "Literal" décalage et aller à l'état 121 + + alnum_by_list aller à l'état 122 + alnum_by aller à l'état 123 + + +État 40 + + 87 cobol_words_directive: RESERVE • alnum_list + + "Literal" décalage et aller à l'état 119 + + alnum_list aller à l'état 124 + + +État 41 + + 10 directive: COBOL_WORDS_DIRECTIVE cobol_words_directive • + + $défaut réduction par utilisation de la règle 10 (directive) + + +État 42 + + 95 control_option: SOURCE • + + $défaut réduction par utilisation de la règle 95 (control_option) + + +État 43 + + 96 control_option: NOSOURCE • + + $défaut réduction par utilisation de la règle 96 (control_option) + + +État 44 + + 97 control_option: LIST • + + $défaut réduction par utilisation de la règle 97 (control_option) + + +État 45 + + 98 control_option: NOLIST • + + $défaut réduction par utilisation de la règle 98 (control_option) + + +État 46 + + 99 control_option: MAP • + + $défaut réduction par utilisation de la règle 99 (control_option) + + +État 47 + + 100 control_option: NOMAP • + + $défaut réduction par utilisation de la règle 100 (control_option) + + +État 48 + + 7 statement: CONTROL_STATEMENT control_options • _dot "end of line" + 94 control_options: control_options • control_option + + "." décalage et aller à l'état 114 + SOURCE décalage et aller à l'état 42 + NOSOURCE décalage et aller à l'état 43 + LIST décalage et aller à l'état 44 + NOLIST décalage et aller à l'état 45 + MAP décalage et aller à l'état 46 + NOMAP décalage et aller à l'état 47 + + $défaut réduction par utilisation de la règle 101 (_dot) + + control_option aller à l'état 125 + _dot aller à l'état 126 + + +État 49 + + 93 control_options: control_option • + + $défaut réduction par utilisation de la règle 93 (control_options) + + +État 50 + + 105 leap_second_directive: OFF • + + $défaut réduction par utilisation de la règle 105 (leap_second_directive) + + +État 51 + + 104 leap_second_directive: ON • + + $défaut réduction par utilisation de la règle 104 (leap_second_directive) + + +État 52 + + 15 directive: LEAP_SECOND_DIRECTIVE leap_second_directive • + + $défaut réduction par utilisation de la règle 15 (directive) + + +État 53 + + 191 _format: FORMAT • + + $défaut réduction par utilisation de la règle 191 (_format) + + +État 54 + + 8 directive: SOURCE_DIRECTIVE source_directive • + + $défaut réduction par utilisation de la règle 8 (directive) + + +État 55 + + 72 source_directive: _format • _is format_type + + IS décalage et aller à l'état 127 + + $défaut réduction par utilisation de la règle 192 (_is) + + _is aller à l'état 128 + + +État 56 + + 23 directive: CALL_DIRECTIVE $@3 • call_directive + + COBOL décalage et aller à l'état 129 + "EXTERN" décalage et aller à l'état 130 + STDCALL décalage et aller à l'état 131 + STATIC décalage et aller à l'état 132 + + call_directive aller à l'état 133 + call_choice aller à l'état 134 + + +État 57 + + 82 define_directive: CONSTANT • "Variable" _as "Literal" _override + + "Variable" décalage et aller à l'état 135 + + +État 58 + + 79 define_directive: "Variable" • _as "Literal" _override + 80 | "Variable" • _as PARAMETER _override + 81 | "Variable" • _as OFF + 130 variable_or_literal: "Variable" • + + AS décalage et aller à l'état 136 + + "end of line" réduction par utilisation de la règle 130 (variable_or_literal) + $défaut réduction par utilisation de la règle 188 (_as) + + _as aller à l'état 137 + + +État 59 + + 131 variable_or_literal: "Literal" • + + $défaut réduction par utilisation de la règle 131 (variable_or_literal) + + +État 60 + + 9 directive: DEFINE_DIRECTIVE define_directive • + + $défaut réduction par utilisation de la règle 9 (directive) + + +État 61 + + 83 define_directive: variable_or_literal • + + $défaut réduction par utilisation de la règle 83 (define_directive) + + +État 62 + + 71 refmod_directive: OFF • + + $défaut réduction par utilisation de la règle 71 (refmod_directive) + + +État 63 + + 197 _on: ON • + + $défaut réduction par utilisation de la règle 197 (_on) + + +État 64 + + 12 directive: REFMOD_DIRECTIVE refmod_directive • + + $défaut réduction par utilisation de la règle 12 (directive) + + +État 65 + + 70 refmod_directive: _on • + + $défaut réduction par utilisation de la règle 70 (refmod_directive) + + +État 66 + + 51 set_choice: OVERRIDE • alnum_equality_list + + "Literal" décalage et aller à l'état 138 + + alnum_equality_list aller à l'état 139 + alnum_equality aller à l'état 140 + + +État 67 + + 32 set_choice: ADDRSV • alnum_list + + "Literal" décalage et aller à l'état 119 + + alnum_list aller à l'état 141 + + +État 68 + + 33 set_choice: ADDSYN • alnum_equality + + "Literal" décalage et aller à l'état 138 + + alnum_equality aller à l'état 142 + + +État 69 + + 34 set_choice: ASSIGN • "Literal" + + "Literal" décalage et aller à l'état 143 + + +État 70 + + 35 set_choice: BOUND • + + $défaut réduction par utilisation de la règle 35 (set_choice) + + +État 71 + + 36 set_choice: CALLFH • "Literal" + 37 | CALLFH • + + "Literal" décalage et aller à l'état 144 + + $défaut réduction par utilisation de la règle 37 (set_choice) + + +État 72 + + 38 set_choice: XFD • "Literal" + + "Literal" décalage et aller à l'état 145 + + +État 73 + + 39 set_choice: COMP1 • "Literal" + + "Literal" décalage et aller à l'état 146 + + +État 74 + + 30 set_choice: CONSTANT • "Variable" "Literal" + + "Variable" décalage et aller à l'état 147 + + +État 75 + + 40 set_choice: "DPC-IN-DATA" • "Literal" + + "Literal" décalage et aller à l'état 148 + + +État 76 + + 41 set_choice: FOLDCOPYNAME • _as "Literal" + + AS décalage et aller à l'état 136 + + $défaut réduction par utilisation de la règle 188 (_as) + + _as aller à l'état 149 + + +État 77 + + 42 set_choice: KEYCOMPRESS • "Literal" + + "Literal" décalage et aller à l'état 150 + + +État 78 + + 43 set_choice: NOKEYCOMPRESS • + + $défaut réduction par utilisation de la règle 43 (set_choice) + + +État 79 + + 44 set_choice: MAKESYN • alnum_equality + + "Literal" décalage et aller à l'état 138 + + alnum_equality aller à l'état 151 + + +État 80 + + 45 set_choice: NOBOUND • + + $défaut réduction par utilisation de la règle 45 (set_choice) + + +État 81 + + 46 set_choice: "NODPC-IN-DATA" • + + $défaut réduction par utilisation de la règle 46 (set_choice) + + +État 82 + + 47 set_choice: NOFOLDCOPYNAME • + + $défaut réduction par utilisation de la règle 47 (set_choice) + + +État 83 + + 49 set_choice: NOODOSLIDE • + + $défaut réduction par utilisation de la règle 49 (set_choice) + + +État 84 + + 48 set_choice: NOSSRANGE • + + $défaut réduction par utilisation de la règle 48 (set_choice) + + +État 85 + + 50 set_choice: ODOSLIDE • + + $défaut réduction par utilisation de la règle 50 (set_choice) + + +État 86 + + 52 set_choice: REMOVE • alnum_list + + "Literal" décalage et aller à l'état 119 + + alnum_list aller à l'état 152 + + +État 87 + + 53 set_choice: SOURCEFORMAT • _as "Literal" + 54 | SOURCEFORMAT • _as error + + AS décalage et aller à l'état 136 + + $défaut réduction par utilisation de la règle 188 (_as) + + _as aller à l'état 153 + + +État 88 + + 55 set_choice: SPZERO • + + $défaut réduction par utilisation de la règle 55 (set_choice) + + +État 89 + + 56 set_choice: SSRANGE • _literal + + "Literal" décalage et aller à l'état 154 + + $défaut réduction par utilisation de la règle 77 (_literal) + + _literal aller à l'état 155 + + +État 90 + + 31 set_choice: "Variable" • set_options + + AS décalage et aller à l'état 136 + + "Literal" réduction par utilisation de la règle 188 (_as) + $défaut réduction par utilisation de la règle 68 (set_options) + + set_options aller à l'état 156 + _as aller à l'état 157 + + +État 91 + + 11 directive: SET_DIRECTIVE set_directive • + 29 set_directive: set_directive • set_choice + + OVERRIDE décalage et aller à l'état 66 + ADDRSV décalage et aller à l'état 67 + ADDSYN décalage et aller à l'état 68 + ASSIGN décalage et aller à l'état 69 + BOUND décalage et aller à l'état 70 + CALLFH décalage et aller à l'état 71 + XFD décalage et aller à l'état 72 + COMP1 décalage et aller à l'état 73 + CONSTANT décalage et aller à l'état 74 + "DPC-IN-DATA" décalage et aller à l'état 75 + FOLDCOPYNAME décalage et aller à l'état 76 + KEYCOMPRESS décalage et aller à l'état 77 + NOKEYCOMPRESS décalage et aller à l'état 78 + MAKESYN décalage et aller à l'état 79 + NOBOUND décalage et aller à l'état 80 + "NODPC-IN-DATA" décalage et aller à l'état 81 + NOFOLDCOPYNAME décalage et aller à l'état 82 + NOODOSLIDE décalage et aller à l'état 83 + NOSSRANGE décalage et aller à l'état 84 + ODOSLIDE décalage et aller à l'état 85 + REMOVE décalage et aller à l'état 86 + SOURCEFORMAT décalage et aller à l'état 87 + SPZERO décalage et aller à l'état 88 + SSRANGE décalage et aller à l'état 89 + "Variable" décalage et aller à l'état 90 + + $défaut réduction par utilisation de la règle 11 (directive) + + set_choice aller à l'état 158 + + +État 92 + + 28 set_directive: set_choice • + + $défaut réduction par utilisation de la règle 28 (set_directive) + + +État 93 + + 17 directive: IF_DIRECTIVE $@1 • if_directive_if + + error décalage et aller à l'état 159 + "Variable" décalage et aller à l'état 160 + "Literal" décalage et aller à l'état 161 + + if_directive_if aller à l'état 162 + if_directive aller à l'état 163 + garbage aller à l'état 164 + variable_or_literal aller à l'état 165 + + +État 94 + + 19 directive: ELIF_DIRECTIVE $@2 • if_directive_elif + + error décalage et aller à l'état 166 + "Variable" décalage et aller à l'état 160 + "Literal" décalage et aller à l'état 161 + + if_directive_elif aller à l'état 167 + if_directive aller à l'état 168 + garbage aller à l'état 164 + variable_or_literal aller à l'état 165 + + +État 95 + + 107 ec_list: "Variable" • + + $défaut réduction par utilisation de la règle 107 (ec_list) + + +État 96 + + 13 directive: TURN_DIRECTIVE turn_directive • + + $défaut réduction par utilisation de la règle 13 (directive) + + +État 97 + + 106 turn_directive: ec_list • CHECKING on_or_off + 108 ec_list: ec_list • "Variable" + + CHECKING décalage et aller à l'état 169 + "Variable" décalage et aller à l'état 170 + + +État 98 + + 5 statement: directive "end of line" • + + $défaut réduction par utilisation de la règle 5 (statement) + + +État 99 + + 3 statement: copy_statement "." • + + $défaut réduction par utilisation de la règle 3 (statement) + + +État 100 + + 4 statement: replace_statement "." • + + $défaut réduction par utilisation de la règle 4 (statement) + + +État 101 + + 150 in_or_of: IN • + + $défaut réduction par utilisation de la règle 150 (in_or_of) + + +État 102 + + 151 in_or_of: OF • + + $défaut réduction par utilisation de la règle 151 (in_or_of) + + +État 103 + + 145 copy_statement: COPY copy_source copy_in • copy_suppress copy_replacing + + SUPPRESS décalage et aller à l'état 171 + + $défaut réduction par utilisation de la règle 152 (copy_suppress) + + copy_suppress aller à l'état 172 + + +État 104 + + 149 copy_in: in_or_of • copy_source + + "Identifier or Literal" décalage et aller à l'état 26 + "Text-Name" décalage et aller à l'état 27 + + copy_source aller à l'état 173 + + +État 105 + + 162 text_src: "==" • token_list "==" + + "Identifier or Literal" décalage et aller à l'état 174 + + token_list aller à l'état 175 + + +État 106 + + 178 lead_trail: LEADING • + + $défaut réduction par utilisation de la règle 178 (lead_trail) + + +État 107 + + 179 lead_trail: TRAILING • + + $défaut réduction par utilisation de la règle 179 (lead_trail) + + +État 108 + + 172 identifier: "Identifier or Literal" • + + $défaut réduction par utilisation de la règle 172 (identifier) + + +État 109 + + 156 replace_statement: REPLACE _also replacing_list • + 160 replacing_list: replacing_list • text_src BY text_dst + 161 | replacing_list • lead_trail text_partial_src BY text_partial_dst + + "==" décalage et aller à l'état 105 + LEADING décalage et aller à l'état 106 + TRAILING décalage et aller à l'état 107 + "Identifier or Literal" décalage et aller à l'état 108 + + $défaut réduction par utilisation de la règle 156 (replace_statement) + + text_src aller à l'état 176 + identifier aller à l'état 111 + lead_trail aller à l'état 177 + + +État 110 + + 158 replacing_list: text_src • BY text_dst + + BY décalage et aller à l'état 178 + + +État 111 + + 163 text_src: identifier • + 173 identifier: identifier • IN "Identifier or Literal" + 174 | identifier • OF "Identifier or Literal" + 175 | identifier • '(' subscripts ')' + + IN décalage et aller à l'état 179 + OF décalage et aller à l'état 180 + '(' décalage et aller à l'état 181 + + $défaut réduction par utilisation de la règle 163 (text_src) + + +État 112 + + 159 replacing_list: lead_trail • text_partial_src BY text_partial_dst + + "==" décalage et aller à l'état 182 + + text_partial_src aller à l'état 183 + + +État 113 + + 157 replace_statement: REPLACE _last OFF • + + $défaut réduction par utilisation de la règle 157 (replace_statement) + + +État 114 + + 102 _dot: "." • + + $défaut réduction par utilisation de la règle 102 (_dot) + + +État 115 + + 92 listing_statement: TITLE_STATEMENT "Literal" _dot • "end of line" + + "end of line" décalage et aller à l'état 184 + + +État 116 + + 64 alnum_with: "Literal" • WITH "Literal" + + WITH décalage et aller à l'état 185 + + +État 117 + + 63 alnum_with_list: alnum_with_list • alnum_with + 84 cobol_words_directive: EQUATE alnum_with_list • + + "Literal" décalage et aller à l'état 116 + + $défaut réduction par utilisation de la règle 84 (cobol_words_directive) + + alnum_with aller à l'état 186 + + +État 118 + + 62 alnum_with_list: alnum_with • + + $défaut réduction par utilisation de la règle 62 (alnum_with_list) + + +État 119 + + 57 alnum_list: "Literal" • + + $défaut réduction par utilisation de la règle 57 (alnum_list) + + +État 120 + + 58 alnum_list: alnum_list • "Literal" + 85 cobol_words_directive: UNDEFINE alnum_list • + + "Literal" décalage et aller à l'état 187 + + $défaut réduction par utilisation de la règle 85 (cobol_words_directive) + + +État 121 + + 67 alnum_by: "Literal" • BY "Literal" + + BY décalage et aller à l'état 188 + + +État 122 + + 66 alnum_by_list: alnum_by_list • alnum_by + 86 cobol_words_directive: SUBSTITUTE alnum_by_list • + + "Literal" décalage et aller à l'état 121 + + $défaut réduction par utilisation de la règle 86 (cobol_words_directive) + + alnum_by aller à l'état 189 + + +État 123 + + 65 alnum_by_list: alnum_by • + + $défaut réduction par utilisation de la règle 65 (alnum_by_list) + + +État 124 + + 58 alnum_list: alnum_list • "Literal" + 87 cobol_words_directive: RESERVE alnum_list • + + "Literal" décalage et aller à l'état 187 + + $défaut réduction par utilisation de la règle 87 (cobol_words_directive) + + +État 125 + + 94 control_options: control_options control_option • + + $défaut réduction par utilisation de la règle 94 (control_options) + + +État 126 + + 7 statement: CONTROL_STATEMENT control_options _dot • "end of line" + + "end of line" décalage et aller à l'état 190 + + +État 127 + + 193 _is: IS • + + $défaut réduction par utilisation de la règle 193 (_is) + + +État 128 + + 72 source_directive: _format _is • format_type + + "word" décalage et aller à l'état 191 + FIXED décalage et aller à l'état 192 + FREE décalage et aller à l'état 193 + VARIABLE décalage et aller à l'état 194 + + format_type aller à l'état 195 + + +État 129 + + 118 call_choice: COBOL • + + $défaut réduction par utilisation de la règle 118 (call_choice) + + +État 130 + + 119 call_choice: "EXTERN" • + + $défaut réduction par utilisation de la règle 119 (call_choice) + + +État 131 + + 120 call_choice: STDCALL • + + $défaut réduction par utilisation de la règle 120 (call_choice) + + +État 132 + + 121 call_choice: STATIC • + + $défaut réduction par utilisation de la règle 121 (call_choice) + + +État 133 + + 23 directive: CALL_DIRECTIVE $@3 call_directive • + 117 call_directive: call_directive • call_choice + + COBOL décalage et aller à l'état 129 + "EXTERN" décalage et aller à l'état 130 + STDCALL décalage et aller à l'état 131 + STATIC décalage et aller à l'état 132 + + $défaut réduction par utilisation de la règle 23 (directive) + + call_choice aller à l'état 196 + + +État 134 + + 116 call_directive: call_choice • + + $défaut réduction par utilisation de la règle 116 (call_directive) + + +État 135 + + 82 define_directive: CONSTANT "Variable" • _as "Literal" _override + + AS décalage et aller à l'état 136 + + $défaut réduction par utilisation de la règle 188 (_as) + + _as aller à l'état 197 + + +État 136 + + 189 _as: AS • + + $défaut réduction par utilisation de la règle 189 (_as) + + +État 137 + + 79 define_directive: "Variable" _as • "Literal" _override + 80 | "Variable" _as • PARAMETER _override + 81 | "Variable" _as • OFF + + OFF décalage et aller à l'état 198 + PARAMETER décalage et aller à l'état 199 + "Literal" décalage et aller à l'état 200 + + +État 138 + + 61 alnum_equality: "Literal" • "=" "Literal" + + "=" décalage et aller à l'état 201 + + +État 139 + + 51 set_choice: OVERRIDE alnum_equality_list • + 60 alnum_equality_list: alnum_equality_list • alnum_equality + + "Literal" décalage et aller à l'état 138 + + $défaut réduction par utilisation de la règle 51 (set_choice) + + alnum_equality aller à l'état 202 + + +État 140 + + 59 alnum_equality_list: alnum_equality • + + $défaut réduction par utilisation de la règle 59 (alnum_equality_list) + + +État 141 + + 32 set_choice: ADDRSV alnum_list • + 58 alnum_list: alnum_list • "Literal" + + "Literal" décalage et aller à l'état 187 + + $défaut réduction par utilisation de la règle 32 (set_choice) + + +État 142 + + 33 set_choice: ADDSYN alnum_equality • + + $défaut réduction par utilisation de la règle 33 (set_choice) + + +État 143 + + 34 set_choice: ASSIGN "Literal" • + + $défaut réduction par utilisation de la règle 34 (set_choice) + + +État 144 + + 36 set_choice: CALLFH "Literal" • + + $défaut réduction par utilisation de la règle 36 (set_choice) + + +État 145 + + 38 set_choice: XFD "Literal" • + + $défaut réduction par utilisation de la règle 38 (set_choice) + + +État 146 + + 39 set_choice: COMP1 "Literal" • + + $défaut réduction par utilisation de la règle 39 (set_choice) + + +État 147 + + 30 set_choice: CONSTANT "Variable" • "Literal" + + "Literal" décalage et aller à l'état 203 + + +État 148 + + 40 set_choice: "DPC-IN-DATA" "Literal" • + + $défaut réduction par utilisation de la règle 40 (set_choice) + + +État 149 + + 41 set_choice: FOLDCOPYNAME _as • "Literal" + + "Literal" décalage et aller à l'état 204 + + +État 150 + + 42 set_choice: KEYCOMPRESS "Literal" • + + $défaut réduction par utilisation de la règle 42 (set_choice) + + +État 151 + + 44 set_choice: MAKESYN alnum_equality • + + $défaut réduction par utilisation de la règle 44 (set_choice) + + +État 152 + + 52 set_choice: REMOVE alnum_list • + 58 alnum_list: alnum_list • "Literal" + + "Literal" décalage et aller à l'état 187 + + $défaut réduction par utilisation de la règle 52 (set_choice) + + +État 153 + + 53 set_choice: SOURCEFORMAT _as • "Literal" + 54 | SOURCEFORMAT _as • error + + error décalage et aller à l'état 205 + "Literal" décalage et aller à l'état 206 + + +État 154 + + 78 _literal: "Literal" • + + $défaut réduction par utilisation de la règle 78 (_literal) + + +État 155 + + 56 set_choice: SSRANGE _literal • + + $défaut réduction par utilisation de la règle 56 (set_choice) + + +État 156 + + 31 set_choice: "Variable" set_options • + + $défaut réduction par utilisation de la règle 31 (set_choice) + + +État 157 + + 69 set_options: _as • "Literal" + + "Literal" décalage et aller à l'état 207 + + +État 158 + + 29 set_directive: set_directive set_choice • + + $défaut réduction par utilisation de la règle 29 (set_directive) + + +État 159 + + 25 if_directive_if: error • + + $défaut réduction par utilisation de la règle 25 (if_directive_if) + + +État 160 + + 122 if_directive: "Variable" • _is _not DEFINED + 123 | "Variable" • _is _not SET + 124 | "Variable" • _is _not condition_clause object_id + 130 variable_or_literal: "Variable" • + + IS décalage et aller à l'état 127 + + error réduction par utilisation de la règle 130 (variable_or_literal) + "end of line" réduction par utilisation de la règle 130 (variable_or_literal) + "Variable" réduction par utilisation de la règle 130 (variable_or_literal) + "Literal" réduction par utilisation de la règle 130 (variable_or_literal) + $défaut réduction par utilisation de la règle 192 (_is) + + _is aller à l'état 208 + + +État 161 + + 125 if_directive: "Literal" • _is _not condition_clause object_id + 131 variable_or_literal: "Literal" • + + IS décalage et aller à l'état 127 + + error réduction par utilisation de la règle 131 (variable_or_literal) + "end of line" réduction par utilisation de la règle 131 (variable_or_literal) + "Variable" réduction par utilisation de la règle 131 (variable_or_literal) + "Literal" réduction par utilisation de la règle 131 (variable_or_literal) + $défaut réduction par utilisation de la règle 192 (_is) + + _is aller à l'état 209 + + +État 162 + + 17 directive: IF_DIRECTIVE $@1 if_directive_if • + + $défaut réduction par utilisation de la règle 17 (directive) + + +État 163 + + 24 if_directive_if: if_directive • + + $défaut réduction par utilisation de la règle 24 (if_directive_if) + + +État 164 + + 126 if_directive: garbage • + 128 garbage: garbage • variable_or_literal + 129 | garbage • error + + error décalage et aller à l'état 210 + "Variable" décalage et aller à l'état 211 + "Literal" décalage et aller à l'état 59 + + "end of line" réduction par utilisation de la règle 126 (if_directive) + + variable_or_literal aller à l'état 212 + + +État 165 + + 127 garbage: variable_or_literal • + + $défaut réduction par utilisation de la règle 127 (garbage) + + +État 166 + + 27 if_directive_elif: error • + + $défaut réduction par utilisation de la règle 27 (if_directive_elif) + + +État 167 + + 19 directive: ELIF_DIRECTIVE $@2 if_directive_elif • + + $défaut réduction par utilisation de la règle 19 (directive) + + +État 168 + + 26 if_directive_elif: if_directive • + + $défaut réduction par utilisation de la règle 26 (if_directive_elif) + + +État 169 + + 106 turn_directive: ec_list CHECKING • on_or_off + + OFF décalage et aller à l'état 213 + ON décalage et aller à l'état 214 + WITH décalage et aller à l'état 215 + LOCATION décalage et aller à l'état 216 + + on_or_off aller à l'état 217 + on_with_loc aller à l'état 218 + with_loc aller à l'état 219 + + +État 170 + + 108 ec_list: ec_list "Variable" • + + $défaut réduction par utilisation de la règle 108 (ec_list) + + +État 171 + + 153 copy_suppress: SUPPRESS • _printing + + PRINTING décalage et aller à l'état 220 + + $défaut réduction par utilisation de la règle 194 (_printing) + + _printing aller à l'état 221 + + +État 172 + + 145 copy_statement: COPY copy_source copy_in copy_suppress • copy_replacing + + REPLACING décalage et aller à l'état 222 + + $défaut réduction par utilisation de la règle 154 (copy_replacing) + + copy_replacing aller à l'état 223 + + +État 173 + + 149 copy_in: in_or_of copy_source • + + $défaut réduction par utilisation de la règle 149 (copy_in) + + +État 174 + + 170 token_list: "Identifier or Literal" • + + $défaut réduction par utilisation de la règle 170 (token_list) + + +État 175 + + 162 text_src: "==" token_list • "==" + 171 token_list: token_list • "Identifier or Literal" + + "==" décalage et aller à l'état 224 + "Identifier or Literal" décalage et aller à l'état 225 + + +État 176 + + 160 replacing_list: replacing_list text_src • BY text_dst + + BY décalage et aller à l'état 226 + + +État 177 + + 161 replacing_list: replacing_list lead_trail • text_partial_src BY text_partial_dst + + "==" décalage et aller à l'état 182 + + text_partial_src aller à l'état 227 + + +État 178 + + 158 replacing_list: text_src BY • text_dst + + "==" décalage et aller à l'état 228 + "Identifier or Literal" décalage et aller à l'état 108 + + text_dst aller à l'état 229 + identifier aller à l'état 230 + + +État 179 + + 173 identifier: identifier IN • "Identifier or Literal" + + "Identifier or Literal" décalage et aller à l'état 231 + + +État 180 + + 174 identifier: identifier OF • "Identifier or Literal" + + "Identifier or Literal" décalage et aller à l'état 232 + + +État 181 + + 175 identifier: identifier '(' • subscripts ')' + + "Identifier or Literal" décalage et aller à l'état 233 + + subscripts aller à l'état 234 + + +État 182 + + 167 text_partial_src: "==" • "Identifier or Literal" "==" + + "Identifier or Literal" décalage et aller à l'état 235 + + +État 183 + + 159 replacing_list: lead_trail text_partial_src • BY text_partial_dst + + BY décalage et aller à l'état 236 + + +État 184 + + 92 listing_statement: TITLE_STATEMENT "Literal" _dot "end of line" • + + $défaut réduction par utilisation de la règle 92 (listing_statement) + + +État 185 + + 64 alnum_with: "Literal" WITH • "Literal" + + "Literal" décalage et aller à l'état 237 + + +État 186 + + 63 alnum_with_list: alnum_with_list alnum_with • + + $défaut réduction par utilisation de la règle 63 (alnum_with_list) + + +État 187 + + 58 alnum_list: alnum_list "Literal" • + + $défaut réduction par utilisation de la règle 58 (alnum_list) + + +État 188 + + 67 alnum_by: "Literal" BY • "Literal" + + "Literal" décalage et aller à l'état 238 + + +État 189 + + 66 alnum_by_list: alnum_by_list alnum_by • + + $défaut réduction par utilisation de la règle 66 (alnum_by_list) + + +État 190 + + 7 statement: CONTROL_STATEMENT control_options _dot "end of line" • + + $défaut réduction par utilisation de la règle 7 (statement) + + +État 191 + + 76 format_type: "word" • + + $défaut réduction par utilisation de la règle 76 (format_type) + + +État 192 + + 73 format_type: FIXED • + + $défaut réduction par utilisation de la règle 73 (format_type) + + +État 193 + + 74 format_type: FREE • + + $défaut réduction par utilisation de la règle 74 (format_type) + + +État 194 + + 75 format_type: VARIABLE • + + $défaut réduction par utilisation de la règle 75 (format_type) + + +État 195 + + 72 source_directive: _format _is format_type • + + $défaut réduction par utilisation de la règle 72 (source_directive) + + +État 196 + + 117 call_directive: call_directive call_choice • + + $défaut réduction par utilisation de la règle 117 (call_directive) + + +État 197 + + 82 define_directive: CONSTANT "Variable" _as • "Literal" _override + + "Literal" décalage et aller à l'état 239 + + +État 198 + + 81 define_directive: "Variable" _as OFF • + + $défaut réduction par utilisation de la règle 81 (define_directive) + + +État 199 + + 80 define_directive: "Variable" _as PARAMETER • _override + + OVERRIDE décalage et aller à l'état 240 + + $défaut réduction par utilisation de la règle 180 (_override) + + _override aller à l'état 241 + + +État 200 + + 79 define_directive: "Variable" _as "Literal" • _override + + OVERRIDE décalage et aller à l'état 240 + + $défaut réduction par utilisation de la règle 180 (_override) + + _override aller à l'état 242 + + +État 201 + + 61 alnum_equality: "Literal" "=" • "Literal" + + "Literal" décalage et aller à l'état 243 + + +État 202 + + 60 alnum_equality_list: alnum_equality_list alnum_equality • + + $défaut réduction par utilisation de la règle 60 (alnum_equality_list) + + +État 203 + + 30 set_choice: CONSTANT "Variable" "Literal" • + + $défaut réduction par utilisation de la règle 30 (set_choice) + + +État 204 + + 41 set_choice: FOLDCOPYNAME _as "Literal" • + + $défaut réduction par utilisation de la règle 41 (set_choice) + + +État 205 + + 54 set_choice: SOURCEFORMAT _as error • + + $défaut réduction par utilisation de la règle 54 (set_choice) + + +État 206 + + 53 set_choice: SOURCEFORMAT _as "Literal" • + + $défaut réduction par utilisation de la règle 53 (set_choice) + + +État 207 + + 69 set_options: _as "Literal" • + + $défaut réduction par utilisation de la règle 69 (set_options) + + +État 208 + + 122 if_directive: "Variable" _is • _not DEFINED + 123 | "Variable" _is • _not SET + 124 | "Variable" _is • _not condition_clause object_id + + NOT décalage et aller à l'état 244 + + $défaut réduction par utilisation de la règle 182 (_not) + + _not aller à l'état 245 + + +État 209 + + 125 if_directive: "Literal" _is • _not condition_clause object_id + + NOT décalage et aller à l'état 244 + + $défaut réduction par utilisation de la règle 182 (_not) + + _not aller à l'état 246 + + +État 210 + + 129 garbage: garbage error • + + $défaut réduction par utilisation de la règle 129 (garbage) + + +État 211 + + 130 variable_or_literal: "Variable" • + + $défaut réduction par utilisation de la règle 130 (variable_or_literal) + + +État 212 + + 128 garbage: garbage variable_or_literal • + + $défaut réduction par utilisation de la règle 128 (garbage) + + +État 213 + + 111 on_or_off: OFF • + + $défaut réduction par utilisation de la règle 111 (on_or_off) + + +État 214 + + 110 on_or_off: ON • + 112 on_with_loc: ON • with_loc + + WITH décalage et aller à l'état 215 + LOCATION décalage et aller à l'état 216 + + $défaut réduction par utilisation de la règle 110 (on_or_off) + + with_loc aller à l'état 247 + + +État 215 + + 114 with_loc: WITH • LOCATION + + LOCATION décalage et aller à l'état 248 + + +État 216 + + 115 with_loc: LOCATION • + + $défaut réduction par utilisation de la règle 115 (with_loc) + + +État 217 + + 106 turn_directive: ec_list CHECKING on_or_off • + + $défaut réduction par utilisation de la règle 106 (turn_directive) + + +État 218 + + 109 on_or_off: on_with_loc • + + $défaut réduction par utilisation de la règle 109 (on_or_off) + + +État 219 + + 113 on_with_loc: with_loc • + + $défaut réduction par utilisation de la règle 113 (on_with_loc) + + +État 220 + + 195 _printing: PRINTING • + + $défaut réduction par utilisation de la règle 195 (_printing) + + +État 221 + + 153 copy_suppress: SUPPRESS _printing • + + $défaut réduction par utilisation de la règle 153 (copy_suppress) + + +État 222 + + 155 copy_replacing: REPLACING • replacing_list + + "==" décalage et aller à l'état 105 + LEADING décalage et aller à l'état 106 + TRAILING décalage et aller à l'état 107 + "Identifier or Literal" décalage et aller à l'état 108 + + replacing_list aller à l'état 249 + text_src aller à l'état 110 + identifier aller à l'état 111 + lead_trail aller à l'état 112 + + +État 223 + + 145 copy_statement: COPY copy_source copy_in copy_suppress copy_replacing • + + $défaut réduction par utilisation de la règle 145 (copy_statement) + + +État 224 + + 162 text_src: "==" token_list "==" • + + $défaut réduction par utilisation de la règle 162 (text_src) + + +État 225 + + 171 token_list: token_list "Identifier or Literal" • + + $défaut réduction par utilisation de la règle 171 (token_list) + + +État 226 + + 160 replacing_list: replacing_list text_src BY • text_dst + + "==" décalage et aller à l'état 228 + "Identifier or Literal" décalage et aller à l'état 108 + + text_dst aller à l'état 250 + identifier aller à l'état 230 + + +État 227 + + 161 replacing_list: replacing_list lead_trail text_partial_src • BY text_partial_dst + + BY décalage et aller à l'état 251 + + +État 228 + + 164 text_dst: "==" • "==" + 165 | "==" • token_list "==" + + "==" décalage et aller à l'état 252 + "Identifier or Literal" décalage et aller à l'état 174 + + token_list aller à l'état 253 + + +État 229 + + 158 replacing_list: text_src BY text_dst • + + $défaut réduction par utilisation de la règle 158 (replacing_list) + + +État 230 + + 166 text_dst: identifier • + 173 identifier: identifier • IN "Identifier or Literal" + 174 | identifier • OF "Identifier or Literal" + 175 | identifier • '(' subscripts ')' + + IN décalage et aller à l'état 179 + OF décalage et aller à l'état 180 + '(' décalage et aller à l'état 181 + + $défaut réduction par utilisation de la règle 166 (text_dst) + + +État 231 + + 173 identifier: identifier IN "Identifier or Literal" • + + $défaut réduction par utilisation de la règle 173 (identifier) + + +État 232 + + 174 identifier: identifier OF "Identifier or Literal" • + + $défaut réduction par utilisation de la règle 174 (identifier) + + +État 233 + + 176 subscripts: "Identifier or Literal" • + + $défaut réduction par utilisation de la règle 176 (subscripts) + + +État 234 + + 175 identifier: identifier '(' subscripts • ')' + 177 subscripts: subscripts • "Identifier or Literal" + + "Identifier or Literal" décalage et aller à l'état 254 + ')' décalage et aller à l'état 255 + + +État 235 + + 167 text_partial_src: "==" "Identifier or Literal" • "==" + + "==" décalage et aller à l'état 256 + + +État 236 + + 159 replacing_list: lead_trail text_partial_src BY • text_partial_dst + + "==" décalage et aller à l'état 257 + + text_partial_dst aller à l'état 258 + + +État 237 + + 64 alnum_with: "Literal" WITH "Literal" • + + $défaut réduction par utilisation de la règle 64 (alnum_with) + + +État 238 + + 67 alnum_by: "Literal" BY "Literal" • + + $défaut réduction par utilisation de la règle 67 (alnum_by) + + +État 239 + + 82 define_directive: CONSTANT "Variable" _as "Literal" • _override + + OVERRIDE décalage et aller à l'état 240 + + $défaut réduction par utilisation de la règle 180 (_override) + + _override aller à l'état 259 + + +État 240 + + 181 _override: OVERRIDE • + + $défaut réduction par utilisation de la règle 181 (_override) + + +État 241 + + 80 define_directive: "Variable" _as PARAMETER _override • + + $défaut réduction par utilisation de la règle 80 (define_directive) + + +État 242 + + 79 define_directive: "Variable" _as "Literal" _override • + + $défaut réduction par utilisation de la règle 79 (define_directive) + + +État 243 + + 61 alnum_equality: "Literal" "=" "Literal" • + + $défaut réduction par utilisation de la règle 61 (alnum_equality) + + +État 244 + + 183 _not: NOT • + + $défaut réduction par utilisation de la règle 183 (_not) + + +État 245 + + 122 if_directive: "Variable" _is _not • DEFINED + 123 | "Variable" _is _not • SET + 124 | "Variable" _is _not • condition_clause object_id + + ">=" décalage et aller à l'état 260 + "<=" décalage et aller à l'état 261 + "<" décalage et aller à l'état 262 + ">" décalage et aller à l'état 263 + "=" décalage et aller à l'état 264 + "<>" décalage et aller à l'état 265 + EQUAL décalage et aller à l'état 266 + GREATER décalage et aller à l'état 267 + LESS décalage et aller à l'état 268 + SET décalage et aller à l'état 269 + DEFINED décalage et aller à l'état 270 + + condition_clause aller à l'état 271 + + +État 246 + + 125 if_directive: "Literal" _is _not • condition_clause object_id + + ">=" décalage et aller à l'état 260 + "<=" décalage et aller à l'état 261 + "<" décalage et aller à l'état 262 + ">" décalage et aller à l'état 263 + "=" décalage et aller à l'état 264 + "<>" décalage et aller à l'état 265 + EQUAL décalage et aller à l'état 266 + GREATER décalage et aller à l'état 267 + LESS décalage et aller à l'état 268 + + condition_clause aller à l'état 272 + + +État 247 + + 112 on_with_loc: ON with_loc • + + $défaut réduction par utilisation de la règle 112 (on_with_loc) + + +État 248 + + 114 with_loc: WITH LOCATION • + + $défaut réduction par utilisation de la règle 114 (with_loc) + + +État 249 + + 155 copy_replacing: REPLACING replacing_list • + 160 replacing_list: replacing_list • text_src BY text_dst + 161 | replacing_list • lead_trail text_partial_src BY text_partial_dst + + "==" décalage et aller à l'état 105 + LEADING décalage et aller à l'état 106 + TRAILING décalage et aller à l'état 107 + "Identifier or Literal" décalage et aller à l'état 108 + + $défaut réduction par utilisation de la règle 155 (copy_replacing) + + text_src aller à l'état 176 + identifier aller à l'état 111 + lead_trail aller à l'état 177 + + +État 250 + + 160 replacing_list: replacing_list text_src BY text_dst • + + $défaut réduction par utilisation de la règle 160 (replacing_list) + + +État 251 + + 161 replacing_list: replacing_list lead_trail text_partial_src BY • text_partial_dst + + "==" décalage et aller à l'état 257 + + text_partial_dst aller à l'état 273 + + +État 252 + + 164 text_dst: "==" "==" • + + $défaut réduction par utilisation de la règle 164 (text_dst) + + +État 253 + + 165 text_dst: "==" token_list • "==" + 171 token_list: token_list • "Identifier or Literal" + + "==" décalage et aller à l'état 274 + "Identifier or Literal" décalage et aller à l'état 225 + + +État 254 + + 177 subscripts: subscripts "Identifier or Literal" • + + $défaut réduction par utilisation de la règle 177 (subscripts) + + +État 255 + + 175 identifier: identifier '(' subscripts ')' • + + $défaut réduction par utilisation de la règle 175 (identifier) + + +État 256 + + 167 text_partial_src: "==" "Identifier or Literal" "==" • + + $défaut réduction par utilisation de la règle 167 (text_partial_src) + + +État 257 + + 168 text_partial_dst: "==" • "==" + 169 | "==" • "Identifier or Literal" "==" + + "==" décalage et aller à l'état 275 + "Identifier or Literal" décalage et aller à l'état 276 + + +État 258 + + 159 replacing_list: lead_trail text_partial_src BY text_partial_dst • + + $défaut réduction par utilisation de la règle 159 (replacing_list) + + +État 259 + + 82 define_directive: CONSTANT "Variable" _as "Literal" _override • + + $défaut réduction par utilisation de la règle 82 (define_directive) + + +État 260 + + 139 condition_clause: ">=" • + + $défaut réduction par utilisation de la règle 139 (condition_clause) + + +État 261 + + 141 condition_clause: "<=" • + + $défaut réduction par utilisation de la règle 141 (condition_clause) + + +État 262 + + 142 condition_clause: "<" • + + $défaut réduction par utilisation de la règle 142 (condition_clause) + + +État 263 + + 140 condition_clause: ">" • + + $défaut réduction par utilisation de la règle 140 (condition_clause) + + +État 264 + + 143 condition_clause: "=" • + + $défaut réduction par utilisation de la règle 143 (condition_clause) + + +État 265 + + 144 condition_clause: "<>" • + + $défaut réduction par utilisation de la règle 144 (condition_clause) + + +État 266 + + 138 condition_clause: EQUAL • _to + + TO décalage et aller à l'état 277 + + $défaut réduction par utilisation de la règle 200 (_to) + + _to aller à l'état 278 + + +État 267 + + 134 condition_clause: GREATER • _than OR EQUAL _to + 135 | GREATER • _than + + THAN décalage et aller à l'état 279 + + $défaut réduction par utilisation de la règle 198 (_than) + + _than aller à l'état 280 + + +État 268 + + 136 condition_clause: LESS • _than OR EQUAL _to + 137 | LESS • _than + + THAN décalage et aller à l'état 279 + + $défaut réduction par utilisation de la règle 198 (_than) + + _than aller à l'état 281 + + +État 269 + + 123 if_directive: "Variable" _is _not SET • + + $défaut réduction par utilisation de la règle 123 (if_directive) + + +État 270 + + 122 if_directive: "Variable" _is _not DEFINED • + + $défaut réduction par utilisation de la règle 122 (if_directive) + + +État 271 + + 124 if_directive: "Variable" _is _not condition_clause • object_id + + "Variable" décalage et aller à l'état 282 + "Literal" décalage et aller à l'état 283 + + object_id aller à l'état 284 + + +État 272 + + 125 if_directive: "Literal" _is _not condition_clause • object_id + + "Variable" décalage et aller à l'état 282 + "Literal" décalage et aller à l'état 283 + + object_id aller à l'état 285 + + +État 273 + + 161 replacing_list: replacing_list lead_trail text_partial_src BY text_partial_dst • + + $défaut réduction par utilisation de la règle 161 (replacing_list) + + +État 274 + + 165 text_dst: "==" token_list "==" • + + $défaut réduction par utilisation de la règle 165 (text_dst) + + +État 275 + + 168 text_partial_dst: "==" "==" • + + $défaut réduction par utilisation de la règle 168 (text_partial_dst) + + +État 276 + + 169 text_partial_dst: "==" "Identifier or Literal" • "==" + + "==" décalage et aller à l'état 286 + + +État 277 + + 201 _to: TO • + + $défaut réduction par utilisation de la règle 201 (_to) + + +État 278 + + 138 condition_clause: EQUAL _to • + + $défaut réduction par utilisation de la règle 138 (condition_clause) + + +État 279 + + 199 _than: THAN • + + $défaut réduction par utilisation de la règle 199 (_than) + + +État 280 + + 134 condition_clause: GREATER _than • OR EQUAL _to + 135 | GREATER _than • + + OR décalage et aller à l'état 287 + + $défaut réduction par utilisation de la règle 135 (condition_clause) + + +État 281 + + 136 condition_clause: LESS _than • OR EQUAL _to + 137 | LESS _than • + + OR décalage et aller à l'état 288 + + $défaut réduction par utilisation de la règle 137 (condition_clause) + + +État 282 + + 133 object_id: "Variable" • + + $défaut réduction par utilisation de la règle 133 (object_id) + + +État 283 + + 132 object_id: "Literal" • + + $défaut réduction par utilisation de la règle 132 (object_id) + + +État 284 + + 124 if_directive: "Variable" _is _not condition_clause object_id • + + $défaut réduction par utilisation de la règle 124 (if_directive) + + +État 285 + + 125 if_directive: "Literal" _is _not condition_clause object_id • + + $défaut réduction par utilisation de la règle 125 (if_directive) + + +État 286 + + 169 text_partial_dst: "==" "Identifier or Literal" "==" • + + $défaut réduction par utilisation de la règle 169 (text_partial_dst) + + +État 287 + + 134 condition_clause: GREATER _than OR • EQUAL _to + + EQUAL décalage et aller à l'état 289 + + +État 288 + + 136 condition_clause: LESS _than OR • EQUAL _to + + EQUAL décalage et aller à l'état 290 + + +État 289 + + 134 condition_clause: GREATER _than OR EQUAL • _to + + TO décalage et aller à l'état 277 + + $défaut réduction par utilisation de la règle 200 (_to) + + _to aller à l'état 291 + + +État 290 + + 136 condition_clause: LESS _than OR EQUAL • _to + + TO décalage et aller à l'état 277 + + $défaut réduction par utilisation de la règle 200 (_to) + + _to aller à l'état 292 + + +État 291 + + 134 condition_clause: GREATER _than OR EQUAL _to • + + $défaut réduction par utilisation de la règle 134 (condition_clause) + + +État 292 + + 136 condition_clause: LESS _than OR EQUAL _to • + + $défaut réduction par utilisation de la règle 136 (condition_clause) diff --git a/cobc/ppparse.y b/cobc/ppparse.y index ce9859aa7..ac1359a68 100644 --- a/cobc/ppparse.y +++ b/cobc/ppparse.y @@ -741,12 +741,12 @@ directive: { current_cmd = PLEX_ACT_IF; } - if_directive + if_directive_if | ELIF_DIRECTIVE { current_cmd = PLEX_ACT_ELIF; } - if_directive + if_directive_elif | ELSE_DIRECTIVE { plex_action_directive (PLEX_ACT_ELSE, 0); @@ -767,6 +767,24 @@ directive: } ; +if_directive_if: + if_directive +| error + { + cb_error (_("invalid %s directive"), "IF"); + yyerrok; + } +; + +if_directive_elif: + if_directive +| error + { + cb_error (_("invalid %s directive"), "ELIF"); + yyerrok; + } +; + set_directive: set_choice | set_directive set_choice @@ -993,7 +1011,7 @@ set_choice: } | SOURCEFORMAT _as error { - /* FIXME: we should consume until end of line here! */ + /* FIXME: we should consume until end of line here! */ ppp_error_invalid_option ("SOURCEFORMAT", NULL); } | SPZERO @@ -1412,12 +1430,19 @@ if_directive: } plex_action_directive (current_cmd, found ^ $3); } -| variable_or_literal +| garbage { - cb_error (_("invalid %s directive"), "IF/ELIF"); + plex_action_directive (current_cmd, 0); + YYERROR; } ; +garbage: + variable_or_literal +| garbage variable_or_literal +| garbage error +; + variable_or_literal: VARIABLE_NAME | LITERAL diff --git a/tests/testsuite.src/run_extensions.at b/tests/testsuite.src/run_extensions.at index cc27a9383..c603daa54 100644 --- a/tests/testsuite.src/run_extensions.at +++ b/tests/testsuite.src/run_extensions.at @@ -5773,99 +5773,6 @@ AT_CHECK([$COBCRUN_DIRECT ./prog], [0], [], []) AT_CLEANUP -AT_SETUP([Conditional / define directives (5)]) -AT_KEYWORDS([extensions directive]) - -AT_DATA([prog.cob], [ - IDENTIFICATION DIVISION. - PROGRAM-ID. prog. - DATA DIVISION. - WORKING-STORAGE SECTION. - PROCEDURE DIVISION. - >>IF ACTIVATE DEFINED - >>DISPLAY NOTOK - >>ELIF ACTIVATE2 DEFINED - >>DISPLAY OK - >>ELSE - >>DISPLAY NOTOK - >>END-IF - STOP RUN. -]) - -AT_CHECK([$COMPILE -DACTIVATE2 prog.cob], [0], -[OK -]) -AT_CLEANUP - - -AT_SETUP([Conditional / define directives (6)]) -AT_KEYWORDS([extensions directive]) - -AT_DATA([prog.cob], [ - IDENTIFICATION DIVISION. - PROGRAM-ID. prog. - PROCEDURE DIVISION. - >>IF X DEFINED - >>DISPLAY X defined - >>ELSE - >>DISPLAY X not defined - >>DEFINE X 1 - >>END-IF - CONTINUE - . -]) - -AT_CHECK([$COMPILE -D X prog.cob], [0], -[X defined -]) -AT_CHECK([$COMPILE prog.cob], [0], -[X not defined -]) -AT_CLEANUP - - -AT_SETUP([Conditional / define directives (7)]) -AT_KEYWORDS([extensions directive]) - -AT_DATA([prog.cob], [ - IDENTIFICATION DIVISION. - PROGRAM-ID. prog. - PROCEDURE DIVISION. - >>IF A IS DEFINED - >>IF B IS DEFINED - CONTINUE - . - >>ELSE - CONTINUE - . - >>END-IF - >>END-IF -]) - -AT_CHECK([$COMPILE prog.cob], [0], []) -AT_CLEANUP - - -AT_SETUP([Conditional / define directives (8)]) -AT_KEYWORDS([extensions directive]) - -AT_DATA([prog.cob], [ - IDENTIFICATION DIVISION. - PROGRAM-ID. prog. - PROCEDURE DIVISION. - >>IF A IS DEFINED - CONTINUE - . - >>else - CONTINUE - . - >>eNd-If -]) - -AT_CHECK([$COMPILE prog.cob], [0], []) -AT_CLEANUP - - AT_SETUP([Variable format]) AT_KEYWORDS([extensions runmisc]) diff --git a/tests/testsuite.src/syn_misc.at b/tests/testsuite.src/syn_misc.at index 364a27b42..4ecd42ceb 100644 --- a/tests/testsuite.src/syn_misc.at +++ b/tests/testsuite.src/syn_misc.at @@ -8224,3 +8224,221 @@ AT_CHECK([$COMPILE_ONLY prog.cob], [0], ]) AT_CLEANUP + +AT_SETUP([conditional / define directives (1)]) +AT_KEYWORDS([misc directive]) + +AT_DATA([prog.cob], [ + IDENTIFICATION DIVISION. + PROGRAM-ID. prog. + DATA DIVISION. + WORKING-STORAGE SECTION. + PROCEDURE DIVISION. + >>IF ACTIVATE DEFINED + >>DISPLAY "NOTOK" + >>ELIF ACTIVATE2 DEFINED + >>DISPLAY "OK" + >>ELSE + >>DISPLAY "NOTOK" + >>END-IF + STOP RUN. +]) + +AT_CHECK([$COMPILE_ONLY -DACTIVATE2 prog.cob], [0], +[OK +]) +AT_CLEANUP + + +AT_SETUP([conditional / define directives (2)]) +AT_KEYWORDS([misc directive]) + +# COBOL 2002 format; checks that defines are applied at correct place + +AT_DATA([prog.cob], [ + IDENTIFICATION DIVISION. + PROGRAM-ID. prog. + PROCEDURE DIVISION. + >> IF X DEFINED + >>DISPLAY "X defined" + >> ELSE + >> DISPLAY "X not defined" + >> DEFINE X 1 + >> END-IF + CONTINUE + . +]) + +AT_CHECK([$COMPILE_ONLY -D X prog.cob], [0], +[X defined +]) +AT_CHECK([$COMPILE_ONLY prog.cob], [0], +[X not defined +]) +AT_CLEANUP + + +AT_SETUP([conditional / define directives (3)]) +AT_KEYWORDS([misc directive]) + +AT_DATA([prog.cob], [ + IDENTIFICATION DIVISION. + PROGRAM-ID. prog. + PROCEDURE DIVISION. + >>IF A IS DEFINED + >>IF B IS DEFINED + CONTINUE + >> DISPLAY "NOT OK (not both definitions)" + . + >>ELSE + CONTINUE + >> DISPLAY "NOT OK (no definitions)" + . + >>END-IF + >>ELSE + CONTINUE + >> DISPLAY "OK" + . + >>END-IF +]) + +AT_CHECK([$COMPILE_ONLY prog.cob], [0], +[OK +], []) +AT_CLEANUP + + +AT_SETUP([conditional / define directives (4)]) +AT_KEYWORDS([misc directive]) + +# check for case-insensivity + +AT_DATA([prog.cob], [ + IDENTIFICATION DIVISION. + PROGRAM-ID. prog. + PROCEDURE DIVISION. + >>IF A IS DEFINED + CONTINUE + . + >>else + CONTINUE + . + >>eNd-If +]) + +AT_CHECK([$COMPILE_ONLY prog.cob], [0], []) +AT_CLEANUP + + +AT_SETUP([error handling in conditional directives]) +AT_KEYWORDS([misc directive]) + +AT_DATA([prog.cob], [ + IDENTIFICATION DIVISION. + PROGRAM-ID. prog. + PROCEDURE DIVISION. + >> IF BANANA + >>DISPLAY "Who throws bananas?" + >> ELSE + >> DISPLAY "No BANANA here." + >> DEFINE X 1 + >> END-IF + CONTINUE + . +]) + +AT_CHECK([$COMPILE_ONLY -D X prog.cob], [1], +[No BANANA here. +], +[prog.cob:5: error: invalid IF directive +prog.cob:9: error: duplicate DEFINE directive 'X' +]) +AT_CLEANUP + + +AT_SETUP([conditional directives with lvl 78 (1)]) +AT_KEYWORDS([misc extensions directive]) + +# MicroFocus format; checks that level 78 are applied + +# FIXME - not done yet: +AT_XFAIL_IF(true) + +AT_DATA([prog.cob], [ + IDENTIFICATION DIVISION. + PROGRAM-ID. prog. + DATA DIVISION. + WORKING-STORAGE SECTION. + 78 Y VALUE 'a'. + PROCEDURE DIVISION. + $IF X DEFINED + $DISPLAY X defined + $ELIF Y DEFINED + $DISPLAY X not defined, but Y via lvl 78 + $ELSE + $DISPLAY X not defined + $END + CONTINUE + . +]) + +AT_CHECK([$COMPILE_ONLY -D X prog.cob], [0], +[X defined +]) +AT_CHECK([$COMPILE_ONLY prog.cob], [0], +[X not defined, but Y via lvl 78 +]) +AT_CLEANUP + + +AT_SETUP([conditional directives with lvl 78 (2)]) +AT_KEYWORDS([misc extensions directive]) + +# MicroFocus format; checks that level 78 are applied with correct values + +# FIXME - not done yet: +AT_XFAIL_IF(true) + +AT_DATA([prog.cob], [ + IDENTIFICATION DIVISION. + PROGRAM-ID. prog. + DATA DIVISION. + WORKING-STORAGE SECTION. + 78 Y VALUE 1. + 78 Y2 VALUE 1. + 78 X VALUE 2. + 78 Z VALUE 354. + PROCEDURE DIVISION. + $IF Y = Y2X + $DISPLAY correct Y = Y2 + $ELSE + $DISPLAY bad: Y should be = Y2 + $END + $IF Y > X + $DISPLAY BAD - Y is not > X + $ELIF Y < X + $DISPLAY correct Y < X + $ELSE + $DISPLAY BROKEN + $END + + $IF X > Y + $DISPLAY correct X > Y + $ELIF X < Y + $DISPLAY BAD - X is not < Y + $ELSE + $DISPLAY BROKEN + $END + CONTINUE + . +]) + +AT_CHECK([$COMPILE_ONLY prog.cob], [0], +[correct Y = Y2 +correct Y < X +correct X > Y +]) +AT_CLEANUP + +# TODO: add missing tests for syntax errors in >>IF/ELSE/END +