[thirdparty/gcc.git] / libgfortran / generated / maxval_r10.c

/* Implementation of the MAXVAL intrinsic
   Copyright 2002, 2007 Free Software Foundation, Inc.
   Contributed by Paul Brook <paul@nowt.org>

This file is part of the GNU Fortran 95 runtime library (libgfortran).

Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.

In addition to the permissions in the GNU General Public License, the
Free Software Foundation gives you unlimited permission to link the
compiled version of this file into combinations with other programs,
and to distribute those combinations without any restriction coming
from the use of this file.  (The General Public License restrictions
do apply in other respects; for example, they cover modification of
the file, and distribution when not linked into a combine
executable.)

Libgfortran is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public
License along with libgfortran; see the file COPYING.  If not,
write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.  */

#include "libgfortran.h"
#include <stdlib.h>
#include <assert.h>


#if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_REAL_10)


extern void maxval_r10 (gfc_array_r10 * const restrict, 
	gfc_array_r10 * const restrict, const index_type * const restrict);
export_proto(maxval_r10);

void
maxval_r10 (gfc_array_r10 * const restrict retarray, 
	gfc_array_r10 * const restrict array, 
	const index_type * const restrict pdim)
{
  index_type count[GFC_MAX_DIMENSIONS];
  index_type extent[GFC_MAX_DIMENSIONS];
  index_type sstride[GFC_MAX_DIMENSIONS];
  index_type dstride[GFC_MAX_DIMENSIONS];
  const GFC_REAL_10 * restrict base;
  GFC_REAL_10 * restrict dest;
  index_type rank;
  index_type n;
  index_type len;
  index_type delta;
  index_type dim;

  /* Make dim zero based to avoid confusion.  */
  dim = (*pdim) - 1;
  rank = GFC_DESCRIPTOR_RANK (array) - 1;

  len = array->dim[dim].ubound + 1 - array->dim[dim].lbound;
  delta = array->dim[dim].stride;

  for (n = 0; n < dim; n++)
    {
      sstride[n] = array->dim[n].stride;
      extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;

      if (extent[n] < 0)
	extent[n] = 0;
    }
  for (n = dim; n < rank; n++)
    {
      sstride[n] = array->dim[n + 1].stride;
      extent[n] =
        array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;

      if (extent[n] < 0)
	extent[n] = 0;
    }

  if (retarray->data == NULL)
    {
      size_t alloc_size;

      for (n = 0; n < rank; n++)
        {
          retarray->dim[n].lbound = 0;
          retarray->dim[n].ubound = extent[n]-1;
          if (n == 0)
            retarray->dim[n].stride = 1;
          else
            retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
        }

      retarray->offset = 0;
      retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;

      alloc_size = sizeof (GFC_REAL_10) * retarray->dim[rank-1].stride
    		   * extent[rank-1];

      if (alloc_size == 0)
	{
	  /* Make sure we have a zero-sized array.  */
	  retarray->dim[0].lbound = 0;
	  retarray->dim[0].ubound = -1;
	  return;
	}
      else
	retarray->data = internal_malloc_size (alloc_size);
    }
  else
    {
      if (rank != GFC_DESCRIPTOR_RANK (retarray))
	runtime_error ("rank of return array incorrect in"
		       " MAXVAL intrinsic: is %d, should be %d",
		       GFC_DESCRIPTOR_RANK (retarray), rank);

      if (compile_options.bounds_check)
	{
	  for (n=0; n < rank; n++)
	    {
	      index_type ret_extent;

	      ret_extent = retarray->dim[n].ubound + 1
		- retarray->dim[n].lbound;
	      if (extent[n] != ret_extent)
		runtime_error ("Incorrect extent in return value of"
			       " MAXVAL intrinsic in dimension %d:"
			       " is %ld, should be %ld", n + 1,
			       (long int) ret_extent, (long int) extent[n]);
	    }
	}
    }

  for (n = 0; n < rank; n++)
    {
      count[n] = 0;
      dstride[n] = retarray->dim[n].stride;
      if (extent[n] <= 0)
        len = 0;
    }

  base = array->data;
  dest = retarray->data;

  while (base)
    {
      const GFC_REAL_10 * restrict src;
      GFC_REAL_10 result;
      src = base;
      {

  result = -GFC_REAL_10_HUGE;
        if (len <= 0)
	  *dest = -GFC_REAL_10_HUGE;
	else
	  {
	    for (n = 0; n < len; n++, src += delta)
	      {

  if (*src > result)
    result = *src;
          }
	    *dest = result;
	  }
      }
      /* Advance to the next element.  */
      count[0]++;
      base += sstride[0];
      dest += dstride[0];
      n = 0;
      while (count[n] == extent[n])
        {
          /* When we get to the end of a dimension, reset it and increment
             the next dimension.  */
          count[n] = 0;
          /* We could precalculate these products, but this is a less
             frequently used path so probably not worth it.  */
          base -= sstride[n] * extent[n];
          dest -= dstride[n] * extent[n];
          n++;
          if (n == rank)
            {
              /* Break out of the look.  */
              base = NULL;
              break;
            }
          else
            {
              count[n]++;
              base += sstride[n];
              dest += dstride[n];
            }
        }
    }
}


