cpptoxml improve:

1. skip "..." (sizeof ...(Args))
2. support template argument type "&&.."
3. ignore typedef decltype(...) Identifier

Author: sanikoyes

cpptoxml/parser/lexer.cpp

@@ -580,10 +580,7 @@ void Lexer::scan_semicolon()
 {
   ++cursor;
   token_stream[(int) index++].kind = ';';
-  if (parse_template) {
-    parse_template = false;
-    parse_template_class = false;
-  }
+  handle_template_scope(';');
 }
 
 void Lexer::scan_less()
@@ -611,12 +608,7 @@ void Lexer::scan_less()
     }
     else
     {
-      if (parse_template_class) {
-        token_stream[(int)index++].kind = '<';
-        token_stream[(int)index++].kind = '<';
-      } else {
-        token_stream[(int)index++].kind = Token_shift;
-      }
+      token_stream[(int)index++].kind = Token_shift;
     }
   }
   else
@@ -669,7 +661,7 @@ void Lexer::scan_greater()
     }
     else
     {
-      if (parse_template_class) {
+      if (in_template_scope()) {
         token_stream[(int)index++].kind = '>';
         token_stream[(int)index++].kind = '>';
       } else {
@@ -724,10 +716,7 @@ void Lexer::scan_left_brace()
 {
   ++cursor;
   token_stream[(int) index++].kind = '{';
-  if (parse_template) {
-    parse_template = false;
-    parse_template_class = false;
-  }
+  handle_template_scope('{');
 }
 
 void Lexer::scan_or()
@@ -758,6 +747,7 @@ void Lexer::scan_right_brace()
 {
   ++cursor;
   token_stream[(int) index++].kind = '}';
+  handle_template_scope('}');
 }
 
 void Lexer::scan_tilde()
@@ -989,6 +979,7 @@ void Lexer::scanKeyword4()
 	  *(cursor + 3) == 'm')
 	{
 	  token_stream[(int) index++].kind = Token_enum;
+    handle_template_scope(Token_enum);
 	  return;
 	}
       break;
@@ -1056,9 +1047,7 @@ void Lexer::scanKeyword5()
 	  *(cursor + 4) == 's')
 	{
 	  token_stream[(int) index++].kind = Token_class;
-    if (parse_template) {
-      parse_template_class = true;
-    }
+    handle_template_scope(Token_class);
 	  return;
 	}
       if (*(cursor + 1) == 'o' &&
@@ -1154,6 +1143,7 @@ void Lexer::scanKeyword5()
 	  *(cursor + 4) == 'g')
 	{
 	  token_stream[(int) index++].kind = Token_using;
+    handle_template_scope(Token_using);
 	  return;
 	}
       break;
@@ -1349,9 +1339,7 @@ void Lexer::scanKeyword6()
 	  *(cursor + 5) == 't')
 	{
 	  token_stream[(int) index++].kind = Token_struct;
-    if (parse_template) {
-      parse_template_class = true;
-    }
+    handle_template_scope(Token_struct);
 	  return;
 	}
       if (*(cursor + 1) == 'w' &&
@@ -1654,7 +1642,7 @@ void Lexer::scanKeyword8()
 	  *(cursor + 7) == 'e')
 	{
 	  token_stream[(int) index++].kind = Token_template;
-    parse_template = true;
+    handle_template_scope(Token_template);
 	  return;
 	}
       if (*(cursor + 1) == 'y' &&
@@ -1918,4 +1906,39 @@ void Lexer::scanKeyword16()
   token_stream[(int) index++].kind = Token_identifier;
 }
 
+bool Lexer::in_template_scope() {
+  return parse_template_class;
+}
+
+void Lexer::handle_template_scope(int kind) {
+  switch (kind)
+  {
+    case Token_template: {
+      parse_template = true;
+    } break;
+    case ';': {
+      if (parse_template) {
+        parse_template = false;
+        parse_template_class = false;
+      }
+    } break;
+    case '{': {
+    } break;
+    case '}': {
+      if (parse_template) {
+        parse_template = false;
+        parse_template_class = false;
+      }
+    } break;
+    case Token_class:
+    case Token_struct:
+    case Token_enum:
+    case Token_using: {
+      if (parse_template) {
+        parse_template_class = true;
+      }
+    } break;
+  }
+}
+
 // kate: space-indent on; indent-width 2; replace-tabs on;

cpptoxml/parser/lexer.h

@@ -265,6 +265,9 @@ class Lexer
   void scan_tilde();
   void scan_EOF();
 
+  void handle_template_scope(int kind);
+  bool in_template_scope();
+
 private:
   Control *control;
   const unsigned char *cursor;

cpptoxml/parser/parser.cpp

@@ -693,7 +693,9 @@ bool Parser::parseUsingTypeAlias(DeclarationAST *&node)
       return false;
     }
 
-  ADVANCE(';', ";");
+  if (token_stream.lookAhead() == ';') {
+    token_stream.nextToken();
+  }
 
   UsingTypeAliasAST *ast = CreateNode<UsingTypeAliasAST>(_M_pool);
   ast->name = name;
@@ -780,7 +782,22 @@ bool Parser::parseTypedef(DeclarationAST *&node)
   TypeSpecifierAST *spec = 0;
   if (!parseTypeSpecifierOrClassSpec(spec))
     {
-      reportError(("Need a type specifier to declare"));
+      // ignore typedef decltype(...) Identifier
+      if (token_stream.lookAhead() == Token_decltype) {
+        token_stream.nextToken();
+
+        if (skip('(', ')')) {
+          token_stream.nextToken();
+        }
+
+        if (token_stream.lookAhead() == Token_identifier) {
+          token_stream.nextToken();
+          return true;
+        }
+
+      } else {
+        reportError(("Need a type specifier to declare"));
+      }
       return false;
     }
 
@@ -1003,10 +1020,21 @@ bool Parser::parseSimpleTypeSpecifier(TypeSpecifierAST *&node,
         case Token_float:
         case Token_double:
         case Token_void:
+        case Token_decltype: {
           integrals = snoc(integrals, token_stream.cursor(), _M_pool);
           isIntegral = true;
-          token_stream.nextToken();
-          break;
+
+          // skip "decltype(...)"
+          if (token_stream.lookAhead() == Token_decltype) {
+            token_stream.nextToken();
+
+            if (skip('(', ')')) {
+              token_stream.nextToken();
+            }
+          } else {
+            token_stream.nextToken();
+          }
+        } break;
 
         default:
           done = true;
@@ -1195,6 +1223,10 @@ bool Parser::parseDeclarator(DeclaratorAST *&node)
     }
   else
     {
+      if (token_stream.lookAhead() == Token_ellipsis) {
+        token_stream.nextToken();
+      }
+
       if (token_stream.lookAhead() == ':')
         {
           // unnamed bitfield
@@ -1786,6 +1818,9 @@ bool Parser::parseParameterDeclaration(ParameterDeclarationAST *&node)
     token_stream.nextToken();
     variadic = true;
   }
+  else if (token_stream.lookAhead(1) == Token_ellipsis) {
+    variadic = true;
+  }
 
   int index = (int) token_stream.cursor();
 
@@ -3817,6 +3852,11 @@ bool Parser::parseUnaryExpression(ExpressionAST *&node)
         ast->sizeof_token = sizeof_token;
 
         std::size_t index = token_stream.cursor();
+        // skip "..." (sizeof ...(Args))
+        if (token_stream.lookAhead() == Token_ellipsis) {
+          token_stream.nextToken();
+        }
+
         if (token_stream.lookAhead() == '(')
           {
             token_stream.nextToken();