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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
dtdparser.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：32k
源码类别：

生物技术

开发平台：

C/C++

dtdparser.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: dtdparser.cpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/01 19:42:52  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.19
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  11. /*  $Id: dtdparser.cpp,v 1000.2 2004/06/01 19:42:52 gouriano Exp $
  12. * ===========================================================================
  13. *
  14. *                            PUBLIC DOMAIN NOTICE
  15. *               National Center for Biotechnology Information
  16. *
  17. *  This software/database is a "United States Government Work" under the
  18. *  terms of the United States Copyright Act.  It was written as part of
  19. *  the author's official duties as a United States Government employee and
  20. *  thus cannot be copyrighted.  This software/database is freely available
  21. *  to the public for use. The National Library of Medicine and the U.S.
  22. *  Government have not placed any restriction on its use or reproduction.
  23. *
  24. *  Although all reasonable efforts have been taken to ensure the accuracy
  25. *  and reliability of the software and data, the NLM and the U.S.
  26. *  Government do not and cannot warrant the performance or results that
  27. *  may be obtained by using this software or data. The NLM and the U.S.
  28. *  Government disclaim all warranties, express or implied, including
  29. *  warranties of performance, merchantability or fitness for any particular
  30. *  purpose.
  31. *
  32. *  Please cite the author in any work or product based on this material.
  33. *
  34. * ===========================================================================
  35. *
  36. * Author: Andrei Gourianov
  37. *
  38. * File Description:
  39. *   DTD parser
  40. *
  41. * ===========================================================================
  42. */
  44. #include <ncbi_pch.hpp>
  45. #include <serial/datatool/exceptions.hpp>
  46. #include <serial/datatool/dtdparser.hpp>
  47. #include <serial/datatool/tokens.hpp>
  48. #include <serial/datatool/module.hpp>
  49. #include <serial/datatool/moduleset.hpp>
  50. #include <serial/datatool/type.hpp>
  51. #include <serial/datatool/statictype.hpp>
  52. #include <serial/datatool/enumtype.hpp>
  53. #include <serial/datatool/reftype.hpp>
  54. #include <serial/datatool/unitype.hpp>
  55. #include <serial/datatool/blocktype.hpp>
  56. #include <serial/datatool/choicetype.hpp>
  57. #include <serial/datatool/value.hpp>
  58. #include <algorithm>
  59. #include <corelib/ncbifile.hpp>
  61. BEGIN_NCBI_SCOPE
  64. /////////////////////////////////////////////////////////////////////////////
  65. // DTDParser
  67. DTDParser::DTDParser(DTDLexer& lexer)
  68.     : AbstractParser(lexer)
  69. {
  70.     m_StackLexer.push(&lexer);
  71. }
  73. DTDParser::~DTDParser(void)
  74. {
  75. }
  78. AutoPtr<CFileModules> DTDParser::Modules(const string& fileName)
  79. {
  80.     AutoPtr<CFileModules> modules(new CFileModules(fileName));
  82.     while( Next() != T_EOF ) {
  83.         CDirEntry entry(fileName);
  84.         m_StackPath.push(entry.GetDir());
  85.         modules->AddModule(Module(entry.GetBase()));
  86.         m_StackPath.pop();
  87.     }
  88. //    CopyComments(modules->LastComments());
  89.     return modules;
  90. }
  92. AutoPtr<CDataTypeModule> DTDParser::Module(const string& name)
  93. {
  94.     AutoPtr<CDataTypeModule> module(new CDataTypeModule(name));
  96.     BuildDocumentTree();
  98. #if defined(NCBI_DTDPARSER_TRACE)
  99.     PrintDocumentTree();
  100. #endif
  102.     GenerateDataTree(*module);
  105. /*
  106.     string moduleName = ModuleReference();
  107.     AutoPtr<CDataTypeModule> module(new CDataTypeModule(moduleName));
  109.     Consume(K_DEFINITIONS, "DEFINITIONS");
  110.     Consume(T_DEFINE, "::=");
  111.     Consume(K_BEGIN, "BEGIN");
  113.     Next();
  115.     CopyComments(module->Comments());
  117.     ModuleBody(*module);
  118.     Consume(K_END, "END");
  120.     CopyComments(module->LastComments());
  122. */
  123.     return module;
  124. }
  127. void DTDParser::BuildDocumentTree(void)
  128. {
  129.     for (;;) {
  130.         try {
  131.             switch ( Next() ) {
  132.             case K_ELEMENT:
  133.                 Consume();
  134.                 BeginElementContent();
  135.                 break;
  136.             case K_ATTLIST:
  137.                 Consume();
  138.                 BeginAttributesContent();
  139.                 break;
  140.             case K_ENTITY:
  141.                 Consume();
  142.                 BeginEntityContent();
  143.                 break;
  144.             case T_ENTITY:
  145.                 // must be external entity
  146.                 PushEntityLexer(NextToken().GetText());
  147.                 break;
  148.             case T_EOF:
  149.                 if (PopEntityLexer()) {
  150.                     // was external entity
  151.                     Consume();
  152.                     break;
  153.                 } else {
  154.                     // end of doc
  155.                     return;
  156.                 }
  157.             default:
  158.                 ParseError("Invalid keyword", "keyword");
  159.                 return;
  160.             }
  161.         }
  162.         catch (CException& e) {
  163.             NCBI_RETHROW_SAME(e,"DTDParser::BuildDocumentTree: failed");
  164.         }
  165.         catch (exception& e) {
  166.             ERR_POST(e.what());
  167.             throw;
  168.         }
  169.     }
  170. }
  172. /////////////////////////////////////////////////////////////////////////////
  173. // DTDParser - elements
  175. void DTDParser::BeginElementContent(void)
  176. {
  177.     // element name
  178.     string name = NextToken().GetText();
  179.     Consume();
  180.     ParseElementContent(name, false);
  181. }
  183. void DTDParser::ParseElementContent(const string& name, bool embedded)
  184. {
  185.     DTDElement& node = m_MapElement[ name];
  186.     node.SetName(name);
  187.     switch (Next()) {
  188.     default:
  189.     case T_IDENTIFIER:
  190.         ParseError("incorrect format","element category");
  191. //        _ASSERT(0);
  192.         break;
  193.     case K_ANY:     // category
  194.         node.SetType(DTDElement::eAny);
  195.         Consume();
  196.         break;
  197.     case K_EMPTY:   // category
  198.         node.SetType(DTDElement::eEmpty);
  199.         Consume();
  200.         break;
  201.     case T_SYMBOL:     // contents. the symbol must be '('
  202.         ConsumeElementContent(node);
  203.         if (embedded) {
  204.             node.SetEmbedded();
  205.             return;
  206.         }
  207.         break;
  208.     case T_ENTITY:
  209.         PushEntityLexer(NextToken().GetText());
  210.         ConsumeElementContent(node);
  211.         PopEntityLexer();
  212.         Consume();
  213.         break;
  214.     }
  215.     // element description is ended
  216.     ConsumeSymbol('>');
  217. }
  219. void DTDParser::ConsumeElementContent(DTDElement& node)
  220. {
  221. // Element content:
  222. // http://www.w3.org/TR/2000/REC-xml-20001006#sec-element-content
  224.     string id_name;
  225.     char symbol;
  226.     int emb=0;
  227.     bool skip;
  229.     if(NextToken().GetSymbol() != '(') {
  230.         ParseError("Incorrect format","(");
  231.     }
  232. //    _ASSERT(NextToken().GetSymbol() == '(');
  234.     for (skip = false; ;) {
  235.         if (skip) {
  236.             skip=false;
  237.         } else {
  238.             Consume();
  239.         }
  240.         switch (Next()) {
  241.         default:
  242.             ParseError("Unrecognized token","token");
  243. //            _ASSERT(0);
  244.             break;
  245.         case T_IDENTIFIER:
  246.             id_name = NextToken().GetText();
  247.             if(id_name.empty()) {
  248.                 ParseError("Incorrect format","identifier");
  249.             }
  250. //            _ASSERT(!id_name.empty());
  251.             break;
  252.         case K_PCDATA:
  253.             node.SetType(DTDElement::eString);
  254.             break;
  255.         case T_SYMBOL:
  256.             switch (symbol = NextToken().GetSymbol()) {
  257.             case '(':
  258.                 // embedded content
  259.                 id_name = node.GetName();
  260.                 id_name += "__emb#__";
  261.                 id_name += NStr::IntToString(emb++);
  262.                 ParseElementContent(id_name, true);
  263.                 skip = true;
  264.                 break;
  265.             case ')':
  266.                 AddElementContent(node, id_name);
  267.                 EndElementContent( node);
  268.                 return;
  269.             case ',':
  270.             case '|':
  271.                 AddElementContent(node, id_name, symbol);
  272.                 break;
  273.             case '+':
  274.             case '*':
  275.             case '?':
  276.                 if(id_name.empty()) {
  277.                     ParseError("Incorrect format","identifier");
  278.                 }
  279. //                _ASSERT(!id_name.empty());
  280.                 node.SetOccurrence(id_name,
  281.                     symbol == '+' ? DTDElement::eOneOrMore :
  282.                         (symbol == '*' ? DTDElement::eZeroOrMore :
  283.                             DTDElement::eZeroOrOne));
  284.                 break;
  285.             default:
  286.                 ParseError("Unrecognized symbol","symbol");
  287. //                _ASSERT(0);
  288.                 break;
  289.             }
  290.             break;
  291.         case T_ENTITY:
  292.             id_name = NextToken().GetText();
  293.             PushEntityLexer(id_name);
  294.             skip = true;
  295.             break;
  296.         case T_EOF:
  297.             PopEntityLexer();
  298.             break;
  299.         }
  300.     }
  301. }
  303. void DTDParser::AddElementContent(DTDElement& node, string& id_name,
  304.     char separator)
  305. {
  306.     // id_name could be empty if the prev token was K_PCDATA
  307.     if (!id_name.empty()) {
  308.         node.AddContent(id_name);
  309.         if (separator != 0) {
  310.             node.SetType(separator == ',' ?
  311.                 DTDElement::eSequence : DTDElement::eChoice);
  312.         } else {
  313.             node.SetTypeIfUnknown(DTDElement::eSequence);
  314.         }
  315.         m_MapElement[ id_name].SetReferenced();
  316.         id_name.erase();
  317.     }
  318. }
  320. void DTDParser::EndElementContent(DTDElement& node)
  321. {
  322.     if (NextToken().GetSymbol() != ')') {
  323.         ParseError("Incorrect format", ")");
  324.     }
  325. //    _ASSERT(NextToken().GetSymbol() == ')');
  326.     Consume();
  327. // occurrence
  328.     char symbol;
  329.     switch (Next()) {
  330.     default:
  331.         break;
  332.     case T_SYMBOL:
  333.         switch (symbol = NextToken().GetSymbol()) {
  334.         default:
  335.             break;
  336.         case '+':
  337.         case '*':
  338.         case '?':
  339.             node.SetOccurrence(
  340.                 symbol == '+' ? DTDElement::eOneOrMore :
  341.                     (symbol == '*' ? DTDElement::eZeroOrMore :
  342.                         DTDElement::eZeroOrOne));
  343.             Consume();
  344.             break;
  345.         }
  346.         break;
  347.     }
  348.     FixEmbeddedNames(node);
  349. }
  351. void DTDParser::FixEmbeddedNames(DTDElement& node)
  352. {
  353.     const list<string>& refs = node.GetContent();
  354.     list<string> fixed;
  355.     for (list<string>::const_iterator i= refs.begin(); i != refs.end(); ++i) {
  356.         DTDElement& refNode = m_MapElement[*i];
  357.         if (refNode.IsEmbedded()) {
  358.             for ( int depth=1; depth<100; ++depth) {
  359.                 string testName = refNode.CreateEmbeddedName(depth);
  360.                 if (find(refs.begin(),refs.end(),testName) == refs.end()) {
  361.                     if (find(fixed.begin(),fixed.end(),testName) == fixed.end()) {
  362.                         fixed.push_back(testName);
  363.                         refNode.SetName(testName);
  364.                         break;
  365.                     }
  366.                 }
  367.             }
  368.         }
  369.     }
  370.  }
  372. /////////////////////////////////////////////////////////////////////////////
  373. // DTDParser - entities
  375. void DTDParser::BeginEntityContent(void)
  376. {
  377. // Entity:
  378. // http://www.w3.org/TR/2000/REC-xml-20001006#sec-entity-decl
  380.     TToken tok = Next();
  381.     if (tok != T_SYMBOL || NextToken().GetSymbol() != '%') {
  382.         ParseError("Incorrect format", "%");
  383.     }
  384. //    _ASSERT(tok == T_SYMBOL);
  385. //    _ASSERT(NextToken().GetSymbol() == '%');
  387.     Consume();
  388.     tok = Next();
  389.     if (tok != T_IDENTIFIER) {
  390.         ParseError("identifier");
  391.     }
  392. //    _ASSERT(tok == T_IDENTIFIER);
  393.     // entity name
  394.     string name = NextToken().GetText();
  395.     Consume();
  396.     ParseEntityContent(name);
  397. }
  399. void DTDParser::ParseEntityContent(const string& name)
  400. {
  401.     DTDEntity& node = m_MapEntity[name];
  402.     node.SetName(name);
  404.     TToken tok = Next();
  405.     if ((tok==K_SYSTEM) || (tok==K_PUBLIC)) {
  406.         node.SetExternal();
  407.         Consume();
  408.         if (tok==K_PUBLIC) {
  409.             // skip public id
  410.             tok = Next();
  411.             if (tok!=T_STRING) {
  412.                 ParseError("string");
  413.             }
  414. //            _ASSERT(tok==T_STRING);
  415.             Consume();
  416.         }
  417.         tok = Next();
  418.     }
  419.     if (tok!=T_STRING) {
  420.         ParseError("string");
  421.     }
  422. //    _ASSERT(tok==T_STRING);
  423.     node.SetData(NextToken().GetText());
  424.     Consume();
  425.     // entity description is ended
  426.     ConsumeSymbol('>');
  427. }
  429. void DTDParser::PushEntityLexer(const string& name)
  430. {
  431.     map<string,DTDEntity>::iterator i = m_MapEntity.find(name);
  432.     if (i == m_MapEntity.end()) {
  433.         ParseError("Undefined entity","entity");
  434.     }
  435. //    _ASSERT (i != m_MapEntity.end());
  436.     CNcbiIstream* in;
  437.     if (m_MapEntity[name].IsExternal()) {
  438.         string filename(m_MapEntity[name].GetData());
  439.         string fullname = CDirEntry::MakePath(m_StackPath.top(), filename);
  440.         CFile  file(fullname);
  441.         if (!file.Exists()) {
  442.             ParseError("file not found", fullname.c_str());
  443.         }
  444. //        _ASSERT(file.Exists());
  445.         in = new CNcbiIfstream(fullname.c_str());
  446.         if (!((CNcbiIfstream*)in)->is_open()) {
  447.             ParseError("cannot access file",fullname.c_str());
  448.         }
  449. //        _ASSERT(((CNcbiIfstream*)in)->is_open());
  450.         m_StackPath.push(file.GetDir());
  451.     } else {
  452.         in = new CNcbiIstrstream(m_MapEntity[name].GetData().c_str());
  453.         m_StackPath.push("");
  454.     }
  455.     DTDEntityLexer *lexer = new DTDEntityLexer(*in);
  456.     m_StackLexer.push(lexer);
  457.     SetLexer(lexer);
  458. }
  460. bool DTDParser::PopEntityLexer(void)
  461. {
  462.     if (m_StackLexer.size() > 1) {
  463.         delete m_StackLexer.top();
  464.         m_StackLexer.pop();
  465.         SetLexer(m_StackLexer.top());
  466.         m_StackPath.pop();
  467.         return true;
  468.     }
  469.     return false;
  470. }
  472. /////////////////////////////////////////////////////////////////////////////
  473. // DTDParser - attributes
  475. void DTDParser::BeginAttributesContent(void)
  476. {
  477. // Attributes
  478. // http://www.w3.org/TR/2000/REC-xml-20001006#attdecls
  479.     // element name
  480.     string name = NextToken().GetText();
  481.     Consume();
  482.     ParseAttributesContent(name);
  484. }
  486. void DTDParser::ParseAttributesContent(const string& name)
  487. {
  488.     string id_name;
  489.     DTDElement& node = m_MapElement[ name];
  490.     while (Next()==T_IDENTIFIER) {
  491.         // attribute name
  492.         id_name = NextToken().GetText();
  493.         Consume();
  494.         ConsumeAttributeContent(node, id_name);
  495.     }
  496.     // attlist description is ended
  497.     ConsumeSymbol('>');
  498. }
  500. void DTDParser::ConsumeAttributeContent(DTDElement& node,
  501.                                         const string& id_name)
  502. {
  503.     bool skip;
  504.     bool done=false;
  505.     DTDAttribute attrib;
  506.     attrib.SetName(id_name);
  507.     for (done=skip=false; !done;) {
  508.         switch(Next()) {
  509.         default:
  510.             ParseError("Unknown token", "token");
  511. //            _ASSERT(0);
  512.             break;
  513.         case T_ENTITY:
  514.             PushEntityLexer(NextToken().GetText());
  515.             skip = true;
  516.             break;
  517.         case T_EOF:
  518.             PopEntityLexer();
  519.             break;
  520.         case T_IDENTIFIER:
  521.             if (attrib.GetType() == DTDAttribute::eUnknown) {
  522.                 ParseError(attrib.GetName().c_str(), "attribute type");
  523.             }
  524.             done = true;
  525.             break;
  526.         case T_SYMBOL:
  527.             switch (NextToken().GetSymbol()) {
  528.             default:
  529.                 done = true;
  530.                 break;
  531.             case '(':
  532.                 // parse enumerated list
  533.                 attrib.SetType(DTDAttribute::eEnum);
  534.                 Consume();
  535.                 ParseEnumeratedList(attrib);
  536.                 break;
  537.             }
  538.             break;
  539.         case T_STRING:
  540.             attrib.SetValue(NextToken().GetText());
  541.             break;
  542.         case K_CDATA:
  543.             attrib.SetType(DTDAttribute::eString);
  544.             break;
  545.         case K_ID:
  546.             attrib.SetType(DTDAttribute::eId);
  547.             break;
  548.         case K_IDREF:
  549.             attrib.SetType(DTDAttribute::eIdRef);
  550.             break;
  551.         case K_IDREFS:
  552.             attrib.SetType(DTDAttribute::eIdRefs);
  553.             break;
  554.         case K_NMTOKEN:
  555.             attrib.SetType(DTDAttribute::eNmtoken);
  556.             break;
  557.         case K_NMTOKENS:
  558.             attrib.SetType(DTDAttribute::eNmtokens);
  559.             break;
  560.         case K_ENTITY:
  561.             attrib.SetType(DTDAttribute::eEntity);
  562.             break;
  563.         case K_ENTITIES:
  564.             attrib.SetType(DTDAttribute::eEntities);
  565.             break;
  566.         case K_NOTATION:
  567.             attrib.SetType(DTDAttribute::eNotation);
  568.             break;
  569.         case K_DEFAULT:
  570.             attrib.SetValueType(DTDAttribute::eDefault);
  571.             break;
  572.         case K_REQUIRED:
  573.             attrib.SetValueType(DTDAttribute::eRequired);
  574.             break;
  575.         case K_IMPLIED:
  576.             attrib.SetValueType(DTDAttribute::eImplied);
  577.             break;
  578.         case K_FIXED:
  579.             attrib.SetValueType(DTDAttribute::eFixed);
  580.             break;
  581.         }
  582.         if (skip) {
  583.             skip=false;
  584.         } else {
  585.             if (!done) {
  586.                 Consume();
  587.             }
  588.         }
  589.     }
  590.     node.AddAttribute(attrib);
  591. }
  593. void DTDParser::ParseEnumeratedList(DTDAttribute& attrib)
  594. {
  595.     for (;;) {
  596.         switch(Next()) {
  597.         default:
  598.             ParseError("Unknown token", "token");
  599. //            _ASSERT(0);
  600.             break;
  601.         case T_IDENTIFIER:
  602.             attrib.AddEnumValue(NextToken().GetText());
  603.             Consume();
  604.             break;
  605.         case T_SYMBOL:
  606.             // may be either '|' or ')'
  607.             if (NextToken().GetSymbol() == ')') {
  608.                 return;
  609.             }
  610.             Consume();
  611.             break;
  612.         case T_ENTITY:
  613.             PushEntityLexer(NextToken().GetText());
  614.             break;
  615.         case T_EOF:
  616.             PopEntityLexer();
  617.             Consume();
  618.             break;
  619.         }
  620.     }
  621. }
  623. /////////////////////////////////////////////////////////////////////////////
  624. // model generation
  626. void DTDParser::GenerateDataTree(CDataTypeModule& module)
  627. {
  628.     map<string,DTDElement>::iterator i;
  629.     for (i = m_MapElement.begin(); i != m_MapElement.end(); ++i) {
  631.         if (i->second.GetName().empty()) {
  632.             ParseError(i->first.c_str(),"definition");
  633.         }
  634.         DTDElement::EType type = i->second.GetType();
  636.         if (((type == DTDElement::eSequence) ||
  637.             (type == DTDElement::eChoice) ||
  638.             i->second.HasAttributes()) &&
  639.             !i->second.IsEmbedded())
  640.         {
  641.             ModuleType(module, i->second);
  642.         }
  643.     }
  644. }
  646. void DTDParser::ModuleType(CDataTypeModule& module, const DTDElement& node)
  647. {
  648.     AutoPtr<CDataType> type = Type(node, node.GetOccurrence(), false);
  649.     module.AddDefinition(node.GetName(), type);
  650. }
  653. AutoPtr<CDataType> DTDParser::Type(
  654.     const DTDElement& node, DTDElement::EOccurrence occ,
  655.     bool fromInside, bool ignoreAttrib)
  656. {
  657.     AutoPtr<CDataType> type(x_Type(node, occ, fromInside, ignoreAttrib));
  658.     return type;
  659. }
  662. CDataType* DTDParser::x_Type(
  663.     const DTDElement& node, DTDElement::EOccurrence occ,
  664.     bool fromInside, bool ignoreAttrib)
  665. {
  666.     CDataType* type;
  668. // if the node contains single embedded element - prune it
  669.     if ((!fromInside || node.IsEmbedded()) && !node.HasAttributes()) {
  670.         const list<string>& refs = node.GetContent();
  671.         if (refs.size() == 1) {
  672.             string refName = refs.front();
  673.             if (m_MapElement[refName].IsEmbedded() &&
  674.                 (node.GetOccurrence(refName) == DTDElement::eOne)) {
  675.                 type = x_Type(m_MapElement[refName],occ,fromInside);
  676.                 if (node.IsEmbedded()) {
  677.                     DTDElement& emb = const_cast<DTDElement&>(node);
  678.                     emb.SetName(m_MapElement[refName].GetName());
  679.                 }
  680.                 return type;
  681.             }
  682.         }
  683.     }
  685.     bool uniseq = (occ == DTDElement::eOneOrMore ||
  686.                    occ == DTDElement::eZeroOrMore);
  687.     bool cont = (node.GetType() == DTDElement::eSequence ||
  688.                  node.GetType() == DTDElement::eChoice);
  689.     bool attrib = !ignoreAttrib && node.HasAttributes();
  690.     bool ref = fromInside && !node.IsEmbedded();
  692.     if ((cont && uniseq && (attrib || node.IsEmbedded())) || (!cont && attrib)) {
  693.         if (ref) {
  694.             type = new CReferenceDataType(node.GetName());
  695.         } else {
  696.             type = CompositeNode(node, occ);
  697.             uniseq = false;
  698.         }
  699.     } else {
  700.         switch (node.GetType()) {
  701.         case DTDElement::eSequence:
  702.             if (ref) {
  703.                 type = new CReferenceDataType(node.GetName());
  704.             } else {
  705.                 type = TypesBlock(new CDataSequenceType(),node,ignoreAttrib);
  706.             }
  707.             break;
  708.         case DTDElement::eChoice:
  709.             if (ref) {
  710.                 type = new CReferenceDataType(node.GetName());
  711.             } else {
  712.                 type = TypesBlock(new CChoiceDataType(),node,ignoreAttrib);
  713.             }
  714.             break;
  715.         case DTDElement::eString:
  716.             type = new CStringDataType();
  717.             break;
  718.         case DTDElement::eAny:
  719.             type = new CAnyContentDataType();
  720.             break;
  721.         case DTDElement::eEmpty:
  722.             type = new CNullDataType();
  723.             break;
  724.         default:
  725.             ParseError("Unknown element", "element");
  726. //            _ASSERT(0);
  727.             break;
  728.         }
  729.     }
  730.     if (uniseq) {
  731.         CUniSequenceDataType* uniType = new CUniSequenceDataType(type);
  732.         uniType->SetNonEmpty( occ == DTDElement::eOneOrMore);
  733.         uniType->SetNoPrefix(true);
  734.         type = uniType;
  735.     }
  736.     return type;
  737. }
  739. CDataType* DTDParser::TypesBlock(
  740.     CDataMemberContainerType* containerType,const DTDElement& node,
  741.     bool ignoreAttrib)
  742. {
  743.     AutoPtr<CDataMemberContainerType> container(containerType);
  745.     if (!ignoreAttrib) {
  746.         AddAttributes(container, node);
  747.     }
  748.     const list<string>& refs = node.GetContent();
  749.     for (list<string>::const_iterator i= refs.begin(); i != refs.end(); ++i) {
  750.         DTDElement& refNode = m_MapElement[*i];
  751.         if (refNode.GetName().empty()) {
  752.             ParseError(i->c_str(),"definition");
  753.         }
  754.         DTDElement::EOccurrence occ = node.GetOccurrence(*i);
  755.         if (refNode.IsEmbedded()) {
  756.             occ = refNode.GetOccurrence();
  757.         }
  758.         AutoPtr<CDataType> type(Type(refNode, occ, true));
  759.         AutoPtr<CDataMember> member(new CDataMember(refNode.GetName(), type));
  760.         if ((occ == DTDElement::eZeroOrOne) ||
  761.             (occ == DTDElement::eZeroOrMore)) {
  762.             member->SetOptional();
  763.         }
  764.         if (refNode.IsEmbedded()) {
  765.             member->SetNotag();
  766.         }
  767.         member->SetNoPrefix();
  768.         container->AddMember(member);
  769.     }
  770.     return container.release();
  771. }
  773. CDataType* DTDParser::CompositeNode(
  774.     const DTDElement& node, DTDElement::EOccurrence occ)
  775. {
  776.     AutoPtr<CDataMemberContainerType> container(new CDataSequenceType());
  778.     AddAttributes(container, node);
  779.     bool uniseq =
  780.         (occ == DTDElement::eOneOrMore || occ == DTDElement::eZeroOrMore);
  782.     AutoPtr<CDataType> type(Type(node, DTDElement::eOne, false, true));
  783.     AutoPtr<CDataMember> member(new CDataMember(node.GetName(),
  784.         uniseq ? (AutoPtr<CDataType>(new CUniSequenceDataType(type))) : type));
  786.     member->SetNoPrefix();
  787.     member->SetNotag();
  788.     if (!uniseq) {
  789.         member->SetSimpleType();
  790.     }
  791.     container->AddMember(member);
  793.     return container.release();
  794. }
  796. void DTDParser::AddAttributes(
  797.     AutoPtr<CDataMemberContainerType>& container, const DTDElement& node)
  798. {
  799.     if (node.HasAttributes()) {
  800.         AutoPtr<CDataMember> member(
  801.             new CDataMember("Attlist", AttribBlock(node)));
  802.         member->SetNoPrefix();
  803.         member->SetAttlist();
  804.         container->AddMember(member);
  805.     }
  806. }
  808. CDataType* DTDParser::AttribBlock(const DTDElement& node)
  809. {
  810.     AutoPtr<CDataMemberContainerType> container(new CDataSequenceType());
  811.     const list<DTDAttribute>& att = node.GetAttributes();
  812.     for (list<DTDAttribute>::const_iterator i= att.begin();
  813.         i != att.end(); ++i) {
  814.         AutoPtr<CDataType> type(x_AttribType(*i));
  815.         AutoPtr<CDataMember> member(new CDataMember(i->GetName(), type));
  816.         string defValue( i->GetValue());
  817.         if (!defValue.empty()) {
  818.             member->SetDefault(new CIdDataValue(defValue));
  819.         }
  820.         if (i->GetValueType() == DTDAttribute::eImplied) {
  821.             member->SetOptional();
  822.         }
  823.         member->SetNoPrefix();
  824.         container->AddMember(member);
  825.     }
  826.     return container.release();
  827. }
  831. CDataType* DTDParser::x_AttribType(const DTDAttribute& att)
  832. {
  833.     CDataType* type=0;
  834.     switch (att.GetType()) {
  835.     case DTDAttribute::eUnknown:
  836.         ParseError("Unknown attribute", "attribute");
  837.         _ASSERT(0);
  838.         break;
  839.     case DTDAttribute::eId:
  840.     case DTDAttribute::eIdRef:
  841.     case DTDAttribute::eIdRefs:
  842.     case DTDAttribute::eNmtoken:
  843.     case DTDAttribute::eNmtokens:
  844.     case DTDAttribute::eEntity:
  845.     case DTDAttribute::eEntities:
  846.     case DTDAttribute::eNotation:
  847.     case DTDAttribute::eString:
  848.         type = new CStringDataType();
  849.         break;
  850.     case DTDAttribute::eEnum:
  851.         type = EnumeratedBlock(att, new CEnumDataType());
  852.         break;
  853.     }
  854.     return type;
  855. }
  857. CDataType* DTDParser::EnumeratedBlock(const DTDAttribute& att,
  858.     CEnumDataType* enumType)
  859. {
  860.     int v=1;
  861.     const list<string>& attEnums = att.GetEnumValues();
  862.     for (list<string>::const_iterator i = attEnums.begin();
  863.         i != attEnums.end(); ++i, ++v)
  864.     {
  865.         enumType->AddValue( *i, v);
  866.     }
  867.     return enumType;
  868. }
  870. /////////////////////////////////////////////////////////////////////////////
  871. // debug printing
  873. #if defined(NCBI_DTDPARSER_TRACE)
  874. void DTDParser::PrintDocumentTree(void)
  875. {
  876.     PrintEntities();
  878.     cout << " === Elements ===" << endl;
  879.     map<string,DTDElement>::iterator i;
  880.     for (i = m_MapElement.begin(); i != m_MapElement.end(); ++i) {
  881.         DTDElement& node = i->second;
  882.         DTDElement::EType type = node.GetType();
  883.         if (((type == DTDElement::eSequence) ||
  884.             (type == DTDElement::eChoice) ||
  885.             node.HasAttributes()) && !node.IsEmbedded()) {
  886.             PrintDocumentNode(i->first,i->second);
  887.         }
  888.     }
  889.     bool started = false;
  890.     for (i = m_MapElement.begin(); i != m_MapElement.end(); ++i) {
  891.         DTDElement& node = i->second;
  892.         if (node.IsEmbedded()) {
  893.             if (!started) {
  894.                 cout << " === Embedded elements ===" << endl;
  895.                 started = true;
  896.             }
  897.             PrintDocumentNode(i->first,i->second);
  898.         }
  899.     }
  900.     started = false;
  901.     for (i = m_MapElement.begin(); i != m_MapElement.end(); ++i) {
  902.         DTDElement& node = i->second;
  903.         DTDElement::EType type = node.GetType();
  904.         if (((type != DTDElement::eSequence) &&
  905.             (type != DTDElement::eChoice)) && !node.IsReferenced()) {
  906.             if (!started) {
  907.                 cout << " === UNREFERENCED elements ===" << endl;
  908.                 started = true;
  909.             }
  910.             PrintDocumentNode(i->first,i->second);
  911.         }
  912.     }
  913.     cout << endl;
  914. }
  916. void DTDParser::PrintEntities(void)
  917. {
  918.     if (!m_MapEntity.empty()) {
  919.         cout << " === Entities ===" << endl;
  920.         map<string,DTDEntity>::iterator i;
  921.         for (i = m_MapEntity.begin(); i != m_MapEntity.end(); ++i) {
  922.             cout << i->second.GetName() << " = "" << i->second.GetData() << """ << endl;
  923.         }
  924.         cout << endl;
  925.     }
  926. }
  928. void DTDParser::PrintDocumentNode(const string& name, const DTDElement& node)
  929. {
  930.     cout << name << ": ";
  931.     switch (node.GetType()) {
  932.     default:
  933.     case DTDElement::eUnknown:  cout << "unknown"; break;
  934.     case DTDElement::eString:   cout << "string";  break;
  935.     case DTDElement::eAny:      cout << "any";     break;
  936.     case DTDElement::eEmpty:    cout << "empty";   break;
  937.     case DTDElement::eSequence: cout << "sequence";break;
  938.     case DTDElement::eChoice:   cout << "choice";  break;
  939.     }
  940.     switch (node.GetOccurrence()) {
  941.     default:
  942.     case DTDElement::eOne:         cout << "(1)";    break;
  943.     case DTDElement::eOneOrMore:   cout << "(1..*)"; break;
  944.     case DTDElement::eZeroOrMore:  cout << "(0..*)"; break;
  945.     case DTDElement::eZeroOrOne:   cout << "(0..1)"; break;
  946.     }
  947.     cout << endl;
  948.     if (node.HasAttributes()) {
  949.         PrintNodeAttributes(node);
  950.     }
  951.     const list<string>& refs = node.GetContent();
  952.     if (!refs.empty()) {
  953.         cout << "        === Contents ===" << endl;
  954.         for (list<string>::const_iterator ir= refs.begin();
  955.             ir != refs.end(); ++ir) {
  956.             cout << "        " << *ir;
  957.             switch (node.GetOccurrence(*ir)) {
  958.             default:
  959.             case DTDElement::eOne:         cout << "(1)"; break;
  960.             case DTDElement::eOneOrMore:   cout << "(1..*)"; break;
  961.             case DTDElement::eZeroOrMore:  cout << "(0..*)"; break;
  962.             case DTDElement::eZeroOrOne:   cout << "(0..1)"; break;
  963.             }
  964.             cout << endl;
  965.         }
  966.     }
  967.     cout << endl;
  968. }
  970. void DTDParser::PrintNodeAttributes(const DTDElement& node)
  971. {
  972.     const list<DTDAttribute>& att = node.GetAttributes();
  973.     cout << "        === Attributes ===" << endl;
  974.     for (list<DTDAttribute>::const_iterator i= att.begin();
  975.         i != att.end(); ++i) {
  976.         cout << "        ";
  977.         cout << i->GetName();
  978.         cout << ": ";
  979.         switch (i->GetType()) {
  980.         case DTDAttribute::eUnknown:  cout << "eUnknown"; break;
  981.         case DTDAttribute::eString:   cout << "eString"; break;
  982.         case DTDAttribute::eEnum:     cout << "eEnum"; break;
  983.         case DTDAttribute::eId:       cout << "eId"; break;
  984.         case DTDAttribute::eIdRef:    cout << "eIdRef"; break;
  985.         case DTDAttribute::eIdRefs:   cout << "eIdRefs"; break;
  986.         case DTDAttribute::eNmtoken:  cout << "eNmtoken"; break;
  987.         case DTDAttribute::eNmtokens: cout << "eNmtokens"; break;
  988.         case DTDAttribute::eEntity:   cout << "eEntity"; break;
  989.         case DTDAttribute::eEntities: cout << "eEntities"; break;
  990.         case DTDAttribute::eNotation: cout << "eNotation"; break;
  991.         }
  992.         {
  993.             const list<string>& enumV = i->GetEnumValues();
  994.             if (!enumV.empty()) {
  995.                 cout << " (";
  996.                 for (list<string>::const_iterator ie= enumV.begin();
  997.                     ie != enumV.end(); ++ie) {
  998.                     if (ie != enumV.begin()) {
  999.                         cout << ",";
  1000.                     }
  1001.                     cout << *ie;
  1002.                 }
  1003.                 cout << ")";
  1004.             }
  1005.         }
  1006.         cout << ", ";
  1007.         switch (i->GetValueType()) {
  1008.         case DTDAttribute::eDefault:  cout << "eDefault"; break;
  1009.         case DTDAttribute::eRequired: cout << "eRequired"; break;
  1010.         case DTDAttribute::eImplied:  cout << "eImplied"; break;
  1011.         case DTDAttribute::eFixed:    cout << "eFixed"; break;
  1012.         }
  1013.         cout << ", ";
  1014.         cout << """ << i->GetValue() << """;
  1015.         cout << endl;
  1016.     }
  1017. }
  1019. #endif
  1021. END_NCBI_SCOPE
  1024. /*
  1025.  * ==========================================================================
  1026.  * $Log: dtdparser.cpp,v $
  1027.  * Revision 1000.2  2004/06/01 19:42:52  gouriano
  1028.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.19
  1029.  *
  1030.  * Revision 1.19  2004/05/19 17:24:18  gouriano
  1031.  * Corrected generation of C++ code by DTD for containers
  1032.  *
  1033.  * Revision 1.18  2004/05/17 21:03:14  gorelenk
  1034.  * Added include of PCH ncbi_pch.hpp
  1035.  *
  1036.  * Revision 1.17  2004/04/27 18:38:53  gouriano
  1037.  * In FixEmbeddedNames() not to use the same "fixed" name twice
  1038.  *
  1039.  * Revision 1.16  2004/04/01 14:14:02  lavr
  1040.  * Spell "occurred", "occurrence", and "occurring"
  1041.  *
  1042.  * Revision 1.15  2004/01/12 16:51:01  gouriano
  1043.  * Improved diagnostics when parsing a DTD
  1044.  *
  1045.  * Revision 1.14  2003/08/13 15:45:54  gouriano
  1046.  * implemented generation of code, which uses AnyContent objects
  1047.  *
  1048.  * Revision 1.13  2003/06/24 20:55:42  gouriano
  1049.  * corrected code generation and serialization of non-empty unnamed containers (XML)
  1050.  *
  1051.  * Revision 1.12  2003/06/16 14:41:05  gouriano
  1052.  * added possibility to convert DTD to XML schema
  1053.  *
  1054.  * Revision 1.11  2003/03/10 18:55:18  gouriano
  1055.  * use new structured exceptions (based on CException)
  1056.  *
  1057.  * Revision 1.10  2003/02/10 17:56:15  gouriano
  1058.  * make it possible to disable scope prefixes when reading and writing objects generated from ASN specification in XML format, or when converting an ASN spec into DTD.
  1059.  *
  1060.  * Revision 1.9  2003/01/21 19:34:17  gouriano
  1061.  * corrected parsing of entities
  1062.  *
  1063.  * Revision 1.8  2003/01/14 19:02:09  gouriano
  1064.  * added parsing of entities as attribute contents
  1065.  *
  1066.  * Revision 1.7  2002/12/17 16:24:43  gouriano
  1067.  * replaced _ASSERTs by throwing an exception
  1068.  *
  1069.  * Revision 1.6  2002/11/26 22:00:29  gouriano
  1070.  * added unnamed lists of sequences (or choices) as container elements
  1071.  *
  1072.  * Revision 1.5  2002/11/19 19:48:28  gouriano
  1073.  * added support of XML attributes of choice variants
  1074.  *
  1075.  * Revision 1.4  2002/11/14 21:05:27  gouriano
  1076.  * added support of XML attribute lists
  1077.  *
  1078.  * Revision 1.3  2002/10/21 16:11:13  gouriano
  1079.  * added parsing of external entities
  1080.  *
  1081.  * Revision 1.2  2002/10/18 14:38:56  gouriano
  1082.  * added parsing of internal parsed entities
  1083.  *
  1084.  * Revision 1.1  2002/10/15 13:54:01  gouriano
  1085.  * DTD lexer and parser, first version
  1086.  *
  1087.  *
  1088.  * ==========================================================================
  1089.  */