public String getStringValue(int v) throws IllegalArgumentException { if (!isStringConstant(v)) { throw new IllegalArgumentException("not a string constant: value number " + v); } return (String) ((ConstantValue) values[v]).getValue(); }
public String getStringValue(int v) throws IllegalArgumentException { if (!isStringConstant(v)) { throw new IllegalArgumentException("not a string constant: value number " + v); } return (String) ((ConstantValue) values[v]).getValue(); }
public TypeAbstraction getConstantType(int valueNumber) { if (ir.getSymbolTable().isStringConstant(valueNumber)) { return new PointType(cha.lookupClass(language.getStringType())); } else { return getConstantPrimitiveType(valueNumber); } }
@Override public IVariable makeVariable(int valueNumber) { SymbolTable st = ir.getSymbolTable(); if (st.isStringConstant(valueNumber)) { IClass klass = cha.lookupClass(TypeReference.JavaLangString); TypeAbstraction stringTypeAbs = new PointType(klass); return new TypeVariable(stringTypeAbs); } else { return super.makeVariable(valueNumber); } }
@Override public IVariable makeVariable(int valueNumber) { SymbolTable st = ir.getSymbolTable(); if (st.isStringConstant(valueNumber)) { IClass klass = cha.lookupClass(TypeReference.JavaLangString); TypeAbstraction stringTypeAbs = new PointType(klass); return new TypeVariable(stringTypeAbs); } else { return super.makeVariable(valueNumber); } }
public TypeAbstraction getConstantType(int valueNumber) { if (ir.getSymbolTable().isStringConstant(valueNumber)) { return new PointType(cha.lookupClass(language.getStringType())); } else { return getConstantPrimitiveType(valueNumber); } }
/** * Determine whether {@code invk} corresponds to a function declaration or function expression. * * TODO: A bit hackish. Is there a more principled way to do this? */ protected boolean isFunctionConstructorInvoke(JavaScriptInvoke invk) { /* * Function objects are allocated by explicit constructor invocations like this: * * v8 = global:global Function * v4 = construct v8@2 v6:#L<fullFunctionName> exception:<nd> */ if(invk.getDeclaredTarget().equals(JavaScriptMethods.ctorReference)) { int fn = invk.getFunction(); SSAInstruction fndef = du.getDef(fn); if(fndef instanceof AstGlobalRead) { AstGlobalRead agr = (AstGlobalRead)fndef; if(agr.getGlobalName().equals("global Function")) { if(invk.getNumberOfPositionalParameters() != 2) return false; // this may be a genuine use of "new Function()", not a declaration/expression if(!symtab.isStringConstant(invk.getUse(1))) return false; return true; } } } return false; } }
/** * Determine whether {@code invk} corresponds to a function declaration or function expression. * * TODO: A bit hackish. Is there a more principled way to do this? */ protected boolean isFunctionConstructorInvoke(JavaScriptInvoke invk) { /* * Function objects are allocated by explicit constructor invocations like this: * * v8 = global:global Function * v4 = construct v8@2 v6:#L<fullFunctionName> exception:<nd> */ if(invk.getDeclaredTarget().equals(JavaScriptMethods.ctorReference)) { int fn = invk.getFunction(); SSAInstruction fndef = du.getDef(fn); if(fndef instanceof AstGlobalRead) { AstGlobalRead agr = (AstGlobalRead)fndef; if(agr.getGlobalName().equals("global Function")) { if(invk.getNumberOfPositionalParameters() != 2) return false; // this may be a genuine use of "new Function()", not a declaration/expression if(!symtab.isStringConstant(invk.getUse(1))) return false; return true; } } } return false; } }
return makeFunctionConstructor(cls, cls); } else if (nargs == 1) { if (ST.isStringConstant(callStmt.getUse(1))) { TypeReference ref = TypeReference.findOrCreate(JavaScriptTypes.jsLoader, TypeName.string2TypeName(ST .getStringValue(callStmt.getUse(1)))); if (!ST.isStringConstant(callStmt.getUse(i))) return makeFunctionConstructor(cls, cls);
return makeFunctionConstructor(cls, cls); } else if (nargs == 1) { if (ST.isStringConstant(callStmt.getUse(1))) { TypeReference ref = TypeReference.findOrCreate(JavaScriptTypes.jsLoader, TypeName.string2TypeName(ST .getStringValue(callStmt.getUse(1)))); if (!ST.isStringConstant(callStmt.getUse(i))) return makeFunctionConstructor(cls, cls);
@Override public TypeAbstraction getConstantType(int valueNumber) { SymbolTable st = ir.getSymbolTable(); if (st.isStringConstant(valueNumber)) { return new PointType(cha.lookupClass(JavaScriptTypes.String)); } else if (st.isBooleanConstant(valueNumber)) { return new PointType(cha.lookupClass(JavaScriptTypes.Boolean)); } else if (st.isNullConstant(valueNumber)) { return new PointType(cha.lookupClass(JavaScriptTypes.Null)); } else { return new PointType(cha.lookupClass(JavaScriptTypes.Number)); } } }
@Override public TypeAbstraction getConstantType(int valueNumber) { SymbolTable st = ir.getSymbolTable(); if (st.isStringConstant(valueNumber)) { return new PointType(cha.lookupClass(JavaScriptTypes.String)); } else if (st.isBooleanConstant(valueNumber)) { return new PointType(cha.lookupClass(JavaScriptTypes.Boolean)); } else if (st.isNullConstant(valueNumber)) { return new PointType(cha.lookupClass(JavaScriptTypes.Null)); } else { return new PointType(cha.lookupClass(JavaScriptTypes.Number)); } } }
if (s.isStringConstant(i)) { TypeReference type = node.getMethod().getDeclaringClass().getClassLoader().getLanguage().getConstantType( s.getStringValue(i));
if (s.isStringConstant(i)) { TypeReference type = node.getMethod().getDeclaringClass().getClassLoader().getLanguage().getConstantType( s.getStringValue(i));
public void visitPutInternal(int rval, int ref, boolean isStatic, FieldReference field) { if (DEBUG) { System.err.println("visitPut " + field); } // skip putfields of primitive type if (field.getFieldType().isPrimitiveType()) { return; } IField f = getClassHierarchy().resolveField(field); if (f == null) { if (DEBUG) { System.err.println("Could not resolve field " + field); } Warnings.add(FieldResolutionFailure.create(field)); return; } assert f.getFieldTypeReference().getName().equals(field.getFieldType().getName()) : "name clash of two fields with the same name but different type: " + f.getReference() + " <=> " + field; assert isStatic || !symbolTable.isStringConstant(ref) : "put to string constant shouldn't be allowed?"; if (isStatic) { processPutStatic(rval, field, f); } else { processPutField(rval, ref, f); } }
public void visitPutInternal(int rval, int ref, boolean isStatic, FieldReference field) { if (DEBUG) { System.err.println("visitPut " + field); } // skip putfields of primitive type if (field.getFieldType().isPrimitiveType()) { return; } IField f = getClassHierarchy().resolveField(field); if (f == null) { if (DEBUG) { System.err.println("Could not resolve field " + field); } Warnings.add(FieldResolutionFailure.create(field)); return; } assert f.getFieldTypeReference().getName().equals(field.getFieldType().getName()) : "name clash of two fields with the same name but different type: " + f.getReference() + " <=> " + field; assert isStatic || !symbolTable.isStringConstant(ref) : "put to string constant shouldn't be allowed?"; if (isStatic) { processPutStatic(rval, field, f); } else { processPutField(rval, ref, f); } }
if (symbolTable.isStringConstant(invokeInstructions[0].getUse(1))) { String sym = symbolTable.getStringValue(use); if (DEBUG) {
if (symbolTable.isStringConstant(invokeInstructions[0].getUse(1))) { String sym = symbolTable.getStringValue(use); if (DEBUG) {
if (symbolTable.isStringConstant(use)) { String className = StringStuff.deployment2CanonicalTypeString(symbolTable.getStringValue(use)); TypeReference t = TypeReference.findOrCreate(caller.getMethod().getDeclaringClass().getClassLoader().getReference(),
if (symbolTable.isStringConstant(use)) { String className = StringStuff.deployment2CanonicalTypeString(symbolTable.getStringValue(use)); TypeReference t = TypeReference.findOrCreate(caller.getMethod().getDeclaringClass().getClassLoader().getReference(),