NTERA/NTERA.EmuEra/Game/EraEmu/GameProc/Function/Argument.cs

using System;
using System.Collections.Generic;
using System.Reflection;
using NTERA.EmuEra.Game.EraEmu.GameData.Expression;
using NTERA.EmuEra.Game.EraEmu.GameData.Function;
using NTERA.EmuEra.Game.EraEmu.GameData.Variable;

namespace NTERA.EmuEra.Game.EraEmu.GameProc.Function
{
	internal abstract class Argument
	{
		public bool IsConst;
		public string ConstStr;
		public Int64 ConstInt;
	}

	internal sealed class VoidArgument : Argument
	{
	}

	internal sealed class ErrorArgument : Argument
	{
		public ErrorArgument(string errorMes)
		{
			this.errorMes = errorMes;
		}
		readonly string errorMes;
	}

	internal sealed class ExpressionArgument : Argument
	{
		public ExpressionArgument(IOperandTerm termSrc)
		{
			Term = termSrc;
		}
		public readonly IOperandTerm Term;
	}

	internal sealed class ExpressionArrayArgument : Argument
	{
		public ExpressionArrayArgument(List<IOperandTerm> termList)
		{
			TermList = new IOperandTerm[termList.Count];
			termList.CopyTo(TermList);
		}
		public readonly IOperandTerm[] TermList;
	}

	internal sealed class SpPrintVArgument : Argument
	{
		public SpPrintVArgument(IOperandTerm[] list)
		{
			Terms = list;
		}
		public readonly IOperandTerm[] Terms;
	}

	internal sealed class SpTimesArgument : Argument
	{
		public SpTimesArgument(VariableTerm var, double d)
		{
			VariableDest = var;
			DoubleValue = d;
		}
		public readonly VariableTerm VariableDest;
		public readonly double DoubleValue;
	}

	internal sealed class SpBarArgument : Argument
	{
		public SpBarArgument(IOperandTerm value, IOperandTerm max, IOperandTerm length)
		{
			Terms[0] = value;
			Terms[1] = max;
			Terms[2] = length;
		}
		public readonly IOperandTerm[] Terms = new IOperandTerm[3];
	}


	internal sealed class SpSwapCharaArgument : Argument
	{
		public SpSwapCharaArgument(IOperandTerm x, IOperandTerm y)
		{
			X = x;
			Y = y;
		}
		public readonly IOperandTerm X;
		public readonly IOperandTerm Y;
	}

	internal sealed class SpSwapVarArgument : Argument
	{
		public SpSwapVarArgument(VariableTerm v1, VariableTerm v2)
		{
			var1 = v1;
			var2 = v2;
		}
		public readonly VariableTerm var1;
		public readonly VariableTerm var2;
	}

	internal sealed class SpVarsizeArgument : Argument
	{
		public SpVarsizeArgument(VariableToken var)
		{
			VariableID = var;
		}
		public readonly VariableToken VariableID;
	}

	internal sealed class SpSaveDataArgument : Argument
	{
		public SpSaveDataArgument(IOperandTerm target, IOperandTerm var)
		{
			Target = target;
			StrExpression = var;
		}
		public readonly IOperandTerm Target;
		public readonly IOperandTerm StrExpression;
	}

	internal sealed class SpTInputsArgument : Argument
	{
		public SpTInputsArgument(IOperandTerm time, IOperandTerm def, IOperandTerm disp, IOperandTerm timeout)
		{
			Time = time;
			Def = def;
			Disp = disp;
            Timeout = timeout;
		}
		public readonly IOperandTerm Time;
		public readonly IOperandTerm Def;
		public readonly IOperandTerm Disp;
        public readonly IOperandTerm Timeout;
	}

	//難読化用属性。enum.ToString()やenum.Parse()を行うなら(Exclude=true)にすること。
	[Obfuscation(Exclude = false)]
	internal enum SortOrder
	{
		UNDEF = 0,
		ASCENDING = 1,
		DESENDING = 2
	}

	internal sealed class SpSortcharaArgument : Argument
	{
		public SpSortcharaArgument(VariableTerm var, SortOrder order)
		{
			SortKey = var;
			SortOrder = order;
		}
		public readonly VariableTerm SortKey;
		public readonly SortOrder SortOrder;
	}

	internal sealed class SpCallFArgment : Argument
	{
		public SpCallFArgment(IOperandTerm funcname, IOperandTerm[] subNames, IOperandTerm[] args)
		{
			FuncnameTerm = funcname;
			SubNames = subNames;
			RowArgs = args;
		}
		public readonly IOperandTerm FuncnameTerm;
		public readonly IOperandTerm[] SubNames;
		public readonly IOperandTerm[] RowArgs;
		public IOperandTerm FuncTerm;
	}

