Expr FixHdrCellRef(ReferenceExpr re)
{
var rng = CellRange.TryFromName(re.name);
if (ConsiderCellRef(rng))
{
return(new IndexExpr(HdrCellsRef, new ConstExpr(re.name)));
}
return(re);
}
public Expr Time2Value(string sTimeRef)
{
Expr time = new ReferenceExpr(sTimeRef);
if (valueFmt == null)
{
return(time);
}
return(new CallExpr("TO_CHAR", time, new ConstExpr(valueFmt)));
}
public static object WRptGenerateReportExpr(CallExpr ce, Generator.Ctx callerCtx)//(object tmplFileName, Expr outputFilesExpr)
{
var ctx = new Generator.Ctx(callerCtx);
ctx.CreateValue(FuncDefs_Core.stateTryGetConst, string.Empty);
var templateFileName = Convert.ToString(Generator.Generate(ce.args[0], ctx));
var outputFilesExpr = ce.args[1];
var sheetExprs = new List <Expr>();
int iSheet = 0;
int blockNum = 0;
var xr = new Xlsx.Reader(templateFileName);
var lstStrTbl = new OPs.ListOfConst(xr.stringTable);
ctx.CreateValue(XlsxR.Sheet.sStrTbl, lstStrTbl);
foreach (var s in xr.EnumSheetInfos())
{
var cells = new XlsxR.Sheet(s.sheetCells.ToArray(), xr.styles);
var sheetExpr = cells.GetSheetExpr(s.sheetFile, ctx, outputFilesExpr, ref blockNum);
sheetExprs.Add(new CallExpr(FuncDefs_Core._block,
sheetExpr,
XlsxR.PROGRESS("sheet", new ConstExpr(xr.sheetNames[iSheet]))
));
iSheet++;
}
;
var loopRef = new ReferenceExpr("sheet");
var res = CallExpr.Eval(
CallExpr.let(new ConstExpr(XlsxR.Sheet.sTmplFiles), new ConstExpr(xr.xmlFiles)),
CallExpr.let(new ConstExpr(XlsxR.Sheet.sStrTbl), new ConstExpr(lstStrTbl)),
XlsxR.PROGRESS("sheets", new ConstExpr(new OPs.ListOfConst(xr.sheetNames))),
new CallExpr(FuncDefs_Core._ForEach, loopRef, new ArrayExpr(sheetExprs), loopRef),
new CallExpr((Fxy)WRptCopyFiles, new ConstExpr(xr.xmlFiles), outputFilesExpr),
new CallExpr((Fx)WRptWriterDone, outputFilesExpr)
);
return(res);
}
public ModifyHelper()
{
modify = Expr.RecursiveModifier(e =>
{
if (e.nodeType == ExprType.Reference || e.nodeType == ExprType.Constant)
{
return(e);
}
if (e.nodeType != ExprType.Call)
{
goto tryConst;
}
var ce = (CallExpr)e;
bool isLet = ce.funcName == "let";
bool isDef = isLet || ce.funcName == "SV" || ce.funcName == "SSV";
if (!isDef && ce.funcName != "GV" && ce.funcName != "GSV")
{
goto tryConst;
}
var arg0 = ce.args[0];
string name;
if (arg0.nodeType == ExprType.Constant)
{
name = Convert.ToString((arg0 as ConstExpr).value);
if (!isLet && ce.args.Count == 1)
{
e = new ReferenceExpr(name);
}
goto constResolved;
}
if (arg0.nodeType == ExprType.Reference)
{
name = (arg0 as ReferenceExpr).name;
goto nameResolved;
}
// try to resolve name
var nameObj = TryGen(ctx, arg0);
if (nameObj == Fail || OPs.KindOf(nameObj) != ValueKind.Const)
{
thereIsNonresolved = true;
return(e);
}
name = Convert.ToString(nameObj);
thereIsNameResolve = true;
constResolved:
var args = new Expr[ce.args.Count];
if (isLet)
{
args[0] = new ReferenceExpr(name);
}
else
{
if (ce.args.Count == 1 && ce.funcName != "GSV")
{
return(new ReferenceExpr(name));
}
args[0] = new ConstExpr(name);
}
for (int i = 1; i < args.Length; i++)
{
args[i] = modify(ce.args[i]);
}
e = new CallExpr(ce.funcName, args);
nameResolved:
if (isDef && ce.args.Count == 2)
{
lets.Add(name);
//var value = modify(ce.args[1]);
//if (value.nodeType == ExprType.Constant)
//{ }
}
return(e);
tryConst:
var val = TryGen(ctx, e);
if (val == Fail || OPs.KindOf(val) != ValueKind.Const)
{
return(e);
}
return(new ConstExpr(val));
});
}
Expr SpecFuncs(CallExpr ce)
{
Expr src, ndx;
bool forPrev = false, forCell = false;
int nMinArgs = 1;
switch (ce.funcName)
{
case "PREVCELL":
forCell = true; forPrev = true; break;
case "PREV":
nMinArgs = 0; forPrev = true; break;
case "INDIRECT":
forCell = true; break;
case nameof(FuncDefs_Xlsx.COLUMN):
// avoid COLUMN(args) fixing
return(new CallExpr(nameof(FuncDefs_Xlsx.COLUMN), ce.args));
default:
return(ce);
}
if (ce.args.Count < nMinArgs)
{
return(ce);
}
Expr arg;
string name;
if (ce.args.Count == 0)
{
arg = null;
name = FCurrName;
}
else
{
arg = ce.args[0];
if (arg.nodeType == ExprType.Reference)
{
name = ((ReferenceExpr)arg).name;
if (IsColumnName(name) || !forPrev && IsFullRelativeCell(CellRange.FromName(name)))
{
forCell = true;
}
else
{
name = OPs.TryAsString(arg, ctxRow) ?? name;
}
}
else
{
arg = FixRowExpr(arg);
name = OPs.TryAsName(arg, ctxRow);
}
}
if (name == null)
{
var undefs = string.Join(", ", ctxHdr.NamesOfUndefinedValues().Concat(ctxRow.NamesOfUndefinedValues()));
throw new Source.Exception($"Constant expected as value of {ce.args[0]}={arg} // ??? {undefs}");
}
if (forCell || IsColumnName(name) || !forPrev && IsFullRelativeCell(CellRange.FromName(name)))
{
if (forPrev)
{
src = new IndexExpr(PrevValsRef, new ConstExpr(ctxRow.IndexOf(CellValsRef.name)));
}
else
{
var re1 = new ReferenceExpr(name);
var re2 = FixHdrCellRef(re1);
if (re2 != re1)
{
// ref to header cell
return(re2);
}
else
{
// ref to row cell
src = CellValsRef;
}
}
ndx = new ConstExpr(name);
}
else
{
int i = ctxRow.IndexOf(name);
if (i < 0 || Generator.Ctx.ctxDepthStep <= i)
{
throw new Source.Exception($"Value named '{name}' not found in row context");
}
src = PrevValsRef;
ndx = new ConstExpr(i);
}
return(new IndexExpr(src, ndx));
}
