name: LanguageModelABNF

synopsis:

 
g++ [flags ...] file ... -l /isip/tools/lib/$ISIP_BINARY/lib_mmedia.a

#include <LanguageModelABNF.h>

boolean read(Sof& sof, long tag, const String& cname = CLASS_NAME);

quick start:

Sof sof;
sof.open("lm_abnf_obj.sof", File::READ_ONLY);

LanguageModelABNF lmabnf;
lmabnf.read(sof, 0);

description:

The LanguageModelABNF is a class that reads in ABNF grammars and gives out a set of Producitons in BNF form. In ABNF there are certain meta symbols that are used, that make sit difficult to be converted into IHD (ISIP Hierarchial Di-Graph). HierarchicalDigraph BNF uses recursion unlike ABNF which uses iteration. This makes it easy to convert BNF Productions into IHD. The implementation of the LanguageModelABNF is such that one methos auto matically calls other methods. convertABNFGrammars method, first look for ALTERNATION in the input Production. If it exists, it passes the Production together with the position of ALTERNATION and the nesting epth till that point. removeAlternation method removes the OR symbol in the input Production and passes it to removeKleenePlus, which in turn calls removeKleeneStar and this continues. In case there is not ALTERNATION in the input Produciton, it is passes directly to removeKleenePlus method. By the end of the conversion process, we have a set of productions which are free of the meta symbols.

dependencies:

public constants:

define the class name:

static const String LanguageModelABNF::CLASS_NAME = L"LanguageModelABNF";

other i/o constants:

static const String LanguageModelABNF::DEF_PARAM;

static const long LanguageModelABNF::DEF_LEVEL;

static const String LanguageModelABNF::PARAM_ABNF;

static const String LanguageModelABNF::DEF_TAG;

error codes:

error code indicating LanguageModelABNF class general error:

static const long ERR = 100800;

static const long ERR_CTXT_INV_SYM = 100801;

static const long ERR_RULE_EMPTY = 100802;

protected data:

search direction
```
enum DIRECTION {RIGHT=0, LEFT};
```
rulemodel name
```
RuleModel abnf_model_d;
```
holds count for non-conflicting variable names
```
long count_d;
```

required public methods:

static methods:
```
static const String& name();
```

debug methods:

static boolean diagnose(Integral::DEBUG level);

boolean debug(const unichar* msg) const;

default constructor:
```
LanguageModelABNF();
```

assign methods:

boolean assign(const LanguageModelABNF& arg);

i/o methods:

boolean read(Sof& sof, long tag, const String& cname = CLASS_NAME);

boolean readData(Sof& sof, const String& pname = DEF_PARAM, long size = SofParser::FULL_OBJECT, boolean param = true, boolean nested = false);

boolean write(Sof& sof, long tag, const String& cname = CLASS_NAME) const;

boolean writeData(Sof& sof, const String& pname = DEF_PARAM) const;

long sofSize() const;

equality methods:

boolean eq(const LanguageModelABNF& arg) const;

boolean eq(const LanguageModelBase& arg) const;

operator method:

boolean operator=(const LanguageModelABNF& lmabnf_a);

clear method:
```
boolean clear(Integral::CMODE ctype);
```

class-specific public methods:

equivalent BNF production rules methods:

RuleModel getRuleModel();;

boolean setRuleModel(const RuleModel& model_a);

equivalent ABNF production rules methods:

RuleModel getABNFRuleModel();

boolean setABNFRuleModel(const RuleModel& model_a);

class-specific protected methods:

ABNF to BNF conversion methods:

WeightedSymbols findRightSymbols(ProductionRuleSet rules, long index, long nest_level, long position, Float weight);

Vector<SearchSymbol> findLeftSymbols(ProductionRuleSet rules, long index, long nest_level, long position);

boolean buildNormBNFRules(Vector<SearchSymbol> left_symbols, WeightedSymbols right_symbols, ProductionRuleSet& bnf_rules);

long findEndOfNestLevel(ProductionRule current_rule, long index, DIRECTION dir);

long findToken(ProductionRule current_rule, long index, ProductionRuleTokenType::TYPE token, DIRECTION dir);

boolean restoreSymbols(ProductionRuleSet& rules, Vector<Pair<SearchSymbol, SearchSymbol>> chart);

boolean createStartRules(RuleModel abnf_rules, ProductionRuleSet& bnf_rules, long level_index, long graph_index);

examples:

This example shows how to use a LanguageModelABNF object to read a LanguageModelABNF object from a file, and retrieve the parsed grammars in BNF form.


// declare an sof object to parse the file
//
Sof sof;

// open the file for reading
//
sof.open("lm_abnf_obj.sof", File::READ_ONLY);

// declare a LMABNF object to read the grammars
//
LanguageModelABNF lmabnf;

// read the grammars
//
lmabnf.read(sof, 0);

// declare an HierarchicalDigraph object to store the grammars in DiGraph form
//
HierarchicalDigraph hg;

// retrieve the grammars from the LMABNF object, and store them in the HD object
//