15478949623

Committed 05 Jun 2025 10:59PM UTC coverage: 55.948% (-0.02%) from 55.966%

Build # 15478949623

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #1906 from nasa/1905-c++20-compatibility

Make Trick core c++20 compatible #1905

Run Details

0 of 11 new or added lines in 3 files covered. (0.0%)

3 existing lines in 3 files now uncovered.

12332 of 22042 relevant lines covered (55.95%)

262601.08 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

45.83

/trick_source/sim_services/MemoryManager/MemoryManager_ref_assignment.cpp

#include "trick/MemoryManager.hh"
#include "trick/bitfield_proto.h"
#include "trick/vval.h"
#include "trick/wcs_ext.h"
#include <limits.h>
#include <sstream>
#include <udunits2.h>
#include <string.h>

int Trick::MemoryManager::assign_recursive(void* base_addr, ATTRIBUTES* attr, int curr_dim, int offset, V_TREE* v_tree, cv_converter* cf) {

   char* assign_addr;
   int remaining_dimensions = attr->num_index - curr_dim;

   if ( remaining_dimensions == 0 ) {

      switch (attr->type) {

           case TRICK_CHARACTER :
           case TRICK_UNSIGNED_CHARACTER :
               assign_addr = (char*)base_addr + offset * sizeof(char);
               if (v_tree && v_tree->v_data) {
                   *(char*)assign_addr = vval_char(v_tree->v_data);
               } else {
                   *(char*)assign_addr = '\0';
               }
               if (debug_level) {
                   std::cout << std::endl << "Assignment: *(char*)" << (void*)assign_addr
                             << " = ";
                   if (isprint(*(char*)assign_addr)) {
                       std::cout << *(char*)assign_addr;
                   } else {
                       std::cout << (int)*(char*)assign_addr;
                   }
                   std::cout << ";" << std::endl;
                   std::cout.flush();
               }
               break;
           case TRICK_WCHAR :
               assign_addr = (char*)base_addr + offset * sizeof(wchar_t);
               if (v_tree && v_tree->v_data) {
                   *(wchar_t*)assign_addr = vval_char(v_tree->v_data);
               } else {
                   *(wchar_t*)assign_addr = 0;
               }
               if (debug_level) {
                   char buff[16] = {0};
                   wctomb(buff,*(wchar_t*)assign_addr);
                   std::cout << std::endl << "Assignment: *(wchar_t*)" << (void*)assign_addr
                             << " = " << buff << ";" << std::endl;
                   std::cout.flush();
               }
               break;
           case TRICK_SHORT :
           case TRICK_UNSIGNED_SHORT :
               assign_addr = (char*)base_addr + offset * sizeof(short);
               if (v_tree && v_tree->v_data) {
                   *(short *)assign_addr = vval_short(v_tree->v_data);
               } else {
                   *(short *)assign_addr = 0;
               }
               if (debug_level) {
                   std::cout << std::endl << "Assignment: *(short*)" << (void*)assign_addr
                             << " = " << *(short*)assign_addr << ";" << std::endl;
                   std::cout.flush();
               }
               break;
           case TRICK_INTEGER :
           case TRICK_UNSIGNED_INTEGER :
               assign_addr = (char*)base_addr + offset * sizeof(int);
               if (v_tree && v_tree->v_data) {
                   int input_value;
                   input_value = vval_int(v_tree->v_data);
                   if (cf == NULL) {
                       *(int *)assign_addr = input_value;
                   } else {
                       *(int *)assign_addr = (int)cv_convert_double(cf, (double)input_value) ;
                   }
               } else {
                   *(int *)assign_addr = 0;
               }
               if (debug_level) {
                   std::cout << std::endl << "Assignment: *(int*)" << (void*)assign_addr
                             << " = " << *(int*)assign_addr << ";" << std::endl;
                   std::cout.flush();
               }
               break;
           case TRICK_BOOLEAN :
               assign_addr = (char*)base_addr + offset * sizeof(bool);
               if (v_tree && v_tree->v_data) {
                   *(bool *)assign_addr = (vval_short(v_tree->v_data)!=0);
               } else {
                   *(bool *)assign_addr = false;
               }
               if (debug_level) {
                   std::cout << std::endl << "Assignment: *(bool*)" << (void*)assign_addr
                             << " = " << *(bool*)assign_addr << ";" << std::endl;
                   std::cout.flush();
               }
               break;
           case TRICK_ENUMERATED :
               if (v_tree && v_tree->v_data) {
                   if ((size_t)attr->size == sizeof(int)) {
                       assign_addr = (char*)base_addr + offset * sizeof(int);
                       *(int *)assign_addr = vval_int(v_tree->v_data);
                       if (debug_level) {
                           std::cout << std::endl << "Assignment (Enum): *(int*)" << (void*)assign_addr
                                     << " = " << *(int*)assign_addr << ";" << std::endl;
                           std::cout.flush();
                       }
                   } else if ((size_t)attr->size == sizeof(short)) {
                       assign_addr = (char*)base_addr + offset * sizeof(short);
                       *(short *)assign_addr = vval_short(v_tree->v_data);
                       if (debug_level) {
                           std::cout << std::endl << "Assignment (Enum): *(short*)" << (void*)assign_addr
                                     << " = " << *(short*)assign_addr << ";" << std::endl;
                           std::cout.flush();
                       }
                   } else if ((size_t)attr->size == sizeof(char)) {
                       assign_addr = (char*)base_addr + offset * sizeof(char);
                       *(char *)assign_addr = vval_char(v_tree->v_data);
                       if (debug_level) {
                           std::cout << std::endl << "Assignment (Enum): *(char*)" << (void*)assign_addr
                                     << " = " << *(char*)assign_addr << ";" << std::endl;
                           std::cout.flush();
                       }
                   } else {
                       std::stringstream message;
                       message << "Enumeration of size " << attr->size << " is not supported.";
                       emitError(message.str());
                   }
               } else {
                   emitError("v_tree data appears to be corrupted.");
               }
               break;
           case TRICK_LONG :
           case TRICK_UNSIGNED_LONG :
               assign_addr = (char*)base_addr + offset * sizeof(long);
               if (v_tree && v_tree->v_data) {
                   long input_value;
                   input_value = vval_long(v_tree->v_data);
                   if (cf == NULL) {
                       *(long *)assign_addr = input_value;
                   } else {
                       *(long *)assign_addr = (long)cv_convert_double(cf, (double)input_value) ;
                   }
               } else {
                   *(long *)assign_addr = 0;
               }
               if (debug_level) {
                   std::cout << std::endl << "Assignment: *(long*)" << (void*)assign_addr
                             << " = " << *(long*)assign_addr << ";" << std::endl;
                   std::cout.flush();
               }
               break;
           case TRICK_FLOAT :
               assign_addr = (char*)base_addr + offset * sizeof(float);
               if (v_tree && v_tree->v_data) {
                   float input_value;
                   input_value = vval_float(v_tree->v_data);
                   if (cf == NULL) {  // There is no units conversion.
                       *(float *)assign_addr = input_value;
                   } else { // There is units conversion.
                       *(float *)assign_addr = (float)cv_convert_double(cf, (double)input_value) ;
                   }
               } else {
                   *(float *)assign_addr = 0;
               }
               if (debug_level) {
                   std::cout << std::endl << "Assignment: *(float*)" << (void*)assign_addr
                             << " = " << *(float*)assign_addr << ";" << std::endl;
                   std::cout.flush();
               }
               break;
           case TRICK_DOUBLE :
               assign_addr = (char*)base_addr + offset * sizeof(double);
               if (v_tree && v_tree->v_data) {
                   double input_value;
                   input_value = vval_double(v_tree->v_data);
                   if (cf == NULL) {
                       *(double *)assign_addr = input_value;
                   } else {
                       *(double *)assign_addr = cv_convert_double(cf, input_value) ;
                   }
               } else {
                   *(double *)assign_addr = 0;
               }
               if (debug_level) {
                   std::cout << std::endl << "Assignment: *(double*)" << (void*)assign_addr
                             << " = " << *(double*)assign_addr << ";" << std::endl;
                   std::cout.flush();
               }
               break;
           case TRICK_LONG_LONG :
           case TRICK_UNSIGNED_LONG_LONG :
               assign_addr = (char*)base_addr + offset * sizeof(long long);
               if (v_tree && v_tree->v_data) {
                   *(long long *)assign_addr = vval_longlong(v_tree->v_data);
               } else {
                   *(long long *)assign_addr = 0;
               }
               if (debug_level) {
                   std::cout << std::endl << "Assignment: *(long long*)" << (void*)assign_addr
                             << " = " << *(long long*)assign_addr << ";" << std::endl;
                   std::cout.flush();
               }
               break;
           case TRICK_BITFIELD :
           case TRICK_UNSIGNED_BITFIELD : {
                   int input_value;
                   assign_addr = (char*)base_addr + offset * (size_t)attr->size;
                   if (v_tree && v_tree->v_data) {
                       input_value = vval_int(v_tree->v_data);
                   } else {
                       input_value = 0;
                   }
                   if (attr->size == sizeof(int)) {
                       *(unsigned int*)assign_addr = insert_bitfield_any(
                           *(unsigned int*)assign_addr, input_value, attr->size, attr->index[0].start, attr->index[0].size);
                   } else if (attr->size == sizeof(short)) {
                       *(unsigned short*)assign_addr = insert_bitfield_any(
                           *(unsigned short*)assign_addr, input_value, attr->size, attr->index[0].start, attr->index[0].size);
                   } else if (attr->size == sizeof(char)) {
                       *(unsigned char*)assign_addr = insert_bitfield_any(
                           *(unsigned char*)assign_addr, input_value, attr->size, attr->index[0].start, attr->index[0].size);
                   } else {
                       std::stringstream message;
                       message << "Unhandled bitfield struct size (" << attr->size << ") in bitfield assignment.";
                       emitError(message.str());
                   }
                   if (debug_level) {
                       std::cout << std::endl << "Assignment: "
                                 << "Within the " << attr->size << " byte struct at " << (void*)assign_addr
                                 << ", the bitfield ["<< attr->index[0].start << ".."
                                 << attr->index[0].start + attr->index[0].size - 1
                                 << "] = " << input_value << ";"
                                 << std::endl;
                       std::cout.flush();
                   }
               } break;
           case TRICK_FILE_PTR :
               if (debug_level) {
                   std::cout << std::endl << "Assignment: TRICK_FILE_PTR assignments not yet implemented."
                             << std::endl;
                   std::cout.flush();
               }
               break;
           case TRICK_VOID_PTR :
               if (debug_level) {
                   std::cout << std::endl << "Assignment: TRICK_VOID_PTR assignments not yet implemented."
                             << std::endl;
                   std::cout.flush();
               }
               break;
           case TRICK_STRING :
               assign_addr = (char*)base_addr + offset * sizeof(std::string);
               if (v_tree && v_tree->v_data) {
                   *(std::string*)assign_addr = vval_string(v_tree->v_data);
               } else {
                   *(std::string*)assign_addr = "";
               }
               if (debug_level) {
                   std::cout << std::endl << "Assignment: *(std::string)" << (void*)assign_addr
                             << " = \"" << *(std::string*)assign_addr << "\";" << std::endl;
                   std::cout.flush();
               }
               break;
           default:
               std::stringstream message;
               message << "Unhandled Type (" << attr->type << ") in assignment.";
               emitError(message.str());
               return (1);
               break;
      }

   } else if ( remaining_dimensions > 0 ) {

       int size_of_curr_dim = attr->index[curr_dim].size ;

       if ( size_of_curr_dim == 0) { // the remaining dimensions are pointer dimensions.

           assign_addr = (char*)base_addr + offset * sizeof(void*);

           if (v_tree && v_tree->v_data) {

               if ((remaining_dimensions == 1) && (v_tree->v_data->type == TRICK_STRING)) {
                   *(char**)assign_addr = mm_strdup( vval_string(v_tree->v_data));
               } else {
                   *(void**)assign_addr = vval_voidp(v_tree->v_data);
               }

           } else {
               *(void**)assign_addr = 0;
           }

           if (debug_level) {
               std::cout << std::endl << "Assignment: *(void**)" << (void*)assign_addr
                         << " = " << *(void**)assign_addr << ";" << std::endl;
               std::cout.flush();
           }

       } else { // next dimension is fixed.

           if ((attr->type == TRICK_CHARACTER) &&
               (remaining_dimensions == 1) &&
               (v_tree) &&
               (v_tree->v_data)
              ) {

               assign_addr = (char*)base_addr + offset * size_of_curr_dim * sizeof(char);

               if ((v_tree->v_data->type == TRICK_STRING) &&
                   (v_tree->v_data->value.cp != NULL)) {

                   int rhs_len = (int)strlen(v_tree->v_data->value.cp) + 1;
                   if (rhs_len <= size_of_curr_dim ) {
                       strcpy((char*)assign_addr, v_tree->v_data->value.cp);
                   } else {
                       emitError("Memory Manager: char array is too small for the attempted string assignment.");
                       return (1);
                   }
               } else {
                   *(char*)assign_addr = '\0';
               }

           } else if ( (attr->type == TRICK_WCHAR) &&
                       (remaining_dimensions == 1)) {

               assign_addr = (char*)base_addr + offset * size_of_curr_dim * sizeof(wchar_t);

               if ((v_tree) &&
                   (v_tree->v_data->type == TRICK_WSTRING) &&
                   (v_tree->v_data->value.wcp != NULL)) {

                       int rhs_len = (int)wcslen(v_tree->v_data->value.wcp) + 1;
                       if (rhs_len <= size_of_curr_dim ) {
                           wcscpy((wchar_t*)assign_addr, v_tree->v_data->value.wcp);
                       } else {
                           std::stringstream message;
                           message << "wchar_t array at [" << (void*)assign_addr
                                   << "] is to small for the attempted string assignment." ;
                           emitError(message.str());
                           return (1);
                       }
               } else if ((v_tree) &&
                          (v_tree->v_data->type == TRICK_STRING) &&
                          (v_tree->v_data->value.cp != NULL)) {

                       int rhs_len = (int)ncs_to_wcs_len(v_tree->v_data->value.cp) + 1;
                       if (rhs_len <= size_of_curr_dim ) {
                           ncs_to_wcs( v_tree->v_data->value.cp, (wchar_t*)assign_addr, rhs_len);
                       } else {
                           std::stringstream message;
                           message << "wchar_t array at [" << (void*)assign_addr
                                   << "] is too small for the attempted string assignment." ;
                           emitError(message.str());
                           return (1);
                       }
               } else {
                   *(wchar_t*)assign_addr = (wchar_t) NULL;
               }

           } else {
               int ii;
               V_TREE* curr_vt_node;
               if (v_tree) {
                   curr_vt_node = v_tree->down;
               } else {
                   curr_vt_node =  NULL;
               }

               for (ii=0; ii < size_of_curr_dim; ii++) {
                   int ret;
                   ret = assign_recursive (base_addr,
                                           attr,
                                           curr_dim+1,
                                           offset * size_of_curr_dim + ii,
                                           curr_vt_node,
                                           cf);

                   if (ret !=0) {
                       return(1);
                   }

                   if (curr_vt_node) {
                     curr_vt_node = curr_vt_node->next;
                   }
               }
           }
       }
   } else {
        emitError("This is bad. In assign_recursive(), remaining_dimensions is negative.");
        return (1);
   }
   return (0);
}

