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