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

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

生物技术

开发平台：

C/C++

lexer.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: lexer.cpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/01 19:43:15  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.18
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: lexer.cpp,v 1000.2 2004/06/01 19:43:15 gouriano Exp $
  11. * ===========================================================================
  12. *
  13. *                            PUBLIC DOMAIN NOTICE
  14. *               National Center for Biotechnology Information
  15. *
  16. *  This software/database is a "United States Government Work" under the
  17. *  terms of the United States Copyright Act.  It was written as part of
  18. *  the author's official duties as a United States Government employee and
  19. *  thus cannot be copyrighted.  This software/database is freely available
  20. *  to the public for use. The National Library of Medicine and the U.S.
  21. *  Government have not placed any restriction on its use or reproduction.
  22. *
  23. *  Although all reasonable efforts have been taken to ensure the accuracy
  24. *  and reliability of the software and data, the NLM and the U.S.
  25. *  Government do not and cannot warrant the performance or results that
  26. *  may be obtained by using this software or data. The NLM and the U.S.
  27. *  Government disclaim all warranties, express or implied, including
  28. *  warranties of performance, merchantability or fitness for any particular
  29. *  purpose.
  30. *
  31. *  Please cite the author in any work or product based on this material.
  32. *
  33. * ===========================================================================
  34. *
  35. * Author: Eugene Vasilchenko
  36. *
  37. * File Description:
  38. *   ASN.1 lexer
  39. *
  40. * ---------------------------------------------------------------------------
  41. * $Log: lexer.cpp,v $
  42. * Revision 1000.2  2004/06/01 19:43:15  gouriano
  43. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.18
  44. *
  45. * Revision 1.18  2004/05/17 21:03:14  gorelenk
  46. * Added include of PCH ncbi_pch.hpp
  47. *
  48. * Revision 1.17  2004/02/25 19:45:20  gouriano
  49. * Made it possible to define DEFAULT for data members of type REAL
  50. *
  51. * Revision 1.16  2003/05/22 20:10:25  gouriano
  52. * added UTF8 strings
  53. *
  54. * Revision 1.15  2003/01/31 03:38:41  lavr
  55. * Heed int->bool performance warnings
  56. *
  57. * Revision 1.14  2002/09/26 16:57:31  vasilche
  58. * Added flag for compatibility with asntool
  59. *
  60. * Revision 1.13  2001/06/11 14:35:02  grichenk
  61. * Added support for numeric tags in ASN.1 specifications and data streams.
  62. *
  63. * Revision 1.12  2001/05/17 15:07:12  lavr
  64. * Typos corrected
  65. *
  66. * Revision 1.11  2000/12/15 15:38:51  vasilche
  67. * Added support of Int8 and long double.
  68. * Added support of BigInt ASN.1 extension - mapped to Int8.
  69. * Enum values now have type Int4 instead of long.
  70. *
  71. * Revision 1.10  2000/11/15 20:34:54  vasilche
  72. * Added user comments to ENUMERATED types.
  73. * Added storing of user comments to ASN.1 module definition.
  74. *
  75. * Revision 1.9  2000/11/14 21:41:25  vasilche
  76. * Added preserving of ASN.1 definition comments.
  77. *
  78. * Revision 1.8  2000/08/25 15:59:22  vasilche
  79. * Renamed directory tool -> datatool.
  80. *
  81. * Revision 1.7  2000/04/07 19:26:27  vasilche
  82. * Added namespace support to datatool.
  83. * By default with argument -oR datatool will generate objects in namespace
  84. * NCBI_NS_NCBI::objects (aka ncbi::objects).
  85. * Datatool's classes also moved to NCBI namespace.
  86. *
  87. * Revision 1.6  2000/02/01 21:48:00  vasilche
  88. * Added CGeneratedChoiceTypeInfo for generated choice classes.
  89. * Removed CMemberInfo subclasses.
  90. * Added support for DEFAULT/OPTIONAL members.
  91. * Changed class generation.
  92. * Moved datatool headers to include/internal/serial/tool.
  93. *
  94. * Revision 1.5  1999/11/15 19:36:16  vasilche
  95. * Fixed warnings on GCC
  96. *
  97. * ===========================================================================
  98. */
  100. #include <ncbi_pch.hpp>
  101. #include <serial/datatool/lexer.hpp>
  102. #include <serial/datatool/tokens.hpp>
  104. BEGIN_NCBI_SCOPE
  106. inline bool IsAlNum(char c)
  107. {
  108.     return isalnum(c) ? true : false;
  109. }
  111. inline bool IsDigit(char c)
  112. {
  113.     return isdigit(c) ? true : false;
  114. }
  116. ASNLexer::ASNLexer(CNcbiIstream& in)
  117.     : AbstractLexer(in)
  118. {
  119. }
  121. ASNLexer::~ASNLexer(void)
  122. {
  123. }
  125. TToken ASNLexer::LookupToken(void)
  126. {
  127.     char c = Char();
  128.     switch ( c ) {
  129.     case ':':
  130.         if ( Char(1) == ':' && Char(2) == '=' ) {
  131.             StartToken();
  132.             AddChars(3);
  133.             return T_DEFINE;
  134.         }
  135.         return T_SYMBOL;
  136.     case '-':
  137.     case '+':
  138.         if ( IsDigit(Char(1)) ) {
  139.             StartToken();
  140.             AddChar();
  141.             return LookupNumber();
  142.         }
  143.         return T_SYMBOL;
  144.     case '"':
  145.         StartToken();
  146.         AddChar();
  147.         StartString();
  148.         LookupString();
  149.         return T_STRING;
  150.     case ''':
  151.         StartToken();
  152.         AddChar();
  153.         return LookupBinHexString();
  154.     case '[':
  155.         StartToken();
  156.         AddChar();
  157.         LookupTag();
  158.         return T_TAG;
  159.     default:
  160.         if ( IsDigit(c) ) {
  161.             StartToken();
  162.             AddChar();
  163.             return LookupNumber();
  164.         }
  165.         else if ( c >= 'a' && c <= 'z' ) {
  166.             StartToken();
  167.             AddChar();
  168.             LookupIdentifier();
  169.             return T_IDENTIFIER;
  170.         }
  171.         else if ( c >= 'A' && c <= 'Z' ) {
  172.             StartToken();
  173.             AddChar();
  174.             LookupIdentifier();
  175.             return LookupKeyword();
  176.         }
  177.         return T_SYMBOL;
  178.     }
  179. }
  181. void ASNLexer::LookupComments(void)
  182. {
  183.     while ( true ) {
  184.         char c = Char();
  185.         switch ( c ) {
  186.         case ' ':
  187.         case 't':
  188.         case 'r':
  189.             SkipChar();
  190.             break;
  191.         case 'n':
  192.             SkipChar();
  193.             NextLine();
  194.             break;
  195.         case '-':
  196.             if ( Char(1) == '-' ) {
  197.                 // comments
  198.                 SkipChars(2);
  199.                 SkipComment();
  200.                 break;
  201.             }
  202.             return;
  203.         default:
  204.             return;
  205.         }
  206.     }
  207. }
  209. void ASNLexer::SkipComment(void)
  210. {
  211.     CComment& comment = AddComment();
  212.     while ( true ) {
  213.         // wait for end of comments
  214.         char c = Char();
  215.         switch ( c ) {
  216.         case 'n':
  217.             SkipChar();
  218.             NextLine();
  219.             return;
  220.         case 0:
  221.             if ( Eof() )
  222.                 return;
  223.             break;
  224.         case '-':
  225.             if ( Char(1) == '-' ) {
  226.                 SkipChars(2);
  227.                 return;
  228.             }
  229.             break;
  230.         }
  231.         comment.AddChar(c);
  232.         SkipChar();
  233.     }
  234. }
  236. void ASNLexer::LookupString(void)
  237. {
  238.     while ( true ) {
  239.         char c = Char();
  240.         switch ( c ) {
  241.         case 'r':
  242.         case 'n':
  243.             LexerWarning("unclosed string");
  244.             return;
  245.         case 0:
  246.             if ( Eof() ) {
  247.                 LexerWarning("unclosed string");
  248.                 return;
  249.             }
  250.             LexerWarning("illegal character in string: \0");
  251.             AddStringChar(c);
  252.             AddChar();
  253.             break;
  254.         case '"':
  255.             if ( Char(1) != '"' ) {
  256.                 AddChar();
  257.                 return;
  258.             }
  259.             AddChars(2);
  260.             break;
  261.         default:
  262.             if ( c < ' ' && c > '' ) {
  263.                 LexerWarning("illegal character in string: \...");
  264.             }
  265.             else {
  266.                 AddStringChar(c);
  267.             }
  268.             AddChar();
  269.             break;
  270.         }
  271.     }
  272. }
  274. TToken ASNLexer::LookupBinHexString(void)
  275. {
  276.     TToken token = T_BINARY_STRING;
  277.     while ( true ) {
  278.         char c = Char();
  279.         switch ( c ) {
  280.         case 'r':
  281.         case 'n':
  282.             LexerWarning("unclosed bit string");
  283.             return token;
  284.         case 0:
  285.             if ( Eof() ) {
  286.                 LexerWarning("unclosed bit string");
  287.                 return token;
  288.             }
  289.             AddChar();
  290.             LexerWarning("illegal character in bit string");
  291.             break;
  292.         case '0':
  293.         case '1':
  294.             AddChar();
  295.             break;
  296.         case '2': case '3': case '4': case '5': case '6': case '7': case '8':
  297.         case '9': case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
  298.             AddChar();
  299.             token = T_HEXADECIMAL_STRING;
  300.             break;
  301.         case ''':
  302.             switch ( Char(1) ) {
  303.             case 'B':
  304.                 AddChars(2);
  305.                 if ( token != T_BINARY_STRING )
  306.                     LexerWarning("binary string contains hexadecimal digits");
  307.                 return T_BINARY_STRING;
  308.             case 'H':
  309.                 AddChars(2);
  310.                 return T_HEXADECIMAL_STRING;
  311.             default:
  312.                 AddChar();
  313.                 LexerWarning("unknown type of bit string");
  314.                 return token;
  315.             }
  316.         default:
  317.             AddChar();
  318.             LexerWarning("illegal character in bit string");
  319.             break;
  320.         }
  321.     }
  322. }
  324. void ASNLexer::LookupIdentifier(void)
  325. {
  326.     while ( true ) {
  327.         char c = Char();
  328.         if ( IsAlNum(c) )
  329.             AddChar();
  330.         else if ( c == '-' ) {
  331.             if ( IsAlNum(Char(1)) )
  332.                 AddChars(2);
  333.             else {
  334.                 if ( AllowIDsEndingWithMinus() )
  335.                     AddChar();
  336.                 return;
  337.             }
  338.         }
  339.         else
  340.             return;
  341.     }
  342. }
  344. TToken ASNLexer::LookupNumber(void)
  345. {
  346.     while ( IsDigit(Char()) ) {
  347.         AddChar();
  348.     }
  349.     char c = Char();
  350.     if (c == '.' || c == 'e' || c == 'E' || c == '-' || c == '+') {
  351.         AddChar();
  352.         LookupNumber();
  353.         return T_DOUBLE;
  354.     }
  355.     return T_NUMBER;
  356. }
  358. void ASNLexer::LookupTag(void)
  359. {
  360.     while ( true ) {
  361.         char c = Char();
  362.         switch ( c ) {
  363.         case 'r':
  364.         case 'n':
  365.             LexerWarning("unclosed tag");
  366.             return;
  367.         case 0:
  368.             if ( Eof() ) {
  369.                 LexerWarning("unclosed tag");
  370.                 return;
  371.             }
  372.             AddChar();
  373.             LexerWarning("illegal character in tag");
  374.             break;
  375.         case ']':
  376.             AddChar();
  377.             return;
  378.         case '0': case '1': case '2': case '3': case '4':
  379.         case '5': case '6': case '7': case '8': case '9':
  380.         // case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
  381.             AddChar();
  382.             break;
  383.         default:
  384.             AddChar();
  385.             LexerWarning("illegal character in tag");
  386.             break;
  387.         }
  388.     }
  389. }
  391. #define CHECK(keyword, t, length) 
  392.     if ( memcmp(token, keyword, length) == 0 ) return t
  394. TToken ASNLexer::LookupKeyword(void)
  395. {
  396.     const char* token = CurrentTokenStart();
  397.     switch ( CurrentTokenLength() ) {
  398.     case 2:
  399.         CHECK("OF", K_OF, 2);
  400.         break;
  401.     case 3:
  402.         CHECK("SET", K_SET, 3);
  403.         CHECK("BIT", K_BIT, 3);
  404.         CHECK("END", K_END, 3);
  405.         break;
  406.     case 4:
  407.         CHECK("TRUE", K_TRUE, 4);
  408.         CHECK("NULL", K_NULL, 4);
  409.         CHECK("REAL", K_REAL, 4);
  410.         CHECK("FROM", K_FROM, 4);
  411.         break;
  412.     case 5:
  413.         CHECK("OCTET", K_OCTET, 5);
  414.         CHECK("BEGIN", K_BEGIN, 5);
  415.         CHECK("FALSE", K_FALSE, 5);
  416.         break;
  417.     case 6:
  418.         CHECK("CHOICE", K_CHOICE, 6);
  419.         CHECK("STRING", K_STRING, 6);
  420.         CHECK("BigInt", K_BIGINT, 6);
  421.         break;
  422.     case 7:
  423.         CHECK("INTEGER", K_INTEGER, 7);
  424.         CHECK("BOOLEAN", K_BOOLEAN, 7);
  425.         CHECK("DEFAULT", K_DEFAULT, 7);
  426.         CHECK("IMPORTS", K_IMPORTS, 7);
  427.         CHECK("EXPORTS", K_EXPORTS, 7);
  428.         break;
  429.     case 8:
  430.         CHECK("SEQUENCE", K_SEQUENCE, 8);
  431.         CHECK("OPTIONAL", K_OPTIONAL, 8);
  432.         break;
  433.     case 10:
  434.         CHECK("ENUMERATED", K_ENUMERATED, 10);
  435.         CHECK("UTF8String", K_UTF8String, 10);
  436.         break;
  437.     case 11:
  438.         CHECK("StringStore", K_StringStore, 11);
  439.         CHECK("DEFINITIONS", K_DEFINITIONS, 11);
  440.         break;
  441.     case 13:
  442.         CHECK("VisibleString", K_VisibleString, 13);
  443.         break;
  444.     }
  445.     return T_TYPE_REFERENCE;
  446. }
  448. void ASNLexer::StartString(void)
  449. {
  450.     _ASSERT(TokenStarted());
  451.     m_StringValue.erase();
  452. }
  454. void ASNLexer::AddStringChar(char c)
  455. {
  456.     _ASSERT(TokenStarted());
  457.     m_StringValue += c;
  458. }
  460. END_NCBI_SCOPE