[multiple changes]

2010-04-12  Jerry DeLisle  <jvdelisle@gcc.gnu.org>

	* array.c (extract_element): Restore function from trunk.
	(gfc_get_array_element): Restore function from trunk.
	(gfc_expand_constructor): Restore check against
	flag_max_array_constructor.
	* constructor.c (node_copy_and_append): Delete unused.
	* gfortran.h: Delete comment and extra include.
	* constructor.h: Bump copyright and clean up TODO comments.
	* resolve.c: Whitespace.

2010-04-12  Daniel Franke  <franke.daniel@gmail.com>

	* simplify.c (compute_dot_product): Replaced usage of ADVANCE macro
	with direct access access to elements. Adjusted prototype, fixed all
	callers.
	(gfc_simplify_dot_product): Removed duplicate check for zero-sized
	array.
	(gfc_simplify_matmul): Removed usage of ADVANCE macro.
	(gfc_simplify_spread): Removed workaround, directly insert elements
	at a given array position.
	(gfc_simplify_transpose): Likewise.
	(gfc_simplify_pack): Replaced usage of ADVANCE macro with corresponding
	function calls.
	(gfc_simplify_unpack): Likewise.

2010-04-12  Daniel Franke  <franke.daniel@gmail.com>

	* simplify.c (only_convert_cmplx_boz): Renamed to ...
	(convert_boz): ... this and moved to start of file.
	(gfc_simplify_abs): Whitespace fix.
	(gfc_simplify_acos): Whitespace fix.
	(gfc_simplify_acosh): Whitespace fix.
	(gfc_simplify_aint): Whitespace fix.
	(gfc_simplify_dint): Whitespace fix.
	(gfc_simplify_anint): Whitespace fix.
	(gfc_simplify_and): Replaced if-gate by more common switch-over-type.
	(gfc_simplify_dnint): Whitespace fix.
	(gfc_simplify_asin): Whitespace fix.
	(gfc_simplify_asinh): Moved creation of result-expr out of switch.
	(gfc_simplify_atan): Likewise.
	(gfc_simplify_atanh): Whitespace fix.
	(gfc_simplify_atan2): Whitespace fix.
	(gfc_simplify_bessel_j0): Removed ATTRIBUTE_UNUSED.
	(gfc_simplify_bessel_j1): Likewise.
	(gfc_simplify_bessel_jn): Likewise.
	(gfc_simplify_bessel_y0): Likewise.
	(gfc_simplify_bessel_y1): Likewise.
	(gfc_simplify_bessel_yn): Likewise.
	(gfc_simplify_ceiling): Reorderd statements.
	(simplify_cmplx): Use convert_boz(), check for constant arguments.
	Whitespace fix.
	(gfc_simplify_cmplx): Use correct default kind. Removed check for
	constant arguments.
	(gfc_simplify_complex): Replaced if-gate. Removed check for
	constant arguments.
	(gfc_simplify_conjg): Whitespace fix.
	(gfc_simplify_cos): Whitespace fix.
	(gfc_simplify_cosh): Replaced if-gate by more common switch-over-type.
	(gfc_simplify_dcmplx): Removed check for constant arguments.
	(gfc_simplify_dble): Use convert_boz() and gfc_convert_constant().
	(gfc_simplify_digits): Whitespace fix.
	(gfc_simplify_dim): Whitespace fix.
	(gfc_simplify_dprod): Reordered statements.
	(gfc_simplify_erf): Whitespace fix.
	(gfc_simplify_erfc): Whitespace fix.
	(gfc_simplify_epsilon): Whitespace fix.
	(gfc_simplify_exp): Whitespace fix.
	(gfc_simplify_exponent): Use convert_boz().
	(gfc_simplify_floor): Reorderd statements.
	(gfc_simplify_gamma): Whitespace fix.
	(gfc_simplify_huge): Whitespace fix.
	(gfc_simplify_iand): Whitespace fix.
	(gfc_simplify_ieor): Whitespace fix.
	(simplify_intconv): Use gfc_convert_constant().
	(gfc_simplify_int): Use simplify_intconv().
	(gfc_simplify_int2): Reorderd statements.
	(gfc_simplify_idint): Reorderd statements.
	(gfc_simplify_ior): Whitespace fix.
	(gfc_simplify_ishftc): Removed duplicate type check.
	(gfc_simplify_len): Use range_check() instead of manual range check.
	(gfc_simplify_lgamma): Removed ATTRIBUTE_UNUSED. Whitespace fix.
	(gfc_simplify_log): Whitespace fix.
	(gfc_simplify_log10): Whitespace fix.
	(gfc_simplify_minval): Whitespace fix.
	(gfc_simplify_maxval): Whitespace fix.
	(gfc_simplify_mod): Whitespace fix.
	(gfc_simplify_modulo): Whitespace fix.
	(simplify_nint): Reorderd statements.
	(gfc_simplify_not): Whitespace fix.
	(gfc_simplify_or): Replaced if-gate by more common switch-over-type.
	(gfc_simplify_radix): Removed unused result-variable. Whitespace fix.
	(gfc_simplify_range): Removed unused result-variable. Whitespace fix.
	(gfc_simplify_real): Use convert_boz() and gfc_convert_constant().
	(gfc_simplify_realpart): Whitespace fix.
	(gfc_simplify_selected_char_kind): Removed unused result-variable.
	(gfc_simplify_selected_int_kind): Removed unused result-variable.
	(gfc_simplify_selected_real_kind): Removed unused result-variable.
	(gfc_simplify_sign): Whitespace fix.
	(gfc_simplify_sin): Whitespace fix.
	(gfc_simplify_sinh): Replaced if-gate by more common switch-over-type.
	(gfc_simplify_sqrt): Avoided goto by inlining check. Whitespace fix.
	(gfc_simplify_tan): Replaced if-gate by more common switch-over-type.
	(gfc_simplify_tanh): Replaced if-gate by more common switch-over-type.
	(gfc_simplify_xor): Replaced if-gate by more common switch-over-type.

