~ubuntu-branches/ubuntu/trusty/emscripten/trusty-proposed

 

// 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);

    var ret = eval(str);

  });

}

 

// Simple #if/else/endif preprocessing for a file. Checks if the

// ident checked is true in our global.

function preprocess(text) {

  var lines = text.split('\n');

  var ret = '';

        ret += line + '\n';

      }

    } else {

          } else {

          }

        }

        showStack.push(!showStack.pop());

        showStack.pop();

      } else {

        throw "Unclear preprocessor command: " + line;

}

 

function isJSVar(ident) {

}

 

function isLocalVar(ident) {

}

 

function isStructPointerType(type) {

  return type[0] == '%';

}

 

function isStructuralType(type) {

  return /^{ ?[^}]* ?}$/.test(type); // { i32, i8 } etc. - anonymous struct types

}

}

 

function isIllegalType(type) {

}

 

function isVoidType(type) {

  if (nonPointing[0] != '(' || nonPointing.substr(-1) != ')')

    return false;

  if (nonPointing === '()') return true;

  var fail = false;

  segments.forEach(function(segment) {

    var subtext = segment[0].text;

    fail = fail || segment.length > 1 || !(isType(subtext) || subtext == '...');

    i--;

  }

  assert(argText);

}

 

function getReturnType(type) {

  if (pointingLevels(type) > 1) return '*'; // the type of a call can be either the return value, or the entire function. ** or more means it is a return value

  var lastOpen = type.lastIndexOf('(');

  if (lastOpen > 0) {

    return type.substr(0, lastOpen-1);

  }

  return type;

  return ret;

}

 

function addIdent(token) {

  token.ident = token.text;

  return token;

function splitTokenList(tokens) {

  if (tokens.length == 0) return [];

  if (!tokens.slice) tokens = tokens.tokens;

  var ret = [];

  var seg = [];

  for (var i = 0; i < tokens.length; i++) {

      seg = [];

    } else if (token.text == ';') {

      ret.push(seg);

    } else {

      seg.push(token);

    }

  }

  return ret;

}

 

function parseParamTokens(params) {

  if (params.length === 0) return [];

  var ret = [];

  var anonymousIndex = 0;

  while (params.length > 0) {

    var i = 0;

    var segment = params.slice(0, i);

    params = params.slice(i+1);

    segment = cleanSegment(segment);

      // handle 'byval' and 'byval align X'. We store the alignment in 'byVal'

      byVal = QUANTUM_SIZE;

      segment.splice(1, 1);

        segment.splice(1, 1);

      }

      if (segment[1] && segment[1].text === 'align') {

        segment.splice(1, 2);

      }

    }

      segment.splice(1, 1);

    }

    if (segment.length == 1) {

        Types.needAnalysis[ret[ret.length-1].type] = 0;

        anonymousIndex ++;

      }

    } else {

      if (segment[2] && segment[2].text == 'to') { // part of bitcast params

        segment = segment.slice(0, 2);

      }

    }

    ret[ret.length-1].byVal = byVal;

  }

  });

}

 

// Segment ==> Parameter

function parseLLVMSegment(segment) {

  var type;

    return parseBlockAddress(segment);

  } else {

    type = segment[0].text;

    Types.needAnalysis[type] = 0;

    return {

      intertype: 'value',

}

 

function cleanSegment(segment) {

    segment.splice(1, 1);

  }

  return segment;

 

var MATHOPS = set(['add', 'sub', 'sdiv', 'udiv', 'mul', 'icmp', 'zext', 'urem', 'srem', 'fadd', 'fsub', 'fmul', 'fdiv', 'fcmp', 'frem', 'uitofp', 'sitofp', 'fpext', 'fptrunc', 'fptoui', 'fptosi', 'trunc', 'sext', 'select', 'shl', 'shr', 'ashl', 'ashr', 'lshr', 'lshl', 'xor', 'or', 'and', 'ptrtoint', 'inttoptr']);

 

var PARSABLE_LLVM_FUNCTIONS = set('getelementptr', 'bitcast');

mergeInto(PARSABLE_LLVM_FUNCTIONS, MATHOPS);

 

  segment = cleanSegment(segment);

  // Remove additional modifiers

  var variant = null;

    variant = segment.splice(2, 1)[0];

    if (variant && variant.text) variant = variant.text; // needed for mathops

  }

  assertTrue(['inreg', 'byval'].indexOf(segment[1].text) == -1);

  assert(segment[1].text in PARSABLE_LLVM_FUNCTIONS);

    segment.splice(2, 1); // Remove modifiers

    if (!segment[2]) throw 'Invalid segment!';

  }

  if (type === '?') {

    if (intertype === 'getelementptr') {

      type = '*'; // a pointer, we can easily say, this is

    }

  }

  var ret = {

    intertype: intertype,

    variant: variant,

    type: type,

  };

  Types.needAnalysis[ret.type] = 0;

  ret.ident = toNiceIdent(ret.params[0].ident || 'NOIDENT');

  if (floatConversion && ASM_JS) lowInput = asmFloatToInt(lowInput);

  var low = lowInput + '>>>0';

  var high = makeInlineCalculation(

      '(VALUE > ' + asmEnsureFloat('0', 'double') + ' ? ' +

      ')' +

    ' : 0',

    value,

}

 

