public void Visit(SubExpr subExpr, object[] args) { subExpr.FirstOp.Accept(this); subExpr.SecondOp.Accept(this); RightValue v1 = readRightValue(subExpr.FirstOp); RightValue v2 = readRightValue(subExpr.SecondOp); DataType resultType = readAlgoOperand(v1, v2, subExpr.Location); if (resultType == DataType.Int) { IntConst result = new IntConst(); result.Value = Convert.ToInt32(v1.GetValueObject()) - Convert.ToInt32(v2.GetValueObject()); subExpr.RightValue = result; //subExpr.DataType = DataType.Int; } else if (resultType == DataType.Float) { FloatConst result = new FloatConst(); result.Value = Convert.ToDouble(v1.GetValueObject()) - Convert.ToDouble(v2.GetValueObject()); subExpr.RightValue = result; //subExpr.DataType = DataType.Float; } else { throw new Exception(); } }
internal RightValue ParseValue(object value, DataType type, Location loc) { //TODO: 完整实现 switch (type) { case DataType.Int: IntConst intResult = new IntConst(); intResult.Value = (int)value; return(intResult); case DataType.Float: FloatConst floatResult = new FloatConst(); floatResult.Value = (double)value; return(floatResult); case DataType.Bool: BoolConst boolResult = new BoolConst(); boolResult.Value = (bool)value; return(boolResult); case DataType.String: StringConst strResult = new StringConst(); strResult.Value = (string)value; return(strResult); } return(null); }
internal RightValue ParseValue(string value, Location loc) { //TODO: 类型歧义问题 if (intValuePattern.IsMatch(value)) { IntConst result = new IntConst(); result.Value = int.Parse(value); return(result); } else if (floatValuePattern.IsMatch(value)) { FloatConst result = new FloatConst(); result.Value = double.Parse(value); return(result); } else if (boolValuePattern.IsMatch(value)) { BoolConst result = new BoolConst(); result.Value = bool.Parse(value); return(result); } else { StringConst result = new StringConst(); result.Value = value; return(result); } }
internal RightValue ParseValue(string value, DataType type, Location loc) { switch (type) { case DataType.Int: int intParsed; if (!int.TryParse(value, out intParsed)) { kernel.IssueError(ErrorType.ParseTypeError, loc, value, type.ToString()); return(null); } IntConst intResult = new IntConst(); intResult.Value = intParsed; return(intResult); case DataType.Float: float floatParsed; if (!float.TryParse(value, out floatParsed)) { kernel.IssueError(ErrorType.ParseTypeError, loc, value, type.ToString()); return(null); } FloatConst floatResult = new FloatConst(); floatResult.Value = floatParsed; return(floatResult); case DataType.Bool: bool boolParsed; int boolIntParsed; double boolFloatParsed; BoolConst boolResult = new BoolConst(); if (bool.TryParse(value, out boolParsed)) { boolResult.Value = boolParsed; return(boolResult); } else if (int.TryParse(value, out boolIntParsed)) { boolResult.Value = (boolIntParsed != 0); return(boolResult); } else if (double.TryParse(value, out boolFloatParsed)) { boolResult.Value = (boolFloatParsed != 0); return(boolResult); } else { kernel.IssueError(ErrorType.ParseTypeError, loc, value, type.ToString()); return(null); } case DataType.String: StringConst strConst = new StringConst(); strConst.Value = value; return(strConst); } return(null); }
/// <summary> /// Generate code or evaluate the type for int const /// </summary> void IConstVisitor.Visit(IntConst This) { if (checkType) { type = TypeEntity.Int; return; } IL.Emit(OpCodes.Ldc_I4, This.Value); }
private static IntConst ApplyOperation(IntConst left, IntConst right, OpCode op) { switch (op) { case OpCode.Plus: return(left + right); case OpCode.Minus: return(left - right); case OpCode.Mul: return(left * right); case OpCode.Div: return(left / right); default: return(left); } }
public override void Init(UIScheme.InnerContainer container) { base.Init(container); mScheme = (IntConst)mContainer.Scheme; mContainer.InnerBuildInfo.BuildString.Parameters = mScheme.Number.ToString(); mNumber.text = mContainer.InnerBuildInfo.BuildString.Parameters; gameObject.name = "Scheme: " + mContainer.InnerBuildInfo.BuildString.Name; transform.localPosition = mContainer.InnerBuildInfo.Position.ToVector3(); (transform as RectTransform).sizeDelta = mContainer.InnerBuildInfo.Size; mName.text = mContainer.InnerBuildInfo.BuildString.Name; mType.text = mContainer.InnerBuildInfo.BuildString.Type; mRemoveButton.onClick.AddListener(() => SchemeDesigner.Instance.RemoveInnerScheme(mContainer)); var outputCount = mContainer.Scheme.IOGroups.Count((x) => x.Value.IO == IO.Output); mOutputDesigns = new List <IOInnerGroupDesign>(outputCount); mIOGroupDesigns = new Dictionary <string, IOInnerGroupDesign>(outputCount); foreach (var ioGroup in mContainer.Scheme.IOGroups) { IOInnerGroupDesign design = null; switch (ioGroup.Value.IO) { case IO.Output: design = Instantiate(mOutputIOGroupPrefab, mOutputs).GetComponent <IOInnerGroupDesign>(); mOutputDesigns.Add(design); mIOGroupDesigns.Add(ioGroup.Key, design); break; } design.Init(ioGroup.Key, ioGroup.Value, mContainer.Scheme); } SchemeDesigner.Instance.AddLinkStateChanged += OnAddLinkStateChanged; if (outputCount > 0) { mAddOutputLink.gameObject.SetActive(true); mAddOutputLink.onClick.AddListener(() => { SchemeDesigner.Instance.AddLinkAsSource(mContainer); }); } mNumber.onEndEdit.AddListener(OnNumberChanged); }
public override TreeNode GetAstCodeGenerator(SymbolTable t) { switch (type) { case "Int": var @int = new IntConst(MIPSCodeGenerator.SymbolUtils.IntTable.AddString(value), Line); SetGeneratorType(@int); return(@int); case "String": var str = new StringConst(MIPSCodeGenerator.SymbolUtils.StrTable.AddString(value), Line); SetGeneratorType(str); return(str); case "Bool": var bol = new BoolConst(bool.Parse(value.ToLower()), Line); SetGeneratorType(bol); return(bol); default: throw new InvalidOperationException(); } }
public void Visit(NegativeExpr negativeExpr, object[] args) { negativeExpr.Op.Accept(this); RightValue v = readRightValue(negativeExpr.Op); //modified by Wander @ 2011 if (v is IntConst) { IntConst result = new IntConst(); result.Value = -(v as IntConst).Value; negativeExpr.RightValue = result; } else if (v is FloatConst) { FloatConst result = new FloatConst(); result.Value = -(v as FloatConst).Value; negativeExpr.RightValue = result; } else { throw new RuntimeException(new Error(ErrorType.OprandTypeError, negativeExpr.Location)); } }
public void Visit(AddExpr addExpr, object[] args) { addExpr.FirstOp.Accept(this); addExpr.SecondOp.Accept(this); RightValue v1 = readRightValue(addExpr.FirstOp); RightValue v2 = readRightValue(addExpr.SecondOp); if (v1 is StringConst || v2 is StringConst) { StringConst result = new StringConst(); result.Value = v1.ToString() + v2.ToString(); addExpr.RightValue = result; //addExpr.DataType = DataType.String; } else { DataType resultType = readAlgoOperand(v1, v2, addExpr.Location); if (resultType == DataType.Int) { IntConst result = new IntConst(); result.Value = Convert.ToInt32(v1.GetValueObject()) + Convert.ToInt32(v2.GetValueObject()); addExpr.RightValue = result; //addExpr.DataType = DataType.Int; } else if (resultType == DataType.Float) { FloatConst result = new FloatConst(); result.Value = Convert.ToDouble(v1.GetValueObject()) + Convert.ToDouble(v2.GetValueObject()); addExpr.RightValue = result; //addExpr.DataType = DataType.Float; } else { throw new Exception(); } } }
public void Visit(DivExpr divExpr, object[] args) { divExpr.FirstOp.Accept(this); divExpr.SecondOp.Accept(this); RightValue v1 = readRightValue(divExpr.FirstOp); RightValue v2 = readRightValue(divExpr.SecondOp); DataType resultType = readAlgoOperand(v1, v2, divExpr.Location); if (resultType == DataType.Int) { IntConst result = new IntConst(); if (Convert.ToInt32(v2.GetValueObject()) == 0) { throw new RuntimeException(new Error(ErrorType.DivisorZero, divExpr.Location)); } result.Value = Convert.ToInt32(v1.GetValueObject()) / Convert.ToInt32(v2.GetValueObject()); divExpr.RightValue = result; //divExpr.DataType = DataType.Int; } else if (resultType == DataType.Float) { FloatConst result = new FloatConst(); if (Convert.ToDouble(v2.GetValueObject()) == 0) { throw new RuntimeException(new Error(ErrorType.DivisorZero, divExpr.Location)); } result.Value = Convert.ToDouble(v1.GetValueObject()) / Convert.ToDouble(v2.GetValueObject()); divExpr.RightValue = result; //divExpr.DataType = DataType.Float; } else { throw new Exception(); } }
public override string VisitIntConst(IntConst t) { return(t.Val.ToString()); }
/// <summary> /// end表示字符串最后一个字符的后一个位置 /// </summary> /// <param name="begin"></param> /// <param name="end"></param> /// <returns></returns> private Expression parse(int begin, int end) { if (begin >= end) { kernel.IssueError(ErrorType.ExpressionSyntaxError, loc.Offset(begin)); return(null); } while (isWhiteSpace(expr[begin])) { begin++; } while (isWhiteSpace(expr[end - 1])) { end--; } int currentParenLevel; bool hasSideParren = true; while (expr[begin] == '(' && hasSideParren) { currentParenLevel = 0; int currentPos; for (currentPos = begin; currentPos < end; currentPos++) { if (expr[currentPos] == '(') { currentParenLevel++; } else if (expr[currentPos] == ')') { currentParenLevel--; if (currentParenLevel == 0) { if (currentPos == end - 1) { begin++; end--; } else { hasSideParren = false; } break; } } } if (currentPos == end && currentParenLevel > 0) { kernel.IssueError(ErrorType.SingleParen, loc.Offset(begin)); return(null); } } currentParenLevel = 0; OpLevel currentLevel = OpLevel.Null; OpLevel minLevel = OpLevel.Null; int minPos = -1; int minOpLength = 0; bool findOp = false; string op = null; MatchTokenResult matchTokenResult; //找到当前应处理的操作符 for (int currentPos = begin; currentPos < end; currentPos = matchTokenResult.EndPos) { //if (expr[currentPos] == ' ' || expr[currentPos] == '\t' || expr[currentPos] == '\n' // || Environment.NewLine.IndexOf(expr[currentPos]) != -1) //{ // op = null; // continue; //} matchTokenResult = MatchToken(currentPos, end); if (matchTokenResult.TokenType == TokenType.Error) { return(null); } if (matchTokenResult.TokenType != TokenType.Operator) { continue; } op = matchTokenResult.Matched; if (op != "(" && op != ")") { findOp = true; } if (op == "(") { currentParenLevel++; continue; } else if (op == ")") { currentParenLevel--; continue; } else if (currentParenLevel > 0) { continue; } else if (currentParenLevel < 0) { kernel.IssueError(ErrorType.SingleParen, loc.Offset(currentPos)); return(null); } if (currentParenLevel == 0 && ( (int)(currentLevel = getOpLevel(op)) < (int)minLevel) || ((int)currentLevel == (int)minLevel && op != "=") //=为右结合 ) { minLevel = currentLevel; minPos = matchTokenResult.BeginPos; minOpLength = op.Length; } } if (currentParenLevel != 0) { kernel.IssueError(ErrorType.SingleParen, loc.Offset(begin)); return(null); } if (!findOp) //单个数据 { string str = expr.Substring(begin, end - begin); int currentPos = begin; matchTokenResult = MatchToken(currentPos, end); switch (matchTokenResult.TokenType) { case TokenType.Int: RightValueExpr intResult = new RightValueExpr(); IntConst intConst = new IntConst(); intConst.Value = int.Parse(matchTokenResult.Matched); intResult.DataType = DataType.Int; intResult.RightValue = intConst; intResult.Location = loc.Offset(begin); return(intResult); case TokenType.Float: RightValueExpr floatResult = new RightValueExpr(); FloatConst floatConst = new FloatConst(); floatConst.Value = float.Parse(matchTokenResult.Matched); floatResult.DataType = DataType.Float; //modified by Wander @ 2011 floatResult.RightValue = floatConst; floatResult.Location = loc.Offset(begin); return(floatResult); case TokenType.String: RightValueExpr strResult = new RightValueExpr(); StringConst strConst = new StringConst(); strConst.Value = matchTokenResult.Matched; strResult.DataType = DataType.String; strResult.RightValue = strConst; strResult.Location = loc.Offset(begin); return(strResult); case TokenType.Bool: RightValueExpr boolResult = new RightValueExpr(); BoolConst boolConst = new BoolConst(); boolConst.Value = bool.Parse(matchTokenResult.Matched); boolResult.DataType = DataType.Bool; boolResult.RightValue = boolConst; boolResult.Location = loc.Offset(begin); return(boolResult); case TokenType.Variable: VarRef varRef = new VarRef(); varRef.VarName = matchTokenResult.Matched; LeftValueExpr leftValueResult = new LeftValueExpr(); leftValueResult.DataType = DataType.Unknown; leftValueResult.Location = loc.Offset(begin); leftValueResult.LeftValue = varRef; return(leftValueResult); default: kernel.IssueError(ErrorType.ExpressionSyntaxError, loc.Offset(begin)); return(null); } } Expression left; Expression right; matchTokenResult = MatchToken(minPos, end); op = matchTokenResult.Matched; left = (begin != minPos) ? parse(begin, minPos) : null; //null表示单目运算符 right = parse(matchTokenResult.EndPos, end); Location currentLoc = loc.Offset(begin); if (right == null) { return(null); } switch (op) { case "=": if (!(left is LeftValueExpr)) { kernel.IssueError(ErrorType.NotLeftValue, currentLoc); return(null); } AssignExpr assignExpr = new AssignExpr(); assignExpr.LeftExpr = left as LeftValueExpr; assignExpr.RightExpr = right; assignExpr.DataType = right.DataType; assignExpr.Location = currentLoc; return(assignExpr); case "&&": return(processBinaryLogicExpr( new AndExpr(), left, right, currentLoc)); case "||": return(processBinaryLogicExpr( new OrExpr(), left, right, currentLoc)); case "==": return(processBinaryCmpExpr(new EquExpr(), left, right, currentLoc)); case "!=": return(processBinaryCmpExpr(new NeqExpr(), left, right, currentLoc)); case ">": return(processBinaryCmpExpr(new GreatExpr(), left, right, currentLoc)); case ">=": return(processBinaryCmpExpr(new GreatEquExpr(), left, right, currentLoc)); case "<": return(processBinaryCmpExpr(new LessExpr(), left, right, currentLoc)); case "<=": return(processBinaryCmpExpr(new LessEquExpr(), left, right, currentLoc)); case "+": return(processBinaryAlgoExpr(new AddExpr(), left, right, currentLoc)); case "-": if (left == null) { NegativeExpr negExpr = new NegativeExpr(); if (right.DataType == DataType.Bool || right.DataType == DataType.String) { kernel.IssueError(ErrorType.OprandTypeError, currentLoc); return(null); } else if (right.DataType == DataType.Int) { negExpr.DataType = DataType.Int; } else if (right.DataType == DataType.Float) { negExpr.DataType = DataType.Float; } else { negExpr.DataType = DataType.Unknown; } negExpr.Op = right; negExpr.Location = currentLoc; return(negExpr); } else { return(processBinaryAlgoExpr(new SubExpr(), left, right, currentLoc)); } case "*": return(processBinaryAlgoExpr(new MulExpr(), left, right, currentLoc)); case "/": return(processBinaryAlgoExpr(new DivExpr(), left, right, currentLoc)); case "^": return(processBinaryAlgoExpr(new PowExpr(), left, right, currentLoc)); case "!": if (left != null) { kernel.IssueError(ErrorType.ExpressionSyntaxError, currentLoc); return(null); } else { NotExpr notExpr = new NotExpr(); notExpr.DataType = DataType.Bool; notExpr.Op = right; notExpr.Location = currentLoc; return(notExpr); } } return(null); }
public override void Visit(IntConst n) { //throw new NotImplementedException(); }
public override void Visit(IntConst n) { emit($"{n.val}"); }
public VarValue() { varType = Type.UNDEF; value = null; }
public static Term IntVal(BigNum num) { Term intConst = new IntConst(num); return(IntVal(intConst)); }
public VarValue(IntConst c) { varType = Type.CONST; value = c; }
public override void Visit(IntConst n) { n.type = AST.INTTYPE; }
public override void Visit(IntConst n) { }
public IProgramAccessor GetIsaProgram( string theoryName, string procName, BoogieMethodData methodData, IsaProgramGeneratorConfig config, IVariableTranslationFactory varTranslationFactory, CFGRepr cfg, out IList <OuterDecl> decls, bool generateMembershipLemmas = true, bool onlyGlobalData = false ) { this.varTranslationFactory = varTranslationFactory; varTranslation = varTranslationFactory.CreateTranslation(); cmdIsaVisitor = new MultiCmdIsaVisitor(varTranslationFactory); /* * Term program = IsaBoogieTerm.Program(IsaCommonTerms.TermIdentFromName(funcs.name), * new TermList(new List<Term>()), * new TermList(new List<Term>()), * IsaCommonTerms.TermIdentFromName(axiomsDecl.name), * new List<Term>() { method }); * * var list = new List<Tuple<IList<Term>, Term>> * { * new Tuple<IList<Term>, Term>(new List<Term>(), program) * }; */ //OuterDecl programDefinition = new DefDecl("ProgramM", new Tuple<IList<Term>, Term>(new List<Term>(), program)); decls = new List <OuterDecl>(); var isaGlobalProgramRepr = new IsaGlobalProgramRepr( FunctionDeclarationsName(), AxiomDeclarationsName(), VariableDeclarationsName("globals"), VariableDeclarationsName("constants") ); var globalsMax = methodData.Constants.Count() + methodData.GlobalVars.Count() - 1; // assume single versioning and order on constants, globals, params, locals var localsMin = globalsMax + 1; if (globalsMax < 0) { globalsMax = 0; } MembershipLemmaManager membershipLemmaManager; if (onlyGlobalData) { membershipLemmaManager = new MembershipLemmaManager( isaGlobalProgramRepr, globalsMax, varTranslationFactory, theoryName); } else { var outEdges = GetOutEdgesIsa(procName, cfg, out var edgeLemmas); var blockInfo = BlockToInfo(theoryName, procName, cfg, edgeLemmas); var isaProgramRepr = new IsaProgramRepr( isaGlobalProgramRepr, PreconditionDeclarationName(), PostconditionDeclarationName(), VariableDeclarationsName("params"), VariableDeclarationsName("locals"), cfgName, procDefName); membershipLemmaManager = new MembershipLemmaManager(config, isaProgramRepr, blockInfo, Tuple.Create(globalsMax, localsMin), varTranslationFactory, theoryName); var nodesToBlocks = GetNodeToBlocksIsa(cfg, blockInfo.BlockCmdsDefs); decls.AddRange(blockInfo.BlockCmdsDefs.Values); Term entry = new IntConst(BigNum.FromInt(cfg.GetUniqueIntLabel(cfg.entry))); var methodBodyCFG = IsaBoogieTerm.MethodCFGBody( entry, IsaCommonTerms.TermIdentFromName(outEdges.Name), IsaCommonTerms.TermIdentFromName(nodesToBlocks.Name) ); var methodBodyDecl = GetMethodBodyCFGDecl(procName, methodBodyCFG); decls.AddRange( new List <OuterDecl> { outEdges, nodesToBlocks, methodBodyDecl }); decls.AddRange(blockInfo.BlockCmdsLemmas.Values); decls.AddRange(blockInfo.BlockOutEdgesLemmas.Values); if (config.specsConfig != SpecsConfig.None) { OuterDecl preconditions; OuterDecl postconditions; if (config.specsConfig == SpecsConfig.AllPreCheckedPost) { preconditions = GetExprListIsa(PreconditionDeclarationName(), methodData.Preconditions.Select(pre => pre.Item1)); postconditions = GetExprListIsa(PostconditionDeclarationName(), methodData.Postconditions.Where(post => !post.Item2).Select(post => post.Item1)); } else { preconditions = GetExprListIsa(PreconditionDeclarationName(), methodData.Preconditions); postconditions = GetExprListIsa(PostconditionDeclarationName(), methodData.Postconditions); } decls.Add(preconditions); decls.Add(postconditions); } if (config.generateParamsAndLocals) { decls.Add(GetVariableDeclarationsIsa("params", methodData.InParams)); decls.Add(GetVariableDeclarationsIsa("locals", methodData.Locals)); } /* membership lemmas might still be added even if the parameter and local variable definitions are not generated * at this point (since the variable context may still be different, which requires other lookup lemmas) */ if (generateMembershipLemmas) { membershipLemmaManager.AddVariableMembershipLemmas(methodData.InParams, VarKind.ParamOrLocal); membershipLemmaManager.AddVariableMembershipLemmas(methodData.Locals, VarKind.ParamOrLocal); } } if (config.generateAxioms) { decls.Add(GetAxioms(methodData.Axioms)); if (generateMembershipLemmas) { membershipLemmaManager.AddAxiomMembershipLemmas(methodData.Axioms); } } if (config.generateFunctions) { decls.Add(GetFunctionDeclarationsIsa(methodData.Functions)); if (generateMembershipLemmas) { membershipLemmaManager.AddFunctionMembershipLemmas(methodData.Functions); } } if (config.generateGlobalsAndConstants) { decls.Add(GetVariableDeclarationsIsa("globals", methodData.GlobalVars)); decls.Add(GetVariableDeclarationsIsa("constants", methodData.Constants)); } if (generateMembershipLemmas) { membershipLemmaManager.AddVariableMembershipLemmas(methodData.GlobalVars, VarKind.Global); membershipLemmaManager.AddVariableMembershipLemmas(methodData.Constants, VarKind.Constant); decls.AddRange(membershipLemmaManager.OuterDecls()); } if (config.specsConfig != SpecsConfig.None) { DefDecl methodDef = MethodDefinition(membershipLemmaManager, methodData, config.specsConfig); decls.Add(methodDef); } return(membershipLemmaManager); }
private void ReadBytecode(Stream input, FunctionDefinition funcDef) { funcDef.Instructions = new List <IInstruction>(); funcDef.InstructionOffsets = new List <int>(); var unencodedByteCodeLength = input.ReadValueEncodedS32(); int read; for (read = 0; read < unencodedByteCodeLength;) { funcDef.InstructionOffsets.Add(read); var op = input.ReadValueU8(); var opcode = (Script.Opcode)op; read++; Script.IInstruction instruction = null; switch (opcode) { case Script.Opcode.OP_Target: { instruction = new Target(); break; } case Script.Opcode.OP_ShortConst: { instruction = new ShortConst(); break; } case Script.Opcode.OP_IntConst: { instruction = new IntConst(); break; } case Script.Opcode.OP_FloatConst: { instruction = new FloatConst(); break; } case Script.Opcode.OP_StringConst: { instruction = new StringConst(this); break; } case Script.Opcode.OP_VirtualFunc: { instruction = new VirtualFunc(this); break; } case Script.Opcode.OP_Context: case Script.Opcode.OP_SwitchLabel: { instruction = new U16U16(opcode); break; } case Script.Opcode.OP_Assign: case Script.Opcode.OP_JumpIfFalse: case Script.Opcode.OP_Jump: case Script.Opcode.OP_Skip: { instruction = new U16(opcode); break; } case Script.Opcode.OP_LocalVar: case Script.Opcode.OP_ObjectVar: case Script.Opcode.OP_ParamVar: case Script.Opcode.OP_StructMember: { instruction = new TypeMember(opcode, this); break; } case Script.Opcode.OP_Switch: { instruction = new Switch(); break; } case Script.Opcode.OP_Constructor: { instruction = new Constructor(this); break; } case Script.Opcode.OP_TestEqual: case Script.Opcode.OP_EnumToInt: case Script.Opcode.OP_ArrayPushBack: case Script.Opcode.OP_ArraySize: case Script.Opcode.OP_ArrayElement: case Script.Opcode.OP_New: case Script.Opcode.OP_ArrayClear: case Script.Opcode.OP_DynamicCast: case Script.Opcode.OP_ArrayContainsFast: case Script.Opcode.OP_ArrayRemoveFast: case Script.Opcode.OP_TestNotEqual: case Script.Opcode.OP_ArrayErase: case Script.Opcode.OP_EnumToString: case Script.Opcode.OP_ArrayContains: case Script.Opcode.OP_ArrayResize: case Script.Opcode.OP_ArrayInsert: case Script.Opcode.OP_ArrayGrow: case Script.Opcode.OP_ArrayFindFirstFast: case Script.Opcode.OP_ArrayLast: case Script.Opcode.OP_ArrayRemove: case Script.Opcode.OP_SaveValue: { instruction = new TypeRef(opcode, this); break; } case Script.Opcode.OP_NameConst: { instruction = new NameConst(Strings); break; } case Script.Opcode.OP_FinalFunc: { instruction = new FinalFunc(this); break; } case Script.Opcode.OP_EntryFunc: case Script.Opcode.OP_SavePoint: { instruction = new U16S32(opcode, this); break; } case Script.Opcode.OP_Nop: case Script.Opcode.OP_ParamEnd: case Script.Opcode.OP_IntZero: case Script.Opcode.OP_IntOne: case Script.Opcode.OP_BoolFalse: case Script.Opcode.OP_BoolTrue: case Script.Opcode.OP_Return: case Script.Opcode.OP_GetServer: case Script.Opcode.OP_GetCamera: case Script.Opcode.OP_NameToString: case Script.Opcode.OP_GetPlayer: case Script.Opcode.OP_IntToFloat: case Script.Opcode.OP_This: case Script.Opcode.OP_Null: case Script.Opcode.OP_GetGame: case Script.Opcode.OP_ObjectToBool: case Script.Opcode.OP_IntToString: case Script.Opcode.OP_FloatToString: case Script.Opcode.OP_IntToByte: case Script.Opcode.OP_ObjectToString: case Script.Opcode.OP_SwitchDefault: case Script.Opcode.OP_BoolToString: case Script.Opcode.OP_GetHud: case Script.Opcode.OP_FloatToInt: case Script.Opcode.OP_NameToBool: case Script.Opcode.OP_Parent: case Script.Opcode.OP_IntToBool: case Script.Opcode.OP_ByteToInt: case Script.Opcode.OP_FloatToBool: case Script.Opcode.OP_ByteToFloat: case Script.Opcode.OP_StringToBool: case Script.Opcode.OP_SavePointEnd: case Script.Opcode.OP_StringToInt: case Script.Opcode.OP_GetSound: { instruction = new Simple(opcode); break; } default: { throw new NotImplementedException("unhandled " + opcode.ToString()); } } read += instruction.Deserialize(input); funcDef.Instructions.Add(instruction); } if (read != unencodedByteCodeLength) { throw new InvalidOperationException(); } }
public VarValue(Var v) { varType = Type.NAC; value = null; }