path: root/src/jsifier.js

// Convert analyzed data to javascript

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

  var TYPES = data.types;

  // type
  substrate.addZyme('Type', {
    processItem: function(item) {
      var type = TYPES[item.name_];
      if (type.needsFlattening) {
        item.JS = 'var ' + toNiceIdent(item.name_) + '___FLATTENER = ' + JSON.stringify(TYPES[item.name_].flatIndexes) + ';';
      } else {
        item.JS = '// type: ' + item.name_;
      }
      item.__result__ = true;
      return [item];
    },
  });

  function makePointer(slab, pos, allocator) {
    // XXX hardcoded ptr impl
    if (slab == 'HEAP') return pos;
    if (slab[0] != '[') {
      slab = '[' + slab + ']';
    }
    return 'Pointer_make(' + slab + ', ' + (pos ? pos : 0) + (allocator ? ', ' + allocator : '') + ')';
  }

  function makeGetSlab(ptr) {
    // XXX hardcoded ptr impl
    //    return ptr + '.slab';
    return 'HEAP';
  }

  function makeGetPos(ptr) {
    // XXX hardcoded ptr impl
    //    return ptr + '.pos';
    return ptr;
  }

  function makeGetValue(ptr, pos, noNeedFirst) {
    return makeGetSlab(ptr) + '[' + (noNeedFirst ? '0' : makeGetPos(ptr)) + (pos ? ' + ' + pos : '') + ']';
  }

  function makeSetValue(ptr, pos, value, noNeedFirst) {
    if (SAFE_HEAP) {
      return 'SAFE_HEAP_STORE(' + (noNeedFirst ? '0' : makeGetPos(ptr)) + (pos ? ' + ' + pos : '') + ', ' + value + ')';
    } else {
      return makeGetSlab(ptr) + '[' + (noNeedFirst ? '0' : makeGetPos(ptr)) + (pos ? ' + ' + pos : '') + '] = ' + value;
    }
  }

  function makeEmptyStruct(type) {
    dprint('types', '??makeemptystruct?? ' + dump(type));
    // XXX hardcoded ptr impl
    var ret = [];
    var typeData = TYPES[type];
    assertTrue(typeData);
    for (var i = 0; i < typeData.flatSize; i++) {
      ret.push(0);
    }
    return ret;
  }

  function alignStruct(values, type) {
    dprint('types', 'alignStruct: ' + dump(type));
    // XXX hardcoded ptr impl
    var ret = [];
    var typeData = TYPES[type];
    assertTrue(typeData);
    var i = 0;
    while (i < values.length) {
      var currField = typeData.fields[i];
      var currValue = values[i];
      if (isStructType[currField]) {
        var fieldTypeData = TYPES[currField];
        assertTrue(fieldTypeData);
        ret = ret.concat(alignStruct(values.slice(i, fieldTypeData.fields.length), currField));
        i += fieldTypeData.fields.length;
      } else {
        ret.push(currValue);
        // pad to align, unless it's a structure and already aligned
        if (currValue[0] != '[') {
          ret = ret.concat(zeros(getNativeFieldSize(currField)-1));
        }
        i += 1;
      }
    }
    return ret;
  }

  // Gets an entire constant expression
  function parseConst(value, type) {
    dprint('gconst', '//yyyyy ' + JSON.stringify(value) + ',' + type + '\n');
    if (isNumberType(type) || pointingLevels(type) == 1) {
      return makePointer(parseNumerical(value.text), null, 'ALLOC_STATIC');
    } else if (value.text == 'zeroinitializer') {
      return makePointer(JSON.stringify(makeEmptyStruct(type)), null, 'ALLOC_STATIC');
    } else if (value.text && value.text[0] == '"') {
      value.text = value.text.substr(1, value.text.length-2);
      return makePointer(JSON.stringify(parseLLVMString(value.text)) + ' /* ' + value.text + '*/', null, 'ALLOC_STATIC');
    } else {
      // Gets an array of constant items, separated by ',' tokens
      function handleSegments(tokens) {
        // Handle a single segment (after comma separation)
        function handleSegment(segment) {
          dprint('gconst', '// seggg: ' + JSON.stringify(segment) + '\n' + '\n')
          if (segment[1].text == 'null') {
            return '0';
          } else if (segment[1].text == 'zeroinitializer') {
            return JSON.