X-Git-Url: https://gitweb.ps.run/toc/blobdiff_plain/c2ba7425955ae538e220cec79d9124756d1b4c8b..b9322dfb8efe37f6f88a899269bdf21015f4db9a:/src/find.h

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)