Rework parsing of parameter types

Use the common data_type_or_implicit rules to support type
definitions for parameters. This eliminates a bunch of special
rules in parse.y, and opens the door for parameters having
more complex types.

netmisc.cc

@@ -1809,3 +1809,52 @@ void check_for_inconsistent_delays(NetScope*scope)
 	    display_ts_dly_warning = false;
       }
 }
+
+
+/*
+ * Calculate the bit vector range for a parameter, from the type of the
+ * parameter. This is expecting that the type is a vector type. The parameter
+ * is presumably declared something like this:
+ *
+ *    parameter [4:1] foo = <value>;
+ *
+ * In this case, the par_type is a netvector with a single dimension. The
+ * par_msv gets 4, and par_lsv get 1. The caller uses these values to
+ * interpret things like bit selects.
+ */
+bool calculate_param_range(const LineInfo&line, ivl_type_t par_type,
+			   long&par_msv, long&par_lsv, long length)
+{
+      const netvector_t*vector_type = dynamic_cast<const netvector_t*> (par_type);
+      if (vector_type == 0) {
+	    // If the parameter doesn't have an explicit range, then
+	    // just return range values of [length-1:0].
+	    par_msv = length-1;
+	    par_lsv = 0;
+	    return true;
+      }
+
+      ivl_assert(line, vector_type->packed());
+      const std::vector<netrange_t>& packed_dims = vector_type->packed_dims();
+
+      // This is a netvector_t with 0 dimensions, then the parameter was
+      // declared with a statement like this:
+      //
+      //    parameter signed foo = <value>;
+      //
+      // The netvector_t is just here to carry the signed-ness, which we don't
+      // even need here. So act like the type is defined by the r-value
+      // length.
+      if (packed_dims.size() == 0) {
+	    par_msv = length-1;
+	    par_lsv = 0;
+	    return true;
+      }
+      ivl_assert(line, packed_dims.size() == 1);
+
+      netrange_t use_range = packed_dims[0];
+      par_msv = use_range.get_msb();
+      par_lsv = use_range.get_lsb();
+
+      return true;
+}