/** * Prints an entire subpopulation in a form readable by humans but also parseable by the computer * using readSubpopulation(EvolutionState, LineNumberReader) with a verbosity of * Output.V_NO_GENERAL. */ public void printSubpopulation(final EvolutionState state, final int log) { state.output.println(NUM_INDIVIDUALS_PREAMBLE + Code.encode(individuals.length), log); for (int i = 0; i < individuals.length; i++) { state.output.println(INDIVIDUAL_INDEX_PREAMBLE + Code.encode(i), log); individuals[i].printIndividual(state, log); } }
/** * Prints an entire subpopulation in a form readable by humans but also parseable by the computer * using readSubpopulation(EvolutionState, LineNumberReader). */ public void printSubpopulation(final EvolutionState state, final PrintWriter writer) { writer.println(NUM_INDIVIDUALS_PREAMBLE + Code.encode(individuals.length)); for (int i = 0; i < individuals.length; i++) { writer.println(INDIVIDUAL_INDEX_PREAMBLE + Code.encode(i)); individuals[i].printIndividual(state, writer); } }
private Code readEmpty( int opcode, boolean wideBase, boolean wideRest, int offset, HashMap<Integer, Code.Label> labels) throws IOException { switch (opcode) { case Code.OPCODE_const: { int target = readBase(wideBase); int idx = readRest(wideRest); Constant c = constantPool[idx]; return Code.Const(target, c); } case Code.OPCODE_goto: { int target = readTarget(wideRest, offset); Code.Label lab = findLabel(target, labels); return Code.Goto(lab.label); } case Code.OPCODE_nop: return Code.Nop; case Code.OPCODE_returnv: return Code.Return(); } throw new RuntimeException("unknown opcode encountered (" + opcode + ")"); }
private Code readBinaryOp( int opcode, boolean wideBase, boolean wideRest, int offset, HashMap<Integer, Code.Label> labels) throws IOException { int leftOperand = readBase(wideBase); int rightOperand = readBase(wideBase); int typeIdx = readRest(wideRest); Type type = typePool[typeIdx]; switch (opcode) { case Code.OPCODE_asserteq: case Code.OPCODE_assertne: case Code.OPCODE_assertlt: case Code.OPCODE_assertle: case Code.OPCODE_assertgt: case Code.OPCODE_assertge: case Code.OPCODE_assertel: case Code.OPCODE_assertss: case Code.OPCODE_assertse: { int msgIdx = readRest(wideRest); String msg = stringPool[msgIdx]; Code.Comparator cop = Code.Comparator.values()[opcode - Code.OPCODE_asserteq]; return Code.Assert(type, leftOperand, rightOperand, cop, msg); } case Code.OPCODE_assumeeq: case Code.OPCODE_assumene: case Code.OPCODE_assumelt: case Code.OPCODE_assumele: case Code.OPCODE_assumegt: case Code.OPCODE_assumege: case Code.OPCODE_assumeel: case Code.OPCODE_assumess: case Code.OPCODE_assumese: { int msgIdx = readRest(wideRest); String msg = stringPool[msgIdx]; Code.Comparator cop = Code.Comparator.values()[opcode - Code.OPCODE_assumeeq]; return Code.Assume(type, leftOperand, rightOperand, cop, msg); } case Code.OPCODE_ifeq: case Code.OPCODE_ifne: case Code.OPCODE_iflt: case Code.OPCODE_ifle: case Code.OPCODE_ifgt: case Code.OPCODE_ifge: case Code.OPCODE_ifel: case Code.OPCODE_ifss: case Code.OPCODE_ifse: { int target = readTarget(wideRest, offset); Code.Label l = findLabel(target, labels); Code.Comparator cop = Code.Comparator.values()[opcode - Code.OPCODE_ifeq]; return Code.If(type, leftOperand, rightOperand, cop, l.label); } } throw new RuntimeException("unknown opcode encountered (" + opcode + ")"); }
private static Code.LoopEnd findLoopLabel(int target, HashMap<Integer, Code.Label> labels) { Code.Label label = labels.get(target); if (label == null) { Code.LoopEnd end = Code.LoopEnd("label" + labelCount++); labels.put(target, end); return end; } else { Code.LoopEnd end = Code.LoopEnd(label.label); labels.put(target, end); return end; } }
/** * Dumps the contents of the specified class to the specified directory. The file is named * dump_dir/[class].bcel. It contains a synopsis of the fields and methods followed by the jvm * code for each method. * * @param jc javaclass to dump * @param dump_dir directory in which to write the file */ public static void dump(JavaClass jc, File dump_dir) { try { dump_dir.mkdir(); File path = new File(dump_dir, jc.getClassName() + ".bcel"); PrintStream p = new PrintStream(path); // Print the class, super class and interfaces p.printf("class %s extends %s\n", jc.getClassName(), jc.getSuperclassName()); String[] inames = jc.getInterfaceNames(); if ((inames != null) && (inames.length > 0)) { p.printf(" "); for (String iname : inames) p.printf("implements %s ", iname); p.printf("\n"); } // Print each field p.printf("\nFields\n"); for (Field f : jc.getFields()) p.printf(" %s\n", f); // Print the signature of each method p.printf("\nMethods\n"); for (Method m : jc.getMethods()) p.printf(" %s\n", m); // If this is not an interface, print the code for each method if (!jc.isInterface()) { for (Method m : jc.getMethods()) { p.printf("\nMethod %s\n", m); Code code = m.getCode(); if (code != null) p.printf(" %s\n", code.toString().replace("\n", "\n ")); } } // Print the details of the constant pool. p.printf("Constant Pool:\n"); ConstantPool cp = jc.getConstantPool(); Constant[] constants = cp.getConstantPool(); for (int ii = 0; ii < constants.length; ii++) { p.printf(" %d %s\n", ii, constants[ii]); } p.close(); } catch (Exception e) { throw new Error("Unexpected error dumping javaclass", e); } }
/** * If debugging was enabled during compilation, this method returns the name of the given * parameter to this method. Otherwise, <code>null</code> is returned. * * @param index The index of the parameter. * @return The name of the parameter, or <code>null</code>. */ public String getParameterName(int index) { if (index >= 0 && index < getParameterCount()) { if (codeAttr != null) { return codeAttr.getParameterName(index); } } return null; }
private static Code.Label findLabel(int target, HashMap<Integer, Code.Label> labels) { Code.Label label = labels.get(target); if (label == null) { label = Code.Label("label" + labelCount++); labels.put(target, label); } return label; }
private Code readOther( int opcode, boolean wideBase, boolean wideRest, int offset, HashMap<Integer, Code.Label> labels) throws IOException { switch (opcode) { case Code.OPCODE_trycatch: { int operand = readBase(wideBase); int target = readTarget(wideRest, offset); Code.Label l = findLabel(target, labels); int nCatches = readRest(wideRest); ArrayList<Pair<Type, String>> catches = new ArrayList<Pair<Type, String>>(); for (int i = 0; i != nCatches; ++i) { Type type = typePool[readRest(wideRest)]; Code.Label handler = findLabel(readTarget(wideRest, offset), labels); catches.add(new Pair<Type, String>(type, handler.label)); } return Code.TryCatch(operand, l.label, catches); } case Code.OPCODE_update: { int target = readBase(wideBase); int nOperands = readBase(wideBase) - 1; int operand = readBase(wideBase); int[] operands = new int[nOperands]; for (int i = 0; i != nOperands; ++i) { operands[i] = readBase(wideBase); } Type beforeType = typePool[readRest(wideRest)]; Type afterType = typePool[readRest(wideRest)]; int nFields = readRest(wideRest); ArrayList<String> fields = new ArrayList<String>(); for (int i = 0; i != nFields; ++i) { String field = stringPool[readRest(wideRest)]; fields.add(field); } return Code.Update(beforeType, target, operand, operands, afterType, fields); } } throw new RuntimeException("unknown opcode encountered (" + opcode + ")"); }
private Code readUnaryOp( int opcode, boolean wideBase, boolean wideRest, int offset, HashMap<Integer, Code.Label> labels) throws IOException { int operand = readBase(wideBase); int typeIdx = readRest(wideRest); Type type = typePool[typeIdx]; switch (opcode) { case Code.OPCODE_debug: return Code.Debug(operand); case Code.OPCODE_ifis: { int resultIdx = readRest(wideRest); Type result = typePool[resultIdx]; int target = readTarget(wideRest, offset); Code.Label l = findLabel(target, labels); return Code.IfIs(type, operand, result, l.label); } case Code.OPCODE_throw: return Code.Throw(type, operand); case Code.OPCODE_return: return Code.Return(type, operand); case Code.OPCODE_switch: { ArrayList<Pair<Constant, String>> cases = new ArrayList<Pair<Constant, String>>(); int target = readTarget(wideRest, offset); Code.Label defaultLabel = findLabel(target, labels); int nCases = readRest(wideRest); for (int i = 0; i != nCases; ++i) { int constIdx = readRest(wideRest); Constant constant = constantPool[constIdx]; target = readTarget(wideRest, offset); Code.Label l = findLabel(target, labels); cases.add(new Pair<Constant, String>(constant, l.label)); } return Code.Switch(type, operand, defaultLabel.label, cases); } } throw new RuntimeException("unknown opcode encountered (" + opcode + ")"); }
protected void parseGenotype(final EvolutionState state, final LineNumberReader reader) throws IOException { // read in the next line. The first item is the number of genes String s = reader.readLine(); DecodeReturn d = new DecodeReturn(s); Code.decode(d); if (d.type != DecodeReturn.T_INTEGER) // uh oh state.output.fatal( "Individual with genome:\n" + s + "\n... does not have an integer at the beginning indicating the genome count."); int lll = (int) (d.l); genome = new boolean[lll]; // read in the genes for (int i = 0; i < genome.length; i++) { Code.decode(d); genome[i] = (boolean) (d.l != 0); } }
/** * Reads a subpopulation from the format generated by printSubpopulation(....). If the number of * individuals is not identical, the individuals array will be deleted and replaced with a new * array, and a warning will be generated as individuals will have to be created using * newIndividual(...) rather than readIndividual(...). */ public void readSubpopulation(final EvolutionState state, final LineNumberReader reader) throws IOException { // read in number of individuals and check to see if this appears to be a valid subpopulation int numIndividuals = Code.readIntegerWithPreamble(NUM_INDIVIDUALS_PREAMBLE, state, reader); // read in individuals if (numIndividuals != individuals.length) { state.output.warnOnce( "On reading subpopulation from text stream, the subpopulation size didn't match.\n" + "Had to resize and use newIndividual() instead of readIndividual()."); individuals = new Individual[numIndividuals]; for (int i = 0; i < individuals.length; i++) { int j = Code.readIntegerWithPreamble(INDIVIDUAL_INDEX_PREAMBLE, state, reader); // sanity check if (j != i) state.output.warnOnce( "On reading subpopulation from text stream, some individual indexes in the subpopulation did not match."); individuals[i] = species.newIndividual(state, reader); } } else for (int i = 0; i < individuals.length; i++) { int j = Code.readIntegerWithPreamble(INDIVIDUAL_INDEX_PREAMBLE, state, reader); // sanity check if (j != i) state.output.warnOnce( "On reading subpopulation from text stream, some individual indexes in the subpopulation did not match."); if (individuals[i] != null) individuals[i].readIndividual(state, reader); else { state.output.warnOnce( "On reading subpopulation from text stream, some of the preexisting subpopulation's slots were null.\n" + "Had to use newIndividual() instead of readIndividual(). If you're starting an evolutionary run by reading an\n" + "existing population from a file, this is expected -- ignore this message."); individuals[i] = species.newIndividual(state, reader); } } }
// While loop handles the basic cases like declare while loop for i<10, iterate until i less than // ten and j less than 20 private void while_loop() { VarSymbol v = null; FuncSymbol f = null; int index = input.indexOf( words.get(wordLoc)); // Index in input string at which the word was encountered index += (words.get(wordLoc).length() + 1); String str = input.substring(index); // Further processing will be done on this string tokens = str.split("[ ]+"); String expString = ""; tIndex = 0; while (true) { if ((v = Controller.varSym.searchSymbol(tokens[tIndex])) != null /*TODO Check whether token is a number*/) { expString = searchExpression(); if (words.get(wordLoc).indexOf("until") != -1) code.setCodeText("while(!(" + expString + "))"); else code.setCodeText("while(" + expString + ")"); code.setErrCode(IErrorCodes.SUCCESS); code.setErrParam(null); break; } else if ((f = Controller.funSym.searchSymbol(tokens[tIndex])) != null) { int tempIndex = input.indexOf(tokens[tIndex]); expString = exp.generateExpression(input.substring(tempIndex)); if (words.get(wordLoc).indexOf("until") != -1) code.setCodeText("while(!(" + expString + "))"); else code.setCodeText("while(" + expString + ")"); code.setErrCode(IErrorCodes.SUCCESS); code.setErrParam(null); break; } else if ((tokens[tIndex].equals("true") || tokens[tIndex].equals("true")) && tIndex + 1 == tokens.length) { code.setCodeText("while(" + tokens[tIndex] + ")"); } } }
public void sendResponseHeaders(int rCode, long contentLen) throws IOException { if (sentHeaders) { throw new IOException("headers already sent"); } this.rcode = rCode; String statusLine = "HTTP/1.1 " + rCode + Code.msg(rCode) + "\r\n"; OutputStream tmpout = new BufferedOutputStream(ros); PlaceholderOutputStream o = getPlaceholderResponseBody(); tmpout.write(bytes(statusLine, 0), 0, statusLine.length()); boolean noContentToSend = false; // assume there is content rspHdrs.set("Date", df.format(new Date())); if (contentLen == 0) { if (http10) { o.setWrappedStream(new UndefLengthOutputStream(this, ros)); close = true; } else { rspHdrs.set("Transfer-encoding", "chunked"); o.setWrappedStream(new ChunkedOutputStream(this, ros)); } } else { if (contentLen == -1) { noContentToSend = true; contentLen = 0; } /* content len might already be set, eg to implement HEAD resp */ if (rspHdrs.getFirst("Content-length") == null) { rspHdrs.set("Content-length", Long.toString(contentLen)); } o.setWrappedStream(new FixedLengthOutputStream(this, ros, contentLen)); } write(rspHdrs, tmpout); this.rspContentLen = contentLen; tmpout.flush(); tmpout = null; sentHeaders = true; if (noContentToSend) { WriteFinishedEvent e = new WriteFinishedEvent(this); server.addEvent(e); closed = true; } server.logReply(rCode, req.requestLine(), null); }
public NewArray(int opcode, long start_byte, Code code) { super(opcode, start_byte, code); if (opcode == 188) // newarray { switch (params[0]) { case T_BOOLEAN: baseType = "boolean"; break; case T_CHAR: baseType = "char"; break; case T_FLOAT: baseType = "float"; break; case T_DOUBLE: baseType = "double"; break; case T_BYTE: baseType = "byte"; break; case T_SHORT: baseType = "short"; break; case T_INT: baseType = "int"; break; case T_LONG: baseType = "long"; break; } } else if (opcode == 189) { classType = ((CONSTANT_Class_info) code.getClazz().getConstant_pool()[(params[0] << 8) | params[1]]) .getFullyQualifiedName(); } }
/** * Reads an attribute for this method from the specified input stream. * * @param in The input stream to read from. * @return The attribute read, possibly <code>null</code> if it was known to be unimportant for * our purposes. * @throws IOException If an IO error occurs. */ private AttributeInfo readAttribute(DataInputStream in) throws IOException { AttributeInfo ai = null; int attributeNameIndex = in.readUnsignedShort(); int attributeLength = in.readInt(); String attrName = cf.getUtf8ValueFromConstantPool(attributeNameIndex); if (CODE.equals(attrName)) { // 4.7.3 ai = Code.read(this, in); } else if (EXCEPTIONS.equals(attrName)) { // 4.7.4 int exceptionCount = in.readUnsignedShort(); int[] exceptionIndexTable = null; if (exceptionCount > 0) { exceptionIndexTable = new int[exceptionCount]; for (int i = 0; i < exceptionCount; i++) { exceptionIndexTable[i] = in.readUnsignedShort(); } } Exceptions e = new Exceptions(this, exceptionIndexTable); ai = e; } // TODO: Handle other Attribute types. // Attributes common to all members, or unhandled attributes. else { ai = super.readAttribute(in, attrName, attributeLength); // if (ai!=null) { // "Deprecated" attribute returns null // System.out.println("-------------- " + ai.getName()); // } } return ai; }
private Code readNaryOp( int opcode, boolean wideBase, boolean wideRest, int offset, HashMap<Integer, Code.Label> labels) throws IOException { int nOperands = readBase(wideBase); int[] operands = new int[nOperands]; for (int i = 0; i != nOperands; ++i) { operands[i] = readBase(wideBase); } if (opcode == Code.OPCODE_loop) { // special case which doesn't have a type. int target = readTarget(wideRest, offset); Code.LoopEnd l = findLoopLabel(target, labels); return Code.Loop(l.label, operands); } int typeIdx = readRest(wideRest); Type type = typePool[typeIdx]; switch (opcode) { case Code.OPCODE_forall: { if (!(type instanceof Type.EffectiveCollection)) { throw new RuntimeException("expected collection type"); } int target = readTarget(wideRest, offset); Code.LoopEnd l = findLoopLabel(target, labels); int indexOperand = operands[0]; int sourceOperand = operands[1]; operands = Arrays.copyOfRange(operands, 2, operands.length); return Code.ForAll( (Type.EffectiveCollection) type, sourceOperand, indexOperand, operands, l.label); } case Code.OPCODE_indirectinvokefnv: case Code.OPCODE_indirectinvokemdv: { if (!(type instanceof Type.FunctionOrMethod)) { throw new RuntimeException("expected function or method type"); } int operand = operands[0]; operands = Arrays.copyOfRange(operands, 1, operands.length); return Code.IndirectInvoke( (Type.FunctionOrMethod) type, Code.NULL_REG, operand, operands); } case Code.OPCODE_invokefnv: case Code.OPCODE_invokemdv: { if (!(type instanceof Type.FunctionOrMethod)) { throw new RuntimeException("expected function or method type"); } int nameIdx = readRest(wideRest); ; NameID nid = namePool[nameIdx]; return Code.Invoke((Type.FunctionOrMethod) type, Code.NULL_REG, operands, nid); } } throw new RuntimeException("unknown opcode encountered (" + opcode + ")"); }
private Code readBinaryAssign(int opcode, boolean wideBase, boolean wideRest) throws IOException { int target = readBase(wideBase); int leftOperand = readBase(wideBase); int rightOperand = readBase(wideBase); int typeIdx = readRest(wideRest); Type type = typePool[typeIdx]; switch (opcode) { case Code.OPCODE_append: case Code.OPCODE_appendl: case Code.OPCODE_appendr: { if (!(type instanceof Type.EffectiveList)) { throw new RuntimeException("expecting list type"); } Code.BinListKind kind = Code.BinListKind.values()[opcode - Code.OPCODE_append]; return Code.BinListOp((Type.EffectiveList) type, target, leftOperand, rightOperand, kind); } case Code.OPCODE_sappend: case Code.OPCODE_sappendl: case Code.OPCODE_sappendr: { if (!(type instanceof Type.Strung)) { throw new RuntimeException("expecting string type"); } Code.BinStringKind kind = Code.BinStringKind.values()[opcode - Code.OPCODE_sappend]; return Code.BinStringOp(target, leftOperand, rightOperand, kind); } case Code.OPCODE_indexof: { if (!(type instanceof Type.EffectiveIndexible)) { throw new RuntimeException("expecting indexible type"); } return Code.IndexOf((Type.EffectiveIndexible) type, target, leftOperand, rightOperand); } case Code.OPCODE_add: case Code.OPCODE_sub: case Code.OPCODE_mul: case Code.OPCODE_div: case Code.OPCODE_rem: case Code.OPCODE_range: case Code.OPCODE_bitwiseor: case Code.OPCODE_bitwisexor: case Code.OPCODE_bitwiseand: case Code.OPCODE_lshr: case Code.OPCODE_rshr: { Code.BinArithKind kind = Code.BinArithKind.values()[opcode - Code.OPCODE_add]; return Code.BinArithOp(type, target, leftOperand, rightOperand, kind); } case Code.OPCODE_union: case Code.OPCODE_unionl: case Code.OPCODE_unionr: case Code.OPCODE_intersect: case Code.OPCODE_intersectl: case Code.OPCODE_intersectr: case Code.OPCODE_difference: case Code.OPCODE_differencel: { if (!(type instanceof Type.EffectiveSet)) { throw new RuntimeException("expecting set type"); } Code.BinSetKind kind = Code.BinSetKind.values()[opcode - Code.OPCODE_union]; return Code.BinSetOp((Type.EffectiveSet) type, target, leftOperand, rightOperand, kind); } } throw new RuntimeException("unknown opcode encountered (" + opcode + ")"); }
private Code readUnaryAssign(int opcode, boolean wideBase, boolean wideRest) throws IOException { int target = readBase(wideBase); int operand = readBase(wideBase); int typeIdx = readRest(wideRest); Type type = typePool[typeIdx]; switch (opcode) { case Code.OPCODE_convert: { int i = readRest(wideRest); Type t = typePool[i]; return Code.Convert(type, target, operand, t); } case Code.OPCODE_assign: return Code.Assign(type, target, operand); case Code.OPCODE_dereference: { if (!(type instanceof Type.Reference)) { throw new RuntimeException("expected reference type"); } return Code.Dereference((Type.Reference) type, target, operand); } case Code.OPCODE_fieldload: { if (!(type instanceof Type.EffectiveRecord)) { throw new RuntimeException("expected record type"); } int i = readRest(wideRest); String field = stringPool[i]; return Code.FieldLoad((Type.EffectiveRecord) type, target, operand, field); } case Code.OPCODE_invert: return Code.Invert(type, target, operand); case Code.OPCODE_newobject: { if (!(type instanceof Type.Reference)) { throw new RuntimeException("expected reference type"); } return Code.NewObject((Type.Reference) type, target, operand); } case Code.OPCODE_lengthof: { if (!(type instanceof Type.EffectiveCollection)) { throw new RuntimeException("expected collection type"); } return Code.LengthOf((Type.EffectiveCollection) type, target, operand); } case Code.OPCODE_move: return Code.Move(type, target, operand); case Code.OPCODE_neg: return Code.UnArithOp(type, target, operand, Code.UnArithKind.NEG); case Code.OPCODE_numerator: return Code.UnArithOp(type, target, operand, Code.UnArithKind.NUMERATOR); case Code.OPCODE_denominator: return Code.UnArithOp(type, target, operand, Code.UnArithKind.DENOMINATOR); case Code.OPCODE_not: { if (!(type instanceof Type.Bool)) { throw new RuntimeException("expected bool type"); } return Code.Not(target, operand); } case Code.OPCODE_tupleload: { if (!(type instanceof Type.EffectiveTuple)) { throw new RuntimeException("expected tuple type"); } int index = readRest(wideRest); return Code.TupleLoad((Type.Tuple) type, target, operand, index); } } throw new RuntimeException("unknown opcode encountered (" + opcode + ")"); }
private void for_loop() { VarSymbol v = null, tempVar = null; FuncSymbol f = null, tempFunc = null; int index = input.indexOf( words.get(wordLoc)); // Index in input string at which the word was encountered String expString = ""; index += (words.get(wordLoc).length() + 1); String str = input.substring(index); // Further processing will be done on this string tokens = str.split("[ ]+"); index = 0; boolean flag = false; String expression = null; String tempStr = null; String loopCounter = ""; while (true) { if ((v = Controller.varSym.searchSymbol(tokens[tIndex])) != null) /*|| (f = Controller.funSym.searchSymbol(tokens[tIndex])) != null*/ { loopCounter = v.getVarName(); // Holds the loopCounter variable expString = searchExpression(); expression = exp.generateExpression(expString); tempVar = v; } else if (tokens[tIndex].equalsIgnoreCase("to")) { // If next token is not an operator loopParams[0] = expression; tIndex++; int tempNum = NumberGenerator.stringToNum(tokens[tIndex]); // if((tempStr = String.valueOf(toNumber(tokens[tIndex++])))){ // TODO Method 'toNumber()' // to be added later if (String.valueOf(tempNum) != null) { condition = tempStr; loopParams[1] = loopCounter + "<" + condition; } else if ((v = Controller.varSym.searchSymbol(tokens[tIndex])) != null || (Controller.funSym.searchSymbol(tokens[tIndex]) != null)) { tempStr = searchExpression(); String tempString = exp.generateExpression(tempStr); int len = v.getVarName().length(); if (tempString.startsWith(loopCounter) && tempString.charAt(len) == '=') { condition = tempString.substring(len + 1); loopParams[1] = loopCounter + "<" + condition; } else { condition = tempString; loopParams[1] = condition; } } } else if (tokens[tIndex].equalsIgnoreCase("increment") || (tokens[tIndex] + tokens[tIndex + 1]).equalsIgnoreCase("plusplus") || tokens[tIndex].equalsIgnoreCase("postincrement") || tokens[tIndex].equalsIgnoreCase("preincrement")) { expression = exp.generateExpression((str.substring(str.indexOf(tokens[tIndex])))); loopParams[2] = expression; break; } else if (tokens[tIndex].equalsIgnoreCase("decrement") || (tokens[tIndex] + tokens[tIndex + 1]).equalsIgnoreCase("minus minus") || tokens[tIndex].equalsIgnoreCase("postdecrement") || tokens[tIndex].equalsIgnoreCase("predecrement")) { expression = exp.generateExpression((str.substring(str.indexOf(tokens[tIndex])))); loopParams[2] = expression; break; } /*if(searchOperator(tIndex) != -1){ //TODO Index variable missing error to be handled }*/ /* if(token is number){ number handling logic. e.g : for loop 0 to 100. } */ if ((tIndex) == tokens.length) { break; } } if (loopParams[2] == null) { loopParams[2] = loopCounter + "++"; } code.setCodeText("for(" + loopParams[0] + ";" + loopParams[1] + ";" + loopParams[2] + ")"); code.setErrCode(IErrorCodes.SUCCESS); code.setErrParam(null); }
private Code readNaryAssign(int opcode, boolean wideBase, boolean wideRest) throws IOException { int target = readBase(wideBase); int nOperands = readBase(wideBase); int[] operands = new int[nOperands]; for (int i = 0; i != nOperands; ++i) { operands[i] = readBase(wideBase); } int typeIdx = readRest(wideRest); Type type = typePool[typeIdx]; switch (opcode) { case Code.OPCODE_indirectinvokefn: case Code.OPCODE_indirectinvokemd: { if (!(type instanceof Type.FunctionOrMethod)) { throw new RuntimeException("expected function or method type"); } int operand = operands[0]; operands = Arrays.copyOfRange(operands, 1, operands.length); return Code.IndirectInvoke((Type.FunctionOrMethod) type, target, operand, operands); } case Code.OPCODE_invokefn: case Code.OPCODE_invokemd: { if (!(type instanceof Type.FunctionOrMethod)) { throw new RuntimeException("expected function or method type"); } int nameIdx = readRest(wideRest); NameID nid = namePool[nameIdx]; return Code.Invoke((Type.FunctionOrMethod) type, target, operands, nid); } case Code.OPCODE_lambdafn: case Code.OPCODE_lambdamd: { if (!(type instanceof Type.FunctionOrMethod)) { throw new RuntimeException("expected function or method type"); } // Lambda's are the only instances of NULLABLENARYASSIGN's for (int i = 0; i != operands.length; ++i) { operands[i] -= 1; } int nameIdx = readRest(wideRest); NameID nid = namePool[nameIdx]; return Code.Lambda((Type.FunctionOrMethod) type, target, operands, nid); } case Code.OPCODE_newmap: { if (!(type instanceof Type.Map)) { throw new RuntimeException("expected map type"); } return Code.NewMap((Type.Map) type, target, operands); } case Code.OPCODE_newrecord: { if (!(type instanceof Type.Record)) { throw new RuntimeException("expected record type"); } return Code.NewRecord((Type.Record) type, target, operands); } case Code.OPCODE_newlist: { if (!(type instanceof Type.List)) { throw new RuntimeException("expected list type"); } return Code.NewList((Type.List) type, target, operands); } case Code.OPCODE_newset: { if (!(type instanceof Type.Set)) { throw new RuntimeException("expected set type"); } return Code.NewSet((Type.Set) type, target, operands); } case Code.OPCODE_newtuple: { if (!(type instanceof Type.Tuple)) { throw new RuntimeException("expected tuple type"); } return Code.NewTuple((Type.Tuple) type, target, operands); } case Code.OPCODE_sublist: { if (!(type instanceof Type.EffectiveList)) { throw new RuntimeException("expected list type"); } return Code.SubList( (Type.EffectiveList) type, target, operands[0], operands[1], operands[2]); } case Code.OPCODE_substring: { if (!(type instanceof Type.Strung)) { throw new RuntimeException("expected string type"); } return Code.SubString(target, operands[0], operands[1], operands[2]); } } throw new RuntimeException("unknown opcode encountered (" + opcode + ")"); }
final void writeAttribute(Attribute attribute, String anchor, int method_number) throws IOException { byte tag = attribute.getTag(); int index; if (tag == ATTR_UNKNOWN) // Don't know what to do about this one return; attr_count++; // Increment number of attributes found so far if (attr_count % 2 == 0) file.print("<TR BGCOLOR=\"#C0C0C0\"><TD>"); else file.print("<TR BGCOLOR=\"#A0A0A0\"><TD>"); file.println( "<H4><A NAME=\"" + anchor + "\">" + attr_count + " " + ATTRIBUTE_NAMES[tag] + "</A></H4>"); /* Handle different attributes */ switch (tag) { case ATTR_CODE: Code c = (Code) attribute; // Some directly printable values file.print( "<UL><LI>Maximum stack size = " + c.getMaxStack() + "</LI>\n<LI>Number of local variables = " + c.getMaxLocals() + "</LI>\n<LI><A HREF=\"" + class_name + "_code.html#method" + method_number + "\" TARGET=Code>Byte code</A></LI></UL>\n"); // Get handled exceptions and list them CodeException[] ce = c.getExceptionTable(); int len = ce.length; if (len > 0) { file.print("<P><B>Exceptions handled</B><UL>"); for (int i = 0; i < len; i++) { int catch_type = ce[i].getCatchType(); // Index in constant pool file.print("<LI>"); if (catch_type != 0) file.print(constant_html.referenceConstant(catch_type)); // Create Link to _cp.html else file.print("Any Exception"); file.print( "<BR>(Ranging from lines " + codeLink(ce[i].getStartPC(), method_number) + " to " + codeLink(ce[i].getEndPC(), method_number) + ", handled at line " + codeLink(ce[i].getHandlerPC(), method_number) + ")</LI>"); } file.print("</UL>"); } break; case ATTR_CONSTANT_VALUE: index = ((ConstantValue) attribute).getConstantValueIndex(); // Reference _cp.html file.print( "<UL><LI><A HREF=\"" + class_name + "_cp.html#cp" + index + "\" TARGET=\"ConstantPool\">Constant value index(" + index + ")</A></UL>\n"); break; case ATTR_SOURCE_FILE: index = ((SourceFile) attribute).getSourceFileIndex(); // Reference _cp.html file.print( "<UL><LI><A HREF=\"" + class_name + "_cp.html#cp" + index + "\" TARGET=\"ConstantPool\">Source file index(" + index + ")</A></UL>\n"); break; case ATTR_EXCEPTIONS: // List thrown exceptions int[] indices = ((ExceptionTable) attribute).getExceptionIndexTable(); file.print("<UL>"); for (int i = 0; i < indices.length; i++) file.print( "<LI><A HREF=\"" + class_name + "_cp.html#cp" + indices[i] + "\" TARGET=\"ConstantPool\">Exception class index(" + indices[i] + ")</A>\n"); file.print("</UL>\n"); break; case ATTR_LINE_NUMBER_TABLE: LineNumber[] line_numbers = ((LineNumberTable) attribute).getLineNumberTable(); // List line number pairs file.print("<P>"); for (int i = 0; i < line_numbers.length; i++) { file.print( "(" + line_numbers[i].getStartPC() + ", " + line_numbers[i].getLineNumber() + ")"); if (i < line_numbers.length - 1) file.print(", "); // breakable } break; case ATTR_LOCAL_VARIABLE_TABLE: LocalVariable[] vars = ((LocalVariableTable) attribute).getLocalVariableTable(); // List name, range and type file.print("<UL>"); for (int i = 0; i < vars.length; i++) { index = vars[i].getSignatureIndex(); String signature = ((ConstantUtf8) constant_pool.getConstant(index, CONSTANT_Utf8)).getBytes(); signature = Utility.signatureToString(signature, false); int start = vars[i].getStartPC(); int end = (start + vars[i].getLength()); file.println( "<LI>" + Class2HTML.referenceType(signature) + " <B>" + vars[i].getName() + "</B> in slot %" + vars[i].getIndex() + "<BR>Valid from lines " + "<A HREF=\"" + class_name + "_code.html#code" + method_number + "@" + start + "\" TARGET=Code>" + start + "</A> to " + "<A HREF=\"" + class_name + "_code.html#code" + method_number + "@" + end + "\" TARGET=Code>" + end + "</A></LI>"); } file.print("</UL>\n"); break; case ATTR_INNER_CLASSES: InnerClass[] classes = ((InnerClasses) attribute).getInnerClasses(); // List inner classes file.print("<UL>"); for (int i = 0; i < classes.length; i++) { String name, access; index = classes[i].getInnerNameIndex(); if (index > 0) name = ((ConstantUtf8) constant_pool.getConstant(index, CONSTANT_Utf8)).getBytes(); else name = "<anonymous>"; access = Utility.accessToString(classes[i].getInnerAccessFlags()); file.print( "<LI><FONT COLOR=\"#FF0000\">" + access + "</FONT> " + constant_html.referenceConstant(classes[i].getInnerClassIndex()) + " in class " + constant_html.referenceConstant(classes[i].getOuterClassIndex()) + " named " + name + "</LI>\n"); } file.print("</UL>\n"); break; default: // Such as Unknown attribute or Deprecated file.print("<P>" + attribute.toString()); } file.println("</TD></TR>"); file.flush(); }
public String genotypeToString() { StringBuilder s = new StringBuilder(); s.append(Code.encode(genome.length)); for (int i = 0; i < genome.length; i++) s.append(Code.encode(genome[i])); return s.toString(); }