Parser: fix arguments name

8 files changed, 189 insertions, 191 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)
diff --git a/miasm2/core/cpu.py b/miasm2/core/cpu.py
index ca419458..d75b99cf 100644
--- a/miasm2/core/cpu.py
+++ b/miasm2/core/cpu.py
@@ -95,9 +95,9 @@ class reg_info(object):
         self.expr = reg_expr
         self.parser = literal_list(reg_str).setParseAction(self.cb_parse)
 
-    def cb_parse(self, t):
-        assert len(t) == 1
-        i = self.str.index(t[0])
+    def cb_parse(self, tokens):
+        assert len(tokens) == 1
+        i = self.str.index(tokens[0])
         reg = self.expr[i]
         result = AstId(reg)
         return result
@@ -119,9 +119,9 @@ class reg_info_dct(object):
         reg_str = [v.name for v in reg_expr.itervalues()]
         self.parser = literal_list(reg_str).setParseAction(self.cb_parse)
 
-    def cb_parse(self, t):
-        assert len(t) == 1
-        i = self.dct_str_inv[t[0]]
+    def cb_parse(self, tokens):
+        assert len(tokens) == 1
+        i = self.dct_str_inv[tokens[0]]
         reg = self.dct_expr[i]
         result = AstId(reg)
         return result
@@ -180,45 +180,45 @@ LPARENTHESIS = pyparsing.Literal("(")
 RPARENTHESIS = pyparsing.Literal(")")
 
 
-def int2expr(t):
-    v = t[0]
+def int2expr(tokens):
+    v = tokens[0]
     return (m2_expr.ExprInt, v)
 
 
-def parse_op(t):
-    v = t[0]
+def parse_op(tokens):
+    v = tokens[0]
     return (m2_expr.ExprOp, v)
 
 
-def parse_id(t):
-    v = t[0]
+def parse_id(tokens):
+    v = tokens[0]
     return (m2_expr.ExprId, v)
 
 
-def ast_parse_op(t):
-    if len(t) == 1:
-        return t[0]
-    if len(t) == 2:
-        if t[0] in ['-', '+', '!']:
-            return m2_expr.ExprOp(t[0], t[1])
-    if len(t) == 3:
-        if t[1] == '-':
+def ast_parse_op(tokens):
+    if len(tokens) == 1:
+        return tokens[0]
+    if len(tokens) == 2:
+        if tokens[0] in ['-', '+', '!']:
+            return m2_expr.ExprOp(tokens[0], tokens[1])
+    if len(tokens) == 3:
+        if tokens[1] == '-':
             # a - b => a + (-b)
-            t[1] = '+'
-            t[2] = - t[2]
-        return m2_expr.ExprOp(t[1], t[0], t[2])
-    t = t[::-1]
-    while len(t) >= 3:
-        o1, op, o2 = t.pop(), t.pop(), t.pop()
+            tokens[1] = '+'
+            tokens[2] = - tokens[2]
+        return m2_expr.ExprOp(tokens[1], tokens[0], tokens[2])
+    tokens = tokens[::-1]
+    while len(tokens) >= 3:
+        o1, op, o2 = tokens.pop(), tokens.pop(), tokens.pop()
         if op == '-':
             # a - b => a + (-b)
             op = '+'
             o2 = - o2
         e = m2_expr.ExprOp(op, o1, o2)
-        t.append(e)
-    if len(t) != 1:
+        tokens.append(e)
+    if len(tokens) != 1:
         raise NotImplementedError('strange op')
-    return t[0]
+    return tokens[0]
 
 
 def ast_id2expr(a):
@@ -229,16 +229,14 @@ def ast_int2expr(a):
     return m2_expr.ExprInt(a, 32)
 
 
-def neg_int(t):
-    x = -t[0]
+def neg_int(tokens):
+    x = -tokens[0]
     return x
 
 
-integer = pyparsing.Word(pyparsing.nums).setParseAction(lambda _a, _b, t:
-                                                            int(t[0]))
+integer = pyparsing.Word(pyparsing.nums).setParseAction(lambda tokens: int(tokens[0]))
 hex_word = pyparsing.Literal('0x') + pyparsing.Word(pyparsing.hexnums)
-hex_int = pyparsing.Combine(hex_word).setParseAction(lambda _a, _b, t:
-                                                         int(t[0], 16))
+hex_int = pyparsing.Combine(hex_word).setParseAction(lambda tokens: int(tokens[0], 16))
 
 # str_int = (Optional('-') + (hex_int | integer))
 str_int_pos = (hex_int | integer)
@@ -266,20 +264,20 @@ def literal_list(l):
     return o
 
 
-def cb_int(t):
-    assert len(t) == 1
-    integer = AstInt(t[0])
+def cb_int(tokens):
+    assert len(tokens) == 1
+    integer = AstInt(tokens[0])
     return integer
 
 
-def cb_parse_id(t):
-    assert len(t) == 1
-    reg = t[0]
+def cb_parse_id(tokens):
+    assert len(tokens) == 1
+    reg = tokens[0]
     return AstId(reg)
 
 
-def cb_op_not(t):
-    tokens = t[0]
+def cb_op_not(tokens):
+    tokens = tokens[0]
     assert len(tokens) == 2
     assert tokens[0] == "!"
     result = AstOp("!", tokens[1])
@@ -302,32 +300,32 @@ def merge_ops(tokens, op):
     return result
 
 
-def cb_op_and(t):
-    result = merge_ops(t[0], "&")
+def cb_op_and(tokens):
+    result = merge_ops(tokens[0], "&")
     return result
 
 
-def cb_op_xor(t):
-    result = merge_ops(t[0], "^")
+def cb_op_xor(tokens):
+    result = merge_ops(tokens[0], "^")
     return result
 
 
-def cb_op_sign(t):
-    assert len(t) == 1
-    op, value = t[0]
+def cb_op_sign(tokens):
+    assert len(tokens) == 1
+    op, value = tokens[0]
     return -value
 
 
-def cb_op_div(t):
-    tokens = t[0]
+def cb_op_div(tokens):
+    tokens = tokens[0]
     assert len(tokens) == 3
     assert tokens[1] == "/"
     result = AstOp("/", tokens[0], tokens[2])
     return result
 
 
-def cb_op_plusminus(t):
-    tokens = t[0]
+def cb_op_plusminus(tokens):
+    tokens = tokens[0]
     if len(tokens) == 3:
         # binary op
         assert isinstance(tokens[0], AstNode)
@@ -355,8 +353,8 @@ def cb_op_plusminus(t):
     return result
 
 
-def cb_op_mul(t):
-    tokens = t[0]
+def cb_op_mul(tokens):
+    tokens = tokens[0]
     assert len(tokens) == 3
     assert isinstance(tokens[0], AstNode)
     assert isinstance(tokens[2], AstNode)
@@ -367,9 +365,9 @@ def cb_op_mul(t):
     return result
 
 
-integer = pyparsing.Word(pyparsing.nums).setParseAction(lambda t: int(t[0]))
+integer = pyparsing.Word(pyparsing.nums).setParseAction(lambda tokens: int(tokens[0]))
 hex_word = pyparsing.Literal('0x') + pyparsing.Word(pyparsing.hexnums)
-hex_int = pyparsing.Combine(hex_word).setParseAction(lambda t: int(t[0], 16))
+hex_int = pyparsing.Combine(hex_word).setParseAction(lambda tokens: int(tokens[0], 16))
 
 str_int_pos = (hex_int | integer)