about summary refs log tree commit diff stats
path: root/miasm2/arch
diff options
context:
space:
mode:
Diffstat (limited to 'miasm2/arch')
-rw-r--r--miasm2/arch/aarch64/arch.py48
-rw-r--r--miasm2/arch/arm/arch.py110
-rw-r--r--miasm2/arch/mips32/arch.py12
-rw-r--r--miasm2/arch/msp430/arch.py24
-rw-r--r--miasm2/arch/ppc/arch.py12
-rw-r--r--miasm2/arch/sh4/arch.py38
-rw-r--r--miasm2/arch/x86/arch.py22
7 files changed, 133 insertions, 133 deletions
diff --git a/miasm2/arch/aarch64/arch.py b/miasm2/arch/aarch64/arch.py
index 06e73ab4..94be74fd 100644
--- a/miasm2/arch/aarch64/arch.py
+++ b/miasm2/arch/aarch64/arch.py
@@ -76,51 +76,51 @@ shift_str = ["LSL", "LSR", "ASR", "ROR"]
 shift_expr = ["<<", ">>", "a>>", '>>>']
 
 
-def cb_shift(t):
-    return shift2expr_dct[t[0]]
+def cb_shift(tokens):
+    return shift2expr_dct[tokens[0]]
 
 
-def cb_extreg(t):
-    return t[0]
+def cb_extreg(tokens):
+    return tokens[0]
 
 
-def cb_shiftreg(t):
-    if len(t) == 1:
-        return t[0]
-    elif len(t) == 3:
-        result = AstOp(t[1], t[0], t[2])
+def cb_shiftreg(tokens):
+    if len(tokens) == 1:
+        return tokens[0]
+    elif len(tokens) == 3:
+        result = AstOp(tokens[1], tokens[0], tokens[2])
         return result
     else:
         raise ValueError('bad string')
 
 
-def cb_shift_sc(t):
-    if len(t) == 1:
-        return t[0]
-    elif len(t) == 3:
-        if t[1] != '<<':
+def cb_shift_sc(tokens):
+    if len(tokens) == 1:
+        return tokens[0]
+    elif len(tokens) == 3:
+        if tokens[1] != '<<':
             raise ValueError('bad op')
-        result = AstOp("slice_at", t[0], t[2])
+        result = AstOp("slice_at", tokens[0], tokens[2])
         return result
     else:
         raise ValueError('bad string')
 
 
-def cb_extend(t):
-    if len(t) == 1:
-        return t[0]
-    result = AstOp(t[1], t[0], t[2])
+def cb_extend(tokens):
+    if len(tokens) == 1:
+        return tokens[0]
+    result = AstOp(tokens[1], tokens[0], tokens[2])
     return result
 
 
-def cb_deref_pc_off(t):
-    if len(t) == 2 and t[0] == "PC":
-        result = AstOp('preinc', AstId(ExprId('PC', 64)), t[1])
+def cb_deref_pc_off(tokens):
+    if len(tokens) == 2 and tokens[0] == "PC":
+        result = AstOp('preinc', AstId(ExprId('PC', 64)), tokens[1])
         return result
     raise ValueError('bad string')
 
-def cb_deref_pc_nooff(t):
-    if len(t) == 1 and t[0] == "PC":
+def cb_deref_pc_nooff(tokens):
+    if len(tokens) == 1 and tokens[0] == "PC":
         result = AstOp('preinc', AstId(PC))
         return result
     raise ValueError('bad string')
diff --git a/miasm2/arch/arm/arch.py b/miasm2/arch/arm/arch.py
index e09619ae..35574a84 100644
--- a/miasm2/arch/arm/arch.py
+++ b/miasm2/arch/arm/arch.py
@@ -105,10 +105,10 @@ barrier_info = reg_info_dct(barrier_expr)
 
 # parser helper ###########
 
-def cb_tok_reg_duo(t):
-    t = t[0]
-    i1 = gpregs.expr.index(t[0].name)
-    i2 = gpregs.expr.index(t[1].name)
+def cb_tok_reg_duo(tokens):
+    tokens = tokens[0]
+    i1 = gpregs.expr.index(tokens[0].name)
+    i2 = gpregs.expr.index(tokens[1].name)
     o = []
     for i in xrange(i1, i2 + 1):
         o.append(AstId(gpregs.expr[i]))
@@ -142,11 +142,11 @@ int_1_32 = str_int.copy().setParseAction(lambda v: check_bounds(1, 32, v[0]))
 int_8_16_24 = str_int.copy().setParseAction(lambda v: check_values([8, 16, 24], v[0]))
 
 
