Improve the compiler command line options

[Its-Kenta]

While you can easily setup a Makefile or such, I do have to say that it is a little bit cumbersome to build a project with litac compiler.

are there any plans to improve this anytime soon? Would love to use LitaC more tbf.

[tonysparks]

I was planning on some more features a kin to Rust cargo (i.e., init, run). Is there something you had in mind?

[Its-Kenta]

Not really, just having options like you've mentioned is really all one needs. What are the plans with passing flags to c compiler with new options though?

[tonysparks]

This is what I'm thinking:

1. Create -pkg-init option. This will create a scaffolding project containing:

bin/              // building will place built binary files here
src/main.lita     // source directory
docs/             // generated documents
lib/              // any static libraries
test/             // tests for the project
pkg.json          // package configuration file

2. Create -pkg-build option. This will read the pkg.json file, right now it has the ability to define user defined commands scripts and run them via the -pkg-run option. The -pkg-build command will be explicitly for building the project.

I'm thinking of having an explicit build_command section which will define debug and release builds which then can define specific OS and Architectures (with default options available for catch-all). From there, you can specify the C command line option and the LitaC command line options (or specifying a script for full control).

Eventually, I'll want to add in a pure Lita build API that can handle these build options, but this seems like significantly less work to implement for now.

    // Specify how to build the project and will recursively build all
    // dependent projects
    "build_command": {
        // For debug mode, "default" can be set as well
        "debug": {
            // Specify custom command for OS
            "windows" : {
                // Specify which CPU architecture
                "x86": {
                    // Specify the C build command.
                    "build_cmd": "clang.exe -std=c99 -g -gcodeview -fsanitize=undefined,address %input% -o %output%  -D_CRT_SECURE_NO_WARNINGS",

                    // (optional) Specify the litac command line options.  Default will include -buildCmd, -outputDir, -output and input file
                    "lita_options": "-cFormat -profile -maxMemory 1GiB",

                    // If "script" is specified, will ignore the build_cmd and lita_options and run the supplied script
                    // "script" : "build.bat",
                }
            },
            "linux" : {
                // etc..
            }
        },
        "release": {
            // default will be used if no explicit OS is present
            "default" : {
                // default will be used if no explicit CPU arch is present
                "default" : {
                    "build_cmd": "clang.exe -std=c99 -o3 %input% -o %output%  -D_CRT_SECURE_NO_WARNINGS",
                    "lita_options": "-maxMemory 1GiB",
                }
            }
        }
    },

Also note, you can configure compiler flags using the compiler_option notes, here is an example.

3. Once you configure your pkg.json the only thing you would need to run in order to build your project would be litac -pkg-build

[Its-Kenta]

In the pkg.json why not simply determine what compiler it should use for C? Rather than including it in the "build_cmd" it could just be using the C flags and then have a field somewhere in pkg.json named "cc" where you put in the compiler you want to use, if empty it would use system default?

I think it would make it much less verbose.
IMO the build file would be great if it was concise and simple to go through. One thing I fear is it could one day end up similar to Zig build where every single newbie ask the same question "What the hell am I doing here"

Also I take it you wouldn't consider TOML rather than JSON?
Thank you for looking into this btw!

[tonysparks]

I would consider TOML over JSON, however I only implemented a JSON parser so far (it's actually a superset of JSON which includes comments, trailing commas and verbatim strings). Implementing (or getting a C binding) of TOML is pretty low priority for me at the moment.

I put out a PR - which is barebones implementation, open to feedback. Thank you for showing interest in LitaC - I love the feedback!

[Its-Kenta]

I think TOML could be on the lower priority if considered? Having things work perfectly I guess would be the first aim.
Unfortunately until #40 is fixed I'm unable to test anything as last time I tested on macOS it was x86 which I no longer have.

LitaC is a really amazing concept and I love the syntax of it. I'm on hunt for the perfect "C" and LitaC is really high on that score! Keep up the amazing work!

[Jomy10]

Personally prefer TOML over json for configuration.

I think separating the c compiler from the build command is a good idea.

Maybe another path to consider is one of code instead of a config file. Similar to how Zig does it.

[Its-Kenta]

Personally prefer TOML over json for configuration.

I think separating the c compiler from the build command is a good idea.

Maybe another path to consider is one of code instead of a config file. Similar to how Zig does it.

Personally see that as a bit of a burden on new users. Especially when looking at Zig and how many new comers ask the question of “how do I setup my build.zig”

I think TOML would just be a perfect match for this.

EDIT:
I've just tried using -pkg-init and -pkg-build both work flawlessly. However, I'm a little bit lost with -pkg-run Is the "script" implemented? Is it supposed to use the build_commands as arguments? Other than that it's amazing work!

[Jomy10]

Build script would be more complex. However it would be nice if the api is made available for those who want to use it. Maybe something similar to rust where you have an optional build.rs alongside the TOML. Either way, focussing on toml is probable the best right now.

[tonysparks]

I found this toml C library -- which is only two files and allows for passing in custom allocator (which fits nicely with LitaC). This would be a nice addition to the stdlib.

The -pkg-run command is meant for running custom scripts, probably will remove this command now that pkg-build exists.

[Its-Kenta]

Why not make -pkg-run simply compile the executable and run it?