external_libraries/yaml-cpp-0.2.6/src/scantag.cpp

   1 #include "scanner.h"
   2 #include "regex.h"
   3 #include "exp.h"
   4 #include "yaml-cpp/exceptions.h"
   5
   6 namespace YAML
   7 {
   8         const std::string ScanVerbatimTag(Stream& INPUT)
   9         {
  10                 std::string tag;
  11
  12                 // eat the start character
  13                 INPUT.get();
  14
  15                 while(INPUT) {
  16                         if(INPUT.peek() == Keys::VerbatimTagEnd) {
  17                                 // eat the end character
  18                                 INPUT.get();
  19                                 return tag;
  20                         }
  21
  22                         int n = Exp::URI().Match(INPUT);
  23                         if(n <= 0)
  24                                 break;
  25
  26                         tag += INPUT.get(n);
  27                 }
  28
  29                 throw ParserException(INPUT.mark(), ErrorMsg::END_OF_VERBATIM_TAG);
  30         }
  31
  32         const std::string ScanTagHandle(Stream& INPUT, bool& canBeHandle)
  33         {
  34                 std::string tag;
  35                 canBeHandle = true;
  36                 Mark firstNonWordChar;
  37
  38                 while(INPUT) {
  39                         if(INPUT.peek() == Keys::Tag) {
  40                                 if(!canBeHandle)
  41                                         throw ParserException(firstNonWordChar, ErrorMsg::CHAR_IN_TAG_HANDLE);
  42                                 break;
  43                         }
  44
  45                         int n = 0;
  46                         if(canBeHandle) {
  47                                 n = Exp::Word().Match(INPUT);
  48                                 if(n <= 0) {
  49                                         canBeHandle = false;
  50                                         firstNonWordChar = INPUT.mark();
  51                                 }
  52                         }
  53
  54                         if(!canBeHandle)
  55                                 n = Exp::Tag().Match(INPUT);
  56
  57                         if(n <= 0)
  58                                 break;
  59
  60                         tag += INPUT.get(n);
  61                 }
  62
  63                 return tag;
  64         }
  65
  66         const std::string ScanTagSuffix(Stream& INPUT)
  67         {
  68                 std::string tag;
  69
  70                 while(INPUT) {
  71                         int n = Exp::Tag().Match(INPUT);
  72                         if(n <= 0)
  73                                 break;
  74
  75                         tag += INPUT.get(n);
  76                 }
  77
  78                 if(tag.empty())
  79                         throw ParserException(INPUT.mark(), ErrorMsg::TAG_WITH_NO_SUFFIX);
  80
  81                 return tag;
  82         }
  83 }
  84