2010-04-12  Daniel Franke  <franke.daniel@gmail.com>

	* gfortran.h (gfc_start_constructor): Removed.
	(gfc_get_array_element): Removed.
	* array.c (gfc_start_constructor): Removed, use gfc_get_array_expr 
	instead. Fixed all callers.
	(extract_element): Removed.
	(gfc_expand_constructor): Temporarily removed check for
	max-array-constructor. Will be re-introduced later if still required.
	(gfc_get_array_element): Removed, use gfc_constructor_lookup_expr
	instead. Fixed all callers.
	* expr.c (find_array_section): Replaced manual lookup of elements
	by gfc_constructor_lookup.

2010-04-12  Daniel Franke  <franke.daniel@gmail.com>

        * gfortran.h (gfc_get_null_expr): New prototype.
        (gfc_get_operator_expr): New prototype.
        (gfc_get_character_expr): New prototype.
        (gfc_get_iokind_expr): New prototype.
        * expr.c (gfc_get_null_expr): New.
        (gfc_get_character_expr): New.
        (gfc_get_iokind_expr): New.
        (gfc_get_operator_expr): Moved here from matchexp.c (build_node).
        * matchexp.c (build_node): Renamed and moved to
        expr.c (gfc_get_operator_expr). Reordered arguments to match 
        other functions. Fixed all callers.
        (gfc_get_parentheses): Use specific function to build expr.
        * array.c (gfc_match_array_constructor): Likewise.
        * arith.c (eval_intrinsic): Likewise.
        (gfc_hollerith2int): Likewise.
        (gfc_hollerith2real): Likewise.
        (gfc_hollerith2complex): Likewise.
        (gfc_hollerith2logical): Likewise.
        * data.c (create_character_intializer): Likewise.
        * decl.c (gfc_match_null): Likewise.
        (enum_initializer): Likewise.
        * io.c (gfc_match_format): Likewise.
        (match_io): Likewise.
        * match.c (gfc_match_nullify): Likewise.
        * primary.c (match_string_constant): Likewise.
        (match_logical_constant): Likewise.
        (build_actual_constructor): Likewise.
        * resolve.c (build_default_init_expr): Likewise.
        * symbol.c (generate_isocbinding_symbol): Likewise.
        (gfc_build_class_symbol): Likewise.
        (gfc_find_derived_vtab): Likewise.
        * simplify.c (simplify_achar_char): Likewise.
        (gfc_simplify_adjustl): Likewise.
        (gfc_simplify_adjustr): Likewise.
        (gfc_simplify_and): Likewise.
        (gfc_simplify_bit_size): Likewise.
        (gfc_simplify_is_iostat_end): Likewise.
        (gfc_simplify_is_iostat_eor): Likewise.
        (gfc_simplify_isnan): Likewise.
        (simplify_bound): Likewise.
        (gfc_simplify_leadz): Likewise.
        (gfc_simplify_len_trim): Likewise.
        (gfc_simplify_logical): Likewise.
        (gfc_simplify_maxexponent): Likewise.
        (gfc_simplify_minexponent): Likewise.
        (gfc_simplify_new_line): Likewise.
        (gfc_simplify_null): Likewise.
        (gfc_simplify_or): Likewise.
        (gfc_simplify_precision): Likewise.
        (gfc_simplify_repeat): Likewise.
        (gfc_simplify_scan): Likewise.
        (gfc_simplify_size): Likewise.
        (gfc_simplify_trailz): Likewise.
        (gfc_simplify_trim): Likewise.
        (gfc_simplify_verify): Likewise.
        (gfc_simplify_xor): Likewise.
        * trans-io.c (build_dt): Likewise.
        (gfc_new_nml_name_expr): Removed.

