expressir 0.2.9-arm64-darwin → 0.2.10-arm64-darwin

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (86) hide show
  1. checksums.yaml +4 -4
  2. data/lib/expressir/express_exp/2.4/express_parser.bundle +0 -0
  3. data/lib/expressir/express_exp/2.5/express_parser.bundle +0 -0
  4. data/lib/expressir/express_exp/2.6/express_parser.bundle +0 -0
  5. data/lib/expressir/express_exp/2.7/express_parser.bundle +0 -0
  6. data/lib/expressir/express_exp/formatter.rb +71 -16
  7. data/lib/expressir/express_exp/visitor.rb +95 -41
  8. data/lib/expressir/model.rb +2 -0
  9. data/lib/expressir/model/attribute.rb +3 -1
  10. data/lib/expressir/model/constant.rb +3 -1
  11. data/lib/expressir/model/entity.rb +11 -21
  12. data/lib/expressir/model/enumeration_item.rb +3 -1
  13. data/lib/expressir/model/expressions/aggregate_initializer.rb +2 -2
  14. data/lib/expressir/model/expressions/aggregate_item.rb +1 -1
  15. data/lib/expressir/model/expressions/attribute_reference.rb +1 -1
  16. data/lib/expressir/model/expressions/binary_expression.rb +1 -1
  17. data/lib/expressir/model/expressions/call.rb +2 -2
  18. data/lib/expressir/model/expressions/entity_constructor.rb +2 -2
  19. data/lib/expressir/model/expressions/group_reference.rb +1 -1
  20. data/lib/expressir/model/expressions/index_reference.rb +1 -1
  21. data/lib/expressir/model/expressions/interval.rb +1 -1
  22. data/lib/expressir/model/expressions/query_expression.rb +3 -1
  23. data/lib/expressir/model/expressions/simple_reference.rb +1 -1
  24. data/lib/expressir/model/expressions/unary_expression.rb +1 -1
  25. data/lib/expressir/model/function.rb +32 -38
  26. data/lib/expressir/model/identifier.rb +1 -2
  27. data/lib/expressir/model/informal_proposition.rb +3 -1
  28. data/lib/expressir/model/interface.rb +2 -2
  29. data/lib/expressir/model/literals/binary.rb +1 -1
  30. data/lib/expressir/model/literals/integer.rb +1 -1
  31. data/lib/expressir/model/literals/logical.rb +1 -1
  32. data/lib/expressir/model/literals/real.rb +1 -1
  33. data/lib/expressir/model/literals/string.rb +1 -1
  34. data/lib/expressir/model/model_element.rb +67 -0
  35. data/lib/expressir/model/parameter.rb +3 -1
  36. data/lib/expressir/model/procedure.rb +33 -39
  37. data/lib/expressir/model/renamed_ref.rb +1 -1
  38. data/lib/expressir/model/repository.rb +3 -3
  39. data/lib/expressir/model/rule.rb +34 -40
  40. data/lib/expressir/model/schema.rb +35 -48
  41. data/lib/expressir/model/scope.rb +0 -3
  42. data/lib/expressir/model/statements/alias.rb +4 -2
  43. data/lib/expressir/model/statements/assignment.rb +1 -1
  44. data/lib/expressir/model/statements/call.rb +2 -2
  45. data/lib/expressir/model/statements/case.rb +2 -2
  46. data/lib/expressir/model/statements/case_action.rb +2 -2
  47. data/lib/expressir/model/statements/compound.rb +2 -2
  48. data/lib/expressir/model/statements/escape.rb +1 -1
  49. data/lib/expressir/model/statements/if.rb +3 -3
  50. data/lib/expressir/model/statements/null.rb +1 -1
  51. data/lib/expressir/model/statements/repeat.rb +4 -2
  52. data/lib/expressir/model/statements/return.rb +1 -1
  53. data/lib/expressir/model/statements/skip.rb +1 -1
  54. data/lib/expressir/model/subtype_constraint.rb +3 -1
  55. data/lib/expressir/model/type.rb +7 -5
  56. data/lib/expressir/model/types/aggregate.rb +3 -1
  57. data/lib/expressir/model/types/array.rb +1 -1
  58. data/lib/expressir/model/types/bag.rb +1 -1
  59. data/lib/expressir/model/types/binary.rb +1 -1
  60. data/lib/expressir/model/types/boolean.rb +1 -1
  61. data/lib/expressir/model/types/enumeration.rb +3 -3
  62. data/lib/expressir/model/types/generic.rb +3 -1
  63. data/lib/expressir/model/types/generic_entity.rb +3 -1
  64. data/lib/expressir/model/types/integer.rb +1 -1
  65. data/lib/expressir/model/types/list.rb +1 -1
  66. data/lib/expressir/model/types/logical.rb +1 -1
  67. data/lib/expressir/model/types/number.rb +1 -1
  68. data/lib/expressir/model/types/real.rb +1 -1
  69. data/lib/expressir/model/types/select.rb +3 -3
  70. data/lib/expressir/model/types/set.rb +1 -1
  71. data/lib/expressir/model/types/string.rb +1 -1
  72. data/lib/expressir/model/unique.rb +4 -2
  73. data/lib/expressir/model/variable.rb +3 -1
  74. data/lib/expressir/model/where.rb +3 -1
  75. data/lib/expressir/version.rb +1 -1
  76. data/original/examples/syntax/remark_formatted.exp +0 -5
  77. data/original/examples/syntax/simple.exp +3 -0
  78. data/original/examples/syntax/syntax.exp +189 -181
  79. data/original/examples/syntax/syntax_formatted.exp +346 -792
  80. data/spec/expressir/express_exp/head_source_spec.rb +1 -4
  81. data/spec/expressir/express_exp/parse_remark_spec.rb +3 -3
  82. data/spec/expressir/express_exp/parse_syntax_spec.rb +1583 -1578
  83. data/spec/expressir/express_exp/source_spec.rb +1 -4
  84. data/spec/expressir/model/model_element_spec.rb +59 -0
  85. data/spec/expressir/model/{find_spec.rb → scope_spec.rb} +1 -1
  86. metadata +6 -3
@@ -1,12 +1,14 @@
1
1
  module Expressir
2
2
  module Model
3
- class Where
3
+ class Where < ModelElement
4
4
  include Identifier
5
5
 
6
6
  attr_accessor :expression
7
7
 
8
8
  def initialize(options = {})
9
9
  @id = options[:id]
10
+ @remarks = options.fetch(:remarks, [])
11
+ @source = options[:source]
10
12
 
11
13
  @expression = options[:expression]
12
14
  end
@@ -1,3 +1,3 @@
1
1
  module Expressir
2
- VERSION = "0.2.9".freeze
2
+ VERSION = "0.2.10".freeze
3
3
  end
@@ -6,7 +6,6 @@ TYPE remark_type = ENUMERATION OF (remark_enumeration_item);
6
6
  WHERE
7
7
  WR1 : TRUE;
8
8
  END_TYPE;
9
-
10
9
  ENTITY remark_entity;
11
10
  remark_attribute : STRING;
12
11
  DERIVE
@@ -18,10 +17,8 @@ ENTITY remark_entity;
18
17
  WHERE
19
18
  WR1 : TRUE;
20
19
  END_ENTITY;
21
-
22
20
  SUBTYPE_CONSTRAINT remark_subtype_constraint FOR remark_entity;
23
21
  END_SUBTYPE_CONSTRAINT;
24
-
25
22
  FUNCTION remark_function(remark_parameter : STRING) : BOOLEAN;
26
23
  TYPE remark_type = ENUMERATION OF (remark_enumeration_item);
27
24
  END_TYPE;
@@ -43,7 +40,6 @@ FUNCTION remark_function(remark_parameter : STRING) : BOOLEAN;
43
40
  --"remark_query" function query scope - function query
44
41
  );
45
42
  END_FUNCTION;
46
-
47
43
  PROCEDURE remark_procedure(remark_parameter : STRING);
48
44
  TYPE remark_type = ENUMERATION OF (remark_enumeration_item);
49
45
  END_TYPE;
@@ -65,7 +61,6 @@ PROCEDURE remark_procedure(remark_parameter : STRING);
65
61
  --"remark_query" procedure query scope - procedure query
66
62
  );
67
63
  END_PROCEDURE;
68
-
69
64
  RULE remark_rule FOR (remark_entity);
70
65
  TYPE remark_type = ENUMERATION OF (remark_enumeration_item);
71
66
  END_TYPE;
@@ -0,0 +1,3 @@
1
+ SCHEMA simple_schema;
2
+ ENTITY empty_entity; END_ENTITY;
3
+ END_SCHEMA;
@@ -119,197 +119,205 @@ RULE multiple_shorthand_variable_expression_rule FOR (empty_entity); LOCAL test,
119
119
  RULE statement_rule FOR (empty_entity); ; WHERE TRUE; END_RULE;
120
120
  RULE where_label_rule FOR (empty_entity); WHERE WR1 : TRUE; END_RULE;
121
121
 
122
- -- simple types
123
- TYPE binary_type = BINARY; END_TYPE;
124
- TYPE binary_width_type = BINARY (3); END_TYPE;
125
- TYPE binary_width_fixed_type = BINARY (3) FIXED; END_TYPE;
126
- TYPE boolean_type = BOOLEAN; END_TYPE;
127
- TYPE integer_type = INTEGER; END_TYPE;
128
- TYPE logical_type = LOGICAL; END_TYPE;
129
- TYPE number_type = NUMBER; END_TYPE;
130
- TYPE real_type = REAL; END_TYPE;
131
- TYPE real_precision_type = REAL (3); END_TYPE;
132
- TYPE string_type = STRING; END_TYPE;
133
- TYPE string_width_type = STRING (3); END_TYPE;
134
- TYPE string_width_fixed_type = STRING (3) FIXED; END_TYPE;
122
+ PROCEDURE statements;
123
+ -- statements
124
+ PROCEDURE alias_simple_reference_statement; ALIAS test FOR test; ; END_ALIAS; END_PROCEDURE;
125
+ PROCEDURE alias_attribute_reference_statement; ALIAS test FOR test.test; ; END_ALIAS; END_PROCEDURE;
126
+ PROCEDURE alias_group_reference_statement; ALIAS test FOR test\test; ; END_ALIAS; END_PROCEDURE;
127
+ PROCEDURE alias_index_reference_statement; ALIAS test FOR test[1]; ; END_ALIAS; END_PROCEDURE;
128
+ PROCEDURE alias_index2_reference_statement; ALIAS test FOR test[1:9]; ; END_ALIAS; END_PROCEDURE;
129
+ PROCEDURE assignment_simple_reference_statement; test := TRUE; END_PROCEDURE;
130
+ PROCEDURE assignment_attribute_reference_statement; test.test := TRUE; END_PROCEDURE;
131
+ PROCEDURE assignment_group_reference_statement; test\test := TRUE; END_PROCEDURE;
132
+ PROCEDURE assignment_index_reference_statement; test[1] := TRUE; END_PROCEDURE;
133
+ PROCEDURE assignment_index2_reference_statement; test[1:9] := TRUE; END_PROCEDURE;
134
+ PROCEDURE case_statement; CASE test OF TRUE : ; END_CASE; END_PROCEDURE;
135
+ PROCEDURE case_multiple_statement; CASE test OF TRUE : ; TRUE : ; END_CASE; END_PROCEDURE;
136
+ PROCEDURE case_multiple_shorthand_statement; CASE test OF TRUE, TRUE : ; END_CASE; END_PROCEDURE;
137
+ PROCEDURE case_otherwise_statement; CASE test OF TRUE : ; OTHERWISE : ; END_CASE; END_PROCEDURE;
138
+ PROCEDURE compound_statement; BEGIN ; END; END_PROCEDURE;
139
+ PROCEDURE escape_statement; ESCAPE; END_PROCEDURE;
140
+ PROCEDURE if_statement; IF TRUE THEN ; END_IF; END_PROCEDURE;
141
+ PROCEDURE if2_statement; IF TRUE THEN ; ; END_IF; END_PROCEDURE;
142
+ PROCEDURE if_else_statement; IF TRUE THEN ; ELSE ; END_IF; END_PROCEDURE;
143
+ PROCEDURE if2_else_statement; IF TRUE THEN ; ; ELSE ; END_IF; END_PROCEDURE;
144
+ PROCEDURE if_else2_statement; IF TRUE THEN ; ELSE ; ; END_IF; END_PROCEDURE;
145
+ PROCEDURE if2_else2_statement; IF TRUE THEN ; ; ELSE ; ; END_IF; END_PROCEDURE;
146
+ PROCEDURE null_statement; ; END_PROCEDURE;
147
+ PROCEDURE call_statement; empty_procedure; END_PROCEDURE;
148
+ PROCEDURE call_parameter_statement; empty_procedure(TRUE); END_PROCEDURE;
149
+ PROCEDURE call_parameter2_statement; empty_procedure(TRUE, TRUE); END_PROCEDURE;
150
+ PROCEDURE call_insert_statement; INSERT(TRUE); END_PROCEDURE;
151
+ PROCEDURE call_remove_statement; REMOVE(TRUE); END_PROCEDURE;
152
+ PROCEDURE repeat_statement; REPEAT; ; END_REPEAT; END_PROCEDURE;
153
+ PROCEDURE repeat_variable_statement; REPEAT test := 1 TO 9; ; END_REPEAT; END_PROCEDURE;
154
+ PROCEDURE repeat_variable_increment_statement; REPEAT test := 1 TO 9 BY 2; ; END_REPEAT; END_PROCEDURE;
155
+ PROCEDURE repeat_while_statement; REPEAT WHILE TRUE; ; END_REPEAT; END_PROCEDURE;
156
+ PROCEDURE repeat_until_statement; REPEAT UNTIL TRUE; ; END_REPEAT; END_PROCEDURE;
157
+ PROCEDURE return_statement; RETURN; END_PROCEDURE;
158
+ PROCEDURE return_expression_statement; RETURN (TRUE); END_PROCEDURE;
159
+ PROCEDURE skip_statement; SKIP; END_PROCEDURE;
160
+ END_PROCEDURE;
135
161
 
