GEEKING

IncludeChecker/Program.cs

@@ -0,0 +1,235 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+using System.Text.RegularExpressions;
+
+namespace IncludeChecker
+{
+    class Node
+    {
+        public string Name { get; set; }
+        private Node(string name)
+        {
+            Name = name.ToLower();
+            allNodes[Name] = this;
+        }
+
+        public static Node Get(string name)
+        {
+            name = name.ToLower();
+            return allNodes.ContainsKey(name) ? allNodes[name] : new Node(name);
+        }
+
+        public void AddInclude(string name)
+        {
+            name = name.ToLower();
+            includes.Add(Get(name));
+        }
+
+        public bool MayInclude(string name)
+        {
+            return MayInclude(name, new HashSet<Node>());
+        }
+
+        bool MayInclude(string name, HashSet<Node> visited)
+        {
+            if (visited.Contains(this))
+                return false;
+            visited.Add(this);
+
+            name = name.ToLower();
+
+            if (!allNodes.ContainsKey(name))
+                return false;
+
+            if (includes.Contains(allNodes[name]))
+                return true;
+
+            foreach (var node in includes)
+                if (node.MayInclude(name, visited))
+                    return true;
+
+            return false;
+        }
+
+        static Dictionary<string, Node> allNodes = new Dictionary<string, Node>();
+        HashSet<Node> includes = new HashSet<Node>();
+    }
+    class Program
+    {
+        static int errorCount = 0;
+        static int checkCount = 0;
+        static void DefineIncludes()
+        {
+            Node.Get("V8DataModel").AddInclude("V8World");  
+            Node.Get("V8DataModel").AddInclude("V8Tree");
+            Node.Get("V8DataModel").AddInclude("Network");
+            Node.Get("V8DataModel").AddInclude("gui");
+            Node.Get("V8DataModel").AddInclude("util");
+            Node.Get("V8DataModel").AddInclude("Tool");
+            Node.Get("V8DataModel").AddInclude("Humanoid");
+            Node.Get("V8DataModel").AddInclude("Script");
+
+            Node.Get("Darwin").AddInclude("V8DataModel");
+
+            Node.Get("src").AddInclude("script");
+
+            Node.Get("Humanoid").AddInclude("V8DataModel");
+            Node.Get("Lua").AddInclude("V8DataModel");
+
+            Node.Get("Script").AddInclude("LUa");
+
+            Node.Get("V8Tree").AddInclude("Reflection");
+            Node.Get("V8Tree").AddInclude("RBX/Intrusive");
+            
+            Node.Get("Reflection").AddInclude("Security");
+            Node.Get("Reflection").AddInclude("util");
+            Node.Get("Reflection").AddInclude("v8xml");
+
+            Node.Get("Darwin").AddInclude("rbx");
+            Node.Get("Darwin").AddInclude("util");
+
+            Node.Get("Security").AddInclude("rbx");
+
+            Node.Get("Tool").AddInclude("V8DataModel");
+
+            Node.Get("V8Kernel").AddInclude("util");
+
+            Node.Get("V8World").AddInclude("V8Kernel");
+            Node.Get("V8World").AddInclude("rbx");
+
+            Node.Get("V8Xml").AddInclude("Util");
+            Node.Get("V8Xml").AddInclude("Reflection");
+
+            Node.Get("util").AddInclude("rbx");
+            Node.Get("util").AddInclude("rbxg3d");
+
+            Node.Get("gui").AddInclude("Util");
+            Node.Get("gui").AddInclude("AppDraw");
+            Node.Get("gui").AddInclude("GfxBase");
+            Node.Get("gui").AddInclude("V8DataModel");
+        }
+        static void Main(string[] args)
+        {
+            DefineIncludes();
+            Console.WriteLine("Go!");
+            DirectoryInfo app = new DirectoryInfo(Directory.GetCurrentDirectory());
+            //Check(app.Parent.Parent.Parent.GetDirectories("Base")[0]);
+            Check(app.Parent.Parent.Parent.GetDirectories("App")[0]);
+            Console.WriteLine(errorCount + " errors out of " + checkCount);
+        }
+
+        private static void Check(DirectoryInfo dir)
+        {
+            foreach (var file in dir.GetFiles())
+                Check(file);
+            foreach (var d in dir.GetDirectories())
+                Check(d);
+        }
+
+        private static void Check(FileInfo file)
+        {
+            if (!IsCFile(file))
+                return;
+
+            var paths = GetIncludePaths(file);
+
+            foreach (var path in paths)
+                Check(file, path);
+
+        }
+
+        private static void Check(FileInfo file, string includePath)
+        {
+            checkCount++;
+
+            // Implement simple rules
+            if (includePath == "")
+                return;
+
+            if (includePath.ToLower() == "g3d")
+                return;
+            if (includePath.ToLower() == "corefoundation")
+                return;
+            if (includePath.StartsWith("boost"))
+                return;
+            if (includePath.StartsWith("mach-o"))
+                return;
+            if (includePath.StartsWith("readline"))
+                return;
+            if (includePath.Contains("fmod"))
+                return;
+            if (includePath.StartsWith("ext"))
+                return;
+            if (includePath.StartsWith("openssl"))
+                return;
+            if (includePath.ToLower() == "rbx/darwin")
+                return;
+            if (includePath.StartsWith("sys"))
+                return;
+            if (includePath.StartsWith("tbb"))
+                return;
+
+            string dir = file.Directory.Name;
+
+            if (dir.ToLower() == includePath.ToLower())
+                return;
+
+            Node node = Node.Get(file.Directory.Name);
+            if (!node.MayInclude(includePath))
+            {
+                Console.WriteLine(file.Directory.Name + "/" + file.Name + " " + includePath);
+                errorCount++;
+            }
+        }
+
+        private static HashSet<string> GetIncludePaths(FileInfo file)
+        {
+            var paths = new HashSet<string>();
+            using (StreamReader reader = new StreamReader(file.FullName))
+            {
+                while (!reader.EndOfStream)
+                {
+                    string line = reader.ReadLine().ToLower();
+                    TryMatch(paths, Regex.Match(line, @"#include ""(.+)"""));
+                    TryMatch(paths, Regex.Match(line, @"#include <(.+)>"));
+                }
+            }
+            return paths;
+        }
+
+        private static void TryMatch(HashSet<string> paths, Match match)
+        {
+            if (match.Groups.Count == 2)
+            {
+                string path = match.Groups[1].Value;
+                if (path.StartsWith("./"))
+                    path = path.Substring(2);
+                int index = path.LastIndexOf('/');
+                if (index > 0)
+                    paths.Add(path.Substring(0, index));
+                else
+                    paths.Add("");
+            }
+        }
+
+        private static bool IsCFile(FileInfo file)
+        {
+            if (file.Extension == ".cpp")
+                return true;
+            if (file.Extension == ".c")
+                return true;
+            if (file.Extension == ".h")
+                return true;
+            if (file.Extension == ".hpp")
+                return true;
+            if (file.Extension == ".inl")
+                return true;
+            if (file.Extension == ".cxx")
+                return true;
+            return false;
+        }
+    }
+}