use @main for juliac executable entry point

Author: JeffBezanson

contrib/juliac-buildscript.jl

@@ -185,13 +185,23 @@ end
 
 import Base.Experimental.entrypoint
 
-let mod = Base.include(Base.__toplevel__, inputfile)
-    if !isa(mod, Module)
-        mod = Main
-    end
+let mod = Base.include(Main, inputfile)
     Core.@latestworld
-    if output_type == "--output-exe" && isdefined(mod, :main) && !add_ccallables
-        entrypoint(mod.main, ())
+    if output_type == "--output-exe"
+        if Base.should_use_main_entrypoint()
+            if hasmethod(Main.main, Tuple{Vector{String}})
+                mainsig = which(Main.main, (Vector{String},)).sig
+                if mainsig != Tuple{typeof(Main.main), Vector{String}}
+                    error("The argument to `@main` must be declared as `::Vector{String}`.")
+                end
+                entrypoint(Main.main, (Vector{String},))
+                Base._ccallable("juliac_main", Cint, mainsig)
+            else
+                error("`@main` must accept a `Vector{String}` argument.")
+            end
+        else
+            error("To generate an executable a `@main` function must be defined.")
+        end
     end
     #entrypoint(join, (Base.GenericIOBuffer{Memory{UInt8}}, Array{Base.SubString{String}, 1}, String))
     #entrypoint(join, (Base.GenericIOBuffer{Memory{UInt8}}, Array{String, 1}, Char))

contrib/juliac.jl

@@ -123,16 +123,33 @@ function compile_products(enable_trim::Bool)
     end
 
     # Compile the initialization code
-    open(initsrc_path, "w") do io
-        print(io, """
-                  #include <julia.h>
-                  __attribute__((constructor)) void static_init(void) {
-                      if (jl_is_initialized())
-                          return;
-                      julia_init(JL_IMAGE_IN_MEMORY);
-                      jl_exception_clear();
-                  }
-                  """)
+    if output_type == "--output-exe"
+        open(initsrc_path, "w") do io
+            print(io, """
+                      #include <julia.h>
+                      int juliac_main(void*);
+                      int main(int argc, char *argv[])
+                      {
+                          julia_init(JL_IMAGE_IN_MEMORY);
+                          jl_exception_clear();
+                          jl_set_ARGS(argc, argv);
+                          return juliac_main(jl_get_global(jl_core_module, jl_symbol("ARGS")));
+                      }
+                      """)
+        end
+    else
+        open(initsrc_path, "w") do io
+            print(io, """
+                      #include <julia.h>
+                      __attribute__((constructor)) void static_init(void)
+                      {
+                          if (jl_is_initialized())
+                              return;
+                          julia_init(JL_IMAGE_IN_MEMORY);
+                          jl_exception_clear();
+                      }
+                      """)
+        end
     end
     run(`cc $(cflags) -g -c -o $init_path $initsrc_path`)
 end

src/gf.c

@@ -4616,8 +4616,6 @@ JL_DLLEXPORT void jl_extern_c(jl_value_t *name, jl_value_t *declrt, jl_tupletype
         jl_error("@ccallable: function object must be a singleton");
 
     // compute / validate return type
-    if (!jl_is_concrete_type(declrt) || jl_is_kind(declrt))
-        jl_error("@ccallable: return type must be concrete and correspond to a C type");
     if (!jl_type_mappable_to_c(declrt))
         jl_error("@ccallable: return type doesn't correspond to a C type");
 

src/jlapi.c

@@ -53,8 +53,10 @@ JL_DLLEXPORT void jl_set_ARGS(int argc, char **argv)
     if (jl_core_module != NULL) {
         jl_array_t *args = (jl_array_t*)jl_get_global(jl_core_module, jl_symbol("ARGS"));
         if (args == NULL) {
-            args = jl_alloc_vec_any(0);
-            JL_GC_PUSH1(&args);
+            jl_value_t *vecstr = NULL;
+            JL_GC_PUSH2(&args, &vecstr);
+            vecstr = jl_apply_array_type((jl_value_t*)jl_string_type, 1);
+            args = jl_alloc_array_1d(vecstr, 0);
             jl_set_const(jl_core_module, jl_symbol("ARGS"), (jl_value_t*)args);
             JL_GC_POP();
         }

test/trimming/basic_jll.jl

@@ -1,14 +1,10 @@
-module MyApp
-
 using Libdl
 using Zstd_jll
 
-Base.@ccallable function main()::Cint
+function @main(args::Vector{String})::Cint
     println(Core.stdout, "Julia! Hello, world!")
     fptr = dlsym(Zstd_jll.libzstd_handle, :ZSTD_versionString)
     println(Core.stdout, unsafe_string(ccall(fptr, Cstring, ())))
     println(Core.stdout, unsafe_string(ccall((:ZSTD_versionString, libzstd), Cstring, ())))
     return 0
 end
-
-end

test/trimming/hello.jl

@@ -1,13 +1,9 @@
-module MyApp
-
 world::String = "world!"
 const str = OncePerProcess{String}() do
     return "Hello, " * world
 end
 
-Base.@ccallable function main()::Cint
+function @main(args::Vector{String})::Cint
     println(Core.stdout, str())
     return 0
 end
-
-end

test/trimming/init.c

@@ -1,9 +1,9 @@
 #include <julia.h>
-
-__attribute__((constructor)) void static_init(void)
+int juliac_main(void*);
+int main(int argc, char *argv[])
 {
-    if (jl_is_initialized())
-        return;
     julia_init(JL_IMAGE_IN_MEMORY);
     jl_exception_clear();
+    jl_set_ARGS(argc, argv);
+    return juliac_main(jl_get_global(jl_core_module, jl_symbol("ARGS")));
 }