136
- -- aggregation types
137
- TYPE array_type = ARRAY [1:9] OF STRING; END_TYPE;
138
- TYPE array_optional_type = ARRAY [1:9] OF OPTIONAL STRING; END_TYPE;
139
- TYPE array_unique_type = ARRAY [1:9] OF UNIQUE STRING; END_TYPE;
140
- TYPE array_optional_unique_type = ARRAY [1:9] OF OPTIONAL UNIQUE STRING; END_TYPE;
141
- TYPE bag_type = BAG OF STRING; END_TYPE;
142
- TYPE bag_bound_type = BAG [1:9] OF STRING; END_TYPE;
143
- TYPE list_type = LIST OF STRING; END_TYPE;
144
- TYPE list_bound_type = LIST [1:9] OF STRING; END_TYPE;
145
- TYPE list_unique_type = LIST OF UNIQUE STRING; END_TYPE;
146
- TYPE list_bound_unique_type = LIST [1:9] OF UNIQUE STRING; END_TYPE;
147
- TYPE set_type = SET OF STRING; END_TYPE;
148
- TYPE set_bound_type = SET [1:9] OF STRING; END_TYPE;
162
+ PROCEDURE types;
163
+ -- simple types
164
+ TYPE binary_type = BINARY; END_TYPE;
165
+ TYPE binary_width_type = BINARY (3); END_TYPE;
166
+ TYPE binary_width_fixed_type = BINARY (3) FIXED; END_TYPE;
167
+ TYPE boolean_type = BOOLEAN; END_TYPE;
168
+ TYPE integer_type = INTEGER; END_TYPE;
169
+ TYPE logical_type = LOGICAL; END_TYPE;
170
+ TYPE number_type = NUMBER; END_TYPE;
171
+ TYPE real_type = REAL; END_TYPE;
172
+ TYPE real_precision_type = REAL (3); END_TYPE;
173
+ TYPE string_type = STRING; END_TYPE;
174
+ TYPE string_width_type = STRING (3); END_TYPE;
175
+ TYPE string_width_fixed_type = STRING (3) FIXED; END_TYPE;
149
176
 
150
- -- constructed types
151
- TYPE select_type = SELECT; END_TYPE;
152
- TYPE select_extensible_type = EXTENSIBLE SELECT; END_TYPE;
153
- TYPE select_extensible_generic_entity_type = EXTENSIBLE GENERIC_ENTITY SELECT; END_TYPE;
154
- TYPE select_list_type = SELECT (empty_type); END_TYPE;
155
- TYPE select_extension_type_ref_type = SELECT BASED_ON select_type; END_TYPE;
156
- TYPE select_extension_type_ref_list_type = SELECT BASED_ON select_type WITH (empty_type); END_TYPE;
157
- TYPE enumeration_type = ENUMERATION; END_TYPE;
158
- TYPE enumeration_extensible_type = EXTENSIBLE ENUMERATION; END_TYPE;
159
- TYPE enumeration_list_type = ENUMERATION OF (test); END_TYPE;
160
- TYPE enumeration_extension_type_ref_type = ENUMERATION BASED_ON enumeration_type; END_TYPE;
161
- TYPE enumeration_extension_type_ref_list_type = ENUMERATION BASED_ON enumeration_type WITH (test); END_TYPE;
177
+ -- aggregation types
178
+ TYPE array_type = ARRAY [1:9] OF STRING; END_TYPE;
179
+ TYPE array_optional_type = ARRAY [1:9] OF OPTIONAL STRING; END_TYPE;
180
+ TYPE array_unique_type = ARRAY [1:9] OF UNIQUE STRING; END_TYPE;
181
+ TYPE array_optional_unique_type = ARRAY [1:9] OF OPTIONAL UNIQUE STRING; END_TYPE;
182
+ TYPE bag_type = BAG OF STRING; END_TYPE;
183
+ TYPE bag_bound_type = BAG [1:9] OF STRING; END_TYPE;
184
+ TYPE list_type = LIST OF STRING; END_TYPE;
185
+ TYPE list_bound_type = LIST [1:9] OF STRING; END_TYPE;
186
+ TYPE list_unique_type = LIST OF UNIQUE STRING; END_TYPE;
187
+ TYPE list_bound_unique_type = LIST [1:9] OF UNIQUE STRING; END_TYPE;
188
+ TYPE set_type = SET OF STRING; END_TYPE;
189
+ TYPE set_bound_type = SET [1:9] OF STRING; END_TYPE;
162
190
 
163
- -- statements
164
- FUNCTION alias_simple_reference_statement : BOOLEAN; ALIAS test FOR test; ; END_ALIAS; END_FUNCTION;
165
- FUNCTION alias_attribute_reference_statement : BOOLEAN; ALIAS test FOR test.test; ; END_ALIAS; END_FUNCTION;
166
- FUNCTION alias_group_reference_statement : BOOLEAN; ALIAS test FOR test\test; ; END_ALIAS; END_FUNCTION;
167
- FUNCTION alias_index_reference_statement : BOOLEAN; ALIAS test FOR test[1]; ; END_ALIAS; END_FUNCTION;
168
- FUNCTION alias_index2_reference_statement : BOOLEAN; ALIAS test FOR test[1:9]; ; END_ALIAS; END_FUNCTION;
169
- FUNCTION assignment_simple_reference_statement : BOOLEAN; test := TRUE; END_FUNCTION;
170
- FUNCTION assignment_attribute_reference_statement : BOOLEAN; test.test := TRUE; END_FUNCTION;
171
- FUNCTION assignment_group_reference_statement : BOOLEAN; test\test := TRUE; END_FUNCTION;
172
- FUNCTION assignment_index_reference_statement : BOOLEAN; test[1] := TRUE; END_FUNCTION;
173
- FUNCTION assignment_index2_reference_statement : BOOLEAN; test[1:9] := TRUE; END_FUNCTION;
174
- FUNCTION case_statement : BOOLEAN; CASE test OF TRUE : ; END_CASE; END_FUNCTION;
175
- FUNCTION case_multiple_statement : BOOLEAN; CASE test OF TRUE : ; TRUE : ; END_CASE; END_FUNCTION;
176
- FUNCTION case_multiple_shorthand_statement : BOOLEAN; CASE test OF TRUE, TRUE : ; END_CASE; END_FUNCTION;
177
- FUNCTION case_otherwise_statement : BOOLEAN; CASE test OF TRUE : ; OTHERWISE : ; END_CASE; END_FUNCTION;
178
- FUNCTION compound_statement : BOOLEAN; BEGIN ; END; END_FUNCTION;
179
- FUNCTION escape_statement : BOOLEAN; ESCAPE; END_FUNCTION;
180
- FUNCTION if_statement : BOOLEAN; IF TRUE THEN ; END_IF; END_FUNCTION;
181
- FUNCTION if2_statement : BOOLEAN; IF TRUE THEN ; ; END_IF; END_FUNCTION;
182
- FUNCTION if_else_statement : BOOLEAN; IF TRUE THEN ; ELSE ; END_IF; END_FUNCTION;
183
- FUNCTION if2_else_statement : BOOLEAN; IF TRUE THEN ; ; ELSE ; END_IF; END_FUNCTION;
184
- FUNCTION if_else2_statement : BOOLEAN; IF TRUE THEN ; ELSE ; ; END_IF; END_FUNCTION;
185
- FUNCTION if2_else2_statement : BOOLEAN; IF TRUE THEN ; ; ELSE ; ; END_IF; END_FUNCTION;
186
- FUNCTION null_statement : BOOLEAN; ; END_FUNCTION;
187
- FUNCTION call_statement : BOOLEAN; empty_procedure; END_FUNCTION;
188
- FUNCTION call_parameter_statement : BOOLEAN; empty_procedure(TRUE); END_FUNCTION;
189
- FUNCTION call_parameter2_statement : BOOLEAN; empty_procedure(TRUE, TRUE); END_FUNCTION;
190
- FUNCTION call_insert_statement : BOOLEAN; INSERT(TRUE); END_FUNCTION;
191
- FUNCTION call_remove_statement : BOOLEAN; REMOVE(TRUE); END_FUNCTION;
192
- FUNCTION repeat_statement : BOOLEAN; REPEAT; ; END_REPEAT; END_FUNCTION;
193
- FUNCTION repeat_variable_statement : BOOLEAN; REPEAT test := 1 TO 9; ; END_REPEAT; END_FUNCTION;
194
- FUNCTION repeat_variable_increment_statement : BOOLEAN; REPEAT test := 1 TO 9 BY 2; ; END_REPEAT; END_FUNCTION;
195
- FUNCTION repeat_while_statement : BOOLEAN; REPEAT WHILE TRUE; ; END_REPEAT; END_FUNCTION;
196
- FUNCTION repeat_until_statement : BOOLEAN; REPEAT UNTIL TRUE; ; END_REPEAT; END_FUNCTION;
197
- FUNCTION return_statement : BOOLEAN; RETURN; END_FUNCTION;
198
- FUNCTION return_expression_statement : BOOLEAN; RETURN (TRUE); END_FUNCTION;
199
- FUNCTION skip_statement : BOOLEAN; SKIP; END_FUNCTION;
191
+ -- constructed types
192
+ TYPE select_type = SELECT; END_TYPE;
193
+ TYPE select_extensible_type = EXTENSIBLE SELECT; END_TYPE;
194
+ TYPE select_extensible_generic_entity_type = EXTENSIBLE GENERIC_ENTITY SELECT; END_TYPE;
195
+ TYPE select_list_type = SELECT (empty_type); END_TYPE;
196
+ TYPE select_extension_type_ref_type = SELECT BASED_ON select_type; END_TYPE;
197
+ TYPE select_extension_type_ref_list_type = SELECT BASED_ON select_type WITH (empty_type); END_TYPE;
198
+ TYPE enumeration_type = ENUMERATION; END_TYPE;
199
+ TYPE enumeration_extensible_type = EXTENSIBLE ENUMERATION; END_TYPE;
200
+ TYPE enumeration_list_type = ENUMERATION OF (test); END_TYPE;
201
+ TYPE enumeration_extension_type_ref_type = ENUMERATION BASED_ON enumeration_type; END_TYPE;
202
+ TYPE enumeration_extension_type_ref_list_type = ENUMERATION BASED_ON enumeration_type WITH (test); END_TYPE;
203
+ END_PROCEDURE;
200
204
 
201
- -- literal expressions
202
- FUNCTION binary_expression : BOOLEAN; RETURN (%011110000111100001111000); END_FUNCTION;
203
- FUNCTION integer_expression : BOOLEAN; RETURN (999); END_FUNCTION;
204
- FUNCTION true_logical_expression : BOOLEAN; RETURN (TRUE); END_FUNCTION;
205
- FUNCTION false_logical_expression : BOOLEAN; RETURN (FALSE); END_FUNCTION;
206
- FUNCTION unknown_logical_expression : BOOLEAN; RETURN (UNKNOWN); END_FUNCTION;
207
- FUNCTION real_expression : BOOLEAN; RETURN (999.999); END_FUNCTION;
208
- FUNCTION simple_string_expression : BOOLEAN; RETURN ('xxx'); END_FUNCTION;
209
- FUNCTION utf8_simple_string_expression : BOOLEAN; RETURN ('UTF8 test: Příliš žluťoučký kůň úpěl ďábelské ódy.'); END_FUNCTION;
210
- FUNCTION encoded_string_expression : BOOLEAN; RETURN ("000000780000007800000078"); END_FUNCTION;
205
+ PROCEDURE expressions;
206
+ LOCAL
207
+ -- literal expressions
208
+ binary_expression : BOOLEAN := %011110000111100001111000;
209
+ integer_expression : BOOLEAN := 999;
210
+ true_logical_expression : BOOLEAN := TRUE;
211
+ false_logical_expression : BOOLEAN := FALSE;
212
+ unknown_logical_expression : BOOLEAN := UNKNOWN;
213
+ real_expression : BOOLEAN := 999.999;
214
+ simple_string_expression : BOOLEAN := 'xxx';
215
+ utf8_simple_string_expression : BOOLEAN := 'UTF8 test: Příliš žluťoučký kůň úpěl ďábelské ódy.';
216
+ encoded_string_expression : BOOLEAN := "000000780000007800000078";
211
217
 
212
- -- constant expressions
213
- FUNCTION const_e_expression : BOOLEAN; RETURN (CONST_E); END_FUNCTION;
214
- FUNCTION indeterminate_expression : BOOLEAN; RETURN (?); END_FUNCTION;
215
- FUNCTION pi_expression : BOOLEAN; RETURN (PI); END_FUNCTION;
216
- FUNCTION self_expression : BOOLEAN; RETURN (SELF); END_FUNCTION;
218
+ -- constant expressions
219
+ const_e_expression : BOOLEAN := CONST_E;
220
+ indeterminate_expression : BOOLEAN := ?;
221
+ pi_expression : BOOLEAN := PI;
222
+ self_expression : BOOLEAN := SELF;
217
223
 
