backyard-generator 0.1.10

Convert AST node back to PHP code.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

use backyard_nodes::{ cast_node, BodyType, Node, NodeWrapper };

use crate::generator::{ Builder, Generator, GeneratorArgument, DEFAULT_GENERATORS };

use super::block::BlockGenerator;

pub struct ForGenerator;

impl ForGenerator {
  pub fn generate<'arena>(
    generator: &mut Generator<'arena, '_>,
    builder: &mut Builder,
    node: &Node<'arena>
  ) {
    let node = cast_node!(For, &node.wrapper);

    builder.push("for (");
    let mut inits = Builder::new();
    if !node.inits.is_empty() {
      generator.generate_nodes(
        &mut inits,
        &node.inits,
        &mut GeneratorArgument::for_parameter(&DEFAULT_GENERATORS)
      );
    }
    builder.push(&inits.print(" "));
    builder.push("; ");
    let mut tests = Builder::new();
    if !node.tests.is_empty() {
      generator.generate_nodes(
        &mut tests,
        &node.tests,
        &mut GeneratorArgument::for_parameter(&DEFAULT_GENERATORS)
      );
    }
    builder.push(&tests.print(" "));
    builder.push("; ");
    let mut increments = Builder::new();
    if !node.increments.is_empty() {
      generator.generate_nodes(
        &mut increments,
        &node.increments,
        &mut GeneratorArgument::for_parameter(&DEFAULT_GENERATORS)
      );
    }
    builder.push(&increments.print(" "));
    builder.push(")");
    match node.body_type {
      BodyType::Basic => {
        if let Some(n) = &node.body {
          BlockGenerator::generate(generator, builder, n, None);
        }
      }
      BodyType::Short => {
        if let Some(n) = &node.body {
          BlockGenerator::generate(generator, builder, n, Some("endfor;"));
        }
      }
      BodyType::Empty => {
        builder.push(";");
      }
    }
  }
}