static Expr AggImpl(CallExpr ce, Generator.Ctx ctx)
{
var valsExpr = ce.args[0];
Expr keysExpr;
if (ce.args.Count > 1)
{
keysExpr = ce.args[1];
}
else
{
keysExpr = new ReferenceExpr(sWithKey);
}
var refAkk = new ReferenceExpr(string.Format("{0}:{1}:{2}", sAkk, valsExpr, keysExpr));
int iAkk = ctx.IndexOf(refAkk.name);
Expr resultExpr;
if (iAkk >= 0)
{
resultExpr = refAkk;
}
else
{
resultExpr = new CallExpr(FuncDefs_Solver.SolverWeightedSumsAdd, refAkk,
new CallExpr(FuncDefs_Solver.SolverWeightedSumsNew, new ReferenceExpr(sFactory), valsExpr, keysExpr));
}
return(resultExpr);
}
static object AggImplSimple(CallExpr ce, Generator.Ctx ctx)
{
var what = ce.funcName;
var expr = new BinaryExpr(ExprType.Fluent, AggImpl(ce, ctx), new CallExpr(FuncDefs_Solver.SolverWeightedSumsGet, new ConstExpr(what)));
return(Generator.Generate(expr, ctx));
}
public static object AGGR(CallExpr call, Generator.Ctx ctx)
{
CallExpr ce;
{
var dict = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
ce = Filter.ReplaceValueInfoRefsWithData(call, DataLoader.sData, dict);
ctx.CreateValue(DataLoader.sUsedParamsDict, dict);
}
var args = new List <Expr>();
args.Add(CallExpr.let(new ReferenceExpr(sFactory),
new CallExpr(FuncDefs_Solver.SolverWeightedSumsFactory, ce.args[0], new ReferenceExpr(sTimeA), new ReferenceExpr(sTimeB))));
args.Add(CallExpr.let(new ReferenceExpr(sWithKey), ce.args[1]));
for (int i = 2; i < ce.args.Count; i++)
{
args.Add(ce.args[i]);
}
var exprAgg = CallExpr.Eval(args.ToArray());
var expr = new CallExpr(FuncDefs_Solver.SolverTimedObjects,
new CallExpr((Fx)FuncDefs_Solver.SolverWeightedSumsFactoryTimes, new ReferenceExpr(sFactory)), exprAgg);
return(Generator.Generate(expr, ctx));
}
static void Required(Generator.Ctx ctx, string section, string key)
{
if (!ctx.name2ndx.TryGetValue(key, out int i) || ctx.values[i] == Generator.Undefined)
{
throw new Exception($"Value named '{key}' required in section '{section}'");
}
}
/// <summary>
/// Function call context
/// </summary>
public AsyncExprCtx(Generator.Ctx funcCtx, AsyncExprCtx callerCtx, IList args, int nArgs)
{
if (funcCtx.parent != null)
{
Trace.Assert(funcCtx.parent.name2ndx == callerCtx.name2ndx);
}
else
{
Trace.Assert(funcCtx.values.Count == nArgs);
}
this.name2ndx = funcCtx.name2ndx;
var values = funcCtx.values;
int n = values.Count;
ctxValues = new CtxValue[n];
//int nArgs = args.Count;
for (int i = 0; i < nArgs; i++)
{
ctxValues[i] = new CtxValue(args[i], callerCtx);
}
for (int i = nArgs; i < n; i++)
{
ctxValues[i] = new CtxValue(values[i]);
}
parent = callerCtx;
}
public static void ValueOfAny(object funcOrValue, Generator.Ctx ctx, int nMaxParallelism, Action <object> onComplete, CancellationToken cancellation)
{
if (nMaxParallelism < 1)
{
nMaxParallelism = 1024;
}
var sema = W.Common.Utils.NewAsyncSemaphore(nMaxParallelism);
var ae = new AsyncExprRootCtx(ctx.name2ndx, ctx.values, sema);
ae.cancellationToken = cancellation;
ThreadPool.QueueUserWorkItem(state =>
{
var task = ConstValueOf(ae, funcOrValue);
//task.Start();
task.ContinueWith(t =>
{
try
{
onComplete(t.Result);
}
catch (Exception ex)
{
onComplete(ex);
Console.WriteLine(string.Join("; ", ctx.name2ndx.Keys));
}
});
});
}
public static object SqlFuncsToText(CallExpr ce, Generator.Ctx ctx)
{
var set = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
{
var arg0 = ctx.GetConstant(ce.args[0]);
if (arg0 is IList lst)
{
foreach (var s in lst)
{
set.Add(Convert.ToString(s));
}
}
else
{
set.Add(Convert.ToString(arg0));
}
}
using (var sw = new StringWriter())
{
SqlFuncsToTextImpl(ctx, sw, vi => set.Contains(vi.location));
return(sw.ToString());
}
}
public static object GetConstant(this Generator.Ctx ctx, string valueName)
{
int i = ctx.IndexOf(valueName);
var val = (i < 0) ? null : ctx[i];
if (val == null)
{
return(null);
}
var expr = val as Expr;
if (expr != null)
{
val = Generator.Generate(expr, ctx);
}
if (OPs.KindOf(val) == ValueKind.Const)
{
return(val);
}
else if (expr != null)
{
return(ctx.Error(string.Format("Constant expected as value of '{0}' // {1}", valueName, expr)));
}
else
{
return(ctx.Error(string.Format("Constant expected as value of '{0}'", valueName)));
}
}
/// <summary>
/// Nested (child) context with validation
/// </summary>
public AsyncExprCtx(Generator.Ctx ctx, IList values, AsyncExprCtx parent)
: this(ctx.name2ndx, values)
{
Trace.Assert(parent != null);
this.parent = parent;
Trace.Assert(parent.name2ndx.Count == 0 || (ctx.parent != null && parent.name2ndx == ctx.parent.name2ndx));
}
public ProcessingContext(Generator.Ctx parent, IReadFiles metaStorage)
{
ctxFile = new Generator.Ctx(parent);
ctxFile.CreateValue(sFileDir);
ctxFile.CreateValue(sFileName);
ctxFile.CreateValue(sSheetName);
var metaFiles = metaStorage.EnumerateFiles("").Where(fn => fn.EndsWith(".src.ini"));
metas = Metadata.Load(metaStorage, metaFiles, ctxFile).ToArray();
dictExt2Kind = new Dictionary <string, string>();
foreach (var m in metas)
{
foreach (var Ext in m.FileNameExtension)
{
var ext = '.' + Ext.ToLowerInvariant();
if (!dictExt2Kind.TryGetValue(ext, out var kind))
{
dictExt2Kind[ext] = m.FileContentKind;
}
else if (kind != m.FileContentKind)
{
throw new Exception($"Can't associate extension '{ext}' with two kinds of content ('{kind}' and '{m.FileContentKind}')");
}
}
}
}
public static object UseSqlAsFuncsFrom(CallExpr ce, Generator.Ctx ctx)
{
var arg0 = Generator.Generate(ce.args[0], ctx);
if (OPs.KindOf(arg0) != ValueKind.Const)
{
ctx.Error("Constant value expected");
}
var arg1 = (ce.args.Count < 2) ? null : Generator.Generate(ce.args[1], ctx);
var sqlFileName = Convert.ToString(arg0);
DbFuncType forKinds;
if (arg1 == null)
{
forKinds = DbFuncType.TimeSlice | DbFuncType.TimeInterval;
}
else
{
var lst = arg1 as IList ?? new object[] { arg1 };
forKinds = DbFuncType.None;
foreach (var v in lst)
{
forKinds |= (DbFuncType)Enum.Parse(typeof(DbFuncType), Convert.ToString(v));
}
}
var dbConnName = (ce.args.Count < 3) ? DefaultDbConnName : OPs.TryAsName(ce.args[2], ctx);
if (string.IsNullOrEmpty(dbConnName))
{
ctx.Error($"Connection name must be nonempty: {ce.args[2]}");
}
var fullFileName = Path.IsPathRooted(sqlFileName)
? sqlFileName
: Path.Combine(AppDomain.CurrentDomain.BaseDirectory, Convert.ToString(sqlFileName));
var cacheKey = $"FuncDefs:{fullFileName}:{forKinds.ToString()}";
Func <object> ldfsFunc = () =>
{
var sqlCtx = new W.Expressions.Sql.Preprocessing.PreprocessingContext()
{
sqlFileName = fullFileName,
cacheSubdomain = "DB",
dbConnValueName = dbConnName,
forKinds = forKinds,
ctx = ctx,
cachingExpiration = TimeSpan.FromMinutes(5),
defaultLocationForValueInfo = (ce.args.Count < 4) ? null : OPs.TryAsString(ce.args[3], ctx)
};
return(sqlCtx.LoadingFuncs());
};
var lfds = (IEnumerable <FuncDef>)FuncDefs_Core._Cached(cacheKey, ldfsFunc, DateTimeOffset.MaxValue, TimeSpan.FromMinutes(5));
return(lfds);
}
public LoadingInfo(string dataExpr, object cookie, Generator.Ctx rootCtx)
{
this.dataExpr = dataExpr;
this.cookie = cookie;
aggCtx = new Generator.Ctx(rootCtx);
var expr = Parser.ParseToExpr(dataExpr);
aggCode = Generator.Generate(expr, aggCtx);
}
public static object SqlFuncsToDDL(CallExpr ce, Generator.Ctx ctx)
{
var locationCode = Convert.ToString(ctx.GetConstant(ce.args[0]));
using (var sw = new StringWriter())
using (var drops = new StringWriter())
{
SqlFuncsToDDL_Impl(ctx, sw, drops, locationCode);
return(new object[] { sw.ToString(), drops.ToString() });
}
}
public static Task <object> GlobalValueOfAny(object funcOrValue, Generator.Ctx ctx, int nMaxParallelism, CancellationToken cancellation)
{
if (nMaxParallelism < 1)
{
nMaxParallelism = 1024;
}
var sema = W.Common.Utils.NewAsyncSemaphore(nMaxParallelism);
var ae = new AsyncExprRootCtx(ctx.name2ndx, ctx.values, sema);
ae.cancellationToken = cancellation;
return(ConstValueOf(ae, funcOrValue));
}
public static Task <object> GlobalValueOfAny(object funcOrValue, Generator.Ctx ctx, CancellationToken cancellation)
{
//if (nMaxParallelism < 1)
// nMaxParallelism = 128;
//var sema = Cached<IAsyncSemaphore>("WExpr:GlobalMaxParallelismSemaphore",
// () => W.Common.Utils.NewAsyncSemaphore(nMaxParallelism),
// null, TimeSpan.FromMinutes(5), System.Web.Caching.Cache.NoAbsoluteExpiration);
var sema = GlobalMaxParallelismSemaphore;
var ae = new AsyncExprRootCtx(ctx.name2ndx, ctx.values, sema);
ae.cancellationToken = cancellation;
return(ConstValueOf(ae, funcOrValue));
}
public static object GetConstant(this Generator.Ctx ctx, Expr expr)
{
var val = Generator.Generate(expr, ctx);
if (OPs.KindOf(val) == ValueKind.Const)
{
return(val);
}
else
{
return(ctx.Error("Constant expected as value of " + expr.ToString()));
}
}
static void SqlFuncsToTextImpl(Generator.Ctx ctx, TextWriter wr, Func <ValueInfo, bool> filter)
{
foreach (var f in ctx.GetFunc(null, 0))
{
if (f.xtraAttrs == null || !f.xtraAttrs.TryGetValue(nameof(QueryTemplate), out var objQT))
{
// no QueryTemplate = is not SQL-originated function
continue;
}
if (!f.resultsInfo.Any(filter))
{
// no any output parameter from specified location/origin/source
continue;
}
Attr.TblAttrsFriendlyText(f.xtraAttrs, wr);
var colAttrs = (IList <Dictionary <Attr.Col, object> >)f.xtraAttrs[nameof(Attr.Tbl._columns_attrs)];
var queryTmpl = (QueryTemplate)objQT;
var sql = queryTmpl.SrcSqlExpr;
foreach (SqlSectionExpr sec in sql.args)
{
var args = sec.args;
var attrs = (sec.kind == SqlSectionExpr.Kind.Select) ? colAttrs : null;
bool fromNewLine = args.Count > 1 || attrs != null;
wr.Write(sec.sectionName);
if (fromNewLine)
{
wr.WriteLine();
}
for (int i = 0; i < args.Count; i++)
{
if (i > 0)
{
wr.WriteLine(',');
}
if (attrs != null)
{
Attr.FriendlyText(attrs[i], wr);
}
wr.Write(fromNewLine ? '\t' : ' ');
wr.Write(args[i]);
}
wr.WriteLine();
}
//wr.WriteLine(sql);
wr.WriteLine(';');
wr.WriteLine();
wr.WriteLine();
}
}
public static object LookupHelperFuncs(CallExpr ce, Generator.Ctx ctx)
{
var dbConn = ce.args[0];
var dbConnName = OPs.TryAsName(dbConn, ctx);
if (dbConnName == null)
{
throw new Generator.Exception($"Can't get DB connection name: {dbConn}");
}
var pairs = ctx.GetConstant(ce.args[1]) as IList;
if (pairs == null)
{
throw new Generator.Exception($"Can't interpet as array of constants: {ce.args[1]}");
}
if (pairs.Count % 2 != 0)
{
throw new Generator.Exception($"Items count must be even (cause it must be array of pairs): {ce.args[1]}");
}
var location = Convert.ToString(ctx.GetConstant(ce.args[2]));
var defs = new List <FuncDef>(pairs.Count / 2);
for (int i = 0; i < pairs.Count; i += 2)
{
var dbTableName = pairs[i].ToString();
var substance = pairs[i + 1].ToString();
// Dictionary loader func
defs.Add(FuncDefs_Core.macroFuncImpl(ctx,
// name
new ConstExpr($"{dbConnName}:{dbTableName}_LoadDict"),
// inputs
new ArrayExpr(),
// outputs
new ArrayExpr(new ConstExpr($"{substance}_DICT_{location}")),
// body
new CallExpr(LoadCodeLookupDictRows, dbConn, new ConstExpr(dbTableName)),
//
null, false
));
}
return(defs);
}
public static object AGGR(CallExpr call, Generator.Ctx ctx)
{
var dictUsedValues = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
//var timeSpanExpr = ce.args[0];
var ce = Filter.ReplaceValueInfoRefsWithData(call, DataLoader.sData, dictUsedValues);
ctx.CreateValue(DataLoader.sUsedParamsDict, dictUsedValues);
var expr = new CallExpr(FuncDefs_Solver.SolverTimedObjects,
new CallExpr((Fx)FuncDefs_Solver.SolverTimesOfIDicts, new ReferenceExpr(DataLoader.sData)),
ce.args[ce.args.Count - 1]
);
return(Generator.Generate(expr, ctx));
}
public static object ValueOfAny(object funcOrValue, int nMaxParallelism, Generator.Ctx ctx, CancellationToken cancellation)
{
if (nMaxParallelism < 1)
{
nMaxParallelism = 128;
}
var ae = new AsyncExprRootCtx(ctx.name2ndx, ctx.values, W.Common.Utils.NewAsyncSemaphore(nMaxParallelism));
ae.cancellationToken = cancellation;
var task = ConstValueOf(ae, funcOrValue);
//task.Start();
task.Wait();
return(task.Exception ?? task.Result);
}
public static string TryAsString(Expr expr, Generator.Ctx ctx)
{
var ce = expr as ConstExpr;
if (ce != null)
{
return(Convert.ToString(ce.value));
}
var val = Generator.Generate(expr, ctx);
if (OPs.KindOf(val) == ValueKind.Const && val != null)
{
return(Convert.ToString(val));
}
return(null);
}
public static IEnumerable <Metadata> Load(IReadFiles storage, IEnumerable <string> files, Generator.Ctx parent)
{
foreach (var fname in files)
{
using (var stream = storage.OpenReadFile(fname))
using (var reader = new StreamReader(stream))
{
var ctx = new Generator.Ctx(parent);
ctx.CreateValue(sMetadataFile, fname);
foreach (var m in Metadata.Create(reader, ctx))
{
yield return(m);
}
}
}
}
public static object COLUMN(CallExpr ce, Generator.Ctx ctx)
{
var cellName = OPs.TryAsName(ce.args[0], ctx);
if (cellName == null)
{
throw new Generator.Exception($"COLUMN(cellName): can't get cell name from expession // {ce.args[0]}");
}
int i = 0;
if (CellRange.ParseCellName(cellName, ref i, cellName.Length, out int row, out int col))
{
return(col);
}
throw new Generator.Exception($"COLUMN(cellName): can't parse given cell name // {cellName}");
}
public static object FindDependencies(CallExpr ce, Generator.Ctx ctx)
{
var arg0 = Generator.Generate(ce.args[0], ctx);
if (OPs.KindOf(arg0) != ValueKind.Const || arg0 == null)
{
throw new SolverException("FindDependencies: list of source params must be constant and not null");
}
var arg1 = (ce.args.Count > 1) ? Generator.Generate(ce.args[1], ctx) : null;
if (OPs.KindOf(arg1) != ValueKind.Const)
{
throw new SolverException("FindDependencies: optional list of dependent params must be constant");
}
var arg2 = (ce.args.Count > 2) ? Generator.Generate(ce.args[2], ctx) : null;
if (OPs.KindOf(arg2) != ValueKind.Const)
{
throw new SolverException("FindDependencies: optional list of unusable params must be constant");
}
var srcPrms = ((IList)arg0).Cast <object>().Select(o => o.ToString()).ToArray();
var depPrms = (arg1 == null) ? null : ((IList)arg1).Cast <object>().Select(o => o.ToString()).ToArray();
var unusables = (arg2 == null)
? new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase)
: ((IList)arg2).Cast <object>().Select(o => o.ToString()).ToDictionary(s => s, StringComparer.OrdinalIgnoreCase);
var aliasOf = GetAliases(ctx);
var funcs = Dependecies.GetFuncInfos(ctx.GetFunc(null, 0), aliasOf, fi => !fi.inputs.Any(inp => unusables.ContainsKey(inp)));
var dependencies = Dependecies.Find(funcs, aliasOf, int.MaxValue, srcPrms, depPrms);
var resDict = new Dictionary <string, bool>(StringComparer.OrdinalIgnoreCase);
var resParams = (depPrms == null)
? dependencies.Keys.Except(srcPrms, StringComparer.OrdinalIgnoreCase)
: depPrms.Where(s => dependencies.ContainsKey(s));
var res = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
foreach (var prmName in resParams)
{
var deps = dependencies[prmName];
var srcs = srcPrms.Where(s => deps.ContainsKey(s)).ToArray();
if (srcs.Length > 0)
{
res.Add(prmName, srcs);
}
}
return(res);
}
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 static object letLookupFunc(CallExpr ce, Generator.Ctx ctx)
{
var arg0 = ce.args[0];
object name;
var ref0 = arg0 as ReferenceExpr;
if (ref0 != null)
{
name = ref0.name;
}
else
{
name = Generator.Generate(arg0, ctx);
if (OPs.KindOf(name) != ValueKind.Const)
{
throw new SolverException("letLookupFunc(name, ...) : name must be constant");
}
}
var keysDescriptorObjs = Generator.Generate(ce.args[1], ctx);
var keysDescriptors = keysDescriptorObjs as IList;
if (OPs.KindOf(keysDescriptorObjs) != ValueKind.Const || keysDescriptors == null)
{
throw new SolverException("letLookupFunc(...,keysDescrs ...) : keysDescrs must be list of constants");
}
var valsDescriptorObjs = Generator.Generate(ce.args[2], ctx);
var valsDescriptors = valsDescriptorObjs as IList;
if (OPs.KindOf(valsDescriptorObjs) != ValueKind.Const || valsDescriptors == null)
{
throw new SolverException("letLookupFunc(...,...,valuesDescrs ...) : valuesDescrs must be list of constants");
}
var body = ce.args[3];
var func = (Macro)((expr, gctx) =>
Generator.Generate(body, gctx)
);
var keys = keysDescriptors.Cast <object>().Select(Convert.ToString);
var vals = valsDescriptors.Cast <object>().Select(Convert.ToString);
var fd = GetLookupFuncDef(Convert.ToString(name), keys, vals, func);
return(Generator.Generate(CallExpr.let(ce.args[0], new ConstExpr(fd)), ctx));
}
public static object Filtering(CallExpr ce, Generator.Ctx ctx)
{
// имя входного параметра
var inputParam = (string)Generator.Generate(ce.args[0], ctx);
var sourceData = ce.args[1].ToString();
// условия фильтрации, связанные по AND
IList <Expr> filterConditions;
{
var cond = ce.args[2] as CallExpr;
if (cond == null || cond.funcName != "AND")
{
cond = (CallExpr)Parser.ParseToExpr(Convert.ToString(Generator.Generate(ce.args[2], ctx)));
System.Diagnostics.Trace.Assert(cond.funcName == "AND", "Filtering: AND");
}
filterConditions = cond.args;
}
var outputParams = ((IList)Generator.Generate(ce.args[3], ctx)).Cast <string>().ToArray();
return(Filter.Filtering(ctx, inputParam, sourceData, filterConditions, outputParams));
}
static object solverAliasImpl(CallExpr ce, Generator.Ctx ctx)
{
var alias = OPs.TryAsName(ce.args[0], ctx);
if (alias == null)
{
throw new SolverException(string.Format(ce.funcName + "(alias ...): alias must be constant or name instead of [{0}]", ce.args[0]));
}
var target = (ce.args.Count > 1) ? OPs.TryAsName(ce.args[1], ctx) : string.Empty;
if (target == null)
{
throw new SolverException(string.Format(ce.funcName + "(..., target ...): target must be constant or name instead of [{0}]", ce.args[0]));
}
int priority = (ce.args.Count > 2) ? Convert.ToInt32(ctx.GetConstant(ce.args[2])) : 255;
int i = ctx.GetOrCreateIndexOf(optionSolverAliases);
var aliases = ctx[i] as SolverAliases;
if (aliases == null)
{
aliases = new SolverAliases();
ctx[i] = aliases;
}
switch (ce.funcName)
{
case nameof(solverAlias):
return(aliases.Set(alias, target, priority));
case nameof(solverAliasPush):
return(aliases.Push(alias, target));
case nameof(solverAliasPop):
return(aliases.Pop(alias));
default:
throw new NotImplementedException(ce.funcName);
}
}
public Task LoadData(AsyncExprCtx rootAec, Expr loadingExpr, CancellationToken ct)
{
int i = aggCtx.IndexOf(sFactory);
if (i >= 0)
{
var f = (WeightedSums.Factory)aggCtx[i];
foreach (var n2i in aggCtx.name2ndx)
{
if (n2i.Key.StartsWith(sAkk))
{
aggCtx[n2i.Value] = f.NewSums();
}
}
}
var loadingCtx = new Generator.Ctx(aggCtx.parent);
loadingCtx.CreateValue(sUsedParamsDict, aggCtx[aggCtx.IndexOf(sUsedParamsDict)]);
loadingCtx.CreateValue(sLoadingInfo, this);
var loadingCode = Generator.Generate(loadingExpr, loadingCtx);
var ae = new AsyncExprCtx(loadingCtx, loadingCtx.values, rootAec);
return(OPs.ConstValueOf(ae, loadingCode));
}
public static object WRptExploreDependencies(CallExpr ce, Generator.Ctx callerCtx)//(object tmplFileName, string[] forCells)
{
var ctx = new Generator.Ctx(callerCtx);
ctx.CreateValue(FuncDefs_Core.stateTryGetConst, string.Empty);
var templateFileName = Convert.ToString(Generator.Generate(ce.args[0], ctx));
var sheets = new Dictionary <string, XlsxR.Sheet>();
var xr = new Xlsx.Reader(templateFileName);
foreach (var s in xr.EnumSheetInfos())
{
sheets.Add(s.sheetName, new XlsxR.Sheet(s.sheetCells.ToArray(), xr.styles));
}
var forCells = Utils.AsIList(Generator.Generate(ce.args[1], ctx))
.Cast <object>()
.Select(o => Convert.ToString(o))
.ToArray();
var code = DepsHelper.DumpDeps(ctx, sheets, xr.stringTable, forCells);
return(code);
}
