private static void ProcessAttr(TBaseParsedToken Token, TFormulaStack ParsedStack)
{
TAttrSpaceToken SpaceToken = Token as TAttrSpaceToken;
if (SpaceToken != null)
{
switch (SpaceToken.SpaceType)
{
case FormulaAttr.bitFSpace: ParsedStack.FmSpaces += new String(' ', SpaceToken.SpaceCount); break;
case FormulaAttr.bitFEnter: ParsedStack.FmSpaces += new String('\u000D', SpaceToken.SpaceCount); break;
case FormulaAttr.bitFPreSpace: ParsedStack.FmPreSpaces += new String(' ', SpaceToken.SpaceCount); break;
case FormulaAttr.bitFPreEnter: ParsedStack.FmPreSpaces += new String('\u000D', SpaceToken.SpaceCount); break;
case FormulaAttr.bitFPostSpace: ParsedStack.FmPostSpaces += new String(' ', SpaceToken.SpaceCount); break;
case FormulaAttr.bitFPostEnter: ParsedStack.FmPostSpaces += new String('\u000D', SpaceToken.SpaceCount); break;
case FormulaAttr.bitFPreFmlaSpace: break; //not handled;
} //case
}
if (Token is TAttrSumToken)
{
string s = ParsedStack.Pop();
ParsedStack.Push(ParsedStack.FmSpaces + TXlsFunction.GetData(4).Name + fts(TFormulaToken.fmOpenParen) + ParsedStack.FmPreSpaces + s + ParsedStack.FmPostSpaces + fts(TFormulaToken.fmCloseParen));
}
}
private void CheckFutureFunction(TParsedTokenListBuilder TokenBuilder, ref int np, TNameRecordList Names, ref TCellFunctionData fd2, TTokenOffset TokenOffset, ref bool HasAggregate)
{
//We need to recursively read parameters in back order to find out the name, which is stored as far as possible from the function :(
TParsedTokenList ParsedList = TokenBuilder.ToParsedTokenList();
ParsedList.ResetPositionToLast();
for (int i = 0; i < np; i++) //np is +1. But we will move below the name, then inc 1, so we know there isn't a "neutral" token like parent or memarea, intead of the real thing.
{
ParsedList.Flush();
}
ParsedList.MoveBack();
TNameToken bp = ParsedList.ForwardPop() as TNameToken;
if (bp is TNameXToken)
{
return; //This name isn't an internal 2007 name.
}
if (bp == null)
{
return;
}
if (bp.NameIndex <= 0 || bp.NameIndex > Names.Count)
{
return;
}
string FunctionName = Names[bp.NameIndex - 1].Name;
if (FunctionName.StartsWith("_xlfn.", StringComparison.InvariantCultureIgnoreCase))
{
TCellFunctionData fn = TXlsFunction.GetData(FunctionName.Substring("_xlfn.".Length));
if (fn != null)
{
if (fn.Index == (int)TFutureFunctions.Aggregate)
{
HasAggregate = true;
}
fd2 = fn;
int tPos = ParsedList.SavePosition();
TokenBuilder.RemoveAt(tPos);
TokenOffset.RemoveToken(tPos);
np--;
}
}
}
private bool Evaluate(TParsedTokenListBuilder TokenBuilder, TTokenOffset TokenOffset, TNameRecordList Names, ptg BaseToken, ptg RealToken,
byte[] RPN, ref int tPos, ref int ArrayPos, ref TUnsupportedFormulaErrorType ErrType, ref string ErrName, ref bool HasSubtotal, ref bool HasAggregate)
{
switch (BaseToken)
{
case ptg.Exp:
AddParsedExp(TokenBuilder, BitOps.GetWord(RPN, tPos + 1), BitOps.GetWord(RPN, tPos + 3));
tPos += 4;
break;
case ptg.Tbl:
AddParsedTable(TokenBuilder, BitOps.GetWord(RPN, tPos + 1), BitOps.GetWord(RPN, tPos + 3));
tPos += 4;
break;
case ptg.Add:
case ptg.Sub:
case ptg.Mul:
case ptg.Div:
case ptg.Power:
case ptg.Concat:
case ptg.LT:
case ptg.LE:
case ptg.EQ:
case ptg.GE:
case ptg.GT:
case ptg.NE:
case ptg.Uminus:
case ptg.Percent:
case ptg.Uplus:
AddParsedOp(TokenBuilder, (TOperator)BaseToken); break;
case ptg.MissArg: AddMissingArg(TokenBuilder); break;
case ptg.Isect: AddParsedSep(TokenBuilder, BaseToken); break;
case ptg.Union: AddParsedSep(TokenBuilder, BaseToken); break;
case ptg.Range: AddParsedSep(TokenBuilder, BaseToken); break;
case ptg.Paren: Push(TokenBuilder, TParenToken.Instance); break;
case ptg.Str:
long sl = 0;
string Result = null;
StrOps.GetSimpleString(false, RPN, tPos + 1, false, 0, ref Result, ref sl);
AddParsed(TokenBuilder, Result);
tPos += (int)sl;
break;
case ptg.Attr: int AttrLen = 0; if (!ProcessAttr(TokenBuilder, RPN, tPos + 1, ref AttrLen))
{
return(false);
}
tPos += AttrLen; break;
case ptg.Sheet: return(false);
case ptg.EndSheet: return(false);
case ptg.Err: AddParsed(TokenBuilder, (TFlxFormulaErrorValue)RPN[tPos + 1]); tPos++; break;
case ptg.Bool: AddParsed(TokenBuilder, RPN[tPos + 1] == 1); tPos++; break;
case ptg.Int: AddParsed16(TokenBuilder, BitOps.GetWord(RPN, tPos + 1)); tPos += 2; break;
case ptg.Num: AddParsed(TokenBuilder, BitConverter.ToDouble(RPN, tPos + 1)); tPos += 8; break;
case ptg.Array: Push(TokenBuilder, GetArrayDataToken(RealToken, RPN, ref ArrayPos)); tPos += 7; break;
case ptg.Func:
bool Result1;
int index = BitOps.GetWord(RPN, tPos + 1);
TCellFunctionData fd = TXlsFunction.GetData(index, out Result1);
if (!Result1)
{
return(false);
}
Debug.Assert(fd.MinArgCount == fd.MaxArgCount, "On a fixed formula the min count of arguments should be the same as the max");
AddParsedFormula(TokenBuilder, RealToken, fd, (byte)fd.MinArgCount);
tPos += 2;
break;
case ptg.FuncVar:
bool Result2;
int index2 = BitOps.GetWord(RPN, tPos + 2);
TCellFunctionData fd2 = TXlsFunction.GetData(index2, out Result2);
if (!Result2)
{
return(false);
}
if (fd2.Index == 344) // SubTotal
{
HasSubtotal = true;
}
int np = RPN[tPos + 1] & 0x7F;
if (fd2.Index == 255)
{
CheckFutureFunction(TokenBuilder, ref np, Names, ref fd2, TokenOffset, ref HasAggregate);
}
AddParsedFormula(TokenBuilder, RealToken, fd2, (byte)np);
tPos += 3;
break;
case ptg.Name:
Push(TokenBuilder, new TNameToken(RealToken, BitOps.GetWord(RPN, tPos + 1)));
tPos += 4;
break;
case ptg.NameX:
Push(TokenBuilder, new TNameXToken(RealToken, BitOps.GetWord(RPN, tPos + 1), BitOps.GetWord(RPN, tPos + 3)));
tPos += 6;
break;
case ptg.RefErr:
case ptg.Ref:
AddParsedRef(TokenBuilder, RealToken, BitOps.GetWord(RPN, tPos + 1), BitOps.GetWord(RPN, tPos + 2 + 1)); tPos += 4;
break;
case ptg.RefN:
AddParsedRefN(TokenBuilder, RealToken, BitOps.GetWord(RPN, tPos + 1), BitOps.GetWord(RPN, tPos + 2 + 1)); tPos += 4;
break;
case ptg.AreaErr:
case ptg.Area:
AddParsedArea(TokenBuilder, RealToken, BitOps.GetWord(RPN, tPos + 1), BitOps.GetWord(RPN, tPos + 2 + 1), BitOps.GetWord(RPN, tPos + 4 + 1), BitOps.GetWord(RPN, tPos + 6 + 1)); tPos += 8;
break;
case ptg.AreaN:
AddParsedAreaN(TokenBuilder, RealToken, BitOps.GetWord(RPN, tPos + 1), BitOps.GetWord(RPN, tPos + 2 + 1), BitOps.GetWord(RPN, tPos + 4 + 1), BitOps.GetWord(RPN, tPos + 6 + 1)); tPos += 8;
break;
case ptg.MemArea:
{
int ArrayLen;
Push(TokenBuilder, new TMemAreaToken(RealToken, GetMemControl(RPN, ArrayPos, out ArrayLen), tPos + 1 + 6 + BitOps.GetWord(RPN, tPos + 1 + 4)));
ArrayPos += ArrayLen; tPos += 6;
break; //this is an optimization, but we don't need it.
}
case ptg.MemErr:
{
Push(TokenBuilder, new TMemErrToken(RealToken, (TFlxFormulaErrorValue)RPN[tPos + 1], tPos + 1 + 6 + BitOps.GetWord(RPN, tPos + 1 + 4)));
tPos += 6;
break; //this is an optimization, but we don't need it.
}
case ptg.MemNoMem:
{
Push(TokenBuilder, new TMemNoMemToken(RealToken, tPos + 1 + 6 + BitOps.GetWord(RPN, tPos + 1 + 4)));
tPos += 6;
break; //this is an optimization, but we don't need it.
}
case ptg.MemFunc:
{
Push(TokenBuilder, new TMemFuncToken(RealToken, tPos + 1 + 2 + BitOps.GetWord(RPN, tPos + 1)));
tPos += 2;
break; //this is an optimization, but we don't need it.
}
case ptg.MemAreaN:
{
Push(TokenBuilder, new TMemAreaNToken(RealToken, tPos + 1 + 2 + BitOps.GetWord(RPN, tPos + 1)));
tPos += 2;
break; //this is an optimization, but we don't need it.
}
case ptg.MemNoMemN:
{
Push(TokenBuilder, new TMemNoMemNToken(RealToken, tPos + 1 + 2 + BitOps.GetWord(RPN, tPos + 1)));
tPos += 2;
break; //this is an optimization, but we don't need it.
}
case ptg.Ref3dErr:
case ptg.Ref3d:
{
int grBit1 = BitOps.GetWord(RPN, tPos + 4 + 1);
int ExternSheet = BitOps.GetWord(RPN, tPos + 1);
int Row1 = BitOps.GetWord(RPN, tPos + 2 + 1);
AddParsed3dRef(TokenBuilder, RealToken, ExternSheet, Row1, grBit1);
tPos += 6;
break;
}
case ptg.Area3dErr:
case ptg.Area3d:
{
int ExternSheet = BitOps.GetWord(RPN, tPos + 1);
int Row1 = BitOps.GetWord(RPN, tPos + 2 + 1);
int Row2 = BitOps.GetWord(RPN, tPos + 4 + 1);
int grBit1 = BitOps.GetWord(RPN, tPos + 6 + 1);
int grBit2 = BitOps.GetWord(RPN, tPos + 8 + 1);
AddParsed3dArea(TokenBuilder, RealToken, ExternSheet, Row1, Row2, grBit1, grBit2);
tPos += 10;
break;
}
default: return(false);
}
return(true);
}
