14740747793

Committed 29 Apr 2025 08:30PM UTC coverage: 55.958% (-0.06%) from 56.017%

Build # 14740747793

Build Type

push

github

Committed by

web-flow

Commit Message

Fix several ICG class template bugs (#1871)

* Fix several bugs with processing templates in ICG

- Fixed an issue where io_src code for some templates was being placed in the
  wrong file.
- Fixed an issue with templates being instantiated with templates as parameters.
- Fixed an issue with templates that instantiate templates.

Added additional tests to cover these cases.

* Moved the list of template argument header dependencies from ClassValues to PrintFileContents10 so they can be printed to the io_ file regardless of the order in which class info is printed.

* Moved the list of template argument header dependencies from ClassValues to PrintFileContents10 so they can be printed to the io_ file regardless of the order in which class info is printed.

Moved the list of template argument header dependencies from ClassValues to PrintFileContents10 so they can be printed to the io_ file regardless of the order in which class info is printed.

* Added support to handle template enum class type argument and removed some commented code.

Added support to handle template enum class type argument and removed some commented code.

---------

Co-authored-by: Hong Chen <hchen99@users.noreply.github.com>

Run Details

12332 of 22038 relevant lines covered (55.96%)

266375.59 hits per line

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

78.79

/trick_source/sim_services/MemoryManager/MemoryManager_add_attr_info.cpp

#include <iostream>
#include <sstream>
#include <algorithm>
#include <dlfcn.h>

#ifdef __GNUC__
#include <cxxabi.h>
#endif

#include "trick/SimObject.hh"
#include "trick/MemoryManager.hh"

/**
 *
 */
int Trick::MemoryManager::add_attr_info( const std::string & user_type_string , ATTRIBUTES * attr , const char * file_name , unsigned int line_num ) {

    std::string user_type_name ;
    std::string sub_attr_name ;
    std::string enum_attr_name ;
    std::string sub_attr_init_name ;
    std::string size_func_name ;
    size_t spos ;
    ATTRIBUTES* sub_attr = NULL ;
    ENUM_ATTR* enum_attr = NULL ;
    void (*init_sub_attr)(void) = NULL ;
    size_t (*size_func)(void) = NULL ;
    unsigned int ii ;
    std::set<std::string>::iterator it ;

    /** @par Design Details: */

    user_type_name = user_type_string ;

    // Check if the type is a primitive type.  If so, we don't need to continue
    it = primitive_types.find(user_type_string) ;
    if ( it != primitive_types.end() ) {
        return 0 ;
    }

    // The user type name may start as const Foo<int>::Bar[4].  We need to convert that to Foo_int___Bar
    // remove const from the typename if it exists
    spos = user_type_name.find("const ") ;
    if ( spos != std::string::npos ) {
        user_type_name.erase( spos , spos + 6) ;
    }
    // remove any brackets
/*
    spos = user_type_name.find("[") ;
    if ( spos != std::string::npos ) {
        user_type_name.erase( spos ) ;
    }
*/
    // replace ":<>,*[]" with '_'
    std::replace( user_type_name.begin(), user_type_name.end(), ':', '_') ;
    std::replace( user_type_name.begin(), user_type_name.end(), '<', '_') ;
    std::replace( user_type_name.begin(), user_type_name.end(), '>', '_') ;
    std::replace( user_type_name.begin(), user_type_name.end(), ',', '_') ;
    std::replace( user_type_name.begin(), user_type_name.end(), '*', '_') ;
    std::replace( user_type_name.begin(), user_type_name.end(), '[', '_') ;
    std::replace( user_type_name.begin(), user_type_name.end(), ']', '_') ;
    // remove spaces
    user_type_name.erase(std::remove_if(user_type_name.begin(), user_type_name.end(), (int(*)(int))std::isspace), user_type_name.end()) ;

    // Attempt to find an io_src_sizeof function for the named user type.
    size_func_name = "io_src_sizeof_" + user_type_name ;
    for ( ii = 0 ; ii < dlhandles.size() && size_func == NULL ; ii++ ) {
        size_func     = (size_t (*)(void))dlsym( dlhandles[ii] , size_func_name.c_str()) ;
        if ( size_func != NULL ) {
            attr->size = (*size_func)() ;
        }
    }

    if ( size_func == NULL)  {
        std::stringstream message;
        message << "(" << file_name << ":" << line_num
            << "): Couldn't find an io_src_sizeof_ function for type "
            << user_type_string.c_str() << "[" << size_func_name.c_str() << "()].";
        emitWarning(message.str());
    }

    // Attempt to find an attributes list for the named user type.
    sub_attr_name = "attr" + user_type_name ;
    for ( ii = 0 ; ii < dlhandles.size() && sub_attr == NULL ; ii++ ) {
        sub_attr      = (ATTRIBUTES *)dlsym( dlhandles[ii] , sub_attr_name.c_str()) ;
    }

    if (sub_attr != NULL) {  // If attributes for the named type were found ...

        // Set type and attr of the ATTRIBUTES structure that we're populating.
        attr->type = TRICK_STRUCTURED ;
        attr->attr = sub_attr;

        // Attempt to find the initialization function for the attributes that we just found.
        sub_attr_init_name = "init_attr" + user_type_name + "_c_intf" ;

        for ( ii = 0 ; ii < dlhandles.size() && init_sub_attr == NULL ; ii++ ) {
            init_sub_attr = (void (*)(void))dlsym( dlhandles[ii] , sub_attr_init_name.c_str()) ;
        }

        if ( init_sub_attr != NULL ) {     // If the initialization function was found,
            (*init_sub_attr)() ;           // then call it.
        } else {
            std::stringstream message;
            message << " ATTRIBUTES init routine for type \""
                    << user_type_name.c_str() << "\" not found.";
            emitWarning(message.str());
            return(1) ;
        }

    } else { // The named user type isn't a structure type. Maybe it's an enumeration type.

        // Check to see whether the user type name is in the enumeration_map.
        ENUMERATION_MAP::iterator curr_pos = enumeration_map.find( user_type_name);

        // If it's not in the enumeration map then
        if (curr_pos == enumeration_map.end()) {

            // Construct the name of the enumeration attributes.
            enum_attr_name = "enum" + user_type_name ;

            // Attempt to find enumeration attributes for the named user type.
            for ( ii = 0 ; ii < dlhandles.size() && enum_attr == NULL ; ii++ ) {
                enum_attr = (ENUM_ATTR *)dlsym( dlhandles[ii] , enum_attr_name.c_str()) ;
            }

            // If enumeration attributes for the named type were found then
            if ( enum_attr != NULL ) {

                // Put them in the enumeration map.
                enumeration_map[ user_type_name] = enum_attr;

            // otherwise ...
            } else {
                std::stringstream message;
                message << "ATTRIBUTES for type \"" << user_type_name.c_str() << "\" not found.";
                emitWarning(message.str());
                return(1) ;
            }
        } else {
            enum_attr = curr_pos->second;
        }

        // Set the type information in the ATTRIBUTES structure that we are populating.
        attr->type = TRICK_ENUMERATED ;
        attr->attr = enum_attr;
    }
    return(0) ;
}


1	#include <iostream>
2	#include <sstream>
3	#include <algorithm>
4	#include <dlfcn.h>
5
6	#ifdef __GNUC__
7	#include <cxxabi.h>
8	#endif
9
10	#include "trick/SimObject.hh"
11	#include "trick/MemoryManager.hh"
12
13	/**
14	*
15	*/
16	int Trick::MemoryManager::add_attr_info( const std::string & user_type_string , ATTRIBUTES * attr , const char * file_name , unsigned int line_num ) {	32,528✔
17
18	std::string user_type_name ;	65,056✔
19	std::string sub_attr_name ;	65,056✔
20	std::string enum_attr_name ;	65,056✔
21	std::string sub_attr_init_name ;	65,056✔
22	std::string size_func_name ;	65,056✔
23	size_t spos ;
24	ATTRIBUTES* sub_attr = NULL ;	32,528✔
25	ENUM_ATTR* enum_attr = NULL ;	32,528✔
26	void (*init_sub_attr)(void) = NULL ;	32,528✔
27	size_t (*size_func)(void) = NULL ;	32,528✔
28	unsigned int ii ;
29	std::set<std::string>::iterator it ;	32,528✔
30
31	/** @par Design Details: */
32
33	user_type_name = user_type_string ;	32,528✔
34
35	// Check if the type is a primitive type. If so, we don't need to continue
36	it = primitive_types.find(user_type_string) ;	32,528✔
37	if ( it != primitive_types.end() ) {	32,528✔
38	return 0 ;	×
39	}
40
41	// The user type name may start as const Foo<int>::Bar[4]. We need to convert that to Foo_int___Bar
42	// remove const from the typename if it exists
43	spos = user_type_name.find("const ") ;	32,528✔
44	if ( spos != std::string::npos ) {	32,528✔
45	user_type_name.erase( spos , spos + 6) ;	×
46	}
47	// remove any brackets
48	/*
49	spos = user_type_name.find("[") ;
50	if ( spos != std::string::npos ) {
51	user_type_name.erase( spos ) ;
52	}
53	*/
54	// replace ":<>,*[]" with '_'
55	std::replace( user_type_name.begin(), user_type_name.end(), ':', '_') ;	32,528✔
56	std::replace( user_type_name.begin(), user_type_name.end(), '<', '_') ;	32,528✔
57	std::replace( user_type_name.begin(), user_type_name.end(), '>', '_') ;	32,528✔
58	std::replace( user_type_name.begin(), user_type_name.end(), ',', '_') ;	32,528✔
59	std::replace( user_type_name.begin(), user_type_name.end(), '*', '_') ;	32,528✔
60	std::replace( user_type_name.begin(), user_type_name.end(), '[', '_') ;	32,528✔
61	std::replace( user_type_name.begin(), user_type_name.end(), ']', '_') ;	32,528✔
62	// remove spaces
63	user_type_name.erase(std::remove_if(user_type_name.begin(), user_type_name.end(), (int(*)(int))std::isspace), user_type_name.end()) ;	32,528✔
64
65	// Attempt to find an io_src_sizeof function for the named user type.
66	size_func_name = "io_src_sizeof_" + user_type_name ;	32,528✔
67	for ( ii = 0 ; ii < dlhandles.size() && size_func == NULL ; ii++ ) {	65,056✔
68	size_func = (size_t (*)(void))dlsym( dlhandles[ii] , size_func_name.c_str()) ;	32,528✔
69	if ( size_func != NULL ) {	32,528✔
70	attr->size = (*size_func)() ;	32,528✔
71	}
72	}
73
74	if ( size_func == NULL) {	32,528✔
75	std::stringstream message;	×
76	message << "(" << file_name << ":" << line_num	×
77	<< "): Couldn't find an io_src_sizeof_ function for type "
78	<< user_type_string.c_str() << "[" << size_func_name.c_str() << "()].";	×
79	emitWarning(message.str());	×
80	}
81
82	// Attempt to find an attributes list for the named user type.
83	sub_attr_name = "attr" + user_type_name ;	32,528✔
84	for ( ii = 0 ; ii < dlhandles.size() && sub_attr == NULL ; ii++ ) {	65,056✔
85	sub_attr = (ATTRIBUTES *)dlsym( dlhandles[ii] , sub_attr_name.c_str()) ;	32,528✔
86	}
87
88	if (sub_attr != NULL) { // If attributes for the named type were found ...	32,528✔
89
90	// Set type and attr of the ATTRIBUTES structure that we're populating.
91	attr->type = TRICK_STRUCTURED ;	28,072✔
92	attr->attr = sub_attr;	28,072✔
93
94	// Attempt to find the initialization function for the attributes that we just found.
95	sub_attr_init_name = "init_attr" + user_type_name + "_c_intf" ;	28,072✔
96
97	for ( ii = 0 ; ii < dlhandles.size() && init_sub_attr == NULL ; ii++ ) {	56,144✔
98	init_sub_attr = (void (*)(void))dlsym( dlhandles[ii] , sub_attr_init_name.c_str()) ;	28,072✔
99	}
100
101	if ( init_sub_attr != NULL ) { // If the initialization function was found,	28,072✔
102	(*init_sub_attr)() ; // then call it.	28,072✔
103	} else {
104	std::stringstream message;	×
105	message << " ATTRIBUTES init routine for type \""
106	<< user_type_name.c_str() << "\" not found.";	×
107	emitWarning(message.str());	×
108	return(1) ;	×
109	}
110
111	} else { // The named user type isn't a structure type. Maybe it's an enumeration type.
112
113	// Check to see whether the user type name is in the enumeration_map.
114	ENUMERATION_MAP::iterator curr_pos = enumeration_map.find( user_type_name);	4,456✔
115
116	// If it's not in the enumeration map then
117	if (curr_pos == enumeration_map.end()) {	4,456✔
118
119	// Construct the name of the enumeration attributes.
120	enum_attr_name = "enum" + user_type_name ;	2,179✔
121
122	// Attempt to find enumeration attributes for the named user type.
123	for ( ii = 0 ; ii < dlhandles.size() && enum_attr == NULL ; ii++ ) {	4,358✔
124	enum_attr = (ENUM_ATTR *)dlsym( dlhandles[ii] , enum_attr_name.c_str()) ;	2,179✔
125	}
126
127	// If enumeration attributes for the named type were found then
128	if ( enum_attr != NULL ) {	2,179✔
129
130	// Put them in the enumeration map.
131	enumeration_map[ user_type_name] = enum_attr;	2,179✔
132
133	// otherwise ...
134	} else {
135	std::stringstream message;	×
136	message << "ATTRIBUTES for type \"" << user_type_name.c_str() << "\" not found.";	×
137	emitWarning(message.str());	×
138	return(1) ;	×
139	}
140	} else {
141	enum_attr = curr_pos->second;	2,277✔
142	}
143
144	// Set the type information in the ATTRIBUTES structure that we are populating.
145	attr->type = TRICK_ENUMERATED ;	4,456✔
146	attr->attr = enum_attr;	4,456✔
147	}
148	return(0) ;	32,528✔
149	}
150

nasa / trick / 14740747793

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