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