#include <iostream>
#include <set>
#include <fstream>
+#include <list>
void print_indentation(unsigned int indentation)
{
std::string name;
std::string noref_name;
bool operator==(const type_info& o) {return (name==o.name) && (noref_name == o.noref_name);}
- std::string noref() const {return noref_name;}
+ std::string noref() const {return noref_name.empty() ? name : noref_name;}
};
std::ostream &operator<<(std::ostream &o, const type_info &t) {
// if we recurse - when do we stop?
// if it is a typedef? yes? (hmm if the typedef is in the file parsed this will not work)
- // TODO: const and reference types (perhaps it is good enough to remove the const and &?)
- // non-const reference types/pointers (output error message? not yet supported)
+ // TODO: const and reference types handling is a ugly hack
std::string tag(element->get_name());
if (tag=="ReferenceType") {
}
assert(element->get_attribute("name"));
- assert(element->get_attribute("context"));
type_info ret;
- ret.name=get_namespace(root, element->get_attribute("context")->get_value())+"::"+element->get_attribute("name")->get_value();
+ if (element->get_attribute("context"))
+ ret.name=get_namespace(root, element->get_attribute("context")->get_value())+"::";
+ ret.name+=element->get_attribute("name")->get_value();
return ret;
}
struct t2n_procedure
{
- typedef std::map<std::string, type_info> Args;
+ typedef std::list<std::pair<std::string, type_info> > Args;
std::string group;
type_info ret_type;
assert(arg->get_name() == "Argument");
assert(arg->get_attribute("name"));
assert(arg->get_attribute("type"));
- assert(f.args.find(arg->get_attribute("name")->get_value())==f.args.end());
- f.args[arg->get_attribute("name")->get_value()]=get_type(root, arg->get_attribute("type")->get_value());
+ f.args.push_back(std::pair<std::string, type_info>(arg->get_attribute("name")->get_value(), get_type(root, arg->get_attribute("type")->get_value())));
}
}
+ std::cerr << "Found function: " << f << std::endl;
m_procedures.push_back(f);
}