shape -> dims

Author: shtaxxx

pyverilog/dataflow/bindvisitor.py

@@ -694,9 +694,9 @@ def getTermWidth(self, name):
         term = self.dataflow.getTerm(name)
         return term.msb, term.lsb
 
-    def getTermShape(self, name):
+    def getTermDims(self, name):
         term = self.dataflow.getTerm(name)
-        return term.shape
+        return term.dims
 
     def getTermtype(self, name):
         term = self.dataflow.getTerm(name)
@@ -708,7 +708,7 @@ def getBindlist(self, name):
     def renameVar(self, name):
         renamedvar = (name[:-1] +
                       ScopeLabel('_rn' + str(self.renamecnt) +
-                                 '_' + name[-1].scopename, 'signal'))
+                                   '_' + name[-1].scopename, 'signal'))
         self.renamecnt += 1
         return renamedvar
 
@@ -866,16 +866,16 @@ def addTerm(self, node, rscope=None):
             msb = DFIntConst('0') if node.width is None else self.makeDFTree(node.width.msb, scope)
         lsb = DFIntConst('0') if node.width is None else self.makeDFTree(node.width.lsb, scope)
 
-        shape = None
+        dims = None
         if node.dimensions is not None:
-            shape = []
+            dims = []
             for length in node.dimensions.lengths:
                 l = self.makeDFTree(length.msb, scope)
                 r = self.makeDFTree(length.lsb, scope)
-                shape.append((l, r))
-            shape = tuple(shape)
+                dims.append((l, r))
+            dims = tuple(dims)
 
-        term = Term(name, termtypes, msb, lsb, shape)
+        term = Term(name, termtypes, msb, lsb, dims)
         self.dataflow.addTerm(name, term)
         self.setConstantTerm(name, term)
 
@@ -1057,7 +1057,7 @@ def makeDFTree(self, node, scope):
             var_df = self.makeDFTree(node.var, scope)
             ptr_df = self.makeDFTree(node.ptr, scope)
 
-            if isinstance(var_df, DFTerminal) and self.getTermShape(var_df.name) is not None:
+            if isinstance(var_df, DFTerminal) and self.getTermDims(var_df.name) is not None:
                 return DFPointer(var_df, ptr_df)
             return DFPartselect(var_df, ptr_df, copy.deepcopy(ptr_df))
 
@@ -1247,7 +1247,7 @@ def resolveBlockingAssign(self, tree, scope):
         if isinstance(tree, DFPointer):
             resolved_ptr = self.resolveBlockingAssign(tree.ptr, scope)
             if (isinstance(tree.var, DFTerminal) and
-                self.getTermShape(tree.var.name) is not None):
+                    self.getTermDims(tree.var.name) is not None):
                 current_bindlist = self.frames.getBlockingAssign(tree.var.name, scope)
                 if len(current_bindlist) == 0:
                     return DFPointer(tree.var, resolved_ptr)
@@ -1273,7 +1273,7 @@ def getFitTree(self, bindlist, msb, lsb):
             if bind.msb is None and bind.lsb is None:
                 return bind.tree
             if (self.optimize(bind.msb) == optimized_msb and
-                self.optimize(bind.lsb) == optimized_lsb):
+                    self.optimize(bind.lsb) == optimized_lsb):
                 return bind.tree
         return self.getMergedTree(bindlist)
 
@@ -1384,7 +1384,7 @@ def getDst(self, left, scope):
             if left.var.scope is not None:
                 name = left.var.scope + ScopeLabel(left.var.name, 'signal')
             ptr = self.optimize(self.makeDFTree(left.ptr, scope))
-            if self.getTermShape(name) is not None:
+            if self.getTermDims(name) is not None:
                 return (name, None, None, ptr)
             return (name, ptr, copy.deepcopy(ptr), None)
 