#ifdef TRICK_VER
#include "trick/UdUnits.hh"
#else
static ut_system * u_system ;
#endif
ut_system * Trick::MemoryManager::get_unit_system() {
#ifdef TRICK_VER
    return Trick::UdUnits::get_u_system() ;
#else
    /* Initialize the udunits-2 library */
    ut_set_error_message_handler(ut_ignore) ;
    if( (u_system = ut_read_xml( NULL )) == NULL ) {
        std::cerr << "Error initializing udunits-2 unit system" << std::endl ;
        return -1 ;
    }
    ut_set_error_message_handler(ut_write_to_stderr) ;
    return u_system ;
#endif
}

// MEMBER FUNCTION
int Trick::MemoryManager::ref_assignment( REF2* R, V_TREE* V) {

    int ret = 0;
    cv_converter * cf = NULL ;

    // Create a units conversion function if necessary.
    if (R->units) {
        ut_unit * from = ut_parse(get_unit_system(), R->units, UT_ASCII) ;
        ut_unit * to = ut_parse(get_unit_system(), R->attr->units, UT_ASCII) ;
        if ( !from or !to ) {
            std::stringstream message;
            message << "Can't convert \"" << R->units << "\" to \"" << R->attr->units << "\".";
            emitError(message.str());
            return TRICK_UNITS_CONVERSION_ERROR ;
        }
        cf = ut_get_converter(from,to) ;
        if ( !cf ) {
            std::stringstream message;
            message << "Can't convert \"" << R->units << "\" to \"" << R->attr->units << "\".";
            emitError(message.str());
            return TRICK_UNITS_CONVERSION_ERROR ;
        }
    }

    // R->num_index is badly named. It is really the current dimension
    ret = assign_recursive( R->address, R->attr, R->num_index, 0, V, cf);
    if ( cf ) cv_free(cf) ;

    return ( ret);

}


