Begin preparation of vector handling in pugs' language

First vectors that will be considered are R^d vectors with d in {1,2,3}.
These will be managed through `TinyVector<double, d>`.

src/language/ASTBuilder.cpp

@@ -223,6 +223,7 @@ using selector = parse_tree::selector<
                                 N_set,
                                 Z_set,
                                 R_set,
+                                vector_type,
                                 string_type,
                                 cout_kw,
                                 cerr_kw,

src/language/ASTNodeDataType.cpp

@@ -20,6 +20,9 @@ dataTypeName(const ASTNodeDataType& data_type)
   case ASTNodeDataType::double_t:
     name = "R";
     break;
+  case ASTNodeDataType::vector_t:
+    name = "vector";
+    break;
   case ASTNodeDataType::string_t:
     name = "string";
     break;
@@ -47,7 +50,7 @@ dataTypePromotion(const ASTNodeDataType& data_type_1, const ASTNodeDataType& dat
   } else if ((std::max(data_type_1, data_type_2) <= ASTNodeDataType::double_t) and
              (std::min(data_type_1, data_type_2) >= ASTNodeDataType::bool_t)) {
     return std::max(data_type_1, data_type_2);
-  } else if ((data_type_1 == ASTNodeDataType::string_t) and (data_type_2 <= ASTNodeDataType::double_t) and
+  } else if ((data_type_1 == ASTNodeDataType::string_t) and (data_type_2 < ASTNodeDataType::string_t) and
              (data_type_2 >= ASTNodeDataType::bool_t)) {
     return data_type_1;
   } else {
@@ -70,8 +73,7 @@ isNaturalConversion(const ASTNodeDataType& data_type, const ASTNodeDataType& tar
     return ((data_type == ASTNodeDataType::unsigned_int_t) or (data_type == ASTNodeDataType::int_t) or
             (data_type == ASTNodeDataType::bool_t));
   } else if (target_data_type == ASTNodeDataType::string_t) {
-    return ((data_type == ASTNodeDataType::double_t) or (data_type == ASTNodeDataType::unsigned_int_t) or
-            (data_type == ASTNodeDataType::int_t) or (data_type == ASTNodeDataType::bool_t));
+    return ((data_type >= ASTNodeDataType::bool_t) and (data_type < ASTNodeDataType::string_t));
   }
   return false;
 }

src/language/ASTNodeDataType.hpp

@@ -13,6 +13,7 @@ enum class ASTNodeDataType : int32_t
   int_t          = 1,
   unsigned_int_t = 2,
   double_t       = 3,
+  vector_t       = 4,
   string_t       = 5,
   typename_t     = 10,
   function_t     = 11,

src/language/ASTNodeDataTypeBuilder.cpp

@@ -37,6 +37,8 @@ ASTNodeDataTypeBuilder::_buildDeclarationNodeDataTypes(ASTNode& type_node, ASTNo
       data_type = ASTNodeDataType::unsigned_int_t;
     } else if (type_node.is_type<language::R_set>()) {
       data_type = ASTNodeDataType::double_t;
+    } else if (type_node.is_type<language::vector_type>()) {
+      data_type = ASTNodeDataType::vector_t;
     } else if (type_node.is_type<language::string_type>()) {
       data_type = ASTNodeDataType::string_t;
     }
@@ -90,6 +92,8 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n) const
         n.m_data_type = ASTNodeDataType::double_t;
       } else if (n.is_type<language::integer>()) {
         n.m_data_type = ASTNodeDataType::int_t;
+      } else if (n.is_type<language::vector_type>()) {
+        n.m_data_type = ASTNodeDataType::vector_t;
       } else if (n.is_type<language::literal>()) {
         n.m_data_type = ASTNodeDataType::string_t;
       } else if (n.is_type<language::cout_kw>() or n.is_type<language::cerr_kw>() or n.is_type<language::clog_kw>()) {
@@ -149,6 +153,8 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n) const
             data_type = ASTNodeDataType::unsigned_int_t;
           } else if (type_node.is_type<language::R_set>()) {
             data_type = ASTNodeDataType::double_t;
+          } else if (type_node.is_type<language::vector_type>()) {
+            data_type = ASTNodeDataType::vector_t;
           } else if (type_node.is_type<language::string_type>()) {
             data_type = ASTNodeDataType::string_t;
           }