extern void mmaxval_r10 (gfc_array_r10 * const restrict, 
	gfc_array_r10 * const restrict, const index_type * const restrict,
	gfc_array_l1 * const restrict);
export_proto(mmaxval_r10);

void
mmaxval_r10 (gfc_array_r10 * const restrict retarray, 
	gfc_array_r10 * const restrict array, 
	const index_type * const restrict pdim, 
	gfc_array_l1 * const restrict mask)
{
  index_type count[GFC_MAX_DIMENSIONS];
  index_type extent[GFC_MAX_DIMENSIONS];
  index_type sstride[GFC_MAX_DIMENSIONS];
  index_type dstride[GFC_MAX_DIMENSIONS];
  index_type mstride[GFC_MAX_DIMENSIONS];
  GFC_REAL_10 * restrict dest;
  const GFC_REAL_10 * restrict base;
  const GFC_LOGICAL_1 * restrict mbase;
  int rank;
  int dim;
  index_type n;
  index_type len;
  index_type delta;
  index_type mdelta;
  int mask_kind;

  dim = (*pdim) - 1;
  rank = GFC_DESCRIPTOR_RANK (array) - 1;

  len = array->dim[dim].ubound + 1 - array->dim[dim].lbound;
  if (len <= 0)
    return;

  mbase = mask->data;

  mask_kind = GFC_DESCRIPTOR_SIZE (mask);

  if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
      || mask_kind == 16
#endif
      )
    mbase = GFOR_POINTER_TO_L1 (mbase, mask_kind);
  else
    runtime_error ("Funny sized logical array");

  delta = array->dim[dim].stride;
  mdelta = mask->dim[dim].stride * mask_kind;

  for (n = 0; n < dim; n++)
    {
      sstride[n] = array->dim[n].stride;
      mstride[n] = mask->dim[n].stride * mask_kind;
      extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;

      if (extent[n] < 0)
	extent[n] = 0;

    }
  for (n = dim; n < rank; n++)
    {
      sstride[n] = array->dim[n + 1].stride;
      mstride[n] = mask->dim[n + 1].stride * mask_kind;
      extent[n] =
        array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;

      if (extent[n] < 0)
	extent[n] = 0;
    }

  if (retarray->data == NULL)
    {
      size_t alloc_size;

      for (n = 0; n < rank; n++)
        {
          retarray->dim[n].lbound = 0;
          retarray->dim[n].ubound = extent[n]-1;
          if (n == 0)
            retarray->dim[n].stride = 1;
          else
            retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
        }

      alloc_size = sizeof (GFC_REAL_10) * retarray->dim[rank-1].stride
    		   * extent[rank-1];

      retarray->offset = 0;
      retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;

      if (alloc_size == 0)
	{
	  /* Make sure we have a zero-sized array.  */
	  retarray->dim[0].lbound = 0;
	  retarray->dim[0].ubound = -1;
	  return;
	}
      else
	retarray->data = internal_malloc_size (alloc_size);

    }
  else
    {
      if (rank != GFC_DESCRIPTOR_RANK (retarray))
	runtime_error ("rank of return array incorrect in MAXVAL intrinsic");

      if (compile_options.bounds_check)
	{
	  for (n=0; n < rank; n++)
	    {
	      index_type ret_extent;

	      ret_extent = retarray->dim[n].ubound + 1
		- retarray->dim[n].lbound;
	      if (extent[n] != ret_extent)
		runtime_error ("Incorrect extent in return value of"
			       " MAXVAL intrinsic in dimension %d:"
			       " is %ld, should be %ld", n + 1,
			       (long int) ret_extent, (long int) extent[n]);
	    }
          for (n=0; n<= rank; n++)
            {
              index_type mask_extent, array_extent;

	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
	      if (array_extent != mask_extent)
		runtime_error ("Incorrect extent in MASK argument of"
			       " MAXVAL intrinsic in dimension %d:"
			       " is %ld, should be %ld", n + 1,
			       (long int) mask_extent, (long int) array_extent);
	    }
	}
    }

  for (n = 0; n < rank; n++)
    {
      count[n] = 0;
      dstride[n] = retarray->dim[n].stride;
      if (extent[n] <= 0)
        return;
    }

  dest = retarray->data;
  base = array->data;

  while (base)
    {
      const GFC_REAL_10 * restrict src;
      const GFC_LOGICAL_1 * restrict msrc;
      GFC_REAL_10 result;
      src = base;
      msrc = mbase;
      {

  result = -GFC_REAL_10_HUGE;
        if (len <= 0)
	  *dest = -GFC_REAL_10_HUGE;
	else
	  {
	    for (n = 0; n < len; n++, src += delta, msrc += mdelta)
	      {

  if (*msrc && *src > result)
    result = *src;
              }
	    *dest = result;
	  }
      }
      /* Advance to the next element.  */
      count[0]++;
      base += sstride[0];
      mbase += mstride[0];
      dest += dstride[0];
      n = 0;
      while (count[n] == extent[n])
        {
          /* When we get to the end of a dimension, reset it and increment
             the next dimension.  */
          count[n] = 0;
          /* We could precalculate these products, but this is a less
             frequently used path so probably not worth it.  */
          base -= sstride[n] * extent[n];
          mbase -= mstride[n] * extent[n];
          dest -= dstride[n] * extent[n];
          n++;
          if (n == rank)
            {
              /* Break out of the look.  */
              base = NULL;
              break;
            }
          else
            {
              count[n]++;
              base += sstride[n];
              mbase += mstride[n];
              dest += dstride[n];
            }
        }
    }
}


