BakeSharp.cs

using System;
using System.Runtime.InteropServices;
using SharpC;

namespace BakeSharp
{
#region Enums
    //kind
    public enum Kind : Int32
    {
        BOOLEAN = 0,
        STRING = 1,
        NUMBER = 2,
        ARRAY = 3,
    }

#endregion

#region Structs
    //bake_attr
    unsafe partial struct BakeAttr
    {
        internal Data* ptr;
        internal BakeAttr(Data* ptr) => this.ptr = ptr;
        [StructLayout(LayoutKind.Sequential)]
        internal unsafe struct Data
        {
            public static implicit operator BakeAttr(Data data) => data.Ptr();
            public static implicit operator Data(BakeAttr _ref) => *_ref.ptr;
            public BakeAttr Ptr() { fixed(Data* ptr = &this) return new BakeAttr(ptr); }
            internal byte* name;
            internal Kind kind;
            internal bool boolean;
            internal byte* @string;
            internal double number;
            internal int array;
            internal bool boolean;
            internal byte* @string;
            internal double number;
            internal int array;
            internal Is @is;
        }

    }

    //bake_driver
    unsafe partial struct BakeDriver
    {
        internal Data* ptr;
        internal BakeDriver(Data* ptr) => this.ptr = ptr;
        [StructLayout(LayoutKind.Sequential)]
        internal unsafe struct Data
        {
            public static implicit operator BakeDriver(Data data) => data.Ptr();
            public static implicit operator Data(BakeDriver _ref) => *_ref.ptr;
            public BakeDriver Ptr() { fixed(Data* ptr = &this) return new BakeDriver(ptr); }
            internal byte* id;
            internal byte* packageId;
            internal int dl;
            internal int nodes;
            internal int ignorePaths;
            internal int error;
            internal Impl.Data impl;
        }

    }

    //impl
    unsafe partial struct Impl
    {
        internal Data* ptr;
        internal Impl(Data* ptr) => this.ptr = ptr;
        [StructLayout(LayoutKind.Sequential)]
        internal unsafe struct Data
        {
            public static implicit operator Impl(Data data) => data.Ptr();
            public static implicit operator Data(Impl _ref) => *_ref.ptr;
            public Impl Ptr() { fixed(Data* ptr = &this) return new Impl(ptr); }
            internal int init;
            internal int artefact;
            internal int linkToLib;
            internal int setup;
            internal int generate;
            internal int prebuild;
            internal int build;
            internal int postbuild;
            internal int clean;
        }

    }

    //bake_filelist
    unsafe partial struct BakeFilelist
    {
        internal Data* ptr;
        internal BakeFilelist(Data* ptr) => this.ptr = ptr;
        [StructLayout(LayoutKind.Sequential)]
        internal unsafe struct Data
        {
            public static implicit operator BakeFilelist(Data data) => data.Ptr();
            public static implicit operator Data(BakeFilelist _ref) => *_ref.ptr;
            public BakeFilelist Ptr() { fixed(Data* ptr = &this) return new BakeFilelist(ptr); }
            internal byte* path;
            internal byte* pattern;
            internal int files;
            internal IntPtr _@set;
        }

    }

    //bake_file
    unsafe partial struct BakeFile
    {
        internal Data* ptr;
        internal BakeFile(Data* ptr) => this.ptr = ptr;
        [StructLayout(LayoutKind.Sequential)]
        internal unsafe struct Data
        {
            public static implicit operator BakeFile(Data data) => data.Ptr();
            public static implicit operator Data(BakeFile _ref) => *_ref.ptr;
            public BakeFile Ptr() { fixed(Data* ptr = &this) return new BakeFile(ptr); }
            internal byte* path;
            internal byte* name;
            internal byte* filePath;
            internal int timestamp;
        }

    }

    //bake_node
    unsafe partial struct BakeNode
    {
        internal Data* ptr;
        internal BakeNode(Data* ptr) => this.ptr = ptr;
        [StructLayout(LayoutKind.Sequential)]
        internal unsafe struct Data
        {
            public static implicit operator BakeNode(Data data) => data.Ptr();
            public static implicit operator Data(BakeNode _ref) => *_ref.ptr;
            public BakeNode Ptr() { fixed(Data* ptr = &this) return new BakeNode(ptr); }
            internal int kind;
            internal readonly CharPtr name;
            internal int deps;
            internal int cond;
        }

    }