218
- -- function expressions
219
- FUNCTION abs_expression : BOOLEAN; RETURN (ABS(TRUE)); END_FUNCTION;
220
- FUNCTION acos_expression : BOOLEAN; RETURN (ACOS(TRUE)); END_FUNCTION;
221
- FUNCTION asin_expression : BOOLEAN; RETURN (ASIN(TRUE)); END_FUNCTION;
222
- FUNCTION atan_expression : BOOLEAN; RETURN (ATAN(TRUE)); END_FUNCTION;
223
- FUNCTION blength_expression : BOOLEAN; RETURN (BLENGTH(TRUE)); END_FUNCTION;
224
- FUNCTION cos_expression : BOOLEAN; RETURN (COS(TRUE)); END_FUNCTION;
225
- FUNCTION exists_expression : BOOLEAN; RETURN (EXISTS(TRUE)); END_FUNCTION;
226
- FUNCTION exp_expression : BOOLEAN; RETURN (EXP(TRUE)); END_FUNCTION;
227
- FUNCTION format_expression : BOOLEAN; RETURN (FORMAT(TRUE)); END_FUNCTION;
228
- FUNCTION hibound_expression : BOOLEAN; RETURN (HIBOUND(TRUE)); END_FUNCTION;
229
- FUNCTION hiindex_expression : BOOLEAN; RETURN (HIINDEX(TRUE)); END_FUNCTION;
230
- FUNCTION length_expression : BOOLEAN; RETURN (LENGTH(TRUE)); END_FUNCTION;
231
- FUNCTION lobound_expression : BOOLEAN; RETURN (LOBOUND(TRUE)); END_FUNCTION;
232
- FUNCTION loindex_expression : BOOLEAN; RETURN (LOINDEX(TRUE)); END_FUNCTION;
233
- FUNCTION log_expression : BOOLEAN; RETURN (LOG(TRUE)); END_FUNCTION;
234
- FUNCTION log2_expression : BOOLEAN; RETURN (LOG2(TRUE)); END_FUNCTION;
235
- FUNCTION log10_expression : BOOLEAN; RETURN (LOG10(TRUE)); END_FUNCTION;
236
- FUNCTION nvl_expression : BOOLEAN; RETURN (NVL(TRUE)); END_FUNCTION;
237
- FUNCTION odd_expression : BOOLEAN; RETURN (ODD(TRUE)); END_FUNCTION;
238
- FUNCTION rolesof_expression : BOOLEAN; RETURN (ROLESOF(TRUE)); END_FUNCTION;
239
- FUNCTION sin_expression : BOOLEAN; RETURN (SIN(TRUE)); END_FUNCTION;
240
- FUNCTION sizeof_expression : BOOLEAN; RETURN (SIZEOF(TRUE)); END_FUNCTION;
241
- FUNCTION sqrt_expression : BOOLEAN; RETURN (SQRT(TRUE)); END_FUNCTION;
242
- FUNCTION tan_expression : BOOLEAN; RETURN (TAN(TRUE)); END_FUNCTION;
243
- FUNCTION typeof_expression : BOOLEAN; RETURN (TYPEOF(TRUE)); END_FUNCTION;
244
- FUNCTION usedin_expression : BOOLEAN; RETURN (USEDIN(TRUE)); END_FUNCTION;
245
- FUNCTION value_expression : BOOLEAN; RETURN (VALUE(TRUE)); END_FUNCTION;
246
- FUNCTION value_in_expression : BOOLEAN; RETURN (VALUE_IN(TRUE)); END_FUNCTION;
247
- FUNCTION value_unique_expression : BOOLEAN; RETURN (VALUE_UNIQUE(TRUE)); END_FUNCTION;
224
+ -- function expressions
225
+ abs_expression : BOOLEAN := ABS(TRUE);
226
+ acos_expression : BOOLEAN := ACOS(TRUE);
227
+ asin_expression : BOOLEAN := ASIN(TRUE);
228
+ atan_expression : BOOLEAN := ATAN(TRUE);
229
+ blength_expression : BOOLEAN := BLENGTH(TRUE);
230
+ cos_expression : BOOLEAN := COS(TRUE);
231
+ exists_expression : BOOLEAN := EXISTS(TRUE);
232
+ exp_expression : BOOLEAN := EXP(TRUE);
233
+ format_expression : BOOLEAN := FORMAT(TRUE);
234
+ hibound_expression : BOOLEAN := HIBOUND(TRUE);
235
+ hiindex_expression : BOOLEAN := HIINDEX(TRUE);
236
+ length_expression : BOOLEAN := LENGTH(TRUE);
237
+ lobound_expression : BOOLEAN := LOBOUND(TRUE);
238
+ loindex_expression : BOOLEAN := LOINDEX(TRUE);
239
+ log_expression : BOOLEAN := LOG(TRUE);
240
+ log2_expression : BOOLEAN := LOG2(TRUE);
241
+ log10_expression : BOOLEAN := LOG10(TRUE);
242
+ nvl_expression : BOOLEAN := NVL(TRUE);
243
+ odd_expression : BOOLEAN := ODD(TRUE);
244
+ rolesof_expression : BOOLEAN := ROLESOF(TRUE);
245
+ sin_expression : BOOLEAN := SIN(TRUE);
246
+ sizeof_expression : BOOLEAN := SIZEOF(TRUE);
247
+ sqrt_expression : BOOLEAN := SQRT(TRUE);
248
+ tan_expression : BOOLEAN := TAN(TRUE);
249
+ typeof_expression : BOOLEAN := TYPEOF(TRUE);
250
+ usedin_expression : BOOLEAN := USEDIN(TRUE);
251
+ value_expression : BOOLEAN := VALUE(TRUE);
252
+ value_in_expression : BOOLEAN := VALUE_IN(TRUE);
253
+ value_unique_expression : BOOLEAN := VALUE_UNIQUE(TRUE);
248
254
 
249
- -- operator expressions
250
- FUNCTION plus_expression : BOOLEAN; RETURN (+4); END_FUNCTION;
251
- FUNCTION plus_addition_expression : BOOLEAN; RETURN (+(4 + 2)); END_FUNCTION;
252
- FUNCTION minus_expression : BOOLEAN; RETURN (-4); END_FUNCTION;
253
- FUNCTION minus_addition_expression : BOOLEAN; RETURN (-(4 + 2)); END_FUNCTION;
254
- FUNCTION addition_expression : BOOLEAN; RETURN (4 + 2); END_FUNCTION;
255
- FUNCTION subtraction_expression : BOOLEAN; RETURN (4 - 2); END_FUNCTION;
256
- FUNCTION multiplication_expression : BOOLEAN; RETURN (4 * 2); END_FUNCTION;
257
- FUNCTION real_division_expression : BOOLEAN; RETURN (4 / 2); END_FUNCTION;
258
- FUNCTION integer_division_expression : BOOLEAN; RETURN (4 DIV 2); END_FUNCTION;
259
- FUNCTION modulo_expression : BOOLEAN; RETURN (4 MOD 2); END_FUNCTION;
260
- FUNCTION exponentiation_expression : BOOLEAN; RETURN (4 ** 2); END_FUNCTION;
261
- FUNCTION addition_addition_expression : BOOLEAN; RETURN (4 + 2 + 1); END_FUNCTION;
262
- FUNCTION subtraction_subtraction_expression : BOOLEAN; RETURN (4 - 2 - 1); END_FUNCTION;
263
- FUNCTION addition_subtraction_expression : BOOLEAN; RETURN (4 + 2 - 1); END_FUNCTION;
264
- FUNCTION subtraction_addition_expression : BOOLEAN; RETURN (4 - 2 + 1); END_FUNCTION;
265
- FUNCTION addition_multiplication_expression : BOOLEAN; RETURN (8 + 4 * 2); END_FUNCTION;
266
- FUNCTION multiplication_addition_expression : BOOLEAN; RETURN (8 * 4 + 2); END_FUNCTION;
267
- FUNCTION parenthesis_addition_multiplication_expression : BOOLEAN; RETURN ((8 + 4) * 2); END_FUNCTION;
268
- FUNCTION multiplication_parenthesis_addition_expression : BOOLEAN; RETURN (8 * (4 + 2)); END_FUNCTION;
269
- FUNCTION equal_expression : BOOLEAN; RETURN (4 = 2); END_FUNCTION;
270
- FUNCTION not_equal_expression : BOOLEAN; RETURN (4 <> 2); END_FUNCTION;
271
- FUNCTION instance_equal_expression : BOOLEAN; RETURN (4 :=: 2); END_FUNCTION;
272
- FUNCTION instance_not_equal_expression : BOOLEAN; RETURN (4 :<>: 2); END_FUNCTION;
273
- FUNCTION lt_expression : BOOLEAN; RETURN (4 < 2); END_FUNCTION;
274
- FUNCTION gt_expression : BOOLEAN; RETURN (4 > 2); END_FUNCTION;
275
- FUNCTION lte_expression : BOOLEAN; RETURN (4 <= 2); END_FUNCTION;
276
- FUNCTION gte_expression : BOOLEAN; RETURN (4 >= 2); END_FUNCTION;
277
- FUNCTION not_expression : BOOLEAN; RETURN (NOT TRUE); END_FUNCTION;
278
- FUNCTION not_or_expression : BOOLEAN; RETURN (NOT (TRUE OR FALSE)); END_FUNCTION;
279
- FUNCTION or_expression : BOOLEAN; RETURN (TRUE OR FALSE); END_FUNCTION;
280
- FUNCTION and_expression : BOOLEAN; RETURN (TRUE AND FALSE); END_FUNCTION;
281
- FUNCTION or_or_expression : BOOLEAN; RETURN (TRUE OR FALSE OR TRUE); END_FUNCTION;
282
- FUNCTION and_and_expression : BOOLEAN; RETURN (TRUE AND FALSE AND TRUE); END_FUNCTION;
283
- FUNCTION or_and_expression : BOOLEAN; RETURN (TRUE OR FALSE AND TRUE); END_FUNCTION;
284
- FUNCTION and_or_expression : BOOLEAN; RETURN (TRUE AND FALSE OR TRUE); END_FUNCTION;
285
- FUNCTION parenthesis_or_and_expression : BOOLEAN; RETURN ((TRUE OR FALSE) AND TRUE); END_FUNCTION;
286
- FUNCTION and_parenthesis_or_expression : BOOLEAN; RETURN (TRUE AND (FALSE OR TRUE)); END_FUNCTION;
287
- FUNCTION combine_expression : BOOLEAN; RETURN (test || test); END_FUNCTION;
288
- FUNCTION in_expression : BOOLEAN; RETURN (TRUE IN [TRUE]); END_FUNCTION;
289
- FUNCTION like_expression : BOOLEAN; RETURN ('xxx' LIKE 'xxx'); END_FUNCTION;
255
+ -- operator expressions
256
+ plus_expression : BOOLEAN := +4;
257
+ plus_addition_expression : BOOLEAN := +(4 + 2);
258
+ minus_expression : BOOLEAN := -4;
259
+ minus_addition_expression : BOOLEAN := -(4 + 2);
260
+ addition_expression : BOOLEAN := 4 + 2;
261
+ subtraction_expression : BOOLEAN := 4 - 2;
262
+ multiplication_expression : BOOLEAN := 4 * 2;
263
+ real_division_expression : BOOLEAN := 4 / 2;
264
+ integer_division_expression : BOOLEAN := 4 DIV 2;
265
+ modulo_expression : BOOLEAN := 4 MOD 2;
266
+ exponentiation_expression : BOOLEAN := 4 ** 2;
267
+ addition_addition_expression : BOOLEAN := 4 + 2 + 1;
268
+ subtraction_subtraction_expression : BOOLEAN := 4 - 2 - 1;
269
+ addition_subtraction_expression : BOOLEAN := 4 + 2 - 1;
270
+ subtraction_addition_expression : BOOLEAN := 4 - 2 + 1;
271
+ addition_multiplication_expression : BOOLEAN := 8 + 4 * 2;
272
+ multiplication_addition_expression : BOOLEAN := 8 * 4 + 2;
273
+ parenthesis_addition_multiplication_expression : BOOLEAN := (8 + 4) * 2;
274
+ multiplication_parenthesis_addition_expression : BOOLEAN := 8 * (4 + 2);
275
+ equal_expression : BOOLEAN := 4 = 2;
276
+ not_equal_expression : BOOLEAN := 4 <> 2;
277
+ instance_equal_expression : BOOLEAN := 4 :=: 2;
278
+ instance_not_equal_expression : BOOLEAN := 4 :<>: 2;
279
+ lt_expression : BOOLEAN := 4 < 2;
280
+ gt_expression : BOOLEAN := 4 > 2;
281
+ lte_expression : BOOLEAN := 4 <= 2;
282
+ gte_expression : BOOLEAN := 4 >= 2;
283
+ not_expression : BOOLEAN := NOT TRUE;
284
+ not_or_expression : BOOLEAN := NOT (TRUE OR FALSE);
285
+ or_expression : BOOLEAN := TRUE OR FALSE;
286
+ and_expression : BOOLEAN := TRUE AND FALSE;
287
+ or_or_expression : BOOLEAN := TRUE OR FALSE OR TRUE;
288
+ and_and_expression : BOOLEAN := TRUE AND FALSE AND TRUE;
289
+ or_and_expression : BOOLEAN := TRUE OR FALSE AND TRUE;
290
+ and_or_expression : BOOLEAN := TRUE AND FALSE OR TRUE;
291
+ parenthesis_or_and_expression : BOOLEAN := (TRUE OR FALSE) AND TRUE;
292
+ and_parenthesis_or_expression : BOOLEAN := TRUE AND (FALSE OR TRUE);
293
+ combine_expression : BOOLEAN := test || test;
294
+ in_expression : BOOLEAN := TRUE IN [TRUE];
295
+ like_expression : BOOLEAN := 'xxx' LIKE 'xxx';
290
296
 