extern void smaxval_r10 (gfc_array_r10 * const restrict, 
	gfc_array_r10 * const restrict, const index_type * const restrict,
	GFC_LOGICAL_4 *);
export_proto(smaxval_r10);

void
smaxval_r10 (gfc_array_r10 * const restrict retarray, 
	gfc_array_r10 * const restrict array, 
	const index_type * const restrict pdim, 
	GFC_LOGICAL_4 * mask)
{
  index_type rank;
  index_type n;
  index_type dstride;
  GFC_REAL_10 *dest;

  if (*mask)
    {
      maxval_r10 (retarray, array, pdim);
      return;
    }
    rank = GFC_DESCRIPTOR_RANK (array);
  if (rank <= 0)
    runtime_error ("Rank of array needs to be > 0");

  if (retarray->data == NULL)
    {
      retarray->dim[0].lbound = 0;
      retarray->dim[0].ubound = rank-1;
      retarray->dim[0].stride = 1;
      retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
      retarray->offset = 0;
      retarray->data = internal_malloc_size (sizeof (GFC_REAL_10) * rank);
    }
  else
    {
      if (compile_options.bounds_check)
	{
	  int ret_rank;
	  index_type ret_extent;

	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
	  if (ret_rank != 1)
	    runtime_error ("rank of return array in MAXVAL intrinsic"
			   " should be 1, is %d", ret_rank);

	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
	    if (ret_extent != rank)
	      runtime_error ("dimension of return array incorrect");
	}
    }
    dstride = retarray->dim[0].stride;
    dest = retarray->data;

    for (n = 0; n < rank; n++)
      dest[n * dstride] = -GFC_REAL_10_HUGE ;
}