@@ -188,7 +194,8 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n) const
         ASTNode& image_domain_node     = *function_descriptor.domainMappingNode().children[1];
         ASTNode& image_expression_node = *function_descriptor.definitionNode().children[1];
 
-        const size_t nb_image_domains = (image_domain_node.children.size() > 0) ? image_domain_node.children.size() : 1;
+        const size_t nb_image_domains =
+          (image_domain_node.is_type<language::type_expression>()) ? image_domain_node.children.size() : 1;
         const size_t nb_image_expressions =
           (image_expression_node.is_type<language::expression_list>()) ? image_expression_node.children.size() : 1;
 
@@ -216,6 +223,8 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n) const
             value_type = ASTNodeDataType::unsigned_int_t;
           } else if (image_node.is_type<language::R_set>()) {
             value_type = ASTNodeDataType::double_t;
+          } else if (image_node.is_type<language::vector_type>()) {
+            value_type = ASTNodeDataType::vector_t;
           } else if (image_node.is_type<language::string_type>()) {
             value_type = ASTNodeDataType::string_t;
           }
@@ -227,13 +236,13 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n) const
           // LCOV_EXCL_STOP
         };
 
-        if (image_domain_node.children.size() == 0) {
-          check_image_type(image_domain_node);
-        } else {
+        if (image_domain_node.is_type<language::type_expression>()) {
           for (size_t i = 0; i < image_domain_node.children.size(); ++i) {
             check_image_type(*image_domain_node.children[i]);
           }
           image_domain_node.m_data_type = ASTNodeDataType::typename_t;
+        } else {
+          check_image_type(image_domain_node);
         }
 
         n.m_data_type = ASTNodeDataType::void_t;

src/language/PEGGrammar.hpp

@@ -65,11 +65,19 @@ struct R_set : TAO_PEGTL_KEYWORD("R"){};
 
 struct string_type : TAO_PEGTL_KEYWORD("string") {};
 
-struct basic_type : sor < B_set, R_set, Z_set, N_set, string_type > {};
+struct scalar_type : sor< B_set, R_set, Z_set, N_set >{};
 
-struct TYPESPECIFIER : seq< basic_type, ignored> {};
+struct vector_type : seq< R_set, ignored, one< '^' >, ignored, integer >{};
 
-struct type_expression : list_must< TYPESPECIFIER, one< '*' > >{};
+struct basic_type : sor< scalar_type, string_type >{};
+
+struct type_specifier : sor< vector_type, basic_type >{};
+
+struct TYPE_SPECIFIER : seq< type_specifier, ignored >{};
+
+struct type_expression : list_must< TYPE_SPECIFIER, seq< one< '*' > > >{};
+
+struct TYPE_EXPRESSION : seq< type_expression, ignored >{};
 
 struct and_kw : TAO_PEGTL_KEYWORD("and") {};
 struct or_kw : TAO_PEGTL_KEYWORD("or") {};
@@ -213,9 +221,9 @@ struct name_list;
 
 struct affectation : seq< sor< NAME, name_list >, if_must< affect_op,  sor< expression_list, expression > > >{};
 
-struct declaration : if_must< type_expression, sor< NAME, name_list>, opt< if_must< seq< one< '=' >, ignored >, sor< expression_list, expression > > > >{};
+struct declaration : if_must< TYPE_EXPRESSION, sor< NAME, name_list>, opt< if_must< seq< one< '=' >, ignored >, sor< expression_list, expression > > > >{};
 
-struct type_mapping : seq< type_expression, RIGHT_ARROW, type_expression >{};
+struct type_mapping : seq< TYPE_EXPRESSION, RIGHT_ARROW, TYPE_EXPRESSION >{};
 
 struct name_list : seq< open_parent, list_must< NAME, COMMA >, close_parent >{};