Merge pull request #497 from serpilliere/rename_symb

Rename symb

13 files changed, 151 insertions, 151 deletions

diff --git a/example/asm/shellcode.py b/example/asm/shellcode.py
index 3ff11489..bacb65fb 100755
--- a/example/asm/shellcode.py
+++ b/example/asm/shellcode.py
@@ -5,7 +5,7 @@ from pdb import pm
 from elfesteem import pe_init
 from elfesteem.strpatchwork import StrPatchwork
 
-from miasm2.core import parse_asm, asmbloc
+from miasm2.core import parse_asm, asmblock
 from miasm2.analysis.machine import Machine
 from miasm2.core.interval import interval
 
@@ -64,7 +64,7 @@ else:
 with open(args.source) as fstream:
     source = fstream.read()
 
-blocs, symbol_pool = parse_asm.parse_txt(machine.mn, attrib, source)
+blocks, symbol_pool = parse_asm.parse_txt(machine.mn, attrib, source)
 
 # Fix shellcode addrs
 symbol_pool.set_offset(symbol_pool.getby_name("main"), addr_main)
@@ -73,14 +73,14 @@ if args.PE:
     symbol_pool.set_offset(symbol_pool.getby_name_create("MessageBoxA"),
                            pe.DirImport.get_funcvirt('USER32.dll', 'MessageBoxA'))
 
-# Print and graph firsts blocs before patching it
-for bloc in blocs:
-    print bloc
-open("graph.dot", "w").write(blocs.dot())
+# Print and graph firsts blocks before patching it
+for block in blocks:
+    print block
+open("graph.dot", "w").write(blocks.dot())
 
 # Apply patches
