/// <summary>
/// 代入行
/// </summary>
/// <param defaultName="primitives"></param>
/// <returns></returns>
private static Assignment readAssignment(TokenCollection stream)
{
//変数を読む。失敗したら代入行じゃない。
VariableToken token = CodeTokenFactory.ReadVariable(stream);
//演算子を読む。失敗するなら代入行じゃない。
if (stream.NextIsEndOfLine)
{
throw new HspLogicalLineException("代入行：演算子なし");
}
OperatorToken op = CodeTokenFactory.ReadOperator(stream);
//式が続かないこともある。"x++"とか
if (stream.NextIsEndOfLine)
{
return(new Assignment(token, op));
}
else
{
//引数を読む。あまりが出なければOK
ArgumentToken arg = CodeTokenFactory.ReadArgument(stream);
if (stream.NextIsEndOfLine)
{
return(new Assignment(token, op, arg));
}
}
throw new HspLogicalLineException("代入行：余分なトークンがある");
}
private bool TryExpandVariable(VariableToken token, Dictionary <string, Token> collection, out Token expandedVariable)
{
expandedVariable = null;
var varName = token.Value;
string newName;
if (collection.TryGetValue(varName, out expandedVariable))
{
return(true);
}
if (currentMachine != null)
{
newName = String.Format("{0}.{1}", Emulation[currentMachine].Replace("-", "_"), varName);
if (collection.TryGetValue(newName, out expandedVariable))
{
return(true);
}
}
newName = String.Format("{0}{1}", globalVariablePrefix, varName);
if (collection.TryGetValue(newName, out expandedVariable))
{
return(true);
}
return(false);
}
public void Visit(VariableToken variableToken)
{
mCurrent = new Variable {
Name = variableToken.Variable
};
HandleNonParenthesesAndOperation();
}
static FunctionMethodTerm CallnameTarget = null; // "$$$"
public static void Initialize()
{
formatCurlyBrace = new FormatCurlyBrace();
formatPercent = new FormatPercent();
formatYenAt = new FormatYenAt();
VariableToken nameID = GlobalStatic.VariableData.GetSystemVariableToken("NAME");
VariableToken callnameID = GlobalStatic.VariableData.GetSystemVariableToken("CALLNAME");
IOperandTerm[] zeroArg = new IOperandTerm[] { new SingleTerm(0) };
VariableTerm target = new VariableTerm(GlobalStatic.VariableData.GetSystemVariableToken("TARGET"), zeroArg);
VariableTerm master = new VariableTerm(GlobalStatic.VariableData.GetSystemVariableToken("MASTER"), zeroArg);
VariableTerm player = new VariableTerm(GlobalStatic.VariableData.GetSystemVariableToken("PLAYER"), zeroArg);
VariableTerm assi = new VariableTerm(GlobalStatic.VariableData.GetSystemVariableToken("ASSI"), zeroArg);
VariableTerm nametarget = new VariableTerm(nameID, new IOperandTerm[] { target });
VariableTerm callnamemaster = new VariableTerm(callnameID, new IOperandTerm[] { master });
VariableTerm callnameplayer = new VariableTerm(callnameID, new IOperandTerm[] { player });
VariableTerm nameassi = new VariableTerm(nameID, new IOperandTerm[] { assi });
VariableTerm callnametarget = new VariableTerm(callnameID, new IOperandTerm[] { target });
NameTarget = new FunctionMethodTerm(formatPercent, new IOperandTerm[] { nametarget, null, null });
CallnameMaster = new FunctionMethodTerm(formatPercent, new IOperandTerm[] { callnamemaster, null, null });
CallnamePlayer = new FunctionMethodTerm(formatPercent, new IOperandTerm[] { callnameplayer, null, null });
NameAssi = new FunctionMethodTerm(formatPercent, new IOperandTerm[] { nameassi, null, null });
CallnameTarget = new FunctionMethodTerm(formatPercent, new IOperandTerm[] { callnametarget, null, null });
}
public FixedVariableTerm(VariableToken token)
: base(token)
{
Identifier = token;
transporter = new long[3];
allArgIsConst = true;
}
public void EqualsSameObjectTest()
{
var token = new VariableToken("x");
Assert.True(token.Equals(token));
Assert.Equal(token, token);
}
public void EqualsNullTest()
{
var token = new VariableToken("x");
Assert.False(token.Equals(null));
Assert.NotNull(token);
}
public void EqualsDiffTypeTest()
{
var token = new VariableToken("x");
Assert.False(token.Equals(1));
Assert.NotEqual((object)1, token);
}
public SpSplitArgument(IOperandTerm s1, IOperandTerm s2, VariableToken varId, VariableTerm num)
{
TargetStr = s1;
Split = s2;
Var = varId;
Num = num;
}
private OperationResult ParseVariable()
{
if (Const.Digits.Contains(LastCharacter) || Regex.IsMatch(LastCharacter.ToString(), "[a-z]") || LastCharacter == Const.RightParenthesis)
{
_operationStack.Push(new BinaryOperationToken {
Value = "*"
});
if (_parenthesesStack.Count >= 1)
{
_parenthesesStack.Push('*');
}
}
LastCharacter = Input[Pointer];
var token = new VariableToken(1, new List <Variable> {
new Variable {
Letter = Input[Pointer], Exponent = 1
}
});
if (NegateFlag && _parenthesesStack.Count == 0)
{
token.Negate();
NegateFlag = false;
}
_expressionStack.Push(token);
return(ParseAndSimplify());
}
public void VariableToken_HasProperValues()
{
VariableToken vt = new VariableToken("IntVariable", 12);
Assert.IsInstanceOf(Type.GetType("System.Int32"), vt.Value);
Assert.AreEqual(12, vt.Value);
Assert.AreEqual("IntVariable", vt.VariableName);
}
internal void AddUseDefinedVariable(VariableToken var)
{
varTokenDic.Add(var.Name, var);
if (var.IsCharacterData)
{
}
nameDic.Add(var.Name, DefinedNameType.UserGlobalVariable);
}
public void EqualsDiffVarTest()
{
var token1 = new VariableToken("x");
var token2 = new VariableToken("y");
Assert.False(token1.Equals(token2));
Assert.NotEqual(token1, token2);
}
public override SemanticPayload Visit(VariableToken token, SemanticPayload payload)
{
if (!payload.Contour.Lookup(token.Item1, out _))
{
payload.Error = payload.Error.Combine(new Error($"Parameter {token.Item1} is unbound"));
}
return(payload);
}
public static void TestGetNextTokenOnVariable()
{
const string input = "$a=42";
var token = Lexer.GetNextToken(input, 0);
var correctToken = new VariableToken("a");
Assert.Equal(correctToken, token);
}
public static void TestParseTokenOnVariable()
{
const string tokenString = "$test";
var token = Lexer.ParseToken(tokenString);
Token correctToken = new VariableToken("test");
Assert.Equal(correctToken, token);
}
//private void analyzeSharpDim(StringStream st, ScriptPosition position, bool dims)
//{
// //WordCollection wc = LexicalAnalyzer.Analyse(st, LexEndWith.EoL, LexAnalyzeFlag.AllowAssignment);
// //UserDefinedVariableData data = UserDefinedVariableData.Create(wc, dims, false, position);
// //if (data.Reference)
// // throw new NotImplCodeEE();
// //VariableToken var = null;
// //if (data.CharaData)
// // var = parentProcess.VEvaluator.VariableData.CreateUserDefCharaVariable(data);
// //else
// // var = parentProcess.VEvaluator.VariableData.CreateUserDefVariable(data);
// //idDic.AddUseDefinedVariable(var);
//}
//1822 #DIMだけまとめておいて後で処理
private bool analyzeSharpDimLines()
{
bool noError = true;
bool tryAgain = true;
while (dimlines.Count > 0)
{
int count = dimlines.Count;
for (int i = 0; i < count; i++)
{
DimLineWC dimline = dimlines.Dequeue();
try
{
UserDefinedVariableData data = UserDefinedVariableData.Create(dimline);
if (data.Reference)
{
throw new NotImplCodeEE();
}
VariableToken var = null;
if (data.CharaData)
{
var = parentProcess.VEvaluator.VariableData.CreateUserDefCharaVariable(data);
}
else
{
var = parentProcess.VEvaluator.VariableData.CreateUserDefVariable(data);
}
idDic.AddUseDefinedVariable(var);
}
catch (IdentifierNotFoundCodeEE e)
{
//繰り返すことで解決する見込みがあるならキューの最後に追加
if (tryAgain)
{
dimline.WC.Pointer = 0;
dimlines.Enqueue(dimline);
}
else
{
ParserMediator.Warn(e.Message, dimline.SC, 2);
noError = true;
}
}
catch (CodeEE e)
{
ParserMediator.Warn(e.Message, dimline.SC, 2);
noError = false;
}
}
if (dimlines.Count == count)
{
tryAgain = false;
}
}
return(noError);
}
private Token ExpandVariable(VariableToken token, Dictionary <string, Token> collection)
{
Token result;
if (!TryExpandVariable(token, collection, out result))
{
throw new RecoverableException(string.Format("No such variable: ${0}", token.Value));
}
return(result);
}
public FixedVariableTerm(VariableToken token, Int64[] args)
: base(token)
{
allArgIsConst = true;
this.Identifier = token;
transporter = new Int64[3];
for (int i = 0; i < args.Length; i++)
{
transporter[i] = args[i];
}
}
public FixedVariableTerm(VariableToken token, long[] args)
: base(token)
{
allArgIsConst = true;
Identifier = token;
transporter = new long[3];
for (var i = 0; i < args.Length; i++)
{
transporter[i] = args[i];
}
}
public static bool IsVariable(string ids)
{
if (string.IsNullOrEmpty(ids))
{
return(false);
}
string[] idlist = ids.Split(':');
//idlist = synonym.ApplySynonym(idlist);
VariableToken id = GlobalStatic.IdentifierDictionary.GetVariableToken(idlist[0], null, false);
return(id != null);
}
public void Visit(VariableToken variableToken)
{
_environment.Define(variableToken.Name);
if (_inLambda)
{
if (_environment.Depth(variableToken.Name) != 0)
{
if (_table.Defined(variableToken.Name, out var symbol) && symbol is VariableLeaf leaf)
{
leaf.IsCaptured = true;
}
}
}
}
/// <summary>
/// 戻り値と引数の数・型の完全一致が必要
/// </summary>
/// <param name="call"></param>
/// <returns>一致ならtrue</returns>
internal bool MatchType(CalledFunction call)
{
FunctionLabelLine label = call.TopLabel;
if (label.IsError)
{
return(false);
}
if (RetType != label.MethodType)
{
return(false);
}
if (ArgTypeList.Length != label.Arg.Length)
{
return(false);
}
for (int i = 0; i < ArgTypeList.Length; i++)
{
VariableToken vToken = label.Arg[i].Identifier;
if (vToken.IsReference)
{
UserDifinedFunctionDataArgType type = UserDifinedFunctionDataArgType.__Ref;
type += vToken.Dimension;
if (vToken.IsInteger)
{
type |= UserDifinedFunctionDataArgType.Int;
}
else
{
type |= UserDifinedFunctionDataArgType.Str;
}
if (ArgTypeList[i] != type)
{
return(false);
}
}
else
{
if (vToken.IsInteger && ArgTypeList[i] != UserDifinedFunctionDataArgType.Int)
{
return(false);
}
if (vToken.IsString && ArgTypeList[i] != UserDifinedFunctionDataArgType.Str)
{
return(false);
}
}
}
return(true);
}
public string Tokenize(string expression, int start)
{
int next;
VariableToken token = new VariableToken();
if (token.Match(expression, start, out next))
{
return(token.Name);
}
else
{
return(null);
}
}
public bool getVarTokenIsForbid(string key)
{
if (localvarTokenDic.ContainsKey(key))
{
return(localvarTokenDic[key].IsForbid);
}
VariableToken var = null;
varTokenDic.TryGetValue(key, out var);
if (var != null)
{
return(var.IsForbid);
}
return(true);
}
protected T Visit(IToken token, T state = default)
{
return(token switch
{
AddToken addToken => Visit(addToken, state),
SubtractToken subtractToken => Visit(subtractToken, state),
MultiplyToken multiplyToken => Visit(multiplyToken, state),
DivideToken divideToken => Visit(divideToken, state),
NegateToken negateToken => Visit(negateToken, state),
NumberToken numberToken => Visit(numberToken, state),
FactorialToken factorialToken => Visit(factorialToken, state),
PowerToken powerToken => Visit(powerToken, state),
VariableToken variableToken => Visit(variableToken, state),
AssignmentToken assignmentToken => Visit(assignmentToken, state),
_ => throw new ArgumentOutOfRangeException(nameof(token))
});
public bool getVarTokenIsForbid(string key)
{
VariableLocal vlocal = null;
if (localvarTokenDic.TryGetValue(key, out vlocal))
{
return(vlocal.IsForbid);
}
VariableToken var = null;
varTokenDic.TryGetValue(key, out var);
if (var != null)
{
return(var.IsForbid);
}
return(true);
}
public VariableTerm(VariableToken token, IOperandTerm[] args)
: base(token.VariableType)
{
Identifier = token;
arguments = args;
transporter = new long[arguments.Length];
allArgIsConst = false;
for (var i = 0; i < arguments.Length; i++)
{
if (!(arguments[i] is SingleTerm))
{
return;
}
transporter[i] = ((SingleTerm)arguments[i]).Int;
}
allArgIsConst = true;
}
public void DivideVariableTokenBy1_ReturnsSameVariableToken()
{
var q = 2;
var v = new List <Variable> {
new Variable('x', 1)
};
var a = new VariableToken(q, v);
var b = new ConstantToken(1);
var op = new BinaryOperationToken {
Value = "/"
};
var res = Simplifier.DoOperation(op, a, b);
Assert.IsTrue(res.Success);
Assert.IsTrue(res.Result is VariableToken);
Assert.IsTrue(((VariableToken)res.Result).Quotient == q);
Assert.IsTrue(((VariableToken)res.Result).Variables.Except(v).Count() == 0);
}
private void analyzeSharpDim(StringStream st, ScriptPosition position, bool dims)
{
var wc = LexicalAnalyzer.Analyse(st, LexEndWith.EoL, LexAnalyzeFlag.AllowAssignment);
var data = UserDefinedVariableData.Create(wc, dims, false, position);
if (data.Reference)
{
throw new NotImplCodeEE();
}
VariableToken var = null;
if (data.CharaData)
{
var = parentProcess.VEvaluator.VariableData.CreateUserDefCharaVariable(data);
}
else
{
var = parentProcess.VEvaluator.VariableData.CreateUserDefVariable(data);
}
idDic.AddUseDefinedVariable(var);
}
public void Run(ICommandInteraction writer, VariableToken variable)
{
ProcessVariable(writer, variable.Value);
}
public void Run(ICommandInteraction writer, VariableToken variable, MultilineStringTerminatorToken dummy)
{
ProcessVariable(writer, variable.Value, true);
}
public void Run(ICommandInteraction writer, VariableToken variable, Token value)
{
Run(writer, new LiteralToken(variable.Value), value);
}
static bool ParseSymbol(VariableToken t, IReadOnlyDictionary<string, bool> symbols)
{
bool value;
symbols.TryGetValue(t.Symbol, out value);
return value;
}
public void Run(ICommandInteraction writer, VariableToken variable)
{
var value = GetVariable(variable);
Run(writer, (StringToken)value);
}