#endif
Commit	Line	Data
644cb69f	1	/* Implementation of the MAXVAL intrinsic
36ae8a61	2	Copyright 2002, 2007 Free Software Foundation, Inc.
644cb69f FXC	3	Contributed by Paul Brook <paul@nowt.org>
	4
	5	This file is part of the GNU Fortran 95 runtime library (libgfortran).
	6
	7	Libgfortran is free software; you can redistribute it and/or
	8	modify it under the terms of the GNU General Public
	9	License as published by the Free Software Foundation; either
	10	version 2 of the License, or (at your option) any later version.
	11
	12	In addition to the permissions in the GNU General Public License, the
	13	Free Software Foundation gives you unlimited permission to link the
	14	compiled version of this file into combinations with other programs,
	15	and to distribute those combinations without any restriction coming
	16	from the use of this file. (The General Public License restrictions
	17	do apply in other respects; for example, they cover modification of
	18	the file, and distribution when not linked into a combine
	19	executable.)
	20
	21	Libgfortran is distributed in the hope that it will be useful,
	22	but WITHOUT ANY WARRANTY; without even the implied warranty of
	23	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	24	GNU General Public License for more details.
	25
	26	You should have received a copy of the GNU General Public
	27	License along with libgfortran; see the file COPYING. If not,
	28	write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	29	Boston, MA 02110-1301, USA. */
	30
36ae8a61	31	#include "libgfortran.h"
644cb69f FXC	32	#include <stdlib.h>
644cb69f FXC	33	#include <assert.h>
644cb69f FXC	34
	35
	36	#if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_REAL_10)
	37
	38
64acfd99 JB	39	extern void maxval_r10 (gfc_array_r10 * const restrict,
64acfd99 JB	40	gfc_array_r10 * const restrict, const index_type * const restrict);
644cb69f FXC	41	export_proto(maxval_r10);
	42
	43	void
64acfd99 JB	44	maxval_r10 (gfc_array_r10 * const restrict retarray,
	45	gfc_array_r10 * const restrict array,
	46	const index_type * const restrict pdim)
