Changeset 5313:5a6c9245dda4 in livinglogic.python.xist

Show
Ignore:
Timestamp:
02/06/13 19:37:55 (6 years ago)
Author:
Walter Doerwald <walter@…>
Branch:
default
Message:

Builtin UL4 functions and methods are now enhanced generators too.

With this <?render?> can be removed.

Rename <?code?> to <?exe?>.

Add UL4 functions print() and printx().

Files:
7 modified

Legend:

Unmodified
Added
Removed
  • MIGRATION.rst

    r5302 r5313  
    55-------------- 
    66 
    7 *   Templates are now defined via ``<?template foo?>``/``<?end template?>`` 
    8     instead of ``<?def foo?>``/``<?end def?>``. 
     7*   The UL4 tag ``<?code?>`` has been renamed to ``<?exe?>`` and the tag 
     8    ``<?render?>`` have been removed. 
     9 
     10    To update your code replace: 
     11 
     12    *    ``<?code x = 42?>`` with ``<?exe x = 42?>`` and 
     13 
     14    *   ``<?render r.render()?>`` with ``<?exe r.render()?>``. 
    915 
    1016*   The UL4 functions ``vars`` and ``get`` have been removed. 
  • NEWS.rst

    r5312 r5313  
    1111    Normal output of the template will be ignored if it is used as a function. 
    1212 
     13*   The UL4 tag ``<?code?>`` has been renamed to ``<?exe?>`` and may now contain 
     14    not only variable assigments, but any other expression. 
     15 
     16*   UL4 functions ``print`` and ``printx`` have been added that behave the same 
     17    as the approiate tags ``<?print?>`` and ``<?printx?>``, but can output an 
     18    arbitrary number of arguments. 
     19 
     20*   The tag ``<?render?>`` has been removed. To update your code replace  
     21    ``<?render r.render()?>`` with ``<?exe r.render()?>``. 
     22 
    1323*   The builtin UL4 functions are now real objects that can be passed to templates 
    1424    as arguments. 
     
    1727 
    1828*   The automatic UL4 variable ``stack`` has been removed too. 
     29 
    1930 
    2031 
  • src/ll/UL4.g

    r5312 r5313  
    141141 
    142142none returns [node] 
    143     : NONE { $node = ul4c.Const(None); } 
     143    : NONE { $node = ul4c.Const(None) } 
    144144    ; 
    145145 
    146146true_ returns [node] 
    147     : TRUE { $node = ul4c.Const(True); } 
     147    : TRUE { $node = ul4c.Const(True) } 
    148148    ; 
    149149 
    150150false_ returns [node] 
    151     : FALSE { $node = ul4c.Const(False); } 
     151    : FALSE { $node = ul4c.Const(False) } 
    152152    ; 
    153153 
    154154int_ returns [node] 
    155     : INT { $node = ul4c.Const(int($INT.text, 0)); } 
     155    : INT { $node = ul4c.Const(int($INT.text, 0)) } 
    156156    ; 
    157157 
    158158float_ returns [node] 
    159     : FLOAT { $node = ul4c.Const(float($FLOAT.text)); } 
     159    : FLOAT { $node = ul4c.Const(float($FLOAT.text)) } 
    160160    ; 
    161161 
    162162string returns [node] 
    163     : STRING { $node = ul4c.Const(ast.literal_eval($STRING.text)); } 
     163    : STRING { $node = ul4c.Const(ast.literal_eval($STRING.text)) } 
    164164    ; 
    165165 
    166166date returns [node] 
    167     : DATE { $node = ul4c.Const(datetime.datetime(*map(int, [f for f in ul4c.datesplitter.split($DATE.text[2:-1]) if f]))); } 
     167    : DATE { $node = ul4c.Const(datetime.datetime(*map(int, [f for f in ul4c.datesplitter.split($DATE.text[2:-1]) if f]))) } 
    168168    ; 
    169169 
    170170color returns [node] 
    171     : COLOR { $node = ul4c.Const(color.Color.fromrepr($COLOR.text)); } 
     171    : COLOR { $node = ul4c.Const(color.Color.fromrepr($COLOR.text)) } 
    172172    ; 
    173173 
    174174name returns [node] 
    175     : NAME { $node = ul4c.Var($NAME.text); } 
     175    : NAME { $node = ul4c.Var($NAME.text) } 
    176176    ; 
    177177 
     
    192192    : 
    193193        '[' 
    194         ']' { $node = ul4c.List(); } 
     194        ']' { $node = ul4c.List() } 
    195195    | 
    196         '[' {$node = ul4c.List(); } 
    197         e1=expr1 { $node.items.append($e1.node); } 
     196        '[' {$node = ul4c.List() } 
     197        e1=expr1 { $node.items.append($e1.node) } 
    198198        ( 
    199199            ',' 
    200             e2=expr1 { $node.items.append($e2.node); } 
     200            e2=expr1 { $node.items.append($e2.node) } 
    201201        )* 
    202202        ','? 
     
    220220            condition=expr1 { _condition = $condition.node; } 
    221221        )? 
    222         ']' { $node = ul4c.ListComp($item.node, $n.varname, $container.node, _condition); } 
     222        ']' { $node = ul4c.ListComp($item.node, $n.varname, $container.node, _condition) } 
    223223    ; 
    224224 
     
    229229        k=expr1 
    230230        ':' 
    231         v=expr1 { $node = ($k.node, $v.node); } 
     231        v=expr1 { $node = ($k.node, $v.node) } 
    232232    | 
    233233        '**' 
    234         d=expr1 { $node = ($d.node,); } 
     234        d=expr1 { $node = ($d.node,) } 
    235235    ; 
    236236 
     
    238238    : 
    239239        '{' 
    240         '}' { $node = ul4c.Dict(); } 
     240        '}' { $node = ul4c.Dict() } 
    241241    | 
    242         '{' { $node = ul4c.Dict(); } 
    243         i1=dictitem { $node.items.append($i1.node); } 
     242        '{' { $node = ul4c.Dict() } 
     243        i1=dictitem { $node.items.append($i1.node) } 
    244244        ( 
    245245            ',' 
    246             i2=dictitem { $node.items.append($i2.node); } 
     246            i2=dictitem { $node.items.append($i2.node) } 
    247247        )* 
    248248        ','? 
     
    268268            condition=expr1 { _condition = $condition.node; } 
    269269        )? 
    270         '}' { $node = ul4c.DictComp($key.node, $value.node, $n.varname, $container.node, _condition); } 
     270        '}' { $node = ul4c.DictComp($key.node, $value.node, $n.varname, $container.node, _condition) } 
    271271    ; 
    272272 
     
    285285            'if' 
    286286            condition=expr1 { _condition = $condition.node; } 
    287         )? { $node = ul4c.GenExpr($item.node, $n.varname, $container.node, _condition); } 
     287        )? { $node = ul4c.GenExpr($item.node, $n.varname, $container.node, _condition) } 
    288288    ; 
    289289 
     
    303303        n=name { $varname = $n.text; } 
    304304    | 
    305         '(' n0=nestedname ',' ')' { $varname = ($n0.varname,); } 
     305        '(' n0=nestedname ',' ')' { $varname = ($n0.varname,) } 
    306306    | 
    307307        '(' 
    308308        n1=nestedname 
    309309        ',' 
    310         n2=nestedname { $varname = ($n1.varname, $n2.varname); } 
     310        n2=nestedname { $varname = ($n1.varname, $n2.varname) } 
    311311        ( 
    312312            ',' 
    313             n3=nestedname { $varname += ($n3.varname,); } 
     313            n3=nestedname { $varname += ($n3.varname,) } 
    314314        )* 
    315315        ','? 
     
    331331            /* Attribute access */ 
    332332            '.' 
    333             n=name { $node = ul4c.GetAttr($node, $n.text); } 
     333            n=name { $node = ul4c.GetAttr($node, $n.text) } 
    334334        | 
    335335            /* Function/method call */ 
    336             '(' { $node = ul4c.CallMeth($node.obj, $node.attrname) if isinstance($node, ul4c.GetAttr) else ul4c.CallFunc($node); } 
     336            '(' { $node = ul4c.CallMeth($node.obj, $node.attrname) if isinstance($node, ul4c.GetAttr) else ul4c.CallFunc($node) } 
    337337            ( 
    338338                /* No arguments */ 
     
    351351            | 
    352352                /* At least one positional argument */ 
    353                 a1=exprarg { $node.args.append($a1.node); } 
    354                 ( 
    355                     ',' 
    356                     a2=exprarg { $node.args.append($a2.node); } 
     353                a1=exprarg { $node.args.append($a1.node) } 
     354                ( 
     355                    ',' 
     356                    a2=exprarg { $node.args.append($a2.node) } 
    357357                )* 
    358358                ( 
    359359                    ',' 
    360                     an3=name '=' av3=exprarg { $node.kwargs.append(($an3.text, $av3.node)); } 
     360                    an3=name '=' av3=exprarg { $node.kwargs.append(($an3.text, $av3.node)) } 
    361361                )* 
    362362                ( 
     
    371371            | 
    372372                /* Keyword arguments only */ 
    373                 an1=name '=' av1=exprarg { $node.kwargs.append(($an1.text, $av1.node)); } 
    374                 ( 
    375                     ',' 
    376                     an2=name '=' av2=exprarg { $node.kwargs.append(($an2.text, $av2.node)); } 
     373                an1=name '=' av1=exprarg { $node.kwargs.append(($an1.text, $av1.node)) } 
     374                ( 
     375                    ',' 
     376                    an2=name '=' av2=exprarg { $node.kwargs.append(($an2.text, $av2.node)) } 
    377377                )* 
    378378                ( 
     
    394394                ( 
    395395                    e2=expr1 { index2 = $e2.node; } 
    396                 )? { $node = ul4c.GetSlice($node, None, index2); } 
     396                )? { $node = ul4c.GetSlice($node, None, index2) } 
    397397            | 
    398398                e2=expr1 { index1 = $e2.node; } 
     
    402402                        e3=expr1 { index2 = $e3.node; } 
    403403                    )? 
    404                 )? { $node = ul4c.GetSlice($node, index1, index2) if slice else ul4c.GetItem($node, index1); } 
     404                )? { $node = ul4c.GetSlice($node, index1, index2) if slice else ul4c.GetItem($node, index1) } 
    405405            ) 
    406406            ']' 
     
    439439                '%' { cls = ul4c.Mod; } 
    440440            ) 
    441             e2=expr8 { $node = cls($node, $e2.node); } 
     441            e2=expr8 { $node = cls($node, $e2.node) } 
    442442        )* 
    443443    ; 
     
    475475                '>=' { cls = ul4c.GE; } 
    476476            ) 
    477             e2=expr6 { $node = cls($node, $e2.node); } 
     477            e2=expr6 { $node = cls($node, $e2.node) } 
    478478        )* 
    479479    ; 
     
    489489            )? 
    490490            'in' 
    491             e2=expr5 { $node = cls($node, $e2.node); } 
     491            e2=expr5 { $node = cls($node, $e2.node) } 
    492492        )? 
    493493    ; 
     
    497497    : 
    498498        'not' 
    499         e=expr4 { $node = ul4c.Not($e.node); } 
     499        e=expr4 { $node = ul4c.Not($e.node) } 
    500500    | 
    501501        e=expr4 { $node = $e.node; } 
     
    509509        ( 
    510510            'and' 
    511             e2=expr3 { $node = ul4c.And($node, $e2.node); } 
     511            e2=expr3 { $node = ul4c.And($node, $e2.node) } 
    512512        )* 
    513513    ; 
     
    519519        ( 
    520520            'or' 
    521             e2=expr2 { $node = ul4c.Or($node, $e2.node); } 
     521            e2=expr2 { $node = ul4c.Or($node, $e2.node) } 
    522522        )* 
    523523    ; 
     
    540540        n=nestedname 
    541541        'in' 
    542         e=expr1 { $node = ul4c.For(self.location, $n.varname, $e.node); } 
     542        e=expr1 { $node = ul4c.For(self.location, $n.varname, $e.node) } 
    543543        EOF 
    544544    ; 
     
    548548 
    549549statement returns [node] 
    550     : nn=nestedname '=' e=expr1 EOF { $node = ul4c.StoreVar(self.location, $nn.varname, $e.node); } 
    551     | n=name '+=' e=expr1 EOF { $node = ul4c.AddVar(self.location, $n.text, $e.node); } 
    552     | n=name '-=' e=expr1 EOF { $node = ul4c.SubVar(self.location, $n.text, $e.node); } 
    553     | n=name '*=' e=expr1 EOF { $node = ul4c.MulVar(self.location, $n.text, $e.node); } 
    554     | n=name '/=' e=expr1 EOF { $node = ul4c.TrueDivVar(self.location, $n.text, $e.node); } 
    555     | n=name '//=' e=expr1 EOF { $node = ul4c.FloorDivVar(self.location, $n.text, $e.node); } 
    556     | n=name '%=' e=expr1 EOF { $node = ul4c.ModVar(self.location, $n.text, $e.node); } 
    557     ; 
     550    : nn=nestedname '=' e=expr1 EOF { $node = ul4c.StoreVar(self.location, $nn.varname, $e.node) } 
     551    | n=name '+=' e=expr1 EOF { $node = ul4c.AddVar(self.location, $n.text, $e.node) } 
     552    | n=name '-=' e=expr1 EOF { $node = ul4c.SubVar(self.location, $n.text, $e.node) } 
     553    | n=name '*=' e=expr1 EOF { $node = ul4c.MulVar(self.location, $n.text, $e.node) } 
     554    | n=name '/=' e=expr1 EOF { $node = ul4c.TrueDivVar(self.location, $n.text, $e.node) } 
     555    | n=name '//=' e=expr1 EOF { $node = ul4c.FloorDivVar(self.location, $n.text, $e.node) } 
     556    | n=name '%=' e=expr1 EOF { $node = ul4c.ModVar(self.location, $n.text, $e.node) } 
     557    | e=expression EOF { $node = $e.node } 
     558    ; 
  • src/ll/UL4Lexer.py

    r5312 r5313  
    1 # $ANTLR 3.4 src/ll/UL4.g 2013-02-06 15:18:23 
     1# $ANTLR 3.4 src/ll/UL4.g 2013-02-06 18:06:39 
    22 
    33import sys 
  • src/ll/UL4Parser.py

    r5312 r5313  
    1 # $ANTLR 3.4 src/ll/UL4.g 2013-02-06 15:18:22 
     1# $ANTLR 3.4 src/ll/UL4.g 2013-02-06 18:06:38 
    22 
    33import sys 
     
    130130                if self._state.backtracking == 0: 
    131131                    pass 
    132                     node =  ul4c.Const(None)  
     132                    node = ul4c.Const(None)  
    133133 
    134134 
     
    164164                if self._state.backtracking == 0: 
    165165                    pass 
    166                     node =  ul4c.Const(True)  
     166                    node = ul4c.Const(True)  
    167167 
    168168 
     
    198198                if self._state.backtracking == 0: 
    199199                    pass 
    200                     node =  ul4c.Const(False)  
     200                    node = ul4c.Const(False)  
    201201 
    202202 
     
    234234                if self._state.backtracking == 0: 
    235235                    pass 
    236                     node =  ul4c.Const(int(INT1.text, 0))  
     236                    node = ul4c.Const(int(INT1.text, 0))  
    237237 
    238238 
     
    270270                if self._state.backtracking == 0: 
    271271                    pass 
    272                     node =  ul4c.Const(float(FLOAT2.text))  
     272                    node = ul4c.Const(float(FLOAT2.text))  
    273273 
    274274 
     
    306306                if self._state.backtracking == 0: 
    307307                    pass 
    308                     node =  ul4c.Const(ast.literal_eval(STRING3.text))  
     308                    node = ul4c.Const(ast.literal_eval(STRING3.text))  
    309309 
    310310 
     
    342342                if self._state.backtracking == 0: 
    343343                    pass 
    344                     node =  ul4c.Const(datetime.datetime(*map(int, [f for f in ul4c.datesplitter.split(DATE4.text[2:-1]) if f])))  
     344                    node = ul4c.Const(datetime.datetime(*map(int, [f for f in ul4c.datesplitter.split(DATE4.text[2:-1]) if f])))  
    345345 
    346346 
     
    378378                if self._state.backtracking == 0: 
    379379                    pass 
    380                     node =  ul4c.Const(color.Color.fromrepr(COLOR5.text))  
     380                    node = ul4c.Const(color.Color.fromrepr(COLOR5.text))  
    381381 
    382382 
     
    424424                if self._state.backtracking == 0: 
    425425                    pass 
    426                     retval.node =  ul4c.Var(NAME6.text)  
     426                    retval.node = ul4c.Var(NAME6.text)  
    427427 
    428428 
     
    705705                    if self._state.backtracking == 0: 
    706706                        pass 
    707                         node =  ul4c.List()  
     707                        node = ul4c.List()  
    708708 
    709709 
     
    717717                    if self._state.backtracking == 0: 
    718718                        pass 
    719                         node =  ul4c.List()  
     719                        node = ul4c.List()  
    720720 
    721721 
     
    728728                    if self._state.backtracking == 0: 
    729729                        pass 
    730                         node.items.append(e1);  
     730                        node.items.append(e1)  
    731731 
    732732 
     
    758758                            if self._state.backtracking == 0: 
    759759                                pass 
    760                                 node.items.append(e2);  
     760                                node.items.append(e2)  
    761761 
    762762 
     
    870870                if self._state.backtracking == 0: 
    871871                    pass 
    872                     node =  ul4c.ListComp(item, n, container, _condition)  
     872                    node = ul4c.ListComp(item, n, container, _condition)  
    873873 
    874874 
     
    939939                    if self._state.backtracking == 0: 
    940940                        pass 
    941                         node =  (k, v)  
     941                        node = (k, v)  
    942942 
    943943 
     
    956956                    if self._state.backtracking == 0: 
    957957                        pass 
    958                         node =  (d,)  
     958                        node = (d,)  
    959959 
    960960 
     
    10271027                    if self._state.backtracking == 0: 
    10281028                        pass 
    1029                         node =  ul4c.Dict()  
     1029                        node = ul4c.Dict()  
    10301030 
    10311031 
     
    10391039                    if self._state.backtracking == 0: 
    10401040                        pass 
    1041                         node =  ul4c.Dict()  
     1041                        node = ul4c.Dict()  
    10421042 
    10431043 
     
    10501050                    if self._state.backtracking == 0: 
    10511051                        pass 
    1052                         node.items.append(i1);  
     1052                        node.items.append(i1)  
    10531053 
    10541054 
     
    10801080                            if self._state.backtracking == 0: 
    10811081                                pass 
    1082                                 node.items.append(i2);  
     1082                                node.items.append(i2)  
    10831083 
    10841084 
     
    12011201                if self._state.backtracking == 0: 
    12021202                    pass 
    1203                     node =  ul4c.DictComp(key, value, n, container, _condition)  
     1203                    node = ul4c.DictComp(key, value, n, container, _condition)  
    12041204 
    12051205 
     
    12891289                if self._state.backtracking == 0: 
    12901290                    pass 
    1291                     node =  ul4c.GenExpr(item, n, container, _condition)  
     1291                    node = ul4c.GenExpr(item, n, container, _condition)  
    12921292 
    12931293 
     
    16061606                    if self._state.backtracking == 0: 
    16071607                        pass 
    1608                         varname =  (n0,)  
     1608                        varname = (n0,)  
    16091609 
    16101610 
     
    16301630                    if self._state.backtracking == 0: 
    16311631                        pass 
    1632                         varname =  (n1, n2)  
     1632                        varname = (n1, n2)  
    16331633 
    16341634 
     
    16601660                            if self._state.backtracking == 0: 
    16611661                                pass 
    1662                                 varname += (n3,);  
     1662                                varname += (n3,)  
    16631663 
    16641664 
     
    17791779                        if self._state.backtracking == 0: 
    17801780                            pass 
    1781                             node =  ul4c.GetAttr(node, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0])  
     1781                            node = ul4c.GetAttr(node, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0])  
    17821782 
    17831783 
     
    17911791                        if self._state.backtracking == 0: 
    17921792                            pass 
    1793                             node =  ul4c.CallMeth(node.obj, node.attrname) if isinstance(node, ul4c.GetAttr) else ul4c.CallFunc(node)  
     1793                            node = ul4c.CallMeth(node.obj, node.attrname) if isinstance(node, ul4c.GetAttr) else ul4c.CallFunc(node)  
    17941794 
    17951795 
     
    19391939                            if self._state.backtracking == 0: 
    19401940                                pass 
    1941                                 node.args.append(a1);  
     1941                                node.args.append(a1)  
    19421942 
    19431943 
     
    19761976                                    if self._state.backtracking == 0: 
    19771977                                        pass 
    1978                                         node.args.append(a2);  
     1978                                        node.args.append(a2)  
    19791979 
    19801980 
     
    20182018                                    if self._state.backtracking == 0: 
    20192019                                        pass 
    2020                                         node.kwargs.append((((an3 is not None) and [self.input.toString(an3.start,an3.stop)] or [None])[0], av3));  
     2020                                        node.kwargs.append((((an3 is not None) and [self.input.toString(an3.start,an3.stop)] or [None])[0], av3))  
    20212021 
    20222022 
     
    21192119                            if self._state.backtracking == 0: 
    21202120                                pass 
    2121                                 node.kwargs.append((((an1 is not None) and [self.input.toString(an1.start,an1.stop)] or [None])[0], av1));  
     2121                                node.kwargs.append((((an1 is not None) and [self.input.toString(an1.start,an1.stop)] or [None])[0], av1))  
    21222122 
    21232123 
     
    21562156                                    if self._state.backtracking == 0: 
    21572157                                        pass 
    2158                                         node.kwargs.append((((an2 is not None) and [self.input.toString(an2.start,an2.stop)] or [None])[0], av2));  
     2158                                        node.kwargs.append((((an2 is not None) and [self.input.toString(an2.start,an2.stop)] or [None])[0], av2))  
    21592159 
    21602160 
     
    22982298                            if self._state.backtracking == 0: 
    22992299                                pass 
    2300                                 node =  ul4c.GetSlice(node, None, index2)  
     2300                                node = ul4c.GetSlice(node, None, index2)  
    23012301 
    23022302 
     
    23622362                            if self._state.backtracking == 0: 
    23632363                                pass 
    2364                                 node =  ul4c.GetSlice(node, index1, index2) if slice else ul4c.GetItem(node, index1)  
     2364                                node = ul4c.GetSlice(node, index1, index2) if slice else ul4c.GetItem(node, index1)  
    23652365 
    23662366 
     
    25802580                        if self._state.backtracking == 0: 
    25812581                            pass 
    2582                             node =  cls(node, e2)  
     2582                            node = cls(node, e2)  
    25832583 
    25842584 
     
    28632863                        if self._state.backtracking == 0: 
    28642864                            pass 
    2865                             node =  cls(node, e2)  
     2865                            node = cls(node, e2)  
    28662866 
    28672867 
     
    29582958                    if self._state.backtracking == 0: 
    29592959                        pass 
    2960                         node =  cls(node, e2)  
     2960                        node = cls(node, e2)  
    29612961 
    29622962 
     
    30213021                    if self._state.backtracking == 0: 
    30223022                        pass 
    3023                         node =  ul4c.Not(e)  
     3023                        node = ul4c.Not(e)  
    30243024 
    30253025 
     
    31023102                        if self._state.backtracking == 0: 
    31033103                            pass 
    3104                             node =  ul4c.And(node, e2)  
     3104                            node = ul4c.And(node, e2)  
    31053105 
    31063106 
     
    31743174                        if self._state.backtracking == 0: 
    31753175                            pass 
    3176                             node =  ul4c.Or(node, e2)  
     3176                            node = ul4c.Or(node, e2)  
    31773177 
    31783178 
     
    38463846                if self._state.backtracking == 0: 
    38473847                    pass 
    3848                     node =  ul4c.For(self.location, n, e)  
     3848                    node = ul4c.For(self.location, n, e)  
    38493849 
    38503850 
     
    38683868 
    38693869    # $ANTLR start "statement" 
    3870     # src/ll/UL4.g:549:1: statement returns [node] : (nn= nestedname '=' e= expr1 EOF |n= name '+=' e= expr1 EOF |n= name '-=' e= expr1 EOF |n= name '*=' e= expr1 EOF |n= name '/=' e= expr1 EOF |n= name '//=' e= expr1 EOF |n= name '%=' e= expr1 EOF ); 
     3870    # src/ll/UL4.g:549:1: statement returns [node] : (nn= nestedname '=' e= expr1 EOF |n= name '+=' e= expr1 EOF |n= name '-=' e= expr1 EOF |n= name '*=' e= expr1 EOF |n= name '/=' e= expr1 EOF |n= name '//=' e= expr1 EOF |n= name '%=' e= expr1 EOF |e= expression EOF ); 
    38713871    def statement(self, ): 
    38723872        node = None 
     
    38823882        try: 
    38833883            try: 
    3884                 # src/ll/UL4.g:550:2: (nn= nestedname '=' e= expr1 EOF |n= name '+=' e= expr1 EOF |n= name '-=' e= expr1 EOF |n= name '*=' e= expr1 EOF |n= name '/=' e= expr1 EOF |n= name '//=' e= expr1 EOF |n= name '%=' e= expr1 EOF ) 
    3885                 alt48 = 7 
    3886                 LA48_0 = self.input.LA(1) 
    3887  
    3888                 if (LA48_0 == NAME) : 
    3889                     LA48 = self.input.LA(2) 
    3890                     if LA48 == 45: 
     3884                # src/ll/UL4.g:550:2: (nn= nestedname '=' e= expr1 EOF |n= name '+=' e= expr1 EOF |n= name '-=' e= expr1 EOF |n= name '*=' e= expr1 EOF |n= name '/=' e= expr1 EOF |n= name '//=' e= expr1 EOF |n= name '%=' e= expr1 EOF |e= expression EOF ) 
     3885                alt48 = 8 
     3886                LA48 = self.input.LA(1) 
     3887                if LA48 == NAME: 
     3888                    LA48_1 = self.input.LA(2) 
     3889 
     3890                    if (self.synpred72_UL4()) : 
    38913891                        alt48 = 1 
    3892                     elif LA48 == 33: 
     3892                    elif (self.synpred73_UL4()) : 
    38933893                        alt48 = 2 
    3894                     elif LA48 == 36: 
     3894                    elif (self.synpred74_UL4()) : 
    38953895                        alt48 = 3 
    3896                     elif LA48 == 31: 
     3896                    elif (self.synpred75_UL4()) : 
    38973897                        alt48 = 4 
    3898                     elif LA48 == 41: 
     3898                    elif (self.synpred76_UL4()) : 
    38993899                        alt48 = 5 
    3900                     elif LA48 == 40: 
     3900                    elif (self.synpred77_UL4()) : 
    39013901                        alt48 = 6 
    3902                     elif LA48 == 26: 
     3902                    elif (self.synpred78_UL4()) : 
    39033903                        alt48 = 7 
     3904                    elif (True) : 
     3905                        alt48 = 8 
    39043906                    else: 
    39053907                        if self._state.backtracking > 0: 
     
    39123914 
    39133915 
    3914                 elif (LA48_0 == 27) : 
    3915                     alt48 = 1 
     3916                elif LA48 == 27: 
     3917                    LA48_2 = self.input.LA(2) 
     3918 
     3919                    if (self.synpred72_UL4()) : 
     3920                        alt48 = 1 
     3921                    elif (True) : 
     3922                        alt48 = 8 
     3923                    else: 
     3924                        if self._state.backtracking > 0: 
     3925                            raise BacktrackingFailed 
     3926 
     3927 
     3928                        nvae = NoViableAltException("", 48, 2, self.input) 
     3929 
     3930                        raise nvae 
     3931 
     3932 
     3933                elif LA48 == COLOR or LA48 == DATE or LA48 == FALSE or LA48 == FLOAT or LA48 == INT or LA48 == NONE or LA48 == STRING or LA48 == TRUE or LA48 == 35 or LA48 == 49 or LA48 == 55 or LA48 == 57: 
     3934                    alt48 = 8 
    39163935                else: 
    39173936                    if self._state.backtracking > 0: 
     
    39433962                    if self._state.backtracking == 0: 
    39443963                        pass 
    3945                         node =  ul4c.StoreVar(self.location, nn, e)  
     3964                        node = ul4c.StoreVar(self.location, nn, e)  
    39463965 
    39473966 
     
    39673986                    if self._state.backtracking == 0: 
    39683987                        pass 
    3969                         node =  ul4c.AddVar(self.location, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0], e)  
     3988                        node = ul4c.AddVar(self.location, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0], e)  
    39703989 
    39713990 
     
    39914010                    if self._state.backtracking == 0: 
    39924011                        pass 
    3993                         node =  ul4c.SubVar(self.location, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0], e)  
     4012                        node = ul4c.SubVar(self.location, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0], e)  
    39944013 
    39954014 
     
    40154034                    if self._state.backtracking == 0: 
    40164035                        pass 
    4017                         node =  ul4c.MulVar(self.location, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0], e)  
     4036                        node = ul4c.MulVar(self.location, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0], e)  
    40184037 
    40194038 
     
    40394058                    if self._state.backtracking == 0: 
    40404059                        pass 
    4041                         node =  ul4c.TrueDivVar(self.location, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0], e)  
     4060                        node = ul4c.TrueDivVar(self.location, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0], e)  
    40424061 
    40434062 
     
    40634082                    if self._state.backtracking == 0: 
    40644083                        pass 
    4065                         node =  ul4c.FloorDivVar(self.location, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0], e)  
     4084                        node = ul4c.FloorDivVar(self.location, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0], e)  
    40664085 
    40674086 
     
    40874106                    if self._state.backtracking == 0: 
    40884107                        pass 
    4089                         node =  ul4c.ModVar(self.location, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0], e)  
     4108                        node = ul4c.ModVar(self.location, ((n is not None) and [self.input.toString(n.start,n.stop)] or [None])[0], e)  
     4109 
     4110 
     4111 
     4112 
     4113                elif alt48 == 8: 
     4114                    # src/ll/UL4.g:557:4: e= expression EOF 
     4115                    pass  
     4116                    self._state.following.append(self.FOLLOW_expression_in_statement2932) 
     4117                    e = self.expression() 
     4118 
     4119                    self._state.following.pop() 
     4120 
     4121                    self.match(self.input, EOF, self.FOLLOW_EOF_in_statement2934) 
     4122 
     4123                    if self._state.backtracking == 0: 
     4124                        pass 
     4125                        node = e  
    40904126 
    40914127 
     
    42674303 
    42684304 
     4305    # $ANTLR start "synpred72_UL4" 
     4306    def synpred72_UL4_fragment(self, ): 
     4307        nn = None 
     4308 
     4309        e = None 
     4310 
     4311 
     4312        # src/ll/UL4.g:550:4: (nn= nestedname '=' e= expr1 EOF ) 
     4313        # src/ll/UL4.g:550:4: nn= nestedname '=' e= expr1 EOF 
     4314        pass  
     4315        self._state.following.append(self.FOLLOW_nestedname_in_synpred72_UL42813) 
     4316        nn = self.nestedname() 
     4317 
     4318        self._state.following.pop() 
     4319 
     4320        self.match(self.input, 45, self.FOLLOW_45_in_synpred72_UL42815) 
     4321 
     4322        self._state.following.append(self.FOLLOW_expr1_in_synpred72_UL42819) 
     4323        e = self.expr1() 
     4324 
     4325        self._state.following.pop() 
     4326 
     4327        self.match(self.input, EOF, self.FOLLOW_EOF_in_synpred72_UL42821) 
     4328 
     4329 
     4330 
     4331    # $ANTLR end "synpred72_UL4" 
     4332 
     4333 
     4334 
     4335    # $ANTLR start "synpred73_UL4" 
     4336    def synpred73_UL4_fragment(self, ): 
     4337        n = None 
     4338 
     4339        e = None 
     4340 
     4341 
     4342        # src/ll/UL4.g:551:4: (n= name '+=' e= expr1 EOF ) 
     4343        # src/ll/UL4.g:551:4: n= name '+=' e= expr1 EOF 
     4344        pass  
     4345        self._state.following.append(self.FOLLOW_name_in_synpred73_UL42830) 
     4346        n = self.name() 
     4347 
     4348        self._state.following.pop() 
     4349 
     4350        self.match(self.input, 33, self.FOLLOW_33_in_synpred73_UL42832) 
     4351 
     4352        self._state.following.append(self.FOLLOW_expr1_in_synpred73_UL42836) 
     4353        e = self.expr1() 
     4354 
     4355        self._state.following.pop() 
     4356 
     4357        self.match(self.input, EOF, self.FOLLOW_EOF_in_synpred73_UL42838) 
     4358 
     4359 
     4360 
     4361    # $ANTLR end "synpred73_UL4" 
     4362 
     4363 
     4364 
     4365    # $ANTLR start "synpred74_UL4" 
     4366    def synpred74_UL4_fragment(self, ): 
     4367        n = None 
     4368 
     4369        e = None 
     4370 
     4371 
     4372        # src/ll/UL4.g:552:4: (n= name '-=' e= expr1 EOF ) 
     4373        # src/ll/UL4.g:552:4: n= name '-=' e= expr1 EOF 
     4374        pass  
     4375        self._state.following.append(self.FOLLOW_name_in_synpred74_UL42847) 
     4376        n = self.name() 
     4377 
     4378        self._state.following.pop() 
     4379 
     4380        self.match(self.input, 36, self.FOLLOW_36_in_synpred74_UL42849) 
     4381 
     4382        self._state.following.append(self.FOLLOW_expr1_in_synpred74_UL42853) 
     4383        e = self.expr1() 
     4384 
     4385        self._state.following.pop() 
     4386 
     4387        self.match(self.input, EOF, self.FOLLOW_EOF_in_synpred74_UL42855) 
     4388 
     4389 
     4390 
     4391    # $ANTLR end "synpred74_UL4" 
     4392 
     4393 
     4394 
     4395    # $ANTLR start "synpred75_UL4" 
     4396    def synpred75_UL4_fragment(self, ): 
     4397        n = None 
     4398 
     4399        e = None 
     4400 
     4401 
     4402        # src/ll/UL4.g:553:4: (n= name '*=' e= expr1 EOF ) 
     4403        # src/ll/UL4.g:553:4: n= name '*=' e= expr1 EOF 
     4404        pass  
     4405        self._state.following.append(self.FOLLOW_name_in_synpred75_UL42864) 
     4406        n = self.name() 
     4407 
     4408        self._state.following.pop() 
     4409 
     4410        self.match(self.input, 31, self.FOLLOW_31_in_synpred75_UL42866) 
     4411 
     4412        self._state.following.append(self.FOLLOW_expr1_in_synpred75_UL42870) 
     4413        e = self.expr1() 
     4414 
     4415        self._state.following.pop() 
     4416 
     4417        self.match(self.input, EOF, self.FOLLOW_EOF_in_synpred75_UL42872) 
     4418 
     4419 
     4420 
     4421    # $ANTLR end "synpred75_UL4" 
     4422 
     4423 
     4424 
     4425    # $ANTLR start "synpred76_UL4" 
     4426    def synpred76_UL4_fragment(self, ): 
     4427        n = None 
     4428 
     4429        e = None 
     4430 
     4431 
     4432        # src/ll/UL4.g:554:4: (n= name '/=' e= expr1 EOF ) 
     4433        # src/ll/UL4.g:554:4: n= name '/=' e= expr1 EOF 
     4434        pass  
     4435        self._state.following.append(self.FOLLOW_name_in_synpred76_UL42881) 
     4436        n = self.name() 
     4437 
     4438        self._state.following.pop() 
     4439 
     4440        self.match(self.input, 41, self.FOLLOW_41_in_synpred76_UL42883) 
     4441 
     4442        self._state.following.append(self.FOLLOW_expr1_in_synpred76_UL42887) 
     4443        e = self.expr1() 
     4444 
     4445        self._state.following.pop() 
     4446 
     4447        self.match(self.input, EOF, self.FOLLOW_EOF_in_synpred76_UL42889) 
     4448 
     4449 
     4450 
     4451    # $ANTLR end "synpred76_UL4" 
     4452 
     4453 
     4454 
     4455    # $ANTLR start "synpred77_UL4" 
     4456    def synpred77_UL4_fragment(self, ): 
     4457        n = None 
     4458 
     4459        e = None 
     4460 
     4461 
     4462        # src/ll/UL4.g:555:4: (n= name '//=' e= expr1 EOF ) 
     4463        # src/ll/UL4.g:555:4: n= name '//=' e= expr1 EOF 
     4464        pass  
     4465        self._state.following.append(self.FOLLOW_name_in_synpred77_UL42898) 
     4466        n = self.name() 
     4467 
     4468        self._state.following.pop() 
     4469 
     4470        self.match(self.input, 40, self.FOLLOW_40_in_synpred77_UL42900) 
     4471 
     4472        self._state.following.append(self.FOLLOW_expr1_in_synpred77_UL42904) 
     4473        e = self.expr1() 
     4474 
     4475        self._state.following.pop() 
     4476 
     4477        self.match(self.input, EOF, self.FOLLOW_EOF_in_synpred77_UL42906) 
     4478 
     4479 
     4480 
     4481    # $ANTLR end "synpred77_UL4" 
     4482 
     4483 
     4484 
     4485    # $ANTLR start "synpred78_UL4" 
     4486    def synpred78_UL4_fragment(self, ): 
     4487        n = None 
     4488 
     4489        e = None 
     4490 
     4491 
     4492        # src/ll/UL4.g:556:4: (n= name '%=' e= expr1 EOF ) 
     4493        # src/ll/UL4.g:556:4: n= name '%=' e= expr1 EOF 
     4494        pass  
     4495        self._state.following.append(self.FOLLOW_name_in_synpred78_UL42915) 
     4496        n = self.name() 
     4497 
     4498        self._state.following.pop() 
     4499 
     4500        self.match(self.input, 26, self.FOLLOW_26_in_synpred78_UL42917) 
     4501 
     4502        self._state.following.append(self.FOLLOW_expr1_in_synpred78_UL42921) 
     4503        e = self.expr1() 
     4504 
     4505        self._state.following.pop() 
     4506 
     4507        self.match(self.input, EOF, self.FOLLOW_EOF_in_synpred78_UL42923) 
     4508 
     4509 
     4510 
     4511    # $ANTLR end "synpred78_UL4" 
     4512 
     4513 
     4514 
     4515 
     4516    def synpred76_UL4(self): 
     4517        self._state.backtracking += 1 
     4518        start = self.input.mark() 
     4519        try: 
     4520            self.synpred76_UL4_fragment() 
     4521        except BacktrackingFailed: 
     4522            success = False 
     4523        else: 
     4524            success = True 
     4525        self.input.rewind(start) 
     4526        self._state.backtracking -= 1 
     4527        return success 
     4528 
     4529    def synpred22_UL4(self): 
     4530        self._state.backtracking += 1 
     4531        start = self.input.mark() 
     4532        try: 
     4533            self.synpred22_UL4_fragment() 
     4534        except BacktrackingFailed: 
     4535            success = False 
     4536        else: 
     4537            success = True 
     4538        self.input.rewind(start) 
     4539        self._state.backtracking -= 1 
     4540        return success 
     4541 
     4542    def synpred78_UL4(self): 
     4543        self._state.backtracking += 1 
     4544        start = self.input.mark() 
     4545        try: 
     4546            self.synpred78_UL4_fragment() 
     4547        except BacktrackingFailed: 
     4548            success = False 
     4549        else: 
     4550            success = True 
     4551        self.input.rewind(start) 
     4552        self._state.backtracking -= 1 
     4553        return success 
     4554 
     4555    def synpred77_UL4(self): 
     4556        self._state.backtracking += 1 
     4557        start = self.input.mark() 
     4558        try: 
     4559            self.synpred77_UL4_fragment() 
     4560        except BacktrackingFailed: 
     4561            success = False 
     4562        else: 
     4563            success = True 
     4564        self.input.rewind(start) 
     4565        self._state.backtracking -= 1 
     4566        return success 
     4567 
     4568    def synpred70_UL4(self): 
     4569        self._state.backtracking += 1 
     4570        start = self.input.mark() 
     4571        try: 
     4572            self.synpred70_UL4_fragment() 
     4573        except BacktrackingFailed: 
     4574            success = False 
     4575        else: 
     4576            success = True 
     4577        self.input.rewind(start) 
     4578        self._state.backtracking -= 1 
     4579        return success 
     4580 
     4581    def synpred24_UL4(self): 
     4582        self._state.backtracking += 1 
     4583        start = self.input.mark() 
     4584        try: 
     4585            self.synpred24_UL4_fragment() 
     4586        except BacktrackingFailed: 
     4587            success = False 
     4588        else: 
     4589            success = True 
     4590        self.input.rewind(start) 
     4591        self._state.backtracking -= 1 
     4592        return success 
     4593 
     4594    def synpred75_UL4(self): 
     4595        self._state.backtracking += 1 
     4596        start = self.input.mark() 
     4597        try: 
     4598            self.synpred75_UL4_fragment() 
     4599        except BacktrackingFailed: 
     4600            success = False 
     4601        else: 
     4602            success = True 
     4603        self.input.rewind(start) 
     4604        self._state.backtracking -= 1 
     4605        return success 
     4606 
     4607    def synpred20_UL4(self): 
     4608        self._state.backtracking += 1 
     4609        start = self.input.mark() 
     4610        try: 
     4611            self.synpred20_UL4_fragment() 
     4612        except BacktrackingFailed: 
     4613            success = False 
     4614        else: 
     4615            success = True 
     4616        self.input.rewind(start) 
     4617        self._state.backtracking -= 1 
     4618        return success 
     4619 
     4620    def synpred23_UL4(self): 
     4621        self._state.backtracking += 1 
     4622        start = self.input.mark() 
     4623        try: 
     4624            self.synpred23_UL4_fragment() 
     4625        except BacktrackingFailed: 
     4626            success = False 
     4627        else: 
     4628            success = True 
     4629        self.input.rewind(start) 
     4630        self._state.backtracking -= 1 
     4631        return success 
    42694632 
    42704633    def synpred26_UL4(self): 
     
    42814644        return success 
    42824645 
    4283     def synpred22_UL4(self): 
     4646    def synpred72_UL4(self): 
    42844647        self._state.backtracking += 1 
    42854648        start = self.input.mark() 
    42864649        try: 
    4287             self.synpred22_UL4_fragment() 
     4650            self.synpred72_UL4_fragment() 
    42884651        except BacktrackingFailed: 
    42894652            success = False 
     
    43074670        return success 
    43084671 
    4309     def synpred70_UL4(self): 
    4310         self._state.backtracking += 1 
    4311         start = self.input.mark() 
    4312         try: 
    4313             self.synpred70_UL4_fragment() 
    4314         except BacktrackingFailed: 
    4315             success = False 
    4316         else: 
    4317             success = True 
    4318         self.input.rewind(start) 
    4319         self._state.backtracking -= 1 
    4320         return success 
    4321  
    43224672    def synpred21_UL4(self): 
    43234673        self._state.backtracking += 1 
     
    43334683        return success 
    43344684 
    4335     def synpred24_UL4(self): 
     4685    def synpred73_UL4(self): 
    43364686        self._state.backtracking += 1 
    43374687        start = self.input.mark() 
    43384688        try: 
    4339             self.synpred24_UL4_fragment() 
     4689            self.synpred73_UL4_fragment() 
    43404690        except BacktrackingFailed: 
    43414691            success = False 
     
    43464696        return success 
    43474697 
    4348     def synpred20_UL4(self): 
     4698    def synpred74_UL4(self): 
    43494699        self._state.backtracking += 1 
    43504700        start = self.input.mark() 
    43514701        try: 
    4352             self.synpred20_UL4_fragment() 
    4353         except BacktrackingFailed: 
    4354             success = False 
    4355         else: 
    4356             success = True 
    4357         self.input.rewind(start) 
    4358         self._state.backtracking -= 1 
    4359         return success 
    4360  
    4361     def synpred23_UL4(self): 
    4362         self._state.backtracking += 1 
    4363         start = self.input.mark() 
    4364         try: 
    4365             self.synpred23_UL4_fragment() 
     4702            self.synpred74_UL4_fragment() 
    43664703        except BacktrackingFailed: 
    43674704            success = False 
     
    45864923    FOLLOW_expr1_in_statement2921 = frozenset([]) 
    45874924    FOLLOW_EOF_in_statement2923 = frozenset([1]) 
     4925    FOLLOW_expression_in_statement2932 = frozenset([]) 
     4926    FOLLOW_EOF_in_statement2934 = frozenset([1]) 
    45884927    FOLLOW_list_in_synpred20_UL41385 = frozenset([1]) 
    45894928    FOLLOW_listcomprehension_in_synpred21_UL41394 = frozenset([1]) 
     
    46004939    FOLLOW_generatorexpression_in_synpred71_UL42738 = frozenset([]) 
    46014940    FOLLOW_EOF_in_synpred71_UL42740 = frozenset([1]) 
     4941    FOLLOW_nestedname_in_synpred72_UL42813 = frozenset([45]) 
     4942    FOLLOW_45_in_synpred72_UL42815 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57]) 
     4943    FOLLOW_expr1_in_synpred72_UL42819 = frozenset([]) 
     4944    FOLLOW_EOF_in_synpred72_UL42821 = frozenset([1]) 
     4945    FOLLOW_name_in_synpred73_UL42830 = frozenset([33]) 
     4946    FOLLOW_33_in_synpred73_UL42832 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57]) 
     4947    FOLLOW_expr1_in_synpred73_UL42836 = frozenset([]) 
     4948    FOLLOW_EOF_in_synpred73_UL42838 = frozenset([1]) 
     4949    FOLLOW_name_in_synpred74_UL42847 = frozenset([36]) 
     4950    FOLLOW_36_in_synpred74_UL42849 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57]) 
     4951    FOLLOW_expr1_in_synpred74_UL42853 = frozenset([]) 
     4952    FOLLOW_EOF_in_synpred74_UL42855 = frozenset([1]) 
     4953    FOLLOW_name_in_synpred75_UL42864 = frozenset([31]) 
     4954    FOLLOW_31_in_synpred75_UL42866 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57]) 
     4955    FOLLOW_expr1_in_synpred75_UL42870 = frozenset([]) 
     4956    FOLLOW_EOF_in_synpred75_UL42872 = frozenset([1]) 
     4957    FOLLOW_name_in_synpred76_UL42881 = frozenset([41]) 
     4958    FOLLOW_41_in_synpred76_UL42883 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57]) 
     4959    FOLLOW_expr1_in_synpred76_UL42887 = frozenset([]) 
     4960    FOLLOW_EOF_in_synpred76_UL42889 = frozenset([1]) 
     4961    FOLLOW_name_in_synpred77_UL42898 = frozenset([40]) 
     4962    FOLLOW_40_in_synpred77_UL42900 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57]) 
     4963    FOLLOW_expr1_in_synpred77_UL42904 = frozenset([]) 
     4964    FOLLOW_EOF_in_synpred77_UL42906 = frozenset([1]) 
     4965    FOLLOW_name_in_synpred78_UL42915 = frozenset([26]) 
     4966    FOLLOW_26_in_synpred78_UL42917 = frozenset([5, 6, 10, 11, 13, 14, 15, 17, 19, 27, 35, 49, 55, 57]) 
     4967    FOLLOW_expr1_in_synpred78_UL42921 = frozenset([]) 
     4968    FOLLOW_EOF_in_synpred78_UL42923 = frozenset([1]) 
    46024969 
    46034970 
  • src/ll/ul4c.py

    r5312 r5313  
    362362 
    363363    def _str(self, indent, keepws): 
    364         yield _repr(self.value) 
     364        yield _repr_(self.value) 
    365365 
    366366    def eval(self, keepws, vars): 
     
    12961296 
    12971297 
     1298@register("print") 
     1299class Print(UnaryTag): 
     1300    """ 
     1301    AST node for a ``<?print?>`` tag. 
     1302    """ 
     1303 
     1304    def _str(self, indent, keepws): 
     1305        yield indent*"\t" 
     1306        yield "print " 
     1307        yield from self.obj._str(indent, keepws) 
     1308        yield "\n" 
     1309 
     1310    def eval(self, keepws, vars): 
     1311        yield _str_((yield from self.obj.eval(keepws, vars))) 
     1312 
     1313 
     1314@register("printx") 
     1315class PrintX(UnaryTag): 
     1316    """ 
     1317    AST node for a ``<?printx?>`` tag. 
     1318    """ 
     1319 
     1320    def _str(self, indent, keepws): 
     1321        yield indent*"\t" 
     1322        yield "printx " 
     1323        yield from self.obj._str(indent, keepws) 
     1324        yield "\n" 
     1325 
     1326    def eval(self, keepws, vars): 
     1327        yield _xmlescape_((yield from self.obj.eval(keepws, vars))) 
     1328 
     1329 
    12981330@register("return") 
    12991331class Return(UnaryTag): 
     
    13111343        value = (yield from self.obj.eval(keepws, vars)) 
    13121344        raise ReturnException(value) 
    1313  
    1314  
    1315 @register("print") 
    1316 class Print(UnaryTag): 
    1317     """ 
    1318     AST node for a ``<?print?>`` tag. 
    1319     """ 
    1320  
    1321     def _str(self, indent, keepws): 
    1322         yield indent*"\t" 
    1323         yield "print " 
    1324         yield from self.obj._str(indent, keepws) 
    1325         yield "\n" 
    1326  
    1327     def eval(self, keepws, vars): 
    1328         yield _str((yield from self.obj.eval(keepws, vars))) 
    1329  
    1330  
    1331 @register("printx") 
    1332 class PrintX(UnaryTag): 
    1333     """ 
    1334     AST node for a ``<?printx?>`` tag. 
    1335     """ 
    1336  
    1337     def _str(self, indent, keepws): 
    1338         yield indent*"\t" 
    1339         yield "printx " 
    1340         yield from self.obj._str(indent, keepws) 
    1341         yield "\n" 
    1342  
    1343     def eval(self, keepws, vars): 
    1344         yield _xmlescape((yield from self.obj.eval(keepws, vars))) 
    13451345 
    13461346 
     
    20172017        if self.remkwargs is not None: 
    20182018            kwargs.update((yield from self.remkwargs.eval(keepws, vars))) 
    2019         return obj(*args, **kwargs) 
     2019        return (yield from obj(*args, **kwargs)) 
    20202020 
    20212021    def ul4ondump(self, encoder): 
     
    21452145        if self.remkwargs is not None: 
    21462146            kwargs.update((yield from self.remkwargs.eval(keepws, vars))) 
    2147         return self.methods[self.methname](obj, *args, **kwargs) 
     2147        return (yield from self.methods[self.methname](obj, *args, **kwargs)) 
    21482148 
    21492149    def ul4ondump(self, encoder): 
     
    21622162        self.remargs = decoder.load() 
    21632163        self.remkwargs = decoder.load() 
    2164  
    2165  
    2166 @register("render") 
    2167 class Render(UnaryTag): 
    2168     """ 
    2169     AST node for the ``<?render?>`` tag. 
    2170     """ 
    2171  
    2172     def _str(self, indent, keepws): 
    2173         yield indent*"\t" 
    2174         yield "render " 
    2175         yield from self.obj._str(indent, keepws) 
    2176         yield "\n" 
    2177  
    2178     def eval(self, keepws, vars): 
    2179         if isinstance(self.obj, CallMeth) and self.obj.methname == "render": 
    2180             output = (yield from self.obj.eval(keepws, vars)) 
    2181             yield from output 
    2182         else: 
    2183             yield _str((yield from self.obj.eval(keepws, vars))) 
    21842164 
    21852165 
     
    23482328        template code. 
    23492329        """ 
    2350         yield from Block.eval(self, self.keepws, vars) 
     2330        yield from super().eval(self.keepws, vars) # Bypass ``self.eval()`` which simply stores the object as a local variable 
    23512331 
    23522332    def renders(self, **vars): 
     
    23592339    def __call__(self, **vars): 
    23602340        """ 
    2361         Call the function and return the resulting value. :var:`vars` contains 
    2362         the top level variables available to the function code. 
     2341        Call the template as a function and return the resulting value. 
     2342        :var:`vars` contains the top level variables available to the template code. 
    23632343        """ 
    23642344        try: 
    2365             for x in Block.eval(self, self.keepws, vars): # Bypass ``self.eval()`` which simply stores the object as a local variable 
     2345            for output in super().eval(self.keepws, vars): # Bypass ``self.eval()`` which simply stores the object as a local variable 
    23662346                pass # Ignore all output 
    23672347        except ReturnException as ex: 
     
    23892369        or non-tag text. It will be called by :meth:`_compile` internally. 
    23902370        """ 
    2391         pattern = "{}(printx|print|code|for|if|elif|else|end|break|continue|render|def|return|note)(\s*((.|\\n)*?)\s*)?{}".format(re.escape(startdelim), re.escape(enddelim)) 
     2371        pattern = "{}(printx|print|exe|for|if|elif|else|end|break|continue|def|return|note)(\s*((.|\\n)*?)\s*)?{}".format(re.escape(startdelim), re.escape(enddelim)) 
    23922372        pos = 0 
    23932373        for match in re.finditer(pattern, source): 
     
    24492429                elif location.type == "printx": 
    24502430                    stack[-1].append(PrintX(location, parseexpr(location))) 
    2451                 elif location.type == "code": 
     2431                elif location.type == "exe": 
    24522432                    stack[-1].append(parsestmt(location)) 
    24532433                elif location.type == "if": 
     
    25062486                            raise BlockError("continue outside of for loop") 
    25072487                    stack[-1].append(Continue(location)) 
    2508                 elif location.type == "render": 
    2509                     stack[-1].append(Render(location, parseexpr(location))) 
    25102488                elif location.type == "def": 
    25112489                    block = Template(None, location.code, self.keepws, self.startdelim, self.enddelim) 
     
    25332511 
    25342512@AST.makefunction 
     2513def _print(*values): 
     2514    for (i, value) in enumerate(values): 
     2515        if i: 
     2516            yield " " 
     2517        yield _str_(value) 
     2518 
     2519 
     2520@AST.makefunction 
     2521def _printx(*values): 
     2522    for (i, value) in enumerate(values): 
     2523        if i: 
     2524            yield " " 
     2525        yield _xmlescape_(value) 
     2526 
     2527 
     2528@AST.makefunction 
    25352529def _str(obj=""): 
    2536     if obj is None: 
    2537         return "" 
    2538     elif isinstance(obj, Undefined): 
    2539         return "" 
    2540     else: 
    2541         return str(obj) 
     2530    yield from () 
     2531    return _str_(obj) 
    25422532 
    25432533 
    25442534@AST.makefunction 
    25452535def _repr(obj): 
    2546     if isinstance(obj, str): 
    2547         return repr(obj) 
    2548     elif isinstance(obj, datetime.datetime): 
    2549         s = str(obj.isoformat()) 
    2550         if s.endswith("T00:00:00"): 
    2551             s = s[:-9] 
    2552         return "@({})".format(s) 
    2553     elif isinstance(obj, datetime.date): 
    2554         return "@({})".format(obj.isoformat()) 
    2555     elif isinstance(obj, datetime.timedelta): 
    2556         return repr(obj).partition(".")[-1] 
    2557     elif isinstance(obj, color.Color): 
    2558         if obj[3] == 0xff: 
    2559             s = "#{:02x}{:02x}{:02x}".format(obj[0], obj[1], obj[2]) 
    2560             if s[1]==s[2] and s[3]==s[4] and s[5]==s[6]: 
    2561                 return "#{}{}{}".format(s[1], s[3], s[5]) 
    2562             return s 
    2563         else: 
    2564             s = "#{:02x}{:02x}{:02x}{:02x}".format(*obj) 
    2565             if s[1]==s[2] and s[3]==s[4] and s[5]==s[6] and s[7]==s[8]: 
    2566                 return "#{}{}{}{}".format(s[1], s[3], s[5], s[7]) 
    2567             return s 
    2568     elif isinstance(obj, collections.Sequence): 
    2569         return "[{}]".format(", ".join(_repr(item) for item in obj)) 
    2570     elif isinstance(obj, collections.Mapping): 
    2571         return "{{{}}}".format(", ".join("{}: {}".format(_repr(key), _repr(value)) for (key, value) in obj.items())) 
    2572     else: 
    2573         return repr(obj) 
     2536    yield from () 
     2537    return _repr_(obj) 
    25742538 
    25752539 
    25762540@AST.makefunction 
    25772541def _now(): 
     2542    yield from () 
    25782543    return datetime.datetime.now() 
    25792544 
     
    25812546@AST.makefunction 
    25822547def _utcnow(): 
     2548    yield from () 
    25832549    return datetime.datetime.utcnow() 
    25842550 
     
    25862552@AST.makefunction 
    25872553def _date(year, month, day, hour=0, minute=0, second=0, microsecond=0): 
     2554    yield from () 
    25882555    return datetime.datetime(year, month, day, hour, minute, second, microsecond) 
    25892556 
     
    25912558@AST.makefunction 
    25922559def _timedelta(days=0, seconds=0, microseconds=0): 
     2560    yield from () 
    25932561    return datetime.timedelta(days, seconds, microseconds) 
    25942562 
     
    25962564@AST.makefunction 
    25972565def _monthdelta(months=0): 
     2566    yield from () 
    25982567    return misc.monthdelta(months) 
    25992568 
     
    26012570@AST.makefunction 
    26022571def _random(): 
     2572    yield from () 
    26032573    return random.random() 
    26042574 
     
    26062576@AST.makefunction 
    26072577def _xmlescape(obj): 
    2608     if obj is None: 
    2609         return "" 
    2610     elif isinstance(obj, Undefined): 
    2611         return "" 
    2612     else: 
    2613         return misc.xmlescape(str(obj)) 
     2578    yield from () 
     2579    return _xmlescape_(obj) 
    26142580 
    26152581 
    26162582@AST.makefunction 
    26172583def _csv(obj): 
     2584    yield from () 
    26182585    if obj is None: 
    26192586        return "" 
     
    26212588        return "" 
    26222589    elif not isinstance(obj, str): 
    2623         obj = _repr(obj) 
     2590        obj = _repr_(obj) 
    26242591    if any(c in obj for c in ',"\n'): 
    26252592        return '"{}"'.format(obj.replace('"', '""')) 
     
    26292596@AST.makefunction 
    26302597def _asjson(obj): 
    2631     if obj is None: 
    2632         return "null" 
    2633     elif isinstance(obj, Undefined): 
    2634         return "{}.undefined" 
    2635     if isinstance(obj, (bool, int, float, str)): 
    2636         return json.dumps(obj) 
    2637     elif isinstance(obj, datetime.datetime): 
    2638         return "new Date({}, {}, {}, {}, {}, {}, {})".format(obj.year, obj.month-1, obj.day, obj.hour, obj.minute, obj.second, obj.microsecond//1000) 
    2639     elif isinstance(obj, datetime.date): 
    2640         return "new Date({}, {}, {})".format(obj.year, obj.month-1, obj.day) 
    2641     elif isinstance(obj, datetime.timedelta): 
    2642         return "ul4.TimeDelta.create({}, {}, {})".format(obj.days, obj.seconds, obj.microseconds) 
    2643     elif isinstance(obj, misc.monthdelta): 
    2644         return "ul4.MonthDelta.create({})".format(obj.months) 
    2645     elif isinstance(obj, color.Color): 
    2646         return "ul4.Color.create({}, {}, {}, {})".format(*obj) 
    2647     elif isinstance(obj, collections.Mapping): 
    2648         return "{{{}}}".format(", ".join("{}: {}".format(_asjson(key), _asjson(value)) for (key, value) in obj.items())) 
    2649     elif isinstance(obj, collections.Sequence): 
    2650         return "[{}]".format(", ".join(_asjson(item) for item in obj)) 
    2651     elif isinstance(obj, Template): 
    2652         return obj.jssource() 
    2653     else: 
    2654         raise TypeError("can't handle object of type {}".format(type(obj))) 
     2598    yield from () 
     2599    return _asjson_(obj) 
    26552600 
    26562601 
     
    26582603def _fromjson(string): 
    26592604    from ll import ul4on 
     2605    yield from () 
    26602606    return json.loads(string) 
    26612607 
     
    26642610def _asul4on(obj): 
    26652611    from ll import ul4on 
     2612    yield from () 
    26662613    return ul4on.dumps(obj) 
    26672614 
     
    26702617def _fromul4on(string): 
    26712618    from ll import ul4on 
     2619    yield from () 
    26722620    return ul4on.loads(string) 
    26732621 
     
    26752623@AST.makefunction 
    26762624def _int(obj=0, base=None): 
     2625    yield from () 
    26772626    if base is None: 
    26782627        return int(obj) 
     
    26832632@AST.makefunction 
    26842633def _float(obj=0.0): 
     2634    yield from () 
    26852635    return float(obj) 
    26862636 
     
    26882638@AST.makefunction 
    26892639def _bool(obj=False): 
     2640    yield from () 
    26902641    return bool(obj) 
    26912642 
     
    26932644@AST.makefunction 
    26942645def _len(sequence): 
     2646    yield from () 
    26952647    return len(sequence) 
    26962648 
     
    26982650@AST.makefunction 
    26992651def _abs(number): 
     2652    yield from () 
    27002653    return abs(number) 
    27012654 
     
    27032656@AST.makefunction 
    27042657def _any(iterable): 
     2658    yield from () 
    27052659    return any(iterable) 
    27062660 
     
    27082662@AST.makefunction 
    27092663def _all(iterable): 
     2664    yield from () 
    27102665    return all(iterable) 
    27112666 
     
    27132668@AST.makefunction 
    27142669def _enumerate(iterable, start=0): 
     2670    yield from () 
    27152671    return enumerate(iterable, start) 
    27162672 
     
    27182674@AST.makefunction 
    27192675def _enumfl(iterable, start=0): 
    2720     lastitem = None 
    2721     first = True 
    2722     i = start 
    2723     it = iter(iterable) 
    2724     try: 
    2725         item = next(it) 
    2726     except StopIteration: 
    2727         return 
    2728     while True: 
     2676    yield from () 
     2677    def result(iterable): 
     2678        lastitem = None 
     2679        first = True 
     2680        i = start 
     2681        it = iter(iterable) 
    27292682        try: 
    2730             (lastitem, item) = (item, next(it)) 
     2683            item = next(it) 
    27312684        except StopIteration: 
    2732             yield (i, first, True, item) # Items haven't been swapped yet 
    27332685            return 
    2734         else: 
    2735             yield (i, first, False, lastitem) 
     2686        while True: 
     2687            try: 
     2688                (lastitem, item) = (item, next(it)) 
     2689            except StopIteration: 
     2690                yield (i, first, True, item) # Items haven't been swapped yet 
     2691                return 
     2692            else: 
     2693                yield (i, first, False, lastitem) 
     2694                first = False 
     2695            i += 1 
     2696    return result(iterable) 
     2697 
     2698 
     2699@AST.makefunction 
     2700def _isfirstlast(iterable): 
     2701    yield from () 
     2702    def result(iterable): 
     2703        lastitem = None 
     2704        first = True 
     2705        it = iter(iterable) 
     2706        try: 
     2707            item = next(it) 
     2708        except StopIteration: 
     2709            return 
     2710        while True: 
     2711            try: 
     2712                (lastitem, item) = (item, next(it)) 
     2713            except StopIteration: 
     2714                yield (first, True, item) # Items haven't been swapped yet 
     2715                return 
     2716            else: 
     2717                yield (first, False, lastitem) 
     2718                first = False 
     2719    return result(iterable) 
     2720 
     2721 
     2722@AST.makefunction 
     2723def _isfirst(iterable): 
     2724    yield from () 
     2725    def result(iterable): 
     2726        first = True 
     2727        for item in iterable: 
     2728            yield (first, item) 
    27362729            first = False 
    2737         i += 1 
    2738  
    2739  
    2740 @AST.makefunction 
    2741 def _isfirstlast(iterable): 
    2742     lastitem = None 
    2743     first = True 
    2744     it = iter(iterable) 
    2745     try: 
    2746         item = next(it) 
    2747     except StopIteration: 
    2748         return 
    2749     while True: 
     2730    return result(iterable) 
     2731 
     2732 
     2733@AST.makefunction 
     2734def _islast(iterable): 
     2735    yield from () 
     2736    def result(iterable): 
     2737        lastitem = None 
     2738        it = iter(iterable) 
    27502739        try: 
    2751             (lastitem, item) = (item, next(it)) 
     2740            item = next(it) 
    27522741        except StopIteration: 
    2753             yield (first, True, item) # Items haven't been swapped yet 
    27542742            return 
    2755         else: 
    2756             yield (first, False, lastitem) 
    2757             first = False 
    2758  
    2759  
    2760 @AST.makefunction 
    2761 def _isfirst(iterable): 
    2762     first = True 
    2763     for item in iterable: 
    2764         yield (first, item) 
    2765         first = False 
    2766  
    2767  
    2768 @AST.makefunction 
    2769 def _islast(iterable): 
    2770     lastitem = None 
    2771     it = iter(iterable) 
    2772     try: 
    2773         item = next(it) 
    2774     except StopIteration: 
    2775         return 
    2776     while True: 
    2777         try: 
    2778             (lastitem, item) = (item, next(it)) 
    2779         except StopIteration: 
    2780             yield (True, item) # Items haven't been swapped yet 
    2781             return 
    2782         else: 
    2783             yield (False, lastitem) 
     2743        while True: 
     2744            try: 
     2745                (lastitem, item) = (item, next(it)) 
     2746            except StopIteration: 
     2747                yield (True, item) # Items haven't been swapped yet 
     2748                return 
     2749            else: 
     2750                yield (False, lastitem) 
     2751    return result(iterable) 
    27842752 
    27852753 
    27862754@AST.makefunction 
    27872755def _isundefined(obj): 
     2756    yield from () 
    27882757    return isinstance(obj, Undefined) 
    27892758 
     
    27912760@AST.makefunction 
    27922761def _isdefined(obj): 
     2762    yield from () 
    27932763    return not isinstance(obj, Undefined) 
    27942764 
     
    27962766@AST.makefunction 
    27972767def _isnone(obj): 
     2768    yield from () 
    27982769    return obj is None 
    27992770 
     
    28012772@AST.makefunction 
    28022773def _isstr(obj): 
     2774    yield from () 
    28032775    return isinstance(obj, str) 
    28042776 
     
    28062778@AST.makefunction 
    28072779def _isint(obj): 
     2780    yield from () 
    28082781    return isinstance(obj, int) and not isinstance(obj, bool) 
    28092782 
     
    28112784@AST.makefunction 
    28122785def _isfloat(obj): 
     2786    yield from () 
    28132787    return isinstance(obj, float) 
    28142788 
     
    28162790@AST.makefunction 
    28172791def _isbool(obj): 
     2792    yield from () 
    28182793    return isinstance(obj, bool) 
    28192794 
     
    28212796@AST.makefunction 
    28222797def _isdate(obj): 
     2798    yield from () 
    28232799    return isinstance(obj, (datetime.datetime, datetime.date)) 
    28242800 
     
    28262802@AST.makefunction 
    28272803def _istimedelta(obj): 
     2804    yield from () 
    28282805    return isinstance(obj, datetime.timedelta) 
    28292806 
     
    28312808@AST.makefunction 
    28322809def _ismonthdelta(obj): 
     2810    yield from () 
    28332811    return isinstance(obj, misc.monthdelta) 
    28342812 
     
    28362814@AST.makefunction 
    28372815def _islist(obj): 
     2816    yield from () 
    28382817    return isinstance(obj, collections.Sequence) and not isinstance(obj, str) and not isinstance(obj, color.Color) 
    28392818 
     
    28412820@AST.makefunction 
    28422821def _isdict(obj): 
     2822    yield from () 
    28432823    return isinstance(obj, collections.Mapping) and not isinstance(obj, Template) 
    28442824 
     
    28462826@AST.makefunction 
    28472827def _iscolor(obj): 
     2828    yield from () 
    28482829    return isinstance(obj, color.Color) 
    28492830 
     
    28512832@AST.makefunction 
    28522833def _istemplate(obj): 
     2834    yield from () 
    28532835    return isinstance(obj, (Template, TemplateClosure)) 
    28542836 
     
    28562838@AST.makefunction 
    28572839def _isfunction(obj): 
     2840    yield from () 
    28582841    return callable(obj) 
    28592842 
     
    28612844@AST.makefunction 
    28622845def _chr(i): 
     2846    yield from () 
    28632847    return chr(i) 
    28642848 
     
    28662850@AST.makefunction 
    28672851def _ord(c): 
     2852    yield from () 
    28682853    return ord(c) 
    28692854 
     
    28712856@AST.makefunction 
    28722857def _hex(number): 
     2858    yield from () 
    28732859    return hex(number) 
    28742860 
     
    28762862@AST.makefunction 
    28772863def _oct(number): 
     2864    yield from () 
    28782865    return oct(number) 
    28792866 
     
    28812868@AST.makefunction 
    28822869def _bin(number): 
     2870    yield from () 
    28832871    return bin(number) 
    28842872 
     
    28862874@AST.makefunction 
    28872875def _min(*args): 
     2876    yield from () 
    28882877    return min(*args) 
    28892878 
     
    28912880@AST.makefunction 
    28922881def _max(*args): 
     2882    yield from () 
    28932883    return max(*args) 
    28942884 
     
    28962886@AST.makefunction 
    28972887def _sorted(iterable): 
     2888    yield from () 
    28982889    return sorted(iterable) 
    28992890 
     
    29012892@AST.makefunction 
    29022893def _range(*args): 
     2894    yield from () 
    29032895    return range(*args) 
    29042896 
     
    29062898@AST.makefunction 
    29072899def _type(obj): 
     2900    yield from () 
    29082901    if obj is None: 
    29092902        return "none" 
     
    29412934@AST.makefunction 
    29422935def _reversed(sequence): 
     2936    yield from () 
    29432937    return reversed(sequence) 
    29442938 
     
    29462940@AST.makefunction 
    29472941def _randrange(*args): 
     2942    yield from () 
    29482943    return random.randrange(*args) 
    29492944 
     
    29512946@AST.makefunction 
    29522947def _randchoice(sequence): 
     2948    yield from () 
    29532949    return random.choice(sequence) 
    29542950 
     
    29562952@AST.makefunction 
    29572953def _format(obj, fmt, lang=None): 
     2954    yield from () 
    29582955    if isinstance(obj, (datetime.date, datetime.time, datetime.timedelta)): 
    29592956        if lang is None: 
     
    29792976@AST.makefunction 
    29802977def _zip(*iterables): 
     2978    yield from () 
    29812979    return zip(*iterables) 
    29822980 
     
    29842982@AST.makefunction 
    29852983def _urlquote(string): 
     2984    yield from () 
    29862985    return urlparse.quote_plus(string) 
    29872986 
     
    29892988@AST.makefunction 
    29902989def _urlunquote(string): 
     2990    yield from () 
    29912991    return urlparse.unquote_plus(string) 
    29922992 
     
    29942994@AST.makefunction 
    29952995def _rgb(r, g, b, a=1.0): 
     2996    yield from () 
    29962997    return color.Color.fromrgb(r, g, b, a) 
    29972998 
     
    29993000@AST.makefunction 
    30003001def _hls(h, l, s, a=1.0): 
     3002    yield from () 
    30013003    return color.Color.fromhls(h, l, s, a) 
    30023004 
     
    30043006@AST.makefunction 
    30053007def _hsv(h, s, v, a=1.0): 
     3008    yield from () 
    30063009    return color.Color.fromhsv(h, s, v, a) 
    30073010 
     
    30093012@AST.makemethod 
    30103013def _split(obj, sep=None, count=None): 
     3014    yield from () 
    30113015    return obj.split(sep, count if count is not None else -1) 
    30123016 
     
    30143018@AST.makemethod 
    30153019def _rsplit(obj, sep=None, count=None): 
     3020    yield from () 
    30163021    return obj.rsplit(sep, count if count is not None else -1) 
    30173022 
     
    30193024@AST.makemethod 
    30203025def _strip(obj, chars=None): 
     3026    yield from () 
    30213027    return obj.strip(chars) 
    30223028 
     
    30243030@AST.makemethod 
    30253031def _lstrip(obj, chars=None): 
     3032    yield from () 
    30263033    return obj.lstrip(chars) 
    30273034 
     
    30293036@AST.makemethod 
    30303037def _rstrip(obj, chars=None): 
     3038    yield from () 
    30313039    return obj.rstrip(chars) 
    30323040 
     
    30343042@AST.makemethod 
    30353043def _find(obj, sub, start=None, end=None): 
     3044    yield from () 
    30363045    if isinstance(obj, str): 
    30373046        return obj.find(sub, start, end) 
     
    30493058@AST.makemethod 
    30503059def _rfind(obj, sub, start=None, end=None): 
     3060    yield from () 
    30513061    if isinstance(obj, str): 
    30523062        return obj.rfind(sub, start, end) 
     
    30603070@AST.makemethod 
    30613071def _startswith(obj, prefix): 
     3072    yield from () 
    30623073    return obj.startswith(prefix) 
    30633074 
     
    30653076@AST.makemethod 
    30663077def _endswith(obj, suffix): 
     3078    yield from () 
    30673079    return obj.endswith(suffix) 
    30683080 
     
    30703082@AST.makemethod 
    30713083def _upper(obj): 
     3084    yield from () 
    30723085    return obj.upper() 
    30733086 
     
    30753088@AST.makemethod 
    30763089def _lower(obj): 
     3090    yield from () 
    30773091    return obj.lower() 
    30783092 
     
    30803094@AST.makemethod 
    30813095def _capitalize(obj): 
     3096    yield from () 
    30823097    return obj.capitalize() 
    30833098 
     
    30853100@AST.makemethod 
    30863101def _replace(obj, old, new, count=None): 
     3102    yield from () 
    30873103    if count is None: 
    30883104        return obj.replace(old, new) 
     
    30933109@AST.makemethod 
    30943110def _r(obj): 
     3111    yield from () 
    30953112    return obj.r() 
    30963113 
     
    30983115@AST.makemethod 
    30993116def _g(obj): 
     3117    yield from () 
    31003118    return obj.g() 
    31013119 
     
    31033121@AST.makemethod 
    31043122def _b(obj): 
     3123    yield from () 
    31053124    return obj.b() 
    31063125 
     
    31083127@AST.makemethod 
    31093128def _a(obj): 
     3129    yield from () 
    31103130    return obj.a() 
    31113131 
     
    31133133@AST.makemethod 
    31143134def _hls(obj): 
     3135    yield from () 
    31153136    return obj.hls() 
    31163137 
     
    31183139@AST.makemethod 
    31193140def _hlsa(obj): 
     3141    yield from () 
    31203142    return obj.hlsa() 
    31213143 
     
    31233145@AST.makemethod 
    31243146def _hsv(obj): 
     3147    yield from () 
    31253148    return obj.hsv() 
    31263149 
     
    31283151@AST.makemethod 
    31293152def _hsva(obj): 
     3153    yield from () 
    31303154    return obj.hsva() 
    31313155 
     
    31333157@AST.makemethod 
    31343158def _lum(obj): 
     3159    yield from () 
    31353160    return obj.lum() 
    31363161 
     
    31383163@AST.makemethod 
    31393164def _weekday(obj): 
     3165    yield from () 
    31403166    return obj.weekday() 
    31413167 
     
    31433169@AST.makemethod 
    31443170def _week(obj, firstweekday=None): 
     3171    yield from () 
    31453172    if firstweekday is None: 
    31463173        firstweekday = 0 
     
    31603187@AST.makemethod 
    31613188def _items(obj): 
     3189    yield from () 
    31623190    return obj.items() 
    31633191 
     
    31653193@AST.makemethod 
    31663194def _values(obj): 
     3195    yield from () 
    31673196    return obj.values() 
    31683197 
     
    31703199@AST.makemethod 
    31713200def _join(obj, iterable): 
     3201    yield from () 
    31723202    return obj.join(iterable) 
    31733203 
     
    31753205@AST.makemethod 
    31763206def _render(obj, **vars): 
    3177     return obj.render(**vars) 
     3207    yield from obj.render(**vars) 
    31783208 
    31793209 
    31803210@AST.makemethod 
    31813211def _renders(obj, **vars): 
     3212    yield from () 
    31823213    return obj.renders(**vars) 
    31833214 
     
    31853216@AST.makemethod 
    31863217def _mimeformat(obj): 
     3218    yield from () 
    31873219    weekdayname = ("Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun") 
    31883220    monthname = (None, "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec") 
     
    31923224@AST.makemethod 
    31933225def _isoformat(obj): 
     3226    yield from () 
    31943227    result = obj.isoformat() 
    31953228    suffix = "T00:00:00" 
     
    32013234@AST.makemethod 
    32023235def _yearday(obj): 
     3236    yield from () 
    32033237    return (obj - obj.__class__(obj.year, 1, 1)).days+1 
    32043238 
     
    32063240@AST.makemethod 
    32073241def _get(obj, key, default=None): 
     3242    yield from () 
    32083243    return obj.get(key, default) 
    32093244 
     
    32113246@AST.makemethod 
    32123247def _withlum(obj, lum): 
     3248    yield from () 
    32133249    return obj.withlum(lum) 
    32143250 
     
    32163252@AST.makemethod 
    32173253def _witha(obj, a): 
     3254    yield from () 
    32183255    return obj.witha(a) 
    32193256 
     
    32213258@AST.makemethod 
    32223259def _day(obj): 
     3260    yield from () 
    32233261    return obj.day 
    32243262 
     
    32263264@AST.makemethod 
    32273265def _month(obj): 
     3266    yield from () 
    32283267    return obj.month 
    32293268 
     
    32313270@AST.makemethod 
    32323271def _year(obj): 
     3272    yield from () 
    32333273    return obj.year 
    32343274 
     
    32363276@AST.makemethod 
    32373277def _hour(obj): 
     3278    yield from () 
    32383279    return obj.hour 
    32393280 
     
    32413282@AST.makemethod 
    32423283def _minute(obj): 
     3284    yield from () 
    32433285    return obj.minute 
    32443286 
     
    32463288@AST.makemethod 
    32473289def _second(obj): 
     3290    yield from () 
    32483291    return obj.second 
    32493292 
     
    32513294@AST.makemethod 
    32523295def _microsecond(obj): 
     3296    yield from () 
    32533297    return obj.microsecond 
    32543298 
     
    32693313 
    32703314    def __call__(self, **vars): 
     3315        yield from () 
    32713316        return self.template(**collections.ChainMap(vars, self.vars)) 
    32723317 
     
    33143359### 
    33153360 
     3361def _str_(obj=""): 
     3362    if obj is None: 
     3363        return "" 
     3364    elif isinstance(obj, Undefined): 
     3365        return "" 
     3366    else: 
     3367        return str(obj) 
     3368 
     3369def _repr_(obj): 
     3370    if isinstance(obj, str): 
     3371        return repr(obj) 
     3372    elif isinstance(obj, datetime.datetime): 
     3373        s = str(obj.isoformat()) 
     3374        if s.endswith("T00:00:00"): 
     3375            s = s[:-9] 
     3376        return "@({})".format(s) 
     3377    elif isinstance(obj, datetime.date): 
     3378        return "@({})".format(obj.isoformat()) 
     3379    elif isinstance(obj, datetime.timedelta): 
     3380        return repr(obj).partition(".")[-1] 
     3381    elif isinstance(obj, color.Color): 
     3382        if obj[3] == 0xff: 
     3383            s = "#{:02x}{:02x}{:02x}".format(obj[0], obj[1], obj[2]) 
     3384            if s[1]==s[2] and s[3]==s[4] and s[5]==s[6]: 
     3385                return "#{}{}{}".format(s[1], s[3], s[5]) 
     3386            return s 
     3387        else: 
     3388            s = "#{:02x}{:02x}{:02x}{:02x}".format(*obj) 
     3389            if s[1]==s[2] and s[3]==s[4] and s[5]==s[6] and s[7]==s[8]: 
     3390                return "#{}{}{}{}".format(s[1], s[3], s[5], s[7]) 
     3391            return s 
     3392    elif isinstance(obj, collections.Sequence): 
     3393        return "[{}]".format(", ".join(_repr_(item) for item in obj)) 
     3394    elif isinstance(obj, collections.Mapping): 
     3395        return "{{{}}}".format(", ".join("{}: {}".format(_repr_(key), _repr_(value)) for (key, value) in obj.items())) 
     3396    else: 
     3397        return repr(obj) 
     3398 
     3399 
     3400def _xmlescape_(obj): 
     3401    if obj is None: 
     3402        return "" 
     3403    elif isinstance(obj, Undefined): 
     3404        return "" 
     3405    else: 
     3406        return misc.xmlescape(str(obj)) 
     3407 
     3408 
     3409def _asjson_(obj): 
     3410    if obj is None: 
     3411        return "null" 
     3412    elif isinstance(obj, Undefined): 
     3413        return "{}.undefined" 
     3414    if isinstance(obj, (bool, int, float, str)): 
     3415        return json.dumps(obj) 
     3416    elif isinstance(obj, datetime.datetime): 
     3417        return "new Date({}, {}, {}, {}, {}, {}, {})".format(obj.year, obj.month-1, obj.day, obj.hour, obj.minute, obj.second, obj.microsecond//1000) 
     3418    elif isinstance(obj, datetime.date): 
     3419        return "new Date({}, {}, {})".format(obj.year, obj.month-1, obj.day) 
     3420    elif isinstance(obj, datetime.timedelta): 
     3421        return "ul4.TimeDelta.create({}, {}, {})".format(obj.days, obj.seconds, obj.microseconds) 
     3422    elif isinstance(obj, misc.monthdelta): 
     3423        return "ul4.MonthDelta.create({})".format(obj.months) 
     3424    elif isinstance(obj, color.Color): 
     3425        return "ul4.Color.create({}, {}, {}, {})".format(*obj) 
     3426    elif isinstance(obj, collections.Mapping): 
     3427        return "{{{}}}".format(", ".join("{}: {}".format(_asjson_(key), _asjson_(value)) for (key, value) in obj.items())) 
     3428    elif isinstance(obj, collections.Sequence): 
     3429        return "[{}]".format(", ".join(_asjson_(item) for item in obj)) 
     3430    elif isinstance(obj, Template): 
     3431        return obj.jssource() 
     3432    else: 
     3433        raise TypeError("can't handle object of type {}".format(type(obj))) 
     3434 
     3435 
    33163436def _makedict(*items): 
    33173437    result = {} 
  • test/test_ul4.py

    r5312 r5313  
    314314def call_python(__, *, keepws=True, **variables): 
    315315    """ 
    316     Compile the function from the source ``__``, call it with the variables ``variables`` and return the result. 
    317     """ 
    318     function = ul4c.Function(__, keepws=keepws) 
     316    Compile the template from the source ``__``, call it as a function with the variables ``variables`` and return the result. 
     317    """ 
     318    template = ul4c.Template(__, keepws=keepws) 
    319319    f = sys._getframe(1) 
    320     print("Testing Python function ({}, line {}):".format(f.f_code.co_filename, f.f_lineno)) 
    321     print(function) 
     320    print("Testing Python template ({}, line {}):".format(f.f_code.co_filename, f.f_lineno)) 
     321    print(template) 
    322322    print("with variables:") 
    323323    print(repr(variables)) 
    324     return function(**variables) 
     324    return template(**variables) 
    325325 
    326326 
    327327def call_python_dumps(__, *, keepws=True, **variables): 
    328328    """ 
    329     Compile the function from the source ``__``, create a string dump from it, 
    330     recreate the function from the dump string, call it with the variables 
    331     ``variables`` and return the result. 
    332     """ 
    333     function = ul4c.Function(__, keepws=keepws) 
    334     function = ul4c.Function.loads(function.dumps()) # Recreate the function from the binary dump 
     329    Compile the template from the source ``__``, create a string dump from it, 
     330    recreate the template from the dump string, call it as a function with the 
     331    variables ``variables`` and return the result. 
     332    """ 
     333    template = ul4c.Template(__, keepws=keepws) 
     334    template = ul4c.Template.loads(template.dumps()) # Recreate the template from the binary dump 
    335335    f = sys._getframe(1) 
    336     print("Testing Python function loaded from string ({}, line {}):".format(f.f_code.co_filename, f.f_lineno)) 
    337     print(function) 
     336    print("Testing Python template loaded from string ({}, line {}):".format(f.f_code.co_filename, f.f_lineno)) 
     337    print(template) 
    338338    print("with variables:") 
    339339    print(repr(variables)) 
    340     return function(**variables) 
     340    return template(**variables) 
    341341 
    342342 
    343343def call_python_dump(__, *, keepws=True, **variables): 
    344344    """ 
    345     Compile the function from the source ``__``, dump it to a stream, recreate 
    346     the function from the dump, call it with the variables ``variables`` and 
    347     return the result. 
    348     """ 
    349     function = ul4c.Function(__, keepws=keepws) 
     345    Compile the template from the source ``__``, dump it to a stream, recreate 
     346    the template from the dump, call it as a function with the variables 
     347    ``variables`` and return the result. 
     348    """ 
     349    template = ul4c.Template(__, keepws=keepws) 
    350350    stream = io.StringIO() 
    351     function.dump(stream) 
     351    template.dump(stream) 
    352352    stream.seek(0) 
    353353    f = sys._getframe(1) 
    354     function = ul4c.Function.load(stream) # Recreate the function from the stream 
    355     print("Testing Python function loaded from stream ({}, line {}):".format(f.f_code.co_filename, f.f_lineno)) 
    356     print(function) 
     354    template = ul4c.Template.load(stream) # Recreate the template from the stream 
     355    print("Testing Python template loaded from stream ({}, line {}):".format(f.f_code.co_filename, f.f_lineno)) 
     356    print(template) 
    357357    print("with variables:") 
    358358    print(repr(variables)) 
    359     return function(**variables) 
     359    return template(**variables) 
    360360 
    361361 
    362362def call_js(__, *, keepws=True, **variables): 
    363363    """ 
    364     Compile the function from the source ``__``, and generate Javascript source 
    365     from it and call it with the variables ``variables``. 
     364    Compile the template from the source ``__``, and generate Javascript source 
     365    from it and call it as a function with the variables ``variables``. 
    366366 
    367367    (this requires an installed ``d8`` shell from V8 (http://code.google.com/p/v8/)) 
    368368    """ 
    369     function = ul4c.Function(__, keepws=keepws) 
    370     js = function.jssource() 
    371     js = "func = {};\ndata = {};\nprint(ul4on.dumps(func.call(data)));\n".format(js, ul4c._asjson(variables)) 
     369    template = ul4c.Template(__, keepws=keepws) 
     370    js = template.jssource() 
     371    js = "template = {};\ndata = {};\nprint(ul4on.dumps(template.call(data)));\n".format(js, ul4c._asjson(variables)) 
    372372    f = sys._getframe(1) 
    373     print("Testing Javascript function compiled by Python ({}, line {}):".format(f.f_code.co_filename, f.f_lineno)) 
     373    print("Testing Javascript template compiled by Python ({}, line {}):".format(f.f_code.co_filename, f.f_lineno)) 
    374374    print(js) 
    375375    with tempfile.NamedTemporaryFile(mode="wb", suffix=".js") as f: 
     
    634634@pytest.mark.ul4 
    635635def test_color(r): 
    636     assert '255,255,255,255' == r('<?code c = #fff?><?print c[0]?>,<?print c[1]?>,<?print c[2]?>,<?print c[3]?>') 
    637     assert '255,255,255,255' == r('<?code c = #ffffff?><?print c[0]?>,<?print c[1]?>,<?print c[2]?>,<?print c[3]?>') 
    638     assert '18,52,86,255' == r('<?code c = #123456?><?print c[0]?>,<?print c[1]?>,<?print c[2]?>,<?print c[3]?>') 
    639     assert '17,34,51,68' == r('<?code c = #1234?><?print c[0]?>,<?print c[1]?>,<?print c[2]?>,<?print c[3]?>') 
    640     assert '18,52,86,120' == r('<?code c = #12345678?><?print c[0]?>,<?print c[1]?>,<?print c[2]?>,<?print c[3]?>') 
     636    assert '255,255,255,255' == r('<?exe c = #fff?><?print c[0]?>,<?print c[1]?>,<?print c[2]?>,<?print c[3]?>') 
     637    assert '255,255,255,255' == r('<?exe c = #ffffff?><?print c[0]?>,<?print c[1]?>,<?print c[2]?>,<?print c[3]?>') 
     638    assert '18,52,86,255' == r('<?exe c = #123456?><?print c[0]?>,<?print c[1]?>,<?print c[2]?>,<?print c[3]?>') 
     639    assert '17,34,51,68' == r('<?exe c = #1234?><?print c[0]?>,<?print c[1]?>,<?print c[2]?>,<?print c[3]?>') 
     640    assert '18,52,86,120' == r('<?exe c = #12345678?><?print c[0]?>,<?print c[1]?>,<?print c[2]?>,<?print c[3]?>') 
    641641    assert 'yes' == r('<?if #fff?>yes<?else?>no<?end if?>') 
    642642 
     
    655655@pytest.mark.ul4 
    656656def test_listcomp(r): 
    657     assert "[2, 6]" == r("<?code d = [2*i for i in range(4) if i%2]?><?print d?>") 
    658     assert "[0, 2, 4, 6]" == r("<?code d = [2*i for i in range(4)]?><?print d?>") 
     657    assert "[2, 6]" == r("<?exe d = [2*i for i in range(4) if i%2]?><?print d?>") 
     658    assert "[0, 2, 4, 6]" == r("<?exe d = [2*i for i in range(4)]?><?print d?>") 
    659659 
    660660    # Make sure that the loop variables doesn't leak into the surrounding scope 
    661     assert "undefined" == r("<?code d = [2*i for i in range(4)]?><?print type(i)?>") 
     661    assert "undefined" == r("<?exe d = [2*i for i in range(4)]?><?print type(i)?>") 
    662662 
    663663 
    664664@pytest.mark.ul4 
    665665def test_genexpr(r): 
    666     assert "2, 6:" == r("<?code ge = (str(2*i) for i in range(4) if i%2)?><?print ', '.join(ge)?>:<?print ', '.join(ge)?>") 
     666    assert "2, 6:" == r("<?exe ge = (str(2*i) for i in range(4) if i%2)?><?print ', '.join(ge)?>:<?print ', '.join(ge)?>") 
    667667    assert "2, 6" == r("<?print ', '.join(str(2*i) for i in range(4) if i%2)?>") 
    668668    assert "0, 2, 4, 6" == r("<?print ', '.join(str(2*i) for i in range(4))?>") 
     
    671671 
    672672    # Make sure that the loop variables doesn't leak into the surrounding scope 
    673     assert "undefined" == r("<?code d = (2*i for i in range(4))?><?print type(i)?>") 
     673    assert "undefined" == r("<?exe d = (2*i for i in range(4))?><?print type(i)?>") 
    674674 
    675675 
     
    689689 
    690690    # Make sure that the loop variables doesn't leak into the surrounding scope 
    691     assert "undefined" == r("<?code d = {i: 2*i for i in range(4)}?><?print type(i)?>") 
     691    assert "undefined" == r("<?exe d = {i: 2*i for i in range(4)}?><?print type(i)?>") 
    692692 
    693693 
     
    695695def test_dictcomp(r): 
    696696    # JS only supports string keys 
    697     assert "" == r("<?code d = {str(i):2*i for i in range(10) if i%2}?><?if '2' in d?><?print d['2']?><?end if?>") 
    698     assert "6" == r("<?code d = {str(i):2*i for i in range(10) if i%2}?><?if '3' in d?><?print d['3']?><?end if?>") 
    699     assert "6" == r("<?code d = {str(i):2*i for i in range(10)}?><?print d['3']?>") 
     697    assert "" == r("<?exe d = {str(i):2*i for i in range(10) if i%2}?><?if '2' in d?><?print d['2']?><?end if?>") 
     698    assert "6" == r("<?exe d = {str(i):2*i for i in range(10) if i%2}?><?if '3' in d?><?print d['3']?><?end if?>") 
     699    assert "6" == r("<?exe d = {str(i):2*i for i in range(10)}?><?print d['3']?>") 
    700700 
    701701 
     
    713713 
    714714@pytest.mark.ul4 
    715 def test_code_storevar(r): 
    716     assert '42' == r('<?code x = 42?><?print x?>') 
    717     assert 'xyzzy' == r('<?code x = "xyzzy"?><?print x?>') 
    718     assert 'x,y' == r('<?code (x, y) = "xy"?><?print x?>,<?print y?>') 
    719     assert '42' == r('<?code (x,) = [42]?><?print x?>') 
    720     assert '17,23' == r('<?code (x,y) = [17, 23]?><?print x?>,<?print y?>') 
    721     assert '17,23,37,42,105' == r('<?code ((v, w), (x,), (y,), z) = [[17, 23], [37], [42], 105]?><?print v?>,<?print w?>,<?print x?>,<?print y?>,<?print z?>') 
    722  
    723  
    724 @pytest.mark.ul4 
    725 def test_code_addvar(r): 
     715def test_storevar(r): 
     716    assert '42' == r('<?exe x = 42?><?print x?>') 
     717    assert 'xyzzy' == r('<?exe x = "xyzzy"?><?print x?>') 
     718    assert 'x,y' == r('<?exe (x, y) = "xy"?><?print x?>,<?print y?>') 
     719    assert '42' == r('<?exe (x,) = [42]?><?print x?>') 
     720    assert '17,23' == r('<?exe (x,y) = [17, 23]?><?print x?>,<?print y?>') 
     721    assert '17,23,37,42,105' == r('<?exe ((v, w), (x,), (y,), z) = [[17, 23], [37], [42], 105]?><?print v?>,<?print w?>,<?print x?>,<?print y?>,<?print z?>') 
     722 
     723 
     724@pytest.mark.ul4 
     725def test_addvar(r): 
    726726    for x in (17, 17., False, True): 
    727727        for y in (23, 23., False, True): 
    728             assert x + y == eval(r('<?code x = {}?><?code x += {}?><?print x?>'.format(x, y))) 
    729     assert 'xyzzy' == r('<?code x = "xyz"?><?code x += "zy"?><?print x?>') 
    730  
    731  
    732 @pytest.mark.ul4 
    733 def test_code_subvar(r): 
     728            assert x + y == eval(r('<?exe x = {}?><?exe x += {}?><?print x?>'.format(x, y))) 
     729    assert 'xyzzy' == r('<?exe x = "xyz"?><?exe x += "zy"?><?print x?>') 
     730 
     731 
     732@pytest.mark.ul4 
     733def test_subvar(r): 
    734734    for x in (17, 17., False, True): 
    735735        for y in (23, 23., False, True): 
    736             assert x - y == eval(r('<?code x = {}?><?code x -= {}?><?print x?>'.format(x, y))) 
    737  
    738  
    739 @pytest.mark.ul4 
    740 def test_code_mulvar(r): 
     736            assert x - y == eval(r('<?exe x = {}?><?exe x -= {}?><?print x?>'.format(x, y))) 
     737 
     738 
     739@pytest.mark.ul4 
     740def test_mulvar(r): 
    741741    for x in (17, 17., False, True): 
    742742        for y in (23, 23., False, True): 
    743             assert x * y == eval(r('<?code x = {}?><?code x *= {}?><?print x?>'.format(x, y))) 
     743            assert x * y == eval(r('<?exe x = {}?><?exe x *= {}?><?print x?>'.format(x, y))) 
    744744    for x in (17, False, True): 
    745745        y = "xyzzy" 
    746         assert x * y == r('<?code x = {}?><?code x *= {!r}?><?print x?>'.format(x, y)) 
    747     assert 17*"xyzzy" == r('<?code x = "xyzzy"?><?code x *= 17?><?print x?>') 
    748  
    749  
    750 @pytest.mark.ul4 
    751 def test_code_floordivvar(r): 
     746        assert x * y == r('<?exe x = {}?><?exe x *= {!r}?><?print x?>'.format(x, y)) 
     747    assert 17*"xyzzy" == r('<?exe x = "xyzzy"?><?exe x *= 17?><?print x?>') 
     748 
     749 
     750@pytest.mark.ul4 
     751def test_floordivvar(r): 
    752752    for x in (5, -5, 5.0, -5.0, 4, -4, 4.0, -4.0, False, True): 
    753753        for y in (2, -2, 2.0, -2.0, True): 
    754             assert x // y == eval(r('<?code x = {}?><?code x //= {}?><?print x?>'.format(x, y))) 
    755  
    756  
    757 @pytest.mark.ul4 
    758 def test_code_truedivvar(r): 
     754            assert x // y == eval(r('<?exe x = {}?><?exe x //= {}?><?print x?>'.format(x, y))) 
     755 
     756 
     757@pytest.mark.ul4 
     758def test_truedivvar(r): 
    759759    for x in (5, -5, 5.0, -5.0, 4, -4, 4.0, -4.0, False, True): 
    760760        for y in (2, -2, 2.0, -2.0, True): 
    761             assert x / y == eval(r('<?code x = {}?><?code x /= {}?><?print x?>'.format(x, y))) 
    762  
    763  
    764 @pytest.mark.ul4 
    765 def test_code_modvar(r): 
     761            assert x / y == eval(r('<?exe x = {}?><?exe x /= {}?><?print x?>'.format(x, y))) 
     762 
     763 
     764@pytest.mark.ul4 
     765def test_modvar(r): 
    766766    for x in (1729, 1729.0, -1729, -1729.0, False, True): 
    767767        for y in (23, 23., -23, -23.0, True): 
    768             assert x % y == eval(r('<?code x = {}?><?code x %= {}?><?print x?>'.format(x, y))) 
    769  
    770  
    771 @pytest.mark.ul4 
    772 def test_code_delvar(r): 
    773     if r is not render_js: 
    774         with raises("(x|not found)"): 
    775             r('<?code x = 1729?><?code del x?><?print x?>') 
     768            assert x % y == eval(r('<?exe x = {}?><?exe x %= {}?><?print x?>'.format(x, y))) 
    776769 
    777770 
     
    891884        render_python('<?for?>') 
    892885    with raises("statement required"): 
    893         render_python('<?code?>') 
    894     with raises("expression required"): 
    895         render_python('<?render?>') 
     886        render_python('<?exe?>') 
    896887 
    897888 
     
    904895        for y in values: 
    905896            assert x + y == eval(r(code, x=x, y=y)) # Using ``evaleq`` avoids problem with the nonexistant int/float distinction in JS 
    906     assert 'foobar' == r('<?code x="foo"?><?code y="bar"?><?print x+y?>') 
     897    assert 'foobar' == r('<?exe x="foo"?><?exe y="bar"?><?print x+y?>') 
    907898    assert '(f)(o)(o)(b)(a)(r)' == r('<?for i in data.foo+data.bar?>(<?print i?>)<?end for?>', data=dict(foo="foo", bar="bar")) 
    908899    assert "2012-10-18 00:00:00" == r(code, x=datetime.datetime(2012, 10, 17), y=datetime.timedelta(1)) 
     
    982973            assert x * y == eval(r(code, x=x, y=y)) 
    983974    assert 17*"foo" == r('<?print 17*"foo"?>') 
    984     assert 17*"foo" == r('<?code x=17?><?code y="foo"?><?print x*y?>') 
    985     assert "foo"*17 == r('<?code x="foo"?><?code y=17?><?print x*y?>') 
     975    assert 17*"foo" == r('<?exe x=17?><?exe y="foo"?><?print x*y?>') 
     976    assert "foo"*17 == r('<?exe x="foo"?><?exe y=17?><?print x*y?>') 
    986977    assert "foo"*17 == r('<?print "foo"*17?>') 
    987978    assert "(foo)(bar)(foo)(bar)(foo)(bar)" == r('<?for i in 3*data?>(<?print i?>)<?end for?>', data=["foo", "bar"]) 
     
    1005996 
    1006997    assert "0.5" == r('<?print 1/2?>') 
    1007     assert "0.5" == r('<?code x=1?><?code y=2?><?print x/y?>') 
     998    assert "0.5" == r('<?exe x=1?><?exe y=2?><?print x/y?>') 
    1008999    assert "0:00:00" == r(code, x=datetime.timedelta(), y=4) 
    10091000    assert "2 days, 0:00:00" == r(code, x=datetime.timedelta(8), y=4) 
     
    10211012def test_floordiv(r): 
    10221013    assert "0" == r('<?print 1//2?>') 
    1023     assert "0" == r('<?code x=1?><?code y=2?><?print x//y?>') 
     1014    assert "0" == r('<?exe x=1?><?exe y=2?><?print x//y?>') 
    10241015    assert "1 month" == r('<?print x//y?>', x=misc.monthdelta(3), y=2) 
    10251016 
     
    12611252 
    12621253    assert str(n) == r('<?print {}?>'.format(sc)) 
    1263     assert str(n) == r('<?code x=4?><?print {}?>'.format(sv)) 
     1254    assert str(n) == r('<?exe x=4?><?print {}?>'.format(sv)) 
    12641255 
    12651256 
     
    12991290 
    13001291    assert "4" == r('<?print {}?>'.format(sc)) 
    1301     assert "4" == r('<?code x=4?><?print {}?>'.format(sv)) 
     1292    assert "4" == r('<?exe x=4?><?print {}?>'.format(sv)) 
    13021293 
    13031294 
     
    14021393    with raises(argumentmismatchmessage): 
    14031394        r("<?print random(foo=1)?>") 
    1404     assert "ok" == r("<?code r = random()?><?if r>=0 and r<1?>ok<?else?>fail<?end if?>") 
     1395    assert "ok" == r("<?exe r = random()?><?if r>=0 and r<1?>ok<?else?>fail<?end if?>") 
    14051396 
    14061397 
     
    14111402    with raises(argumentmismatchmessage): 
    14121403        r("<?print randrange(foo=1)?>") 
    1413     assert "ok" == r("<?code r = randrange(4)?><?if r>=0 and r<4?>ok<?else?>fail<?end if?>") 
    1414     assert "ok" == r("<?code r = randrange(17, 23)?><?if r>=17 and r<23?>ok<?else?>fail<?end if?>") 
    1415     assert "ok" == r("<?code r = randrange(17, 23, 2)?><?if r>=17 and r<23 and r%2?>ok<?else?>fail<?end if?>") 
     1404    assert "ok" == r("<?exe r = randrange(4)?><?if r>=0 and r<4?>ok<?else?>fail<?end if?>") 
     1405    assert "ok" == r("<?exe r = randrange(17, 23)?><?if r>=17 and r<23?>ok<?else?>fail<?end if?>") 
     1406    assert "ok" == r("<?exe r = randrange(17, 23, 2)?><?if r>=17 and r<23 and r%2?>ok<?else?>fail<?end if?>") 
    14161407 
    14171408 
     
    14201411    with raises(argumentmismatchmessage): 
    14211412        r("<?print randchoice()?>") 
    1422     assert "ok" == r("<?code r = randchoice('abc')?><?if r in 'abc'?>ok<?else?>fail<?end if?>") 
    1423     assert "ok" == r("<?code s = [17, 23, 42]?><?code r = randchoice(s)?><?if r in s?>ok<?else?>fail<?end if?>") 
    1424     assert "ok" == r("<?code s = #12345678?><?code sl = [0x12, 0x34, 0x56, 0x78]?><?code r = randchoice(s)?><?if r in sl?>ok<?else?>fail<?end if?>") 
    1425  
    1426     # Make sure that the parameters have the same name in all implementations 
    1427     assert "ok" == r("<?code s = [17, 23, 42]?><?code r = randchoice(sequence=s)?><?if r in s?>ok<?else?>fail<?end if?>") 
     1413    assert "ok" == r("<?exe r = randchoice('abc')?><?if r in 'abc'?>ok<?else?>fail<?end if?>") 
     1414    assert "ok" == r("<?exe s = [17, 23, 42]?><?exe r = randchoice(s)?><?if r in s?>ok<?else?>fail<?end if?>") 
     1415    assert "ok" == r("<?exe s = #12345678?><?exe sl = [0x12, 0x34, 0x56, 0x78]?><?exe r = randchoice(s)?><?if r in sl?>ok<?else?>fail<?end if?>") 
     1416 
     1417    # Make sure that the parameters have the same name in all implementations 
     1418    assert "ok" == r("<?exe s = [17, 23, 42]?><?exe r = randchoice(sequence=s)?><?if r in s?>ok<?else?>fail<?end if?>") 
    14281419 
    14291420 
     
    28182809@pytest.mark.ul4 
    28192810def test_method_r_g_b_a(r): 
    2820     assert '0x11' == r('<?code c = #123?><?print hex(c.r())?>') 
    2821     assert '0x22' == r('<?code c = #123?><?print hex(c.g())?>') 
    2822     assert '0x33' == r('<?code c = #123?><?print hex(c.b())?>') 
    2823     assert '0xff' == r('<?code c = #123?><?print hex(c.a())?>') 
     2811    assert '0x11' == r('<?exe c = #123?><?print hex(c.r())?>') 
     2812    assert '0x22' == r('<?exe c = #123?><?print hex(c.g())?>') 
     2813    assert '0x33' == r('<?exe c = #123?><?print hex(c.b())?>') 
     2814    assert '0xff' == r('<?exe c = #123?><?print hex(c.a())?>') 
    28242815 
    28252816 
    28262817@pytest.mark.ul4 
    28272818def test_method_hls(r): 
    2828     assert '0' == r('<?code c = #fff?><?print int(c.hls()[0])?>') 
    2829     assert '1' == r('<?code c = #fff?><?print int(c.hls()[1])?>') 
    2830     assert '0' == r('<?code c = #fff?><?print int(c.hls()[2])?>') 
     2819    assert '0' == r('<?exe c = #fff?><?print int(c.hls()[0])?>') 
     2820    assert '1' == r('<?exe c = #fff?><?print int(c.hls()[1])?>') 
     2821    assert '0' == r('<?exe c = #fff?><?print int(c.hls()[2])?>') 
    28312822 
    28322823 
    28332824@pytest.mark.ul4 
    28342825def test_method_hlsa(r): 
    2835     assert '0' == r('<?code c = #fff?><?print int(c.hlsa()[0])?>') 
    2836     assert '1' == r('<?code c = #fff?><?print int(c.hlsa()[1])?>') 
    2837     assert '0' == r('<?code c = #fff?><?print int(c.hlsa()[2])?>') 
    2838     assert '1' == r('<?code c = #fff?><?print int(c.hlsa()[3])?>') 
     2826    assert '0' == r('<?exe c = #fff?><?print int(c.hlsa()[0])?>') 
     2827    assert '1' == r('<?exe c = #fff?><?print int(c.hlsa()[1])?>') 
     2828    assert '0' == r('<?exe c = #fff?><?print int(c.hlsa()[2])?>') 
     2829    assert '1' == r('<?exe c = #fff?><?print int(c.hlsa()[3])?>') 
    28392830 
    28402831 
    28412832@pytest.mark.ul4 
    28422833def test_method_hsv(r): 
    2843     assert '0' == r('<?code c = #fff?><?print int(c.hsv()[0])?>') 
    2844     assert '0' == r('<?code c = #fff?><?print int(c.hsv()[1])?>') 
    2845     assert '1' == r('<?code c = #fff?><?print int(c.hsv()[2])?>') 
     2834    assert '0' == r('<?exe c = #fff?><?print int(c.hsv()[0])?>') 
     2835    assert '0' == r('<?exe c = #fff?><?print int(c.hsv()[1])?>') 
     2836    assert '1' == r('<?exe c = #fff?><?print int(c.hsv()[2])?>') 
    28462837 
    28472838 
    28482839@pytest.mark.ul4 
    28492840def test_method_hsva(r): 
    2850     assert '0' == r('<?code c = #fff?><?print int(c.hsva()[0])?>') 
    2851     assert '0' == r('<?code c = #fff?><?print int(c.hsva()[1])?>') 
    2852     assert '1' == r('<?code c = #fff?><?print int(c.hsva()[2])?>') 
    2853     assert '1' == r('<?code c = #fff?><?print int(c.hsva()[3])?>') 
     2841    assert '0' == r('<?exe c = #fff?><?print int(c.hsva()[0])?>') 
     2842    assert '0' == r('<?exe c = #fff?><?print int(c.hsva()[1])?>') 
     2843    assert '1' == r('<?exe c = #fff?><?print int(c.hsva()[2])?>') 
     2844    assert '1' == r('<?exe c = #fff?><?print int(c.hsva()[3])?>') 
    28542845 
    28552846 
     
    30163007    t = ul4c.Template('<?print prefix?><?print data?><?print suffix?>') 
    30173008 
    3018     assert '(f)(o)(o)' == r('<?for c in data?><?render t.render(data=c, prefix="(", suffix=")")?><?end for?>', t=t, data='foo') 
    3019     assert '(f)(o)(o)' == r('<?for c in data?><?render t.render(data=c, **{"prefix": "(", "suffix": ")"})?><?end for?>', t=t, data='foo') 
     3009    assert '(f)(o)(o)' == r('<?for c in data?><?exe t.render(data=c, prefix="(", suffix=")")?><?end for?>', t=t, data='foo') 
     3010    assert '(f)(o)(o)' == r('<?for c in data?><?exe t.render(data=c, **{"prefix": "(", "suffix": ")"})?><?end for?>', t=t, data='foo') 
    30203011 
    30213012 
     
    30273018@pytest.mark.ul4 
    30283019def test_pass_function(r): 
    3029     assert "&lt;" == r("<?def x?><?print xe('<')?><?end def?><?render x.render(xe=xmlescape)?>") 
    3030     assert "&lt;" == r("<?def xe?><?return xmlescape(s)?><?end def?><?def x?><?print xe(s='<')?><?end def?><?render x.render(xe=xe)?>") 
    3031     assert "&lt;" == r("<?def xe?><?return xmlescape(s)?><?end def?><?def x?><?print xe(s='<')?><?end def?><?render x.render()?>") 
     3020    assert "&lt;" == r("<?def x?><?print xe('<')?><?end def?><?exe x.render(xe=xmlescape)?>") 
     3021    assert "&lt;" == r("<?def xe?><?return xmlescape(s)?><?end def?><?def x?><?print xe(s='<')?><?end def?><?exe x.render(xe=xe)?>") 
     3022    assert "&lt;" == r("<?def xe?><?return xmlescape(s)?><?end def?><?def x?><?print xe(s='<')?><?end def?><?exe x.render()?>") 
    30323023 
    30333024 
     
    30403031def test_nested_exceptions(r): 
    30413032    tmpl1 = ul4c.Template("<?print 2*x?>", "tmpl1") 
    3042     tmpl2 = ul4c.Template("<?render tmpl1.render(x=x)?>", "tmpl2") 
    3043     tmpl3 = ul4c.Template("<?render tmpl2.render(tmpl1=tmpl1, x=x)?>", "tmpl3") 
     3033    tmpl2 = ul4c.Template("<?exe tmpl1.render(x=x)?>", "tmpl2") 
     3034    tmpl3 = ul4c.Template("<?exe tmpl2.render(tmpl1=tmpl1, x=x)?>", "tmpl3") 
    30443035 
    30453036    with raises("unsupported operand type|not supported"): 
    3046         r("<?render tmpl3.render(tmpl1=tmpl1, tmpl2=tmpl2, x=x)?>", tmpl1=tmpl1, tmpl2=tmpl2, tmpl3=tmpl3, x=None) 
     3037        r("<?exe tmpl3.render(tmpl1=tmpl1, tmpl2=tmpl2, x=x)?>", tmpl1=tmpl1, tmpl2=tmpl2, tmpl3=tmpl3, x=None) 
    30473038 
    30483039 
     
    30933084            <?print i?>! 
    30943085        <?end def?> 
    3095         <?render x.render()?> 
     3086        <?exe x.render()?> 
    30963087    <?end for?> 
    30973088    """ 
     
    31013092    # so the following code will use ``i = 1`` instead of ``i = 2`` even if the subtemplate is called after the variable has been changed. 
    31023093    source = """ 
    3103     <?code i = 1?> 
     3094    <?exe i = 1?> 
    31043095    <?def x?> 
    31053096        <?print i?> 
    31063097    <?end def?> 
    3107     <?code i = 2?> 
    3108     <?render x.render()?> 
     3098    <?exe i = 2?> 
     3099    <?exe x.render()?> 
    31093100    """ 
    31103101    assert "1" == r(source, keepws=False) 
     
    31173108    <?def outer?> 
    31183109        <?def inner?> 
    3119             <?code x += 1?> 
    3120             <?code y += 1?> 
     3110            <?exe x += 1?> 
     3111            <?exe y += 1?> 
    31213112            <?print x?>! 
    31223113            <?print y?>! 
    31233114        <?end def?> 
    3124         <?code x += 1?> 
    3125         <?code y += 1?> 
    3126         <?render inner.render(x=x)?> 
     3115        <?exe x += 1?> 
     3116        <?exe y += 1?> 
     3117        <?exe inner.render(x=x)?> 
    31273118        <?print x?>! 
    31283119        <?print y?>! 
    31293120    <?end def?> 
    3130     <?code x += 1?> 
    3131     <?code y += 1?> 
    3132     <?render outer.render(x=x)?> 
     3121    <?exe x += 1?> 
     3122    <?exe y += 1?> 
     3123    <?exe outer.render(x=x)?> 
    31333124    <?print x?>! 
    31343125    <?print y?>! 
     
    31413132    return ul4c.Template(""" 
    31423133        text 
    3143         <?code x = 'gurk'?> 
    3144         <?code x = 42?> 
    3145         <?code x = 4.2?> 
    3146         <?code x = Undefined?> 
    3147         <?code x = ReallyUndefined?> 
    3148         <?code x = None?> 
    3149         <?code x = False?> 
    3150         <?code x = True?> 
    3151         <?code x = @(2009-01-04)?> 
    3152         <?code x = #0063a8?> 
    3153         <?code x = [42]?> 
    3154         <?code x = {"fortytwo": 42}?> 
    3155         <?code x = {**{"fortytwo": 42}}?> 
    3156         <?code x = [x for x in range(10) if i % 2]?> 
    3157         <?code x = {x : x*x for x in range(10) if i % 2}?> 
    3158         <?code x = (x for x in range(10) if i % 2)?> 
    3159         <?code x = y?> 
    3160         <?code x += 42?> 
    3161         <?code x -= 42?> 
    3162         <?code x *= 42?> 
    3163         <?code x /= 42?> 
    3164         <?code x //= 42?> 
    3165         <?code x %= 42?> 
     3134        <?exe x = 'gurk'?> 
     3135        <?exe x = 42?> 
     3136        <?exe x = 4.2?> 
     3137        <?exe x = Undefined?> 
     3138        <?exe x = ReallyUndefined?> 
     3139        <?exe x = None?> 
     3140        <?exe x = False?> 
     3141        <?exe x = True?> 
     3142        <?exe x = @(2009-01-04)?> 
     3143        <?exe x = #0063a8?> 
     3144        <?exe x = [42]?> 
     3145        <?exe x = {"fortytwo": 42}?> 
     3146        <?exe x = {**{"fortytwo": 42}}?> 
     3147        <?exe x = [x for x in range(10) if i % 2]?> 
     3148        <?exe x = {x : x*x for x in range(10) if i % 2}?> 
     3149        <?exe x = (x for x in range(10) if i % 2)?> 
     3150        <?exe x = y?> 
     3151        <?exe x += 42?> 
     3152        <?exe x -= 42?> 
     3153        <?exe x *= 42?> 
     3154        <?exe x /= 42?> 
     3155        <?exe x //= 42?> 
     3156        <?exe x %= 42?> 
    31663157        <?print x.gurk?> 
    31673158        <?print x["gurk"]?> 
     
    32013192        <?print x.find(1, 2, x=17, y=23, *args, **kwargs)?> 
    32023193        <?if x?>gurk<?elif y?>hurz<?else?>hinz<?end if?> 
    3203         <?render x.render(a=1, b=2)?> 
     3194        <?exe x.render(a=1, b=2)?> 
    32043195        <?def x?>foo<?end def?> 
    32053196        <?def x?><?return x?><?end def?> 
    3206         <?render x.render()?> 
     3197        <?exe x.render()?> 
    32073198    """) 
    32083199 
     
    32353226@pytest.mark.ul4 
    32363227def test_keepws_nested(r): 
    3237     s1 = "<?def nested1?>1n\n<?render second.render()?><?end def?>1\n<?render nested1.render(second=second)?>" 
    3238     s2 = "<?def nested2?>2n\n<?end def?>2\n<?render nested2.render()?>" 
     3228    s1 = "<?def nested1?>1n\n<?exe second.render()?><?end def?>1\n<?exe nested1.render(second=second)?>" 
     3229    s2 = "<?def nested2?>2n\n<?end def?>2\n<?exe nested2.render()?>" 
    32393230 
    32403231    assert "1\n1n\n22n" == r(s1, keepws=True, second=ul4c.Template(s2, keepws=False)) 
     
    32643255@pytest.mark.ul4 
    32653256def test_function_closure(c): 
    3266     assert 24 == c("<?code y=3?><?def inner?><?return 2*x*y?><?end def?><?return inner(x=4)?>") 
    3267     assert 24 == c("<?def outer?><?code y=3?><?def inner?><?return 2*x*y?><?end def?><?return inner?><?end def?><?return outer()(x=4)?>") 
     3257    assert 24 == c("<?exe y=3?><?def inner?><?return 2*x*y?><?end def?><?return inner(x=4)?>") 
     3258    assert 24 == c("<?def outer?><?exe y=3?><?def inner?><?return 2*x*y?><?end def?><?return inner?><?end def?><?return outer()(x=4)?>") 
    32683259 
    32693260