Use vectors internally for script arrays, replace array logic WIP

Engine/source/console/console.cpp

@@ -69,6 +69,28 @@ char* ConsoleValue::convertToBuffer() const
    return buffer;
 }
 
+char* ConsoleValue::convertVectorToBuffer() const
+{
+   if (!vec || vec->size() == 0)
+      return (char*)"";
+
+   // use FrameAllocator to avoid static overwrite
+   char* buffer = static_cast<char*>(sConversionAllocator.alloc(4096));
+   buffer[0] = 0;
+
+   for (U32 v = 0; v < vec->size(); v++)
+   {
+      const char* elemStr = (*vec)[v].getString();
+
+      if (v > 0)
+         dStrcat(buffer, " ", 4096);
+
+      dStrcat(buffer, elemStr, 4096);
+   }
+
+   return buffer;
+}
+
 const char* ConsoleValue::getConsoleData() const
 {
    return Con::getData(type, dataPtr, 0, enumTable);

Engine/source/console/console.h

@@ -32,8 +32,10 @@
 #ifndef _REFBASE_H_
 #include "core/util/refBase.h"
 #endif
+#ifndef __RESOURCE_H__
+#include "core/resource.h"
+#endif
 #include <stdarg.h>
-
 #include "core/util/str.h"
 #include "core/util/journal/journaledSignal.h"
 #include "core/stringTable.h"
@@ -120,12 +122,13 @@ typedef const char *StringTableEntry;
 
 enum ConsoleValueType
 {
-   cvNULL = -5,
+   cvNULL = -6,
+   cvVector = -5,
    cvInteger = -4,
    cvFloat = -3,
    cvString = -2,
    cvSTEntry = -1,
-   cvConsoleValueType = 0
+   cvConsoleValueType = 0,
 };
 
 class ConsoleValue
@@ -151,22 +154,29 @@ class ConsoleValue
 
    S32 type;
    U32 bufferLen;
-
+   std::shared_ptr<Vector<ConsoleValue>> vec;
    static DataChunker sConversionAllocator;
 
    char* convertToBuffer() const;
+   char* convertVectorToBuffer() const;
 
    const char* getConsoleData() const;
 
    TORQUE_FORCEINLINE void cleanupData()
    {
-      if (type <= cvString && bufferLen > 0)
+      if (type <= ConsoleValueType::cvString && bufferLen > 0)
       {
          dFree(s);
          bufferLen = 0;
       }
 
       s = const_cast<char*>(StringTable->EmptyString());
+
+      if (type == ConsoleValueType::cvVector)
+      {
+         vec.reset();
+      }
+
       type = ConsoleValueType::cvNULL;
    }
    ConsoleValue()
@@ -199,6 +209,9 @@ class ConsoleValue
       case cvString:
          setString(ref.s);
          break;
+      case cvVector:
+         setVector(ref.vec);  // copy-by-reference, no ownership
+         break;
       default:
          setConsoleData(ref.type, ref.dataPtr, ref.enumTable);
          break;
@@ -212,6 +225,9 @@ class ConsoleValue
       case cvNULL:
          std::cout << "Ref already cleared!";
          break;
+      case cvVector:
+         setVector(ref.vec);
+         break;
       case cvInteger:
          setInt(ref.i);
          break;
@@ -251,6 +267,8 @@ class ConsoleValue
          return s == StringTable->EmptyString() ? 0.0f : dAtof(s);
       if (type == ConsoleValueType::cvString)
          return dStrcmp(s, "") == 0 ? 0.0f : dAtof(s);
+      if (type == ConsoleValueType::cvVector)
+         return vec->size();
       return dAtof(getConsoleData());
    }
 
@@ -264,16 +282,79 @@ class ConsoleValue
          return s == StringTable->EmptyString() ? 0 : dAtoi(s);
       if (type == ConsoleValueType::cvString)
          return dStrcmp(s, "") == 0 ? 0 : dAtoi(s);
-
+      if (type == ConsoleValueType::cvVector)
+         return vec->size();
       return dAtoi(getConsoleData());
    }
 
+   TORQUE_FORCEINLINE void setVector(std::shared_ptr<Vector<ConsoleValue>> v)
+   {
+      cleanupData();
+      type = ConsoleValueType::cvVector;
+      vec = v;
+   }
+
+   TORQUE_FORCEINLINE std::shared_ptr<Vector<ConsoleValue>> getVector() const
+   {
+      if (type == cvVector)
+         return vec;
+
+      // Handle string or string table entry as a space-delimited vector
+      if (isNumberType() || isStringType())
+      {
+         if (type == cvString || type == cvSTEntry)
+         {
+            if (s == StringTable->EmptyString())
+               return NULL;
+         }
+
+         std::shared_ptr<Vector<ConsoleValue>> temp = std::make_shared<Vector<ConsoleValue>>();
+         if (isNumberType())
+         {
+            ConsoleValue elem;
+            if (type == cvFloat)
+               elem.setFloat(f);
+            else if (type == cvInteger)
+               elem.setInt(i);
+
+            temp->push_back(elem);
+            return temp;
+         }
+
+         if (type == cvString || type == cvSTEntry)
+         {
+            if (s == StringTable->EmptyString())
+               return NULL;
+
+            const char* str = s ? s : "";
+
+            char* buffer = dStrdup(str);
+            char* tok = dStrtok(buffer, " \t\r\n");
+
+            while (tok)
+            {
+               ConsoleValue elem;
+               elem.setString(tok);
+               temp->push_back(elem);
+               tok = dStrtok(NULL, " \t\r\n");
+            }
+
+            dFree(buffer);
+            return temp;
+         }
+      }
+
+      return NULL;
+   }
+
    TORQUE_FORCEINLINE const char* getString() const
    {
       if (isStringType())
          return s;
       if (isNumberType())
          return convertToBuffer();
+      if ((type == cvVector))
+         return convertVectorToBuffer();
       return getConsoleData();
    }
 
