Changeset 3468:e656913270cd in livinglogic.python.xist

Show
Ignore:
Timestamp:
07/08/08 18:23:18 (11 years ago)
Author:
Walter Doerwald <walter@…>
Branch:
default
Message:

Implement operators, <, <=, >, >=. Rename == and != opcodes. Add tests.

Files:
2 modified

Legend:

Unmodified
Added
Removed
  • src/ll/ul4c.py

    r3466 r3468  
    350350        resulting bool in the register :attr:`r1`. 
    351351 
    352     ``"equals"``: 
     352    ``"eq"``: 
    353353        Compare the objects in register :attr:`r2` and :attr:`r3` and store 
    354354        ``True`` in the register :attr:`r1` if they are equal, ``False`` otherwise. 
    355355 
    356     ``"notequals"``: 
     356    ``"ne"``: 
    357357        Compare the objects in register :attr:`r2` and :attr:`r3` and store 
    358358        ``False`` in the register :attr:`r1` if they are equal, ``True`` otherwise. 
     359 
     360    ``"lt"``: 
     361        Does a "<" comparison of the objects in register :attr:`r2` and :attr:`r3` 
     362        and stores the result in register :attr:`r1`. 
     363 
     364    ``"le"``: 
     365        Does a "<=" comparison of the objects in register :attr:`r2` and :attr:`r3` 
     366        and stores the result in register :attr:`r1`. 
     367 
     368    ``"gt"``: 
     369        Does a ">" comparison of the objects in register :attr:`r2` and :attr:`r3` 
     370        and stores the result in register :attr:`r1`. 
     371 
     372    ``"ge"``: 
     373        Does a ">=" comparison of the objects in register :attr:`r2` and :attr:`r3` 
     374        and stores the result in register :attr:`r1`. 
    359375 
    360376    ``"contains"``: 
     
    519535        elif self.code == "not": 
    520536            return "r%r = not r%r" % (self.r1, self.r2) 
    521         elif self.code == "equals": 
     537        elif self.code == "eq": 
    522538            return "r%r = r%r == r%r" % (self.r1, self.r2, self.r3) 
    523         elif self.code == "notequals": 
     539        elif self.code == "ne": 
    524540            return "r%r = r%r != r%r" % (self.r1, self.r2, self.r3) 
     541        elif self.code == "lt": 
     542            return "r%r = r%r < r%r" % (self.r1, self.r2, self.r3) 
     543        elif self.code == "le": 
     544            return "r%r = r%r <= r%r" % (self.r1, self.r2, self.r3) 
     545        elif self.code == "gt": 
     546            return "r%r = r%r > r%r" % (self.r1, self.r2, self.r3) 
     547        elif self.code == "ge": 
     548            return "r%r = r%r >= r%r" % (self.r1, self.r2, self.r3) 
    525549        elif self.code == "contains": 
    526550            return "r%r = r%r in r%r" % (self.r1, self.r2, self.r3) 
     
    578602    returns a generator) or :meth:`renders` (which returns a string). 
    579603    """ 
    580     version = "2" 
     604    version = "3" 
    581605 
    582606    def __init__(self): 
     
    850874                elif opcode.code == "notcontains": 
    851875                    _code("reg%d = reg%d not in reg%d" % (opcode.r1, opcode.r2, opcode.r3)) 
    852                 elif opcode.code == "equals": 
     876                elif opcode.code == "eq": 
    853877                    _code("reg%d = reg%d == reg%d" % (opcode.r1, opcode.r2, opcode.r3)) 
    854                 elif opcode.code == "notequals": 
     878                elif opcode.code == "ne": 
    855879                    _code("reg%d = reg%d != reg%d" % (opcode.r1, opcode.r2, opcode.r3)) 
     880                elif opcode.code == "lt": 
     881                    _code("reg%d = reg%d < reg%d" % (opcode.r1, opcode.r2, opcode.r3)) 
     882                elif opcode.code == "le": 
     883                    _code("reg%d = reg%d <= reg%d" % (opcode.r1, opcode.r2, opcode.r3)) 
     884                elif opcode.code == "gt": 
     885                    _code("reg%d = reg%d > reg%d" % (opcode.r1, opcode.r2, opcode.r3)) 
     886                elif opcode.code == "ge": 
     887                    _code("reg%d = reg%d >= reg%d" % (opcode.r1, opcode.r2, opcode.r3)) 
    856888                elif opcode.code == "add": 
    857889                    _code("reg%d = reg%d + reg%d" % (opcode.r1, opcode.r2, opcode.r3)) 
     
    14671499 
    14681500 
    1469 class Equal(Binary): 
    1470     opcode = "equals" 
    1471  
    1472  
    1473 class NotEqual(Binary): 
    1474     opcode = "notequals" 
     1501class EQ(Binary): 
     1502    opcode = "eq" 
     1503 
     1504 
     1505class NE(Binary): 
     1506    opcode = "ne" 
     1507 
     1508 
     1509class LT(Binary): 
     1510    opcode = "lt" 
     1511 
     1512 
     1513class LE(Binary): 
     1514    opcode = "le" 
     1515 
     1516 
     1517class GT(Binary): 
     1518    opcode = "gt" 
     1519 
     1520 
     1521class GE(Binary): 
     1522    opcode = "ge" 
    14751523 
    14761524 
     
    16731721        self.rv.append(Date(start, end, datetime.datetime(*map(int, filter(None, datesplitter.split(s)))))) 
    16741722 
    1675     @spark.token("\\(|\\)|\\[|\\]|\\{|\\}|\\.|,|==|\\!=|=|\\+=|\\-=|\\*=|//=|/=|%=|%|:|\\+|-|\\*|//|/", "default") 
     1723    @spark.token("\\(|\\)|\\[|\\]|\\{|\\}|\\.|,|==|\\!=|<=|<|>=|>|=|\\+=|\\-=|\\*=|//=|/=|%=|%|:|\\+|-|\\*|//|/", "default") 
    16761724    def token(self, start, end, s): 
    16771725        self.rv.append(Token(start, end, s)) 
     
    20242072 
    20252073    @spark.production('expr4 ::= expr4 == expr4') 
    2026     def expr_equal(self, obj1, _0, obj2): 
     2074    def expr_eq(self, obj1, _0, obj2): 
    20272075        if isinstance(obj1, Const) and isinstance(obj2, Const): # Constant folding 
    20282076            return self.makeconst(obj1.start, obj2.end, obj1.value == obj2.value) 
    2029         return Equal(obj1.start, obj2.end, obj1, obj2) 
     2077        return EQ(obj1.start, obj2.end, obj1, obj2) 
    20302078 
    20312079    @spark.production('expr4 ::= expr4 != expr4') 
    2032     def expr_notequal(self, obj1, _0, obj2): 
     2080    def expr_ne(self, obj1, _0, obj2): 
    20332081        if isinstance(obj1, Const) and isinstance(obj2, Const): # Constant folding 
    20342082            return self.makeconst(obj1.start, obj2.end, obj1.value != obj2.value) 
    2035         return NotEqual(obj1.start, obj2.end, obj1, obj2) 
     2083        return NE(obj1.start, obj2.end, obj1, obj2) 
     2084 
     2085    @spark.production('expr4 ::= expr4 < expr4') 
     2086    def expr_lt(self, obj1, _0, obj2): 
     2087        if isinstance(obj1, Const) and isinstance(obj2, Const): # Constant folding 
     2088            return self.makeconst(obj1.start, obj2.end, obj1.value < obj2.value) 
     2089        return LT(obj1.start, obj2.end, obj1, obj2) 
     2090 
     2091    @spark.production('expr4 ::= expr4 <= expr4') 
     2092    def expr_le(self, obj1, _0, obj2): 
     2093        if isinstance(obj1, Const) and isinstance(obj2, Const): # Constant folding 
     2094            return self.makeconst(obj1.start, obj2.end, obj1.value <= obj2.value) 
     2095        return LE(obj1.start, obj2.end, obj1, obj2) 
     2096 
     2097    @spark.production('expr4 ::= expr4 > expr4') 
     2098    def expr_gt(self, obj1, _0, obj2): 
     2099        if isinstance(obj1, Const) and isinstance(obj2, Const): # Constant folding 
     2100            return self.makeconst(obj1.start, obj2.end, obj1.value > obj2.value) 
     2101        return GT(obj1.start, obj2.end, obj1, obj2) 
     2102 
     2103    @spark.production('expr4 ::= expr4 >= expr4') 
     2104    def expr_ge(self, obj1, _0, obj2): 
     2105        if isinstance(obj1, Const) and isinstance(obj2, Const): # Constant folding 
     2106            return self.makeconst(obj1.start, obj2.end, obj1.value >= obj2.value) 
     2107        return GE(obj1.start, obj2.end, obj1, obj2) 
    20362108 
    20372109    @spark.production('expr3 ::= expr3 in expr3') 
  • test/test_ul4.py

    r3467 r3468  
    328328def test_mod(): 
    329329    check(str(42%17), '<?code x=42?><?code y=17?><?print x%y?>') 
     330 
     331 
     332def test_eq(): 
     333    check("False", '<?print 17==23?>') 
     334    check("True", '<?print 17==17?>') 
     335    check("False", '<?print x==23?>', x=17) 
     336    check("True", '<?print x==23?>', x=23) 
     337 
     338 
     339def test_ne(): 
     340    check("True", '<?print 17!=23?>') 
     341    check("False", '<?print 17!=17?>') 
     342    check("True", '<?print x!=23?>', x=17) 
     343    check("False", '<?print x!=23?>', x=23) 
     344 
     345 
     346def test_lt(): 
     347    check("True", '<?print 1<2?>') 
     348    check("False", '<?print 2<2?>') 
     349    check("False", '<?print 3<2?>') 
     350    check("True", '<?print x<2?>', x=1) 
     351    check("False", '<?print x<2?>', x=2) 
     352    check("False", '<?print x<2?>', x=3) 
     353 
     354 
     355def test_le(): 
     356    check("True", '<?print 1<=2?>') 
     357    check("True", '<?print 2<=2?>') 
     358    check("False", '<?print 3<=2?>') 
     359    check("True", '<?print x<=2?>', x=1) 
     360    check("True", '<?print x<=2?>', x=2) 
     361    check("False", '<?print x<=2?>', x=3) 
     362 
     363 
     364def test_gt(): 
     365    check("False", '<?print 1>2?>') 
     366    check("False", '<?print 2>2?>') 
     367    check("True", '<?print 3>2?>') 
     368    check("False", '<?print x>2?>', x=1) 
     369    check("False", '<?print x>2?>', x=2) 
     370    check("True", '<?print x>2?>', x=3) 
     371 
     372 
     373def test_ge(): 
     374    check("False", '<?print 1>=2?>') 
     375    check("True", '<?print 2>=2?>') 
     376    check("True", '<?print 3>=2?>') 
     377    check("False", '<?print x>=2?>', x=1) 
     378    check("True", '<?print x>=2?>', x=2) 
     379    check("True", '<?print x>=2?>', x=3) 
    330380 
    331381