Lines Matching defs:code
2 // Use of this source code is governed by a BSD-style license that can be
31 // bytecodes or native code.
39 // 3) From the nodes we generate either byte codes or native code
41 // the search). The code generation step is described in more
65 // The code generated (whether as byte codes or native code) maintains
77 // which will be presented first. The actual code generated is a more
83 // push backtrack code location
84 // <generate code to test for choice>
85 // backtrack code location:
88 // <generate code to test for last choice>
92 // <generate code to perform action>
93 // push backtrack code location
94 // <generate code to test for following nodes>
95 // backtrack code location:
102 // <generate code to test for following nodes>
112 // the node has already been code generated then the Emit() call will
113 // generate a jump to the previously generated code instead. In order to
116 // destination of the jump is resolved later when the code is generated.
118 // Actual regular expression code generation.
121 // to improve the efficiency of the generated code some optimizations are
142 // are needed and to generate code for a node more than once, allowing
143 // specialized an efficient versions of the code to be created. This is
148 // Instead of emitting code, nodes that manipulate the state can record their
150 // current position offset, an optional backtrack code location on the top of
153 // will emit code to bring the actual state into line with the virtual state.
158 // known backtrack code location than it is to pop an unknown backtrack
161 // The virtual state found in the Trace affects code generation. For example
163 // position and the virtual current position, and matching code needs to use
165 // string. Therefore code generated for a non-trivial trace is specialized
166 // to that trace. The code generator therefore has the ability to generate
167 // code for each node several times. In order to limit the size of the
168 // generated code there is an arbitrary limit on how many specialized sets of
169 // code may be generated for a given node. If the limit is reached, the
170 // trace is flushed and a generic version of the code for a node is emitted.
171 // This is subsequently used for that node. The code emitted for non-generic
173 // the event that code generation is requested for an identical trace.
238 // Attempts to compile the regexp using an Irregexp code generator. Returns
288 Handle<HeapObject> code = macro_assembler_->GetCode(pattern);
289 isolate->IncreaseTotalRegexpCodeGenerated(code);
292 return {code, next_register_};
523 // nodes. It normalizes the state of the code generator to ensure we can
524 // generate generic code.
541 // Generate deferred actions here along with code to undo them again.
592 // so this code can be used as the generic version.
721 // Emit code.
879 // involved in order to simplify code generation.
1067 // The first test ensures that we get to the code that handles the Latin1
1265 // a potentially problematic increase in code size.
1322 // If we are generating a greedy loop then don't stop and don't reuse code.
1331 // recursed too deeply then just generate a jump to that code.
1351 // If we get here code has been generated for this node too many times or
1352 // recursion is too deep. Time to switch to a generic version. The code for
2114 // Emit the code to check for a ^ in multiline mode (1-character lookbehind
2157 // Emit the code to handle \b and \B (word-boundary or non-word-boundary).
2304 // We call this repeatedly to generate code for each pass over the text node.
2328 // order to get to the code we are now generating. The quick check can involve
2458 // This generates the code to match a text node. A text node can contain
2462 // emitting code for some character positions every time. See the comment on
2575 // Later we will generate code for all these text nodes using recursion
2657 // records the way the alternative is being code generated.
2976 * next GoTo if we decide to reuse some already generated code. Some
3014 * For greedy loops we push the current position, then generate the code that
3016 * continuation) is generated by the normal code in EmitChoices, and steps back
3017 * in the input to the starting position when it fails to match. The loop code
3018 * looks like this (U is the unwind code that steps back in the greedy loop).
3087 // other choice nodes we only flush if we are out of code size budget.
3194 // but there is no need, because the code it generates cannot backtrack, and
3283 // No quick check was generated. Put the full code here.
3334 // code through a quick check which already did the checked load.