| java.lang.Object
 org.ofbiz.rules.logikus.LogikusParser
| LogikusParser | | public class LogikusParser (Code) | | This class provides a parser for Logikus, a logic
language similar to Prolog.
The grammar this class supports is:
structure = functor ('(' commaList(term) ')' | Empty);
functor = '.' | LowercaseWord | QuotedString;
term = structure | Num | list | variable;
variable = UppercaseWord | '_';
factor = '(' expression ')' | Num | variable;
axiom = structure (ruleDef | Empty);
structure = functor ('(' commaList(term) ')');
functor = '.' | LowercaseWord | UppercaseWord;
term = structure | Num | QuotedString | list | variable;
variable = LowercaseWord | UppercaseWord | '_';
ruleDef = ":-" commaList(condition);
condition = structure | not | evaluation | comparison | list;
not = "not" structure ;
evaluation = '#' '(' arg ',' arg ')';
comparison = operator '(' arg ',' arg ')';
arg = expression | functor;
operator = '<' | '>' | '=' | "<=" | ">=" | "!=" ;
expression = phrase ('+' phrase | '-' phrase)*;
phrase = factor ('*' factor | '/' factor)*;
factor = '(' expression ')' | Num | QuotedString | variable;
list = '[' (listContents | Empty) ']';
listContents = commaList(term) listTail;
listTail = ('|' (variable | list)) | Empty;
commaList(p) = p (',' p)*;
The following program and query use most of the features of
the Logikus grammar:
// program
member(X, [X | Rest]);
member(X, [Y | Rest]) :- member(X, Rest);
primes([2, 3, 5, 7, 11, 13]);
factor(X, P, Q) :-
primes(Primes),
member(P, Primes), member(Q, Primes), =(P*Q, X);
// query
factor(91, A, B)
// results
A = 7.0, B = 13.0
A = 13.0, B = 7.0
no
The class LogikusFacade simplifies the
construction of Program and Query
objects from the text given above. A Java program can prove
the query to generate the results.
The class LogikusIde is an example of using the
Logikus parser in practice. It uses
LogikusFacade to create a Query,
proves the query, and displays the query's variables for
each proof. As in Prolog, the Logikus development
environment prints "no" when no further proofs remain.
author:
Steven J. Metsker
version:
1.0 |
| arg | | protected Parser arg()(Code) | | Return a parser that recognizes the grammar:
arg = expression | functor;
|
| axiom | | public Parser axiom()(Code) | | Return a parser that recognizes the grammar:
axiom = structure (ruleDef | Empty);
a parser that recognizes an axiom |
| commaList | | protected static Sequence commaList(Parser p)(Code) | | Using the given parser, this method composes a new
parser with the grammar:
commaList(p) = p (',' p)*;
The Logikus language uses this construction several
times.
|
| comparison | | public Sequence comparison()(Code) | | Return a parser that recognizes the grammar:
comparison = operator '(' arg ',' arg ')';
a parser that recognizes a comparison |
| condition | | public Alternation condition()(Code) | | Return a parser that recognizes the grammar:
condition = structure | not | evaluation | comparison |
list;
a parser that recognizes a condition |
| divideFactor | | protected Parser divideFactor()(Code) | | Return a parser that recognizes the grammar:
divideFactor = '/' factor;
|
| evaluation | | protected Parser evaluation()(Code) | | Return a parser that recognizes the grammar:
evaluation = '#' '(' arg ',' arg ')';
For example, this parser will recognize
"#(X, 12321/111)", translating it to an Evaluation
object. When asked to prove itself, the Evaluation
object will unify its first term with the value of
its second term.
|
| expression | | protected Parser expression()(Code) | | Return a parser that recognizes the grammar:
expression = phrase ('+' phrase | '-' phrase)*;
|
| factor | | protected Parser factor()(Code) | | Return a parser that recognizes the grammar:
factor = '(' expression ')' | Num | QuotedString | variable;
|
| functor | | protected Parser functor()(Code) | | Return a parser that recognizes the grammar:
functor = '.' | LowercaseWord | UppercaseWord;
|
| list | | public Sequence list()(Code) | | Return a parser that recognizes the grammar:
list = '[' (listContents | Empty) ']';
The class comment gives the complete grammar for lists,
as part of the Logikus grammar.
a parser that recognizes a list |
| listContents | | protected Parser listContents()(Code) | | Return a parser that recognizes the grammar:
listContents = commaList(term) listTail;
|
| listTail | | protected Parser listTail()(Code) | | Return a parser that recognizes the grammar:
listTail = ('|' (variable | list)) | Empty;
|
| minusPhrase | | protected Parser minusPhrase()(Code) | | Return a parser that recognizes the grammar:
minusPhrase = '-' phrase;
|
| not | | protected Parser not()(Code) | | Return a parser that recognizes the grammar:
not = "not" structure;
|
| num | | public Parser num()(Code) | | Return a parser that recognizes a number and stacks a corresponding atom.
|
| operator | | protected Parser operator()(Code) | | Return a parser that recognizes the grammar:
operator = '<' | '>' | '=' | "<=" | ">=" | "!=" ;
|
| phrase | | protected Parser phrase()(Code) | | Return a parser that recognizes the grammar:
phrase = factor ('*' factor | '/' factor)*;
|
| plusPhrase | | protected Parser plusPhrase()(Code) | | Return a parser that recognizes the grammar:
plusPhrase = '+' phrase;
|
| query | | public static Parser query()(Code) | | Return a parser that recognizes the grammar:
query = commaList(condition);
a parser that recognizes a query |
| ruleDef | | protected Parser ruleDef()(Code) | | Return a parser that recognizes the grammar:
ruleDef = ":-" commaList(condition);
|
| start | | public static Parser start()(Code) | | Return a parser that recognizes the grammar:
axiom = condition (ruleDefinition | empty);
a parser that recognizes an axiom |
| string | | public Parser string()(Code) | | Return a parser that recognizes a number and stacks a corresponding atom.
|
| structure | | protected Parser structure()(Code) | | Return a parser that recognizes the grammar:
structure = functor ('(' commaList(term) ')');
This definition of structure accounts for normal-looking
structures that have a string as a functor. Strictly
speaking, numbers and lists are also structures. The
definition for term includes these.
|
| term | | protected Parser term()(Code) | | Return a parser that recognizes the grammar:
term = structure | Num | QuotedString | list | variable;
|
| timesFactor | | protected Parser timesFactor()(Code) | | Return a parser that recognizes the grammar:
timesFactor = '*' factor;
|
| variable | | protected Parser variable()(Code) | | Return a parser that recognizes the grammar:
variable = LowercaseWord | UppercaseWord | '_';
The underscore represents and will translate to an
anonymous variable.
|
|
|