644cb69f FXC	47	{
	48	index_type count[GFC_MAX_DIMENSIONS];
	49	index_type extent[GFC_MAX_DIMENSIONS];
	50	index_type sstride[GFC_MAX_DIMENSIONS];
	51	index_type dstride[GFC_MAX_DIMENSIONS];
64acfd99 JB	52	const GFC_REAL_10 * restrict base;
64acfd99 JB	53	GFC_REAL_10 * restrict dest;
644cb69f FXC	54	index_type rank;
	55	index_type n;
	56	index_type len;
	57	index_type delta;
	58	index_type dim;
	59
	60	/* Make dim zero based to avoid confusion. */
	61	dim = (*pdim) - 1;
	62	rank = GFC_DESCRIPTOR_RANK (array) - 1;
	63
644cb69f FXC	64	len = array->dim[dim].ubound + 1 - array->dim[dim].lbound;
	65	delta = array->dim[dim].stride;
	66
	67	for (n = 0; n < dim; n++)
	68	{
	69	sstride[n] = array->dim[n].stride;
	70	extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
80ee04b9 TK	71
	72	if (extent[n] < 0)
	73	extent[n] = 0;
644cb69f FXC	74	}
	75	for (n = dim; n < rank; n++)
	76	{
	77	sstride[n] = array->dim[n + 1].stride;
	78	extent[n] =
	79	array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
80ee04b9 TK	80
	81	if (extent[n] < 0)
	82	extent[n] = 0;
644cb69f FXC	83	}
	84
	85	if (retarray->data == NULL)
	86	{
80ee04b9 TK	87	size_t alloc_size;
80ee04b9 TK	88
644cb69f FXC	89	for (n = 0; n < rank; n++)
	90	{
	91	retarray->dim[n].lbound = 0;
	92	retarray->dim[n].ubound = extent[n]-1;
	93	if (n == 0)
	94	retarray->dim[n].stride = 1;
	95	else
	96	retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
	97	}
	98
644cb69f FXC	99	retarray->offset = 0;
644cb69f FXC	100	retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) \| rank;
80ee04b9 TK	101
	102	alloc_size = sizeof (GFC_REAL_10) * retarray->dim[rank-1].stride
	103	* extent[rank-1];
	104
	105	if (alloc_size == 0)
	106	{
	107	/* Make sure we have a zero-sized array. */
	108	retarray->dim[0].lbound = 0;
	109	retarray->dim[0].ubound = -1;
	110	return;
	111	}
	112	else
	113	retarray->data = internal_malloc_size (alloc_size);
644cb69f FXC	114	}
	115	else
	116	{
644cb69f	117	if (rank != GFC_DESCRIPTOR_RANK (retarray))
fd6590f8 TK	118	runtime_error ("rank of return array incorrect in"
	119	" MAXVAL intrinsic: is %d, should be %d",
	120	GFC_DESCRIPTOR_RANK (retarray), rank);
	121
	122	if (compile_options.bounds_check)
	123	{
	124	for (n=0; n < rank; n++)
	125	{
	126	index_type ret_extent;
	127
	128	ret_extent = retarray->dim[n].ubound + 1
	129	- retarray->dim[n].lbound;
	130	if (extent[n] != ret_extent)
	131	runtime_error ("Incorrect extent in return value of"
	132	" MAXVAL intrinsic in dimension %d:"
	133	" is %ld, should be %ld", n + 1,
	134	(long int) ret_extent, (long int) extent[n]);
	135	}
	136	}
644cb69f FXC	137	}
	138
	139	for (n = 0; n < rank; n++)
	140	{
	141	count[n] = 0;
	142	dstride[n] = retarray->dim[n].stride;
	143	if (extent[n] <= 0)
	144	len = 0;
	145	}
	146
	147	base = array->data;
	148	dest = retarray->data;
	149
	150	while (base)
	151	{
64acfd99	152	const GFC_REAL_10 * restrict src;
644cb69f FXC	153	GFC_REAL_10 result;
	154	src = base;
	155	{
	156
	157	result = -GFC_REAL_10_HUGE;
	158	if (len <= 0)
	159	*dest = -GFC_REAL_10_HUGE;
	160	else
	161	{
	162	for (n = 0; n < len; n++, src += delta)
	163	{
	164
	165	if (*src > result)
	166	result = *src;
	167	}
	168	*dest = result;
	169	}
	170	}
	171	/* Advance to the next element. */
	172	count[0]++;
	173	base += sstride[0];
	174	dest += dstride[0];
	175	n = 0;
	176	while (count[n] == extent[n])
	177	{
	178	/* When we get to the end of a dimension, reset it and increment
	179	the next dimension. */
	180	count[n] = 0;
	181	/* We could precalculate these products, but this is a less
5d7adf7a	182	frequently used path so probably not worth it. */
644cb69f FXC	183	base -= sstride[n] * extent[n];
	184	dest -= dstride[n] * extent[n];
	185	n++;
	186	if (n == rank)
	187	{
	188	/* Break out of the look. */
	189	base = NULL;
	190	break;
	191	}
	192	else
	193	{
	194	count[n]++;
	195	base += sstride[n];
	196	dest += dstride[n];
	197	}
	198	}
	199	}
	200	}
	201
	202
64acfd99 JB	203	extern void mmaxval_r10 (gfc_array_r10 * const restrict,
64acfd99 JB	204	gfc_array_r10 * const restrict, const index_type * const restrict,
28dc6b33	205	gfc_array_l1 * const restrict);
644cb69f FXC	206	export_proto(mmaxval_r10);
	207
	208	void
