X-Git-Url: http://developer.intra2net.com/git/?p=libt2n;a=blobdiff_plain;f=codegen%2Fmain.cpp;h=a023eaf2e1bbadd706956cb2e5e36932197aafdb;hp=6cf197e748e146de9d85629a0c20998db76d0090;hb=52b6f93ade9aebf4d3313a7b5fc2b63a0cc68c3d;hpb=e035276bf0ac5abea21a0aafc6d05e7746e902d1

diff --git a/codegen/main.cpp b/codegen/main.cpp
index 6cf197e..a023eaf 100644
--- a/codegen/main.cpp
+++ b/codegen/main.cpp
@@ -3,25 +3,26 @@
 #include <iostream>
 #include <set>
 #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)
 {
@@ -30,6 +31,21 @@ 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)
+{
+     // todo: improve this
+     std::string error;
+     std::string to_match("gccxml(libt2n-");
+     std::string::size_type p(attrs.find(to_match));
+     if (p==std::string::npos) return error;
+     std::string group(attrs, p+to_match.length(), attrs.length());
+     p=group.find_first_of(')');
+     assert(p!=std::string::npos);
+     return std::string(group,0,p);
+}
+
 //! get child element by id
 /*!
   \return pointer to element having id or null on error
@@ -65,13 +81,34 @@ 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
 {
      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) {
@@ -93,8 +130,7 @@ type_info get_type(const xmlpp::Element* root, const std::string &id)
      // 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") {
@@ -115,26 +151,28 @@ type_info get_type(const xmlpp::Element* root, const std::string &id)
      }
 
      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;
      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";
      }
 };
 
@@ -181,21 +219,23 @@ 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?
-	  if (attributes->get_value().find("gccxml(libt2n")==std::string::npos) return;
 
-	  // TODO: extract command group
-	  // something like: sed 's,gccxml(libt2n-\([a-z]*}),\1,'
 	  t2n_procedure f;
-	  f.group=("default");
+	  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)
@@ -205,10 +245,10 @@ protected:
 		    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);
      }
 
@@ -227,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: