public override long GetIntValue(ExpressionMediator exm)
{
if (dic == null)
{
dic = exm.VEvaluator.Constant.GetKeywordDictionary(out errPos, parentCode, index);
}
var key = strTerm.GetStrValue(exm);
if (key == "")
{
throw new CodeEE("キーワードを空には出来ません");
}
int i;
if (!dic.TryGetValue(key, out i))
{
if (errPos == null)
{
throw new CodeEE("配列変数" + parentCode + "の要素を文字列で指定することはできません");
}
else
{
throw new CodeEE(errPos + "の中に\"" + key + "\"の定義がありません");
}
}
return(i);
}
public virtual FixedVariableTerm GetFixedVariableTerm(ExpressionMediator exm)
{
if (!allArgIsConst)
{
for (var i = 0; i < arguments.Length; i++)
{
transporter[i] = arguments[i].GetIntValue(exm);
}
}
var fp = new FixedVariableTerm(Identifier);
if (transporter.Length >= 1)
{
fp.Index1 = transporter[0];
}
if (transporter.Length >= 2)
{
fp.Index2 = transporter[1];
}
if (transporter.Length >= 3)
{
fp.Index3 = transporter[2];
}
return(fp);
}
public override IOperandTerm Restructure(ExpressionMediator exm)
{
if (method.HasUniqueRestructure)
{
if (method.UniqueRestructure(exm, arguments) && method.CanRestructure)
{
return(GetValue(exm));
}
return(this);
}
bool argIsConst = true;
for (int i = 0; i < arguments.Length; i++)
{
if (arguments[i] == null)
{
continue;
}
arguments[i] = arguments[i].Restructure(exm);
argIsConst &= arguments[i] is SingleTerm;
}
if ((method.CanRestructure) && (argIsConst))
{
return(GetValue(exm));
}
return(this);
}
public override string GetStrValue(ExpressionMediator exm, IOperandTerm[] arguments)
{
string ret = arguments[0].GetStrValue(exm);
if (arguments[1] == null)
{
return(ret);
}
int totalLength = (int)arguments[1].GetIntValue(exm);
int currentLength = LangManager.GetStrlenLang(ret);
totalLength -= currentLength - ret.Length; //全角文字の数だけマイナス。タブ文字？ゼロ幅文字？知るか！
if (totalLength < ret.Length)
{
return(ret); //PadLeftは0未満を送ると例外を投げる
}
if (arguments[2] != null)
{
ret = ret.PadRight(totalLength, ' '); //LEFT
}
else
{
ret = ret.PadLeft(totalLength, ' '); //RIGHT
}
return(ret);
}
public override string GetStrValue(ExpressionMediator exm)
{
try
{
if (!allArgIsConst)
{
for (var i = 0; i < arguments.Length; i++)
{
transporter[i] = arguments[i].GetIntValue(exm);
}
}
var ret = Identifier.GetStrValue(exm, transporter);
if (ret == null)
{
return("");
}
return(ret);
}
catch (Exception e)
{
if (e is IndexOutOfRangeException || e is ArgumentOutOfRangeException || e is OverflowException)
{
Identifier.CheckElement(transporter);
}
throw;
}
}
public void SetTransporter(ExpressionMediator exm)
{
for (int i = 0; i < Arguments.Length; i++)
{
if (Arguments[i] == null)
{
continue;
}
if (isRef[i])
{
VariableTerm vTerm = (VariableTerm)Arguments[i];
if (vTerm.Identifier.IsCharacterData)
{
Int64 charaNo = vTerm.GetElementInt(0, exm);
if ((charaNo < 0) || (charaNo >= GlobalStatic.VariableData.CharacterList.Count))
{
throw new CodeEE("キャラクタ配列変数" + vTerm.Identifier.Name + "の第１引数(" + charaNo.ToString() + ")はキャラ登録番号の範囲外です");
}
TransporterRef[i] = (Array)vTerm.Identifier.GetArrayChara((int)charaNo);
}
else
{
TransporterRef[i] = (Array)vTerm.Identifier.GetArray();
}
}
else if (Arguments[i].GetOperandType() == typeof(Int64))
{
TransporterInt[i] = Arguments[i].GetIntValue(exm);
}
else
{
TransporterStr[i] = Arguments[i].GetStrValue(exm);
}
}
}
public override SingleTerm GetValue(ExpressionMediator exm)
{
if (Identifier.VariableType == typeof(long))
{
return(new SingleTerm(GetIntValue(exm)));
}
return(new SingleTerm(GetStrValue(exm)));
}
public virtual SingleTerm GetReturnValue(ExpressionMediator exm, IOperandTerm[] arguments)
{
if (ReturnType == typeof(long))
{
return(new SingleTerm(GetIntValue(exm, arguments)));
}
return(new SingleTerm(GetStrValue(exm, arguments)));
}
public long GetElementInt(int i, ExpressionMediator exm)
{
if (allArgIsConst)
{
return(transporter[i]);
}
return(arguments[i].GetIntValue(exm));
}
public override IOperandTerm Restructure(ExpressionMediator exm)
{
if (Identifier.CanRestructure)
{
return(GetValue(exm));
}
return(this);
}
public override long GetIntValue(ExpressionMediator exm)
{
var term = exm.Process.GetValue(this);
if (term == null)
{
return(0);
}
return(term.Int);
}
public override string GetStrValue(ExpressionMediator exm)
{
var term = exm.Process.GetValue(this);
if (term == null)
{
return("");
}
return(term.Str);
}
public virtual void SetValue(SingleTerm value, ExpressionMediator exm)
{
if (Identifier.VariableType == typeof(long))
{
SetValue(value.Int, exm);
}
else
{
SetValue(value.Str, exm);
}
}
public virtual void SetValue(IOperandTerm value, ExpressionMediator exm)
{
if (Identifier.VariableType == typeof(long))
{
SetValue(value.GetIntValue(exm), exm);
}
else
{
SetValue(value.GetStrValue(exm), exm);
}
}
public override IOperandTerm Restructure(ExpressionMediator exm)
{
if (dic == null)
{
dic = exm.VEvaluator.Constant.GetKeywordDictionary(out errPos, parentCode, index);
}
strTerm = strTerm.Restructure(exm);
if (!(strTerm is SingleTerm))
{
return(this);
}
return(new SingleTerm(GetIntValue(exm)));
}
public static void Reset()
{
Process = null;
ConstantData = null;
GameBaseData = null;
EMediator = null;
VEvaluator = null;
VariableData = null;
Console = null;
MainWindow = null;
LabelDictionary = null;
IdentifierDictionary = null;
tempDic.Clear();
}
public override IOperandTerm Restructure(ExpressionMediator exm)
{
StrForm.Restructure(exm);
if (StrForm.IsConst)
{
return(new SingleTerm(StrForm.GetString(exm)));
}
var term = StrForm.GetIOperandTerm();
if (term != null)
{
return(term);
}
return(this);
}
public override void SetValue(string value, ExpressionMediator exm)
{
try
{
Identifier.SetValue(value, transporter);
}
catch (Exception e)
{
if ((e is IndexOutOfRangeException) || (e is ArgumentOutOfRangeException) || (e is OverflowException))
{
Identifier.CheckElement(transporter);
}
throw;
}
}
public override Int64 PlusValue(Int64 value, ExpressionMediator exm)
{
try
{
return(Identifier.PlusValue(value, transporter));
}
catch (Exception e)
{
if ((e is IndexOutOfRangeException) || (e is ArgumentOutOfRangeException) || (e is OverflowException))
{
Identifier.CheckElement(transporter);
}
throw;
}
}
public override IOperandTerm Restructure(ExpressionMediator exm)
{
for (int i = 0; i < srcArgs.Length; i++)
{
if ((reffunc.ArgTypeList[i] & UserDifinedFunctionDataArgType.__Ref) == UserDifinedFunctionDataArgType.__Ref)
{
srcArgs[i].Restructure(exm);
}
else
{
srcArgs[i] = srcArgs[i].Restructure(exm);
}
}
return(this);
}
public string GetString(ExpressionMediator exm)
{
if (strs.Length == 1)
{
return(strs[0]);
}
StringBuilder builder = new StringBuilder(100);
for (int i = 0; i < strs.Length - 1; i++)
{
builder.Append(strs[i]);
builder.Append(terms[i].GetStrValue(exm));
}
builder.Append(strs[strs.Length - 1]);
return(builder.ToString());
}
public override SingleTerm GetValue(ExpressionMediator exm)
{
var term = exm.Process.GetValue(this);
if (term == null)
{
if (GetOperandType() == typeof(long))
{
return(new SingleTerm(0));
}
else
{
return(new SingleTerm(""));
}
}
return(term);
}
public override string GetStrValue(ExpressionMediator exm, IOperandTerm[] arguments)
{
string ret = arguments[0].GetIntValue(exm).ToString();
if (arguments[1] == null)
{
return(ret);
}
if (arguments[2] != null)
{
ret = ret.PadRight((int)arguments[1].GetIntValue(exm), ' '); //LEFT
}
else
{
ret = ret.PadLeft((int)arguments[1].GetIntValue(exm), ' '); //RIGHT
}
return(ret);
}
public override IOperandTerm Restructure(ExpressionMediator exm)
{
var canCheck = new bool[arguments.Length];
allArgIsConst = true;
for (var i = 0; i < arguments.Length; i++)
{
arguments[i] = arguments[i].Restructure(exm);
if (!(arguments[i] is SingleTerm))
{
allArgIsConst = false;
canCheck[i] = false;
}
else
{
//キャラクターデータの第1引数はこの時点でチェックしても意味がないのと
//ARG系は限界超えてても必要な数に拡張されるのでチェックしなくていい
if (i == 0 && Identifier.IsCharacterData || Identifier.Name == "ARG" || Identifier.Name == "ARGS")
{
canCheck[i] = false;
}
else
{
canCheck[i] = true;
}
//if (allArgIsConst)
//チェックのために値が必要
transporter[i] = arguments[i].GetIntValue(exm);
}
}
if (!Identifier.IsReference)
{
Identifier.CheckElement(transporter, canCheck);
}
if (Identifier.CanRestructure && allArgIsConst)
{
return(GetValue(exm));
}
if (allArgIsConst)
{
return(new FixedVariableTerm(Identifier, transporter));
}
return(this);
}
public UserDefinedFunctionArgument Restructure(ExpressionMediator exm)
{
for (var i = 0; i < Arguments.Length; i++)
{
if (Arguments[i] == null)
{
continue;
}
if (isRef[i])
{
Arguments[i].Restructure(exm);
}
else
{
Arguments[i] = Arguments[i].Restructure(exm);
}
}
return(this);
}
public void Restructure(ExpressionMediator exm)
{
if (strs.Length == 1)
{
return;
}
bool canRestructure = false;
for (int i = 0; i < terms.Length; i++)
{
terms[i] = terms[i].Restructure(exm);
if (terms[i] is SingleTerm)
{
canRestructure = true;
}
}
if (!canRestructure)
{
return;
}
List <string> strList = new List <string>();
List <IOperandTerm> termList = new List <IOperandTerm>();
strList.AddRange(strs);
termList.AddRange(terms);
for (int i = 0; i < termList.Count; i++)
{
if (termList[i] is SingleTerm)
{
string str = termList[i].GetStrValue(exm);
strList[i] = strList[i] + str + strList[i + 1];
termList.RemoveAt(i);
strList.RemoveAt(i + 1);
i--;
}
}
strs = new string[strList.Count];
terms = new IOperandTerm[termList.Count];
strList.CopyTo(strs);
termList.CopyTo(terms);
return;
}
public override string GetStrValue(ExpressionMediator exm)
{
try
{
string ret = Identifier.GetStrValue(exm, transporter);
if (ret == null)
{
return("");
}
return(ret);
}
catch (Exception e)
{
if ((e is IndexOutOfRangeException) || (e is ArgumentOutOfRangeException) || (e is OverflowException))
{
Identifier.CheckElement(transporter);
}
throw;
}
}
public virtual void SetValue(long value, ExpressionMediator exm)
{
try
{
if (!allArgIsConst)
{
for (var i = 0; i < arguments.Length; i++)
{
transporter[i] = arguments[i].GetIntValue(exm);
}
}
Identifier.SetValue(value, transporter);
}
catch (Exception e)
{
if (e is IndexOutOfRangeException || e is ArgumentOutOfRangeException || e is OverflowException)
{
Identifier.CheckElement(transporter);
}
throw;
}
}
public override Int64 GetIntValue(ExpressionMediator exm)
{
try
{
if (!allArgIsConst)
{
for (int i = 0; i < arguments.Length; i++)
{
transporter[i] = arguments[i].GetIntValue(exm);
}
}
return(Identifier.GetIntValue(exm, transporter));
}
catch (Exception e)
{
if ((e is IndexOutOfRangeException) || (e is ArgumentOutOfRangeException) || (e is OverflowException))
{
Identifier.CheckElement(transporter);
}
throw;
}
}
public virtual void SetValue(string[] array, ExpressionMediator exm)
{
try
{
if (!allArgIsConst)
{
for (var i = 0; i < arguments.Length; i++)
{
transporter[i] = arguments[i].GetIntValue(exm);
}
}
Identifier.SetValue(array, transporter);
}
catch (Exception e)
{
if (e is IndexOutOfRangeException || e is ArgumentOutOfRangeException || e is OverflowException)
{
Identifier.CheckElement(transporter);
throw new CodeEE("配列変数" + Identifier.Name + "の要素数を超えて代入しようとしました");
}
throw;
}
}