64acfd99 JB	209	mmaxval_r10 (gfc_array_r10 * const restrict retarray,
	210	gfc_array_r10 * const restrict array,
	211	const index_type * const restrict pdim,
28dc6b33	212	gfc_array_l1 * const restrict mask)
644cb69f FXC	213	{
	214	index_type count[GFC_MAX_DIMENSIONS];
	215	index_type extent[GFC_MAX_DIMENSIONS];
	216	index_type sstride[GFC_MAX_DIMENSIONS];
	217	index_type dstride[GFC_MAX_DIMENSIONS];
	218	index_type mstride[GFC_MAX_DIMENSIONS];
64acfd99 JB	219	GFC_REAL_10 * restrict dest;
64acfd99 JB	220	const GFC_REAL_10 * restrict base;
28dc6b33	221	const GFC_LOGICAL_1 * restrict mbase;
644cb69f FXC	222	int rank;
	223	int dim;
	224	index_type n;
	225	index_type len;
	226	index_type delta;
	227	index_type mdelta;
28dc6b33	228	int mask_kind;
644cb69f FXC	229
	230	dim = (*pdim) - 1;
	231	rank = GFC_DESCRIPTOR_RANK (array) - 1;
	232
644cb69f FXC	233	len = array->dim[dim].ubound + 1 - array->dim[dim].lbound;
	234	if (len <= 0)
	235	return;
28dc6b33 TK	236
	237	mbase = mask->data;
	238
	239	mask_kind = GFC_DESCRIPTOR_SIZE (mask);
	240
	241	if (mask_kind == 1 \|\| mask_kind == 2 \|\| mask_kind == 4 \|\| mask_kind == 8
	242	#ifdef HAVE_GFC_LOGICAL_16
	243	\|\| mask_kind == 16
	244	#endif
	245	)
	246	mbase = GFOR_POINTER_TO_L1 (mbase, mask_kind);
	247	else
	248	runtime_error ("Funny sized logical array");
	249
644cb69f	250	delta = array->dim[dim].stride;
28dc6b33	251	mdelta = mask->dim[dim].stride * mask_kind;
644cb69f FXC	252
	253	for (n = 0; n < dim; n++)
	254	{
	255	sstride[n] = array->dim[n].stride;
28dc6b33	256	mstride[n] = mask->dim[n].stride * mask_kind;
644cb69f	257	extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
80ee04b9 TK	258
	259	if (extent[n] < 0)
	260	extent[n] = 0;
	261
644cb69f FXC	262	}
	263	for (n = dim; n < rank; n++)
	264	{
	265	sstride[n] = array->dim[n + 1].stride;
28dc6b33	266	mstride[n] = mask->dim[n + 1].stride * mask_kind;
644cb69f FXC	267	extent[n] =
644cb69f FXC	268	array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
80ee04b9 TK	269
	270	if (extent[n] < 0)
	271	extent[n] = 0;
644cb69f FXC	272	}
	273
	274	if (retarray->data == NULL)
	275	{
80ee04b9 TK	276	size_t alloc_size;
80ee04b9 TK	277
644cb69f FXC	278	for (n = 0; n < rank; n++)
	279	{
	280	retarray->dim[n].lbound = 0;
	281	retarray->dim[n].ubound = extent[n]-1;
	282	if (n == 0)
	283	retarray->dim[n].stride = 1;
	284	else
	285	retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
	286	}
	287
80ee04b9 TK	288	alloc_size = sizeof (GFC_REAL_10) * retarray->dim[rank-1].stride
	289	* extent[rank-1];
	290
644cb69f FXC	291	retarray->offset = 0;
644cb69f FXC	292	retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) \| rank;
80ee04b9 TK	293
	294	if (alloc_size == 0)
	295	{
	296	/* Make sure we have a zero-sized array. */
	297	retarray->dim[0].lbound = 0;
	298	retarray->dim[0].ubound = -1;
	299	return;
	300	}
	301	else
	302	retarray->data = internal_malloc_size (alloc_size);
	303
644cb69f FXC	304	}
	305	else
	306	{
644cb69f	307	if (rank != GFC_DESCRIPTOR_RANK (retarray))
fd6590f8 TK	308	runtime_error ("rank of return array incorrect in MAXVAL intrinsic");
	309
	310	if (compile_options.bounds_check)
	311	{
	312	for (n=0; n < rank; n++)
	313	{
	314	index_type ret_extent;
	315
	316	ret_extent = retarray->dim[n].ubound + 1
	317	- retarray->dim[n].lbound;
	318	if (extent[n] != ret_extent)
	319	runtime_error ("Incorrect extent in return value of"
	320	" MAXVAL intrinsic in dimension %d:"
	321	" is %ld, should be %ld", n + 1,
	322	(long int) ret_extent, (long int) extent[n]);
	323	}
	324	for (n=0; n<= rank; n++)
	325	{
	326	index_type mask_extent, array_extent;
	327
	328	array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
	329	mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
	330	if (array_extent != mask_extent)
	331	runtime_error ("Incorrect extent in MASK argument of"
	332	" MAXVAL intrinsic in dimension %d:"
	333	" is %ld, should be %ld", n + 1,
	334	(long int) mask_extent, (long int) array_extent);
	335	}
	336	}
644cb69f FXC	337	}
	338
	339	for (n = 0; n < rank; n++)
	340	{
	341	count[n] = 0;
	342	dstride[n] = retarray->dim[n].stride;
	343	if (extent[n] <= 0)
	344	return;
	345	}
	346
	347	dest = retarray->data;
	348	base = array->data;