    //bake_pattern
    unsafe partial struct BakePattern
    {
        internal Data* ptr;
        internal BakePattern(Data* ptr) => this.ptr = ptr;
        [StructLayout(LayoutKind.Sequential)]
        internal unsafe struct Data
        {
            public static implicit operator BakePattern(Data data) => data.Ptr();
            public static implicit operator Data(BakePattern _ref) => *_ref.ptr;
            public BakePattern Ptr() { fixed(Data* ptr = &this) return new BakePattern(ptr); }
            internal BakeNode.Data super;
            internal readonly CharPtr pattern;
        }

    }

    //bake_rule
    unsafe partial struct BakeRule
    {
        internal Data* ptr;
        internal BakeRule(Data* ptr) => this.ptr = ptr;
        [StructLayout(LayoutKind.Sequential)]
        internal unsafe struct Data
        {
            public static implicit operator BakeRule(Data data) => data.Ptr();
            public static implicit operator Data(BakeRule _ref) => *_ref.ptr;
            public BakeRule Ptr() { fixed(Data* ptr = &this) return new BakeRule(ptr); }
            internal BakeNode.Data super;
            internal readonly CharPtr source;
            internal int target;
            internal int action;
        }

    }

    //bake_dependency_rule
    unsafe partial struct BakeDependencyRule
    {
        internal Data* ptr;
        internal BakeDependencyRule(Data* ptr) => this.ptr = ptr;
        [StructLayout(LayoutKind.Sequential)]
        internal unsafe struct Data
        {
            public static implicit operator BakeDependencyRule(Data data) => data.Ptr();
            public static implicit operator Data(BakeDependencyRule _ref) => *_ref.ptr;
            public BakeDependencyRule Ptr() { fixed(Data* ptr = &this) return new BakeDependencyRule(ptr); }
            internal BakeNode.Data super;
            internal int target;
            internal readonly CharPtr deps;
            internal int action;
        }

    }

#endregion

#region OpaquePtrs
    //bake_config
    unsafe partial struct BakeConfig
    {
        IntPtr ptr;
        public BakeConfig(IntPtr ptr) => this.ptr = ptr;
        internal BakeConfig* Ptr => (BakeConfig*) ptr;
    }

    //bake_project
    unsafe partial struct BakeProject
    {
        IntPtr ptr;
        public BakeProject(IntPtr ptr) => this.ptr = ptr;
        internal BakeProject* Ptr => (BakeProject*) ptr;
    }

#endregion

#region Delegates
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    internal unsafe delegate int SetDelegate();

#endregion

#region Unions
    [StructLayout(LayoutKind.Explicit)]
    public unsafe partial struct is
    {
         [FieldOffset(0)]
        internal bool boolean;
         [FieldOffset(0)]
        internal byte* @string;
         [FieldOffset(0)]
        internal double number;
         [FieldOffset(0)]
        internal int array;
    }

#endregion

    internal unsafe static partial class bake
    {
        [DllImport(DLL, EntryPoint = "bake_attr_get", CallingConvention=CallingConvention.Cdecl)]
        public static extern BakeAttr attr_get(int attributes, CharPtr name);

        [DllImport(DLL, EntryPoint = "bake_attr_free", CallingConvention=CallingConvention.Cdecl)]
        public static extern void attr_free(BakeAttr attr);

        [DllImport(DLL, EntryPoint = "bake_attr_free_attr_array", CallingConvention=CallingConvention.Cdecl)]
        public static extern void attr_free_attr_array(int list);

        [DllImport(DLL, EntryPoint = "bake_attr_free_string_array", CallingConvention=CallingConvention.Cdecl)]
        public static extern void attr_free_string_array(int list);

        [DllImport(DLL, EntryPoint = "bake_attr_add", CallingConvention=CallingConvention.Cdecl)]
        public static extern int attr_add(BakeConfig config, BakeProject project, CharPtr projectId, int attributes, CharPtr name, int* @value);

        [DllImport(DLL, EntryPoint = "bake_message", CallingConvention=CallingConvention.Cdecl)]
        public static extern void message(int kind, CharPtr bracketTxt, CharPtr fmt);

        [DllImport(DLL, EntryPoint = "bake_config_load", CallingConvention=CallingConvention.Cdecl)]
        public static extern int config_load(BakeConfig cfgOut, CharPtr envId);

        [DllImport(DLL, EntryPoint = "bake_config_export", CallingConvention=CallingConvention.Cdecl)]
        public static extern int config_export(BakeConfig cfg, CharPtr expr);

        [DllImport(DLL, EntryPoint = "bake_config_unset", CallingConvention=CallingConvention.Cdecl)]
        public static extern int config_unset(BakeConfig cfg, CharPtr expr);

