2010-06-21 Atsushi Enomoto <atsushi@ximian.com>

[mcs.git] / tools / ictool / ictool.cs

//
// file:        ictool.cs
// author:      Dan Lewis (dihlewis@yahoo.co.uk)
//              (C) 2002
//
// description:
//
// Tool for generating C prototypes and structures suitable for use by the runtime
// from a list of supplied assemblies. See ictool-config.xml for configuration details.
//

using System;
using System.IO;
using System.Xml;
using System.Reflection;
using System.Collections;

public class ICTool {
        public static void Main (string[] args) {
                string filename = "ictool-config.xml";
                if (args.Length == 1) {
                        filename = args[0];
                }
                else if (args.Length > 1) {
                        Console.Error.WriteLine ("Usage: ictool.exe [config.xml]");
                        Environment.Exit (-1);
                }

                try {
                        Stream config = File.OpenRead (filename);
                        Configure (config);
                }
                catch (Exception e) {
                        Console.Error.WriteLine ("Error: could not read configuration file.");
                        Console.Error.WriteLine (e);
                        Environment.Exit (-1);
                }

                EmitPrototypes ();
                EmitStructures ();
        }

        // private

        private static void EmitPrototypes () {
                StreamWriter methods_file = GetOutputFile ("methods");
                StreamWriter map_file = GetOutputFile ("map");

                // includes

                methods_file.WriteLine ("#include \"{0}\"\n", output_files["types"]);
                map_file.WriteLine ("#include \"{0}\"\n", output_files["methods"]);

                map_file.Write (
                        "static gpointer icall_map [] = {\n\t"
                );

                ArrayList map_lines = new ArrayList ();

                BindingFlags binding =
                        BindingFlags.DeclaredOnly |
                        BindingFlags.Instance |
                        BindingFlags.Static |
                        BindingFlags.Public |
                        BindingFlags.NonPublic;

                foreach (Type type in types.Values) {
                        bool has_icall = false;
                        MethodInfo[] methods = type.GetMethods (binding);

                        foreach (MethodInfo method in methods) {
                                if (IsInternalCall (method)) {
                                        has_icall = true;
                                        break;
                                }
                        }

                        if (!has_icall)
                                continue;

                        methods_file.WriteLine ("\n/* {0} */\n", type.FullName);
                        //map_lines.Add (String.Format ("\n/* {0} */\n", type.FullName));
                        
                        foreach (MethodInfo method in methods) {
                                if (!IsInternalCall (method))
                                        continue;

                                // function name

                                string func_name = String.Format ("ves_icall_{0}_{1}",
                                        
                                        type.FullName,
                                        method.Name
                                );

                                func_name = func_name.Replace ('.', '_');

                                // map file

                                map_lines.Add (String.Format (
                                        "\"{0}::{1}\", {2}",

                                        type.FullName.Replace ('.', '_'),
                                        method.Name,
                                        func_name
                                ));

                                // methods file

                                ArrayList args = new ArrayList ();

                                // FIXME: return types that are structs need to be inserted
                                // into the argument list as a destination pointer

                                // object/value instance pointer
                                
                                if (IsInstanceMethod (method)) {
                                        args.Add (String.Format (
                                                "{0}{1}",

                                                peer_map.GetPeer (method.DeclaringType).GetTypedef (1),
                                                "this"
                                        ));
                                }

                                // arguments

                                foreach (ParameterInfo param in method.GetParameters ()) {
                                        Type arg_type = param.ParameterType;

                                        int refs = 0;
                                        if (arg_type.IsByRef) {
                                                arg_type = arg_type.GetElementType ();
                                                ++ refs;
                                        }

                                        Peer arg_peer = peer_map.GetPeer (arg_type);
                                        if (!arg_peer.IsValueType)
                                                ++ refs;

                                        args.Add (String.Format ("{0}{1}", arg_peer.GetTypedef (refs), param.Name));
                                }

                                Peer ret = peer_map.GetPeer (method.ReturnType);
                                methods_file.WriteLine ("static {0}", ret.GetTypedef (ret.IsValueType ? 0 : 1));
                                methods_file.WriteLine ("{0} ({1});",
                                        
                                        func_name,
                                        Join (", ", args)
                                );
                                methods_file.WriteLine ();
                        }

                }

                methods_file.Close ();

                // write map file and close it

                map_file.Write (
                        "{0}\n}};\n", Join (",\n\t", map_lines)
                );

                map_file.Close ();
        }

