I have an application that uses xml config file, where I'm describing layouts for components.
Currently I have 3 layouts: grid, horizontal and vertical.
I want to create a layout which will use those three.

Finally I found a way to do this: for each of the layout class I define a protected package-protected field of that layout class a initialize them in declaration. My general rule uses those fields. The only thing to remember is that they all have their own stacks, which is not a problem, because you can call a code like this: `push(gridLayoutParser.pop())`.

Here is the example of usage of different parsers in one:

First child parser:

```
 public static class P1 extends BaseParser<String> {
    public Rule FullContent() {
        return Sequence(Content(), EOI);
    }

    public Rule Content() {
        return Sequence(
                push(""),
                String("STRING1"),
                swap() && push(pop() + " fromParser1 "),
                String(" SOMESTRING1 ")
        );
    }
}

```

The second is the same:

```
public static class P2 extends BaseParser<String> {
    public Rule FullContent() {
        return Sequence(Content(), EOI);
    }

    public Rule Content() {
        return Sequence(
                push(""),
                String("STRING2"),
                swap() && push(pop() + " fromParser2 "),
                String(" SOMESTRING2 ")
        );
    }
}

```

And here the parser that uses both of them:

public class OP extends BaseParser {

```
protected P1 bool1 = Parboiled.createParser(P1.class);
protected P2 bool2 = Parboiled.createParser(P2.class);

public Rule FullContent() {
    return Sequence(
            push(""),
            OneOrMore(
                    FirstOf(
                            Sequence(
                                    bool1.Content(),
                                    swap() && push(pop() + bool1.pop())
                                    ),
                            Sequence(
                                    bool2.Content(),
                                    swap() && push(pop() + bool2.pop())
                            )
                    )

            )
    );
}

```

}

For me it works fine. But will it be fine for more complex grammars?