Changeset 363 for proto/Compiler


Ignore:
Timestamp:
Feb 12, 2010, 2:31:54 PM (9 years ago)
Author:
eamiri
Message:

Function inlining added.
Parabix2 can be compiled with some modifications

Location:
proto/Compiler
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • proto/Compiler/basic_block.py

    r344 r363  
    6565       e1 = genobj.expr_string_to_variable(expr2simd(genobj, expr.operand1))
    6666       e2 = genobj.expr_string_to_variable(expr2simd(genobj, expr.operand2))
    67        brw = "brw%i"%BasicBlock.brw_counter
     67       brw = "carry_brw%i"%BasicBlock.brw_counter
    6868       return bitexpr.Sub(e1, e2, brw)
    6969    elif isinstance(expr, bitexpr.Andc):
     
    252252
    253253def simplify(code, previous):
    254     for i in previous:
    255         print i, previous[i].varname
     254    #for i in previous:
     255        #print i, previous[i].varname
    256256    changed = True
    257257    while changed:
  • proto/Compiler/bitexpr.py

    r344 r363  
    102102    def __init__(self, expr1, expr2, brw = None):
    103103        self.op_C = "sbb128"
    104         self.brw = None
     104        self.brw = brw
    105105        BitExpr.__init__(self, expr1, expr2, "Sub")
    106106    def show(self): return 'Sub(%s, %s)' % (self.operand1.show(), self.operand2.show())
  • proto/Compiler/bitstream_compiler.py

    r354 r363  
    3535    def generate_code(self, s):
    3636        s = ast.parse(s)
    37         c, s = py2bitexpr.do_inlining(s)
    38        
    3937        #return s
    40         #s = s.body[0].body
    41 
    42         #FUNCTION INLINING
    43 
     38        livelist,s = py2bitexpr.get_lives(s)
     39        livelist.append('error_mask')
     40        s = py2bitexpr.do_inlining(s)
     41        #return s
    4442        s = py2bitexpr.translate_stmts(s)
    45 
    4643        st = py2bitexpr.gen_sym_table(s)
    47 
    4844        s=py2bitexpr.make_SSA(s, st)
    49 
    5045        s = py2bitexpr.partition2bb(s, )
    51 
    5246        s = py2bitexpr.apply_all_opt(s)
    5347        s = py2bitexpr.normalize(s)
    5448        py2bitexpr.simplify_tree(s)
     49        all_lives, s = py2bitexpr.eliminate_dead_code(s, set(livelist))
     50        s = py2bitexpr.factor_out(s)
     51        s, livelist = py2bitexpr.process_while_loops(s)
    5552
    56         livelist = ['error_mask', 'u16','u8_pre', 'u8_butlast', 'u8_last']
     53        declarations = py2bitexpr.gen_declarations(s)
     54        templ = self.read_template()
    5755
    58         all_lives, s = py2bitexpr.eliminate_dead_code(s, set(livelist))
    59 
    60         s=py2bitexpr.factor_out(s)
    61 
    62         s, livelist = py2bitexpr.process_while_loops(s)
    63         declarations = py2bitexpr.gen_declarations(s)
    64 
    65 
    66         #print py2bitexpr.print_prog(s)
    67         templ = self.read_template()
    6856        templ = self.output(declarations, py2bitexpr.print_prog(s), templ)
    6957        self.write_final_code(templ)
     
    7260###############################################################
    7361
    74 if __name__ == '__main__':
     62if __name__ == '__main__' or True:
    7563        mycode = ""
    7664        if len(sys.argv) < 2:
    7765            print "Usage: python bitstream_compiler.py <input file> [output file]"
    78             exit()
    79        
    80         inp_file = open(sys.argv[1])
     66            #exit()
     67
     68        inp_file = open("parabix2.py")
     69        #inp_file = open(sys.argv[1])
    8170        for line in inp_file:
    8271            mycode += line
  • proto/Compiler/py2bitexpr.py

    r353 r363  
    1515import ast, bitexpr, copy, basic_block
    1616
     17type_dict = {}
     18structs = {}
     19arrays = {}
     20
    1721AllOne = 'AllOne'
    1822AllZero = 'AllZero'
    1923
     24STRUCT_TEMPLATE="struct_%s_%s_"
     25ARRAY_TEMPLATE="array_%s_%s_"
     26
     27
    2028class PyBitError(Exception):
    2129        pass
     30
     31#############################################################################################
     32## Extracting list of live variables
     33#############################################################################################
     34def get_lives(s):
     35    for item in s.body:
     36        if isinstance(item, ast.FunctionDef):
     37            if (item.name =="main"):
     38                assert (isinstance(item.body[-1], ast.Return))
     39                ret = item.body[-1].value
     40                if isinstance(ret, ast.Tuple):
     41                    del item.body[-1]
     42                    return [translate_var(x) for x in ret.elts],s
     43                else:
     44                    assert(isinstance(ret, ast.Name))
     45                    del item.body[-1]
     46                    return [translate_var(ret)],s
    2247
    2348#############################################################################################
     
    2651TEMP_VAR_TEMPLATE = "InlineTemp%i"
    2752
    28 
    29 def replace_in_exp(exp, translation):
     53def get_var_name(var):
     54    var_name = translate_var(var)
     55    if isinstance(var, ast.Name):
     56        type_name = "simple"
     57        extra = None
     58    if isinstance(var, ast.Attribute):
     59        type_name = "structure"
     60        extra = var.attr
     61    if isinstance(var, ast.Index):
     62        type_name = "array"
     63        extra = translate_index(v.slice.value)
     64
     65    return type_name, var_name, extra
     66
     67def register_var(final_name, original_name, type_name, extra):
     68    pass
     69    #type_dict[original_name] = type_name
     70    #type_dict[final_name] = type_name
     71
     72def collect_functions(module):
     73    imps = []
     74    to_remove = []
     75    for index, item in enumerate(module.body):
     76        if isinstance(item, ast.Import):
     77            imps.append(item)
     78            to_remove.append(index)
     79
     80    for n in reversed(to_remove):
     81        del module.body[n]
     82
     83    for imp in imps:
     84        for mod in imp.names:
     85            mod_file = open(mod.name + '.py')
     86            mod_code = ""
     87            for line in mod_file:
     88                mod_code += line
     89            mod_file.close()
     90            mod_parsed = ast.parse(mod_code)
     91            for item in mod_parsed.body:
     92                #assert (isinstance(item, ast.FunctionDef))
     93                if isinstance(item, ast.FunctionDef):
     94                    item.name = translate_var(ast.Attribute(value=ast.Name(id=mod.name), attr=item.name))
     95            module.body += mod_parsed.body
     96    return module
     97
     98def collect_names(body):
     99    names = {}
     100    for index, item in enumerate(body):
     101        if isinstance(item, ast.FunctionDef):
     102            names[item.name] = index
     103
     104    return names
     105
     106def modify_name(var, args, cargs, unique_prefix):
     107    carg_names = [x.id for x in cargs]
     108    arg_names = [translate_var(x) for x in args]
     109
     110    varname = translate_var(var)
     111    if isinstance(var, ast.Name):
     112        if varname in carg_names:
     113            return ast.Name(id=arg_names[carg_names.index(varname)])
     114        return ast.Name(id=unique_prefix+varname)
     115    if isinstance(var, ast.Attribute) or isinstance(var, ast.Subscript):
     116        if var.value.id in carg_names:
     117            var.value.id = arg_names[carg_names.index(var.value.id)]
     118            return ast.Name(id=translate_var(var))
     119        return ast.Name(id=unique_prefix+translate_var(var))
     120
     121def replace_in_exp(exp, args, cargs, unique_prefix):
    30122    if isinstance(exp, ast.BinOp):
    31         exp.left = replace_in_exp(exp.left, translation)
    32         exp.right = replace_in_exp(exp.right, translation)
     123        exp.left = replace_in_exp(exp.left, args, cargs, unique_prefix)
     124        exp.right = replace_in_exp(exp.right, args, cargs, unique_prefix)
    33125    elif isinstance(exp, ast.UnaryOp):
    34         exp.operand = replace_in_exp(ast.UnaryOp)
     126        exp.operand = replace_in_exp(exp.operand, args, cargs, unique_prefix)
    35127    elif isinstance(exp, ast.Name):
    36         exp.id = translation.setdefault(exp.id, exp.id)
    37     elif isinstance(exp.ast.Attribute):
    38         exp.value.id = translation.setdefault(exp.value.id, exp.value.id)
     128        exp = modify_name(exp, args, cargs, unique_prefix)
     129    elif isinstance(exp, ast.Attribute):
     130        exp = modify_name(exp, args, cargs, unique_prefix)
    39131    elif isinstance(exp, ast.Subscript):
    40         exp.value.id = translation.setdefault(exp.value.id, exp.value.id)
     132        exp = modify_name(exp, args, cargs, unique_prefix)
     133    elif isinstance(exp, ast.Call):
     134        for index, item in enumerate(exp.args):
     135            exp.args[index] = replace_in_exp(item, args, cargs, unique_prefix)
     136    elif isinstance(exp, ast.Tuple):
     137        for index, elt in enumerate(exp.elts):
     138            exp.elts[index] = replace_in_exp(elt, args, cargs, unique_prefix)
     139    #elif isinstance(exp,)
    41140    else:
     141        #print exp
    42142        assert(1==0)
    43143
    44144    return exp
    45145
    46 def get_all_calls(main):
     146def get_all_calls(main, all_func):
    47147    call_list = []
    48148    for index, loc in enumerate(main.body):
    49149        if isinstance(loc, ast.Assign) and isinstance(loc.value, ast.Call):
    50             call_list.append(index)
     150                func_name = translate_var(loc.value.func)
     151                if func_name in all_func:
     152                    call_list.append(index)
    51153        if isinstance(loc, ast.AugAssign) and isinstance(loc.value, ast.Call):
    52             call_list.append(index)
     154                func_name = translate_var(loc.value.func)
     155                if func_name in all_func:
     156                    call_list.append(index)
    53157    return call_list
    54158
    55 
    56 def prepare_code(callee, args, unique_num):
    57     #check number of args matches
     159def update_var_names(callee, args):
     160    unique_prefix = '_'+callee.name.replace('.', '_')+'_'
     161   
     162
    58163    assert (len(args)==len(callee.args.args))
    59     translation = {}
    60     for index in range(len(args)):
    61         translation[translate_var(callee.args.args[index])] = translate_var(args[index])
    62 
    63     #print translation
    64     rets = {}
     164
    65165    for index, loc in enumerate(callee.body):
    66166        if isinstance(loc, ast.Assign):
    67167            for index, var in enumerate(loc.targets):
    68                 var = ast.Name(id=translation.setdefault(translate_var(var), translate_var(var)))
    69             loc.value = replace_in_exp(loc.value, translation)
     168                loc.targets[index] = modify_name(var, args, callee.args.args, unique_prefix)
     169            loc.value = replace_in_exp(loc.value, args, callee.args.args, unique_prefix)
    70170        elif isinstance(loc, ast.AugAssign):
    71             loc.target = ast.Name(id=translation.setdefault(translate_var(loc.target), translate_var(loc.target)))
    72             loc.value = replace_in_exp(loc.value, translation)
     171            loc.target = modify_name(loc.target, args, callee.args.args, unique_prefix)
     172            loc.value = replace_in_exp(loc.value, args, callee.args.args, unique_prefix)
    73173        elif isinstance(loc, ast.Return):
    74             rets[index] = ast.Assign([ast.Name(id=TEMP_VAR_TEMPLATE%unique_num)], loc.value)
    75 
     174            pass
     175            #loc.value = replace_in_exp(loc.value, args, callee.args.args, unique_prefix)
    76176        else:
    77             assert(1==0)
    78 
    79         for key in rets:
    80             callee.body[key] = rets[index]
    81 
     177            assert (1==0)
     178
     179    return callee, unique_prefix
     180
     181def remove_unsupported_code(callee):
     182    to_remove = []
     183
     184    for index, loc in enumerate(callee.body):
     185        if not (isinstance(loc, ast.Assign) or isinstance(loc, ast.AugAssign) or isinstance(loc, ast.Return)):
     186            to_remove.append(index)
     187    to_remove.sort(reverse=True)
     188    for line_no in to_remove:
     189        del callee.body[line_no]
    82190    return callee
    83191
    84 def finalize(main, inline_code, call_list):
    85     for list_index, main_index in enumerate(reversed(call_list)):
    86         main.body[main_index].value = ast.Name(id=TEMP_VAR_TEMPLATE%main_index)
    87         main.body = main.body[:main_index]+inline_code[-list_index-1].body+main.body[main_index:]
     192
     193def remove_return_stmt(callee, unique_num):
     194    rets = {}
     195    for index, loc in enumerate(callee.body):
     196        if isinstance(loc, ast.Return):
     197            if isinstance(loc.value, ast.Tuple):
     198                all_assignments = []
     199                for ind, item in enumerate(loc.value.elts):
     200                    #print item.id
     201                    next = ast.Assign([ast.Name(id=TEMP_VAR_TEMPLATE%unique_num+"_"+str(ind))], item )
     202                    all_assignments.append(next)
     203                rets[index] = all_assignments
     204            else:
     205                rets[index] = [ast.Assign([ast.Name(id=(TEMP_VAR_TEMPLATE+"_0")%unique_num)], loc.value)]
     206
     207    ret_keys = [x for x in rets]
     208    ret_keys.sort(reverse=True)
     209    for key in ret_keys:
     210        callee.body = callee.body[:key]+rets[key]+callee.body[key+1:]
     211    return callee
     212
     213def get_name(loc, index):
     214    if isinstance(loc.value, ast.Tuple):
     215        return translate_var(loc.value.elts[index])
     216    elif index == 0:
     217        return translate_var(loc.value)
     218    else:
     219        assert(1==0)
     220
     221def modify_assignments_in_caller(main, line_no, return_list, prefix, callee):
     222    #print "*********", prefix, "************"
     223    if isinstance(main.body[line_no].targets[0], ast.Tuple):
     224        all_vars = main.body[line_no].targets[0].elts
     225    else:
     226        all_vars = main.body[line_no].targets
     227    new_code = []
     228
     229    if isinstance(callee.body[-1].value, ast.Tuple):
     230        return_vars = [translate_var(x) for x in callee.body[-1].value.elts]
     231    else:
     232        return_vars = [translate_var(callee.body[-1].value)]
     233
     234    for index, item in enumerate(all_vars):
     235        actual_name = translate_var(item)
     236        if actual_name in [translate_var(x) for x in main.body[line_no].value.args]:
     237            continue
     238        temp_name = return_vars[index]
     239
     240        if temp_name in [translate_var(x) for x in callee.args.args]:
     241            second_index = [translate_var(x) for x in callee.args.args].index(temp_name)
     242            final_name = translate_var(main.body[line_no].value.args[second_index])
     243            #print "1111"
     244        else:
     245            final_name = prefix+temp_name
     246            #print "2222", final_name
     247
     248        if return_list[temp_name][0] == "struct":
     249            my_template = STRUCT_TEMPLATE
     250        elif return_list[temp_name][0] == "array":
     251            my_template = ARRAY_TEMPLATE
     252 
     253        if return_list[temp_name][0] == "bitblock":
     254            new_code.append(ast.Assign( [ast.Name(id=item.id)] , ast.Name(id=final_name) ))
     255        else:
     256            for elem in return_list[temp_name][1]:
     257                #print final_name, elem
     258                new_code.append(ast.Assign([ast.Name(id=my_template%(item.id, elem))], ast.Name(id=prefix+my_template%(temp_name, elem))))
     259    main.body = main.body[:line_no]+new_code+main.body[line_no+1:]
    88260    return main
     261
     262def get_return_list(callee):
     263    ret_list = []
     264    loc = callee.body[-1]
     265    if isinstance(loc, ast.Return):
     266        if isinstance(loc.value, ast.Tuple):
     267            all_rets = loc.value.elts
     268        else:
     269            all_rets = [loc.value]
     270        for item in all_rets:
     271            if isinstance(item, ast.Attribute) or isinstance(item, ast.Subscript):
     272                ret_list.append(item.value.id)
     273            if isinstance(item, ast.Name):
     274                ret_list.append(item.id)
     275    return ret_list
     276
     277def get_updated(loc):
     278    if isinstance(loc, ast.AugAssign):
     279        updated = [loc.target]
     280    elif isinstance(loc, ast.Assign):
     281        if isinstance(loc.targets[0], ast.Tuple):
     282            updated = loc.targets[0].elts
     283        else:
     284            updated = loc.targets
     285    else:
     286        updated = []
     287    return updated
     288
     289def get_update_details(callee, ret_list):
     290    field_info = {}
     291    for item in ret_list:
     292        field_info[item] = ['simple', set([])]
     293    for loc in callee.body:
     294        updated = get_updated(loc)
     295        for item in updated:
     296            type, name, extra = parse_var(translate_var(item, True))
     297            if name in field_info:
     298                field_info[name][0] = type
     299                if type=='struct':
     300                    field_info[name][1].add(extra)
     301                if type == 'array':
     302                    field_info[name][1].add(extra)
     303    return field_info
     304
     305def process_return(callee):
     306    if not isinstance(callee.body[-1], ast.Return):
     307        return {}
     308    ret_list = get_return_list(callee)
     309    field_info = get_update_details(callee, ret_list)
     310    return field_info
     311
     312def fix_return_list(callee, args):
     313    if isinstance(callee.body[-1].value, ast.Tuple):
     314        all_ret = [translate_var(x, True) for x in callee.body[-1].value.elts]
     315        tuple_return = True
     316    else:
     317        all_ret = [translate_var(callee.body[-1].value, True)]
     318        tuple_return = False
    89319   
     320    myargs = [translate_var(x, True) for x in callee.args.args]
     321    caller_args = [translate_var(x, True) for x in args]
     322   
     323    to_remove = []
     324    for index, item in enumerate(all_ret):
     325        if item in myargs:
     326            arg_index = myargs.index(item)
     327            if caller_args[arg_index] == item:
     328                to_remove.append(index)
     329   
     330    if len(to_remove) == 0:
     331        return callee
     332   
     333    if tuple_return:
     334        to_remove.sort(reverse = True)
     335        for rem in to_remove:
     336            del callee.body[-1].value.elts[rem]   
     337    else:
     338        del callee.body[-1]
     339        return callee
     340
    90341def do_inlining(module):
    91     func_dict = {}
    92     for index, func in enumerate(module.body):
    93         func_dict[func.name] = index
     342    module = collect_functions(module)
     343    func_dict = collect_names(module.body)
    94344
    95345    main = module.body[func_dict["main"]]
    96     call_list = get_all_calls(main)
    97 
     346    call_list = get_all_calls(main, [func for func in func_dict])
    98347    inline_code = []
     348    call_list.sort(reverse=True)
    99349    for line_no in call_list:
    100         callee = copy.deepcopy(module.body[func_dict[main.body[line_no].value.func.id]])
     350        callee = copy.deepcopy(module.body[func_dict[translate_var(main.body[line_no].value.func)]])
    101351        args = main.body[line_no].value.args
    102         inline_code.append(prepare_code(callee, args, line_no))
    103     main = finalize(main, inline_code, call_list)
    104 
    105     return call_list, module.body[func_dict["main"]].body
     352        callee = remove_unsupported_code(callee)
     353        #callee = fix_return_list(callee, args)
     354        return_list = process_return(callee)
     355        callee, prefix = update_var_names(callee, args)
     356        #callee = remove_return_stmt(callee, line_no)
     357
     358        main = modify_assignments_in_caller(main, line_no, return_list, prefix, callee)
     359
     360        if isinstance(callee.body[-1], ast.Return):
     361            del callee.body[-1]
     362        main.body = main.body[:line_no]+callee.body+main.body[line_no:]
     363    return module.body[func_dict["main"]].body
    106364
    107365#############################################################################################
     
    132390                if ast_expr.id=="allone":
    133391                        return bitexpr.TrueLiteral()
    134                 return bitexpr.Var(ast_expr.id)
     392                return bitexpr.Var(translate_var(ast_expr))
    135393        elif isinstance(ast_expr, ast.Num):
    136394                assert(ast_expr.n == 0)
    137                 return bitexpr.FalseLiteral()
     395                return bitexpr.FalseLiteral()       
    138396        elif isinstance(ast_expr, ast.Attribute):
    139397                if isinstance(ast_expr.value, ast.Name):
     398                        return bitexpr.Var(translate_var(ast_expr))
    140399                        return bitexpr.Var("%s.%s" % (ast_expr.value.id, ast_expr.attr))
    141400                else: raise PyBitError("Illegal attribute %s\n" % ast.dump(ast_expr))
    142401        elif isinstance(ast_expr, ast.Subscript):
    143                 if isinstance(ast_expr.value, ast.Name) and isinstance(ast_expr.slice.value, ast.Num):
     402                if isinstance(ast_expr.value, ast.Name) and isinstance(ast_expr.slice, ast.Index):
     403                        return bitexpr.Var(translate_var(ast_expr))
    144404                        return bitexpr.Var("%s[%s]" % (ast_expr.value.id, translate_index(ast_expr.slice.value)))
    145                 elif isinstance(ast_expr.value, ast.Name) and isinstance(ast_expr.slice.value, ast.Str):
    146                         return bitexpr.Var("%s.%s" % (ast_expr.value.id, translate_index(ast_expr.slice.value)))
    147405                else: raise PyBitError("Illegal array %s\n" % ast.dump(ast_expr))
    148406        elif isinstance(ast_expr, ast.UnaryOp):
     
    174432                        e1 = translate(ast_expr.args[1])
    175433                        return bitexpr.make_and(bitexpr.make_add(e0, e1), bitexpr.make_not(e1))
    176                 else: raise PyBitError("Bad PyBit function call: %s\n" % ast.dump(ast_expr))
     434                else:
     435                    raise PyBitError("Bad PyBit function call: %s\n" % ast.dump(ast_expr))
    177436        elif isinstance(ast_expr, ast.Compare):
    178437                if (isinstance(ast_expr.ops[0], ast.Gt) and (ast_expr.comparators[0].n==0)):
     
    182441        else: raise PyBitError("Unknown expression %s\n" % ast.dump(ast_expr))
    183442
    184 def translate_var(v):
     443def translate_var(v, aggregate_type = False):
    185444        if isinstance(v, ast.Name):
    186                 return v.id
     445            agg_name = v.id
     446            var_name = v.id
    187447        elif isinstance(v, ast.Attribute):
    188                 if isinstance(v.value, ast.Name):
    189                         return "%s.%s" % (v.value.id, v.attr)
    190                 else: raise PyBitError("Illegal attribute %s\n" % ast.dump(v))
     448           if isinstance(v.value, ast.Name):
     449               var_name = STRUCT_TEMPLATE%(v.value.id, v.attr)
     450               agg_name = "%s.%s" % (v.value.id, v.attr)
     451           else: raise PyBitError("Illegal attribute %s\n" % ast.dump(v))
    191452        elif isinstance(v, ast.Subscript):
    192                 if isinstance(v.value, ast.Name) and isinstance(v.slice, ast.Index):
    193                         if isinstance(v.slice.value, ast.Num):
    194                             return "%s[%s]" % (v.value.id, translate_index(v.slice.value))
    195                         elif isinstance(v.slice.value, ast.Str):
    196                             return "%s.%s" % (v.value.id, translate_index(v.slice.value))
    197                         else:
    198                             assert(1==0)
    199                 else: raise PyBitError("Unknown operator %s\n" % ast.dump(v))
    200 
     453           if isinstance(v.value, ast.Name) and isinstance(v.slice, ast.Index):
     454               var_name = ARRAY_TEMPLATE%(v.value.id, translate_index(v.slice.value))
     455               agg_name = "%s[%s]" % (v.value.id, translate_index(v.slice.value))
     456        else: raise PyBitError("Unknown operator %s\n" % ast.dump(v))
     457
     458        if aggregate_type:
     459            return agg_name
     460        else:
     461            return var_name
    201462
    202463def translate_stmts(ast_stmts):
     
    219480                        e = translate(s.test)
    220481                        body = translate_stmts(s.body)
    221                         translated.append(bitexpr.WhileLoop(e, body))
     482                        translated.append(bitexpr.WhileLoop(bitexpr.isNoneZero(e), body))
    222483                else: raise PyBitError("Unknown PyBit statement type %s\n" % ast.dump(s))
    223484        return translated
    224 
    225485#############################################################################################
    226486## Conversion to SSA form --- Pass 3
     
    300560##################################################################################
    301561def get_line(code, line):
    302 
    303562    lineno = 0
    304563    for stmt in code:
     
    339598    if isinstance(rhs, bitexpr.Var):
    340599        if rhs.varname == varname:
    341             #if varname == "u8.unibyte":
    342             #    print ")))))))))))))))))"
    343            
    344600            rhs.varname = newname
    345601        return rhs
     
    374630    if index >= 0:
    375631        right_index = var.find(']')
    376         if var[index+1:right_index].isdigit():
    377            return ('array', var[0:index], var[index+1:right_index])     
    378         else:
    379             return ('struct', var[0:index], var[index+1:right_index])
     632        return ('array', var[0:index], var[index+1:right_index])       
    380633   
    381634    if var.startswith("carry") or var.startswith("Carry"):
     
    11371390        code[key].carry_expr = bitexpr.isNoneZero(carry_variable)
    11381391    return code, all
    1139 
    1140 
    1141 
    1142 
    1143 
    1144 
    11451392#################################################################################################################
    11461393## This pass factors out the code that is common between the true branch and false branch of an if
     
    12571504        return "bitblock_has_bit(%s)"%(expr.var.varname)
    12581505    else:
    1259         print expr
     1506        #print expr
    12601507        assert (1==0)
    12611508
     
    12681515        return "\n%s(%s) {\n"%(" "*indent+cond_stmt+" ", generate_condition(expr))
    12691516    else:
    1270         print expr
     1517        #print expr
    12711518        assert (1==0)
    12721519
     
    13121559                code += s[0].RHS.carry
    13131560                code += ");\n"
     1561            elif isinstance(s[0].RHS, bitexpr.Sub):
     1562                code += s[0].RHS.op_C + "("
     1563                code += s[0].RHS.operand1.varname
     1564                code += ','
     1565                code += s[0].RHS.operand2.varname
     1566                code += ','
     1567                code += s[0].RHS.brw
     1568                code += ");\n"
    13141569
    13151570            else:
     
    13381593    if index < 0 or index >= len(code):
    13391594        return None
    1340    
     1595
    13411596    if isinstance(code[index], bitexpr.If):
    13421597        return code[index]
Note: See TracChangeset for help on using the changeset viewer.