private void ParseHeaderFile(FileInfo m, string filename, Metadata metadata)
        {
            string className = filename.Substring(0, filename.Length - 2);
            metadata.ClassName = className;
            Console.WriteLine("Parsing header file, classname: " + className);
            string headerPath = Path.Combine(m.DirectoryName, className + ".h");

            if (!File.Exists(headerPath))
            {
                Console.WriteLine("Header file is missing - " + headerPath);
                return;
            }

            string text = File.ReadAllText(headerPath);

            var enumMatches = Regex.Matches(text, @"typedef enum \{([^\}]*?)\}(.*?);");

            foreach (Match match in enumMatches)
            {
                var e = new Enumeration();

                string enumName = match.Groups[2].Value.Trim();
                if (enumName.StartsWith(className, StringComparison.OrdinalIgnoreCase))
                    enumName = enumName.Substring(className.Length);

                string enumBody = match.Groups[1].Value;
                foreach (string line in enumBody.Split('\n'))
                {
                    string l = line.Trim();
                    if (string.IsNullOrEmpty(l))
                        continue;

                    if (l.StartsWith(className + enumName))
                        l = l.Substring(className.Length + enumName.Length);

                    e.Options.Add(l);
                }

                e.ClassName = className;
                e.Name = enumName;
                metadata.Enums.Add(e);
            }

            var defineMatches = Regex.Matches(text, "^#define.*?$", RegexOptions.Multiline);
            foreach (Match match in defineMatches)
                metadata.Defines.Add(ReplaceDefineStatements(match.Value));
        }
        private string TransformM(string text, Metadata metadata)
        {
            foreach (var e in metadata.Enums)
            {
                foreach (string option in e.Options)
                {
                    string optionCleaned = option;
                    int i = option.IndexOf(" ");
                    if (i != -1)
                        optionCleaned = option.Substring(0, i);

                    optionCleaned = optionCleaned.Trim(',');

                    string token = e.ClassName + e.Name + optionCleaned;

                    text = text.Replace(token, e.Name + "." + optionCleaned);
                }
            }

            text = ParseImpl(text);

            return text;
        }
        private Metadata TransformFile(string filePath, string outputDir, Metadata metadata)
        {
            var f = new FileInfo(filePath);

            string filename = f.Name;

            if (!filename.EndsWith(".m"))
                throw new InvalidOperationException("Only supports .m files");

            if (metadata == null)
                metadata = new Metadata();

            ParseHeaderFile(f, filename, metadata);

            string result = "";

            foreach (string define in metadata.Defines)
                result += define + Environment.NewLine;

            foreach (var e in metadata.Enums.Where(enu => enu.ClassName == metadata.ClassName))
            {
                result += string.Format(
@"public enum {0} 
{{
    {1}
}}

",
   e.Name, e.Options.JoinStrings("\r\n\t"));
            }

            string text = File.ReadAllText(filePath);
            text = TransformM(text, metadata);
            result += text;
            File.WriteAllText(@"C:\Users\jivko\Downloads\" + metadata.ClassName + ".cs", result);

            return metadata;
        }