        [DllImport(DLL, EntryPoint = "bake_do_pre_discovery", CallingConvention=CallingConvention.Cdecl)]
        public static extern int do_pre_discovery(BakeConfig config, BakeProject project);

        [DllImport(DLL, EntryPoint = "bake_do_post_discovery", CallingConvention=CallingConvention.Cdecl)]
        public static extern int do_post_discovery(BakeConfig config, BakeProject project);

        [DllImport(DLL, EntryPoint = "bake_do_build", CallingConvention=CallingConvention.Cdecl)]
        public static extern int do_build(BakeConfig config, BakeProject p);

        [DllImport(DLL, EntryPoint = "bake_do_clean", CallingConvention=CallingConvention.Cdecl)]
        public static extern int do_clean(BakeConfig config, BakeProject p);

        [DllImport(DLL, EntryPoint = "bake_do_rebuild", CallingConvention=CallingConvention.Cdecl)]
        public static extern int do_rebuild(BakeConfig config, BakeProject p);

        [DllImport(DLL, EntryPoint = "bake_do_install", CallingConvention=CallingConvention.Cdecl)]
        public static extern int do_install(BakeConfig config, BakeProject p);

        [DllImport(DLL, EntryPoint = "bake_run", CallingConvention=CallingConvention.Cdecl)]
        public static extern int run(BakeConfig config, CharPtr appId, bool interactive, int argc, byte* argv);

        [DllImport(DLL, EntryPoint = "bake_clone", CallingConvention=CallingConvention.Cdecl)]
        public static extern int clone(BakeConfig config, CharPtr url);

        [DllImport(DLL, EntryPoint = "bake_update", CallingConvention=CallingConvention.Cdecl)]
        public static extern int update(BakeConfig config, CharPtr url);

        [DllImport(DLL, EntryPoint = "bake_publish", CallingConvention=CallingConvention.Cdecl)]
        public static extern int publish(BakeConfig config, BakeProject project, CharPtr publishCmd);

        [DllImport(DLL, EntryPoint = "bake_install_template", CallingConvention=CallingConvention.Cdecl)]
        public static extern int install_template(BakeConfig cfg, BakeProject project);

        [DllImport(DLL, EntryPoint = "bake_install_metadata", CallingConvention=CallingConvention.Cdecl)]
        public static extern int install_metadata(BakeConfig config, BakeProject project);

        [DllImport(DLL, EntryPoint = "bake_install_prebuild", CallingConvention=CallingConvention.Cdecl)]
        public static extern int install_prebuild(BakeConfig config, BakeProject project);

        [DllImport(DLL, EntryPoint = "bake_install_postbuild", CallingConvention=CallingConvention.Cdecl)]
        public static extern int install_postbuild(BakeConfig config, BakeProject project);

        [DllImport(DLL, EntryPoint = "bake_install_clear", CallingConvention=CallingConvention.Cdecl)]
        public static extern int install_clear(BakeConfig config, BakeProject project, CharPtr projectId, bool uninstall);

        [DllImport(DLL, EntryPoint = "bake_install_uninstall", CallingConvention=CallingConvention.Cdecl)]
        public static extern int install_uninstall(BakeConfig config, CharPtr projectId);

        [DllImport(DLL, EntryPoint = "bake_install_uninstall_template", CallingConvention=CallingConvention.Cdecl)]
        public static extern int install_uninstall_template(BakeConfig config, CharPtr projectId);

        [DllImport(DLL, EntryPoint = "bake_driver_get", CallingConvention=CallingConvention.Cdecl)]
        public static extern BakeDriver driver_get(CharPtr id);

        [DllImport(DLL, EntryPoint = "bake_driver__artefact", CallingConvention=CallingConvention.Cdecl)]
        public static extern byte* driver__artefact(BakeDriver driver, BakeConfig config, BakeProject project);

        [DllImport(DLL, EntryPoint = "bake_driver__link_to_lib", CallingConvention=CallingConvention.Cdecl)]
        public static extern byte* driver__link_to_lib(BakeDriver driver, BakeConfig config, BakeProject project, CharPtr link);

        [DllImport(DLL, EntryPoint = "bake_driver__clean", CallingConvention=CallingConvention.Cdecl)]
        public static extern int driver__clean(BakeDriver driver, BakeConfig config, BakeProject project);

        [DllImport(DLL, EntryPoint = "bake_driver__setup", CallingConvention=CallingConvention.Cdecl)]
        public static extern int driver__setup(BakeDriver driver, BakeConfig config, BakeProject project);

        [DllImport(DLL, EntryPoint = "bake_driver__init", CallingConvention=CallingConvention.Cdecl)]
        public static extern int driver__init(BakeDriver driver, BakeConfig config, BakeProject project);

