X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=vg_build.h;h=965f14cac3941c73e687985360410d581b5008a3;hb=HEAD;hp=b582d0f9f727e9171af3877ee990208444b3c3fe;hpb=7108996fc9e1baebc3b3f09e950ce08487f9d5a6;p=vg.git

diff --git a/vg_build.h b/vg_build.h
index b582d0f..9a1d861 100644
--- a/vg_build.h
+++ b/vg_build.h
@@ -1,5 +1,3 @@
-/* zig cc scripting tools */
-
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
@@ -9,22 +7,26 @@
 #include "vg_opt.h"
 #include "vg_log.h"
 #include "vg_string.h"
+#include "vg_build_font.h"
 
 /* we dont free dynamic vg_strs in this program. so, we dont care.. */
 const char *__asan_default_options() { return "detect_leaks=0"; }
 
-struct vg_env
+struct vg_project
 {
-   u32 optimization;
+   vg_str uid, bin_folder;
+};
 
-   bool fresh,
-        debug_asan;
+struct vg_compiler_env
+{
+   u32 optimization;
+   bool debug_asan;
 
    enum platform 
    {
       k_platform_anyplatform,
       k_platform_windows,
-      k_platform_linux
+      k_platform_linux,
    }
    platform;
 
@@ -40,7 +42,7 @@ struct vg_env
    {
       k_compiler_blob,
       k_compiler_clang,
-      k_compiler_zigcc
+      k_compiler_zigcc,
    }
    compiler;
 
@@ -50,49 +52,40 @@ struct vg_env
       k_libc_version_2_23,
    }
    libc;
-};
-
-struct vg_env vg_test_env = {
-   .arch = k_architecture_x86_64,
-   .compiler = k_compiler_clang,
-   .libc = k_libc_version_native,
+}
+vg_test_env = 
+{
+   .optimization = 0,
    .debug_asan = 1,
-   .fresh = 0,
    .platform = k_platform_linux,
-   .optimization = 0
-};
-
-struct vg_env vg_release_env = {
    .arch = k_architecture_x86_64,
-   .compiler = k_compiler_zigcc,
-   .libc = k_libc_version_2_23,
-   .fresh = 1,
+   .compiler = k_compiler_clang,
+   .libc = k_libc_version_native
+},
+vg_release_env = 
+{
    .optimization = 3,
+   .debug_asan = 0,
    .platform = k_platform_anyplatform,
-   .debug_asan = 0
+   .arch = k_architecture_x86_64,
+   .compiler = k_compiler_zigcc,
+   .libc = k_libc_version_2_23
 };
 
-struct vg_project
+struct vg_compiler_conf 
 {
-   struct vg_env *env;
-
-   vg_str include,      /* -I<path> */
-          library,      /* -L<path> */
-          link,         /* -llibrary */
-          sources,      /* file.c obj.o */
-          uid,          /* env/project identifier */
-          target,       /* result object name */
-
-          /* generated */
-          compiled_objects; /* space seperated paths to compiled objects */
-
-   enum obj_type {
-      k_obj_type_none,
-      k_obj_type_exe,
-      k_obj_type_obj,
-      k_obj_type_shared,
-   }
-   type;
+   vg_str include,
+          library,
+          link,
+          defines;
+};
+
+enum obj_type 
+{
+   k_obj_type_none,
+   k_obj_type_exe,
+   k_obj_type_obj,
+   k_obj_type_shared,
 };
 
 /* 
@@ -103,28 +96,21 @@ static const char *platform_names[] =
 {
    [k_platform_anyplatform] = "anyplatform",
    [k_platform_windows]     = "windows",
-   [k_platform_linux]       = "linux"
+   [k_platform_linux]       = "linux",
 };
 
 static const char *architecture_names[] = 
 {
    [k_architecture_anyarch] = "anyarch",
    [k_architecture_i386]    = "i386",
-   [k_architecture_x86_64]  = "x86_64"
+   [k_architecture_x86_64]  = "x86_64",
 };
 
 static const char *compiler_names[] = 
 {
    [k_compiler_blob]    = "blob",
    [k_compiler_clang]   = "clang",
-   [k_compiler_zigcc]   = "zig-cc"
-};
-
-static const char *compiler_paths[] = 
-{
-   [k_compiler_blob]    = NULL,
-   [k_compiler_clang]   = "clang",
-   [k_compiler_zigcc]   = "zig cc"
+   [k_compiler_zigcc]   = "zig-cc",
 };
 
 static const char *libc_names[] = 
@@ -133,45 +119,6 @@ static const char *libc_names[] =
    [k_libc_version_2_23]    = ".2.23"
 };
 
-/*
- * source specification
- * -------------------------------------------------------------------------- */
-
-void vg_add_source( struct vg_project *proj, const char *source )
-{
-   if( proj->type == k_obj_type_none )
-      vg_fatal_error( "Cannot add source code without setting binary type\n" );
-
-   vg_strcat( &proj->sources, source );
-   vg_strcat( &proj->sources, " " );
-}
-
-void vg_include_dir( struct vg_project *proj, const char *dir )
-{
-   if( proj->type == k_obj_type_none )
-      vg_fatal_error( "Cannot add include dir without setting binary type\n" );
-
-   vg_strcat( &proj->include, dir );
-   vg_strcat( &proj->include, " " );
-}
-
-void vg_library_dir( struct vg_project *proj, const char *dir )
-{
-   if( proj->type == k_obj_type_none )
-      vg_fatal_error( "Cannot add library dir without setting binary type\n" );
-
-   vg_strcat( &proj->library, dir );
-   vg_strcat( &proj->library, " " );
-}
-
-void vg_link( struct vg_project *proj, const char *lib )
-{
-   if( proj->type == k_obj_type_none )
-      vg_fatal_error( "Cannot link library without setting binary type\n" );
-
-   vg_strcat( &proj->link, lib );
-}
-
 /*
  * OS & file tools
  * -------------------------------------------------------------------------- */
