def getRules ( self , a ):
"""
get appropriate macros for text with specified starting char
arguments:
self -
a - first letter of current buffer contents (NOT space!)
returns:
a list of unpacked macro rules to try out
"""
# print 'getRules(a=' , a , ')'
if a == '': return [ ]
if ellyChar.isLetterOrDigit(a):
k = ellyChar.toIndex(a)
ls = self.index[k]
# print 'index a=' , a , 'k=' , k
ws = self.letWx if ellyChar.isLetter(a) else self.digWx
uniqueAdd(ls,ws)
uniqueAdd(ls,self.anyWx)
elif ellyChar.isApostrophe(a):
ls = self.apoWx
else:
ls = self.index[0]
uniqueAdd(ls,self.anyWx)
# print len(ls) , ' rules to check'
return [ r.unpack() for r in ls ]
def getRules(self, a):
"""
get appropriate macros for text with specified starting char
arguments:
self -
a - first letter of current buffer contents (NOT space!)
returns:
a list of unpacked macro rules to try out
"""
# print ( 'getRules(a=' , a , ')' )
if a == '': return []
if ellyChar.isLetterOrDigit(a):
k = ellyChar.toIndex(a)
ls = self.index[k]
# print ( 'index a=' , a , 'k=' , k )
ws = self.letWx if ellyChar.isLetter(a) else self.digWx
uniqueAdd(ls, ws)
uniqueAdd(ls, self.anyWx)
elif ellyChar.isApostrophe(a):
ls = self.apoWx
else:
ls = self.index[0]
uniqueAdd(ls, self.anyWx)
# print ( len(ls) , ' rules to check' )
return [r.unpack() for r in ls]
def getRules ( self , a ):
"""
get appropriate macros for text starting with specified first char
arguments:
self -
a - first letter of current buffer contents (NOT space!)
returns:
a list of macro rules to try out
"""
if a == '': return [ ]
if ellyChar.isLetterOrDigit(a):
k = ellyChar.toIndex(a)
ws = self.letWx if ellyChar.isLetter(a) else self.digWx
ls = self.index[k] + ws + self.anyWx
else:
ls = self.index[0] + self.anyWx
return ls
def _store ( self , defs , nowarn ):
"""
put macro substitutions into table with indexing by first char of pattern
arguments:
self -
defs - list of macro definition as strings
nowarn - whether to turn warnings off
exceptions:
TableFailure on error
"""
while True:
l = defs.readline() # next macro rule
# print "rule input=" , l
if len(l) == 0: break # EOF check
dl = definitionLine.DefinitionLine(l,False)
left = dl.left # pattern to be matched
tail = dl.tail # transformation to apply to match
if left == None or tail == None:
self._err(l=l)
continue
mp = ellyWildcard.convert(left)
if mp == None:
self._err('bad wildcards',l)
continue
pe = mp[-1]
if pe != ellyWildcard.cALL and pe != ellyWildcard.cEND:
mp += ellyWildcard.cEND # pattern must end in $ if it does not end in *
if not _checkBindings(mp,tail):
self._err('bad bindings in substitution',l)
continue
if not nowarn and not _checkExpansion(mp,tail):
self._err('substitution longer than original string',l,0)
r = [ mp , tail ]
# print "rule =" , [ left , tail ]
pat = r[0] # get coded pattern
if pat == None:
self._err('no pattern',l)
continue
c = pat[0] # first char of pattern
# check type to see how to index rule
# print 'c=' , ord(c)
p = pat
while c == ellyWildcard.cSOS: # optional sequence?
k = p.find(ellyWildcard.cEOS) # if so, find the end of sequence
if k < 0 or k == 1: break # if no end or empty sequence, stop
k += 1
if k == len(pat): break # should be something after sequence
m = ellyChar.toIndex(pat[1]) # index by first char of optional sequence
self.index[m].append(r) # (must be non-wildcard)
p = p[k:] # move up in pattern
c = p[0] # but check for another optional sequence
if c == ellyWildcard.cSOS:
self._err(l=l)
continue # bad sequence, skip this rule
# print 'c=' , ord(c)
if ellyChar.isLetterOrDigit(c): # check effective first char of pattern
m = ellyChar.toIndex(c)
self.index[m].append(r) # add to index under alphanumeric char
elif ellyChar.isText(c):
self.index[0].append(r) # add to index under punctuation
elif not c in ellyWildcard.Matching:
if c == ellyWildcard.cEND:
print >> sys.stderr , '** macro warning: pattern can have empty match'
print >> sys.stderr , '* at [' , l , ']'
else:
dc = '=' + str(ord(c) - ellyWildcard.X)
self._err('bad wildcard code' , dc)
continue
elif c == ellyWildcard.cANY or c == ellyWildcard.cALL:
self.anyWx.append(r) # under general wildcards
elif c == ellyWildcard.cCAN:
self.index[0].append(r) # under punctuation
elif c == ellyWildcard.cDIG or c == ellyWildcard.cSDG:
self.digWx.append(r) # under digit wildcards
elif c == ellyWildcard.cSAN:
self.digWx.append(r) # under both digit and
self.letWx.append(r) # letter wildcards
elif c == ellyWildcard.cSPC or c == ellyWildcard.cEND:
self._err('bad wildcard in context',l)
continue # wildcards unacceptable here
else:
self.letWx.append(r) # everything else under letter wildcard
self.count += 1 # count up macro substitution
if self._errcount > 0:
print >> sys.stderr , '**' , self._errcount , 'macro errors in all'
print >> sys.stderr , 'macro table definition FAILed'
raise ellyException.TableFailure
def _store ( self , defs , nowarn ):
"""
put macro substitutions into table with indexing by first char of pattern
arguments:
self -
defs - list of macro definition as strings
nowarn - whether to turn warnings off
exceptions:
TableFailure on error
"""
# print defs.linecount() , 'lines'
while True:
l = defs.readline() # next macro rule
# print "rule input=" , l
if len(l) == 0: break # EOF check
dl = definitionLine.DefinitionLine(l,False)
left = dl.left # pattern to be matched
tail = dl.tail # transformation to apply to match
# print 'dl.left=' , left
if left == None or tail == None:
self._err(l=l) # report missing part of rule
continue
if left.find(' ') >= 0: # pattern side of macro rule
ms = 'pattern in macro contains spaces'
self._err(s=ms,l=l,d=1) # cannot contain any space chars
continue
lefts = list(left)
# print 'left=' , lefts
nspm = ellyWildcard.numSpaces(lefts)
pat = ellyWildcard.convert(left) # get pattern with encoded wildcards
if pat == None:
self._err('bad wildcards',l)
continue
# print 'pat=' , ellyWildcard.deconvert(pat) , 'len=' , len(pat)
# print 'pat=' , list(pat)
pe = pat[-1]
if not pe in [ ellyWildcard.cALL , ellyWildcard.cEND , ellyWildcard.cSPC ]:
pat += ellyWildcard.cEND # pattern must end in $ if it does not end in * or _
if not _checkBindings(pat,tail):
self._err('bad bindings in substitution',l)
continue
if not nowarn and not _checkExpansion(pat,tail):
self._err('substitution may be longer than original string',l,0)
# print "rule =" , [ left , nspm , tail ]
if pat == None:
self._err('no pattern',l)
continue
r = Rule( pat , nspm , tail )
c = pat[0] # first char of pattern
# check type to see how to index rule
# print 'c=' , ellyWildcard.deconvert(c) , ', pat=' , ellyWildcard.deconvert(pat)
p = pat
while c == ellyWildcard.cSOS: # optional sequence?
if not cEOS in p:
break
k = p.index(cEOS) # if so, find the end of sequence
if k < 0 or k == 1: break # if no end or empty sequence, stop
k += 1
if k == len(pat): break # should be something after sequence
m = ellyChar.toIndex(pat[1]) # index by first char of optional sequence
self.index[m].append(r) # (must be non-wildcard)
p = p[k:] # move up in pattern
c = p[0] # but check for another optional sequence
if c == ellyWildcard.cSOS:
self._err(l=l)
continue # bad sequence, skip this rule
# print 'c=' , ord(c)
if ellyChar.isLetterOrDigit(c): # check effective first char of pattern
m = ellyChar.toIndex(c)
self.index[m].append(r) # add to index under alphanumeric char
elif ellyChar.isText(c):
self.index[0].append(r) # add to index under punctuation
elif not c in ellyWildcard.Matching:
if c == ellyWildcard.cEND:
print >> sys.stderr , '** macro warning: pattern can have empty match'
print >> sys.stderr , '* at [' , l , ']'
else:
dc = '=' + str(ord(c) - ellyWildcard.X)
self._err('bad wildcard code' , dc)
continue
elif c == ellyWildcard.cANY or c == ellyWildcard.cALL:
self.anyWx.append(r) # under general wildcards
elif c == ellyWildcard.cCAN:
self.index[0].append(r) # under punctuation
elif c == ellyWildcard.cDIG or c == ellyWildcard.cSDG:
self.digWx.append(r) # under digit wildcards
elif c == ellyWildcard.cSAN:
self.digWx.append(r) # under both digit and
self.letWx.append(r) # letter wildcards
elif c == ellyWildcard.cAPO: # right single quote or apostrophe
self.apoWx.append(r) #
elif c == ellyWildcard.cSPC or c == ellyWildcard.cEND:
self._err('bad wildcard in context',l)
continue # wildcards unacceptable here
else:
self.letWx.append(r) # everything else under letter wildcard
self.count += 1 # count up macro substitution
# print 'count=' , self.count
if self._errcount > 0:
print >> sys.stderr , '**' , self._errcount , 'macro errors in all'
print >> sys.stderr , 'macro table definition FAILed'
raise ellyException.TableFailure
def _store(self, defs, nowarn):
"""
put macro substitutions into table with indexing by first char of pattern
arguments:
self -
defs - list of macro definition as strings
nowarn - whether to turn warnings off
exceptions:
TableFailure on error
"""
# print ( defs.linecount() , 'lines' )
while True:
l = defs.readline() # next macro rule
# print ( "rule input=" , l )
if len(l) == 0: break # EOF check
dl = definitionLine.DefinitionLine(l, False)
left = dl.left # pattern to be matched
tail = dl.tail # transformation to apply to match
# print ( 'dl.left=' , left )
if left == None or tail == None:
self._err(l=l) # report missing part of rule
continue
if left.find(' ') >= 0: # pattern side of macro rule
ms = 'pattern in macro contains spaces'
self._err(s=ms, l=l, d=1) # cannot contain any space chars
continue
lefts = list(left)
# print ( 'left=' , lefts )
nspm = ellyWildcard.numSpaces(lefts)
pat = ellyWildcard.convert(
left) # get pattern with encoded wildcards
if pat == None:
self._err('bad wildcards', l)
continue
# print ( 'pat=' , ellyWildcard.deconvert(pat) , 'len=' , len(pat) )
# print ( 'pat=' , list(pat) )
pe = pat[-1]
if not pe in [
ellyWildcard.cALL, ellyWildcard.cEND, ellyWildcard.cSPC
]:
pat += ellyWildcard.cEND # pattern must end in $ if it does not end in * or _
if not _checkBindings(pat, tail):
self._err('bad bindings in substitution', l)
continue
if not nowarn and not _checkExpansion(pat, tail):
self._err('substitution may be longer than original string', l,
0)
# print ( "rule =" , [ left , nspm , tail ] )
if pat == None:
self._err('no pattern', l)
continue
r = Rule(pat, nspm, tail)
c = pat[0] # first char of pattern
# check type to see how to index rule
# print ( 'c=' , ellyWildcard.deconvert(c) , ', pat=' , ellyWildcard.deconvert(pat) )
p = pat
while c == ellyWildcard.cSOS: # optional sequence?
if not cEOS in p:
break
k = p.index(cEOS) # if so, find the end of sequence
if k < 0 or k == 1: break # if no end or empty sequence, stop
k += 1
if k == len(pat): break # should be something after sequence
m = ellyChar.toIndex(
pat[1]) # index by first char of optional sequence
self.index[m].append(r) # (must be non-wildcard)
p = p[k:] # move up in pattern
c = p[0] # but check for another optional sequence
if c == ellyWildcard.cSOS:
self._err(l=l)
continue # bad sequence, skip this rule
# print ( 'c=' , ord(c) )
if ellyChar.isLetterOrDigit(
c): # check effective first char of pattern
m = ellyChar.toIndex(c)
self.index[m].append(r) # add to index under alphanumeric char
elif ellyChar.isText(c):
self.index[0].append(r) # add to index under punctuation
elif not c in ellyWildcard.Matching:
if c == ellyWildcard.cEND:
print('** macro warning: pattern can have empty match',
file=sys.stderr)
print('* at [', l, ']', file=sys.stderr)
else:
dc = '=' + str(ord(c) - ellyWildcard.X)
self._err('bad wildcard code', dc)
continue
elif c == ellyWildcard.cANY or c == ellyWildcard.cALL:
self.anyWx.append(r) # under general wildcards
elif c == ellyWildcard.cCAN:
self.index[0].append(r) # under punctuation
elif c == ellyWildcard.cDIG or c == ellyWildcard.cSDG:
self.digWx.append(r) # under digit wildcards
elif c == ellyWildcard.cSAN:
self.digWx.append(r) # under both digit and
self.letWx.append(r) # letter wildcards
elif c == ellyWildcard.cAPO: # right single quote or apostrophe
self.apoWx.append(r) #
elif c == ellyWildcard.cSPC or c == ellyWildcard.cEND:
self._err('bad wildcard in context', l)
continue # wildcards unacceptable here
else:
self.letWx.append(r) # everything else under letter wildcard
self.count += 1 # count up macro substitution
# print ( 'count=' , self.count )
if self._errcount > 0:
print(self._errcount, 'macro errors in all', file=sys.stderr)
print('macro table definition FAILed', file=sys.stderr)
raise ellyException.TableFailure
