package edgir.expr

Get desktop application:
View/edit binary Protocol Buffers messages

* Creates an array from element exprs

Used in: ValueExpr

• repeated ValueExpr vals = 1

Variable assignment (from an expression value), which allows dataflow to be directioned and explicit. Assignments should not be cyclic.

Used in: ValueExpr

• optional ref.LocalPath dst = 1

• optional ValueExpr src = 2

Used in: ValueExpr

• BinaryExpr.Op op = 1

• optional ValueExpr lhs = 2

• optional ValueExpr rhs = 3

Used in: BinaryExpr

• UNDEFINED = 0

• ADD = 10

  * Add :: Numeric a => (lhs :: a, rhs :: a) -> a :: Numeric a => (lhs :: a, rhs :: Range a) -> Range a :: Numeric a => (lhs :: Range a, rhs :: a) -> Range a :: Numeric a => (lhs :: Range a, rhs :: Range a) -> Range a

• SHRINK_SUB = 56

  SUB = 11; // Use ADD and NEGATE instead A span-shrinking subtract operation for two Range types. See the documentation for shrink_sub in the Python core HDL code for details.

• MULT = 12

  * Mult :: Numeric a => (lhs :: a, rhs :: a) -> a :: Numeric a => (lhs :: a, rhs :: Range a) -> Range a :: Numeric a => (lhs :: Range a, rhs :: a) -> Range a :: Numeric a => (lhs :: Range a, rhs :: Range a) -> Range a

• SHRINK_MULT = 55

  A shrinking multiply operation for two Range types. Not commutative. See the documentation for shrink_multiply in the Python core HDL code for details.

• AND = 20

  * And :: (lhs :: Bool, rhs :: Bool) -> Bool

• OR = 21

  * Or :: (lhs :: Bool, rhs :: Bool) -> Bool

• XOR = 22

  * Xor :: (lhs :: Bool, rhs :: Bool) -> Bool

• IMPLIES = 23

  * Implies :: (lhs :: Bool, rhs :: Bool) -> Bool

• EQ = 30

  * Eq :: (Equality a) => (lhs :: a, rhs :: a) -> Bool

• NEQ = 31

  * Neq :: (Equality a) => (lhs :: a, rhs : a) -> Bool

• GT = 40

  * GT :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool

• GTE = 41

  * GTE :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool

• LT = 42

  * LT :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool

• LTE = 44

  * LTE :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool

• MAX = 45

  * Max :: (Comparable a) => (lhs :: a, rhs :: a) -> a

• MIN = 46

  * Min :: (Comparable a) => (lhs :: a, rhs :: a) -> a

• INTERSECTION = 51

  * Intersection :: (Numeric a) => (lhs : Range a, rhs : Range a) -> Range a

• HULL = 54

  * Hull :: (lhs :: Range a, rhs :: Range a) -> Range a Given two input ranges, returns the convex hull (union with all the inner missing bits filled in)

• WITHIN = 53

  * Within :: (Numeric a) => (lhs :: Range a, rhs :: Range a) -> Bool :: (Numeric a) => (lhs :: a, rhs :: Range a) -> Bool Whether the lhs range or point is entirely within (contained by) the rhs. Used to be named SUBSET changed to a name that doesn't also imply a set op.

• RANGE = 1

  * Range :: (Comparable a) => (lower :: a, upper :: a) -> Range a

Used in: ValueExpr

• BinarySetExpr.Op op = 1

• optional ValueExpr lhset = 2

• optional ValueExpr rhs = 3

Used in: BinarySetExpr

• UNDEFINED = 0

• ADD = 10

  * Add :: Numeric a => (lhset : Set a, rhs : a) -> Set a :: Numeric a => (lhset : Set a, rhs : Range a) -> Set (Range a) :: Numeric a => (lhset : Set (Range a), rhs : a) -> Set (Range a) :: Numeric a => (lhset : Set (Range a), rhs : Range a) -> Set (Range a)

• MULT = 12

  * Mult :: Numeric a => (lhset : Set a, rhs : a) -> Set a :: Numeric a => (lhset : Set a, rhs : Range a) -> Set (Range a) :: Numeric a => (lhset : Set (Range a), rhs : a) -> Set (Range a) :: Numeric a => (lhset : Set (Range a), rhs : Range a) -> Set (Range a)

• CONCAT = 20

  String concatenate operator Concatenate : (lhs: String, rhss: Set[String]) -> Set[String] (prepend lhs to all elements) : (lhss: Set[String], rhs: String) -> Set[String] (append rhs to all elements)

• EQ = 30

  Equality operator (lhss: Set[A], elt: A) -> Set[Bool] (pointwise equality of all elements in the set to the element)

* isConnected :: Port -> Port -> Bool This tells us whether the specified ports are connected

Used in: ValueExpr

• optional ValueExpr block_port = 1

• optional ValueExpr link_port = 2

• repeated ConnectedExpr expanded = 3

  During compilation, ConnectedExpr may be expanded (allocate replaced with concrete path indices, and arrays replaced with individual element connects). The expanded forms are stored here (including multiple elements in the array case), while the original (parent) is not modified.

* isExported :: Port -> Port -> Bool This tells us whether the specified port is exported to the hierarchy block exterior port

Used in: ValueExpr

• optional ValueExpr exterior_port = 1

• optional ValueExpr internal_block_port = 2

• bool tap = 4

  if true, this is a tap, which allows the exterior port to have multiple internal connections

• repeated ExportedExpr expanded = 3

  see comment in ConnectedExpr

