Changeset 16:c83bfa277e45 in livinglogic.googleappengine.ul4

Show
Ignore:
Timestamp:
08/06/08 16:29:21 (10 years ago)
Author:
Walter Doerwald <walter@…>
Branch:
default
Tags:
tip
Message:

Update XIST version.

Location:
ll
Files:
4 modified

Legend:

Unmodified
Added
Removed
  • ll/make.py

    r0 r16  
    5353from __future__ import with_statement 
    5454 
    55 import sys, os, os.path, optparse, warnings, re, datetime, cStringIO, errno, tempfile, operator, types, cPickle, gc, contextlib 
     55import sys, os, os.path, optparse, warnings, re, datetime, cStringIO, errno, tempfile, operator, types, cPickle, gc, contextlib, locale 
    5656 
    5757from ll import misc, url 
     
    6262    from ll import astyle 
    6363 
     64 
     65try: 
     66    locale.setlocale(locale.LC_NUMERIC, "en_US") 
     67except Exception: 
     68    pass 
    6469 
    6570__docformat__ = "reStructuredText" 
     
    22322237        self.starttime = datetime.datetime.utcnow() 
    22332238 
     2239        def format(v): 
     2240            return locale.format("%d", v, True) 
     2241 
    22342242        with url.Context(): 
    22352243            self.stack = [] 
     
    22552263                    s4action(self.__class__.__module__, ".", self.__class__.__name__), 
    22562264                    ": ", 
    2257                     s4data(str(len(self))), 
     2265                    s4data(format(len(self))), 
    22582266                    " registered targets; ", 
    2259                     s4data(str(self.actionscalled)), 
     2267                    s4data(format(self.actionscalled)), 
    22602268                    " actions called; ", 
    2261                     s4data(str(self.stepsexecuted)), 
     2269                    s4data(format(self.stepsexecuted)), 
    22622270                    " steps executed; ", 
    2263                     s4data(str(self.filesread)), 
     2271                    s4data(format(self.filesread)), 
    22642272                    " files/", 
    2265                     s4data(str(self.bytesread)), 
     2273                    s4data(format(self.bytesread)), 
    22662274                    " bytes read; ", 
    2267                     s4data(str(self.fileswritten)), 
     2275                    s4data(format(self.fileswritten)), 
    22682276                    " files/", 
    2269                     s4data(str(self.byteswritten)), 
     2277                    s4data(format(self.byteswritten)), 
    22702278                    " bytes written; ", 
    2271                     s4data(str(self.actionsfailed)), 
     2279                    s4data(format(self.actionsfailed)), 
    22722280                    " actions failed", 
    22732281                ) 
  • ll/misc.py

    r0 r16  
    1717 
    1818import sys, types, collections, weakref 
     19 
     20 
     21__docformat__ = "reStructuredText" 
    1922 
    2023 
     
    8689        return count 
    8790 
    88     def _xmlescape(string, maps): 
    89         for (s, r) in maps: 
    90             string = string.replace(s, r) 
    91         if isinstance(string, str): 
    92             chars = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x0b\x0c\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1f\x7f\x80\x81\x82\x83\x84\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f" 
    93         else: 
    94             chars = u"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x0b\x0c\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1f\x7f\x80\x81\x82\x83\x84\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f" 
    95         for c in chars: 
    96             string = string.replace(c, "&#%d;" % ord(c)) 
    97         return string 
    98  
    9991    def xmlescape(string): 
    10092        """ 
     
    10395        replaced with their XML character entity or character reference. 
    10496        """ 
    105         maps = ( 
    106             ("&", "&amp;"), 
    107             ("<", "&lt;"), 
    108             (">", "&gt;"), 
    109             ("'", "&apos;"), 
    110             ('"', "&quot;"), 
    111         ) 
    112         return _xmlescape(string, maps) 
     97        if isinstance(string, unicode): 
     98            return string.translate({0x00: u'&#0;', 0x01: u'&#1;', 0x02: u'&#2;', 0x03: u'&#3;', 0x04: u'&#4;', 0x05: u'&#5;', 0x06: u'&#6;', 0x07: u'&#7;', 0x08: u'&#8;', 0x0b: u'&#11;', 0x0c: u'&#12;', 0x0e: u'&#14;', 0x0f: u'&#15;', 0x10: u'&#16;', 0x11: u'&#17;', 0x12: u'&#18;', 0x13: u'&#19;', 0x14: u'&#20;', 0x15: u'&#21;', 0x16: u'&#22;', 0x17: u'&#23;', 0x18: u'&#24;', 0x19: u'&#25;', 0x1a: u'&#26;', 0x1b: u'&#27;', 0x1c: u'&#28;', 0x1d: u'&#29;', 0x1e: u'&#30;', 0x1f: u'&#31;', 0x22: u'&quot;', 0x26: u'&amp;', 0x27: u'&#39;', 0x3c: u'&lt;', 0x3e: u'&gt;', 0x7f: u'&#127;', 0x80: u'&#128;', 0x81: u'&#129;', 0x82: u'&#130;', 0x83: u'&#131;', 0x84: u'&#132;', 0x86: u'&#134;', 0x87: u'&#135;', 0x88: u'&#136;', 0x89: u'&#137;', 0x8a: u'&#138;', 0x8b: u'&#139;', 0x8c: u'&#140;', 0x8d: u'&#141;', 0x8e: u'&#142;', 0x8f: u'&#143;', 0x90: u'&#144;', 0x91: u'&#145;', 0x92: u'&#146;', 0x93: u'&#147;', 0x94: u'&#148;', 0x95: u'&#149;', 0x96: u'&#150;', 0x97: u'&#151;', 0x98: u'&#152;', 0x99: u'&#153;', 0x9a: u'&#154;', 0x9b: u'&#155;', 0x9c: u'&#156;', 0x9d: u'&#157;', 0x9e: u'&#158;', 0x9f: u'&#159;'}) 
     99        else: 
     100            string = string.replace("&", "&amp;") 
     101            string = string.replace("<", "&lt;") 
     102            string = string.replace(">", "&gt;") 
     103            string = string.replace("'", "&#39;") 
     104            string = string.replace('"', "&quot;") 
     105            for c in "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x0b\x0c\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1f\x7f\x80\x81\x82\x83\x84\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f": 
     106                string = string.replace(c, "&#%d;" % ord(c)) 
     107            return string 
    113108 
    114109    def xmlescape_text(string): 
     
    118113        XML character entity or character reference. 
    119114        """ 
    120         maps = ( 
    121             ("&", "&amp;"), 
    122             ("<", "&lt;"), 
    123             (">", "&gt;"), 
    124         ) 
    125         return _xmlescape(string, maps) 
     115        if isinstance(string, unicode): 
     116            return string.translate({0x00: u'&#0;', 0x01: u'&#1;', 0x02: u'&#2;', 0x03: u'&#3;', 0x04: u'&#4;', 0x05: u'&#5;', 0x06: u'&#6;', 0x07: u'&#7;', 0x08: u'&#8;', 0x0b: u'&#11;', 0x0c: u'&#12;', 0x0e: u'&#14;', 0x0f: u'&#15;', 0x10: u'&#16;', 0x11: u'&#17;', 0x12: u'&#18;', 0x13: u'&#19;', 0x14: u'&#20;', 0x15: u'&#21;', 0x16: u'&#22;', 0x17: u'&#23;', 0x18: u'&#24;', 0x19: u'&#25;', 0x1a: u'&#26;', 0x1b: u'&#27;', 0x1c: u'&#28;', 0x1d: u'&#29;', 0x1e: u'&#30;', 0x1f: u'&#31;', 0x26: u'&amp;', 0x3c: u'&lt;', 0x3e: u'&gt;', 0x7f: u'&#127;', 0x80: u'&#128;', 0x81: u'&#129;', 0x82: u'&#130;', 0x83: u'&#131;', 0x84: u'&#132;', 0x86: u'&#134;', 0x87: u'&#135;', 0x88: u'&#136;', 0x89: u'&#137;', 0x8a: u'&#138;', 0x8b: u'&#139;', 0x8c: u'&#140;', 0x8d: u'&#141;', 0x8e: u'&#142;', 0x8f: u'&#143;', 0x90: u'&#144;', 0x91: u'&#145;', 0x92: u'&#146;', 0x93: u'&#147;', 0x94: u'&#148;', 0x95: u'&#149;', 0x96: u'&#150;', 0x97: u'&#151;', 0x98: u'&#152;', 0x99: u'&#153;', 0x9a: u'&#154;', 0x9b: u'&#155;', 0x9c: u'&#156;', 0x9d: u'&#157;', 0x9e: u'&#158;', 0x9f: u'&#159;'}) 
     117        else: 
     118            string = string.replace("&", "&amp;") 
     119            string = string.replace("<", "&lt;") 
     120            string = string.replace(">", "&gt;") 
     121            for c in "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x0b\x0c\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1f\x7f\x80\x81\x82\x83\x84\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f": 
     122                string = string.replace(c, "&#%d;" % ord(c)) 
     123            return string 
    126124 
    127125    def xmlescape_attr(string): 
     
    131129        their XML character entity or character reference. 
    132130        """ 
    133         maps = ( 
    134             ("&", "&amp;"), 
    135             ("<", "&lt;"), 
    136             (">", "&gt;"), 
    137             ("'", "&apos;"), 
    138         ) 
    139         return _xmlescape(string, maps) 
    140  
    141  
    142 __docformat__ = "reStructuredText" 
     131        if isinstance(string, unicode): 
     132            return string.translate({0x00: u'&#0;', 0x01: u'&#1;', 0x02: u'&#2;', 0x03: u'&#3;', 0x04: u'&#4;', 0x05: u'&#5;', 0x06: u'&#6;', 0x07: u'&#7;', 0x08: u'&#8;', 0x0b: u'&#11;', 0x0c: u'&#12;', 0x0e: u'&#14;', 0x0f: u'&#15;', 0x10: u'&#16;', 0x11: u'&#17;', 0x12: u'&#18;', 0x13: u'&#19;', 0x14: u'&#20;', 0x15: u'&#21;', 0x16: u'&#22;', 0x17: u'&#23;', 0x18: u'&#24;', 0x19: u'&#25;', 0x1a: u'&#26;', 0x1b: u'&#27;', 0x1c: u'&#28;', 0x1d: u'&#29;', 0x1e: u'&#30;', 0x1f: u'&#31;', 0x22: u'&quot;', 0x26: u'&amp;', 0x3c: u'&lt;', 0x3e: u'&gt;', 0x7f: u'&#127;', 0x80: u'&#128;', 0x81: u'&#129;', 0x82: u'&#130;', 0x83: u'&#131;', 0x84: u'&#132;', 0x86: u'&#134;', 0x87: u'&#135;', 0x88: u'&#136;', 0x89: u'&#137;', 0x8a: u'&#138;', 0x8b: u'&#139;', 0x8c: u'&#140;', 0x8d: u'&#141;', 0x8e: u'&#142;', 0x8f: u'&#143;', 0x90: u'&#144;', 0x91: u'&#145;', 0x92: u'&#146;', 0x93: u'&#147;', 0x94: u'&#148;', 0x95: u'&#149;', 0x96: u'&#150;', 0x97: u'&#151;', 0x98: u'&#152;', 0x99: u'&#153;', 0x9a: u'&#154;', 0x9b: u'&#155;', 0x9c: u'&#156;', 0x9d: u'&#157;', 0x9e: u'&#158;', 0x9f: u'&#159;'}) 
     133        else: 
     134            string = string.replace("&", "&amp;") 
     135            string = string.replace("<", "&lt;") 
     136            string = string.replace(">", "&gt;") 
     137            string = string.replace('"', "&quot;") 
     138            for c in "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x0b\x0c\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1f\x7f\x80\x81\x82\x83\x84\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f": 
     139                string = string.replace(c, "&#%d;" % ord(c)) 
     140            return string 
    143141 
    144142 
  • ll/ul4c.py

    r0 r16  
    1616 
    1717:mod:`ll.ul4c` compiles a template to a bytecode format, which makes it possible 
    18 to implement renderers for these templates in multiple programming languages. 
     18to implement template renderers in multiple programming languages. 
    1919""" 
    2020 
     
    2424 
    2525 
    26 import re, datetime, marshal, StringIO, locale 
     26import re, datetime, StringIO, locale 
    2727 
    2828from ll import spark 
     
    432432 
    433433    ``"render"``: 
    434         Render the template whose name is in the attribute :attr:`arg`. The 
    435         content of register :attr:`r1` (which must be a dictionary) will be passed 
    436         to the template as the variable dictionary. 
     434        Render the template in the attribute :attr:`r1`. The content of register 
     435        :attr:`r2` (which must be a dictionary) will be passed to the template as 
     436        the variable dictionary. 
    437437    """ 
    438438    __slots__ = ("code", "r1", "r2", "r3", "r4", "r5", "arg", "location", "jump") 
     
    582582            return "r%r = r%r.%s(r%r, r%r, r%r)" % (self.r1, self.r2, self.arg, self.r3, self.r4, self.r5) 
    583583        elif self.code == "render": 
    584             return "render %s(r%r)" % (self.arg, self.r1) 
     584            return "render r%r(r%r)" % (self.r1, self.r2) 
    585585        else: 
    586586            raise UnknownOpcodeError(self.code) 
     
    600600    returns a generator) or :meth:`renders` (which returns a string). 
    601601    """ 
    602     version = "5" 
     602    version = "6" 
    603603 
    604604    def __init__(self): 
     
    781781 
    782782        if function is not None: 
    783             _code("def %s(templates={}, **variables):" % function) 
     783            _code("def %s(**variables):" % function) 
    784784            indent += 1 
    785785        _code("import sys, datetime, itertools") 
     
    948948                    elif opcode.arg == "isdict": 
    949949                        _code("reg%d = isinstance(reg%d, dict)" % (opcode.r1, opcode.r2)) 
     950                    elif opcode.arg == "istemplate": 
     951                        _code("reg%d = hasattr(reg%d, '__call__')" % (opcode.r1, opcode.r2)) # this supports normal generators too. 
    950952                    elif opcode.arg == "repr": 
    951953                        _code("reg%d = ul4c._repr(reg%d)" % (opcode.r1, opcode.r2)) 
     
    10231025                    _code("# end if") 
    10241026                elif opcode.code == "render": 
    1025                     _code('for chunk in templates[%r](templates, **dict((key.encode("utf-8"), value) for (key, value) in reg%d.iteritems())): yield chunk' % (opcode.arg, opcode.r1)) 
     1027                    _code('for chunk in reg%d(**dict((key.encode("utf-8"), value) for (key, value) in reg%d.iteritems())): yield chunk' % (opcode.r1, opcode.r2)) 
    10261028                else: 
    10271029                    raise UnknownOpcodeError(opcode.code) 
     
    10401042        """ 
    10411043        Return a Python generator that can be called to render the template. The 
    1042         argument signature of the function will be ``templates={}, **variables``. 
     1044        argument signature of the function will be ``**variables``. 
    10431045        """ 
    10441046        if self._pythonfunction is None: 
     
    10491051        return self._pythonfunction 
    10501052 
    1051     def __call__(self, templates={}, **variables): 
    1052         return self.pythonfunction()(templates, **variables) 
    1053  
    1054     def render(self, templates={}, **variables): 
     1053    def __call__(self, **variables): 
     1054        return self.pythonfunction()(**variables) 
     1055 
     1056    def render(self, **variables): 
    10551057        """ 
    10561058        Render the template iteratively (i.e. this is a generator). 
    1057         :var:`templates` contains the templates that should be available to the 
    1058         ``<?render?>`` tag. :var:`variables` contains the top level variables 
    1059         available to the template code. 
    1060         """ 
    1061         return self.pythonfunction()(templates, **variables) 
    1062  
    1063     def renders(self, templates={}, **variables): 
    1064         """ 
    1065         Render the template as a string. :var:`templates` contains the templates 
    1066         that should be available to the ``<?render?>`` tag. :var:`variables` 
    1067         contains the top level variables available to the template code. 
    1068         """ 
    1069         return "".join(self.render(templates, **variables)) 
     1059        :var:`variables` contains the top level variables available to the 
     1060        template code. 
     1061        """ 
     1062        return self.pythonfunction()(**variables) 
     1063 
     1064    def renders(self, **variables): 
     1065        """ 
     1066        Render the template as a string. :var:`variables` contains the top level 
     1067        variables available to the template code. 
     1068        """ 
     1069        return "".join(self.render(**variables)) 
    10701070 
    10711071    def format(self, indent="\t"): 
     
    16871687 
    16881688class Render(AST): 
    1689     def __init__(self, start, end, name, *variables): 
     1689    def __init__(self, start, end, template, *variables): 
    16901690        AST.__init__(self, start, end) 
    1691         self.name = name 
     1691        self.template = template 
    16921692        self.variables = list(variables) 
    16931693 
    16941694    def __repr__(self): 
    1695         return "%s(%r, %r, %r, %s)" % (self.__class__.__name__, self.start, self.end, self.name, repr(self.variables)[1:-1]) 
     1695        return "%s(%r, %r, %r, %s)" % (self.__class__.__name__, self.start, self.end, self.template, repr(self.variables)[1:-1]) 
    16961696 
    16971697    def compile(self, template): 
    1698         r = template._allocreg() 
    1699         template.opcode("builddict", r1=r) 
     1698        ra = template._allocreg() 
     1699        template.opcode("builddict", r1=ra) 
    17001700        for (key, value) in self.variables: 
    17011701            rv = value.compile(template) 
    17021702            rk = template._allocreg() 
    17031703            template.opcode("loadstr", r1=rk, arg=key.name) 
    1704             template.opcode("adddict", r1=r, r2=rk, r3=rv) 
     1704            template.opcode("adddict", r1=ra, r2=rk, r3=rv) 
    17051705            template._freereg(rk) 
    17061706            template._freereg(rv) 
    1707         template.opcode("render", r1=r, arg=self.name.name) 
    1708         template._freereg(r) 
     1707        rt = self.template.compile(template) 
     1708        template.opcode("render", r1=rt, r2=ra) 
     1709        template._freereg(rt) 
     1710        template._freereg(ra) 
    17091711 
    17101712 
     
    22262228    start = "render" 
    22272229 
    2228     @spark.production('render ::= name ( )') 
    2229     def emptyrender(self, name, _0, _1): 
    2230         return Render(name.start, _1.end, name) 
    2231  
    2232     @spark.production('buildrender ::= name ( name = expr0') 
    2233     def startrender(self, name, _0, argname, _1, argvalue): 
    2234         return Render(name.start, argvalue.end, name, (argname, argvalue)) 
     2230    @spark.production('render ::= expr0 ( )') 
     2231    def emptyrender(self, template, _0, _1): 
     2232        return Render(template.start, _1.end, template) 
     2233 
     2234    @spark.production('buildrender ::= expr0 ( name = expr0') 
     2235    def startrender(self, template, _0, argname, _1, argvalue): 
     2236        return Render(template.start, argvalue.end, template, (argname, argvalue)) 
    22352237 
    22362238    @spark.production('buildrender ::= buildrender , name = expr0') 
  • ll/xist/parsers.py

    r0 r16  
    2222 
    2323from ll import url, xml_codec 
    24 from ll.xist import xsc, sgmlop 
     24from ll.xist import xsc 
     25try: 
     26    from ll.xist import sgmlop 
     27except ImportError: 
     28    pass 
    2529from ll.xist.ns import xml, html 
    2630