Rename opcodes

Author: antonmedv

compiler/compiler.go

@@ -196,19 +196,19 @@ func (c *compiler) NilNode(_ *ast.NilNode) {
 
 func (c *compiler) IdentifierNode(node *ast.IdentifierNode) {
 	if c.mapEnv {
-		c.emit(OpFetchEnvFast, c.addConstant(node.Value))
+		c.emit(OpEnvFast, c.addConstant(node.Value))
 	} else if len(node.FieldIndex) > 0 {
-		c.emit(OpFetchEnvField, c.addConstant(&runtime.Field{
+		c.emit(OpEnvField, c.addConstant(&runtime.Field{
 			Index: node.FieldIndex,
 			Path:  []string{node.Value},
 		}))
 	} else if node.Method {
-		c.emit(OpMethodEnv, c.addConstant(&runtime.Method{
+		c.emit(OpEnvMethod, c.addConstant(&runtime.Method{
 			Name:  node.Value,
 			Index: node.MethodIndex,
 		}))
 	} else {
-		c.emit(OpFetchEnv, c.addConstant(node.Value))
+		c.emit(OpEnvConst, c.addConstant(node.Value))
 	}
 	if node.Deref {
 		c.emit(OpDeref)
@@ -454,7 +454,7 @@ func (c *compiler) MemberNode(node *ast.MemberNode) {
 				}
 				index = append(ident.FieldIndex, index...)
 				path = append([]string{ident.Value}, path...)
-				c.emitLocation(ident.Location(), OpFetchEnvField, c.addConstant(
+				c.emitLocation(ident.Location(), OpEnvField, c.addConstant(
 					&runtime.Field{Index: index, Path: path},
 				))
 				goto deref

compiler/compiler_test.go

@@ -159,7 +159,7 @@ func TestCompile(t *testing.T) {
 					},
 				},
 				Bytecode: []vm.Opcode{
-					vm.OpFetchEnvField,
+					vm.OpEnvField,
 				},
 				Arguments: []int{0},
 			},
@@ -178,7 +178,7 @@ func TestCompile(t *testing.T) {
 					},
 				},
 				Bytecode: []vm.Opcode{
-					vm.OpFetchEnvField,
+					vm.OpEnvField,
 					vm.OpJumpIfNil,
 					vm.OpFetchField,
 				},
@@ -199,7 +199,7 @@ func TestCompile(t *testing.T) {
 					},
 				},
 				Bytecode: []vm.Opcode{
-					vm.OpFetchEnvField,
+					vm.OpEnvField,
 					vm.OpJumpIfNil,
 					vm.OpFetchField,
 				},
@@ -221,7 +221,7 @@ func TestCompile(t *testing.T) {
 					},
 				},
 				Bytecode: []vm.Opcode{
-					vm.OpFetchEnvField,
+					vm.OpEnvField,
 					vm.OpPush,
 					vm.OpFetch,
 					vm.OpFetchField,

vm/opcodes.go

@@ -7,13 +7,13 @@ const (
 	OpPushInt
 	OpPop
 	OpRot
+	OpEnvConst
+	OpEnvField
+	OpEnvFast
+	OpEnvMethod
 	OpFetch
 	OpFetchField
-	OpFetchEnv
-	OpFetchEnvField
-	OpFetchEnvFast
 	OpMethod
-	OpMethodEnv
 	OpTrue
 	OpFalse
 	OpNil

vm/program.go

@@ -72,27 +72,27 @@ func (program *Program) Disassemble() string {
 		case OpRot:
 			code("OpRot")
 
+		case OpEnvConst:
+			constant("OpEnvConst")
+
+		case OpEnvField:
+			constant("OpEnvField")
+
+		case OpEnvFast:
+			constant("OpEnvFast")
+
+		case OpEnvMethod:
+			constant("OpEnvMethod")
+
 		case OpFetch:
 			code("OpFetch")
 
 		case OpFetchField:
 			constant("OpFetchField")
 
-		case OpFetchEnv:
-			constant("OpFetchEnv")
-
-		case OpFetchEnvField:
-			constant("OpFetchEnvField")
-
-		case OpFetchEnvFast:
-			constant("OpFetchEnvFast")
-
 		case OpMethod:
 			constant("OpMethod")
 
-		case OpMethodEnv:
-			constant("OpMethodEnv")
-
 		case OpTrue:
 			code("OpTrue")
 

vm/vm.go

@@ -100,6 +100,18 @@ func (vm *VM) Run(program *Program, env interface{}) (out interface{}, err error
 			vm.push(b)
 			vm.push(a)
 
+		case OpEnvConst:
+			vm.push(runtime.Fetch(env, program.Constants[arg]))
+
+		case OpEnvField:
+			vm.push(runtime.FetchField(env, program.Constants[arg].(*runtime.Field)))
+
+		case OpEnvFast:
+			vm.push(env.(map[string]interface{})[program.Constants[arg].(string)])
+
+		case OpEnvMethod:
+			vm.push(runtime.FetchMethod(env, program.Constants[arg].(*runtime.Method)))
+
 		case OpFetch:
 			b := vm.pop()
 			a := vm.pop()
@@ -109,22 +121,10 @@ func (vm *VM) Run(program *Program, env interface{}) (out interface{}, err error
 			a := vm.pop()
 			vm.push(runtime.FetchField(a, program.Constants[arg].(*runtime.Field)))
 
-		case OpFetchEnv:
-			vm.push(runtime.Fetch(env, program.Constants[arg]))
-
-		case OpFetchEnvField:
-			vm.push(runtime.FetchField(env, program.Constants[arg].(*runtime.Field)))
-
-		case OpFetchEnvFast:
-			vm.push(env.(map[string]interface{})[program.Constants[arg].(string)])
-
 		case OpMethod:
 			a := vm.pop()
 			vm.push(runtime.FetchMethod(a, program.Constants[arg].(*runtime.Method)))
 
-		case OpMethodEnv:
-			vm.push(runtime.FetchMethod(env, program.Constants[arg].(*runtime.Method)))
-
 		case OpTrue:
 			vm.push(true)