function parseNumerical(value, type) {

    // Hexadecimal double value, as the llvm docs say,

    // "The one non-intuitive notation for constants is the hexadecimal form of floating point constants."

    value = IEEEUnHex(value);

  } else if (USE_TYPED_ARRAYS == 2 && isIllegalType(type)) {

    return value; // do not parseFloat etc., that can lead to loss of precision

    // NULL *is* 0, in C/C++. No JS null! (null == 0 is false, etc.)

    value = '0';

  } else if (value === 'true') {

  }

  if (isNumber(value)) {

    var ret = parseFloat(value); // will change e.g. 5.000000e+01 to 50

    return ret.toString();

  } else {

    return value;

  var ret = [];

  var i = 0;

  while (i < str.length) {

      i++;

    } else {

      i += 3;

    }

  }

  return ret;

}

 

function getLabelIds(labels) {

  return labels.map(function(label) { return label.ident });

}

}

 

function calcAllocatedSize(type) {

}

 

// Generates the type signature for a structure, for each byte, the type that is there.

  var ret = new Array(size);

  var index = 0;

  function add(typeData) {

    var start = index;

      if (!SAFE_HEAP && isPointerType(type)) type = '*'; // do not include unneeded type names without safe heap

      if (Runtime.isNumberType(type) || isPointerType(type)) {

        if (USE_TYPED_ARRAYS == 2 && type == 'i64') {

        }

        add(Types.types[type]);

      }

      for (var j = 0; j < more; j++) {

        ret[index++] = 0;

      }

  return js;

}

 

function asmEnsureFloat(value, type) { // ensures that a float type has either 5.5 (clearly a float) or +5 (float due to asm coercion)

  if (!ASM_JS) return value;

  } else {

    return value;

  }

}

 

  if (type in Runtime.FLOAT_TYPES) {

  } else {

    return '0';

  }

          value = '(' + value + ')|0';

        }

      }

    }

  } else {

    return '((' + value + ')|0)';

    var typeData = Types.types[type];

    var ret = [];

    for (var i = 0; i < typeData.fields.length; i++) {

    }

    return '{ ' + ret.join(', ') + ' }';

  }

  // In double mode 1, in x86 we always assume unaligned because we can't trust that; otherwise in le32

  // we need this code path if we are not fully aligned.

  if (DOUBLE_MODE == 1 && USE_TYPED_ARRAYS == 2 && type == 'double' && (TARGET_X86 || align < 8)) {

            makeGetTempDouble(0, 'double') + ')';

  }

 

      if (isIntImplemented(type)) {

        if (bytes == 4 && align == 2) {

          // Special case that we can optimize

        } else { // XXX we cannot truly handle > 4... (in x86)

          ret = '';

          for (var i = 0; i < bytes; i++) {

            if (i < bytes-1) ret += '|';

          }

          ret = '(' + makeSignOp(ret, type, unsigned ? 'un' : 're', true);

      value = range(typeData.fields.length).map(function(i) { return value + '.f' + i });

    }

    for (var i = 0; i < typeData.fields.length; i++) {

    }

    return ret.join('; ');

  }

        if (bytes == 4 && align == 2) {

          // Special case that we can optimize

          ret += 'tempBigInt=' + value + sep;

        } else {

          ret += 'tempBigInt=' + value + sep;

          for (var i = 0; i < bytes; i++) {

            if (i < bytes-1) ret += sep + 'tempBigInt = tempBigInt>>8' + sep;

          }

        }

      } else {

        ret += makeCopyValues(getFastValue(ptr, '+', pos), 'tempDoublePtr', Runtime.getNativeTypeSize(type), type, null, align, sep);

      }

      return ret;

 

  value = indexizeFunctions(value, type);

  var offset = calcFastOffset(ptr, pos, noNeedFirst);

  if (SAFE_HEAP && !noSafe) {

    var printType = type;

    if (printType !== 'null' && printType[0] !== '#') printType = '"' + safeQuote(printType) + '"';

    // If we don't know how to handle this at compile-time, or handling it is best done in a large amount of code, call memset

    // TODO: optimize the case of numeric num but non-numeric value

    if (!isNumber(num) || !isNumber(value) || (parseInt(num)/align >= UNROLL_LOOP_MAX)) {

    }

    num = parseInt(num);

    value = parseInt(value);

  return 'HEAP' + which + '.subarray((' + start + ')' + mod + ',(' + end + ')' + mod + ')';

}

 

var TWO_TWENTY = Math.pow(2, 20);

 

// Given two values and an operation, returns the result of that operation.

// Tries to do as much as possible at compile time.

// Leaves overflows etc. unhandled, *except* for integer multiply, in order to be efficient with Math.imul

function getFastValue(a, op, b, type) {

    }

  }

      return '(1 << (' + b + '))';

    }

  }

    var c = b;

    b = a;

    a = c;

  }