generic functions and structs

1 files changed, 109 insertions, 2 deletions

diff --git a/src/find.h b/src/find.h
index 1876a1e..fec540f 100644
--- a/src/find.h
+++ b/src/find.h
@@ -18,6 +18,15 @@ opt<T> find(const std::vector<T> & ts, std::function<bool(T)> f)
   return nullopt;

 }

 

+template<typename T>

+opt<T *> findPtr(const std::vector<T> & ts, std::function<bool(T)> f)

+{

+  for (int i = 0; i < ts.size(); i++)

+    if (f(ts[i]))

+      return &((T *)ts.data())[i];

+  return nullopt;

+}

+

 opt<Function> findFunction(

   const Program & p,

   const std::string & name,

@@ -55,6 +64,43 @@ opt<Function> findFunction(
   return find<Function>(p.functions, [&](Function f) { return f.name == name; });

 }

 

+opt<Function *> findFunctionPtr(

+  const Program & p,

+  const std::string & name,

+  const std::vector<std::string> & namespacePrefixes)

+{

+  if (namespacePrefixes.empty())

+  {

+    return findPtr<Function>(p.functions, [&](Function f) { return f.name == name; });

+  }

+  

+  auto n = find<Namespace>(p.namespaces, [&](Namespace n) { return n.name == namespacePrefixes[0]; });

+

+  if (!n.has_value())

+    return nullopt;

+

+  std::vector<Namespace> namespaces = { n.value() };

+

+  for (int i = 1; i < namespacePrefixes.size(); i++)

+  {

+    n = find<Namespace>(n.value().namespaces, [&](Namespace n) { return n.name == namespacePrefixes[i]; });

+    

+    if (!n.has_value())

+      return nullopt;

+

+    namespaces.push_back(n.value());

+  }

+

+  for (int i = namespaces.size()-1; i >= 0; i--)

+  {

+    auto f = findPtr<Function>(namespaces[i].functions, [&](Function f) { return f.name == name; });

+    if (f.has_value())

+      return f.value();

+  }

+

+  return findPtr<Function>(p.functions, [&](Function f) { return f.name == name; });

+}

+

 opt<Struct> findStruct(

   const Program & p,

   const std::string & name,

@@ -69,6 +115,8 @@ opt<Struct> findStruct(
   

   if (!n.has_value())

     return nullopt;

+

+  std::vector<Namespace> namespaces = { n.value() };

     

   for (int i = 1; i < namespacePrefixes.size(); i++)

   {

@@ -76,10 +124,57 @@ opt<Struct> findStruct(
 

     if (!n.has_value())

       return nullopt;

+

+    namespaces.push_back(n.value());

+  }

+

+  for (int i = namespaces.size()-1; i >= 0; i--)

+  {

+    auto f = find<Struct>(namespaces[i].structs, [&](Struct f) { return f.name == name; });

+    if (f.has_value())

+      return f.value();

   }

+

   return find<Struct>(n.value().structs, [&](Struct s) { return s.name == name; });

 }

 

+opt<Struct *> findStructPtr(

+  const Program & p,

+  const std::string & name,

+  const std::vector<std::string> & namespacePrefixes)

+{

+  if (namespacePrefixes.empty())

+  {

+    return findPtr<Struct>(p.structs, [&](Struct s) { return s.name == name; });

+  }

+  

+  auto n = find<Namespace>(p.namespaces, [&](Namespace n) { return n.name == namespacePrefixes[0]; });

+  

+  if (!n.has_value())

+    return nullopt;

+

+  std::vector<Namespace> namespaces = { n.value() };

+    

+  for (int i = 1; i < namespacePrefixes.size(); i++)

+  {

+    n = find<Namespace>(n.value().namespaces, [&](Namespace n) { return n.name == namespacePrefixes[i]; });

+

+    if (!n.has_value())

+      return nullopt;

+

+    namespaces.push_back(n.value());

+  }

+

+  for (int i = namespaces.size()-1; i >= 0; i--)

+  {

+    auto f = findPtr<Struct>(namespaces[i].structs, [&](Struct f) { return f.name == name; });

+    if (f.has_value())

+      return f.value();

+  }

+

+  return findPtr<Struct>(n.value().structs, [&](Struct s) { return s.name == name; });

+}

+

 opt<Variable> findVariable(

   const Program & p,

   const std::string & name,

@@ -96,7 +191,7 @@ opt<Variable> findVariable(
   return nullopt;

 }

 

-opt<Function> findStructMethod(

+opt<StructMember<Function>> findStructMethod(

   const Program & p,

   const std::string & name,

   TypeInfo ti)

@@ -108,8 +203,20 @@ opt<Function> findStructMethod(
     return nullopt;

   return find<StructMember<Function>>(s.value().methods, [&](Function f) { return f.name == name; });

 }

+opt<StructMember<Function> *> findStructMethodPtr(

+  const Program & p,

+  const std::string & name,

+  TypeInfo ti)

+{

+  if (!ti.isStruct)

+    return nullopt;

+  auto s = findStruct(p, ti.type.name, ti.type.namespacePrefixes);

+  if (!s.has_value())

+    return nullopt;

+  return findPtr<StructMember<Function>>(s.value().methods, [&](Function f) { return f.name == name; });

+}

 

-opt<Variable> findStructMember(

+opt<StructMember<Variable>> findStructMember(

   const Program & p,

   TypeInfo ti,

   const std::string & name)