public override dynamic Run(FunctionStruct fs)
{
var args = fs.ListArgs;
if (args.Count < 1)
{
throw new Exception($"функция #{FuncsEnum.создатьАВ} принимает 1+ параметров ( сложность арифм. выражения | диапазон | тип | зависимость от кол-ва пермененных) | строка = [ {fs.ToString()} ]");
}
try
{
// получение параметров
double range = args.Count > 1 ? double.Parse(args[1].Replace('.', ',')) : 25;
bool isDouble = args.Count > 2 ? args[2].Trim(' ') == TypesEnum.дробное.ToString() : false;
int countofvars = args.Count > 3 ? int.Parse(args[3]) : 1;
int finesse = args.Count > 4 ? int.Parse(args[4]) : 2;
bool frac = args.Count > 5 ? bool.Parse(args[5]) : _makeFrac;
int diff = int.Parse(args[0]);
// генерация арифм. выражения
_arithmExpr.MakeAE(diff, range, isDouble, countofvars, finesse, frac);
}
catch (Exception ex)
{
throw new Exception($"Ошибка во время парсинга аргументов функции #{FuncsEnum.создатьАВ} | строка = [ {fs.Raw} | ошибка = {ex.Message}]");
}
// все возвращаемые значения
return(new List <(string, string)> {
("выражение", _arithmExpr.ExpressionMD),
("вычисление", _arithmExpr.Expression),
("условие", _arithmExpr.Conditions),
("код", _arithmExpr.Code)
});
// шаблонный метод
public List <(string, string)> Call(FunctionStruct fs)
{
// вовзвращаемые данные
List <(string, string)> returningData = new List <(string, string)>();
// вызов конкретного метода
var result = Run(fs);
// создание списка готовых значений
if (MultypleReturnDatas)
{
if (result.ToString() == "table")
{
LuaTable lt = (LuaTable)result;
foreach (var k in lt.Keys)
{
returningData.Add((k.ToString().ToLower(), lt[k].ToString()));
}
}
else
{
return(result);
}
}
else
{
returningData.Add(("0", result));
}
return(returningData);
}
public override dynamic Run(FunctionStruct fs)
{
// получение кода на lua из аргумента
StringBuilder s = new StringBuilder(fs.Args);
if (s[0] == '\"' && s[^ 1] == '\"')
{
s[0] = ' ';
s[^ 1] = ' ';
public override dynamic Run(FunctionStruct fs)
{
var args = fs.ListArgs;
if (args.Count == 3)
{
args.Insert(2, TypesEnum.дробное.ToString());
}
if (args.Count == 2)
{
args.Add(TypesEnum.дробное.ToString());
}
return(Next(args, fs.ToString()));
}
// вызов необходимых функций
public List <(string, string)> WhatToDoWithParam(FunctionStruct fs)
{
List <(string, string)> ls = new List <(string, string)>();
switch (fs.FuncsEnum)
{
// если функция вовсе не фукнция, а просто строка - возвращаем ее
case FuncsEnum.justString:
ls.Add(("0", fs.Raw));
break;
// вызов необходимой функции
default:
ls = _f[fs.FuncsEnum].Call(fs);
break;
}
return(ls);
}
public override dynamic Run(FunctionStruct fs)
{
// анализ - какой метод необходимо вызвать и из какого модуля
List <(string, string)> ls = new List <(string, string)>();
int pos = fs.FullFunctionName.IndexOf('.');
if (pos == -1)
{
ls.Add(("0", fs.Raw)); return(ls);
}
string moduleName = fs.FullFunctionName.Substring(0, pos).Replace("\\", "/");
string funcName = fs.FullFunctionName.Substring(pos + 1, fs.FullFunctionName.Length - pos - 1);
// создание кода для вызова метода
var package = GetPackage(moduleName);
fs.Args = $"\"{package} local lib = require('{moduleName}');return lib.{funcName}({fs.Args});\"";
// вызов метода
return(base.Run(fs));
}
public override dynamic Run(FunctionStruct fs)
{
var args = fs.ListArgs;
return(Next(args, fs.ToString()));
}
public override dynamic Run(FunctionStruct fs)
{
return(base.Run(fs));
}
/// <summary>
/// 解析一个方法的注释,并把方法信息装箱到_ClassStruct
/// </summary>
/// <param name="docs"></param>
/// <returns></returns>
void AnalyticalFunction(List <Dictionary <string, string> > docs)
{
FunctionStruct fs = new FunctionStruct();
foreach (var item in docs)
{
//这是一个方法
if (item.ContainsValue(functionKey))
{
string[] line = item.Keys.First().Split(spaseKey, StringSplitOptions.None);
string functionName = line[1];
string functionClass = line[0].Split(new string[] { "=#" }, StringSplitOptions.None)[1].Replace("]", "");
if (functionClass == _classStruct._Class)
{
fs._Function = functionName;
}
}
else if (item.ContainsValue(functionDocKey))
{
fs._Doc += item.Keys.First();
}
//这是一个参数
else if (item.ContainsValue(paramKey))
{
string key = item.Keys.First();
if (!IsIgnoreKey(key))
{
int index = key.IndexOf(" ");
if (index == -1)
{
index = key.Length;
}
string[] keyData = key.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < keyData.Length - 1; i++)
{
sb.Add(keyData[i]).Add(" ");
}
string paramType = sb.GetString().Trim(' ').Trim('#');
string paramName = keyData[keyData.Length - 1].Trim(' ').Trim('#'); //key.Substring(index, key.Length - index).Trim(' ');
ParamStruct ps;
if (fs._Params == null)
{
fs._Params = new List <ParamStruct>();
}
if (fs._Params.Exists(x =>
x._Param == paramName))
{
ps = fs._Params.Find(x => x._Param == paramName);
fs._Params.Remove(ps);
}
else
{
ps = new ParamStruct();
ps._Param = paramName;
}
ps._Type = paramType;
fs._Params.Add(ps);
}
}
//这是一个参数的注释
else if (item.ContainsValue(paramDocKey))
{
string key = item.Keys.First();
int index = key.IndexOf(" ");
if (index == -1)
{
index = key.Length;
}
string paramName = key.Substring(0, index).Trim(' ');
string paramDoc = key.Substring(index, key.Length - index).Trim(' ');
ParamStruct ps;
if (fs._Params == null)
{
fs._Params = new List <ParamStruct>();
}
if (fs._Params.Exists(x =>
x._Param == paramName))
{
ps = fs._Params.Find(x => x._Param == paramName);
fs._Params.Remove(ps);
}
else
{
ps = new ParamStruct();
ps._Param = paramName;
}
ps._Doc = paramDoc;
fs._Params.Add(ps);
}
//这是一个返回值
else if (item.ContainsValue(returnKey))
{
fs._Return._ReturnType = item.Keys.First().Split(new string[] { "#" }, StringSplitOptions.None)[0];
}
}
if (_classStruct._Functions == null)
{
_classStruct._Functions = new List <FunctionStruct>();
}
_classStruct._Functions.Add(fs);
}
public abstract dynamic Run(FunctionStruct fs);
