// Finds the set of frontier nodes. The definition of a frontier node differs
// from Galley et al's (2004) in the following ways:
//
// 1. A node with an empty span is not a frontier node (this excludes
// unaligned target subtrees).
// 2. Target word nodes are not frontier nodes.
// 3. Source word nodes are not frontier nodes.
// 4. Unless the --AllowUnary option is used, a node is not a frontier node if
// it has the same span as its parent.
void AlignmentGraph::ComputeFrontierSet(Node *root,
const Options &options,
std::set<Node *> &frontierSet) const
{
// Don't include word nodes or unaligned target subtrees.
if (root->GetType() != TREE || root->GetSpan().empty()) {
return;
}
if (!SpansIntersect(root->GetComplementSpan(), Closure(root->GetSpan()))) {
// Unless unary rules are explicitly allowed, we use Chung et al's (2011)
// modified defintion of a frontier node to eliminate the production of
// non-lexical unary rules.
assert(root->GetParents().size() <= 1);
if (options.allowUnary
|| root->GetParents().empty()
|| root->GetParents()[0]->GetSpan() != root->GetSpan()) {
frontierSet.insert(root);
}
}
const std::vector<Node *> &children = root->GetChildren();
for (std::vector<Node *>::const_iterator p(children.begin());
p != children.end(); ++p) {
ComputeFrontierSet(*p, options, frontierSet);
}
}
/*
function goto(I, X);
begin
let J be the set of items [A -> aX*b, a] such that
[A -> a*Xb, a] is in I;
return closure(J)
end;
*/
LR_ITEM_SET* Goto(LR_ITEM_SET* I, int X, GRAMMAR_TABLE* G)
{
// J := {};
LR_ITEM_SET* J = NULL;
// for each item A -> a*Xb in I
LR_ITEM_SET* itr;
for (itr = I; itr; itr = itr->next)
{
LR_ITEM item = itr->item;
int B = G->rules[item.production].rhs[item.dot];
if (B == X)
{
// add A -> aX*b to J
LR_ITEM_SET* add = malloc(sizeof(LR_ITEM_SET));
add->item = item;
add->item.dot++;
add->next = J;
J = add;
}
}
// return closure(J)
LR_ITEM_SET* K = Closure(J, G);
FreeItemSet(J);
return K;
}
/*
* This routine is called by the domain manager to complete initialisation
* of the first domain.
*/
void Binder_Done(DomainMgr_st *dm_st)
{
PerDomain_st *bst = ROP_TO_PDS(dm_st->dm_dom);
Closure_clp cl;
bst->callback = dm_st->bcb;
TRC(eprintf ("Binder_Done: bst=%x callback=%x.\n", bst, bst->callback));
cl = Entry$Closure (Pvs(entry));
Threads$Fork (Pvs(thds), cl->op->Apply, cl, 0);
Threads$Fork (Pvs(thds), cl->op->Apply, cl, 0);
#if 0
Threads$Fork (Pvs(thds), cl->op->Apply, cl, 0);
#endif /* 0 */
TRC(eprintf ("Binder_Done: forked server thread\n"));
}
void ScfgRule::PushSourceLabel(const SyntaxNodeCollection *sourceNodeCollection,
const Node *node,
const std::string &nonMatchingLabel)
{
ContiguousSpan span = Closure(node->GetSpan());
if (sourceNodeCollection->HasNode(span.first,span.second)) { // does a source constituent match the span?
std::vector<SyntaxNode*> sourceLabels =
sourceNodeCollection->GetNodes(span.first,span.second);
if (!sourceLabels.empty()) {
// store the topmost matching label from the source syntax tree
m_sourceLabels.push_back(sourceLabels.back()->label);
}
} else {
// no matching source-side syntactic constituent: store nonMatchingLabel
m_sourceLabels.push_back(nonMatchingLabel);
}
}
// generates the got state for this symbol
dParserCompiler::dState* dParserCompiler::Goto (
const dState* const state,
dCRCTYPE symbol,
const dTree<dTokenInfo, dCRCTYPE>& symbolList,
const dTree<dList<void*>, dCRCTYPE>& ruleMap) const
{
dList<dItem> itemSet;
// iterate over each item contained on state
for (dState::dListNode* node = state->GetFirst(); node; node = node->GetNext()) {
const dItem& item = node->GetInfo();
int index = 0;
const dRuleInfo& ruleInfo = item.m_ruleNode->GetInfo();
// for this item get it rule, and iterate over ever rule symbol.
for (dRuleInfo::dListNode* infoSymbolNode = ruleInfo.GetFirst(); infoSymbolNode; infoSymbolNode = infoSymbolNode->GetNext()) {
// see if this rule symbol match symbol
const dSymbol& infoSymbol = infoSymbolNode->GetInfo();
if (infoSymbol.m_nameCRC == symbol) {
// a symbol was found, now see if it is at the right position in the rule
if (index == item.m_indexMarker) {
// the rule match symbol at the right position, add this rule to the new item set.
dItem& newItem = itemSet.Append()->GetInfo();
newItem.m_indexMarker = index + 1;
newItem.m_ruleNode = item.m_ruleNode;
newItem.m_lookAheadSymbolCRC = item.m_lookAheadSymbolCRC;
newItem.m_lookAheadSymbolName = item.m_lookAheadSymbolName;
break;
}
}
index ++;
}
}
//find the closure for this new item set.
dState* const closureState = Closure (itemSet, symbolList, ruleMap);
return closureState;
}
ConsoleControl_clp InitConsole(Wr_clp *console)
{
struct Console_st *console_st;
console_st = Heap$Malloc(Pvs(heap), sizeof(*console_st));
CL_INIT(console_st->cl, &wr_op, console_st);
CL_INIT(console_st->control_cl, &control_op, console_st);
MU_INIT(&console_st->mu);
LINK_INIT(&console_st->outputs);
/* Chuck another thread into Pvs(entry) in case we need to do
IDC to our own domain (serial driver, for example) */
{
Closure_clp c=Entry$Closure(Pvs(entry));
Threads$Fork(Pvs(thds), c->op->Apply, c, 0);
}
*console=&console_st->cl;
return &console_st->control_cl;
}
// generates the canonical Items set for a LR(1) grammar
void dParserCompiler::CanonicalItemSets (
dTree<dState*, dCRCTYPE>& stateMap,
const dProductionRule& ruleList,
const dTree<dTokenInfo, dCRCTYPE>& symbolList,
const dOperatorsPrecedence& operatorPrecedence,
FILE* const debugFile)
{
dList<dItem> itemSet;
dList<dState*> stateList;
// start by building an item set with only the first rule
dItem& item = itemSet.Append()->GetInfo();
item.m_indexMarker = 0;
item.m_lookAheadSymbolCRC = dCRC64 (DACCEPT_SYMBOL);
item.m_lookAheadSymbolName = DACCEPT_SYMBOL;
item.m_ruleNode = ruleList.GetFirst();
// build a rule info map
dTree<dList<void*>, dCRCTYPE> ruleMap;
for (dProductionRule::dListNode* ruleNode = ruleList.GetFirst(); ruleNode; ruleNode = ruleNode->GetNext()) {
dRuleInfo& info = ruleNode->GetInfo();
dTree<dList<void*>, dCRCTYPE>::dTreeNode* node = ruleMap.Find(info.m_nameCRC);
if (!node) {
node = ruleMap.Insert(info.m_nameCRC);
}
dList<void*>& entry = node->GetInfo();
entry.Append(ruleNode);
}
// find the closure for the first this item set with only the first rule
dState* const state = Closure (itemSet, symbolList, ruleMap);
operatorPrecedence.SaveLastOperationSymbol (state);
stateMap.Insert(state, state->GetKey());
stateList.Append(state);
state->Trace(debugFile);
// now for each state found
int stateNumber = 1;
for (dList<dState*>::dListNode* node = stateList.GetFirst(); node; node = node->GetNext()) {
dState* const state = node->GetInfo();
dTree<dTokenInfo, dCRCTYPE>::Iterator iter (symbolList);
for (iter.Begin(); iter; iter ++) {
dCRCTYPE symbol = iter.GetKey();
dState* const newState = Goto (state, symbol, symbolList, ruleMap);
if (newState->GetCount()) {
const dTokenInfo& tokenInfo = iter.GetNode()->GetInfo();
dTransition& transition = state->m_transitions.Append()->GetInfo();
transition.m_symbol = symbol;
transition.m_name = tokenInfo.m_name;
transition.m_type = tokenInfo.m_type;
dAssert (transition.m_symbol == dCRC64(transition.m_name.GetStr()));
transition.m_targetState = newState;
dTree<dState*, dCRCTYPE>::dTreeNode* const targetStateNode = stateMap.Find(newState->GetKey());
if (!targetStateNode) {
newState->m_number = stateNumber;
stateNumber ++;
stateMap.Insert(newState, newState->GetKey());
newState->Trace(debugFile);
stateList.Append(newState);
operatorPrecedence.SaveLastOperationSymbol (newState);
} else {
transition.m_targetState = targetStateNode->GetInfo();
delete newState;
}
} else {
delete newState;
}
}
dTrace (("state#:%d items: %d transitions: %d\n", state->m_number, state->GetCount(), state->m_transitions.GetCount()));
}
}
/*
// LR(1) canonical collection of sets
procedure items(G');
begin
C := {closure({[S' -> *S, $]})};
repeat
for each set of items I in C and each grammar symbol X
such that goto(I, X) is not empty and not in C do
add goto(I, X) to C
until no more sets of items can be added to C
end
*/
LR_ITEM_COLLECTION* CanonicalCollection(GRAMMAR_TABLE* G)
{
// C := {closure({[S' -> *S, $]})};
LR_ITEM_COLLECTION* C = malloc(sizeof(LR_ITEM_COLLECTION));
C->set = malloc(sizeof(LR_ITEM_SET));
C->set->item.production = 0;
C->set->item.dot = 0;
C->set->item.lookahead = gSymbolEOF;
C->set->next = NULL;
C->next = NULL;
LR_ITEM_SET* closure = Closure(C->set, G);
FreeItemSet(C->set);
C->set = closure;
// repeat
int count = 0;
int finished;
do {
finished = 1;
// for each set of items I in C
LR_ITEM_COLLECTION* itr;
for (itr = C; itr; itr = itr->next)
{
LR_ITEM_SET* I = itr->set;
// and each grammar symbol X
int i;
for (i = 0; i < G->numSymbols + G->numTokens; i++)
{
int X = (i < G->numSymbols) ? K_SYMBOL + i + 1 :
K_TOKEN + (i - G->numSymbols) + 1;
LR_ITEM_SET* gotoSet = Goto(I, X, G);
// such that goto(I, X) is not empty
if (gotoSet == NULL) continue;
// and not in C
LR_ITEM_COLLECTION* find;
for (find = C; find; find = find->next)
{
if (CompareItemSets(find->set, gotoSet) == 0)
{
FreeItemSet(gotoSet);
gotoSet = NULL;
break;
}
else if (find->next == NULL)
{
// add goto(I, X) to C
find->next = malloc(sizeof(LR_ITEM_COLLECTION));
find = find->next;
find->next = NULL;
find->set = gotoSet;
finished = 0;
// print for debugging
printf("I(%i);\n", count++);
//PrintItemSet(gotoSet, G);
//printf("\n");
}
}
}
}
} while (!finished);
// until no more sets of items can be added to C
return C;
}
group* Carttype(matrix* m)
{ group* type=mkgroup(s=Ssrank(grp)); /* rank bounds number of components */
Closure(m,false,type); return type;
}