291
- -- aggregate initializer expressions
292
- FUNCTION aggregate_initializer_expression : BOOLEAN; RETURN ([4]); END_FUNCTION;
293
- FUNCTION repeated_aggregate_initializer_expression : BOOLEAN; RETURN ([4:2]); END_FUNCTION;
294
- FUNCTION complex_aggregate_initializer_expression : BOOLEAN; RETURN ([4 + 2]); END_FUNCTION;
295
- FUNCTION complex_repeated_aggregate_initializer_expression : BOOLEAN; RETURN ([4 + 2:4 + 2]); END_FUNCTION;
297
+ -- aggregate initializer expressions
298
+ aggregate_initializer_expression : BOOLEAN := [4];
299
+ repeated_aggregate_initializer_expression : BOOLEAN := [4:2];
300
+ complex_aggregate_initializer_expression : BOOLEAN := [4 + 2];
301
+ complex_repeated_aggregate_initializer_expression : BOOLEAN := [4 + 2:4 + 2];
296
302
 
297
- -- function call or entity constructor expressions
298
- FUNCTION call_expression : BOOLEAN; RETURN (parameter_function(TRUE)); END_FUNCTION;
303
+ -- function call or entity constructor expressions
304
+ call_expression : BOOLEAN := parameter_function(TRUE);
299
305
 
300
- -- reference expressions
301
- FUNCTION simple_reference_expression : BOOLEAN; RETURN (simple_string_expression); END_FUNCTION;
302
- FUNCTION attribute_reference_expression : BOOLEAN; RETURN (simple_string_expression.test); END_FUNCTION;
303
- FUNCTION group_reference_expression : BOOLEAN; RETURN (simple_string_expression\test); END_FUNCTION;
304
- FUNCTION index_reference_expression : BOOLEAN; RETURN (simple_string_expression[1]); END_FUNCTION;
305
- FUNCTION index2_reference_expression : BOOLEAN; RETURN (simple_string_expression[1:9]); END_FUNCTION;
306
+ -- reference expressions
307
+ simple_reference_expression : BOOLEAN := simple_string_expression;
308
+ attribute_reference_expression : BOOLEAN := simple_string_expression.test;
309
+ group_reference_expression : BOOLEAN := simple_string_expression\test;
310
+ index_reference_expression : BOOLEAN := simple_string_expression[1];
311
+ index2_reference_expression : BOOLEAN := simple_string_expression[1:9];
306
312
 
307
- -- interval expressions
308
- FUNCTION lt_lt_interval_expression : BOOLEAN; RETURN ({1 < 5 < 9}); END_FUNCTION;
309
- FUNCTION lte_lt_interval_expression : BOOLEAN; RETURN ({1 <= 5 < 9}); END_FUNCTION;
310
- FUNCTION lt_lte_interval_expression : BOOLEAN; RETURN ({1 < 5 <= 9}); END_FUNCTION;
311
- FUNCTION lte_lte_interval_expression : BOOLEAN; RETURN ({1 <= 5 <= 9}); END_FUNCTION;
313
+ -- interval expressions
314
+ lt_lt_interval_expression : BOOLEAN := {1 < 5 < 9};
315
+ lte_lt_interval_expression : BOOLEAN := {1 <= 5 < 9};
316
+ lt_lte_interval_expression : BOOLEAN := {1 < 5 <= 9};
317
+ lte_lte_interval_expression : BOOLEAN := {1 <= 5 <= 9};
312
318
 
313
- -- query expressions
314
- FUNCTION query_expression : BOOLEAN; RETURN (QUERY(test <* test2 | TRUE)); END_FUNCTION;
319
+ -- query expressions
320
+ query_expression : BOOLEAN := QUERY(test <* test2 | TRUE);
321
+ END_LOCAL;
322
+ END_PROCEDURE;
315
323
  END_SCHEMA;
@@ -18,254 +18,198 @@ CONSTANT
18
18
  END_CONSTANT;
19
19
  TYPE empty_type = BOOLEAN;
20
20
  END_TYPE;
21
-
22
21
  TYPE where_type = BOOLEAN;
23
22
  WHERE
24
23
  TRUE;
25
24
  END_TYPE;
26
-
27
25
  TYPE where_label_type = BOOLEAN;
28
26
  WHERE
29
27
  WR1 : TRUE;
30
28
  END_TYPE;
31
-
32
29
  ENTITY empty_entity;
33
30
  END_ENTITY;
34
-
35
31
  ENTITY abstract_entity
36
32
  ABSTRACT SUPERTYPE;
37
33
  END_ENTITY;
38
-
39
34
  ENTITY abstract_supertype_entity
40
35
  ABSTRACT SUPERTYPE;
41
36
  END_ENTITY;
42
-
43
37
  ENTITY abstract_supertype_constraint_entity
44
38
  ABSTRACT SUPERTYPE OF (empty_entity);
45
39
  END_ENTITY;
46
-
47
40
  ENTITY supertype_constraint_entity
48
41
  SUPERTYPE OF (empty_entity);
49
42
  END_ENTITY;
50
-
51
43
  ENTITY subtype_entity
52
44
  SUBTYPE OF (empty_entity);
53
45
  END_ENTITY;
54
-
55
46
  ENTITY supertype_constraint_subtype_entity
56
47
  SUPERTYPE OF (empty_entity)
57
48
  SUBTYPE OF (empty_entity);
58
49
  END_ENTITY;
59
-
60
50
  ENTITY attribute_entity;
61
51
  test : BOOLEAN;
62
52
  END_ENTITY;
63
-
64
53
  ENTITY attribute_optional_entity;
65
54
  test : OPTIONAL BOOLEAN;
66
55
  END_ENTITY;
67
-
68
56
  ENTITY attribute_multiple_entity;
69
57
  test : BOOLEAN;
70
58
  test2 : BOOLEAN;
71
59
  END_ENTITY;
72
-
73
60
  ENTITY attribute_multiple_shorthand_entity;
74
61
  test : BOOLEAN;
75
62
  test2 : BOOLEAN;
76
63
  END_ENTITY;
77
-
78
64
  ENTITY attribute_redeclared_entity;
79
65
  SELF\attribute_entity.test : BOOLEAN;
80
66
  END_ENTITY;
81
-
82
67
  ENTITY attribute_redeclared_renamed_entity;
83
68
  SELF\attribute_entity.test RENAMED test2 : BOOLEAN;
84
69
  END_ENTITY;
85
-
86
70
  ENTITY derived_attribute_entity;
87
71
  DERIVE
88
72
  test : BOOLEAN := TRUE;
89
73
  END_ENTITY;
90
-
91
74
  ENTITY derived_attribute_redeclared_entity;
92
75
  DERIVE
93
76
  SELF\attribute_entity.test : BOOLEAN := TRUE;
94
77
  END_ENTITY;
95
-
96
78
  ENTITY derived_attribute_redeclared_renamed_entity;
97
79
  DERIVE
98
80
  SELF\attribute_entity.test RENAMED test2 : BOOLEAN := TRUE;
99
81
  END_ENTITY;
100
-
101
82
  ENTITY inverse_attribute_entity;
102
83
  INVERSE
103
84
  test : attribute_entity FOR test;
104
85
  END_ENTITY;
105
-
106
86
  ENTITY inverse_attribute_entity_entity;
107
87
  INVERSE
108
88
  test : attribute_entity FOR attribute_entity.test;
109
89
  END_ENTITY;
110
-
111
90
  ENTITY inverse_attribute_set_entity;
112
91
  INVERSE
113
92
  test : SET OF attribute_entity FOR test;
114
93
  END_ENTITY;
115
-
116
94
  ENTITY inverse_attribute_set_bound_entity;
117
95
  INVERSE
118
96
  test : SET [1:9] OF attribute_entity FOR test;
119
97
  END_ENTITY;
120
-
121
98
  ENTITY inverse_attribute_bag_entity;
122
99
  INVERSE
123
100
  test : BAG OF attribute_entity FOR test;
124
101
  END_ENTITY;
125
-
126
102
  ENTITY inverse_attribute_bag_bound_entity;
127
103
  INVERSE
128
104
  test : BAG [1:9] OF attribute_entity FOR test;
129
105
  END_ENTITY;
130
-
131
106
  ENTITY inverse_attribute_redeclared_entity;
132
107
  INVERSE
133
108
  SELF\attribute_entity.test : attribute_entity FOR test;
134
109
  END_ENTITY;
135
-
136
110
  ENTITY inverse_attribute_redeclared_renamed_entity;
137
111
  INVERSE
138
112
  SELF\attribute_entity.test RENAMED test2 : attribute_entity FOR test;
139
113
  END_ENTITY;
140
-
141
114
  ENTITY unique_entity;
142
115
  test : BOOLEAN;
143
116
  UNIQUE
144
117
  test;
145
118
  END_ENTITY;
146
-
147
119
  ENTITY unique_label_entity;
148
120
  test : BOOLEAN;
149
121
  UNIQUE
150
122
  UR1 : test;
151
123
  END_ENTITY;
152
-
153
124
  ENTITY unique_qualified_entity;
154
125
  UNIQUE
155
126
  SELF\attribute_entity.test;
156
127
  END_ENTITY;
157
-
158
128
  ENTITY unique_label_qualified_entity;
159
129
  UNIQUE
160
130
  UR1 : SELF\attribute_entity.test;
161
131
  END_ENTITY;
162
-
163
132
  ENTITY where_entity;
164
133
  WHERE
165
134
  TRUE;
166
135
  END_ENTITY;
167
-
168
136
  ENTITY where_label_entity;
169
137
  WHERE
170
138
  WR1 : TRUE;
171
139
  END_ENTITY;
172
-
173
140
  SUBTYPE_CONSTRAINT empty_subtype_constraint FOR empty_entity;
174
141
  END_SUBTYPE_CONSTRAINT;
175
-
176
142
  SUBTYPE_CONSTRAINT abstract_supertype_subtype_constraint FOR empty_entity;
177
143
  ABSTRACT SUPERTYPE;
178
144
  END_SUBTYPE_CONSTRAINT;
179
-
180
145
  SUBTYPE_CONSTRAINT total_over_subtype_constraint FOR empty_entity;
181
146
  TOTAL_OVER(a);
182
147
  END_SUBTYPE_CONSTRAINT;
183
-
184
148
  SUBTYPE_CONSTRAINT supertype_expression_subtype_constraint FOR empty_entity;
185
149
  a;
186
150
  END_SUBTYPE_CONSTRAINT;
187
-
188
151
  SUBTYPE_CONSTRAINT supertype_expression_andor_subtype_constraint FOR empty_entity;
189
152
  a ANDOR b;
190
153
  END_SUBTYPE_CONSTRAINT;
191
-
192
154
  SUBTYPE_CONSTRAINT supertype_expression_and_subtype_constraint FOR empty_entity;
193
155
  a AND b;
194
156
  END_SUBTYPE_CONSTRAINT;
195
-
196
157
  SUBTYPE_CONSTRAINT supertype_expression_andor_and_subtype_constraint FOR empty_entity;
197
158
  a ANDOR b AND c;
198
159
  END_SUBTYPE_CONSTRAINT;
199
-
200
160
  SUBTYPE_CONSTRAINT supertype_expression_and_andor_subtype_constraint FOR empty_entity;
201
161
  a AND b ANDOR c;
202
162
  END_SUBTYPE_CONSTRAINT;
203
-
204
163
  SUBTYPE_CONSTRAINT supertype_expression_parenthesis_andor_and_subtype_constraint FOR empty_entity;
205
164
  (a ANDOR b) AND c;
206
165
  END_SUBTYPE_CONSTRAINT;
207
-
208
166
  SUBTYPE_CONSTRAINT supertype_expression_and_parenthesis_andor_subtype_constraint FOR empty_entity;
209
167
  a AND (b ANDOR c);
210
168
  END_SUBTYPE_CONSTRAINT;
211
-
212
169
  SUBTYPE_CONSTRAINT supertype_expression_oneof_subtype_constraint FOR empty_entity;
213
170
  ONEOF(a, b);
214
171
  END_SUBTYPE_CONSTRAINT;
215
-
216
172
  SUBTYPE_CONSTRAINT supertype_expression_and_oneof_subtype_constraint FOR empty_entity;
217
173
  a AND ONEOF(b, c);
218
174
  END_SUBTYPE_CONSTRAINT;
219
-
220
175
  SUBTYPE_CONSTRAINT supertype_expression_andor_oneof_subtype_constraint FOR empty_entity;
221
176
  a ANDOR ONEOF(b, c);
222
177
  END_SUBTYPE_CONSTRAINT;
223
-
224
178
  SUBTYPE_CONSTRAINT supertype_expression_oneof_and_subtype_constraint FOR empty_entity;
225
179
  ONEOF(a, b) AND c;
226
180
  END_SUBTYPE_CONSTRAINT;