	internal sealed class SpCallArgment : Argument
	{
		public SpCallArgment(IOperandTerm funcname, IOperandTerm[] subNames, IOperandTerm[] args)
		{
			FuncnameTerm = funcname;
			SubNames = subNames;
			RowArgs = args;
		}
		public readonly IOperandTerm FuncnameTerm;
		public readonly IOperandTerm[] SubNames;
		public readonly IOperandTerm[] RowArgs;
		public UserDefinedFunctionArgument UDFArgument;
		public CalledFunction CallFunc;
	}

	internal sealed class SpForNextArgment : Argument
	{
		public SpForNextArgment(VariableTerm var, IOperandTerm start, IOperandTerm end, IOperandTerm step)
		{
			Cnt = var;
			Start = start;
			End = end;
			Step = step;
		}
		public readonly VariableTerm Cnt;
		public readonly IOperandTerm Start;
		public readonly IOperandTerm End;
		public readonly IOperandTerm Step;
	}

	internal sealed class SpPowerArgument : Argument
	{
		public SpPowerArgument(VariableTerm var, IOperandTerm x, IOperandTerm y)
		{
			VariableDest = var;
			X = x;
			Y = y;
		}
		public readonly VariableTerm VariableDest;
		public readonly IOperandTerm X;
		public readonly IOperandTerm Y;
	}

	internal sealed class CaseArgument : Argument
	{
		public CaseArgument(CaseExpression[] args)
		{
			CaseExps = args;
		}
		public readonly CaseExpression[] CaseExps;
	}

	internal sealed class PrintDataArgument : Argument
	{
		public PrintDataArgument(VariableTerm var)
		{
			Var = var;
		}
		public readonly VariableTerm Var;
	}

    internal sealed class StrDataArgument : Argument
    {
        public StrDataArgument(VariableTerm var)
        {
            Var = var;
        }
        public readonly VariableTerm Var;
    }

	internal sealed class MethodArgument : Argument
	{
		public MethodArgument(IOperandTerm method)
		{
			MethodTerm = method;
		}
		public readonly IOperandTerm MethodTerm;
	}

	internal sealed class BitArgument : Argument
	{
		public BitArgument(VariableTerm var, IOperandTerm[] termSrc)
		{
			VariableDest = var;
			Term = termSrc;
		}
		public readonly VariableTerm VariableDest;
		public readonly IOperandTerm[] Term;
	}

	internal sealed class SpVarSetArgument : Argument
	{
		public SpVarSetArgument(VariableTerm var, IOperandTerm termSrc, IOperandTerm start, IOperandTerm end)
		{
			VariableDest = var;
			Term = termSrc;
			Start = start;
			End = end;
		}
		public readonly VariableTerm VariableDest;
		public readonly IOperandTerm Term;
		public readonly IOperandTerm Start;
		public readonly IOperandTerm End;
	}

	internal sealed class SpCVarSetArgument : Argument
	{
		public SpCVarSetArgument(VariableTerm var, IOperandTerm indexTerm, IOperandTerm termSrc, IOperandTerm start, IOperandTerm end)
		{
			VariableDest = var;
			Index = indexTerm;
			Term = termSrc;
			Start = start;
			End = end;
		}
		public readonly VariableTerm VariableDest;
		public readonly IOperandTerm Index;
		public readonly IOperandTerm Term;
		public readonly IOperandTerm Start;
		public readonly IOperandTerm End;
	}

	internal sealed class SpButtonArgument : Argument
	{
		public SpButtonArgument(IOperandTerm p1, IOperandTerm p2)
		{
			PrintStrTerm = p1;
			ButtonWord = p2;
		}
		public readonly IOperandTerm PrintStrTerm;
		public readonly IOperandTerm ButtonWord;
	}


	internal sealed class SpColorArgument : Argument
	{
		public SpColorArgument(IOperandTerm r, IOperandTerm g, IOperandTerm b)
		{
			R = r;
			G = g;
			B = b;
		}
		public SpColorArgument(IOperandTerm rgb)
		{
			RGB = rgb;
		}
		public readonly IOperandTerm R;
		public readonly IOperandTerm G;
		public readonly IOperandTerm B;
		public readonly IOperandTerm RGB;
	}

	internal sealed class SpSplitArgument : Argument
	{
		public SpSplitArgument(IOperandTerm s1, IOperandTerm s2, VariableToken varId, VariableTerm num)
		{
			TargetStr = s1;
			Split = s2;
			Var = varId;
            Num = num;
		}
		public readonly IOperandTerm TargetStr;
		public readonly IOperandTerm Split;
		public readonly VariableToken Var;
        public readonly VariableTerm Num;
	}
	
	internal sealed class SpHtmlSplitArgument : Argument
	{
		public SpHtmlSplitArgument(IOperandTerm s1,VariableToken varId, VariableTerm num)
		{
			TargetStr = s1;
			Var = varId;
            Num = num;
		}
		public readonly IOperandTerm TargetStr;
		public readonly VariableToken Var;
        public readonly VariableTerm Num;
	}

	internal sealed class SpGetIntArgument : Argument
	{
		public SpGetIntArgument(VariableTerm var)
		{
			VarToken = var;
		}
		public readonly VariableTerm VarToken;
	}

