public static SheetCellRange[] ExtractAllExternalReference(ICalcEvaluator evaluator, CalcExpression expression)
{
if (expression != null)
{
List <CalcReferenceExpression> nodes = new List <CalcReferenceExpression>();
FormulaUtility.ExtractAllReferenceExpression(evaluator, expression, nodes);
if (nodes.Count > 0)
{
List <SheetCellRange> list2 = new List <SheetCellRange>();
foreach (CalcReferenceExpression expression2 in nodes)
{
if (expression2 is CalcExternalRangeExpression)
{
CalcExternalRangeExpression expression3 = expression2 as CalcExternalRangeExpression;
SheetCellRange range = new SheetCellRange(expression3.Source as Worksheet, expression3.StartRow, expression3.StartColumn, (expression3.EndRow - expression3.StartRow) + 1, (expression3.EndColumn - expression3.StartColumn) + 1);
list2.Add(range);
}
else if (expression2 is CalcExternalCellExpression)
{
CalcExternalCellExpression expression4 = expression2 as CalcExternalCellExpression;
SheetCellRange range2 = new SheetCellRange(expression4.Source as Worksheet, expression4.Row, expression4.Column, 1, 1);
list2.Add(range2);
}
else
{
return(null);
}
}
return(list2.ToArray());
}
}
return(null);
}
protected override CalcExpression VisitExternalRangeExpression(CalcExternalRangeExpression expr, int baseRow, int baseColumn)
{
if (expr.Source == this._source)
{
this.AddPredenceIds((expr.GetId(this._baseRow, this._BaseColumn) as CalcExternalIdentity).ConvertToLocal(), ((expr.StartRowRelative && expr.StartColumnRelative) && expr.EndRowRelative) && expr.EndColumnRelative);
}
return(base.VisitExternalRangeExpression(expr, baseRow, baseColumn));
}
protected override CalcExpression VisitExternalRangeExpression(CalcExternalRangeExpression expr, int baseRow, int baseColumn)
{
int num3;
int num4;
int num6;
int num8;
if ((base.CurrentCalcSource == null) || (base.CurrentCalcSource != expr.Source))
{
return(expr);
}
if (this._isFullBand && ((this._isRow && expr.StartRowRelative) || (!this._isRow && expr.StartColumnRelative)))
{
return(expr);
}
CalcExternalRangeIdentity id = expr.GetId(baseRow, baseColumn) as CalcExternalRangeIdentity;
int oldStart = this._isRow ? id.RowIndex : id.ColumnIndex;
int oldEnd = this._isRow ? ((id.RowIndex + id.RowCount) - 1) : ((id.ColumnIndex + id.ColumnCount) - 1);
this.GetRangeOffset(oldStart, oldEnd, out num3, out num4);
int oldIndex = this._isRow ? baseRow : baseColumn;
this.GetCellOffset(oldIndex, out num6);
int num7 = this._isRow ? (baseRow + id.RowCount) : (baseColumn + id.ColumnCount);
this.GetCellOffset(num7, out num8);
if ((num3 == -2147483648) && (num4 == -2147483648))
{
return(new CalcErrorExpression(CalcErrors.Reference));
}
if ((num3 == -2147483648) || (num4 == -2147483648))
{
return(expr);
}
int row = num3 - oldStart;
if ((this._isRow && expr.StartRowRelative) || (!this._isRow && expr.StartColumnRelative))
{
row -= num6 - oldIndex;
}
int endRow = num4 - oldEnd;
if ((this._isRow && expr.EndRowRelative) || (!this._isRow && expr.EndColumnRelative))
{
endRow -= num8 - num7;
}
if ((row == 0) && (endRow == 0))
{
return(base.VisitExternalRangeExpression(expr, baseRow, baseColumn));
}
if (this._isRow)
{
return(expr.Offset(row, 0, endRow, 0, true, !this.OffsetAbsoluteOnly));
}
return(expr.Offset(0, row, 0, endRow, true, !this.OffsetAbsoluteOnly));
}
public static SheetCellRange Formula2SheetRange(ICalcEvaluator evaluator, string formula)
{
CalcExternalRangeExpression expression = FormulaUtility.Formula2Expression(evaluator, formula) as CalcExternalRangeExpression;
if (expression == null)
{
return(null);
}
return(new SheetCellRange(expression.Source as Worksheet, expression.StartRow, expression.StartColumn, (expression.EndRow - expression.StartRow) + 1, (expression.EndColumn - expression.StartColumn) + 1));
}
protected override CalcExpression VisitExternalRangeExpression(CalcExternalRangeExpression expr, int baseRow, int baseColumn)
{
CalcExternalRangeIdentity id = expr.GetId(baseRow, baseColumn) as CalcExternalRangeIdentity;
if (this._isCopy && this._offsetForDependency)
{
return(expr);
}
if (this._offsetForDependency)
{
if ((!id.IsFullColumn && (((id.RowIndex + this._rowOffset) < 0) || ((((id.RowIndex + id.RowCount) - 1) + this._rowOffset) >= this._rowCount))) || (!id.IsFullRow && (((id.ColumnIndex + this._columnOffset) < 0) || ((((id.ColumnIndex + id.ColumnCount) - 1) + this._columnOffset) >= this._columnCount))))
{
return(new CalcErrorExpression(CalcErrors.Reference));
}
if (this.NeedMove(id.RowIndex, id.ColumnIndex, (id.RowIndex + id.RowCount) - 1, (id.ColumnIndex + id.ColumnCount) - 1))
{
expr = expr.Offset(this._rowOffset, this._columnOffset, this._offsetForDependency, true) as CalcExternalRangeExpression;
}
}
else if (!this._isCopy)
{
if (!expr.StartRowRelative && !expr.EndRowRelative)
{
this._rowOffset = 0;
}
if (!expr.StartColumnRelative && !expr.EndColumnRelative)
{
this._columnOffset = 0;
}
if (this.NeedMove(baseRow, baseColumn, baseRow + id.RowCount, baseColumn + id.ColumnCount))
{
expr = expr.Offset(-this._rowOffset, -this._columnOffset, false, true) as CalcExternalRangeExpression;
}
}
if (!this._convertToExternal || (expr.Source == this._extSource))
{
return(expr);
}
if (expr.IsFullRow && expr.IsFullColumn)
{
return(new CalcExternalRangeExpression(this._extSource));
}
if (expr.IsFullRow)
{
return(new CalcExternalRangeExpression(this._extSource, expr.StartRow, expr.EndRow, expr.StartRowRelative, expr.EndRowRelative, true));
}
if (expr.IsFullColumn)
{
return(new CalcExternalRangeExpression(this._extSource, expr.StartColumn, expr.EndColumn, expr.StartColumnRelative, expr.EndColumnRelative, false));
}
return(new CalcExternalRangeExpression(this._extSource, expr.StartRow, expr.StartColumn, expr.EndRow, expr.EndColumn, expr.StartRowRelative, expr.StartColumnRelative, expr.EndRowRelative, expr.EndColumnRelative));
}
static bool ContainsCell(CalcExpression exp, int row, int column)
{
CalcRangeExpression expression = exp as CalcRangeExpression;
if (expression != null)
{
return((((row >= expression.StartRow) && (row <= expression.EndRow)) && (column >= expression.StartColumn)) && (column <= expression.EndColumn));
}
CalcExternalRangeExpression expression2 = exp as CalcExternalRangeExpression;
if (expression2 == null)
{
return(false);
}
return((((row >= expression2.StartRow) && (row <= expression2.EndRow)) && (column >= expression2.StartColumn)) && (column <= expression2.EndColumn));
}
void GetStartAndEnd()
{
switch (this.DataOrientation)
{
case Dt.Cells.Data.DataOrientation.Vertical:
{
CalcRangeExpression dataReference = this.DataReference as CalcRangeExpression;
if (dataReference != null)
{
this.start = dataReference.StartRow;
this.end = dataReference.EndRow;
this.anchorLine = dataReference.StartColumn;
}
CalcExternalRangeExpression expression2 = this.DataReference as CalcExternalRangeExpression;
if (expression2 == null)
{
break;
}
this.start = expression2.StartRow;
this.end = expression2.EndRow;
this.anchorLine = expression2.StartColumn;
return;
}
case Dt.Cells.Data.DataOrientation.Horizontal:
{
CalcRangeExpression expression3 = this.DataReference as CalcRangeExpression;
if (expression3 != null)
{
this.start = expression3.StartColumn;
this.end = expression3.EndColumn;
this.anchorLine = expression3.StartRow;
}
CalcExternalRangeExpression expression4 = this.DataReference as CalcExternalRangeExpression;
if (expression4 != null)
{
this.start = expression4.StartColumn;
this.end = expression4.EndColumn;
this.anchorLine = expression4.StartRow;
}
break;
}
default:
return;
}
}
public static string SheetRange2Formula(ICalcEvaluator evaluator, SheetCellRange range)
{
if (evaluator == null)
{
return(null);
}
string str = null;
try
{
CalcExternalRangeExpression expression = new CalcExternalRangeExpression(range.Sheet, range.Row, range.Column, (range.Row + range.RowCount) - 1, (range.Column + range.ColumnCount) - 1, false, false, false, false);
str = evaluator.Expression2Formula(expression, 0, 0);
}
catch (Exception)
{
}
return(str);
}
static CalcExpression ConvertToExternal(ICalcSource extSource, CalcExpression exp)
{
if (exp is CalcRangeExpression)
{
CalcRangeExpression expression = (CalcRangeExpression)exp;
if (expression.IsFullRow && expression.IsFullColumn)
{
return(new CalcExternalRangeExpression(extSource));
}
if (expression.IsFullRow)
{
return(new CalcExternalRangeExpression(extSource, expression.StartRow, expression.EndRow, expression.StartRowRelative, expression.EndRowRelative, true));
}
if (expression.IsFullColumn)
{
return(new CalcExternalRangeExpression(extSource, expression.StartColumn, expression.EndColumn, expression.StartColumnRelative, expression.EndColumnRelative, false));
}
return(new CalcExternalRangeExpression(extSource, expression.StartRow, expression.StartColumn, expression.EndRow, expression.EndColumn, expression.StartRowRelative, expression.StartColumnRelative, expression.EndRowRelative, expression.EndColumnRelative));
}
if (exp is CalcCellExpression)
{
CalcCellExpression expression2 = (CalcCellExpression)exp;
return(new CalcExternalCellExpression(extSource, expression2.Row, expression2.Column, expression2.RowRelative, expression2.ColumnRelative));
}
if (exp is CalcExternalRangeExpression)
{
CalcExternalRangeExpression expression3 = (CalcExternalRangeExpression)exp;
if (expression3.Source != extSource)
{
return(new CalcExternalRangeExpression(extSource, expression3.StartRow, expression3.StartColumn, expression3.EndRow, expression3.EndColumn, expression3.StartRowRelative, expression3.StartColumnRelative, expression3.EndRowRelative, expression3.EndColumnRelative));
}
return(exp);
}
if (exp is CalcExternalCellExpression)
{
CalcExternalCellExpression expression4 = (CalcExternalCellExpression)exp;
if (expression4.Source != extSource)
{
return(new CalcExternalCellExpression(extSource, expression4.Row, expression4.Column, expression4.RowRelative, expression4.ColumnRelative));
}
}
return(exp);
}
static CellRange GetExpressionRange(CalcExpression exp)
{
if (exp is CalcRangeExpression)
{
CalcRangeExpression expression = (CalcRangeExpression)exp;
if (expression.IsFullRow && expression.IsFullColumn)
{
return(new CellRange(-1, -1, -1, -1));
}
if (expression.IsFullRow)
{
return(new CellRange(-1, expression.StartColumn, -1, (expression.EndColumn - expression.StartColumn) + 1));
}
if (expression.IsFullColumn)
{
return(new CellRange(expression.StartRow, -1, (expression.EndRow - expression.StartRow) + 1, -1));
}
return(new CellRange(expression.StartRow, expression.StartColumn, (expression.EndRow - expression.StartRow) + 1, (expression.EndColumn - expression.StartColumn) + 1));
}
if (!(exp is CalcExternalRangeExpression))
{
return(null);
}
CalcExternalRangeExpression expression2 = (CalcExternalRangeExpression)exp;
if (expression2.IsFullRow && expression2.IsFullColumn)
{
return(new CellRange(-1, -1, -1, -1));
}
if (expression2.IsFullRow)
{
return(new CellRange(-1, expression2.StartColumn, -1, (expression2.EndColumn - expression2.StartColumn) + 1));
}
if (expression2.IsFullColumn)
{
return(new CellRange(expression2.StartRow, -1, (expression2.EndRow - expression2.StartRow) + 1, -1));
}
return(new CellRange(expression2.StartRow, expression2.StartColumn, (expression2.EndRow - expression2.StartRow) + 1, (expression2.EndColumn - expression2.StartColumn) + 1));
}
protected override CalcExpression VisitExternalRangeExpression(CalcExternalRangeExpression expr, int baseRow, int baseColumn)
{
bool flag = !expr.IsFullColumn && expr.StartRowRelative;
bool flag2 = !expr.IsFullRow && expr.StartColumnRelative;
bool flag3 = !expr.IsFullColumn && expr.EndRowRelative;
bool flag4 = !expr.IsFullRow && expr.EndColumnRelative;
if ((!flag && !flag2) && (!flag3 && !flag4))
{
return(expr);
}
int num = expr.Source.GetRowCount() - 1;
int num2 = expr.Source.GetColumnCount() - 1;
CalcExternalRangeIdentity identity = this.GetId(expr, baseRow, baseColumn) as CalcExternalRangeIdentity;
int num3 = (identity.RowIndex + identity.RowCount) - 1;
int num4 = (identity.ColumnIndex + identity.ColumnCount) - 1;
if (((!flag || ((identity.RowIndex >= 0) && (identity.RowIndex <= num))) && (!flag2 || ((identity.ColumnIndex >= 0) && (identity.ColumnIndex <= num2)))) && ((!flag3 || ((num3 >= 0) && (num3 <= num))) && (!flag4 || ((num4 >= 0) && (num4 <= num2)))))
{
return(base.VisitExternalRangeExpression(expr, baseRow, baseColumn));
}
return(new CalcErrorExpression(CalcErrors.Reference));
}
protected override CalcExpression VisitExternalRangeExpression(CalcExternalRangeExpression expr, int baseRow, int baseColumn)
{
if (expr.IsFullRow && expr.IsFullColumn)
{
return(expr);
}
if (this._isRow && expr.IsFullRow)
{
if (expr.StartRow == expr.EndRow)
{
return(new CalcExternalCellExpression(expr.Source, expr.StartRow, this._index));
}
return(new CalcExternalRangeExpression(expr.Source, expr.StartRow, this._index, expr.EndRow, this._index));
}
if (this._isRow || !expr.IsFullColumn)
{
return(base.VisitExternalRangeExpression(expr, baseRow, baseColumn));
}
if (expr.StartColumn == expr.EndColumn)
{
return(new CalcExternalCellExpression(expr.Source, this._index, expr.StartColumn));
}
return(new CalcExternalRangeExpression(expr.Source, this._index, expr.StartColumn, this._index, expr.EndColumn));
}
public static void ExtractAllReferenceExpression(ICalcEvaluator evaluator, CalcExpression root, List <CalcReferenceExpression> nodes)
{
if (root is CalcBinaryOperatorExpression)
{
CalcBinaryOperatorExpression expression = root as CalcBinaryOperatorExpression;
ExtractAllReferenceExpression(evaluator, expression.Left, nodes);
ExtractAllReferenceExpression(evaluator, expression.Right, nodes);
}
else if (root is CalcParenthesesExpression)
{
CalcParenthesesExpression expression2 = root as CalcParenthesesExpression;
ExtractAllReferenceExpression(evaluator, expression2.Arg, nodes);
}
else if (root is CalcExternalNameExpression)
{
CalcExternalNameExpression expression3 = root as CalcExternalNameExpression;
ICalcSource source = expression3.Source;
if (source != null)
{
CalcExpression expression4 = source.GetDefinedName(expression3.Name, -1, -1);
if (expression4 != null)
{
ExtractAllReferenceExpression(evaluator, expression4, nodes);
}
}
}
else if (root is CalcFunctionExpression)
{
CalcFunctionExpression expr = root as CalcFunctionExpression;
Worksheet worksheet = evaluator as Worksheet;
if (worksheet != null)
{
CalcEvaluatorContext context = new CalcEvaluatorContext(worksheet, false, worksheet.ActiveRowIndex, worksheet.ActiveColumnIndex, 1, 1);
object obj2 = new CalcEvaluator().Evaluate(expr, context, true, true);
if (obj2 is CalcReference)
{
CalcReference reference = obj2 as CalcReference;
int row = reference.GetRow(0);
int rowCount = reference.GetRowCount(0);
int column = reference.GetColumn(0);
int columnCount = reference.GetColumnCount(0);
ICalcSource source2 = null;
CalcReference reference2 = reference.GetSource();
// hdt
MethodInfo info = reference2.GetType().GetRuntimeMethod("GetContext", null);
if (info != null)
{
source2 = info.Invoke(reference2, null) as ICalcSource;
}
if (source2 == null)
{
source2 = worksheet;
}
CalcExternalRangeExpression expression6 = CreateExternalRangeExpressionByCount(source2, row, column, rowCount, columnCount, false, false, false, false);
nodes.Add(expression6);
}
}
}
else if (root is CalcReferenceExpression)
{
nodes.Add(root as CalcReferenceExpression);
}
}
public static CellRange GetRangeFromExpression(CalcReferenceExpression reference)
{
int row = 0;
int column = 0;
int rowCount = 0;
int columnCount = 0;
if (reference is CalcCellExpression)
{
CalcCellExpression expression = reference as CalcCellExpression;
row = expression.Row;
column = expression.Column;
rowCount = 1;
columnCount = 1;
}
else if (reference is CalcRangeExpression)
{
CalcRangeExpression expression2 = reference as CalcRangeExpression;
if (expression2.IsFullColumn)
{
row = -1;
column = expression2.StartColumn;
rowCount = -1;
columnCount = (expression2.EndColumn - expression2.StartColumn) + 1;
}
else if (expression2.IsFullRow)
{
row = expression2.StartRow;
column = -1;
rowCount = (expression2.EndRow - expression2.StartRow) + 1;
columnCount = -1;
}
else
{
row = expression2.StartRow;
column = expression2.StartColumn;
rowCount = (expression2.EndRow - expression2.StartRow) + 1;
columnCount = (expression2.EndColumn - expression2.StartColumn) + 1;
}
}
else if (reference is CalcExternalCellExpression)
{
CalcExternalCellExpression expression3 = reference as CalcExternalCellExpression;
row = expression3.Row;
column = expression3.Column;
rowCount = 1;
columnCount = 1;
}
else if (reference is CalcExternalRangeExpression)
{
CalcExternalRangeExpression expression4 = reference as CalcExternalRangeExpression;
if (expression4.IsFullColumn)
{
row = -1;
column = expression4.StartColumn;
rowCount = -1;
columnCount = (expression4.EndColumn - expression4.StartColumn) + 1;
}
else if (expression4.IsFullRow)
{
row = expression4.StartRow;
column = -1;
rowCount = (expression4.EndRow - expression4.StartRow) + 1;
columnCount = -1;
}
else
{
row = expression4.StartRow;
column = expression4.StartColumn;
rowCount = (expression4.EndRow - expression4.StartRow) + 1;
columnCount = (expression4.EndColumn - expression4.StartColumn) + 1;
}
}
return(new CellRange(row, column, rowCount, columnCount));
}
public virtual CalcExpression Visit(CalcExpression expr, int baseRow, int baseColumn)
{
CalcConstantExpression expression = expr as CalcConstantExpression;
if (expression != null)
{
return(this.VisitConstantExpression(expression));
}
CalcCellExpression expression2 = expr as CalcCellExpression;
if (expression2 != null)
{
return(this.VisitCellExpression(expression2, baseRow, baseColumn));
}
CalcRangeExpression expression3 = expr as CalcRangeExpression;
if (expression3 != null)
{
return(this.VisitRangeExpression(expression3, baseRow, baseColumn));
}
CalcUnaryOperatorExpression expression4 = expr as CalcUnaryOperatorExpression;
if (expression4 != null)
{
return(this.VisitUnaryOperatorExpression(expression4, baseRow, baseColumn));
}
CalcBinaryOperatorExpression expression5 = expr as CalcBinaryOperatorExpression;
if (expression5 != null)
{
return(this.VisitBinaryOperatorExpression(expression5, baseRow, baseColumn));
}
CalcFunctionExpression expression6 = expr as CalcFunctionExpression;
if (expression6 != null)
{
return(this.VisitFunctionExpression(expression6, baseRow, baseColumn));
}
CalcExternalCellExpression expression7 = expr as CalcExternalCellExpression;
if (expression7 != null)
{
return(this.VisitExternalCellExpression(expression7, baseRow, baseColumn));
}
CalcExternalRangeExpression expression8 = expr as CalcExternalRangeExpression;
if (expression8 != null)
{
return(this.VisitExternalRangeExpression(expression8, baseRow, baseColumn));
}
if (expr is CalcSharedExpression)
{
CalcExpression expression9 = (expr as CalcSharedExpression).Expression;
CalcExpression expression10 = this.Visit(expression9, baseRow, baseColumn);
if (expression10 == expression9)
{
return(expr);
}
return(new CalcSharedExpression(expression10));
}
CalcParenthesesExpression expression11 = expr as CalcParenthesesExpression;
if (expression11 != null)
{
return(this.VisitParenthesesExpression(expression11, baseRow, baseColumn));
}
CalcNameExpression expression12 = expr as CalcNameExpression;
if (expression12 != null)
{
return(this.VisitNameExpression(expression12, baseRow, baseColumn));
}
CalcExternalNameExpression expression13 = expr as CalcExternalNameExpression;
if (expression13 != null)
{
return(this.VisitExternalNameExpression(expression13, baseRow, baseColumn));
}
CalcSheetRangeExpression expression14 = expr as CalcSheetRangeExpression;
if (expression14 != null)
{
return(this.VisitSheetRangeExpression(expression14, baseRow, baseColumn));
}
return(expr);
}
protected virtual CalcExpression VisitExternalRangeExpression(CalcExternalRangeExpression expr, int baseRow, int baseColumn)
{
return(expr);
}
