public void visit(ParameterAccessType parameterAccessType) { // TODO: type support // System.out.println(getExpression.getFieldName()+" "+param.getIndex()); Parameter param = parameterAccessType.getParam(); // TODO: check boxing methodByteCodeContext.load(param.getType(), methodByteCodeContext.getParamByteCodeIndex(param.getIndex()), "get param", getExpression.getFieldName()); lastExpressionType = param.getType(); } @Override
private ImmutableList<Parameter> convertParameters(Class<?>[] parameterTypes) { ArrayList<Parameter> parameters = new ArrayList<Parameter>(); for (int i = 0; i < parameterTypes.length; i++) { Class<?> paramClass = parameterTypes[i]; parameters.add( new Parameter( ExistingType.existing(paramClass), "arg"+i, i)); } return ImmutableList.from(parameters); }
public String getSignature() { StringBuilder signature = new StringBuilder("("); for (Parameter parameter : parameters) { signature.append(parameter.getType().getSignature()); } signature.append(")"); signature.append(returnType.getSignature()); return signature.toString(); }
private Parameter getParam(String fieldName) { Iterable<Parameter> parameters = method.getParameters(); for (Parameter parameter : parameters) { if (parameter.getName().equals(fieldName)) { return parameter; } } return null; }
MethodByteCodeContext(MethodContext methodContext) { Method method = methodContext.getMethod(); logger.fine(method.toString()); this.methodNode = new MethodNode(getAccess(method.getFlags()), method.getName(), method.getSignature(), null, null); this.methodContext = methodContext; Iterable<Parameter> parameters = methodContext.getMethod().getParameters(); if (!methodContext.getMethod().isStatic()) { currentLocalVariableByteCodeIndex = 1; } for (Parameter parameter : parameters) { paramIndexToBytecodeIndex.add(currentLocalVariableByteCodeIndex); incLocalVarIndex(parameter.getType()); } }
public void visit(ParameterAccessType parameterAccessType) { Type expressionType = evalExp(); // TODO: type support // System.out.println(getExpression.getFieldName()+" "+param.getIndex()); Parameter param = parameterAccessType.getParam(); // TODO: long and double take 2 slots // TODO: check boxing methodByteCodeContext.store( param.getType(), // TODO: static methods don't have this methodByteCodeContext.getParamByteCodeIndex(param.getIndex()), "set param", setStatement.getTo()); } public void visit(FieldAccessType fieldAccessType) {
private void loadParameters(String methodName, Method method, ImmutableList<Expression> parameters) { methodByteCodeContext.incIndent("pass", parameters.size(), "params to", methodName); ImmutableList<Expression> parameterValues = parameters; ImmutableList<Parameter> parameterTypes = method.getParameters(); if (parameterTypes.size() != parameterValues.size()) { throw new RuntimeException("parameters passed do not match, parameters declared in "+method); } for (int i = 0; i < parameterValues.size(); i++) { methodByteCodeContext.incIndent("param", i); Expression expression = parameterValues.get(i); Type expected = parameterTypes.get(i).getType(); expression.accept(this); methodByteCodeContext.handleConversion(lastExpressionType, expected, "param", i, "for", methodName); methodByteCodeContext.decIndent(); } methodByteCodeContext.decIndent(); }
/** * declares a parameter * @param type the type of the parameter * @param name the name of the parameter * @return this */ public ConstructorDeclarationBuilder param(Type type, String name) { return new ConstructorDeclarationBuilder( classIdentifier, protection, parameters.append(new Parameter(type, name, parameters.size())), methodHandler, builder); }
/** * declares a parameter * @param type the type of the parameter * @param name the name of the parameter * @return this */ public MethodDeclarationBuilder param(Type type, String name) { return new MethodDeclarationBuilder( builder, classIdentifier, memberFlags, returnType, methodName, methodHandler, parameters.append(new Parameter(type, name, parameters.size()))); }