227
-
228
181
  SUBTYPE_CONSTRAINT supertype_expression_oneof_andor_subtype_constraint FOR empty_entity;
229
182
  ONEOF(a, b) ANDOR c;
230
183
  END_SUBTYPE_CONSTRAINT;
231
-
232
184
  SUBTYPE_CONSTRAINT supertype_expression_oneof_and_oneof_subtype_constraint FOR empty_entity;
233
185
  ONEOF(a, b) AND ONEOF(c, d);
234
186
  END_SUBTYPE_CONSTRAINT;
235
-
236
187
  SUBTYPE_CONSTRAINT supertype_expression_oneof_andor_oneof_subtype_constraint FOR empty_entity;
237
188
  ONEOF(a, b) ANDOR ONEOF(c, d);
238
189
  END_SUBTYPE_CONSTRAINT;
239
-
240
190
  FUNCTION empty_function : BOOLEAN;
241
191
  ;
242
192
  END_FUNCTION;
243
-
244
193
  FUNCTION parameter_function(test : BOOLEAN) : BOOLEAN;
245
194
  ;
246
195
  END_FUNCTION;
247
-
248
196
  FUNCTION multiple_parameter_function(test : BOOLEAN; test2 : BOOLEAN) : BOOLEAN;
249
197
  ;
250
198
  END_FUNCTION;
251
-
252
199
  FUNCTION multiple_shorthand_parameter_function(test : BOOLEAN; test2 : BOOLEAN) : BOOLEAN;
253
200
  ;
254
201
  END_FUNCTION;
255
-
256
202
  FUNCTION type_function : BOOLEAN;
257
203
  TYPE test = BOOLEAN;
258
204
  END_TYPE;
259
205
  ;
260
206
  END_FUNCTION;
261
-
262
207
  FUNCTION constant_function : BOOLEAN;
263
208
  CONSTANT
264
209
  test : BOOLEAN := TRUE;
265
210
  END_CONSTANT;
266
211
  ;
267
212
  END_FUNCTION;
268
-
269
213
  FUNCTION multiple_constant_function : BOOLEAN;
270
214
  CONSTANT
271
215
  test : BOOLEAN := TRUE;
@@ -273,14 +217,12 @@ FUNCTION multiple_constant_function : BOOLEAN;
273
217
  END_CONSTANT;
274
218
  ;
275
219
  END_FUNCTION;
276
-
277
220
  FUNCTION variable_function : BOOLEAN;
278
221
  LOCAL
279
222
  test : BOOLEAN;
280
223
  END_LOCAL;
281
224
  ;
282
225
  END_FUNCTION;
283
-
284
226
  FUNCTION multiple_variable_function : BOOLEAN;
285
227
  LOCAL
286
228
  test : BOOLEAN;
@@ -288,7 +230,6 @@ FUNCTION multiple_variable_function : BOOLEAN;
288
230
  END_LOCAL;
289
231
  ;
290
232
  END_FUNCTION;
291
-
292
233
  FUNCTION multiple_shorthand_variable_function : BOOLEAN;
293
234
  LOCAL
294
235
  test : BOOLEAN;
@@ -296,14 +237,12 @@ FUNCTION multiple_shorthand_variable_function : BOOLEAN;
296
237
  END_LOCAL;
297
238
  ;
298
239
  END_FUNCTION;
299
-
300
240
  FUNCTION variable_expression_function : BOOLEAN;
301
241
  LOCAL
302
242
  test : BOOLEAN := TRUE;
303
243
  END_LOCAL;
304
244
  ;
305
245
  END_FUNCTION;
306
-
307
246
  FUNCTION multiple_variable_expression_function : BOOLEAN;
308
247
  LOCAL
309
248
  test : BOOLEAN := TRUE;
@@ -311,7 +250,6 @@ FUNCTION multiple_variable_expression_function : BOOLEAN;
311
250
  END_LOCAL;
312
251
  ;
313
252
  END_FUNCTION;
314
-
315
253
  FUNCTION multiple_shorthand_variable_expression_function : BOOLEAN;
316
254
  LOCAL
317
255
  test : BOOLEAN := TRUE;
@@ -319,105 +257,430 @@ FUNCTION multiple_shorthand_variable_expression_function : BOOLEAN;
319
257
  END_LOCAL;
320
258
  ;
321
259
  END_FUNCTION;
322
-
323
260
  PROCEDURE empty_procedure;
324
261
  END_PROCEDURE;
325
-
326
262
  PROCEDURE parameter_procedure(test : BOOLEAN);
327
263
  END_PROCEDURE;
328
-
329
264
  PROCEDURE multiple_parameter_procedure(test : BOOLEAN; test2 : BOOLEAN);
330
265
  END_PROCEDURE;
331
-
332
266
  PROCEDURE multiple_shorthand_parameter_procedure(test : BOOLEAN; test2 : BOOLEAN);
333
267
  END_PROCEDURE;
334
-
335
268
  PROCEDURE variable_parameter_procedure(VAR test : BOOLEAN);
336
269
  END_PROCEDURE;
337
-
338
270
  PROCEDURE multiple_variable_parameter_procedure(VAR test : BOOLEAN; test2 : BOOLEAN);
339
271
  END_PROCEDURE;
340
-
341
272
  PROCEDURE multiple_variable_parameter2_procedure(test : BOOLEAN; VAR test2 : BOOLEAN);
342
273
  END_PROCEDURE;
343
-
344
274
  PROCEDURE multiple_shorthand_variable_parameter_procedure(VAR test : BOOLEAN; VAR test2 : BOOLEAN);
345
275
  END_PROCEDURE;
346
-
347
276
  PROCEDURE type_procedure;
348
277
  TYPE test = BOOLEAN;
349
278
  END_TYPE;
350
279
  END_PROCEDURE;
351
-
352
280
  PROCEDURE constant_procedure;
353
281
  CONSTANT
354
282
  test : BOOLEAN := TRUE;
355
283
  END_CONSTANT;
356
284
  END_PROCEDURE;
357
-
358
285
  PROCEDURE multiple_constant_procedure;
359
286
  CONSTANT
360
287
  test : BOOLEAN := TRUE;
361
288
  test2 : BOOLEAN := TRUE;
362
289
  END_CONSTANT;
363
290
  END_PROCEDURE;
364
-
365
291
  PROCEDURE variable_procedure;
366
292
  LOCAL
367
293
  test : BOOLEAN;
368
294
  END_LOCAL;
369
295
  END_PROCEDURE;
370
-
371
296
  PROCEDURE multiple_variable_procedure;
372
297
  LOCAL
373
298
  test : BOOLEAN;
374
299
  test2 : BOOLEAN;
375
300
  END_LOCAL;
376
301
  END_PROCEDURE;
377
-
378
302
  PROCEDURE multiple_shorthand_variable_procedure;
379
303
  LOCAL
380
304
  test : BOOLEAN;
381
305
  test2 : BOOLEAN;
382
306
  END_LOCAL;
383
307
  END_PROCEDURE;
384
-
385
308
  PROCEDURE variable_expression_procedure;
386
309
  LOCAL
387
310
  test : BOOLEAN := TRUE;
388
311
  END_LOCAL;
389
312
  END_PROCEDURE;
390
-
391
313
  PROCEDURE multiple_variable_expression_procedure;
392
314
  LOCAL
393
315
  test : BOOLEAN := TRUE;
394
316
  test2 : BOOLEAN := TRUE;
395
317
  END_LOCAL;
396
318
  END_PROCEDURE;
397
-
398
319
  PROCEDURE multiple_shorthand_variable_expression_procedure;
399
320
  LOCAL
400
321
  test : BOOLEAN := TRUE;
401
322
  test2 : BOOLEAN := TRUE;
402
323
  END_LOCAL;
403
324
  END_PROCEDURE;
404
-
405
325
  PROCEDURE statement_procedure;
406
326
  ;
407
327
  END_PROCEDURE;
