?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added posix library to make files
[pwlib.git] / tools / asnparser / main.cxx
blob8949590ad58165fbe02facb7fb2e659768593406
1 /*
2 * main.cxx
3 *
4 * PWLib application source file for asnparser
5 *
6 * ASN.1 compiler to produce C++ classes.
7 *
8 * Copyright (c) 1997-1999 Equivalence Pty. Ltd.
9 *
10 * The contents of this file are subject to the Mozilla Public License
11 * Version 1.0 (the "License"); you may not use this file except in
12 * compliance with the License. You may obtain a copy of the License at
13 * http://www.mozilla.org/MPL/
14 *
15 * Software distributed under the License is distributed on an "AS IS"
16 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
17 * the License for the specific language governing rights and limitations
18 * under the License.
19 *
20 * The Original Code is ASN Parser.
21 *
22 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
23 *
24 * Portions of this code were written with the assisance of funding from
25 * Vovida Networks, Inc. http://www.vovida.com.
26 *
27 * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
28 * All Rights Reserved.
29 *
30 * Contributor(s): ______________________________________.
31 *
32 * $Log$
33 * Revision 1.51 2004/04/25 08:58:58 rjongbloed
34 * Fixed GCC 3.4 warning
35 *
36 * Revision 1.50 2004/04/21 00:32:02 csoutheren
37 * Fixed problem with XER and the new RTTI system
38 * Thanks to Federico Pinna and Reitek S.p.A.
39 *
40 * Revision 1.49 2004/04/13 11:33:55 csoutheren
41 * Fixed XER output, thanks to Federico Pinna
42 *
43 * Revision 1.48 2004/04/03 08:22:23 csoutheren
44 * Remove pseudo-RTTI and replaced with real RTTI
45 *
46 * Revision 1.47 2004/02/17 10:24:04 rjongbloed
47 * Updated version number so will rebuild ASN files.
48 *
49 * Revision 1.46 2004/02/17 09:38:24 csoutheren
50 * Added change to remove duplicate forward declarations
51 * See SourceForge bug 832245
52 * Thanks to Vyacheslav E. Andrejev
53 *
54 * Revision 1.45 2003/10/03 00:13:04 rjongbloed
55 * Added ability to specify CHOICE field selection by function rather than operator as the operator technique does not work with some dumb compilers.
56 * Added ability to specify that the header file name be different from the module name and module prefix string.
57 *
58 * Revision 1.44 2003/02/27 04:05:30 robertj
59 * Added ability to have alternate directories for header file
60 * includes in generated C++ code.
61 * Added constructors to PASN_OctetString descendant classes to help
62 * with doing simple assignments.
63 *
64 * Revision 1.43 2003/02/26 01:57:44 robertj
65 * Added XML encoding rules to ASN system, thanks Federico Pinna
66 *
67 * Revision 1.42 2003/02/19 14:18:55 craigs
68 * Fixed ifdef problem with multipart cxx files
69 *
70 * Revision 1.41 2003/02/18 10:50:41 craigs
71 * Added minor optimisation of outputted ASN code
72 * Added automatic insertion of defines to allow disabling of generated code
73 *
74 * Revision 1.40 2002/11/27 11:42:52 robertj
75 * Rearranged code to avoid GNU compiler problem.
76 * Changed new classheader parameters to be full C literal like string for
77 * improved backslash conversion.
78 * Incremented version number.
79 *
80 * Revision 1.39 2002/11/26 11:39:10 craigs
81 * Added option to allow adding functions to generated header files
82 *
83 * Revision 1.38 2002/09/16 01:08:59 robertj
84 * Added #define so can select if #pragma interface/implementation is used on
85 * platform basis (eg MacOS) rather than compiler, thanks Robert Monaghan.
86 *
87 * Revision 1.37 2001/10/02 00:56:14 robertj
88 * Fixed problem with autonumering enumerated types.
89 *
90 * Revision 1.36 2001/08/06 01:39:02 robertj
91 * Added assignement operator with RHS of PASN_BMPString to classes
92 * descended from PASN_BMPString.
93 *
94 * Revision 1.35 2001/08/03 09:01:02 robertj
95 * Added assignement operator with RHS of PWORDArray to classes
96 * descended from PASN_BMPString.
97 *
98 * Revision 1.34 2001/06/14 02:09:20 robertj
99 * Corrected support for ASN object class type reference constructs
100 * ie TYPE-IDENTIFIER.&Type encoded as octet string.
101 *
102 * Revision 1.33 2001/04/26 08:15:58 robertj
103 * Fixed problem with ASN compile of single constraints on enumerations.
104 *
105 * Revision 1.32 2001/04/23 04:40:14 robertj
106 * Added ASN standard types GeneralizedTime and UTCTime
107 *
108 * Revision 1.31 2001/02/22 23:31:42 robertj
109 * Fixed display of version number just added.
110 *
111 * Revision 1.30 2001/02/22 22:31:01 robertj
112 * Added command line flag to display version number only.
113 *
114 * Revision 1.29 2000/10/12 23:11:48 robertj
115 * Fixed problem with BER encoding of ASN with optional fields.
116 *
117 * Revision 1.28 2000/06/26 13:14:46 robertj
118 * Nucleus++ port.
119 *
120 * Revision 1.27 2000/03/21 21:23:23 robertj
121 * Added option to rename imported module names, allows include filename matching.
122 *
123 * Revision 1.26 2000/01/19 12:33:07 robertj
124 * Fixed parsing of OID's in IMPORTS section.
125 *
126 * Revision 1.25 2000/01/19 03:38:12 robertj
127 * Fixed support for parsing multiple IMPORTS
128 *
129 * Revision 1.24 1999/09/18 04:17:40 robertj
130 * Added generation of C++ inlines for some functions.
131 * Optimised CreateObject() switch statements, collapsing common cases.
132 *
133 * Revision 1.23 1999/09/18 02:42:27 craigs
134 * Added optimisation to collapse switch arms in CreateObject functions
135 *
136 * Revision 1.22 1999/09/07 09:56:04 robertj
137 * Fixed failure to put "using anmespace" in every generated .cxx file.
138 *
139 * Revision 1.21 1999/08/28 01:48:55 robertj
140 * Fixed anomaly to always include non-optional extensions in encodings.
141 *
142 * Revision 1.20 1999/08/09 13:02:36 robertj
143 * Added ASN compiler #defines for backward support of pre GCC 2.9 compilers.
144 * Added ASN compiler #defines to reduce its memory footprint.
145 * Added ASN compiler code generation of assignment operators for string classes.
146 *
147 * Revision 1.19 1999/07/22 06:48:55 robertj
148 * Added comparison operation to base ASN classes and compiled ASN code.
149 * Added support for ANY type in ASN parser.
150 *
151 * Revision 1.18 1999/07/06 05:00:26 robertj
152 * Incremented release number
153 *
154 * Revision 1.17 1999/07/01 12:21:46 robertj
155 * Changed PASN_Choice cast operators so no longer "break" const-ness of object.
156 *
157 * Revision 1.16 1999/06/30 08:57:19 robertj
158 * Fixed bug in encodeing sequence of constrained primitive type. Constraint not set.
159 * Fixed bug in not emitting namespace use clause.
160 * Added "normalisation" of separate sequence of <base type> to be single class.
161 *
162 * Revision 1.15 1999/06/14 13:00:15 robertj
163 * Fixed bug in code generation for string constraints.
164 *
165 * Revision 1.14 1999/06/09 06:58:09 robertj
166 * Adjusted heading comments.
167 *
168 * Revision 1.13 1999/06/09 02:07:49 robertj
169 * Fixed backward compatibility of generated template code with G++ 2.7.x
170 *
171 * Revision 1.12 1999/06/07 01:56:25 robertj
172 * Added header comment on license.
173 *
174 */
175
176 #include <ptlib.h>
177
178 #include "main.h"
179 #include "asn_grammar.h"
180
181
182 #define MAJOR_VERSION 1
183 #define MINOR_VERSION 9
184 #define BUILD_TYPE ReleaseCode
185 #define BUILD_NUMBER 1
186
187
188 unsigned lineNumber;
189 PString fileName;
190
191 unsigned fatals, warnings;
192
193 extern FILE * yyin;
194 extern int yydebug;
195 extern int LexEcho;
196
197 ModuleDefinition * Module;
198
199
200 static const char * UniversalTagClassNames[] = {
201 "UniversalTagClass",
202 "ApplicationTagClass",
203 "ContextSpecificTagClass",
204 "PrivateTagClass"
205 };
206
207 static const char * UniversalTagNames[] = {
208 NULL,
209 "UniversalBoolean",
210 "UniversalInteger",
211 "UniversalBitString",
212 "UniversalOctetString",
213 "UniversalNull",
214 "UniversalObjectId",
215 "UniversalObjectDescriptor",
216 "UniversalExternalType",
217 "UniversalReal",
218 "UniversalEnumeration",
219 "UniversalEmbeddedPDV",
220 NULL,
221 NULL,
222 NULL,
223 NULL,
224 "UniversalSequence",
225 "UniversalSet",
226 "UniversalNumericString",
227 "UniversalPrintableString",
228 "UniversalTeletexString",
229 "UniversalVideotexString",
230 "UniversalIA5String",
231 "UniversalUTCTime",
232 "UniversalGeneralisedTime",
233 "UniversalGraphicString",
234 "UniversalVisibleString",
235 "UniversalGeneralString",
236 "UniversalUniversalString",
237 NULL,
238 "UniversalBMPString"
239 };
240
241
242 static const char * const StandardClasses[] = {
243 "PASN_Null",
244 "PASN_Boolean",
245 "PASN_Integer",
246 "PASN_Enumeration",
247 "PASN_Real",
248 "PASN_ObjectId",
249 "PASN_BitString",
250 "PASN_OctetString",
251 "PASN_NumericString",
252 "PASN_PrintableString",
253 "PASN_VisibleString",
254 "PASN_IA5String",
255 "PASN_GeneralString",
256 "PASN_BMPString",
257 "PASN_Sequence"
258 };
259
260
261 /////////////////////////////////////////
262 //
263 // yyerror
264 // required function for flex
265 //
266
267 void yyerror(char * str)
268 {
269 extern char * yytext;
270 PError << StdError(Fatal) << str << " near token \"" << yytext <<"\"\n";
271 }
272
273 ostream & operator<<(ostream & out, const StdError & e)
274 {
275 out << fileName << '(' << lineNumber << ") : ";
276 if (e.e == Fatal) {
277 fatals++;
278 out << "error";
279 }
280 else {
281 warnings++;
282 out << "warning";
283 }
284 return out << ": ";
285 }
286
287
288 /////////////////////////////////////////////////////////
289 //
290 // Utility
291 //
292
293 static PString MakeIdentifierC(const PString & identifier)
294 {
295 PString s = identifier;
296 s.Replace("-", "_", TRUE);
297 return s;
298 }
299
300
301 class OutputFile : public PTextFile
302 {
303 PCLASSINFO(OutputFile, PTextFile);
304 public:
305 ~OutputFile() { Close(); }
306
307 BOOL Open(const PFilePath & path, const PString & suffix, const char * extension);
308 BOOL Close();
309 };
310
311
312 BOOL OutputFile::Open(const PFilePath & path,
313 const PString & suffix,
314 const char * extension)
315 {
316 PFilePath fn = path.GetDirectory() + path.GetTitle() + suffix;
317 fn.SetType(extension);
318
319 if (PTextFile::Open(fn, WriteOnly))
320 *this << "//\n"
321 "// " << GetFilePath().GetFileName() << "\n"
322 "//\n"
323 "// Code automatically generated by asnparse.\n"
324 "//\n"
325 "\n";
326 else
327 PError << PProcess::Current().GetName() << ": cannot create \""
328 << GetFilePath() << "\" :" << GetErrorText() << endl;
329
330 return IsOpen();
331 }
332
333
334 BOOL OutputFile::Close()
335 {
336 if (IsOpen())
337 *this << "\n"
338 "// End of " << GetFilePath().GetFileName() << '\n';
339
340 return PTextFile::Close();
341 }
342
343
344 /////////////////////////////////////////////////////////
345 //
346 // Application
347 //
348
349 class App : public PProcess
350 {
351 PCLASSINFO(App, PProcess);
352 public:
353 App();
354 void Main();
355 BOOL SetClassHeaderFile(PArgList & args);
356 BOOL SetClassHeader(PArgList & args);
357 void OutputAdditionalHeaders(ostream & hdr, const PString & className);
358 protected:
359 PStringToString classToHeader;
360 };
361
362 PCREATE_PROCESS(App);
363
364 App::App()
365 : PProcess("Equivalence", "ASNParse", MAJOR_VERSION, MINOR_VERSION, BUILD_TYPE, BUILD_NUMBER)
366 {
367 }
368
369 void App::Main()
370 {
371 cout << GetName() << " version " << GetVersion(TRUE)
372 << " for " << GetOSClass() << ' ' << GetOSName()
373 << " by " << GetManufacturer() << endl;
374
375 PArgList & args = GetArguments();
376 args.Parse("c-c++."
377 "d-debug."
378 "e-echo."
379 "h-hdr-prefix:"
380 "i-inlines."
381 "m-module:"
382 "n-namespace."
383 "o-output:"
384 "r-rename:"
385 "s-split;"
386 "V-version."
387 "v-verbose."
388 "x-xml."
389 "-no-operators."
390 "-classheader:"
391 "-classheaderfile:");
392
393 if (args.HasOption('V'))
394 return;
395
396 unsigned numFiles = 1;
397 if (args.HasOption('s')) {
398 PString numFilesStr = args.GetOptionString('s');
399 if (numFilesStr.IsEmpty())
400 numFiles = 2;
401 else
402 numFiles = numFilesStr.AsUnsigned();
403 }
404
405 if (args.GetCount() < 1 || args.GetCount() > 1 || numFiles == 0) {
406 PError << "usage: asnparse [options] asnfile\n"
407 " -V --version Display version and exit\n"
408 " -v --verbose Verbose output (multiple times for more verbose)\n"
409 " -e --echo Echo input file\n"
410 " -d --debug Debug output (copious!)\n"
411 " -c --c++ Generate C++ files\n"
412 " -n --namespace Use C++ namespace\n"
413 " -h --hdr-prefix str Prefix for C++ include of header (eg directory)\n"
414 " -i --inlines Use C++ inlines\n"
415 " -s[n] --split[n] Split output into n (default 2) files\n"
416 " -m --module name Module name prefix/namespace\n"
417 " -r --rename args Rename import module where arg is:\n"
418 " from=name[,prefix[,fname]]\n"
419 " from is module name in ASN file\n"
420 " name is target header file name\n"
421 " prefix is optional prefix for include\n"
422 " (eg header directory)\n"
423 " fname is optional base name for header files\n"
424 " --no-operators Generate functions instead of operators for choice\n"
425 " sub-object extraction.\n"
426 " -x --xml X.693 support (XER)\n"
427 " -o --output file Output filename/directory\n"
428 << endl;
429 return;
430 }
431
432 PTextFile prcFile;
433 if (!prcFile.Open(args[0], PFile::ReadOnly)) {
434 PError << GetName() << ": cannot open \""
435 << prcFile.GetFilePath() << "\" :" << prcFile.GetErrorText() << endl;
436 return;
437 }
438
439 if (args.HasOption('d'))
440 yydebug = 1;
441 if (args.HasOption('e'))
442 LexEcho = TRUE;
443
444 fileName = prcFile.GetFilePath();
445 lineNumber = 1;
446 fatals = 0;
447 warnings = 0;
448
449 if (args.HasOption("classheaderfile")) {
450 if (!SetClassHeaderFile(args))
451 return;
452 }
453
454 if (args.HasOption("classheader")) {
455 if (!SetClassHeader(args))
456 return;
457 }
458
459 if (args.HasOption('v'))
460 cout << "Parsing..." << endl;
461
462 yyin = _fdopen(prcFile.GetHandle(), "r");
463 PAssert(yyin != NULL, "fdopen failed!");
464 yyparse();
465
466 if (Module != NULL) {
467 if (args.GetOptionCount('v') > 1)
468 PError << "Module " << *Module << endl;
469
470 if (args.HasOption('c'))
471 Module->GenerateCplusplus(args.GetOptionString('o', args[0]),
472 args.GetOptionString('m'),
473 args.GetOptionString('h'),
474 numFiles,
475 args.HasOption('n'),
476 args.HasOption('i'),
477 !args.HasOption("no-operators"),
478 args.HasOption('v'));
479 }
480 }
481
482
483 BOOL App::SetClassHeaderFile(PArgList & args)
484 {
485 PStringArray lines = args.GetOptionString("classheaderfile").Lines();
486 if (lines.IsEmpty()) {
487 PError << GetName() << ": malformed --classheaderfile option\n";
488 return FALSE;
489 }
490
491 for (PINDEX i = 0; i < lines.GetSize(); i++) {
492 PString str = lines[i];
493 PINDEX pos = str.Find("=");
494 if (pos == P_MAX_INDEX) {
495 PError << GetName() << ": malformed --classheaderfile option\n";
496 return FALSE;
497 }
498
499 PFilePath fn = str.Right(pos+1);
500 PTextFile file(fn, PFile::ReadOnly);
501 if (!file.IsOpen()) {
502 PError << GetName() << ": cannot open file required for --classheaderfile option \"" << fn
503 << "\" :" << file.GetErrorText() << '\n';
504 return FALSE;
505 }
506
507 PString text;
508 PString line;
509 while (file.ReadLine(line))
510 text += PString(PString::Literal, (const char *)line) + '\n';
511 classToHeader.SetAt(str.Left(pos), text);
512 }
513
514 return TRUE;
515 }
516
517
518 BOOL App::SetClassHeader(PArgList & args)
519 {
520 PStringArray lines = args.GetOptionString("classheader").Lines();
521 if (lines.IsEmpty()) {
522 PError << GetName() << ": malformed --classheader option\n";
523 return FALSE;
524 }
525
526 for (PINDEX i = 0; i < lines.GetSize(); i++) {
527 PString str = lines[i];
528 PINDEX pos = str.Find("=");
529 if (pos == P_MAX_INDEX) {
530 PError << GetName() << ": malformed --classheader option\n";
531 return FALSE;
532 }
533
534 PString text(PString::Literal, (const char *)str.Mid(pos+1));
535 classToHeader.SetAt(str.Left(pos), text);
536 }
537
538 return TRUE;
539 }
540
541
542 void App::OutputAdditionalHeaders(ostream & hdr, const PString & className)
543 {
544 if (classToHeader.Contains(className)) {
545 hdr << "// following code added by command line option\n"
546 "\n"
547 << classToHeader[className] << "\n"
548 "\n"
549 "// end of added code\n"
550 "\n";
551 }
552 }
553
554 /////////////////////////////////////////
555 //
556 // miscellaneous
557 //
558
559 class indent
560 {
561 public:
562 indent() { }
563 friend ostream & operator<<(ostream & s, const indent &)
564 { return s << setw(Module->GetIndentLevel()*3) << ' '; }
565 };
566
567
568 /////////////////////////////////////////
569 //
570 // intermediate structures from parser
571 //
572
573 NamedNumber::NamedNumber(PString * nam)
574 : name(*nam)
575 {
576 delete nam;
577 number = 0;
578 autonumber = TRUE;
579 }
580
581
582 NamedNumber::NamedNumber(PString * nam, int num)
583 : name(*nam)
584 {
585 delete nam;
586 number = num;
587 autonumber = FALSE;
588 }
589
590
591 NamedNumber::NamedNumber(PString * nam, const PString & ref)
592 : name(*nam), reference(ref)
593 {
594 delete nam;
595 number = 0;
596 autonumber = FALSE;
597 }
598
599
600 void NamedNumber::PrintOn(ostream & strm) const
601 {
602 strm << name << " (";
603 if (reference.IsEmpty())
604 strm << number;
605 else
606 strm << reference;
607 strm << ')';
608 }
609
610
611 void NamedNumber::SetAutoNumber(const NamedNumber & prev)
612 {
613 if (autonumber) {
614 number = prev.number + 1;
615 autonumber = FALSE;
616 }
617 }
618
619
620 /////////////////////////////////////////////////////////
621
622 Tag::Tag(unsigned tagNum)
623 {
624 type = Universal;
625 number = tagNum;
626 mode = Module->GetDefaultTagMode();
627 }
628
629
630 const char * Tag::classNames[] = {
631 "UNIVERSAL", "APPLICATION", "CONTEXTSPECIFIC", "PRIVATE"
632 };
633
634
635 const char * Tag::modeNames[] = {
636 "IMPLICIT", "EXPLICIT", "AUTOMATIC"
637 };
638
639
640 void Tag::PrintOn(ostream & strm) const
641 {
642 if (type != Universal || number != IllegalUniversalTag) {
643 strm << '[';
644 if (type != ContextSpecific)
645 strm << classNames[type] << ' ';
646 strm << number << "] " << modeNames[mode] << ' ';
647 }
648 }
649
650
651 /////////////////////////////////////////////////////////
652
653 Constraint::Constraint(ConstraintElementBase * elmt)
654 {
655 standard.Append(elmt);
656 extendable = FALSE;
657 }
658
659
660 Constraint::Constraint(ConstraintElementList * stnd, BOOL extend, ConstraintElementList * ext)
661 {
662 if (stnd != NULL) {
663 standard = *stnd;
664 delete stnd;
665 }
666 extendable = extend;
667 if (ext != NULL) {
668 extensions = *ext;
669 delete ext;
670 }
671 }
672
673
674 void Constraint::PrintOn(ostream & strm) const
675 {
676 strm << '(';
677 for (PINDEX i = 0; i < standard.GetSize(); i++)
678 strm << standard[i];
679 if (extendable) {
680 strm << indent();
681 if (standard.GetSize() > 0)
682 strm << ", ";
683 strm << "..., ";
684 for (PINDEX i = 0; i < extensions.GetSize(); i++)
685 strm << extensions[i];
686 }
687 strm << ')';
688 }
689
690
691 void Constraint::GenerateCplusplus(const PString & fn, ostream & hdr, ostream & cxx)
692 {
693 switch (standard.GetSize()) {
694 case 0 :
695 return;
696 case 1 :
697 break;
698 default :
699 PError << StdError(Warning) << "unsupported UNION constraints, ignored." << endl;
700 }
701
702 if (extensions.GetSize() > 0)
703 PError << StdError(Warning) << "unsupported extension constraints, ignored." << endl;
704
705 PString fn2 = fn;
706 if (fn.Find("PASN_Object::") == P_MAX_INDEX) {
707 if (extendable)
708 fn2 += "PASN_Object::ExtendableConstraint";
709 else
710 fn2 += "PASN_Object::FixedConstraint";
711 }
712
713 standard[0].GenerateCplusplus(fn2, hdr, cxx);
714 }
715
716
717 BOOL Constraint::ReferencesType(const TypeBase & type)
718 {
719 PINDEX i;
720
721 for (i = 0; i < standard.GetSize(); i++) {
722 if (standard[i].ReferencesType(type))
723 return TRUE;
724 }
725
726 for (i = 0; i < extensions.GetSize(); i++) {
727 if (extensions[i].ReferencesType(type))
728 return TRUE;
729 }
730
731 return FALSE;
732 }
733
734
735 /////////////////////////////////////////////////////////
736
737 ConstraintElementBase::ConstraintElementBase()
738 {
739 exclusions = NULL;
740 }
741
742
743 void ConstraintElementBase::GenerateCplusplus(const PString &, ostream &, ostream &)
744 {
745 PError << StdError(Warning) << "unsupported constraint, ignored." << endl;
746 }
747
748
749 BOOL ConstraintElementBase::ReferencesType(const TypeBase &)
750 {
751 return FALSE;
752 }
753
754
755 /////////////////////////////////////////////////////////
756
757 ConstrainAllConstraintElement::ConstrainAllConstraintElement(ConstraintElementBase * excl)
758 {
759 SetExclusions(excl);
760 }
761
762
763 /////////////////////////////////////////////////////////
764
765 ElementListConstraintElement::ElementListConstraintElement(ConstraintElementList * list)
766 : elements(*list)
767 {
768 delete list;
769 }
770
771
772 void ElementListConstraintElement::PrintOn(ostream & strm) const
773 {
774 elements.PrintOn(strm);
775 }
776
777
778 void ElementListConstraintElement::GenerateCplusplus(const PString & fn, ostream & hdr, ostream & cxx)
779 {
780 for (PINDEX i = 0; i < elements.GetSize(); i++)
781 elements[i].GenerateCplusplus(fn, hdr, cxx);
782 }
783
784
785 BOOL ElementListConstraintElement::ReferencesType(const TypeBase & type)
786 {
787 for (PINDEX i = 0; i < elements.GetSize(); i++) {
788 if (elements[i].ReferencesType(type))
789 return TRUE;
790 }
791 return FALSE;
792 }
793
794
795 /////////////////////////////////////////////////////////
796
797 SingleValueConstraintElement::SingleValueConstraintElement(ValueBase * val)
798 {
799 value = val;
800 }
801
802
803 SingleValueConstraintElement::~SingleValueConstraintElement()
804 {
805 delete value;
806 }
807
808
809 void SingleValueConstraintElement::PrintOn(ostream & strm) const
810 {
811 strm << *value;
812 }
813
814
815 void SingleValueConstraintElement::GenerateCplusplus(const PString & fn, ostream & hdr, ostream & cxx)
816 {
817 cxx << fn << ", ";
818 value->GenerateCplusplus(hdr, cxx);
819 cxx << ");\n";
820 }
821
822
823 /////////////////////////////////////////////////////////
824
825 ValueRangeConstraintElement::ValueRangeConstraintElement(ValueBase * lowerBound, ValueBase * upperBound)
826 {
827 lower = lowerBound;
828 upper = upperBound;
829 }
830
831
832 ValueRangeConstraintElement::~ValueRangeConstraintElement()
833 {
834 delete lower;
835 delete upper;
836 }
837
838
839 void ValueRangeConstraintElement::PrintOn(ostream & strm) const
840 {
841 strm << *lower << ".." << *upper;
842 }
843
844
845 void ValueRangeConstraintElement::GenerateCplusplus(const PString & fn, ostream & hdr, ostream & cxx)
846 {
847 cxx << fn << ", ";
848 lower->GenerateCplusplus(hdr, cxx);
849 cxx << ", ";
850 upper->GenerateCplusplus(hdr, cxx);
851 cxx << ");\n";
852 }
853
854
855 /////////////////////////////////////////////////////////
856
857 SubTypeConstraintElement::SubTypeConstraintElement(TypeBase * typ)
858 {
859 subtype = typ;
860 }
861
862
863 SubTypeConstraintElement::~SubTypeConstraintElement()
864 {
865 delete subtype;
866 }
867
868
869 void SubTypeConstraintElement::PrintOn(ostream & strm) const
870 {
871 strm << subtype->GetTypeName();
872 }
873
874
875 void SubTypeConstraintElement::GenerateCplusplus(const PString &, ostream & hdr, ostream &)
876 {
877 hdr << subtype->GetTypeName();
878 }
879
880
881 BOOL SubTypeConstraintElement::ReferencesType(const TypeBase & type)
882 {
883 return subtype->ReferencesType(type);
884 }
885
886
887 /////////////////////////////////////////////////////////
888
889 NestedConstraintConstraintElement::NestedConstraintConstraintElement(Constraint * con)
890 {
891 constraint = con;
892 }
893
894
895 NestedConstraintConstraintElement::~NestedConstraintConstraintElement()
896 {
897 delete constraint;
898 }
899
900
901 BOOL NestedConstraintConstraintElement::ReferencesType(const TypeBase & type)
902 {
903 if (constraint == NULL)
904 return FALSE;
905
906 return constraint->ReferencesType(type);
907 }
908
909
910 /////////////////////////////////////////////////////////
911
912 SizeConstraintElement::SizeConstraintElement(Constraint * constraint)
913 : NestedConstraintConstraintElement(constraint)
914 {
915 }
916
917
918 void SizeConstraintElement::PrintOn(ostream & strm) const
919 {
920 strm << "SIZE" << *constraint;
921 }
922
923
924 void SizeConstraintElement::GenerateCplusplus(const PString & fn, ostream & hdr, ostream & cxx)
925 {
926 constraint->GenerateCplusplus(fn, hdr, cxx);
927 }
928
929
930 /////////////////////////////////////////////////////////
931
932 FromConstraintElement::FromConstraintElement(Constraint * constraint)
933 : NestedConstraintConstraintElement(constraint)
934 {
935 }
936
937
938 void FromConstraintElement::PrintOn(ostream & strm) const
939 {
940 strm << "FROM" << *constraint;
941 }
942
943
944 void FromConstraintElement::GenerateCplusplus(const PString & fn, ostream & hdr, ostream & cxx)
945 {
946 PString newfn = fn;
947 newfn.Replace("SetConstraints(", "SetCharacterSet(");
948 constraint->GenerateCplusplus(newfn, hdr, cxx);
949 }
950
951
952 /////////////////////////////////////////////////////////
953
954 WithComponentConstraintElement::WithComponentConstraintElement(PString * newName,
955 Constraint * constraint,
956 int pres)
957 : NestedConstraintConstraintElement(constraint)
958 {
959 if (newName != NULL) {
960 name = *newName;
961 delete newName;
962 }
963
964 presence = pres;
965 }
966
967
968 void WithComponentConstraintElement::PrintOn(ostream & strm) const
969 {
970 if (name.IsEmpty())
971 strm << "WITH COMPONENT";
972 else
973 strm << name;
974
975 if (constraint != NULL)
976 strm << *constraint;
977
978 switch (presence) {
979 case Present :
980 strm << " PRESENT";
981 break;
982 case Absent :
983 strm << " ABSENT";
984 break;
985 case Optional :
986 strm << " OPTIONAL";
987 break;
988 }
989 }
990
991
992 void WithComponentConstraintElement::GenerateCplusplus(const PString &, ostream &, ostream & cxx)
993 {
994 if (presence == Present)
995 cxx << " IncludeOptionalField(e_" << name << ");\n";
996 }
997
998
999 /////////////////////////////////////////////////////////
1000
1001 InnerTypeConstraintElement::InnerTypeConstraintElement(ConstraintElementList * list,
1002 BOOL part)
1003 : ElementListConstraintElement(list)
1004 {
1005 partial = part;
1006 }
1007
1008
1009 void InnerTypeConstraintElement::PrintOn(ostream & strm) const
1010 {
1011 strm << "WITH COMPONENTS { ";
1012
1013 if (partial)
1014 strm << "..., ";
1015
1016 for (PINDEX i = 0; i < elements.GetSize(); i++) {
1017 if (i > 0)
1018 strm << ", ";
1019 elements[i].PrintOn(strm);
1020 }
1021
1022 strm << " }";
1023 }
1024
1025
1026 void InnerTypeConstraintElement::GenerateCplusplus(const PString & fn, ostream & hdr, ostream & cxx)
1027 {
1028 for (PINDEX i = 0; i < elements.GetSize(); i++)
1029 elements[i].GenerateCplusplus(fn, hdr, cxx);
1030 }
1031
1032
1033 /////////////////////////////////////////////////////////
1034
1035 UserDefinedConstraintElement::UserDefinedConstraintElement(TypesList * t)
1036 {
1037 if (t != NULL) {
1038 types = *t;
1039 delete t;
1040 }
1041 }
1042
1043
1044 void UserDefinedConstraintElement::PrintOn(ostream & strm) const
1045 {
1046 strm << "CONSTRAINED BY { ";
1047 for (PINDEX i = 0; i < types.GetSize(); i++) {
1048 if (i > 0)
1049 strm << ", ";
1050 strm << types[i].GetTypeName();
1051 }
1052 strm << " }";
1053 }
1054
1055
1056 void UserDefinedConstraintElement::GenerateCplusplus(const PString &, ostream &, ostream &)
1057 {
1058 }
1059
1060
1061 /////////////////////////////////////////////////////////
1062
1063 TypeBase::TypeBase(unsigned tagNum)
1064 : tag(tagNum), defaultTag(tagNum)
1065 {
1066 isOptional = FALSE;
1067 defaultValue = NULL;
1068 isGenerated = FALSE;
1069 }
1070
1071
1072 TypeBase::TypeBase(TypeBase * copy)
1073 : name(copy->name),
1074 identifier(MakeIdentifierC(name)),
1075 tag(copy->tag),
1076 defaultTag(copy->tag)
1077 {
1078 isOptional = copy->isOptional;
1079 defaultValue = NULL;
1080 isGenerated = FALSE;
1081 }
1082
1083
1084 PObject::Comparison TypeBase::Compare(const PObject & obj) const
1085 {
1086 return name.Compare(((const TypeBase &)obj).name);
1087 }
1088
1089
1090 void TypeBase::PrintOn(ostream & strm) const
1091 {
1092 PrintStart(strm);
1093 PrintFinish(strm);
1094 }
1095
1096
1097 void TypeBase::PrintStart(ostream & strm) const
1098 {
1099 strm << indent();
1100 if (!name) {
1101 strm << name;
1102 if (!parameters.IsEmpty()) {
1103 strm << " { ";
1104 for (PINDEX i = 0; i < parameters.GetSize(); i++) {
1105 if (i > 0)
1106 strm << ", ";
1107 strm << parameters[i];
1108 }
1109 strm << " } ";
1110 }
1111 strm << ": ";
1112 }
1113 strm << tag << GetClass() << ' ';
1114 Module->SetIndentLevel(1);
1115 }
1116
1117
1118 void TypeBase::PrintFinish(ostream & strm) const
1119 {
1120 Module->SetIndentLevel(-1);
1121 strm << ' ' << constraints;
1122 if (isOptional)
1123 strm << " OPTIONAL";
1124 if (defaultValue != NULL)
1125 strm << " DEFAULT " << *defaultValue;
1126 strm << '\n';
1127 }
1128
1129
1130 int TypeBase::GetIdentifierTokenContext() const
1131 {
1132 return IDENTIFIER;
1133 }
1134
1135
1136 int TypeBase::GetBraceTokenContext() const
1137 {
1138 return '{';
1139 }
1140
1141
1142 void TypeBase::SetName(PString * newName)
1143 {
1144 name = *newName;
1145 delete newName;
1146 identifier = MakeIdentifierC(name);
1147 }
1148
1149
1150 void TypeBase::AdjustIdentifier()
1151 {
1152 identifier = Module->GetPrefix() + MakeIdentifierC(name);
1153 }
1154
1155
1156 void TypeBase::SetTag(Tag::Type type, unsigned num, Tag::Mode mode)
1157 {
1158 tag.type = type;
1159 tag.number = num;
1160 tag.mode = mode;
1161 }
1162
1163
1164 void TypeBase::SetParameters(PStringList * list)
1165 {
1166 parameters = *list;
1167 delete list;
1168 }
1169
1170
1171 void TypeBase::MoveConstraints(TypeBase * from)
1172 {
1173 from->constraints.DisallowDeleteObjects();
1174
1175 while (!from->constraints.IsEmpty())
1176 constraints.Append(from->constraints.RemoveAt(0));
1177
1178 from->constraints.AllowDeleteObjects();
1179 }
1180
1181
1182 void TypeBase::FlattenUsedTypes()
1183 {
1184 }
1185
1186
1187 TypeBase * TypeBase::FlattenThisType(const TypeBase &)
1188 {
1189 return this;
1190 }
1191
1192
1193 BOOL TypeBase::IsChoice() const
1194 {
1195 return FALSE;
1196 }
1197
1198
1199 BOOL TypeBase::IsParameterizedType() const
1200 {
1201 return FALSE;
1202 }
1203
1204
1205 BOOL TypeBase::IsPrimitiveType() const
1206 {
1207 return TRUE;
1208 }
1209
1210
1211 void TypeBase::GenerateCplusplus(ostream & hdr, ostream & cxx)
1212 {
1213 BeginGenerateCplusplus(hdr, cxx);
1214
1215 // Close off the constructor implementation
1216 cxx << ")\n"
1217 "{\n";
1218 GenerateCplusplusConstraints(PString(), hdr, cxx);
1219
1220 EndGenerateCplusplus(hdr, cxx);
1221 }
1222
1223
1224 void TypeBase::GenerateForwardDecls(ostream &)
1225 {
1226 }
1227
1228
1229 void TypeBase::GenerateOperators(ostream &, ostream &, const TypeBase &)
1230 {
1231 }
1232
1233
1234 PString TypeBase::GetTypeName() const
1235 {
1236 return GetAncestorClass();
1237 }
1238
1239
1240 BOOL TypeBase::CanReferenceType() const
1241 {
1242 return FALSE;
1243 }
1244
1245
1246 BOOL TypeBase::ReferencesType(const TypeBase &)
1247 {
1248 return FALSE;
1249 }
1250
1251
1252 void TypeBase::SetImportPrefix(const PString &)
1253 {
1254 }
1255
1256
1257 BOOL TypeBase::IsParameterisedImport() const
1258 {
1259 return FALSE;
1260 }
1261
1262
1263 void TypeBase::BeginGenerateCplusplus(ostream & hdr, ostream & cxx)
1264 {
1265 classNameString = GetIdentifier();
1266
1267 if (!parameters.IsEmpty()) {
1268 templatePrefix = "template <";
1269 classNameString += '<';
1270 for (PINDEX i = 0; i < parameters.GetSize(); i++) {
1271 if (i > 0) {
1272 templatePrefix += ", ";
1273 classNameString += ", ";
1274 }
1275 PString ident = MakeIdentifierC(parameters[i]);
1276 templatePrefix += "class " + ident;
1277 classNameString += ident;
1278 }
1279 templatePrefix += ">\n";
1280 classNameString += '>';
1281 }
1282
1283 // Output header file declaration of class
1284 hdr << "//\n"
1285 "// " << GetName() << "\n"
1286 "//\n"
1287 "\n";
1288 GenerateForwardDecls(hdr);
1289 hdr << templatePrefix
1290 << "class " << GetIdentifier() << " : public " << GetTypeName() << "\n"
1291 "{\n"
1292 "#ifndef PASN_LEANANDMEAN\n"
1293 " PCLASSINFO(" << GetIdentifier() << ", " << GetTypeName() << ");\n"
1294 "#endif\n"
1295 " public:\n"
1296 " " << GetIdentifier() << "(unsigned tag = ";
1297 if (tag.type == Tag::Universal &&
1298 tag.number < PARRAYSIZE(UniversalTagNames) &&
1299 UniversalTagNames[tag.number] != NULL)
1300 hdr << UniversalTagNames[tag.number];
1301 else
1302 hdr << tag.number;
1303 hdr << ", TagClass tagClass = " << UniversalTagClassNames[tag.type] << ");\n\n";
1304
1305 App & app = (App &)PProcess::Current();
1306 app.OutputAdditionalHeaders(hdr, GetIdentifier());
1307
1308 // Output cxx file implementation of class
1309 cxx << "//\n"
1310 "// " << GetName() << "\n"
1311 "//\n"
1312 "\n"
1313 << GetTemplatePrefix()
1314 << GetClassNameString() << "::" << GetIdentifier() << "(unsigned tag, PASN_Object::TagClass tagClass)\n"
1315 " : " << GetTypeName() << "(tag, tagClass";
1316 }
1317
1318
1319 void TypeBase::EndGenerateCplusplus(ostream & hdr, ostream & cxx)
1320 {
1321 cxx << "}\n"
1322 "\n"
1323 "\n";
1324
1325 GenerateOperators(hdr, cxx, *this);
1326
1327 // Output header file declaration of class
1328 hdr << " PObject * Clone() const;\n"
1329 "};\n"
1330 "\n"
1331 "\n";
1332
1333 // Output cxx file implementation of class
1334 cxx << GetTemplatePrefix()
1335 << "PObject * " << GetClassNameString() << "::Clone() const\n"
1336 "{\n"
1337 "#ifndef PASN_LEANANDMEAN\n"
1338 " PAssert(IsClass(" << GetClassNameString() << "::Class()), PInvalidCast);\n"
1339 "#endif\n"
1340 " return new " << GetClassNameString() << "(*this);\n"
1341 "}\n"
1342 "\n"
1343 "\n";
1344
1345 isGenerated = TRUE;
1346 }
1347
1348
1349 void TypeBase::GenerateCplusplusConstructor(ostream &, ostream & cxx)
1350 {
1351 cxx << '(';
1352 if (HasNonStandardTag()) {
1353 if (tag.type == Tag::Universal &&
1354 tag.number < PARRAYSIZE(UniversalTagNames) &&
1355 UniversalTagNames[tag.number] != NULL)
1356 cxx << UniversalTagNames[tag.number];
1357 else
1358 cxx << tag.number;
1359 cxx << ", " << UniversalTagClassNames[tag.type];
1360 }
1361 cxx << ')';
1362 }
1363
1364
1365 void TypeBase::GenerateCplusplusConstraints(const PString & prefix, ostream & hdr, ostream & cxx)
1366 {
1367 for (PINDEX i = 0; i < constraints.GetSize(); i++)
1368 constraints[i].GenerateCplusplus(" " + prefix + "SetConstraints(", hdr, cxx);
1369 }
1370
1371
1372 /////////////////////////////////////////////////////////
1373
1374 DefinedType::DefinedType(PString * name, BOOL parameter)
1375 : TypeBase(Tag::IllegalUniversalTag),
1376 referenceName(*name)
1377 {
1378 delete name;
1379 baseType = NULL;
1380 unresolved = !parameter;
1381 }
1382
1383
1384 DefinedType::DefinedType(TypeBase * refType, TypeBase * bType)
1385 : TypeBase(refType),
1386 referenceName(bType->GetName())
1387 {
1388 MoveConstraints(refType);
1389
1390 baseType = bType;
1391 unresolved = FALSE;
1392 }
1393
1394
1395 DefinedType::DefinedType(TypeBase * refType, const PString & refName)
1396 : TypeBase(refType)
1397 {
1398 MoveConstraints(refType);
1399 ConstructFromType(refType, refName);
1400 }
1401
1402
1403 DefinedType::DefinedType(TypeBase * refType, const TypeBase & parent)
1404 : TypeBase(refType)
1405 {
1406 if (!name)
1407 ConstructFromType(refType, parent.GetName() + '_' + name);
1408 else
1409 ConstructFromType(refType, parent.GetName() + "_subtype");
1410 }
1411
1412
1413 void DefinedType::ConstructFromType(TypeBase * refType, const PString & name)
1414 {
1415 referenceName = name;
1416 refType->SetName(new PString(name));
1417
1418 Module->AppendType(refType);
1419
1420 baseType = refType;
1421 unresolved = FALSE;
1422 }
1423
1424
1425 void DefinedType::PrintOn(ostream & strm) const
1426 {
1427 PrintStart(strm);
1428 strm << referenceName << ' ';
1429 PrintFinish(strm);
1430 }
1431
1432
1433 BOOL DefinedType::CanReferenceType() const
1434 {
1435 return TRUE;
1436 }
1437
1438
1439 BOOL DefinedType::IsChoice() const
1440 {
1441 if (baseType != NULL)
1442 return baseType->IsChoice();
1443 return FALSE;
1444 }
1445
1446
1447 BOOL DefinedType::IsParameterizedType() const
1448 {
1449 if (baseType != NULL)
1450 return baseType->IsParameterizedType();
1451 return FALSE;
1452 }
1453
1454
1455 BOOL DefinedType::ReferencesType(const TypeBase & type)
1456 {
1457 if (unresolved) {
1458 unresolved = FALSE;
1459
1460 if ((baseType = Module->FindType(referenceName)) == NULL)
1461 PError << StdError(Warning) << "unresolved symbol: " << referenceName << endl;
1462 else {
1463 if (!HasNonStandardTag())
1464 defaultTag = tag = baseType->GetTag();
1465 }
1466 }
1467
1468 return type.GetName() == referenceName;
1469 }
1470
1471
1472 void DefinedType::GenerateOperators(ostream & hdr, ostream & cxx, const TypeBase & actualType)
1473 {
1474 if (baseType != NULL)
1475 baseType->GenerateOperators(hdr, cxx, actualType);
1476 }
1477
1478
1479 const char * DefinedType::GetAncestorClass() const
1480 {
1481 if (baseType != NULL)
1482 return baseType->GetAncestorClass();
1483 return NULL;
1484 }
1485
1486
1487 PString DefinedType::GetTypeName() const
1488 {
1489 if (baseType == NULL)
1490 return referenceName;
1491
1492 if (HasConstraints() && baseType->IsPrimitiveType())
1493 return baseType->GetTypeName();
1494
1495 return baseType->GetIdentifier();
1496 }
1497
1498
1499 /////////////////////////////////////////////////////////
1500
1501 ParameterizedType::ParameterizedType(PString * name, TypesList * args)
1502 : DefinedType(name, FALSE),
1503 arguments(*args)
1504 {
1505 delete args;
1506 }
1507
1508
1509 void ParameterizedType::PrintOn(ostream & strm) const
1510 {
1511 PrintStart(strm);
1512 strm << referenceName << " { ";
1513 for (PINDEX i = 0; i < arguments.GetSize(); i++) {
1514 if (i > 0)
1515 strm << ", ";
1516 strm << arguments[i].GetTypeName();
1517 }
1518 strm << " }";
1519 PrintFinish(strm);
1520 }
1521
1522
1523 BOOL ParameterizedType::IsParameterizedType() const
1524 {
1525 return TRUE;
1526 }
1527
1528
1529 BOOL ParameterizedType::ReferencesType(const TypeBase & type)
1530 {
1531 for (PINDEX i = 0; i < arguments.GetSize(); i++) {
1532 if (arguments[i].ReferencesType(type))
1533 return TRUE;
1534 }
1535
1536 return DefinedType::ReferencesType(type);
1537 }
1538
1539
1540 PString ParameterizedType::GetTypeName() const
1541 {
1542 PString typeName = DefinedType::GetTypeName();
1543 if (!arguments.IsEmpty()) {
1544 typeName += '<';
1545 for (PINDEX i = 0; i < arguments.GetSize(); i++) {
1546 if (i > 0)
1547 typeName += ", ";
1548 typeName += arguments[i].GetTypeName();
1549 }
1550 typeName += '>';
1551 }
1552 return typeName;
1553 }
1554
1555
1556 /////////////////////////////////////////////////////////
1557
1558 SelectionType::SelectionType(PString * name, TypeBase * base)
1559 : TypeBase(Tag::IllegalUniversalTag),
1560 selection(*name)
1561 {
1562 delete name;
1563 baseType = PAssertNULL(base);
1564 }
1565
1566
1567 SelectionType::~SelectionType()
1568 {
1569 delete baseType;
1570 }
1571
1572
1573 void SelectionType::PrintOn(ostream & strm) const
1574 {
1575 PrintStart(strm);
1576 strm << selection << '<' << *baseType;
1577 PrintFinish(strm);
1578 }
1579
1580
1581 void SelectionType::FlattenUsedTypes()
1582 {
1583 baseType = baseType->FlattenThisType(*this);
1584 }
1585
1586
1587 TypeBase * SelectionType::FlattenThisType(const TypeBase & parent)
1588 {
1589 return new DefinedType(this, parent);
1590 }
1591
1592
1593 void SelectionType::GenerateCplusplus(ostream &, ostream &)
1594 {
1595 PError << StdError(Fatal) << "Cannot generate code for Selection type" << endl;
1596 isGenerated = TRUE;
1597 }
1598
1599
1600 const char * SelectionType::GetAncestorClass() const
1601 {
1602 return "";
1603 }
1604
1605
1606 BOOL SelectionType::CanReferenceType() const
1607 {
1608 return TRUE;
1609 }
1610
1611
1612 BOOL SelectionType::ReferencesType(const TypeBase & type)
1613 {
1614 return baseType->ReferencesType(type);
1615 }
1616
1617
1618 /////////////////////////////////////////////////////////
1619
1620 BooleanType::BooleanType()
1621 : TypeBase(Tag::UniversalBoolean)
1622 {
1623 }
1624
1625
1626 void BooleanType::GenerateOperators(ostream & hdr, ostream & cxx, const TypeBase & actualType)
1627 {
1628 hdr << " " << actualType.GetIdentifier() << " & operator=(BOOL v)";
1629 if (Module->UsingInlines())
1630 hdr << " { SetValue(v); return *this; }\n";
1631 else {
1632 hdr << ";\n";
1633 cxx << actualType.GetTemplatePrefix()
1634 << actualType.GetIdentifier() << " & "
1635 << actualType.GetClassNameString() << "::operator=(BOOL v)\n"
1636 "{\n"
1637 " SetValue(v);\n"
1638 " return *this;\n"
1639 "}\n"
1640 "\n"
1641 "\n";
1642 }
1643 }
1644
1645
1646 const char * BooleanType::GetAncestorClass() const
1647 {
1648 return "PASN_Boolean";
1649 }
1650
1651
1652 /////////////////////////////////////////////////////////
1653
1654 IntegerType::IntegerType()
1655 : TypeBase(Tag::UniversalInteger)
1656 {
1657 }
1658
1659
1660 IntegerType::IntegerType(NamedNumberList * lst)
1661 : TypeBase(Tag::UniversalInteger),
1662 allowedValues(*lst)
1663 {
1664 delete lst;
1665 }
1666
1667
1668 void IntegerType::GenerateOperators(ostream & hdr, ostream & cxx, const TypeBase & actualType)
1669 {
1670 hdr << " " << actualType.GetIdentifier() << " & operator=(int v)";
1671 if (Module->UsingInlines())
1672 hdr << " { SetValue(v); return *this; }\n";
1673 else {
1674 hdr << ";\n";
1675 cxx << actualType.GetTemplatePrefix()
1676 << actualType.GetIdentifier() << " & "
1677 << actualType.GetClassNameString() << "::operator=(int v)\n"
1678 "{\n"
1679 " SetValue(v);\n"
1680 " return *this;\n"
1681 "}\n"
1682 "\n"
1683 "\n";
1684 }
1685
1686 hdr << " " << actualType.GetIdentifier() << " & operator=(unsigned v)";
1687 if (Module->UsingInlines())
1688 hdr << " { SetValue(v); return *this; }\n";
1689 else {
1690 hdr << ";\n";
1691 cxx << actualType.GetTemplatePrefix()
1692 << actualType.GetIdentifier() << " & "
1693 << actualType.GetClassNameString() << "::operator=(unsigned v)\n"
1694 "{\n"
1695 " SetValue(v);\n"
1696 " return *this;\n"
1697 "}\n"
1698 "\n"
1699 "\n";
1700 }
1701 }
1702
1703
1704 const char * IntegerType::GetAncestorClass() const
1705 {
1706 return "PASN_Integer";
1707 }
1708
1709
1710 /////////////////////////////////////////////////////////
1711
1712 EnumeratedType::EnumeratedType(NamedNumberList * enums, BOOL extend, NamedNumberList * ext)
1713 : TypeBase(Tag::UniversalEnumeration),
1714 enumerations(*enums)
1715 {
1716 numEnums = enums->GetSize();
1717 delete enums;
1718 extendable = extend;
1719 if (ext != NULL) {
1720 ext->DisallowDeleteObjects();
1721 for (PINDEX i = 0; i < ext->GetSize(); i++)
1722 enumerations.Append(ext->GetAt(i));
1723 delete ext;
1724 }
1725 }
1726
1727
1728 void EnumeratedType::PrintOn(ostream & strm) const
1729 {
1730 PrintStart(strm);
1731 strm << '\n';
1732 PINDEX i;
1733 for (i = 0; i < numEnums; i++)
1734 strm << indent() << enumerations[i] << '\n';
1735 if (extendable) {
1736 strm << "...\n";
1737 for (; i < enumerations.GetSize(); i++)
1738 strm << indent() << enumerations[i] << '\n';
1739 }
1740 PrintFinish(strm);
1741 }
1742
1743
1744 TypeBase * EnumeratedType::FlattenThisType(const TypeBase & parent)
1745 {
1746 return new DefinedType(this, parent);
1747 }
1748
1749
1750 void EnumeratedType::GenerateCplusplus(ostream & hdr, ostream & cxx)
1751 {
1752 PINDEX i;
1753 PArgList & args = PProcess::Current().GetArguments();
1754 BOOL xml_output = args.HasOption('x');
1755
1756 BeginGenerateCplusplus(hdr, cxx);
1757
1758 int maxEnumValue = 0;
1759 for (i = 0; i < enumerations.GetSize(); i++) {
1760 int num = enumerations[i].GetNumber();
1761 if (maxEnumValue < num)
1762 maxEnumValue = num;
1763 }
1764
1765 // Generate enumerations and complete the constructor implementation
1766 hdr << " enum Enumerations {\n";
1767 cxx << ", " << maxEnumValue << ", " << (extendable ? "TRUE" : "FALSE") << "\n"
1768 "#ifndef PASN_NOPRINTON\n"
1769 " , \"";
1770
1771 int prevNum = -1;
1772 for (i = 0; i < enumerations.GetSize(); i++) {
1773 if (i > 0) {
1774 hdr << ",\n";
1775 cxx << " \"";
1776 }
1777
1778 hdr << " e_" << MakeIdentifierC(enumerations[i].GetName());
1779 cxx << enumerations[i].GetName();
1780
1781 int num = enumerations[i].GetNumber();
1782 if (num != prevNum+1) {
1783 hdr << " = " << num;
1784 cxx << '=' << num;
1785 }
1786 prevNum = num;
1787
1788 cxx << " \"\n";
1789 }
1790
1791 hdr << "\n"
1792 " };\n"
1793 "\n";
1794 cxx << "#endif\n"
1795 " )\n"
1796 "{\n";
1797 GenerateCplusplusConstraints(PString(), hdr, cxx);
1798
1799 if (xml_output)
1800 {
1801 hdr << " BOOL DecodeXER(PXER_Stream & strm);\n"
1802 " void EncodeXER(PXER_Stream & strm) const;\n";
1803
1804 cxx << "}\n"
1805 "\n"
1806 << GetTemplatePrefix()
1807 << "BOOL " << GetClassNameString() << "::DecodeXER(PXER_Stream & strm)\n"
1808 "{\n"
1809 " PXMLElement * elem = strm.GetCurrentElement();\n"
1810 " PXMLObject * sub_elem = elem->GetElement();\n"
1811 "\n"
1812 " if (!elem || !elem->IsElement())\n"
1813 " return FALSE;\n"
1814 "\n"
1815 " PCaselessString id = ((PXMLElement *)sub_elem)->GetName();\n"
1816 "\n"
1817 " ";
1818
1819 for (i = 0 ; i < enumerations.GetSize() ; i++) {
1820 cxx << " if (id == \"" << enumerations[i].GetName() << "\") {\n"
1821 " value = " << enumerations[i].GetNumber() << ";\n"
1822 " return TRUE;\n"
1823 " }\n"
1824 " else";
1825 }
1826
1827 cxx << "\n"
1828 " return FALSE;\n"
1829 "}\n"
1830 "\n";
1831
1832 cxx << GetTemplatePrefix()
1833 << "void " << GetClassNameString() << "::EncodeXER(PXER_Stream & strm) const\n"
1834 "{\n"
1835 " PXMLElement * elem = strm.GetCurrentElement();\n"
1836 " PString id;\n"
1837 "\n"
1838 " switch(value)\n"
1839 " {\n";
1840
1841 for (i = 0 ; i < enumerations.GetSize() ; i++) {
1842 cxx << " case " << enumerations[i].GetNumber() << ":\n"
1843 " elem->AddChild(new PXMLElement(elem, \"" << enumerations[i].GetName() << "\"));\n"
1844 " break;\n";
1845 }
1846
1847 cxx << " default:\n"
1848 " break;\n"
1849 " }\n";
1850 }
1851
1852 EndGenerateCplusplus(hdr, cxx);
1853 }
1854
1855
1856 void EnumeratedType::GenerateOperators(ostream & hdr, ostream & cxx, const TypeBase & actualType)
1857 {
1858 hdr << " " << actualType.GetIdentifier() << " & operator=(unsigned v)";
1859 if (Module->UsingInlines())
1860 hdr << " { SetValue(v); return *this; }\n";
1861 else {
1862 hdr << ";\n";
1863 cxx << actualType.GetTemplatePrefix()
1864 << actualType.GetIdentifier() << " & "
1865 << actualType.GetClassNameString() << "::operator=(unsigned v)\n"
1866 "{\n"
1867 " SetValue(v);\n"
1868 " return *this;\n"
1869 "}\n"
1870 "\n"
1871 "\n";
1872 }
1873 }
1874
1875
1876 const char * EnumeratedType::GetAncestorClass() const
1877 {
1878 return "PASN_Enumeration";
1879 }
1880
1881
1882 /////////////////////////////////////////////////////////
1883
1884 RealType::RealType()
1885 : TypeBase(Tag::UniversalReal)
1886 {
1887 }
1888
1889
1890 const char * RealType::GetAncestorClass() const
1891 {
1892 return "PASN_Real";
1893 }
1894
1895
1896 /////////////////////////////////////////////////////////
1897
1898 BitStringType::BitStringType()
1899 : TypeBase(Tag::UniversalBitString)
1900 {
1901 }
1902
1903
1904 BitStringType::BitStringType(NamedNumberList * lst)
1905 : TypeBase(Tag::UniversalBitString),
1906 allowedBits(*lst)
1907 {
1908 delete lst;
1909 }
1910
1911 int BitStringType::GetIdentifierTokenContext() const
1912 {
1913 return OID_IDENTIFIER;
1914 }
1915
1916
1917 int BitStringType::GetBraceTokenContext() const
1918 {
1919 return BITSTRING_BRACE;
1920 }
1921
1922
1923 const char * BitStringType::GetAncestorClass() const
1924 {
1925 return "PASN_BitString";
1926 }
1927
1928
1929 /////////////////////////////////////////////////////////
1930
1931 OctetStringType::OctetStringType()
1932 : TypeBase(Tag::UniversalOctetString)
1933 {
1934 }
1935
1936
1937 void OctetStringType::GenerateOperators(ostream & hdr, ostream & cxx, const TypeBase & actualType)
1938 {
1939 static const char * const types[] = {
1940 "char *", "PString &", "PBYTEArray &"
1941 };
1942
1943 PINDEX i;
1944 for (i = 0; i < PARRAYSIZE(types); i++) {
1945 hdr << " " << actualType.GetIdentifier() << "(const " << types[i] << " v)";
1946 if (Module->UsingInlines())
1947 hdr << " { SetValue(v); }\n";
1948 else {
1949 hdr << ";\n";
1950 cxx << actualType.GetTemplatePrefix()
1951 << actualType.GetIdentifier() << "::" << actualType.GetIdentifier() << "(const " << types[i] << " v)\n"
1952 "{\n"
1953 " SetValue(v);\n"
1954 "}\n"
1955 "\n"
1956 "\n";
1957 }
1958 }
1959
1960 hdr << '\n';
1961
1962 for (i = 0; i < PARRAYSIZE(types); i++) {
1963 hdr << " " << actualType.GetIdentifier() << " & operator=(const " << types[i] << " v)";
1964 if (Module->UsingInlines())
1965 hdr << " { SetValue(v); return *this; }\n";
1966 else {
1967 hdr << ";\n";
1968 cxx << actualType.GetTemplatePrefix()
1969 << actualType.GetIdentifier() << " & "
1970 << actualType.GetClassNameString() << "::operator=(const " << types[i] << " v)\n"
1971 "{\n"
1972 " SetValue(v);\n"
1973 " return *this;\n"
1974 "}\n"
1975 "\n"
1976 "\n";
1977 }
1978 }
1979 }
1980
1981
1982 const char * OctetStringType::GetAncestorClass() const
1983 {
1984 return "PASN_OctetString";
1985 }
1986
1987
1988 /////////////////////////////////////////////////////////
1989
1990 NullType::NullType()
1991 : TypeBase(Tag::UniversalNull)
1992 {
1993 }
1994
1995
1996 const char * NullType::GetAncestorClass() const
1997 {
1998 return "PASN_Null";
1999 }
2000
2001
2002 /////////////////////////////////////////////////////////
2003
2004 SequenceType::SequenceType(TypesList * stnd,
2005 BOOL extend,
2006 TypesList * ext,
2007 unsigned tagNum)
2008 : TypeBase(tagNum)
2009 {
2010 if (stnd != NULL) {
2011 numFields = stnd->GetSize();
2012 fields = *stnd;
2013 delete stnd;
2014 }
2015 else
2016 numFields = 0;
2017 extendable = extend;
2018 if (ext != NULL) {
2019 ext->DisallowDeleteObjects();
2020 for (PINDEX i = 0; i < ext->GetSize(); i++)
2021 fields.Append(ext->GetAt(i));
2022 delete ext;
2023 }
2024 }
2025
2026
2027 void SequenceType::PrintOn(ostream & strm) const
2028 {
2029 PrintStart(strm);
2030 strm << '\n';
2031 PINDEX i;
2032 for (i = 0; i < numFields; i++)
2033 strm << fields[i];
2034 if (extendable) {
2035 strm << indent() << "...\n";
2036 for (; i < fields.GetSize(); i++)
2037 strm << fields[i];
2038 }
2039 PrintFinish(strm);
2040 }
2041
2042
2043 void SequenceType::FlattenUsedTypes()
2044 {
2045 for (PINDEX i = 0; i < fields.GetSize(); i++)
2046 fields.SetAt(i, fields[i].FlattenThisType(*this));
2047 }
2048
2049
2050 TypeBase * SequenceType::FlattenThisType(const TypeBase & parent)
2051 {
2052 return new DefinedType(this, parent);
2053 }
2054
2055
2056 BOOL SequenceType::IsPrimitiveType() const
2057 {
2058 return FALSE;
2059 }
2060
2061
2062 void SequenceType::GenerateCplusplus(ostream & hdr, ostream & cxx)
2063 {
2064 PArgList & args = PProcess::Current().GetArguments();
2065 BOOL xml_output = args.HasOption('x');
2066
2067 PINDEX i;
2068
2069 BeginGenerateCplusplus(hdr, cxx);
2070
2071 PINDEX baseOptions = 0;
2072 for (i = 0; i < fields.GetSize(); i++) {
2073 if (i < numFields && fields[i].IsOptional())
2074 baseOptions++;
2075 }
2076
2077 // Complete ancestor constructor parameters
2078 cxx << ", " << baseOptions << ", "
2079 << (extendable ? "TRUE" : "FALSE") << ", "
2080 << fields.GetSize() - numFields
2081 << ')';
2082
2083 // Output enum for optional parameters
2084 BOOL outputEnum = FALSE;
2085 for (i = 0; i < fields.GetSize(); i++) {
2086 if (i >= numFields || fields[i].IsOptional()) {
2087 if (outputEnum)
2088 hdr << ",\n";
2089 else {
2090 hdr << " enum OptionalFields {\n";
2091 outputEnum = TRUE;
2092 }
2093 hdr << " e_" << fields[i].GetIdentifier();
2094 }
2095 }
2096
2097 if (outputEnum)
2098 hdr << "\n"
2099 " };\n"
2100 "\n";
2101
2102 // Output the declarations and constructors for member variables
2103 for (i = 0; i < fields.GetSize(); i++) {
2104 PString varname = "m_" + fields[i].GetIdentifier();
2105 hdr << " " << fields[i].GetTypeName() << ' ' << varname << ";\n";
2106 if (fields[i].HasNonStandardTag()) {
2107 cxx << ",\n"
2108 " " << varname;
2109 fields[i].GenerateCplusplusConstructor(hdr, cxx);
2110 }
2111 }
2112
2113 // Output declarations for generated functions
2114 hdr << "\n"
2115 " PINDEX GetDataLength() const;\n"
2116 " BOOL Decode(PASN_Stream & strm);\n"
2117 " void Encode(PASN_Stream & strm) const;\n"
2118 "#ifndef PASN_NOPRINTON\n"
2119 " void PrintOn(ostream & strm) const;\n"
2120 "#endif\n";
2121
2122 if (xml_output)
2123 {
2124 hdr << " BOOL PreambleDecodeXER(PXER_Stream & strm);\n";
2125
2126 if (fields.GetSize())
2127 hdr << " void PreambleEncodeXER(PXER_Stream &) const;\n";
2128 }
2129
2130
2131 if (numFields > 0)
2132 hdr << " Comparison Compare(const PObject & obj) const;\n";
2133
2134 cxx << "\n"
2135 "{\n";
2136 GenerateCplusplusConstraints(PString(), hdr, cxx);
2137 for (i = 0; i < fields.GetSize(); i++) {
2138 PString ident = fields[i].GetIdentifier();
2139 fields[i].GenerateCplusplusConstraints("m_" + ident + ".", hdr, cxx);
2140 if (i >= numFields && !fields[i].IsOptional())
2141 cxx << " IncludeOptionalField(e_" << ident << ");\n";
2142 }
2143 cxx << "}\n"
2144 "\n"
2145 "\n"
2146 "#ifndef PASN_NOPRINTON\n"
2147 << GetTemplatePrefix()
2148 << "void " << GetClassNameString() << "::PrintOn(ostream & strm) const\n"
2149 "{\n"
2150 " int indent = strm.precision() + 2;\n"
2151 " strm << \"{\\n\";\n";
2152
2153 for (i = 0; i < fields.GetSize(); i++) {
2154 PString id = fields[i].GetIdentifier();
2155 if (i >= numFields || fields[i].IsOptional())
2156 cxx << " if (HasOptionalField(e_" << id << "))\n"
2157 " ";
2158 cxx << " strm << setw(indent+" << id.GetLength()+3 << ") << \""
2159 << id << " = \" << setprecision(indent) << m_" << id << " << '\\n';\n";
2160 }
2161
2162 cxx << " strm << setw(indent-1) << \"}\";\n"
2163 "}\n"
2164 "#endif\n"
2165 "\n"
2166 "\n";
2167
2168 if (xml_output)
2169 {
2170 cxx << GetTemplatePrefix()
2171 << "BOOL " << GetClassNameString() << "::PreambleDecodeXER(PXER_Stream & strm)\n"
2172 "{\n";
2173
2174 if (fields.GetSize())
2175 {
2176 cxx << " PXMLElement * elem = strm.GetCurrentElement();\n"
2177 " PXMLElement * sub_elem;\n"
2178 " BOOL result;\n"
2179 "\n";
2180
2181 for (i = 0; i < fields.GetSize(); i++)
2182 {
2183 PString id = fields[i].GetIdentifier();
2184 cxx << " if ((sub_elem = (PXMLElement *)elem->GetElement(\"" << id << "\")) && sub_elem->IsElement())\n"
2185 " {\n";
2186
2187 if (i >= numFields || fields[i].IsOptional())
2188 cxx << " IncludeOptionalField(e_" << id << ");\n";
2189
2190 cxx << " strm.SetCurrentElement(sub_elem);\n"
2191 " result = m_" << id << ".Decode(strm);\n"
2192 " strm.SetCurrentElement(sub_elem);\n"
2193 " if (!result)\n"
2194 " return FALSE;\n"
2195 " }\n"
2196 "\n";
2197 }
2198 }
2199
2200 cxx << " return TRUE;\n"
2201 "}\n"
2202 "\n";
2203
2204 if (fields.GetSize())
2205 {
2206 cxx << GetTemplatePrefix()
2207 << "void " << GetClassNameString() << "::PreambleEncodeXER(PXER_Stream & strm) const\n"
2208 "{\n";
2209
2210 cxx << " PXMLElement * elem = strm.GetCurrentElement();\n"
2211 " PXMLElement * sub_elem;\n"
2212 "\n";
2213
2214 for (i = 0; i < fields.GetSize(); i++)
2215 {
2216 PString id = fields[i].GetIdentifier();
2217
2218 if (i >= numFields || fields[i].IsOptional())
2219 cxx << " if (HasOptionalField(e_" << id << "))\n"
2220 " {\n";
2221
2222 cxx << " sub_elem = elem->AddChild(new PXMLElement(elem, \"" << id << "\"));\n"
2223 " strm.SetCurrentElement(sub_elem);\n"
2224 " m_" << id << ".Encode(strm);\n";
2225
2226 if (i >= numFields || fields[i].IsOptional())
2227 cxx << " }\n";
2228
2229 cxx << "\n";
2230 }
2231
2232 cxx << " strm.SetCurrentElement(elem);\n"
2233 "}\n"
2234 "\n";
2235 }
2236 }
2237
2238 if (numFields > 0) {
2239 cxx << GetTemplatePrefix()
2240 << "PObject::Comparison " << GetClassNameString() << "::Compare(const PObject & obj) const\n"
2241 "{\n"
2242 "#ifndef PASN_LEANANDMEAN\n"
2243 " PAssert(PIsDescendant(this, " << GetClassNameString() << "), PInvalidCast);\n"
2244 "#endif\n"
2245 " const " << GetClassNameString() << " & other = (const " << GetClassNameString() << " &)obj;\n"
2246 "\n"
2247 " Comparison result;\n"
2248 "\n";
2249
2250 for (i = 0; i < numFields; i++) {
2251 PString identifier = fields[i].GetIdentifier();
2252 cxx << " if ((result = m_" << identifier << ".Compare(other.m_" << identifier << ")) != EqualTo)\n"
2253 " return result;\n";
2254 }
2255
2256 cxx << "\n"
2257 " return PASN_Sequence::Compare(other);\n"
2258 "}\n"
2259 "\n"
2260 "\n";
2261 }
2262
2263 cxx << GetTemplatePrefix()
2264 << "PINDEX " << GetClassNameString() << "::GetDataLength() const\n"
2265 "{\n"
2266 " PINDEX length = 0;\n";
2267
2268 for (i = 0; i < numFields; i++) {
2269 if (fields[i].IsOptional())
2270 cxx << " if (HasOptionalField(e_" << fields[i].GetIdentifier() << "))\n ";
2271 cxx << " length += m_" << fields[i].GetIdentifier() << ".GetObjectLength();\n";
2272 }
2273
2274 cxx << " return length;\n"
2275 "}\n"
2276 "\n"
2277 "\n"
2278 << GetTemplatePrefix()
2279 << "BOOL " << GetClassNameString() << "::Decode(PASN_Stream & strm)\n"
2280 "{\n"
2281 " if (!PreambleDecode(strm))\n"
2282 " return FALSE;\n\n";
2283
2284 if (xml_output)
2285 {
2286 cxx << " if (PIsDescendant(&strm, PXER_Stream))\n"
2287 " return TRUE;\n\n";
2288 }
2289
2290 for (i = 0; i < numFields; i++) {
2291 cxx << " if (";
2292 if (fields[i].IsOptional())
2293 cxx << "HasOptionalField(e_" << fields[i].GetIdentifier() << ") && ";
2294 cxx << "!m_" << fields[i].GetIdentifier() << ".Decode(strm))\n"
2295 " return FALSE;\n";
2296 }
2297
2298 for (; i < fields.GetSize(); i++)
2299 cxx << " if (!KnownExtensionDecode(strm, e_"
2300 << fields[i].GetIdentifier()
2301 << ", m_" << fields[i].GetIdentifier() << "))\n"
2302 " return FALSE;\n";
2303
2304 cxx << "\n"
2305 " return UnknownExtensionsDecode(strm);\n"
2306 "}\n"
2307 "\n"
2308 "\n"
2309 << GetTemplatePrefix()
2310 << "void " << GetClassNameString() << "::Encode(PASN_Stream & strm) const\n"
2311 "{\n"
2312 " PreambleEncode(strm);\n\n";
2313
2314 if (xml_output)
2315 {
2316 cxx << " if (PIsDescendant(&strm, PXER_Stream))\n"
2317 " return;\n\n";
2318 }
2319
2320 for (i = 0; i < numFields; i++) {
2321 if (fields[i].IsOptional())
2322 cxx << " if (HasOptionalField(e_" << fields[i].GetIdentifier() << "))\n"
2323 " ";
2324 cxx << " m_" << fields[i].GetIdentifier() << ".Encode(strm);\n";
2325 }
2326
2327 for (; i < fields.GetSize(); i++)
2328 cxx << " KnownExtensionEncode(strm, e_"
2329 << fields[i].GetIdentifier()
2330 << ", m_" << fields[i].GetIdentifier() << ");\n";
2331
2332 cxx << "\n"
2333 " UnknownExtensionsEncode(strm);\n";
2334
2335 EndGenerateCplusplus(hdr, cxx);
2336 }
2337
2338
2339 const char * SequenceType::GetAncestorClass() const
2340 {
2341 return "PASN_Sequence";
2342 }
2343
2344
2345 BOOL SequenceType::CanReferenceType() const
2346 {
2347 return TRUE;
2348 }
2349
2350
2351 BOOL SequenceType::ReferencesType(const TypeBase & type)
2352 {
2353 for (PINDEX i = 0; i < fields.GetSize(); i++)
2354 if (fields[i].ReferencesType(type))
2355 return TRUE;
2356 return FALSE;
2357 }
2358
2359
2360 /////////////////////////////////////////////////////////
2361
2362 SequenceOfType::SequenceOfType(TypeBase * base, Constraint * constraint, unsigned tag)
2363 : TypeBase(tag)
2364 {
2365 baseType = base;
2366 if (constraint != NULL)
2367 AddConstraint(constraint);
2368 }
2369
2370
2371 SequenceOfType::~SequenceOfType()
2372 {
2373 delete baseType;
2374 }
2375
2376
2377 void SequenceOfType::PrintOn(ostream & strm) const
2378 {
2379 PrintStart(strm);
2380 if (baseType == NULL)
2381 strm << "!!Null Type!!\n";
2382 else
2383 strm << *baseType << '\n';
2384 PrintFinish(strm);
2385 }
2386
2387
2388 void SequenceOfType::FlattenUsedTypes()
2389 {
2390 baseType = baseType->FlattenThisType(*this);
2391 }
2392
2393
2394 TypeBase * SequenceOfType::FlattenThisType(const TypeBase & parent)
2395 {
2396 if (!baseType->IsPrimitiveType() || baseType->HasConstraints())
2397 return new DefinedType(this, parent);
2398
2399 // Search for an existing sequence of type
2400 PString seqName = "ArrayOf_" + baseType->GetTypeName();
2401
2402 TypeBase * existingType = Module->FindType(seqName);
2403 if (existingType != NULL)
2404 return new DefinedType(this, existingType);
2405
2406 return new DefinedType(this, seqName);
2407 }
2408
2409
2410 BOOL SequenceOfType::IsPrimitiveType() const
2411 {
2412 return FALSE;
2413 }
2414
2415
2416 void SequenceOfType::GenerateCplusplus(ostream & hdr, ostream & cxx)
2417 {
2418 BeginGenerateCplusplus(hdr, cxx);
2419 cxx << ")\n"
2420 "{\n";
2421 GenerateCplusplusConstraints(PString(), hdr, cxx);
2422 cxx << "}\n"
2423 "\n"
2424 "\n";
2425
2426 PString baseTypeName = baseType->GetTypeName();
2427
2428 // Generate declarations for generated functions
2429 hdr << " PASN_Object * CreateObject() const;\n"
2430 " " << baseTypeName << " & operator[](PINDEX i) const";
2431 if (Module->UsingInlines())
2432 hdr << " { return (" << baseTypeName << " &)array[i]; }\n";
2433 else
2434 hdr << ";\n";
2435
2436 // Generate implementation for functions
2437 cxx << GetTemplatePrefix()
2438 << "PASN_Object * " << GetClassNameString() << "::CreateObject() const\n"
2439 "{\n";
2440
2441 if (baseType->HasConstraints()) {
2442 cxx << " " << baseTypeName << " * obj = new " << baseTypeName << ";\n";
2443 baseType->GenerateCplusplusConstraints("obj->", hdr, cxx);
2444 cxx << " return obj;\n";
2445 }
2446 else
2447 cxx << " return new " << baseTypeName << ";\n";
2448
2449 if (!Module->UsingInlines())
2450 cxx << "}\n"
2451 "\n"
2452 "\n"
2453 << GetTemplatePrefix()
2454 << baseTypeName << " & " << GetClassNameString() << "::operator[](PINDEX i) const\n"
2455 "{\n"
2456 " return (" << baseTypeName << " &)array[i];\n";
2457
2458 EndGenerateCplusplus(hdr, cxx);
2459 }
2460
2461
2462 void SequenceOfType::GenerateForwardDecls(ostream & hdr)
2463 {
2464 if (baseType->IsParameterizedType())
2465 return;
2466
2467 PString baseTypeName = baseType->GetTypeName();
2468
2469 PStringSet typesOutput(PARRAYSIZE(StandardClasses), StandardClasses);
2470 typesOutput += GetIdentifier();
2471
2472 if (!typesOutput.Contains(baseTypeName))
2473 hdr << "class " << baseTypeName << ";\n\n";
2474 }
2475
2476
2477 const char * SequenceOfType::GetAncestorClass() const
2478 {
2479 return "PASN_Array";
2480 }
2481
2482
2483 BOOL SequenceOfType::CanReferenceType() const
2484 {
2485 return TRUE;
2486 }
2487
2488
2489 BOOL SequenceOfType::ReferencesType(const TypeBase & type)
2490 {
2491 return baseType->ReferencesType(type) && baseType->IsParameterizedType();
2492 }
2493
2494
2495 /////////////////////////////////////////////////////////
2496
2497 SetType::SetType()
2498 : SequenceType(NULL, FALSE, NULL, Tag::UniversalSet)
2499 {
2500 }
2501
2502
2503 SetType::SetType(SequenceType * seq)
2504 : SequenceType(*seq)
2505 {
2506 tag.number = Tag::UniversalSet;
2507 }
2508
2509
2510 const char * SetType::GetAncestorClass() const
2511 {
2512 return "PASN_Set";
2513 }
2514
2515
2516 /////////////////////////////////////////////////////////
2517
2518 SetOfType::SetOfType(TypeBase * base, Constraint * constraint)
2519 : SequenceOfType(base, constraint, Tag::UniversalSet)
2520 {
2521 }
2522
2523
2524 /////////////////////////////////////////////////////////
2525
2526 ChoiceType::ChoiceType(TypesList * stnd,
2527 BOOL extendable,
2528 TypesList * extensions)
2529 : SequenceType(stnd, extendable, extensions, Tag::IllegalUniversalTag)
2530 {
2531 }
2532
2533
2534 void ChoiceType::GenerateCplusplus(ostream & hdr, ostream & cxx)
2535 {
2536 PINDEX i;
2537
2538
2539 BeginGenerateCplusplus(hdr, cxx);
2540
2541 // Complete the ancestor constructor parameters
2542 cxx << ", " << numFields << ", " << (extendable ? "TRUE" : "FALSE");
2543
2544 // Generate the enum's for each choice discriminator, and include strings for
2545 // PrintOn() debug output into acncestor constructor
2546 BOOL outputEnum = FALSE;
2547 int prevNum = -1;
2548 for (i = 0; i < fields.GetSize(); i++) {
2549 const Tag & fieldTag = fields[i].GetTag();
2550 if (fieldTag.mode == Tag::Automatic || !fields[i].IsChoice()) {
2551 if (outputEnum) {
2552 hdr << ",\n";
2553 cxx << " \"";
2554 }
2555 else {
2556 hdr << " enum Choices {\n";
2557 cxx << "\n"
2558 "#ifndef PASN_NOPRINTON\n"
2559 " , \"";
2560 outputEnum = TRUE;
2561 }
2562
2563 hdr << " e_" << fields[i].GetIdentifier();
2564 cxx << fields[i].GetIdentifier();
2565
2566 if (fieldTag.mode != Tag::Automatic && fieldTag.number != (unsigned)(prevNum+1)) {
2567 hdr << " = " << fieldTag.number;
2568 cxx << '=' << fieldTag.number;
2569 }
2570 prevNum = fieldTag.number;
2571 cxx << " \"\n";
2572 }
2573 }
2574
2575 if (outputEnum) {
2576 hdr << "\n"
2577 " };\n"
2578 "\n";
2579 cxx << "#endif\n"
2580 " ";
2581 }
2582
2583 cxx << ")\n"
2584 "{\n";
2585 GenerateCplusplusConstraints(PString(), hdr, cxx);
2586 cxx << "}\n"
2587 "\n"
2588 "\n";
2589
2590 // Generate code for type safe cast operators of selected choice object
2591 BOOL needExtraLine = FALSE;
2592
2593 if (Module->UsingOperators()) {
2594 PStringSet typesOutput(PARRAYSIZE(StandardClasses), StandardClasses);
2595 typesOutput += GetIdentifier();
2596
2597 for (i = 0; i < fields.GetSize(); i++) {
2598 PString type = fields[i].GetTypeName();
2599 if (!typesOutput.Contains(type)) {
2600 if (Module->UsingInlines()) {
2601 hdr << "#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9\n"
2602 " operator " << type << " &() const { return *(" << type << " *)choice; }\n"
2603 "#else\n"
2604 " operator " << type << " &() { return *(" << type << " *)choice; }\n"
2605 " operator const " << type << " &() const { return *(const " << type << " *)choice; }\n"
2606 "#endif\n";
2607 }
2608 else {
2609 hdr << "#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9\n"
2610 " operator " << type << " &() const;\n"
2611 "#else\n"
2612 " operator " << type << " &();\n"
2613 " operator const " << type << " &() const;\n"
2614 "#endif\n";
2615 cxx << "#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9\n"
2616 << GetTemplatePrefix()
2617 << GetClassNameString() << "::operator " << type << " &() const\n"
2618 "#else\n"
2619 << GetTemplatePrefix()
2620 << GetClassNameString() << "::operator " << type << " &()\n"
2621 "{\n"
2622 "#ifndef PASN_LEANANDMEAN\n"
2623 " PAssert(PIsDescendant(PAssertNULL(choice), " << type << "), PInvalidCast);\n"
2624 "#endif\n"
2625 " return *(" << type << " *)choice;\n"
2626 "}\n"
2627 "\n"
2628 "\n"
2629 << GetTemplatePrefix()
2630 << GetClassNameString() << "::operator const " << type << " &() const\n"
2631 "#endif\n"
2632 "{\n"
2633 "#ifndef PASN_LEANANDMEAN\n"
2634 " PAssert(PIsDescendant(PAssertNULL(choice), " << type << "), PInvalidCast);\n"
2635 "#endif\n"
2636 " return *(" << type << " *)choice;\n"
2637 "}\n"
2638 "\n"
2639 "\n";
2640 }
2641 typesOutput += type;
2642 needExtraLine = TRUE;
2643 }
2644 }
2645 }
2646 else {
2647 for (i = 0; i < fields.GetSize(); i++) {
2648 PString type = fields[i].GetTypeName();
2649 PString fieldName = fields[i].GetIdentifier();
2650 if (Module->UsingInlines()) {
2651 hdr << " " << type << " & m_" << fieldName << "() { return *(" << type << " *)choice; }\n"
2652 " const " << type << " & m_" << fieldName << "() const { return *(const " << type << " *)choice; }\n";
2653 }
2654 else {
2655 hdr << " " << type << " & m_" << fieldName << "();\n"
2656 " const " << type << " & m_" << fieldName << "() const;\n";
2657 cxx << GetTemplatePrefix() << type << " & "
2658 << GetClassNameString() << "::m_" << fieldName << "()\n"
2659 "{\n"
2660 "#ifndef PASN_LEANANDMEAN\n"
2661 " PAssert(PIsDescendant(PAssertNULL(choice), " << type << "), PInvalidCast);\n"
2662 "#endif\n"
2663 " return *(" << type << " *)choice;\n"
2664 "}\n"
2665 "\n"
2666 "\n"
2667 << GetTemplatePrefix() << type << " const & "
2668 << GetClassNameString() << "::m_" << fieldName << "() const\n"
2669 "{\n"
2670 "#ifndef PASN_LEANANDMEAN\n"
2671 " PAssert(PIsDescendant(PAssertNULL(choice), " << type << "), PInvalidCast);\n"
2672 "#endif\n"
2673 " return *(" << type << " *)choice;\n"
2674 "}\n"
2675 "\n"
2676 "\n";
2677 }
2678 }
2679 needExtraLine = TRUE;
2680 }
2681
2682 if (needExtraLine)
2683 hdr << '\n';
2684
2685
2686 // Generate virtual function to create chosen object based on discriminator
2687 hdr << " BOOL CreateObject();\n";
2688 cxx << GetTemplatePrefix()
2689 << "BOOL " << GetClassNameString() << "::CreateObject()\n"
2690 "{\n";
2691
2692 // special case: if choice is all NULLs then simply output code
2693 BOOL allNull = TRUE;
2694 for (i = 0; allNull && i < fields.GetSize(); i++)
2695 allNull = allNull && strcmp(fields[i].GetAncestorClass(), "PASN_Null") == 0;
2696
2697 if (allNull) {
2698 cxx << " choice = (tag <= e_" << fields[fields.GetSize()-1].GetIdentifier() << ") ? new PASN_Null() : NULL;\n"
2699 << " return choice != NULL;\n";
2700 }
2701
2702 else {
2703 // declare an array of flags indicating whether the tag has been output or not
2704 PBYTEArray flags(fields.GetSize());
2705 for (i = 0; i < fields.GetSize(); i++)
2706 flags[i] = 0;
2707
2708 // keep
2709 outputEnum = FALSE;
2710 for (i = 0; i < fields.GetSize(); i++) {
2711
2712 if (fields[i].GetTag().mode == Tag::Automatic || !fields[i].IsChoice()) {
2713
2714 // ignore this tag if output previously
2715 if (flags[i] != 0)
2716 continue;
2717
2718 if (!outputEnum) {
2719 cxx << " switch (tag) {\n";
2720 outputEnum = TRUE;
2721 }
2722
2723 // if the field has constraints, then output it alone
2724 // otherwise, look for all fields with the same type
2725 PString name = fields[i].GetTypeName();
2726 if (fields[i].HasConstraints()) {
2727 cxx << " case e_" << fields[i].GetIdentifier() << " :\n";
2728 flags[i] = 1;
2729 } else {
2730 PINDEX j;
2731 for (j = i; j < fields.GetSize(); j++) {
2732 if (fields[j].GetTypeName() == name) {
2733 cxx << " case e_" << fields[j].GetIdentifier() << " :\n";
2734 flags[j] = 1;
2735 }
2736 }
2737 }
2738
2739 cxx << " choice = new " << name;
2740 fields[i].GenerateCplusplusConstructor(hdr, cxx);
2741 cxx << ";\n";
2742 fields[i].GenerateCplusplusConstraints(" choice->", hdr, cxx);
2743 cxx << " return TRUE;\n";
2744 }
2745 }
2746
2747 if (outputEnum)
2748 cxx << " }\n"
2749 "\n";
2750
2751 for (i = 0; i < fields.GetSize(); i++) {
2752 if (fields[i].GetTag().mode != Tag::Automatic && fields[i].IsChoice())
2753 cxx << " choice = new " << fields[i].GetTypeName() << "(tag, tagClass);\n"
2754 " if (((PASN_Choice*)choice)->CreateObject())\n"
2755 " return TRUE;\n"
2756 " delete choice;\n"
2757 "\n";
2758 }
2759
2760 cxx << " choice = NULL;\n"
2761 " return FALSE;\n";
2762 }
2763
2764 EndGenerateCplusplus(hdr, cxx);
2765 }
2766
2767
2768 void ChoiceType::GenerateForwardDecls(ostream & hdr)
2769 {
2770 // Output forward declarations for choice pointers, but not standard classes
2771 BOOL needExtraLine = FALSE;
2772
2773 PStringSet typesOutput(PARRAYSIZE(StandardClasses), StandardClasses);
2774 typesOutput += GetIdentifier();
2775
2776 PStringSet forwards;
2777
2778 for (PINDEX i = 0; i < fields.GetSize(); i++) {
2779 PString type = fields[i].GetTypeName();
2780 if (!fields[i].IsParameterizedType() &&
2781 !typesOutput.Contains(type) &&
2782 !forwards.Contains(type)) {
2783 hdr << "class " << type << ";\n";
2784 needExtraLine = TRUE;
2785 forwards.Include(type);
2786 }
2787 }
2788
2789 if (needExtraLine)
2790 hdr << '\n';
2791 }
2792
2793
2794 BOOL ChoiceType::IsPrimitiveType() const
2795 {
2796 return FALSE;
2797 }
2798
2799
2800 BOOL ChoiceType::IsChoice() const
2801 {
2802 return TRUE;
2803 }
2804
2805
2806 const char * ChoiceType::GetAncestorClass() const
2807 {
2808 return "PASN_Choice";
2809 }
2810
2811
2812 BOOL ChoiceType::ReferencesType(const TypeBase & type)
2813 {
2814 for (PINDEX i = 0; i < fields.GetSize(); i++) {
2815 if (fields[i].ReferencesType(type) && fields[i].IsParameterizedType())
2816 return TRUE;
2817 }
2818 return FALSE;
2819 }
2820
2821
2822 /////////////////////////////////////////////////////////
2823
2824 EmbeddedPDVType::EmbeddedPDVType()
2825 : TypeBase(Tag::UniversalEmbeddedPDV)
2826 {
2827 }
2828
2829
2830 const char * EmbeddedPDVType::GetAncestorClass() const
2831 {
2832 return "PASN_OctetString";
2833 }
2834
2835
2836 /////////////////////////////////////////////////////////
2837
2838 ExternalType::ExternalType()
2839 : TypeBase(Tag::UniversalExternalType)
2840 {
2841 }
2842
2843
2844 const char * ExternalType::GetAncestorClass() const
2845 {
2846 return "PASN_OctetString";
2847 }
2848
2849
2850 /////////////////////////////////////////////////////////
2851
2852 AnyType::AnyType(PString * ident)
2853 : TypeBase(Tag::UniversalExternalType)
2854 {
2855 if (ident != NULL) {
2856 identifier = *ident;
2857 delete ident;
2858 }
2859 }
2860
2861
2862 void AnyType::PrintOn(ostream & strm) const
2863 {
2864 PrintStart(strm);
2865 if (!identifier)
2866 strm << "Defined by " << identifier;
2867 PrintFinish(strm);
2868 }
2869
2870
2871 const char * AnyType::GetAncestorClass() const
2872 {
2873 return "PASN_OctetString";
2874 }
2875
2876
2877 /////////////////////////////////////////////////////////
2878
2879 StringTypeBase::StringTypeBase(int tag)
2880 : TypeBase(tag)
2881 {
2882 }
2883
2884
2885 int StringTypeBase::GetBraceTokenContext() const
2886 {
2887 return STRING_BRACE;
2888 }
2889
2890
2891 static void GenerateOperator(const char * rhsType, ostream & hdr, ostream & cxx, const TypeBase & actualType)
2892 {
2893 hdr << " " << actualType.GetIdentifier() << " & operator=(const " << rhsType << " v)";
2894 if (Module->UsingInlines())
2895 hdr << " { SetValue(v); return *this; }\n";
2896 else {
2897 hdr << ";\n";
2898 cxx << actualType.GetTemplatePrefix()
2899 << actualType.GetIdentifier() << " & "
2900 << actualType.GetClassNameString() << "::operator=(const " << rhsType << " v)\n"
2901 "{\n"
2902 " SetValue(v);\n"
2903 " return *this;\n"
2904 "}\n"
2905 "\n"
2906 "\n";
2907 }
2908 }
2909
2910
2911 void StringTypeBase::GenerateOperators(ostream & hdr, ostream & cxx, const TypeBase & actualType)
2912 {
2913 GenerateOperator("char *", hdr, cxx, actualType);
2914 GenerateOperator("PString &", hdr, cxx, actualType);
2915 }
2916
2917
2918 /////////////////////////////////////////////////////////
2919
2920 BMPStringType::BMPStringType()
2921 : StringTypeBase(Tag::UniversalBMPString)
2922 {
2923 }
2924
2925
2926 const char * BMPStringType::GetAncestorClass() const
2927 {
2928 return "PASN_BMPString";
2929 }
2930
2931
2932 void BMPStringType::GenerateOperators(ostream & hdr, ostream & cxx, const TypeBase & actualType)
2933 {
2934 StringTypeBase::GenerateOperators(hdr, cxx, actualType);
2935 GenerateOperator("PWORDArray &", hdr, cxx, actualType);
2936 GenerateOperator("PASN_BMPString &", hdr, cxx, actualType);
2937 }
2938
2939
2940 /////////////////////////////////////////////////////////
2941
2942 GeneralStringType::GeneralStringType()
2943 : StringTypeBase(Tag::UniversalGeneralString)
2944 {
2945 }
2946
2947
2948 const char * GeneralStringType::GetAncestorClass() const
2949 {
2950 return "PASN_GeneralString";
2951 }
2952
2953
2954 /////////////////////////////////////////////////////////
2955
2956 GraphicStringType::GraphicStringType()
2957 : StringTypeBase(Tag::UniversalGraphicString)
2958 {
2959 }
2960
2961
2962 const char * GraphicStringType::GetAncestorClass() const
2963 {
2964 return "PASN_GraphicString";
2965 }
2966
2967
2968 /////////////////////////////////////////////////////////
2969
2970 IA5StringType::IA5StringType()
2971 : StringTypeBase(Tag::UniversalIA5String)
2972 {
2973 }
2974
2975
2976 const char * IA5StringType::GetAncestorClass() const
2977 {
2978 return "PASN_IA5String";
2979 }
2980
2981
2982 /////////////////////////////////////////////////////////
2983
2984 ISO646StringType::ISO646StringType()
2985 : StringTypeBase(Tag::UniversalVisibleString)
2986 {
2987 }
2988
2989
2990 const char * ISO646StringType::GetAncestorClass() const
2991 {
2992 return "PASN_ISO646String";
2993 }
2994
2995
2996 /////////////////////////////////////////////////////////
2997
2998 NumericStringType::NumericStringType()
2999 : StringTypeBase(Tag::UniversalNumericString)
3000 {
3001 }
3002
3003
3004 const char * NumericStringType::GetAncestorClass() const
3005 {
3006 return "PASN_NumericString";
3007 }
3008
3009
3010 /////////////////////////////////////////////////////////
3011
3012 PrintableStringType::PrintableStringType()
3013 : StringTypeBase(Tag::UniversalPrintableString)
3014 {
3015 }
3016
3017
3018 const char * PrintableStringType::GetAncestorClass() const
3019 {
3020 return "PASN_PrintableString";
3021 }
3022
3023
3024 /////////////////////////////////////////////////////////
3025
3026 TeletexStringType::TeletexStringType()
3027 : StringTypeBase(Tag::UniversalTeletexString)
3028 {
3029 }
3030
3031
3032 const char * TeletexStringType::GetAncestorClass() const
3033 {
3034 return "PASN_TeletexString";
3035 }
3036
3037
3038 /////////////////////////////////////////////////////////
3039
3040 T61StringType::T61StringType()
3041 : StringTypeBase(Tag::UniversalTeletexString)
3042 {
3043 }
3044
3045
3046 const char * T61StringType::GetAncestorClass() const
3047 {
3048 return "PASN_T61String";
3049 }
3050
3051
3052 /////////////////////////////////////////////////////////
3053
3054 UniversalStringType::UniversalStringType()
3055 : StringTypeBase(Tag::UniversalUniversalString)
3056 {
3057 }
3058
3059
3060 const char * UniversalStringType::GetAncestorClass() const
3061 {
3062 return "PASN_UniversalString";
3063 }
3064
3065
3066 /////////////////////////////////////////////////////////
3067
3068 VideotexStringType::VideotexStringType()
3069 : StringTypeBase(Tag::UniversalVideotexString)
3070 {
3071 }
3072
3073
3074 const char * VideotexStringType::GetAncestorClass() const
3075 {
3076 return "PASN_VideotexString";
3077 }
3078
3079
3080 /////////////////////////////////////////////////////////
3081
3082 VisibleStringType::VisibleStringType()
3083 : StringTypeBase(Tag::UniversalVisibleString)
3084 {
3085 }
3086
3087
3088 const char * VisibleStringType::GetAncestorClass() const
3089 {
3090 return "PASN_VisibleString";
3091 }
3092
3093
3094 /////////////////////////////////////////////////////////
3095
3096 UnrestrictedCharacterStringType::UnrestrictedCharacterStringType()
3097 : StringTypeBase(Tag::UniversalUniversalString)
3098 {
3099 }
3100
3101
3102 const char * UnrestrictedCharacterStringType::GetAncestorClass() const
3103 {
3104 return "PASN_UnrestrictedString";
3105 }
3106
3107
3108 /////////////////////////////////////////////////////////
3109
3110 GeneralizedTimeType::GeneralizedTimeType()
3111 : TypeBase(Tag::UniversalGeneralisedTime)
3112 {
3113 }
3114
3115
3116 const char * GeneralizedTimeType::GetAncestorClass() const
3117 {
3118 return "PASN_GeneralisedTime";
3119 }
3120
3121
3122 /////////////////////////////////////////////////////////
3123
3124 UTCTimeType::UTCTimeType()
3125 : TypeBase(Tag::UniversalUTCTime)
3126 {
3127 }
3128
3129
3130 const char * UTCTimeType::GetAncestorClass() const
3131 {
3132 return "PASN_UniversalTime";
3133 }
3134
3135
3136 /////////////////////////////////////////////////////////
3137
3138 ObjectDescriptorType::ObjectDescriptorType()
3139 : TypeBase(Tag::UniversalObjectDescriptor)
3140 {
3141 }
3142
3143
3144 const char * ObjectDescriptorType::GetAncestorClass() const
3145 {
3146 return "PASN_ObectDescriptor";
3147 }
3148
3149
3150 /////////////////////////////////////////////////////////
3151
3152 ObjectIdentifierType::ObjectIdentifierType()
3153 : TypeBase(Tag::UniversalObjectId)
3154 {
3155 }
3156
3157
3158 int ObjectIdentifierType::GetIdentifierTokenContext() const
3159 {
3160 return OID_IDENTIFIER;
3161 }
3162
3163
3164 int ObjectIdentifierType::GetBraceTokenContext() const
3165 {
3166 return OID_BRACE;
3167 }
3168
3169
3170 const char * ObjectIdentifierType::GetAncestorClass() const
3171 {
3172 return "PASN_ObjectId";
3173 }
3174
3175
3176 /////////////////////////////////////////////////////////
3177
3178 ObjectClassFieldType::ObjectClassFieldType(PString * objclass, PString * field)
3179 : TypeBase(Tag::IllegalUniversalTag),
3180 asnObjectClassName(*objclass),
3181 asnObjectClassField(*field)
3182 {
3183 delete objclass;
3184 delete field;
3185 }
3186
3187
3188 const char * ObjectClassFieldType::GetAncestorClass() const
3189 {
3190 return "PASN_OctetString";
3191 }
3192
3193
3194 void ObjectClassFieldType::PrintOn(ostream & strm) const
3195 {
3196 PrintStart(strm);
3197 strm << asnObjectClassName << '.' << asnObjectClassField;
3198 PrintFinish(strm);
3199 }
3200
3201
3202 TypeBase * ObjectClassFieldType::FlattenThisType(const TypeBase & parent)
3203 {
3204 return new DefinedType(this, parent);
3205 }
3206
3207
3208 BOOL ObjectClassFieldType::IsPrimitiveType() const
3209 {
3210 return FALSE;
3211 }
3212
3213
3214 void ObjectClassFieldType::GenerateCplusplus(ostream & hdr, ostream & cxx)
3215 {
3216 BeginGenerateCplusplus(hdr, cxx);
3217
3218 hdr << " BOOL DecodeSubType(";
3219 GenerateCplusplusConstraints(PString(), hdr, cxx);
3220 hdr << " & obj) { return PASN_OctetString::DecodeSubType(obj); }\n"
3221 " void EncodeSubType(const ";
3222 GenerateCplusplusConstraints(PString(), hdr, cxx);
3223 hdr << " & obj) { PASN_OctetString::EncodeSubType(obj); } \n"
3224 "\n";
3225
3226 cxx << ")\n"
3227 "{\n";
3228
3229 EndGenerateCplusplus(hdr, cxx);
3230 }
3231
3232
3233 BOOL ObjectClassFieldType::CanReferenceType() const
3234 {
3235 return TRUE;
3236 }
3237
3238
3239 BOOL ObjectClassFieldType::ReferencesType(const TypeBase & type)
3240 {
3241 for (PINDEX i = 0; i < constraints.GetSize(); i++) {
3242 if (constraints[i].ReferencesType(type))
3243 return TRUE;
3244 }
3245 return FALSE;
3246 }
3247
3248
3249 /////////////////////////////////////////////////////////
3250
3251 ImportedType::ImportedType(PString * theName, BOOL param)
3252 : TypeBase(Tag::IllegalUniversalTag)
3253 {
3254 identifier = name = *theName;
3255 delete theName;
3256
3257 parameterised = param;
3258 }
3259
3260
3261 const char * ImportedType::GetAncestorClass() const
3262 {
3263 return identifier;
3264 }
3265
3266
3267 void ImportedType::AdjustIdentifier()
3268 {
3269 identifier = modulePrefix + '_' + MakeIdentifierC(name);
3270 }
3271
3272
3273 void ImportedType::GenerateCplusplus(ostream &, ostream &)
3274 {
3275 }
3276
3277
3278 void ImportedType::SetImportPrefix(const PString & prefix)
3279 {
3280 modulePrefix = prefix;
3281 }
3282
3283
3284 BOOL ImportedType::IsParameterisedImport() const
3285 {
3286 return parameterised;
3287 }
3288
3289
3290 /////////////////////////////////////////////////////////
3291
3292 SearchType::SearchType(const PString & theName)
3293 : TypeBase(Tag::IllegalUniversalTag)
3294 {
3295 identifier = name = theName;
3296 }
3297
3298
3299 const char * SearchType::GetAncestorClass() const
3300 {
3301 return identifier;
3302 }
3303
3304
3305 /////////////////////////////////////////////////////////
3306
3307 void ValueBase::SetValueName(PString * name)
3308 {
3309 valueName = *name;
3310 delete name;
3311 }
3312
3313
3314 void ValueBase::PrintBase(ostream & strm) const
3315 {
3316 if (!valueName)
3317 strm << '\n' << indent() << valueName << '=';
3318 }
3319
3320
3321 void ValueBase::GenerateCplusplus(ostream &, ostream &)
3322 {
3323 PError << StdError(Warning) << "unsupported value type." << endl;
3324 }
3325
3326
3327 /////////////////////////////////////////////////////////
3328
3329 DefinedValue::DefinedValue(PString * name)
3330 : referenceName(*name)
3331 {
3332 delete name;
3333 actualValue = NULL;
3334 unresolved = TRUE;
3335 }
3336
3337
3338 void DefinedValue::PrintOn(ostream & strm) const
3339 {
3340 PrintBase(strm);
3341 strm << referenceName;
3342 }
3343
3344
3345 void DefinedValue::GenerateCplusplus(ostream & hdr, ostream & cxx)
3346 {
3347 if (unresolved) {
3348 unresolved = FALSE;
3349
3350 const ValuesList & values = Module->GetValues();
3351 for (PINDEX i = 0; i < values.GetSize(); i++) {
3352 if (values[i].GetName() == referenceName) {
3353 actualValue = &values[i];
3354 break;
3355 }
3356 }
3357 }
3358
3359 if (actualValue != NULL)
3360 actualValue->GenerateCplusplus(hdr, cxx);
3361 else
3362 cxx << "e_" << referenceName;
3363 }
3364
3365
3366 /////////////////////////////////////////////////////////
3367
3368 BooleanValue::BooleanValue(BOOL newVal)
3369 {
3370 value = newVal;
3371 }
3372
3373
3374 void BooleanValue::PrintOn(ostream & strm) const
3375 {
3376 PrintBase(strm);
3377 strm << (value ? "TRUE" : "FALSE");
3378 }
3379
3380
3381 void BooleanValue::GenerateCplusplus(ostream &, ostream & cxx)
3382 {
3383 cxx << (value ? "TRUE" : "FALSE");
3384 }
3385
3386
3387 /////////////////////////////////////////////////////////
3388
3389 IntegerValue::IntegerValue(PInt64 newVal)
3390 {
3391 value = newVal;
3392 }
3393
3394
3395 void IntegerValue::PrintOn(ostream & strm) const
3396 {
3397 PrintBase(strm);
3398
3399 strm << value;
3400 }
3401
3402
3403 void IntegerValue::GenerateCplusplus(ostream &, ostream & cxx)
3404 {
3405 cxx << value;
3406 if (value > INT_MAX)
3407 cxx << 'U';
3408 }
3409
3410
3411 /////////////////////////////////////////////////////////
3412
3413 RealValue::RealValue(double newVal)
3414 {
3415 value = newVal;
3416 }
3417
3418
3419 /////////////////////////////////////////////////////////
3420
3421 OctetStringValue::OctetStringValue(PString * newVal)
3422 {
3423 // value = *newVal;
3424 delete newVal;
3425 }
3426
3427
3428 /////////////////////////////////////////////////////////
3429
3430 BitStringValue::BitStringValue(PString * newVal)
3431 {
3432 // value = *newVal;
3433 delete newVal;
3434 }
3435
3436
3437 BitStringValue::BitStringValue(PStringList * newVal)
3438 {
3439 // value = *newVal;
3440 delete newVal;
3441 }
3442
3443
3444 /////////////////////////////////////////////////////////
3445
3446 CharacterValue::CharacterValue(BYTE c)
3447 {
3448 value = c;
3449 }
3450
3451
3452 CharacterValue::CharacterValue(BYTE t1, BYTE t2)
3453 {
3454 value = (t1<<8) + t2;
3455 }
3456
3457
3458 CharacterValue::CharacterValue(BYTE q1, BYTE q2, BYTE q3, BYTE q4)
3459 {
3460 value = (q1<<24) + (q2<<16) + (q3<<8) + q4;
3461 }
3462
3463
3464 void CharacterValue::PrintOn(ostream & strm) const
3465 {
3466 strm << "'\\x" << hex << value << '\'';
3467 }
3468
3469
3470 void CharacterValue::GenerateCplusplus(ostream &, ostream & cxx)
3471 {
3472 cxx << value;
3473 }
3474
3475
3476 /////////////////////////////////////////////////////////
3477
3478 CharacterStringValue::CharacterStringValue(PString * newVal)
3479 {
3480 value = *newVal;
3481 delete newVal;
3482 }
3483
3484
3485 CharacterStringValue::CharacterStringValue(PStringList * newVal)
3486 {
3487 for (PINDEX i = 0; i < newVal->GetSize(); i++)
3488 value += (*newVal)[i];
3489 delete newVal;
3490 }
3491
3492
3493 void CharacterStringValue::PrintOn(ostream & strm) const
3494 {
3495 strm << value;
3496 }
3497
3498
3499 void CharacterStringValue::GenerateCplusplus(ostream &, ostream & cxx)
3500 {
3501 cxx << value;
3502 }
3503
3504
3505 /////////////////////////////////////////////////////////
3506
3507 ObjectIdentifierValue::ObjectIdentifierValue(PString * newVal)
3508 {
3509 value.Append(newVal);
3510 }
3511
3512
3513 ObjectIdentifierValue::ObjectIdentifierValue(PStringList * newVal)
3514 {
3515 value = *newVal;
3516 delete newVal;
3517 }
3518
3519
3520 void ObjectIdentifierValue::PrintOn(ostream & strm) const
3521 {
3522 PrintBase(strm);
3523 if (value.IsEmpty())
3524 strm << "empty object identifier";
3525 else {
3526 strm << value[0];
3527 for (PINDEX i = 1; i < value.GetSize(); i++)
3528 strm << '.' << value[i];
3529 }
3530 strm << '\n';
3531 }
3532
3533
3534 /////////////////////////////////////////////////////////
3535
3536 void MinValue::PrintOn(ostream & strm) const
3537 {
3538 strm << "MIN";
3539 }
3540
3541
3542 void MinValue::GenerateCplusplus(ostream &, ostream & cxx)
3543 {
3544 cxx << "MinimumValue";
3545 }
3546
3547
3548 /////////////////////////////////////////////////////////
3549
3550 void MaxValue::PrintOn(ostream & strm) const
3551 {
3552 strm << "MAX";
3553 }
3554
3555
3556 void MaxValue::GenerateCplusplus(ostream &, ostream & cxx)
3557 {
3558 cxx << "MaximumValue";
3559 }
3560
3561
3562 /////////////////////////////////////////////////////////
3563
3564 SequenceValue::SequenceValue(ValuesList * list)
3565 {
3566 if (list != NULL) {
3567 values = *list;
3568 delete list;
3569 }
3570 }
3571
3572
3573 void SequenceValue::PrintOn(ostream & strm) const
3574 {
3575 strm << "{ ";
3576 for (PINDEX i = 0; i < values.GetSize(); i++) {
3577 if (i > 0)
3578 strm << ", ";
3579 strm << values[i];
3580 }
3581 strm << " }";
3582 }
3583
3584
3585 /////////////////////////////////////////////////////////
3586
3587 MibBase::MibBase(PString * nam,
3588 PString * descr,
3589 PString * refer,
3590 ValueBase * val)
3591 : name(*nam)
3592 {
3593 delete nam;
3594 if (descr != NULL) {
3595 description = *descr;
3596 delete descr;
3597 }
3598 if (refer != NULL) {
3599 reference = *refer;
3600 delete refer;
3601 }
3602 value = val;
3603 }
3604
3605
3606 MibBase::~MibBase()
3607 {
3608 delete value;
3609 }
3610
3611
3612 /////////////////////////////////////////////////////////
3613
3614 MibObject::MibObject(PString * nam,
3615 TypeBase * typ,
3616 Access acc,
3617 Status stat,
3618 PString * descr,
3619 PString * refer,
3620 PStringList * idx,
3621 ValueBase * defVal,
3622 ValueBase * setVal)
3623 : MibBase(nam, descr, refer, setVal)
3624 {
3625 type = typ;
3626 access = acc;
3627 status = stat;
3628 if (idx != NULL) {
3629 index = *idx;
3630 delete idx;
3631 }
3632 defaultValue = defVal;
3633 }
3634
3635
3636 MibObject::~MibObject()
3637 {
3638 delete type;
3639 delete defaultValue;
3640 }
3641
3642
3643 void MibObject::PrintOn(ostream & strm) const
3644 {
3645 strm << " Object: " << name << "\n " << *type
3646 << " " << description << "\n"
3647 " " << *value << '\n';
3648 }
3649
3650
3651 /////////////////////////////////////////////////////////
3652
3653 MibTrap::MibTrap(PString * nam, ValueBase * ent, ValuesList * var,
3654 PString * descr, PString * refer, ValueBase * val)
3655 : MibBase(nam, descr, refer, val)
3656 {
3657 enterprise = ent;
3658 if (var != NULL) {
3659 variables = *var;
3660 delete var;
3661 }
3662 }
3663
3664
3665 MibTrap::~MibTrap()
3666 {
3667 delete enterprise;
3668 }
3669
3670
3671 void MibTrap::PrintOn(ostream & strm) const
3672 {
3673 strm << " Trap: " << name << "\n " << *enterprise
3674 << " " << description << "\n"
3675 " " << *value << '\n';
3676 }
3677
3678
3679 /////////////////////////////////////////////////////////
3680
3681 ImportModule::ImportModule(PString * name, TypesList * syms)
3682 : fullModuleName(*name),
3683 shortModuleName(Module->GetImportModuleName(*name)),
3684 filename(shortModuleName.ToLower())
3685 {
3686 delete name;
3687 symbols = *syms;
3688 delete syms;
3689
3690 PStringArray renameArgs = shortModuleName.Tokenise(',');
3691 switch (renameArgs.GetSize())
3692 {
3693 case 3 :
3694 filename = renameArgs[2];
3695 case 2 :
3696 directoryPrefix = renameArgs[1];
3697 shortModuleName = renameArgs[0];
3698 }
3699
3700 for (PINDEX i = 0; i < symbols.GetSize(); i++) {
3701 symbols[i].SetImportPrefix(shortModuleName);
3702 Module->AppendType(&symbols[i]);
3703 }
3704 }
3705
3706
3707 void ImportModule::PrintOn(ostream & strm) const
3708 {
3709 strm << " " << fullModuleName << " (" << shortModuleName << "):\n";
3710 for (PINDEX i = 0; i < symbols.GetSize(); i++)
3711 strm << " " << symbols[i];
3712 strm << '\n';
3713 }
3714
3715
3716 void ImportModule::GenerateCplusplus(ostream & hdr, ostream & cxx)
3717 {
3718 hdr << "#include \"" << directoryPrefix << filename << ".h\"\n";
3719
3720 for (PINDEX i = 0; i < symbols.GetSize(); i++) {
3721 if (symbols[i].IsParameterisedImport()) {
3722 cxx << "#include \"" << filename << "_t.cxx\"\n";
3723 break;
3724 }
3725 }
3726 }
3727
3728
3729 /////////////////////////////////////////////////////////
3730
3731 ModuleDefinition::ModuleDefinition(PString * name, PStringList * id, Tag::Mode defTagMode)
3732 : moduleName(*name),
3733 definitiveId(*id)
3734 {
3735 delete name;
3736 delete id;
3737 defaultTagMode = defTagMode;
3738 exportAll = FALSE;
3739 indentLevel = 1;
3740
3741 PArgList & args = PProcess::Current().GetArguments();
3742 if (args.HasOption('r')) {
3743 PStringArray renames = args.GetOptionString('r').Lines();
3744 for (PINDEX i = 0; i < renames.GetSize(); i++) {
3745 PINDEX equal = renames[i].Find('=');
3746 if (equal > 0 && equal != P_MAX_INDEX)
3747 importNames.SetAt(renames[i].Left(equal).Trim(), renames[i].Mid(equal+1).Trim());
3748 }
3749 }
3750 }
3751
3752
3753 void ModuleDefinition::SetExportAll()
3754 {
3755 exportAll = TRUE;
3756 }
3757
3758
3759 void ModuleDefinition::SetExports(TypesList * syms)
3760 {
3761 exports = *syms;
3762 delete syms;
3763 }
3764
3765
3766 void ModuleDefinition::PrintOn(ostream & strm) const
3767 {
3768 strm << moduleName << "\n"
3769 "Default Tags: " << Tag::modeNames[defaultTagMode] << "\n"
3770 "Exports:";
3771 if (exportAll)
3772 strm << " ALL";
3773 else {
3774 strm << "\n ";
3775 for (PINDEX i = 0; i < exports.GetSize(); i++)
3776 strm << exports[i] << ' ';
3777 strm << '\n';
3778 }
3779 strm << "Imports:\n" << imports << "\n"
3780 "Types:\n" << types << "\n"
3781 "Values:\n" << values << "\n"
3782 "MIBs:\n" << mibs << endl;
3783 }
3784
3785
3786 void ModuleDefinition::AppendType(TypeBase * type)
3787 {
3788 types.Append(type);
3789 sortedTypes.Append(type);
3790 }
3791
3792
3793 TypeBase * ModuleDefinition::FindType(const PString & name)
3794 {
3795 PINDEX pos = sortedTypes.GetValuesIndex(SearchType(name));
3796 if (pos != P_MAX_INDEX)
3797 return &sortedTypes[pos];
3798 return NULL;
3799 }
3800
3801
3802 PString ModuleDefinition::GetImportModuleName(const PString & moduleName)
3803 {
3804 if (importNames.Contains(moduleName))
3805 return importNames[moduleName];
3806
3807 PINDEX pos = moduleName.Find('-');
3808 if (pos > 32)
3809 pos = 32;
3810 return moduleName.Left(pos);
3811 }
3812
3813
3814 void ModuleDefinition::GenerateCplusplus(const PFilePath & path,
3815 const PString & modName,
3816 const PString & headerPrefix,
3817 unsigned numFiles,
3818 BOOL useNamespaces,
3819 BOOL useInlines,
3820 BOOL useOperators,
3821 BOOL verbose)
3822 {
3823 PArgList & args = PProcess::Current().GetArguments();
3824 BOOL xml_output = args.HasOption('x');
3825 PINDEX i;
3826
3827 usingInlines = useInlines;
3828 usingOperators = useOperators;
3829
3830 // Adjust the module name to what is specified to a default
3831 if (!modName)
3832 moduleName = modName;
3833 else
3834 moduleName = MakeIdentifierC(moduleName);
3835
3836 // Set the prefix on all external class names
3837 if (!useNamespaces)
3838 classNamePrefix = moduleName + '_';
3839
3840
3841 if (verbose)
3842 cout << "Sorting " << types.GetSize() << " types..." << endl;
3843
3844
3845 // Create sorted list for faster searching.
3846 sortedTypes.DisallowDeleteObjects();
3847 for (i = 0; i < types.GetSize(); i++)
3848 sortedTypes.Append(&types[i]);
3849
3850 // Flatten types by generating types for "inline" definitions
3851 for (i = 0; i < types.GetSize(); i++)
3852 types[i].FlattenUsedTypes();
3853
3854 // Reorder types
3855 // Determine if we need a separate file for template closure
3856 BOOL hasTemplates = FALSE;
3857 types.DisallowDeleteObjects();
3858 PINDEX loopDetect = 0;
3859 PINDEX bubble = 0;
3860 while (bubble < types.GetSize()) {
3861 BOOL makesReference = FALSE;
3862
3863 TypeBase & bubbleType = types[bubble];
3864 if (bubbleType.CanReferenceType()) {
3865 for (i = bubble; i < types.GetSize(); i++) {
3866 if (bubbleType.ReferencesType(types[i])) {
3867 makesReference = TRUE;
3868 break;
3869 }
3870 }
3871 }
3872
3873 if (makesReference) {
3874 types.Append(types.RemoveAt(bubble));
3875 if (loopDetect > types.GetSize()) {
3876 PError << StdError(Fatal)
3877 << "Recursive type definition: " << bubbleType.GetName() << endl;
3878 break;
3879 }
3880 loopDetect++;
3881 }
3882 else {
3883 loopDetect = bubble;
3884 bubble++;
3885 }
3886
3887 if (bubbleType.HasParameters())
3888 hasTemplates = TRUE;
3889 }
3890 types.AllowDeleteObjects();
3891
3892 // Adjust all of the C++ identifiers prepending module name
3893 for (i = 0; i < types.GetSize(); i++)
3894 types[i].AdjustIdentifier();
3895
3896
3897 // Generate the code
3898 if (verbose)
3899 cout << "Generating code (" << types.GetSize() << " classes) ..." << endl;
3900
3901
3902 // Output the special template closure file, if necessary
3903 PString templateFilename;
3904 if (hasTemplates) {
3905 OutputFile templateFile;
3906 if (!templateFile.Open(path, "_t", ".cxx"))
3907 return;
3908
3909 for (i = 0; i < types.GetSize(); i++) {
3910 if (types[i].HasParameters()) {
3911 PStringStream dummy;
3912 types[i].GenerateCplusplus(dummy, templateFile);
3913 }
3914 }
3915
3916 if (verbose)
3917 cout << "Completed " << templateFile.GetFilePath() << endl;
3918
3919 templateFilename = templateFile.GetFilePath().GetFileName();
3920 }
3921
3922 // Start the header file
3923 OutputFile hdrFile;
3924 if (!hdrFile.Open(path, "", ".h"))
3925 return;
3926
3927 hdrFile << "#if ! H323_DISABLE_" << moduleName.ToUpper() << "\n\n";
3928
3929 hdrFile << "#ifndef __" << moduleName.ToUpper() << "_H\n"
3930 "#define __" << moduleName.ToUpper() << "_H\n"
3931 "\n"
3932 "#ifdef P_USE_PRAGMA\n"
3933 "#pragma interface\n"
3934 "#endif\n"
3935 "\n";
3936
3937 if (xml_output)
3938 hdrFile << "#define P_EXPAT 1\n"
3939 "#include <ptclib/pxml.h>\n";
3940
3941 hdrFile << "#include <ptclib/asner.h>\n"
3942 "\n";
3943
3944 // Start the first (and maybe only) cxx file
3945 OutputFile cxxFile;
3946 if (!cxxFile.Open(path, numFiles > 1 ? "_1" : "", ".cxx"))
3947 return;
3948
3949 PString headerName = hdrFile.GetFilePath().GetFileName();
3950
3951 cxxFile << "#ifdef P_USE_PRAGMA\n"
3952 "#pragma implementation \"" << headerName << "\"\n"
3953 "#endif\n"
3954 "\n"
3955 "#include <ptlib.h>\n"
3956 "#include \"" << headerPrefix << headerName << "\"\n"
3957 "\n"
3958 "#define new PNEW\n"
3959 "\n"
3960 "\n";
3961
3962 cxxFile << "#if ! H323_DISABLE_" << moduleName.ToUpper() << "\n\n";
3963
3964 // Include the template closure file.
3965 if (hasTemplates)
3966 cxxFile << "#include \"" << templateFilename << "\"\n\n";
3967
3968
3969 for (i = 0; i < imports.GetSize(); i++)
3970 imports[i].GenerateCplusplus(hdrFile, cxxFile);
3971 if (!imports.IsEmpty()) {
3972 hdrFile << "\n\n";
3973 cxxFile << "\n\n";
3974 }
3975
3976
3977 if (useNamespaces) {
3978 hdrFile << "namespace " << moduleName << " {\n"
3979 "\n";
3980 cxxFile << "using namespace " << moduleName << ";\n"
3981 "\n";
3982 }
3983
3984
3985 PINDEX classesPerFile = (types.GetSize()+numFiles-1)/numFiles;
3986 for (i = 0; i < types.GetSize(); i++) {
3987 if (i > 0 && i%classesPerFile == 0) {
3988
3989 cxxFile << "#endif // if ! H323_DISABLE_" << moduleName.ToUpper() << "\n"
3990 "\n";
3991
3992 cxxFile.Close();
3993
3994 if (verbose)
3995 cout << "Completed " << cxxFile.GetFilePath() << endl;
3996
3997 if (!cxxFile.Open(path, psprintf("_%u", i/classesPerFile+1), ".cxx"))
3998 return;
3999
4000 cxxFile << "#include <ptlib.h>\n"
4001 "#include \"" << headerPrefix << headerName << "\"\n"
4002 "\n";
4003
4004 if (useNamespaces)
4005 cxxFile << "using namespace " << moduleName << ";\n"
4006 "\n";
4007 cxxFile << "#define new PNEW\n"
4008 "\n"
4009 "\n";
4010
4011 cxxFile << "#if ! H323_DISABLE_" << moduleName.ToUpper() << "\n\n";
4012
4013 }
4014
4015 if (types[i].HasParameters()) {
4016 PStringStream dummy;
4017 types[i].GenerateCplusplus(hdrFile, dummy);
4018 }
4019 else
4020 types[i].GenerateCplusplus(hdrFile, cxxFile);
4021 }
4022
4023
4024 // Close off the files
4025 if (useNamespaces)
4026 hdrFile << "};\n"
4027 "\n";
4028
4029 hdrFile << "#endif // __" << moduleName.ToUpper() << "_H\n"
4030 "\n";
4031
4032 hdrFile << "#endif // if ! H323_DISABLE_" << moduleName.ToUpper() << "\n"
4033 "\n";
4034
4035 cxxFile << "#endif // if ! H323_DISABLE_" << moduleName.ToUpper() << "\n"
4036 "\n";
4037
4038 if (verbose)
4039 cout << "Completed " << cxxFile.GetFilePath() << endl;
4040 }
4041
4042
4043 //////////////////////////////////////////////////////////////////////////////
Unofficial PWLib (OpenH323) repository