path: root/src/jsifier.js

//"use strict";

// Convert analyzed data to javascript. Everything has already been calculated
// before this stage, which just does the final conversion to JavaScript.

// Handy sets

var STRUCT_LIST = set('struct', 'list');
var UNDERSCORE_OPENPARENS = set('_', '(');

// JSifier
function JSify(data, functionsOnly, givenFunctions) {
  var mainPass = !functionsOnly;

  if (mainPass) {
    // We will start to print out the data, but must do so carefully - we are
    // dealing with potentially *huge* strings. Convenient replacements and
    // manipulations may create in-memory copies, and we may OOM.
    //
    // Final shape that will be created:
    //    shell
    //      (body)
    //        preamble
    //          runtime
    //        generated code
    //        postamble
    //          global_vars
    //
    // First, we print out everything until the generated code. Then the
    // functions will print themselves out as they are parsed. Finally, we
    // will call finalCombiner in the main pass, to print out everything
    // else. This lets us not hold any strings in memory, we simply print
    // things out as they are ready.

    var shellFile = BUILD_AS_SHARED_LIB ? 'shell_sharedlib.js' : 'shell.js';
    var shellParts = read(shellFile).split('{{BODY}}');
    print(shellParts[0]);
    var preFile = BUILD_AS_SHARED_LIB ? 'preamble_sharedlib.js' : 'preamble.js';
    var pre = processMacros(preprocess(read(preFile).replace('{{RUNTIME}}', getRuntime())));
    print(pre);
    print('Runtime.QUANTUM_SIZE = ' + QUANTUM_SIZE);

    Functions.implementedFunctions = set(data.unparsedFunctions.map(function(func) { return func.ident }));
  }

  // Does simple 'macro' substitution, using Django-like syntax,
  // {{{ code }}} will be replaced with |eval(code)|.
  function processMacros(text) {
    return text.replace(/{{{[^}]+}}}/g, function(str) {
      str = str.substr(3, str.length-6);
      return eval(str).toString();
    });
  }

  var substrate = new Substrate('JSifyer');

  if (mainPass) {
    // Handle unparsed types TODO: Batch them
    analyzer(intertyper(data.unparsedTypess[0].lines, true));
    data.unparsedTypess = null;

    // Add additional necessary items for the main pass. We can now do this since types are parsed (types can be used through
    // generateStructInfo in library.js)
    LibraryManager.load();
    var libFuncsToInclude;
    if (INCLUDE_FULL_LIBRARY) {
      assert(!BUILD_AS_SHARED_LIB, 'Cannot have both INCLUDE_FULL_LIBRARY and BUILD_AS_SHARED_LIB set.')
      libFuncsToInclude = [];
      for (var key in LibraryManager.library) {
        if (!key.match(/__(deps|postset)$/)) {
          libFuncsToInclude.push(key);
        }
      }
    } else {
      libFuncsToInclude = ['memset', 'malloc', 'free'];
    }
    libFuncsToInclude.forEach(function(ident) {
      data.functionStubs.push({
        intertype: 'functionStub',
        ident: '_' + ident
      });
    });
  }

  // Functions

  Functions.currFunctions = !mainPass ? givenFunctions.currFunctions : {};
  Functions.currExternalFunctions = !mainPass ? givenFunctions.currExternalFunctions : {};

  // Now that first-pass analysis has completed (so we have basic types, etc.), we can get around to handling unparsedFunctions
  (!mainPass ? data.functions : data.unparsedFunctions.concat(data.functions)).forEach(function(func) {
    // Save just what we need, to save memory
    Functions.currFunctions[func.ident] = {
      hasVarArgs: func.hasVarArgs,
      numParams: func.params.length,
      labelIds: func.labelIds // TODO: We need this for globals, but perhaps we can calculate them early and free this
   };
  });