2010-04-12  Daniel Franke  <franke.daniel@gmail.com>

	* arith.h (gfc_constant_result): Removed prototype.
	* constructor.h (gfc_build_array_expr): Removed prototype.
	(gfc_build_structure_constructor_expr): Removed prototype.
	* gfortran.h (gfc_int_expr): Removed prototype.
	(gfc_logical_expr): Removed prototype.
	(gfc_get_array_expr): New prototype.
	(gfc_get_structure_constructor_expr): New prototype.
	(gfc_get_constant_expr): New prototype.
	(gfc_get_int_expr): New prototype.
	(gfc_get_logical_expr): New prototype.
	* arith.c (gfc_constant_result): Moved and renamed to
	expr.c (gfc_get_constant_expr). Fixed all callers.
	* constructor.c (gfc_build_array_expr): Moved and renamed to
	expr.c (gfc_get_array_expr). Split gfc_typespec argument to type
	and kind. Fixed all callers.
	(gfc_build_structure_constructor_expr): Moved and renamed to
	expr.c (gfc_get_structure_constructor_expr). Split gfc_typespec argument
	to type and kind. Fixed all callers.
	* expr.c (gfc_logical_expr): Renamed to ...
	(gfc_get_logical_expr): ... this. Added kind argument. Fixed all callers.
	(gfc_int_expr): Renamed to ...
	(gfc_get_int_expr): ... this. Added kind and where arguments. Fixed all
	callers.
	(gfc_get_constant_expr): New.
	(gfc_get_array_expr): New.
	(gfc_get_structure_constructor_expr): New.
	* simplify.c (int_expr_with_kind): Removed, callers use gfc_get_int_expr
	instead.

2010-04-12  Daniel Franke  <franke.daniel@gmail.com>

	* constructor.h: New.
	* constructor.c: New.
	* Make-lang.in: Add new files to F95_PARSER_OBJS.
	* arith.c (reducy_unary): Use constructor API.
	(reduce_binary_ac): Likewise.
	(reduce_binary_ca): Likewise.
	(reduce_binary_aa): Likewise.
	* check.c (gfc_check_pack): Likewise.
	(gfc_check_reshape): Likewise.
	(gfc_check_unpack): Likewise.
	* decl.c (add_init_expr_to_sym): Likewise.
	(build_struct): Likewise.
	* dependency.c (gfc_check_dependency): Likewise.
	(contains_forall_index_p): Likewise.
	* dump-parse-tree.c (show_constructor): Likewise.
	* expr.c (free_expr0): Likewise.
	(gfc_copy_expr): Likewise.
	(gfc_is_constant_expr): Likewise.
	(simplify_constructor): Likewise.
	(find_array_element): Likewise.
	(find_component_ref): Likewise.
	(find_array_section): Likewise.
	(find_substring_ref): Likewise.
	(simplify_const_ref): Likewise.
	(scalarize_intrinsic_call): Likewise.
	(check_alloc_comp_init): Likewise.
	(gfc_default_initializer): Likewise.
	(gfc_traverse_expr): Likewise.
	* iresolve.c (check_charlen_present): Likewise.
	(gfc_resolve_reshape): Likewise.
	(gfc_resolve_transfer): Likewise.
	* module.c (mio_constructor): Likewise.
	* primary.c (build_actual_constructor): Likewise.
	(gfc_match_structure_constructor): Likewise.
	* resolve.c (resolve_structure_cons): Likewise.
	* simplify.c (is_constant_array_expr): Likewise.
	(init_result_expr): Likewise.
	(transformational_result): Likewise.
	(simplify_transformation_to_scalar): Likewise.
	(simplify_transformation_to_array): Likewise.
	(gfc_simplify_dot_product): Likewise.
	(simplify_bound): Likewise.
	(simplify_matmul): Likewise.
	(simplify_minval_maxval): Likewise.
	(gfc_simplify_pack): Likewise.
	(gfc_simplify_reshape): Likewise.
	(gfc_simplify_shape): Likewise.
	(gfc_simplify_spread): Likewise.
	(gfc_simplify_transpose): Likewise.
	(gfc_simplify_unpack): Likewise.q
	(gfc_convert_constant): Likewise.
	(gfc_convert_char_constant): Likewise.
	* target-memory.c (size_array): Likewise.
	(encode_array): Likewise.
	(encode_derived): Likewise.
	(interpret_array): Likewise.
	(gfc_interpret_derived): Likewise.
	(expr_to_char): Likewise.
	(gfc_merge_initializers): Likewise.
	* trans-array.c (gfc_get_array_constructor_size): Likewise.
	(gfc_trans_array_constructor_value): Likewise.
	(get_array_ctor_strlen): Likewise.
	(gfc_constant_array_constructor_p): Likewise.
	(gfc_build_constant_array_constructor): Likewise.
	(gfc_trans_array_constructor): Likewise.
	(gfc_conv_array_initializer): Likewise.
	* trans-decl.c (check_constant_initializer): Likewise.
	* trans-expr.c (flatten_array_ctors_without_strlen): Likewise.
	(gfc_apply_interface_mapping_to_cons): Likewise.
	(gfc_trans_structure_assign): Likewise.
	(gfc_conv_structure): Likewise.
	* array.c (check_duplicate_iterator): Likewise.
	(match_array_list): Likewise.
	(match_array_cons_element): Likewise.
	(gfc_match_array_constructor): Likewise.
	(check_constructor_type): Likewise.
	(check_constructor): Likewise.
	(expand): Likewise.
	(expand_constructor): Likewise.
	(extract_element): Likewise.
	(gfc_expanded_ac): Likewise.
	(resolve_array_list): Likewise.
	(gfc_resolve_character_array_constructor): Likewise.
	(copy_iterator): Renamed to ...
	(gfc_copy_iterator): ... this.
	(gfc_append_constructor): Removed.
	(gfc_insert_constructor): Removed unused function.
	(gfc_get_constructor): Removed.
	(gfc_free_constructor): Removed.
	(qgfc_copy_constructor): Removed.
	* gfortran.h (struct gfc_expr): Removed member 'con_by_offset'.
	Removed all references. Replaced constructor list by splay-tree.
	(struct gfc_constructor): Removed member 'next', moved 'offset' from
	the inner struct, added member 'base'.
	(gfc_append_constructor): Removed prototype.
	(gfc_insert_constructor): Removed prototype.
	(gfc_get_constructor): Removed prototype.
	(gfc_free_constructor): Removed prototype.
	(qgfc_copy_constructor): Removed prototype.
	(gfc_copy_iterator): New prototype.
	* trans-array.h (gfc_constant_array_constructor_p): Adjusted prototype.

