从非递归上下文无关语法生成有限语言的算法

Question

I am searching an algorithm to generate the complete finite language from a non-recursive context-free grammar. The application is the generation of a set of possible scenarios for test automation.

Example grammar in EBNF (S is the start rule):

S = Sender, Receiver;
Sender = Human | Machine;
Human = "user-type-1" | "user-type-2"
Machine = Access, Protocol;
Access = "internal" | "external";
Protocol = "soap" | "smtp";
Receiver = "local" | "remote";

should produce a set of sentences like:

user-type-1 local
internal soap local
external smtp remote

Examples and literature I have found so far refered to randomised generation of examples based on recursive grammars. But my problem is more simple. All hints, names or links to publications are welcome.

Thanks,

S.

Answer 1

One way is to define the grammar in a programming language, and then write code to iterate over all possibilities. Your grammar is specified using variables and three constructions: lit(x) which represents a literal like "local" , alt(a, b, c, ...) which represents a choice of one of the alternatives a , b , c , ... and seq(a, b, ..., z) which represents a sequence of one thing from a , concatenated with one thing from b and so on.

Here's your grammar in that form.

Protocol = alt(lit("soap"), lit("smtp"))
Receiver = alt(lit("local"), lit("remote"))
Access = alt(lit("internal"), lit("external"))
Human = alt(lit("user-type-1"), lit("user-type-2"))
Machine = seq(Access, Protocol)
Sender = alt(Human, Machine)
S = seq(Sender, Receiver)

And here's some full (Python) code that uses carefully chosen definitions for alt , seq and lit to make each production rule a function that generates all of its possibilities:

import itertools

def seq(*xs):
    def r():
        for f in itertools.product(*[x() for x in xs]):
            yield ' '.join(f)
    return r

def alt(*xs):
    def r():
        for x in xs:
            for f in x():
                yield f
    return r

def lit(x):
    def r():
        yield x
    return r

Protocol = alt(lit("soap"), lit("smtp"))
Receiver = alt(lit("local"), lit("remote"))
Access = alt(lit("internal"), lit("external"))
Human = alt(lit("user-type-1"), lit("user-type-2"))
Machine = seq(Access, Protocol)
Sender = alt(Human, Machine)
S = seq(Sender, Receiver)

for s in S():
    print s

Answer 2

You can recursively generate a tree whose branches will represent derivations according to the rules of the grammar and whose leaves will represent words in the language of the grammar. Recovering the entire finite language is then as simple as saving off leaves as you generate them.

Represent each node as an ordered collection of symbols (terminals or nonterminals). For each nonterminal, recursively descend to a new set of nodes where every possible replacement is made. Continue until your list contains only terminal symbols and then output the in-order concatenation of symbols corresponding to your node. Your initial node will always be [S] . Example:

S = Sender, Receiver;
Sender = Human | Machine;
Human = "user-type-1" | "user-type-2"
Machine = Access, Protocol;
Access = "internal" | "external";
Protocol = "soap" | "smtp";
Receiver = "local" | "remote";

[S]
 [Sender, ",", Receiver]
  [Human, ",", Receiver]
   ["user-type-1", ",", Receiver]
    ["user-type-1", ",", "local"]   ***
    ["user-type-1", ",", "remote"]  ***
   ["user-type-2", ",", Receiver]
    ["user-type-2", ",", "local"]   ***
    ["user-type-2", ",", "remote"]  ***
  [Machine, ",", Receiver]
   [Access, ",", Protocol, ",", Receiver]
    ["internal", ",", Protocol, ",", Receiver]
     ["internal", ",", "soap", ",", Receiver]
      ["internal", ",", "soap", ",", "local"]   ***
      ["internal", ",", "soap", ",", "remote"]  ***
     ["internal", ",", "smtp", ",", Receiver]
      ["internal", ",", "smtp", ",", "local"]   ***
      ["internal", ",", "smtp", ",", "remote"]  ***
    ["external", ",", Protocol, ",", Receiver]
     ["external", ",", "soap", ",", Receiver]
      ["external", ",", "soap", ",", "local"]   ***
      ["external", ",", "soap", ",", "remote"]  ***
     ["external", ",", "smtp", ",", Receiver]
      ["external", ",", "smtp", ",", "local"]   ***
      ["external", ",", "smtp", ",", "remote"]  ***