code stringlengths 73 34.1k | label stringclasses 1
value |
|---|---|
public static Expr.VariableAccess extractAssignedVariable(LVal lval) {
if (lval instanceof Expr.VariableAccess) {
return (Expr.VariableAccess) lval;
} else if (lval instanceof Expr.RecordAccess) {
Expr.RecordAccess e = (Expr.RecordAccess) lval;
return extractAssignedVariable((LVal) e.getOperand());
} els... | java |
public static boolean isPure(SyntacticItem item) {
// Examine expression to determine whether this expression is impure.
if (item instanceof Expr.StaticVariableAccess || item instanceof Expr.Dereference || item instanceof Expr.New) {
return false;
} else if (item instanceof Expr.Invoke) {
Expr.Invoke e = (E... | java |
private void translateConstantDeclaration(WyilFile.Decl.StaticVariable decl) {
if (decl.hasInitialiser()) {
// The environments are needed to prevent clashes between variable
// versions across verification conditions, and also to type variables
// used in verification conditions.
GlobalEnvironment global... | java |
private void translateTypeDeclaration(WyilFile.Decl.Type declaration) {
WyilFile.Tuple<WyilFile.Expr> invariants = declaration.getInvariant();
WyalFile.Stmt.Block[] invariant = new WyalFile.Stmt.Block[invariants.size()];
WyalFile.Type type = convert(declaration.getType(), declaration);
WyalFile.VariableDeclarat... | java |
private void translateFunctionOrMethodDeclaration(WyilFile.Decl.FunctionOrMethod declaration) {
// Create the prototype for this function or method. This is the
// function or method declaration which can be used within verification
// conditions to refer to this function or method. This does not include
// a b... | java |
private void translatePreconditionMacros(WyilFile.Decl.FunctionOrMethod declaration) {
Tuple<WyilFile.Expr> invariants = declaration.getRequires();
//
for (int i = 0; i != invariants.size(); ++i) {
// Construct fresh environment for this macro. This is necessary to
// avoid name clashes with subsequent macr... | java |
private Context translateAssert(WyilFile.Stmt.Assert stmt, Context context) {
Pair<Expr, Context> p = translateExpressionWithChecks(stmt.getCondition(), null, context);
Expr condition = p.first();
context = p.second();
//
VerificationCondition verificationCondition = new VerificationCondition("assertion faile... | java |
private Context translateAssign(WyilFile.Stmt.Assign stmt, Context context) {
Tuple<WyilFile.LVal> lhs = stmt.getLeftHandSide();
Tuple<WyilFile.Expr> rhs = stmt.getRightHandSide();
WyilFile.LVal[][] lvals = new LVal[rhs.size()][];
Expr[][] rvals = new Expr[rhs.size()][];
// First, generate bundles
for (int ... | java |
private Context translateAssign(WyilFile.LVal[] lval, Expr[] rval, Context context) {
Expr[] ls = new Expr[lval.length];
for (int i = 0; i != ls.length; ++i) {
WyilFile.LVal lhs = lval[i];
generateTypeInvariantCheck(lhs.getType(), rval[i], context);
context = translateSingleAssignment(lval[i], rval[i], con... | java |
private Context translateSingleAssignment(WyilFile.LVal lval, Expr rval, Context context) {
// FIXME: this method is a bit of a kludge. It would be nicer,
// eventually, to have all right-hand side expression represented in
// WyTP directly. This could potentially be done by including an update
// operation in... | java |
private Context translateRecordAssign(WyilFile.Expr.RecordAccess lval, Expr rval, Context context) {
// Translate src expression
Pair<Expr, Context> p1 = translateExpressionWithChecks(lval.getOperand(), null, context);
Expr source = p1.first();
WyalFile.Identifier field = new WyalFile.Identifier(lval.getField()... | java |
private Context translateArrayAssign(WyilFile.Expr.ArrayAccess lval, Expr rval, Context context) {
// Translate src and index expressions
Pair<Expr, Context> p1 = translateExpressionWithChecks(lval.getFirstOperand(), null, context);
Pair<Expr, Context> p2 = translateExpressionWithChecks(lval.getSecondOperand(), n... | java |
private Context translateDereference(WyilFile.Expr.Dereference lval, Expr rval, Context context) {
Expr e = translateDereference(lval, context.getEnvironment());
return context.assume(new Expr.Equal(e, rval));
} | java |
private Context translateVariableAssign(WyilFile.Expr.VariableAccess lval, Expr rval, Context context) {
WyilFile.Decl.Variable decl = lval.getVariableDeclaration();
context = context.havoc(decl);
WyalFile.VariableDeclaration nVersionedVar = context.read(decl);
Expr.VariableAccess var = new Expr.VariableAccess(... | java |
private WyilFile.Expr.VariableAccess extractAssignedVariable(WyilFile.LVal lval) {
//
switch (lval.getOpcode()) {
case WyilFile.EXPR_arrayaccess:
case WyilFile.EXPR_arrayborrow:
Expr.ArrayAccess ae = (Expr.ArrayAccess) lval;
return extractAssignedVariable((LVal) ae.getSource());
case WyilFile.EXPR_deref... | java |
private Context translateBreak(WyilFile.Stmt.Break stmt, Context context) {
LoopScope enclosingLoop = context.getEnclosingLoopScope();
enclosingLoop.addBreakContext(context);
return null;
} | java |
private Context translateContinue(WyilFile.Stmt.Continue stmt, Context context) {
LoopScope enclosingLoop = context.getEnclosingLoopScope();
enclosingLoop.addContinueContext(context);
return null;
} | java |
private Context translateDoWhile(WyilFile.Stmt.DoWhile stmt, Context context) {
WyilFile.Decl.FunctionOrMethod declaration = (WyilFile.Decl.FunctionOrMethod) context.getEnvironment()
.getParent().enclosingDeclaration;
// Translate the loop invariant and generate appropriate macro
translateLoopInvariantMacros(... | java |
private Context translateFail(WyilFile.Stmt.Fail stmt, Context context) {
Expr condition = new Expr.Constant(new Value.Bool(false));
//
VerificationCondition verificationCondition = new VerificationCondition("possible panic", context.assumptions,
condition, stmt.getParent(WyilFile.Attribute.Span.class));
co... | java |
private Context translateIf(WyilFile.Stmt.IfElse stmt, Context context) {
//
Pair<Expr, Context> p = translateExpressionWithChecks(stmt.getCondition(), null, context);
Expr trueCondition = p.first();
// FIXME: this is broken as includes assumptions propagated through
// logical &&'s
context = p.second();
... | java |
private Context translateNamedBlock(WyilFile.Stmt.NamedBlock stmt, Context context) {
return translateStatementBlock(stmt.getBlock(), context);
} | java |
private Context translateReturn(WyilFile.Stmt.Return stmt, Context context) {
//
Tuple<WyilFile.Expr> returns = stmt.getReturns();
//
if (returns.size() > 0) {
// There is at least one return value. Therefore, we need to check
// any preconditions for those return expressions and, potentially,
// ensur... | java |
private void generateReturnTypeInvariantCheck(WyilFile.Stmt.Return stmt, Expr[] exprs, Context context) {
WyilFile.Decl.FunctionOrMethod declaration = (WyilFile.Decl.FunctionOrMethod) context.getEnvironment()
.getParent().enclosingDeclaration;
Tuple<WyilFile.Type> returnTypes = declaration.getType().getReturns(... | java |
private void generatePostconditionChecks(WyilFile.Stmt.Return stmt, Expr[] exprs, Context context) {
WyilFile.Decl.FunctionOrMethod declaration = (WyilFile.Decl.FunctionOrMethod) context.getEnvironment()
.getParent().enclosingDeclaration;
WyilFile.Tuple<WyilFile.Expr> postcondition = declaration.getEnsures();
... | java |
private Context translateSwitch(WyilFile.Stmt.Switch stmt, Context context) {
Tuple<WyilFile.Stmt.Case> cases = stmt.getCases();
//
Pair<Expr, Context> p = translateExpressionWithChecks(stmt.getCondition(), null, context);
Expr value = p.first();
context = p.second();
//
WyalFile.Stmt defaultValue = null;... | java |
private Context translateWhile(WyilFile.Stmt.While stmt, Context context) {
WyilFile.Decl.FunctionOrMethod declaration = (WyilFile.Decl.FunctionOrMethod) context.getEnvironment()
.getParent().enclosingDeclaration;
// Translate the loop invariant and generate appropriate macro
translateLoopInvariantMacros(stmt... | java |
private void translateLoopInvariantMacros(Stmt.Loop stmt, WyilFile.Decl.FunctionOrMethod declaration,
WyalFile wyalFile) {
//
Identifier[] prefix = declaration.getQualifiedName().toName().getAll();
Tuple<WyilFile.Expr> loopInvariant = stmt.getInvariant();
//
for (int i = 0; i != loopInvariant.size(); ++i) ... | java |
private Context translateVariableDeclaration(WyilFile.Decl.Variable stmt, Context context) {
if (stmt.hasInitialiser()) {
Pair<Expr, Context> p = translateExpressionWithChecks(stmt.getInitialiser(), null, context);
context = p.second();
generateTypeInvariantCheck(stmt.getType(), p.first(), context);
conte... | java |
private Expr translateAsUnknown(WyilFile.Expr expr, LocalEnvironment environment) {
// What we're doing here is creating a completely fresh variable to
// represent the return value. This is basically saying the return value
// could be anything, and we don't care what.
String name = "r" + Integer.toString(expr... | java |
private WyalFile.VariableDeclaration[] generateQuantifierTypePattern(WyilFile.Expr.Quantifier expr,
LocalEnvironment environment) {
//
Tuple<WyilFile.Decl.Variable> params = expr.getParameters();
WyalFile.VariableDeclaration[] vardecls = new WyalFile.VariableDeclaration[params.size()];
for (int i = 0; i != p... | java |
private WyalFile.Stmt implies(WyalFile.Stmt antecedent, WyalFile.Stmt consequent) {
if (antecedent == null) {
return consequent;
} else {
WyalFile.Stmt.Block antecedentBlock = new WyalFile.Stmt.Block(antecedent);
WyalFile.Stmt.Block consequentBlock = new WyalFile.Stmt.Block(consequent);
return new WyalF... | java |
private WyalFile.Stmt and(WyalFile.Stmt lhs, WyalFile.Stmt rhs) {
if (lhs == null) {
return rhs;
} else if (rhs == null) {
return rhs;
} else {
return new WyalFile.Stmt.Block(lhs, rhs);
}
} | java |
private WyalFile.Stmt or(WyalFile.Stmt lhs, WyalFile.Stmt rhs) {
if (lhs == null) {
return rhs;
} else if (rhs == null) {
return rhs;
} else {
WyalFile.Stmt.Block lhsBlock = new WyalFile.Stmt.Block(lhs);
WyalFile.Stmt.Block rhsBlock = new WyalFile.Stmt.Block(rhs);
return new WyalFile.Stmt.CaseOf(lh... | java |
private AssumptionSet updateVariableVersions(AssumptionSet assumptions, LocalEnvironment original,
LocalEnvironment updated) {
for (Map.Entry<WyilFile.Decl.Variable, WyalFile.VariableDeclaration> e : updated.locals.entrySet()) {
WyilFile.Decl.Variable var = e.getKey();
WyalFile.VariableDeclaration newVarVer... | java |
private LocalEnvironment joinEnvironments(Context... contexts) {
//
Context head = contexts[0];
GlobalEnvironment global = head.getEnvironment().getParent();
HashSet<WyilFile.Decl.Variable> modified = new HashSet<>();
HashSet<WyilFile.Decl.Variable> deleted = new HashSet<>();
Map<WyilFile.Decl.Variable, Wya... | java |
private void createFunctionOrMethodPrototype(WyilFile.Decl.FunctionOrMethod declaration) {
Tuple<WyilFile.Decl.Variable> params = declaration.getParameters();
Tuple<WyilFile.Decl.Variable> returns = declaration.getReturns();
//
WyalFile.VariableDeclaration[] parameters = new WyalFile.VariableDeclaration[params.... | java |
private void createAssertions(WyilFile.Decl declaration, List<VerificationCondition> vcs,
GlobalEnvironment environment) {
// FIXME: should be logged somehow?
for (int i = 0; i != vcs.size(); ++i) {
VerificationCondition vc = vcs.get(i);
// Build the actual verification condition
WyalFile.Stmt.Block ver... | java |
public WyalFile.Stmt.Block buildVerificationCondition(WyilFile.Decl declaration, GlobalEnvironment environment,
VerificationCondition vc) {
WyalFile.Stmt antecedent = flatten(vc.antecedent);
Expr consequent = vc.consequent;
HashSet<WyalFile.VariableDeclaration> freeVariables = new HashSet<>();
freeVariables(... | java |
private WyalFile.Stmt flatten(AssumptionSet assumptions) {
WyalFile.Stmt result = flattenUpto(assumptions, null);
if (result == null) {
return new Expr.Constant(new Value.Bool(true));
} else {
return result;
}
} | java |
private WyalFile.Stmt flattenUpto(AssumptionSet assumptions, AssumptionSet ancestor) {
if (assumptions == ancestor) {
// We have reached the ancestor
return null;
} else {
// Flattern parent assumptions
AssumptionSet[] parents = assumptions.parents;
WyalFile.Stmt e = null;
switch (parents.length)... | java |
private Expr determineVariableAliases(GlobalEnvironment environment,
Set<WyalFile.VariableDeclaration> freeVariables) {
Expr aliases = null;
for (WyalFile.VariableDeclaration var : freeVariables) {
WyalFile.VariableDeclaration parent = environment.getParent(var);
if (parent != null) {
// This indicates... | java |
private WyalFile.VariableDeclaration[] generatePreconditionParameters(WyilFile.Decl.Callable declaration,
LocalEnvironment environment) {
Tuple<WyilFile.Decl.Variable> params = declaration.getParameters();
WyalFile.VariableDeclaration[] vars = new WyalFile.VariableDeclaration[params.size()];
// second, set ini... | java |
private WyalFile.VariableDeclaration[] generatePostconditionTypePattern(WyilFile.Decl.FunctionOrMethod declaration,
LocalEnvironment environment) {
Tuple<Decl.Variable> params = declaration.getParameters();
Tuple<Decl.Variable> returns = declaration.getReturns();
WyalFile.VariableDeclaration[] vars = new WyalF... | java |
private WyalFile.VariableDeclaration[] generateLoopInvariantParameterDeclarations(Stmt.Loop loop,
LocalEnvironment environment) {
// Extract all used variables within the loop invariant. This is necessary to
// determine what parameters are required for the loop invariant macros.
Tuple<Decl.Variable> modified ... | java |
public Tuple<Decl.Variable> determineUsedVariables(Tuple<WyilFile.Expr> exprs) {
HashSet<Decl.Variable> used = new HashSet<>();
usedVariableExtractor.visitExpressions(exprs, used);
return new Tuple<>(used);
} | java |
public WyalFile.Name convert(QualifiedName id, SyntacticItem context) {
return convert(id.getUnit(), id.getName().get(), context);
} | java |
public WyalFile.Name convert(QualifiedName id, String suffix, SyntacticItem context) {
return convert(id.getUnit(), id.getName().get().concat(suffix), context);
} | java |
private static boolean typeMayHaveInvariant(Type type, Context context) {
if (type instanceof Type.Void) {
return false;
} else if (type instanceof Type.Null) {
return false;
} else if (type instanceof Type.Bool) {
return false;
} else if (type instanceof Type.Byte) {
return false;
} else if (type... | java |
public void freeVariables(SyntacticItem e, Set<WyalFile.VariableDeclaration> freeVars) {
if (e instanceof Expr.VariableAccess) {
Expr.VariableAccess va = (Expr.VariableAccess) e;
freeVars.add(va.getVariableDeclaration());
} else if (e instanceof Expr.Quantifier) {
Expr.Quantifier q = (Expr.Quantifier) e;
... | java |
private static <T> T[] removeNull(T[] items) {
int count = 0;
for (int i = 0; i != items.length; ++i) {
if (items[i] == null) {
count = count + 1;
}
}
if (count == 0) {
return items;
} else {
T[] rs = java.util.Arrays.copyOf(items, items.length - count);
for (int i = 0, j = 0; i != items.le... | java |
private boolean isApplicable(Type.Callable candidate, LifetimeRelation lifetimes,
Tuple<? extends SemanticType> args) {
Tuple<Type> parameters = candidate.getParameters();
if (parameters.size() != args.size()) {
// Differing number of parameters / arguments. Since we don't
// support variable-length argume... | java |
private Binding selectCallableCandidate(Name name, List<Binding> candidates, LifetimeRelation lifetimes) {
Binding best = null;
Type.Callable bestType = null;
boolean bestValidWinner = false;
//
for (int i = 0; i != candidates.size(); ++i) {
Binding candidate = candidates.get(i);
Type.Callable candidate... | java |
private boolean isSubtype(Type.Callable lhs, Type.Callable rhs, LifetimeRelation lifetimes) {
Tuple<Type> parentParams = lhs.getParameters();
Tuple<Type> childParams = rhs.getParameters();
if (parentParams.size() != childParams.size()) {
// Differing number of parameters / arguments. Since we don't
// suppo... | java |
private static int extractNonMatchingFields(Tuple<Type.Field> lhsFields, Tuple<Type.Field> rhsFields,
Type.Field[] result, int index) {
outer: for (int i = 0; i != lhsFields.size(); ++i) {
for (int j = 0; j != rhsFields.size(); ++j) {
Type.Field lhsField = lhsFields.get(i);
Type.Field rhsField = rhsFiel... | java |
public boolean apply() {
// FIXME: need to make this incremental
// Create initial set of patches.
List<Patch> patches = resolver.apply(target);
// Keep iterating until all patches are resolved
while (patches.size() > 0) {
// Create importer
Importer importer = new Importer(target, true);
// Now cont... | java |
private List<WyilFile> getExternals() throws IOException {
ArrayList<WyilFile> externals = new ArrayList<>();
List<Build.Package> pkgs = project.getPackages();
// Consider each package in turn and identify all contained WyilFiles
for (int i = 0; i != pkgs.size(); ++i) {
Build.Package p = pkgs.get(i);
// F... | java |
public void checkTypeDeclaration(Decl.Type decl) {
Environment environment = new Environment();
// Check type is contractive
checkContractive(decl);
// Check variable declaration is not empty
checkVariableDeclaration(decl.getVariableDeclaration(), environment);
// Check the type invariant
checkConditions(... | java |
public void checkStaticVariableDeclaration(Decl.StaticVariable decl) {
Environment environment = new Environment();
// Check type not void
checkVariableDeclaration(decl, environment);
} | java |
public void checkFunctionOrMethodDeclaration(Decl.FunctionOrMethod d) {
// Construct initial environment
Environment environment = new Environment();
// Update environment so this within declared lifetimes
environment = FlowTypeUtils.declareThisWithin(d, environment);
// Check parameters and returns are not e... | java |
private void checkReturnValue(Decl.FunctionOrMethod d, Environment last) {
if (d.match(Modifier.Native.class) == null && last != FlowTypeUtils.BOTTOM && d.getReturns().size() != 0) {
// In this case, code reaches the end of the function or method and,
// furthermore, that this requires a return value. To get he... | java |
private Environment checkBlock(Stmt.Block block, Environment environment, EnclosingScope scope) {
for (int i = 0; i != block.size(); ++i) {
Stmt stmt = block.get(i);
environment = checkStatement(stmt, environment, scope);
}
return environment;
} | java |
private Environment checkFail(Stmt.Fail stmt, Environment environment, EnclosingScope scope) {
return FlowTypeUtils.BOTTOM;
} | java |
private Environment checkVariableDeclarations(Tuple<Decl.Variable> decls, Environment environment) {
for (int i = 0; i != decls.size(); ++i) {
environment = checkVariableDeclaration(decls.get(i), environment);
}
return environment;
} | java |
private Environment checkVariableDeclaration(Decl.Variable decl, Environment environment) {
// Check type is sensible
checkNonEmpty(decl, environment);
// Check type of initialiser.
if (decl.hasInitialiser()) {
SemanticType type = checkExpression(decl.getInitialiser(), environment);
checkIsSubtype(decl.ge... | java |
private Environment checkAssign(Stmt.Assign stmt, Environment environment, EnclosingScope scope)
throws IOException {
Tuple<LVal> lvals = stmt.getLeftHandSide();
Type[] types = new Type[lvals.size()];
for (int i = 0; i != lvals.size(); ++i) {
types[i] = checkLVal(lvals.get(i), environment);
}
checkMulti... | java |
private Environment checkBreak(Stmt.Break stmt, Environment environment, EnclosingScope scope) {
// FIXME: need to check environment to the break destination
return FlowTypeUtils.BOTTOM;
} | java |
private Environment checkContinue(Stmt.Continue stmt, Environment environment, EnclosingScope scope) {
// FIXME: need to check environment to the continue destination
return FlowTypeUtils.BOTTOM;
} | java |
private Environment checkDebug(Stmt.Debug stmt, Environment environment, EnclosingScope scope) {
// FIXME: want to refine integer type here
Type std_ascii = new Type.Array(Type.Int);
SemanticType type = checkExpression(stmt.getOperand(), environment);
checkIsSubtype(std_ascii, type, environment, stmt.getOperand... | java |
private Environment checkDoWhile(Stmt.DoWhile stmt, Environment environment, EnclosingScope scope) {
// Type check loop body
environment = checkBlock(stmt.getBody(), environment, scope);
// Type check invariants
checkConditions(stmt.getInvariant(), true, environment);
// Determine and update modified variable... | java |
public Type checkLVal(LVal lval, Environment environment) {
Type type;
switch (lval.getOpcode()) {
case EXPR_variablecopy:
type = checkVariableLVal((Expr.VariableAccess) lval, environment);
break;
case EXPR_staticvariable:
type = checkStaticVariableLVal((Expr.StaticVariableAccess) lval, environment);
... | java |
public final void checkMultiExpressions(Tuple<Expr> expressions, Environment environment, Tuple<Type> expected) {
for (int i = 0, j = 0; i != expressions.size(); ++i) {
Expr expression = expressions.get(i);
switch (expression.getOpcode()) {
case EXPR_invoke: {
Tuple<Type> results = checkInvoke((Expr.Invo... | java |
private SemanticType checkConstant(Expr.Constant expr, Environment env) {
Value item = expr.getValue();
switch (item.getOpcode()) {
case ITEM_null:
return Type.Null;
case ITEM_bool:
return Type.Bool;
case ITEM_int:
return Type.Int;
case ITEM_byte:
return Type.Byte;
case ITEM_utf8:
// FIXME:... | java |
private SemanticType checkVariable(Expr.VariableAccess expr, Environment environment) {
Decl.Variable var = expr.getVariableDeclaration();
return environment.getType(var);
} | java |
private SemanticType checkIntegerOperator(Expr.BinaryOperator expr, Environment environment) {
checkOperand(Type.Int, expr.getFirstOperand(), environment);
checkOperand(Type.Int, expr.getSecondOperand(), environment);
return Type.Int;
} | java |
private void checkNonEmpty(Tuple<Decl.Variable> decls, LifetimeRelation lifetimes) {
for (int i = 0; i != decls.size(); ++i) {
checkNonEmpty(decls.get(i), lifetimes);
}
} | java |
private void checkNonEmpty(Decl.Variable d, LifetimeRelation lifetimes) {
if (relaxedSubtypeOperator.isVoid(d.getType(), lifetimes)) {
syntaxError(d.getType(), EMPTY_TYPE);
}
} | java |
public SemanticType.Array extractArrayType(SemanticType type, Environment environment,
ReadWriteTypeExtractor.Combinator<SemanticType.Array> combinator, SyntacticItem item) {
//
if (type != null) {
SemanticType.Array sourceArrayT = rwTypeExtractor.apply(type, environment, combinator);
//
if (sourceArray... | java |
public SemanticType extractElementType(SemanticType.Array type, SyntacticItem item) {
if (type == null) {
return null;
} else {
return type.getElement();
}
} | java |
public SemanticType.Record extractRecordType(SemanticType type, Environment environment,
ReadWriteTypeExtractor.Combinator<SemanticType.Record> combinator, SyntacticItem item) {
//
if (type != null) {
SemanticType.Record recordT = rwTypeExtractor.apply(type, environment, combinator);
//
if (recordT == n... | java |
public SemanticType extractFieldType(SemanticType.Record type, Identifier field) {
if (type == null) {
return null;
} else {
SemanticType fieldType = type.getField(field);
if (fieldType == null) {
// Indicates an invalid field selection
syntaxError(field, INVALID_FIELD);
}
return fieldType;
... | java |
public SemanticType.Reference extractReferenceType(SemanticType type, Environment environment,
ReadWriteTypeExtractor.Combinator<SemanticType.Reference> combinator, SyntacticItem item) {
//
if (type != null) {
SemanticType.Reference refT = rwTypeExtractor.apply(type, environment, combinator);
//
if (ref... | java |
public SemanticType extractElementType(SemanticType.Reference type, SyntacticItem item) {
if (type == null) {
return null;
} else {
return type.getElement();
}
} | java |
public Type.Callable extractLambdaType(SemanticType type, Environment environment,
ReadWriteTypeExtractor.Combinator<Type.Callable> combinator, SyntacticItem item) {
//
if (type != null) {
Type.Callable refT = rwTypeExtractor.apply(type, environment, combinator);
//
if (refT == null) {
syntaxError(i... | java |
public List<Token> scan() {
ArrayList<Token> tokens = new ArrayList<>();
pos = 0;
while (pos < input.length()) {
char c = input.charAt(pos);
if (isDigit(c)) {
tokens.add(scanNumericLiteral());
} else if (c == '"') {
tokens.add(scanStringLiteral());
} else if (c == '\'') {
tokens.add(scan... | java |
public Token scanIndent() {
int start = pos;
while (pos < input.length()
&& (input.charAt(pos) == ' ' || input.charAt(pos) == '\t')) {
pos++;
}
return new Token(Token.Kind.Indent, input.substring(start, pos), start);
} | java |
public void skipWhitespace(List<Token> tokens) {
while (pos < input.length()
&& (input.charAt(pos) == '\n' || input.charAt(pos) == '\t')) {
pos++;
}
} | java |
private static WyilFile compile(List<Path.Entry<WhileyFile>> sources, Path.Entry<WyilFile> target) throws IOException {
// Read target WyilFile. This may have already been compiled in a previous run
// and, in such case, we are invalidating some or all of the existing file.
WyilFile wyil = target.read();
// Par... | java |
public boolean contains(QualifiedName name) {
Name unit = name.getUnit();
// Get information associated with this unit
SymbolTable.Group group = symbolTable.get(unit);
return group != null && group.isValid(name.getName());
} | java |
public boolean isAvailable(QualifiedName name) {
SymbolTable.Group group = symbolTable.get(name.getUnit());
return group != null && group.isAvailable(name.getName());
} | java |
public List<Decl.Named> getRegisteredDeclarations(QualifiedName name) {
Group g = symbolTable.get(name.getUnit());
if (g != null) {
return g.getRegisteredDeclarations(name.getName());
} else {
return Collections.EMPTY_LIST;
}
} | java |
public void addAvailable(QualifiedName name, List<Decl.Named> available) {
ExternalGroup group = (ExternalGroup) symbolTable.get(name.getUnit());
//
for (int i = 0; i != available.size(); ++i) {
group.addAvailable(available.get(i));
}
} | java |
public void consolidate() {
Decl.Module module = target.getModule();
for(ExternalGroup group : consolidations) {
// TODO: this could be made way more efficient by collecting all consolidate
// units into one batch
module.putExtern(group.consolidate());
}
consolidations.clear();
} | java |
private Type.Field[] determinePivotFields(Tuple<Type.Field> lhsFields, Tuple<Type.Field> rhsFields,
LifetimeRelation lifetimes, LinkageStack stack) {
Type.Field[] pivots = new Type.Field[lhsFields.size()];
//
for (int i = 0; i != lhsFields.size(); ++i) {
Type.Field lhsField = lhsFields.get(i);
Identifier... | java |
@Override
public ControlFlow visitBlock(Stmt.Block block, DefinitelyAssignedSet environment) {
DefinitelyAssignedSet nextEnvironment = environment;
DefinitelyAssignedSet breakEnvironment = null;
for(int i=0;i!=block.size();++i) {
Stmt s = block.get(i);
ControlFlow nf = visitStatement(s, nextEnvironment);
... | java |
public static void syntaxError(SyntacticItem e, int code, SyntacticItem... context) {
WyilFile wf = (WyilFile) e.getHeap();
// Allocate syntax error in the heap));
SyntacticItem.Marker m = wf.allocate(new WyilFile.SyntaxError(code, e, new Tuple<>(context)));
// Record marker to ensure it gets written to disk
... | java |
private RValue[] packReturns(CallStack frame, Decl.Callable decl) {
if (decl instanceof Decl.Property) {
return new RValue[] { RValue.True };
} else {
Tuple<Decl.Variable> returns = decl.getReturns();
RValue[] values = new RValue[returns.size()];
for (int i = 0; i != values.length; ++i) {
values[i] ... | java |
private Status executeBlock(Stmt.Block block, CallStack frame, EnclosingScope scope) {
for (int i = 0; i != block.size(); ++i) {
Stmt stmt = block.get(i);
Status r = executeStatement(stmt, frame, scope);
// Now, see whether we are continuing or not
if (r != Status.NEXT) {
return r;
}
}
return S... | java |
private Status executeStatement(Stmt stmt, CallStack frame, EnclosingScope scope) {
switch (stmt.getOpcode()) {
case WyilFile.STMT_assert:
return executeAssert((Stmt.Assert) stmt, frame, scope);
case WyilFile.STMT_assume:
return executeAssume((Stmt.Assume) stmt, frame, scope);
case WyilFile.STMT_assign:
... | java |
private Status executeBreak(Stmt.Break stmt, CallStack frame, EnclosingScope scope) {
// TODO: the break bytecode supports a non-nearest exit and eventually
// this should be supported.
return Status.BREAK;
} | java |
private Status executeContinue(Stmt.Continue stmt, CallStack frame, EnclosingScope scope) {
return Status.CONTINUE;
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.