Work towards nested packed struct member vectors.

elab_lval.cc

@@ -157,7 +157,7 @@ NetAssign_*PEIdent::scan_lname_for_nested_members_(Design*des, NetScope*scope,
 	    return 0;
 
       pform_name_t use_path = cur_path;
-      perm_string tmp_name = peek_tail_name(use_path);
+      name_component_t tail = use_path.back();
       use_path.pop_back();
 
       NetNet*       reg = 0;
@@ -171,18 +171,19 @@ NetAssign_*PEIdent::scan_lname_for_nested_members_(Design*des, NetScope*scope,
 		  return 0;
 
 	    tmp = new NetAssign_(tmp);
-	    tmp->set_property(tmp_name);
+	    tmp->set_property(tail.name);
 	    return tmp;
       }
 
       if (reg->struct_type()) {
 	    cerr << get_fileline() << ": sorry: "
-		 << "I don't know what to do with struct " << use_path << endl;
+		 << "I don't know what to do with struct " << use_path
+		 << " with member " << tail << "." << endl;
 	    return 0;
       }
 
       if (reg->class_type()) {
-	    return elaborate_lval_net_class_member_(des, scope, reg, tmp_name);
+	    return elaborate_lval_net_class_member_(des, scope, reg, tail.name);
       }
 
       return 0;

elab_type.cc

@@ -32,6 +32,44 @@
 
 using namespace std;
 
+/*
+ * Some types have a list of ranges that need to be elaborated. This
+ * function elaborates the ranges referenced by "dims" into the vector
+ * "ranges".
+ */
+static void elaborate_array_ranges(Design*des, NetScope*scope,
+				   vector<netrange_t>&ranges,
+				   const list<pform_range_t>*dims)
+{
+      if (dims == 0)
+	    return;
+
+      for (list<pform_range_t>::const_iterator cur = dims->begin()
+		 ; cur != dims->end() ; ++ cur) {
+
+	    NetExpr*me = elab_and_eval(des, scope, cur->first, 0, true);
+
+	    NetExpr*le = elab_and_eval(des, scope, cur->second, 0, true);
+
+	      /* If elaboration failed for either expression, we
+		 should have already reported the error, so just
+		 skip the following evaluation to recover. */
+
+	    long mnum = 0, lnum = 0;
+	    if ( me && ! eval_as_long(mnum, me) ) {
+		  assert(0);
+		  des->errors += 1;
+	    }
+
+	    if ( le && ! eval_as_long(lnum, le) ) {
+		  assert(0);
+		  des->errors += 1;
+	    }
+
+	    ranges.push_back(netrange_t(mnum, lnum));
+      }
+}
+
 /*
  * Elaborations of types may vary depending on the scope that it is
  * done in, so keep a per-scope cache of the results.
@@ -120,33 +158,7 @@ ivl_type_s* enum_type_t::elaborate_type_raw(Design*des, NetScope*scope) const
 ivl_type_s* vector_type_t::elaborate_type_raw(Design*des, NetScope*scope) const
 {
       vector<netrange_t> packed;
-
-      if (pdims.get()) {
-	    for (list<pform_range_t>::const_iterator cur = pdims->begin()
-		       ; cur != pdims->end() ; ++ cur) {
-
-		  NetExpr*me = elab_and_eval(des, scope, cur->first, 0, true);
-
-		  NetExpr*le = elab_and_eval(des, scope, cur->second, 0, true);
-
-		    /* If elaboration failed for either expression, we
-		       should have already reported the error, so just
-		       skip the following evaluation to recover. */
-
-		  long mnum = 0, lnum = 0;
-		  if ( me && ! eval_as_long(mnum, me) ) {
-			assert(0);
-			des->errors += 1;
-		  }
-
-		  if ( le && ! eval_as_long(lnum, le) ) {
-			assert(0);
-			des->errors += 1;
-		  }
-
-		  packed.push_back(netrange_t(mnum, lnum));
-	    }
-      }
+      elaborate_array_ranges(des, scope, packed, pdims.get());
 
       netvector_t*tmp = new netvector_t(packed, base_type);
       tmp->set_signed(signed_flag);
@@ -171,13 +183,14 @@ ivl_type_s* string_type_t::elaborate_type_raw(Design*, NetScope*) const
       return &netstring_t::type_string;
 }
 
-ivl_type_s* parray_type_t::elaborate_type_raw(Design*des, NetScope*) const
+ivl_type_s* parray_type_t::elaborate_type_raw(Design*des, NetScope*scope) const
 {
-      cerr << get_fileline() << " : sorry: "
-           << "Packed arrays are not currently supported in this context."
-           << endl;
-      des->errors += 1;
-      return 0;
+      vector<netrange_t>packed;
+      elaborate_array_ranges(des, scope, packed, dims.get());
+
+      ivl_type_t etype = base_type->elaborate_type(des, scope);
+
+      return new netparray_t(packed, etype);
 }
 
 netstruct_t* struct_type_t::elaborate_type_raw(Design*des, NetScope*scope) const

netparray.cc

@@ -34,6 +34,12 @@ netparray_t::~netparray_t()
  * The packed width of a packed array is the packed width of the
  * element times the dimension width of the array itself.
  */
+
+bool netparray_t::packed(void) const
+{
+      return true;
+}
+
 long netparray_t::packed_width(void) const
 {
       long cur_width = element_type()->packed_width();

netparray.h

@@ -64,6 +64,7 @@ class netparray_t : public netsarray_t {
 
     public:
 	// Virtual methods from the ivl_type_s type...
+      bool packed(void) const;
       long packed_width(void) const;
       std::vector<netrange_t> slice_dimensions() const;