11312961858

Committed 13 Oct 2024 08:46AM UTC coverage: 55.922% (+0.01%) from 55.91%

Build # 11312961858

Build Type

Pull #3531

github

Committed by

web-flow

Commit Message

Merge 367d9b40f into a32693924

Pull Request Pull Request #3531: Fixed hashcode for Buffer

Run Details

5776 of 8908 branches covered (64.84%)

Branch coverage included in aggregate %.

12 of 12 new or added lines in 5 files covered. (100.0%)

29 existing lines in 5 files now uncovered.

21721 of 40262 relevant lines covered (53.95%)

86514.04 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

67.19

/src/Neo.VM/Script.cs

// Copyright (C) 2015-2024 The Neo Project.
//
// Script.cs file belongs to the neo project and is free
// software distributed under the MIT software license, see the
// accompanying file LICENSE in the main directory of the
// repository or http://www.opensource.org/licenses/mit-license.php
// for more details.
//
// Redistribution and use in source and binary forms with or without
// modifications are permitted.

using Neo.VM.Types;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.CompilerServices;

namespace Neo.VM
{
    /// <summary>
    /// Represents the script executed in the VM.
    /// </summary>
    [DebuggerDisplay("Length={Length}")]
    public class Script
    {
        private readonly ReadOnlyMemory<byte> _value;
        private readonly bool strictMode;
        private readonly Dictionary<int, Instruction> _instructions = new();

        /// <summary>
        /// The length of the script.
        /// </summary>
        public int Length
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get
            {
                return _value.Length;
            }
        }

        /// <summary>
        /// Gets the <see cref="OpCode"/> at the specified index.
        /// </summary>
        /// <param name="index">The index to locate.</param>
        /// <returns>The <see cref="OpCode"/> at the specified index.</returns>
        public OpCode this[int index]
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get
            {
                return (OpCode)_value.Span[index];
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Script"/> class.
        /// </summary>
        /// <param name="script">The bytecodes of the script.</param>
        public Script(ReadOnlyMemory<byte> script) : this(script, false)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Script"/> class.
        /// </summary>
        /// <param name="script">The bytecodes of the script.</param>
        /// <param name="strictMode">
        /// Indicates whether strict mode is enabled.
        /// In strict mode, the script will be checked, but the loading speed will be slower.
        /// </param>
        /// <exception cref="BadScriptException">In strict mode, the script was found to contain bad instructions.</exception>
        public Script(ReadOnlyMemory<byte> script, bool strictMode)
        {
            _value = script;
            if (strictMode)
            {
                for (int ip = 0; ip < script.Length; ip += GetInstruction(ip).Size) { }
                foreach (var (ip, instruction) in _instructions)
                {
                    switch (instruction.OpCode)
                    {
                        case OpCode.JMP:
                        case OpCode.JMPIF:
                        case OpCode.JMPIFNOT:
                        case OpCode.JMPEQ:
                        case OpCode.JMPNE:
                        case OpCode.JMPGT:
                        case OpCode.JMPGE:
                        case OpCode.JMPLT:
                        case OpCode.JMPLE:
                        case OpCode.CALL:
                        case OpCode.ENDTRY:
                            if (!_instructions.ContainsKey(checked(ip + instruction.TokenI8)))
                                throw new BadScriptException($"ip: {ip}, opcode: {instruction.OpCode}");
                            break;
                        case OpCode.PUSHA:
                        case OpCode.JMP_L:
                        case OpCode.JMPIF_L:
                        case OpCode.JMPIFNOT_L:
                        case OpCode.JMPEQ_L:
                        case OpCode.JMPNE_L:
                        case OpCode.JMPGT_L:
                        case OpCode.JMPGE_L:
                        case OpCode.JMPLT_L:
                        case OpCode.JMPLE_L:
                        case OpCode.CALL_L:
                        case OpCode.ENDTRY_L:
                            if (!_instructions.ContainsKey(checked(ip + instruction.TokenI32)))
                                throw new BadScriptException($"ip: {ip}, opcode: {instruction.OpCode}");
                            break;
                        case OpCode.TRY:
                            if (!_instructions.ContainsKey(checked(ip + instruction.TokenI8)))
                                throw new BadScriptException($"ip: {ip}, opcode: {instruction.OpCode}");
                            if (!_instructions.ContainsKey(checked(ip + instruction.TokenI8_1)))
                                throw new BadScriptException($"ip: {ip}, opcode: {instruction.OpCode}");
                            break;
                        case OpCode.TRY_L:
                            if (!_instructions.ContainsKey(checked(ip + instruction.TokenI32)))
                                throw new BadScriptException($"ip: {ip}, opcode: {instruction.OpCode}");
                            if (!_instructions.ContainsKey(checked(ip + instruction.TokenI32_1)))
                                throw new BadScriptException($"ip: {ip}, opcode: {instruction.OpCode}");
                            break;
                        case OpCode.NEWARRAY_T:
                        case OpCode.ISTYPE:
                        case OpCode.CONVERT:
                            StackItemType type = (StackItemType)instruction.TokenU8;
                            if (!Enum.IsDefined(typeof(StackItemType), type))
                                throw new BadScriptException();
                            if (instruction.OpCode != OpCode.NEWARRAY_T && type == StackItemType.Any)
                                throw new BadScriptException($"ip: {ip}, opcode: {instruction.OpCode}");
                            break;
                    }
                }
            }
            this.strictMode = strictMode;
        }

        /// <summary>
        /// Get the <see cref="Instruction"/> at the specified position.
        /// </summary>
        /// <param name="ip">The position to get the <see cref="Instruction"/>.</param>
        /// <returns>The <see cref="Instruction"/> at the specified position.</returns>
        /// <exception cref="ArgumentException">In strict mode, the <see cref="Instruction"/> was not found at the specified position.</exception>
        public Instruction GetInstruction(int ip)
        {
            if (ip >= Length) throw new ArgumentOutOfRangeException(nameof(ip));
            if (!_instructions.TryGetValue(ip, out Instruction? instruction))
            {
                if (strictMode) throw new ArgumentException($"ip not found with strict mode", nameof(ip));
                instruction = new Instruction(_value, ip);
                _instructions.Add(ip, instruction);
            }
            return instruction;
        }

        public static implicit operator ReadOnlyMemory<byte>(Script script) => script._value;
        public static implicit operator Script(ReadOnlyMemory<byte> script) => new(script);
        public static implicit operator Script(byte[] script) => new(script);
    }
}

