def __init__(self, syms, defn=None): """ initialization arguments: self - syms - symbol table for grammar defn - EllyDefinitionReader grammar definition exceptions: TableFailure on error """ self.initzn = [] # preset global variables self.proc = {} # named semantic procedures self.dctn = {} # builtin words and semantics self.pndx = {} # standalone procedures self.extens = [] # 1-branch rule self.splits = [] # 2-branch rule for _ in range(symbolTable.NMAX): self.extens.append( []) # list of 1-branch rules for each syntax type self.splits.append( []) # list of 2-branch rules for each syntax type` self.mat = derivabilityMatrix.DerivabilityMatrix(symbolTable.NMAX) # coding of predefined syntax types self.START = syms.getSyntaxTypeIndexNumber('sent') self.END = syms.getSyntaxTypeIndexNumber('end') self.UNKN = syms.getSyntaxTypeIndexNumber('unkn') self.SEPR = syms.getSyntaxTypeIndexNumber('sepr') self.XXX = syms.getSyntaxTypeIndexNumber('...') # special rule for ... type going to null fets = ellyBits.EllyBits(symbolTable.FMAX) self.arbr = grammarRule.ExtendingRule(self.XXX, fets) self.arbr.cogs = None self.arbr.gens = compile(syms, 'g', []) # special rule for SENT->SENT END ru = grammarRule.SplittingRule(self.START, fets) ru.rtyp = self.END ru.ltfet = ru.rtfet = ellyBits.join(fets, fets) ru.cogs = None ru.gens = None self.splits[self.START].append(ru) # special rule for RS (ASCII record separator) ru = grammarRule.ExtendingRule(self.SEPR, fets) ru.cogs = None ru.gens = None self.dctn[ellyChar.RS] = [ru] # should be only rule here ever # predefined generative semantic procedures self.pndx['defl'] = compile(syms, 'g', ['left']) self.pndx['defr'] = compile(syms, 'g', ['right']) self.pndx['deflr'] = compile(syms, 'g', ['left', 'right']) self.d1bp = self.pndx['defl'] # default 1-branch generative semantics self.d2bp = self.pndx['deflr'] # default 2-branch if defn != None: if not self.define(syms, defn): print >> sys.stderr, 'grammar table definition FAILed' raise ellyException.TableFailure
def _doSplit(self, syms, s, t, u): """ define a 2-branch grammar rule arguments: self - syms - grammar symbol table s - left part of rule t - first half of right part of rule u - second returns: 2-branch splitting rule on success, None otherwise """ # print 'split=' , s , '->' , t , u if t == None or len(t) == 0 or u == None or len(u) == 0: print >> sys.stderr, '** incomplete grammar rule' return None try: # print 's=' , s ss = syntaxSpecification.SyntaxSpecification(syms, s) ns = ss.catg fs = ss.synf # print 'fs=' , fs st = syntaxSpecification.SyntaxSpecification(syms, t) nt = st.catg ft = st.synf su = syntaxSpecification.SyntaxSpecification(syms, u) nu = su.catg fu = su.synf if fs == None: # lh = False rh = False else: # rh = fs.positive.test(0) lh = fs.positive.test(1) if not symbolTable.featureConsistencySplit(fs, ft, fu, lh, rh): print >> sys.stderr, '** bad syntactic feature inheritance' raise ellyException.FormatFailure except ellyException.FormatFailure: return None if ns >= symbolTable.NMAX or nt >= symbolTable.NMAX or nu >= symbolTable.NMAX: print >> sys.stderr, 'too many syntactic categories' return None if ns < 0 or nt < 0 or nu < 0: print >> sys.stderr, '** bad syntax specification' return None fs.negative.complement() ru = grammarRule.SplittingRule(ns, fs.positive, fs.negative) # print 'splt rule=' , unicode(ru) ru.gens = self.d2bp ru.ltfet = ft.makeTest( ) # combine positive and negative features for testing ru.rtfet = fu.makeTest( ) # combine positive and negative features for testing ru.rtyp = nu if t == '...': if u == '...': print >> sys.stderr, '** bad type 0 rule' return None # cannot have a rule of the form X->... ... else: self.mat.join(ns, nu) # for rule of form X->... Y, we see X->Y else: self.mat.join(ns, nt) # otherwise, treat as normal 2-branch self.splits[nt].append(ru) # add rule to grammar table return ru
def __init__(self): """ create environment for testing semantic procedure arguments: self """ stb = symbolTable.SymbolTable() # empty hry = conceptualHierarchy.ConceptualHierarchy() # empty ctx = interpretiveContext.InterpretiveContext(stb, {}, {}, hry) self.context = ctx # make available ptb = parseTreeBase.ParseTreeBase() # just for generating phrases self.toknL = ellyToken.EllyToken( 'uvwxxyz') # insert dummy data that might self.toknR = ellyToken.EllyToken('abcdefg') # be replaced from outside ctx.addTokenToListing(self.toknL) # put a token in first position ctx.addTokenToListing(self.toknR) # and a token in second x = ctx.syms.getSyntaxTypeIndexNumber( 'x') # for consistency, define two y = ctx.syms.getSyntaxTypeIndexNumber( 'y') # syntactic categories for rules fbs = ellyBits.EllyBits(symbolTable.FMAX) # zero feature bits exL = grammarRule.ExtendingRule(x, fbs) # dummy rules as a place for exR = grammarRule.ExtendingRule(x, fbs) # attaching semantic procedures spl = grammarRule.SplittingRule(y, fbs) # for testing # dummy semantic procedures gX = ["left", "right"] # generative gL = ["obtain"] # gR = ["obtain"] # gP = ["append did it!"] # for standalone generative subprocedure cX = [] # cognitive cL = [">> +1"] # cR = [">> -1"] # ctx.pushStack() # needed for local variables usable in testing ctx.setLocalVariable( "vl", "LLLL") # make two variables available to work with ctx.setLocalVariable("vr", "RRRR") # ctx.setProcedure('do', self._genp(gP)) # define procedure 'do' exL.gens = self._genp(gL) # assign semantic procedures to rules exL.cogs = self._cogp(cL) # exR.gens = self._genp(gR) # exR.cogs = self._cogp(cR) # spl.gens = self._genp(gX) # spl.cogs = self._cogp(cX) # phr = ptb.makePhrase(0, spl) # make phrase for splitting plus phr.krnl.lftd = ptb.makePhrase(0, exL) # left and right descendants phr.krnl.rhtd = ptb.makePhrase(1, exR) # defined by left and right # extending rules from above phr.ntok = 1 stb.getFeatureSet('!one,two', True) # define semantic feature print stb.smindx smx = stb.smindx['!'] # ix = smx['one'] # print 'ix=', ix phr.krnl.semf.set(ix) # turn on feature for phrase ix = smx['two'] # print 'ix=', ix phr.krnl.semf.set(ix) # turn on feature for phrase print 'semf=', phr.krnl.semf self.phrase = phr # make phrase available