-def cb_reglistparse(s, l, t):
-    t = t[0]
-    if t[-1] == "^":
-        return AstOp('sbit', AstOp('reglist', *t[:-1]))
-    return AstOp('reglist', *t)
+def cb_reglistparse(tokens):
+    tokens = tokens[0]
+    if tokens[-1] == "^":
+        return AstOp('sbit', AstOp('reglist', *tokens[:-1]))
+    return AstOp('reglist', *tokens)
 
 
 allshifts = ['<<', '>>', 'a>>', '>>>', 'rrx']
@@ -158,8 +158,8 @@ shift2expr_dct = {'LSL': '<<', 'LSR': '>>', 'ASR': 'a>>',
 expr2shift_dct = dict([(x[1], x[0]) for x in shift2expr_dct.items()])
 
 
-def op_shift2expr(s, l, t):
-    return shift2expr_dct[t[0]]
+def op_shift2expr(tokens):
+    return shift2expr_dct[tokens[0]]
 
 reg_duo = Group(gpregs.parser + MINUS +
                 gpregs.parser).setParseAction(cb_tok_reg_duo)
@@ -188,13 +188,13 @@ gpreg_p = gpregs.parser
 psr_p = cpsr_regs.parser | spsr_regs.parser
 
 
-def cb_shift(t):
-    if len(t) == 1:
-        ret = t[0]
-    elif len(t) == 2:
-        ret = AstOp(t[1], t[0])
-    elif len(t) == 3:
-        ret = AstOp(t[1], t[0], t[2])
+def cb_shift(tokens):
+    if len(tokens) == 1:
+        ret = tokens[0]
+    elif len(tokens) == 2:
+        ret = AstOp(tokens[1], tokens[0])
+    elif len(tokens) == 3:
+        ret = AstOp(tokens[1], tokens[0], tokens[2])
     else:
         raise ValueError("Bad arg")
     return ret
@@ -214,15 +214,15 @@ rot2_expr = (gpregs.parser + Optional(
 
 OP_LSL = Suppress("LSL")
 
-def cb_deref_reg_reg(t):
-    if len(t) != 2:
+def cb_deref_reg_reg(tokens):
+    if len(tokens) != 2:
         raise ValueError("Bad mem format")
-    return AstMem(AstOp('+', t[0], t[1]), 8)
+    return AstMem(AstOp('+', tokens[0], tokens[1]), 8)
 
-def cb_deref_reg_reg_lsl_1(t):
-    if len(t) != 3:
+def cb_deref_reg_reg_lsl_1(tokens):
+    if len(tokens) != 3:
         raise ValueError("Bad mem format")
-    reg1, reg2, index = t
+    reg1, reg2, index = tokens
     if not isinstance(index, AstInt) or index.value != 1:
         raise ValueError("Bad index")
     ret = AstMem(AstOp('+', reg1, AstOp('<<', reg2, index)), 16)
@@ -242,42 +242,42 @@ deref_reg_reg_lsl_1 = (LBRACK + gpregs.parser + COMMA + gpregs.parser + OP_LSL +
 
 reg_or_base = gpregs.parser | base_expr
 
-def deref2expr_nooff(s, l, t):
-    t = t[0]
+def deref2expr_nooff(tokens):
+    tokens = tokens[0]
     # XXX default
-    return ExprOp("preinc", t[0], ExprInt(0, 32))
+    return ExprOp("preinc", tokens[0], ExprInt(0, 32))
 
 
-def cb_deref_preinc(t):
-    t = t[0]
-    if len(t) == 1:
-        return AstOp("preinc", t[0], AstInt(0))
-    elif len(t) == 2:
-        return AstOp("preinc", t[0], t[1])
+def cb_deref_preinc(tokens):
+    tokens = tokens[0]
+    if len(tokens) == 1:
+        return AstOp("preinc", tokens[0], AstInt(0))
+    elif len(tokens) == 2:
+        return AstOp("preinc", tokens[0], tokens[1])
     else:
-        raise NotImplementedError('len(t) > 2')
+        raise NotImplementedError('len(tokens) > 2')
 
 
-def cb_deref_pre_mem(t):
-    t = t[0]
-    if len(t) == 1:
-        return AstMem(AstOp("preinc", t[0], AstInt(0)), 32)
-    elif len(t) == 2:
-        return AstMem(AstOp("preinc", t[0], t[1]), 32)
+def cb_deref_pre_mem(tokens):
+    tokens = tokens[0]
+    if len(tokens) == 1:
+        return AstMem(AstOp("preinc", tokens[0], AstInt(0)), 32)
+    elif len(tokens) == 2:
+        return AstMem(AstOp("preinc", tokens[0], tokens[1]), 32)
     else:
-        raise NotImplementedError('len(t) > 2')
+        raise NotImplementedError('len(tokens) > 2')
 
 
-def cb_deref_post(t):
-    t = t[0]
-    return AstOp("postinc", t[0], t[1])
+def cb_deref_post(tokens):
+    tokens = tokens[0]
+    return AstOp("postinc", tokens[0], tokens[1])
 
 
-def cb_deref_wb(t):
-    t = t[0]
-    if t[-1] == '!':
-        return AstMem(AstOp('wback', *t[:-1]), 32)
-    return AstMem(t[0], 32)
+def cb_deref_wb(tokens):
+    tokens = tokens[0]
+    if tokens[-1] == '!':
+        return AstMem(AstOp('wback', *tokens[:-1]), 32)
+    return AstMem(tokens[0], 32)
 
 # shift_off.setParseAction(deref_off)
 deref_nooff = Group(
@@ -290,12 +290,12 @@ deref = Group((deref_post | deref_pre | deref_nooff)
               + Optional('!')).setParseAction(cb_deref_wb)
 
 
-def cb_gpreb_wb(t):
-    assert len(t) == 1
-    t = t[0]
-    if t[-1] == '!':
-        return AstOp('wback', *t[:-1])
-    return t[0]
+def cb_gpreb_wb(tokens):
+    assert len(tokens) == 1
+    tokens = tokens[0]
+    if tokens[-1] == '!':
+        return AstOp('wback', *tokens[:-1])
+    return tokens[0]
 
 gpregs_wb = Group(gpregs.parser + Optional('!')).setParseAction(cb_gpreb_wb)
 
diff --git a/miasm2/arch/mips32/arch.py b/miasm2/arch/mips32/arch.py
index 817954b6..15c59cf0 100644
--- a/miasm2/arch/mips32/arch.py
+++ b/miasm2/arch/mips32/arch.py
@@ -25,15 +25,15 @@ gpregs = cpu.reg_info(regs.regs32_str, regs.regs32_expr)
 LPARENTHESIS = Literal("(")
 RPARENTHESIS = Literal(")")
 
-def cb_deref(t):
-    if len(t) != 4:
+def cb_deref(tokens):
+    if len(tokens) != 4:
         raise NotImplementedError("TODO")
-    return AstMem(t[2] + t[0], 32)
+    return AstMem(tokens[2] + tokens[0], 32)
 
-def cb_deref_nooff(t):
-    if len(t) != 3:
+def cb_deref_nooff(tokens):
+    if len(tokens) != 3:
         raise NotImplementedError("TODO")
-    return AstMem(t[1], 32)
+    return AstMem(tokens[1], 32)
 
 base_expr = cpu.base_expr
 
diff --git a/miasm2/arch/msp430/arch.py b/miasm2/arch/msp430/arch.py
index e27d714e..e4d03edb 100644
--- a/miasm2/arch/msp430/arch.py
+++ b/miasm2/arch/msp430/arch.py
@@ -20,28 +20,28 @@ conditional_branch = ['jnz', 'jz', 'jnc', 'jc',
                       'jn', 'jge', 'jl']
 unconditional_branch = ['jmp']
 
-def cb_deref_nooff(t):
-    assert len(t) == 1
-    result = AstMem(t[0], 16)
+def cb_deref_nooff(tokens):
+    assert len(tokens) == 1
+    result = AstMem(tokens[0], 16)
     return result
 
 
-def cb_deref_pinc(t):
-    assert len(t) == 1
+def cb_deref_pinc(tokens):
+    assert len(tokens) == 1
 
-    result = AstOp('autoinc', *t)
+    result = AstOp('autoinc', *tokens)
     return result
 
 
-def cb_deref_off(t):
-    assert len(t) == 2
-    result = AstMem(t[1] + t[0], 16)
+def cb_deref_off(tokens):
+    assert len(tokens) == 2
+    result = AstMem(tokens[1] + tokens[0], 16)
     return result
 
 
-def cb_expr(t):
-    assert(len(t) == 1)
-    result = t[0]
+def cb_expr(tokens):
+    assert(len(tokens) == 1)
+    result = tokens[0]
     return result
 
 
diff --git a/miasm2/arch/ppc/arch.py b/miasm2/arch/ppc/arch.py
index d6a2b912..945824a0 100644
--- a/miasm2/arch/ppc/arch.py
+++ b/miasm2/arch/ppc/arch.py
@@ -19,13 +19,13 @@ log.setLevel(logging.DEBUG)
 LPARENTHESIS = Suppress(Literal("("))
 RPARENTHESIS = Suppress(Literal(")"))
 
-def cb_deref_imm_reg(t):
-    if len(t) == 1:
-        return AstMem(t[0], 32)
-    elif len(t) == 2:
-        return AstMem(t[1] + t[0], 32)
+def cb_deref_imm_reg(tokens):
+    if len(tokens) == 1:
+        return AstMem(tokens[0], 32)
+    elif len(tokens) == 2:
+        return AstMem(tokens[1] + tokens[0], 32)
     else:
-        raise NotImplementedError('len(t) > 2')
+        raise NotImplementedError('len(tokens) > 2')
 
 
 deref_reg_disp = (Optional(base_expr) + LPARENTHESIS + gpregs.parser +  RPARENTHESIS).setParseAction(cb_deref_imm_reg)
diff --git a/miasm2/arch/sh4/arch.py b/miasm2/arch/sh4/arch.py
index 59e363f6..14f46265 100644
--- a/miasm2/arch/sh4/arch.py
+++ b/miasm2/arch/sh4/arch.py
@@ -28,12 +28,12 @@ LPARENT = Suppress("(")
 RPARENT = Suppress(")")
 
 
-def cb_deref_pcimm(t):
-    return t[0] + t[1]
+def cb_deref_pcimm(tokens):
+    return tokens[0] + tokens[1]
 
 
-def cb_pcandimmimm(t):
-    return (t[0] & t[1]) + t[2]
+def cb_pcandimmimm(tokens):
+    return (tokens[0] & tokens[1]) + tokens[2]
 
 
 
@@ -44,33 +44,33 @@ pcdisp = (reg_info_pc.parser + AND + base_expr + PLUS + base_expr).setParseActio
 PTR = Suppress('PTR')
 
 
-def cb_deref_mem(t):
-    assert len(t) == 1
-    result = AstMem(t[0], 32)
+def cb_deref_mem(tokens):
+    assert len(tokens) == 1
+    result = AstMem(tokens[0], 32)
     return result
 
 
-def cb_predec(t):
-    assert len(t) == 1
-    result = AstMem(AstOp('predec', t[0]), 32)
+def cb_predec(tokens):
+    assert len(tokens) == 1
+    result = AstMem(AstOp('predec', tokens[0]), 32)
     return result
 
 
-def cb_postinc(t):
-    assert len(t) == 1
-    result = AstMem(AstOp('postinc', t[0]), 32)
+def cb_postinc(tokens):
+    assert len(tokens) == 1
+    result = AstMem(AstOp('postinc', tokens[0]), 32)
     return result
 
 
-def cb_regdisp(t):
-    assert len(t) == 2
-    result = AstMem(t[0] + t[1], 32)
+def cb_regdisp(tokens):
+    assert len(tokens) == 2
+    result = AstMem(tokens[0] + tokens[1], 32)
     return result
 
 
-def cb_regreg(t):
-    assert len(t) == 2
-    result = AstMem(t[0] + t[1], 32)
+def cb_regreg(tokens):
+    assert len(tokens) == 2
+    result = AstMem(tokens[0] + tokens[1], 32)
     return result
 
 
diff --git a/miasm2/arch/x86/arch.py b/miasm2/arch/x86/arch.py
index 9310ce1d..fc3a5882 100644
--- a/miasm2/arch/x86/arch.py
+++ b/miasm2/arch/x86/arch.py
@@ -184,13 +184,13 @@ gpreg = (
 
 
 
-def cb_deref_segmoff(t):
-    assert len(t) == 2
-    return AstOp('segm', t[0], t[1])
+def cb_deref_segmoff(tokens):
+    assert len(tokens) == 2
+    return AstOp('segm', tokens[0], tokens[1])
 
 
-def cb_deref_base_expr(t):
-    tokens = t[0]
+def cb_deref_base_expr(tokens):
+    tokens = tokens[0]
     assert isinstance(tokens, AstNode)
     addr = tokens
     return addr
@@ -218,15 +218,15 @@ MEMPREFIX2SIZE = {'BYTE': 8, 'WORD': 16, 'DWORD': 32,
 
 SIZE2MEMPREFIX = dict((x[1], x[0]) for x in MEMPREFIX2SIZE.items())
 
-def cb_deref_mem(t):
-    if len(t) == 2:
-        s, ptr = t
+def cb_deref_mem(tokens):
+    if len(tokens) == 2:
+        s, ptr = tokens
         assert isinstance(ptr, AstNode)
         return AstMem(ptr, MEMPREFIX2SIZE[s])
-    elif len(t) == 3:
-        s, segm, ptr = t
+    elif len(tokens) == 3:
+        s, segm, ptr = tokens
         return AstMem(AstOp('segm', segm, ptr), MEMPREFIX2SIZE[s])
-    raise ValueError('len(t) > 3')
+    raise ValueError('len(tokens) > 3')
 
 mem_size = (BYTE | DWORD | QWORD | WORD | TBYTE | XMMWORD)
 deref_mem = (mem_size + PTR + Optional((base_expr + COLON))+ deref_mem_ad).setParseAction(cb_deref_mem)