@@ -292,6 +373,8 @@ class ConsoleValue
          return s == StringTable->EmptyString() ? false : dAtob(s);
       if (type == ConsoleValueType::cvString)
          return dStrcmp(s, "") == 0 ? false : dAtob(s);
+      if (type == ConsoleValueType::cvVector)
+         return vec->size() > 0;
       return dAtob(getConsoleData());
    }
 

Engine/source/console/consoleInternal.h

@@ -338,6 +338,11 @@ class Dictionary
          return value.getString();
       }
 
+      inline std::shared_ptr<Vector<ConsoleValue>> getVectorValue()
+      {
+         return value.getVector();
+      }
+
       void setIntValue(U32 val)
       {
          if (mIsConstant)
@@ -406,6 +411,28 @@ class Dictionary
          if (notify)
             notify->trigger();
       }
+
+      void setVectorValue(std::shared_ptr<Vector<ConsoleValue>> val)
+      {
+         if (mIsConstant)
+         {
+            Con::errorf("Cannot assign value to constant '%s'.", name);
+            return;
+         }
+
+         if (value.isConsoleType())
+         {
+            Con::setData(value.type, value.dataPtr, 0, 1, NULL, value.enumTable); // null for now
+         }
+         else
+         {
+            value.setVector(val);
+         }
+
+         // Fire off the notification if we have one.
+         if (notify)
+            notify->trigger();
+      }
    };
 
    struct HashTableData

Engine/source/console/torquescript/CMDgram.y

@@ -461,6 +461,19 @@ expr
       { $$ = (ExprNode*)VarNode::alloc( $1.lineNumber, $1.value, NULL); }
    | VAR '[' aidx_expr ']'
       { $$ = (ExprNode*)VarNode::alloc( $1.lineNumber, $1.value, $3 ); }
+   | expr '[' expr ']' 
+      { $$ = VectorIndexNode::alloc($1->dbgLineNumber, $1, $3); }
+   | '[' expr_list_decl ']'
+      {
+         Vector<ExprNode*> elems;
+         if ($2) {
+            // expr_list already chains ExprNodes using append(),
+            // so walk and collect them
+            for (ExprNode* e = $2; e; e = (ExprNode*)e->getNext())
+               elems.push_back(e);
+         }
+         $$ = VectorExprNode::alloc(@1.first_line, elems);
+      }
    ;
 /*
    | rwDEFINE '(' var_list_decl ')' '{' statement_list '}'

Engine/source/console/torquescript/ast.h

@@ -40,7 +40,8 @@ enum TypeReq
    TypeReqNone,
    TypeReqUInt,
    TypeReqFloat,
-   TypeReqString
+   TypeReqString,
+   TypeReqVector
 };
 
 enum ExprNodeName
@@ -134,6 +135,32 @@ struct ExprNode : StmtNode
    virtual ExprNodeName getExprNodeNameEnum() const { return NameExprNode; }
 };
 
+struct VectorExprNode : ExprNode
+{
+   Vector<ExprNode*> elements;  ///< Elements of the vector literal
+
+   static VectorExprNode* alloc(S32 lineNumber, const Vector<ExprNode*>& elements);
+
+   U32 compile(CodeStream& codeStream, U32 ip, TypeReq type) override;
+   TypeReq getPreferredType() override { return TypeReqVector; }
+   DBG_STMT_TYPE(VectorExprNode);
+};
+
+struct VectorIndexNode : ExprNode
+{
+   ExprNode* base;
+   ExprNode* index;
+
+   static VectorIndexNode* alloc(S32 lineNumber, ExprNode* b, ExprNode* i);
+
+   U32 compile(CodeStream& codeStream, U32 ip, TypeReq type) override;
+   TypeReq getPreferredType() override { return TypeReqNone; }
+   DBG_STMT_TYPE(VectorIndexNode);
+
+   ExprNode* getBase() const { return base; }
+   ExprNode* getIndex() const { return index; }
+};
+
 struct ReturnStmtNode : StmtNode
 {
    ExprNode* expr;

Engine/source/console/torquescript/astAlloc.cpp

@@ -37,6 +37,27 @@ using namespace Compiler;
 
 //------------------------------------------------------------
 
+VectorExprNode* VectorExprNode::alloc(S32 lineNumber, const Vector<ExprNode*>& elements)
+{
+   VectorExprNode* ret = (VectorExprNode*)consoleAlloc(sizeof(VectorExprNode));
+   constructInPlace(ret);
+   ret->dbgLineNumber = lineNumber;
+   ret->optimizedNode = NULL;
+   ret->elements = elements;
+   return ret;
+}
+
+VectorIndexNode* VectorIndexNode::alloc(S32 lineNumber, ExprNode* b, ExprNode* i)
+{
+   VectorIndexNode* ret = (VectorIndexNode*)consoleAlloc(sizeof(VectorIndexNode));
+   constructInPlace(ret);
+   ret->dbgLineNumber = lineNumber;
+   ret->optimizedNode = NULL;
+   ret->base = b;
+   ret->index = i;
+   return ret;
+}
+
 BreakStmtNode* BreakStmtNode::alloc(S32 lineNumber)
 {
    BreakStmtNode* ret = (BreakStmtNode*)consoleAlloc(sizeof(BreakStmtNode));