protected Object clone() 
{
		try {
			return super.clone();
		} catch (CloneNotSupportedException e) {
			throw new RuntimeException(e);
		}
}

 public final Ptg copy() 
{
		// TODO - all base tokens are logically immutable, but AttrPtg needs some clean-up 
		if (this instanceof ValueOperatorPtg) {
			return this;
		}
		if (this instanceof ScalarConstantPtg) {
			return this;
		}
		return (Ptg) clone();
}

 public static Stack createParsedExpressionTokens(short size,
    RecordInputStream in) 
{
		Stack stack = new Stack();
		int pos = 0;
		List arrayPtgs = null;
		while ( pos <  size )
		{
			Ptg ptg = Ptg.createPtg( in );
			if (ptg instanceof ArrayPtg) {
				if (arrayPtgs == null)
					arrayPtgs = new ArrayList(5);
				arrayPtgs.add(ptg);
				pos += 8;
			} else pos += ptg.getSize();
			stack.push( ptg );
		}
		if(pos != size) {
			throw new RuntimeException("Ptg array size mismatch");
		}
		if (arrayPtgs != null) {
			for (int i=0;i< arrayPtgs.size();i++) {
				ArrayPtg p = (ArrayPtg)arrayPtgs.get(i);
				p.readTokenValues(in);
			}
		}
		return stack;
}

 public static Ptg createPtg(RecordInputStream in) 
{
		byte id = in.readByte();
		if (id <  0x20) {
			return createBasePtg(id, in);
		}
		Ptg  retval = createClassifiedPtg(id, in);
		if (id  > 0x60) {
			retval.setClass(CLASS_ARRAY);
		} else if (id  > 0x40) {
			retval.setClass(CLASS_VALUE);
		} else {
			retval.setClass(CLASS_REF);
		}
	   return retval;
}

 public final byte[] getBytes() 
{
		int    size  = getSize();
		byte[] bytes = new byte[ size ];
		writeBytes(bytes, 0);
		return bytes;
}

 abstract public byte getDefaultOperandClass()

 public static int getEncodedSize(Stack ptgs) 
{
		return getEncodedSize(toPtgArray(ptgs));
}

 public static int getEncodedSize(Ptg[] ptgs) 
{
		int result = 0;
		for (int i = 0; i <  ptgs.length; i++) {
			result += ptgs[i].getSize();
		}
		return result;
}

 public final byte getPtgClass() 
{
		return ptgClass;
}

 abstract public int getSize()

 abstract public boolean isBaseToken()

 public static Ptg[] readTokens(int size,
    RecordInputStream in) 
{
		Stack temp = createParsedExpressionTokens((short)size, in);
		return toPtgArray(temp);
}

Reads size bytes of the input stream, to create an array of Ptgs. Extra data (beyond size) may be read if and ArrayPtgs are present.

 public static int serializePtgStack(Stack expression,
    byte[] array,
    int offset) 
{
		int pos = 0;
		int size = 0;
		if (expression != null)
			size = expression.size();
		List arrayPtgs = null;
		for (int k = 0; k <  size; k++) {
			Ptg ptg = ( Ptg ) expression.get(k);
			ptg.writeBytes(array, pos + offset);
			if (ptg instanceof ArrayPtg) {
			  if (arrayPtgs == null)
				  arrayPtgs = new ArrayList(5);
			  arrayPtgs.add(ptg);
			  pos += 8;
			} else pos += ptg.getSize();
		}
		if (arrayPtgs != null) {
			for (int i=0;i< arrayPtgs.size();i++) {
				ArrayPtg p = (ArrayPtg)arrayPtgs.get(i);
				pos += p.writeTokenValueBytes(array, pos + offset);
			}
		}
		return pos;
}

 public static int serializePtgs(Ptg[] ptgs,
    byte[] data,
    int offset) 
{
		return serializePtgStack(createStack(ptgs), data, offset);
}

Writes the ptgs to the data buffer, starting at the specified offset.
The 2 byte encode length field is not written by this method.

 public final  void setClass(byte thePtgClass) 
{
 //base ptg
		if (isBaseToken()) {
			throw new RuntimeException("setClass should not be called on a base token");
		}
		ptgClass = thePtgClass;
}

 public final String toDebugString() 
{
		byte[] ba = new byte[getSize()];
		String retval=null;
		writeBytes(ba,0);
		try {
			retval = org.apache.poi.util.HexDump.dump(ba,0,0);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return retval;
}

dump a debug representation (hexdump) to a string

 abstract public String toFormulaString(HSSFWorkbook book)
return a string representation of this token alone

 public String toString() 
{
		return this.getClass().toString();
}

Overridden toString method to ensure object hash is not printed. This helps get rid of gratuitous diffs when comparing two dumps Subclasses may output more relevant information by overriding this method

 abstract public  void writeBytes(byte[] array,
    int offset)
write this Ptg to a byte array