Fast Excel file reader with basic functionality

public ExcelDataReader(Stream fileStream, bool promoteToColumns, int double_decimals)
{
	m_PromoteToColumns = promoteToColumns;
	m_double_decimals = double_decimals;

	using (m_file = fileStream)
	{
		m_hdr = XlsHeader.ReadHeader(m_file);
		XlsRootDirectory dir = new XlsRootDirectory(m_hdr);
		XlsDirectoryEntry workbookEntry = dir.FindEntry(WORKBOOK) ?? dir.FindEntry(BOOK);

		if (workbookEntry == null)
			throw new FileNotFoundException(Errors.ErrorStreamWorkbookNotFound);
		if (workbookEntry.EntryType != STGTY.STGTY_STREAM)
			throw new FormatException(Errors.ErrorWorkbookIsNotStream);

		m_stream = new XlsBiffStream(m_hdr, workbookEntry.StreamFirstSector);

		ReadWorkbookGlobals();

		m_workbookData = new DataSet();

		for (int i = 0; i < m_sheets.Count; i++)
		{
			if (ReadWorksheet(m_sheets[i], (i + 1 < m_sheets.Count ? m_sheets[i + 1] : null)))
				m_workbookData.Tables.Add(m_sheets[i].Data);
		}

		m_globals.SST = null;
		m_globals = null;
		m_sheets = null;
		m_stream = null;
		m_hdr = null;

		GC.Collect();
		GC.SuppressFinalize(this);
	}
}

private bool ReadWorksheet(XlsWorksheet sheet, XlsWorksheet next_sheet)
{
	m_stream.Seek((int)sheet.DataOffset, SeekOrigin.Begin);

	XlsBiffBOF bof = m_stream.Read() as XlsBiffBOF;
	if (bof == null || bof.Type != BIFFTYPE.Worksheet)
		return false;

	XlsBiffRecord trec;
	XlsBiffIndex idx;

	// next statement fails if this is a non-indexed worksheet
	// XlsBiffIndex idx = m_stream.Read() as XlsBiffIndex;
	// split it up, so we keep a reference to the record itself
	trec = m_stream.Read();
	idx = trec as XlsBiffIndex;
	if (idx == null)
	{
		try
		{
			idx = null;
			do
			{
				trec = m_stream.Read();
				idx = trec as XlsBiffIndex;
			}
			while (idx == null && trec.ID != BIFFRECORDTYPE.DIMENSIONS);
		}
		catch
		{
			trec = null;
			idx = null;
		}
	}
	bool isV8 = (m_version >= 0x600);

	if (idx != null || (trec != null && trec.ID == BIFFRECORDTYPE.DIMENSIONS))
	{
		DataTable dt = new DataTable(sheet.Name);

		XlsBiffDimensions dims = null;
		if (idx == null)
		{
			dims = (XlsBiffDimensions)trec;
		}
		else
		{
			idx.IsV8 = isV8;

			do
			{
				trec = m_stream.Read();
				if (trec.ID == BIFFRECORDTYPE.DIMENSIONS)
				{
					dims = (XlsBiffDimensions)trec;
					break;
				}

			} while (trec != null && trec.ID != BIFFRECORDTYPE.ROW);
		}

		int maxCol = 256;

		if (dims != null)
		{
			dims.IsV8 = isV8;
			maxCol = dims.LastColumn - 1;
			sheet.Dimensions = dims;
		}

		InitializeColumns(ref dt, maxCol);

		sheet.Data = dt;

		uint maxRow = (idx == null ? dims.LastRow : idx.LastExistingRow);
		uint minRow = (idx == null ? dims.FirstRow : idx.FirstExistingRow);
		if (maxRow <= minRow)
		{
			return true;
		}

		dt.BeginLoadData();

		// add (empty) rows - changed init value for i to minRow instead of 0
		for (int i = (int) minRow; i < maxRow; i++)
		{
			dt.Rows.Add(dt.NewRow());
		}

		if (idx == null)
		{
			// the long way: just follow the stream for this worksheet looking for valid XlsBiffBlankCell elements
			int offs = trec.Offset;
			int maxOffset = (next_sheet == null ? trec.Bytes.Length : (int)next_sheet.DataOffset) - 1;
			m_stream.Seek(offs, SeekOrigin.Begin);
			
			while (offs < maxOffset && LoadCellValues(ref offs, ref dt, ref maxCol, ref maxRow))
			{ }
		}
		else
		{
			uint[] dbCellAddrs = idx.DbCellAddresses;

			for (int i = 0; i < dbCellAddrs.Length; i++)
			{
				XlsBiffDbCell dbCell = (XlsBiffDbCell)m_stream.ReadAt((int) dbCellAddrs[i]);
				XlsBiffRow row = null;
				int offs = dbCell.RowAddress;

				do
				{
					row = m_stream.ReadAt(offs) as XlsBiffRow;
					if (row == null) break;

					offs += row.Size;

				} while (null != row);

				while (LoadCellValues(ref offs, ref dt, ref maxCol, ref maxRow))
				{ }
			}
		}

		dt.EndLoadData();

		if (m_PromoteToColumns)
		{
			RemapColumnsNames(ref dt, dt.Rows[0].ItemArray);
			dt.Rows.RemoveAt(0);
			dt.AcceptChanges();
		}

	}
	else
	{
		return false;
	}

	return true;
}