1	#include "trick/MemoryManager.hh"
2	#include "trick/bitfield_proto.h"
3	#include "trick/vval.h"
4	#include "trick/wcs_ext.h"
5	#include <limits.h>
6	#include <sstream>
7	#include <udunits2.h>
8	#include <string.h>
9
10	int Trick::MemoryManager::assign_recursive(void* base_addr, ATTRIBUTES* attr, int curr_dim, int offset, V_TREE* v_tree, cv_converter* cf) {	17,300✔
11
12	char* assign_addr;
13	int remaining_dimensions = attr->num_index - curr_dim;	17,300✔
14
15	if ( remaining_dimensions == 0 ) {	17,300✔
16
17	switch (attr->type) {	15,216✔
18
19	case TRICK_CHARACTER :	597✔
20	case TRICK_UNSIGNED_CHARACTER :
21	assign_addr = (char)base_addr + offset sizeof(char);	597✔
22	if (v_tree && v_tree->v_data) {	597✔
23	(char)assign_addr = vval_char(v_tree->v_data);	597✔
24	} else {
25	(char)assign_addr = '\0';	×
26	}
27	if (debug_level) {	597✔
28	std::cout << std::endl << "Assignment: (char)" << (void*)assign_addr	×
29	<< " = ";	×
30	if (isprint((char)assign_addr)) {	×
31	std::cout << (char)assign_addr;	×
32	} else {
33	std::cout << (int)(char)assign_addr;	×
34	}
35	std::cout << ";" << std::endl;	×
36	std::cout.flush();	×
37	}
38	break;	15,216✔
39	case TRICK_WCHAR :	×
40	assign_addr = (char)base_addr + offset sizeof(wchar_t);	×
41	if (v_tree && v_tree->v_data) {	×
42	(wchar_t)assign_addr = vval_char(v_tree->v_data);	×
43	} else {
44	(wchar_t)assign_addr = 0;	×
45	}
46	if (debug_level) {	×
NEW 47	char buff[16] = {0};	×
NEW 48	wctomb(buff,(wchar_t)assign_addr);	×
49	std::cout << std::endl << "Assignment: (wchar_t)" << (void*)assign_addr	×
NEW 50	<< " = " << buff << ";" << std::endl;	×
51	std::cout.flush();	×
52	}
53	break;	×
54	case TRICK_SHORT :	1,059✔
55	case TRICK_UNSIGNED_SHORT :
56	assign_addr = (char)base_addr + offset sizeof(short);	1,059✔
57	if (v_tree && v_tree->v_data) {	1,059✔
58	(short )assign_addr = vval_short(v_tree->v_data);	1,059✔
59	} else {
60	(short )assign_addr = 0;	×
61	}
62	if (debug_level) {	1,059✔
63	std::cout << std::endl << "Assignment: (short)" << (void*)assign_addr	×
64	<< " = " << (short)assign_addr << ";" << std::endl;	×
65	std::cout.flush();	×
66	}
67	break;	1,059✔
68	case TRICK_INTEGER :	4,283✔
69	case TRICK_UNSIGNED_INTEGER :
70	assign_addr = (char)base_addr + offset sizeof(int);	4,283✔
71	if (v_tree && v_tree->v_data) {	4,283✔
72	int input_value;
73	input_value = vval_int(v_tree->v_data);	4,277✔
74	if (cf == NULL) {	4,277✔
75	(int )assign_addr = input_value;	4,274✔
76	} else {
77	(int )assign_addr = (int)cv_convert_double(cf, (double)input_value) ;	3✔
78	}	4,277✔
79	} else {
80	(int )assign_addr = 0;	6✔
81	}
82	if (debug_level) {	4,283✔
83	std::cout << std::endl << "Assignment: (int)" << (void*)assign_addr	×
84	<< " = " << (int)assign_addr << ";" << std::endl;	×
85	std::cout.flush();	×
86	}
87	break;	4,283✔
88	case TRICK_BOOLEAN :	1,441✔
89	assign_addr = (char)base_addr + offset sizeof(bool);	1,441✔
90	if (v_tree && v_tree->v_data) {	1,441✔
91	(bool )assign_addr = (vval_short(v_tree->v_data)!=0);	1,441✔
92	} else {
93	(bool )assign_addr = false;	×
94	}
95	if (debug_level) {	1,441✔
96	std::cout << std::endl << "Assignment: (bool)" << (void*)assign_addr	×
97	<< " = " << (bool)assign_addr << ";" << std::endl;	×
98	std::cout.flush();	×
99	}
100	break;	1,441✔
101	case TRICK_ENUMERATED :	30✔
102	if (v_tree && v_tree->v_data) {	30✔
103	if ((size_t)attr->size == sizeof(int)) {	30✔
104	assign_addr = (char)base_addr + offset sizeof(int);	30✔
105	(int )assign_addr = vval_int(v_tree->v_data);	30✔
106	if (debug_level) {	30✔
107	std::cout << std::endl << "Assignment (Enum): (int)" << (void*)assign_addr	×
108	<< " = " << (int)assign_addr << ";" << std::endl;	×
109	std::cout.flush();	×
110	}
111	} else if ((size_t)attr->size == sizeof(short)) {	×
112	assign_addr = (char)base_addr + offset sizeof(short);	×
113	(short )assign_addr = vval_short(v_tree->v_data);	×
114	if (debug_level) {	×
115	std::cout << std::endl << "Assignment (Enum): (short)" << (void*)assign_addr	×
116	<< " = " << (short)assign_addr << ";" << std::endl;	×
117	std::cout.flush();	×
118	}
119	} else if ((size_t)attr->size == sizeof(char)) {	×
120	assign_addr = (char)base_addr + offset sizeof(char);	×
121	(char )assign_addr = vval_char(v_tree->v_data);	×
122	if (debug_level) {	×
123	std::cout << std::endl << "Assignment (Enum): (char)" << (void*)assign_addr	×
124	<< " = " << (char)assign_addr << ";" << std::endl;	×
125	std::cout.flush();	×
126	}
127	} else {
128	std::stringstream message;	×
129	message << "Enumeration of size " << attr->size << " is not supported.";	×
130	emitError(message.str());	×
131	}	30✔
132	} else {
133	emitError("v_tree data appears to be corrupted.");	×
134	}
135	break;	30✔
136	case TRICK_LONG :	60✔
137	case TRICK_UNSIGNED_LONG :
138	assign_addr = (char)base_addr + offset sizeof(long);	60✔
139	if (v_tree && v_tree->v_data) {	60✔
140	long input_value;
141	input_value = vval_long(v_tree->v_data);	60✔
142	if (cf == NULL) {	60✔
143	(long )assign_addr = input_value;	58✔
144	} else {
145	(long )assign_addr = (long)cv_convert_double(cf, (double)input_value) ;	2✔
146	}	60✔
147	} else {
148	(long )assign_addr = 0;	×
149	}
150	if (debug_level) {	60✔
151	std::cout << std::endl << "Assignment: (long)" << (void*)assign_addr	×
152	<< " = " << (long)assign_addr << ";" << std::endl;	×
153	std::cout.flush();	×
154	}
155	break;	60✔
156	case TRICK_FLOAT :	18✔
157	assign_addr = (char)base_addr + offset sizeof(float);	18✔
158	if (v_tree && v_tree->v_data) {	18✔
159	float input_value;
160	input_value = vval_float(v_tree->v_data);	18✔
161	if (cf == NULL) { // There is no units conversion.	18✔
162	(float )assign_addr = input_value;	17✔
163	} else { // There is units conversion.
164	(float )assign_addr = (float)cv_convert_double(cf, (double)input_value) ;	1✔
165	}	18✔
166	} else {
167	(float )assign_addr = 0;	×
168	}
169	if (debug_level) {	18✔
170	std::cout << std::endl << "Assignment: (float)" << (void*)assign_addr	×
171	<< " = " << (float)assign_addr << ";" << std::endl;	×
172	std::cout.flush();	×
173	}
174	break;	18✔
175	case TRICK_DOUBLE :	2,959✔
176	assign_addr = (char)base_addr + offset sizeof(double);	2,959✔
177	if (v_tree && v_tree->v_data) {	2,959✔
178	double input_value;
179	input_value = vval_double(v_tree->v_data);	2,959✔
180	if (cf == NULL) {	2,959✔
181	(double )assign_addr = input_value;	2,953✔
182	} else {
183	(double )assign_addr = cv_convert_double(cf, input_value) ;	6✔
184	}	2,959✔
185	} else {
186	(double )assign_addr = 0;	×
187	}
188	if (debug_level) {	2,959✔
189	std::cout << std::endl << "Assignment: (double)" << (void*)assign_addr	×
190	<< " = " << (double)assign_addr << ";" << std::endl;	×
191	std::cout.flush();	×
192	}
193	break;	2,959✔
194	case TRICK_LONG_LONG :	460✔
195	case TRICK_UNSIGNED_LONG_LONG :
196	assign_addr = (char)base_addr + offset sizeof(long long);	460✔
197	if (v_tree && v_tree->v_data) {	460✔
198	(long long )assign_addr = vval_longlong(v_tree->v_data);	460✔
199	} else {
200	(long long )assign_addr = 0;	×
201	}
202	if (debug_level) {	460✔
203	std::cout << std::endl << "Assignment: (long long)" << (void*)assign_addr	×
204	<< " = " << (long long)assign_addr << ";" << std::endl;	×
205	std::cout.flush();	×
206	}
207	break;	460✔
208	case TRICK_BITFIELD :	×
209	case TRICK_UNSIGNED_BITFIELD : {
210	int input_value;
211	assign_addr = (char)base_addr + offset (size_t)attr->size;	×
212	if (v_tree && v_tree->v_data) {	×
213	input_value = vval_int(v_tree->v_data);	×
214	} else {
215	input_value = 0;	×
216	}
217	if (attr->size == sizeof(int)) {	×
218	(unsigned int)assign_addr = insert_bitfield_any(	×
219	(unsigned int)assign_addr, input_value, attr->size, attr->index[0].start, attr->index[0].size);
220	} else if (attr->size == sizeof(short)) {	×
221	(unsigned short)assign_addr = insert_bitfield_any(	×
222	(unsigned short)assign_addr, input_value, attr->size, attr->index[0].start, attr->index[0].size);	×
223	} else if (attr->size == sizeof(char)) {	×
224	(unsigned char)assign_addr = insert_bitfield_any(	×
225	(unsigned char)assign_addr, input_value, attr->size, attr->index[0].start, attr->index[0].size);	×
226	} else {
227	std::stringstream message;	×
228	message << "Unhandled bitfield struct size (" << attr->size << ") in bitfield assignment.";	×
229	emitError(message.str());	×
230	}
231	if (debug_level) {	×
232	std::cout << std::endl << "Assignment: "	×
233	<< "Within the " << attr->size << " byte struct at " << (void*)assign_addr	×
234	<< ", the bitfield ["<< attr->index[0].start << ".."	×
235	<< attr->index[0].start + attr->index[0].size - 1	×
236	<< "] = " << input_value << ";"	×
237	<< std::endl;	×
238	std::cout.flush();	×
239	}
240	} break;	×
241	case TRICK_FILE_PTR :	×
242	if (debug_level) {	×
243	std::cout << std::endl << "Assignment: TRICK_FILE_PTR assignments not yet implemented."	×
244	<< std::endl;	×
245	std::cout.flush();	×
246	}
247	break;	×
248	case TRICK_VOID_PTR :	×
249	if (debug_level) {	×
250	std::cout << std::endl << "Assignment: TRICK_VOID_PTR assignments not yet implemented."	×
251	<< std::endl;	×
252	std::cout.flush();	×
253	}
254	break;	×
255	case TRICK_STRING :	4,309✔
256	assign_addr = (char)base_addr + offset sizeof(std::string);	4,309✔
257	if (v_tree && v_tree->v_data) {	4,309✔
258	(std::string)assign_addr = vval_string(v_tree->v_data);	4,309✔
259	} else {
260	(std::string)assign_addr = "";	×
261	}
262	if (debug_level) {	4,309✔
263	std::cout << std::endl << "Assignment: (std::string)" << (void)assign_addr	×
264	<< " = \"" << (std::string)assign_addr << "\";" << std::endl;	×
265	std::cout.flush();	×
266	}
267	break;	4,309✔
268	default:	×
269	std::stringstream message;	×
270	message << "Unhandled Type (" << attr->type << ") in assignment.";	×
271	emitError(message.str());	×
272	return (1);	×
273	break;
274	}
275
276	} else if ( remaining_dimensions > 0 ) {	2,084✔
277
278	int size_of_curr_dim = attr->index[curr_dim].size ;	2,084✔
279
280	if ( size_of_curr_dim == 0) { // the remaining dimensions are pointer dimensions.	2,084✔
281
282	assign_addr = (char)base_addr + offset sizeof(void*);	587✔
283
284	if (v_tree && v_tree->v_data) {	587✔
285
286	if ((remaining_dimensions == 1) && (v_tree->v_data->type == TRICK_STRING)) {	1,174✔
287	(char*)assign_addr = mm_strdup( vval_string(v_tree->v_data));	27✔
288	} else {
289	(void*)assign_addr = vval_voidp(v_tree->v_data);	560✔
290	}
291
292	} else {
293	(void*)assign_addr = 0;	×
294	}
295
296	if (debug_level) {	587✔
297	std::cout << std::endl << "Assignment: (void)" << (void)assign_addr	×
298	<< " = " << (void*)assign_addr << ";" << std::endl;	×
299	std::cout.flush();	×
300	}
301
302	} else { // next dimension is fixed.
303
304	if ((attr->type == TRICK_CHARACTER) &&	1,497✔
305	(remaining_dimensions == 1) &&	75✔
306	(v_tree) &&	75✔
307	(v_tree->v_data)	75✔
308	) {
309
310	assign_addr = (char)base_addr + offset size_of_curr_dim * sizeof(char);	66✔
311
312	if ((v_tree->v_data->type == TRICK_STRING) &&	66✔
313	(v_tree->v_data->value.cp != NULL)) {	66✔
314
315	int rhs_len = (int)strlen(v_tree->v_data->value.cp) + 1;	66✔
316	if (rhs_len <= size_of_curr_dim ) {	66✔
317	strcpy((char*)assign_addr, v_tree->v_data->value.cp);	66✔
318	} else {
319	emitError("Memory Manager: char array is too small for the attempted string assignment.");	×
320	return (1);	×
321	}	66✔
322	} else {
323	(char)assign_addr = '\0';	×
324	}	66✔
325
326	} else if ( (attr->type == TRICK_WCHAR) &&	1,431✔
327	(remaining_dimensions == 1)) {
328
329	assign_addr = (char)base_addr + offset size_of_curr_dim * sizeof(wchar_t);	×
330
331	if ((v_tree) &&	×
332	(v_tree->v_data->type == TRICK_WSTRING) &&	×
333	(v_tree->v_data->value.wcp != NULL)) {	×
334
335	int rhs_len = (int)wcslen(v_tree->v_data->value.wcp) + 1;	×
336	if (rhs_len <= size_of_curr_dim ) {	×
337	wcscpy((wchar_t*)assign_addr, v_tree->v_data->value.wcp);	×
338	} else {
339	std::stringstream message;	×
340	message << "wchar_t array at [" << (void*)assign_addr	×
341	<< "] is to small for the attempted string assignment." ;	×
342	emitError(message.str());	×
343	return (1);	×
344	}	×
345	} else if ((v_tree) &&	×
346	(v_tree->v_data->type == TRICK_STRING) &&	×
347	(v_tree->v_data->value.cp != NULL)) {	×
348
349	int rhs_len = (int)ncs_to_wcs_len(v_tree->v_data->value.cp) + 1;	×
350	if (rhs_len <= size_of_curr_dim ) {	×
351	ncs_to_wcs( v_tree->v_data->value.cp, (wchar_t*)assign_addr, rhs_len);	×
352	} else {
353	std::stringstream message;	×
354	message << "wchar_t array at [" << (void*)assign_addr	×
355	<< "] is too small for the attempted string assignment." ;	×
356	emitError(message.str());	×
357	return (1);	×
358	}	×
359	} else {
360	(wchar_t)assign_addr = (wchar_t) NULL;	×
361	}	×
362
363	} else {
364	int ii;
365	V_TREE* curr_vt_node;
366	if (v_tree) {	1,431✔
367	curr_vt_node = v_tree->down;	1,431✔
368	} else {
369	curr_vt_node = NULL;	×
370	}
371
372	for (ii=0; ii < size_of_curr_dim; ii++) {	4,125✔
373	int ret;
374	ret = assign_recursive (base_addr,	5,388✔
375	attr,
376	curr_dim+1,
377	offset * size_of_curr_dim + ii,	2,694✔
378	curr_vt_node,
379	cf);
380
381	if (ret !=0) {	2,694✔
382	return(1);	×
383	}
384
385	if (curr_vt_node) {	2,694✔
386	curr_vt_node = curr_vt_node->next;	2,688✔
387	}
388	}
389	}
390	}
391	} else {
392	emitError("This is bad. In assign_recursive(), remaining_dimensions is negative.");	×
393	return (1);	×
394	}
395	return (0);	17,300✔
396	}
397
398	#ifdef TRICK_VER
399	#include "trick/UdUnits.hh"
400	#else
401	static ut_system * u_system ;
402	#endif
403	ut_system * Trick::MemoryManager::get_unit_system() {	38✔
404	#ifdef TRICK_VER
405	return Trick::UdUnits::get_u_system() ;	38✔
406	#else
407	/* Initialize the udunits-2 library */
408	ut_set_error_message_handler(ut_ignore) ;
409	if( (u_system = ut_read_xml( NULL )) == NULL ) {
410	std::cerr << "Error initializing udunits-2 unit system" << std::endl ;
411	return -1 ;
412	}
413	ut_set_error_message_handler(ut_write_to_stderr) ;
414	return u_system ;
415	#endif
416	}
417
418	// MEMBER FUNCTION
419	int Trick::MemoryManager::ref_assignment( REF2* R, V_TREE* V) {	14,607✔
420
421	int ret = 0;	14,607✔
422	cv_converter * cf = NULL ;	14,607✔
423
424	// Create a units conversion function if necessary.
425	if (R->units) {	14,607✔
426	ut_unit * from = ut_parse(get_unit_system(), R->units, UT_ASCII) ;	19✔
427	ut_unit * to = ut_parse(get_unit_system(), R->attr->units, UT_ASCII) ;	19✔
428	if ( !from or !to ) {	19✔
429	std::stringstream message;	×
430	message << "Can't convert \"" << R->units << "\" to \"" << R->attr->units << "\".";	×
431	emitError(message.str());	×
432	return TRICK_UNITS_CONVERSION_ERROR ;	×
433	}
434	cf = ut_get_converter(from,to) ;	19✔
435	if ( !cf ) {	19✔
436	std::stringstream message;	1✔
437	message << "Can't convert \"" << R->units << "\" to \"" << R->attr->units << "\".";	1✔
438	emitError(message.str());	1✔
439	return TRICK_UNITS_CONVERSION_ERROR ;	1✔
440	}
441	}
442
443	// R->num_index is badly named. It is really the current dimension
444	ret = assign_recursive( R->address, R->attr, R->num_index, 0, V, cf);	14,606✔
445	if ( cf ) cv_free(cf) ;	14,606✔
446
447	return ( ret);	14,606✔
448
449	}
450

nasa / trick / 15478949623

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous