public override bool Equals(object obj)
{
// If parameter is null return false.
if (obj == null)
{
return(false);
}
// If parameter cannot be cast to ArgsList return false.
ArgsList otherList = obj as ArgsList;
if ((System.Object)otherList == null)
{
return(false);
}
// Return true if other have the same elements in the same order.
if (otherList.Length != this.Length)
{
return(false);
}
for (int i = 0; i < this.Length; ++i)
{
if (otherList[i] != this[i])
{
return(false);
}
}
return(true);
}
public override string Execute()
{
AbstractHero hero = (AbstractHero)this.Manager.heroes[ArgsList[1]];
ArgsList.RemoveAt(1);
return(Manager.AddRecipeToHero(ArgsList, hero));
}
public void PopBack()
{
if (ArgsList.Count > 0)
{
ArgsList.RemoveAt(ArgsList.Count - 1);
}
}
private static Expression makeSimpleOperand(Token token, ArgsList argsList)
{
switch (token.Type)
{
case TokenType.DecLiteral:
return(new LiteralNode(ExpressionValue.makeValue(long.Parse(token.Value))));
case TokenType.HexLiteral:
return(new LiteralNode(ExpressionValue.makeValue(
long.Parse(token.Value.Substring(1), NumberStyles.HexNumber))));
case TokenType.CharLiteral:
return(new LiteralNode(ExpressionValue.makeValue(
token.Value.Substring(1, token.Value.Length - 2)[0])));
case TokenType.StringLiteral:
return(new LiteralNode(ExpressionValue.makeValue(
token.Value.Substring(1, token.Value.Length - 2))));
case TokenType.SpecialRegister:
return(new LiteralNode(ExpressionValue.makeSpecialRegister(token.Value)));
case TokenType.LocationPtr:
if (!argsList.Contains(token.Value))
{
argsList.Add(token.Value);
}
return(new ArgumentRefNode(ExpressionValue.makeVaribleRef(token.Value)));
case TokenType.LocalBackRef: {
var refName = "@" + token.Value + "_" + (++_uniqSeed);
if (!argsList.Contains(token.Value))
{
argsList.Add(refName);
}
return(new ArgumentRefNode(ExpressionValue.makeVaribleRef(refName)));
}
case TokenType.LocalForwRef: {
var refName = "@" + token.Value + "_" + (++_uniqSeed);
if (!argsList.Contains(token.Value))
{
argsList.Add(refName);
}
return(new ArgumentRefNode(ExpressionValue.makeVaribleRef(refName)));
}
case TokenType.LabelRef:
if (!argsList.Contains(token.Value))
{
argsList.Add(token.Value);
}
return(new ArgumentRefNode(ExpressionValue.makeVaribleRef(token.Value)));
default:
throw new Exception("Can't make operand from token " + token);
}
}
public static Expression buildExpression(string arg)
{
var argsList = new ArgsList();
var expr =
buildExpression0(new Tokenizer(arg), false,
new LinkedList <Expression>(), new LinkedList <Token>(),
argsList, 0);
return(new CommonExpression(argsList, expr));
}
public OutputParser(string[] args) : base(args)
{
Password = ArgsList.ContainsKey(ArgsType.PASSWORD) ? ArgsList[ArgsType.PASSWORD].Parameter : "";
Message = ArgsList.ContainsKey(ArgsType.INPUTCONSOLE) ? ArgsList[ArgsType.INPUTCONSOLE].Parameter : "";
Filein = ArgsList.ContainsKey(ArgsType.INPUTFILE) ? ArgsList[ArgsType.INPUTFILE].Parameter : "";
Fileout = ArgsList.ContainsKey(ArgsType.OUTPUTFILE) ? ArgsList[ArgsType.OUTPUTFILE].Parameter : "";
Mode = ArgsList.ContainsKey(ArgsType.DECRYPT) ?
ArgsList[ArgsType.DECRYPT].Arg == ArgsType.DECRYPT ?
ArgsType.DECRYPT : ArgsType.ENCRYPT : ArgsType.ENCRYPT;
}
private static Expression buildExpression0(Tokenizer tokenizer,
bool prevTokenIsOperand, LinkedList <Expression> operandDeque,
LinkedList <Token> operatorDeque,
ArgsList argsList, int nestingLevel)
{
var token = tokenizer.getNextToken();
if (!tokenIsTerminator(token, nestingLevel))
{
bool tokenIsOperand;
if (tokenIsOperator(token))
{
tokenIsOperand = false;
if (prevTokenIsOperand)
{
operatorDeque.AddLast(token);
}
else
{
operandDeque.AddLast(new FakeLeftOperandForUnaryOp());
operatorDeque.AddLast(makeTokenForUnaryOperator(token));
}
}
else
{
tokenIsOperand = true;
var operand =
token.Type != TokenType.BraceOpen
? makeSimpleOperand(token, argsList)
: buildExpression0(tokenizer, false,
new LinkedList <Expression>(), new LinkedList <Token>(),
argsList, nestingLevel + 1);
operandDeque.AddLast(operand);
reduce(operandDeque, operatorDeque);
}
return(buildExpression0(tokenizer, tokenIsOperand,
operandDeque, operatorDeque, argsList, nestingLevel));
}
else
{
while (operatorDeque.Last != null &&
operatorDeque.Last.Previous != null)
{
reduce(operandDeque, operatorDeque);
}
if (operatorDeque.Last != null)
{
reduceRight(operandDeque, operatorDeque);
}
return(operandDeque.First.Value);
}
}
public Object OutputClass()
{
if (ArgsConflict == null & ArgsOoR == null & ToManyArgs == null & ArgsUnknown == null)
{
if (ArgsList.ContainsKey(ArgsType.HELP))
{
return(new HelpInfo());
}
else if (ArgsList.ContainsKey(ArgsType.INPUTCONSOLE) & ArgsList.ContainsKey(ArgsType.OUTPUTCONSOLE))
{
return(new ConsoleInOut(Message, Password, Mode));
}
else if (ArgsList.ContainsKey(ArgsType.INPUTCONSOLE) & ArgsList.ContainsKey(ArgsType.OUTPUTFILE))
{
return(new ConsoleInFileOut(Message, Fileout, Password, Mode));
}
else if (ArgsList.ContainsKey(ArgsType.INPUTFILE) & ArgsList.ContainsKey(ArgsType.OUTPUTCONSOLE))
{
return(new FileInConsoleOut(Filein, Password, Mode));
}
else if (ArgsList.ContainsKey(ArgsType.INPUTFILE) & ArgsList.ContainsKey(ArgsType.OUTPUTFILE))
{
return(new FileInOut(Filein, Fileout, Password, Mode));
}
}
else if (ArgsConflict != null)
{
return(ArgsConflict);
}
else if (ArgsOoR != null)
{
return(ArgsOoR);
}
else if (ToManyArgs != null)
{
return(ToManyArgs);
}
return(ArgsUnknown);
}
public ErrorParser(string[] args) : base(args)
{
if (ArgsList.ContainsKey(ArgsType.HELP) ^
!((ArgsList.ContainsKey(ArgsType.INPUTFILE) ^ ArgsList.ContainsKey(ArgsType.INPUTCONSOLE)) &
(ArgsList.ContainsKey(ArgsType.ENCRYPT) ^ ArgsList.ContainsKey(ArgsType.DECRYPT))))
{
ArgsConflict = new Exception("Противоречие или отсутствие аргументов");
}
if (Outofrange)
{
ArgsOoR = new Exception("Отсутсвие параметров для аргумента или их неявное задание");
}
if (UnunknownArg)
{
ArgsUnknown = new Exception("Присутсвует неизвестный аргумент");
}
foreach (ArgsType x in ArgsList.Keys)
{
if (ArgsList[x].Count > 1)
{
ToManyArgs = new Exception("Нерациональное количество одинаковых аргументов");
}
}
}
public void PushBack(Value val)
{
ArgsList.Add(val);
}
public void PushFront(Value val)
{
ArgsList.Insert(0, val);
}
static void List(ArgsList cmd)
{
string hubCmdString = string.Format(_cmdFormat, "List", Guid.Empty, 0);
EvalCommand(cmd.pHub, cmd.evalServiceGuid, hubCmdString);
}
//Запись в строку
public override string ToTestString()
{
return(ToTestWithChildren(ArgsList.ToArray()));
}
internal CommonExpression(ArgsList dependencyList,
Expression nestedExpression)
{
this._argsList = dependencyList;
this._expression = nestedExpression;
}