	internal sealed class SpArrayControlArgument : Argument
	{
		public SpArrayControlArgument(VariableTerm var, IOperandTerm num1, IOperandTerm num2)
		{
			VarToken = var;
			Num1 = num1;
			Num2 = num2;
		}
		public readonly VariableTerm VarToken;
		public readonly IOperandTerm Num1;
		public readonly IOperandTerm Num2;
	}

	internal sealed class SpArrayShiftArgument : Argument
	{
		public SpArrayShiftArgument(VariableTerm var, IOperandTerm num1, IOperandTerm num2, IOperandTerm num3, IOperandTerm num4)
		{
			VarToken = var;
			Num1 = num1;
			Num2 = num2;
			Num3 = num3;
			Num4 = num4;
		}
		public readonly VariableTerm VarToken;
		public readonly IOperandTerm Num1;
		public readonly IOperandTerm Num2;
		public readonly IOperandTerm Num3;
		public readonly IOperandTerm Num4;
	}

    internal sealed class SpArraySortArgument : Argument
    {
        public SpArraySortArgument(VariableTerm var, SortOrder order, IOperandTerm num1, IOperandTerm num2)
        {
            VarToken = var;
            Order = order;
            Num1 = num1;
            Num2 = num2;
        }
        public readonly VariableTerm VarToken;
        public readonly SortOrder Order;
        public readonly IOperandTerm Num1;
        public readonly IOperandTerm Num2;
    }

    internal sealed class SpCopyArrayArgument : Argument
    {
        public SpCopyArrayArgument(IOperandTerm str1, IOperandTerm str2)
        {
            VarName1 = str1;
            VarName2 = str2;
        }
        public readonly IOperandTerm VarName1;
        public readonly IOperandTerm VarName2;
    }

	internal sealed class SpSaveVarArgument : Argument
	{
		public SpSaveVarArgument(IOperandTerm term, IOperandTerm mes, VariableToken[] varTokens)
		{
			Term = term;
			SavMes = mes;
			VarTokens = varTokens;
		}
		public readonly IOperandTerm Term;
		public readonly IOperandTerm SavMes;
		public readonly VariableToken[] VarTokens;
	}

	internal sealed class RefArgument : Argument
	{
		public RefArgument(UserDefinedRefMethod udrm, UserDefinedRefMethod src)
		{
			RefMethodToken = udrm;
			SrcRefMethodToken = src;
		}
		public RefArgument(UserDefinedRefMethod udrm, CalledFunction src)
		{
			RefMethodToken = udrm;
			SrcCalledFunction = src;
		}
		public RefArgument(UserDefinedRefMethod udrm, IOperandTerm src)
		{
			RefMethodToken = udrm;
			SrcTerm = src;
		}
		
		public RefArgument(ReferenceToken vt, VariableToken src)
		{
			RefVarToken = vt;
			SrcVarToken = src;
		}
		public RefArgument(ReferenceToken vt, IOperandTerm src)
		{
			RefVarToken = vt;
			SrcTerm = src;
		}
		public readonly UserDefinedRefMethod RefMethodToken;
		public readonly UserDefinedRefMethod SrcRefMethodToken;
		public readonly CalledFunction SrcCalledFunction;

		public readonly ReferenceToken RefVarToken;
		public readonly VariableToken SrcVarToken;
		public readonly IOperandTerm SrcTerm;
	}

    internal sealed class OneInputArgument : Argument
    {
        public OneInputArgument(IOperandTerm term, IOperandTerm flag)
        {
            Term = term;
            Flag = flag;
        }
        public readonly IOperandTerm Term;
        public readonly IOperandTerm Flag;
    }

    internal sealed class OneInputsArgument : Argument
    {
        public OneInputsArgument(IOperandTerm term, IOperandTerm flag)
        {
            Term = term;
            Flag = flag;
        }
        public readonly IOperandTerm Term;
        public readonly IOperandTerm Flag;
    }
    
	#region set系
	internal sealed class SpSetArgument : Argument
	{
		public SpSetArgument(VariableTerm var, IOperandTerm termSrc)
		{
			VariableDest = var;
			Term = termSrc;
		}
		public readonly VariableTerm VariableDest;
		public readonly IOperandTerm Term;
		public bool AddConst = false;
	}

	internal sealed class SpSetArrayArgument : Argument
	{
		public SpSetArrayArgument(VariableTerm var, IOperandTerm[] termList, Int64[] constList)
		{
			VariableDest = var;
			TermList = termList;
			ConstIntList = constList;
		}
		public SpSetArrayArgument(VariableTerm var, IOperandTerm[] termList, string[] constList)
		{
			VariableDest = var;
			TermList = termList;
			ConstStrList = constList;
		}
		public readonly VariableTerm VariableDest;
		public readonly IOperandTerm[] TermList;
		public readonly Int64[] ConstIntList;
		public readonly string[] ConstStrList;
	}
	#endregion




}