-patches = asmbloc.asm_resolve_final(machine.mn,
-                                    blocs,
+patches = asmblock.asm_resolve_final(machine.mn,
+                                    blocks,
                                     symbol_pool,
                                     dst_interval)
 if args.encrypt:
diff --git a/example/asm/simple.py b/example/asm/simple.py
index d7623908..62d2ff80 100644
--- a/example/asm/simple.py
+++ b/example/asm/simple.py
@@ -2,11 +2,11 @@ from pdb import pm
 from pprint import pprint
 
 from miasm2.arch.x86.arch import mn_x86
-from miasm2.core import parse_asm, asmbloc
+from miasm2.core import parse_asm, asmblock
 
 
 # Assemble code
-blocs, symbol_pool = parse_asm.parse_txt(mn_x86, 32, '''
+blocks, symbol_pool = parse_asm.parse_txt(mn_x86, 32, '''
 main:
    MOV    EAX, 1
    MOV    EBX, 2
@@ -25,11 +25,11 @@ loop:
 symbol_pool.set_offset(symbol_pool.getby_name("main"), 0x0)
 
 # Spread information and resolve instructions offset
-patches = asmbloc.asm_resolve_final(mn_x86, blocs, symbol_pool)
+patches = asmblock.asm_resolve_final(mn_x86, blocks, symbol_pool)
 
-# Show resolved blocs
-for bloc in blocs:
-    print bloc
+# Show resolved blocks
+for block in blocks:
+    print block
 
 # Print offset -> bytes
 pprint(patches)
diff --git a/example/disasm/callback.py b/example/disasm/callback.py
index 4a7507dd..06159138 100644
--- a/example/disasm/callback.py
+++ b/example/disasm/callback.py
@@ -1,5 +1,5 @@
 from miasm2.core.bin_stream import bin_stream_str
-from miasm2.core.asmbloc import asm_label, asm_constraint, expr_is_label
+from miasm2.core.asmblock import AsmLabel, AsmConstraint, expr_is_label
 from miasm2.arch.x86.disasm import dis_x86_32, cb_x86_funcs
 
 
@@ -34,7 +34,7 @@ def cb_x86_callpop(cur_bloc, symbol_pool, *args, **kwargs):
 
     # Update next blocks to process in the disassembly engine
     cur_bloc.bto.clear()
-    cur_bloc.add_cst(dst.name.offset, asm_constraint.c_next, symbol_pool)
+    cur_bloc.add_cst(dst.name.offset, AsmConstraint.c_next, symbol_pool)
 
 
 # Prepare a tiny shellcode
diff --git a/example/disasm/full.py b/example/disasm/full.py
index f15b59eb..e768e21c 100644
--- a/example/disasm/full.py
+++ b/example/disasm/full.py
@@ -4,7 +4,7 @@ from argparse import ArgumentParser
 from pdb import pm
 
 from miasm2.analysis.binary import Container
-from miasm2.core.asmbloc import log_asmbloc, asm_label, AsmCFG
+from miasm2.core.asmblock import log_asmblock, AsmLabel, AsmCFG
 from miasm2.expression.expression import ExprId
 from miasm2.core.interval import interval
 from miasm2.analysis.machine import Machine
@@ -56,7 +56,7 @@ parser.add_argument('-c', "--rawbinary", default=False, action="store_true",
 args = parser.parse_args()
 
 if args.verbose:
-    log_asmbloc.setLevel(logging.DEBUG)
+    log_asmblock.setLevel(logging.DEBUG)
 
 log.info('Load binary')
 if args.rawbinary:
@@ -108,7 +108,7 @@ for ad in addrs:
 
 done = set()
 all_funcs = set()
-all_funcs_blocs = {}
+all_funcs_blocks = {}
 
 
 done_interval = interval()
@@ -121,27 +121,27 @@ while not finish and todo:
         if ad in done:
             continue
         done.add(ad)
-        ab = mdis.dis_multibloc(ad)
+        allblocks = mdis.dis_multibloc(ad)
 
         log.info('func ok %.16x (%d)' % (ad, len(all_funcs)))
 
         all_funcs.add(ad)
-        all_funcs_blocs[ad] = ab
-        for b in ab:
-            for l in b.lines:
+        all_funcs_blocks[ad] = allblocks
+        for block in allblocks:
+            for l in block.lines:
                 done_interval += interval([(l.offset, l.offset + l.l)])
 
         if args.funcswatchdog is not None:
             args.funcswatchdog -= 1
         if args.recurfunctions:
-            for b in ab:
-                i = b.get_subcall_instr()
-                if not i:
+            for block in allblocks:
+                instr = block.get_subcall_instr()
+                if not isntr:
                     continue
-                for d in i.getdstflow(mdis.symbol_pool):
-                    if not (isinstance(d, ExprId) and isinstance(d.name, asm_label)):
+                for dest in instr.getdstflow(mdis.symbol_pool):
+                    if not (isinstance(dest, ExprId) and isinstance(dest.name, AsmLabel)):
                         continue
-                    todo.append((mdis, i, d.name.offset))
+                    todo.append((mdis, instr, dest.name.offset))
 
         if args.funcswatchdog is not None and args.funcswatchdog <= 0:
             finish = True
@@ -155,13 +155,13 @@ while not finish and todo:
 
 
 # Generate dotty graph
-all_blocs = AsmCFG()
-for blocs in all_funcs_blocs.values():
-    all_blocs += blocs
+all_blocks = AsmCFG()
+for blocks in all_funcs_blocks.values():
+    all_blocks += blocks
 
 
 log.info('generate graph file')
-open('graph_execflow.dot', 'w').write(all_blocs.dot(offset=True))
+open('graph_execflow.dot', 'w').write(all_blocks.dot(offset=True))
 
 log.info('generate intervals')
 
@@ -188,23 +188,23 @@ if args.gen_ir:
 
     ir_arch = ir(mdis.symbol_pool)
     ir_arch_a = ira(mdis.symbol_pool)
-    ir_arch.blocs = {}
-    ir_arch_a.blocs = {}
-    for ad, all_bloc in all_funcs_blocs.items():
+    ir_arch.blocks = {}
+    ir_arch_a.blocks = {}
+    for ad, all_block in all_funcs_blocks.items():
         log.info("generating IR... %x" % ad)
-        for b in all_bloc:
-            ir_arch_a.add_bloc(b)
-            ir_arch.add_bloc(b)
+        for block in all_block:
+            ir_arch_a.add_bloc(block)
+            ir_arch.add_bloc(block)
 
-    log.info("Print blocs (without analyse)")
-    for label, bloc in ir_arch.blocs.iteritems():
-        print bloc
+    log.info("Print blocks (without analyse)")
+    for label, block in ir_arch.blocks.iteritems():
+        print block
 
     log.info("Gen Graph... %x" % ad)
 
-    log.info("Print blocs (with analyse)")
-    for label, bloc in ir_arch_a.blocs.iteritems():
-        print bloc
+    log.info("Print blocks (with analyse)")
+    for label, block in ir_arch_a.blocks.iteritems():
+        print block
 
     if args.simplify:
         ir_arch_a.dead_simp()
diff --git a/example/expression/access_c.py b/example/expression/access_c.py
index 1df51b00..eabc3770 100644
--- a/example/expression/access_c.py
+++ b/example/expression/access_c.py
@@ -58,7 +58,7 @@ ExprCompose(var1, 0) => var1
 def find_call(ira):
     """Returns (irb, index) which call"""
 
-    for irb in ira.blocs.values():
+    for irb in ira.blocks.values():
         out = set()
         if len(irb.irs) < 2:
             continue
diff --git a/example/expression/asm_to_ir.py b/example/expression/asm_to_ir.py
index 2f8999a4..b28f8a81 100644
--- a/example/expression/asm_to_ir.py
+++ b/example/expression/asm_to_ir.py
@@ -3,12 +3,12 @@ from pdb import pm
 from miasm2.arch.x86.arch import mn_x86
 from miasm2.core import parse_asm
 from miasm2.expression.expression import *
-from miasm2.core import asmbloc
+from miasm2.core import asmblock
 from miasm2.arch.x86.ira import ir_a_x86_32
 
 
 # First, asm code
-blocs, symbol_pool = parse_asm.parse_txt(mn_x86, 32, '''
+blocks, symbol_pool = parse_asm.parse_txt(mn_x86, 32, '''
 main:
    MOV    EAX, 1
    MOV    EBX, 2
@@ -25,24 +25,24 @@ loop:
 
 
 symbol_pool.set_offset(symbol_pool.getby_name("main"), 0x0)
-for b in blocs:
-    print b
+for block in blocks:
+    print block
 
 
 print "symbols:"
 print symbol_pool
-patches = asmbloc.asm_resolve_final(mn_x86, blocs, symbol_pool)
+patches = asmblock.asm_resolve_final(mn_x86, blocks, symbol_pool)
 
 # Translate to IR
 ir_arch = ir_a_x86_32(symbol_pool)
-for b in blocs:
-    print 'add bloc'
-    print b
-    ir_arch.add_bloc(b)
+for block in blocks:
+    print 'add block'
+    print block
+    ir_arch.add_bloc(block)
 
 # Display IR
-for lbl, b in ir_arch.blocs.items():
-    print b
+for lbl, irblock in ir_arch.blocks.items():
+    print irblock
 
 # Dead propagation
 open('graph.dot', 'w').write(ir_arch.graph.dot())
@@ -51,6 +51,6 @@ ir_arch.dead_simp()
 open('graph2.dot', 'w').write(ir_arch.graph.dot())
 
 # Display new IR
-print 'new ir blocs'
-for lbl, b in ir_arch.blocs.items():
-    print b
+print 'new ir blocks'
+for lbl, irblock in ir_arch.blocks.items():
+    print irblock
diff --git a/example/expression/get_read_write.py b/example/expression/get_read_write.py
index cb9e0900..f4dde4b5 100644
--- a/example/expression/get_read_write.py
+++ b/example/expression/get_read_write.py
@@ -16,7 +16,7 @@ l.offset, l.l = 0, 15
 ir_arch.add_instr(l)
 
 print '*' * 80
-for lbl, b in ir_arch.blocs.items():
+for lbl, b in ir_arch.blocks.items():
     print b
     for irs in b.irs:
         o_r, o_w = get_rw(irs)
diff --git a/example/expression/graph_dataflow.py b/example/expression/graph_dataflow.py
index 64801e52..bd767165 100644
--- a/example/expression/graph_dataflow.py
+++ b/example/expression/graph_dataflow.py
@@ -7,7 +7,7 @@ from miasm2.arch.x86.ira import ir_a_x86_32
 from miasm2.arch.x86.disasm import dis_x86_32
 from miasm2.analysis.data_analysis import intra_bloc_flow_raw, inter_bloc_flow
 from miasm2.core.graph import DiGraph
-from miasm2.ir.symbexec import symbexec
+from miasm2.ir.symbexec import SymbolicExecutionEngine
 
 
 parser = ArgumentParser("Simple expression use for generating dataflow graph")
@@ -49,12 +49,12 @@ def get_modified_symbols(sb):
     return out
 
 
-def intra_bloc_flow_symb(ir_arch, flow_graph, irbloc):
+def intra_bloc_flow_symb(ir_arch, flow_graph, irblock):
     symbols_init = ir_arch.arch.regs.regs_init.copy()
-    sb = symbexec(ir_arch, symbols_init)
-    sb.emulbloc(irbloc)
+    sb = SymbolicExecutionEngine(ir_arch, symbols_init)
+    sb.emulbloc(irblock)
     print '*' * 40
-    print irbloc
+    print irblock
     in_nodes = {}
     out_nodes = {}
 
@@ -68,7 +68,7 @@ def intra_bloc_flow_symb(ir_arch, flow_graph, irbloc):
             all_mems.update(get_expr_mem(n))
 
         for n in all_mems:
-            node_n_w = get_node_name(irbloc.label, 0, n)
+            node_n_w = get_node_name(irblock.label, 0, n)
             if not n == src:
                 continue
             o_r = n.arg.get_r(mem_read=False, cst_read=True)
@@ -76,7 +76,7 @@ def intra_bloc_flow_symb(ir_arch, flow_graph, irbloc):
                 if n_r in current_nodes:
                     node_n_r = current_nodes[n_r]
                 else:
-                    node_n_r = get_node_name(irbloc.label, i, n_r)
+                    node_n_r = get_node_name(irblock.label, i, n_r)
                 if not n_r in in_nodes:
                     in_nodes[n_r] = node_n_r
                 flow_graph.add_uniq_edge(node_n_r, node_n_w)
@@ -89,20 +89,20 @@ def intra_bloc_flow_symb(ir_arch, flow_graph, irbloc):
             if n_r in current_nodes:
                 node_n_r = current_nodes[n_r]
             else:
-                node_n_r = get_node_name(irbloc.label, 0, n_r)
+                node_n_r = get_node_name(irblock.label, 0, n_r)
             if not n_r in in_nodes:
                 in_nodes[n_r] = node_n_r
 
             flow_graph.add_node(node_n_r)
             for n_w in nodes_w:
-                node_n_w = get_node_name(irbloc.label, 1, n_w)
+                node_n_w = get_node_name(irblock.label, 1, n_w)
                 out_nodes[n_w] = node_n_w
 
                 flow_graph.add_node(node_n_w)
                 flow_graph.add_uniq_edge(node_n_r, node_n_w)
 
-    irbloc.in_nodes = in_nodes
-    irbloc.out_nodes = out_nodes
+    irblock.in_nodes = in_nodes
+    irblock.out_nodes = out_nodes
 
 
 def node2str(self, node):
@@ -110,31 +110,31 @@ def node2str(self, node):
     return out
 
 
-def gen_bloc_data_flow_graph(ir_arch, ad, block_flow_cb):
-    for irbloc in ir_arch.blocs.values():
-        print irbloc
+def gen_block_data_flow_graph(ir_arch, ad, block_flow_cb):
+    for irblock in ir_arch.blocks.values():
+        print irblock
 
     ir_arch.dead_simp()
 
-    irbloc_0 = None
-    for irbloc in ir_arch.blocs.values():
-        if irbloc.label.offset == ad:
-            irbloc_0 = irbloc
+    irblock_0 = None
+    for irblock in ir_arch.blocks.values():
+        if irblock.label.offset == ad:
+            irblock_0 = irblock
             break
-    assert(irbloc_0 is not None)
+    assert(irblock_0 is not None)
     flow_graph = DiGraph()
     flow_graph.node2str = lambda n: node2str(flow_graph, n)
 
-    for irbloc in ir_arch.blocs.values():
-        block_flow_cb(ir_arch, flow_graph, irbloc)
+    for irblock in ir_arch.blocks.values():
+        block_flow_cb(ir_arch, flow_graph, irblock)
 
-    for irbloc in ir_arch.blocs.values():
-        print irbloc
-        print 'IN', [str(x) for x in irbloc.in_nodes]
-        print 'OUT', [str(x) for x in irbloc.out_nodes]
+    for irblock in ir_arch.blocks.values():
+        print irblock
+        print 'IN', [str(x) for x in irblock.in_nodes]
+        print 'OUT', [str(x) for x in irblock.out_nodes]
 
-    print '*' * 20, 'interbloc', '*' * 20
-    inter_bloc_flow(ir_arch, flow_graph, irbloc_0.label)
+    print '*' * 20, 'interblock', '*' * 20
+    inter_bloc_flow(ir_arch, flow_graph, irblock_0.label)
 
     # from graph_qt import graph_qt
     # graph_qt(flow_graph)
@@ -154,13 +154,13 @@ print 'ok'
 print 'generating dataflow graph for:'
 ir_arch = ir_a_x86_32(mdis.symbol_pool)
 
-blocs = ab
-for bloc in blocs:
-    print bloc
-    ir_arch.add_bloc(bloc)
-for irbloc in ir_arch.blocs.values():
-    print irbloc
-    if irbloc.label.offset != 0:
+blocks = ab
+for block in blocks:
+    print block
+    ir_arch.add_bloc(block)
+for irblock in ir_arch.blocks.values():
+    print irblock
+    if irblock.label.offset != 0:
         continue
 
 
@@ -169,7 +169,7 @@ if args.symb:
 else:
     block_flow_cb = intra_bloc_flow_raw
 
-gen_bloc_data_flow_graph(ir_arch, ad, block_flow_cb)
+gen_block_data_flow_graph(ir_arch, ad, block_flow_cb)
 
 print '*' * 40
 print """
diff --git a/example/expression/solve_condition_stp.py b/example/expression/solve_condition_stp.py
index 2a3b42fd..03d652cf 100644
--- a/example/expression/solve_condition_stp.py
+++ b/example/expression/solve_condition_stp.py
@@ -9,9 +9,9 @@ from miasm2.arch.x86.arch import *
 from miasm2.arch.x86.regs import *
 from miasm2.arch.x86.sem import *
 from miasm2.core.bin_stream import bin_stream_str
-from miasm2.core import asmbloc
+from miasm2.core import asmblock
 from miasm2.expression.expression import get_rw
-from miasm2.ir.symbexec import symbexec
+from miasm2.ir.symbexec import SymbolicExecutionEngine
 from miasm2.expression.simplifications import expr_simp
 from miasm2.expression import stp
 from miasm2.core import parse_asm
@@ -35,18 +35,18 @@ if not args:
     sys.exit(0)
 
 
-def get_bloc(ir_arch, mdis, ad):
-    if isinstance(ad, asmbloc.asm_label):
+def get_block(ir_arch, mdis, ad):
+    if isinstance(ad, asmblock.AsmLabel):
         l = ad
     else:
         l = mdis.symbol_pool.getby_offset_create(ad)
-    if not l in ir_arch.blocs:
+    if not l in ir_arch.blocks:
         ad = l.offset
         b = mdis.dis_bloc(ad)
         ir_arch.add_bloc(b)
     b = ir_arch.get_bloc(l)
     if b is None:
-        raise LookupError('no bloc found at that address: %s' % l)
+        raise LookupError('no block found at that address: %s' % l)
     return b
 
 
@@ -58,15 +58,15 @@ def emul_symb(ir_arch, mdis, states_todo, states_done):
             print 'skip', ad
             continue
         states_done.add((ad, symbols, conds))
-        sb = symbexec(ir_arch, {})
+        sb = SymbolicExecutionEngine(ir_arch, {})
         sb.symbols = symbols.copy()
         if ir_arch.pc in sb.symbols:
             del(sb.symbols[ir_arch.pc])
-        b = get_bloc(ir_arch, mdis, ad)
+        b = get_block(ir_arch, mdis, ad)
 
-        print 'run bloc'
+        print 'run block'
         print b
-        # print blocs[ad]
+        # print blocks[ad]
         ad = sb.emulbloc(b)
         print 'final state'
         sb.dump_id()
@@ -87,8 +87,8 @@ def emul_symb(ir_arch, mdis, states_todo, states_done):
             p2[ad.cond] = ExprInt(1, ad.cond.size)
             ad1 = expr_simp(sb.eval_expr(ad.replace_expr(c1), {}))
             ad2 = expr_simp(sb.eval_expr(ad.replace_expr(c2), {}))
-            if not (isinstance(ad1, ExprInt) or (isinstance(ad1, ExprId) and isinstance(ad1.name, asmbloc.asm_label)) and
-                    isinstance(ad2, ExprInt) or (isinstance(ad2, ExprId) and isinstance(ad2.name, asmbloc.asm_label))):
+            if not (isinstance(ad1, ExprInt) or (isinstance(ad1, ExprId) and isinstance(ad1.name, asmblock.AsmLabel)) and
+                    isinstance(ad2, ExprInt) or (isinstance(ad2, ExprId) and isinstance(ad2.name, asmblock.AsmLabel))):
                 print str(ad1), str(ad2)
                 raise ValueError("zarb condition")
             conds1 = list(conds) + c1.items()
@@ -106,7 +106,7 @@ def emul_symb(ir_arch, mdis, states_todo, states_done):
         elif isinstance(ad, ExprInt):
             ad = int(ad.arg)
             states_todo.add((ad, sb.symbols.copy(), tuple(conds)))
-        elif isinstance(ad, ExprId) and isinstance(ad.name, asmbloc.asm_label):
+        elif isinstance(ad, ExprId) and isinstance(ad.name, asmblock.AsmLabel):
             if isinstance(ad, ExprId):
                 ad = ad.name
             states_todo.add((ad, sb.symbols.copy(), tuple(conds)))
@@ -159,33 +159,33 @@ if __name__ == '__main__':
 
     ir_arch = ir_x86_32(mdis.symbol_pool)
 
-    sb = symbexec(ir_arch, symbols_init)
+    sb = SymbolicExecutionEngine(ir_arch, symbols_init)
 
-    blocs, symbol_pool = parse_asm.parse_txt(mn_x86, 32, '''
+    blocks, symbol_pool = parse_asm.parse_txt(mn_x86, 32, '''
     PUSH argv
     PUSH argc
     PUSH ret_addr
     ''')
 
 
-    b = list(blocs)[0]
+    b = list(blocks)[0]
     print b
     # add fake address and len to parsed instructions
-    for i, l in enumerate(b.lines):
-        l.offset, l.l = i, 1
+    for i, line in enumerate(b.lines):
+        line.offset, line.l = i, 1
     ir_arch.add_bloc(b)
-    irb = get_bloc(ir_arch, mdis, 0)
+    irb = get_block(ir_arch, mdis, 0)
     sb.emulbloc(irb)
     sb.dump_mem()
 
-    # reset ir_arch blocs
-    ir_arch.blocs = {}
+    # reset ir_arch blocks
+    ir_arch.blocks = {}
 
     states_todo = set()
     states_done = set()
     states_todo.add((uint32(ad), sb.symbols, ()))
 
-    # emul blocs, propagate states
+    # emul blocks, propagate states
     emul_symb(ir_arch, mdis, states_todo, states_done)
 
     all_info = []
@@ -201,7 +201,7 @@ if __name__ == '__main__':
 
     all_cases = set()
 
-    sb = symbexec(ir_arch, symbols_init)
+    sb = SymbolicExecutionEngine(ir_arch, symbols_init)
     for ad, reqs_cond in all_info:
         all_ids = set()
         for k, v in reqs_cond:
diff --git a/example/ida/depgraph.py b/example/ida/depgraph.py
index 002075ee..faec2857 100644
--- a/example/ida/depgraph.py
+++ b/example/ida/depgraph.py
@@ -2,7 +2,7 @@ import os
 import tempfile
 
 from miasm2.core.bin_stream_ida import bin_stream_ida
-from miasm2.core.asmbloc import *
+from miasm2.core.asmblock import *
 from miasm2.expression import expression as m2_expr
 
 from miasm2.expression.simplifications import expr_simp
@@ -21,12 +21,12 @@ class depGraphSettingsForm(Form):
         self.stk_unalias_force = False
 
         self.address = ScreenEA()
-        cur_bloc = list(ira.getby_offset(self.address))[0]
-        for line_nb, l in enumerate(cur_bloc.lines):
+        cur_block = list(ira.getby_offset(self.address))[0]
+        for line_nb, l in enumerate(cur_block.lines):
             if l.offset == self.address:
                 break
-        cur_label = str(cur_bloc.label)
-        labels = sorted(map(str, ira.blocs.keys()))
+        cur_label = str(cur_block.label)
+        labels = sorted(map(str, ira.blocks.keys()))
         regs = sorted(ir_arch.arch.regs.all_regs_ids_byname.keys())
         regs += self.stk_args.keys()
         reg_default = regs[0]
@@ -82,7 +82,7 @@ Method to use:
     @property
     def label(self):
         value = self.cbBBL.value
-        for real_label in self.ira.blocs:
+        for real_label in self.ira.blocks:
             if str(real_label) == value:
                 return real_label
         raise ValueError("Bad label")
@@ -96,13 +96,13 @@ Method to use:
         elif mode == 1:
             return value + 1
         else:
-            return len(self.ira.blocs[self.label].irs)
+            return len(self.ira.blocks[self.label].irs)
 
     @property
     def elements(self):
         value = self.cbReg.value
         if value in self.stk_args:
-            line = self.ira.blocs[self.label].lines[self.line_nb]
+            line = self.ira.blocks[self.label].lines[self.line_nb]
             arg_num = self.stk_args[value]
             stk_high = m2_expr.ExprInt(GetSpd(line.offset), ir_arch.sp.size)
             stk_off = m2_expr.ExprInt(self.ira.sp.size/8 * arg_num, ir_arch.sp.size)
@@ -151,11 +151,11 @@ for ad, name in Names():
 # Get the current function
 addr = ScreenEA()
 func = idaapi.get_func(addr)
-blocs = mdis.dis_multibloc(func.startEA)
+blocks = mdis.dis_multibloc(func.startEA)
 
 # Generate IR
-for bloc in blocs:
-    ir_arch.add_bloc(bloc)
+for block in blocks:
+    ir_arch.add_bloc(block)
 
 # Get settings
 settings = depGraphSettingsForm(ir_arch)
@@ -163,7 +163,7 @@ settings.Execute()
 
 label, elements, line_nb = settings.label, settings.elements, settings.line_nb
 # Simplify affectations
-for irb in ir_arch.blocs.values():
+for irb in ir_arch.blocks.values():
     fix_stack = irb.label.offset is not None and settings.unalias_stack
     for i, assignblk in enumerate(irb.irs):
         if fix_stack:
@@ -215,7 +215,7 @@ def treat_element():
 
     for node in graph.relevant_nodes:
         try:
-            offset = ir_arch.blocs[node.label].lines[node.line_nb].offset
+            offset = ir_arch.blocks[node.label].lines[node.line_nb].offset
         except IndexError:
             print "Unable to highlight %s" % node
             continue
diff --git a/example/ida/graph_ir.py b/example/ida/graph_ir.py
index 188c8fa6..3aac0281 100644
--- a/example/ida/graph_ir.py
+++ b/example/ida/graph_ir.py
@@ -5,7 +5,7 @@ import tempfile
 from idaapi import GraphViewer
 
 from miasm2.core.bin_stream_ida import bin_stream_ida
-from miasm2.core.asmbloc import *
+from miasm2.core.asmblock import *
 from miasm2.expression.simplifications import expr_simp
 from miasm2.expression.expression import *
 from miasm2.analysis.data_analysis import inter_bloc_flow, \
@@ -48,11 +48,11 @@ class GraphMiasmIR(GraphViewer):
         print 'refresh'
         self.Clear()
         addr_id = {}
-        for irbloc in self.ir_arch.blocs.values():
+        for irbloc in self.ir_arch.blocks.values():
             id_irbloc = self.AddNode(color_irbloc(irbloc))
             addr_id[irbloc] = id_irbloc
 
-        for irbloc in self.ir_arch.blocs.values():
+        for irbloc in self.ir_arch.blocks.values():
             if not irbloc:
                 continue
             dst = ir_arch.dst_trackback(irbloc)
@@ -61,9 +61,9 @@ class GraphMiasmIR(GraphViewer):
                     continue
 
                 d = d.name
-                if not d in self.ir_arch.blocs:
+                if not d in self.ir_arch.blocks:
                     continue
-                b = self.ir_arch.blocs[d]
+                b = self.ir_arch.blocks[d]
                 node1 = addr_id[irbloc]
                 node2 = addr_id[b]
                 self.AddEdge(node1, node2)
@@ -125,15 +125,15 @@ open('asm_flow.dot', 'w').write(ab.dot())
 
 print "generating IR... %x" % ad
 
-for b in ab:
+for block in ab:
     print 'ADD'
-    print b
-    ir_arch.add_bloc(b)
+    print block
+    ir_arch.add_bloc(block)
 
 
 print "IR ok... %x" % ad
 
-for irb in ir_arch.blocs.values():
+for irb in ir_arch.blocks.values():
     for assignblk in irb.irs:
         for dst, src in assignblk.items():
             del(assignblk[dst])
@@ -201,7 +201,7 @@ def gen_bloc_data_flow_graph(ir_arch, in_str, ad):  # arch, attrib, pool_bin, bl
     # ir_arch.dead_simp()
 
     irbloc_0 = None
-    for irbloc in ir_arch.blocs.values():
+    for irbloc in ir_arch.blocks.values():
         if irbloc.label.offset == ad:
             irbloc_0 = irbloc
             break
@@ -212,11 +212,11 @@ def gen_bloc_data_flow_graph(ir_arch, in_str, ad):  # arch, attrib, pool_bin, bl
 
     bloc2w = {}
 
-    for irbloc in ir_arch.blocs.values():
+    for irbloc in ir_arch.blocks.values():
         intra_bloc_flow_symbexec(ir_arch, flow_graph, irbloc)
         # intra_bloc_flow_symb(ir_arch, flow_graph, irbloc)
 
-    for irbloc in ir_arch.blocs.values():
+    for irbloc in ir_arch.blocks.values():
         print irbloc
         print 'IN', [str(x) for x in irbloc.in_nodes]
         print 'OUT', [str(x) for x in irbloc.out_nodes]
diff --git a/example/ida/symbol_exec.py b/example/ida/symbol_exec.py
index 751f9a58..70e1cfc1 100644
--- a/example/ida/symbol_exec.py
+++ b/example/ida/symbol_exec.py
@@ -75,7 +75,7 @@ class symbolicexec_t(idaapi.simplecustviewer_t):
 
 
 def symbolic_exec():
-    from miasm2.ir.symbexec import symbexec
+    from miasm2.ir.symbexec import SymbolicExecutionEngine
     from miasm2.core.bin_stream_ida import bin_stream_ida
 
     from utils import guess_machine
@@ -87,13 +87,13 @@ def symbolic_exec():
     start, end = SelStart(), SelEnd()
 
     mdis.dont_dis = [end]
-    blocs = mdis.dis_multibloc(start)
+    blocks = mdis.dis_multibloc(start)
     ira = machine.ira()
-    for bloc in blocs:
-        ira.add_bloc(bloc)
+    for block in blocks:
+        ira.add_bloc(block)
 
     print "Run symbolic execution..."
-    sb = symbexec(ira, machine.mn.regs.regs_init)
+    sb = SymbolicExecutionEngine(ira, machine.mn.regs.regs_init)
     sb.emul_ir_blocks(start)
 
     modified = {}
diff --git a/example/symbol_exec/single_instr.py b/example/symbol_exec/single_instr.py
index 365a17ec..3e418e5a 100644
--- a/example/symbol_exec/single_instr.py
+++ b/example/symbol_exec/single_instr.py
@@ -1,6 +1,6 @@
 # Minimalist Symbol Exec example
 from miasm2.core.bin_stream import bin_stream_str
-from miasm2.ir.symbexec import symbexec
+from miasm2.ir.symbexec import SymbolicExecutionEngine
 from miasm2.analysis.machine import Machine
 
 START_ADDR = 0
@@ -23,7 +23,7 @@ ira.add_bloc(asm_block)
 # Instanciate a Symbolic Execution engine with default value for registers
 ## EAX = EAX_init, ...
 symbols_init = ira.arch.regs.regs_init
-symb = symbexec(ira, symbols_init)
+symb = SymbolicExecutionEngine(ira, symbols_init)
 
 # Emulate one IR basic block
 ## Emulation of several basic blocks can be done through .emul_ir_blocks