Updated to write string literal format for C-string in checkpoint. (#1975)

* Updated to write string literal format for C-string in checkpoint.

* Changed one of updated write_var return type back to void to be consistent with all others.

Author: hchen99

trick_source/sim_services/CheckPointAgent/ClassicCheckPointerAgent.cpp

@@ -108,6 +108,11 @@ void Trick::ClassicCheckPointAgent::write_decl(std::ostream& chkpnt_os, ALLOC_IN
 
     const char *type_spec;
 
+    // Safety check for NULL info pointer or NULL name
+    if (info == NULL || info->name == NULL) {
+        return;
+    }
+
     type_spec = trickTypeCharString(info->type, info->user_type_name);
 
     if (info->stcl == TRICK_EXTERN) {
@@ -828,20 +833,33 @@ std::string Trick::ClassicCheckPointAgent::
         alloc_info = mem_mgr->get_alloc_info_of( pointer);
 
         if (alloc_info != NULL) {
-            int alloc_elem_size;
-            int alloc_elem_index;
-            int misalignment;
+            // Special handling for character strings: prefer string literal format over allocation reference
+            // The following info for "char *" is for reference purpose:
+            // curr_dim = 0
+            // attr.type = TRICK_CHARACTER (base type)
+            // attr.num_index = 1 (1D array)
+            // attr.index[0].size = 0 (not static array)
+            // attr.size = sizeof(char)
+            // This prevents anonymous allocations from appearing in subsequent checkpoints
+            if ((attr != NULL) && (attr->type == TRICK_CHARACTER || attr->type == TRICK_UNSIGNED_CHARACTER) && ((curr_dim + 1) == attr->num_index)) {
+                std::stringstream ss;
+                write_quoted_str( ss, (const char*)pointer);
+                reference_string = ss.str();
+            } else {
+                int alloc_elem_size;
+                int alloc_elem_index;
+                int misalignment;
 
-            alloc_elem_size = alloc_info->size;
-            alloc_elem_index = (int) (((long) pointer - (long) alloc_info->start) / alloc_elem_size);
-            misalignment = (int) (((long) pointer - (long) alloc_info->start) % alloc_elem_size);
+                alloc_elem_size = alloc_info->size;
+                alloc_elem_index = (int) (((long) pointer - (long) alloc_info->start) / alloc_elem_size);
+                misalignment = (int) (((long) pointer - (long) alloc_info->start) % alloc_elem_size);
 
-            // If type-checking AND the type specifiers match AND  the type we're looking for
-            // is either not structured or if it is, the attr-list that describes the contents
-            // of the structure is the same.
+                // If type-checking AND the type specifiers match AND  the type we're looking for
+                // is either not structured or if it is, the attr-list that describes the contents
+                // of the structure is the same.
 
-            if ( (attr != NULL) && (attr->type == alloc_info->type) &&
-                 ( (attr->type != TRICK_STRUCTURED) || (attr->attr == alloc_info->attr))) {
+                if ( (attr != NULL) && (attr->type == alloc_info->type) &&
+                     ( (attr->type != TRICK_STRUCTURED) || (attr->attr == alloc_info->attr))) {
 
                 int ii;
                 int n_l_ptrs, n_r_ptrs;
@@ -945,6 +963,7 @@ std::string Trick::ClassicCheckPointAgent::
                     }
                 }
 
+                }
             }
         } else if ((attr != NULL) && ((curr_dim + 1) == attr->num_index)) {
 

trick_source/sim_services/MemoryManager/MemoryManager_write_checkpoint.cpp

@@ -34,6 +34,15 @@ void Trick::MemoryManager::execute_checkpoint( std::ostream& out_s ) {
         alloc_info = dependencies[ii];
         /** Generate temporary names for anonymous variables. */
         if (alloc_info->name == NULL) {
+            // Skip naming individual C-string allocations to eliminate unused declarations
+            // Individual char arrays (size=1, num_index=1) represent single strings that are
+            // included in char* arrays, so we don't need separate allocations for them
+            if ((alloc_info->type == TRICK_CHARACTER || alloc_info->type == TRICK_UNSIGNED_CHARACTER) && 
+                alloc_info->size == 1 && alloc_info->num_index == 1 && alloc_info->stcl == TRICK_LOCAL) {
+                // Skip naming this individual char array allocation to prevent unused declarations
+                continue;
+            }
+
             if ( alloc_info->stcl == TRICK_LOCAL) {
                 snprintf( name, sizeof(name), "%s%d", local_anon_var_prefix, local_anon_var_number++);
                 alloc_info->name = strdup( name);
@@ -70,8 +79,17 @@ void Trick::MemoryManager::execute_checkpoint( std::ostream& out_s ) {
 
     for (int ii = 0 ; ii < n_depends ; ii ++) {
         alloc_info = dependencies[ii];
-        write_var( out_s, alloc_info);
-        out_s << std::endl;
+        // Skip naming individual C-string allocations to eliminate unused declarations.
+        // Individual char arrays (size=1, num_index=1) represent single strings that are
+        // included in char* arrays, so we don't need separate allocations for them.
+        // Also, safety check for NULL name before pushing to name stack later.
+        if (!((alloc_info->type == TRICK_CHARACTER || alloc_info->type == TRICK_UNSIGNED_CHARACTER) &&
+               alloc_info->size == 1 && alloc_info->num_index == 1 && alloc_info->stcl == TRICK_LOCAL) &&
+             alloc_info->name != NULL)
+        {
+            write_var(out_s, alloc_info);
+            out_s << std::endl;
+        }
     }
 
     // Free all of the temporary names that were created for the checkpoint.