api/semantic/expression.go - platform/tools/gpu - Git at Google

 // Copyright (C) 2014 The Android Open Source Project
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 package semantic

 import "android.googlesource.com/platform/tools/gpu/api/ast"

 // Select is the expression form of a switch.
 type Select struct {
 	AST     *ast.Switch // the underlying syntax node this was built from
 	Type    Type        // the return type of the select if valid
 	Value   Expression  // the value to match the cases against
 	Choices []*Choice   // The set of possible choices to match
 	Default *Expression // the expression to use if no condition matches
 }

 // ExpressionType implements Expression with the unified type of the choices
 func (s *Select) ExpressionType() Type { return s.Type }

 // Choice represents a possible choice in a select
 type Choice struct {
 	AST        *ast.Case    // the underlying syntax node this was built from
 	Conditions []Expression // the set of expressions to match the select value against
 	Expression Expression   // the expression to use if a condition matches
 }

 // Local represents an immutable local storage slot, created by a DeclareLocal,
 // and referred to by identifiers that resolve to that slot.
 type Local struct {
 	Declaration *DeclareLocal // the statement that created the local
 	Type        Type          // the type of the storage
 	Named                     // the identifier that will resolve to this local
 	Value       Expression    // the expression the local was assigned on creation
 }

 // ExpressionType implements Expression
 func (l *Local) ExpressionType() Type { return l.Type }

 // UnaryOp represents an operator applied to a single expression.
 // It's type depends on the operator and the type of the expression it is
 // being applied to.
 type UnaryOp struct {
 	AST        *ast.UnaryOp // the underlying syntax node this was built from
 	Type       Type         // the resolved type of the operation
 	Operator   string       // the operator being applied
 	Expression Expression   // the expression to apply the operator to
 }

 // ExpressionType implements Expression
 func (b *UnaryOp) ExpressionType() Type { return b.Type }

 // BinaryOp represents any operator applied to two arguments.
 // The resolved type of the expression depends on the types of the two
 // arguments and which operator it represents.
 type BinaryOp struct {
 	AST      *ast.BinaryOp // the underlying syntax node this was built from
 	Type     Type          // the resolved type of this binary expression
 	LHS      Expression    // the expression that appears on the left of the operator
 	Operator string        // the operator being applied
 	RHS      Expression    // the expression that appears on the right of the operator
 }

 // ExpressionType implements Expression
 func (b *BinaryOp) ExpressionType() Type { return b.Type }

 // BitTest is the "in" operator applied to a bitfield.
 type BitTest struct {
 	AST      *ast.BinaryOp // the underlying syntax node this was built from
 	Bitfield Expression    // the bitfield being tested
 	Bits     Expression    // the bits to test for
 }

 // ExpressionType implements Expression
 func (BitTest) ExpressionType() Type { return BoolType }

 // MapContains is the "in" operator applied to a map.
 type MapContains struct {
 	AST *ast.BinaryOp // the underlying syntax node this was built from
 	Map Expression    // the map being tested
 	Key Expression    // the key to test for
 }

 // ExpressionType implements Expression
 func (MapContains) ExpressionType() Type { return BoolType }

 // Member is an expression that looks up a field by name from an object.
 type Member struct {
 	AST    *ast.Member // the underlying syntax node this was built from
 	Object Expression  // the object to look up a field of
 	Field  *Field      // the field to look up
 }

 // ExpressionType implements Expression returning the type of the field.
 func (m *Member) ExpressionType() Type { return m.Field.Type }

 // PointerRange represents using the indexing operator on a pointer type with a
 // range expression.
 type PointerRange struct {
 	AST     *ast.Index // the underlying syntax node this was built from
 	Type    *Slice     // the slice type returned.
 	Pointer Expression // the expression that returns the pointer to be indexed
 	Range   *BinaryOp  // the range to use on the slice
 }

 // ExpressionType implements Expression.
 // It returns the same slice type being sliced.
 func (i *PointerRange) ExpressionType() Type { return i.Type }

 // SliceRange represents using the indexing operator on a slice type with a
 // range expression.
 type SliceRange struct {
 	AST   *ast.Index // the underlying syntax node this was built from
 	Type  *Slice     // the slice type
 	Slice Expression // the expression that returns the slice to be indexed
 	Range *BinaryOp  // the range to use on the slice
 }

 // ExpressionType implements Expression.
 // It returns the same slice type being sliced.
 func (i *SliceRange) ExpressionType() Type { return i.Type }

 // ArrayIndex represents using the indexing operator on a static-array type.
 type ArrayIndex struct {
 	AST   *ast.Index   // the underlying syntax node this was built from
 	Type  *StaticArray // the array type
 	Array Expression   // the expression that returns the array to be indexed
 	Index Expression   // the index to use on the array
 }

 // ExpressionType implements Expression.
 // It returns the element type of the array.
 func (i *ArrayIndex) ExpressionType() Type { return i.Type.ValueType }

 // SliceIndex represents using the indexing operator on a slice type.
 type SliceIndex struct {
 	AST   *ast.Index // the underlying syntax node this was built from
 	Type  *Slice     // the slice type
 	Slice Expression // the expression that returns the slice to be indexed
 	Index Expression // the index to use on the slice
 }

 // ExpressionType implements Expression.
 // It returns the value type of the slice.
 func (i *SliceIndex) ExpressionType() Type { return i.Type.To }

 // MapIndex represents using the indexing operator on a map type.
 type MapIndex struct {
 	AST   *ast.Index // the underlying syntax node this was built from
 	Type  *Map       // the value type of the map being indexed
 	Map   Expression // the expression that returns the map to be indexed
 	Index Expression // the index to use on the map
 }

 // ExpressionType implements Expression returning the value type of the map.
 func (i *MapIndex) ExpressionType() Type { return i.Type.ValueType }

 // Unknown represents a value that cannot be predicted.
 // These values are non-deterministic with regard to the API specification and
 // may vary between implementations of the API.
 type Unknown struct {
 	AST      *ast.Unknown // the underlying syntax node this was built from
 	Inferred Expression   // the inferred expression to derive the unknown from the outputs
 }

 // ExpressionType implements Expression with the inferred type of the unknown.
 // If the unknown could not be inferred, it will be of type "any" so allow
 // expressions using it to resolve anyway.
 func (u Unknown) ExpressionType() Type {
 	if u.Inferred == nil {
 		return AnyType
 	}
 	return u.Inferred.ExpressionType()
 }

 // Ignore represents an _ expression.
 type Ignore struct {
 	AST ast.Node // the underlying syntax node this was built from
 }

 // ExpressionType implements Expression.
 func (i Ignore) ExpressionType() Type {
 	return AnyType
 }

 // Null represents a default value.
 type Null struct {
 	AST  *ast.Null // the underlying syntax node this was built from
 	Type Type      // the resolved type of this null
 }

 // ExpressionType implements Expression with the inferred type of the null.
 func (n Null) ExpressionType() Type {
 	return n.Type
 }

 // Int8Value is an int8 that implements Expression so it can be in the semantic graph
 type Int8Value int8

 // ExpressionType implements Expression with a type of Int8Type
 func (v Int8Value) ExpressionType() Type { return Int8Type }

 // Uint8Value is a uint8 that implements Expression so it can be in the semantic graph
 type Uint8Value uint8

 // ExpressionType implements Expression with a type of Uint8Type
 func (v Uint8Value) ExpressionType() Type { return Uint8Type }

 // Int16Value is an int16 that implements Expression so it can be in the semantic graph
 type Int16Value int16

 // ExpressionType implements Expression with a type of Int16Type
 func (v Int16Value) ExpressionType() Type { return Int16Type }

 // Uint16Value is a uint16 that implements Expression so it can be in the semantic graph
 type Uint16Value uint16

 // ExpressionType implements Expression with a type of Uint16Type
 func (v Uint16Value) ExpressionType() Type { return Uint16Type }

 // Int32Value is an int32 that implements Expression so it can be in the semantic graph
 type Int32Value int32

 // ExpressionType implements Expression with a type of Int32Type
 func (v Int32Value) ExpressionType() Type { return Int32Type }

 // Uint32Value is a uint32 that implements Expression so it can be in the semantic graph
 type Uint32Value uint32

 // ExpressionType implements Expression with a type of Uint32Type
 func (v Uint32Value) ExpressionType() Type { return Uint32Type }

 // Int64Value is an int64 that implements Expression so it can be in the semantic graph
 type Int64Value int64

 // ExpressionType implements Expression with a type of Int64Type
 func (v Int64Value) ExpressionType() Type { return Int64Type }

 // Uint64Value is a uint64 that implements Expression so it can be in the semantic graph
 type Uint64Value uint64

 // ExpressionType implements Expression with a type of Uint64Type
 func (v Uint64Value) ExpressionType() Type { return Uint64Type }

 // BoolValue is a bool that implements Expression so it can be in the semantic graph
 type BoolValue bool

 // ExpressionType implements Expression with a type of BoolType
 func (v BoolValue) ExpressionType() Type { return BoolType }

 // StringValue is a string that implements Expression so it can be in the semantic graph
 type StringValue string

 // ExpressionType implements Expression with a type of StringType
 func (v StringValue) ExpressionType() Type { return StringType }

 // Float64Value is a float64 that implements Expression so it can be in the semantic graph
 type Float64Value float64

 // ExpressionType implements Expression with a type of Float64Type
 func (v Float64Value) ExpressionType() Type { return Float64Type }

 // Float32Value is a float32 that implements Expression so it can be in the semantic graph
 type Float32Value float32

 // ExpressionType implements Expression with a type of Float32Type
 func (v Float32Value) ExpressionType() Type { return Float32Type }
	// Copyright (C) 2014 The Android Open Source Project
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	package semantic

	import "android.googlesource.com/platform/tools/gpu/api/ast"

	// Select is the expression form of a switch.
	type Select struct {
	AST *ast.Switch // the underlying syntax node this was built from
	Type Type // the return type of the select if valid
	Value Expression // the value to match the cases against
	Choices []*Choice // The set of possible choices to match
	Default *Expression // the expression to use if no condition matches
	}

	// ExpressionType implements Expression with the unified type of the choices
	func (s *Select) ExpressionType() Type { return s.Type }

	// Choice represents a possible choice in a select
	type Choice struct {
	AST *ast.Case // the underlying syntax node this was built from
	Conditions []Expression // the set of expressions to match the select value against
	Expression Expression // the expression to use if a condition matches
	}

	// Local represents an immutable local storage slot, created by a DeclareLocal,
	// and referred to by identifiers that resolve to that slot.
	type Local struct {
	Declaration *DeclareLocal // the statement that created the local
	Type Type // the type of the storage
	Named // the identifier that will resolve to this local
	Value Expression // the expression the local was assigned on creation
	}

	// ExpressionType implements Expression
	func (l *Local) ExpressionType() Type { return l.Type }

	// UnaryOp represents an operator applied to a single expression.
	// It's type depends on the operator and the type of the expression it is
	// being applied to.
	type UnaryOp struct {
	AST *ast.UnaryOp // the underlying syntax node this was built from
	Type Type // the resolved type of the operation
	Operator string // the operator being applied
	Expression Expression // the expression to apply the operator to
	}

	// ExpressionType implements Expression
	func (b *UnaryOp) ExpressionType() Type { return b.Type }

	// BinaryOp represents any operator applied to two arguments.
	// The resolved type of the expression depends on the types of the two
	// arguments and which operator it represents.
	type BinaryOp struct {
	AST *ast.BinaryOp // the underlying syntax node this was built from
	Type Type // the resolved type of this binary expression
	LHS Expression // the expression that appears on the left of the operator
	Operator string // the operator being applied
	RHS Expression // the expression that appears on the right of the operator
	}

	// ExpressionType implements Expression
	func (b *BinaryOp) ExpressionType() Type { return b.Type }

	// BitTest is the "in" operator applied to a bitfield.
	type BitTest struct {
	AST *ast.BinaryOp // the underlying syntax node this was built from
	Bitfield Expression // the bitfield being tested
	Bits Expression // the bits to test for
	}

	// ExpressionType implements Expression
	func (BitTest) ExpressionType() Type { return BoolType }

	// MapContains is the "in" operator applied to a map.
	type MapContains struct {
	AST *ast.BinaryOp // the underlying syntax node this was built from
	Map Expression // the map being tested
	Key Expression // the key to test for
	}

	// ExpressionType implements Expression
	func (MapContains) ExpressionType() Type { return BoolType }

	// Member is an expression that looks up a field by name from an object.
	type Member struct {
	AST *ast.Member // the underlying syntax node this was built from
	Object Expression // the object to look up a field of
	Field *Field // the field to look up
	}

	// ExpressionType implements Expression returning the type of the field.
	func (m *Member) ExpressionType() Type { return m.Field.Type }

	// PointerRange represents using the indexing operator on a pointer type with a
	// range expression.
	type PointerRange struct {
	AST *ast.Index // the underlying syntax node this was built from
	Type *Slice // the slice type returned.
	Pointer Expression // the expression that returns the pointer to be indexed
	Range *BinaryOp // the range to use on the slice
	}

	// ExpressionType implements Expression.
	// It returns the same slice type being sliced.
	func (i *PointerRange) ExpressionType() Type { return i.Type }

	// SliceRange represents using the indexing operator on a slice type with a
	// range expression.
	type SliceRange struct {
	AST *ast.Index // the underlying syntax node this was built from
	Type *Slice // the slice type
	Slice Expression // the expression that returns the slice to be indexed
	Range *BinaryOp // the range to use on the slice
	}

	// ExpressionType implements Expression.
	// It returns the same slice type being sliced.
	func (i *SliceRange) ExpressionType() Type { return i.Type }

	// ArrayIndex represents using the indexing operator on a static-array type.
	type ArrayIndex struct {
	AST *ast.Index // the underlying syntax node this was built from
	Type *StaticArray // the array type
	Array Expression // the expression that returns the array to be indexed
	Index Expression // the index to use on the array
	}

	// ExpressionType implements Expression.
	// It returns the element type of the array.
	func (i *ArrayIndex) ExpressionType() Type { return i.Type.ValueType }

	// SliceIndex represents using the indexing operator on a slice type.
	type SliceIndex struct {
	AST *ast.Index // the underlying syntax node this was built from
	Type *Slice // the slice type
	Slice Expression // the expression that returns the slice to be indexed
	Index Expression // the index to use on the slice
	}

	// ExpressionType implements Expression.
	// It returns the value type of the slice.
	func (i *SliceIndex) ExpressionType() Type { return i.Type.To }

	// MapIndex represents using the indexing operator on a map type.
	type MapIndex struct {
	AST *ast.Index // the underlying syntax node this was built from
	Type *Map // the value type of the map being indexed
	Map Expression // the expression that returns the map to be indexed
	Index Expression // the index to use on the map
	}

	// ExpressionType implements Expression returning the value type of the map.
	func (i *MapIndex) ExpressionType() Type { return i.Type.ValueType }

	// Unknown represents a value that cannot be predicted.
	// These values are non-deterministic with regard to the API specification and
	// may vary between implementations of the API.
	type Unknown struct {
	AST *ast.Unknown // the underlying syntax node this was built from
	Inferred Expression // the inferred expression to derive the unknown from the outputs
	}

	// ExpressionType implements Expression with the inferred type of the unknown.
	// If the unknown could not be inferred, it will be of type "any" so allow
	// expressions using it to resolve anyway.
	func (u Unknown) ExpressionType() Type {
	if u.Inferred == nil {
	return AnyType
	}
	return u.Inferred.ExpressionType()
	}

	// Ignore represents an _ expression.
	type Ignore struct {
	AST ast.Node // the underlying syntax node this was built from
	}

	// ExpressionType implements Expression.
	func (i Ignore) ExpressionType() Type {
	return AnyType
	}

	// Null represents a default value.
	type Null struct {
	AST *ast.Null // the underlying syntax node this was built from
	Type Type // the resolved type of this null
	}

	// ExpressionType implements Expression with the inferred type of the null.
	func (n Null) ExpressionType() Type {
	return n.Type
	}

	// Int8Value is an int8 that implements Expression so it can be in the semantic graph
	type Int8Value int8

	// ExpressionType implements Expression with a type of Int8Type
	func (v Int8Value) ExpressionType() Type { return Int8Type }

	// Uint8Value is a uint8 that implements Expression so it can be in the semantic graph
	type Uint8Value uint8

	// ExpressionType implements Expression with a type of Uint8Type
	func (v Uint8Value) ExpressionType() Type { return Uint8Type }

	// Int16Value is an int16 that implements Expression so it can be in the semantic graph
	type Int16Value int16

	// ExpressionType implements Expression with a type of Int16Type
	func (v Int16Value) ExpressionType() Type { return Int16Type }

	// Uint16Value is a uint16 that implements Expression so it can be in the semantic graph
	type Uint16Value uint16

	// ExpressionType implements Expression with a type of Uint16Type
	func (v Uint16Value) ExpressionType() Type { return Uint16Type }

	// Int32Value is an int32 that implements Expression so it can be in the semantic graph
	type Int32Value int32

	// ExpressionType implements Expression with a type of Int32Type
	func (v Int32Value) ExpressionType() Type { return Int32Type }

	// Uint32Value is a uint32 that implements Expression so it can be in the semantic graph
	type Uint32Value uint32

	// ExpressionType implements Expression with a type of Uint32Type
	func (v Uint32Value) ExpressionType() Type { return Uint32Type }

	// Int64Value is an int64 that implements Expression so it can be in the semantic graph
	type Int64Value int64

	// ExpressionType implements Expression with a type of Int64Type
	func (v Int64Value) ExpressionType() Type { return Int64Type }

	// Uint64Value is a uint64 that implements Expression so it can be in the semantic graph
	type Uint64Value uint64

	// ExpressionType implements Expression with a type of Uint64Type
	func (v Uint64Value) ExpressionType() Type { return Uint64Type }

	// BoolValue is a bool that implements Expression so it can be in the semantic graph
	type BoolValue bool

	// ExpressionType implements Expression with a type of BoolType
	func (v BoolValue) ExpressionType() Type { return BoolType }

	// StringValue is a string that implements Expression so it can be in the semantic graph
	type StringValue string

	// ExpressionType implements Expression with a type of StringType
	func (v StringValue) ExpressionType() Type { return StringType }

	// Float64Value is a float64 that implements Expression so it can be in the semantic graph
	type Float64Value float64

	// ExpressionType implements Expression with a type of Float64Type
	func (v Float64Value) ExpressionType() Type { return Float64Type }

	// Float32Value is a float32 that implements Expression so it can be in the semantic graph
	type Float32Value float32

	// ExpressionType implements Expression with a type of Float32Type
	func (v Float32Value) ExpressionType() Type { return Float32Type }