///-----------------------------------------------------------------
private void GatherVariantsSlots(int s, int[] slots, List <FunctionVariant> variants, ScriptContent data, ClassContent contentSrc, ClassContent contentDst)
{
var varCount = contentSrc.VarCount + 1;
for (var c = 0; c < varCount; c++)
{
slots[s] = c;
if (s + 1 < slots.Length)
{
GatherVariantsSlots(s + 1, slots, variants, data, contentSrc, contentDst);
}
else
{
if (data.classDefaultExportOnly)
{
var foundValid = false;
for (var exp = 0; exp < slots.Length; exp++)
{
if (slots[exp] >= contentSrc.VarCount)
{
foundValid = true;
break;
}
}
if (!foundValid)
{
continue;
}
}
var sn = 0;
var variant = new FunctionVariant(3);
variant[1] += Glossary.Code.argsV;
for (var v = 0; v < slots.Length; v++)
{
var sv = slots[v];
if (sv < contentSrc.VarCount)
{
var name = sv < contentSrc.NameCount ? contentSrc.names[sv] : contentSrc.variables[sv];
variant.Call = name;
var variable = contentSrc.variables[sv];
variant[2] = string.Format(Glossary.Code.varsV, variable);
}
else
{
variant.Call = Glossary.Code.callN;
variant[1] = string.Format(Glossary.Code.argsNOpt, data.classDefaultType, sn, data.classDefaultValue);
variant[2] = string.Format(Glossary.Code.varsN, sn);
sn++;
}
}
if (sn != slots.Length)
{
variants.Add(variant);
}
}
}
}
///-----------------------------------------------------------------
#region Rule internal
protected override void GatherVariants(List <FunctionVariant> variants, ScriptContent scriptContent, ClassContent contentSrc, ClassContent contentDst)
{
keywords.Clear();
identifiers.Clear();
Glossary.Macros.GetTags(this);
variants.Clear();
if (scriptContent.functionContents.Count == 0)
{
return;
}
var result = string.Empty;
for (var k = 0; k < keywords.Count; k++)
{
result += scriptContent.functionContents[0].body;
result = (Variables[0] + keywords[k]).Apply(result);
}
var variant = new FunctionVariant(result, 1);
result = string.Empty;
for (var i = 0; i < identifiers.Count; i++)
{
result += scriptContent.functionContents[0].body;
result = (Variables[0] + identifiers[i]).Apply(result);
}
variant[1] = result;
variants.Add(variant);
}
///-----------------------------------------------------------------
private void GatherVariants(int s, int[] slots, List <FunctionVariant> variants, ScriptContent data, ClassContent contentSrc, ClassContent contentDst)
{
if (s < slots.Length)
{
for (var p = 0; p < 2; p++)
{
slots[s] = p;
GatherVariants(s + 1, slots, variants, data, contentSrc, contentDst);
}
}
else
{
var variant = new FunctionVariant(2);
for (var sv = 0; sv < slots.Length; sv++)
{
if (slots[sv] == 0)
{
for (var i = 0; i < data.functionContents.Count; i++)
{
var info = data.functionContents[i].body;
info = (Names[0] + contentSrc.names[sv * 2 + 0]).Apply(info);
info = (Names[1] + contentSrc.names[sv * 2 + 1]).Apply(info);
variant[i] = info;
}
}
}
if (variant.Call != string.Empty)
{
variants.Add(variant);
}
}
}
protected override void GatherVariants(List <FunctionVariant> variants, ScriptContent scriptContent, ClassContent contentSrc, ClassContent contentDst)
{
variants.Clear();
for (int r = 0; r < repeatCount; r++)
{
var variant = new FunctionVariant(scriptContent.functionContents.Count);
for (var fc = 0; fc < scriptContent.functionContents.Count; fc++)
{
var functionContent = scriptContent.functionContents[fc];
for (var v = 0; v < contentSrc.names.Count; v++)
{
var functionBody = functionContent.body;
if (Defaults[0].CanSwap(functionBody))
{
var swap = Defaults[0] + scriptContent.classDefaultType;
functionBody = swap.Apply(functionBody);
}
if (Defaults[1].CanSwap(functionBody))
{
var swap = Defaults[1] + (r + 1).ToString();
functionBody = swap.Apply(functionBody);
}
if (Names.DefaultSymbol.CanSwap(functionBody))
{
var swap = Names.DefaultSymbol + contentSrc.names[v] + r.ToString();
functionBody = swap.Apply(functionBody);
}
if (Variables.DefaultSymbol.CanSwap(functionBody))
{
var swap = Variables.DefaultSymbol + r.ToString();
functionBody = swap.Apply(functionBody);
}
variant[fc] = functionBody;
}
}
variants.Add(variant);
}
}
///-----------------------------------------------------------------
private void GatherVariants(int s, int[] slots, int count, List <FunctionVariant> variants, ScriptContent data, ClassContent contentSrc)
{
var classCount = data.classInfos.Count + 1;
for (var c = 0; c < classCount; c++)
{
var varCount = c == 0 ? 1 : data.classInfos[c - 1].VarCount;
slots[s] = c;
if (count - varCount > 0)
{
GatherVariants(s + 1, slots, count - varCount, variants, data, contentSrc);
}
else if (count - varCount == 0)
{
var sn = 0;
var sv = 0;
var variant = new FunctionVariant(contentSrc.names[0], 2);
for (var v = 0; v < slots.Length && v < s + 1; v++)
{
var sl = slots[v];
if (sl == 0)
{
variant[1] = string.Format(Glossary.Code.argsN, data.classDefaultType, sn);
variant[2] = string.Format(Glossary.Code.varsN, sn);
sn++;
}
else
{
sl -= 1;
var info = data.classInfos[sl];
variant[1] = string.Format(Glossary.Code.argsV_, info.className, sv);
for (var vr = 0; vr < info.VarCount; vr++)
{
variant[2] = string.Format(Glossary.Code.varsV_, sv, info.variables[vr]);
}
sv++;
}
}
variants.Add(variant);
}
}
}
///-----------------------------------------------------------------
#region Rule internal
protected override void GatherVariants(List <FunctionVariant> variants, ScriptContent scriptContent, ClassContent contentSrc, ClassContent contentDst)
{
infos.Clear();
Glossary.Macros.GetTags(this);
variants.Clear();
if (scriptContent.functionContents.Count == 0)
{
return;
}
var result = string.Empty;
var variant = new FunctionVariant(result);
for (var k = 0; k < infos.Count; k++)
{
result += scriptContent.functionContents[0].body;
result = (Variables[0] + infos[k].name).Apply(result);
}
variant[0] = result;
variants.Add(variant);
}
///-----------------------------------------------------------------
#region Rule internal
protected override void GatherVariants(List <FunctionVariant> variants, ScriptContent scriptContent, ClassContent contentSrc, ClassContent contentDst)
{
var slots = new int[contentSrc.VarCount];
for (var s = 0; s < slots.Length; s++)
{
slots[s] = 0;
}
variants.Clear();
GatherVariants(0, slots, slots.Length, variants, scriptContent, contentSrc);
//Add Default vec(f)
var variant = new FunctionVariant(contentSrc.names[0], 2);
variant[1] = string.Format(Glossary.Code.argsN, scriptContent.classDefaultType, 0);
for (var v = 0; v < contentSrc.VarCount; v++)
{
variant[2] = string.Format(Glossary.Code.varsN, 0);
}
variants.Add(variant);
}
///-----------------------------------------------------------------
#region Rule internal
protected override void GatherVariants(List <FunctionVariant> variants, ScriptContent scriptContent, ClassContent contentSrc, ClassContent contentDst)
{
variants.Clear();
if (scriptContent.functionContents.Count == 0)
{
variants.Add(new FunctionVariant());
}
else
{
var variant = new FunctionVariant(scriptContent.functionContents.Count);
for (var d = 0; d < scriptContent.functionContents.Count; d++)
{
var functionContent = scriptContent.functionContents[d];
for (var v = 0; v < contentSrc.variables.Count; v++)
{
var functionData = functionContent.body;
if (Variables.DefaultSymbol.CanSwap(functionContent.body))
{
var swap = Variables.DefaultSymbol + contentSrc.variables[v];
functionData = swap.Apply(functionData);
}
var currentVariable = Variables[v];
if (currentVariable.CanSwap(functionContent.body))
{
var swap = currentVariable + contentSrc.variables[v];
functionData = swap.Apply(functionData);
}
variant[d] = functionData;
}
}
variants.Add(variant);
}
}
///-----------------------------------------------------------------
protected override void GatherVariants(List <FunctionVariant> variants, ScriptContent scriptContent, ClassContent contentSrc, ClassContent contentDst)
{
variants.Clear();
var isDefault = contentSrc.VarCount == 0;
for (var d = 0; d < scriptContent.functionContents.Count; d++)
{
for (var p = 0; p < (isDefault ? 1 : 2); p++)
{
if (scriptContent.classDefaultExportOnly && (isDefault || p == 0))
{
continue;
}
var funcInfo = scriptContent.functionContents[d];
var variant = new FunctionVariant(funcInfo.funcName, 2);
var varsCount = Variables.FindCount(funcInfo.body);
if (p == 1 && varsCount == 1)
{
continue;
}
var vars = funcInfo.body;
for (var a = 0; a < varsCount; a++)
{
if (isDefault)
{
variant[1] = string.Format(Glossary.Code.argsN, scriptContent.classDefaultType, a);
vars = (Variables[a] + string.Format(Glossary.Code.varsN, a)).Apply(vars);
}
else
{
variant[1] = p == 1 && a != 0
? string.Format(Glossary.Code.argsN, scriptContent.classDefaultType, a)
: string.Format(Glossary.Code.argsV_, contentSrc.className, a);
}
}
if (isDefault)
{
variant[2] = vars;
}
else
{
for (var v = 0; v < contentSrc.VarCount; v++)
{
var varsA = vars;
for (var a = 0; a < varsCount; a++)
{
varsA = p == 1 && a != 0
? (Variables[a] + string.Format(Glossary.Code.varsN, a)).Apply(varsA)
: (Variables[a] + string.Format(Glossary.Code.varsV_, a, contentSrc.variables[v])).Apply(varsA);
}
variant[2] = varsA;
}
var v2 = new FunctionVariant(variant.Call, 2);
v2[1] = variant[1];
v2[2] = Glossary.Code.varNew + contentSrc.className + Strings.Separator.ParenthesisOpen.C() + variant[2] + Strings.Separator.ParenthesisClose.C();
variant = v2;
}
variants.Add(variant);
}
}
}
