def add(cls, **columns): r'''Internal method called by `create`. This inserts the new type (and sub_elements, if any) into the database. This method is shared by all base classes. ''' sub_elements = None if 'sub_elements' in columns: sub_elements = columns['sub_elements'] del columns['sub_elements'] insert_columns = columns.copy() if 'element_type' in insert_columns: insert_columns['element_type'] = insert_columns['element_type'].id id = crud.insert('type', kind=cls.__name__, **insert_columns) if sub_elements: for i, field in enumerate(sub_elements): if isinstance(field, base_type): name = None type = field else: name, type = field crud.insert('sub_element', parent_id=id, element_order=i, name=name, element_type=type) return cls(id, columns, sub_elements)
def uses(fn_id, var_id): r'''Function fn_id directly references global variable var_id. Fn_id and var_id are the symbol_ids of the function and global variable, respectively. ''' crud.insert('fn_global_var_uses', 'ignore', fn_id=fn_id, var_id=var_id, sets=False)
def sets(fn_id, var_id): r'''Function fn_id directly sets global variable var_id. Fn_id and var_id are the symbol_ids of the function and global variable, respectively. ''' # FIX: Shouldn't this be 'replace'? crud.insert('fn_global_var_uses', 'ignore', fn_id=fn_id, var_id=var_id, sets=True)
def init(): crud.Db_conn = crud.db.connect('avr.db') crud.Db_cur = crud.Db_conn.cursor() try: # insert 0's for m=0: crud.Db_cur.execute(""" insert into worst (N, C, m, value) select N.id, C.id, 0, 0 from reg_class N cross join reg_class C """) crud.Db_conn.commit() registers = crud.read_column('register', 'name') aliases = {} for R in registers: aliases[R] = frozenset(crud.read_column('alias', 'r2', r1=R)) reg_classes = crud.read_column('reg_class', 'id') regs_in_class = {} for C in reg_classes: regs_in_class[C] = \ frozenset(crud.read_column('reg_in_class', 'reg', reg_class=C)) print 'reg_classes', reg_classes for N in reg_classes: print 'N', N N_regs = regs_in_class[N] for C in reg_classes: C_regs = regs_in_class[C] print 'C', C, C_regs # {set of S: set of registers} worsts0 = {frozenset(): frozenset()} for m in range(1, len(C_regs) + 1): print 'm', m worsts1 = {} for R in C_regs: for S0, regs in worsts0.iteritems(): if R not in S0: worsts1[S0.union((R,))] = \ regs.union(aliases[R]).intersection(N_regs) crud.insert('worst', N=N, C=C, m=m, value=max(len(regs) for regs in worsts1.itervalues())) worsts0 = worsts1 crud.Db_conn.commit() worst0 = worst1 = None except: crud.Db_conn.rollback() raise finally: crud.Db_cur.close() crud.Db_conn.close()
def create(cls, label, kind, context = None, **attributes): r'''Creates a new symbol_table entry. Updates an existing database row (if found), or inserts a new row. Returns the id of the row. ''' if context is None: id = crud.read1_column('symbol_table', 'id', label=label, context=None, zero_ok=True) if id is not None: crud.update('symbol_table', {'id': id}, kind=kind, **attributes) if id in Symbols_by_id: del Symbols_by_id[id] del Symbols[label, None] return cls(id, label, context, kind=kind, **attributes) id = crud.insert('symbol_table', option='replace', label=label, kind=kind, context=context and context.id, **attributes) return cls(id, label, context, kind=kind, **attributes)
def write(self, next = None): r'''Writes the block and associated triples to the database. Returns the id assigned to the block. ''' global Current_block #print self.name, "write" if self.state == 'end_absolute': next = None else: assert next is not None id = crud.insert('blocks', name=self.name, word_symbol_id=self.word_symbol_id, last_triple_id=self.last_triple.id if self.last_triple else None, next=next, next_conditional=self.next_conditional) # add final labels to their associated triples: for var_id, t in self.labels.iteritems(): t.add_label(var_id, True) # write out triples: # # first figure out the set of all triples that will be forcably # written: forced_triples = set(self.labels.values()) if self.side_effects is not None: #print self.name, "adding", self.side_effects, "due to side_effects" forced_triples.add(self.side_effects) forced_triples.update(self.sets_global.values()) if self.last_triple is not None: #print self.name, "adding", self.last_triple, "as last_triple" forced_triples.add(self.last_triple) # # then write them all: # for t in forced_triples: t.write(id) # # then call write_soft_predecessors for all of them: # for t in forced_triples: t.write_soft_predecessors(id) assert self.name not in Block_ids Block_ids[self.name] = id Current_block = None #print self.name, "write returning", id return id
def save(self, word_symbol, parent = None, parent_arg_num = None, arg_order = None): r'''Writes itself and its children (args) to the database. ''' kws = dict(itertools.chain( map(lambda attr: (attr, getattr(self, attr)), self.attr_cols), zip(self.arg_cols, (word_symbol.id, parent, parent_arg_num, arg_order)))) self.word_symbol = word_symbol self.id = crud.insert('ast', **kws) save_args(self.args, word_symbol, self.id)
def calls(caller_id, called_id): r'''Function caller_id directly calls function called_id. Both caller_id and called_id are the symbol_id of the function. ''' crud.insert('fn_calls', 'ignore', caller_id=caller_id, called_id=called_id)