408
-
328
+ PROCEDURE statements;
329
+ PROCEDURE alias_simple_reference_statement;
330
+ ALIAS test FOR test;
331
+ ;
332
+ END_ALIAS;
333
+ END_PROCEDURE;
334
+ PROCEDURE alias_attribute_reference_statement;
335
+ ALIAS test FOR test.test;
336
+ ;
337
+ END_ALIAS;
338
+ END_PROCEDURE;
339
+ PROCEDURE alias_group_reference_statement;
340
+ ALIAS test FOR test\test;
341
+ ;
342
+ END_ALIAS;
343
+ END_PROCEDURE;
344
+ PROCEDURE alias_index_reference_statement;
345
+ ALIAS test FOR test[1];
346
+ ;
347
+ END_ALIAS;
348
+ END_PROCEDURE;
349
+ PROCEDURE alias_index2_reference_statement;
350
+ ALIAS test FOR test[1:9];
351
+ ;
352
+ END_ALIAS;
353
+ END_PROCEDURE;
354
+ PROCEDURE assignment_simple_reference_statement;
355
+ test := TRUE;
356
+ END_PROCEDURE;
357
+ PROCEDURE assignment_attribute_reference_statement;
358
+ test.test := TRUE;
359
+ END_PROCEDURE;
360
+ PROCEDURE assignment_group_reference_statement;
361
+ test\test := TRUE;
362
+ END_PROCEDURE;
363
+ PROCEDURE assignment_index_reference_statement;
364
+ test[1] := TRUE;
365
+ END_PROCEDURE;
366
+ PROCEDURE assignment_index2_reference_statement;
367
+ test[1:9] := TRUE;
368
+ END_PROCEDURE;
369
+ PROCEDURE case_statement;
370
+ CASE test OF
371
+ TRUE :
372
+ ;
373
+ END_CASE;
374
+ END_PROCEDURE;
375
+ PROCEDURE case_multiple_statement;
376
+ CASE test OF
377
+ TRUE :
378
+ ;
379
+ TRUE :
380
+ ;
381
+ END_CASE;
382
+ END_PROCEDURE;
383
+ PROCEDURE case_multiple_shorthand_statement;
384
+ CASE test OF
385
+ TRUE, TRUE :
386
+ ;
387
+ END_CASE;
388
+ END_PROCEDURE;
389
+ PROCEDURE case_otherwise_statement;
390
+ CASE test OF
391
+ TRUE :
392
+ ;
393
+ OTHERWISE :
394
+ ;
395
+ END_CASE;
396
+ END_PROCEDURE;
397
+ PROCEDURE compound_statement;
398
+ BEGIN
399
+ ;
400
+ END;
401
+ END_PROCEDURE;
402
+ PROCEDURE escape_statement;
403
+ ESCAPE;
404
+ END_PROCEDURE;
405
+ PROCEDURE if_statement;
406
+ IF TRUE THEN
407
+ ;
408
+ END_IF;
409
+ END_PROCEDURE;
410
+ PROCEDURE if2_statement;
411
+ IF TRUE THEN
412
+ ;
413
+ ;
414
+ END_IF;
415
+ END_PROCEDURE;
416
+ PROCEDURE if_else_statement;
417
+ IF TRUE THEN
418
+ ;
419
+ ELSE
420
+ ;
421
+ END_IF;
422
+ END_PROCEDURE;
423
+ PROCEDURE if2_else_statement;
424
+ IF TRUE THEN
425
+ ;
426
+ ;
427
+ ELSE
428
+ ;
429
+ END_IF;
430
+ END_PROCEDURE;
431
+ PROCEDURE if_else2_statement;
432
+ IF TRUE THEN
433
+ ;
434
+ ELSE
435
+ ;
436
+ ;
437
+ END_IF;
438
+ END_PROCEDURE;
439
+ PROCEDURE if2_else2_statement;
440
+ IF TRUE THEN
441
+ ;
442
+ ;
443
+ ELSE
444
+ ;
445
+ ;
446
+ END_IF;
447
+ END_PROCEDURE;
448
+ PROCEDURE null_statement;
449
+ ;
450
+ END_PROCEDURE;
451
+ PROCEDURE call_statement;
452
+ empty_procedure;
453
+ END_PROCEDURE;
454
+ PROCEDURE call_parameter_statement;
455
+ empty_procedure(TRUE);
456
+ END_PROCEDURE;
457
+ PROCEDURE call_parameter2_statement;
458
+ empty_procedure(TRUE, TRUE);
459
+ END_PROCEDURE;
460
+ PROCEDURE call_insert_statement;
461
+ INSERT(TRUE);
462
+ END_PROCEDURE;
463
+ PROCEDURE call_remove_statement;
464
+ REMOVE(TRUE);
465
+ END_PROCEDURE;
466
+ PROCEDURE repeat_statement;
467
+ REPEAT;
468
+ ;
469
+ END_REPEAT;
470
+ END_PROCEDURE;
471
+ PROCEDURE repeat_variable_statement;
472
+ REPEAT test := 1 TO 9;
473
+ ;
474
+ END_REPEAT;
475
+ END_PROCEDURE;
476
+ PROCEDURE repeat_variable_increment_statement;
477
+ REPEAT test := 1 TO 9 BY 2;
478
+ ;
479
+ END_REPEAT;
480
+ END_PROCEDURE;
481
+ PROCEDURE repeat_while_statement;
482
+ REPEAT WHILE TRUE;
483
+ ;
484
+ END_REPEAT;
485
+ END_PROCEDURE;
486
+ PROCEDURE repeat_until_statement;
487
+ REPEAT UNTIL TRUE;
488
+ ;
489
+ END_REPEAT;
490
+ END_PROCEDURE;
491
+ PROCEDURE return_statement;
492
+ RETURN;
493
+ END_PROCEDURE;
494
+ PROCEDURE return_expression_statement;
495
+ RETURN (TRUE);
496
+ END_PROCEDURE;
497
+ PROCEDURE skip_statement;
498
+ SKIP;
499
+ END_PROCEDURE;
500
+ END_PROCEDURE;
501
+ PROCEDURE types;
502
+ TYPE binary_type = BINARY;
503
+ END_TYPE;
504
+ TYPE binary_width_type = BINARY (3);
505
+ END_TYPE;
506
+ TYPE binary_width_fixed_type = BINARY (3) FIXED;
507
+ END_TYPE;
508
+ TYPE boolean_type = BOOLEAN;
509
+ END_TYPE;
510
+ TYPE integer_type = INTEGER;
511
+ END_TYPE;
512
+ TYPE logical_type = LOGICAL;
513
+ END_TYPE;
514
+ TYPE number_type = NUMBER;
515
+ END_TYPE;
516
+ TYPE real_type = REAL;
517
+ END_TYPE;
518
+ TYPE real_precision_type = REAL (3);
519
+ END_TYPE;
520
+ TYPE string_type = STRING;
521
+ END_TYPE;
522
+ TYPE string_width_type = STRING (3);
523
+ END_TYPE;
524
+ TYPE string_width_fixed_type = STRING (3) FIXED;
525
+ END_TYPE;
526
+ TYPE array_type = ARRAY [1:9] OF STRING;
527
+ END_TYPE;
528
+ TYPE array_optional_type = ARRAY [1:9] OF OPTIONAL STRING;
529
+ END_TYPE;
530
+ TYPE array_unique_type = ARRAY [1:9] OF UNIQUE STRING;
531
+ END_TYPE;
532
+ TYPE array_optional_unique_type = ARRAY [1:9] OF OPTIONAL UNIQUE STRING;
533
+ END_TYPE;
534
+ TYPE bag_type = BAG OF STRING;
535
+ END_TYPE;
536
+ TYPE bag_bound_type = BAG [1:9] OF STRING;
537
+ END_TYPE;
538
+ TYPE list_type = LIST OF STRING;
539
+ END_TYPE;
540
+ TYPE list_bound_type = LIST [1:9] OF STRING;
541
+ END_TYPE;
542
+ TYPE list_unique_type = LIST OF UNIQUE STRING;
543
+ END_TYPE;
544
+ TYPE list_bound_unique_type = LIST [1:9] OF UNIQUE STRING;
545
+ END_TYPE;
546
+ TYPE set_type = SET OF STRING;
547
+ END_TYPE;
548
+ TYPE set_bound_type = SET [1:9] OF STRING;
549
+ END_TYPE;
550
+ TYPE select_type = SELECT;
551
+ END_TYPE;
552
+ TYPE select_extensible_type = EXTENSIBLE SELECT;
553
+ END_TYPE;
554
+ TYPE select_extensible_generic_entity_type = EXTENSIBLE GENERIC_ENTITY SELECT;
555
+ END_TYPE;
556
+ TYPE select_list_type = SELECT (empty_type);
557
+ END_TYPE;
558
+ TYPE select_extension_type_ref_type = SELECT BASED_ON select_type;
559
+ END_TYPE;
560
+ TYPE select_extension_type_ref_list_type = SELECT BASED_ON select_type WITH (empty_type);
561
+ END_TYPE;
562
+ TYPE enumeration_type = ENUMERATION;
563
+ END_TYPE;
564
+ TYPE enumeration_extensible_type = EXTENSIBLE ENUMERATION;
565
+ END_TYPE;
566
+ TYPE enumeration_list_type = ENUMERATION OF (test);
567
+ END_TYPE;
568
+ TYPE enumeration_extension_type_ref_type = ENUMERATION BASED_ON enumeration_type;
569
+ END_TYPE;
570
+ TYPE enumeration_extension_type_ref_list_type = ENUMERATION BASED_ON enumeration_type WITH (test);
571
+ END_TYPE;
572
+ END_PROCEDURE;
573
+ PROCEDURE expressions;
574
+ LOCAL
575
+ binary_expression : BOOLEAN := %011110000111100001111000;
576
+ integer_expression : BOOLEAN := 999;
577
+ true_logical_expression : BOOLEAN := TRUE;
578
+ false_logical_expression : BOOLEAN := FALSE;
579
+ unknown_logical_expression : BOOLEAN := UNKNOWN;
580
+ real_expression : BOOLEAN := 999.999;
581
+ simple_string_expression : BOOLEAN := 'xxx';
582
+ utf8_simple_string_expression : BOOLEAN := 'UTF8 test: Příliš žluťoučký kůň úpěl ďábelské ódy.';
583
+ encoded_string_expression : BOOLEAN := "000000780000007800000078";
584
+ const_e_expression : BOOLEAN := CONST_E;
585
+ indeterminate_expression : BOOLEAN := ?;
586
+ pi_expression : BOOLEAN := PI;
587
+ self_expression : BOOLEAN := SELF;
588
+ abs_expression : BOOLEAN := ABS(TRUE);
589
+ acos_expression : BOOLEAN := ACOS(TRUE);
590
+ asin_expression : BOOLEAN := ASIN(TRUE);
591
+ atan_expression : BOOLEAN := ATAN(TRUE);
592
+ blength_expression : BOOLEAN := BLENGTH(TRUE);
593
+ cos_expression : BOOLEAN := COS(TRUE);
594
+ exists_expression : BOOLEAN := EXISTS(TRUE);
595
+ exp_expression : BOOLEAN := EXP(TRUE);
596
+ format_expression : BOOLEAN := FORMAT(TRUE);
597
+ hibound_expression : BOOLEAN := HIBOUND(TRUE);
598
+ hiindex_expression : BOOLEAN := HIINDEX(TRUE);
599
+ length_expression : BOOLEAN := LENGTH(TRUE);
600
+ lobound_expression : BOOLEAN := LOBOUND(TRUE);
601
+ loindex_expression : BOOLEAN := LOINDEX(TRUE);
602
+ log_expression : BOOLEAN := LOG(TRUE);
603
+ log2_expression : BOOLEAN := LOG2(TRUE);
604
+ log10_expression : BOOLEAN := LOG10(TRUE);
605
+ nvl_expression : BOOLEAN := NVL(TRUE);
606
+ odd_expression : BOOLEAN := ODD(TRUE);
607
+ rolesof_expression : BOOLEAN := ROLESOF(TRUE);
608
+ sin_expression : BOOLEAN := SIN(TRUE);
609
+ sizeof_expression : BOOLEAN := SIZEOF(TRUE);
610
+ sqrt_expression : BOOLEAN := SQRT(TRUE);
611
+ tan_expression : BOOLEAN := TAN(TRUE);
612
+ typeof_expression : BOOLEAN := TYPEOF(TRUE);
613
+ usedin_expression : BOOLEAN := USEDIN(TRUE);
614
+ value_expression : BOOLEAN := VALUE(TRUE);
615
+ value_in_expression : BOOLEAN := VALUE_IN(TRUE);
616
+ value_unique_expression : BOOLEAN := VALUE_UNIQUE(TRUE);
617
+ plus_expression : BOOLEAN := +4;
618
+ plus_addition_expression : BOOLEAN := +(4 + 2);
619
+ minus_expression : BOOLEAN := -4;
620
+ minus_addition_expression : BOOLEAN := -(4 + 2);
621
+ addition_expression : BOOLEAN := 4 + 2;
622
+ subtraction_expression : BOOLEAN := 4 - 2;
623
+ multiplication_expression : BOOLEAN := 4 * 2;
624
+ real_division_expression : BOOLEAN := 4 / 2;
625
+ integer_division_expression : BOOLEAN := 4 DIV 2;
626
+ modulo_expression : BOOLEAN := 4 MOD 2;
627
+ exponentiation_expression : BOOLEAN := 4 ** 2;
628
+ addition_addition_expression : BOOLEAN := 4 + 2 + 1;
629
+ subtraction_subtraction_expression : BOOLEAN := 4 - 2 - 1;
630
+ addition_subtraction_expression : BOOLEAN := 4 + 2 - 1;
631
+ subtraction_addition_expression : BOOLEAN := 4 - 2 + 1;
632
+ addition_multiplication_expression : BOOLEAN := 8 + 4 * 2;
633
+ multiplication_addition_expression : BOOLEAN := 8 * 4 + 2;
634
+ parenthesis_addition_multiplication_expression : BOOLEAN := (8 + 4) * 2;
635
+ multiplication_parenthesis_addition_expression : BOOLEAN := 8 * (4 + 2);
636
+ equal_expression : BOOLEAN := 4 = 2;
637
+ not_equal_expression : BOOLEAN := 4 <> 2;
638
+ instance_equal_expression : BOOLEAN := 4 :=: 2;
639
+ instance_not_equal_expression : BOOLEAN := 4 :<>: 2;
640
+ lt_expression : BOOLEAN := 4 < 2;
641
+ gt_expression : BOOLEAN := 4 > 2;
642
+ lte_expression : BOOLEAN := 4 <= 2;
643
+ gte_expression : BOOLEAN := 4 >= 2;
644
+ not_expression : BOOLEAN := NOT TRUE;
645
+ not_or_expression : BOOLEAN := NOT (TRUE OR FALSE);
646
+ or_expression : BOOLEAN := TRUE OR FALSE;
647
+ and_expression : BOOLEAN := TRUE AND FALSE;
648
+ or_or_expression : BOOLEAN := TRUE OR FALSE OR TRUE;
649
+ and_and_expression : BOOLEAN := TRUE AND FALSE AND TRUE;
650
+ or_and_expression : BOOLEAN := TRUE OR FALSE AND TRUE;
651
+ and_or_expression : BOOLEAN := TRUE AND FALSE OR TRUE;
652
+ parenthesis_or_and_expression : BOOLEAN := (TRUE OR FALSE) AND TRUE;
653
+ and_parenthesis_or_expression : BOOLEAN := TRUE AND (FALSE OR TRUE);
654
+ combine_expression : BOOLEAN := test || test;
655
+ in_expression : BOOLEAN := TRUE IN [TRUE];
656
+ like_expression : BOOLEAN := 'xxx' LIKE 'xxx';
657
+ aggregate_initializer_expression : BOOLEAN := [4];
658
+ repeated_aggregate_initializer_expression : BOOLEAN := [4:2];
659
+ complex_aggregate_initializer_expression : BOOLEAN := [4 + 2];
660
+ complex_repeated_aggregate_initializer_expression : BOOLEAN := [4 + 2:4 + 2];
661
+ call_expression : BOOLEAN := parameter_function(TRUE);
662
+ simple_reference_expression : BOOLEAN := simple_string_expression;
663
+ attribute_reference_expression : BOOLEAN := simple_string_expression.test;
664
+ group_reference_expression : BOOLEAN := simple_string_expression\test;
665
+ index_reference_expression : BOOLEAN := simple_string_expression[1];
666
+ index2_reference_expression : BOOLEAN := simple_string_expression[1:9];
667
+ lt_lt_interval_expression : BOOLEAN := {1 < 5 < 9};
668
+ lte_lt_interval_expression : BOOLEAN := {1 <= 5 < 9};
669
+ lt_lte_interval_expression : BOOLEAN := {1 < 5 <= 9};
670
+ lte_lte_interval_expression : BOOLEAN := {1 <= 5 <= 9};
671
+ query_expression : BOOLEAN := QUERY(test <* test2 | TRUE);
672
+ END_LOCAL;
673
+ END_PROCEDURE;
409
674
  RULE empty_rule FOR (empty_entity);
410
675
  WHERE
411
676
  TRUE;
412
677
  END_RULE;
413
-
414
678
  RULE type_rule FOR (empty_entity);
415
679
  TYPE test = BOOLEAN;
416
680
  END_TYPE;
417
681
  WHERE
418
682
  TRUE;
419
683
  END_RULE;
420
-
421
684
  RULE constant_rule FOR (empty_entity);
422
685
  CONSTANT
423
686
  test : BOOLEAN := TRUE;
@@ -425,7 +688,6 @@ RULE constant_rule FOR (empty_entity);
425
688
  WHERE
426
689
  TRUE;
427
690
  END_RULE;
428
-
429
691
  RULE multiple_constant_rule FOR (empty_entity);
430
692
  CONSTANT
431
693
  test : BOOLEAN := TRUE;
@@ -434,7 +696,6 @@ RULE multiple_constant_rule FOR (empty_entity);
434
696
  WHERE
435
697
  TRUE;
436
698
  END_RULE;
437
-
438
699
  RULE variable_rule FOR (empty_entity);
439
700
  LOCAL
440
701
  test : BOOLEAN;
@@ -442,7 +703,6 @@ RULE variable_rule FOR (empty_entity);
442
703
  WHERE
443
704
  TRUE;
444
705
  END_RULE;
445
-
446
706
  RULE multiple_variable_rule FOR (empty_entity);
447
707
  LOCAL
448
708
  test : BOOLEAN;
@@ -451,7 +711,6 @@ RULE multiple_variable_rule FOR (empty_entity);
451
711
  WHERE
452
712
  TRUE;
453
713
  END_RULE;
454
-
455
714
  RULE multiple_shorthand_variable_rule FOR (empty_entity);
456
715
  LOCAL
457
716
  test : BOOLEAN;
@@ -460,7 +719,6 @@ RULE multiple_shorthand_variable_rule FOR (empty_entity);
460
719
  WHERE
