def _phase3 ( self , phr , fbs ):
"""
create a goal at next position for the right branch of each
2-branch splitting syntax rule having a left branch going to
the type of the current phrase
arguments:
self -
phr - current phrase
fbs - its compounded feature bits
"""
rls = self.gtb.splits[phr.krnl.typx]
po = phr.krnl.posn
if po < 0 : po = 0 # position check needed for ... phrase type
gb = self.gbits[po]
np = self.wordno + 1
# print ( '> PHASE 3' , phr )
# print ( '> PHASE 3 at' , po , '=' , len(rls) , 'rules, gb=' , gb.hexadecimal() )
for r in rls:
nt = r.styp
# print ( 'type=' , nt , 'dm=' , self.gtb.mat.dm[nt].hexadecimal() )
if self.gtb.mat.derivable(nt,gb): # rule is applicable at current position?
# print ( 'left test=' , r.ltfet )
if ellyBits.check(fbs,r.ltfet): # phrase has required features for rule?
g = self.makeGoal(r,phr) # allocate new goal
# print ( 'at ' + str(np) + ',' , g )
if np == len(self.goal): # check for end of goal array
self.addGoalPositions() # add new positions when needed
self.goal[np].append(g) # add it to next position
self.gbits[np].set(g.cat) # and set bit for type of goal
def _phase3 ( self , phr , fbs ):
"""
create a goal at next position for the right branch of each
2-branch splitting syntax rule having a left branch going to
the type of the current phrase
arguments:
self -
phr - current phrase
fbs - its compounded feature bits
"""
rls = self.gtb.splits[phr.krnl.typx]
po = phr.krnl.posn
if po < 0 : po = 0 # position check needed for ... phrase type
gb = self.gbits[po]
np = self.wordno + 1
# print '> PHASE 3' , phr
# print '> PHASE 3 at' , po , '=' , len(rls) , 'rules, gb=' , gb.hexadecimal()
for r in rls:
nt = r.styp
# print 'type=' , nt , 'dm=' , self.gtb.mat.dm[nt].hexadecimal()
if self.gtb.mat.derivable(nt,gb): # rule is applicable at current position?
# print 'left test=' , r.ltfet
if ellyBits.check(fbs,r.ltfet): # phrase has required features for rule?
g = self.makeGoal(r,phr) # allocate new goal
# print 'at ' + str(np) + ',' , g
if np == len(self.goal): # check for end of goal array
self.addGoalPositions() # add new positions when needed
self.goal[np].append(g) # add it to next position
self.gbits[np].set(g.cat) # and set bit for type of goal
def _phase2(self, phr, fbs):
"""
create phrase for each 1-branch syntax rule going to
the type of the current phrase
arguments:
self -
phr - current phrase
fbs - its compounded feature bits
exceptions:
ParseOverflow
"""
po = phr.krnl.posn
gb = self.gbits[po]
rls = self.gtb.extens[phr.krnl.typx]
# print '> PHASE 2 at' , po , '=' , len(rls) , 'rules, gb=' , gb.hexadecimal()
for r in rls:
nt = r.styp
# print 'type=' , nt , 'dm=' , self.gtb.mat.dm[nt].hexadecimal()
if self.gtb.mat.derivable(
nt, gb): # rule applicable at current position?
# print 'phr fet=' , fbs
# print 'rul fet=' , r.utfet
if ellyBits.check(
fbs,
r.utfet): # phrase has required features for rule?
phn = self.makePhrase(
po, r) # make new phrase if checks succeed
if phn == None:
break
phn.krnl.lftd = phr # current phrase is part of new one
phn.ntok = phr.ntok # set token count for new phrase
phn.lens = phr.lens # set token count for new phrase
# print 'phn=' , phn
# print 'phr=' , phr
self._score(phn) # compute bias score
rF = phn.krnl.synf.test(0)
lF = phn.krnl.synf.test(1)
if lF or rF: # inherit features from current phrase?
# print 'lF or rF'
phn.krnl.synf.combine(phr.krnl.synf)
if lF:
phn.krnl.synf.unset(0)
else:
phn.krnl.synf.unset(1)
# print 'TO' , str(phn.krnl.synf)
phn.krnl.synf.reset(
r.sftr) # reset selected inherited bits
# print 'phn=' , phn
self.enqueue(phn) # save new phrase to ramify (phase 2)
def _phase1(self, phr, fbs):
"""
check for goals at current position for current phrase type
and create new phrase for each match
arguments:
self -
phr - current phrase
fbs - its compounded feature bits
exceptions:
ParseOverflow
"""
po = phr.krnl.posn
gls = self.goal[po]
# print '> PHASE 1 at' , po , '=' , len(gls) , 'goals'
for g in gls:
# print 'goal of' , g.cat
if phr.krnl.typx == g.cat:
r = g.rul
# print 'r=' , r.seqn , r.rtfet
if ellyBits.check(fbs, r.rtfet):
phx = g.lph # phrase that generated pertinent goal
phn = self.makePhrase(phx.krnl.posn,
r) # new phrase to satisfy goal
if phn == None:
break
phn.krnl.lftd = phx # goal phrase is left part of new one
phn.krnl.rhtd = phr # current phrase is right part
phn.ntok = phx.ntok + phr.ntok # set token count for new phrase
phn.lens = phx.lens + phr.lens # and char count
self._score(phn) # compute bias score
rF = phn.krnl.synf.test(0)
lF = phn.krnl.synf.test(1)
if lF: # inherit features from previous phrase?
# print '*l set' , str(phx.krnl.synf)
phn.krnl.synf.combine(phx.krnl.synf)
phn.krnl.synf.unset(0)
# print 'TO' , str(phn.krnl.synf)
if rF: # inherit features from ramified phrase?
# print '*r set' , str(phx.krnl.synf)
phn.krnl.synf.combine(phr.krnl.synf)
phn.krnl.synf.unset(1)
# print 'TO' , str(phn.krnl.synf)
phn.krnl.synf.reset(
r.sftr) # reset selected inherited bits
# print 'phr=' , phr , 'phn=' , phn
self.enqueue(phn) # save new phrase to ramify (phase 1)
def _phase2 ( self , phr , fbs ):
"""
create phrase for each 1-branch syntax rule going to
the type of the current phrase
arguments:
self -
phr - current phrase
fbs - its compounded feature bits
exceptions:
ParseOverflow
"""
po = phr.krnl.posn
gb = self.gbits[po]
rls = self.gtb.extens[phr.krnl.typx]
# print '> PHASE 2 at' , po , '=' , len(rls) , 'rules, gb=' , gb.hexadecimal()
for r in rls:
nt = r.styp
# print 'type=' , nt , 'dm=' , self.gtb.mat.dm[nt].hexadecimal()
if self.gtb.mat.derivable(nt,gb): # rule applicable at current position?
# print 'phr fet=' , fbs
# print 'rul fet=' , r.utfet
if ellyBits.check(fbs,r.utfet): # phrase has required features for rule?
phn = self.makePhrase(po,r) # make new phrase if checks succeed
if phn == None:
break
phn.krnl.lftd = phr # current phrase is part of new one
phn.ntok = phr.ntok # set token count for new phrase
# print 'phn=' , phn
# print 'phr=' , phr
self._score(phn) # compute bias score
rF = phn.krnl.synf.test(0)
lF = phn.krnl.synf.test(1)
if lF or rF: # inherit features from current phrase?
# print 'lF or rF'
phn.krnl.synf.combine(phr.krnl.synf)
if lF:
phn.krnl.synf.unset(0)
else:
phn.krnl.synf.unset(1)
# print 'TO' , str(phn.krnl.synf)
phn.krnl.synf.reset(r.sftr) # reset selected inherited bits
# print 'phn=' , phn
self.enqueue(phn) # save new phrase for ramification
def _phase1 ( self , phr , fbs ):
"""
check for goals at current position for current phrase type
and create new phrase for each match
arguments:
self -
phr - current phrase
fbs - its compounded feature bits
exceptions:
ParseOverflow
"""
po = phr.krnl.posn
gls = self.goal[po]
# print '> PHASE 1 at' , po , '=' , len(gls) , 'goals'
for g in gls:
# print 'goal of' , g.cat
if phr.krnl.typx == g.cat:
r = g.rul
if ellyBits.check(fbs,r.rtfet):
phx = g.lph # phrase that generated pertinent goal
phn = self.makePhrase(phx.krnl.posn,r) # new phrase to satisfy goal
if phn == None:
break
phn.krnl.lftd = phx # goal phrase is left part of new one
phn.krnl.rhtd = phr # current phrase is right part
phn.ntok = phx.ntok + phr.ntok # set token count for new phrase
self._score(phn) # compute bias score
rF = phn.krnl.synf.test(0)
lF = phn.krnl.synf.test(1)
if lF: # inherit features from previous phrase?
# print '*l set' , str(phx.krnl.synf)
phn.krnl.synf.combine(phx.krnl.synf)
phn.krnl.synf.unset(0)
# print 'TO' , str(phn.krnl.synf)
if rF: # inherit features from ramified phrase?
# print '*r set' , str(phx.krnl.synf)
phn.krnl.synf.combine(phr.krnl.synf)
phn.krnl.synf.unset(1)
# print 'TO' , str(phn.krnl.synf)
phn.krnl.synf.reset(r.sftr) # reset selected inherited bits
# print 'phr=' , phr , 'phn=' , phn
self.enqueue(phn) # save new phrase for ramification
def run ( self , cntx , phrs , pnam=None ):
"""
execute a generative procedure in context
arguments:
self -
cntx - interpretive context
phrs - phrase to which procedure is attached
pnam - procedure name to associate with call
returns:
True on success, False otherwise
"""
if self.logic == None:
return True # trivial success
if phrs == None:
print >> sys.stderr , 'null phrase:' , self
return False
# print 'run semantics for phr' , phrs.krnl.seqn , 'rule=' , phrs.krnl.rule.seqn
cntx.pushStack() # ready for any local variables
# print 'pnam=' , pnam
if pnam != None: # save any procedure name for TRACE
cntx.defineLocalVariable(PNAM,pnam)
code = Code(self.logic) # get code of procedure to run
# generativeDefiner.showCode(self.logic)
status = True # success flag to be return
while status:
op = code.next() # iterate on operations in code
# print 'op=' , op , 'code @' + str(code.index)
if op < 0: break # op codes are non-negative numeric
if op == semanticCommand.Gnoop: # no op
pass
elif op == semanticCommand.Gretn: # successful return
# print 'return'
break
elif op == semanticCommand.Gfail: # unsuccessful return
print >> sys.stderr , 'generative semantic FAIL'
status = False
elif op == semanticCommand.Gleft: # go to procedure for left descendant
if phrs.krnl.lftd == None:
print >> sys.stderr , 'no left descendant for:' , phrs
status = False
else:
# print 'to left descendant'
status = phrs.krnl.lftd.krnl.rule.gens.doRun(cntx,phrs.krnl.lftd)
elif op == semanticCommand.Grght: # go to procedure for right descendant, or left
# print 'descent from' , phrs
if phrs.krnl.rhtd == None:
if phrs.krnl.lftd == None:
print >> sys.stderr , 'no descendants for:' , phrs
status = False
# print 'to left descendant instead'
status = phrs.krnl.lftd.krnl.rule.gens.doRun(cntx,phrs.krnl.lftd)
else:
# print 'to right descendant'
status = phrs.krnl.rhtd.krnl.rule.gens.doRun(cntx,phrs.krnl.rhtd)
elif op == semanticCommand.Gblnk: # insert space into output buffer
cntx.insertCharsIntoBuffer(u' ')
elif op == semanticCommand.Glnfd: # insert linefeed into output buffer
cntx.insertCharsIntoBuffer(u'\n ')
elif op == semanticCommand.Gsplt: # split off new buffer for output
cntx.splitBuffer()
# print "split",
# cntx.printStatus()
elif op == semanticCommand.Gback: # go back to previous buffer
cntx.backBuffer()
# print "back",
# cntx.printStatus()
elif op == semanticCommand.Gmrge: # merge buffers into current one
cntx.mergeBuffers()
# print "merge",
# cntx.printStatus()
elif op == semanticCommand.Gchng: # merge with substitution
ts = code.next()
ss = code.next()
cntx.mergeBuffersWithReplacement(ts,ss)
elif ( op == semanticCommand.Gchck or
op == semanticCommand.Gnchk ):
sens = (op == semanticCommand.Gchck)
ids = code.next()
ref = code.next()
val = cntx.getLocalVariable(ids)
# print "chk",ids,"[",ref,"]","[",val,"]"
# print (val in ref),sens
if (val in ref) == sens:
# print "match"
code.next()
continue
# print "no match"
code.skip() # match fails
elif op == semanticCommand.Gchkf:
refr = code.next()
dblb = phrs.krnl.semf.compound()
if ellyBits.check(dblb,refr):
code.next()
continue
code.skip() # match fails
elif op == semanticCommand.Gskip: # unconditional branch
code.skip()
elif op == semanticCommand.Gvar: # define new local variable
var = code.next()
val = code.next()
# print "var",var,"[",val,"]"
cntx.defineLocalVariable(var,val)
elif op == semanticCommand.Gpeek:
var = code.next()
sns = code.next()
val = cntx.peekIntoBuffer(nxtb=sns)
cntx.setLocalVariable(var,val)
elif ( op == semanticCommand.Gset or
op == semanticCommand.Gextl or
op == semanticCommand.Gextr ):
var = code.next() # set a local variable
if op == semanticCommand.Gset:
val = code.next() # from string
elif op == semanticCommand.Gextl:
val = cntx.extractCharsFromBuffer(code.next(),1) # from buffer chars
else:
val = cntx.extractCharsFromBuffer(code.next(),0) # from buffer chars
# print 'val=' , val
cntx.setLocalVariable(var,val)
elif ( op == semanticCommand.Ginsr or
op == semanticCommand.Ginsn ):
var = code.next() # insert value local variable into buffer
s = cntx.getLocalVariable(var)
if s != '':
if op == semanticCommand.Ginsn:
cntx.insertCharsIntoBuffer(s,1)
else:
cntx.insertCharsIntoBuffer(s,0)
elif op == semanticCommand.Gshft: # shift text between buffers
cntx.moveCharsBufferToBuffer(code.next())
elif op == semanticCommand.Gdele: # delete text from buffers
cntx.deleteCharsFromBuffer(code.next())
elif op == semanticCommand.Gdelt: # delete to subsequence
s = code.next()
t = code.next()
if t > 0:
cntx.deleteCharsInBufferTo(s)
else:
cntx.deleteCharsInBufferFrom(s)
elif op == semanticCommand.Gstor: # save deletion to variable
var = code.next() # set a local variable from string
nde = code.next() # deletion count
# print 'var=',var,'nde=',nde
val = cntx.getDeletion() # last deleted sequence
# print 'val=',val
if abs(nde) >= len(val):
val = [ ] # set to empty sequence
elif nde > 0:
val = val[:-nde] # drop final chars
elif nde < 0:
val = val[-nde:] # drop initial chars
cntx.setLocalVariable(var,val) # set variable to deleted string
elif op == semanticCommand.Gfnd: # find sequence in buffer
cntx.findCharsInBuffer(code.next(),code.next())
elif op == semanticCommand.Gpick: # use local variable to select text
var = code.next() # to insert into buffer
s = cntx.getLocalVariable(var)
# print 'pick with',s
dct = code.next()
# print 'in',dct
if not s in dct:
if '' in dct:
s = ''
else:
continue
cntx.insertCharsIntoBuffer(dct[s])
elif op == semanticCommand.Gappd: # append explicit text to buffer
s = code.next()
cntx.insertCharsIntoBuffer(s)
elif op == semanticCommand.Gget: # assign global value to local variable
var = code.next()
gvn = code.next()
cntx.setLocalVariable(var,cntx.getGlobalVariable(gvn))
elif op == semanticCommand.Gput: # assign value of local variable to global
var = code.next()
gvn = code.next()
cntx.setGlobalVariable(gvn,cntx.getLocalVariable(var))
elif op == semanticCommand.Gassg: # assign one local variable to another
dst = code.next() # note order difference here!
src = code.next()
cntx.setLocalVariable(dst,cntx.getLocalVariable(src))
elif op == semanticCommand.Gque: # queue up or count down iteration
dst = code.next() # note order difference here!
src = code.next()
cno = code.next() # > 0 for QUEUE, < 0 for UNQUEUE
val = cntx.getLocalVariable(src)
if len(val) == 0: # src is empty string?
if cno == 0: continue # if so, do nothing for QUEUE
it = '' # otherwise set dst to ''
elif cno <= 0:
# print 'dst=',dst
it = cntx.getLocalVariable(dst) + val # QUEUE concatenates
else:
if cno > len(val): # UNQUEUE pops up to n chars for dst
cno = len(val)
it = val[:cno]
cntx.setLocalVariable(src,val[cno:])
cntx.setLocalVariable(dst,it) # new value for dst
# print 'op=',op,'dst=',it
elif op in [semanticCommand.Gunio,semanticCommand.Gintr,semanticCommand.Gcomp]:
dst = code.next() # note order difference here!
src = code.next()
# print 'dst=',dst,'src=',src
dv = cntx.getLocalVariable(dst)
sv = cntx.getLocalVariable(src)
# print 'op=',op,'dv=',dv,'sv=',sv
lstd = [ ] if len(dv) == 0 else dv.split(LSTJ)
lsts = [ ] if len(sv) == 0 else sv.split(LSTJ)
ls = [ ]
if op == semanticCommand.Gunio: # union of two list values
for x in lsts:
if not x in lstd:
lstd.append(x)
ls = lstd
elif op == semanticCommand.Gintr: # intersection of two list values
for x in lsts:
if x in lstd:
ls.append(x)
else: # complement of list value
for x in lstd:
if not x in lsts:
ls.append(x)
js = LSTJ.join(ls)
# print 'ls=',ls,'js=',js
cntx.setLocalVariable(dst,js)
elif op == semanticCommand.Gobtn: # obtain string for current parse position
tok = cntx.getNthTokenInListing(phrs.krnl.posn)
# print 'obtain: ' , tok.toUnicode()
cntx.insertCharsIntoBuffer(tok.toUnicode())
elif op == semanticCommand.Gcapt: # capitalize first char in buffer
c = cntx.extractCharsFromBuffer()
if c != '':
cntx.insertCharsIntoBuffer(c.upper(),1)
elif op == semanticCommand.Gucpt: # capitalize first char in buffer
c = cntx.extractCharsFromBuffer()
if c != '':
cntx.insertCharsIntoBuffer(c.lower(),1)
elif op == semanticCommand.Gtrce: # show phrase info to trace execution
cat = cntx.syms.getSyntaxTypeName(phrs.krnl.typx)
brn = 1 if isinstance(phrs.krnl.rule,grammarRule.ExtendingRule) else 2
pnam = cntx.getLocalVariable(PNAM)
fm = u'TRACE @{0:d} type={1:s} rule={2:d} ({3:d}-br)'
fs = fm.format(phrs.krnl.posn,cat,phrs.krnl.rule.seqn,brn)
sys.stderr.write(fs)
sys.stderr.flush()
cntx.printStatus(pnam)
elif op == semanticCommand.Gshow: # show local variable
vr = code.next()
ms = code.next()
st = despace(cntx.getLocalVariable(vr))
fm = u'SHOW @phr {0:d} : [{1:s}] VAR {2:s}= [{3:s}]'
fs = fm.format(phrs.krnl.seqn,ms,vr,st)
sys.stderr.write(fs)
sys.stderr.write('\n')
sys.stderr.flush()
elif op == semanticCommand.Gview: # show current and new buffers partially
nc = code.next()
cbl , nbl = cntx.viewBufferDivide(nc)
fm = u'VIEW @phr {0:d} : {1:s} | {2:s}\n'
st = fm.format(phrs.krnl.seqn,str(cbl),str(nbl))
sys.stderr.write(st)
sys.stderr.flush()
elif op == semanticCommand.Gproc: # semantic subprocedure
name = code.next()
# print >> sys.stderr , 'run procedure (' + name + ')'
if name == '': continue # null procedure is no operation`
proc = cntx.getProcedure(name)
if proc == None:
print >> sys.stderr , 'unknown subprocedure name' , name
status = False
else:
status = proc.run(cntx,phrs,name)
else:
print >> sys.stderr , GenerativeProcedure._error , 'op=' , op
status = False
cntx.popStack() # undefine local variables for procedure
return status
def score(self, cntx, phrs):
"""
compute plausibility score
arguments:
self -
cntx - interpretive context
phrs - associated phrase
returns:
integer plausibility score
"""
if self.logic == None: return 0
# print 'cognitive scoring: phrs=' , phrs
trce = False # enable diagnostic tracing
clno = 0 # clause index
psum = 0 # to accumulate plausibility score
for cls in self.logic: # go through all clauses
clno += 1
# print 'clno=' , clno
for p in cls[0]: # go through all predicates of clause
op = p[0]
if op == semanticCommand.Ctrc:
print >> sys.stderr, ''
print >> sys.stderr, ' at phrase', phrs.krnl.seqn, ': rule=', phrs.krnl.rule.seqn,
print >> sys.stderr, 'with current bias= ', phrs.krnl.rule.bias
print >> sys.stderr, ' l:', phrs.krnl.lftd
print >> sys.stderr, ' r:', phrs.krnl.rhtd
trce = True
break
elif op == semanticCommand.Clftf or op == semanticCommand.Crhtf:
# test features of descendants
if phrs.krnl.lftd == None: break
dph = (phrs.krnl.lftd if op == semanticCommand.Clftf
or phrs.krnl.rhtd == None else phrs.krnl.rhtd)
bts = dph.krnl.semf.compound()
if not ellyBits.check(p[1], bts): break
elif op == semanticCommand.Clftc or op == semanticCommand.Crhtc:
# check concepts of descendants
if phrs.krnl.lftd == None: break
if cntx == None:
print >> sys.stderr, ' no context for conceptual hierarchy'
break
dph = (phrs.krnl.lftd if op == semanticCommand.Clftc
or phrs.krnl.rhtd == None else phrs.krnl.rhtd)
cnc = dph.krnl.cncp
cx = p[1] # concepts to check against
mxw = -1
mxc = None
for c in cx:
w = cntx.wghtg.hiery.isA(cnc, c)
if mxw < w:
mxw = w
mxc = c
if mxw < 0: break
cntx.wghtg.noteConcept(mxc)
else:
# unknown command
print >> sys.stderr, 'bad cog sem action=', op
break
else: # execute actions of clause if ALL predicates satisfied
if trce:
ncls = len(self.logic)
print >> sys.stderr, ' cog sem at clause', clno, 'of', ncls
# print >> sys.stderr , ' =' , cls[1]
for a in cls[1]: # get next action
op = a[0]
if op == semanticCommand.Cadd: # add to score?
psum += a[1]
elif op == semanticCommand.Csetf: # set semantic features?
phrs.krnl.semf.combine(a[1])
elif op == semanticCommand.Crstf: # reset semantic features?
phrs.krnl.semf.reset(a[1])
elif op == semanticCommand.Csetc: # set concepts?
phrs.krnl.cncp = a[1]
elif phrs.krnl.lftd == None:
pass
elif op == semanticCommand.Clhr: # inherit from left descendant?
phrs.krnl.semf.combine(phrs.krnl.lftd.krnl.semf)
phrs.krnl.cncp = phrs.krnl.lftd.krnl.cncp
elif op == semanticCommand.Crhr: # inherit from right?
dsc = phrs.krnl.rhtd if phrs.krnl.rhtd != None else phrs.krnl.lftd
phrs.krnl.semf.combine(dsc.krnl.semf)
phrs.krnl.cncp = dsc.krnl.cncp
# if trce:
# print >> sys.stderr , '->' , phr.krnl.semf
break # ignore subsequent clauses on taking action
inc = 0 # compute conceptual contribution
rwy = phrs.krnl.rule.nmrg
# print >> sys.stderr , 'conceptual plausibility'
if rwy == 2: # 2-branch splitting rule?
# print '2-branch!'
inc = cntx.wghtg.relateConceptPair(phrs.krnl.lftd.krnl.cncp,
phrs.krnl.rhtd.krnl.cncp)
# print >> sys.stderr , phrs.krnl.lftd.krnl.cncp , ':' , phrs.krnl.rhtd.krnl.cncp , '=' , inc , '!'
if inc > 1:
phrs.krnl.ctxc = cntx.wghtg.getIntersection()
# print >> sys.stderr , '2-way bias incr=' , inc
elif phrs.krnl.lftd != None: # 1-branch extending rule?
# print >> sys.stderr , '1-branch!'
dst = cntx.wghtg.interpretConcept(phrs.krnl.lftd.krnl.cncp)
if dst > 0:
phrs.krnl.ctxc = cntx.wghtg.getIntersection()
inc = 1
# print >> sys.stderr , '1-way bias incr=' , inc
if inc > 0: psum += inc # only positive increments contribute
# print >> sys.stderr , 'phrase' , phrs.krnl.seqn, 'intersect=' , phrs.krnl.ctxc
if trce:
print >> sys.stderr, ' incremental scoring=', psum,
print >> sys.stderr, 'sem[' + phrs.krnl.semf.hexadecimal() + ']'
return psum
def run ( self , code , cntx , phrs , pnam=None ):
"""
execute a generative procedure in context
arguments:
self -
code - actual generative semantics to run
cntx - interpretive context
phrs - phrase to which procedure is attached
pnam - procedure name to associate with call
returns:
True on success, False otherwise
"""
if code == None:
return True # trivial success
if phrs == None:
print >> sys.stderr , 'null phrase:' , self
return False
# print 'run code =' , code
# if len(code.lstg) > 4:
# generativeDefiner.showCode(code.lstg)
# print 'run semantics for phr' , phrs.krnl.seqn , 'rule=' , phrs.krnl.rule.seqn
cntx.pushStack() # ready for any local variables
# print 'pnam=' , pnam
if pnam != None: # save any procedure name for TRACE
cntx.defineLocalVariable(PNAM,pnam)
status = True # success flag to be return
while status:
op = code.next() # iterate on operations in code
# print 'op=' , op , 'code @' + str(code.index)
if op < 0: break # op codes are non-negative numeric
if op == semanticCommand.Gnoop: # no op
pass
elif op == semanticCommand.Gretn: # successful return
# print 'return'
break
elif op == semanticCommand.Gfail: # unsuccessful return
print >> sys.stderr , 'generative semantic FAIL'
status = False
elif op == semanticCommand.Gleft: # go to procedure for left descendant
if phrs.krnl.lftd == None:
print >> sys.stderr , 'no left descendant for:' , phrs
status = False
else:
# print 'to left descendant'
status = phrs.krnl.lftd.krnl.rule.gens.doRun(cntx,phrs.krnl.lftd)
elif op == semanticCommand.Grght: # go to procedure for right descendant, or left
# print 'descent from' , phrs
if phrs.krnl.rhtd == None:
if phrs.krnl.lftd == None:
print >> sys.stderr , 'no descendants for:' , phrs
status = False
# print 'to left descendant instead'
status = phrs.krnl.lftd.krnl.rule.gens.doRun(cntx,phrs.krnl.lftd)
else:
# print 'to right descendant'
status = phrs.krnl.rhtd.krnl.rule.gens.doRun(cntx,phrs.krnl.rhtd)
elif op == semanticCommand.Gblnk: # insert space into output buffer
cntx.insertCharsIntoBuffer(u' ')
elif op == semanticCommand.Glnfd: # insert linefeed into output buffer
cntx.insertCharsIntoBuffer(u'\n ')
elif op == semanticCommand.Gsplt: # split off new buffer for output
cntx.splitBuffer()
# print "split",
# cntx.printStatus()
elif op == semanticCommand.Gback: # go back to previous buffer
cntx.backBuffer()
# print "back",
# cntx.printStatus()
elif op == semanticCommand.Gmrge: # merge buffers into current one
cntx.mergeBuffer()
# print "merge",
# cntx.printStatus()
elif op == semanticCommand.Gchng: # merge with substitution
ts = code.next()
ss = code.next()
cntx.mergeBufferWithReplacement(ts,ss)
elif ( op == semanticCommand.Gchck or
op == semanticCommand.Gnchk ):
sens = (op == semanticCommand.Gchck)
ids = code.next()
ref = code.next()
val = cntx.getLocalVariable(ids)
# print "chk",ids,"[",ref,"]","[",val,"]"
# print (val in ref),sens
if (val in ref) == sens:
# print "match"
code.next()
continue
# print "no match"
code.skip() # match fails
elif op == semanticCommand.Gchkf:
refr = code.next()
dblb = phrs.krnl.semf.compound()
if ellyBits.check(dblb,refr):
code.next()
continue
code.skip() # match fails
elif op == semanticCommand.Gskip: # unconditional branch
code.skip()
elif op == semanticCommand.Gvar: # define new local variable
var = code.next()
val = code.next()
# print "var",var,"[",val,"]"
cntx.defineLocalVariable(var,val)
elif op == semanticCommand.Gpeek:
var = code.next()
sns = code.next()
val = cntx.peekIntoBuffer(nxtb=sns)
cntx.setLocalVariable(var,val)
elif ( op == semanticCommand.Gset or
op == semanticCommand.Gextl or
op == semanticCommand.Gextr ):
var = code.next() # set a local variable
if op == semanticCommand.Gset:
val = code.next() # from string
elif op == semanticCommand.Gextl: # source is current buffer
val = cntx.extractCharsFromBuffer(code.next(),m=0) # get buffer chars
else: # source is next buffer
val = cntx.extractCharsFromBuffer(code.next(),m=1) # get buffer chars
# print 'val=' , val
cntx.setLocalVariable(var,val)
elif ( op == semanticCommand.Ginsr or
op == semanticCommand.Ginsn ):
var = code.next() # insert value local variable into buffer
s = cntx.getLocalVariable(var)
if s != '':
if op == semanticCommand.Ginsn:
cntx.insertCharsIntoBuffer(s,m=1)
else:
cntx.insertCharsIntoBuffer(s,m=0)
elif op == semanticCommand.Gshft: # shift text between buffers
cntx.moveCharsBufferToBuffer(code.next())
elif op == semanticCommand.Gdele: # delete text from buffers
cntx.deleteCharsFromBuffer(code.next())
elif op == semanticCommand.Gdelt: # delete to subsequence
s = code.next()
t = code.next()
if t > 0:
cntx.deleteCharsInBufferTo(s)
else:
cntx.deleteCharsInBufferFrom(s)
elif op == semanticCommand.Gstor: # save deletion to variable
var = code.next() # set a local variable from string
nde = code.next() # deletion count
# print 'var=',var,'nde=',nde
val = cntx.getDeletion() # last deleted sequence
# print 'val=',val
if abs(nde) >= len(val):
val = [ ] # set to empty sequence
elif nde > 0:
val = val[:-nde] # drop final chars
elif nde < 0:
val = val[-nde:] # drop initial chars
cntx.setLocalVariable(var,val) # set variable to deleted string
elif op == semanticCommand.Gfnd: # find sequence in buffer
cntx.findCharsInBuffer(code.next(),code.next())
elif op == semanticCommand.Galgn: # align buffer to start of line
sens = code.next() # direction of alignment
cntx.findCharsInBuffer('\n',sens)
if sens:
if cntx.peekIntoBuffer(False) == '\n':
cntx.moveCharsBufferToBuffer(1) # move over expected space after \n
else:
if cntx.peekIntoBuffer(True) == '\n':
cntx.moveCharsBufferToBuffer(2) # move \n + space to current buffer
elif op == semanticCommand.Gpick: # use local variable to select text
var = code.next() # to insert into buffer
s = cntx.getLocalVariable(var)
# print 'pick with',s
dct = code.next()
# print 'in',dct
if not s in dct:
if '' in dct:
s = ''
else:
continue
cntx.insertCharsIntoBuffer(dct[s])
elif op == semanticCommand.Gappd: # append explicit text to current buffer
s = code.next()
cntx.insertCharsIntoBuffer(s)
elif op == semanticCommand.Gget: # assign global value to local variable
var = code.next()
gvn = code.next()
cntx.setLocalVariable(var,cntx.getGlobalVariable(gvn))
elif op == semanticCommand.Gput: # assign value of local variable to global
var = code.next()
gvn = code.next()
cntx.setGlobalVariable(gvn,cntx.getLocalVariable(var))
elif op == semanticCommand.Gassg: # assign one local variable to another
dst = code.next() # note order difference here!
src = code.next()
cntx.setLocalVariable(dst,cntx.getLocalVariable(src))
elif op == semanticCommand.Gque: # queue up or count down iteration
dst = code.next() # note order difference here!
src = code.next()
cno = code.next() # > 0 for QUEUE, < 0 for UNQUEUE
val = cntx.getLocalVariable(src)
if len(val) == 0: # src is empty string?
if cno == 0: continue # if so, do nothing for QUEUE
it = '' # otherwise set dst to ''
elif cno <= 0:
# print 'dst=',dst
it = cntx.getLocalVariable(dst) + val # QUEUE concatenates
else:
if cno > len(val): # UNQUEUE pops up to n chars for dst
cno = len(val)
it = val[:cno]
cntx.setLocalVariable(src,val[cno:])
cntx.setLocalVariable(dst,it) # new value for dst
# print 'op=',op,'dst=',it
elif op in [semanticCommand.Gunio,semanticCommand.Gintr,semanticCommand.Gcomp]:
dst = code.next() # note order difference here!
src = code.next()
# print 'dst=',dst,'src=',src
dv = cntx.getLocalVariable(dst)
sv = cntx.getLocalVariable(src)
# print 'op=',op,'dv=',dv,'sv=',sv
lstd = [ ] if len(dv) == 0 else dv.split(LSTJ)
lsts = [ ] if len(sv) == 0 else sv.split(LSTJ)
ls = [ ]
if op == semanticCommand.Gunio: # union of two list values
for x in lsts:
if not x in lstd:
lstd.append(x)
ls = lstd
elif op == semanticCommand.Gintr: # intersection of two list values
for x in lsts:
if x in lstd:
ls.append(x)
else: # complement of list value
for x in lstd:
if not x in lsts:
ls.append(x)
js = LSTJ.join(ls)
# print 'ls=',ls,'js=',js
cntx.setLocalVariable(dst,js)
elif op == semanticCommand.Gobtn: # obtain string for current parse position
tok = cntx.getNthTokenInListing(phrs.krnl.posn)
# print 'obtain: ' , tok.toUnicode()
cntx.insertCharsIntoBuffer(tok.toUnicode())
elif op == semanticCommand.Gcapt: # capitalize first char in next buffer
c = cntx.extractCharsFromBuffer(m=1)
if c != '':
cntx.insertCharsIntoBuffer(c.upper(),m=1)
elif op == semanticCommand.Gucpt: # uncapitalize first char in next buffer
c = cntx.extractCharsFromBuffer(m=1)
if c != '':
cntx.insertCharsIntoBuffer(c.lower(),m=1)
elif op == semanticCommand.Gtrce: # show phrase info to trace execution
cat = cntx.syms.getSyntaxTypeName(phrs.krnl.typx)
brn = 1 if isinstance(phrs.krnl.rule,grammarRule.ExtendingRule) else 2
pnam = cntx.getLocalVariable(PNAM)
fm = u'TRACE @{0:d} type={1:s} rule={2:d} ({3:d}-br)'
fs = fm.format(phrs.krnl.posn,cat,phrs.krnl.rule.seqn,brn)
sys.stderr.write(fs)
sys.stderr.flush()
cntx.printStatus(pnam)
elif op == semanticCommand.Gshow: # show local variable
vr = code.next()
ms = code.next()
st = despace(cntx.getLocalVariable(vr))
fm = u'SHOW @phr {0:d} : [{1:s}] VAR {2:s}= [{3:s}]'
fs = fm.format(phrs.krnl.seqn,ms,vr,st)
sys.stderr.write(fs)
sys.stderr.write('\n')
sys.stderr.flush()
elif op == semanticCommand.Gview: # show current and new buffers partially
nc = code.next()
cbl , nbl = cntx.viewBufferDivide(nc)
cbn = cntx.getCurrentBuffer()
fm = u'VIEW ={0:2d} @phr {1:d} : {2:s} | {3:s}\n'
st = fm.format(cbn,phrs.krnl.seqn,str(cbl),str(nbl))
sys.stderr.write(st)
sys.stderr.flush()
elif op == semanticCommand.Gproc: # semantic subprocedure
name = code.next()
# print >> sys.stderr , 'run procedure (' + name + ')' , 'in' , phrs
if name == '': continue # null procedure is no operation`
proc = cntx.getProcedure(name) # generative semantics object
if proc == None:
print >> sys.stderr , 'unknown subprocedure name' , name
status = False
else:
status = proc.run(Code(proc.logic),cntx,phrs,name)
else:
print >> sys.stderr , '** unknown generative semantic op=' , op , 'in' , phrs
status = False
cntx.popStack() # undefine local variables for procedure
return status
def score(self, cntx, phrs):
"""
compute plausibility score
arguments:
self -
cntx - interpretive context
phrs - associated phrase
returns:
integer plausibility score
"""
if self.logic == None: return 0
# print ( 'cognitive scoring: phrs=' , phrs )
trce = False # enable diagnostic tracing
clno = 0 # clause index
psum = 0 # to accumulate plausibility score
for cls in self.logic: # go through all clauses
clno += 1
# print ( 'clno=' , clno )
for p in cls[0]: # go through all predicates of clause
op = p[0]
# print ( 'cog sem op=' , op )
if op == semanticCommand.Ctrc:
print(' at phrase',
phrs.krnl.seqn,
': rule=',
phrs.krnl.rule.seqn,
end=' ',
file=sys.stderr)
print('with current bias= ',
phrs.krnl.rule.bias,
file=sys.stderr)
print(' l:', phrs.krnl.lftd, file=sys.stderr)
print(' r:', phrs.krnl.rhtd, file=sys.stderr)
print(' ',
phrs.ntok,
'token(s) spanned',
end=' ',
file=sys.stderr)
print('@' + str(phrs.krnl.posn), file=sys.stderr)
print(file=sys.stderr)
trce = True
break
elif op == semanticCommand.Clftf or op == semanticCommand.Crhtf:
# test features of descendants
# print ( 'op=' , p , file=sys.stderr )
if phrs.krnl.lftd == None: break
# print ('lftd=' , phrs.krnl.lftd.krnl.seqn , file=sys.stderr )
dph = (phrs.krnl.lftd if op == semanticCommand.Clftf
or phrs.krnl.rhtd == None else phrs.krnl.rhtd)
# print ( 'dph=' , dph , file=sys.stderr )
bts = dph.krnl.semf.compound()
# print ( 'bts=' , bts , file=sys.stderr )
# print ( 'cnd=' , p[1] , file=sys.stderr )
if not ellyBits.check(p[1], bts): break
elif op == semanticCommand.Clftc or op == semanticCommand.Crhtc:
# check concepts of descendants
if phrs.krnl.lftd == None: break
if cntx == None:
print(' no context for conceptual hierarchy',
file=sys.stderr)
break
dph = (phrs.krnl.lftd if op == semanticCommand.Clftc
or phrs.krnl.rhtd == None else phrs.krnl.rhtd)
cnc = dph.krnl.cncp
cx = p[1] # concepts to check against
mxw = -1
mxc = None
for c in cx:
w = cntx.wghtg.hiery.isA(cnc, c)
if mxw < w:
mxw = w
mxc = c
if mxw < 0: break
cntx.wghtg.noteConcept(mxc)
elif op == semanticCommand.Cngt or op == semanticCommand.Cnlt:
# check token count of evaluated phrase
nt = phrs.ntok
nm = p[1]
if op == semanticCommand.Cngt:
if nt <= nm: break
else:
if nt >= nm: break
elif op == semanticCommand.Cpgt or op == semanticCommand.Cplt:
# check position of evaluated phrase
po = phrs.krnl.posn
nm = p[1]
# print ( 'po=' , po , 'nm=' ,nm )
if op == semanticCommand.Cpgt:
if po <= nm: break
else:
if po >= nm: break
# print ( 'no break' )
elif op == semanticCommand.Ccgt or op == semanticCommand.Cclt:
# check token count of evaluated phrase
nc = phrs.lens
nm = p[1]
if op == semanticCommand.Ccgt:
if nc <= nm: break
else:
if nc >= nm: break
else:
# unknown command
print('bad cog sem action=', op, file=sys.stderr)
break
else: # execute actions of clause if ALL predicates satisfied
if trce:
ncls = len(self.logic)
print(' cog sem at clause',
clno,
'of',
ncls,
file=sys.stderr)
# print ( ' =' , cls[1] , file=sys.stderr )
print(file=sys.stderr)
for a in cls[1]: # get next action
op = a[0]
if op == semanticCommand.Cadd: # add to score?
psum += a[1]
elif op == semanticCommand.Csetf: # set semantic features?
phrs.krnl.semf.combine(a[1])
elif op == semanticCommand.Crstf: # reset semantic features?
phrs.krnl.semf.reset(a[1])
elif op == semanticCommand.Csetc: # set concepts?
phrs.krnl.cncp = a[1]
elif phrs.krnl.lftd == None:
pass
elif op == semanticCommand.Clhr: # inherit from left descendant?
phrs.krnl.semf.combine(phrs.krnl.lftd.krnl.semf)
phrs.krnl.cncp = phrs.krnl.lftd.krnl.cncp
elif op == semanticCommand.Crhr: # inherit from right?
dsc = phrs.krnl.rhtd if phrs.krnl.rhtd != None else phrs.krnl.lftd
phrs.krnl.semf.combine(dsc.krnl.semf)
phrs.krnl.cncp = dsc.krnl.cncp
# if trce:
# print ( '->' , phr.krnl.semf , file=sys.stderr )
break # ignore subsequent clauses on taking action
inc = 0 # compute conceptual contribution
rwy = phrs.krnl.rule.nmrg
# print ( 'conceptual plausibility' , file=sys.stderr )
if rwy == 2: # 2-branch splitting rule?
# print ( '2-branch!' )
inc = cntx.wghtg.relateConceptPair(phrs.krnl.lftd.krnl.cncp,
phrs.krnl.rhtd.krnl.cncp)
# print ( phrs.krnl.lftd.krnl.cncp , ':' , phrs.krnl.rhtd.krnl.cncp , '=' , inc , '!' , file=sys.stderr )
if inc > 1:
phrs.krnl.ctxc = cntx.wghtg.getIntersection()
# print ( '2-way bias incr=' , inc , file=sys.stderr )
elif phrs.krnl.lftd != None: # 1-branch extending rule?
# print ( '1-branch!' , file=sys.stderr )
dst = cntx.wghtg.interpretConcept(phrs.krnl.lftd.krnl.cncp)
if dst > 0:
phrs.krnl.ctxc = cntx.wghtg.getIntersection()
inc = 1
# print ( '1-way bias incr=' , inc , file=sys.stderr )
if inc > 0: psum += inc # only positive increments contribute
# print ( 'phrase' , phrs.krnl.seqn, 'intersect=' , phrs.krnl.ctxc , file=sys.stderr )
if trce:
print(' raw plausibility=', phrs.krnl.bias, file=sys.stderr)
print(' adjustment=', psum, end=' ', file=sys.stderr)
print('sem[' + phrs.krnl.semf.hexadecimal() + ']', file=sys.stderr)
print(file=sys.stderr)
return psum
def score ( self , cntx , phrs ):
"""
compute plausibility score
arguments:
self -
cntx - interpretive context
phrs - associated phrase
returns:
integer plausibility score
"""
if self.logic == None: return 0
# print 'cognitive scoring'
psum = 0 # to accumulate plausibility score
for cls in self.logic: # go through all clauses
for p in cls[0]: # go through all predicates of clause
op = p[0]
if op == semanticCommand.Clftf or op == semanticCommand.Crhtf:
# test features of descendants
dph = phrs.lftd if op == semanticCommand.Clftf else phrs.rhtd
bts = dph.semf.compound()
if not ellyBits.check(p[1],bts): break
elif op == semanticCommand.Clftc or op == semanticCommand.Crhtc:
# check concepts of descendants
dph = phrs.lftd if op == semanticCommand.Clftc else phrs.rhtd
cnc = dph.cons
cx = p[1] # concepts to check against
mxw = -1
mxc = None
for c in cx:
w = cntx.wghtg.hier.isA(cnc,c)
if mxw < w:
mxw = w
mxc = c
if mxw < 0: break
cntx.wghtg.noteConcept(mxc)
else:
# unknown command
print >> sys.stderr , 'bad cog sem action=' , op
break
else: # execute actions of clause if ALL predicates satisfied
for a in cls[1]: # get mext action
op = a[0]
if op == semanticCommand.Cadd: # add to score?
psum += a[1]
elif op == semanticCommand.Clhr: # inherit from left descendant?
phrs.semf.combine(phrs.lftd.semf)
phrs.cncp = phrs.lftd.cncp
elif op == semanticCommand.Crhr: # inherit from right?
phrs.semf.combine(phrs.rhtd.semf)
phrs.cncp = phrs.rhtd.cncp
elif op == semanticCommand.Csetf: # set semantic features?
phrs.semf.combine(a[1])
elif op == semanticCommand.Csetc: # set concepts?
phrs.cncp = a[1]
break # ignore subsequent clauses on taking action
inc = 0 # compute conceptual contribution
rwy = phrs.rule.nmrg
# print >> sys.stderr , 'conceptual plausibility'
if rwy == 2: # 2-branch splitting rule?
# print '2-branch!'
inc = cntx.wghtg.relateConceptPair(phrs.lftd.cncp,phrs.rhtd.cncp)
# print >> sys.stderr , phrs.lftd.cncp , ':' , phrs.rhtd.cncp , '=' , inc , '!'
if inc > 1:
phrs.ctxc = cntx.wghtg.getIntersection()
# print >> sys.stderr , '2-way bias incr=' , inc
elif phrs.lftd != None: # 1-branch extending rule?
# print >> sys.stderr , '1-branch!'
dst = cntx.wghtg.interpretConcept(phrs.lftd.cncp)
if dst > 0:
phrs.ctxc = cntx.wghtg.getIntersection()
inc = 1
# print >> sys.stderr , '1-way bias incr=' , inc
if inc > 0: psum += inc # only positive increments contribute
# print >> sys.stderr , 'phrase' , phrs.seqn, 'intersect=' , phrs.ctxc
return psum
