/**
  * Reads <c>size</c> bytes of the input stream, to Create an array of <c>Ptg</c>s.
  * Extra data (beyond <c>size</c>) may be Read if and <c>ArrayPtg</c>s are present.
  */
 public static Ptg[] ReadTokens(int size, ILittleEndianInput in1)
 {
     ArrayList temp = new ArrayList(4 + size / 2);
     int pos = 0;
     bool hasArrayPtgs = false;
     while (pos < size)
     {
         Ptg ptg = Ptg.CreatePtg(in1);
         if (ptg is ArrayPtg.Initial)
         {
             hasArrayPtgs = true;
         }
         pos += ptg.Size;
         temp.Add(ptg);
     }
     if (pos != size)
     {
         throw new Exception("Ptg array size mismatch");
     }
     if (hasArrayPtgs)
     {
         Ptg[] result = ToPtgArray(temp);
         for (int i = 0; i < result.Length; i++)
         {
             if (result[i] is ArrayPtg.Initial)
             {
                 result[i] = ((ArrayPtg.Initial)result[i]).FinishReading(in1);
             }
         }
         return result;
     }
     return ToPtgArray(temp);
 }

        public static SubRecord CreateSubRecord(ILittleEndianInput in1, CommonObjectType cmoOt)
        {
            int sid = in1.ReadUShort();
            int secondUShort = in1.ReadUShort(); // Often (but not always) the datasize for the sub-record


            switch (sid)
            {
                case CommonObjectDataSubRecord.sid:
                    return new CommonObjectDataSubRecord(in1, secondUShort);
                case EmbeddedObjectRefSubRecord.sid:
                    return new EmbeddedObjectRefSubRecord(in1, secondUShort);
                case GroupMarkerSubRecord.sid:
                    return new GroupMarkerSubRecord(in1, secondUShort);
                case EndSubRecord.sid:
                    return new EndSubRecord(in1, secondUShort);
                case NoteStructureSubRecord.sid:
                    return new NoteStructureSubRecord(in1, secondUShort);
                case LbsDataSubRecord.sid:
                    return new LbsDataSubRecord(in1, secondUShort, (int)cmoOt);
                case FtCblsSubRecord.sid:
                    return new FtCblsSubRecord(in1, secondUShort);
            }
            return new UnknownSubRecord(in1, sid, secondUShort);
        }

        /**
         * Constructs a End record and Sets its fields appropriately.
         *
         * @param in the RecordInputstream to Read the record from
         */

        public EndSubRecord(ILittleEndianInput in1, int size)
        {
            if ((size & 0xFF) != ENCODED_SIZE)
            { // mask out random crap in upper byte
                throw new RecordFormatException("Unexpected size (" + size + ")");
            }

        }

 public FtCfSubRecord(ILittleEndianInput in1, int size)
 {
     if (size != length)
     {
         throw new RecordFormatException("Unexpected size (" + size + ")");
     }
     flags = in1.ReadShort();
 }

 public static object[] Parse(ILittleEndianInput in1, int nValues)
 {
     object[] result = new Object[nValues];
     for (int i = 0; i < result.Length; i++)
     {
         result[i]=ReadAConstantValue(in1);
     }
     return result;
 }

 /**
  * Constructs a NoteStructureSubRecord and Sets its fields appropriately.
  *
  */
 public NoteStructureSubRecord(ILittleEndianInput in1, int size)
 {
     if (size != ENCODED_SIZE) {
         throw new RecordFormatException("Unexpected size (" + size + ")");
     }
     //just grab the raw data
     byte[] buf = new byte[size];
     in1.ReadFully(buf);
     reserved = buf;
 }

 private static Object ReadBoolean(ILittleEndianInput in1)
 {
     byte val = (byte)in1.ReadLong(); // 7 bytes 'not used'
     switch (val)
     {
         case FALSE_ENCODING:
             return false;
         case TRUE_ENCODING:
             return true;
     }
     // Don't tolerate Unusual bool encoded values (unless it becomes evident that they occur)
     throw new Exception("unexpected bool encoding (" + val + ")");
 }

        /** Create a StringPtg from a stream */
        public StringPtg(ILittleEndianInput in1)
        {
            int field_1_length = in1.ReadUByte();
			field_2_options = (byte)in1.ReadByte();
            _is16bitUnicode = (field_2_options & 0x01) != 0;
            if (_is16bitUnicode)
            {
                field_3_string = StringUtil.ReadUnicodeLE(in1, field_1_length);
            }
            else
            {
                field_3_string = StringUtil.ReadCompressedUnicode(in1, field_1_length);
            }
        }

        public Biff8DecryptingStream(Stream in1, int InitialOffSet, Biff8EncryptionKey key)
        {
            _rc4 = new Biff8RC4(InitialOffSet, key);

            if (in1 is ILittleEndianInput)
            {
                // accessing directly is an optimisation
                _le = (ILittleEndianInput)in1;
            }
            else
            {
                // less optimal, but should work OK just the same. Often occurs in junit tests.
                _le = new LittleEndianInputStream(in1);
            }
        }

 public ScrollableObjectSubRecord(ILittleEndianInput in1, int size)
 {
     if (size !=this.DataSize)
     {
         throw new RecordFormatException(string.Format(CultureInfo.CurrentCulture, "Expected size {0} but got ({1})", this.DataSize, size));
     }
     in1.ReadInt();
     field_1_iVal=in1.ReadShort();
     field_2_iMin=in1.ReadShort();
     field_3_iMax=in1.ReadShort();
     field_4_dInc=in1.ReadShort();
     field_5_dPage=in1.ReadShort();
     field_6_fHoriz = in1.ReadShort();
     field_7_dxScroll = in1.ReadShort();
     field_8_options = in1.ReadShort();
 }

        public AttrPtg(ILittleEndianInput in1)
        {
            field_1_options =(byte)in1.ReadByte();
            field_2_data = in1.ReadShort();
            if (IsOptimizedChoose)
            {
                int nCases = field_2_data;
                int[] jumpTable = new int[nCases];
                for (int i = 0; i < jumpTable.Length; i++)
                {
                    jumpTable[i] = in1.ReadUShort();
                }
                _jumpTable = jumpTable;
                _chooseFuncOffset = in1.ReadUShort();
            }
            else
            {
                _jumpTable = null;
                _chooseFuncOffset = -1;
            }

        }

 private static object ReadAConstantValue(ILittleEndianInput in1)
 {
     byte grbit = (byte)in1.ReadByte();
     switch (grbit)
     {
         case TYPE_EMPTY:
             in1.ReadLong(); // 8 byte 'not used' field
             return EMPTY_REPRESENTATION;
         case TYPE_NUMBER:
             return in1.ReadDouble();
         case TYPE_STRING:
             return StringUtil.ReadUnicodeString(in1);
         case TYPE_BOOLEAN:
             return ReadBoolean(in1);
         case TYPE_ERROR_CODE:
             int errCode = in1.ReadUShort();
             // next 6 bytes are Unused
             in1.ReadUShort();
             in1.ReadInt();
             return ErrorConstant.ValueOf(errCode);
     }
     throw new Exception("Unknown grbit value (" + grbit + ")");
 }

 public MemAreaPtg(ILittleEndianInput in1)
 {
     field_1_reserved = in1.ReadInt();
     field_2_subex_len = in1.ReadShort();
 }

		public GUID(ILittleEndianInput in1) 
            :this(in1.ReadInt(), in1.ReadUShort(), in1.ReadUShort(), in1.ReadLong())
        {
			
		}

        public NameXPtg(ILittleEndianInput in1)
            :this(in1.ReadUShort(), in1.ReadUShort(), in1.ReadUShort())
        {

        }

        public RefPtg(ILittleEndianInput in1)
            : base(in1)
        {

        }

            /**
             * Read in the actual token (array) values. This occurs
             * AFTER the last Ptg in the expression.
             * See page 304-305 of Excel97-2007BinaryFileFormat(xls)Specification.pdf
             */
            public ArrayPtg FinishReading(ILittleEndianInput in1)
            {
                int nColumns = in1.ReadUByte();
                short nRows = in1.ReadShort();
                //The token_1_columns and token_2_rows do not follow the documentation.
                //The number of physical rows and columns is actually +1 of these values.
                //Which is not explicitly documented.
                nColumns++;
                nRows++;

                int totalCount = nRows * nColumns;
                Object[] arrayValues = ConstantValueParser.Parse(in1, totalCount);

                ArrayPtg result = new ArrayPtg(_reserved0, _reserved1, _reserved2, nColumns, nRows, arrayValues);
                result.PtgClass = this.PtgClass;
                return result;
            }

 public Initial(ILittleEndianInput in1)
 {
     _reserved0 = in1.ReadInt();
     _reserved1 = in1.ReadUShort();
     _reserved2 = in1.ReadUByte();
 }

        public RefErrorPtg(ILittleEndianInput in1)
        {
            field_1_reserved = in1.ReadInt();

        }

 private static byte[] ReadRawData(ILittleEndianInput in1, int size)
 {
     if (size < 0)
     {
         throw new ArgumentException("Negative size (" + size + ")");
     }
     if (size == 0)
     {
         return EMPTY_BYTE_ARRAY;
     }
     byte[] result = new byte[size];
     in1.ReadFully(result);
     return result;
 }