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