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

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

生物技术

开发平台：

C/C++

test.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: test.cpp,v $
  4.  * PRODUCTION Revision 1000.1  2004/06/01 18:27:14  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.3
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. #include <ncbi_pch.hpp>
  11. #include <corelib/ncbiapp.hpp>
  12. #include <corelib/ncbienv.hpp>
  13. #include <serial/strbuffer.hpp>
  15. USING_NCBI_SCOPE;
  17. class CTest : public CNcbiApplication
  18. {
  19. public:
  20.     int Run(void);
  21. };
  23. int main(int argc, char** argv)
  24. {
  25.     return CTest().AppMain(argc, argv);
  26. }
  28. inline
  29. bool FirstIdChar(char c)
  30. {
  31.     return isalpha(c) || c == '_';
  32. }
  34. inline
  35. bool IdChar(char c)
  36. {
  37.     return isalnum(c) || c == '_' || c == '.';
  38. }
  40. inline
  41. void SkipEndOfLine(CStreamBuffer& b, char lastChar)
  42. {
  43.     b.SkipEndOfLine(lastChar);
  44. }
  46. void SkipComments(CStreamBuffer& b)
  47. {
  48.     ERR_POST("SkipComments @ " << b.GetLine());
  49.     try {
  50.         for ( ;; ) {
  51.             char c = b.GetChar();
  52.             switch ( c ) {
  53.             case 'r':
  54.             case 'n':
  55.                 SkipEndOfLine(b, c);
  56.                 ERR_POST("-SkipComments @ " << b.GetLine());
  57.                 return;
  58.             case '-':
  59.                 c = b.GetChar();
  60.                 switch ( c ) {
  61.                 case 'r':
  62.                 case 'n':
  63.                     SkipEndOfLine(b, c);
  64.                     ERR_POST("-SkipComments @ " << b.GetLine());
  65.                     return;
  66.                 case '-':
  67.                     ERR_POST("-SkipComments @ " << b.GetLine());
  68.                     return;
  69.                 }
  70.                 continue;
  71.             default:
  72.                 continue;
  73.             }
  74.         }
  75.     }
  76.     catch ( CSerialEofException& /* ignored */ ) {
  77.         ERR_POST("-SkipComments @ " << b.GetLine());
  78.         return;
  79.     }
  80. }
  82. #if 1
  83. #undef ERR_POST
  84. #define ERR_POST(m)
  85. #endif
  87. char SkipWhiteSpace(CStreamBuffer& b)
  88. {
  89.     ERR_POST("SkipWhiteSpaceAndGetChar @ " << b.GetLine());
  90.     for ( ;; ) {
  91. char c = b.SkipSpaces();
  92.         switch ( c ) {
  93.         case 't':
  94.             b.SkipChar();
  95.             continue;
  96.         case 'r':
  97.         case 'n':
  98.             b.SkipChar();
  99.             SkipEndOfLine(b, c);
  100.             continue;
  101.         case '-':
  102.             // check for comments
  103.             if ( b.PeekChar(1) != '-' ) {
  104.                 ERR_POST("-SkipWhiteSpaceAndGetChar @ " << b.GetLine());
  105.                 return '-';
  106.             }
  107.             b.SkipChars(2);
  108.             // skip comments
  109.             SkipComments(b);
  110.             continue;
  111.         default:
  112.             ERR_POST("-SkipWhiteSpaceAndGetChar @ " << b.GetLine());
  113.             return c;
  114.         }
  115.     }
  116. }
  118. inline
  119. char SkipWhiteSpaceAndGetChar(CStreamBuffer& b)
  120. {
  121.     char c = SkipWhiteSpace(b);
  122.     b.SkipChar();
  123.     return c;
  124. }
  126. inline
  127. void UngetNonWhiteSpace(CStreamBuffer& b, char c)
  128. {
  129.     switch ( c ) {
  130.     case ' ':
  131.     case 't':
  132.         break;
  133.     case 'r':
  134.     case 'n':
  135.         SkipEndOfLine(b, c);
  136.         break;
  137.     default:
  138.         b.UngetChar();
  139.         break;
  140.     }
  141. }
  143. size_t ReadId(CStreamBuffer& b)
  144. {
  145.     ERR_POST("ReadId @ " << b.GetLine());
  146.     char c = SkipWhiteSpace(b);
  147.     if ( c == '[' ) {
  148.         for ( size_t i = 1; ; ++i ) {
  149.             switch ( b.PeekChar(i) ) {
  150.             case 'r':
  151.             case 'n':
  152.                 b.UngetChar();
  153.                 THROW1_TRACE(runtime_error, "end of line: expected ']'");
  154.                 break;
  155.             case ']':
  156.                 b.SkipChars(i + 1);
  157.                 ERR_POST("-ReadId @ " << b.GetLine());
  158.                 return i;
  159.             }
  160.         }
  161.     }
  162. else {
  163.         if ( !FirstIdChar(c) ) {
  164.             ERR_POST("-ReadId @ " << b.GetLine());
  165.             return 0;
  166.         }
  167.         else {
  168.             for ( size_t i = 1; ; ++i ) {
  169.                 c = b.PeekChar(i);
  170.                 if ( !IdChar(c) &&
  171.                      (c != '-' || !IdChar(b.PeekChar(i + 1))) ) {
  172.                     b.SkipChars(i);
  173.                     ERR_POST("-ReadId @ " << b.GetLine());
  174.                     return i;
  175.                 }
  176.             }
  177.         }
  178. }
  179. }
  181. void ReadNumber(CStreamBuffer& b)
  182. {
  183.     char c = SkipWhiteSpaceAndGetChar(b);
  184.     switch ( c ) {
  185.     case '-':
  186.         c = b.GetChar();
  187.         break;
  188.     case '+':
  189.         c = b.GetChar();
  190.         break;
  191.     }
  192.     if ( c < '0' || c > '9' ) {
  193.         b.UngetChar();
  194.         THROW1_TRACE(runtime_error, "bad number start");
  195.     }
  196.     for (;;) {
  197.         c = b.PeekChar();
  198.         if ( c < '0' || c > '9' ) {
  199.             return;
  200.         }
  201.         b.SkipChar();
  202.     }
  203. }
  205. void ReadString(CStreamBuffer& b)
  206. {
  207.     ERR_POST("ReadStrign @ " << b.GetLine());
  208.     string s;
  209.     s.erase();
  210.     for (;;) {
  211.         char c = b.GetChar();
  212.         switch ( c ) {
  213.         case 'r':
  214.         case 'n':
  215.             SkipEndOfLine(b, c);
  216.             ERR_POST("line: " << b.GetLine());
  217.             continue;
  218.         case '"':
  219.             if ( b.PeekChar() == '"' ) {
  220.                 // double quote -> one quote
  221.                 b.SkipChar();
  222.                 s += '"';
  223.             }
  224.             else {
  225.                 // end of string
  226.                 ERR_POST("-ReadStrign @ " << b.GetLine());
  227.                 return;
  228.             }
  229.             continue;
  230.         default:
  231.             if ( c < ' ' && c >= 0 ) {
  232.                 b.UngetChar();
  233.                 THROW1_TRACE(runtime_error,
  234.                              "bad char in string: " + NStr::IntToString(c));
  235.             }
  236.             else {
  237.                 s += c;
  238.             }
  239.             continue;
  240.         }
  241.     }
  242. }
  244. int GetHexChar(CStreamBuffer& b)
  245. {
  246.     for ( ;; ) {
  247.         char c = b.GetChar();
  248.         if ( c >= '0' && c <= '9' ) {
  249.             return c - '0';
  250.         }
  251.         else if ( c >= 'A' && c <= 'Z' ) {
  252.             return c - 'A' + 10;
  253.         }
  254.         else if ( c >= 'a' && c <= 'z' ) {
  255.             return c - 'a' + 10;
  256.         }
  257.         switch ( c ) {
  258.         case ''':
  259.             return -1;
  260.         case 'r':
  261.         case 'n':
  262.             SkipEndOfLine(b, c);
  263.             ERR_POST("line: " << b.GetLine());
  264.             break;
  265.         default:
  266.             b.UngetChar();
  267.             THROW1_TRACE(runtime_error,
  268.                          string("bad char in octet string: '") + c + "'");
  269.         }
  270.     }
  271. }
  273. pair<size_t, bool> ReadBytes(CStreamBuffer& b, char* dst, size_t length)
  274. {
  275. size_t count = 0;
  276. while ( length-- > 0 ) {
  277.         int c1 = GetHexChar(b);
  278.         if ( c1 < 0 ) {
  279.             return make_pair(count, true);
  280.         }
  281.         int c2 = GetHexChar(b);
  282.         if ( c2 < 0 ) {
  283.             *dst++ = c1 << 4;
  284.             count++;
  285.             return make_pair(count, true);
  286.         }
  287.         else {
  288.             *dst++ = (c1 << 4) | c2;
  289.             count++;
  290.         }
  291. }
  292. return make_pair(count, false);
  293. }
  295. void ReadOctetString(CStreamBuffer& b)
  296. {
  297.     ERR_POST("ReadOctetString @ " << b.GetLine());
  298.     char buffer[1024];
  299.     while ( !ReadBytes(b, buffer, sizeof(buffer)).second ) {
  300.     }
  301.     if ( SkipWhiteSpaceAndGetChar(b) != 'H' ) {
  302.         b.UngetChar();
  303.         THROW1_TRACE(runtime_error, "no tailing 'H' in octet string");
  304.     }
  305.     ERR_POST("-ReadOctentStrign @ " << b.GetLine());
  306. }
  308. void ReadBlock(CStreamBuffer& b);
  309. void ReadValue(CStreamBuffer& b);
  311. void ReadValue(CStreamBuffer& b)
  312. {
  313.     ERR_POST("ReadValue @ " << b.GetLine());
  314.     char c = SkipWhiteSpace(b);
  315.     switch ( c ) {
  316.     case '{':
  317.         b.SkipChar();
  318.         ReadBlock(b);
  319.         break;
  320.     case '-':
  321.         ReadNumber(b);
  322.         break;
  323.     case '[':
  324.         ReadId(b);
  325.         break;
  326.     case ',':
  327.     case '}':
  328.         return;
  329.     case ''':
  330.         b.SkipChar();
  331.         ReadOctetString(b);
  332.         break;
  333.     case '"':
  334.         b.SkipChar();
  335.         ReadString(b);
  336.         break;
  337.     default:
  338.         if ( c >= '0' && c <= '9' ) {
  339.             ReadNumber(b);
  340.         }
  341.         else if ( c >= 'a' && c <= 'z' ) {
  342.             ReadId(b);
  343.             ReadValue(b);
  344.         }
  345.         else if ( c >= 'A' && c <= 'Z' ) {
  346.             ReadId(b);
  347.         }
  348.         break;
  349.     }
  350.     ERR_POST("-ReadValue @ " << b.GetLine());
  351. }
  353. void ReadBlock(CStreamBuffer& b)
  354. {
  355.     ERR_POST("ReadBlock @ " << b.GetLine());
  356.     if ( SkipWhiteSpace(b) == '}' ) {
  357.         b.SkipChar();
  358.         ERR_POST("-ReadBlock @ " << b.GetLine());
  359.         return;
  360.     }
  361.     for (;;) {
  362.         ReadValue(b);
  363.         switch ( SkipWhiteSpaceAndGetChar(b) ) {
  364.         case ',':
  365.             break;
  366.         case '}':
  367.             ERR_POST("-ReadBlock @ " << b.GetLine());
  368.             return;
  369.         default:
  370.             b.UngetChar();
  371.             THROW1_TRACE(runtime_error,
  372.                          string("invalid block char: ") + b.PeekChar());
  373.         }
  374.     }
  375. }
  377. int CTest::Run(void)
  378. {
  379.     CNcbiIstream* in = &NcbiCin;
  380.     enum EType {
  381.         eByteType,
  382.         eCharType,
  383.         eWhiteSpaceType,
  384.         eFullParseType
  385.     } type = eFullParseType;
  386.     for ( size_t i = 1; i < GetArguments().Size(); ++i ) {
  387.         if ( GetArguments()[i] == "-f" )
  388.             type = eFullParseType;
  389.         else if ( GetArguments()[i] == "-w" )
  390.             type = eWhiteSpaceType;
  391.         else if ( GetArguments()[i] == "-c" )
  392.             type = eCharType;
  393.         else if ( GetArguments()[i] == "-b" )
  394.             type = eByteType;
  395.         else {
  396.             CNcbiIstream* fin = new CNcbiIfstream(GetArguments()[i].c_str());
  397.             in = fin;
  398.         }
  399.     }
  400.     CStreamBuffer b(*in);
  401.     try {
  402.         switch ( type ) {
  403.         case eByteType:
  404.             {
  405.                 size_t count = 0;
  406.                 char buffer[8192];
  407.                 for (;;) {
  408.                     in->read(buffer, sizeof(buffer));
  409.                     size_t c = in->gcount();
  410.                     if ( c == 0 )
  411.                         break;
  412.                     count += c;
  413.                 }
  414.                 NcbiCout << count << " chars" << NcbiEndl;
  415.             }
  416.             break;
  417.         case eCharType:
  418.             {
  419.                 size_t count = 0;
  420.                 try {
  421.                     for (;;) {
  422.                         b.GetChar();
  423.                         ++count;
  424.                     }
  425.                 }
  426.                 catch ( CSerialEofException& /*exc*/ ) {
  427.                 }
  428.                 NcbiCout << count << " chars" << NcbiEndl;
  429.             }
  430.             break;
  431.         case eWhiteSpaceType:
  432.             try {
  433.                 for (;;) {
  434.                     SkipWhiteSpaceAndGetChar(b);
  435.                 }
  436.             }
  437.             catch ( CSerialEofException& /*exc*/ ) {
  438.             }
  439.             break;
  440.         case eFullParseType:
  441.             ReadId(b);
  442.             if ( SkipWhiteSpaceAndGetChar(b) != ':' ||
  443.                  b.GetChar() != ':' || b.GetChar() != '=' ) {
  444.                 b.UngetChar();
  445.                 THROW1_TRACE(runtime_error, ""::=" expected");
  446.             }
  447.             ReadValue(b);
  448.             break;
  449.         }
  450.     }
  451.     catch (exception& exc) {
  452.         NcbiCerr << exc.what() << NcbiEndl;
  453.     }
  454.     NcbiCout << b.GetLine() << " lines" << NcbiEndl;
  455.     return 0;
  456. }