644cb69f FXC	349
	350	while (base)
	351	{
64acfd99	352	const GFC_REAL_10 * restrict src;
28dc6b33	353	const GFC_LOGICAL_1 * restrict msrc;
644cb69f FXC	354	GFC_REAL_10 result;
	355	src = base;
	356	msrc = mbase;
	357	{
	358
	359	result = -GFC_REAL_10_HUGE;
	360	if (len <= 0)
	361	*dest = -GFC_REAL_10_HUGE;
	362	else
	363	{
	364	for (n = 0; n < len; n++, src += delta, msrc += mdelta)
	365	{
	366
	367	if (msrc && src > result)
	368	result = *src;
	369	}
	370	*dest = result;
	371	}
	372	}
	373	/* Advance to the next element. */
	374	count[0]++;
	375	base += sstride[0];
	376	mbase += mstride[0];
	377	dest += dstride[0];
	378	n = 0;
	379	while (count[n] == extent[n])
	380	{
	381	/* When we get to the end of a dimension, reset it and increment
	382	the next dimension. */
	383	count[n] = 0;
	384	/* We could precalculate these products, but this is a less
5d7adf7a	385	frequently used path so probably not worth it. */
644cb69f FXC	386	base -= sstride[n] * extent[n];
	387	mbase -= mstride[n] * extent[n];
	388	dest -= dstride[n] * extent[n];
	389	n++;
	390	if (n == rank)
	391	{
	392	/* Break out of the look. */
	393	base = NULL;
	394	break;
	395	}
	396	else
	397	{
	398	count[n]++;
	399	base += sstride[n];
	400	mbase += mstride[n];
	401	dest += dstride[n];
	402	}
	403	}
	404	}
	405	}
	406
97a62038 TK	407
	408	extern void smaxval_r10 (gfc_array_r10 * const restrict,
	409	gfc_array_r10 * const restrict, const index_type * const restrict,
	410	GFC_LOGICAL_4 *);
	411	export_proto(smaxval_r10);
	412
	413	void
	414	smaxval_r10 (gfc_array_r10 * const restrict retarray,
	415	gfc_array_r10 * const restrict array,
	416	const index_type * const restrict pdim,
	417	GFC_LOGICAL_4 * mask)
	418	{
	419	index_type rank;
	420	index_type n;
	421	index_type dstride;
	422	GFC_REAL_10 *dest;
	423
	424	if (*mask)
	425	{
	426	maxval_r10 (retarray, array, pdim);
	427	return;
	428	}
	429	rank = GFC_DESCRIPTOR_RANK (array);
	430	if (rank <= 0)
	431	runtime_error ("Rank of array needs to be > 0");
	432
	433	if (retarray->data == NULL)
	434	{
	435	retarray->dim[0].lbound = 0;
	436	retarray->dim[0].ubound = rank-1;
	437	retarray->dim[0].stride = 1;
	438	retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) \| 1;
	439	retarray->offset = 0;
	440	retarray->data = internal_malloc_size (sizeof (GFC_REAL_10) * rank);
	441	}
	442	else
	443	{
fd6590f8 TK	444	if (compile_options.bounds_check)
	445	{
	446	int ret_rank;
	447	index_type ret_extent;
97a62038	448
fd6590f8 TK	449	ret_rank = GFC_DESCRIPTOR_RANK (retarray);
	450	if (ret_rank != 1)
	451	runtime_error ("rank of return array in MAXVAL intrinsic"
	452	" should be 1, is %d", ret_rank);
97a62038	453
fd6590f8 TK	454	ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
	455	if (ret_extent != rank)
	456	runtime_error ("dimension of return array incorrect");
	457	}
	458	}
97a62038 TK	459	dstride = retarray->dim[0].stride;
	460	dest = retarray->data;
	461
	462	for (n = 0; n < rank; n++)
	463	dest[n * dstride] = -GFC_REAL_10_HUGE ;
	464	}
	465
644cb69f	466	#endif