        private static bool IsInternalCall (MethodInfo meth) {
                return (meth.GetMethodImplementationFlags () & MethodImplAttributes.InternalCall) != 0;
        }

        private static bool IsInstanceMethod (MethodInfo meth) {
                return (meth.CallingConvention & CallingConventions.HasThis) != 0;
        }

        private static void EmitStructures () {
                StreamWriter file = GetOutputFile ("types");

                // build dependency graph
                
                DependencyGraph dg = new DependencyGraph ();
                foreach (Peer peer in peer_map.Peers) {
                        dg.AddNode (peer);

                        // peer depends on nearest base

                        if (peer.NearestBase != null)
                                dg.AddEdge (peer.NearestBase, peer);

                        // peer depends on any value types used for fields

                        foreach (PeerField field in peer.Fields) {
                                if (field.Peer.IsValueType)
                                        dg.AddEdge (field.Peer, peer);
                        }
                }

                // write structures in order

                foreach (Peer peer in dg.TopologicalSort ()) {
                        if (peer.IsOpaque)
                                continue;

                        if (peer.IsEnum) {
                                file.WriteLine ("typedef {0} {1};", peer.UnderlyingPeer.Name, peer.Name);
                                file.WriteLine ("enum _{0} {{", peer.Name);

                                ArrayList enum_lines = new ArrayList ();
                                foreach (string name in peer.EnumConstants.Keys) {
                                        enum_lines.Add (String.Format ("\t{0}_{1} = {2}",
                                                peer.Name,
                                                name,
                                                peer.EnumConstants[name]
                                        ));
                                }
                                
                                file.WriteLine ("{0}\n}};\n", Join (",\n", enum_lines));
                        }
                        else {
                                file.WriteLine ("typedef struct _{0} {{", peer.Name);

                                // base type
                                
                                if (peer.NearestBase != null) {
                                        file.WriteLine ("\t{0} __base;", peer.NearestBase.Name);
                                        file.WriteLine ();
                                }

                                // fields
                                
                                foreach (PeerField field in peer.Fields) {
                                        bool use_struct = true;
                                        if (field.Peer.IsValueType || field.Peer.IsOpaque)
                                                use_struct = false;
                                
                                        file.WriteLine ("\t{0}{1}{2};",
                                                use_struct ? "struct _" : "",
                                                field.Peer.GetTypedef (field.Peer.IsValueType ? 0 : 1),
                                                field.Name
                                        );
                                }

                                file.WriteLine ("}} {0};\n", peer.Name);
                        }
                }
        }

        private static void LoadAssemblies () {
                types = new Hashtable ();

                foreach (string filename in assemblies) {
                        Assembly assembly;

                        // find assembly

                        FileInfo info = null;
                        foreach (string path in assembly_paths) {
                                info = new FileInfo (Path.Combine (path, filename));
                                if (info.Exists)
                                        break;
                        }

                        if (!info.Exists) {
                                Console.Error.WriteLine ("Error: assembly {0} not found.", filename);
                                Environment.Exit (-1);
                        }

                        // load assembly

                        assembly = Assembly.LoadFrom (info.FullName);

                        // load types

                        ArrayList loaded_types;
                        
                        try {
                                loaded_types = new ArrayList (assembly.GetTypes ());
                        }
                        catch (ReflectionTypeLoadException e) {
                                loaded_types = new ArrayList ();
                                foreach (Type type in e.Types) {
                                        if (type != null)
                                                loaded_types.Add (type);
                                }

                                foreach (Exception f in e.LoaderExceptions) {
                                        if (f is TypeLoadException) {
                                                Console.Error.WriteLine ("Warning: {0} could not be loaded from assembly {1}.",
                                                        ((TypeLoadException)f).TypeName,
                                                        filename
                                                );
                                        }
                                        else
                                                Console.Error.WriteLine (f);
                                }
                        }

                        // add to type dictionary

                        foreach (Type type in loaded_types) {
                                if (!types.Contains (type.FullName))
                                        types.Add (type.FullName, type);
                        }
                }
        }

