allow to set default group, cleanup, added support for overloaded procedures

[libt2n] / codegen / main.cpp

diff --git a/codegen/main.cpp b/codegen/main.cpp
index 0c60908..a023eaf 100644 (file)
--- a/codegen/main.cpp
+++ b/codegen/main.cpp
@@ -5,24 +5,24 @@
 #include <fstream>
 #include <list>
 
-void print_indentation(unsigned int indentation)
-{
-     for(unsigned int i = 0; i < indentation; ++i)
-         std::cout << " ";
-}
-
+//! convert string to upper case
 std::string
 toupper(std::string s) {
      for (unsigned i=0; i<s.length(); ++i) s[i]=toupper(s[i]);
      return s;
 }
 
+//! replace all characters f by r in string s
 std::string
 replace(std::string s, char f, char r) {
      for (unsigned i=0; i<s.length(); ++i) if (s[i]==f) s[i]=r;
      return s;
 }
 
+//! strip prefix from string s
+/*!
+  \return string s without prefix or an empty string on error
+ */
 std::string
 strip(std::string s, std::string prefix)
 {
@@ -31,6 +31,7 @@ strip(std::string s, std::string prefix)
      return std::string(s, prefix.length(), s.length()-prefix.length());
 }
 
+//! extract group from attributes
 std::string
 extract_group(const std::string &attrs)
 {
@@ -80,6 +81,27 @@ std::string get_namespace(const xmlpp::Element* root, const std::string &id)
      return element->get_attribute("name")->get_value();
 }
 
+//! get default group
+std::string get_default_group(const xmlpp::Element* root) {
+     std::string error;
+
+     if (   (root->get_attribute("name"))
+        && (root->get_attribute("attributes"))
+        && (root->get_name() == "Typedef")
+        && (root->get_attribute("name")->get_value()=="libt2n_default_group"))
+         return extract_group(root->get_attribute("attributes")->get_value());
+
+     //Recurse through child nodes:
+     xmlpp::Node::NodeList list = root->get_children();
+     for(xmlpp::Node::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter)
+     {
+         if (const xmlpp::Element* elem=dynamic_cast<const xmlpp::Element*>(*iter)) {
+              std::string ret(get_default_group(elem));
+              if (!ret.empty()) return ret;
+         }
+     }
+     return error;
+}
 
 struct type_info
 {
@@ -143,13 +165,14 @@ struct t2n_procedure
      std::string group;
      type_info ret_type;
      std::string name;
+     std::string mangled;
      Args  args;
 
      std::string ret_classname() const {
-         return name+"_res";
+         return name+mangled+"_res";
      }
      std::string cmd_classname() const {
-         return name+"_cmd";
+         return name+mangled+"_cmd";
      }
 };
 
@@ -196,8 +219,9 @@ protected:
 
          const xmlpp::Attribute* attributes = element->get_attribute("attributes");
          const xmlpp::Attribute* name = element->get_attribute("name");
+         const xmlpp::Attribute* mangled = element->get_attribute("mangled");
          const xmlpp::Attribute* returns = element->get_attribute("returns");
-         if ((!attributes)||(!name)||(!returns)) return;
+         if ((!attributes)||(!name)||(!mangled)||(!returns)) return;
 
          // check wether the procedure is marked (TODO: improve)
          // attributes are speparated by spaces?
@@ -206,10 +230,12 @@ protected:
          f.group=extract_group(attributes->get_value());
          if (f.group.empty()) return;
          // todo: handle default group
+         if (f.group=="default") f.group=get_default_group(root);
 
          // we need the return type
          f.ret_type=get_type(root, returns->get_value());
          f.name=name->get_value();
+         f.mangled=mangled->get_value();
 
          xmlpp::Node::NodeList list = node->get_children("Argument");
          for(xmlpp::Node::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter)
@@ -241,61 +267,8 @@ protected:
 
               if(!nodeText && !nodeComment && !nodename.empty()) //Let's not say "name: text".
               {
-                    //   print_indentation(indentation);
-                   //    std::cout << "Node name = " << node->get_name() << std::endl;
-                   //    std::cout << "Node name = " << nodename << std::endl;
-                   if (node->get_name() == "Function") {
-                        parse_function(root, node);
-                   }
-              }
-#if 0
-              else if(nodeText) //Let's say when it's text. - e.g. let's say what that white space is.
-              {
-                   print_indentation(indentation);
-                   std::cout << "Text Node" << std::endl;
-              }
-
-              //Treat the various node types differently: 
-              if(nodeText)
-              {
-                   print_indentation(indentation);
-                   std::cout << "text = \"" << nodeText->get_content() << "\"" << std::endl;
-              }
-              else if(nodeComment)
-              {
-                   print_indentation(indentation);
-                   std::cout << "comment = " << nodeComment->get_content() << std::endl;
-              }
-              else if(nodeContent)
-              {
-                   print_indentation(indentation);
-                   std::cout << "content = " << nodeContent->get_content() << std::endl;
-              }
-              else if(const xmlpp::Element* nodeElement = dynamic_cast<const xmlpp::Element*>(node))
-              {
-                   //A normal Element node:
-
-                   //line() works only for ElementNodes.
-                   print_indentation(indentation);
-                   std::cout << "     line = " << node->get_line() << std::endl;
-
-                   //Print attributes:
-                   const xmlpp::Element::AttributeList& attributes = nodeElement->get_attributes();
-                   for(xmlpp::Element::AttributeList::const_iterator iter = attributes.begin(); iter != attributes.end(); ++iter)
-                   {
-                        const xmlpp::Attribute* attribute = *iter;
-                        print_indentation(indentation);
-                        std::cout << "  Attribute " << attribute->get_name() << " = " << attribute->get_value() << std::endl;
-                   }
-
-                   const xmlpp::Attribute* attribute = nodeElement->get_attribute("title");
-                   if(attribute)
-                   {
-                        std::cout << "title found: =" << attribute->get_value() << std::endl;
-      
-                   }
+                   if (node->get_name() == "Function") parse_function(root, node);
               }
-#endif
               if(!nodeContent)
               {
                    //Recurse through child nodes: