path: root/src/jsifier.js

// Convert analyzed data to javascript

function JSify(data) {
  substrate = new Substrate('JSifyer');

  var TYPES = data.types;
  var FUNCTIONS = {};
  data.functions.forEach(function(func) {
    FUNCTIONS[func.ident] = func;
  });

  // type
  substrate.addZyme('Type', {
    processItem: function(item) {
      var type = TYPES[item.name_];
      var niceName = toNiceIdent(item.name_)
      // We might export all of TYPES, cleaner that way, but do not want slowdowns in accessing flatteners
      item.JS = 'var ' + niceName + '___SIZE = ' + TYPES[item.name_].flatSize + '; // ' + item.name_ + '\n';
      if (type.needsFlattening && !type.flatFactor) {
        item.JS += 'var ' + niceName + '___FLATTENER = ' + JSON.stringify(TYPES[item.name_].flatIndexes) + ';';
      }
      item.__result__ = true;
      return [item];
    },
  });

  function makePointer(slab, pos, allocator, type) { // type is FFU
    if (slab in set('HEAP', 'IHEAP', 'FHEAP')) return pos;
    if (slab[0] != '[') {
      slab = '[' + slab + ']';
    }
    return 'Pointer_make(' + slab + ', ' + (pos ? pos : 0) + (allocator ? ', ' + allocator : '') + ')';
  }

  function makeGetSlab(ptr, type) {
    assert(type);
    if (!USE_TYPED_ARRAYS) {
      return 'HEAP';
    } else {
      if (type in Runtime.FLOAT_TYPES || type === 'int64') {
        return 'FHEAP';
      } else if (type in Runtime.INT_TYPES || isPointerType(type)) {
        return 'IHEAP';
      } else {
        return 'HEAP';
      }
    }
  }

  function makeGetPos(ptr) {
    return ptr;
  }

  function calcFastOffset(ptr, pos, noNeedFirst) {
    var offset = noNeedFirst ? '0' : makeGetPos(ptr);
    return getFastValue(offset, '+', pos);
  }

  function makeGetValue(ptr, pos, noNeedFirst, type) {
    if (isStructType(type)) {
      var typeData = TYPES[type];
      var ret = [];
      for (var i = 0; i < typeData.fields.length; i++) {
        ret.push('f' + i + ': ' + makeGetValue(ptr, pos + typeData.flatIndexes[i], noNeedFirst, typeData.fields[i]));
      }
      return '{ ' + ret.join(', ') + ' }';
    }

    return makeGetSlab(ptr, type) + '[' + calcFastOffset(ptr, pos, noNeedFirst) + ']';
  }

  function indexizeFunctions(value) { // TODO: Also check for other functions (externals, library, etc.)
    if (value in FUNCTIONS) {
      value = value + '.__index__'; // Store integer value
    }
    return value;
  }

  function makeSetValue(ptr, pos, value, noNeedFirst, type) {
    if (isStructType(type)) {
      var typeData = TYPES[type];
      var ret = [];
      for (var i = 0; i < typeData.fields.length; i++) {
        ret.push(makeSetValue(ptr, pos + typeData.flatIndexes[i], value[i], noNeedFirst, typeData.fields[i]));
      }
      return ret.join('; ');
    }

    value = indexizeFunctions(value);
    var offset = calcFastOffset(ptr, pos, noNeedFirst);
    if (SAFE_HEAP) {
      return 'SAFE_HEAP_STORE(' + offset + ', ' + value + ')';
    } else {
      return makeGetSlab(ptr, type) + '[' + offset + '] = ' + value;
    }