461
720
  TRUE;
462
721
  END_RULE;
463
-
464
722
  RULE variable_expression_rule FOR (empty_entity);
465
723
  LOCAL
466
724
  test : BOOLEAN := TRUE;
@@ -468,7 +726,6 @@ RULE variable_expression_rule FOR (empty_entity);
468
726
  WHERE
469
727
  TRUE;
470
728
  END_RULE;
471
-
472
729
  RULE multiple_variable_expression_rule FOR (empty_entity);
473
730
  LOCAL
474
731
  test : BOOLEAN := TRUE;
@@ -477,7 +734,6 @@ RULE multiple_variable_expression_rule FOR (empty_entity);
477
734
  WHERE
478
735
  TRUE;
479
736
  END_RULE;
480
-
481
737
  RULE multiple_shorthand_variable_expression_rule FOR (empty_entity);
482
738
  LOCAL
483
739
  test : BOOLEAN := TRUE;
@@ -486,715 +742,13 @@ RULE multiple_shorthand_variable_expression_rule FOR (empty_entity);
486
742
  WHERE
487
743
  TRUE;
488
744
  END_RULE;
489
-
490
745
  RULE statement_rule FOR (empty_entity);
491
746
  ;
492
747
  WHERE
493
748
  TRUE;
494
749
  END_RULE;
495
-
496
750
  RULE where_label_rule FOR (empty_entity);
497
751
  WHERE
498
752
  WR1 : TRUE;
499
753
  END_RULE;
