Merge branch 'feature/dictionary'

Author: c-lipka

changes.txt

@@ -49,6 +49,16 @@ Prior to the release of 3.7.1, the following items still need urgent attention:
 New Features
 ------------
 
+- Array elements no longer have to be of the same type.
+
+- Support for variable-size arrays has been added.
+
+- A new data container, `dictionary`, has been added to support structured
+  storage of data.
+
+- Pseudo-dictionaries `local` and `global` have been added, allowing to
+  specifically access local or global identifiers, respectively.
+
 - A new special pigment pattern, `user_defined`, has been added to define the
   pigment colour directly in terms of a set of functions.
 
@@ -89,9 +99,6 @@ New Features
   assignments. The main purpose is to allow macros to return a set of values
   rather than just a single one.
 
-- `local()` and `global()` pseudo-functions have been added to specifically
-  refer to a local or global identifier, respectively.
-
 - The macro syntax has been extended to allow for optional parameters.
 
 - Light sources' distance-based fading can now be set to obey an inverse-power

source/parser/parser.cpp

@@ -198,12 +198,12 @@ void Parser::Run()
                 if(i->second[0] == '\"')
                 {
                     string tmp(i->second, 1, i->second.length() - 2);
-                    Temp_Entry = Add_Symbol(1, const_cast<char *>(i->first.c_str()), STRING_ID_TOKEN);
+                    Temp_Entry = Add_Symbol(SYM_TABLE_GLOBAL, const_cast<char *>(i->first.c_str()), STRING_ID_TOKEN);
                     Temp_Entry->Data = String_Literal_To_UCS2(const_cast<char *>(tmp.c_str()), false);
                 }
                 else
                 {
-                    Temp_Entry = Add_Symbol(1, const_cast<char *>(i->first.c_str()), FLOAT_ID_TOKEN);
+                    Temp_Entry = Add_Symbol(SYM_TABLE_GLOBAL, const_cast<char *>(i->first.c_str()), FLOAT_ID_TOKEN);
                     Temp_Entry->Data = Create_Float();
                     *(reinterpret_cast<DBL *>(Temp_Entry->Data)) = atof(i->second.c_str());
                 }
@@ -8556,7 +8556,7 @@ void Parser::Parse_Declare(bool is_local, bool after_hash)
     }
     else
     {
-        Local_Index=1;
+        Local_Index = SYM_TABLE_GLOBAL;
     }
 
     LValue_Ok = true;
@@ -8608,9 +8608,16 @@ void Parser::Parse_Declare(bool is_local, bool after_hash)
 
         EXPECT_ONE
             CASE (IDENTIFIER_TOKEN)
-                POV_PARSER_ASSERT(!Token.is_array_elem);
+                POV_PARSER_ASSERT(!Token.is_array_elem || Token.is_mixed_array_elem);
                 allow_redefine = true; // should actually be irrelevant downstream, thanks to Previous==IDENTIFIER_TOKEN
-                Temp_Entry = Add_Symbol (Local_Index,Token.Token_String,IDENTIFIER_TOKEN);
+                if (Token.is_array_elem || Token.is_dictionary_elem)
+                {
+                    if (is_local && (Token.context != Table_Index))
+                        Error ("Cannot use '#local' to assign a non-local array or dictionary element.");
+                    Temp_Entry = Add_Symbol (Token.table, Token.Token_String, IDENTIFIER_TOKEN);
+                }
+                else
+                    Temp_Entry = Add_Symbol (Local_Index, Token.Token_String, IDENTIFIER_TOKEN);
                 numberPtr = &(Temp_Entry->Token_Number);
                 dataPtr = &(Temp_Entry->Data);
                 Previous = Token.Token_Id;
@@ -8648,11 +8655,11 @@ void Parser::Parse_Declare(bool is_local, bool after_hash)
             CASE4 (PIGMENT_MAP_ID_TOKEN, MEDIA_ID_TOKEN, STRING_ID_TOKEN, INTERIOR_ID_TOKEN)
             CASE4 (DENSITY_MAP_ID_TOKEN, ARRAY_ID_TOKEN, DENSITY_ID_TOKEN, UV_ID_TOKEN)
             CASE4 (VECTOR_4D_ID_TOKEN, RAINBOW_ID_TOKEN, FOG_ID_TOKEN, SKYSPHERE_ID_TOKEN)
