public MethodSigInfo Create(Blocks blocks)
        {
            methodSigInfo = new MethodSigInfo();

            this.blocks = blocks;
            allBlocks   = blocks.MethodBlocks.GetAllBlocks();

            blockToInfo = new Dictionary <Block, BlockInfo>();
            foreach (var block in allBlocks)
            {
                var blockInfo = new BlockInfo();
                blockToInfo[block] = blockInfo;
                methodSigInfo.BlockInfos.Add(blockInfo);
            }

            foreach (var block in allBlocks)
            {
                var blockInfo = blockToInfo[block];
                Update(blockInfo, block);
                if (block.FallThrough != null)
                {
                    blockInfo.Targets.Add(allBlocks.IndexOf(block.FallThrough));
                }
                if (block.Targets != null)
                {
                    foreach (var target in block.Targets)
                    {
                        blockInfo.Targets.Add(allBlocks.IndexOf(target));
                    }
                }
            }

            return(methodSigInfo);
        }
Esempio n. 2
0
        static List <OpCodeHandlerInfo> ReadV1(BinaryReader reader)
        {
            int numHandlers = reader.ReadInt32();
            var list        = new List <OpCodeHandlerInfo>(numHandlers);

            for (int i = 0; i < numHandlers; i++)
            {
                var typeCode = (HandlerTypeCode)reader.ReadInt32();
                int numInfos = reader.ReadInt32();
                var sigInfo  = new MethodSigInfo();
                for (int j = 0; j < numInfos; j++)
                {
                    var info = new BlockInfo();

                    info.Hash = reader.ReadBytes(reader.ReadInt32());
                    if (info.Hash.Length == 0)
                    {
                        info.Hash = null;
                    }

                    int numTargets = reader.ReadInt32();
                    for (int k = 0; k < numTargets; k++)
                    {
                        info.Targets.Add(reader.ReadInt32());
                    }

                    sigInfo.BlockInfos.Add(info);
                }

                list.Add(new OpCodeHandlerInfo(typeCode, sigInfo));
            }
            return(list);
        }
		static List<OpCodeHandlerInfo> ReadV1(BinaryReader reader) {
			int numHandlers = reader.ReadInt32();
			var list = new List<OpCodeHandlerInfo>(numHandlers);
			for (int i = 0; i < numHandlers; i++) {
				var typeCode = (HandlerTypeCode)reader.ReadInt32();
				int numInfos = reader.ReadInt32();
				var sigInfo = new MethodSigInfo();
				for (int j = 0; j < numInfos; j++) {
					var info = new BlockInfo();

					info.Hash = reader.ReadBytes(reader.ReadInt32());
					if (info.Hash.Length == 0)
						info.Hash = null;

					int numTargets = reader.ReadInt32();
					for (int k = 0; k < numTargets; k++)
						info.Targets.Add(reader.ReadInt32());

					sigInfo.BlockInfos.Add(info);
				}

				list.Add(new OpCodeHandlerInfo(typeCode, sigInfo));
			}
			return list;
		}
        bool Matches(MethodSigInfo handlerSig, SigState sigState)
        {
            stack.Clear();
            sigIndexToHandlerIndex.Clear();
            handlerIndexToSigIndex.Clear();
            var handlerInfos = handlerSig.BlockInfos;
            var sigInfos     = sigState.SigInfo.BlockInfos;

            stack.Push(new MatchInfo(0, 0));
            while (stack.Count > 0)
            {
                var info = stack.Pop();

                int  handlerIndex, sigIndex;
                bool hasVisitedHandler = handlerIndexToSigIndex.TryGetValue(info.HandlerIndex, out sigIndex);
                bool hasVisitedSig     = sigIndexToHandlerIndex.TryGetValue(info.SigIndex, out handlerIndex);
                if (hasVisitedHandler != hasVisitedSig)
                {
                    return(false);
                }
                if (hasVisitedHandler)
                {
                    if (handlerIndex != info.HandlerIndex || sigIndex != info.SigIndex)
                    {
                        return(false);
                    }
                    continue;
                }
                handlerIndexToSigIndex[info.HandlerIndex] = info.SigIndex;
                sigIndexToHandlerIndex[info.SigIndex]     = info.HandlerIndex;

                var handlerBlock = handlerInfos[info.HandlerIndex];
                var sigBlock     = sigInfos[info.SigIndex];

                if (!handlerBlock.Equals(sigBlock))
                {
                    return(false);
                }

                for (int i = 0; i < handlerBlock.Targets.Count; i++)
                {
                    int handlerTargetIndex = handlerBlock.Targets[i];
                    int sigTargetIndex     = sigBlock.Targets[i];
                    stack.Push(new MatchInfo(handlerTargetIndex, sigTargetIndex));
                }
            }

            return(true);
        }
		bool Matches(MethodSigInfo handlerSig, SigState sigState) {
			stack.Clear();
			sigIndexToHandlerIndex.Clear();
			handlerIndexToSigIndex.Clear();
			var handlerInfos = handlerSig.BlockInfos;
			var sigInfos = sigState.SigInfo.BlockInfos;

			stack.Push(new MatchInfo(0, 0));
			while (stack.Count > 0) {
				var info = stack.Pop();

				int handlerIndex, sigIndex;
				bool hasVisitedHandler = handlerIndexToSigIndex.TryGetValue(info.HandlerIndex, out sigIndex);
				bool hasVisitedSig = sigIndexToHandlerIndex.TryGetValue(info.SigIndex, out handlerIndex);
				if (hasVisitedHandler != hasVisitedSig)
					return false;
				if (hasVisitedHandler) {
					if (handlerIndex != info.HandlerIndex || sigIndex != info.SigIndex)
						return false;
					continue;
				}
				handlerIndexToSigIndex[info.HandlerIndex] = info.SigIndex;
				sigIndexToHandlerIndex[info.SigIndex] = info.HandlerIndex;

				var handlerBlock = handlerInfos[info.HandlerIndex];
				var sigBlock = sigInfos[info.SigIndex];

				if (!handlerBlock.Equals(sigBlock))
					return false;

				for (int i = 0; i < handlerBlock.Targets.Count; i++) {
					int handlerTargetIndex = handlerBlock.Targets[i];
					int sigTargetIndex = sigBlock.Targets[i];
					stack.Push(new MatchInfo(handlerTargetIndex, sigTargetIndex));
				}
			}

			return true;
		}
Esempio n. 6
0
 public OpCodeHandlerInfo(HandlerTypeCode typeCode, MethodSigInfo execSig)
 {
     this.TypeCode = typeCode;
     this.Name     = GetHandlerName(typeCode);
     this.ExecSig  = execSig;
 }
 public SigState(PrimitiveHandlerMethod handlerMethod)
 {
     this.SigInfo = handlerMethod.Sig;
 }
		public OpCodeHandlerInfo(HandlerTypeCode typeCode, MethodSigInfo execSig) {
			this.TypeCode = typeCode;
			this.Name = GetHandlerName(typeCode);
			this.ExecSig = execSig;
		}
			public SigState(PrimitiveHandlerMethod handlerMethod) {
				this.SigInfo = handlerMethod.Sig;
			}