500
-
501
- TYPE binary_type = BINARY;
502
- END_TYPE;
503
-
504
- TYPE binary_width_type = BINARY (3);
505
- END_TYPE;
506
-
507
- TYPE binary_width_fixed_type = BINARY (3) FIXED;
508
- END_TYPE;
509
-
510
- TYPE boolean_type = BOOLEAN;
511
- END_TYPE;
512
-
513
- TYPE integer_type = INTEGER;
514
- END_TYPE;
515
-
516
- TYPE logical_type = LOGICAL;
517
- END_TYPE;
518
-
519
- TYPE number_type = NUMBER;
520
- END_TYPE;
521
-
522
- TYPE real_type = REAL;
523
- END_TYPE;
524
-
525
- TYPE real_precision_type = REAL (3);
526
- END_TYPE;
527
-
528
- TYPE string_type = STRING;
529
- END_TYPE;
530
-
531
- TYPE string_width_type = STRING (3);
532
- END_TYPE;
533
-
534
- TYPE string_width_fixed_type = STRING (3) FIXED;
535
- END_TYPE;
536
-
537
- TYPE array_type = ARRAY [1:9] OF STRING;
538
- END_TYPE;
539
-
540
- TYPE array_optional_type = ARRAY [1:9] OF OPTIONAL STRING;
541
- END_TYPE;
542
-
543
- TYPE array_unique_type = ARRAY [1:9] OF UNIQUE STRING;
544
- END_TYPE;
545
-
546
- TYPE array_optional_unique_type = ARRAY [1:9] OF OPTIONAL UNIQUE STRING;
547
- END_TYPE;
548
-
549
- TYPE bag_type = BAG OF STRING;
550
- END_TYPE;
551
-
552
- TYPE bag_bound_type = BAG [1:9] OF STRING;
553
- END_TYPE;
554
-
555
- TYPE list_type = LIST OF STRING;
556
- END_TYPE;
557
-
558
- TYPE list_bound_type = LIST [1:9] OF STRING;
559
- END_TYPE;
560
-
561
- TYPE list_unique_type = LIST OF UNIQUE STRING;
562
- END_TYPE;
563
-
564
- TYPE list_bound_unique_type = LIST [1:9] OF UNIQUE STRING;
565
- END_TYPE;
566
-
567
- TYPE set_type = SET OF STRING;
568
- END_TYPE;
569
-
570
- TYPE set_bound_type = SET [1:9] OF STRING;
571
- END_TYPE;
572
-
573
- TYPE select_type = SELECT;
574
- END_TYPE;
575
-
576
- TYPE select_extensible_type = EXTENSIBLE SELECT;
577
- END_TYPE;
578
-
579
- TYPE select_extensible_generic_entity_type = EXTENSIBLE GENERIC_ENTITY SELECT;
580
- END_TYPE;
581
-
582
- TYPE select_list_type = SELECT (empty_type);
583
- END_TYPE;
584
-
585
- TYPE select_extension_type_ref_type = SELECT BASED_ON select_type;
586
- END_TYPE;
587
-
588
- TYPE select_extension_type_ref_list_type = SELECT BASED_ON select_type WITH (empty_type);
589
- END_TYPE;
590
-
591
- TYPE enumeration_type = ENUMERATION;
592
- END_TYPE;
593
-
594
- TYPE enumeration_extensible_type = EXTENSIBLE ENUMERATION;
595
- END_TYPE;
596
-
597
- TYPE enumeration_list_type = ENUMERATION OF (test);
598
- END_TYPE;
599
-
600
- TYPE enumeration_extension_type_ref_type = ENUMERATION BASED_ON enumeration_type;
601
- END_TYPE;
602
-
603
- TYPE enumeration_extension_type_ref_list_type = ENUMERATION BASED_ON enumeration_type WITH (test);
604
- END_TYPE;
605
-
606
- FUNCTION alias_simple_reference_statement : BOOLEAN;
607
- ALIAS test FOR test;
608
- ;
609
- END_ALIAS;
610
- END_FUNCTION;
611
-
612
- FUNCTION alias_attribute_reference_statement : BOOLEAN;
613
- ALIAS test FOR test.test;
614
- ;
615
- END_ALIAS;
616
- END_FUNCTION;
617
-
618
- FUNCTION alias_group_reference_statement : BOOLEAN;
619
- ALIAS test FOR test\test;
620
- ;
621
- END_ALIAS;
622
- END_FUNCTION;
623
-
624
- FUNCTION alias_index_reference_statement : BOOLEAN;
625
- ALIAS test FOR test[1];
626
- ;
627
- END_ALIAS;
628
- END_FUNCTION;
629
-
630
- FUNCTION alias_index2_reference_statement : BOOLEAN;
631
- ALIAS test FOR test[1:9];
632
- ;
633
- END_ALIAS;
634
- END_FUNCTION;
635
-
636
- FUNCTION assignment_simple_reference_statement : BOOLEAN;
637
- test := TRUE;
638
- END_FUNCTION;
639
-
640
- FUNCTION assignment_attribute_reference_statement : BOOLEAN;
641
- test.test := TRUE;
642
- END_FUNCTION;
643
-
644
- FUNCTION assignment_group_reference_statement : BOOLEAN;
645
- test\test := TRUE;
646
- END_FUNCTION;
647
-
648
- FUNCTION assignment_index_reference_statement : BOOLEAN;
649
- test[1] := TRUE;
650
- END_FUNCTION;
651
-
652
- FUNCTION assignment_index2_reference_statement : BOOLEAN;
653
- test[1:9] := TRUE;
654
- END_FUNCTION;
655
-
656
- FUNCTION case_statement : BOOLEAN;
657
- CASE test OF
658
- TRUE :
659
- ;
660
- END_CASE;
661
- END_FUNCTION;
662
-
663
- FUNCTION case_multiple_statement : BOOLEAN;
664
- CASE test OF
665
- TRUE :
666
- ;
667
- TRUE :
668
- ;
669
- END_CASE;
670
- END_FUNCTION;
671
-
672
- FUNCTION case_multiple_shorthand_statement : BOOLEAN;
673
- CASE test OF
674
- TRUE, TRUE :
675
- ;
676
- END_CASE;
677
- END_FUNCTION;
678
-
679
- FUNCTION case_otherwise_statement : BOOLEAN;
680
- CASE test OF
681
- TRUE :
682
- ;
683
- OTHERWISE :
684
- ;
685
- END_CASE;
686
- END_FUNCTION;
687
-
688
- FUNCTION compound_statement : BOOLEAN;
689
- BEGIN
690
- ;
691
- END;
692
- END_FUNCTION;
693
-
694
- FUNCTION escape_statement : BOOLEAN;
695
- ESCAPE;
696
- END_FUNCTION;
697
-
698
- FUNCTION if_statement : BOOLEAN;
699
- IF TRUE THEN
700
- ;
701
- END_IF;
702
- END_FUNCTION;
703
-
704
- FUNCTION if2_statement : BOOLEAN;
705
- IF TRUE THEN
706
- ;
707
- ;
708
- END_IF;
709
- END_FUNCTION;
710
-
711
- FUNCTION if_else_statement : BOOLEAN;
712
- IF TRUE THEN
713
- ;
714
- ELSE
715
- ;
716
- END_IF;
717
- END_FUNCTION;
718
-
719
- FUNCTION if2_else_statement : BOOLEAN;
720
- IF TRUE THEN
721
- ;
722
- ;
723
- ELSE
724
- ;
725
- END_IF;
726
- END_FUNCTION;
727
-
728
- FUNCTION if_else2_statement : BOOLEAN;
729
- IF TRUE THEN
730
- ;
731
- ELSE
732
- ;
733
- ;
734
- END_IF;
735
- END_FUNCTION;
736
-
737
- FUNCTION if2_else2_statement : BOOLEAN;
738
- IF TRUE THEN
739
- ;
740
- ;
741
- ELSE
742
- ;
743
- ;
744
- END_IF;
745
- END_FUNCTION;
746
-
747
- FUNCTION null_statement : BOOLEAN;
748
- ;
749
- END_FUNCTION;
750
-
751
- FUNCTION call_statement : BOOLEAN;
752
- empty_procedure;
753
- END_FUNCTION;
754
-
755
- FUNCTION call_parameter_statement : BOOLEAN;
756
- empty_procedure(TRUE);
757
- END_FUNCTION;
758
-
759
- FUNCTION call_parameter2_statement : BOOLEAN;
760
- empty_procedure(TRUE, TRUE);
761
- END_FUNCTION;
762
-
763
- FUNCTION call_insert_statement : BOOLEAN;
764
- INSERT(TRUE);
765
- END_FUNCTION;
766
-
767
- FUNCTION call_remove_statement : BOOLEAN;
768
- REMOVE(TRUE);
769
- END_FUNCTION;
770
-
771
- FUNCTION repeat_statement : BOOLEAN;
772
- REPEAT;
773
- ;
774
- END_REPEAT;
775
- END_FUNCTION;
776
-
777
- FUNCTION repeat_variable_statement : BOOLEAN;
778
- REPEAT test := 1 TO 9;
779
- ;
780
- END_REPEAT;
781
- END_FUNCTION;
782
-
783
- FUNCTION repeat_variable_increment_statement : BOOLEAN;
784
- REPEAT test := 1 TO 9 BY 2;
785
- ;
786
- END_REPEAT;
787
- END_FUNCTION;
788
-
789
- FUNCTION repeat_while_statement : BOOLEAN;
790
- REPEAT WHILE TRUE;
791
- ;
792
- END_REPEAT;
793
- END_FUNCTION;
794
-
795
- FUNCTION repeat_until_statement : BOOLEAN;
796
- REPEAT UNTIL TRUE;
797
- ;
798
- END_REPEAT;
799
- END_FUNCTION;
800
-
801
- FUNCTION return_statement : BOOLEAN;
802
- RETURN;
803
- END_FUNCTION;
804
-
805
- FUNCTION return_expression_statement : BOOLEAN;
806
- RETURN (TRUE);
807
- END_FUNCTION;
808
-
809
- FUNCTION skip_statement : BOOLEAN;
810
- SKIP;
811
- END_FUNCTION;
812
-
813
- FUNCTION binary_expression : BOOLEAN;
814
- RETURN (%011110000111100001111000);
815
- END_FUNCTION;
816
-
817
- FUNCTION integer_expression : BOOLEAN;
818
- RETURN (999);
819
- END_FUNCTION;
820
-
821
- FUNCTION true_logical_expression : BOOLEAN;
822
- RETURN (TRUE);
823
- END_FUNCTION;
824
-
825
- FUNCTION false_logical_expression : BOOLEAN;
826
- RETURN (FALSE);
827
- END_FUNCTION;
828
-
829
- FUNCTION unknown_logical_expression : BOOLEAN;
830
- RETURN (UNKNOWN);
831
- END_FUNCTION;
832
-
833
- FUNCTION real_expression : BOOLEAN;
834
- RETURN (999.999);
835
- END_FUNCTION;
836
-
837
- FUNCTION simple_string_expression : BOOLEAN;
838
- RETURN ('xxx');
839
- END_FUNCTION;
840
-
841
- FUNCTION utf8_simple_string_expression : BOOLEAN;
842
- RETURN ('UTF8 test: Příliš žluťoučký kůň úpěl ďábelské ódy.');
843
- END_FUNCTION;
844
-
845
- FUNCTION encoded_string_expression : BOOLEAN;
846
- RETURN ("000000780000007800000078");
847
- END_FUNCTION;
848
-
849
- FUNCTION const_e_expression : BOOLEAN;
850
- RETURN (CONST_E);
851
- END_FUNCTION;
852
-
853
- FUNCTION indeterminate_expression : BOOLEAN;
854
- RETURN (?);
855
- END_FUNCTION;
856
-
857
- FUNCTION pi_expression : BOOLEAN;
858
- RETURN (PI);
859
- END_FUNCTION;
860
-
861
- FUNCTION self_expression : BOOLEAN;
862
- RETURN (SELF);
863
- END_FUNCTION;
864
-
865
- FUNCTION abs_expression : BOOLEAN;
866
- RETURN (ABS(TRUE));
867
- END_FUNCTION;
868
-
869
- FUNCTION acos_expression : BOOLEAN;
870
- RETURN (ACOS(TRUE));
871
- END_FUNCTION;
872
-
873
- FUNCTION asin_expression : BOOLEAN;
874
- RETURN (ASIN(TRUE));
875
- END_FUNCTION;
876
-
877
- FUNCTION atan_expression : BOOLEAN;
878
- RETURN (ATAN(TRUE));
879
- END_FUNCTION;
880
-
881
- FUNCTION blength_expression : BOOLEAN;
882
- RETURN (BLENGTH(TRUE));
883
- END_FUNCTION;
884
-
885
- FUNCTION cos_expression : BOOLEAN;
886
- RETURN (COS(TRUE));
887
- END_FUNCTION;
888
-
889
- FUNCTION exists_expression : BOOLEAN;
890
- RETURN (EXISTS(TRUE));
891
- END_FUNCTION;
892
-
893
- FUNCTION exp_expression : BOOLEAN;
894
- RETURN (EXP(TRUE));
895
- END_FUNCTION;
896
-
897
- FUNCTION format_expression : BOOLEAN;
898
- RETURN (FORMAT(TRUE));
899
- END_FUNCTION;
900
-
901
- FUNCTION hibound_expression : BOOLEAN;
902
- RETURN (HIBOUND(TRUE));
903
- END_FUNCTION;
904
-
905
- FUNCTION hiindex_expression : BOOLEAN;
906
- RETURN (HIINDEX(TRUE));
907
- END_FUNCTION;
908
-
909
- FUNCTION length_expression : BOOLEAN;
910
- RETURN (LENGTH(TRUE));
911
- END_FUNCTION;
912
-
913
- FUNCTION lobound_expression : BOOLEAN;
914
- RETURN (LOBOUND(TRUE));
915
- END_FUNCTION;
916
-
917
- FUNCTION loindex_expression : BOOLEAN;
918
- RETURN (LOINDEX(TRUE));
919
- END_FUNCTION;
920
-
921
- FUNCTION log_expression : BOOLEAN;
922
- RETURN (LOG(TRUE));
923
- END_FUNCTION;
924
-
925
- FUNCTION log2_expression : BOOLEAN;
926
- RETURN (LOG2(TRUE));
927
- END_FUNCTION;
928
-
929
- FUNCTION log10_expression : BOOLEAN;
930
- RETURN (LOG10(TRUE));
931
- END_FUNCTION;
932
-
933
- FUNCTION nvl_expression : BOOLEAN;
934
- RETURN (NVL(TRUE));
935
- END_FUNCTION;
936
-
937
- FUNCTION odd_expression : BOOLEAN;
938
- RETURN (ODD(TRUE));
939
- END_FUNCTION;
940
-
941
- FUNCTION rolesof_expression : BOOLEAN;
942
- RETURN (ROLESOF(TRUE));
943
- END_FUNCTION;
944
-
945
- FUNCTION sin_expression : BOOLEAN;
946
- RETURN (SIN(TRUE));
947
- END_FUNCTION;
948
-
949
- FUNCTION sizeof_expression : BOOLEAN;
950
- RETURN (SIZEOF(TRUE));
951
- END_FUNCTION;
952
-
953
- FUNCTION sqrt_expression : BOOLEAN;
954
- RETURN (SQRT(TRUE));
955
- END_FUNCTION;
956
-
957
- FUNCTION tan_expression : BOOLEAN;
958
- RETURN (TAN(TRUE));
959
- END_FUNCTION;
960
-
961
- FUNCTION typeof_expression : BOOLEAN;
962
- RETURN (TYPEOF(TRUE));
963
- END_FUNCTION;
964
-
965
- FUNCTION usedin_expression : BOOLEAN;
966
- RETURN (USEDIN(TRUE));
967
- END_FUNCTION;
968
-
969
- FUNCTION value_expression : BOOLEAN;
970
- RETURN (VALUE(TRUE));
971
- END_FUNCTION;
972
-
973
- FUNCTION value_in_expression : BOOLEAN;
974
- RETURN (VALUE_IN(TRUE));
975
- END_FUNCTION;
976
-
977
- FUNCTION value_unique_expression : BOOLEAN;
978
- RETURN (VALUE_UNIQUE(TRUE));
979
- END_FUNCTION;
980
-
981
- FUNCTION plus_expression : BOOLEAN;
982
- RETURN (+4);
983
- END_FUNCTION;
984
-
985
- FUNCTION plus_addition_expression : BOOLEAN;
986
- RETURN (+(4 + 2));
987
- END_FUNCTION;
988
-
989
- FUNCTION minus_expression : BOOLEAN;
990
- RETURN (-4);
991
- END_FUNCTION;
992
-
993
- FUNCTION minus_addition_expression : BOOLEAN;
994
- RETURN (-(4 + 2));
995
- END_FUNCTION;
996
-
997
- FUNCTION addition_expression : BOOLEAN;
998
- RETURN (4 + 2);
999
- END_FUNCTION;
1000
-
1001
- FUNCTION subtraction_expression : BOOLEAN;
1002
- RETURN (4 - 2);
1003
- END_FUNCTION;
1004
-
1005
- FUNCTION multiplication_expression : BOOLEAN;
1006
- RETURN (4 * 2);
1007
- END_FUNCTION;
1008
-
1009
- FUNCTION real_division_expression : BOOLEAN;
1010
- RETURN (4 / 2);
1011
- END_FUNCTION;
1012
-
1013
- FUNCTION integer_division_expression : BOOLEAN;
1014
- RETURN (4 DIV 2);
1015
- END_FUNCTION;
1016
-
1017
- FUNCTION modulo_expression : BOOLEAN;
1018
- RETURN (4 MOD 2);
1019
- END_FUNCTION;
1020
-
1021
- FUNCTION exponentiation_expression : BOOLEAN;
1022
- RETURN (4 ** 2);
1023
- END_FUNCTION;
1024
-
1025
- FUNCTION addition_addition_expression : BOOLEAN;
1026
- RETURN (4 + 2 + 1);
1027
- END_FUNCTION;
1028
-
1029
- FUNCTION subtraction_subtraction_expression : BOOLEAN;
1030
- RETURN (4 - 2 - 1);
1031
- END_FUNCTION;
1032
-
1033
- FUNCTION addition_subtraction_expression : BOOLEAN;
1034
- RETURN (4 + 2 - 1);
1035
- END_FUNCTION;
1036
-
1037
- FUNCTION subtraction_addition_expression : BOOLEAN;
1038
- RETURN (4 - 2 + 1);
1039
- END_FUNCTION;
1040
-
1041
- FUNCTION addition_multiplication_expression : BOOLEAN;
1042
- RETURN (8 + 4 * 2);
1043
- END_FUNCTION;
1044
-
1045
- FUNCTION multiplication_addition_expression : BOOLEAN;
1046
- RETURN (8 * 4 + 2);
1047
- END_FUNCTION;
1048
-
1049
- FUNCTION parenthesis_addition_multiplication_expression : BOOLEAN;
1050
- RETURN ((8 + 4) * 2);
1051
- END_FUNCTION;
1052
-
1053
- FUNCTION multiplication_parenthesis_addition_expression : BOOLEAN;
1054
- RETURN (8 * (4 + 2));
1055
- END_FUNCTION;
1056
-
1057
- FUNCTION equal_expression : BOOLEAN;
1058
- RETURN (4 = 2);
1059
- END_FUNCTION;
1060
-
1061
- FUNCTION not_equal_expression : BOOLEAN;
1062
- RETURN (4 <> 2);
1063
- END_FUNCTION;
1064
-
1065
- FUNCTION instance_equal_expression : BOOLEAN;
1066
- RETURN (4 :=: 2);
1067
- END_FUNCTION;
1068
-
1069
- FUNCTION instance_not_equal_expression : BOOLEAN;
1070
- RETURN (4 :<>: 2);
1071
- END_FUNCTION;
1072
-
1073
- FUNCTION lt_expression : BOOLEAN;
1074
- RETURN (4 < 2);
1075
- END_FUNCTION;
1076
-
1077
- FUNCTION gt_expression : BOOLEAN;
1078
- RETURN (4 > 2);
1079
- END_FUNCTION;
1080
-
1081
- FUNCTION lte_expression : BOOLEAN;
1082
- RETURN (4 <= 2);
1083
- END_FUNCTION;
1084
-
1085
- FUNCTION gte_expression : BOOLEAN;
1086
- RETURN (4 >= 2);
1087
- END_FUNCTION;
1088
-
1089
- FUNCTION not_expression : BOOLEAN;
1090
- RETURN (NOT TRUE);
1091
- END_FUNCTION;
1092
-
1093
- FUNCTION not_or_expression : BOOLEAN;
1094
- RETURN (NOT (TRUE OR FALSE));
1095
- END_FUNCTION;
1096
-
1097
- FUNCTION or_expression : BOOLEAN;
1098
- RETURN (TRUE OR FALSE);
1099
- END_FUNCTION;
1100
-
1101
- FUNCTION and_expression : BOOLEAN;
1102
- RETURN (TRUE AND FALSE);
1103
- END_FUNCTION;
1104
-
1105
- FUNCTION or_or_expression : BOOLEAN;
1106
- RETURN (TRUE OR FALSE OR TRUE);
1107
- END_FUNCTION;
1108
-
1109
- FUNCTION and_and_expression : BOOLEAN;
1110
- RETURN (TRUE AND FALSE AND TRUE);
1111
- END_FUNCTION;
1112
-
1113
- FUNCTION or_and_expression : BOOLEAN;
1114
- RETURN (TRUE OR FALSE AND TRUE);
1115
- END_FUNCTION;
1116
-
1117
- FUNCTION and_or_expression : BOOLEAN;
1118
- RETURN (TRUE AND FALSE OR TRUE);
1119
- END_FUNCTION;
1120
-
1121
- FUNCTION parenthesis_or_and_expression : BOOLEAN;
1122
- RETURN ((TRUE OR FALSE) AND TRUE);
1123
- END_FUNCTION;
1124
-
1125
- FUNCTION and_parenthesis_or_expression : BOOLEAN;
1126
- RETURN (TRUE AND (FALSE OR TRUE));
1127
- END_FUNCTION;
1128
-
1129
- FUNCTION combine_expression : BOOLEAN;
1130
- RETURN (test || test);
1131
- END_FUNCTION;
1132
-
1133
- FUNCTION in_expression : BOOLEAN;
1134
- RETURN (TRUE IN [TRUE]);
1135
- END_FUNCTION;
1136
-
1137
- FUNCTION like_expression : BOOLEAN;
1138
- RETURN ('xxx' LIKE 'xxx');
1139
- END_FUNCTION;
1140
-
1141
- FUNCTION aggregate_initializer_expression : BOOLEAN;
1142
- RETURN ([4]);
1143
- END_FUNCTION;
1144
-
1145
- FUNCTION repeated_aggregate_initializer_expression : BOOLEAN;
1146
- RETURN ([4:2]);
1147
- END_FUNCTION;
1148
-
1149
- FUNCTION complex_aggregate_initializer_expression : BOOLEAN;
1150
- RETURN ([4 + 2]);
1151
- END_FUNCTION;
1152
-
1153
- FUNCTION complex_repeated_aggregate_initializer_expression : BOOLEAN;
1154
- RETURN ([4 + 2:4 + 2]);
1155
- END_FUNCTION;
1156
-
1157
- FUNCTION call_expression : BOOLEAN;
1158
- RETURN (parameter_function(TRUE));
1159
- END_FUNCTION;
1160
-
1161
- FUNCTION simple_reference_expression : BOOLEAN;
1162
- RETURN (simple_string_expression);
1163
- END_FUNCTION;
1164
-
1165
- FUNCTION attribute_reference_expression : BOOLEAN;
1166
- RETURN (simple_string_expression.test);
1167
- END_FUNCTION;
1168
-
1169
- FUNCTION group_reference_expression : BOOLEAN;
1170
- RETURN (simple_string_expression\test);
1171
- END_FUNCTION;
1172
-
1173
- FUNCTION index_reference_expression : BOOLEAN;
1174
- RETURN (simple_string_expression[1]);
1175
- END_FUNCTION;
1176
-
1177
- FUNCTION index2_reference_expression : BOOLEAN;
1178
- RETURN (simple_string_expression[1:9]);
1179
- END_FUNCTION;
1180
-
1181
- FUNCTION lt_lt_interval_expression : BOOLEAN;
1182
- RETURN ({1 < 5 < 9});
1183
- END_FUNCTION;
1184
-
1185
- FUNCTION lte_lt_interval_expression : BOOLEAN;
1186
- RETURN ({1 <= 5 < 9});
1187
- END_FUNCTION;
1188
-
1189
- FUNCTION lt_lte_interval_expression : BOOLEAN;
1190
- RETURN ({1 < 5 <= 9});
1191
- END_FUNCTION;
1192
-
1193
- FUNCTION lte_lte_interval_expression : BOOLEAN;
1194
- RETURN ({1 <= 5 <= 9});
1195
- END_FUNCTION;
1196
-
1197
- FUNCTION query_expression : BOOLEAN;
1198
- RETURN (QUERY(test <* test2 | TRUE));
1199
- END_FUNCTION;
1200
754
  END_SCHEMA;