Lines Matching refs:Rust
50 DSL compiler will convert this list of patterns into efficient Rust
56 generate a decision tree in Rust that can call into arbitrary
76 * ISLE with Rust: covers how ISLE provides an "FFI" (foreign function
77 interface) of sorts to allow interaction with Rust code, and
78 describes the scheme by which ISLE execution is mapped onto Rust
83 combined into executable Rust code that efficiently traverses the
86 [^1]: One might call this the BRIDGE (Basic Rust Interface Designed
388 separate Rust functions, so factoring rules to use intermediate
390 ISLE-generated Rust code as well.
473 integration with Rust, including a well-defined "FFI" mapping that
474 allows ISLE rules to call into Rust in both their patterns and
476 surrounding Rust code. This allows for easy and direct embedding into
478 next section, [ISLE to Rust](#isle-to-rust).
569 can be integers or symbolic constants (imported from the Rust
570 embedding), and *enums*, which correspond directly to Rust enums with
577 ;; spelled `u32` in the generated Rust code.
589 ;; generated Rust, but rather, assumed to exist
651 compilation-to-Rust strategy: every constructor actually does evaluate
652 to a Rust value of the given "return value" type, given actual Rust
848 external extractors, which are defined in Rust; we will discuss this
987 constructors return `Option<T>` at the Rust level and can return
1007 to arbitrary Rust code and have side-effects. So, we add a new
1022 a pure term is a promise by the ISLE programmer that the external Rust
1094 ## ISLE to Rust
1097 how it interacts with Rust code. We consider these interactions to be
1102 ### Mapping to Rust: Constructors, Functions, and Control Flow argument
1105 its language semantics to Rust semantics. This means that the
1107 Rust. The basic principles are:
1109 1. Every term with rules in ISLE becomes a single Rust function. The
1110 arguments are the Rust function arguments. The term's "return
1111 value" is the Rust function's return value (wrapped in an `Option`
1114 2. One rewrite step is one Rust function call.
1116 3. Rewriting is thus eager, and reified through ordinary Rust control
1131 stack-frames while the corresponding Rust function executes. This
1134 overhead and/or the effectiveness of the Rust inliner).
1138 internal to the generated Rust function for rewriting one
1151 respect to external Rust actions) easier.
1153 This will become more clear as we look at how Rust interfaces are
1158 ISLE programs interact with the surrounding Rust code in which they
1170 of Rust function calls rather than plain data.
1177 further rewriting rules results in a Rust function call to the body of
1196 which means that there is a Rust function `ctor_func` on the context
1206 invoking external Rust code, that behavior should occur in an extractor
1217 a Rust function with the value of the term to be deconstructed, and
1234 which means that there is a Rust function `etor_func` on the context
1242 ### Mapping Type Declarations to Rust argument
1252 ISLE will generate the Rust type definition
1377 that corresponds to the final Rust code's control flow and order of
1381 understanding of how the DSL compiler weaves rules together into Rust
1398 used to generate Rust source.
1430 various edges; we can use a Rust `match` statement in the generated