private int Parse(String inTokens[], int inStart) throws Exception { boolean first = (inStart == 0); for (int n = inStart; n < inTokens.length; n++) { String token = inTokens[n]; if (!token.equals("")) { if (token.equals("(")) { // Found an open paren -- begin a recursive Parse, though // the very first // token in the list is a special case -- no need to create // a sub-program if (!first) { Program p = new Program(_interpreter); n = p.Parse(inTokens, n + 1); push(p); } } else if (token.equals(")")) { // End of the program -- return the advanced token index to // the caller return n; } else if (Character.isLetter(token.charAt(0))) { push(token); // This makes printing stacks very ugly. For now, will store // program instructions as strings, as was done before. /* Instruction i = _interpreter._instructions.get(token); if (i != null) push(i); else push(token); */ } else { Object number; if (token.indexOf('.') != -1) number = Float.parseFloat(token); else number = Integer.parseInt(token); push(number); } first = false; } } // If we're here, there was no closing brace for one of the programs throw new Exception("no closing brace found for program"); }
public void Flatten(int inIndex) { if (inIndex < _size) { // If here, the index to be flattened is in this program. So, push // the rest of the program onto a new program, and replace this with // that new program. Program replacement = new Program(this); clear(); for (int i = 0; i < replacement._size; i++) { if (inIndex == i) { if (replacement._stack[i] instanceof Program) { Program p = (Program) replacement._stack[i]; for (int j = 0; j < p._size; j++) this.push(p._stack[j]); } else { this.push(replacement._stack[i]); } } else { this.push(replacement._stack[i]); } } } else { int startIndex = _size; for (int n = 0; n < _size; n++) { Object o = _stack[n]; if (o instanceof Program) { Program sub = (Program) o; int length = sub.programsize(); if (inIndex - startIndex < length) { sub.Flatten(inIndex - startIndex); break; } startIndex += length; } } } }
/** * Returns a subtree of the program. * * @param inIndex The index of the requested subtree. * @return The program subtree. */ public Object Subtree(int inIndex) { if (inIndex < _size) { return _stack[inIndex]; } else { int startIndex = _size; for (int n = 0; n < _size; n++) { Object o = _stack[n]; if (o instanceof Program) { Program sub = (Program) o; int length = sub.programsize(); if (inIndex - startIndex < length) return sub.Subtree(inIndex - startIndex); startIndex += length; } } } return null; }
/** * Replaces a subtree of this Program with a new object. * * @param inIndex The index of the subtree to replace. * @param inReplacement The replacement for the subtree * @return True if a replacement was made (the index was valid). */ public boolean ReplaceSubtree(int inIndex, Object inReplacement) { if (inIndex < _size) { _stack[inIndex] = cloneforprogram(inReplacement); return true; } else { int startIndex = _size; for (int n = 0; n < _size; n++) { Object o = _stack[n]; if (o instanceof Program) { Program sub = (Program) o; int length = sub.programsize(); if (inIndex - startIndex < length) return sub.ReplaceSubtree(inIndex - startIndex, inReplacement); startIndex += length; } } } return false; }
/** * Constructs a copy of an existing Program. * * @param inOther The Push program to copy. */ public Program(Program inOther) { inOther.CopyTo(this); _interpreter = inOther._interpreter; }
/** * Copies this program to another. * * @param inOther The program to receive the copy of this program */ public void CopyTo(Program inOther) { for (int n = 0; n < _size; n++) inOther.push(_stack[n]); }