        [DllImport(DLL, EntryPoint = "bake_driver__generate", CallingConvention=CallingConvention.Cdecl)]
        public static extern int driver__generate(BakeDriver driver, BakeConfig config, BakeProject project);

        [DllImport(DLL, EntryPoint = "bake_driver__prebuild", CallingConvention=CallingConvention.Cdecl)]
        public static extern int driver__prebuild(BakeDriver driver, BakeConfig config, BakeProject project);

        [DllImport(DLL, EntryPoint = "bake_driver__build", CallingConvention=CallingConvention.Cdecl)]
        public static extern int driver__build(BakeDriver driver, BakeConfig config, BakeProject project);

        [DllImport(DLL, EntryPoint = "bake_driver__postbuild", CallingConvention=CallingConvention.Cdecl)]
        public static extern int driver__postbuild(BakeDriver driver, BakeConfig config, BakeProject project);

        [DllImport(DLL, EntryPoint = "bake_filelist_new", CallingConvention=CallingConvention.Cdecl)]
        public static extern BakeFilelist filelist_new(CharPtr path, CharPtr pattern);

        [DllImport(DLL, EntryPoint = "bake_filelist_free", CallingConvention=CallingConvention.Cdecl)]
        public static extern void filelist_free(BakeFilelist fl);

        [DllImport(DLL, EntryPoint = "bake_filelist_set", CallingConvention=CallingConvention.Cdecl)]
        public static extern int filelist_set(BakeFilelist fl, CharPtr pattern);

        [DllImport(DLL, EntryPoint = "bake_filelist_iter", CallingConvention=CallingConvention.Cdecl)]
        public static extern int filelist_iter(BakeFilelist fl);

        [DllImport(DLL, EntryPoint = "bake_filelist_add_file", CallingConvention=CallingConvention.Cdecl)]
        public static extern BakeFile filelist_add_file(BakeFilelist fl, CharPtr filepath, CharPtr file);

        [DllImport(DLL, EntryPoint = "bake_filelist_add_pattern", CallingConvention=CallingConvention.Cdecl)]
        public static extern int filelist_add_pattern(BakeFilelist fl, CharPtr path, CharPtr pattern);

        [DllImport(DLL, EntryPoint = "bake_filelist_merge", CallingConvention=CallingConvention.Cdecl)]
        public static extern int filelist_merge(BakeFilelist dst, BakeFilelist src);

        [DllImport(DLL, EntryPoint = "bake_filelist_count", CallingConvention=CallingConvention.Cdecl)]
        public static extern int filelist_count(BakeFilelist fl);

        [DllImport(DLL, EntryPoint = "bake_node_find", CallingConvention=CallingConvention.Cdecl)]
        public static extern BakeNode node_find(BakeDriver driver, CharPtr name);

        [DllImport(DLL, EntryPoint = "bake_pattern_new", CallingConvention=CallingConvention.Cdecl)]
        public static extern BakePattern pattern_new(CharPtr name, CharPtr pattern);

        [DllImport(DLL, EntryPoint = "bake_file_pattern_new", CallingConvention=CallingConvention.Cdecl)]
        public static extern BakePattern file_pattern_new(CharPtr name, CharPtr pattern);

        [DllImport(DLL, EntryPoint = "bake_rule_new", CallingConvention=CallingConvention.Cdecl)]
        public static extern BakeRule rule_new(CharPtr name, CharPtr source, int target, int action);

        [DllImport(DLL, EntryPoint = "bake_dependency_rule_new", CallingConvention=CallingConvention.Cdecl)]
        public static extern BakeDependencyRule dependency_rule_new(CharPtr name, CharPtr deps, int depMapping, int action);

        [DllImport(DLL, EntryPoint = "bake_node_eval", CallingConvention=CallingConvention.Cdecl)]
        public static extern int node_eval(BakeDriver driver, BakeNode n, BakeProject p, BakeConfig c, BakeFilelist inherits, BakeFilelist outputs);

        [DllImport(DLL, EntryPoint = "bake_attrs_parse", CallingConvention=CallingConvention.Cdecl)]
        public static extern int attrs_parse(BakeConfig config, BakeProject project, CharPtr projectId, int* @object, int existing);

        [DllImport(DLL, EntryPoint = "bake_attr_replace", CallingConvention=CallingConvention.Cdecl)]
        public static extern byte* attr_replace(BakeConfig config, BakeProject project, CharPtr packageId, CharPtr input);

        [DllImport(DLL, EntryPoint = "bake_clean_string_array", CallingConvention=CallingConvention.Cdecl)]
        public static extern void clean_string_array(int list);

