// パラメータセット
void SetParam(ref ParamMode _mode, ParticleSystem.MinMaxCurve _data)
{
_mode.constant = _data.constant;
_mode.constantTwo = _data.constantMax;
if (_data.curve == null)
{
return;
}
int keyNum = _data.curve.keys.Length;
if (keyNum == 0)
{
return;
}
_mode.curve.keys = new KeyInfo[keyNum];
for (int i = 0; i < keyNum; ++i)
{
_mode.curve.keys[i].inTangent = _data.curve.keys[i].inTangent;
_mode.curve.keys[i].outTangent = _data.curve.keys[i].outTangent;
_mode.curve.keys[i].time = _data.curve.keys[i].time;
_mode.curve.keys[i].value = _data.curve.keys[i].value;
}
}
public static IntOp ParseFromString(string s)
{
// An IntOp comes in the form of 5 digits
// ABCDE A B C are parameter modes, DE is the double digit operation code
// Enter out any omitted 0s
s = s.PadLeft(5).Replace(' ', '0');
// Get digits DE as the OpCode
var code = (OpCode)int.Parse(s.Substring(3));
// Get digits ABC as ParamModes
var modes = new ParamMode[] { 0, 0, 0 };
for (var i = 0; i < 3; i++)
{
modes[i] = (ParamMode)int.Parse(s.Substring(i, 1));
}
// ABC are read right to left, to correspond to
// A being param 0, reverse array.
modes = modes.Reverse().ToArray();
return(new IntOp(code, modes));
}
/// <summary>
///
/// </summary>
static string OnConflictDoUpdate(OnConflictDoUpdateClause doUpdate, ParamMode paramMode, SqlParamDic paramDic, string origTableName)
{
var b = new StringBuilder();
b.AppendLine("DO UPDATE");
b.AppendLine("SET");
var exprAlias = new[]
{
new SqlFromList.ExprStrRawSql(doUpdate.Set.Parameters[0], "EXCLUDED"),
new SqlFromList.ExprStrRawSql(doUpdate.Set.Parameters[1], $"\"{origTableName}\""),
};
var setSql = SqlUpdate.SetToSql(doUpdate.Set.Body, paramMode, paramDic, exprAlias);
b.Append(SqlSelect.TabStr(setSql));
if (doUpdate.Where != null)
{
b.AppendLine();
var pars = new SqlExprParams(null, null, false, "", new SqlFromList.ExprStrRawSql[0], paramMode, paramDic);
var whereSql = SqlExpression.ExprToSql(doUpdate.Where.Body, pars, true);
b.Append(whereSql);
}
return(b.ToString());
}
private void Continue()
{
Debug.Assert(_memoryPtr < length, "End of program reached before halt opcode found.");
state = State.Default;
int ReadMemory() => _memory[_memoryPtr++];
while (state == State.Default)
{
int opData = ReadMemory();
int opCode = opData % 100;
opData /= 100;
Operator op = Operators[opCode];
Param[] opParams = new Param[op.paramCount];
for (int i = 0; i < op.paramCount; i++)
{
ParamMode paramMode = (ParamMode)(opData % 10);
opData /= 10;
int param = ReadMemory();
opParams[i] = new Param {
value = param, mode = paramMode
};
}
op.action(opParams);
}
}
/// <summary>
/// Converts an <see cref="ISqlQuery"/> to string
/// </summary>
public static QueryToStrResult QueryToStr(ISqlQuery item, ParamMode paramMode, SqlParamDic paramDic)
{
if (item is ISqlSelectHasClause select)
{
var str = SqlSelect.SelectToStringScalar(select.Clause, paramMode, paramDic);
return(new QueryColsToStrResult(str.Sql, str.Columns));
}
else if (item is ISqlWithSelect withSelect)
{
var withSql = SqlWith.WithToSql(withSelect.With.With, withSelect.With.Param, paramMode, paramDic);
var subquerySql = FromListTargetToStr(withSelect.Query, paramMode, paramDic);
var ret = $"{withSql}{Environment.NewLine}{subquerySql.Sql}";
if (subquerySql is QueryColsToStrResult subCols)
{
return(new QueryColsToStrResult(ret, subCols.Columns));
}
return(new QueryToStrResult(ret));
}
else if (item is ISqlSelectRaw subq)
{
return(new QueryToStrResult(SqlSelect.DetabStr(subq.Raw)));
}
throw new ArgumentException("El from item target debe de ser una tabla o un select");
}
public void Execute()
{
Debug.Assert(_state == State.Loaded, _state == State.Uninitialized
? "Unable to execute before loading, no program to run!"
: "Already executed! Reset and load before executing again.");
while (_state != State.Complete)
{
Debug.Assert(_memoryPtr < Length, "End of program reached before halt opcode found.");
int opData = _memory[_memoryPtr++];
int opCode = opData % 100;
opData /= 100;
Debug.Assert(s_Instructions.ContainsKey(opCode), "Unknown opCode: " + opCode);
Instruction instruction = s_Instructions[opCode];
Param[] opParams = new Param[instruction.paramCount];
for (int i = 0; i < instruction.paramCount; i++)
{
ParamMode paramMode = (ParamMode)(opData % 10);
opData /= 10;
int param = _memory[_memoryPtr++];
opParams[i] = new Param {
value = param, mode = paramMode
};
}
instruction.action(opParams);
}
}
public string GetCharListRawData(string the_file)
{
string str1 = "";
ParamMode paramMode = ParamMode.NONE;
StreamReader streamReader = null;
try
{
streamReader = new StreamReader(the_file, Encoding.Default);
while (streamReader.Peek() >= 0)
{
string stBuffer = streamReader.ReadLine().Trim();
if (stBuffer.IndexOf(";", 0) != 0)
{
int length1 = stBuffer.IndexOf(';');
if (length1 > 0)
{
stBuffer = stBuffer.Substring(0, length1);
}
int length2 = stBuffer.IndexOf(',');
if (length2 > 0)
{
stBuffer = stBuffer.Substring(0, length2);
}
switch (_CheckParamMode(stBuffer))
{
case ParamMode.NONE:
if (paramMode == ParamMode.CHARACTERS)
{
string str2 = stBuffer;
string lower = stBuffer.ToLower();
if (!lower.Contains("randomselect") && !lower.Contains("blank") && !lower.Contains("empty") && !lower.Contains("none"))
{
str1 = str1 + str2 + Environment.NewLine;
continue;
}
continue;
}
continue;
case ParamMode.CHARACTERS:
paramMode = ParamMode.CHARACTERS;
continue;
default:
paramMode = ParamMode.NONE;
continue;
}
}
}
}
catch
{
streamReader?.Close();
return(str1);
}
streamReader?.Close();
return(str1);
}
/// <summary>
/// Convierte un INSERT a string
/// </summary>
static StatementToStrResult InsertToStr(ISqlInsert item, ParamMode paramMode, SqlParamDic paramDic)
{
if (item is ISqlInsertHasClause clau)
{
return(SqlInsertConverter.InsertToString(clau.Clause, paramMode, paramDic));
}
throw new ArgumentException(nameof(item));
}
/// <summary>
/// Obtiene el SQL y los parámetros de un select
/// </summary>
public static SqlResult ToSql(this ISqlStatement statement, ParamMode mode)
{
var dic = new SqlParamDic();
var sql = StatementStr.StatementToString(statement, mode, dic).Sql;
var pars = dic.Items.Select(x => new SqlParam(x.ParamName, x.GetValue(), x.GetParamType()));
return(new SqlResult(sql, pars.ToList()));
}
private void WriteResult(long loc, long val, ParamMode mode)
{
if (mode == ParamMode.Positional)
{
WriteMem(ReadMem(loc), val);
}
else
{
WriteMem(_rp + ReadMem(loc), val);
}
}
/// <summary>
/// Convierte una cláusula de INSERT a string.
/// Si el INSERT devuelve valores.
///
/// Devuelve ya sea un <see cref="InsertNoReturningStrResult"/> o un <see cref="InsertReturningToStr"/>
/// </summary>
public static StatementToStrResult InsertToString(InsertClause clause, ParamMode paramMode, SqlParamDic paramDic)
{
var b = new StringBuilder();
b.Append("INSERT INTO ");
b.Append($"\"{clause.Table}\" ");
if ((clause.Value == null) == (clause.Query == null))
{
throw new ArgumentException("Query debe de ser null si value no es null");
}
if (clause.Value != null)
{
b.Append(InsertValueToString(clause, paramMode, paramDic));
}
else
{
//Query
var sqlQuery = SqlSelect.SelectToStringScalar(clause.Query, paramMode, paramDic);
//Texto de las columnas:
b.Append("(");
b.Append(string.Join(", ", sqlQuery.Columns));
b.AppendLine(")");
b.Append(sqlQuery.Sql);
}
if (clause.OnConflict != null)
{
b.AppendLine();
b.Append(OnConflict(clause.OnConflict, paramMode, paramDic, clause.Table));
}
//Columnas del returning
IReadOnlyList <string> columns = null;
if (clause.Returning != null)
{
b.AppendLine();
var returning = ReturningToString(clause.Returning, paramMode, paramDic, clause.Table);
b.Append(returning.sql);
columns = returning.cols;
}
var sql = b.ToString();
if (columns != null)
{
return(new InsertReturningToStr(sql, columns));
}
return(new InsertNoReturningStrResult(sql));
}
static void ConvertWhere(StringBuilder b, DeleteClause clause, ParamMode paramMode, SqlParamDic paramDic)
{
var whereParms = clause.Where.Parameters;
var tableParam = whereParms[0];
var usingParam = whereParms[1];
var replace = new SqlFromList.ExprStrRawSql[0];
var pars = new SqlExprParams(tableParam, null, false, null, replace, paramMode, paramDic);
var whereSql = SqlExpression.ExprToSql(clause.Where.Body, pars, true);
b.Append("WHERE ");
b.Append(whereSql);
}
static string ParamToSql(SqlParamItem param, ParamMode mode)
{
switch (mode)
{
case ParamMode.EntityFramework:
return($"@{param.ParamName}");
case ParamMode.Substitute:
return(SqlConst.ConstToSql(param.GetValue()));
default:
throw new ArgumentException("No se pueden usar parametros con el param mode 'None'");
}
}
/// <summary>
/// Convierte un <see cref="IFromListItemTarget"/> a string, devuelve true si el elemento requiered de un alias
/// </summary>
static StatementToStrResult FromListTargetToStr(IFromListItemTarget item, ParamMode paramMode, SqlParamDic paramDic)
{
if (item is ISqlQuery query)
{
return(QueryToStr(query, paramMode, paramDic));
}
else if (item is SqlTable table)
{
return(new TableToStrResult(TableToString(table)));
}
else if (item is ISqlTableRefRaw raw)
{
return(new TableToStrResult(raw.Raw));
}
throw new ArgumentException("El from item target debe de ser una tabla o un select");
}
private bool CheckParamMode(string stBuffer)
{
ParamMode paramMode = _CheckParamMode(stBuffer);
switch (paramMode)
{
case ParamMode.MUGEN:
case ParamMode.AUTO_MODE:
case ParamMode.CHARACTERS:
_paramMode = paramMode;
return(true);
default:
return(false);
}
}
private long GetParamAt(long loc, ParamMode mode)
{
if (mode == ParamMode.Immediate)
{
return(ReadMem(_ip + loc));
}
if (mode == ParamMode.Positional)
{
return(ReadMem(ReadMem(_ip + loc)));
}
if (mode == ParamMode.Relative)
{
return(ReadMem(_rp + ReadMem(_ip + loc)));
}
return(0);
}
/// <summary>
/// Convierte una sentencia de SQL a string.
/// Puede convertir SELECT (fluent o RAW), INSERT y TABLE
/// </summary>
public static StatementToStrResult StatementToString(ISqlStatement item, ParamMode paramMode, SqlParamDic paramDic)
{
switch (item)
{
case ISqlInsert insert:
return(InsertToStr(insert, paramMode, paramDic));
case ISqlQuery query:
return(QueryToStr(query, paramMode, paramDic));
case IFromListItemTarget fromItem:
return(FromListTargetToStr(fromItem, paramMode, paramDic));
default:
throw new ArgumentException(nameof(item));
}
}
protected ExpressionInfo Build(string expression, ParamMode mode, string paramStr, IKeyWordProvider provider)
{
ExpressionInfo expressionInfo;
switch (mode)
{
case ParamMode.Expression:
{
var relatedExpressionInfo = new RelatedExpressionInfo();
var strArry = paramStr.Replace(provider.ExpressionString, string.Empty).Split(provider.ExpressionSplitChar);
relatedExpressionInfo.InvokeName = strArry[0];
if (strArry.Length == 2)
{
relatedExpressionInfo.ReturnTypeName = strArry[1];
}
expressionInfo = relatedExpressionInfo;
}
break;
case ParamMode.Func:
{
var funcExpressionInfo = new FuncExpressionInfo();
var strArry = paramStr.Replace(provider.FuncString, string.Empty).Split(provider.ExpressionSplitChar);
funcExpressionInfo.Name = strArry[0];
if (strArry.Length > 1)
{
funcExpressionInfo.InvokeName = strArry[1];
}
expressionInfo = funcExpressionInfo;
}
break;
default:
expressionInfo = new ExpressionInfo();
break;
}
expressionInfo.Mode = mode;
expressionInfo.Str = paramStr;
return(expressionInfo);
}
private bool CheckParamMode(string stBuffer)
{
ParamMode paramMode = _CheckParamMode(stBuffer);
switch (paramMode)
{
case ParamMode.VSMode:
case ParamMode.P1History:
case ParamMode.P2History:
case ParamMode.P3History:
case ParamMode.P4History:
_paramMode = paramMode;
return(true);
default:
return(false);
}
}
/// <summary>
/// Convierte a string la parte del VALUE de un INSERT
/// </summary>
static string InsertValueToString(InsertClause clause, ParamMode paramMode, SqlParamDic paramDic)
{
var b = new StringBuilder();
//Note que aquí el fromAlias no afecta ya se se usan directamente los nombres de las columnas
//y no se puede referenciar a la tabla de origen en los VALUES
var pars = new SqlExprParams(null, null, false, null, new SqlFromList.ExprStrRawSql[0], paramMode, paramDic);
//Hacer el rewrite en todo el body:
var visitor = new SqlRewriteVisitor(pars);
var body = visitor.Visit(clause.Value);
var exprs = SqlSelect
.ExtractInitExpr(body)
.Select(x => (x.mem, sql: SqlExpression.ExprToSqlStar(x.expr, pars, false)))
;
if (exprs.Any(y => y.sql.star))
{
throw new ArgumentException("No esta soportado una expresión star '*' en la asignación de los valores de un INSERT");
}
var subpaths = exprs.SelectMany(x => x.sql.sql, (parent, child) => (member: parent.mem, subpath: child));
//Nombres de las columnas del INSERT
var columns = subpaths
.Select(x => SqlSelect.MemberToColumnName(x.member, x.subpath))
.Select(SqlSelect.ColNameToStr);
;
//Valores:
var values = subpaths.Select(x => x.subpath.Sql);
//Texto de las columnas:
b.Append("(");
b.Append(string.Join(", ", columns));
b.AppendLine(")");
//Texto de los vaues:
b.Append("VALUES (");
b.Append(string.Join(", ", values));
b.Append(")");
return(b.ToString());
}
static public Int64 EvalParamIndex(int Offset)
{
int PositionMode = ParamMode.ElementAtOrDefault(Offset);
Int64 RealIndex;
if (PositionMode == 0)
{
RealIndex = Data[Index + Offset + 1];
}
else if (PositionMode == 1)
{
RealIndex = Index + Offset + 1;
}
else
{
RealIndex = GetBase() + Data[Index + Offset + 1];
}
return(RealIndex);
}
/// <summary>
/// Convierte el cuerpo de la expresión SET a SQL
/// </summary>
public static string SetToSql(Expression body,
ParamMode paramMode,
SqlParamDic paramDic,
IEnumerable <SqlFromList.ExprStrRawSql> exprAlias
)
{
var b = new StringBuilder();
var pars = new SqlExprParams(null, null, false, null, exprAlias.ToList(), paramMode, paramDic);
//Hacer el rewrite en todo el body:
var visitor = new SqlRewriteVisitor(pars);
body = visitor.Visit(body);
var exprs = SqlSelect
.ExtractInitExpr(body)
.Select(x => (x.mem, sql: SqlExpression.ExprToSqlStar(x.expr, pars, false)))
;
if (exprs.Any(y => y.sql.star))
{
throw new ArgumentException("No esta soportado una expresión star '*' en la asignación de los valores de un INSERT");
}
var subpaths = exprs.SelectMany(x => x.sql.sql, (parent, child) => (member: parent.mem, subpath: child));
var sets = subpaths.Select(x => (
column: SqlSelect.MemberToColumnName(x.member, x.subpath),
value: x.subpath.Sql))
;
var setSql = sets
.Select(x =>
$"{SqlSelect.ColNameToStr(x.column)} = {x.value}"
);
var sql = string.Join($", {Environment.NewLine}", setSql);
return(sql);
}
/// <summary>
/// Convierte la cláusura ON CONFLICT
/// </summary>
static string OnConflict(OnConflictClause onConf, ParamMode paramMode, SqlParamDic paramDic, string tableName)
{
var b = new StringBuilder();
//fromAlias es null ya que en la expresion de indice de ON CONFLICT no se permiten
//los identificadores de las tablas, sólo se permiten los nombres tal cual de las columnas
var pars = new SqlExprParams(null, null, false, null, new SqlFromList.ExprStrRawSql[0], paramMode, paramDic);
var indexExpr = onConf
.IndexExpressions
.Select(x => SqlExpression.ExprToSql(x.Body, pars.ReplaceSelectParams(x.Parameters[0], null), true))
;
b.Append("ON CONFLICT ");
if (indexExpr.Any())
{
b.Append("(");
b.Append(string.Join(", ", indexExpr));
b.Append(") ");
}
if (onConf.Where != null)
{
var whereSql = SqlExpression.ExprToSql(onConf.Where.Body, pars.ReplaceSelectParams(onConf.Where.Parameters[0], null), true);
b.Append("WHERE ");
b.Append(whereSql);
}
if (onConf.DoUpdate == null)
{
//Si DoUpdate es null se considera que es DO NOTHING
b.Append("DO NOTHING");
}
else
{
b.Append(OnConflictDoUpdate(onConf.DoUpdate, paramMode, paramDic, tableName));
}
return(b.ToString());
}
public SqlExprParams(ParameterExpression param, ParameterExpression window, bool fromListNamed, string fromListAlias, IReadOnlyList <ExprStrRawSql> replace, ParamMode paramMode, SqlParamDic paramDic)
{
if (replace.Count > 0)
{
;
}
if (fromListNamed && fromListAlias != null)
{
throw new ArgumentException($"'{nameof(fromListAlias)}' debe de ser null cuando '{nameof(fromListNamed)}' = true");
}
if (fromListAlias == "")
{
throw new ArgumentException($"'{nameof(fromListAlias)}' no debe de ser una cadena vacía");
}
Param = param;
Window = window;
FromListNamed = fromListNamed;
FromListAlias = fromListAlias;
Replace = replace;
ParamMode = paramMode;
ParamDic = paramDic;
}
static void ConvertDelete(StringBuilder b, DeleteClause clause, ParamMode paramMode, SqlParamDic paramDic)
{
b.Append("DELETE FROM ");
if (clause.Only)
{
b.Append("ONLY ");
}
b.Append(SqlSelect.TableNameToStr(clause.Table));
if (clause.Using.Any())
{
b.AppendLine();
b.Append("USING ");
b.Append(string.Join(", ", clause.Using));
}
if (clause.Where != null)
{
b.AppendLine();
ConvertWhere(b, clause, paramMode, paramDic);
}
}
public void ResetConf()
{
_paramMode = ParamMode.MUGEN;
_characters.Clear();
profile_name = null;
mugen_path = null;
mugen_exe = null;
mugen_select_cfg = null;
mugen_cmdline_options_base = null;
mugen_cmdline_options = null;
speed_mode = false;
skip_mode = false;
experimental_bps = false;
debug_mode = false;
auto_mode_available = false;
error_retry = 0;
default_color = 1;
rounds_count = 1;
strict_round_mode = false;
max_round_time = 10;
char_list_raw_data = null;
screen_width = 640;
screen_height = 480;
}
public GpuParamSet(object instance, ValueMode vmode, ParamMode mode = FunctionBase.ParamMode.Value)
{
ParamMode = mode;
Instance = instance;
ValueMode = vmode;
}
public GpuParamSet(ComputeBuffer <Real> instance, ParamMode mode = FunctionBase.ParamMode.Memory)
{
ParamMode = mode;
Instance = instance;
}
protected void SetParameter(object instance, ValueMode vmode, ParamMode mode = FunctionBase.ParamMode.Value)
{
GpuParameter[sellectionIndex].Add(new GpuParamSet(instance, vmode, mode));
}
protected void SetParameter(ComputeBuffer <Real> instance, ParamMode mode = FunctionBase.ParamMode.Memory)
{
GpuParameter[sellectionIndex].Add(new GpuParamSet(instance, mode));
}