        private static void Configure (Stream input) {
                XmlDocument doc = new XmlDocument ();
                doc.Load (input);

                // assemblies

                assembly_paths = new ArrayList ();
                assembly_paths.Add (".");

                foreach (XmlNode node in doc.SelectNodes ("config/assemblypath")) {
                        assembly_paths.Add (node.Attributes["path"].Value);
                }

                assemblies = new ArrayList ();
                foreach (XmlNode node in doc.SelectNodes ("config/assembly")) {
                        assemblies.Add (node.Attributes["file"].Value);
                }

                LoadAssemblies ();

                // outputfiles

                output_path = ".";
                XmlNode path_node = doc.SelectSingleNode ("config/outputpath");
                if (path_node != null)
                        output_path = path_node.Attributes["path"].Value;

                output_files = new Hashtable ();
                output_includes = new Hashtable ();
                foreach (XmlNode node in doc.SelectNodes ("config/outputfile")) {
                        string name = node.Attributes["name"].Value;
                        output_files.Add (name, node.Attributes["file"].Value);

                        foreach (XmlNode child in node.ChildNodes) {
                                if (child.Name == "include")
                                        output_includes[name] = child.InnerText;
                        }
                }

                // typemap

                peer_map = new PeerMap ();
                foreach (XmlNode node in doc.SelectNodes ("config/typemap/namespace")) {
                        string ns = node.Attributes["name"].Value;

                        foreach (XmlNode child in node.ChildNodes) {
                                if (child.Name == "type") {
                                        string name = child.Attributes["name"].Value;
                                        string peer_name = child.Attributes["peer"].Value;

                                        bool opaque = false;
                                        if (child.Attributes["opaque"] != null && child.Attributes["opaque"].Value == "true")
                                                opaque = true;

                                        String fullname = String.Format ("{0}.{1}", ns, name);
                                        
                                        Type type;
                                        if (child.Attributes["default"] != null && child.Attributes["default"].Value == "true")
                                                type = Type.GetType (fullname);
                                        else
                                                type = (Type)types [fullname];

                                        if (type != null)
                                                peer_map.Add (new Peer (type, peer_name, opaque));
                                }
                        }
                }

                peer_map.ResolvePeers ();
        }

        private static StreamWriter GetOutputFile (string name) {
                string filename = Path.Combine (output_path, (string)output_files[name]);
                StreamWriter file = File.CreateText (filename);
                file.AutoFlush = true;

                file.Write (

// (verbatim string)
                
@"/**
 *  {0}
 *
 *  This file was automatically generated on {1} by ictool.exe from
 *  the following assemblies:
 *    {2}
 */
 
",

                        output_files[name],
                        DateTime.Now.ToString ("d"),
                        Join (", ", assemblies)
                );

                if (output_includes.Contains (name)) {
                        file.WriteLine (output_includes [name]);
                        file.WriteLine ();
                }

                return file;
        }

        private static string Join (string separator, ICollection values) {
                // note to microsoft: please implement this in String :)

                string[] strs = new string[values.Count];

                int i = 0;
                foreach (object value in values)
                        strs[i ++] = value.ToString ();

                return String.Join (separator, strs);
        }
        
        private static ArrayList assembly_paths;
        private static ArrayList assemblies;
        private static string output_path;
        private static Hashtable output_files;
        private static Hashtable output_includes;
        private static PeerMap peer_map;
        private static Hashtable types;
}