From-SVN: r158253

1 files changed, 111 insertions, 337 deletions

diff --git a/gcc/fortran/array.c b/gcc/fortran/array.c
index 5ceca4b..c3e366d 100644
--- a/gcc/fortran/array.c
+++ b/gcc/fortran/array.c
@@ -23,6 +23,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "system.h"
 #include "gfortran.h"
 #include "match.h"
+#include "constructor.h"
 
 /**************** Array reference matching subroutines *****************/
 
@@ -365,7 +366,7 @@ match_array_element_spec (gfc_array_spec *as)
 
   if (gfc_match_char ('*') == MATCH_YES)
     {
-      *lower = gfc_int_expr (1);
+      *lower = gfc_get_int_expr (gfc_default_integer_kind, NULL, 1);
       return AS_ASSUMED_SIZE;
     }
 
@@ -382,7 +383,7 @@ match_array_element_spec (gfc_array_spec *as)
 
   if (gfc_match_char (':') == MATCH_NO)
     {
-      *lower = gfc_int_expr (1);
+      *lower = gfc_get_int_expr (gfc_default_integer_kind, NULL, 1);
       return AS_EXPLICIT;
     }
 
@@ -635,7 +636,7 @@ done:
       for (i = 0; i < as->rank + as->corank; i++)
 	{
 	  if (as->lower[i] == NULL)
-	    as->lower[i] = gfc_int_expr (1);
+	    as->lower[i] = gfc_get_int_expr (gfc_default_integer_kind, NULL, 1);
 	}
     }
 
@@ -806,151 +807,6 @@ gfc_compare_array_spec (gfc_array_spec *as1, gfc_array_spec *as2)
 
 /****************** Array constructor functions ******************/
 
-/* Start an array constructor.  The constructor starts with zero
-   elements and should be appended to by gfc_append_constructor().  */
-
-gfc_expr *
-gfc_start_constructor (bt type, int kind, locus *where)
-{
-  gfc_expr *result;
-
-  result = gfc_get_expr ();
-
-  result->expr_type = EXPR_ARRAY;
-  result->rank = 1;
-
-  result->ts.type = type;
-  result->ts.kind = kind;
-  result->where = *where;
-  return result;
-}
-
-
-/* Given an array constructor expression, append the new expression
-   node onto the constructor.  */
-
-void
-gfc_append_constructor (gfc_expr *base, gfc_expr *new_expr)
-{
-  gfc_constructor *c;
-
-  if (base->value.constructor == NULL)
-    base->value.constructor = c = gfc_get_constructor ();
-  else
-    {
-      c = base->value.constructor;
-      while (c->next)
-	c = c->next;
-
-      c->next = gfc_get_constructor ();
-      c = c->next;
-    }
-
-  c->expr = new_expr;
-
-  if (new_expr
-      && (new_expr->ts.type != base->ts.type || new_expr->ts.kind != base->ts.kind))
-    gfc_internal_error ("gfc_append_constructor(): New node has wrong kind");
-}
-
-
-/* Given an array constructor expression, insert the new expression's
-   constructor onto the base's one according to the offset.  */
-
-void
-gfc_insert_constructor (gfc_expr *base, gfc_constructor *c1)
-{
-  gfc_constructor *c, *pre;
-  expr_t type;
-  int t;
-
-  type = base->expr_type;
-
-  if (base->value.constructor == NULL)
-    base->value.constructor = c1;
-  else
-    {
-      c = pre = base->value.constructor;
-      while (c)
-	{
-	  if (type == EXPR_ARRAY)
-	    {
-	      t = mpz_cmp (c->n.offset, c1->n.offset);
-	      if (t < 0)
-		{
-		  pre = c;
-		  c = c->next;
-		}
-	      else if (t == 0)
-		{
-		  gfc_error ("duplicated initializer");
-		  break;
-		}
-	      else
-		break;
-	    }
-	  else
-	    {
-	      pre = c;
-	      c = c->next;
-	    }
-	}
-
-      if (pre != c)
-	{
-	  pre->next = c1;
-	  c1->next = c;
-	}
-      else
-	{
-	  c1->next = c;
-	  base->value.constructor = c1;
-	}
-    }
-}
-
-
-/* Get a new constructor.  */
-
-gfc_constructor *
-gfc_get_constructor (void)
-{
-  gfc_constructor *c;
-
-  c = XCNEW (gfc_constructor);
-  c->expr = NULL;
-  c->iterator = NULL;
-  c->next = NULL;
-  mpz_init_set_si (c->n.offset, 0);
-  mpz_init_set_si (c->repeat, 0);
-  return c;
-}
-
-
-/* Free chains of gfc_constructor structures.  */
-
-void
-gfc_free_constructor (gfc_constructor *p)
-{
-  gfc_constructor *next;
-
-  if (p == NULL)
-    return;
-
-  for (; p; p = next)
-    {
-      next = p->next;
-
-      if (p->expr)
-	gfc_free_expr (p->expr);
-      if (p->iterator != NULL)
-	gfc_free_iterator (p->iterator, 1);
-      mpz_clear (p->n.offset);
-      mpz_clear (p->repeat);
-      gfc_free (p);
-    }
-}
-
 
 /* Given an expression node that might be an array constructor and a
    symbol, make sure that no iterators in this or child constructors
@@ -958,11 +814,12 @@ gfc_free_constructor (gfc_constructor *p)
    duplicate was found.  */
 
 static int
