Commit | Line | Data |
---|---|---|
970ed795 | 1 | /****************************************************************************** |
d44e3c4f | 2 | * Copyright (c) 2000-2016 Ericsson Telecom AB |
970ed795 EL |
3 | * All rights reserved. This program and the accompanying materials |
4 | * are made available under the terms of the Eclipse Public License v1.0 | |
5 | * which accompanies this distribution, and is available at | |
6 | * http://www.eclipse.org/legal/epl-v10.html | |
d44e3c4f | 7 | * |
8 | * Contributors: | |
9 | * Balasko, Jeno | |
10 | * Baranyi, Botond | |
11 | * Raduly, Csaba | |
12 | * Szabo, Janos Zoltan – initial implementation | |
13 | * Szalai, Gabor | |
14 | * Zalanyi, Balazs Andor | |
15 | * | |
970ed795 EL |
16 | ******************************************************************************/ |
17 | /* RAW encoding/decoding specification parser & compiler */ | |
18 | ||
19 | %{ | |
20 | #include <stdlib.h> | |
21 | #include <stdio.h> | |
22 | #include <string.h> | |
23 | #include "../../common/memory.h" | |
24 | #include "../Int.hh" | |
25 | #include "../Real.hh" | |
26 | #include "../Value.hh" | |
27 | #include "AST_ttcn3.hh" | |
28 | #include "rawASTspec.h" | |
29 | #include "RawAST.hh" | |
30 | #include "../XerAttributes.hh" | |
31 | #include "BerAST.hh" | |
32 | #include "JsonAST.hh" | |
33 | ||
34 | extern void rawAST_error(const char *str); | |
35 | extern int rawAST_lex(); | |
36 | ||
37 | extern RawAST* rawstruct; | |
38 | extern Common::Module *mymod; | |
39 | extern int length_multiplier; | |
40 | extern TextAST *textstruct; | |
41 | extern bool raw_f; | |
42 | extern bool text_f; | |
43 | extern bool xer_f; | |
44 | extern bool ber_f; | |
45 | extern bool json_f; | |
46 | extern XerAttributes* xerstruct; | |
47 | extern BerAST* berstruct; | |
48 | extern JsonAST* jsonstruct; | |
49 | ||
50 | extern string *parse_charstring_value(const char *str, | |
51 | const Common::Location& loc); | |
52 | ||
53 | #define YYERROR_VERBOSE | |
54 | ||
55 | #ifndef NDEBUG | |
56 | union YYSTYPE; | |
57 | static void yyprint(FILE *file, int type, const YYSTYPE& value); | |
58 | #define YYPRINT(f,t,v) yyprint(f,t,v) | |
59 | #endif | |
60 | ||
61 | %} | |
62 | ||
63 | %union { | |
64 | bool boolval; | |
65 | int enumval; | |
66 | char* str; | |
67 | const char *cstr; | |
68 | Common::Int intval; | |
69 | Common::Real floatval; | |
70 | Common::Value::verdict_t verdictval; | |
71 | Common::Identifier *identifier; | |
72 | rawAST_field_list *fieldlist; | |
73 | rawAST_tag_list taglist; | |
74 | rawAST_tag_field_value keyid; | |
75 | rawAST_single_tag singletag; | |
76 | rawAST_toplevel toplevel; | |
77 | rawAST_values values; | |
78 | struct { | |
79 | char *token; | |
80 | bool case_sensitive; | |
81 | } decodetoken; | |
82 | NamespaceSpecification nsspec; | |
83 | NamespaceRestriction nsrestr; | |
84 | } | |
85 | ||
86 | %token <intval> XNumber | |
87 | %token <floatval> XFloatValue | |
88 | %token <identifier> XIdentifier | |
89 | %token <str> XBstring | |
90 | %token <str> XHstring | |
91 | %token <str> XOstring | |
92 | %token <str> XCstring | |
93 | %token <str> Xstring | |
94 | %token <boolval> XBooleanConst | |
95 | %token <verdictval> XVerdictConst | |
96 | %token XNullKeyword | |
97 | %token XNULLKeyword | |
98 | %token XOmitKeyword | |
99 | ||
100 | %token <str> Xtoken | |
101 | %token XBeginKeyword | |
102 | %token XEndKeyword | |
103 | %token XSeparatorKeyword | |
104 | %token XCodingKeyword | |
105 | %token XLengthToken | |
106 | %token XLowerToken | |
107 | %token XUpperToken | |
108 | %token XJustToken | |
109 | %token XLeftToken | |
110 | %token XRightToken | |
111 | %token XCenterToken | |
112 | %token XLeadingToken | |
113 | %token XTrueToken | |
114 | %token XSensitivToken | |
115 | %token XInSensitivToken | |
116 | %token XConvertToken | |
117 | %token XFalseToken | |
118 | %token XRepeatToken | |
119 | ||
120 | %token XPaddingKeyword | |
121 | %token XPaddAllKeyword | |
122 | %token XPrePaddingKeyword | |
123 | %token XPaddingPatternKeyword | |
124 | %token XOtherwise | |
125 | %token <enumval> XYes | |
126 | %token <enumval> XNo | |
127 | %token <enumval> XReverse | |
128 | %token XFieldOrderKeyword | |
129 | %token <enumval> XMsb | |
130 | %token <enumval> XLsb | |
131 | %token XExtensionBitKeyword | |
132 | %token XExtensionBitGroupKeyword | |
133 | %token XLengthToKeyword | |
134 | %token XPointerToKeyword | |
135 | %token XUnitKeyword | |
136 | %token XPtrUnitKeyword | |
137 | %token XPtrOffsetKeyword | |
138 | %token <enumval> XBits | |
139 | %token <enumval> XOctets | |
140 | %token XLengthIndexKeyword | |
141 | %token XTagKeyword | |
142 | %token XCrossTagKeyword | |
143 | %token XPresenceKeyword | |
144 | %token XFieldLengthKeyword | |
145 | %token XAlignKeyword | |
146 | %token <enumval> XLeft | |
147 | %token <enumval> XRight | |
148 | %token XCompKeyword | |
149 | %token <enumval> XUnsigned | |
150 | %token <enumval> XCompl | |
151 | %token <enumval> XSignbit | |
152 | %token XByteOrderKeyword | |
153 | %token <enumval> XFirst | |
154 | %token <enumval> XLast | |
155 | %token XBitOrderKeyword | |
156 | %token XBitOrderInFieldKeyword | |
157 | %token XBitOrderInOctetKeyword | |
158 | %token XHexOrderKeyword | |
159 | %token <enumval> XLow | |
160 | %token <enumval> XHigh | |
161 | %token XToplevelKeyword | |
162 | %token XRepeatableKeyword | |
3abe9331 | 163 | %token XIntXKeyword |
51fa56b9 | 164 | %token XBitKeyword |
165 | %token XUnsignedKeyword | |
970ed795 EL |
166 | |
167 | /* XER attributes */ | |
168 | %token XKWall "all" | |
169 | %token XKWas "as" | |
170 | %token XKWin "in" | |
171 | %token XKWcapitalized "capitalized" | |
172 | %token XKWuncapitalized "uncapitalized" | |
173 | %token XKWlowercased "lowercased" | |
174 | %token XKWuppercased "uppercased" | |
175 | %token XKWpreserve "preserve" | |
176 | %token XKWreplace "replace" | |
177 | %token XKWcollapse "collapse" | |
178 | %token XKWfrom "from" | |
179 | %token XKWexcept "except" | |
180 | %token XKWunqualified "unqualified" | |
181 | %token XKWqualified "qualified" | |
182 | %token XKWprefix "prefix" | |
183 | ||
184 | ||
51fa56b9 | 185 | %token XKWabstract "abstact" |
970ed795 EL |
186 | %token XKWanyAttributes "anyAttributes" |
187 | %token XKWanyElement "anyElement" | |
188 | %token XKWattribute "attribute" | |
189 | %token XKWattributeFormQualified "attributeFormQualified" | |
51fa56b9 | 190 | %token XKWblock "block" |
970ed795 EL |
191 | %token XKWcontrolNamespace "controlNamespace" |
192 | %token XKWdefaultForEmpty "defaultForEmpty" | |
193 | %token XKWelement "element" | |
194 | %token XKWelementFormQualified "elementFormQualified" | |
195 | %token XKWembedValues "embedValues" | |
196 | %token XKWform "form" | |
197 | %token XKWlist "list" | |
198 | %token XKWname "name" | |
199 | %token XKWnamespace "namespace" | |
200 | %token XKWtext "text" | |
201 | %token XKWuntagged "untagged" | |
202 | %token XKWuseNil "useNil" | |
203 | %token XKWuseNumber "useNumber" | |
204 | %token XKWuseOrder "useOrder" | |
205 | %token XKWuseUnion "useUnion" | |
206 | %token XKWuseType "useType" | |
207 | %token XKWwhiteSpace "whiteSpace" | |
208 | %token XSD "XSD" | |
209 | ||
210 | /* XSD:something */ | |
211 | %token XSDstring "string" | |
212 | %token XSDnormalizedString "normalizedString" | |
213 | %token XSDtoken "token" | |
214 | %token XSDName "Name" | |
215 | %token XSDNMTOKEN "NMTOKEN" | |
216 | %token XSDNCName "NCName" | |
217 | %token XSDID "ID" | |
218 | %token XSDIDREF "IDREF" | |
219 | %token XSDENTITY "ENTITY" | |
220 | %token XSDhexBinary "hexBinary" | |
221 | %token XSDbase64Binary "base64Binary" | |
222 | %token XSDanyURI "anyURI" | |
223 | %token XSDlanguage "language" | |
224 | %token XSDinteger "integer" | |
225 | %token XSDpositiveInteger "positiveInteger" | |
226 | %token XSDnonPositiveInteger "nonPositiveInteger" | |
227 | %token XSDnegativeInteger "negativeInteger" | |
228 | %token XSDnonNegativeInteger "nonNegativeInteger" | |
229 | /* XKWlong instead of %token XSDlong */ | |
230 | %token XSDunsignedLong "unsignedLong" | |
231 | %token XSDint "int" | |
232 | %token XSDunsignedInt "unsignedInt" | |
233 | /* XKWshort instead of %token XSDshort */ | |
234 | %token XSDunsignedShort "unsignedShort" | |
235 | %token XSDbyte "byte" | |
236 | %token XSDunsignedByte "unsignedByte" | |
237 | %token XSDdecimal "decimal" | |
238 | %token XSDfloat "float" | |
239 | %token XSDdouble "double" | |
240 | %token XSDduration "duration" | |
241 | %token XSDdateTime "dateTime" | |
242 | %token XSDtime "time" | |
243 | %token XSDdate "date" | |
244 | %token XSDgYearMonth "gYearMonth" | |
245 | %token XSDgYear "gYear" | |
246 | %token XSDgMonthDay "gMonthDay" | |
247 | %token XSDgDay "gDay" | |
248 | %token XSDgMonth "gMonth" | |
249 | %token XSDNMTOKENS "NMTOKENS" | |
250 | %token XSDIDREFS "IDREFS" | |
251 | %token XSDENTITIES "ENTITIES" | |
252 | %token XSDQName "QName" | |
253 | %token XSDboolean "boolean" | |
254 | %token XSDanySimpleType "anySimpleType" | |
255 | %token XSDanyType "anyType" | |
256 | ||
257 | ||
258 | ||
259 | /* BER attributes */ | |
260 | %token XKWlength "length" | |
261 | %token XKWaccept "accept" | |
262 | %token XKWlong "long" | |
263 | %token XKWshort "short" | |
264 | %token XKWindefinite "indefinite" | |
265 | %token XKWdefinite "definite" | |
266 | ||
267 | ||
268 | // JSON attributes | |
269 | %token XKWjson "JSON" | |
270 | %token XKWomit "omit" | |
271 | %token XKWnull "null" | |
272 | %token XAliasToken "JSON alias" | |
273 | %token XKWvalue "value" | |
274 | %token XKWdefault "default" | |
3abe9331 | 275 | %token XKWextend "extend" |
276 | %token XKWmetainfo "metainfo" | |
277 | %token XKWfor "for" | |
278 | %token XKWunbound "unbound" | |
970ed795 EL |
279 | %token XJsonValueStart "(" |
280 | %token XJsonValueEnd ")" | |
281 | %token XJsonValueSegment "JSON value" | |
282 | ||
283 | ||
284 | %type <enumval> | |
285 | XYesOrNo XMsbOrLsb XFieldOrderDef XPaddingDef XExtensionBitDef XUnitDef | |
286 | XBitsOctets XAlignDef XLeftOrRight XCompDef XCompValues XByteOrderDef | |
287 | XFirstOrLast XBitOrderDef XBitOrderInFieldDef XBitOrderInOctetDef | |
288 | XHexOrderDef XLowOrHigh XYesOrNoOrReverse XFieldLengthDef | |
289 | XPtrOffsetDef XPrePaddingDef XRepeatableDef form | |
290 | ||
291 | %type <fieldlist> | |
292 | XLengthIndexDef XStructFieldRefOrEmpty XStructFieldRef | |
293 | ||
294 | %type <str> | |
3abe9331 | 295 | XEncodeToken XmatchDef XAliasToken XJsonValueSegment XJsonValueCore XJsonValue |
970ed795 EL |
296 | |
297 | %type <decodetoken> | |
298 | XDecodeToken | |
299 | ||
300 | %type <cstr> | |
feade998 | 301 | XTextReservedWord XJsonAlias |
970ed795 EL |
302 | |
303 | %type <identifier> | |
304 | XPointerToDef XRecordFieldRef XIdentifierOrReserved | |
305 | ||
306 | %type <values> | |
307 | XRvalue | |
308 | ||
309 | %type <taglist> | |
310 | XAssocList | |
311 | ||
312 | /* note: multiple "XSingleEncodingDefs have to be merged into one 'fullspec' */ | |
313 | %type <fullspec> | |
314 | XEncodingDefList XSingleEncodingDef | |
315 | ||
316 | %type <keyid> | |
317 | XKeyId | |
318 | %type <boolval> | |
319 | XmodifierDef | |
320 | ||
321 | %type <singletag> | |
322 | XAssocElement XKeyIdOrIdList XKeyIdList XMultiKeyId | |
323 | ||
324 | %type <toplevel> | |
325 | XToplevelDef XTopDefList XTopDef | |
326 | ||
327 | /* XER */ | |
328 | %type <nsrestr> | |
329 | anyAttributes anyElement optNamespaceRestriction urilist | |
330 | ||
331 | ||
332 | %type <str> defaultForEmpty name newnameOrKeyword keyword optPrefix quotedURIorAbsent | |
333 | ||
334 | %type <nsspec> namespace namespacespecification controlNamespace text | |
335 | ||
336 | %type <intval> whiteSpace | |
337 | ||
338 | /* destructors */ | |
339 | %destructor { Free($$); } | |
340 | XBstring | |
341 | XCstring | |
342 | XEncodeToken | |
343 | XHstring | |
344 | XmatchDef | |
345 | XOstring | |
346 | Xtoken | |
347 | Xstring | |
348 | XAliasToken | |
349 | XJsonValueSegment | |
3abe9331 | 350 | XJsonValueCore |
970ed795 EL |
351 | XJsonValue |
352 | ||
353 | %destructor { delete $$; } | |
354 | XIdentifier | |
355 | XIdentifierOrReserved | |
356 | XPointerToDef | |
357 | XRecordFieldRef | |
358 | ||
359 | %destructor { free_rawAST_field_list($$); } | |
360 | XLengthIndexDef | |
361 | XStructFieldRef | |
362 | XStructFieldRefOrEmpty | |
363 | ||
364 | %destructor { free_rawAST_tag_list(&$$); } | |
365 | XAssocList | |
366 | ||
367 | %destructor { free_rawAST_tag_field_value(&$$); } | |
368 | XKeyId | |
369 | ||
370 | %destructor { free_rawAST_single_tag(&$$); } | |
371 | XAssocElement | |
372 | XKeyIdList | |
373 | XKeyIdOrIdList | |
374 | XMultiKeyId | |
375 | ||
376 | %destructor { | |
377 | Free($$.value); | |
378 | delete $$.v_value; | |
379 | } | |
380 | XRvalue | |
381 | ||
382 | %destructor { Free($$.token); } | |
383 | XDecodeToken | |
384 | ||
385 | %destructor { | |
386 | FreeNamespaceRestriction($$); | |
387 | } | |
388 | anyAttributes anyElement optNamespaceRestriction urilist | |
389 | ||
390 | %destructor { | |
391 | Free($$.uri); | |
392 | Free($$.prefix); | |
393 | } | |
394 | namespace | |
395 | namespacespecification | |
396 | text | |
397 | controlNamespace | |
398 | ||
399 | %start XAttribSpec | |
400 | ||
401 | %% | |
402 | ||
403 | /* BNF, actions */ | |
404 | ||
405 | XAttribSpec : /* Empty */ | |
406 | | XEncodingDefList | |
407 | { } | |
408 | | XERattributes | |
409 | { } | |
410 | | XBERattributes | |
411 | { } | |
412 | ; | |
413 | ||
414 | XBERattributes : | |
415 | XKWlength XKWaccept XKWshort { berstruct->decode_param = BerAST::LENGTH_ACCEPT_SHORT; ber_f=true; } | |
416 | | XKWlength XKWaccept XKWlong { berstruct->decode_param = BerAST::LENGTH_ACCEPT_LONG; ber_f=true; } | |
417 | | XKWlength XKWaccept XKWindefinite { berstruct->decode_param = BerAST::LENGTH_ACCEPT_INDEFINITE; ber_f=true; } | |
418 | | XKWlength XKWaccept XKWdefinite { berstruct->decode_param = BerAST::LENGTH_ACCEPT_DEFINITE; ber_f=true; } | |
419 | ; | |
420 | ||
421 | XEncodingDefList : XSingleEncodingDef | |
422 | { } | |
423 | | XEncodingDefList ',' XSingleEncodingDef | |
424 | { }; | |
425 | ||
426 | XSingleEncodingDef : XPaddingDef | |
427 | { rawstruct->padding=$1;raw_f=true;} | |
428 | | XPrePaddingDef | |
429 | { rawstruct->prepadding=$1;raw_f=true;} | |
430 | | XPaddingPattern { raw_f=true;} | |
431 | | XPaddAll { rawstruct->paddall=XDEFYES;raw_f=true;} | |
432 | | XFieldOrderDef | |
433 | { rawstruct->fieldorder=$1;raw_f=true;} | |
434 | | XExtensionBitDef | |
435 | { rawstruct->extension_bit=$1;raw_f=true;} | |
436 | | XExtensionBitGroupDef | |
437 | { raw_f=true;} | |
438 | | XLengthToDef | |
439 | { raw_f=true;} | |
440 | | XPointerToDef | |
441 | { delete rawstruct->pointerto; | |
442 | rawstruct->pointerto = $1; | |
443 | raw_f=true; | |
444 | } | |
445 | | XUnitDef | |
446 | { rawstruct->unit=$1; raw_f=true;} | |
447 | | XLengthIndexDef | |
448 | { free_rawAST_field_list(rawstruct->lengthindex); | |
449 | rawstruct->lengthindex = $1;raw_f=true; } | |
450 | | XTagDef | |
451 | {raw_f=true; } | |
452 | | XCrossTagDef | |
453 | {raw_f=true; } | |
454 | | XPresenceDef | |
455 | { raw_f=true;} | |
456 | | XFieldLengthDef | |
457 | { rawstruct->fieldlength = $1*length_multiplier; raw_f=true;} | |
458 | | XPtrOffsetDef | |
459 | { raw_f=true; } | |
460 | | XAlignDef | |
461 | { rawstruct->align = $1; raw_f=true;} | |
462 | | XCompDef | |
463 | { rawstruct->comp = $1;raw_f=true; } | |
464 | | XByteOrderDef | |
465 | { rawstruct->byteorder = $1; raw_f=true;} | |
466 | | XBitOrderInFieldDef | |
467 | { rawstruct->bitorderinfield = $1; raw_f=true;} | |
468 | | XBitOrderInOctetDef | |
469 | { rawstruct->bitorderinoctet = $1; raw_f=true;} | |
470 | | XHexOrderDef | |
471 | { rawstruct->hexorder = $1;raw_f=true; } | |
472 | | XRepeatableDef | |
473 | { rawstruct->repeatable = $1;raw_f=true; } | |
474 | | XToplevelDef | |
475 | { rawstruct->topleveleind=1; raw_f=true;} | |
3abe9331 | 476 | | XIntXKeyword |
477 | { rawstruct->intx = true; raw_f = true; } | |
51fa56b9 | 478 | | XBitDef |
479 | { raw_f = true; } | |
970ed795 EL |
480 | /* TEXT encoder keywords */ |
481 | | XBeginDef | |
482 | { text_f=true; } | |
483 | | XEndDef | |
484 | { text_f=true; } | |
485 | | XSeparatorDef | |
486 | { text_f=true; } | |
487 | | XCodingDef | |
488 | { text_f=true; } | |
489 | | XJsonDef | |
490 | { json_f = true; } | |
491 | ; | |
492 | ||
493 | XRepeatableDef : XRepeatableKeyword '(' XYesOrNo ')' { $$ = $3; } | |
494 | ||
495 | /* Padding*/ | |
496 | XPaddingDef : XPaddingKeyword '(' XYesOrNo ')' { $$ = $3==XDEFYES?8:0; } | |
497 | | XPaddingKeyword '(' XBitsOctets ')' { $$ = $3;}; | |
498 | XPrePaddingDef : XPrePaddingKeyword '(' XYesOrNo ')' { $$ = $3==XDEFYES?8:0; } | |
499 | | XPrePaddingKeyword '(' XBitsOctets ')' { $$ = $3;}; | |
500 | XYesOrNo : XYes | XNo; | |
501 | ||
502 | XPaddingPattern: | |
503 | XPaddingPatternKeyword '(' XBstring ')' | |
504 | { | |
505 | Free(rawstruct->padding_pattern); | |
506 | size_t len = strlen($3); | |
507 | if (len > 0) { | |
508 | rawstruct->padding_pattern = mcopystr($3); | |
509 | rawstruct->padding_pattern_length = len; | |
510 | while (rawstruct->padding_pattern_length % 8 != 0) { | |
511 | rawstruct->padding_pattern = mputstr(rawstruct->padding_pattern, $3); | |
512 | rawstruct->padding_pattern_length += len; | |
513 | } | |
514 | } else rawstruct->padding_pattern = NULL; | |
515 | Free($3); | |
516 | } | |
517 | ; | |
518 | ||
519 | XPaddAll: XPaddAllKeyword | |
520 | /* FieldOrder */ | |
521 | XFieldOrderDef : XFieldOrderKeyword '(' XMsbOrLsb ')' | |
522 | { $$ = $3; }; | |
523 | XMsbOrLsb : XMsb | XLsb; | |
524 | ||
525 | /* Extension bit */ | |
526 | XExtensionBitDef : XExtensionBitKeyword '(' XYesOrNoOrReverse ')' | |
527 | { $$ = $3; }; | |
528 | XYesOrNoOrReverse : XYes | XNo | XReverse; | |
529 | ||
530 | XExtensionBitGroupDef: XExtensionBitGroupKeyword '(' XYesOrNoOrReverse ',' | |
531 | XIdentifier ',' XIdentifier ')' | |
532 | { if(rawstruct->ext_bit_goup_num==0){ | |
533 | rawstruct->ext_bit_groups= | |
534 | (rawAST_ext_bit_group*)Malloc(sizeof(rawAST_ext_bit_group)); | |
535 | rawstruct->ext_bit_goup_num=1; | |
536 | } else{ | |
537 | rawstruct->ext_bit_goup_num++; | |
538 | rawstruct->ext_bit_groups=(rawAST_ext_bit_group*) | |
539 | Realloc(rawstruct->ext_bit_groups, | |
540 | rawstruct->ext_bit_goup_num*sizeof(rawAST_ext_bit_group)); | |
541 | } | |
542 | rawstruct->ext_bit_groups[rawstruct->ext_bit_goup_num-1].ext_bit=$3; | |
543 | rawstruct->ext_bit_groups[rawstruct->ext_bit_goup_num-1].from=$5; | |
544 | rawstruct->ext_bit_groups[rawstruct->ext_bit_goup_num-1].to=$7; | |
545 | } | |
546 | ||
547 | /* LengthTo */ | |
548 | XLengthToDef : XLengthToKeyword '(' XRecordFieldRefList ')' | |
549 | { }; | |
550 | ||
551 | /* PointerTo */ | |
552 | XPointerToDef : XPointerToKeyword '(' XRecordFieldRef ')' | |
553 | { $$ = $3; }; | |
554 | ||
555 | /* Unit */ | |
556 | XUnitDef : XUnitKeyword '(' XBitsOctets ')' { $$ = $3; } | |
557 | | XPtrUnitKeyword '(' XBitsOctets ')' { $$ = $3; }; | |
558 | XBitsOctets : XBits {$$=$1;} | |
559 | | XOctets {$$=$1;} | |
560 | | XNumber {$$=$1;}; | |
561 | ||
562 | /* LengthIndex */ | |
563 | XLengthIndexDef : XLengthIndexKeyword '(' XStructFieldRefOrEmpty ')' | |
564 | { $$ = $3; }; | |
565 | ||
566 | ||
567 | /* Tag, Crosstag */ | |
568 | XTagDef : XTagKeyword '(' XAssocList XoptSemiColon ')' | |
569 | { free_rawAST_tag_list(&(rawstruct->taglist)); | |
570 | link_rawAST_tag_list(&(rawstruct->taglist),&$3);}; | |
571 | XCrossTagDef : XCrossTagKeyword '(' XAssocList XoptSemiColon ')' | |
572 | { free_rawAST_tag_list(&(rawstruct->crosstaglist)); | |
573 | link_rawAST_tag_list(&(rawstruct->crosstaglist),&$3);}; | |
574 | ||
575 | XAssocList: | |
576 | XAssocElement | |
577 | { | |
578 | $$.nElements = 1; | |
579 | $$.tag = (rawAST_single_tag*)Malloc(sizeof(*$$.tag)); | |
580 | link_rawAST_single_tag($$.tag, &$1); | |
581 | } | |
582 | | XAssocList XSemiColon XAssocElement | |
583 | { | |
584 | int dupl_id_index = -1; | |
585 | if ($3.nElements > 0) { | |
586 | /* the otherwise element is never merged */ | |
587 | for (int i = 0; i < $1.nElements; i++) | |
588 | if (*$1.tag[i].fieldName == *$3.fieldName) { | |
589 | dupl_id_index = i; | |
590 | break; | |
591 | } | |
592 | } | |
593 | if (dupl_id_index >= 0) { | |
594 | /* this identifier is already specified in XAssocList | |
595 | merge the new parameters to the existing entry */ | |
596 | $$ = $1; | |
597 | rawAST_single_tag *tag = $$.tag + dupl_id_index; | |
598 | tag->keyList = (rawAST_tag_field_value*) | |
599 | Realloc(tag->keyList, (tag->nElements + $3.nElements) | |
600 | * sizeof(*tag->keyList)); | |
601 | memcpy(tag->keyList + tag->nElements, $3.keyList, | |
602 | $3.nElements * sizeof(*$3.keyList)); | |
603 | tag->nElements += $3.nElements; | |
604 | delete $3.fieldName; | |
605 | Free($3.keyList); | |
606 | } else { | |
607 | $$.nElements = $1.nElements + 1; | |
608 | $$.tag = (rawAST_single_tag*) | |
609 | Realloc($1.tag, $$.nElements * sizeof(*$$.tag)); | |
610 | $$.tag[$1.nElements] = $3; | |
611 | } | |
612 | } | |
613 | ; | |
614 | ||
615 | XSemiColon: | |
616 | ';' | |
617 | ; | |
618 | ||
619 | XoptSemiColon: | |
620 | /* Empty */ | |
621 | | ';' | |
622 | ; | |
623 | ||
624 | XAssocElement: | |
625 | XIdentifier ',' XKeyIdOrIdList | |
626 | { | |
627 | $$.fieldName = $1; | |
628 | $$.nElements = $3.nElements; | |
629 | $$.keyList = $3.keyList; | |
630 | } | |
631 | | XIdentifier ',' XOtherwise | |
632 | { | |
633 | $$.fieldName = $1; | |
634 | $$.nElements = 0; | |
635 | $$.keyList = NULL; | |
636 | } | |
637 | ; | |
638 | ||
639 | XKeyIdOrIdList: | |
640 | XKeyId | |
641 | { | |
642 | $$.fieldName = NULL; | |
643 | $$.nElements = 1; | |
644 | $$.keyList = (rawAST_tag_field_value*)Malloc(sizeof(*$$.keyList)); | |
645 | $$.keyList[0] = $1; | |
646 | } | |
647 | | XKeyIdList { $$ = $1; } | |
648 | ; | |
649 | ||
650 | XKeyIdList: | |
651 | '{' XMultiKeyId '}' { $$ = $2; } | |
652 | ; | |
653 | ||
654 | XMultiKeyId: | |
655 | XKeyId | |
656 | { | |
657 | $$.fieldName = NULL; | |
658 | $$.nElements = 1; | |
659 | $$.keyList = (rawAST_tag_field_value*)Malloc(sizeof(*$$.keyList)); | |
660 | $$.keyList[0] = $1; | |
661 | } | |
662 | | XMultiKeyId ',' XKeyId | |
663 | { | |
664 | $$.fieldName = NULL; | |
665 | $$.nElements = $1.nElements + 1; | |
666 | $$.keyList = (rawAST_tag_field_value*) | |
667 | Realloc($1.keyList, $$.nElements * sizeof(*$$.keyList)); | |
668 | $$.keyList[$1.nElements] = $3; | |
669 | } | |
670 | ; | |
671 | ||
672 | XKeyId: | |
673 | XStructFieldRef '=' XRvalue | |
674 | { | |
675 | $$.keyField = $1; | |
676 | $$.value = $3.value; | |
677 | $$.v_value = $3.v_value; | |
678 | } | |
679 | ; | |
680 | ||
681 | /* Presence */ | |
682 | XPresenceDef : XPresenceKeyword '(' XKeyIdList XoptSemiColon ')' | |
683 | { free_rawAST_single_tag(&(rawstruct->presence)); | |
684 | link_rawAST_single_tag(&(rawstruct->presence), &$3);} | |
685 | | XPresenceKeyword '(' XMultiKeyId XoptSemiColon ')' | |
686 | { free_rawAST_single_tag(&(rawstruct->presence)); | |
687 | link_rawAST_single_tag(&(rawstruct->presence), &$3);}; | |
688 | ||
689 | ||
690 | /* FieldLength */ | |
691 | XFieldLengthDef : XFieldLengthKeyword '(' XNumber ')' | |
692 | { $$ = $3;}; | |
693 | ||
694 | /* PtrOffset */ | |
695 | XPtrOffsetDef : XPtrOffsetKeyword '(' XNumber ')' | |
696 | { rawstruct->ptroffset = $3; } | |
697 | |XPtrOffsetKeyword '(' XIdentifier ')' | |
698 | { | |
699 | delete rawstruct->ptrbase; | |
700 | rawstruct->ptrbase = $3; | |
701 | } | |
702 | /* Align */ | |
703 | XAlignDef : XAlignKeyword '(' XLeftOrRight ')' | |
704 | { $$ = $3; }; | |
705 | XLeftOrRight : XLeft | XRight; | |
706 | ||
707 | /* Comp */ | |
708 | XCompDef : XCompKeyword '(' XCompValues ')' | |
709 | { $$ = $3; }; | |
710 | XCompValues : XUnsigned | XCompl | XSignbit; | |
711 | ||
712 | /* ByteOrder */ | |
713 | XByteOrderDef : XByteOrderKeyword '(' XFirstOrLast ')' | |
714 | { $$ = $3; }; | |
715 | XFirstOrLast : XFirst | XLast; | |
716 | ||
717 | /* BitOrder */ | |
718 | XBitOrderInFieldDef : XBitOrderInFieldKeyword '(' XMsbOrLsb ')' | |
719 | { $$ = $3; }; | |
720 | XBitOrderInOctetDef : XBitOrderInOctetKeyword '(' XMsbOrLsb ')' | |
721 | { $$ = $3; } | |
722 | | XBitOrderKeyword '(' XMsbOrLsb ')' { $$ = $3; }; | |
723 | XToplevelDef : XToplevelKeyword '(' XTopDefList ')' | |
724 | { }; | |
725 | XTopDefList : XTopDef | |
726 | { } | |
727 | | XTopDefList ',' XTopDef | |
728 | { }; | |
729 | XTopDef : XBitOrderDef | |
730 | { rawstruct->toplevel.bitorder = $1;}; | |
731 | XBitOrderDef : XBitOrderKeyword '(' XMsbOrLsb ')' | |
732 | { $$ = $3; }; | |
733 | ||
734 | /* HexOrder */ | |
735 | XHexOrderDef : XHexOrderKeyword '(' XLowOrHigh ')' | |
736 | { $$ = $3; }; | |
737 | XLowOrHigh : XLow | XHigh; | |
738 | ||
739 | /* General types */ | |
740 | /* FieldRefList */ | |
741 | XRecordFieldRefList : XRecordFieldRef | |
742 | { rawstruct->lengthto_num = 1; | |
743 | rawstruct->lengthto = | |
744 | (Common::Identifier**)Malloc(sizeof(*(rawstruct->lengthto))); | |
745 | rawstruct->lengthto[0] = $1; | |
746 | } | |
747 | | XRecordFieldRefList ',' XRecordFieldRef | |
748 | { rawstruct->lengthto_num++; | |
749 | rawstruct->lengthto = | |
750 | (Common::Identifier**)Realloc(rawstruct->lengthto, | |
751 | rawstruct->lengthto_num*sizeof(*(rawstruct->lengthto))); | |
752 | rawstruct->lengthto[rawstruct->lengthto_num - 1] = $3; | |
753 | } | |
754 | ; | |
755 | ||
756 | XRecordFieldRef : XIdentifier | |
757 | { $$ = $1; }; | |
758 | ||
759 | XStructFieldRefOrEmpty : /* Empty */ | |
760 | { $$ = NULL;} | |
761 | | XStructFieldRef | |
762 | { $$ = $1; }; | |
763 | ||
764 | XStructFieldRef : XIdentifier | |
765 | { $$ = (rawAST_field_list*)Malloc(sizeof(*$$)); | |
766 | $$->nElements=1; | |
767 | $$->names = (Common::Identifier**)Malloc(sizeof(*($$->names))); | |
768 | $$->names[0] = $1; | |
769 | } | |
770 | | XStructFieldRef '.' XIdentifier | |
771 | { $$ = $1; | |
772 | $$->nElements++; | |
773 | $$->names = (Common::Identifier**) | |
774 | Realloc($$->names, $$->nElements*sizeof(*($$->names))); | |
775 | $$->names[$$->nElements - 1] = $3; | |
776 | } | |
777 | ; | |
778 | ||
779 | XRvalue: XIdentifier{ | |
780 | $$.value = mcopystr($1->get_name().c_str()); | |
781 | $$.v_value = new Common::Value(Common::Value::V_UNDEF_LOWERID, $1); | |
782 | $$.v_value->set_location(infile, @$); | |
783 | } | |
784 | | XBstring{ | |
785 | string *str= new string($1); | |
786 | $$.value=mprintf(" %s", mymod->add_bitstring_literal(*str).c_str()); | |
787 | $$.v_value=new Common::Value(Common::Value::V_BSTR,str); | |
788 | $$.v_value->set_location(infile, @$); | |
789 | Free($1); | |
790 | } | |
791 | | XHstring{ | |
792 | string *str= new string($1); | |
793 | $$.value=mprintf(" %s", mymod->add_hexstring_literal(*str).c_str()); | |
794 | $$.v_value=new Common::Value(Common::Value::V_HSTR,str); | |
795 | $$.v_value->set_location(infile, @$); | |
796 | Free($1); | |
797 | } | |
798 | ||
799 | | XOstring{ | |
800 | string *str= new string($1); | |
801 | $$.value=mprintf(" %s", mymod->add_octetstring_literal(*str).c_str()); | |
802 | $$.v_value=new Common::Value(Common::Value::V_OSTR,str); | |
803 | $$.v_value->set_location(infile, @$); | |
804 | Free($1); | |
805 | } | |
806 | | XCstring{ | |
807 | Common::Location loc(infile, @$); | |
808 | string *str = parse_charstring_value($1, loc); | |
809 | Free($1); | |
810 | $$.value=mprintf(" %s", mymod->add_charstring_literal(*str).c_str()); | |
811 | $$.v_value=new Common::Value(Common::Value::V_CSTR,str); | |
812 | $$.v_value->set_location(loc); | |
813 | } | |
814 | | XFloatValue{ | |
815 | $$.value=mcopystr(Common::Real2code($1).c_str()); | |
816 | $$.v_value=new Common::Value(Common::Value::V_REAL, $1); | |
817 | $$.v_value->set_location(infile, @$); | |
818 | } | |
819 | | XNumber{ | |
820 | $$.value = mcopystr(Common::Int2string($1).c_str()); | |
821 | $$.v_value=new Common::Value(Common::Value::V_INT, $1); | |
822 | $$.v_value->set_location(infile, @$); | |
823 | } | |
824 | | XBooleanConst | |
825 | { | |
826 | $$.value = mcopystr($1 ? "TRUE" : "FALSE"); | |
827 | $$.v_value=new Common::Value(Common::Value::V_BOOL, $1); | |
828 | $$.v_value->set_location(infile, @$); | |
829 | } | |
830 | | XVerdictConst | |
831 | { | |
832 | $$.v_value = new Common::Value(Common::Value::V_VERDICT, $1); | |
833 | $$.v_value->set_location(infile, @$); | |
834 | $$.value = mcopystr($$.v_value->get_single_expr().c_str()); | |
835 | } | |
836 | | XNullKeyword | |
837 | { | |
838 | $$.value = mcopystr("NULL_COMPREF"); | |
839 | $$.v_value = new Common::Value(Common::Value::V_TTCN3_NULL); | |
840 | $$.v_value->set_location(infile, @$); | |
841 | } | |
842 | | XNULLKeyword | |
843 | { | |
844 | $$.value = mcopystr("ASN_NULL_VALUE"); | |
845 | $$.v_value = new Common::Value(Common::Value::V_NULL); | |
846 | $$.v_value->set_location(infile, @$); | |
847 | } | |
848 | | XOmitKeyword | |
849 | { | |
850 | $$.value = mcopystr("OMIT_VALUE"); | |
851 | $$.v_value = new Common::Value(Common::Value::V_OMIT); | |
852 | $$.v_value->set_location(infile, @$); | |
853 | } | |
854 | ; | |
855 | ||
51fa56b9 | 856 | /* Alternative RAW attributes for types defined in annex E of the TTCN-3 standard */ |
857 | XBitDef: | |
858 | XNumber XBitKeyword | |
859 | { | |
860 | rawstruct->fieldlength = $1; | |
861 | rawstruct->comp = XDEFSIGNBIT; | |
862 | rawstruct->byteorder = XDEFLAST; | |
863 | } | |
864 | | XUnsignedKeyword XNumber XBitKeyword | |
865 | { | |
866 | rawstruct->fieldlength = $2; | |
867 | rawstruct->comp = XDEFUNSIGNED; | |
868 | rawstruct->byteorder = XDEFLAST; | |
869 | } | |
870 | ; | |
871 | ||
970ed795 EL |
872 | /* Text encoder */ |
873 | XBeginDef: | |
874 | XBeginKeyword '(' XEncodeToken ')' { | |
875 | if(textstruct->begin_val==NULL){ | |
876 | textstruct->begin_val=(textAST_matching_values*) | |
877 | Malloc(sizeof(textAST_matching_values)); | |
878 | init_textAST_matching_values(textstruct->begin_val); | |
879 | } | |
880 | Free(textstruct->begin_val->encode_token); | |
881 | textstruct->begin_val->encode_token=$3; | |
882 | } | |
883 | | XBeginKeyword '(' XEncodeToken ',' XmatchDef ')' { | |
884 | if(textstruct->begin_val==NULL){ | |
885 | textstruct->begin_val=(textAST_matching_values*) | |
886 | Malloc(sizeof(textAST_matching_values)); | |
887 | init_textAST_matching_values(textstruct->begin_val); | |
888 | } | |
889 | Free(textstruct->begin_val->encode_token); | |
890 | textstruct->begin_val->encode_token=$3; | |
891 | if($5){ | |
892 | Free(textstruct->begin_val->decode_token); | |
893 | textstruct->begin_val->decode_token=$5; | |
894 | } | |
895 | } | |
896 | | XBeginKeyword '(' XEncodeToken ',' XmatchDef ',' XmodifierDef ')'{ | |
897 | if(textstruct->begin_val==NULL){ | |
898 | textstruct->begin_val=(textAST_matching_values*) | |
899 | Malloc(sizeof(textAST_matching_values)); | |
900 | init_textAST_matching_values(textstruct->begin_val); | |
901 | } | |
902 | Free(textstruct->begin_val->encode_token); | |
903 | textstruct->begin_val->encode_token=$3; | |
904 | if($5){ | |
905 | Free(textstruct->begin_val->decode_token); | |
906 | textstruct->begin_val->decode_token=$5; | |
907 | } | |
908 | textstruct->begin_val->case_sensitive=$7; | |
909 | } | |
910 | ; | |
911 | ||
912 | XEndDef: | |
913 | XEndKeyword '(' XEncodeToken ')' { | |
914 | if(textstruct->end_val==NULL){ | |
915 | textstruct->end_val=(textAST_matching_values*) | |
916 | Malloc(sizeof(textAST_matching_values)); | |
917 | init_textAST_matching_values(textstruct->end_val); | |
918 | } | |
919 | Free(textstruct->end_val->encode_token); | |
920 | textstruct->end_val->encode_token=$3; | |
921 | } | |
922 | | XEndKeyword '(' XEncodeToken ',' XmatchDef ')'{ | |
923 | if(textstruct->end_val==NULL){ | |
924 | textstruct->end_val=(textAST_matching_values*) | |
925 | Malloc(sizeof(textAST_matching_values)); | |
926 | init_textAST_matching_values(textstruct->end_val); | |
927 | } | |
928 | Free(textstruct->end_val->encode_token); | |
929 | textstruct->end_val->encode_token=$3; | |
930 | if($5){ | |
931 | Free(textstruct->end_val->decode_token); | |
932 | textstruct->end_val->decode_token=$5; | |
933 | } | |
934 | } | |
935 | | XEndKeyword '(' XEncodeToken ',' XmatchDef ',' XmodifierDef ')'{ | |
936 | if(textstruct->end_val==NULL){ | |
937 | textstruct->end_val=(textAST_matching_values*) | |
938 | Malloc(sizeof(textAST_matching_values)); | |
939 | init_textAST_matching_values(textstruct->end_val); | |
940 | } | |
941 | Free(textstruct->end_val->encode_token); | |
942 | textstruct->end_val->encode_token=$3; | |
943 | if($5){ | |
944 | Free(textstruct->end_val->decode_token); | |
945 | textstruct->end_val->decode_token=$5; | |
946 | } | |
947 | textstruct->end_val->case_sensitive=$7; | |
948 | } | |
949 | ; | |
950 | ||
951 | XSeparatorDef: | |
952 | XSeparatorKeyword '(' XEncodeToken ')'{ | |
953 | if(textstruct->separator_val==NULL){ | |
954 | textstruct->separator_val=(textAST_matching_values*) | |
955 | Malloc(sizeof(textAST_matching_values)); | |
956 | init_textAST_matching_values(textstruct->separator_val); | |
957 | } | |
958 | Free(textstruct->separator_val->encode_token); | |
959 | textstruct->separator_val->encode_token=$3; | |
960 | } | |
961 | | XSeparatorKeyword '(' XEncodeToken ',' XmatchDef ')'{ | |
962 | if(textstruct->separator_val==NULL){ | |
963 | textstruct->separator_val=(textAST_matching_values*) | |
964 | Malloc(sizeof(textAST_matching_values)); | |
965 | init_textAST_matching_values(textstruct->separator_val); | |
966 | } | |
967 | Free(textstruct->separator_val->encode_token); | |
968 | textstruct->separator_val->encode_token=$3; | |
969 | if($5){ | |
970 | Free(textstruct->separator_val->decode_token); | |
971 | textstruct->separator_val->decode_token=$5; | |
972 | } | |
973 | } | |
974 | | XSeparatorKeyword '(' XEncodeToken ',' XmatchDef ',' XmodifierDef ')'{ | |
975 | if(textstruct->separator_val==NULL){ | |
976 | textstruct->separator_val=(textAST_matching_values*) | |
977 | Malloc(sizeof(textAST_matching_values)); | |
978 | init_textAST_matching_values(textstruct->separator_val); | |
979 | } | |
980 | Free(textstruct->separator_val->encode_token); | |
981 | textstruct->separator_val->encode_token=$3; | |
982 | if($5){ | |
983 | Free(textstruct->separator_val->decode_token); | |
984 | textstruct->separator_val->decode_token=$5; | |
985 | } | |
986 | textstruct->separator_val->case_sensitive=$7; | |
987 | } | |
988 | ; | |
989 | ||
990 | XCodingDef: | |
991 | XCodingKeyword '(' XCodingRule ')' | |
992 | { } | |
993 | | XCodingKeyword '(' XCodingRule ',' XDecodingRule ')' | |
994 | { } | |
995 | | XCodingKeyword '(' XCodingRule ',' XDecodingRule ',' XmatchDef ')' { | |
996 | Free(textstruct->decode_token); | |
997 | textstruct->decode_token=$7; | |
998 | } | |
999 | | XCodingKeyword '(' XCodingRule ',' XDecodingRule ',' XmatchDef ',' | |
1000 | XmodifierDef ')' { | |
1001 | if($7){ | |
1002 | Free(textstruct->decode_token); | |
1003 | textstruct->decode_token=$7; | |
1004 | } | |
1005 | textstruct->case_sensitive=$9; | |
1006 | } | |
1007 | ; | |
1008 | ||
1009 | XCodingRule: | |
1010 | /* empty */ {} | |
1011 | | Xattrlistenc {} | |
1012 | | XtokendefList {} | |
1013 | ; | |
1014 | ||
1015 | XDecodingRule: | |
1016 | /* empty */ {} | |
1017 | | XattrList {} | |
1018 | | XDecodingtokendefList {} | |
1019 | ; | |
1020 | ||
1021 | XattrList: | |
1022 | Xattr {} | |
1023 | | XattrList ';' Xattr {} | |
1024 | ; | |
1025 | ||
1026 | Xattr: | |
1027 | XLengthToken '=' XNumber { | |
1028 | textstruct->decoding_params.min_length=$3; | |
1029 | } | |
1030 | | XLengthToken '=' XNumber '-' XNumber { | |
1031 | textstruct->decoding_params.min_length=$3; | |
1032 | textstruct->decoding_params.max_length=$5; | |
1033 | } | |
1034 | | XConvertToken '=' XLowerToken { | |
1035 | textstruct->decoding_params.convert=-1; | |
1036 | } | |
1037 | | XConvertToken '=' XUpperToken { | |
1038 | textstruct->decoding_params.convert=1; | |
1039 | } | |
1040 | | XJustToken '=' XLeftToken { | |
1041 | textstruct->decoding_params.just=-1; | |
1042 | } | |
1043 | | XJustToken '=' XRightToken { | |
1044 | textstruct->decoding_params.just=1; | |
1045 | } | |
1046 | | XJustToken '=' XCenterToken { | |
1047 | textstruct->decoding_params.just=0; | |
1048 | } | |
1049 | | XLeadingToken '=' XTrueToken { | |
1050 | textstruct->decoding_params.leading_zero=true; | |
1051 | } | |
1052 | | XLeadingToken '=' XFalseToken { | |
1053 | textstruct->decoding_params.leading_zero=false; | |
1054 | } | |
1055 | | XRepeatToken '=' XTrueToken { | |
1056 | textstruct->decoding_params.repeatable=true; | |
1057 | } | |
1058 | | XRepeatToken '=' XFalseToken { | |
1059 | textstruct->decoding_params.repeatable=false; | |
1060 | }; | |
1061 | ||
1062 | Xattrlistenc: | |
1063 | Xattrenc {} | |
1064 | | Xattrlistenc ';' Xattrenc {} | |
1065 | ; | |
1066 | ||
1067 | Xattrenc: | |
1068 | XLengthToken '=' XNumber { | |
1069 | textstruct->coding_params.min_length=$3; | |
1070 | textstruct->decoding_params.min_length=$3; | |
1071 | } | |
1072 | | XLengthToken '=' XNumber '-' XNumber { | |
1073 | textstruct->coding_params.min_length=$3; | |
1074 | textstruct->coding_params.max_length=$5; | |
1075 | textstruct->decoding_params.min_length=$3; | |
1076 | textstruct->decoding_params.max_length=$5; | |
1077 | } | |
1078 | | XConvertToken '=' XLowerToken { | |
1079 | textstruct->coding_params.convert=-1; | |
1080 | textstruct->decoding_params.convert=-1; | |
1081 | } | |
1082 | | XConvertToken '=' XUpperToken { | |
1083 | textstruct->coding_params.convert=1; | |
1084 | textstruct->decoding_params.convert=1; | |
1085 | } | |
1086 | | XJustToken '=' XLeftToken { | |
1087 | textstruct->coding_params.just=-1; | |
1088 | textstruct->decoding_params.just=-1; | |
1089 | } | |
1090 | | XJustToken '=' XRightToken { | |
1091 | textstruct->coding_params.just=1; | |
1092 | textstruct->decoding_params.just=1; | |
1093 | } | |
1094 | | XJustToken '=' XCenterToken { | |
1095 | textstruct->coding_params.just=0; | |
1096 | textstruct->decoding_params.just=0; | |
1097 | } | |
1098 | | XLeadingToken '=' XTrueToken { | |
1099 | textstruct->coding_params.leading_zero=true; | |
1100 | textstruct->decoding_params.leading_zero=true; | |
1101 | } | |
1102 | | XLeadingToken '=' XFalseToken { | |
1103 | textstruct->coding_params.leading_zero=false; | |
1104 | textstruct->decoding_params.leading_zero=false; | |
1105 | } | |
1106 | | XRepeatToken '=' XTrueToken { | |
1107 | textstruct->coding_params.repeatable=true; | |
1108 | textstruct->decoding_params.repeatable=true; | |
1109 | } | |
1110 | | XRepeatToken '=' XFalseToken { | |
1111 | textstruct->coding_params.repeatable=false; | |
1112 | textstruct->decoding_params.repeatable=false; | |
1113 | }; | |
1114 | ||
1115 | ||
1116 | XtokendefList: | |
1117 | Xtokendef {} | |
1118 | | XtokendefList ';' Xtokendef {} | |
1119 | ; | |
1120 | ||
1121 | Xtokendef: | |
1122 | XIdentifierOrReserved ':' XEncodeToken | |
1123 | { | |
1124 | int idx = textstruct->get_field_param_index($1); | |
1125 | if (textstruct->field_params[idx]->value.encode_token) { | |
1126 | Free(textstruct->field_params[idx]->value.encode_token); | |
1127 | Common::Location loc(infile, @3); | |
1128 | loc.error("Duplicate encode token for value `%s'", | |
1129 | $1->get_dispname().c_str()); | |
1130 | } | |
1131 | textstruct->field_params[idx]->value.encode_token = $3; | |
1132 | delete $1; | |
1133 | } | |
1134 | | XTrueToken ':' XEncodeToken | |
1135 | { | |
1136 | if (textstruct->true_params == NULL) { | |
1137 | textstruct->true_params = (textAST_matching_values*) | |
1138 | Malloc(sizeof(textAST_matching_values)); | |
1139 | textstruct->true_params->encode_token = $3; | |
1140 | textstruct->true_params->decode_token = NULL; | |
1141 | textstruct->true_params->case_sensitive = true; | |
1142 | textstruct->true_params->generated_decode_token = false; | |
1143 | } else { | |
1144 | if (textstruct->true_params->encode_token) { | |
1145 | Free(textstruct->true_params->encode_token); | |
1146 | Common::Location loc(infile, @3); | |
1147 | loc.error("Duplicate encode token for true value"); | |
1148 | } | |
1149 | textstruct->true_params->encode_token = $3; | |
1150 | } | |
1151 | } | |
1152 | | XFalseToken ':' XEncodeToken | |
1153 | { | |
1154 | if (textstruct->false_params == NULL) { | |
1155 | textstruct->false_params = (textAST_matching_values*) | |
1156 | Malloc(sizeof(textAST_matching_values)); | |
1157 | textstruct->false_params->encode_token = $3; | |
1158 | textstruct->false_params->decode_token = NULL; | |
1159 | textstruct->false_params->case_sensitive = true; | |
1160 | textstruct->false_params->generated_decode_token = false; | |
1161 | } else { | |
1162 | if (textstruct->false_params->encode_token) { | |
1163 | Free(textstruct->false_params->encode_token); | |
1164 | Common::Location loc(infile, @3); | |
1165 | loc.error("Duplicate encode token for false value"); | |
1166 | } | |
1167 | textstruct->false_params->encode_token = $3; | |
1168 | } | |
1169 | } | |
1170 | ; | |
1171 | ||
1172 | XIdentifierOrReserved: | |
1173 | XIdentifier { $$ = $1; } | |
1174 | | XTextReservedWord | |
1175 | { $$ = new Common::Identifier(Common::Identifier::ID_TTCN, string($1)); } | |
1176 | ; | |
1177 | ||
1178 | XTextReservedWord: | |
1179 | XLengthToken { $$ = "length"; } | |
1180 | | XRepeatToken { $$ = "repeatable"; } | |
1181 | | XConvertToken { $$ = "convert"; } | |
1182 | | XLowerToken { $$ = "lower_case"; } | |
1183 | | XUpperToken { $$ = "upper_case"; } | |
1184 | | XJustToken { $$ = "just"; } | |
1185 | | XLeftToken { $$ = "left"; } | |
1186 | | XRightToken { $$ = "right"; } | |
1187 | | XCenterToken { $$ = "center"; } | |
1188 | | XLeadingToken { $$ = "leading0"; } | |
1189 | | XSensitivToken { $$ = "case_sensitive"; } | |
1190 | | XInSensitivToken { $$ = "case_insensitive"; } | |
1191 | ; | |
1192 | ||
1193 | XDecodingtokendefList: | |
1194 | Xdecodingtokendef {} | |
1195 | | XDecodingtokendefList ';' Xdecodingtokendef {} | |
1196 | ; | |
1197 | ||
1198 | Xdecodingtokendef: | |
1199 | XIdentifierOrReserved ':' XDecodeToken | |
1200 | { | |
1201 | int idx = textstruct->get_field_param_index($1); | |
1202 | if (textstruct->field_params[idx]->value.decode_token) { | |
1203 | Free(textstruct->field_params[idx]->value.decode_token); | |
1204 | Common::Location loc(infile, @3); | |
1205 | loc.error("Duplicate decode token for value `%s'", | |
1206 | $1->get_dispname().c_str()); | |
1207 | } | |
1208 | textstruct->field_params[idx]->value.decode_token = $3.token; | |
1209 | textstruct->field_params[idx]->value.case_sensitive = $3.case_sensitive; | |
1210 | delete $1; | |
1211 | } | |
1212 | | XTrueToken ':' XDecodeToken | |
1213 | { | |
1214 | if (textstruct->true_params == NULL) { | |
1215 | textstruct->true_params = (textAST_matching_values*) | |
1216 | Malloc(sizeof(textAST_matching_values)); | |
1217 | textstruct->true_params->encode_token = NULL; | |
1218 | textstruct->true_params->decode_token = $3.token; | |
1219 | textstruct->true_params->case_sensitive = $3.case_sensitive; | |
1220 | textstruct->true_params->generated_decode_token = false; | |
1221 | } else { | |
1222 | if (textstruct->true_params->decode_token) { | |
1223 | Free(textstruct->true_params->decode_token); | |
1224 | Common::Location loc(infile, @3); | |
1225 | loc.error("Duplicate decode token for true value"); | |
1226 | } | |
1227 | textstruct->true_params->decode_token = $3.token; | |
1228 | textstruct->true_params->case_sensitive = $3.case_sensitive; | |
1229 | } | |
1230 | } | |
1231 | | XFalseToken ':' XDecodeToken | |
1232 | { | |
1233 | if (textstruct->false_params == NULL) { | |
1234 | textstruct->false_params = (textAST_matching_values*) | |
1235 | Malloc(sizeof(textAST_matching_values)); | |
1236 | textstruct->false_params->encode_token = NULL; | |
1237 | textstruct->false_params->decode_token= $3.token; | |
1238 | textstruct->false_params->case_sensitive = $3.case_sensitive; | |
1239 | textstruct->false_params->generated_decode_token = false; | |
1240 | } else { | |
1241 | if (textstruct->false_params->decode_token) { | |
1242 | Free(textstruct->false_params->decode_token); | |
1243 | Common::Location loc(infile, @3); | |
1244 | loc.error("Duplicate decode token for false value"); | |
1245 | } | |
1246 | textstruct->false_params->decode_token = $3.token; | |
1247 | textstruct->false_params->case_sensitive = $3.case_sensitive; | |
1248 | } | |
1249 | } | |
1250 | ; | |
1251 | ||
1252 | XEncodeToken: | |
1253 | Xtoken | |
1254 | { | |
1255 | Common::Location loc(infile, @$); | |
1256 | string *str = parse_charstring_value($1, loc); | |
1257 | Free($1); | |
1258 | $$ = mcopystr(str->c_str()); | |
1259 | delete str; | |
1260 | } | |
1261 | ; | |
1262 | ||
1263 | XDecodeToken: | |
1264 | Xtoken | |
1265 | { | |
1266 | $$.token = $1; | |
1267 | $$.case_sensitive = true; | |
1268 | } | |
1269 | | '{' Xtoken '}' | |
1270 | { | |
1271 | $$.token = $2; | |
1272 | $$.case_sensitive = true; | |
1273 | } | |
1274 | | '{' XmatchDef ',' XmodifierDef '}' | |
1275 | { | |
1276 | $$.token = $2; | |
1277 | $$.case_sensitive = $4; | |
1278 | } | |
1279 | ; | |
1280 | ||
1281 | XmatchDef: | |
1282 | /* empty */ { $$ = NULL; } | |
1283 | | Xtoken { $$ = $1; } | |
1284 | ; | |
1285 | ||
1286 | XmodifierDef: | |
1287 | /* empty */ { $$ = true; } | |
1288 | | XSensitivToken { $$ = true; } | |
1289 | | XInSensitivToken { $$ = false; } | |
1290 | ; | |
1291 | ||
1292 | /********** XERSTUFF "raw" attributes */ | |
1293 | ||
1294 | XERattributes: /* a non-empty list */ | |
1295 | XERattribute { xer_f = true; } | |
1296 | ; | |
1297 | ||
1298 | XERattribute: | |
51fa56b9 | 1299 | XKWabstract { xerstruct->abstract_ = true; } |
1300 | | anyAttributes { FreeNamespaceRestriction(xerstruct->anyAttributes_); xerstruct->anyAttributes_ = $1; } | |
970ed795 EL |
1301 | | anyElement { FreeNamespaceRestriction(xerstruct->anyElement_); xerstruct->anyElement_ = $1; } |
1302 | | XKWattribute { xerstruct->attribute_ = true; } | |
1303 | | XKWattributeFormQualified { xerstruct->form_ |= XerAttributes::ATTRIBUTE_DEFAULT_QUALIFIED; } | |
51fa56b9 | 1304 | | XKWblock { xerstruct->block_ = true; } |
970ed795 EL |
1305 | | controlNamespace /* directly on the module */ |
1306 | { | |
1307 | mymod->set_controlns($1.uri, $1.prefix); | |
1308 | } | |
1309 | | defaultForEmpty { xerstruct->defaultForEmpty_ = $1; } | |
1310 | | XKWelement { xerstruct->element_ = true; } | |
1311 | | XKWelementFormQualified { xerstruct->form_ |= XerAttributes::ELEMENT_DEFAULT_QUALIFIED; } | |
1312 | | XKWembedValues { xerstruct->embedValues_ = true; } | |
1313 | | form { xerstruct->form_ |= $1; } | |
1314 | | XKWlist { xerstruct->list_ = true; } | |
1315 | | name | |
1316 | { /* overwrites any previous name */ | |
1317 | switch (xerstruct->name_.kw_) { | |
1318 | case NamespaceSpecification::NO_MANGLING: | |
1319 | case NamespaceSpecification::CAPITALIZED: | |
1320 | case NamespaceSpecification::UNCAPITALIZED: | |
1321 | case NamespaceSpecification::UPPERCASED: | |
1322 | case NamespaceSpecification::LOWERCASED: | |
1323 | break; // nothing to do | |
1324 | default: // real string, must be freed | |
1325 | Free(xerstruct->name_.nn_); | |
1326 | } | |
1327 | xerstruct->name_.nn_ = $1; | |
1328 | } | |
1329 | | namespace | |
1330 | { /* overwrites any previous namespace */ | |
1331 | Free(xerstruct->namespace_.uri); | |
1332 | Free(xerstruct->namespace_.prefix); | |
1333 | xerstruct->namespace_ = $1; | |
1334 | } | |
1335 | | text | |
1336 | { | |
1337 | xerstruct->text_ = (NamespaceSpecification *)Realloc(xerstruct->text_, | |
1338 | ++xerstruct->num_text_ * sizeof(NamespaceSpecification)); | |
1339 | xerstruct->text_[xerstruct->num_text_-1] = $1; | |
1340 | } | |
1341 | | XKWuntagged { xerstruct->untagged_ = true; } | |
1342 | | XKWuseNil { xerstruct->useNil_ = true; } | |
1343 | | XKWuseNumber { xerstruct->useNumber_ = true; } | |
1344 | | XKWuseOrder { xerstruct->useOrder_ = true; } | |
1345 | | XKWuseUnion { xerstruct->useUnion_ = true; } | |
1346 | | XKWuseType { xerstruct->useType_ = true; } | |
1347 | | whiteSpace | |
1348 | { | |
1349 | xerstruct->whitespace_ = static_cast<XerAttributes::WhitespaceAction>($1); | |
1350 | } | |
1351 | | XSD ':' xsddata {} | |
1352 | ; | |
1353 | ||
1354 | anyAttributes: | |
1355 | XKWanyAttributes optNamespaceRestriction | |
1356 | { $$ = $2; } | |
1357 | ; | |
1358 | ||
1359 | anyElement: | |
1360 | XKWanyElement optNamespaceRestriction | |
1361 | { $$ = $2; } | |
1362 | ; | |
1363 | ||
1364 | optNamespaceRestriction: | |
1365 | /* empty */ { | |
1366 | $$.nElements_ = 0; $$.uris_ = 0; $$.type_ = NamespaceRestriction::NOTHING; | |
1367 | } | |
1368 | | XKWfrom urilist { $$ = $2; $$.type_ = NamespaceRestriction::FROM; } | |
1369 | | XKWexcept urilist { $$ = $2; $$.type_ = NamespaceRestriction::EXCEPT; } | |
1370 | ; | |
1371 | ||
1372 | urilist: /* a non-empty list */ | |
1373 | quotedURIorAbsent { | |
1374 | $$.nElements_ = 1; | |
1375 | $$.uris_ = (char**)Malloc(sizeof($$.uris_[0])); | |
1376 | $$.uris_[0] = $1; | |
1377 | } | |
1378 | | urilist ',' quotedURIorAbsent | |
1379 | { | |
1380 | $$ = $1; | |
1381 | $$.uris_ = (char**)Realloc($$.uris_, ++$$.nElements_ * sizeof($$.uris_[0])); | |
1382 | $$.uris_[$$.nElements_-1] = $3; | |
1383 | } | |
1384 | ; | |
1385 | ||
1386 | quotedURIorAbsent: | |
1387 | Xstring /* as quotedURI */ | |
1388 | | XKWunqualified { $$ = NULL; } | |
1389 | ; | |
1390 | ||
1391 | controlNamespace: /* nsspec */ | |
1392 | XKWcontrolNamespace Xstring /* <-- as the QuotedURI */ XKWprefix Xstring | |
1393 | /* Prefix is required by TTCN-3; it is optional in the ASN.1 standard | |
1394 | * but the OSS ASN.1 compiler seems to require it anyway */ | |
1395 | { | |
1396 | $$.uri = $2; | |
1397 | $$.prefix = $4; | |
1398 | } | |
1399 | ; | |
1400 | ||
1401 | ||
1402 | form: | |
1403 | XKWform XKWas XKWunqualified { $$ = XerAttributes::UNQUALIFIED; } | |
1404 | | XKWform XKWas XKWqualified { $$ = XerAttributes::QUALIFIED; } | |
1405 | ||
1406 | ||
1407 | name: | |
1408 | XKWname XKWas newnameOrKeyword { $$ = $3; } | |
1409 | ; | |
1410 | ||
1411 | newnameOrKeyword: keyword | |
1412 | | Xstring { $$ = $1; } | |
1413 | ; | |
1414 | ||
1415 | keyword: | |
1416 | XKWcapitalized { $$ = (char*)NamespaceSpecification::CAPITALIZED; } | |
1417 | | XKWuncapitalized { $$ = (char*)NamespaceSpecification::UNCAPITALIZED; } | |
1418 | | XKWlowercased { $$ = (char*)NamespaceSpecification::LOWERCASED; } | |
1419 | | XKWuppercased { $$ = (char*)NamespaceSpecification::UPPERCASED; } | |
1420 | ; | |
1421 | ||
1422 | namespace: | |
1423 | XKWnamespace namespacespecification | |
1424 | { $$ = $2; } | |
1425 | ; | |
1426 | ||
1427 | namespacespecification: | |
1428 | XKWas | |
1429 | Xstring /* as QuotedURI, required */ | |
1430 | optPrefix | |
1431 | { | |
1432 | if (*$2) { | |
1433 | $$.uri = $2; $$.prefix = $3; | |
1434 | } | |
1435 | else { /* URI is empty */ | |
1436 | if (*$3) { /* prefix not empty, error */ | |
1437 | Common::Location loc(infile, @2); | |
1438 | loc.error("Empty string is not a valid URI"); | |
1439 | } | |
1440 | else { | |
1441 | /* Both are empty strings, use one of the non-string values | |
1442 | * to signal "override and remove any namespace" */ | |
1443 | Free($2); | |
1444 | Free($3); | |
1445 | $$.keyword = NamespaceSpecification::UNCAPITALIZED; | |
1446 | $$.prefix = NULL; | |
1447 | } | |
1448 | } | |
1449 | } | |
1450 | ; | |
1451 | ||
1452 | optPrefix: /* empty */ { $$ = memptystr(); } | |
1453 | | XKWprefix Xstring | |
1454 | { $$ = $2; } | |
1455 | ; | |
1456 | ||
1457 | text: | |
1458 | XKWtext Xstring XKWas newnameOrKeyword | |
1459 | { $$.uri = $4; $$.prefix = $2; } | |
1460 | | XKWtext XKWall XKWas newnameOrKeyword | |
1461 | { $$.uri = $4; $$.prefix = (char*)NamespaceSpecification::ALL; } | |
1462 | | XKWtext | |
1463 | { $$.uri = 0; $$.prefix = 0; } | |
1464 | /* "text as <something>" is not allowed */ | |
1465 | ; | |
1466 | ||
1467 | defaultForEmpty: | |
1468 | XKWdefaultForEmpty XKWas Xstring | |
1469 | { $$ = $3; } | |
1470 | ; | |
1471 | ||
1472 | ||
1473 | ||
1474 | whiteSpace: | |
1475 | XKWwhiteSpace XKWpreserve { $$ = XerAttributes::PRESERVE; } | |
1476 | | XKWwhiteSpace XKWreplace { $$ = XerAttributes::REPLACE; } | |
1477 | | XKWwhiteSpace XKWcollapse { $$ = XerAttributes::COLLAPSE; } | |
1478 | ; | |
1479 | ||
1480 | xsddata: /* XSD:something */ | |
1481 | XSDbase64Binary { | |
1482 | xerstruct->base64_ = true; | |
1483 | } | |
1484 | | XSDdecimal { | |
1485 | xerstruct->decimal_ = true; | |
1486 | } | |
1487 | | XSDhexBinary { | |
1488 | xerstruct->hex_ = true; | |
1489 | } | |
1490 | | XSDQName { | |
1491 | xerstruct->useQName_ = true; | |
1492 | } | |
1493 | /* everything below is recognized and ignored */ | |
1494 | | XKWshort {} | |
1495 | | XKWlong {} | |
1496 | | XSDstring {} | |
1497 | | XSDnormalizedString {} | |
1498 | | XSDtoken {} | |
1499 | | XSDName {} | |
1500 | | XSDNMTOKEN {} | |
1501 | | XSDNCName {} | |
1502 | | XSDID {} | |
1503 | | XSDIDREF {} | |
1504 | | XSDENTITY {} | |
1505 | | XSDanyURI {} | |
1506 | | XSDlanguage {} | |
1507 | /* TODO apply subtype to the types below */ | |
1508 | | XSDinteger {} | |
1509 | | XSDpositiveInteger {} | |
1510 | | XSDnonPositiveInteger {} | |
1511 | | XSDnegativeInteger {} | |
1512 | | XSDnonNegativeInteger {} | |
1513 | | XSDunsignedLong {} | |
1514 | | XSDint {} | |
1515 | | XSDunsignedInt {} | |
1516 | | XSDunsignedShort {} | |
1517 | | XSDbyte {} | |
1518 | | XSDunsignedByte {} | |
1519 | | XSDfloat {} | |
1520 | | XSDdouble {} | |
1521 | | XSDduration {} | |
1522 | | XSDdateTime {} | |
1523 | | XSDtime {} | |
1524 | | XSDdate {} | |
1525 | | XSDgYearMonth {} | |
1526 | | XSDgYear {} | |
1527 | | XSDgMonthDay {} | |
1528 | | XSDgDay {} | |
1529 | | XSDgMonth {} | |
1530 | | XSDNMTOKENS {} | |
1531 | | XSDIDREFS {} | |
1532 | | XSDENTITIES {} | |
1533 | | XSDboolean {} | |
1534 | ||
1535 | | XSDanySimpleType {} | |
1536 | | XSDanyType {} | |
1537 | ||
1538 | ; | |
1539 | ||
1540 | // JSON encoder | |
1541 | XJsonDef: | |
3abe9331 | 1542 | XOptSpaces XKWjson XOptSpaces ':' XOptSpaces XJsonAttribute XOptSpaces |
970ed795 EL |
1543 | ; |
1544 | ||
1545 | XJsonAttribute: | |
1546 | XOmitAsNull | |
1547 | | XNameAs | |
1548 | | XAsValue | |
1549 | | XDefault | |
3abe9331 | 1550 | | XExtend |
1551 | | XMetainfoForUnbound | |
970ed795 EL |
1552 | ; |
1553 | ||
1554 | XOmitAsNull: | |
1555 | XKWomit XSpaces XKWas XSpaces XKWnull { jsonstruct->omit_as_null = true; } | |
1556 | ; | |
1557 | ||
1558 | XNameAs: | |
feade998 | 1559 | XKWname XSpaces XKWas XSpaces XJsonAlias { jsonstruct->alias = mcopystr($5); } |
970ed795 EL |
1560 | ; |
1561 | ||
feade998 | 1562 | XJsonAlias: // include all keywords, so they can be used as aliases for fields, too |
1563 | XAliasToken { $$ = $1; } | |
1564 | | XKWomit { $$ = "omit"; } | |
1565 | | XKWas { $$ = "as"; } | |
1566 | | XKWnull { $$ = "null"; } | |
1567 | | XKWname { $$ = "name"; } | |
1568 | | XKWvalue { $$ = "value"; } | |
1569 | | XKWdefault { $$ = "default"; } | |
1570 | | XKWextend { $$ = "extend"; } | |
1571 | | XKWmetainfo { $$ = "metainfo"; } | |
1572 | | XKWfor { $$ = "for"; } | |
1573 | | XKWunbound { $$ = "unbound"; } | |
1574 | ||
970ed795 EL |
1575 | XAsValue: |
1576 | XKWas XSpaces XKWvalue { jsonstruct->as_value = true; } | |
1577 | ; | |
1578 | ||
1579 | XDefault: | |
3abe9331 | 1580 | XKWdefault XOptSpaces XJsonValue { jsonstruct->default_value = mcopystr($3); } |
1581 | ; | |
1582 | ||
1583 | XExtend: | |
1584 | XKWextend XOptSpaces XJsonValue XOptSpaces ':' XOptSpaces XJsonValue | |
1585 | { jsonstruct->schema_extensions.add(new JsonSchemaExtension($3, $7)); } | |
970ed795 EL |
1586 | ; |
1587 | ||
1588 | XJsonValue: | |
3abe9331 | 1589 | XJsonValueStart XJsonValueCore XJsonValueEnd { $$ = mcopystr($2); } |
1590 | | XJsonValueStart XJsonValueEnd { $$ = mcopystr(""); } | |
1591 | ; | |
1592 | ||
1593 | XJsonValueCore: | |
1594 | XJsonValueCore XJsonValueSegment { $$ = mcopystr($1); $$ = mputstr($$, $2); } | |
1595 | | XJsonValueSegment { $$ = mcopystr($1); } | |
1596 | ; | |
1597 | ||
1598 | XMetainfoForUnbound: | |
1599 | XKWmetainfo XOptSpaces XKWfor XOptSpaces XKWunbound { jsonstruct->metainfo_unbound = true; } | |
970ed795 EL |
1600 | ; |
1601 | ||
1602 | XOptSpaces: | |
1603 | /* Empty */ | |
1604 | | XSpaces | |
1605 | ; | |
1606 | ||
1607 | XSpaces: | |
1608 | XSpaces XSpace | |
1609 | | XSpace | |
1610 | ; | |
1611 | ||
1612 | XSpace: | |
1613 | ' ' | |
1614 | | '\t' | |
1615 | ; | |
1616 | ||
1617 | %% | |
1618 | ||
1619 | /* parse_rawAST(), which calls our rawAST_parse, is over in rawASST.l */ | |
1620 | ||
1621 | #ifndef NDEBUG | |
1622 | static void yyprint(FILE *file, int type, const YYSTYPE& value) | |
1623 | { | |
1624 | switch (type) { | |
1625 | case XIdentifier: | |
1626 | fprintf(file, "``%s''", value.identifier->get_name().c_str()); | |
1627 | break; | |
1628 | case Xstring: | |
1629 | fprintf(file, "``%s''", value.str); | |
1630 | break; | |
1631 | default: | |
1632 | fprintf(file, "# %d", type); | |
1633 | break; | |
1634 | } | |
1635 | } | |
1636 | #endif | |
1637 | ||
1638 | /* | |
1639 | Local Variables: | |
1640 | mode: C | |
1641 | indent-tabs-mode: nil | |
1642 | c-basic-offset: 4 | |
1643 | End: | |
1644 | */ |