@@ -192,14 +139,14 @@ void vg_syscall( const char *fmt, ... )
 
 void vg_add_blob( struct vg_project *proj, const char *blob, const char *dest )
 {
-   vg_syscall( "cp %s bin/%s/%s", blob, proj->uid.buffer, dest );
+   vg_syscall( "cp %s %s/%s", blob, proj->bin_folder.buffer, dest );
 }
 
 void vg_symlink( struct vg_project *proj,
                  const char *folder, const char *bin_name )
 {
    char dest[512];
-   snprintf( dest, 512, "bin/%s/%s", proj->uid.buffer, bin_name );
+   snprintf( dest, 512, "%s/%s", proj->bin_folder.buffer, bin_name );
    if( !access( dest, F_OK ) )
       vg_syscall( "unlink %s", dest );
    vg_syscall( "ln -srf %s %s", folder, dest );
@@ -207,207 +154,226 @@ void vg_symlink( struct vg_project *proj,
 
 void vg_tarball_project( struct vg_project *proj )
 {
-   vg_syscall( "tar -chzvf dist/%s-%u.tar.gz bin/%s/",
-               proj->uid.buffer, time(NULL), proj->uid.buffer );
+   vg_syscall( "tar -chzvf dist/%s-%u.tar.gz %s/",
+               proj->uid.buffer, time(NULL), proj->bin_folder.buffer );
+}
+
+bool vg_platform_posix( enum platform p )
+{
+   if( p == k_platform_linux ) return 1;
+   else return 0;
 }
 
 /*
- * The project configurator and compiler.
+ * Project
  * -------------------------------------------------------------------------- */
 
-void vg_project_new_target( struct vg_project *proj, const char *name, 
-                            enum obj_type type )
+/* Initialize the project structure, proj, 
+ *  IN folder/name,
+ *  CLEAR IF fresh
+ */
+void vg_project_init( struct vg_project *proj, 
+                      const char *folder,
+                      const char *name,
+                      struct vg_compiler_env *env,
+                      bool fresh )
 {
-   proj->type = type;
+   vg_strnull( &proj->uid, NULL, 0 );
+   vg_strcat( &proj->uid, name );
 
-   vg_strnull( &proj->include, NULL, -1 );
-   vg_strnull( &proj->library, NULL, -1 );
-   vg_strnull( &proj->link, NULL, -1 );
-   vg_strnull( &proj->sources, NULL, -1 );
-   vg_strnull( &proj->target, NULL, -1 );
-
-   /*
-    * Setup target with appropriate extension
-    */
-   vg_strcat( &proj->target, name );
-
-   if( proj->env->platform == k_platform_windows )
+   if( env )
    {
-      if( type == k_obj_type_exe )
-         vg_strcat( &proj->target, ".exe" );
-      else if( type == k_obj_type_shared )
-         vg_strcat( &proj->target, ".dll" );
-      else if( type == k_obj_type_obj )
-         vg_strcat( &proj->target, ".obj" );
+      vg_strcat( &proj->uid, "-" );
+      vg_strcat( &proj->uid, platform_names[ env->platform ] );
+      vg_strcat( &proj->uid, "-" );
+      vg_strcat( &proj->uid, architecture_names[ env->arch ] );
+      vg_strcat( &proj->uid, "-" );
+      vg_strcat( &proj->uid, compiler_names[ env->compiler ] );
    }
 
+   vg_strnull( &proj->bin_folder, NULL, 0 );
+   vg_strcat( &proj->bin_folder, folder );
+   vg_strcat( &proj->bin_folder, "/" );
+   vg_strcat( &proj->bin_folder, proj->uid.buffer );
 
-   if( proj->env->platform == k_platform_linux )
-   {
-      if( type == k_obj_type_shared )
-         vg_strcat( &proj->target, ".so" );
-      else if( type == k_obj_type_obj )
-         vg_strcat( &proj->target, ".o" );
-   }
-
-   /* 
-    * Add some regular includes / library dirs 
-    */
-   if( type != k_obj_type_none )
-   {
-      vg_include_dir( proj, "-I." );
-      vg_include_dir( proj, "-I./vg" );
-      vg_library_dir( proj, "-L." );
-      vg_library_dir( proj, "-L/usr/lib" );
-   }
+   vg_info( "project_init: %s (fresh: %s)\n   (%s)\n", 
+               name, 
+               fresh? "yes":"no",
+               proj->bin_folder.buffer );
 
-   vg_info( "  New target: %s\n", name );
+   if( fresh )
+      vg_syscall( "rm -rf %s", proj->bin_folder.buffer );
+   vg_syscall( "mkdir -p %s", proj->bin_folder.buffer );
 }
 
-void vg_project_init( struct vg_project *proj,
-                      struct vg_env *env,
-                      const char *identifier )
+struct compile_result
 {
-   proj->env = env;
-   proj->type = k_obj_type_none;
-
-   vg_strnull( &proj->uid, NULL, -1 );
-   vg_strnull( &proj->compiled_objects, NULL, -1 );
+   vg_str path, 
+          rel_path;
+};
 
+/* run a compiler.. return compiled object relative to project folder
+ */
+struct compile_result 
+vg_compiler_run( struct vg_project *project, 
+                 struct vg_compiler_env *env,
+                 struct vg_compiler_conf *conf,
+                 const char *sources,
+                 const char *target_name,
+                 enum obj_type type )
+{
    /* check for problems in configuration */
-   if( env->libc != k_libc_version_native ){
-      if( env->compiler != k_compiler_zigcc ){
-         vg_fatal_error( 
+   if( env->libc != k_libc_version_native )
+   {
+      if( env->compiler != k_compiler_zigcc )
+      {
+         vg_fatal_condition();
+         vg_info(
                "Cannot specify libc version using the '%s' compiler.\n",
                compiler_names[ env->compiler ] );
+         vg_fatal_exit();
       }
    }
 
-   if( env->compiler == k_compiler_clang ){
-      if( env->platform != k_platform_linux ){
-         vg_fatal_error( "Cannot compile for '%s' using the '%s' compiler;" );
+   if( env->compiler == k_compiler_clang )
+   {
+      if( env->platform != k_platform_linux )
+      {
+         vg_fatal_condition();
+         vg_info( "Cannot compile for '%s' using the '%s' compiler;" );
+         vg_fatal_exit();
       }
    }
 
-   vg_strcat( &proj->uid, identifier );
-   vg_strcatch( &proj->uid, '-' );
-   vg_strcat( &proj->uid, platform_names[ env->platform ] );
-   vg_strcatch( &proj->uid, '-' );
-   vg_strcat( &proj->uid, architecture_names[ env->arch ] );
-   vg_strcatch( &proj->uid, '-' );
-   vg_strcat( &proj->uid, compiler_names[ env->compiler ] );
-
-   if( proj->uid.i < 3 )
-      vg_fatal_error( "failed to create project UID\n" );
-
-   vg_info( "project_init: %s (%s, %s, compiler: %s, opt:%u, fresh: %s)\n", 
-               identifier, 
-               platform_names[env->platform],
-               architecture_names[env->arch],
-               compiler_names[env->compiler],
-               env->optimization,
-               env->fresh? "yes":"no");
-
-   if( env->fresh )
-      vg_syscall( "rm -rf bin/%s", proj->uid.buffer );
-   vg_syscall( "mkdir -p bin/%s", proj->uid.buffer );
-}
-
-void vg_compile_project( struct vg_project *proj )
-{
-   vg_str cmd;
-   vg_strnull( &cmd, NULL, -1 );
+   vg_str cmd = {0};
+   vg_strcat( &cmd, "ccache " );
 
    /* compiler specification */
-   vg_strcat( &cmd, "ccache " );
-   vg_strcat( &cmd, compiler_paths[ proj->env->compiler ] );
+
+   if( env->compiler == k_compiler_zigcc ) 
+      vg_strcat( &cmd, "zig cc " );
+   else if( env->compiler == k_compiler_clang )
+      vg_strcat( &cmd, "clang" );
+
    vg_strcat( &cmd, " -std=gnu99 -D_REENTRANT \\\n" );
 
-   if( proj->env->optimization )
+   if( env->optimization )
    {
       vg_strcat( &cmd, "  -O" );
-      vg_strcati32( &cmd, proj->env->optimization );
-      vg_strcat( &cmd, " -flto \\\n" );
+      vg_strcati32( &cmd, env->optimization );
    }
    else 
    {
-      /* add debugger / asan information */
       vg_strcat( &cmd, "  -O0 -ggdb3 -fno-omit-frame-pointer " );
-
-      if( (proj->env->compiler == k_compiler_clang) && proj->env->debug_asan )
-      {
-         vg_strcat( &cmd, "  -rdynamic -fsanitize=address -fPIE "
-                          "-fstack-protector-strong " );
-      }
-
       vg_strcat( &cmd, "\\\n" );
    }
 
+   if( (env->compiler == k_compiler_clang) && env->debug_asan )
+   {
+      vg_strcat( &cmd, "  -rdynamic -fsanitize=address -fPIE "
+                       "-fstack-protector-strong " );
+   }
+
+   /* always want this */
+   vg_strcat( &cmd, " -flto \\\n" );
+
    /* want a lot of warnings but not useless ones */
    vg_strcat( &cmd, "  -Wall -ferror-limit=8\\\n"
       "    -Wno-unused-function -Wno-unused-variable\\\n"
       "    -Wno-unused-command-line-argument -Wno-unused-but-set-variable\\\n"
    );
 
-   if( proj->env->compiler != k_compiler_clang )
+   if( env->compiler != k_compiler_clang )
       vg_strcat( &cmd, "    -Wno-format-truncation\\\n" );
 
+   /* defines */
+   vg_strcat( &cmd, "  " );
+   vg_strcat( &cmd, conf->defines.buffer );
+   vg_strcat( &cmd, "\\\n" );
+
    /* include paths */
    vg_strcat( &cmd, "  " );
-   vg_strcat( &cmd, proj->include.buffer );
+   vg_strcat( &cmd, conf->include.buffer );
    vg_strcat( &cmd, "\\\n" );
    
    /* library paths */
    vg_strcat( &cmd, "  " );
-   vg_strcat( &cmd, proj->library.buffer );
+   vg_strcat( &cmd, conf->library.buffer ); 
    vg_strcat( &cmd, "\\\n" );
 
    /* sources */
    vg_strcat( &cmd, "  " );
 
-   if( proj->type == k_obj_type_obj )
-      vg_strcat( &cmd, "-c " );
+   if( type == k_obj_type_obj )
+      vg_strcat( &cmd, "-c -fPIC " );
 
-   if( proj->type == k_obj_type_shared )
+   if( type == k_obj_type_shared )
+   {
       vg_strcat( &cmd, "-shared -fPIC " );
+   }
 
-   vg_strcat( &cmd, proj->sources.buffer );
+   vg_strcat( &cmd, sources );
    vg_strcat( &cmd, "\\\n" );
 
-   /* output */
-   vg_strcat( &cmd, "  -o bin/" );
-   vg_strcat( &cmd, proj->uid.buffer );
-   vg_strcat( &cmd, "/" );
-   vg_strcat( &cmd, proj->target.buffer );
+   struct compile_result res = {0};
+
+   vg_strcat( &res.rel_path, target_name );
+
+   if( env->platform == k_platform_windows )
+   {
+      if( type == k_obj_type_exe )
+         vg_strcat( &res.rel_path, ".exe" );
+      else if( type == k_obj_type_shared )
+         vg_strcat( &res.rel_path, ".dll" );
+      else if( type == k_obj_type_obj )
+         vg_strcat( &res.rel_path, ".obj" );
+   }
+
+   if( vg_platform_posix( env->platform ) )
+   {
+      if( type == k_obj_type_shared )
+         vg_strcat( &res.rel_path, ".so" );
+      else if( type == k_obj_type_obj )
+         vg_strcat( &res.rel_path, ".o" );
+   }
+
+   vg_strcat( &res.path, project->bin_folder.buffer );
+   vg_strcat( &res.path, "/" );
+   vg_strcat( &res.path, res.rel_path.buffer );
+   
+   vg_strcat( &cmd, "  -o " );
+   vg_strcat( &cmd, res.path.buffer );
    vg_strcat( &cmd, "\\\n" );
 
    /* link */
    vg_strcat( &cmd, "  " );
-   vg_strcat( &cmd, proj->link.buffer );
+   vg_strcat( &cmd, conf->link.buffer );
    vg_strcat( &cmd, "\\\n" );
    
-   if( proj->type == k_obj_type_exe )
+   if( type == k_obj_type_exe )
    {
       vg_strcat( &cmd, "  -Wl,-rpath=./\\\n" );
    }
 
-   /* target platform specification (zig-cc only) */
-   if( proj->env->compiler == k_compiler_zigcc ){
+   /* platform specification (zig-cc only) */
+   if( env->compiler == k_compiler_zigcc )
+   {
       vg_strcat( &cmd, "  -target " );
-      vg_strcat( &cmd, architecture_names[proj->env->arch] );
+      vg_strcat( &cmd, architecture_names[env->arch] );
       vg_strcat( &cmd, "-" );
-      vg_strcat( &cmd, platform_names[proj->env->platform] );
+      vg_strcat( &cmd, platform_names[env->platform] );
 
-      if( proj->env->platform == k_platform_linux ){
+      if( env->platform == k_platform_linux )
+      {
          vg_strcat( &cmd, "-gnu" );
-         vg_strcat( &cmd, libc_names[proj->env->libc] );
+         vg_strcat( &cmd, libc_names[env->libc] );
       }
 
-      if( proj->env->platform == k_platform_windows )
+      if( env->platform == k_platform_windows )
       {
          /* we currently dont want pdb pretty much ever. goodbye! */
 
-         if( proj->type == k_obj_type_exe )
+         if( type == k_obj_type_exe )
          {
             vg_strcat( &cmd, " /pdb:/dev/null" );
             vg_strcat( &cmd, " /SUBSYSTEM:windows" );
@@ -416,13 +382,7 @@ void vg_compile_project( struct vg_project *proj )
    }
 
    vg_syscall( cmd.buffer );
-
-   /* add to results */
-   vg_strcat( &proj->compiled_objects, "bin/" );
-   vg_strcat( &proj->compiled_objects, proj->uid.buffer );
-   vg_strcat( &proj->compiled_objects, "/" );
-   vg_strcat( &proj->compiled_objects, proj->target.buffer );
-   vg_strcat( &proj->compiled_objects, " \\\n " );
+   return res;
 }
 
 /*
@@ -431,113 +391,144 @@ void vg_compile_project( struct vg_project *proj )
 
 struct vg_engine_config
 {
-   bool use_3d, legacy_support_vg_msg1, log_source_info, steam_api,
+   bool use_3d, 
+        legacy_support_vg_msg1, 
+        log_source_info, 
+        steam_api,
         custom_game_settings,
-        release_mode, custom_shaders;
+        custom_shaders;
    i32 fixed_update_hz;
 }
-vg_engine_default_config = {
+vg_engine_default_config = 
+{
    .use_3d = 1,
    .fixed_update_hz = 60,
    .legacy_support_vg_msg1 = 0,
    .log_source_info = 1,
    .steam_api = 0,
    .custom_game_settings = 0,
-   .release_mode = 0,
    .custom_shaders = 0
 };
 
-void vg_add_engine( struct vg_project *proj, struct vg_engine_config *config )
+struct compile_result
+vg_make_app( struct vg_project *proj, 
+             struct vg_engine_config *vg_conf,
+             struct vg_compiler_env *env,
+             struct vg_compiler_conf *conf,
+             const char *sources,
+             const char *appname )
 {
-   if( !config ) config = &vg_engine_default_config;
-   vg_str config_string;
-   vg_strnull( &config_string, NULL, -1 );
-   vg_strcat( &config_string, config->use_3d? "-DVG_3D \\\n": "-DVG_2D \\\n" );
-   vg_strcat( &config_string, "-DVG_TIMESTEP_FIXED=\"(1.0/" );
-   vg_strcati32( &config_string, config->fixed_update_hz );
-   vg_strcat( &config_string, ".0)\" \\\n" );
-   if( config->legacy_support_vg_msg1 )
-      vg_strcat( &config_string, "-DVG_MSG_V1_SUPPORT \\\n" );
-   if( config->log_source_info )
-      vg_strcat( &config_string, "-DVG_LOG_SOURCE_INFO \\\n" );
-   if( config->custom_game_settings )
-      vg_strcat( &config_string, "-DVG_GAME_SETTINGS \\\n" );
-   if( config->custom_game_settings )
-      vg_strcat( &config_string, "-DVG_RELEASE \\\n" );
-   if( config->custom_shaders )
-      vg_strcat( &config_string, "-DVG_CUSTOM_SHADERS \\\n" );
-
-   vg_strcat( &config_string, "\\\n" );
-
-   /* compile heavy dependencies seperately */
-   struct vg_project dep_proj;
-   struct vg_env env = *proj->env;
-   env.optimization = 3;
-   env.debug_asan = 0;
-
-   vg_project_init( &dep_proj, proj->env, "vg" );
+   struct vg_project vg_proj;
+   vg_project_init( &vg_proj, "bin", ".vg", env, 0 );
+
+   /* building assets */
+   vg_build_default_font();
+
+   /* add config defines to compiler config */
+   if( !vg_conf ) vg_conf = &vg_engine_default_config;
+   vg_strcat( &conf->defines, vg_conf->use_3d? "-DVG_3D \\\n": "-DVG_2D \\\n" );
+   vg_strcatf( &conf->defines, "-DVG_TIMESTEP_FIXED=\"(1.0/%d.0)\" \\\n",
+               vg_conf->fixed_update_hz );
+
+   if( vg_conf->legacy_support_vg_msg1 )
+      vg_strcat( &conf->defines, "-DVG_MSG_V1_SUPPORT \\\n" );
+
+   if( vg_conf->log_source_info )
+      vg_strcat( &conf->defines, "-DVG_LOG_SOURCE_INFO \\\n" );
+
+   if( vg_conf->custom_game_settings )
+      vg_strcat( &conf->defines, "-DVG_GAME_SETTINGS \\\n" );
+
+   if( vg_conf->custom_shaders )
+      vg_strcat( &conf->defines, "-DVG_CUSTOM_SHADERS \\\n" );
+
+   if( env->arch == k_architecture_i386 )
+      vg_strcat( &conf->defines, "-DVG_32 \\\n" );
+   else
+      vg_strcat( &conf->defines, "-DVG_64 \\\n" );
+
+   vg_strcat( &conf->defines, "\\\n" );
+   vg_strcat( &conf->include, "-I. -I./vg -I./vg/dep " );
+
+   /* compile all the components 
+    * ----------------------------------------------------------------------- */
+   vg_str components = {0};
+   vg_strcatf( &components, "%s ", sources );
+
+   struct vg_compiler_env denv = *env;
+   //denv.optimization = 3;
 
    /* external dependencies */
-   vg_project_new_target( &dep_proj, "vg_deps", k_obj_type_obj );
-   vg_add_source( &dep_proj, "vg/vg_depencies.c" );
-   vg_compile_project( &dep_proj );
+   struct compile_result depencies = 
+      vg_compiler_run( &vg_proj, &denv, conf, "vg/vg_depencies.c",
+                        "vg_deps", k_obj_type_obj );
+   vg_strcatf( &components, "%s ", depencies.path );
 
    /* glad */
-   vg_project_new_target( &dep_proj, "vg_glad", k_obj_type_obj );
-   vg_add_source( &dep_proj, "vg/dep/glad/glad.c" );
-   vg_include_dir( &dep_proj, "-I./vg/dep " );
-   vg_compile_project( &dep_proj );
+   struct compile_result glad = 
+      vg_compiler_run( &vg_proj, &denv, conf, "vg/dep/glad/glad.c",
+                        "vg_glad", k_obj_type_obj );
+   vg_strcatf( &components, "%s ", glad.path );
 
    /* core engine */
-   vg_project_new_target( &dep_proj, "vg_engine_core", k_obj_type_obj );
-   vg_add_source( &dep_proj, config_string.buffer );
-   vg_add_source( &dep_proj, "vg/vg_engine.c" );
-   vg_include_dir( &dep_proj, "-I./vg/dep " );
-   vg_compile_project( &dep_proj );
+   struct compile_result vg = 
+      vg_compiler_run( &vg_proj, &denv, conf, "vg/vg_engine.c",
+                        "vg_engine_core", k_obj_type_obj );
+   vg_strcatf( &components, "%s ", vg.path );
 
    /* steamworks */
-   if( config->steam_api )
+   if( vg_conf->steam_api )
    {
-      vg_project_new_target( &dep_proj, "vg_steam", k_obj_type_obj );
-      vg_add_source( &dep_proj, "vg/vg_steam.c" );
-      vg_compile_project( &dep_proj );
+      struct compile_result steam =
+         vg_compiler_run( &vg_proj, &denv, conf, "vg/vg_steam.c",
+                           "vg_steam", k_obj_type_obj );
+      vg_strcatf( &components, "%s ", steam.path );
 
-      if( proj->env->platform == k_platform_linux )
+      if( env->platform == k_platform_linux )
       {
          vg_add_blob( proj, "vg/dep/steam/libsteam_api.so", "" );
-         vg_link( proj, "-lsteam_api " );
+         vg_strcat( &conf->link, "-lsteam_api " );
       }
-      else if( proj->env->platform == k_platform_windows )
+      else if( env->platform == k_platform_windows )
       {
          vg_add_blob( proj, "vg/dep/steam/steam_api64.dll", "" );
-         vg_link( proj, "vg/dep/steam/steam_api64.dll " );
+         vg_strcat( &conf->link, "vg/dep/steam/steam_api64.dll " );
       }
 
-      vg_library_dir( proj, "-L./vg/dep/steam " );
-      vg_include_dir( proj, "-I./vg/dep " );
+      vg_strcat( &conf->library, "-L./vg/dep/steam " );
    }
 
-   /* precipitate to the client project */
+   /* link */
+   vg_strcat( &conf->library, "-L. -L/usr/lib " );
+   vg_strcat( &conf->link, "-lm " );
 
-   vg_link( proj, "-lm " );
-   if( proj->env->platform == k_platform_linux )
+   if( env->platform == k_platform_linux )
    {
-      vg_link( proj, "-lSDL2 -lGL -lX11 -lXxf86vm "
-                     "-lXrandr -lXi -ldl -pthread " );
+      vg_strcat( &conf->link, "-lSDL2 -lGL -lX11 -lXxf86vm "
+                              "-lXrandr -lXi -ldl -pthread " );
+
+      return vg_compiler_run( proj, env, conf, components.buffer, 
+                              appname, k_obj_type_exe );
    }
-   else if( proj->env->platform == k_platform_windows )
+   else if( env->platform == k_platform_windows )
    {
-      vg_link( proj, "-lSDL2main -lSDL2 -lopengl32 \\\n" );
-      vg_link( proj, "vg/dep/sdl/SDL2.dll " );
+      vg_strcat( &conf->link, "-lSDL2main -lSDL2 -lopengl32 \\\n" );
+      vg_strcat( &conf->link, "vg/dep/sdl/SDL2.dll " );
       vg_add_blob( proj, "vg/dep/sdl/SDL2.dll ", "" );
-      vg_library_dir( proj, "-L./vg/dep/sdl " );
+      vg_strcat( &conf->library, "-L./vg/dep/sdl " );
+
+      return vg_compiler_run( proj, env, conf, components.buffer, 
+                              appname, k_obj_type_exe );
+   }
+   else
+   {
+      vg_fatal_condition();
+      vg_info( "No compile procedure set for platform '%s'\n", 
+            platform_names[env->platform] );
+      vg_fatal_exit();
    }
 
-   vg_add_source( proj, config_string.buffer );
-   vg_add_source( proj, dep_proj.compiled_objects.buffer );
-   vg_add_source( proj, "\\\n" );
-   vg_include_dir( proj, "-I./vg/dep " );
-   vg_link( proj, "-lm " );
+   return (struct compile_result){};
 }
 
 void vg_add_controller_database( struct vg_project *proj )