private bool LoadCellValues(ref int offs, ref DataTable dt, ref int maxCol, ref uint maxRow)
{
	XlsBiffRecord rec = m_stream.ReadAt(offs);
	offs += rec.Size;
	if (rec is XlsBiffDbCell) return false;
	if (rec is XlsBiffEOF) return false;
	XlsBiffBlankCell cell = rec as XlsBiffBlankCell;

	if (cell == null) return true;
	if (cell.ColumnIndex >= maxCol) return true;
	if (cell.RowIndex > maxRow) return true;

	switch (cell.ID)
	{
		case BIFFRECORDTYPE.INTEGER:
		case BIFFRECORDTYPE.INTEGER_OLD:
			dt.Rows[cell.RowIndex][cell.ColumnIndex] = ((XlsBiffIntegerCell)cell).Value.ToString();
			break;
		case BIFFRECORDTYPE.NUMBER:
		case BIFFRECORDTYPE.NUMBER_OLD:
			dt.Rows[cell.RowIndex][cell.ColumnIndex] = FormatNumber(((XlsBiffNumberCell)cell).Value);
			break;
		case BIFFRECORDTYPE.LABEL:
		case BIFFRECORDTYPE.LABEL_OLD:
		case BIFFRECORDTYPE.RSTRING:
			dt.Rows[cell.RowIndex][cell.ColumnIndex] = ((XlsBiffLabelCell)cell).Value;
			break;
		case BIFFRECORDTYPE.LABELSST:
			string tmp = m_globals.SST.GetString(((XlsBiffLabelSSTCell)cell).SSTIndex);
			dt.Rows[cell.RowIndex][cell.ColumnIndex] = tmp;
			break;
		case BIFFRECORDTYPE.RK:
			dt.Rows[cell.RowIndex][cell.ColumnIndex] = FormatNumber(((XlsBiffRKCell)cell).Value);
			break;
		case BIFFRECORDTYPE.MULRK:
			for (ushort j = cell.ColumnIndex; j <= ((XlsBiffMulRKCell)cell).LastColumnIndex; j++)
			{
				dt.Rows[cell.RowIndex][j] = FormatNumber(((XlsBiffMulRKCell)cell).GetValue(j));
			}
			break;
		case BIFFRECORDTYPE.BLANK:
		case BIFFRECORDTYPE.BLANK_OLD:
		case BIFFRECORDTYPE.MULBLANK:
			// Skip blank cells

			break;
		case BIFFRECORDTYPE.FORMULA:
		case BIFFRECORDTYPE.FORMULA_OLD:
			((XlsBiffFormulaCell)cell).UseEncoding = m_encoding;
			object val = ((XlsBiffFormulaCell)cell).Value;
			if (val == null)
				val = string.Empty;
			else if (val is FORMULAERROR)
				val = "#" + ((FORMULAERROR)val);
			else if (val is double)
				val = FormatNumber((double)val);
			dt.Rows[cell.RowIndex][cell.ColumnIndex] = val.ToString();
			break;
		case BIFFRECORDTYPE.BOOLERR:
			dt.Rows[cell.RowIndex][cell.ColumnIndex] = ((XlsBiffBoolErrCell)cell).Value;
			break;
		default:
			break;
	}
	return true;
}

if (idx == null)<br />
{<br />
   idx = m_stream.Read() as XlsBiffIndex;<br />
}

XlsBiffIndex idx = null;<br />
do<br />
  {<br />
     idx = m_stream.Read() as XlsBiffIndex;<br />
  }<br />
while (idx == null);

case BIFFRECORDTYPE.BOOLERR:<br />
   return new XlsBiffBoolErrCell(bytes, offset);<br />
   break;<br />

case BIFFRECORDTYPE.BOOLERR:<br />
   dt.Rows[cell.RowIndex][cell.ColumnIndex] = ((XlsBiffBoolErrCell)cell).Value;<br />
   break;