-            CASE2 (MATERIAL_ID_TOKEN, SPLINE_ID_TOKEN )
-                if (is_local && (Token.Table_Index != Table_Index))
+            CASE3 (MATERIAL_ID_TOKEN, SPLINE_ID_TOKEN, DICTIONARY_ID_TOKEN)
+                if (is_local && (Token.context != Table_Index))
                 {
-                    if (Token.is_array_elem)
-                        Error("Cannot use '#local' to assign a non-local array element.");
+                    if (Token.is_array_elem || Token.is_dictionary_elem)
+                        Error ("Cannot use '#local' to assign a non-local array or dictionary element.");
                     allow_redefine = true; // should actually be irrelevant downstream, thanks to Previous==IDENTIFIER_TOKEN
                     Temp_Entry = Add_Symbol (Local_Index,Token.Token_String,IDENTIFIER_TOKEN);
                     numberPtr = &(Temp_Entry->Token_Number);
@@ -8661,7 +8668,7 @@ void Parser::Parse_Declare(bool is_local, bool after_hash)
                 }
                 else
                 {
-                    allow_redefine = !Token.is_array_elem;
+                    allow_redefine = !Token.is_array_elem || Token.is_mixed_array_elem;
                     numberPtr = Token.NumberPtr;
                     dataPtr   = Token.DataPtr;
                     Previous  = Token.Token_Id;
@@ -8681,10 +8688,10 @@ void Parser::Parse_Declare(bool is_local, bool after_hash)
                 {
                     case VECTOR_ID_TOKEN:
                     case FLOAT_ID_TOKEN:
-                        if (is_local && (Token.Table_Index != Table_Index))
+                        if (is_local && (Token.context != Table_Index))
                         {
-                            if (Token.is_array_elem)
-                                Error("Cannot use '#local' to assign a non-local array element.");
+                            if (Token.is_array_elem || Token.is_dictionary_elem)
+                                Error("Cannot use '#local' to assign a non-local array or dictionary element.");
                             allow_redefine = true; // should actually be irrelevant downstream, thanks to Previous==IDENTIFIER_TOKEN
                             Temp_Entry = Add_Symbol (Local_Index,Token.Token_String,IDENTIFIER_TOKEN);
                             numberPtr = &(Temp_Entry->Token_Number);
@@ -8693,7 +8700,7 @@ void Parser::Parse_Declare(bool is_local, bool after_hash)
                         }
                         else
                         {
-                            allow_redefine  = !Token.is_array_elem;
+                            allow_redefine  = !Token.is_array_elem || Token.is_mixed_array_elem;
                             numberPtr = Token.NumberPtr;
                             dataPtr   = Token.DataPtr;
                             Previous  = Token.Function_Id;
@@ -8714,7 +8721,7 @@ void Parser::Parse_Declare(bool is_local, bool after_hash)
                     // the resulting value.
                     // We do this by assigning the resulting value to a dummy symbol entry.
                     allow_redefine = true; // should actually be irrelevant downstream, thanks to Previous=IDENTIFIER_TOKEN
-                    Temp_Entry = Create_Entry (0, "", DUMMY_SYMBOL_TOKEN);
+                    Temp_Entry = Create_Entry ("", DUMMY_SYMBOL_TOKEN, false);
                     numberPtr = &(Temp_Entry->Token_Number);
                     dataPtr = &(Temp_Entry->Data);
                     optional = true;
@@ -8801,14 +8808,14 @@ void Parser::Parse_Declare(bool is_local, bool after_hash)
     }
     else if (larrayDeclare)
     {
-        SYM_ENTRY *rvalue = Create_Entry (0, "", DUMMY_SYMBOL_TOKEN);
+        SYM_ENTRY *rvalue = Create_Entry ("", DUMMY_SYMBOL_TOKEN, false);
         if (!Parse_RValue (IDENTIFIER_TOKEN, &(rvalue->Token_Number), &(rvalue->Data), NULL, false, false, true, true, false, MAX_NUMBER_OF_TABLES) ||
             (rvalue->Token_Number != ARRAY_ID_TOKEN))
             Expectation_Error("array RValue");
         POV_ARRAY *a = reinterpret_cast<POV_ARRAY *>(rvalue->Data);
-        if (lvalues.size() > a->Total)
+        if (lvalues.size() > a->DataPtrs.size())
             Error ("array size mismatch");
-        if (a->DataPtrs == NULL)
+        if (a->DataPtrs.empty())
             Error ("cannot assign from uninitialized array");
 
         for (int i = 0; i < lvalues.size(); ++i)
@@ -8827,7 +8834,7 @@ void Parser::Parse_Declare(bool is_local, bool after_hash)
             *dataPtr = Copy_Identifier(a->DataPtrs[i], a->Type);
         }
 
-        Destroy_Entry (0, rvalue);
+        Destroy_Entry (rvalue, false);
     }
     else
     {
@@ -8892,7 +8899,7 @@ void Parser::Parse_Declare(bool is_local, bool after_hash)
     for (vector<LValue>::iterator i = lvalues.begin(); i != lvalues.end(); ++i)
     {
         if ((i->symEntry != NULL) && (i->symEntry->Token_Number == DUMMY_SYMBOL_TOKEN))
-            Destroy_Entry (0, i->symEntry);
+            Destroy_Entry (i->symEntry, false);
     }
 
     if ( after_hash )
@@ -8903,6 +8910,18 @@ void Parser::Parse_Declare(bool is_local, bool after_hash)
     }
 }
 