@@ -1480,8 +1480,8 @@ def makeBind(self, name, msb, lsb, ptr, part_msb, part_lsb,
         if len(current_bindlist) > 0:
             for current_bind in current_bindlist:
                 if (current_bind.msb == msb and
-                    current_bind.lsb == lsb and
-                        current_bind.ptr == ptr ):
+                    current_bind.lsb == lsb
+                        and current_bind.ptr == ptr ):
                     current_tree = current_bind.tree
                     current_msb = current_bind.msb
                     current_lsb = current_bind.lsb
@@ -1494,8 +1494,8 @@ def makeBind(self, name, msb, lsb, ptr, part_msb, part_lsb,
 
         match_flowlist = ()
         if (current_msb == msb and
-            current_lsb == lsb and
-                current_ptr == ptr ):
+            current_lsb == lsb
+                and current_ptr == ptr ):
             (rest_tree,
              rest_condlist,
              rest_flowlist,

pyverilog/dataflow/dataflow.py

@@ -687,12 +687,12 @@ def __hash__(self):
 
 
 class Term(object):
-    def __init__(self, name, termtype=(), msb=None, lsb=None, shape=None):
+    def __init__(self, name, termtype=(), msb=None, lsb=None, dims=None):
         self.name = name  # tuple (str)
         self.termtype = termtype  # set (str)
         self.msb = msb  # DFNode
         self.lsb = lsb  # DFNode
-        self.shape = shape  # tuple/list of pair of DFNode
+        self.dims = dims  # tuple/list of pair of DFNode
 
     def __repr__(self):
         return str(self.name)
@@ -704,10 +704,10 @@ def tostr(self):
             ret += ' msb:' + self.msb.tostr()
         if self.lsb is not None:
             ret += ' lsb:' + self.lsb.tostr()
-        if self.shape is not None:
-            ret += ' shape:'
+        if self.dims is not None:
+            ret += ' dims:'
             ret += ''.join(['[' + l.tostr() + ':' + r.tostr() + ']'
-                            for l, r in self.shape])
+                            for l, r in self.dims])
         ret += ')'
         return ret
 
@@ -721,10 +721,10 @@ def __eq__(self, other):
                 and self.termtype == other.termtype
                 and self.msb == other.msb
                 and self.lsb == other.lsb
-                and self.shape == other.shape)
+                and self.dims == other.dims)
 
     def __hash__(self):
-        return hash((self.name, self.termtype, self.msb, self.lsb, self.shape))
+        return hash((self.name, self.termtype, self.msb, self.lsb, self.dims))
 
     def getScope(self, termname):
         return termname[:-1]
@@ -768,9 +768,9 @@ def tocode(self):
                 and self.msb is not None and self.lsb is not None):
             code += '[' + self.msb.tocode(None) + ':' + self.lsb.tocode(None) + '] '
         code += flatname  # signal name
-        if self.shape is not None:
+        if self.dims is not None:
             code += ''.join(['[' + l.tocode() + ':' + r.tocode() + ']'
-                             for l, r in self.shape])
+                             for l, r in self.dims])
         code += ';\n'
         return code
 
@@ -969,8 +969,8 @@ def setTerm(self, name, term):
             self.terms[name].msb = term.msb
         if self.terms[name].lsb is None:
             self.terms[name].lsb = term.lsb
-        if self.terms[name].shape is None:
-            self.terms[name].shape = term.shape
+        if self.terms[name].dims is None:
+            self.terms[name].dims = term.dims
 
     def hasTerm(self, name):
         return name in self.terms

pyverilog/dataflow/merge.py

@@ -59,11 +59,11 @@ def getTermtype(self, termname):
             raise verror.DefinitionError('No such Term: %s' % termname)
         return term.termtype
 
-    def getTermShape(self, termname):
+    def getTermDims(self, termname):
         term = self.getTerm(termname)
         if term is None:
             raise verror.DefinitionError('No such Term: %s' % termname)
-        return term.shape
+        return term.dims
 
     def getAssignType(self, termname, bind):
         termtype = self.getTermtype(termname)
