Add the clang library to the repo (with some of my changes, too).

1 files changed, 168 insertions, 0 deletions

diff --git a/clang/include/clang/Analysis/Analyses/IntervalSolver/Operator.hpp b/clang/include/clang/Analysis/Analyses/IntervalSolver/Operator.hpp
new file mode 100644
index 0000000..b67591f
--- /dev/null
+++ b/clang/include/clang/Analysis/Analyses/IntervalSolver/Operator.hpp
@@ -0,0 +1,168 @@
+#ifndef OPERATOR_HPP
+#define OPERATOR_HPP
+
+#include <vector>
+
+template<typename Domain>
+struct Operator {
+  virtual ~Operator() { }
+
+  virtual Domain eval(const std::vector<Domain>&) const = 0;
+
+  virtual void print(std::ostream&) const = 0;
+};
+
+template<typename Domain>
+struct Maximum : public Operator<Domain> {
+  virtual Domain eval(const std::vector<Domain>& arguments) const {
+    Domain result = -infinity<Domain>();
+    for (typename std::vector<Domain>::const_iterator it = arguments.begin();
+         it != arguments.end();
+         ++it) {
+      result = (result < *it ? *it : result);
+    }
+    return result;
+  }
+  void print(std::ostream& cout) const {
+    cout << "max";
+  }
+};
+
+template<typename Domain>
+struct Minimum : public Operator<Domain> {
+  virtual Domain eval(const std::vector<Domain>& arguments) const {
+    Domain result = infinity<Domain>();
+    for (typename std::vector<Domain>::const_iterator it = arguments.begin();
+         it != arguments.end();
+         ++it) {
+      result = (*it < result ? *it : result);
+    }
+    return result;
+  }
+  void print(std::ostream& cout) const {
+    cout << "min";
+  }
+};
+
+template<typename Domain>
+struct Negation : public Operator<Domain> {
+  virtual Domain eval(const std::vector<Domain>& arguments) const {
+    if (arguments.size() > 1)
+      throw "Too many arguments to a negation.";
+    return -arguments[0];
+  }
+  void print(std::ostream& cout) const {
+    cout << "-";
+  }
+};
+
+template<typename Domain>
+struct Addition : public Operator<Domain> {
+  virtual Domain eval(const std::vector<Domain>& arguments) const {
+    Domain result = 0;
+    for (typename std::vector<Domain>::const_iterator it = arguments.begin();
+         it != arguments.end();
+         ++it) {
+      result += *it;
+    }
+    return result;
+  }
+  void print(std::ostream& cout) const {
+    cout << "add";
+  }
+};
+
+template<typename Domain>
+struct Subtraction : public Operator<Domain> {
+  virtual Domain eval(const std::vector<Domain>& arguments) const {
+    Domain result = 0;
+    for (typename std::vector<Domain>::const_iterator it = arguments.begin();
+         it != arguments.end();
+         ++it) {
+      if (it == arguments.begin())
+        result = *it;
+      else
+        result -= *it;
+    }
+    return result;
+  }
+  void print(std::ostream& cout) const {
+    cout << "sub";
+  }
+};
+
+template<typename Domain>
+struct Multiplication : public Operator<Domain> {
+  virtual Domain eval(const std::vector<Domain>& arguments) const {
+    Domain result = 1;
+    for (typename std::vector<Domain>::const_iterator it = arguments.begin(),
+           end = arguments.end();
+         it != end;
+         ++it) {
+      result *= *it;
+    }
+    return result;
+  }
+  void print(std::ostream& cout) const {
+    cout << "mult";
+  }
+};
+
+template<typename Domain>
+struct Comma : public Operator<Domain> {
+  virtual Domain eval(const std::vector<Domain>& arguments) const {
+    if (arguments[0] == -infinity<Domain>()) {
+      return -infinity<Domain>();
+    }
+    return arguments[1];
+  }
+  void print(std::ostream& cout) const {
+    cout << "comma";
+  }
+};
+
+template<typename Domain>
+struct Guard : public Operator<Domain> {
+  virtual Domain eval(const std::vector<Domain>& arguments) const {
+    Domain result = arguments[2];
+    if (arguments[0] < arguments[1]) {
+      result = -infinity<Domain>();
+    }
+    return result;
+  }
+  void print(std::ostream& cout) const {
+    cout << "guard";
+  }
+};
+
+/*#include "TemplateConstraintMatrix.hpp"
+
+template<typename Domain>
+struct MinimumCostFlow : public Operator<Domain> {
+  MinimumCostFlow() {
+  }
+  Domain solve(const Domain& d) const {
+  
+  }
+  virtual Domain eval(const std::vector<Domain>& arguments) const {
+    if (arguments.size() != 1)
+      throw "Incorrect number of arguments.";
+    return solve(arguments[0]);
+  }
+  void print(std::ostream& cout) const {
+    cout << "minCostFlow";
+  }
+private:
+  TemplateConstraintMatrix& constraint; // T
+  std::vector<Domain> guard; // c
+  std::vector<std::vector<Domain>> multiplication; //A
+  unsigned int row;
+};*/
+
+template<typename T>
+std::ostream& operator<<(std::ostream& cout, const Operator<T>& op) {
+  op.print(cout);
+  return cout;
+}
+
+#endif