        [DllImport(DLL, EntryPoint = "bake_json_set_boolean", CallingConvention=CallingConvention.Cdecl)]
        public static extern int json_set_boolean(bool* ptr, CharPtr member, int* v);

        [DllImport(DLL, EntryPoint = "bake_json_set_string", CallingConvention=CallingConvention.Cdecl)]
        public static extern int json_set_string(CharPtr* ptr, CharPtr member, int* v);

        [DllImport(DLL, EntryPoint = "bake_json_set_array", CallingConvention=CallingConvention.Cdecl)]
        public static extern int json_set_array(int* ptr, CharPtr member, int* v);

        [DllImport(DLL, EntryPoint = "bake_json_find_or_create_object", CallingConvention=CallingConvention.Cdecl)]
        public static extern int* json_find_or_create_object(int* @value, CharPtr member);

        [DllImport(DLL, EntryPoint = "bake_setup", CallingConvention=CallingConvention.Cdecl)]
        public static extern int setup(CharPtr cmd, bool local);

        [DllImport(DLL, EntryPoint = "bake_usage", CallingConvention=CallingConvention.Cdecl)]
        public static extern void usage();

        [DllImport(DLL, EntryPoint = "bake_version", CallingConvention=CallingConvention.Cdecl)]
        public static extern void version();

        [DllImport(DLL, EntryPoint = "bake_set_verbosity", CallingConvention=CallingConvention.Cdecl)]
        public static extern void set_verbosity(CharPtr verbosity);

        [DllImport(DLL, EntryPoint = "bake_parse_project_type", CallingConvention=CallingConvention.Cdecl)]
        public static extern int parse_project_type(CharPtr type);

        [DllImport(DLL, EntryPoint = "bake_init_action", CallingConvention=CallingConvention.Cdecl)]
        public static extern int init_action(CharPtr arg);

        [DllImport(DLL, EntryPoint = "bake_parse_args", CallingConvention=CallingConvention.Cdecl)]
        public static extern int parse_args(int argc, byte* argv);

        [DllImport(DLL, EntryPoint = "bake_project_from_cmdline", CallingConvention=CallingConvention.Cdecl)]
        public static extern BakeProject project_from_cmdline(BakeConfig config);

        ///<summary>
        /// Create project from manually specified parameters 
        ///</summary>
        ///<code>
        ///bake_project *bake_project_from_cmdline(bake_config *config)
        ///</code>
        [DllImport(DLL, EntryPoint = "bake_discovery", CallingConvention=CallingConvention.Cdecl)]
        public static extern int discovery(BakeConfig config);

        [DllImport(DLL, EntryPoint = "bake_build", CallingConvention=CallingConvention.Cdecl)]
        public static extern int build(BakeConfig config, CharPtr action);

        [DllImport(DLL, EntryPoint = "bake_env", CallingConvention=CallingConvention.Cdecl)]
        public static extern int env(BakeConfig config);

        ///<summary>
        /// Create project from manually specified parameters 
        ///</summary>
        ///<code>
        ///bake_project *bake_project_from_cmdline(bake_config *config)
        ///</code>
        [DllImport(DLL, EntryPoint = "bake_new_project", CallingConvention=CallingConvention.Cdecl)]
        public static extern int new_project(BakeConfig config);

        [DllImport(DLL, EntryPoint = "bake_publish_project", CallingConvention=CallingConvention.Cdecl)]
        public static extern int publish_project(BakeConfig config);

        [DllImport(DLL, EntryPoint = "bake_info", CallingConvention=CallingConvention.Cdecl)]
        public static extern int info(BakeConfig config, CharPtr id, CharPtr cfg, bool inCurrentCfg, bool testLib, int* typeOut, bool cleanMissing);

        [DllImport(DLL, EntryPoint = "bake_list", CallingConvention=CallingConvention.Cdecl)]
        public static extern int list(BakeConfig config, bool cleanMissing);

        [DllImport(DLL, EntryPoint = "bake_foreach_action", CallingConvention=CallingConvention.Cdecl)]
        public static extern int foreach_action(BakeConfig config, BakeProject project);

        [DllImport(DLL, EntryPoint = "bake_dump_env", CallingConvention=CallingConvention.Cdecl)]
        public static extern void dump_env();

        [DllImport(DLL, EntryPoint = "bake_run_template", CallingConvention=CallingConvention.Cdecl)]
        public static extern int run_template(BakeConfig config, CharPtr path, bool interactive, CharPtr bakeExec, int argc, byte* argv);

    }

}