Fixed some bugs about array and added some new features.

Author: ax-6

.vscode/launch.json

@@ -6,7 +6,7 @@
             "type": "cppdbg",
             "request": "launch",
             "program": "${workspaceFolder}/build/aq",  // 替换为实际可执行文件路径
-            "args": ["${workspaceFolder}/build/test.aq"],
+            "args": ["${workspaceFolder}/build/test1.aq"],
             "stopAtEntry": false,
             "cwd": "${workspaceFolder}",
             "environment": [],

CMakeLists.txt

@@ -8,7 +8,7 @@ project(AQ CXX)
 set(CMAKE_CXX_COMPILER "g++")
 set(CMAKE_CXX_STANDARD 20)
 SET(CMAKE_BUILD_TYPE "Debug")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O3")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g")
 
 
 

src/ast/ast.h

@@ -420,32 +420,25 @@ class Variable : public Declaration, public Expression {
 
 class ArrayDeclaration : public Variable {
  public:
-  ArrayDeclaration(Type* type, Expression* name, Expression* size) {
+  ArrayDeclaration(Type* type, Expression* name) {
     Declaration::statement_type_ = StatementType::kArrayDeclaration;
     variable_type_ = type;
     variable_name_ = name;
-    array_size_ = size;
     variable_value_.clear();
   }
 
-  ArrayDeclaration(Type* type, Expression* name, Expression* size,
-                   std::vector<Expression*> value) {
+  ArrayDeclaration(Type* type, Expression* name,
+                   std::vector<Expression*>&& value) {
     Declaration::statement_type_ = StatementType::kArrayDeclaration;
     variable_type_ = type;
     variable_name_ = name;
-    array_size_ = size;
     variable_value_ = value;
   }
 
   virtual ~ArrayDeclaration() = default;
 
-  Expression* GetArraySizeExpression() { return array_size_; }
-
   ArrayDeclaration(const ArrayDeclaration&) = default;
   ArrayDeclaration& operator=(const ArrayDeclaration&) = default;
-
- private:
-  Expression* array_size_ = nullptr;
 };
 
 class FunctionDeclaration : public Declaration {

src/ast/type.cc

@@ -171,14 +171,8 @@ Type* Type::CreateConstDerivedType(Type* sub_type, Token* token,
   // If it is not a post const type, it is a pre const type.
   if (sub_type == nullptr) sub_type = CreateType(token, length, ++index);
 
-  // ConstType* const_type = new ConstType();
-  // if (const_type == nullptr) INTERNAL_ERROR("const_type is nullptr.");
-
   if (sub_type == nullptr) INTERNAL_ERROR("type is nullptr.");
 
-  // const_type->SetSubType(sub_type);
-  // return const_type;
-
   LOGGING_WARNING("The C-style const declaration method is now deprecated.");
 
   return sub_type;
@@ -198,6 +192,18 @@ Type* Type::CreateOperatorDerivedType(Type* sub_type, Token* token,
       break;
     }
 
+    case Token::OperatorType::l_square: {
+      if (token[index + 1].type != Token::Type::OPERATOR &&
+          token[index + 1].value.oper != Token::OperatorType::r_square)
+        LOGGING_WARNING("Unsupported array size yet.");
+
+      index++;
+
+      ArrayType* array_type = new ArrayType();
+      array_type->SetSubType(type);
+      type = array_type;
+    }
+
     default:
       return type;
   }

src/ast/type.h

@@ -5,14 +5,13 @@
 #ifndef AQ_AST_TYPE_H_
 #define AQ_AST_TYPE_H_
 
+#include <cstdint>
 #include <string>
 #include <vector>
-#include <cstdint>
 
 #include "logging/logging.h"
 #include "token/token.h"
 
-
 namespace Aq {
 namespace Ast {
 
@@ -145,27 +144,16 @@ class ConstType : public Type {
 
 class ArrayType : public Type {
  public:
-  ArrayType() {
-    type_category_ = TypeCategory::kArray;
-    size_ = nullptr;
-  }
-  void SetSubType(Type* type, Expression* size) {
-    type_data_ = type;
-    size_ = size;
-  }
+  ArrayType() { type_category_ = TypeCategory::kArray; }
+  void SetSubType(Type* type) { type_data_ = type; }
   virtual ~ArrayType() = default;
 
   Type* GetSubType() { return type_data_; }
 
-  Expression* GetArraySize() { return size_; }
-
   operator std::string() override { return std::string(*type_data_) + "*"; }
 
   ArrayType(const ArrayType&) = default;
   ArrayType& operator=(const ArrayType&) = default;
-
- private:
-  Expression* size_;
 };
 
 class ReferenceType : public Type {

src/interpreter/declaration_interpreter.cc

@@ -206,7 +206,7 @@ void HandleClassDeclaration(Interpreter& interpreter, Ast::Class* declaration) {
 
   // Check if there are any errors in the preprocessing.
   if (classes.find(class_name) == classes.end())
-    INTERNAL_ERROR("Not found class declaration.");
+    INTERNAL_ERROR("Not found class declaration: " + class_name);
   current_class = &classes[class_name];
 
   // Adds the special variable into class memory.
@@ -528,9 +528,9 @@ std::size_t HandleArrayDeclaration(Interpreter& interpreter,
   // initialized when the ARRAY operator is called.
   if (sub_type_category == Ast::Type::TypeCategory::kClass) {
     std::size_t current_index = global_memory->Add(1);
-    code.push_back(Bytecode{
-        _AQVM_OPERATOR_ARRAY,
-        {current_index, array_index, global_memory->GetUint64tData(0)}});
+    code.push_back(
+        Bytecode{_AQVM_OPERATOR_ARRAY,
+                 {current_index, array_index, global_memory->AddUint64t(0)}});
     code.push_back(
         Bytecode{_AQVM_OPERATOR_INVOKE_METHOD,
                  {current_index, global_memory->AddString("@constructor"),
@@ -542,9 +542,9 @@ std::size_t HandleArrayDeclaration(Interpreter& interpreter,
     for (std::size_t i = 0; i < declaration->GetVariableValue().size(); i++) {
       // Gets the corresponding array index reference.
       std::size_t current_index = global_memory->Add(1);
-      code.push_back(Bytecode{
-          _AQVM_OPERATOR_ARRAY,
-          {current_index, array_index, global_memory->GetUint64tData(i)}});
+      code.push_back(
+          Bytecode{_AQVM_OPERATOR_ARRAY,
+                   {current_index, array_index, global_memory->AddUint64t(i)}});
 
       // Gets the value of the initialization list and assigns value to
       // corresponding index.

src/interpreter/preprocesser.cc

@@ -90,6 +90,8 @@ void PreProcessClassDeclaration(Interpreter& interpreter,
 
   classes[full_name] = current_class;
 
+  LOGGING_INFO(full_name);
+
   for (std::size_t i = 0; i < statement->GetSubClasses().size(); i++) {
     if (Ast::IsOfType<Ast::Class>(statement->GetSubClasses()[i])) {
       PreProcessClassDeclaration(

src/parser/declaration_parser.cc

@@ -5,7 +5,6 @@
 #include "parser/declaration_parser.h"
 
 #include <cstddef>
-#include <string>
 
 #include "ast/ast.h"
 #include "ast/type.h"
@@ -158,7 +157,7 @@ Ast::Variable* Parser::DeclarationParser::ParseVariableDeclaration(
   if (name == nullptr) INTERNAL_ERROR("name is nullptr.");
 
   // Checks if the variable is an array declaration.
-  if (*name == Ast::Statement::StatementType::kArray)
+  if (type->GetTypeCategory() == Ast::Type::TypeCategory::kArray)
     return ParseArrayDeclaration(type, name, token, length, index);
 
   // Declaration with initialization value.
@@ -276,24 +275,19 @@ bool Parser::DeclarationParser::HasCustomTypeBeforeExpression(
 Ast::ArrayDeclaration* Parser::DeclarationParser::ParseArrayDeclaration(
     Ast::Type* type, Ast::Expression* name, Token* token, std::size_t length,
     std::size_t& index) {
-
-
   if (token == nullptr) INTERNAL_ERROR("token is nullptr.");
   if (index >= length) INTERNAL_ERROR("index is out of range.");
-  Ast::Array* array = Ast::Cast<Ast::Array>(name);
-  if (array == nullptr) INTERNAL_ERROR("name is not an array.");
 
   if (token[index].value.oper == Token::OperatorType::equal) {
     index++;
     if (token[index].type == Token::Type::OPERATOR &&
-        token[index].value.oper == Token::OperatorType::l_brace) {
+        token[index].value.oper == Token::OperatorType::l_square) {
       std::vector<Ast::Expression*> values;
       while (true) {
-      
-        // Skip the l_brace or comma.
+        // Skip the l_square or comma.
         values.push_back(ExpressionParser::ParseExpressionWithoutComma(
             token, length, ++index));
-        if (token[index] == Token::OperatorType::r_brace) {
+        if (token[index] == Token::OperatorType::r_square) {
           index++;
           break;
         }
@@ -303,15 +297,13 @@ Ast::ArrayDeclaration* Parser::DeclarationParser::ParseArrayDeclaration(
               "found.");
         }
       }
-      return new Ast::ArrayDeclaration(type, array->GetExpression(),
-                                       array->GetIndexExpression(), values);
+      return new Ast::ArrayDeclaration(type, name, std::move(values));
     } else {
       LOGGING_ERROR(
           "Expected '{' or ',' after '=' in array declaration, but not found.");
     }
   }
-  return new Ast::ArrayDeclaration(type, array->GetExpression(),
-                                   array->GetIndexExpression());
+  return new Ast::ArrayDeclaration(type, name);
 }
 
 }  // namespace Aq