1	// Copyright (C) 2015-2024 The Neo Project.
2	//
3	// Script.cs file belongs to the neo project and is free
4	// software distributed under the MIT software license, see the
5	// accompanying file LICENSE in the main directory of the
6	// repository or http://www.opensource.org/licenses/mit-license.php
7	// for more details.
8	//
9	// Redistribution and use in source and binary forms with or without
10	// modifications are permitted.
11
12	using Neo.VM.Types;
13	using System;
14	using System.Collections.Generic;
15	using System.Diagnostics;
16	using System.Runtime.CompilerServices;
17
18	namespace Neo.VM
19	{
20	/// <summary>
21	/// Represents the script executed in the VM.
22	/// </summary>
23	[DebuggerDisplay("Length={Length}")]
24	public class Script
25	{
26	private readonly ReadOnlyMemory<byte> _value;
27	private readonly bool strictMode;
28	private readonly Dictionary<int, Instruction> _instructions = new();	1,750✔
29
30	/// <summary>
31	/// The length of the script.
32	/// </summary>
33	public int Length
34	{
35	[MethodImpl(MethodImplOptions.AggressiveInlining)]
36	get
37	{	580,216✔
38	return _value.Length;	580,216✔
39	}	580,216✔
40	}
41
42	/// <summary>
43	/// Gets the <see cref="OpCode"/> at the specified index.
44	/// </summary>
45	/// <param name="index">The index to locate.</param>
46	/// <returns>The <see cref="OpCode"/> at the specified index.</returns>
47	public OpCode this[int index]
48	{
49	[MethodImpl(MethodImplOptions.AggressiveInlining)]
50	get
51	{	543✔
52	return (OpCode)_value.Span[index];	543✔
53	}	543✔
54	}
55
56	/// <summary>
57	/// Initializes a new instance of the <see cref="Script"/> class.
58	/// </summary>
59	/// <param name="script">The bytecodes of the script.</param>
60	public Script(ReadOnlyMemory<byte> script) : this(script, false)	1,676✔
61	{	1,676✔
62	}	1,676✔
63
64	/// <summary>
65	/// Initializes a new instance of the <see cref="Script"/> class.
66	/// </summary>
67	/// <param name="script">The bytecodes of the script.</param>
68	/// <param name="strictMode">
69	/// Indicates whether strict mode is enabled.
70	/// In strict mode, the script will be checked, but the loading speed will be slower.
71	/// </param>
72	/// <exception cref="BadScriptException">In strict mode, the script was found to contain bad instructions.</exception>
73	public Script(ReadOnlyMemory<byte> script, bool strictMode)	1,750✔
74	{	1,750✔
75	_value = script;	1,750✔
76	if (strictMode)	1,750✔
77	{	72✔
78	for (int ip = 0; ip < script.Length; ip += GetInstruction(ip).Size) { }	9,015✔
79	foreach (var (ip, instruction) in _instructions)	4,627✔
80	{	2,213✔
81	switch (instruction.OpCode)	2,213!
82	{
83	case OpCode.JMP:
84	case OpCode.JMPIF:
85	case OpCode.JMPIFNOT:
86	case OpCode.JMPEQ:
87	case OpCode.JMPNE:
88	case OpCode.JMPGT:
89	case OpCode.JMPGE:
90	case OpCode.JMPLT:
91	case OpCode.JMPLE:
92	case OpCode.CALL:
93	case OpCode.ENDTRY:
94	if (!_instructions.ContainsKey(checked(ip + instruction.TokenI8)))	15!
UNCOV 95	throw new BadScriptException($"ip: {ip}, opcode: {instruction.OpCode}");	×
96	break;	15✔
97	case OpCode.PUSHA:
98	case OpCode.JMP_L:
99	case OpCode.JMPIF_L:
100	case OpCode.JMPIFNOT_L:
101	case OpCode.JMPEQ_L:
102	case OpCode.JMPNE_L:
103	case OpCode.JMPGT_L:
104	case OpCode.JMPGE_L:
105	case OpCode.JMPLT_L:
106	case OpCode.JMPLE_L:
107	case OpCode.CALL_L:
108	case OpCode.ENDTRY_L:
UNCOV 109	if (!_instructions.ContainsKey(checked(ip + instruction.TokenI32)))	×
110	throw new BadScriptException($"ip: {ip}, opcode: {instruction.OpCode}");	×
111	break;	×
112	case OpCode.TRY:
UNCOV 113	if (!_instructions.ContainsKey(checked(ip + instruction.TokenI8)))	×
114	throw new BadScriptException($"ip: {ip}, opcode: {instruction.OpCode}");	×
115	if (!_instructions.ContainsKey(checked(ip + instruction.TokenI8_1)))	×
116	throw new BadScriptException($"ip: {ip}, opcode: {instruction.OpCode}");	×
117	break;	×
118	case OpCode.TRY_L:
UNCOV 119	if (!_instructions.ContainsKey(checked(ip + instruction.TokenI32)))	×
120	throw new BadScriptException($"ip: {ip}, opcode: {instruction.OpCode}");	×
121	if (!_instructions.ContainsKey(checked(ip + instruction.TokenI32_1)))	×
122	throw new BadScriptException($"ip: {ip}, opcode: {instruction.OpCode}");	×
123	break;	×
124	case OpCode.NEWARRAY_T:
125	case OpCode.ISTYPE:
126	case OpCode.CONVERT:
127	StackItemType type = (StackItemType)instruction.TokenU8;	4✔
128	if (!Enum.IsDefined(typeof(StackItemType), type))	4!
UNCOV 129	throw new BadScriptException();	×
130	if (instruction.OpCode != OpCode.NEWARRAY_T && type == StackItemType.Any)	4!
UNCOV 131	throw new BadScriptException($"ip: {ip}, opcode: {instruction.OpCode}");	×
132	break;	4✔
133	}
134	}	2,213✔
135	}	67✔
136	this.strictMode = strictMode;	1,745✔
137	}	1,745✔
138
139	/// <summary>
140	/// Get the <see cref="Instruction"/> at the specified position.
141	/// </summary>
142	/// <param name="ip">The position to get the <see cref="Instruction"/>.</param>
143	/// <returns>The <see cref="Instruction"/> at the specified position.</returns>
144	/// <exception cref="ArgumentException">In strict mode, the <see cref="Instruction"/> was not found at the specified position.</exception>
145	public Instruction GetInstruction(int ip)
146	{	189,817✔
147	if (ip >= Length) throw new ArgumentOutOfRangeException(nameof(ip));	189,818✔
148	if (!_instructions.TryGetValue(ip, out Instruction? instruction))	189,816✔
149	{	19,820✔
150	if (strictMode) throw new ArgumentException($"ip not found with strict mode", nameof(ip));	19,820!
151	instruction = new Instruction(_value, ip);	19,820✔
152	_instructions.Add(ip, instruction);	19,806✔
153	}	19,806✔
154	return instruction;	189,802✔
155	}	189,802✔
156
157	public static implicit operator ReadOnlyMemory<byte>(Script script) => script._value;	1,158✔
158	public static implicit operator Script(ReadOnlyMemory<byte> script) => new(script);	621✔
159	public static implicit operator Script(byte[] script) => new(script);	1,049✔
160	}
161	}

neo-project / neo / 11312961858

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous