Changeset 5338:e92983e8b63a in livinglogic.python.xist

Show
Ignore:
Timestamp:
02/11/13 14:17:19 (7 years ago)
Author:
Walter Doerwald <walter@…>
Branch:
default
Message:

Rename _str() argument indent to level.

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • src/ll/ul4c.py

    r5337 r5338  
    302302 
    303303    @misc.notimplemented 
    304     def _str(self, indent): 
     304    def _str(self, level): 
    305305        """ 
    306         Format :var:`self` (with the indentation level :var:`indent`). 
     306        Format :var:`self` (with the indentation level :var:`level`). 
    307307 
    308308        This is used by :meth:`__str__. 
     
    359359        return "<{0.__class__.__module__}.{0.__class__.__qualname__} {0.location.code!r} at {1:#x}>".format(self, id(self)) 
    360360 
    361     def _str(self, indent): 
     361    def _str(self, level): 
    362362        yield "text {!r}\n".format(self.text()) 
    363363 
     
    378378        self.value = value 
    379379 
    380     def _str(self, indent): 
     380    def _str(self, level): 
    381381        yield _repr(self.value) 
    382382 
     
    427427                p.text("at {:#x}".format(id(self))) 
    428428 
    429     def _str(self, indent): 
     429    def _str(self, level): 
    430430        yield "[" 
    431431        for (i, item) in enumerate(self.items): 
    432432            if i: 
    433433                yield ", " 
    434             yield from item._str(indent) 
     434            yield from item._str(level) 
    435435        yield "]" 
    436436 
     
    499499                p.text("at {:#x}".format(id(self))) 
    500500 
    501     def _str(self, indent): 
     501    def _str(self, level): 
    502502        yield "[" 
    503         yield from self.item._str(indent) 
     503        yield from self.item._str(level) 
    504504        yield " for " 
    505505        yield _formatnestednameul4(self.varname) 
    506506        yield " in " 
    507         yield from self.container._str(indent) 
     507        yield from self.container._str(level) 
    508508        if self.condition is not None: 
    509509            yield " if " 
    510             yield from self.condition._str(indent) 
     510            yield from self.condition._str(level) 
    511511        yield "]" 
    512512 
     
    567567                p.text("at {:#x}".format(id(self))) 
    568568 
    569     def _str(self, indent): 
     569    def _str(self, level): 
    570570        yield "{" 
    571571        for (i, item) in enumerate(self.items): 
    572572            if i: 
    573573                yield ", " 
    574             yield from item[0]._str(indent) 
     574            yield from item[0]._str(level) 
    575575            yield ": " 
    576             yield from item[1]._str(indent) 
     576            yield from item[1]._str(level) 
    577577        yield "}" 
    578578 
     
    642642                p.text("at {:#x}".format(id(self))) 
    643643 
    644     def _str(self, indent): 
     644    def _str(self, level): 
    645645        yield "{" 
    646         yield from self.key._str(indent) 
     646        yield from self.key._str(level) 
    647647        yield " : " 
    648         yield from self.value._str(indent) 
     648        yield from self.value._str(level) 
    649649        yield " for " 
    650650        yield _formatnestednameul4(self.varname) 
    651651        yield " in " 
    652         yield from self.container._str(indent) 
     652        yield from self.container._str(level) 
    653653        if self.condition is not None: 
    654654            yield " if " 
    655             yield from self.condition._str(indent) 
     655            yield from self.condition._str(level) 
    656656        yield "]" 
    657657 
     
    729729                p.text("at {:#x}".format(id(self))) 
    730730 
    731     def _str(self, indent): 
     731    def _str(self, level): 
    732732        yield "(" 
    733         yield from self.item._str(indent) 
     733        yield from self.item._str(level) 
    734734        yield " for " 
    735735        yield _formatnestednameul4(self.varname) 
    736736        yield " in " 
    737         yield from self.container._str(indent) 
     737        yield from self.container._str(level) 
    738738        if self.condition is not None: 
    739739            yield " if " 
    740             yield from self.condition._str(indent) 
     740            yield from self.condition._str(level) 
    741741        yield ")" 
    742742 
     
    784784        return "<{0.__class__.__module__}.{0.__class__.__qualname__} {0.name!r} at {1:#x}>".format(self, id(self)) 
    785785 
    786     def _str(self, indent): 
     786    def _str(self, level): 
    787787        yield self.name 
    788788 
     
    826826        self.content.append(item) 
    827827 
    828     def _str(self, indent): 
     828    def _str(self, level): 
    829829        if self.content: 
    830830            for node in self.content: 
    831                 yield indent*"\t" 
    832                 yield from node._str(indent) 
     831                yield level*"\t" 
     832                yield from node._str(level) 
    833833        else: 
    834             yield indent*"\t" 
     834            yield level*"\t" 
    835835            yield "pass\n" 
    836836 
     
    924924                p.text("at {:#x}".format(id(self))) 
    925925 
    926     def _str(self, indent): 
     926    def _str(self, level): 
    927927        yield "if " 
    928         yield from self.condition._str(indent) 
     928        yield from self.condition._str(level) 
    929929        yield ":\n" 
    930         yield from super()._str(indent+1) 
     930        yield from super()._str(level+1) 
    931931 
    932932    def ul4ondump(self, encoder): 
     
    968968                p.text("at {:#x}".format(id(self))) 
    969969 
    970     def _str(self, indent): 
     970    def _str(self, level): 
    971971        yield "elif " 
    972         yield from self.condition._str(indent) 
     972        yield from self.condition._str(level) 
    973973        yield ":\n" 
    974         yield from super()._str(indent+1) 
     974        yield from super()._str(level+1) 
    975975 
    976976    def ul4ondump(self, encoder): 
     
    10031003                p.text("at {:#x}".format(id(self))) 
    10041004 
    1005     def _str(self, indent): 
     1005    def _str(self, level): 
    10061006        yield "else:\n" 
    1007         yield from super()._str(indent+1) 
     1007        yield from super()._str(level+1) 
    10081008 
    10091009 
     
    10511051        self.container = decoder.load() 
    10521052 
    1053     def _str(self, indent): 
     1053    def _str(self, level): 
    10541054        yield "for " 
    10551055        yield _formatnestednameul4(self.varname) 
    10561056        yield " in " 
    1057         yield from self.container._str(indent) 
     1057        yield from self.container._str(level) 
    10581058        yield ":\n" 
    1059         yield from super()._str(indent+1) 
     1059        yield from super()._str(level+1) 
    10601060 
    10611061    @handleeval 
     
    10791079    """ 
    10801080 
    1081     def _str(self, indent): 
     1081    def _str(self, level): 
    10821082        yield "break\n" 
    10831083 
     
    10931093    """ 
    10941094 
    1095     def _str(self, indent): 
     1095    def _str(self, level): 
    10961096        yield "continue\n" 
    10971097 
     
    11351135                p.text("at {:#x}".format(id(self))) 
    11361136 
    1137     def _str(self, indent): 
     1137    def _str(self, level): 
    11381138        yield from self._formatop(self.obj) 
    11391139        yield "." 
     
    12011201                p.text("at {:#x}".format(id(self))) 
    12021202 
    1203     def _str(self, indent): 
     1203    def _str(self, level): 
    12041204        yield from self._formatop(self.obj) 
    12051205        yield "[" 
    12061206        if self.index1 is not None: 
    1207             yield from self.index1._str(indent) 
     1207            yield from self.index1._str(level) 
    12081208        yield ":" 
    12091209        if self.index2 is not None: 
    1210             yield from self.index2._str(indent) 
     1210            yield from self.index2._str(level) 
    12111211        yield "]" 
    12121212 
     
    12951295    precedence = 2 
    12961296 
    1297     def _str(self, indent): 
     1297    def _str(self, level): 
    12981298        yield "not " 
    12991299        yield from self._formatop(self.obj) 
     
    13121312    precedence = 7 
    13131313 
    1314     def _str(self, indent): 
     1314    def _str(self, level): 
    13151315        yield "-" 
    13161316        yield from self._formatop(self.obj) 
     
    13271327    """ 
    13281328 
    1329     def _str(self, indent): 
     1329    def _str(self, level): 
    13301330        yield "print " 
    1331         yield from self.obj._str(indent) 
     1331        yield from self.obj._str(level) 
    13321332        yield "\n" 
    13331333 
     
    13431343    """ 
    13441344 
    1345     def _str(self, indent): 
     1345    def _str(self, level): 
    13461346        yield "printx " 
    1347         yield from self.obj._str(indent) 
     1347        yield from self.obj._str(level) 
    13481348        yield "\n" 
    13491349 
     
    13591359    """ 
    13601360 
    1361     def _str(self, indent): 
     1361    def _str(self, level): 
    13621362        yield "return " 
    1363         yield from self.obj._str(indent) 
     1363        yield from self.obj._str(level) 
    13641364        yield "\n" 
    13651365 
     
    14381438        return obj1[obj2] 
    14391439 
    1440     def _str(self, indent): 
    1441         yield from self.obj1._str(indent) 
     1440    def _str(self, level): 
     1441        yield from self.obj1._str(level) 
    14421442        yield "[" 
    1443         yield from self.obj2._str(indent) 
     1443        yield from self.obj2._str(level) 
    14441444        yield "]" 
    14451445 
     
    14631463    associative = False 
    14641464 
    1465     def _str(self, indent): 
     1465    def _str(self, level): 
    14661466        yield from self._formatop(self.obj1) 
    14671467        yield " == " 
     
    14821482    associative = False 
    14831483 
    1484     def _str(self, indent): 
     1484    def _str(self, level): 
    14851485        yield from self._formatop(self.obj1) 
    14861486        yield " != " 
     
    15011501    associative = False 
    15021502 
    1503     def _str(self, indent): 
     1503    def _str(self, level): 
    15041504        yield from self._formatop(self.obj1) 
    15051505        yield " < " 
     
    15201520    associative = False 
    15211521 
    1522     def _str(self, indent): 
     1522    def _str(self, level): 
    15231523        yield from self._formatop(self.obj1) 
    15241524        yield " <= " 
     
    15391539    associative = False 
    15401540 
    1541     def _str(self, indent): 
     1541    def _str(self, level): 
    15421542        yield from self._formatop(self.obj1) 
    15431543        yield " > " 
     
    15581558    associative = False 
    15591559 
    1560     def _str(self, indent): 
     1560    def _str(self, level): 
    15611561        yield from self._formatop(self.obj1) 
    15621562        yield " >= " 
     
    15811581    associative = False 
    15821582 
    1583     def _str(self, indent): 
     1583    def _str(self, level): 
    15841584        yield from self._formatop(self.obj1) 
    15851585        yield " in " 
     
    16041604    associative = False 
    16051605 
    1606     def _str(self, indent): 
     1606    def _str(self, level): 
    16071607        yield from self._formatop(self.obj1) 
    16081608        yield " not in " 
     
    16221622    precedence = 5 
    16231623 
    1624     def _str(self, indent): 
     1624    def _str(self, level): 
    16251625        yield from self._formatop(self.obj1) 
    16261626        yield "+" 
     
    16411641    associative = False 
    16421642 
    1643     def _str(self, indent): 
     1643    def _str(self, level): 
    16441644        yield from self._formatop(self.obj1) 
    16451645        yield "-" 
     
    16591659    precedence = 6 
    16601660 
    1661     def _str(self, indent): 
     1661    def _str(self, level): 
    16621662        yield from self._formatop(self.obj1) 
    16631663        yield "*" 
     
    16781678    associative = False 
    16791679 
    1680     def _str(self, indent): 
     1680    def _str(self, level): 
    16811681        yield from self._formatop(self.obj1) 
    16821682        yield "//" 
     
    16971697    associative = False 
    16981698 
    1699     def _str(self, indent): 
     1699    def _str(self, level): 
    17001700        yield from self._formatop(self.obj1) 
    17011701        yield "/" 
     
    17151715    precedence = 1 
    17161716 
    1717     def _str(self, indent): 
     1717    def _str(self, level): 
    17181718        yield from self._formatop(self.obj1) 
    17191719        yield " and " 
     
    17421742    precedence = 0 
    17431743 
    1744     def _str(self, indent): 
     1744    def _str(self, level): 
    17451745        yield from self._formatop(self.obj1) 
    17461746        yield " or " 
     
    17691769    associative = False 
    17701770 
    1771     def _str(self, indent): 
     1771    def _str(self, level): 
    17721772        yield from self._formatop(self.obj1) 
    17731773        yield "%" 
     
    18291829    """ 
    18301830 
    1831     def _str(self, indent): 
     1831    def _str(self, level): 
    18321832        yield _formatnestednameul4(self.varname) 
    18331833        yield " = " 
    1834         yield from self.value._str(indent) 
     1834        yield from self.value._str(level) 
    18351835        yield "\n" 
    18361836 
     
    18471847    """ 
    18481848 
    1849     def _str(self, indent): 
     1849    def _str(self, level): 
    18501850        yield _formatnestednameul4(self.varname) 
    18511851        yield " += " 
    1852         yield from self.value._str(indent) 
     1852        yield from self.value._str(level) 
    18531853        yield "\n" 
    18541854 
     
    18651865    """ 
    18661866 
    1867     def _str(self, indent): 
     1867    def _str(self, level): 
    18681868        yield _formatnestednameul4(self.varname) 
    18691869        yield " -= " 
    1870         yield from self.value._str(indent) 
     1870        yield from self.value._str(level) 
    18711871        yield "\n" 
    18721872 
     
    18831883    """ 
    18841884 
    1885     def _str(self, indent): 
     1885    def _str(self, level): 
    18861886        yield _formatnestednameul4(self.varname) 
    18871887        yield " *= " 
    1888         yield from self.value._str(indent) 
     1888        yield from self.value._str(level) 
    18891889        yield "\n" 
    18901890 
     
    19021902    """ 
    19031903 
    1904     def _str(self, indent): 
     1904    def _str(self, level): 
    19051905        yield _formatnestednameul4(self.varname) 
    19061906        yield " //= " 
    1907         yield from self.value._str(indent) 
     1907        yield from self.value._str(level) 
    19081908        yield "\n" 
    19091909 
     
    19201920    """ 
    19211921 
    1922     def _str(self, indent): 
     1922    def _str(self, level): 
    19231923        yield _formatnestednameul4(self.varname) 
    19241924        yield " /= " 
    1925         yield from self.value._str(indent) 
     1925        yield from self.value._str(level) 
    19261926        yield "\n" 
    19271927 
     
    19381938    """ 
    19391939 
    1940     def _str(self, indent): 
     1940    def _str(self, level): 
    19411941        yield _formatnestednameul4(self.varname) 
    19421942        yield " %= " 
    1943         yield from self.value._str(indent) 
     1943        yield from self.value._str(level) 
    19441944        yield "\n" 
    19451945 
     
    20102010                p.text("at {:#x}".format(id(self))) 
    20112011 
    2012     def _str(self, indent): 
    2013         yield from self.obj._str(indent) 
     2012    def _str(self, level): 
     2013        yield from self.obj._str(level) 
    20142014        yield "(" 
    20152015        first = True 
     
    20192019            else: 
    20202020                yield ", " 
    2021             yield from arg._str(indent) 
     2021            yield from arg._str(level) 
    20222022        for (argname, argvalue) in self.kwargs: 
    20232023            if first: 
     
    20272027            yield argname 
    20282028            yield "=" 
    2029             yield from argvalue._str(indent) 
     2029            yield from argvalue._str(level) 
    20302030        if self.remargs is not None: 
    20312031            if first: 
     
    20342034                yield ", " 
    20352035            yield "*" 
    2036             yield from self.remargs._str(indent) 
     2036            yield from self.remargs._str(level) 
    20372037        if self.remkwargs is not None: 
    20382038            if first: 
     
    20412041                yield ", " 
    20422042            yield "**" 
    2043             yield from self.remkwargs._str(indent) 
     2043            yield from self.remkwargs._str(level) 
    20442044        yield ")" 
    20452045 
     
    21462146                p.text("at {:#x}".format(id(self))) 
    21472147 
    2148     def _str(self, indent): 
     2148    def _str(self, level): 
    21492149        yield from self._formatop(self.obj) 
    21502150        yield "." 
     
    21572157            else: 
    21582158                yield ", " 
    2159             yield from arg._str(indent) 
     2159            yield from arg._str(level) 
    21602160        for (argname, argvalue) in self.kwargs: 
    21612161            if first: 
     
    21652165            yield argname 
    21662166            yield "=" 
    2167             yield from argvalue._str(indent) 
     2167            yield from argvalue._str(level) 
    21682168        if self.remargs is not None: 
    21692169            if first: 
     
    21722172                yield ", " 
    21732173            yield "*" 
    2174             yield from self.remargs._str(indent) 
     2174            yield from self.remargs._str(level) 
    21752175        if self.remkwargs is not None: 
    21762176            if first: 
     
    21792179                yield ", " 
    21802180            yield "**" 
    2181             yield from self.remkwargs._str(indent) 
     2181            yield from self.remkwargs._str(level) 
    21822182        yield ")" 
    21832183 
     
    22832283        return s + " at {:#x}>".format(id(self)) 
    22842284 
    2285     def _str(self, indent): 
     2285    def _str(self, level): 
    22862286        yield "def " 
    22872287        yield self.name if self.name is not None else "unnamed" 
    22882288        yield ":\n" 
    2289         yield from super()._str(indent+1) 
     2289        yield from super()._str(level+1) 
    22902290 
    22912291    def _repr_pretty_(self, p, cycle):