+bool Parser::PassParameterByReference (int callingContext)
+{
+    if (Token.is_dictionary_elem)
+    {
+        return true;
+    }
+    else
+    {
+        return (Token.context <= callingContext);
+    }
+}
+
 bool Parser::Parse_RValue (int Previous, int *NumberPtr, void **DataPtr, SYM_ENTRY *sym, bool ParFlag, bool SemiFlag, bool is_local, bool allow_redefine, bool allowUndefined, int old_table_index)
 {
     EXPRESS Local_Express;
@@ -8928,21 +8947,21 @@ bool Parser::Parse_RValue (int Previous, int *NumberPtr, void **DataPtr, SYM_ENT
     bool callable_identifier;
     bool had_callable_identifier;
     SYM_ENTRY* symbol_entry;
+    SYM_TABLE* symbol_entry_table;
 
     EXPECT_ONE
         CASE4 (NORMAL_ID_TOKEN, FINISH_ID_TOKEN, TEXTURE_ID_TOKEN, OBJECT_ID_TOKEN)
         CASE4 (COLOUR_MAP_ID_TOKEN, TRANSFORM_ID_TOKEN, CAMERA_ID_TOKEN, PIGMENT_ID_TOKEN)
         CASE4 (SLOPE_MAP_ID_TOKEN,NORMAL_MAP_ID_TOKEN,TEXTURE_MAP_ID_TOKEN,ARRAY_ID_TOKEN)
         CASE4 (PIGMENT_MAP_ID_TOKEN, MEDIA_ID_TOKEN,INTERIOR_ID_TOKEN,DENSITY_ID_TOKEN)
         CASE4 (DENSITY_MAP_ID_TOKEN, RAINBOW_ID_TOKEN, FOG_ID_TOKEN, SKYSPHERE_ID_TOKEN)
-        CASE2 (MATERIAL_ID_TOKEN, STRING_ID_TOKEN)
-            if ((ParFlag) && (Token.Table_Index <= old_table_index))
+        CASE3 (MATERIAL_ID_TOKEN, STRING_ID_TOKEN, DICTIONARY_ID_TOKEN)
+            if ((ParFlag) && PassParameterByReference (old_table_index))
             {
                 // pass by reference
                 New_Par            = reinterpret_cast<POV_PARAM *>(POV_MALLOC(sizeof(POV_PARAM),"parameter"));
                 New_Par->NumberPtr = Token.NumberPtr;
                 New_Par->DataPtr   = Token.DataPtr;
-                New_Par->Table_Index = Token.Table_Index;
                 *NumberPtr = PARAMETER_ID_TOKEN;
                 *DataPtr   = reinterpret_cast<void *>(New_Par);
             }
@@ -9024,9 +9043,12 @@ bool Parser::Parse_RValue (int Previous, int *NumberPtr, void **DataPtr, SYM_ENT
             if ((Token.Token_Id==FUNCT_ID_TOKEN) || (Token.Token_Id==VECTFUNCT_ID_TOKEN) || (Token.Token_Id==SPLINE_ID_TOKEN) ||
                 (Token.Token_Id==UV_ID_TOKEN) || (Token.Token_Id==VECTOR_4D_ID_TOKEN) || (Token.Token_Id==COLOUR_ID_TOKEN))
             {
-                symbol_entry = Find_Symbol(Token.Table_Index, Token.Token_String);
+                symbol_entry = Find_Symbol (Token.table, Token.Token_String);
                 if (symbol_entry)
+                {
+                    symbol_entry_table = Token.table;
                     Acquire_Entry_Reference(symbol_entry);
+                }
             }
             else
             {
@@ -9048,7 +9070,7 @@ bool Parser::Parse_RValue (int Previous, int *NumberPtr, void **DataPtr, SYM_ENT
                 Error("Identifier expected, incomplete function call or spline call found instead.");
 
             // only one identifier token has been found so pass it by reference
-            if (((Temp_Count==-1) || (Temp_Count==TOKEN_OVERFLOW_RESET_COUNT)) && (Token.Table_Index <= old_table_index))
+            if (((Temp_Count==-1) || (Temp_Count==TOKEN_OVERFLOW_RESET_COUNT)) && PassParameterByReference (old_table_index))
             {
                 // It is important that functions are passed by value and not by reference! [trf]
                 if(!(ParFlag) || (ParFlag && function_identifier))
@@ -9065,7 +9087,6 @@ bool Parser::Parse_RValue (int Previous, int *NumberPtr, void **DataPtr, SYM_ENT
                     New_Par            = reinterpret_cast<POV_PARAM *>(POV_MALLOC(sizeof(POV_PARAM),"parameter"));
                     New_Par->NumberPtr = Token.NumberPtr;
                     New_Par->DataPtr   = Token.DataPtr;
-                    New_Par->Table_Index = Token.Table_Index;
 
                     *NumberPtr = PARAMETER_ID_TOKEN;
                     *DataPtr   = reinterpret_cast<void *>(New_Par);
@@ -9110,7 +9131,7 @@ bool Parser::Parse_RValue (int Previous, int *NumberPtr, void **DataPtr, SYM_ENT
                 }
             }
             if (symbol_entry)
-                Release_Entry_Reference(Token.Table_Index, symbol_entry);
+                Release_Entry_Reference (symbol_entry_table, symbol_entry);
 
             // allow #declares again
             Ok_To_Declare = true;
@@ -9329,6 +9350,13 @@ bool Parser::Parse_RValue (int Previous, int *NumberPtr, void **DataPtr, SYM_ENT
             *DataPtr   = Temp_Data;
         END_CASE
 
+        CASE (DICTIONARY_TOKEN)
+            Temp_Data  = reinterpret_cast<void *>(Parse_Dictionary_Declare());
+            *NumberPtr = DICTIONARY_ID_TOKEN;
+            Test_Redefine (Previous,NumberPtr,*DataPtr, allow_redefine);
+            *DataPtr   = Temp_Data;
+        END_CASE
+
         OTHERWISE
             UNGET
             Local_Object = Parse_Object ();
@@ -9438,15 +9466,20 @@ void Parser::Destroy_Ident_Data(void *Data, int Type)
             break;
         case ARRAY_ID_TOKEN:
             a = reinterpret_cast<POV_ARRAY *>(Data);
-            if(a->DataPtrs != NULL)
+            if(!a->DataPtrs.empty())
             {
-                for(i=0; i<a->Total; i++)
+                for(i=0; i<a->DataPtrs.size(); i++)
                 {
-                    Destroy_Ident_Data(a->DataPtrs[i], a->Type);
+                    if (a->Types.empty())
+                        Destroy_Ident_Data (a->DataPtrs[i], a->Type);
+                    else
+                        Destroy_Ident_Data (a->DataPtrs[i], a->Types[i]);
                 }
-                POV_FREE(a->DataPtrs);
             }
-            POV_FREE(a);
+            delete a;
+            break;
+        case DICTIONARY_ID_TOKEN:
+            Destroy_Sym_Table (reinterpret_cast<SYM_TABLE *>(Data));
             break;
         case PARAMETER_ID_TOKEN:
             POV_FREE(Data);
@@ -10519,16 +10552,30 @@ void *Parser::Copy_Identifier (void *Data, int Type)
             POV_MEMMOVE(reinterpret_cast<void *>(New), reinterpret_cast<void *>(Data), len * sizeof(UCS2));
             break;
         case ARRAY_ID_TOKEN:
-            a=reinterpret_cast<POV_ARRAY *>(Data);
-            na=reinterpret_cast<POV_ARRAY *>(POV_MALLOC(sizeof(POV_ARRAY),"array"));
-            *na=*a;
-            na->DataPtrs = reinterpret_cast<void **>(POV_MALLOC(sizeof(void *)*(a->Total),"array"));
-            for (i=0; i<a->Total; i++)
+            a = reinterpret_cast<POV_ARRAY *>(Data);
+            na = new POV_ARRAY;
+            na->Dims = a->Dims;
+            na->Type = a->Type;
+            na->resizable = a->resizable;
+            for (i = 0; i < 5; ++i)
+            {
+                na->Sizes[i] = a->Sizes[i];
+                na->Mags[i] = a->Mags[i];
+            }
+            na->DataPtrs.resize(a->DataPtrs.size());
+            na->Types = a->Types;
+            for (i=0; i<a->DataPtrs.size(); i++)
             {
-                na->DataPtrs[i] = reinterpret_cast<void *>(Copy_Identifier (a->DataPtrs[i],a->Type));
+                if (a->Types.empty())
+                    na->DataPtrs[i] = reinterpret_cast<void *>(Copy_Identifier (a->DataPtrs[i],a->Type));
+                else
+                    na->DataPtrs[i] = reinterpret_cast<void *>(Copy_Identifier (a->DataPtrs[i], a->Types[i]));
             }
             New = reinterpret_cast<void *>(na);
             break;
+        case DICTIONARY_ID_TOKEN:
+            New = reinterpret_cast<void *>(Copy_Sym_Table (reinterpret_cast<SYM_TABLE *>(Data)));
+            break;
         case FUNCT_ID_TOKEN:
         case VECTFUNCT_ID_TOKEN:
             New = reinterpret_cast<void *>(fnVMContext->functionvm->CopyFunction((FUNCTION_PTR )Data));