* Extract :: (container :: Array a , index :: Int) -> a Extract :: (container :: Struct{index :: a}, index :: string) -> a Extract :: (container :: Range a , index :: {"minimum"|"maximum"}) -> a

Used in: ValueExpr

• optional ValueExpr container = 1

• optional ValueExpr index = 2

* IfThenElse :: (cond :: Bool, tru :: a, fal :: a) -> a

Used in: ValueExpr

• optional ValueExpr cond = 1

• optional ValueExpr tru = 2

• optional ValueExpr fal = 3

• optional common.Metadata meta = 127

/** MapExtract :: (container :: Array a , path :: LocalRef{from :: a, to :: b}) -> Array b MapExtract :: (container :: Set a , path :: LocalRef{from :: a, to :: b}) -> Set b This expression can map over a container and return a container of the relevant subexpression determined by a path. */

Used in: ValueExpr

• optional ValueExpr container = 1

• optional ref.LocalPath path = 2

* Ranges have an expression form, allowing you to constrain them without specifying them fully

Used in: ValueExpr

• optional ValueExpr minimum = 1

• optional ValueExpr maximum = 2

* Structs have an expression form, allowing you to constrain them without specifying them fully

Used in: ValueExpr

• map<string, ValueExpr> vals = 1

Used in: ValueExpr

• UnaryExpr.Op op = 1

• optional ValueExpr val = 2

Used in: UnaryExpr

• UNDEFINED = 0

• NEGATE = 1

  * Negate :: Numeric a => a -> a :: Numeric a => Range a -> Range a

• NOT = 2

  * Not :: Bool -> Bool

• INVERT = 3

  * Invert :: Float -> Float :: Range Float -> Range Float

• MIN = 4

  * Min :: Range a -> a

• MAX = 5

  * Max :: Range a -> a

• CENTER = 6

  * Center :: Range a -> a

• WIDTH = 7

  * Width :: Range a -> a

Used in: ValueExpr

• UnarySetExpr.Op op = 1

• optional ValueExpr vals = 4

• optional ValueExpr empty_value = 5

  value returned on an empty set, especially for reductions

Used in: UnarySetExpr

• UNDEFINED = 0

• SUM = 1

  * Sum :: (Numeric a) => Set a -> a :: (Numeric a) => Set (Range a) -> Range a Sum({}) = 0

• ALL_TRUE = 2

  * All :: Set Bool -> Bool All inputs are true All({}) = True

• ANY_TRUE = 3

  * Any :: Set Bool -> Bool Any of the inputs are true Any({}) = False

• ALL_EQ = 4

  * AllEq :: (Equality a) => Set a -> Bool AllEq({}) = True

• ALL_UNIQUE = 5

  * AllUnique :: (Equality a) => Set a -> Bool AllUnique(EmptySet) = True

• MAXIMUM = 10

  * Maximum :: (Ordered a) => Set a -> a This op requires that the non-emptyness of the relevant set is assured before being valid.

• MINIMUM = 11

  * Minimum :: (Ordered a) => Set a -> a This op requires that the non-emptyness of the relevant set is assured before being valid.

• SET_EXTRACT = 12

  * SetExtract :: Set a -> a This op requires that the non-emptyness of the relevant set is assured before being valid. In addition this assumes all values in the set are equal.

• INTERSECTION = 13

  * Intersection :: Set (Range a) -> Range a May produce an empty range. Intersection({}) = [-inf, +inf]

• HULL = 14

  * Hull :: Set (Range a) -> Range a Returns the convex hull (union with all the inner missing bits filled in) Hull({}) = EmptyRange

• NEGATE = 20

  * Negate :: Numeric a => Set a -> Set a :: Numeric a => Set (Range a) -> Set (Range a) Pointwise negate

• INVERT = 21

  * Invert :: Set Float -> Set Float :: Set (Range Float) -> Set (Range Float) Pointwise Invert

• FLATTEN = 30

  Flatten[A] : Set[Set[A]] -> Set[A] Given an array of array of elements, flattens the inner array. Alternatively stated, concatenates all of the elements of the outer arrary

Used in: elem.HierarchyBlock, elem.NamedValueExpr, ArrayExpr, AssignExpr, BinaryExpr, BinarySetExpr, ConnectedExpr, ExportedExpr, ExtractExpr, IfThenElseExpr, MapExtractExpr, RangeExpr, StructExpr, UnaryExpr, UnarySetExpr

• oneof expr

  • lit.ValueLit literal = 1

  • BinaryExpr binary = 2

  • BinarySetExpr binary_set = 18

  • UnaryExpr unary = 3

  • UnarySetExpr unary_set = 4

  • ArrayExpr array = 6

    SetExpr set = 5;

  • StructExpr struct = 7

  • RangeExpr range = 8

  • IfThenElseExpr ifThenElse = 10

  • ExtractExpr extract = 12

  • MapExtractExpr map_extract = 14

  • ConnectedExpr connected = 15

    single port to single port connect

  • ExportedExpr exported = 16

    single port to single port export

  • ConnectedExpr connectedArray = 19

    array to array connect, where allocate means allocate a subarray

  • ExportedExpr exportedArray = 20

    array to array export, where allocate means allocate a subarray

  • AssignExpr assign = 17

  • ExportedExpr exportedTunnel = 21

    These Exprs support cross-hierarchy operations

    single port to single port tunneling (cross-hierarchy) export:

  • AssignExpr assignTunnel = 22

    parameter assignment which may be cross-hierarchy

  • ref.LocalPath ref = 99

• optional common.Metadata meta = 127