开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
main.cxx
资源名称：pwlib_1.1pl17.zip　[点击查看]
上传用户：hzhsqp
上传日期：2007-01-06
资源大小：1600k
文件大小：81k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

main.cxx：源码内容
  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: main.cxx,v $
  33.  * Revision 1.28  2000/06/26 13:14:46  robertj
  34.  * Nucleus++ port.
  35.  *
  36.  * Revision 1.27  2000/03/21 21:23:23  robertj
  37.  * Added option to rename imported module names, allows include filename matching.
  38.  *
  39.  * Revision 1.26  2000/01/19 12:33:07  robertj
  40.  * Fixed parsing of OID's in IMPORTS section.
  41.  *
  42.  * Revision 1.25  2000/01/19 03:38:12  robertj
  43.  * Fixed support for parsing multiple IMPORTS
  44.  *
  45.  * Revision 1.24  1999/09/18 04:17:40  robertj
  46.  * Added generation of C++ inlines for some  functions.
  47.  * Optimised CreateObject() switch statements, collapsing common cases.
  48.  *
  49.  * Revision 1.23  1999/09/18 02:42:27  craigs
  50.  * Added optimisation to collapse switch arms in CreateObject functions
  51.  *
  52.  * Revision 1.22  1999/09/07 09:56:04  robertj
  53.  * Fixed failure to put "using anmespace" in every generated .cxx file.
  54.  *
  55.  * Revision 1.21  1999/08/28 01:48:55  robertj
  56.  * Fixed anomaly to always include non-optional extensions in encodings.
  57.  *
  58.  * Revision 1.20  1999/08/09 13:02:36  robertj
  59.  * Added ASN compiler #defines for backward support of pre GCC 2.9 compilers.
  60.  * Added ASN compiler #defines to reduce its memory footprint.
  61.  * Added ASN compiler code generation of assignment operators for string classes.
  62.  *
  63.  * Revision 1.19  1999/07/22 06:48:55  robertj
  64.  * Added comparison operation to base ASN classes and compiled ASN code.
  65.  * Added support for ANY type in ASN parser.
  66.  *
  67.  * Revision 1.18  1999/07/06 05:00:26  robertj
  68.  * Incremented release number
  69.  *
  70.  * Revision 1.17  1999/07/01 12:21:46  robertj
  71.  * Changed PASN_Choice cast operators so no longer "break" const-ness of object.
  72.  *
  73.  * Revision 1.16  1999/06/30 08:57:19  robertj
  74.  * Fixed bug in encodeing sequence of constrained primitive type. Constraint not set.
  75.  * Fixed bug in not emitting namespace use clause.
  76.  * Added "normalisation" of separate sequence of <base type> to be single class.
  77.  *
  78.  * Revision 1.15  1999/06/14 13:00:15  robertj
  79.  * Fixed bug in code generation for string constraints.
  80.  *
  81.  * Revision 1.14  1999/06/09 06:58:09  robertj
  82.  * Adjusted heading comments.
  83.  *
  84.  * Revision 1.13  1999/06/09 02:07:49  robertj
  85.  * Fixed backward compatibility of generated template code with G++ 2.7.x
  86.  *
  87.  * Revision 1.12  1999/06/07 01:56:25  robertj
  88.  * Added header comment on license.
  89.  *
  90.  */
  92. #include <ptlib.h>
  94. #include "main.h"
  95. #include "asn_grammar.h"
  97. unsigned lineNumber;
  98. PString  fileName;
  100. unsigned fatals, warnings;
  102. extern FILE * yyin;
  103. extern int yydebug;
  104. extern int LexEcho;
  106. ModuleDefinition * Module;
  109. static const char * UniversalTagClassNames[] = {
  110.   "UniversalTagClass",
  111.   "ApplicationTagClass",
  112.   "ContextSpecificTagClass",
  113.   "PrivateTagClass"
  114. };
  116. static const char * UniversalTagNames[] = {
  117.   NULL,
  118.   "UniversalBoolean",
  119.   "UniversalInteger",
  120.   "UniversalBitString",
  121.   "UniversalOctetString",
  122.   "UniversalNull",
  123.   "UniversalObjectId",
  124.   "UniversalObjectDescriptor",
  125.   "UniversalExternalType",
  126.   "UniversalReal",
  127.   "UniversalEnumeration",
  128.   "UniversalEmbeddedPDV",
  129.   NULL,
  130.   NULL,
  131.   NULL,
  132.   NULL,
  133.   "UniversalSequence",
  134.   "UniversalSet",
  135.   "UniversalNumericString",
  136.   "UniversalPrintableString",
  137.   "UniversalTeletexString",
  138.   "UniversalVideotexString",
  139.   "UniversalIA5String",
  140.   "UniversalUTCTime",
  141.   "UniversalGeneralisedTime",
  142.   "UniversalGraphicString",
  143.   "UniversalVisibleString",
  144.   "UniversalGeneralString",
  145.   "UniversalUniversalString",
  146.   NULL,
  147.   "UniversalBMPString"
  148. };
  151. static const char * const StandardClasses[] = {
  152.   "PASN_Null",
  153.   "PASN_Boolean",
  154.   "PASN_Integer",
  155.   "PASN_Enumeration",
  156.   "PASN_Real",
  157.   "PASN_ObjectId",
  158.   "PASN_BitString",
  159.   "PASN_OctetString",
  160.   "PASN_NumericString",
  161.   "PASN_PrintableString",
  162.   "PASN_VisibleString",
  163.   "PASN_IA5String",
  164.   "PASN_GeneralString",
  165.   "PASN_BMPString",
  166.   "PASN_Sequence"
  167. };
  170. /////////////////////////////////////////
  171. //
  172. //  yyerror
  173. //  required function for flex
  174. //
  176. void yyerror(char * str)
  177. {
  178.   extern char * yytext;
  179.   PError << StdError(Fatal) << str << " near token "" << yytext <<""n";
  180. }
  182. ostream & operator<<(ostream & out, const StdError & e)
  183. {
  184.   out << fileName << '(' << lineNumber << ") : ";
  185.   if (e.e == Fatal) {
  186.     fatals++;
  187.     out << "error";
  188.   }
  189.   else {
  190.     warnings++;
  191.     out << "warning";
  192.   }
  193.   return out << ": ";
  194. }
  197. /////////////////////////////////////////////////////////
  198. //
  199. //  Utility
  200. //
  202. static PString MakeIdentifierC(const PString & identifier)
  203. {
  204.   PString s = identifier;
  205.   s.Replace("-", "_", TRUE);
  206.   return s;
  207. }
  210. class OutputFile : public PTextFile
  211. {
  212.     PCLASSINFO(OutputFile, PTextFile);
  213.   public:
  214.     ~OutputFile() { Close(); }
  216.     BOOL Open(const PFilePath & path, const PString & suffix, const char * extension);
  217.     BOOL Close();
  218. };
  221. BOOL OutputFile::Open(const PFilePath & path,
  222.                       const PString & suffix,
  223.                       const char * extension)
  224. {
  225.   PFilePath fn = path.GetDirectory() + path.GetTitle() + suffix;
  226.   fn.SetType(extension);
  228.   if (PTextFile::Open(fn, WriteOnly))
  229.     *this << "//n"
  230.              "// " << GetFilePath().GetFileName() << "n"
  231.              "//n"
  232.              "// Code automatically generated by asnparse.n"
  233.              "//n"
  234.              "n";
  235.   else
  236.     PError << PProcess::Current().GetName() << ": cannot create "" 
  237.          << GetFilePath() << "" :" << GetErrorText() << endl;
  239.   return IsOpen();
  240. }
  243. BOOL OutputFile::Close()
  244. {
  245.   if (IsOpen())
  246.     *this << "n"
  247.              "// End of " << GetFilePath().GetFileName() << 'n';
  249.   return PTextFile::Close();
  250. }
  253. /////////////////////////////////////////////////////////
  254. //
  255. //  Application
  256. //
  258. class App : public PProcess
  259. {
  260.     PCLASSINFO(App, PProcess);
  261.   public:
  262.     App();
  263.     void Main();
  264. };
  266. PCREATE_PROCESS(App);
  268. App::App()
  269.   : PProcess("Equivalence", "ASNParse", 1, 3, BetaCode, 3)
  270. {
  271. }
  273. void App::Main()
  274. {
  275.   PArgList & args = GetArguments();
  276.   args.Parse("v-verbose."
  277.              "e-echo."
  278.              "d-debug."
  279.              "c-c++."
  280.              "n-namespace."
  281.              "i-inlines."
  282.              "s-split;"
  283.              "o-output:"
  284.              "m-module:"
  285.              "r-rename:");
  287.   unsigned numFiles = 1;
  288.   if (args.HasOption('s')) {
  289.     PString numFilesStr = args.GetOptionString('s');
  290.     if (numFilesStr.IsEmpty())
  291.       numFiles = 2;
  292.     else
  293.       numFiles = numFilesStr.AsUnsigned();
  294.   }
  296.   if (args.GetCount() < 1 || args.GetCount() > 1 || numFiles == 0) {
  297.     PError << "usage: asnparse [options] asnfilen"
  298.               "  -v --verbose        Verbose output (multiple times for more verbose)n"
  299.               "  -e --echo           Echo input filen"
  300.               "  -d --debug          Debug output (copious!)n"
  301.               "  -c --c++            Generate C++ filesn"
  302.               "  -n --namespace      Use C++ namespacen"
  303.               "  -i --inlines        Use C++ inlinesn"
  304.               "  -s[n] --split[n]    Split output into n (default 2) filesn"
  305.               "  -o --output file    Output filename/directoryn"
  306.               "  -m --module name    Module name prefix/namespacen"
  307.               "  -r --rename from=to Rename import modulen"
  308.            << endl;
  309.     return;
  310.   }
  312.   PTextFile prcFile;
  313.   if (!prcFile.Open(args[0], PFile::ReadOnly)) {
  314.     PError << GetName() << ": cannot open "" 
  315.          << prcFile.GetFilePath() << "" :" << prcFile.GetErrorText() << endl;
  316.     return;
  317.   }
  319.   cout << GetName() << " version " << GetVersion(TRUE)
  320.        << " for " << GetOSClass() << ' ' << GetOSName()
  321.        << " by " << GetManufacturer() << endl;
  323.   if (args.HasOption('d'))
  324.     yydebug = 1;
  325.   if (args.HasOption('e'))
  326.     LexEcho = TRUE;
  328.   fileName   = prcFile.GetFilePath();
  329.   lineNumber = 1;
  330.   fatals     = 0;
  331.   warnings   = 0;
  333.   if (args.HasOption('v'))
  334.     cout << "Parsing..." << endl;
  336.   yyin = _fdopen(prcFile.GetHandle(), "r");
  337.   PAssertNULL(yyin);
  338.   yyparse();
  340.   if (Module != NULL) {
  341.     if (args.GetOptionCount('v') > 1)
  342.       PError << "Module " << *Module << endl;
  344.     if (args.HasOption('c'))
  345.       Module->GenerateCplusplus(args.GetOptionString('o', args[0]),
  346.                                 args.GetOptionString('m'),
  347.                                 numFiles,
  348.                                 args.HasOption('n'),
  349.                                 args.HasOption('i'),
  350.                                 args.HasOption('v'));
  351.   }
  352. }
  355. /////////////////////////////////////////
  356. //
  357. //  miscellaneous
  358. //
  360. class indent
  361. {
  362.   public:
  363.     indent() { }
  364.     friend ostream & operator<<(ostream & s, const indent &)
  365.     { return s << setw(Module->GetIndentLevel()*3) << ' '; }
  366. };
  369. /////////////////////////////////////////
  370. //
  371. //  intermediate structures from parser
  372. //
  374. NamedNumber::NamedNumber(PString * nam)
  375.   : name(*nam)
  376. {
  377.   delete nam;
  378.   number = 0;
  379.   autonumber = TRUE;
  380. }
  383. NamedNumber::NamedNumber(PString * nam, int num)
  384.   : name(*nam)
  385. {
  386.   delete nam;
  387.   number = num;
  388.   autonumber = FALSE;
  389. }
  392. NamedNumber::NamedNumber(PString * nam, const PString & ref)
  393.   : name(*nam), reference(ref)
  394. {
  395.   delete nam;
  396.   number = 0;
  397.   autonumber = FALSE;
  398. }
  401. void NamedNumber::PrintOn(ostream & strm) const
  402. {
  403.   strm << name << " (";
  404.   if (reference.IsEmpty())
  405.     strm << number;
  406.   else
  407.     strm << reference;
  408.   strm << ')';
  409. }
  412. void NamedNumber::SetAutoNumber(const NamedNumber & prev)
  413. {
  414.   if (autonumber) {
  415.     number = prev.number + 1;
  416.     autonumber = FALSE;
  417.   }
  418. }
  421. /////////////////////////////////////////////////////////
  423. Tag::Tag(unsigned tagNum)
  424. {
  425.   type = Universal;
  426.   number = tagNum;
  427.   mode = Module->GetDefaultTagMode();
  428. }
  431. const char * Tag::classNames[] = {
  432.   "UNIVERSAL", "APPLICATION", "CONTEXTSPECIFIC", "PRIVATE"
  433. };
  436. const char * Tag::modeNames[] = {
  437.   "IMPLICIT", "EXPLICIT", "AUTOMATIC"
  438. };
  441. void Tag::PrintOn(ostream & strm) const
  442. {
  443.   if (type != Universal || number != IllegalUniversalTag) {
  444.     strm << '[';
  445.     if (type != ContextSpecific)
  446.       strm << classNames[type] << ' ';
  447.     strm << number << "] " << modeNames[mode] << ' ';
  448.   }
  449. }
  452. /////////////////////////////////////////////////////////
  454. Constraint::Constraint(ConstraintElementBase * elmt)
  455. {
  456.   standard.Append(elmt);
  457.   extendable = FALSE;
  458. }
  461. Constraint::Constraint(ConstraintElementList * stnd, BOOL extend, ConstraintElementList * ext)
  462. {
  463.   if (stnd != NULL) {
  464.     standard = *stnd;
  465.     delete stnd;
  466.   }
  467.   extendable = extend;
  468.   if (ext != NULL) {
  469.     extensions = *ext;
  470.     delete ext;
  471.   }
  472. }
  475. void Constraint::PrintOn(ostream & strm) const
  476. {
  477.   strm << '(';
  478.   for (PINDEX i = 0; i < standard.GetSize(); i++)
  479.     strm << standard[i];
  480.   if (extendable) {
  481.     strm << indent();
  482.     if (standard.GetSize() > 0)
  483.       strm << ", ";
  484.     strm << "..., ";
  485.     for (PINDEX i = 0; i < extensions.GetSize(); i++)
  486.       strm << extensions[i];
  487.   }
  488.   strm << ')';
  489. }
  492. void Constraint::GenerateCplusplus(const PString & fn, ostream & hdr, ostream & cxx)
  493. {
  494.   switch (standard.GetSize()) {
  495.     case 0 :
  496.       return;
  497.     case 1 :
  498.       break;
  499.     default :
  500.       PError << StdError(Warning) << "unsupported UNION constraints, ignored." << endl;
  501.   }
  503.   if (extensions.GetSize() > 0)
  504.     PError << StdError(Warning) << "unsupported extension constraints, ignored." << endl;
  506.   PString fn2 = fn;
  507.   if (fn.Find("PASN_Object::") == P_MAX_INDEX) {
  508.     if (extendable)
  509.       fn2 += "PASN_Object::ExtendableConstraint";
  510.     else
  511.       fn2 += "PASN_Object::FixedConstraint";
  512.   }
  514.   standard[0].GenerateCplusplus(fn2, hdr, cxx);
  515. }
  518. BOOL Constraint::ReferencesType(const TypeBase & type)
  519. {
  520.   PINDEX i;
  522.   for (i = 0; i < standard.GetSize(); i++) {
  523.     if (standard[i].ReferencesType(type))
  524.       return TRUE;
  525.   }
  527.   for (i = 0; i < extensions.GetSize(); i++) {
  528.     if (extensions[i].ReferencesType(type))
  529.       return TRUE;
  530.   }
  532.   return FALSE;
  533. }
  536. /////////////////////////////////////////////////////////
  538. ConstraintElementBase::ConstraintElementBase()
  539. {
  540.   exclusions = NULL;
  541. }
  544. void ConstraintElementBase::GenerateCplusplus(const PString &, ostream &, ostream &)
  545. {
  546.   PError << StdError(Warning) << "unsupported constraint, ignored." << endl;
  547. }
  550. BOOL ConstraintElementBase::ReferencesType(const TypeBase &)
  551. {
  552.   return FALSE;
  553. }
  556. /////////////////////////////////////////////////////////
  558. ConstrainAllConstraintElement::ConstrainAllConstraintElement(ConstraintElementBase * excl)
  559. {
  560.   SetExclusions(excl);
  561. }
  564. /////////////////////////////////////////////////////////
  566. ElementListConstraintElement::ElementListConstraintElement(ConstraintElementList * list)
  567.   : elements(*list)
  568. {
  569.   delete list;
  570. }
  573. void ElementListConstraintElement::PrintOn(ostream & strm) const
  574. {
  575.   elements.PrintOn(strm);
  576. }
  579. void ElementListConstraintElement::GenerateCplusplus(const PString & fn, ostream & hdr, ostream & cxx)
  580. {
  581.   for (PINDEX i = 0; i < elements.GetSize(); i++)
  582.     elements[i].GenerateCplusplus(fn, hdr, cxx);
  583. }
  586. BOOL ElementListConstraintElement::ReferencesType(const TypeBase & type)
  587. {
  588.   for (PINDEX i = 0; i < elements.GetSize(); i++) {
  589.     if (elements[i].ReferencesType(type))
  590.       return TRUE;
  591.   }
  592.   return FALSE;
  593. }
  596. /////////////////////////////////////////////////////////
  598. SingleValueConstraintElement::SingleValueConstraintElement(ValueBase * val)
  599. {
  600.   value = val;
  601. }
  604. SingleValueConstraintElement::~SingleValueConstraintElement()
  605. {
  606.   delete value;
  607. }
  610. void SingleValueConstraintElement::PrintOn(ostream & strm) const
  611. {
  612.   strm << *value;
  613. }
  616. void SingleValueConstraintElement::GenerateCplusplus(const PString & fn, ostream & hdr, ostream & cxx)
  617. {
  618.   if (value->IsDescendant(IntegerValue::Class())) {
  619.     cxx << fn << ", ";
  620.     value->GenerateCplusplus(hdr, cxx);
  621.     cxx << ", ";
  622.     value->GenerateCplusplus(hdr, cxx);
  623.     cxx << ");n";
  624.     return;
  625.   }
  627.   if (value->IsDescendant(CharacterStringValue::Class())) {
  628.     cxx << fn << ", ";
  629.     value->GenerateCplusplus(hdr, cxx);
  630.     cxx << ");n";
  631.     return;
  632.   }
  634.   PError << StdError(Warning) << "Unsupported constraint type, ignoring." << endl;
  635. }
  638. /////////////////////////////////////////////////////////
  640. ValueRangeConstraintElement::ValueRangeConstraintElement(ValueBase * lowerBound, ValueBase * upperBound)
  641. {
  642.   lower = lowerBound;
  643.   upper = upperBound;
  644. }
  647. ValueRangeConstraintElement::~ValueRangeConstraintElement()
  648. {
  649.   delete lower;
  650.   delete upper;
  651. }
  654. void ValueRangeConstraintElement::PrintOn(ostream & strm) const
  655. {
  656.   strm << *lower << ".." << *upper;
  657. }
  660. void ValueRangeConstraintElement::GenerateCplusplus(const PString & fn, ostream & hdr, ostream & cxx)
  661. {
  662.   cxx << fn << ", ";
  663.   lower->GenerateCplusplus(hdr, cxx);
  664.   cxx << ", ";
  665.   upper->GenerateCplusplus(hdr, cxx);
  666.   cxx << ");n";
  667. }
  670. /////////////////////////////////////////////////////////
  672. SubTypeConstraintElement::SubTypeConstraintElement(TypeBase * typ)
  673. {
  674.   subtype = typ;
  675. }
  678. SubTypeConstraintElement::~SubTypeConstraintElement()
  679. {
  680.   delete subtype;
  681. }
  684. void SubTypeConstraintElement::PrintOn(ostream & strm) const
  685. {
  686.   strm << subtype->GetTypeName();
  687. }
  690. void SubTypeConstraintElement::GenerateCplusplus(const PString &, ostream & hdr, ostream &)
  691. {
  692.   hdr << subtype->GetTypeName();
  693. }
  696. BOOL SubTypeConstraintElement::ReferencesType(const TypeBase & type)
  697. {
  698.   return subtype->ReferencesType(type);
  699. }
  702. /////////////////////////////////////////////////////////
  704. NestedConstraintConstraintElement::NestedConstraintConstraintElement(Constraint * con)
  705. {
  706.   constraint = con;
  707. }
  710. NestedConstraintConstraintElement::~NestedConstraintConstraintElement()
  711. {
  712.   delete constraint;
  713. }
  716. BOOL NestedConstraintConstraintElement::ReferencesType(const TypeBase & type)
  717. {
  718.   if (constraint == NULL)
  719.     return FALSE;
  721.   return constraint->ReferencesType(type);
  722. }
  725. /////////////////////////////////////////////////////////
  727. SizeConstraintElement::SizeConstraintElement(Constraint * constraint)
  728.   : NestedConstraintConstraintElement(constraint)
  729. {
  730. }
  733. void SizeConstraintElement::PrintOn(ostream & strm) const
  734. {
  735.   strm << "SIZE" << *constraint;
  736. }
  739. void SizeConstraintElement::GenerateCplusplus(const PString & fn, ostream & hdr, ostream & cxx)
  740. {
  741.   constraint->GenerateCplusplus(fn, hdr, cxx);
  742. }
  745. /////////////////////////////////////////////////////////
  747. FromConstraintElement::FromConstraintElement(Constraint * constraint)
  748.   : NestedConstraintConstraintElement(constraint)
  749. {
  750. }
  753. void FromConstraintElement::PrintOn(ostream & strm) const
  754. {
  755.   strm << "FROM" << *constraint;
  756. }
  759. void FromConstraintElement::GenerateCplusplus(const PString & fn, ostream & hdr, ostream & cxx)
  760. {
  761.   PString newfn = fn;
  762.   newfn.Replace("SetConstraints(", "SetCharacterSet(");
  763.   constraint->GenerateCplusplus(newfn, hdr, cxx);
  764. }
  767. /////////////////////////////////////////////////////////
  769. WithComponentConstraintElement::WithComponentConstraintElement(PString * newName,
  770.                                                                Constraint * constraint,
  771.                                                                int pres)
  772.   : NestedConstraintConstraintElement(constraint)
  773. {
  774.   if (newName != NULL) {
  775.     name = *newName;
  776.     delete newName;
  777.   }
  779.   presence = pres;
  780. }
  783. void WithComponentConstraintElement::PrintOn(ostream & strm) const
  784. {
  785.   if (name.IsEmpty())
  786.     strm << "WITH COMPONENT";
  787.   else
  788.     strm << name;
  790.   if (constraint != NULL)
  791.     strm << *constraint;
  793.   switch (presence) {
  794.     case Present :
  795.       strm << " PRESENT";
  796.       break;
  797.     case Absent :
  798.       strm << " ABSENT";
  799.       break;
  800.     case Optional :
  801.       strm << " OPTIONAL";
  802.       break;
  803.   }
  804. }
  807. void WithComponentConstraintElement::GenerateCplusplus(const PString &, ostream &, ostream & cxx)
  808. {
  809.   if (presence == Present)
  810.     cxx << "  IncludeOptionalField(e_" << name << ");n";
  811. }
  814. /////////////////////////////////////////////////////////
  816. InnerTypeConstraintElement::InnerTypeConstraintElement(ConstraintElementList * list,
  817.                                                        BOOL part)
  818.   : ElementListConstraintElement(list)
  819. {
  820.   partial = part;
  821. }
  824. void InnerTypeConstraintElement::PrintOn(ostream & strm) const
  825. {
  826.   strm << "WITH COMPONENTS { ";
  828.   if (partial)
  829.     strm << "..., ";
  831.   for (PINDEX i = 0; i < elements.GetSize(); i++) {
  832.     if (i > 0)
  833.       strm << ", ";
  834.     elements[i].PrintOn(strm);
  835.   }
  837.   strm << " }";
  838. }
  841. void InnerTypeConstraintElement::GenerateCplusplus(const PString & fn, ostream & hdr, ostream & cxx)
  842. {
  843.   for (PINDEX i = 0; i < elements.GetSize(); i++)
  844.     elements[i].GenerateCplusplus(fn, hdr, cxx);
  845. }
  848. /////////////////////////////////////////////////////////
  850. UserDefinedConstraintElement::UserDefinedConstraintElement(TypesList * t)
  851. {
  852.   if (t != NULL) {
  853.     types = *t;
  854.     delete t;
  855.   }
  856. }
  859. void UserDefinedConstraintElement::PrintOn(ostream & strm) const
  860. {
  861.   strm << "CONSTRAINED BY { ";
  862.   for (PINDEX i = 0; i < types.GetSize(); i++) {
  863.     if (i > 0)
  864.       strm << ", ";
  865.     strm << types[i].GetTypeName();
  866.   }
  867.   strm << " }";
  868. }
  871. void UserDefinedConstraintElement::GenerateCplusplus(const PString &, ostream &, ostream &)
  872. {
  873. }
  876. /////////////////////////////////////////////////////////
  878. TypeBase::TypeBase(unsigned tagNum)
  879.   : tag(tagNum), defaultTag(tagNum)
  880. {
  881.   isOptional = FALSE;
  882.   defaultValue = NULL;
  883.   isGenerated = FALSE;
  884. }
  887. TypeBase::TypeBase(TypeBase * copy)
  888.   : name(copy->name),
  889.     identifier(MakeIdentifierC(name)),
  890.     tag(copy->tag),
  891.     defaultTag(copy->tag)
  892. {
  893.   isOptional = copy->isOptional;
  894.   defaultValue = NULL;
  895.   isGenerated = FALSE;
  896. }
  899. PObject::Comparison TypeBase::Compare(const PObject & obj) const
  900. {
  901.   return name.Compare(((const TypeBase &)obj).name);
  902. }
  905. void TypeBase::PrintOn(ostream & strm) const
  906. {
  907.   PrintStart(strm);
  908.   PrintFinish(strm);
  909. }
  912. void TypeBase::PrintStart(ostream & strm) const
  913. {
  914.   strm << indent();
  915.   if (!name) {
  916.     strm << name;
  917.     if (!parameters.IsEmpty()) {
  918.       strm << " { ";
  919.       for (PINDEX i = 0; i < parameters.GetSize(); i++) {
  920.         if (i > 0)
  921.           strm << ", ";
  922.         strm << parameters[i];
  923.       }
  924.       strm << " } ";
  925.     }
  926.     strm << ": ";
  927.   }
  928.   strm << tag << GetClass() << ' ';
  929.   Module->SetIndentLevel(1);
  930. }
  933. void TypeBase::PrintFinish(ostream & strm) const
  934. {
  935.   Module->SetIndentLevel(-1);
  936.   strm << ' ' << constraints;
  937.   if (isOptional)
  938.     strm << " OPTIONAL";
  939.   if (defaultValue != NULL)
  940.     strm << " DEFAULT " << *defaultValue;
  941.   strm << 'n';
  942. }
  945. int TypeBase::GetIdentifierTokenContext() const
  946. {
  947.   return IDENTIFIER;
  948. }
  951. int TypeBase::GetBraceTokenContext() const
  952. {
  953.   return '{';
  954. }
  957. void TypeBase::SetName(PString * newName)
  958. {
  959.   name = *newName;
  960.   delete newName;
  961.   identifier = MakeIdentifierC(name);
  962. }
  965. void TypeBase::AdjustIdentifier()
  966. {
  967.   identifier = Module->GetPrefix() + MakeIdentifierC(name);
  968. }
  971. void TypeBase::SetTag(Tag::Type type, unsigned num, Tag::Mode mode)
  972. {
  973.   tag.type = type;
  974.   tag.number = num;
  975.   tag.mode = mode;
  976. }
  979. void TypeBase::SetParameters(PStringList * list)
  980. {
  981.   parameters = *list;
  982.   delete list;
  983. }
  986. void TypeBase::MoveConstraints(TypeBase * from)
  987. {
  988.   from->constraints.DisallowDeleteObjects();
  990.   while (!from->constraints.IsEmpty())
  991.     constraints.Append(from->constraints.RemoveAt(0));
  993.   from->constraints.AllowDeleteObjects();
  994. }
  997. void TypeBase::FlattenUsedTypes()
  998. {
  999. }
  1002. TypeBase * TypeBase::FlattenThisType(const TypeBase &)
  1003. {
  1004.   return this;
  1005. }
  1008. BOOL TypeBase::IsChoice() const
  1009. {
  1010.   return FALSE;
  1011. }
  1014. BOOL TypeBase::IsParameterizedType() const
  1015. {
  1016.   return FALSE;
  1017. }
  1020. BOOL TypeBase::IsPrimitiveType() const
  1021. {
  1022.   return TRUE;
  1023. }
  1026. void TypeBase::GenerateCplusplus(ostream & hdr, ostream & cxx)
  1027. {
  1028.   BeginGenerateCplusplus(hdr, cxx);
  1030.   // Close off the constructor implementation
  1031.   cxx << ")n"
  1032.          "{n";
  1033.   GenerateCplusplusConstraints(PString(), hdr, cxx);
  1035.   EndGenerateCplusplus(hdr, cxx);
  1036. }
  1039. void TypeBase::GenerateForwardDecls(ostream &)
  1040. {
  1041. }
  1044. void TypeBase::GenerateOperators(ostream &, ostream &, const TypeBase &)
  1045. {
  1046. }
  1049. PString TypeBase::GetTypeName() const
  1050. {
  1051.   return GetAncestorClass();
  1052. }
  1055. BOOL TypeBase::CanReferenceType() const
  1056. {
  1057.   return FALSE;
  1058. }
  1061. BOOL TypeBase::ReferencesType(const TypeBase &)
  1062. {
  1063.   return FALSE;
  1064. }
  1067. void TypeBase::SetImportPrefix(const PString &)
  1068. {
  1069. }
  1072. BOOL TypeBase::IsParameterisedImport() const
  1073. {
  1074.   return FALSE;
  1075. }
  1078. void TypeBase::BeginGenerateCplusplus(ostream & hdr, ostream & cxx)
  1079. {
  1080.   classNameString = GetIdentifier();
  1082.   if (!parameters.IsEmpty()) {
  1083.     templatePrefix = "template <";
  1084.     classNameString += '<';
  1085.     for (PINDEX i = 0; i < parameters.GetSize(); i++) {
  1086.       if (i > 0) {
  1087.         templatePrefix += ", ";
  1088.         classNameString += ", ";
  1089.       }
  1090.       PString ident = MakeIdentifierC(parameters[i]);
  1091.       templatePrefix += "class " + ident;
  1092.       classNameString += ident;
  1093.     }
  1094.     templatePrefix += ">n";
  1095.     classNameString += '>';
  1096.   }
  1098.   // Output header file declaration of class
  1099.   hdr << "//n"
  1100.          "// " << GetName() << "n"
  1101.          "//n"
  1102.          "n";
  1103.   GenerateForwardDecls(hdr);
  1104.   hdr << templatePrefix
  1105.       << "class " << GetIdentifier() << " : public " << GetTypeName() << "n"
  1106.          "{n"
  1107.          "#ifndef PASN_LEANANDMEANn"
  1108.          "    PCLASSINFO(" << GetIdentifier() << ", " << GetTypeName() << ");n"
  1109.          "#endifn"
  1110.          "  public:n"
  1111.          "    " << GetIdentifier() << "(unsigned tag = ";
  1112.   if (tag.type == Tag::Universal &&
  1113.       tag.number < PARRAYSIZE(UniversalTagNames) &&
  1114.       UniversalTagNames[tag.number] != NULL)
  1115.     hdr << UniversalTagNames[tag.number];
  1116.   else
  1117.     hdr << tag.number;
  1118.   hdr << ", TagClass tagClass = " << UniversalTagClassNames[tag.type] << ");nn";
  1120.   // Output cxx file implementation of class
  1121.   cxx << "//n"
  1122.          "// " << GetName() << "n"
  1123.          "//n"
  1124.          "n"
  1125.       << GetTemplatePrefix()
  1126.       << GetClassNameString() << "::" << GetIdentifier() << "(unsigned tag, PASN_Object::TagClass tagClass)n"
  1127.          "  : " << GetTypeName() << "(tag, tagClass";
  1128. }
  1131. void TypeBase::EndGenerateCplusplus(ostream & hdr, ostream & cxx)
  1132. {
  1133.   cxx << "}n"
  1134.          "n"
  1135.          "n";
  1137.   GenerateOperators(hdr, cxx, *this);
  1139.   // Output header file declaration of class
  1140.   hdr << "    PObject * Clone() const;n"
  1141.          "};n"
  1142.          "n"
  1143.          "n";
  1145.   // Output cxx file implementation of class
  1146.   cxx << GetTemplatePrefix()
  1147.       << "PObject * " << GetClassNameString() << "::Clone() constn"
  1148.          "{n"
  1149.          "#ifndef PASN_LEANANDMEANn"
  1150.          "  PAssert(IsClass(" << GetClassNameString() << "::Class()), PInvalidCast);n"
  1151.          "#endifn"
  1152.          "  return new " << GetClassNameString() << "(*this);n"
  1153.          "}n"
  1154.          "n"
  1155.          "n";
  1157.   isGenerated = TRUE;
  1158. }
  1161. void TypeBase::GenerateCplusplusConstructor(ostream &, ostream & cxx)
  1162. {
  1163.   cxx << '(';
  1164.   if (HasNonStandardTag()) {
  1165.     if (tag.type == Tag::Universal &&
  1166.         tag.number < PARRAYSIZE(UniversalTagNames) &&
  1167.         UniversalTagNames[tag.number] != NULL)
  1168.       cxx << UniversalTagNames[tag.number];
  1169.     else
  1170.       cxx << tag.number;
  1171.     cxx << ", " << UniversalTagClassNames[tag.type];
  1172.   }
  1173.   cxx << ')';
  1174. }
  1177. void TypeBase::GenerateCplusplusConstraints(const PString & prefix, ostream & hdr, ostream & cxx)
  1178. {
  1179.   for (PINDEX i = 0; i < constraints.GetSize(); i++)
  1180.     constraints[i].GenerateCplusplus("  " + prefix + "SetConstraints(", hdr, cxx);
  1181. }
  1184. /////////////////////////////////////////////////////////
  1186. DefinedType::DefinedType(PString * name, BOOL parameter)
  1187.   : TypeBase(Tag::IllegalUniversalTag),
  1188.     referenceName(*name)
  1189. {
  1190.   delete name;
  1191.   baseType = NULL;
  1192.   unresolved = !parameter;
  1193. }
  1196. DefinedType::DefinedType(TypeBase * refType, TypeBase * bType)
  1197.   : TypeBase(refType),
  1198.     referenceName(bType->GetName())
  1199. {
  1200.   MoveConstraints(refType);
  1202.   baseType = bType;
  1203.   unresolved = FALSE;
  1204. }
  1207. DefinedType::DefinedType(TypeBase * refType, const PString & refName)
  1208.   : TypeBase(refType)
  1209. {
  1210.   MoveConstraints(refType);
  1211.   ConstructFromType(refType, refName);
  1212. }
  1215. DefinedType::DefinedType(TypeBase * refType, const TypeBase & parent)
  1216.   : TypeBase(refType)
  1217. {
  1218.   if (!name)
  1219.     ConstructFromType(refType, parent.GetName() + '_' + name);
  1220.   else
  1221.     ConstructFromType(refType, parent.GetName() + "_subtype");
  1222. }
  1225. void DefinedType::ConstructFromType(TypeBase * refType, const PString & name)
  1226. {
  1227.   referenceName = name;
  1228.   refType->SetName(new PString(name));
  1230.   Module->AppendType(refType);
  1232.   baseType = refType;
  1233.   unresolved = FALSE;
  1234. }
  1237. void DefinedType::PrintOn(ostream & strm) const
  1238. {
  1239.   PrintStart(strm);
  1240.   strm << referenceName << ' ';
  1241.   PrintFinish(strm);
  1242. }
  1245. BOOL DefinedType::CanReferenceType() const
  1246. {
  1247.   return TRUE;
  1248. }
  1251. BOOL DefinedType::IsChoice() const
  1252. {
  1253.   if (baseType != NULL)
  1254.     return baseType->IsChoice();
  1255.   return FALSE;
  1256. }
  1259. BOOL DefinedType::IsParameterizedType() const
  1260. {
  1261.   if (baseType != NULL)
  1262.     return baseType->IsParameterizedType();
  1263.   return FALSE;
  1264. }
  1267. BOOL DefinedType::ReferencesType(const TypeBase & type)
  1268. {
  1269.   if (unresolved) {
  1270.     unresolved = FALSE;
  1272.     if ((baseType = Module->FindType(referenceName)) == NULL)
  1273.       PError << StdError(Warning) << "unresolved symbol: " << referenceName << endl;
  1274.     else {
  1275.       if (!HasNonStandardTag())
  1276.         defaultTag = tag = baseType->GetTag();
  1277.     }
  1278.   }
  1280.   return type.GetName() == referenceName;
  1281. }
  1284. void DefinedType::GenerateOperators(ostream & hdr, ostream & cxx, const TypeBase & actualType)
  1285. {
  1286.   if (baseType != NULL)
  1287.     baseType->GenerateOperators(hdr, cxx, actualType);
  1288. }
  1291. const char * DefinedType::GetAncestorClass() const
  1292. {
  1293.   if (baseType != NULL)
  1294.     return baseType->GetAncestorClass();
  1295.   return NULL;
  1296. }
  1299. PString DefinedType::GetTypeName() const
  1300. {
  1301.   if (baseType == NULL)
  1302.     return referenceName;
  1304.   if (HasConstraints() && baseType->IsPrimitiveType())
  1305.     return baseType->GetTypeName();
  1307.   return baseType->GetIdentifier();
  1308. }
  1311. /////////////////////////////////////////////////////////
  1313. ParameterizedType::ParameterizedType(PString * name, TypesList * args)
  1314.   : DefinedType(name, FALSE),
  1315.     arguments(*args)
  1316. {
  1317.   delete args;
  1318. }
  1321. void ParameterizedType::PrintOn(ostream & strm) const
  1322. {
  1323.   PrintStart(strm);
  1324.   strm << referenceName << " { ";
  1325.   for (PINDEX i = 0; i < arguments.GetSize(); i++) {
  1326.     if (i > 0)
  1327.       strm << ", ";
  1328.     strm << arguments[i].GetTypeName();
  1329.   }
  1330.   strm << " }";
  1331.   PrintFinish(strm);
  1332. }
  1335. BOOL ParameterizedType::IsParameterizedType() const
  1336. {
  1337.   return TRUE;
  1338. }
  1341. BOOL ParameterizedType::ReferencesType(const TypeBase & type)
  1342. {
  1343.   for (PINDEX i = 0; i < arguments.GetSize(); i++) {
  1344.     if (arguments[i].ReferencesType(type))
  1345.       return TRUE;
  1346.   }
  1348.   return DefinedType::ReferencesType(type);
  1349. }
  1352. PString ParameterizedType::GetTypeName() const
  1353. {
  1354.   PString typeName = DefinedType::GetTypeName();
  1355.   if (!arguments.IsEmpty()) {
  1356.     typeName += '<';
  1357.     for (PINDEX i = 0; i < arguments.GetSize(); i++) {
  1358.       if (i > 0)
  1359.         typeName += ", ";
  1360.       typeName += arguments[i].GetTypeName();
  1361.     }
  1362.     typeName += '>';
  1363.   }
  1364.   return typeName;
  1365. }
  1368. /////////////////////////////////////////////////////////
  1370. SelectionType::SelectionType(PString * name, TypeBase * base)
  1371.   : TypeBase(Tag::IllegalUniversalTag),
  1372.     selection(*name)
  1373. {
  1374.   delete name;
  1375.   baseType = PAssertNULL(base);
  1376. }
  1379. SelectionType::~SelectionType()
  1380. {
  1381.   delete baseType;
  1382. }
  1385. void SelectionType::PrintOn(ostream & strm) const
  1386. {
  1387.   PrintStart(strm);
  1388.   strm << selection << '<' << *baseType;
  1389.   PrintFinish(strm);
  1390. }
  1393. void SelectionType::FlattenUsedTypes()
  1394. {
  1395.   baseType = baseType->FlattenThisType(*this);
  1396. }
  1399. TypeBase * SelectionType::FlattenThisType(const TypeBase & parent)
  1400. {
  1401.   return new DefinedType(this, parent);
  1402. }
  1405. void SelectionType::GenerateCplusplus(ostream &, ostream &)
  1406. {
  1407.   PError << StdError(Fatal) << "Cannot generate code for Selection type" << endl;
  1408.   isGenerated = TRUE;
  1409. }
  1412. const char * SelectionType::GetAncestorClass() const
  1413. {
  1414.   return "";
  1415. }
  1418. BOOL SelectionType::CanReferenceType() const
  1419. {
  1420.   return TRUE;
  1421. }
  1424. BOOL SelectionType::ReferencesType(const TypeBase & type)
  1425. {
  1426.   return baseType->ReferencesType(type);
  1427. }
  1430. /////////////////////////////////////////////////////////
  1432. BooleanType::BooleanType()
  1433.   : TypeBase(Tag::UniversalBoolean)
  1434. {
  1435. }
  1438. void BooleanType::GenerateOperators(ostream & hdr, ostream & cxx, const TypeBase & actualType)
  1439. {
  1440.   hdr << "    " << actualType.GetIdentifier() << " & operator=(BOOL v)";
  1441.   if (Module->UsingInlines())
  1442.     hdr << " { SetValue(v);  return *this; }n";
  1443.   else {
  1444.     hdr << ";n";
  1445.     cxx << actualType.GetTemplatePrefix()
  1446.         << actualType.GetIdentifier() << " & "
  1447.         << actualType.GetClassNameString() << "::operator=(BOOL v)n"
  1448.            "{n"
  1449.            "  SetValue(v);n"
  1450.            "  return *this;n"
  1451.            "}n"
  1452.            "n"
  1453.            "n";
  1454.   }
  1455. }
  1458. const char * BooleanType::GetAncestorClass() const
  1459. {
  1460.   return "PASN_Boolean";
  1461. }
  1464. /////////////////////////////////////////////////////////
  1466. IntegerType::IntegerType()
  1467.   : TypeBase(Tag::UniversalInteger)
  1468. {
  1469. }
  1472. IntegerType::IntegerType(NamedNumberList * lst)
  1473.   : TypeBase(Tag::UniversalInteger),
  1474.     allowedValues(*lst)
  1475. {
  1476.   delete lst;
  1477. }
  1480. void IntegerType::GenerateOperators(ostream & hdr, ostream & cxx, const TypeBase & actualType)
  1481. {
  1482.   hdr << "    " << actualType.GetIdentifier() << " & operator=(int v)";
  1483.   if (Module->UsingInlines())
  1484.     hdr << " { SetValue(v);  return *this; }n";
  1485.   else {
  1486.     hdr << ";n";
  1487.     cxx << actualType.GetTemplatePrefix()
  1488.         << actualType.GetIdentifier() << " & "
  1489.         << actualType.GetClassNameString() << "::operator=(int v)n"
  1490.            "{n"
  1491.            "  SetValue(v);n"
  1492.            "  return *this;n"
  1493.            "}n"
  1494.            "n"
  1495.            "n";
  1496.   }
  1498.   hdr << "    " << actualType.GetIdentifier() << " & operator=(unsigned v)";
  1499.   if (Module->UsingInlines())
  1500.     hdr << " { SetValue(v);  return *this; }n";
  1501.   else {
  1502.     hdr << ";n";
  1503.     cxx  << actualType.GetTemplatePrefix()
  1504.         << actualType.GetIdentifier() << " & "
  1505.         << actualType.GetClassNameString() << "::operator=(unsigned v)n"
  1506.            "{n"
  1507.            "  SetValue(v);n"
  1508.            "  return *this;n"
  1509.            "}n"
  1510.            "n"
  1511.            "n";
  1512.   }
  1513. }
  1516. const char * IntegerType::GetAncestorClass() const
  1517. {
  1518.   return "PASN_Integer";
  1519. }
  1522. /////////////////////////////////////////////////////////
  1524. EnumeratedType::EnumeratedType(NamedNumberList * enums, BOOL extend, NamedNumberList * ext)
  1525.   : TypeBase(Tag::UniversalEnumeration),
  1526.     enumerations(*enums)
  1527. {
  1528.   numEnums = enums->GetSize();
  1529.   delete enums;
  1530.   extendable = extend;
  1531.   if (ext != NULL) {
  1532.     ext->DisallowDeleteObjects();
  1533.     for (PINDEX i = 0; i < ext->GetSize(); i++)
  1534.       enumerations.Append(ext->GetAt(i));
  1535.     delete ext;
  1536.   }
  1537. }
  1540. void EnumeratedType::PrintOn(ostream & strm) const
  1541. {
  1542.   PrintStart(strm);
  1543.   strm << 'n';
  1544.   PINDEX i;
  1545.   for (i = 0; i < numEnums; i++)
  1546.     strm << indent() << enumerations[i] << 'n';
  1547.   if (extendable) {
  1548.     strm << "...n";
  1549.     for (; i < enumerations.GetSize(); i++)
  1550.       strm << indent() << enumerations[i] << 'n';
  1551.   }
  1552.   PrintFinish(strm);
  1553. }
  1556. TypeBase * EnumeratedType::FlattenThisType(const TypeBase & parent)
  1557. {
  1558.   return new DefinedType(this, parent);
  1559. }
  1562. void EnumeratedType::GenerateCplusplus(ostream & hdr, ostream & cxx)
  1563. {
  1564.   PINDEX i;
  1566.   BeginGenerateCplusplus(hdr, cxx);
  1568.   int maxEnumValue = 0;
  1569.   for (i = 0; i < enumerations.GetSize(); i++) {
  1570.     int num = enumerations[i].GetNumber();
  1571.     if (maxEnumValue < num)
  1572.       maxEnumValue = num;
  1573.   }
  1575.   // Generate enumerations and complete the constructor implementation
  1576.   hdr << "    enum Enumerations {n";
  1577.   cxx << ", " << maxEnumValue << ", " << (extendable ? "TRUE" : "FALSE") << "n"
  1578.          "#ifndef PASN_NOPRINTONn"
  1579.          "      , "";
  1581.   int prevNum = -1;
  1582.   for (i = 0; i < enumerations.GetSize(); i++) {
  1583.     if (i > 0) {
  1584.       hdr << ",n";
  1585.       cxx << "        "";
  1586.     }
  1588.     hdr << "      e_" << MakeIdentifierC(enumerations[i].GetName());
  1589.     cxx << enumerations[i].GetName();
  1591.     int num = enumerations[i].GetNumber();
  1592.     if (num != prevNum+1) {
  1593.       hdr << " = " << num;
  1594.       cxx << '=' << num;
  1595.     }
  1596.     prevNum = num;
  1598.     cxx << " "n";
  1599.   }
  1601.   hdr << "n"
  1602.          "    };n"
  1603.          "n";
  1604.   cxx << "#endifn"
  1605.          "    )n"
  1606.          "{n";
  1607.   GenerateCplusplusConstraints(PString(), hdr, cxx);
  1608.   EndGenerateCplusplus(hdr, cxx);
  1609. }
  1612. void EnumeratedType::GenerateOperators(ostream & hdr, ostream & cxx, const TypeBase & actualType)
  1613. {
  1614.   hdr << "    " << actualType.GetIdentifier() << " & operator=(unsigned v)";
  1615.   if (Module->UsingInlines())
  1616.     hdr << " { SetValue(v);  return *this; }n";
  1617.   else {
  1618.     hdr << ";n";
  1619.     cxx << actualType.GetTemplatePrefix()
  1620.         << actualType.GetIdentifier() << " & "
  1621.         << actualType.GetClassNameString() << "::operator=(unsigned v)n"
  1622.            "{n"
  1623.            "  SetValue(v);n"
  1624.            "  return *this;n"
  1625.            "}n"
  1626.            "n"
  1627.            "n";
  1628.   }
  1629. }
  1632. const char * EnumeratedType::GetAncestorClass() const
  1633. {
  1634.   return "PASN_Enumeration";
  1635. }
  1638. /////////////////////////////////////////////////////////
  1640. RealType::RealType()
  1641.   : TypeBase(Tag::UniversalReal)
  1642. {
  1643. }
  1646. const char * RealType::GetAncestorClass() const
  1647. {
  1648.   return "PASN_Real";
  1649. }
  1652. /////////////////////////////////////////////////////////
  1654. BitStringType::BitStringType()
  1655.   : TypeBase(Tag::UniversalBitString)
  1656. {
  1657. }
  1660. BitStringType::BitStringType(NamedNumberList * lst)
  1661.   : TypeBase(Tag::UniversalBitString),
  1662.     allowedBits(*lst)
  1663. {
  1664.   delete lst;
  1665. }
  1667. int BitStringType::GetIdentifierTokenContext() const
  1668. {
  1669.   return OID_IDENTIFIER;
  1670. }
  1673. int BitStringType::GetBraceTokenContext() const
  1674. {
  1675.   return BITSTRING_BRACE;
  1676. }
  1679. const char * BitStringType::GetAncestorClass() const
  1680. {
  1681.   return "PASN_BitString";
  1682. }
  1685. /////////////////////////////////////////////////////////
  1687. OctetStringType::OctetStringType()
  1688.   : TypeBase(Tag::UniversalOctetString)
  1689. {
  1690. }
  1693. void OctetStringType::GenerateOperators(ostream & hdr, ostream & cxx, const TypeBase & actualType)
  1694. {
  1695.   hdr << "    " << actualType.GetIdentifier() << " & operator=(const char * v)";
  1696.   if (Module->UsingInlines())
  1697.     hdr << " { SetValue(v);  return *this; }n";
  1698.   else {
  1699.     hdr << ";n";
  1700.     cxx << actualType.GetTemplatePrefix()
  1701.         << actualType.GetIdentifier() << " & "
  1702.         << actualType.GetClassNameString() << "::operator=(const char * v)n"
  1703.            "{n"
  1704.            "  SetValue(v);n"
  1705.            "  return *this;n"
  1706.            "}n"
  1707.            "n"
  1708.            "n";
  1709.   }
  1711.   hdr << "    " << actualType.GetIdentifier() << " & operator=(const PString & v)";
  1712.   if (Module->UsingInlines())
  1713.     hdr << " { SetValue(v);  return *this; }n";
  1714.   else {
  1715.     hdr << ";n";
  1716.     cxx << actualType.GetTemplatePrefix()
  1717.         << actualType.GetIdentifier() << " & "
  1718.         << actualType.GetClassNameString() << "::operator=(const PString & v)n"
  1719.            "{n"
  1720.            "  SetValue(v);n"
  1721.            "  return *this;n"
  1722.            "}n"
  1723.            "n"
  1724.            "n";
  1725.   }
  1727.   hdr << "    " << actualType.GetIdentifier() << " & operator=(const PBYTEArray & v)";
  1728.   if (Module->UsingInlines())
  1729.     hdr << " { SetValue(v);  return *this; }n";
  1730.   else {
  1731.     hdr << ";n";
  1732.     cxx << actualType.GetTemplatePrefix()
  1733.         << actualType.GetIdentifier() << " & "
  1734.         << actualType.GetClassNameString() << "::operator=(const PBYTEArray & v)n"
  1735.            "{n"
  1736.            "  SetValue(v);n"
  1737.            "  return *this;n"
  1738.            "}n"
  1739.            "n"
  1740.            "n";
  1741.   }
  1742. }
  1745. const char * OctetStringType::GetAncestorClass() const
  1746. {
  1747.   return "PASN_OctetString";
  1748. }
  1751. /////////////////////////////////////////////////////////
  1753. NullType::NullType()
  1754.   : TypeBase(Tag::UniversalNull)
  1755. {
  1756. }
  1759. const char * NullType::GetAncestorClass() const
  1760. {
  1761.   return "PASN_Null";
  1762. }
  1765. /////////////////////////////////////////////////////////
  1767. SequenceType::SequenceType(TypesList * stnd,
  1768.                            BOOL extend,
  1769.                            TypesList * ext,
  1770.                            unsigned tagNum)
  1771.   : TypeBase(tagNum)
  1772. {
  1773.   if (stnd != NULL) {
  1774.     numFields = stnd->GetSize();
  1775.     fields = *stnd;
  1776.     delete stnd;
  1777.   }
  1778.   else
  1779.     numFields = 0;
  1780.   extendable = extend;
  1781.   if (ext != NULL) {
  1782.     ext->DisallowDeleteObjects();
  1783.     for (PINDEX i = 0; i < ext->GetSize(); i++)
  1784.       fields.Append(ext->GetAt(i));
  1785.     delete ext;
  1786.   }
  1787. }
  1790. void SequenceType::PrintOn(ostream & strm) const
  1791. {
  1792.   PrintStart(strm);
  1793.   strm << 'n';
  1794.   PINDEX i;
  1795.   for (i = 0; i < numFields; i++)
  1796.     strm << fields[i];
  1797.   if (extendable) {
  1798.     strm << indent() << "...n";
  1799.     for (; i < fields.GetSize(); i++)
  1800.       strm << fields[i];
  1801.   }
  1802.   PrintFinish(strm);
  1803. }
  1806. void SequenceType::FlattenUsedTypes()
  1807. {
  1808.   for (PINDEX i = 0; i < fields.GetSize(); i++)
  1809.     fields.SetAt(i, fields[i].FlattenThisType(*this));
  1810. }
  1813. TypeBase * SequenceType::FlattenThisType(const TypeBase & parent)
  1814. {
  1815.   return new DefinedType(this, parent);
  1816. }
  1819. BOOL SequenceType::IsPrimitiveType() const
  1820. {
  1821.   return FALSE;
  1822. }
  1825. void SequenceType::GenerateCplusplus(ostream & hdr, ostream & cxx)
  1826. {
  1827.   PINDEX i;
  1829.   BeginGenerateCplusplus(hdr, cxx);
  1831.   PINDEX baseOptions = 0;
  1832.   for (i = 0; i < fields.GetSize(); i++) {
  1833.     if (i < numFields && fields[i].IsOptional())
  1834.       baseOptions++;
  1835.   }
  1837.   // Complete ancestor constructor parameters
  1838.   cxx << ", " << baseOptions << ", "
  1839.       << (extendable ? "TRUE" : "FALSE") << ", "
  1840.       << fields.GetSize() - numFields
  1841.       << ')';
  1843.   // Output enum for optional parameters
  1844.   BOOL outputEnum = FALSE;
  1845.   for (i = 0; i < fields.GetSize(); i++) {
  1846.     if (i >= numFields || fields[i].IsOptional()) {
  1847.       if (outputEnum)
  1848.         hdr << ",n";
  1849.       else {
  1850.         hdr << "    enum OptionalFields {n";
  1851.         outputEnum = TRUE;
  1852.       }
  1853.       hdr << "      e_" << fields[i].GetIdentifier();
  1854.     }
  1855.   }
  1857.   if (outputEnum)
  1858.     hdr << "n"
  1859.            "    };n"
  1860.            "n";
  1862.   // Output the declarations and constructors for member variables
  1863.   for (i = 0; i < fields.GetSize(); i++) {
  1864.     PString varname = "m_" + fields[i].GetIdentifier();
  1865.     hdr << "    " << fields[i].GetTypeName() << ' ' << varname << ";n";
  1866.     if (fields[i].HasNonStandardTag()) {
  1867.       cxx << ",n"
  1868.              "    " << varname;
  1869.       fields[i].GenerateCplusplusConstructor(hdr, cxx);
  1870.     }
  1871.   }
  1873.   // Output declarations for generated functions
  1874.   hdr << "n"
  1875.          "    PINDEX GetDataLength() const;n"
  1876.          "    BOOL Decode(PASN_Stream & strm);n"
  1877.          "    void Encode(PASN_Stream & strm) const;n"
  1878.          "#ifndef PASN_NOPRINTONn"
  1879.          "    void PrintOn(ostream & strm) const;n"
  1880.          "#endifn";
  1881.   if (numFields > 0)
  1882.     hdr << "    Comparison Compare(const PObject & obj) const;n";
  1884.   cxx << "n"
  1885.          "{n";
  1886.   GenerateCplusplusConstraints(PString(), hdr, cxx);
  1887.   for (i = 0; i < fields.GetSize(); i++) {
  1888.     PString ident = fields[i].GetIdentifier();
  1889.     fields[i].GenerateCplusplusConstraints("m_" + ident + ".", hdr, cxx);
  1890.     if (i >= numFields && !fields[i].IsOptional())
  1891.       cxx << "  IncludeOptionalField(e_" << ident << ");n";
  1892.   }
  1893.   cxx << "}n"
  1894.          "n"
  1895.          "n"
  1896.          "#ifndef PASN_NOPRINTONn"
  1897.       << GetTemplatePrefix()
  1898.       << "void " << GetClassNameString() << "::PrintOn(ostream & strm) constn"
  1899.          "{n"
  1900.          "  int indent = strm.precision() + 2;n"
  1901.          "  strm << "{\n";n";
  1903.   for (i = 0; i < fields.GetSize(); i++) {
  1904.     PString id = fields[i].GetIdentifier();
  1905.     if (i >= numFields || fields[i].IsOptional())
  1906.       cxx << "  if (HasOptionalField(e_" << id << "))n"
  1907.              "  ";
  1908.     cxx << "  strm << setw(indent+" << id.GetLength()+3 << ") << ""
  1909.         << id << " = " << setprecision(indent) << m_" << id << " << '\n';n";
  1910.   }
  1912.   cxx << "  strm << setw(indent-1) << "}";n"
  1913.          "}n"
  1914.          "#endifn"
  1915.          "n"
  1916.          "n";
  1918.   if (numFields > 0) {
  1919.     cxx << GetTemplatePrefix()
  1920.         << "PObject::Comparison " << GetClassNameString() << "::Compare(const PObject & obj) constn"
  1921.            "{n"
  1922.            "#ifndef PASN_LEANANDMEANn"
  1923.            "  PAssert(IsDescendant(" << GetClassNameString() << "::Class()), PInvalidCast);n"
  1924.            "#endifn"
  1925.            "  const " << GetClassNameString() << " & other = (const " << GetClassNameString() << " &)obj;n"
  1926.            "n"
  1927.            "  Comparison result;n"
  1928.            "n";
  1930.     for (i = 0; i < numFields; i++) {
  1931.       PString identifier = fields[i].GetIdentifier();
  1932.       cxx << "  if ((result = m_" << identifier << ".Compare(other.m_" << identifier << ")) != EqualTo)n"
  1933.              "    return result;n";
  1934.     }
  1936.     cxx << "n"
  1937.            "  return PASN_Sequence::Compare(other);n"
  1938.            "}n"
  1939.            "n"
  1940.            "n";
  1941.   }
  1943.   cxx << GetTemplatePrefix()
  1944.       << "PINDEX " << GetClassNameString() << "::GetDataLength() constn"
  1945.          "{n"
  1946.          "  return ";
  1948.   outputEnum = FALSE;
  1949.   for (i = 0; i < numFields; i++) {
  1950.     if (outputEnum)
  1951.       cxx << " +n"
  1952.              "         ";
  1953.     else
  1954.       outputEnum = TRUE;
  1955.     cxx << "m_" << fields[i].GetIdentifier() << ".GetObjectLength()";
  1956.   }
  1957.   if (!outputEnum)
  1958.     cxx << '0';
  1960.   cxx << ";n"
  1961.          "}n"
  1962.          "n"
  1963.          "n"
  1964.       << GetTemplatePrefix()
  1965.       << "BOOL " << GetClassNameString() << "::Decode(PASN_Stream & strm)n"
  1966.          "{n"
  1967.          "  if (!PreambleDecode(strm))n"
  1968.          "    return FALSE;nn";
  1970.   for (i = 0; i < numFields; i++) {
  1971.     cxx << "  if (";
  1972.     if (fields[i].IsOptional())
  1973.       cxx << "HasOptionalField(e_" << fields[i].GetIdentifier() << ") && ";
  1974.     cxx << "!m_" << fields[i].GetIdentifier() << ".Decode(strm))n"
  1975.            "    return FALSE;n";
  1976.   }
  1978.   for (; i < fields.GetSize(); i++)
  1979.     cxx << "  if (!KnownExtensionDecode(strm, e_"
  1980.         << fields[i].GetIdentifier()
  1981.         << ", m_" << fields[i].GetIdentifier() << "))n"
  1982.            "    return FALSE;n";
  1984.   cxx << "n"
  1985.          "  return UnknownExtensionsDecode(strm);n"
  1986.          "}n"
  1987.          "n"
  1988.          "n"
  1989.       << GetTemplatePrefix()
  1990.       << "void " << GetClassNameString() << "::Encode(PASN_Stream & strm) constn"
  1991.          "{n"
  1992.          "  PreambleEncode(strm);nn";
  1994.   for (i = 0; i < numFields; i++) {
  1995.     if (fields[i].IsOptional())
  1996.       cxx << "  if (HasOptionalField(e_" << fields[i].GetIdentifier() << "))n"
  1997.              "  ";
  1998.     cxx << "  m_" << fields[i].GetIdentifier() << ".Encode(strm);n";
  1999.   }
  2001.   for (; i < fields.GetSize(); i++)
  2002.     cxx << "  KnownExtensionEncode(strm, e_"
  2003.         << fields[i].GetIdentifier()
  2004.         << ", m_" << fields[i].GetIdentifier() << ");n";
  2006.   cxx << "n"
  2007.          "  UnknownExtensionsEncode(strm);n";
  2009.   EndGenerateCplusplus(hdr, cxx);
  2010. }
  2013. const char * SequenceType::GetAncestorClass() const
  2014. {
  2015.   return "PASN_Sequence";
  2016. }
  2019. BOOL SequenceType::CanReferenceType() const
  2020. {
  2021.   return TRUE;
  2022. }
  2025. BOOL SequenceType::ReferencesType(const TypeBase & type)
  2026. {
  2027.   for (PINDEX i = 0; i < fields.GetSize(); i++)
  2028.     if (fields[i].ReferencesType(type))
  2029.       return TRUE;
  2030.   return FALSE;
  2031. }
  2034. /////////////////////////////////////////////////////////
  2036. SequenceOfType::SequenceOfType(TypeBase * base, Constraint * constraint, unsigned tag)
  2037.   : TypeBase(tag)
  2038. {
  2039.   baseType = base;
  2040.   if (constraint != NULL)
  2041.     AddConstraint(constraint);
  2042. }
  2045. SequenceOfType::~SequenceOfType()
  2046. {
  2047.   delete baseType;
  2048. }
  2051. void SequenceOfType::PrintOn(ostream & strm) const
  2052. {
  2053.   PrintStart(strm);
  2054.   if (baseType == NULL)
  2055.     strm << "!!Null Type!!n";
  2056.   else
  2057.     strm << *baseType << 'n';
  2058.   PrintFinish(strm);
  2059. }
  2062. void SequenceOfType::FlattenUsedTypes()
  2063. {
  2064.   baseType = baseType->FlattenThisType(*this);
  2065. }
  2068. TypeBase * SequenceOfType::FlattenThisType(const TypeBase & parent)
  2069. {
  2070.   if (!baseType->IsPrimitiveType() || baseType->HasConstraints())
  2071.     return new DefinedType(this, parent);
  2073.   // Search for an existing sequence of type
  2074.   PString seqName = "ArrayOf_" + baseType->GetTypeName();
  2076.   TypeBase * existingType = Module->FindType(seqName);
  2077.   if (existingType != NULL)
  2078.     return new DefinedType(this, existingType);
  2080.   return new DefinedType(this, seqName);
  2081. }
  2084. BOOL SequenceOfType::IsPrimitiveType() const
  2085. {
  2086.   return FALSE;
  2087. }
  2090. void SequenceOfType::GenerateCplusplus(ostream & hdr, ostream & cxx)
  2091. {
  2092.   BeginGenerateCplusplus(hdr, cxx);
  2093.   cxx << ")n"
  2094.          "{n";
  2095.   GenerateCplusplusConstraints(PString(), hdr, cxx);
  2096.   cxx << "}n"
  2097.          "n"
  2098.          "n";
  2100.   PString baseTypeName = baseType->GetTypeName();
  2102.   // Generate declarations for generated functions
  2103.   hdr << "    PASN_Object * CreateObject() const;n"
  2104.          "    " << baseTypeName << " & operator[](PINDEX i) const";
  2105.   if (Module->UsingInlines())
  2106.     hdr << " { return (" << baseTypeName << " &)array[i]; }n";
  2107.   else
  2108.     hdr << ";n";
  2110.   // Generate implementation for functions
  2111.   cxx << GetTemplatePrefix()
  2112.       << "PASN_Object * " << GetClassNameString() << "::CreateObject() constn"
  2113.          "{n";
  2115.   if (baseType->HasConstraints()) {
  2116.     cxx << "  " << baseTypeName << " * obj = new " << baseTypeName << ";n";
  2117.     baseType->GenerateCplusplusConstraints("obj->", hdr, cxx);
  2118.     cxx << "  return obj;n";
  2119.   }
  2120.   else
  2121.     cxx << "  return new " << baseTypeName << ";n";
  2123.   if (!Module->UsingInlines())
  2124.     cxx << "}n"
  2125.            "n"
  2126.            "n"
  2127.         << GetTemplatePrefix()
  2128.         << baseTypeName << " & " << GetClassNameString() << "::operator[](PINDEX i) constn"
  2129.            "{n"
  2130.            "  return (" << baseTypeName << " &)array[i];n";
  2132.   EndGenerateCplusplus(hdr, cxx);
  2133. }
  2136. void SequenceOfType::GenerateForwardDecls(ostream & hdr)
  2137. {
  2138.   if (baseType->IsParameterizedType())
  2139.     return;
  2141.   PString baseTypeName = baseType->GetTypeName();
  2143.   PStringSet typesOutput(PARRAYSIZE(StandardClasses), StandardClasses);
  2144.   typesOutput += GetIdentifier();
  2146.   if (!typesOutput.Contains(baseTypeName))
  2147.     hdr << "class " << baseTypeName << ";nn";
  2148. }
  2151. const char * SequenceOfType::GetAncestorClass() const
  2152. {
  2153.   return "PASN_Array";
  2154. }
  2157. BOOL SequenceOfType::CanReferenceType() const
  2158. {
  2159.   return TRUE;
  2160. }
  2163. BOOL SequenceOfType::ReferencesType(const TypeBase & type)
  2164. {
  2165.   return baseType->ReferencesType(type) && baseType->IsParameterizedType();
  2166. }
  2169. /////////////////////////////////////////////////////////
  2171. SetType::SetType()
  2172.   : SequenceType(NULL, FALSE, NULL, Tag::UniversalSet)
  2173. {
  2174. }
  2177. SetType::SetType(SequenceType * seq)
  2178.   : SequenceType(*seq)
  2179. {
  2180.   tag.number = Tag::UniversalSet;
  2181. }
  2184. const char * SetType::GetAncestorClass() const
  2185. {
  2186.   return "PASN_Set";
  2187. }
  2190. /////////////////////////////////////////////////////////
  2192. SetOfType::SetOfType(TypeBase * base, Constraint * constraint)
  2193.   : SequenceOfType(base, constraint, Tag::UniversalSet)
  2194. {
  2195. }
  2198. /////////////////////////////////////////////////////////
  2200. ChoiceType::ChoiceType(TypesList * stnd,
  2201.                        BOOL extendable,
  2202.                        TypesList * extensions)
  2203.   : SequenceType(stnd, extendable, extensions, Tag::IllegalUniversalTag)
  2204. {
  2205. }
  2208. void ChoiceType::GenerateCplusplus(ostream & hdr, ostream & cxx)
  2209. {
  2210.   PINDEX i;
  2213.   BeginGenerateCplusplus(hdr, cxx);
  2215.   // Complete the ancestor constructor parameters
  2216.   cxx << ", " << numFields << ", " << (extendable ? "TRUE" : "FALSE");
  2218.   // Generate the enum's for each choice discriminator, and include strings for
  2219.   // PrintOn() debug output into acncestor constructor
  2220.   BOOL outputEnum = FALSE;
  2221.   int prevNum = -1;
  2222.   for (i = 0; i < fields.GetSize(); i++) {
  2223.     const Tag & fieldTag = fields[i].GetTag();
  2224.     if (fieldTag.mode == Tag::Automatic || !fields[i].IsChoice()) {
  2225.       if (outputEnum) {
  2226.         hdr << ",n";
  2227.         cxx << "        "";
  2228.       }
  2229.       else {
  2230.         hdr << "    enum Choices {n";
  2231.         cxx << "n"
  2232.                "#ifndef PASN_NOPRINTONn"
  2233.                "      , "";
  2234.         outputEnum = TRUE;
  2235.       }
  2237.       hdr << "      e_" << fields[i].GetIdentifier();
  2238.       cxx << fields[i].GetIdentifier();
  2240.       if (fieldTag.mode != Tag::Automatic && fieldTag.number != (unsigned)(prevNum+1)) {
  2241.         hdr << " = " << fieldTag.number;
  2242.         cxx << '=' << fieldTag.number;
  2243.       }
  2244.       prevNum = fieldTag.number;
  2245.       cxx << " "n";
  2246.     }
  2247.   }
  2249.   if (outputEnum) {
  2250.     hdr << "n"
  2251.            "    };n"
  2252.            "n";
  2253.     cxx << "#endifn"
  2254.            "    ";
  2255.   }
  2257.   cxx << ")n"
  2258.          "{n";
  2259.   GenerateCplusplusConstraints(PString(), hdr, cxx);
  2260.   cxx << "}n"
  2261.          "n"
  2262.          "n";
  2264.   // Generate code for type safe cast operators of selected choice object
  2265.   BOOL needExtraLine = FALSE;
  2267.   PStringSet typesOutput(PARRAYSIZE(StandardClasses), StandardClasses);
  2268.   typesOutput += GetIdentifier();
  2270.   for (i = 0; i < fields.GetSize(); i++) {
  2271.     PString type = fields[i].GetTypeName();
  2272.     if (!typesOutput.Contains(type)) {
  2273.       if (Module->UsingInlines()) {
  2274.         hdr << "#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9n"
  2275.                "    operator " << type << " &() const { return *(" << type << " *)choice; }n"
  2276.                "#elsen"
  2277.                "    operator " << type << " &() { return *(" << type << " *)choice; }n"
  2278.                "    operator const " << type << " &() const { return *(const " << type << " *)choice; }n"
  2279.                "#endifn";
  2280.       }
  2281.       else {
  2282.         hdr << "#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9n"
  2283.                "    operator " << type << " &() const;n"
  2284.                "#elsen"
  2285.                "    operator " << type << " &();n"
  2286.                "    operator const " << type << " &() const;n"
  2287.                "#endifn";
  2288.         cxx << "#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9n"
  2289.             << GetTemplatePrefix()
  2290.             << GetClassNameString() << "::operator " << type << " &() constn"
  2291.                "#elsen"
  2292.             << GetTemplatePrefix()
  2293.             << GetClassNameString() << "::operator " << type << " &()n"
  2294.                "{n"
  2295.                "#ifndef PASN_LEANANDMEANn"
  2296.                "  PAssert(PAssertNULL(choice)->IsDescendant(" << type << "::Class()), PInvalidCast);n"
  2297.                "#endifn"
  2298.                "  return *(" << type << " *)choice;n"
  2299.                "}n"
  2300.                "n"
  2301.                "n"
  2302.             << GetTemplatePrefix()
  2303.             << GetClassNameString() << "::operator const " << type << " &() constn"
  2304.                "#endifn"
  2305.                "{n"
  2306.                "#ifndef PASN_LEANANDMEANn"
  2307.                "  PAssert(PAssertNULL(choice)->IsDescendant(" << type << "::Class()), PInvalidCast);n"
  2308.                "#endifn"
  2309.                "  return *(" << type << " *)choice;n"
  2310.                "}n"
  2311.                "n"
  2312.                "n";
  2313.       }
  2314.       typesOutput += type;
  2315.       needExtraLine = TRUE;
  2316.     }
  2317.   }
  2319.   if (needExtraLine)
  2320.     hdr << 'n';
  2323.   // Generate virtual function to create chosen object based on discriminator
  2324.   hdr << "    BOOL CreateObject();n";
  2325.   cxx << GetTemplatePrefix()
  2326.       << "BOOL " << GetClassNameString() << "::CreateObject()n"
  2327.          "{n";
  2330.   // declare an array of flags indicating whether the tag has been output or not
  2331.   PBYTEArray flags(fields.GetSize());
  2332.   for (i = 0; i < fields.GetSize(); i++)
  2333.     flags[i] = 0;
  2335.   // keep
  2336.   outputEnum = FALSE;
  2337.   for (i = 0; i < fields.GetSize(); i++) {
  2339.     if (fields[i].GetTag().mode == Tag::Automatic || !fields[i].IsChoice()) {
  2341.       // ignore this tag if output previously
  2342.       if (flags[i] != 0)
  2343.         continue;
  2344.     
  2345.       if (!outputEnum) {
  2346.         cxx << "  switch (tag) {n";
  2347.         outputEnum = TRUE;
  2348.       }
  2350.       // if the field has constraints, then output it alone
  2351.       // otherwise, look for all fields with the same type
  2352.       PString name = fields[i].GetTypeName();
  2353.       if (fields[i].HasConstraints()) {
  2354.         cxx << "    case e_" << fields[i].GetIdentifier() << " :n";
  2355.         flags[i] = 1;
  2356.       } else {
  2357.         PINDEX j;
  2358.         for (j = i; j < fields.GetSize(); j++) {
  2359.           if (fields[j].GetTypeName() == name) {
  2360.             cxx << "    case e_" << fields[j].GetIdentifier() << " :n";
  2361.             flags[j] = 1;
  2362.           }
  2363.         }
  2364.       }
  2366.       cxx << "      choice = new " << name;
  2367.       fields[i].GenerateCplusplusConstructor(hdr, cxx);
  2368.       cxx << ";n";
  2369.       fields[i].GenerateCplusplusConstraints("    choice->", hdr, cxx);
  2370.       cxx << "      return TRUE;n";
  2371.     }
  2372.   }
  2374.   if (outputEnum)
  2375.     cxx << "  }n"
  2376.            "n";
  2378.   for (i = 0; i < fields.GetSize(); i++) {
  2379.     if (fields[i].GetTag().mode != Tag::Automatic && fields[i].IsChoice())
  2380.       cxx << "  choice = new " << fields[i].GetTypeName() << "(tag, tagClass);n"
  2381.              "  if (((PASN_Choice*)choice)->CreateObject())n"
  2382.              "    return TRUE;n"
  2383.              "  delete choice;n"
  2384.              "n";
  2385.   }
  2387.   cxx << "  choice = NULL;n"
  2388.          "  return FALSE;n";
  2390.   EndGenerateCplusplus(hdr, cxx);
  2391. }
  2394. void ChoiceType::GenerateForwardDecls(ostream & hdr)
  2395. {
  2396.   // Output forward declarations for choice pointers, but not standard classes
  2397.   BOOL needExtraLine = FALSE;
  2399.   PStringSet typesOutput(PARRAYSIZE(StandardClasses), StandardClasses);
  2400.   typesOutput += GetIdentifier();
  2402.   for (PINDEX i = 0; i < fields.GetSize(); i++) {
  2403.     PString type = fields[i].GetTypeName();
  2404.     if (!fields[i].IsParameterizedType() && !typesOutput.Contains(type)) {
  2405.       hdr << "class " << type << ";n";
  2406.       needExtraLine = TRUE;
  2407.     }
  2408.   }
  2410.   if (needExtraLine)
  2411.     hdr << 'n';
  2412. }
  2415. BOOL ChoiceType::IsPrimitiveType() const
  2416. {
  2417.   return FALSE;
  2418. }
  2421. BOOL ChoiceType::IsChoice() const
  2422. {
  2423.   return TRUE;
  2424. }
  2427. const char * ChoiceType::GetAncestorClass() const
  2428. {
  2429.   return "PASN_Choice";
  2430. }
  2433. BOOL ChoiceType::ReferencesType(const TypeBase & type)
  2434. {
  2435.   for (PINDEX i = 0; i < fields.GetSize(); i++) {
  2436.     if (fields[i].ReferencesType(type) && fields[i].IsParameterizedType())
  2437.       return TRUE;
  2438.   }
  2439.   return FALSE;
  2440. }
  2443. /////////////////////////////////////////////////////////
  2445. EmbeddedPDVType::EmbeddedPDVType()
  2446.   : TypeBase(Tag::UniversalEmbeddedPDV)
  2447. {
  2448. }
  2451. const char * EmbeddedPDVType::GetAncestorClass() const
  2452. {
  2453.   return "PASN_OctetString";
  2454. }
  2457. /////////////////////////////////////////////////////////
  2459. ExternalType::ExternalType()
  2460.   : TypeBase(Tag::UniversalExternalType)
  2461. {
  2462. }
  2465. const char * ExternalType::GetAncestorClass() const
  2466. {
  2467.   return "PASN_OctetString";
  2468. }
  2471. /////////////////////////////////////////////////////////
  2473. AnyType::AnyType(PString * ident)
  2474.   : TypeBase(Tag::UniversalExternalType)
  2475. {
  2476.   if (ident != NULL) {
  2477.     identifier = *ident;
  2478.     delete ident;
  2479.   }
  2480. }
  2483. void AnyType::PrintOn(ostream & strm) const
  2484. {
  2485.   PrintStart(strm);
  2486.   if (!identifier)
  2487.     strm << "Defined by " << identifier;
  2488.   PrintFinish(strm);
  2489. }
  2492. const char * AnyType::GetAncestorClass() const
  2493. {
  2494.   return "PASN_OctetString";
  2495. }
  2498. /////////////////////////////////////////////////////////
  2500. StringTypeBase::StringTypeBase(int tag)
  2501.   : TypeBase(tag)
  2502. {
  2503. }
  2506. int StringTypeBase::GetBraceTokenContext() const
  2507. {
  2508.   return STRING_BRACE;
  2509. }
  2512. void StringTypeBase::GenerateOperators(ostream & hdr, ostream & cxx, const TypeBase & actualType)
  2513. {
  2514.   hdr << "    " << actualType.GetIdentifier() << " & operator=(const char * v)";
  2515.   if (Module->UsingInlines())
  2516.     hdr << " { SetValue(v);  return *this; }n";
  2517.   else {
  2518.     hdr << ";n";
  2519.     cxx << actualType.GetTemplatePrefix()
  2520.         << actualType.GetIdentifier() << " & "
  2521.         << actualType.GetClassNameString() << "::operator=(const char * v)n"
  2522.            "{n"
  2523.            "  SetValue(v);n"
  2524.            "  return *this;n"
  2525.            "}n"
  2526.            "n"
  2527.            "n";
  2528.   }
  2530.   hdr << "    " << actualType.GetIdentifier() << " & operator=(const PString & v)";
  2531.   if (Module->UsingInlines())
  2532.     hdr << " { SetValue(v);  return *this; }n";
  2533.   else {
  2534.     hdr << ";n";
  2535.     cxx << actualType.GetTemplatePrefix()
  2536.         << actualType.GetIdentifier() << " & "
  2537.         << actualType.GetClassNameString() << "::operator=(const PString & v)n"
  2538.            "{n"
  2539.            "  SetValue(v);n"
  2540.            "  return *this;n"
  2541.            "}n"
  2542.            "n"
  2543.            "n";
  2544.   }
  2545. }
  2548. /////////////////////////////////////////////////////////
  2550. BMPStringType::BMPStringType()
  2551.   : StringTypeBase(Tag::UniversalBMPString)
  2552. {
  2553. }
  2556. const char * BMPStringType::GetAncestorClass() const
  2557. {
  2558.   return "PASN_BMPString";
  2559. }
  2562. /////////////////////////////////////////////////////////
  2564. GeneralStringType::GeneralStringType()
  2565.   : StringTypeBase(Tag::UniversalGeneralString)
  2566. {
  2567. }
  2570. const char * GeneralStringType::GetAncestorClass() const
  2571. {
  2572.   return "PASN_GeneralString";
  2573. }
  2576. /////////////////////////////////////////////////////////
  2578. GraphicStringType::GraphicStringType()
  2579.   : StringTypeBase(Tag::UniversalGraphicString)
  2580. {
  2581. }
  2584. const char * GraphicStringType::GetAncestorClass() const
  2585. {
  2586.   return "PASN_GraphicString";
  2587. }
  2590. /////////////////////////////////////////////////////////
  2592. IA5StringType::IA5StringType()
  2593.   : StringTypeBase(Tag::UniversalIA5String)
  2594. {
  2595. }
  2598. const char * IA5StringType::GetAncestorClass() const
  2599. {
  2600.   return "PASN_IA5String";
  2601. }
  2604. /////////////////////////////////////////////////////////
  2606. ISO646StringType::ISO646StringType()
  2607.   : StringTypeBase(Tag::UniversalVisibleString)
  2608. {
  2609. }
  2612. const char * ISO646StringType::GetAncestorClass() const
  2613. {
  2614.   return "PASN_ISO646String";
  2615. }
  2618. /////////////////////////////////////////////////////////
  2620. NumericStringType::NumericStringType()
  2621.   : StringTypeBase(Tag::UniversalNumericString)
  2622. {
  2623. }
  2626. const char * NumericStringType::GetAncestorClass() const
  2627. {
  2628.   return "PASN_NumericString";
  2629. }
  2632. /////////////////////////////////////////////////////////
  2634. PrintableStringType::PrintableStringType()
  2635.   : StringTypeBase(Tag::UniversalPrintableString)
  2636. {
  2637. }
  2640. const char * PrintableStringType::GetAncestorClass() const
  2641. {
  2642.   return "PASN_PrintableString";
  2643. }
  2646. /////////////////////////////////////////////////////////
  2648. TeletexStringType::TeletexStringType()
  2649.   : StringTypeBase(Tag::UniversalTeletexString)
  2650. {
  2651. }
  2654. const char * TeletexStringType::GetAncestorClass() const
  2655. {
  2656.   return "PASN_TeletexString";
  2657. }
  2660. /////////////////////////////////////////////////////////
  2662. T61StringType::T61StringType()
  2663.   : StringTypeBase(Tag::UniversalTeletexString)
  2664. {
  2665. }
  2668. const char * T61StringType::GetAncestorClass() const
  2669. {
  2670.   return "PASN_T61String";
  2671. }
  2674. /////////////////////////////////////////////////////////
  2676. UniversalStringType::UniversalStringType()
  2677.   : StringTypeBase(Tag::UniversalUniversalString)
  2678. {
  2679. }
  2682. const char * UniversalStringType::GetAncestorClass() const
  2683. {
  2684.   return "PASN_UniversalString";
  2685. }
  2688. /////////////////////////////////////////////////////////
  2690. VideotexStringType::VideotexStringType()
  2691.   : StringTypeBase(Tag::UniversalVideotexString)
  2692. {
  2693. }
  2696. const char * VideotexStringType::GetAncestorClass() const
  2697. {
  2698.   return "PASN_VideotexString";
  2699. }
  2702. /////////////////////////////////////////////////////////
  2704. VisibleStringType::VisibleStringType()
  2705.   : StringTypeBase(Tag::UniversalVisibleString)
  2706. {
  2707. }
  2710. const char * VisibleStringType::GetAncestorClass() const
  2711. {
  2712.   return "PASN_VisibleString";
  2713. }
  2716. /////////////////////////////////////////////////////////
  2718. UnrestrictedCharacterStringType::UnrestrictedCharacterStringType()
  2719.   : StringTypeBase(Tag::UniversalUniversalString)
  2720. {
  2721. }
  2724. const char * UnrestrictedCharacterStringType::GetAncestorClass() const
  2725. {
  2726.   return "PASN_UnrestrictedString";
  2727. }
  2730. /////////////////////////////////////////////////////////
  2732. GeneralizedTimeType::GeneralizedTimeType()
  2733.   : TypeBase(Tag::UniversalGeneralisedTime)
  2734. {
  2735. }
  2738. const char * GeneralizedTimeType::GetAncestorClass() const
  2739. {
  2740.   return "PASN_GeneralizedTime";
  2741. }
  2744. /////////////////////////////////////////////////////////
  2746. UTCTimeType::UTCTimeType()
  2747.   : TypeBase(Tag::UniversalUTCTime)
  2748. {
  2749. }
  2752. const char * UTCTimeType::GetAncestorClass() const
  2753. {
  2754.   return "PASN_UTCTime";
  2755. }
  2758. /////////////////////////////////////////////////////////
  2760. ObjectDescriptorType::ObjectDescriptorType()
  2761.   : TypeBase(Tag::UniversalObjectDescriptor)
  2762. {
  2763. }
  2766. const char * ObjectDescriptorType::GetAncestorClass() const
  2767. {
  2768.   return "PASN_ObectDescriptor";
  2769. }
  2772. /////////////////////////////////////////////////////////
  2774. ObjectIdentifierType::ObjectIdentifierType()
  2775.   : TypeBase(Tag::UniversalObjectId)
  2776. {
  2777. }
  2780. int ObjectIdentifierType::GetIdentifierTokenContext() const
  2781. {
  2782.   return OID_IDENTIFIER;
  2783. }
  2786. int ObjectIdentifierType::GetBraceTokenContext() const
  2787. {
  2788.   return OID_BRACE;
  2789. }
  2792. const char * ObjectIdentifierType::GetAncestorClass() const
  2793. {
  2794.   return "PASN_ObjectId";
  2795. }
  2798. /////////////////////////////////////////////////////////
  2800. ObjectClassFieldType::ObjectClassFieldType(PString * objclass, PString * field)
  2801.   : TypeBase(Tag::IllegalUniversalTag),
  2802.     asnObjectClassName(*objclass),
  2803.     asnObjectClassField(*field)
  2804. {
  2805.   delete objclass;
  2806.   delete field;
  2807. }
  2810. const char * ObjectClassFieldType::GetAncestorClass() const
  2811. {
  2812.   return "";
  2813. }
  2816. void ObjectClassFieldType::PrintOn(ostream & strm) const
  2817. {
  2818.   PrintStart(strm);
  2819.   strm << asnObjectClassName << '.' << asnObjectClassField;
  2820.   PrintFinish(strm);
  2821. }
  2824. void ObjectClassFieldType::GenerateCplusplus(ostream & hdr, ostream & cxx)
  2825. {
  2826.   hdr << "//n"
  2827.          "// " << GetName() << "n"
  2828.          "//n"
  2829.          "n"
  2830.          "typedef ";
  2831.   GenerateCplusplusConstraints(PString(), hdr, cxx);
  2832.   hdr << ' ' << GetIdentifier() << ";n"
  2833.          "n"
  2834.          "n";
  2835. }
  2838. BOOL ObjectClassFieldType::CanReferenceType() const
  2839. {
  2840.   return TRUE;
  2841. }
  2844. BOOL ObjectClassFieldType::ReferencesType(const TypeBase & type)
  2845. {
  2846.   for (PINDEX i = 0; i < constraints.GetSize(); i++) {
  2847.     if (constraints[i].ReferencesType(type))
  2848.       return TRUE;
  2849.   }
  2850.   return FALSE;
  2851. }
  2854. /////////////////////////////////////////////////////////
  2856. ImportedType::ImportedType(PString * theName, BOOL param)
  2857.   : TypeBase(Tag::IllegalUniversalTag)
  2858. {
  2859.   identifier = name = *theName;
  2860.   delete theName;
  2862.   parameterised = param;
  2863. }
  2866. const char * ImportedType::GetAncestorClass() const
  2867. {
  2868.   return identifier;
  2869. }
  2872. void ImportedType::AdjustIdentifier()
  2873. {
  2874.   identifier = modulePrefix + '_' + MakeIdentifierC(name);
  2875. }
  2878. void ImportedType::GenerateCplusplus(ostream &, ostream &)
  2879. {
  2880. }
  2883. void ImportedType::SetImportPrefix(const PString & prefix)
  2884. {
  2885.   modulePrefix = prefix;
  2886. }
  2889. BOOL ImportedType::IsParameterisedImport() const
  2890. {
  2891.   return parameterised;
  2892. }
  2895. /////////////////////////////////////////////////////////
  2897. SearchType::SearchType(const PString & theName)
  2898.   : TypeBase(Tag::IllegalUniversalTag)
  2899. {
  2900.   identifier = name = theName;
  2901. }
  2904. const char * SearchType::GetAncestorClass() const
  2905. {
  2906.   return identifier;
  2907. }
  2910. /////////////////////////////////////////////////////////
  2912. void ValueBase::SetValueName(PString * name)
  2913. {
  2914.   valueName = *name;
  2915.   delete name;
  2916. }
  2919. void ValueBase::PrintBase(ostream & strm) const
  2920. {
  2921.   if (!valueName)
  2922.     strm << 'n' << indent() << valueName << '=';
  2923. }
  2926. void ValueBase::GenerateCplusplus(ostream &, ostream &)
  2927. {
  2928.   PError << StdError(Warning) << "unsupported value type." << endl;
  2929. }
  2932. /////////////////////////////////////////////////////////
  2934. DefinedValue::DefinedValue(PString * name)
  2935.   : referenceName(*name)
  2936. {
  2937.   delete name;
  2938.   actualValue = NULL;
  2939.   unresolved = TRUE;
  2940. }
  2943. void DefinedValue::PrintOn(ostream & strm) const
  2944. {
  2945.   PrintBase(strm);
  2946.   strm << referenceName;
  2947. }
  2950. void DefinedValue::GenerateCplusplus(ostream & hdr, ostream & cxx)
  2951. {
  2952.   if (unresolved) {
  2953.     unresolved = FALSE;
  2955.     const ValuesList & values = Module->GetValues();
  2956.     for (PINDEX i = 0; i < values.GetSize(); i++) {
  2957.       if (values[i].GetName() == referenceName) {
  2958.         actualValue = &values[i];
  2959.         break;
  2960.       }
  2961.     }
  2962.   }
  2964.   if (actualValue != NULL)
  2965.     actualValue->GenerateCplusplus(hdr, cxx);
  2966.   else
  2967.     cxx << referenceName;
  2968. }
  2971. /////////////////////////////////////////////////////////
  2973. BooleanValue::BooleanValue(BOOL newVal)
  2974. {
  2975.   value = newVal;
  2976. }
  2979. void BooleanValue::PrintOn(ostream & strm) const
  2980. {
  2981.   PrintBase(strm);
  2982.   strm << (value ? "TRUE" : "FALSE");
  2983. }
  2986. void BooleanValue::GenerateCplusplus(ostream &, ostream & cxx)
  2987. {
  2988.   cxx << (value ? "TRUE" : "FALSE");
  2989. }
  2992. /////////////////////////////////////////////////////////
  2994. IntegerValue::IntegerValue(PInt64 newVal)
  2995. {
  2996.   value = newVal;
  2997. }
  3000. void IntegerValue::PrintOn(ostream & strm) const
  3001. {
  3002.   PrintBase(strm);
  3003.   
  3004.   strm << value;
  3005. }
  3008. void IntegerValue::GenerateCplusplus(ostream &, ostream & cxx)
  3009. {
  3010.   cxx << value;
  3011.   if (value > INT_MAX)
  3012.     cxx << 'U';
  3013. }
  3016. /////////////////////////////////////////////////////////
  3018. RealValue::RealValue(double newVal)
  3019. {
  3020.   value = newVal;
  3021. }
  3024. /////////////////////////////////////////////////////////
  3026. OctetStringValue::OctetStringValue(PString * newVal)
  3027. {
  3028.   // value = *newVal;
  3029.   delete newVal;
  3030. }
  3033. /////////////////////////////////////////////////////////
  3035. BitStringValue::BitStringValue(PString * newVal)
  3036. {
  3037.   // value = *newVal;
  3038.   delete newVal;
  3039. }
  3042. BitStringValue::BitStringValue(PStringList * newVal)
  3043. {
  3044.   // value = *newVal;
  3045.   delete newVal;
  3046. }
  3049. /////////////////////////////////////////////////////////
  3051. CharacterValue::CharacterValue(BYTE c)
  3052. {
  3053.   value = c;
  3054. }
  3057. CharacterValue::CharacterValue(BYTE t1, BYTE t2)
  3058. {
  3059.   value = (t1<<8) + t2;
  3060. }
  3063. CharacterValue::CharacterValue(BYTE q1, BYTE q2, BYTE q3, BYTE q4)
  3064. {
  3065.   value = (q1<<24) + (q2<<16) + (q3<<8) + q4;
  3066. }
  3069. void CharacterValue::PrintOn(ostream & strm) const
  3070. {
  3071.   strm << "'\x" << hex << value << ''';
  3072. }
  3075. void CharacterValue::GenerateCplusplus(ostream &, ostream & cxx)
  3076. {
  3077.   cxx << value;
  3078. }
  3081. /////////////////////////////////////////////////////////
  3083. CharacterStringValue::CharacterStringValue(PString * newVal)
  3084. {
  3085.   value = *newVal;
  3086.   delete newVal;
  3087. }
  3090. CharacterStringValue::CharacterStringValue(PStringList * newVal)
  3091. {
  3092.   for (PINDEX i = 0; i < newVal->GetSize(); i++)
  3093.     value += (*newVal)[i];
  3094.   delete newVal;
  3095. }
  3098. void CharacterStringValue::PrintOn(ostream & strm) const
  3099. {
  3100.   strm << value;
  3101. }
  3104. void CharacterStringValue::GenerateCplusplus(ostream &, ostream & cxx)
  3105. {
  3106.   cxx << value;
  3107. }
  3110. /////////////////////////////////////////////////////////
  3112. ObjectIdentifierValue::ObjectIdentifierValue(PString * newVal)
  3113. {
  3114.   value.Append(newVal);
  3115. }
  3118. ObjectIdentifierValue::ObjectIdentifierValue(PStringList * newVal)
  3119. {
  3120.   value = *newVal;
  3121.   delete newVal;
  3122. }
  3125. void ObjectIdentifierValue::PrintOn(ostream & strm) const
  3126. {
  3127.   PrintBase(strm);
  3128.   if (value.IsEmpty())
  3129.     strm << "empty object identifier";
  3130.   else {
  3131.     strm << value[0];
  3132.     for (PINDEX i = 1; i < value.GetSize(); i++)
  3133.       strm << '.' << value[i];
  3134.   }
  3135.   strm << 'n';
  3136. }
  3139. /////////////////////////////////////////////////////////
  3141. void MinValue::PrintOn(ostream & strm) const
  3142. {
  3143.   strm << "MIN";
  3144. }
  3147. void MinValue::GenerateCplusplus(ostream &, ostream & cxx)
  3148. {
  3149.   cxx << "MinimumValue";
  3150. }
  3153. /////////////////////////////////////////////////////////
  3155. void MaxValue::PrintOn(ostream & strm) const
  3156. {
  3157.   strm << "MAX";
  3158. }
  3161. void MaxValue::GenerateCplusplus(ostream &, ostream & cxx)
  3162. {
  3163.   cxx << "MaximumValue";
  3164. }
  3167. /////////////////////////////////////////////////////////
  3169. SequenceValue::SequenceValue(ValuesList * list)
  3170. {
  3171.   if (list != NULL) {
  3172.     values = *list;
  3173.     delete list;
  3174.   }
  3175. }
  3178. void SequenceValue::PrintOn(ostream & strm) const
  3179. {
  3180.   strm << "{ ";
  3181.   for (PINDEX i = 0; i < values.GetSize(); i++) {
  3182.     if (i > 0)
  3183.       strm << ", ";
  3184.     strm << values[i];
  3185.   }
  3186.   strm << " }";
  3187. }
  3190. /////////////////////////////////////////////////////////
  3192. MibBase::MibBase(PString * nam,
  3193.                  PString * descr,
  3194.                  PString * refer,
  3195.                  ValueBase * val)
  3196.   : name(*nam)
  3197. {
  3198.   delete nam;
  3199.   if (descr != NULL) {
  3200.     description = *descr;
  3201.     delete descr;
  3202.   }
  3203.   if (refer != NULL) {
  3204.     reference = *refer;
  3205.     delete refer;
  3206.   }
  3207.   value = val;
  3208. }
  3211. MibBase::~MibBase()
  3212. {
  3213.   delete value;
  3214. }
  3217. /////////////////////////////////////////////////////////
  3219. MibObject::MibObject(PString * nam,
  3220.                      TypeBase * typ,
  3221.                      Access acc,
  3222.                      Status stat,
  3223.                      PString * descr,
  3224.                      PString * refer,
  3225.                      PStringList * idx,
  3226.                      ValueBase * defVal,
  3227.                      ValueBase * setVal)
  3228.   : MibBase(nam, descr, refer, setVal)
  3229. {
  3230.   type = typ;
  3231.   access = acc;
  3232.   status = stat;
  3233.   if (idx != NULL) {
  3234.     index = *idx;
  3235.     delete idx;
  3236.   }
  3237.   defaultValue = defVal;
  3238. }
  3241. MibObject::~MibObject()
  3242. {
  3243.   delete type;
  3244.   delete defaultValue;
  3245. }
  3248. void MibObject::PrintOn(ostream & strm) const
  3249. {
  3250.   strm << "  Object: " << name << "n  " << *type
  3251.        << "    " << description << "n"
  3252.           "    " << *value << 'n';
  3253. }
  3256. /////////////////////////////////////////////////////////
  3258. MibTrap::MibTrap(PString * nam, ValueBase * ent, ValuesList * var,
  3259.                  PString * descr, PString * refer, ValueBase * val)
  3260.   : MibBase(nam, descr, refer, val)
  3261. {
  3262.   enterprise = ent;
  3263.   if (var != NULL) {
  3264.     variables = *var;
  3265.     delete var;
  3266.   }
  3267. }
  3270. MibTrap::~MibTrap()
  3271. {
  3272.   delete enterprise;
  3273. }
  3276. void MibTrap::PrintOn(ostream & strm) const
  3277. {
  3278.   strm << "  Trap: " << name << "n  " << *enterprise
  3279.        << "    " << description << "n"
  3280.           "    " << *value << 'n';
  3281. }
  3284. /////////////////////////////////////////////////////////
  3286. ImportModule::ImportModule(PString * name, TypesList * syms)
  3287.   : fullModuleName(*name),
  3288.     shortModuleName(Module->GetImportModuleName(*name))
  3289. {
  3290.   delete name;
  3291.   symbols = *syms;
  3292.   delete syms;
  3294.   for (PINDEX i = 0; i < symbols.GetSize(); i++) {
  3295.     symbols[i].SetImportPrefix(shortModuleName);
  3296.     Module->AppendType(&symbols[i]);
  3297.   }
  3298. }
  3301. void ImportModule::PrintOn(ostream & strm) const
  3302. {
  3303.   strm << "  " << fullModuleName << " (" << shortModuleName << "):n";
  3304.   for (PINDEX i = 0; i < symbols.GetSize(); i++)
  3305.     strm << "    " << symbols[i];
  3306.   strm << 'n';
  3307. }
  3310. void ImportModule::GenerateCplusplus(ostream & hdr, ostream & cxx)
  3311. {
  3312.   PString filename = shortModuleName.ToLower();
  3314.   hdr << "#include "" << filename << ".h"n";
  3316.   for (PINDEX i = 0; i < symbols.GetSize(); i++) {
  3317.     if (symbols[i].IsParameterisedImport()) {
  3318.       cxx << "#include "" << filename << "_t.cxx"n";
  3319.       break;
  3320.     }
  3321.   }
  3322. }
  3325. /////////////////////////////////////////////////////////
  3327. ModuleDefinition::ModuleDefinition(PString * name, PStringList * id, Tag::Mode defTagMode)
  3328.   : moduleName(*name),
  3329.     definitiveId(*id)
  3330. {
  3331.   delete name;
  3332.   delete id;
  3333.   defaultTagMode = defTagMode;
  3334.   exportAll = FALSE;
  3335.   indentLevel = 1;
  3337.   PArgList & args = PProcess::Current().GetArguments();
  3338.   if (args.HasOption('r')) {
  3339.     PStringArray renames = args.GetOptionString('r').Lines();
  3340.     for (PINDEX i = 0; i < renames.GetSize(); i++) {
  3341.       PINDEX equal = renames[i].Find('=');
  3342.       if (equal > 0 && equal != P_MAX_INDEX)
  3343.         importNames.SetAt(renames[i].Left(equal).Trim(), renames[i].Mid(equal+1).Trim());
  3344.     }
  3345.   }
  3346. }
  3349. void ModuleDefinition::SetExportAll()
  3350. {
  3351.   exportAll = TRUE;
  3352. }
  3355. void ModuleDefinition::SetExports(TypesList * syms)
  3356. {
  3357.   exports = *syms;
  3358.   delete syms;
  3359. }
  3362. void ModuleDefinition::PrintOn(ostream & strm) const
  3363. {
  3364.   strm << moduleName << "n"
  3365.           "Default Tags: " << Tag::modeNames[defaultTagMode] << "n"
  3366.           "Exports:";
  3367.   if (exportAll)
  3368.     strm << " ALL";
  3369.   else {
  3370.     strm << "n  ";
  3371.     for (PINDEX i = 0; i < exports.GetSize(); i++)
  3372.       strm << exports[i] << ' ';
  3373.     strm << 'n';
  3374.   }
  3375.   strm << "Imports:n" << imports << "n"
  3376.           "Types:n" << types << "n"
  3377.           "Values:n" << values << "n"
  3378.           "MIBs:n" << mibs << endl;
  3379. }
  3382. void ModuleDefinition::AppendType(TypeBase * type)
  3383. {
  3384.   types.Append(type);
  3385.   sortedTypes.Append(type);
  3386. }
  3389. TypeBase * ModuleDefinition::FindType(const PString & name)
  3390. {
  3391.   PINDEX pos = sortedTypes.GetValuesIndex(SearchType(name));
  3392.   if (pos != P_MAX_INDEX)
  3393.     return &sortedTypes[pos];
  3394.   return NULL;
  3395. }
  3398. PString ModuleDefinition::GetImportModuleName(const PString & moduleName)
  3399. {
  3400.   if (importNames.Contains(moduleName))
  3401.     return importNames[moduleName];
  3403.   PINDEX pos = moduleName.Find('-');
  3404.   if (pos > 32)
  3405.     pos = 32;
  3406.   return moduleName.Left(pos);
  3407. }
  3410. void ModuleDefinition::GenerateCplusplus(const PFilePath & path,
  3411.                                          const PString & modName,
  3412.                                          unsigned numFiles,
  3413.                                          BOOL useNamespaces,
  3414.                                          BOOL useInlines,
  3415.                                          BOOL verbose)
  3416. {
  3417.   PINDEX i;
  3419.   usingInlines = useInlines;
  3421.   // Adjust the module name to what is specified to a default
  3422.   if (!modName)
  3423.     moduleName = modName;
  3424.   else
  3425.     moduleName = MakeIdentifierC(moduleName);
  3427.   // Set the prefix on all external class names
  3428.   if (!useNamespaces)
  3429.     classNamePrefix = moduleName + '_';
  3432.   if (verbose)
  3433.     cout << "Sorting " << types.GetSize() << " types..." << endl;
  3436.   // Create sorted list for faster searching.
  3437.   sortedTypes.DisallowDeleteObjects();
  3438.   for (i = 0; i < types.GetSize(); i++)
  3439.     sortedTypes.Append(&types[i]);
  3441.   // Flatten types by generating types for "inline" definitions
  3442.   for (i = 0; i < types.GetSize(); i++)
  3443.     types[i].FlattenUsedTypes();
  3445.   // Reorder types
  3446.   // Determine if we need a separate file for template closure
  3447.   BOOL hasTemplates = FALSE;
  3448.   types.DisallowDeleteObjects();
  3449.   PINDEX loopDetect = 0;
  3450.   PINDEX bubble = 0;
  3451.   while (bubble < types.GetSize()) {
  3452.     BOOL makesReference = FALSE;
  3454.     TypeBase & bubbleType = types[bubble];
  3455.     if (bubbleType.CanReferenceType()) {
  3456.       for (i = bubble; i < types.GetSize(); i++) {
  3457.         if (bubbleType.ReferencesType(types[i])) {
  3458.           makesReference = TRUE;
  3459.           break;
  3460.         }
  3461.       }
  3462.     }
  3464.     if (makesReference) {
  3465.       types.Append(types.RemoveAt(bubble));
  3466.       if (loopDetect > types.GetSize()) {
  3467.         PError << StdError(Fatal)
  3468.                << "Recursive type definition: " << bubbleType.GetName() << endl;
  3469.         break;
  3470.       }
  3471.       loopDetect++;
  3472.     }
  3473.     else {
  3474.       loopDetect = bubble;
  3475.       bubble++;
  3476.     }
  3478.     if (bubbleType.HasParameters())
  3479.       hasTemplates = TRUE;
  3480.   }
  3481.   types.AllowDeleteObjects();
  3483.   // Adjust all of the C++ identifiers prepending module name
  3484.   for (i = 0; i < types.GetSize(); i++)
  3485.     types[i].AdjustIdentifier();
  3488.   // Generate the code
  3489.   if (verbose)
  3490.     cout << "Generating code (" << types.GetSize() << " classes) ..." << endl;
  3493.   // Output the special template closure file, if necessary
  3494.   PString templateFilename;
  3495.   if (hasTemplates) {
  3496.     OutputFile templateFile;
  3497.     if (!templateFile.Open(path, "_t", ".cxx"))
  3498.       return;
  3500.     for (i = 0; i < types.GetSize(); i++) {
  3501.       if (types[i].HasParameters()) {
  3502.         PStringStream dummy;
  3503.         types[i].GenerateCplusplus(dummy, templateFile);
  3504.       }
  3505.     }
  3507.     if (verbose)
  3508.       cout << "Completed " << templateFile.GetFilePath() << endl;
  3510.     templateFilename = templateFile.GetFilePath().GetFileName();
  3511.   }
  3513.   // Start the header file
  3514.   OutputFile hdrFile;
  3515.   if (!hdrFile.Open(path, "", ".h"))
  3516.     return;
  3518.   hdrFile << "#ifndef __" << moduleName.ToUpper() << "_Hn"
  3519.              "#define __" << moduleName.ToUpper() << "_Hn"
  3520.              "n"
  3521.              "#ifdef __GNUC__n"
  3522.              "#pragma interfacen"
  3523.              "#endifn"
  3524.              "n"
  3525.              "#include <ptclib/asner.h>n"
  3526.              "n";
  3528.   // Start the first (and maybe only) cxx file
  3529.   OutputFile cxxFile;
  3530.   if (!cxxFile.Open(path, numFiles > 1 ? "_1" : "", ".cxx"))
  3531.     return;
  3533.   PString headerName = hdrFile.GetFilePath().GetFileName();
  3535.   cxxFile << "#ifdef __GNUC__n"
  3536.              "#pragma implementation "" << headerName << ""n"
  3537.              "#endifn"
  3538.              "n"
  3539.              "#include <ptlib.h>n"
  3540.              "#include "" << headerName << ""n"
  3541.              "n"
  3542.              "#define new PNEWn"
  3543.              "n"
  3544.              "n";
  3546.   // Include the template closure file.
  3547.   if (hasTemplates)
  3548.     cxxFile << "#include "" << templateFilename << ""nn";
  3551.   for (i = 0; i < imports.GetSize(); i++)
  3552.     imports[i].GenerateCplusplus(hdrFile, cxxFile);
  3553.   if (!imports.IsEmpty()) {
  3554.     hdrFile << "nn";
  3555.     cxxFile << "nn";
  3556.   }
  3559.   if (useNamespaces) {
  3560.     hdrFile << "namespace " << moduleName << " {n"
  3561.                "n";
  3562.     cxxFile << "using namespace " << moduleName << ";n"
  3563.                "n";
  3564.   }
  3567.   PINDEX classesPerFile = (types.GetSize()+numFiles-1)/numFiles;
  3568.   for (i = 0; i < types.GetSize(); i++) {
  3569.     if (i > 0 && i%classesPerFile == 0) {
  3570.       cxxFile.Close();
  3571.       if (verbose)
  3572.         cout << "Completed " << cxxFile.GetFilePath() << endl;
  3574.       if (!cxxFile.Open(path, psprintf("_%u", i/classesPerFile+1), ".cxx"))
  3575.         return;
  3577.       cxxFile << "#include <ptlib.h>n"
  3578.                  "#include "" << headerName << ""n"
  3579.                  "n";
  3580.       if (useNamespaces)
  3581.         cxxFile << "using namespace " << moduleName << ";n"
  3582.                    "n";
  3583.       cxxFile << "#define new PNEWn"
  3584.                  "n"
  3585.                  "n";
  3586.     }
  3588.     if (types[i].HasParameters()) {
  3589.       PStringStream dummy;
  3590.       types[i].GenerateCplusplus(hdrFile, dummy);
  3591.     }
  3592.     else
  3593.       types[i].GenerateCplusplus(hdrFile, cxxFile);
  3594.   }
  3597.   // Close off the files
  3598.   if (useNamespaces)
  3599.     hdrFile << "};n"
  3600.                "n";
  3602.   hdrFile << "#endif // __" << moduleName.ToUpper() << "_Hn"
  3603.              "n";
  3605.   if (verbose)
  3606.     cout << "Completed " << cxxFile.GetFilePath() << endl;
  3607. }
  3610. //////////////////////////////////////////////////////////////////////////////