bootstrap init

internal/engine.cm

@@ -1,4 +1,5 @@
-// Hidden vars (os, actorsym, init, core_path, shop_path, analyze, run_ast_fn, run_ast_noopt_fn, json, use_cache, content_hash, cache_path, ensure_build_dir, compile_to_blob_fn) come from env
+// Hidden vars (os, actorsym, init, core_path, shop_path, json, args) come from env
+// Engine is self-sufficient: defines its own compilation pipeline
 var ACTORDATA = actorsym
 var SYSYM = '__SYSTEM__'
 
@@ -14,7 +15,7 @@ var cases = {
 var dylib_ext = cases[os.platform()]
 
 var MOD_EXT = '.cm'
-var ACTOR_EXT = '.ce'  
+var ACTOR_EXT = '.ce'
 
 var load_internal = os.load_internal
 function use_embed(name) {
@@ -47,11 +48,159 @@ function ends_with(str, suffix) {
 
 var fd = use_embed('internal_fd')
 var js = use_embed('js')
+var crypto = use_embed('crypto')
 
-// core_path and shop_path come from env (bootstrap.cm passes them through)
+// core_path and shop_path come from env (C runtime passes them through)
 // shop_path may be null if --core was used without --shop
 var packages_path = shop_path ? shop_path + '/packages' : null
 
+// Self-sufficient initialization: content-addressed cache
+var use_cache = {}
+
+function content_hash(content) {
+  return text(crypto.blake2(content), 'h')
+}
+
+function cache_path(hash) {
+  if (!shop_path) return null
+  return shop_path + '/build/' + hash
+}
+
+function ensure_build_dir() {
+  if (!shop_path) return null
+  var dir = shop_path + '/build'
+  if (!fd.is_dir(dir)) fd.mkdir(dir)
+  return dir
+}
+
+// Load a pipeline module from cache, with boot/ seed fallback
+function load_pipeline_module(name, env) {
+  var source_path = core_path + '/' + name + '.cm'
+  var source_blob = null
+  var hash = null
+  var cached = null
+  var mcode_path = null
+  var mcode_blob = null
+  var mach_blob = null
+  if (fd.is_file(source_path)) {
+    source_blob = fd.slurp(source_path)
+    hash = content_hash(source_blob)
+    cached = cache_path(hash)
+    if (cached && fd.is_file(cached))
+      return mach_load(fd.slurp(cached), env)
+  }
+  // Boot seed fallback
+  mcode_path = core_path + '/boot/' + name + '.cm.mcode'
+  if (fd.is_file(mcode_path)) {
+    mcode_blob = fd.slurp(mcode_path)
+    mach_blob = mach_compile_mcode_bin(name, text(mcode_blob))
+    return mach_load(mach_blob, env)
+  }
+  print("error: cannot load pipeline module: " + name + "\n")
+  disrupt
+}
+
+// Load compilation pipeline
+var pipeline_env = {use: use_embed}
+var tokenize_mod = load_pipeline_module('tokenize', pipeline_env)
+var parse_mod = load_pipeline_module('parse', pipeline_env)
+var fold_mod = load_pipeline_module('fold', pipeline_env)
+var mcode_mod = load_pipeline_module('mcode', pipeline_env)
+var streamline_mod = load_pipeline_module('streamline', pipeline_env)
+
+use_cache['tokenize'] = tokenize_mod
+use_cache['parse'] = parse_mod
+use_cache['fold'] = fold_mod
+use_cache['mcode'] = mcode_mod
+use_cache['core/mcode'] = mcode_mod
+use_cache['streamline'] = streamline_mod
+use_cache['core/streamline'] = streamline_mod
+
+// analyze: tokenize + parse + fold, check for errors
+function analyze(src, filename) {
+  var tok_result = tokenize_mod(src, filename)
+  var _ast = parse_mod(tok_result.tokens, src, filename, tokenize_mod)
+  var _i = 0
+  var prev_line = -1
+  var prev_msg = null
+  var e = null
+  var msg = null
+  var line = null
+  var col = null
+  var has_errors = _ast.errors != null && length(_ast.errors) > 0
+  if (has_errors) {
+    while (_i < length(_ast.errors)) {
+      e = _ast.errors[_i]
+      msg = e.message
+      line = e.line
+      col = e.column
+      if (msg != prev_msg || line != prev_line) {
+        if (line != null && col != null)
+          print(`${filename}:${text(line)}:${text(col)}: error: ${msg}`)
+        else
+          print(`${filename}: error: ${msg}`)
+      }
+      prev_line = line
+      prev_msg = msg
+      _i = _i + 1
+    }
+    disrupt
+  }
+  return fold_mod(_ast)
+}
+
+// Lazy-loaded verify_ir module (loaded on first use)
+var _verify_ir_mod = null
+
+// Run AST through mcode pipeline -> register VM
+function run_ast_fn(name, ast, env) {
+  var compiled = mcode_mod(ast)
+  if (os._verify_ir) {
+    if (_verify_ir_mod == null) {
+      _verify_ir_mod = load_pipeline_module('verify_ir', pipeline_env)
+    }
+    compiled._verify = true
+    compiled._verify_mod = _verify_ir_mod
+  }
+  var optimized = streamline_mod(compiled)
+  if (optimized._verify) {
+    delete optimized._verify
+    delete optimized._verify_mod
+  }
+  var mcode_json = json.encode(optimized)
+  var mach_blob = mach_compile_mcode_bin(name, mcode_json)
+  return mach_load(mach_blob, env)
+}
+
+// Run AST through mcode pipeline WITHOUT optimization -> register VM
+function run_ast_noopt_fn(name, ast, env) {
+  var compiled = mcode_mod(ast)
+  var mcode_json = json.encode(compiled)
+  var mach_blob = mach_compile_mcode_bin(name, mcode_json)
+  return mach_load(mach_blob, env)
+}
+
+// Compile AST to blob without loading (for caching)
+function compile_to_blob(name, ast) {
+  var compiled = mcode_mod(ast)
+  var optimized = streamline_mod(compiled)
+  return mach_compile_mcode_bin(name, json.encode(optimized))
+}
+
+// If loaded directly by C runtime (not via bootstrap), convert args -> init
+var _program = null
+var _user_args = []
+var _j = 1
+var _init = init
+if (args != null && _init == null) {
+  _program = args[0]
+  while (_j < length(args)) {
+    push(_user_args, args[_j])
+    _j = _j + 1
+  }
+  _init = {program: _program, arg: _user_args}
+}
+
 use_cache['core/os'] = os
 
 // Extra env properties added as engine initializes (log, runtime fns, etc.)
@@ -68,8 +217,6 @@ function use_core(path) {
   var result = null
   var script = null
   var ast = null
-  var mcode_path = null
-  var mcode_blob = null
   var _load_mod = null
 
   // Build env: merge core_extras
@@ -82,32 +229,6 @@ function use_core(path) {
   var source_blob = null
   var file_path = null
 
-  // Check for pre-compiled .cm.mcode JSON IR (generated by regen)
-  mcode_path = core_path + '/boot/' + replace(path, '/', '_') + '.cm.mcode'
-  if (fd.is_file(mcode_path)) {
-    _load_mod = function() {
-      mcode_blob = fd.slurp(mcode_path)
-      hash = content_hash(mcode_blob)
-      cached_path = cache_path(hash)
-      if (cached_path && fd.is_file(cached_path)) {
-        result = mach_load(fd.slurp(cached_path), env)
-      } else {
-        mach_blob = mach_compile_mcode_bin('core:' + path, text(mcode_blob))
-        if (cached_path) {
-          ensure_build_dir()
-          fd.slurpwrite(cached_path, mach_blob)
-        }
-        result = mach_load(mach_blob, env)
-      }
-    } disruption {
-      print("use('" + path + "'): failed to load from " + mcode_path + "\n")
-      disrupt
-    }
-    _load_mod()
-    use_cache[cache_key] = result
-    return result
-  }
-
   // Compile from source .cm file
   file_path = core_path + '/' + path + MOD_EXT
   if (fd.is_file(file_path)) {
@@ -120,7 +241,7 @@ function use_core(path) {
       } else {
         script = text(source_blob)
         ast = analyze(script, file_path)
-        mach_blob = compile_to_blob_fn('core:' + path, ast)
+        mach_blob = compile_to_blob('core:' + path, ast)
         if (cached_path) {
           ensure_build_dir()
           fd.slurpwrite(cached_path, mach_blob)
@@ -230,7 +351,7 @@ function actor_die(err)
 
 //actor_mod.on_exception(actor_die)
 
-_cell.args = init != null ? init : {}
+_cell.args = _init != null ? _init : {}
 _cell.id = "newguy"
 
 function create_actor(desc) {
@@ -245,7 +366,7 @@ $_.self = create_actor()
 
 use_cache['core/json'] = json
 
-// Create runtime_env early (empty) — filled after pronto loads.
+// Create runtime_env early (empty) -- filled after pronto loads.
 // Shop accesses it lazily (in inject_env, called at module-use time, not load time)
 // so it sees the filled version.
 var runtime_env = {}
@@ -266,8 +387,9 @@ core_extras.runtime_env = runtime_env
 core_extras.content_hash = content_hash
 core_extras.cache_path = cache_path
 core_extras.ensure_build_dir = ensure_build_dir
+core_extras.compile_to_blob = compile_to_blob
 
-// NOW load shop — it receives all of the above via env
+// NOW load shop -- it receives all of the above via env
 var shop = use_core('internal/shop')
 var time = use_core('time')
 
@@ -388,7 +510,7 @@ REPLYTIMEOUT = config.reply_timeout
     replycc: the actor that is waiting for the reply
     target: ID of the actor that's supposed to receive the message. Only added to non direct sends (out of portals)
     return: reply ID so the replycc actor can know what callback to send the message to
-    
+
     data: the actual content of the message
   }
 
@@ -459,7 +581,7 @@ $_.connection = function(callback, actor, config) {
     callback({type:"local"})
     return
   }
-  
+
   callback()
 }
 
@@ -540,10 +662,10 @@ $_.start = function start(cb, program) {
     if (!program) return
 
     var id = guid()
-    var startup = { 
-      id, 
-      overling: $_.self, 
-      root, 
+    var startup = {
+      id,
+      overling: $_.self,
+      root,
       program,
     }
     greeters[id] = cb
@@ -749,7 +871,7 @@ actor_mod.register_actor(_cell.id, turn, true, config.ar_timer)
 
 if (config.actor_memory)
   js.mem_limit(config.actor_memory)
-  
+
 if (config.stack_max)
   js.max_stacksize(config.system.stack_max);
 
@@ -862,7 +984,7 @@ function handle_message(msg) {
 function enet_check()
 {
   if (portal) portal.service(handle_host)
-  
+
   $_.delay(enet_check, ENETSERVICE);
 }
 
@@ -941,7 +1063,7 @@ $_.clock(_ => {
   } else {
     script = text(source_blob)
     ast = analyze(script, prog_path)
-    mach_blob = compile_to_blob_fn(prog, ast)
+    mach_blob = compile_to_blob(prog, ast)
     if (cached_path) {
       ensure_build_dir()
       fd.slurpwrite(cached_path, mach_blob)