public Unary(LIRMethod parent, ISource src, IDestination dest, UnaryOperation op, LIRType argType) : base(parent, LIROpCode.Unary)
{
Source = src;
Destination = dest;
Operation = op;
ArgumentType = argType;
}
public static string GetUnaryOperator(UnaryOperation unaryOperation)
{
if (!UnaryOperators.Keys.Contains(unaryOperation))
{
throw new InvalidOperationException("Required operation was not recognized.");
}
return UnaryOperators[unaryOperation];
}
/// <summary>
/// Used to create: {UnaryOperation}{Value}
/// </summary>
public Expression(UnaryOperation unaryOperation, IValueType value)
{
StringBuilder sb = new StringBuilder(512);
this.UnaryOperator = Operation.GetUnaryOperator(unaryOperation);
sb.Append(this.UnaryOperator);
sb.Append(value.ToString());
this.Value = sb.ToString();
}
private static string GetOperationSymbol(UnaryOperation op)
{
switch (op)
{
case UnaryOperation.Negate:
return "-";
case UnaryOperation.Not:
return "!";
default:
throw new NotSupportedException();
}
}
public override IList<AddressIndependentThing> Encode(UnaryOperation<Amd64Operation> op)
{
var ret = new List<AddressIndependentThing>();
// any rex op
ret.AddRange(OpCode.Convert());
switch (Operand.Type)
{
case OperandType.Immediate:
ret.AddRange(EncodeImmediate(op.Target));
break;
default:
throw new Exception("bad things");
}
return ret;
}
public UnaryExpression(UnaryOperation operation, Expression arg)
{
Operation = operation;
Argument = arg ?? throw new ArgumentNullException(nameof(arg));
}
public UnaryOperationExpression(UnaryOperation op, Expression exp)
{
mOp = op;
mExpr = exp;
}
private static bool IsUnaryOperator(TokenType type, out UnaryOperation operation)
{
return(UnaryOperations.Forward.TryGetValue(type, out operation));
}
/// <summary>
/// Initializes a new instance of the <see cref="T:Lore.UnaryExpression"/> class.
/// </summary>
/// <param name="location">Location.</param>
/// <param name="op">Op.</param>
/// <param name="child">Child.</param>
UnaryExpression(SourceLocation location, UnaryOperation op, AstNode child) : base(location)
{
Operation = op;
Child = child;
}
double[] CalculateMultipleWithBuffer(MemoryStream codeStream, IReadOnlyTable <double> table, double[][] parameters)
{
int iterations = parameters.GetLength(0);
Stack <double[]> resultStack = new Stack <double[]>();
byte[] buffer = new byte[sizeof(double)];
// a small memory & time optimization: it allows multiple usage of number buffers after performing calculations on them
Queue <double[]> freeValueBuffers = new Queue <double[]>();
while (true)
{
int command = codeStream.ReadByte();
if (command == -1)
{
throw new Exception("Can't execute next command");
}
double[] values = (freeValueBuffers.Count > 0) ? freeValueBuffers.Dequeue() : new double[iterations];
if ((PostfixFunction.PostfixCommand)command == PostfixFunction.PostfixCommand.End)
{
return(resultStack.Pop());
}
switch ((PostfixFunction.PostfixCommand)command)
{
case PostfixFunction.PostfixCommand.PushLiteral:
{
codeStream.Read(buffer, 0, sizeof(double));
double literal = BitConverter.ToDouble(buffer, 0);
for (int i = 0; i < iterations; ++i)
{
values[i] = literal;
}
}
break;
case PostfixFunction.PostfixCommand.PushVariable:
{
codeStream.Read(buffer, 0, sizeof(int));
int index = BitConverter.ToInt32(buffer, 0);
for (int i = 0; i < iterations; ++i)
{
values[i] = table[index];
}
}
break;
case PostfixFunction.PostfixCommand.PushParameter:
{
codeStream.Read(buffer, 0, sizeof(int));
int index = BitConverter.ToInt32(buffer, 0);
for (int i = 0; i < iterations; ++i)
{
values[i] = parameters[i][index];
}
}
break;
case PostfixFunction.PostfixCommand.CalculateUnary:
{
double[] operands = resultStack.Pop();
codeStream.Read(buffer, 0, sizeof(int));
int id = BitConverter.ToInt32(buffer, 0);
UnaryOperation operation = (UnaryOperation)Operation.AllOperations[id];
for (int i = 0; i < values.Length; ++i)
{
values[i] = operation.Function(operands[i]);
}
// add free buffer to the queue
freeValueBuffers.Enqueue(operands);
}
break;
case PostfixFunction.PostfixCommand.CalculateBinary:
{
// pop in reverse order!
double[] rightOperands = resultStack.Pop();
double[] leftOperands = resultStack.Pop();
codeStream.Read(buffer, 0, sizeof(int));
int id = BitConverter.ToInt32(buffer, 0);
BinaryOperation operation = (BinaryOperation)Operation.AllOperations[id];
for (int i = 0; i < values.Length; ++i)
{
values[i] = operation.Function(leftOperands[i], rightOperands[i]);
}
// add free buffers to the queue
freeValueBuffers.Enqueue(rightOperands);
freeValueBuffers.Enqueue(leftOperands);
}
break;
}
resultStack.Push(values);
}
}
public UnaryExpression(Expression Source, UnaryOperation Operation)
{
this.Source = Source;
this.Operation = Operation;
}
public static double InvokeUnary(UnaryOperation unaryOperation, double num)
{
return(Round(unaryOperation.Invoke(num), DigitsLimit));
}
public override AstNode Visit(UnaryOperation node)
{
// Visit recursively.
node.GetExpression().Accept(this);
return(node);
}
public UnaryExpression(UnaryOperation op, Expression sub)
{
Op = op;
Sub = sub;
}
public void TestValidationCoolectioninCollectionModerator()
{
var model = new UnaryOperation()
{
Operand = new PropertyCollectionOperation
{
Collection = new[]
{
new PropertyCollectionOperation
{
Collection = new[]
{
new ContextProperty {
DynamicValue = (ctx) => ctx.Card(1, x => x.Voltage.Current)
},
new ContextProperty {
DynamicValue = (ctx) => ctx.Card(2, x => x.Voltage.Current)
},
new ContextProperty {
DynamicValue = (ctx) => ctx.Card(3, x => x.Voltage.Current)
},
new ContextProperty {
DynamicValue = (ctx) => ctx.Card(4, x => x.Voltage.Current)
},
new ContextProperty {
DynamicValue = (ctx) => ctx.Card(5, x => x.Voltage.Current)
},
},
Operator = CollectionOperator.AllEqual,
Property = new BaseProperty
{
Value = 1111
}
},
new PropertyCollectionOperation
{
Collection = new[]
{
new ContextProperty {
DynamicValue = (ctx) => ctx.Card(1, x => x.TempLimit.Current)
},
new ContextProperty {
DynamicValue = (ctx) => ctx.Card(2, x => x.TempLimit.Current)
},
new ContextProperty {
DynamicValue = (ctx) => ctx.Card(3, x => x.TempLimit.Current)
},
new ContextProperty {
DynamicValue = (ctx) => ctx.Card(4, x => x.TempLimit.Current)
},
new ContextProperty {
DynamicValue = (ctx) => ctx.Card(5, x => x.TempLimit.Current)
},
},
Operator = CollectionOperator.Contains,
Property = new BaseProperty
{
Value = 50
}
}
},
Operator = CollectionOperator.AllEqual,
Property = new BaseProperty
{
Value = true
}
}
};
var moderator = new FarmVisitor();
var result = moderator.Validate(model, FakeState());
Assert.AreEqual(result.IsValid, true);
}
// 遍历词法分析器序列，对于不同类型的关键字，跳转到特殊函数执行
public void BParser()
{
try
{
// 当词法分析器序列tt没有读尽，就继续处理
while (tt[tt_i] != null)
{
// 读取到auto关键字,跳转到auto函数处理
if (tt[tt_i].Type.Equals("auto"))
{
Auto.M_Auto(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3);
} // 读取到putnumb关键字,跳转到putnumb函数,输出数值型变量值
else if (tt[tt_i].Type.Equals("putnumb"))
{
Putnumb.Put_numb(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3);
} // 读取到putchar关键字,跳转到putchar函数,输出字符型型变量值
else if (tt[tt_i].Type.Equals("putchar"))
{
Putchar.Put_char(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3);
} // 单目运算，自增自减
else if (tt[tt_i].Code.Equals("++") || tt[tt_i].Code.Equals("--"))
{
UnaryOperation.Unary_Operation(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3);
} // 读取到类型为operator,即操作符类型，跳转到operator函数
else if (tt[tt_i].Type.Equals("operator"))
{
BOperator.Operator(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3);
} // 读取到关键字getchar,跳转到getchar函数进行读入字符串操作
else if (tt[tt_i].Type.Equals("getchar"))
{
Getchar.Get_char(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3);
} // 读取到关键字getnumb,跳转到getnumb函数执行读入数值操作
else if (tt[tt_i].Type.Equals("getnumb"))
{
Getnumb.Get_numb(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3);
} // 读取到关键字goto,跳转到Bgoto函数处理goto语句
else if (tt[tt_i].Type.Equals("goto"))
{
Bgoto.B_goto(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3, ref markmap);
} // 读取到if关键字,跳转到Bif函数处理if语句
else if (tt[tt_i].Type.Equals("if"))
{
Bif.B_if(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3, ref markmap, ref while_or);
} // 读取到while关键字, 跳转到BWhile函数处理while循环语句
else if (tt[tt_i].Type.Equals("while"))
{
BWhile.B_While(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3, ref markmap, ref while_or);
} // 读取到do关键字,跳转到BDo_while函数执行do while函数执行
else if (tt[tt_i].Type.Equals("do"))
{
BDoWhile.B_Dowhile(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3, ref markmap, ref while_or);
} // 读取到for关键字，执行for循环
else if (tt[tt_i].Type.Equals("for"))
{
Bfor.B_for(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3);
} // 读取到note关键字, 跳转到Note函数处理注释
else if (tt[tt_i].Type.Equals("note"))
{
Note.M_Note(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3);
} // 读取到putstr函数，输出数组
else if (tt[tt_i].Type.Equals("putstr"))
{
Putstr.Put_str(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3);
} // 读取到switch
else if (tt[tt_i].Type.Equals("switch"))
{
Bswitch.B_switch(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3, ref markmap, ref while_or);
} // 都不满足就将tt_i下标加1,不作处理
else
{
tt_i++;
}
}
}
catch (NotDefineVarException e)
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
}
catch (NotAVarException e)
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
}
catch (WrongGrammarException e)
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
}
catch (NotFoundMarkException e)
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
}
}
public virtual IodineObject PerformUnaryOperation(VirtualMachine vm, UnaryOperation op)
{
string methodName = null;
switch (op) {
case UnaryOperation.Negate:
methodName = "__negate__";
break;
case UnaryOperation.Not:
methodName = "__not__";
break;
case UnaryOperation.BoolNot:
methodName = "__logicalNot__";
break;
}
if (HasAttribute (methodName)) {
return GetAttribute (vm, methodName).Invoke (vm, new IodineObject[] { });
}
vm.RaiseException (new IodineNotSupportedException (
"The requested unary operator has not been implemented"));
return null;
}
public UnaryExpressionOperator(string symbol, ExpressionResultType result, bool canOverflow, bool signed, UnaryOperation type, UnaryOperatorDelegate code)
{
this.Symbol = symbol;
this.ResultType = result;
this.CanOverflow = canOverflow;
this.Signed = signed;
this.OperationType = type;
this.Operation = code;
}
private static string ToPTX(this BasicBlockInstruction bbi)
{
BinaryOperation bop = bbi as BinaryOperation;
UnaryOperation uop = bbi as UnaryOperation;
switch (bbi.OpCode)
{
case IROpCodes.ADD:
case IROpCodes.SUB:
case IROpCodes.REM:
case IROpCodes.MIN:
case IROpCodes.MAX:
return(bop.OpCode.ToString().ToLower() + "." + bop.Target.DataType.ToPTX() +
" " + bop.Target + ", " + bop.LeftOperand + ", " + bop.RightOperand);
case IROpCodes.MUL:
return("mul." + (Util.IntegralTypes.Contains(bop.Target.DataType) ? "lo." : "") + bop.Target.DataType.ToPTX() +
" " + bop.Target + ", " + bop.LeftOperand + ", " + bop.RightOperand);
case IROpCodes.MAD:
MADOperation mad = bbi as MADOperation;
return("mad." + (Util.IntegralTypes.Contains(mad.Target.DataType) ? "lo." : "") + mad.Target.DataType.ToPTX() +
" " + mad.Target + ", " + mad.MulLeftOperand + ", " + mad.MulRightOperand + ", " + mad.AddOperand);
case IROpCodes.DIV:
return("div." + (Util.IntegralTypes.Contains(bop.Target.DataType) ? bop.Target.DataType.ToPTX() :
(bop.Target.DataType == typeof(float)) ? "approx.f32" : "rz.f64") +
" " + bop.Target + ", " + bop.LeftOperand + ", " + bop.RightOperand);
case IROpCodes.AND:
case IROpCodes.OR:
case IROpCodes.XOR:
return(bop.OpCode.ToString().ToLower() + ".b" + bop.Target.DataType.SizeOf() * 8 +
" " + bop.Target + ", " + bop.LeftOperand + ", " + bop.RightOperand);
case IROpCodes.EQ:
case IROpCodes.NE:
case IROpCodes.GE:
case IROpCodes.GT:
case IROpCodes.LE:
case IROpCodes.LT:
return("set." + bop.OpCode.ToString().ToLower() +
"." + bop.Target.DataType.ToPTX() + "." + bop.LeftOperand.DataType.ToPTX() +
" " + bop.Target + ", " + bop.LeftOperand + ", " + bop.RightOperand);
case IROpCodes.ABS:
case IROpCodes.NEG:
case IROpCodes.MOV:
return(uop.OpCode.ToString().ToLower() + "." + uop.Target.DataType.ToPTX() +
" " + uop.Target + ", " + uop.Operand);
case IROpCodes.NOT:
return("not.b" + uop.Target.DataType.SizeOf() * 8 +
" " + uop.Target + ", " + uop.Operand);
case IROpCodes.CVT:
{
string targetModif = uop.Target.DataType.ToPTX();
string operandModif = uop.Operand.DataType.ToPTX();
string roundModif = (uop.Target.DataType == typeof(float)) && (uop.Operand.DataType == typeof(double)) ? ".rz" :
Util.RealTypes.Contains(uop.Target.DataType) && Util.IntegralTypes.Contains(uop.Operand.DataType) ? ".rz" :
Util.IntegralTypes.Contains(uop.Target.DataType) && Util.RealTypes.Contains(uop.Operand.DataType) ? ".rzi" :
"";
return(((targetModif != operandModif) ? "cvt" + roundModif + "." + targetModif : "mov") + "." + operandModif +
" " + uop.Target + ", " + uop.Operand);
}
case IROpCodes.LD:
{
LDInstruction op = bbi as LDInstruction;
return("ld." + op.Address.StateSpace.ToString().ToLower() + "." + op.Address.UnderlyingType.ToPTX() +
" " + op.Target + ", [" + op.Address + "]");
}
case IROpCodes.ST:
{
STInstruction op = bbi as STInstruction;
return("st." + op.Address.StateSpace.ToString().ToLower() + "." + op.Address.UnderlyingType.ToPTX() +
" " + "[" + op.Address + "], " + op.Source);
}
case IROpCodes.SYNC:
return("bar.sync 0");
case IROpCodes.SQRT:
return("sqrt" + ((uop.Target.DataType == typeof(float)) ? ".approx.f32" : ".rz.f64") +
" " + uop.Target + ", " + uop.Operand);
case IROpCodes.RSQRT:
case IROpCodes.SIN:
case IROpCodes.COS:
case IROpCodes.LG2:
case IROpCodes.EX2:
return(uop.OpCode.ToString().ToLower() + ".approx.f32" +
" " + uop.Target + ", " + uop.Operand);
case IROpCodes.CALL:
{
CALLInstruction call = bbi as CALLInstruction;
IEnumerable <Tuple <FormalParameter, GenericOperand> > argmap =
call.Target.FormalParameters.Zip(call.Arguments, (fp, ap) =>
new Tuple <FormalParameter, GenericOperand>(fp, ap));
return(string.Format("call.uni ({0}), {1}, ({2})",
string.Join(", ", from tuple in argmap where tuple.Item1.PassingStyle != PassingStyles.VAL select tuple.Item2),
call.Target.Name,
string.Join(", ", from tuple in argmap where tuple.Item1.PassingStyle != PassingStyles.OUT select tuple.Item2)));
}
default:
throw new NotSupportedException(bbi.OpCode.ToString());
}
}
public override bool Visit(UnaryOperation node)
{
return(false);
}
public UnaryExpression(Location location, Expression sub, UnaryOperation operation)
: base(location)
{
this.sub = sub;
this.operation = operation;
}
public UnaryExpression(Expression operand, UnaryOperation operation, MjoType type)
{
Operand = operand;
Operation = operation;
Type = type;
}
public void VisitUnaryOperation(UnaryOperation node)
{
throw new NotImplementedException();
}
public UnaryOperationNode(SourceLocation location, AstNode target, UnaryOperation unaryOperation)
{
this.SourceLocation = location;
Children.Add(target);
UnaryOperation = unaryOperation;
}
public double Calculate(PostfixFunction function, double[] parameters)
{
Stack <double> resultStack = new Stack <double>();
MemoryStream codeStream = function.GetStream();
byte[] buffer = new byte[sizeof(double)];
while (true)
{
int command = codeStream.ReadByte();
if (command == -1)
{
throw new Exception("Can't execute next command");
}
switch ((PostfixFunction.PostfixCommand)command)
{
case PostfixFunction.PostfixCommand.End: return(resultStack.Pop());
case PostfixFunction.PostfixCommand.PushLiteral:
{
codeStream.Read(buffer, 0, sizeof(double));
double literal = BitConverter.ToDouble(buffer, 0);
resultStack.Push(literal);
}
break;
case PostfixFunction.PostfixCommand.PushVariable:
{
codeStream.Read(buffer, 0, sizeof(int));
int index = BitConverter.ToInt32(buffer, 0);
resultStack.Push(function.OriginalFunction.VariableTable[index]);
}
break;
case PostfixFunction.PostfixCommand.PushParameter:
{
codeStream.Read(buffer, 0, sizeof(int));
int index = BitConverter.ToInt32(buffer, 0);
resultStack.Push(parameters[index]);
}
break;
case PostfixFunction.PostfixCommand.CalculateUnary:
{
double operand = resultStack.Pop();
codeStream.Read(buffer, 0, sizeof(int));
int id = BitConverter.ToInt32(buffer, 0);
UnaryOperation operation = (UnaryOperation)Operation.AllOperations[id];
resultStack.Push(operation.Function(operand));
}
break;
case PostfixFunction.PostfixCommand.CalculateBinary:
{
// pop in reverse order!
double rightOperand = resultStack.Pop();
double leftOperand = resultStack.Pop();
codeStream.Read(buffer, 0, sizeof(int));
int id = BitConverter.ToInt32(buffer, 0);
BinaryOperation operation = (BinaryOperation)Operation.AllOperations[id];
resultStack.Push(operation.Function(leftOperand, rightOperand));
}
break;
default: throw new Exception("Unknown command");
}
}
}
public virtual IList<AddressIndependentThing> Encode(UnaryOperation<Amd64Operation> op)
{
throw new InvalidOperationException();
}
public void VisitUnaryOperation(UnaryOperation node) => InferSimpleType(node.Operand);
protected void Attribute(string name, UnaryOperation value)
{
wr.WriteAttributeString(name, Convert(value));
}
/// <summary> /// Create a new instance of the <see cref="BinaryExpression"/> class. /// </summary> /// <param name="location">Location.</param> /// <param name="op">Op.</param> /// <param name="child">Right.</param> public static UnaryExpression Create(SourceLocation location, UnaryOperation op, AstNode child) => new UnaryExpression(location, op, child);
public void VisitUnaryOperation(UnaryOperation node)
{
Visit(node.expr);
}
public override IodineObject PerformUnaryOperation (VirtualMachine vm, UnaryOperation op)
{
switch (op) {
case UnaryOperation.Not:
return new IodineInteger (~Value);
case UnaryOperation.Negate:
return new IodineInteger (-Value);
}
return null;
}
public UnaryExpression(SourceLocation location, UnaryOperation op, AstNode val)
: base(location)
{
Operation = op;
Add(val);
}
public static UnaryExpression <T> Create <T>(Filter <T> left, UnaryOperation op)
{
return(new UnaryExpression <T>(left, op));
}
public UnaryExpression(Location location, UnaryOperation op, AstNode val)
: base(location)
{
Operation = op;
Add (val);
}
public static void Parser_ReNamed2(ref WordType[] tt, ref int tt_i, ref MyArray[] a, ref int a_i, ref string parseresult, ref Dictionary<string, int> varmap, ref Dictionary<string, string> varmap2, ref Dictionary<string, MyArray> varmap3, int start_num, int end_num, int eend_num)
{
try
{
for (tt_i = start_num; tt_i < end_num && tt[tt_i] != null; )
{
// 读取到auto关键字,跳转到auto函数处理
if (tt[tt_i].Type.Equals("auto"))
{
Auto.M_Auto(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3);
}
// 读取到putnumb关键字,跳转到putnumb函数,输出数值型变量值
else if (tt[tt_i].Type.Equals("putnumb"))
{
Putnumb.Put_numb(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3);
}
// 读取到putchar关键字,跳转到putchar函数,输出字符型型变量值
else if (tt[tt_i].Type.Equals("putchar"))
{
Putchar.Put_char(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3);
}
// 单目运算，自增自减
else if (tt[tt_i].Code.Equals("++") || tt[tt_i].Code.Equals("--"))
{
UnaryOperation.Unary_Operation(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3);
}
// 读取到类型为operator,即操作符类型，跳转到operator函数
else if (tt[tt_i].Type.Equals("operator"))
{
BOperator.Operator(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3);
}
// 读取到关键字getchar,跳转到getchar函数进行获取字符串输入操作
else if (tt[tt_i].Type.Equals("getchar"))
{
Getchar.Get_char(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3);
}
// 读取到关键字getnumb,跳转到getnumb函数进行获取数值输入操作
else if (tt[tt_i].Type.Equals("getnumb"))
{
Getnumb.Get_numb(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3);
}
// 读取到note关键字, 跳转到Note函数处理注释
else if (tt[tt_i].Type.Equals("note"))
{
Note.M_Note(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3);
}
// 读取到putstr函数，输出数组
else if (tt[tt_i].Type.Equals("putstr"))
{
Putstr.Put_str(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3);
}
// 都不满足就将tt_i下标加1,不作处理
else
{
tt_i++;
}
}
}
catch (NotDefineVarException e)
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
}
catch (NotAVarException e)
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
}
catch (WrongGrammarException e)
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
}
tt_i = eend_num;
return;
}
void IUnaryOperationVisitor.Visit(UnaryOperation This)
{
throw new Exception("The method or operation is not implemented.");
}
public override IodineObject PerformUnaryOperation(VirtualMachine vm, UnaryOperation op)
{
switch (op) {
case UnaryOperation.BoolNot:
return IodineBool.Create (!Value);
}
return null;
}
public UnaryInstruction(uint label, IVariable result, UnaryOperation operation, IVariable operand)
: base(label, result)
{
this.Operation = operation;
this.Operand = operand;
}
public TotemUnaryOperationBinder Register(Type type, UnaryOperation operation)
{
unops.Add(type, operation);
return this;
}
public UnaryOperationExpression(UnaryOperation operation, ValueExpression operand)
{
Operation = operation;
Operand = operand;
}
public static void F_Parser(ref WordType[] tt, ref int tt_i, ref MyArray[] a, ref int a_i, ref string parseresult, ref Dictionary <string, int> varmap, ref Dictionary <string, string> varmap2, ref Dictionary <string, MyArray> varmap3, int start_num, int end_num)
{
for (tt_i = start_num; tt_i < end_num && tt[tt_i] != null;)
{
if (tt[tt_i].Type.Equals("auto"))
{
try
{
Auto.M_Auto(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3);
}
catch (WrongGrammarException e)
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
}
catch (NotAVarException e)
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
}
}
else if (tt[tt_i].Type.Equals("putnumb"))
{
try
{
Putnumb.Put_numb(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3);
}
catch (NotDefineVarException e)
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
}
catch (WrongGrammarException e)
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
}
catch (NotAVarException e)
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
}
}
else if (tt[tt_i].Type.Equals("putchar"))
{
try
{
Putchar.Put_char(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3);
}
catch (NotDefineVarException e)
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
}
catch (WrongGrammarException e)
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
}
}
else if (tt[tt_i].Code.Equals("++") || tt[tt_i].Code.Equals("--"))
{
try
{
UnaryOperation.Unary_Operation(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3);
}
catch (NotDefineVarException e)
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
}
catch (WrongGrammarException e)
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
}
}
else if (tt[tt_i].Type.Equals("operator"))
{
try
{
BOperator.Operator(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3);
}
catch (NotAVarException e)
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
}
catch (NotDefineVarException e)
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
}
}
else if (tt[tt_i].Type.Equals("getchar"))
{
try
{
Getchar.Get_char(ref tt, ref tt_i, ref a, ref a_i, ref parseresult, ref varmap, ref varmap2, ref varmap3);
}
catch (NotDefineVarException e)
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
}
catch (WrongGrammarException e)
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
}
}
else
{
tt_i++;
}
}
return;
}
public UnaryOpNode(UnaryOperation type, AstNode value)
{
this.UnOp = type;
this.Children.Add(value);
}
void IExpressionVisitor.Visit(UnaryOperation This)
{
result = new ILUnaryOperation(generator, This);
}
public virtual bool Visit(UnaryOperation node)
{
return(CommonVisit(node));
}
public virtual void EndVisit(UnaryOperation node)
{
CommonEndVisit(node);
}
public UnaryOpNode(UnaryOperation type, AstNode value)
{
this.UnOp = type;
this.Children.Add(value);
}