@@ -115,7 +115,7 @@ def getTree(self, termname, ptr=None):
         if len(bindlist) == 0:
             return None
 
-        if self.getTermShape(termname) is not None:
+        if self.getTermDims(termname) is not None:
             discretebinds = {}
             for bind in bindlist:
                 if isinstance(bind.ptr, DFEvalValue):
@@ -221,8 +221,8 @@ def getTermSources(self, termname):
         sources = set()
         sources |= self.getTreeSources(term.msb)
         sources |= self.getTreeSources(term.lsb)
-        if term.shape is not None:
-            for l, r in term.shape:
+        if term.dims is not None:
+            for l, r in term.dims:
                 sources |= self.getTreeSources(l)
                 sources |= self.getTreeSources(r)
         return sources
@@ -416,7 +416,7 @@ def splitBind(self, bind, splitpos):
         lsb = self.optimizer.optimizeConstant(bind.lsb)
         ptr = self.optimizer.optimizeConstant(bind.ptr)
         if ptr is not None and msb is None or lsb is None:
-            if self.getTermShape(bind.dest) is not None:
+            if self.getTermDims(bind.dest) is not None:
                 msb = self.optimizer.optimizeConstant(copy.deepcopy(term.msb))
                 lsb = self.optimizer.optimizeConstant(copy.deepcopy(term.lsb))
             else:

pyverilog/dataflow/optimizer.py

@@ -146,7 +146,7 @@ def optimizeConstant(self, tree):
             term = self.getTerm(tree.var.name)
             var = self.optimizeConstant(tree.var)
             ptr = self.optimizeConstant(tree.ptr)
-            if term.shape is not None:
+            if term.dims is not None:
                 return DFPointer(var, ptr)
             if isinstance(var, DFEvalValue) and isinstance(ptr, DFEvalValue):
                 evalcc = self.evalPointer(var, ptr)
@@ -335,7 +335,7 @@ def getWidth(self, node):
             if not isinstance(node.var, DFTerminal):
                 return 1
             term = self.getTerm(node.var.name)
-            if term.shape is not None:
+            if term.dims is not None:
                 msb = self.optimizeConstant(term.msb).value
                 lsb = self.optimizeConstant(term.lsb).value
                 width = abs(msb - lsb) + 1
@@ -1023,10 +1023,10 @@ def resolveConstant(self):
             if tv.lsb is not None:
                 rslt = self.optimizeConstant(tv.lsb)
                 self.resolved_terms[tk].lsb = rslt
-            if tv.shape is not None:
-                shape = []
-                for l, r in tv.shape:
+            if tv.dims is not None:
+                dims = []
+                for l, r in tv.dims:
                     l = self.optimizeConstant(l)
                     r = self.optimizeConstant(r)
-                    shape.append((l, r))
-                self.resolved_terms[tk].shape = tuple(shape)
+                    dims.append((l, r))
+                self.resolved_terms[tk].dims = tuple(dims)

pyverilog/dataflow/walker.py

@@ -60,7 +60,7 @@ def walkTree(self, tree, visited=set([]), step=0, delay=False, msb=None, lsb=Non
                 return tree
 
             nptr = None
-            if self.getTermShape(termname) is not None:
+            if self.getTermDims(termname) is not None:
                 if ptr is None:
                     raise verror.FormatError('Array variable requires an pointer.')
                 if msb is not None and lsb is not None:
@@ -106,7 +106,7 @@ def walkTree(self, tree, visited=set([]), step=0, delay=False, msb=None, lsb=Non
             ptr = self.walkTree(tree.ptr, visited, step, delay)
             var = self.walkTree(tree.var, visited, step, delay, ptr=ptr)
             if isinstance(tree.var, DFTerminal):
-                if (self.getTermShape(tree.var.name) is not None and
+                if (self.getTermDims(tree.var.name) is not None and
                         not (isinstance(var, DFTerminal) and var.name == tree.var.name)):
                     return var
             return DFPointer(var, ptr)