-check_duplicate_iterator (gfc_constructor *c, gfc_symbol *master)
+check_duplicate_iterator (gfc_constructor_base base, gfc_symbol *master)
 {
+  gfc_constructor *c;
   gfc_expr *e;
 
-  for (; c; c = c->next)
+  for (c = gfc_constructor_first (base); c; c = gfc_constructor_next (c))
     {
       e = c->expr;
 
@@ -987,14 +844,15 @@ check_duplicate_iterator (gfc_constructor *c, gfc_symbol *master)
 
 
 /* Forward declaration because these functions are mutually recursive.  */
-static match match_array_cons_element (gfc_constructor **);
+static match match_array_cons_element (gfc_constructor_base *);
 
 /* Match a list of array elements.  */
 
 static match
-match_array_list (gfc_constructor **result)
+match_array_list (gfc_constructor_base *result)
 {
-  gfc_constructor *p, *head, *tail, *new_cons;
+  gfc_constructor_base head;
+  gfc_constructor *p;
   gfc_iterator iter;
   locus old_loc;
   gfc_expr *e;
@@ -1013,8 +871,6 @@ match_array_list (gfc_constructor **result)
   if (m != MATCH_YES)
     goto cleanup;
 
-  tail = head;
-
   if (gfc_match_char (',') != MATCH_YES)
     {
       m = MATCH_NO;
@@ -1029,7 +885,7 @@ match_array_list (gfc_constructor **result)
       if (m == MATCH_ERROR)
 	goto cleanup;
 
-      m = match_array_cons_element (&new_cons);
+      m = match_array_cons_element (&head);
       if (m == MATCH_ERROR)
 	goto cleanup;
       if (m == MATCH_NO)
@@ -1040,9 +896,6 @@ match_array_list (gfc_constructor **result)
 	  goto cleanup;		/* Could be a complex constant */
 	}
 
-      tail->next = new_cons;
-      tail = new_cons;
-
       if (gfc_match_char (',') != MATCH_YES)
 	{
 	  if (n > 2)
@@ -1061,19 +914,13 @@ match_array_list (gfc_constructor **result)
       goto cleanup;
     }
 
-  e = gfc_get_expr ();
-  e->expr_type = EXPR_ARRAY;
-  e->where = old_loc;
+  e = gfc_get_array_expr (BT_UNKNOWN, 0, &old_loc);
   e->value.constructor = head;
 
-  p = gfc_get_constructor ();
-  p->where = gfc_current_locus;
+  p = gfc_constructor_append_expr (result, e, &gfc_current_locus);
   p->iterator = gfc_get_iterator ();
   *p->iterator = iter;
 
-  p->expr = e;
-  *result = p;
-
   return MATCH_YES;
 
 syntax:
@@ -1081,7 +928,7 @@ syntax:
   m = MATCH_ERROR;
 
 cleanup:
-  gfc_free_constructor (head);
+  gfc_constructor_free (head);
   gfc_free_iterator (&iter, 0);
   gfc_current_locus = old_loc;
   return m;
@@ -1092,9 +939,8 @@ cleanup:
    single expression or a list of elements.  */
 
 static match
-match_array_cons_element (gfc_constructor **result)
+match_array_cons_element (gfc_constructor_base *result)
 {
-  gfc_constructor *p;
   gfc_expr *expr;
   match m;
 
@@ -1106,11 +952,7 @@ match_array_cons_element (gfc_constructor **result)
   if (m != MATCH_YES)
     return m;
 
-  p = gfc_get_constructor ();
-  p->where = gfc_current_locus;
-  p->expr = expr;
-
-  *result = p;
+  gfc_constructor_append_expr (result, expr, &gfc_current_locus);
   return MATCH_YES;
 }
 
@@ -1120,7 +962,7 @@ match_array_cons_element (gfc_constructor **result)
 match
 gfc_match_array_constructor (gfc_expr **result)
 {
-  gfc_constructor *head, *tail, *new_cons;
+  gfc_constructor_base head, new_cons;
   gfc_expr *expr;
   gfc_typespec ts;
   locus where;
@@ -1144,7 +986,7 @@ gfc_match_array_constructor (gfc_expr **result)
     end_delim = " /)";
 
   where = gfc_current_locus;
-  head = tail = NULL;
+  head = new_cons = NULL;
   seen_ts = false;
 
   /* Try to match an optional "type-spec ::"  */
@@ -1176,19 +1018,12 @@ gfc_match_array_constructor (gfc_expr **result)
 
   for (;;)
     {
-      m = match_array_cons_element (&new_cons);
+      m = match_array_cons_element (&head);
       if (m == MATCH_ERROR)
 	goto cleanup;
       if (m == MATCH_NO)
 	goto syntax;
 
-      if (head == NULL)
-	head = new_cons;
-      else
-	tail->next = new_cons;
-
-      tail = new_cons;
-
       if (gfc_match_char (',') == MATCH_NO)
 	break;
     }
@@ -1197,24 +1032,19 @@ gfc_match_array_constructor (gfc_expr **result)
     goto syntax;
 
 done:
-  expr = gfc_get_expr ();
-
-  expr->expr_type = EXPR_ARRAY;
-
-  expr->value.constructor = head;
   /* Size must be calculated at resolution time.  */
-
   if (seen_ts)
-    expr->ts = ts;
+    {
+      expr = gfc_get_array_expr (ts.type, ts.kind, &where);
+      expr->ts = ts;
+    }
   else
-    expr->ts.type = BT_UNKNOWN;
-  
+    expr = gfc_get_array_expr (BT_UNKNOWN, 0, &where);
+
+  expr->value.constructor = head;
   if (expr->ts.u.cl)
     expr->ts.u.cl->length_from_typespec = seen_ts;
 
-  expr->where = where;
-  expr->rank = 1;
-
   *result = expr;
   return MATCH_YES;
 
@@ -1222,7 +1052,7 @@ syntax:
   gfc_error ("Syntax error in array constructor at %C");
 
 cleanup:
-  gfc_free_constructor (head);
+  gfc_constructor_free (head);
   return MATCH_ERROR;
 }
 
@@ -1278,11 +1108,12 @@ check_element_type (gfc_expr *expr, bool convert)
 /* Recursive work function for gfc_check_constructor_type().  */
 
 static gfc_try
-check_constructor_type (gfc_constructor *c, bool convert)
+check_constructor_type (gfc_constructor_base base, bool convert)
 {
+  gfc_constructor *c;
   gfc_expr *e;
 
-  for (; c; c = c->next)
+  for (c = gfc_constructor_first (base); c; c = gfc_constructor_next (c))
     {
       e = c->expr;
 
@@ -1341,7 +1172,7 @@ cons_stack;
 
 static cons_stack *base;
 
-static gfc_try check_constructor (gfc_constructor *, gfc_try (*) (gfc_expr *));
+static gfc_try check_constructor (gfc_constructor_base, gfc_try (*) (gfc_expr *));
 
 /* Check an EXPR_VARIABLE expression in a constructor to make sure
    that that variable is an iteration variables.  */
@@ -1367,13 +1198,14 @@ gfc_check_iter_variable (gfc_expr *expr)
    constructor, giving variables with the names of iterators a pass.  */
 
 static gfc_try
-check_constructor (gfc_constructor *c, gfc_try (*check_function) (gfc_expr *))
+check_constructor (gfc_constructor_base ctor, gfc_try (*check_function) (gfc_expr *))
 {
   cons_stack element;
   gfc_expr *e;
   gfc_try t;
+  gfc_constructor *c;
 
-  for (; c; c = c->next)
+  for (c = gfc_constructor_first (ctor); c; c = gfc_constructor_next (c))
     {
       e = c->expr;
 
@@ -1427,7 +1259,7 @@ iterator_stack *iter_stack;
 
 typedef struct
 {
-  gfc_constructor *new_head, *new_tail;
+  gfc_constructor_base base;
   int extract_count, extract_n;
   gfc_expr *extracted;
   mpz_t *count;
@@ -1442,7 +1274,7 @@ expand_info;
 
 static expand_info current_expand;
 
-static gfc_try expand_constructor (gfc_constructor *);
+static gfc_try expand_constructor (gfc_constructor_base);
 
 
 /* Work function that counts the number of elements present in a
@@ -1501,21 +1333,10 @@ extract_element (gfc_expr *e)
 static gfc_try
 expand (gfc_expr *e)
 {
-  if (current_expand.new_head == NULL)
-    current_expand.new_head = current_expand.new_tail =
-      gfc_get_constructor ();
-  else
-    {
-      current_expand.new_tail->next = gfc_get_constructor ();
-      current_expand.new_tail = current_expand.new_tail->next;
-    }
+  gfc_constructor *c = gfc_constructor_append_expr (&current_expand.base,
+						    e, &e->where);
 
-  current_expand.new_tail->where = e->where;
-  current_expand.new_tail->expr = e;
-
-  mpz_set (current_expand.new_tail->n.offset, *current_expand.offset);
-  current_expand.new_tail->n.component = current_expand.component;
-  mpz_set (current_expand.new_tail->repeat, *current_expand.repeat);
+  c->n.component = current_expand.component;
   return SUCCESS;
 }
 
@@ -1535,7 +1356,7 @@ gfc_simplify_iterator_var (gfc_expr *e)
   if (p == NULL)
     return;		/* Variable not found */
 
-  gfc_replace_expr (e, gfc_int_expr (0));
+  gfc_replace_expr (e, gfc_get_int_expr (gfc_default_integer_kind, NULL, 0));
 
   mpz_set (e->value.integer, p->value);
 
@@ -1649,11 +1470,12 @@ cleanup:
    passed expression.  */
 
 static gfc_try
-expand_constructor (gfc_constructor *c)
+expand_constructor (gfc_constructor_base base)
 {
+  gfc_constructor *c;
   gfc_expr *e;
 
-  for (; c; c = c->next)
+  for (c = gfc_constructor_first (base); c; c = gfc_constructor_next(c))
     {
       if (c->iterator != NULL)
 	{
@@ -1678,9 +1500,9 @@ expand_constructor (gfc_constructor *c)
 	  gfc_free_expr (e);
 	  return FAILURE;
 	}
-      current_expand.offset = &c->n.offset;
-      current_expand.component = c->n.component;
+      current_expand.offset = &c->offset;
       current_expand.repeat = &c->repeat;
+      current_expand.component = c->n.component;
       if (current_expand.expand_work_function (e) == FAILURE)
 	return FAILURE;
     }
@@ -1688,6 +1510,39 @@ expand_constructor (gfc_constructor *c)
 }
 
 
+/* Given an array expression and an element number (starting at zero),
+   return a pointer to the array element.  NULL is returned if the
+   size of the array has been exceeded.  The expression node returned
+   remains a part of the array and should not be freed.  Access is not
+   efficient at all, but this is another place where things do not
+   have to be particularly fast.  */
+
+static gfc_expr *
+gfc_get_array_element (gfc_expr *array, int element)
+{
+  expand_info expand_save;
+  gfc_expr *e;
+  gfc_try rc;
+
+  expand_save = current_expand;
+  current_expand.extract_n = element;
+  current_expand.expand_work_function = extract_element;
+  current_expand.extracted = NULL;
+  current_expand.extract_count = 0;
+
+  iter_stack = NULL;
+
+  rc = expand_constructor (array->value.constructor);
+  e = current_expand.extracted;
+  current_expand = expand_save;
+
+  if (rc == FAILURE)
+    return NULL;
+
+  return e;
+}
+
+
 /* Top level subroutine for expanding constructors.  We only expand
    constructor if they are small enough.  */
 
@@ -1698,6 +1553,8 @@ gfc_expand_constructor (gfc_expr *e)
   gfc_expr *f;
   gfc_try rc;
 
+  /* If we can successfully get an array element at the max array size then
+     the array is too big to expand, so we just return.  */
   f = gfc_get_array_element (e, gfc_option.flag_max_array_constructor);
   if (f != NULL)
     {
@@ -1705,8 +1562,9 @@ gfc_expand_constructor (gfc_expr *e)
       return SUCCESS;
     }
 
+  /* We now know the array is not too big so go ahead and try to expand it.  */
   expand_save = current_expand;
-  current_expand.new_head = current_expand.new_tail = NULL;
+  current_expand.base = NULL;
 
   iter_stack = NULL;
 
@@ -1714,13 +1572,13 @@ gfc_expand_constructor (gfc_expr *e)
 
   if (expand_constructor (e->value.constructor) == FAILURE)
     {
-      gfc_free_constructor (current_expand.new_head);
+      gfc_constructor_free (current_expand.base);
       rc = FAILURE;
       goto done;
     }
 
-  gfc_free_constructor (e->value.constructor);
-  e->value.constructor = current_expand.new_head;
+  gfc_constructor_free (e->value.constructor);
+  e->value.constructor = current_expand.base;
 
   rc = SUCCESS;
 
@@ -1758,37 +1616,14 @@ gfc_constant_ac (gfc_expr *e)
 {
   expand_info expand_save;
   gfc_try rc;
-  gfc_constructor * con;
-  
-  rc = SUCCESS;
 
-  if (e->value.constructor
-      && e->value.constructor->expr->expr_type == EXPR_ARRAY)
-    {
-      /* Expand the constructor.  */
-      iter_stack = NULL;
-      expand_save = current_expand;
-      current_expand.expand_work_function = is_constant_element;
+  iter_stack = NULL;
+  expand_save = current_expand;
+  current_expand.expand_work_function = is_constant_element;
 
-      rc = expand_constructor (e->value.constructor);
-
-      current_expand = expand_save;
-    }
-  else
-    {
-      /* No need to expand this further.  */
-      for (con = e->value.constructor; con; con = con->next)
-	{
-	  if (con->expr->expr_type == EXPR_CONSTANT)
-	    continue;
-	  else
-	    {
-	      if (!gfc_is_constant_expr (con->expr))
-		rc = FAILURE;
-	    }
-	}
-    }
+  rc = expand_constructor (e->value.constructor);
 
+  current_expand = expand_save;
   if (rc == FAILURE)
     return 0;
 
@@ -1802,11 +1637,12 @@ gfc_constant_ac (gfc_expr *e)
 int
 gfc_expanded_ac (gfc_expr *e)
 {
-  gfc_constructor *p;
+  gfc_constructor *c;
 
   if (e->expr_type == EXPR_ARRAY)
-    for (p = e->value.constructor; p; p = p->next)
-      if (p->iterator != NULL || !gfc_expanded_ac (p->expr))
+    for (c = gfc_constructor_first (e->value.constructor);
+	 c; c = gfc_constructor_next (c))
+      if (c->iterator != NULL || !gfc_expanded_ac (c->expr))
 	return 0;
 
   return 1;
@@ -1819,19 +1655,20 @@ gfc_expanded_ac (gfc_expr *e)
    be of the same type.  */
 
 static gfc_try
-resolve_array_list (gfc_constructor *p)
+resolve_array_list (gfc_constructor_base base)
 {
   gfc_try t;
+  gfc_constructor *c;
 
   t = SUCCESS;
 
-  for (; p; p = p->next)
+  for (c = gfc_constructor_first (base); c; c = gfc_constructor_next (c))
     {
-      if (p->iterator != NULL
-	  && gfc_resolve_iterator (p->iterator, false) == FAILURE)
+      if (c->iterator != NULL
+	  && gfc_resolve_iterator (c->iterator, false) == FAILURE)
 	t = FAILURE;
 
-      if (gfc_resolve_expr (p->expr) == FAILURE)
+      if (gfc_resolve_expr (c->expr) == FAILURE)
 	t = FAILURE;
     }
 
@@ -1854,7 +1691,8 @@ gfc_resolve_character_array_constructor (gfc_expr *expr)
 
   if (expr->ts.u.cl == NULL)
     {
-      for (p = expr->value.constructor; p; p = p->next)
+      for (p = gfc_constructor_first (expr->value.constructor);
+	   p; p = gfc_constructor_next (p))
 	if (p->expr->ts.u.cl != NULL)
 	  {
 	    /* Ensure that if there is a char_len around that it is
@@ -1875,7 +1713,8 @@ got_charlen:
       /* Check that all constant string elements have the same length until
 	 we reach the end or find a variable-length one.  */
 
-      for (p = expr->value.constructor; p; p = p->next)
+      for (p = gfc_constructor_first (expr->value.constructor);
+	   p; p = gfc_constructor_next (p))
 	{
 	  int current_length = -1;
 	  gfc_ref *ref;
@@ -1922,7 +1761,8 @@ got_charlen:
       gcc_assert (found_length != -1);
 
       /* Update the character length of the array constructor.  */
-      expr->ts.u.cl->length = gfc_int_expr (found_length);
+      expr->ts.u.cl->length = gfc_get_int_expr (gfc_default_integer_kind,
+						NULL, found_length);
     }
   else 
     {
@@ -1940,7 +1780,8 @@ got_charlen:
 	 (without typespec) all elements are verified to have the same length
 	 anyway.  */
       if (found_length != -1)
-	for (p = expr->value.constructor; p; p = p->next)
+	for (p = gfc_constructor_first (expr->value.constructor);
+	     p; p = gfc_constructor_next (p))
 	  if (p->expr->expr_type == EXPR_CONSTANT)
 	    {
 	      gfc_expr *cl = NULL;
@@ -1990,8 +1831,8 @@ gfc_resolve_array_constructor (gfc_expr *expr)
 
 /* Copy an iterator structure.  */
 
-static gfc_iterator *
-copy_iterator (gfc_iterator *src)
+gfc_iterator *
+gfc_copy_iterator (gfc_iterator *src)
 {
   gfc_iterator *dest;
 
@@ -2009,73 +1850,6 @@ copy_iterator (gfc_iterator *src)
 }
 
 
-/* Copy a constructor structure.  */
-
-gfc_constructor *
-gfc_copy_constructor (gfc_constructor *src)
-{
-  gfc_constructor *dest;
-  gfc_constructor *tail;
-
-  if (src == NULL)
-    return NULL;
-
-  dest = tail = NULL;
-  while (src)
-    {
-      if (dest == NULL)
-	dest = tail = gfc_get_constructor ();
-      else
-	{
-	  tail->next = gfc_get_constructor ();
-	  tail = tail->next;
-	}
-      tail->where = src->where;
-      tail->expr = gfc_copy_expr (src->expr);
-      tail->iterator = copy_iterator (src->iterator);
-      mpz_set (tail->n.offset, src->n.offset);
-      tail->n.component = src->n.component;
-      mpz_set (tail->repeat, src->repeat);
-      src = src->next;
-    }
-
-  return dest;
-}
-
-
-/* Given an array expression and an element number (starting at zero),
-   return a pointer to the array element.  NULL is returned if the
-   size of the array has been exceeded.  The expression node returned
-   remains a part of the array and should not be freed.  Access is not
-   efficient at all, but this is another place where things do not
-   have to be particularly fast.  */
-
-gfc_expr *
-gfc_get_array_element (gfc_expr *array, int element)
-{
-  expand_info expand_save;
-  gfc_expr *e;
-  gfc_try rc;
-
-  expand_save = current_expand;
-  current_expand.extract_n = element;
-  current_expand.expand_work_function = extract_element;
-  current_expand.extracted = NULL;
-  current_expand.extract_count = 0;
-
-  iter_stack = NULL;
-
-  rc = expand_constructor (array->value.constructor);
-  e = current_expand.extracted;
-  current_expand = expand_save;
-
-  if (rc == FAILURE)
-    return NULL;
-
-  return e;
-}
-
-
 /********* Subroutines for determining the size of an array *********/
 
 /* These are needed just to accommodate RESHAPE().  There are no