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

/* Implementation of the RESHAPE intrinsic
   Copyright (C) 2002-2019 Free Software Foundation, Inc.
   Contributed by Paul Brook <paul@nowt.org>

This file is part of the GNU Fortran 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 3 of the License, or (at your option) any later version.

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.

Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.

You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
<http://www.gnu.org/licenses/>.  */

#include "libgfortran.h"


#if defined (HAVE_GFC_INTEGER_8)

typedef GFC_FULL_ARRAY_DESCRIPTOR(1, index_type) shape_type;


extern void reshape_8 (gfc_array_i8 * const restrict, 
	gfc_array_i8 * const restrict, 
	shape_type * const restrict,
	gfc_array_i8 * const restrict, 
	shape_type * const restrict);
export_proto(reshape_8);

void
reshape_8 (gfc_array_i8 * const restrict ret, 
	gfc_array_i8 * const restrict source, 
	shape_type * const restrict shape,
	gfc_array_i8 * const restrict pad, 
	shape_type * const restrict order)
{
  /* r.* indicates the return array.  */
  index_type rcount[GFC_MAX_DIMENSIONS];
  index_type rextent[GFC_MAX_DIMENSIONS];
  index_type rstride[GFC_MAX_DIMENSIONS];
  index_type rstride0;
  index_type rdim;
  index_type rsize;
  index_type rs;
  index_type rex;
  GFC_INTEGER_8 *rptr;
  /* s.* indicates the source array.  */
  index_type scount[GFC_MAX_DIMENSIONS];
  index_type sextent[GFC_MAX_DIMENSIONS];
  index_type sstride[GFC_MAX_DIMENSIONS];
  index_type sstride0;
  index_type sdim;
  index_type ssize;
  const GFC_INTEGER_8 *sptr;
  /* p.* indicates the pad array.  */
  index_type pcount[GFC_MAX_DIMENSIONS];
  index_type pextent[GFC_MAX_DIMENSIONS];
  index_type pstride[GFC_MAX_DIMENSIONS];
  index_type pdim;
  index_type psize;
  const GFC_INTEGER_8 *pptr;

  const GFC_INTEGER_8 *src;
  int sempty, pempty, shape_empty;
  index_type shape_data[GFC_MAX_DIMENSIONS];

  rdim = GFC_DESCRIPTOR_EXTENT(shape,0);
  /* rdim is always > 0; this lets the compiler optimize more and
   avoids a potential warning.  */
  GFC_ASSERT(rdim>0);

  if (rdim != GFC_DESCRIPTOR_RANK(ret))
    runtime_error("rank of return array incorrect in RESHAPE intrinsic");

  shape_empty = 0;

  for (index_type n = 0; n < rdim; n++)
    {
      shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
      if (shape_data[n] <= 0)
      {
        shape_data[n] = 0;
	shape_empty = 1;
      }
    }

  if (ret->base_addr == NULL)
    {
      index_type alloc_size;

      rs = 1;
      for (index_type n = 0; n < rdim; n++)
	{
	  rex = shape_data[n];

	  GFC_DIMENSION_SET(ret->dim[n], 0, rex - 1, rs);

	  rs *= rex;
	}
      ret->offset = 0;

      if (unlikely (rs < 1))
        alloc_size = 0;
      else
        alloc_size = rs;

      ret->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
      ret->dtype.rank = rdim;
    }

  if (shape_empty)
    return;

  if (pad)
    {
      pdim = GFC_DESCRIPTOR_RANK (pad);
      psize = 1;
      pempty = 0;
      for (index_type n = 0; n < pdim; n++)
        {
          pcount[n] = 0;
          pstride[n] = GFC_DESCRIPTOR_STRIDE(pad,n);
          pextent[n] = GFC_DESCRIPTOR_EXTENT(pad,n);
          if (pextent[n] <= 0)
	    {
	      pempty = 1;
	      pextent[n] = 0;
	    }

          if (psize == pstride[n])
            psize *= pextent[n];
          else
            psize = 0;
        }
      pptr = pad->base_addr;
    }
  else
    {
      pdim = 0;
      psize = 1;
      pempty = 1;
      pptr = NULL;
    }

  if (unlikely (compile_options.bounds_check))
    {
      index_type ret_extent, source_extent;

      rs = 1;
      for (index_type n = 0; n < rdim; n++)
	{
	  rs *= shape_data[n];
	  ret_extent = GFC_DESCRIPTOR_EXTENT(ret,n);
	  if (ret_extent != shape_data[n])
	    runtime_error("Incorrect extent in return value of RESHAPE"
			  " intrinsic in dimension %ld: is %ld,"
			  " should be %ld", (long int) n+1,
			  (long int) ret_extent, (long int) shape_data[n]);
	}

      source_extent = 1;
      sdim = GFC_DESCRIPTOR_RANK (source);
      for (index_type n = 0; n < sdim; n++)
	{
	  index_type se;
	  se = GFC_DESCRIPTOR_EXTENT(source,n);
	  source_extent *= se > 0 ? se : 0;
	}

      if (rs > source_extent && (!pad || pempty))
	runtime_error("Incorrect size in SOURCE argument to RESHAPE"
		      " intrinsic: is %ld, should be %ld",
		      (long int) source_extent, (long int) rs);

      if (order)
	{
	  int seen[GFC_MAX_DIMENSIONS];
	  index_type v;

	  for (index_type n = 0; n < rdim; n++)
	    seen[n] = 0;

	  for (index_type n = 0; n < rdim; n++)
	    {
	      v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;

	      if (v < 0 || v >= rdim)
		runtime_error("Value %ld out of range in ORDER argument"
			      " to RESHAPE intrinsic", (long int) v + 1);

	      if (seen[v] != 0)
		runtime_error("Duplicate value %ld in ORDER argument to"
			      " RESHAPE intrinsic", (long int) v + 1);
		
	      seen[v] = 1;
	    }
	}
    }

  rsize = 1;
  for (index_type n = 0; n < rdim; n++)
    {
      index_type dim;
      if (order)
        dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
      else
        dim = n;

      rcount[n] = 0;
      rstride[n] = GFC_DESCRIPTOR_STRIDE(ret,dim);
      rextent[n] = GFC_DESCRIPTOR_EXTENT(ret,dim);
      if (rextent[n] < 0)
        rextent[n] = 0;

      if (rextent[n] != shape_data[dim])
        runtime_error ("shape and target do not conform");

      if (rsize == rstride[n])
        rsize *= rextent[n];
      else
        rsize = 0;
      if (rextent[n] <= 0)
        return;
    }

  sdim = GFC_DESCRIPTOR_RANK (source);

  /* sdim is always > 0; this lets the compiler optimize more and
   avoids a warning.  */
  GFC_ASSERT(sdim>0);

  ssize = 1;
  sempty = 0;
  for (index_type n = 0; n < sdim; n++)
    {
      scount[n] = 0;
      sstride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
      sextent[n] = GFC_DESCRIPTOR_EXTENT(source,n);
      if (sextent[n] <= 0)
	{
	  sempty = 1;
	  sextent[n] = 0;
	}

      if (ssize == sstride[n])
        ssize *= sextent[n];
      else
        ssize = 0;
    }

  if (rsize != 0 && ssize != 0 && psize != 0)
    {
      rsize *= sizeof (GFC_INTEGER_8);
      ssize *= sizeof (GFC_INTEGER_8);
      psize *= sizeof (GFC_INTEGER_8);
      reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
		      ssize, pad ? (char *)pad->base_addr : NULL, psize);
      return;
    }
  rptr = ret->base_addr;
  src = sptr = source->base_addr;
  rstride0 = rstride[0];
  sstride0 = sstride[0];

  if (sempty && pempty)
    abort ();

  if (sempty)
    {
      /* Pretend we are using the pad array the first time around, too.  */
      src = pptr;
      sptr = pptr;
      sdim = pdim;
      for (index_type dim = 0; dim < pdim; dim++)
	{
	  scount[dim] = pcount[dim];
	  sextent[dim] = pextent[dim];
	  sstride[dim] = pstride[dim];
	  sstride0 = pstride[0];
	}
    }

  while (rptr)
    {
      /* Select between the source and pad arrays.  */
      *rptr = *src;
      /* Advance to the next element.  */
      rptr += rstride0;
      src += sstride0;
      rcount[0]++;
      scount[0]++;

      /* Advance to the next destination element.  */
      index_type n = 0;
      while (rcount[n] == rextent[n])
        {
          /* When we get to the end of a dimension, reset it and increment
             the next dimension.  */
          rcount[n] = 0;
          /* We could precalculate these products, but this is a less
             frequently used path so probably not worth it.  */
          rptr -= rstride[n] * rextent[n];
          n++;
          if (n == rdim)
            {
              /* Break out of the loop.  */
              rptr = NULL;
              break;
            }
          else
            {
              rcount[n]++;
              rptr += rstride[n];
            }
        }
      /* Advance to the next source element.  */
      n = 0;
      while (scount[n] == sextent[n])
        {
          /* When we get to the end of a dimension, reset it and increment
             the next dimension.  */
          scount[n] = 0;
          /* We could precalculate these products, but this is a less
             frequently used path so probably not worth it.  */
          src -= sstride[n] * sextent[n];
          n++;
          if (n == sdim)
            {
              if (sptr && pad)
                {
                  /* Switch to the pad array.  */
                  sptr = NULL;
                  sdim = pdim;
                  for (index_type dim = 0; dim < pdim; dim++)
                    {
                      scount[dim] = pcount[dim];
                      sextent[dim] = pextent[dim];
                      sstride[dim] = pstride[dim];
                      sstride0 = sstride[0];
                    }
                }
              /* We now start again from the beginning of the pad array.  */
              src = pptr;
              break;
            }
          else
            {
              scount[n]++;
              src += sstride[n];
            }
        }
    }
}

#endif
Commit	Line	Data
827aef63	1	/* Implementation of the RESHAPE intrinsic
fbd26352	2	Copyright (C) 2002-2019 Free Software Foundation, Inc.
4ee9c684	3	Contributed by Paul Brook <paul@nowt.org>
4ee9c684	4
553877d9	5	This file is part of the GNU Fortran runtime library (libgfortran).
4ee9c684	6
b417ea8c	7	Libgfortran is free software; you can redistribute it and/or
b417ea8c	8	modify it under the terms of the GNU General Public
4ee9c684	9	License as published by the Free Software Foundation; either
6bc9506f	10	version 3 of the License, or (at your option) any later version.
b417ea8c	11
b417ea8c	12	Libgfortran is distributed in the hope that it will be useful,
4ee9c684	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
4ee9c684	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
b417ea8c	15	GNU General Public License for more details.
4ee9c684	16
6bc9506f	17	Under Section 7 of GPL version 3, you are granted additional
	18	permissions described in the GCC Runtime Library Exception, version
	19	3.1, as published by the Free Software Foundation.
	20
	21	You should have received a copy of the GNU General Public License and
	22	a copy of the GCC Runtime Library Exception along with this program;
	23	see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
	24	<http://www.gnu.org/licenses/>. */
4ee9c684	25
41f2d5e8	26	#include "libgfortran.h"
41f2d5e8	27
4ee9c684	28
920e54ef	29	#if defined (HAVE_GFC_INTEGER_8)
920e54ef	30
6fae9f17	31	typedef GFC_FULL_ARRAY_DESCRIPTOR(1, index_type) shape_type;
4ee9c684	32
7b6cb5bd	33
b4cafd67	34	extern void reshape_8 (gfc_array_i8 * const restrict,
	35	gfc_array_i8 * const restrict,
	36	shape_type * const restrict,
	37	gfc_array_i8 * const restrict,
	38	shape_type * const restrict);
820b4fbd	39	export_proto(reshape_8);
7b6cb5bd	40
4ee9c684	41	void
b4cafd67	42	reshape_8 (gfc_array_i8 * const restrict ret,
	43	gfc_array_i8 * const restrict source,
	44	shape_type * const restrict shape,
	45	gfc_array_i8 * const restrict pad,
	46	shape_type * const restrict order)
4ee9c684	47	{
4ee9c684	48	/* r.* indicates the return array. */
2be2fbdf	49	index_type rcount[GFC_MAX_DIMENSIONS];
	50	index_type rextent[GFC_MAX_DIMENSIONS];
	51	index_type rstride[GFC_MAX_DIMENSIONS];
4ee9c684	52	index_type rstride0;
	53	index_type rdim;
	54	index_type rsize;
93c57576	55	index_type rs;
93c57576	56	index_type rex;
4ee9c684	57	GFC_INTEGER_8 *rptr;
4ee9c684	58	/* s.* indicates the source array. */
2be2fbdf	59	index_type scount[GFC_MAX_DIMENSIONS];
	60	index_type sextent[GFC_MAX_DIMENSIONS];
	61	index_type sstride[GFC_MAX_DIMENSIONS];
4ee9c684	62	index_type sstride0;
	63	index_type sdim;
	64	index_type ssize;
	65	const GFC_INTEGER_8 *sptr;
	66	/* p.* indicates the pad array. */
2be2fbdf	67	index_type pcount[GFC_MAX_DIMENSIONS];
	68	index_type pextent[GFC_MAX_DIMENSIONS];
	69	index_type pstride[GFC_MAX_DIMENSIONS];
4ee9c684	70	index_type pdim;
	71	index_type psize;
	72	const GFC_INTEGER_8 *pptr;
	73
	74	const GFC_INTEGER_8 *src;
c808637e	75	int sempty, pempty, shape_empty;
	76	index_type shape_data[GFC_MAX_DIMENSIONS];
	77
827aef63	78	rdim = GFC_DESCRIPTOR_EXTENT(shape,0);
d0ccf356	79	/* rdim is always > 0; this lets the compiler optimize more and
d0ccf356	80	avoids a potential warning. */
f746796e	81	GFC_ASSERT(rdim>0);
d0ccf356	82
c808637e	83	if (rdim != GFC_DESCRIPTOR_RANK(ret))
	84	runtime_error("rank of return array incorrect in RESHAPE intrinsic");
	85
	86	shape_empty = 0;
	87
df52c9a4	88	for (index_type n = 0; n < rdim; n++)
c808637e	89	{
553877d9	90	shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
c808637e	91	if (shape_data[n] <= 0)
	92	{
	93	shape_data[n] = 0;
	94	shape_empty = 1;
	95	}
	96	}
4ee9c684	97
553877d9	98	if (ret->base_addr == NULL)
93c57576	99	{
568408e3	100	index_type alloc_size;
568408e3	101
93c57576	102	rs = 1;
df52c9a4	103	for (index_type n = 0; n < rdim; n++)
93c57576	104	{
c808637e	105	rex = shape_data[n];
827aef63	106
	107	GFC_DIMENSION_SET(ret->dim[n], 0, rex - 1, rs);
	108
93c57576	109	rs *= rex;
93c57576	110	}
93830de1	111	ret->offset = 0;
568408e3	112
568408e3	113	if (unlikely (rs < 1))
af1e9051	114	alloc_size = 0;
568408e3	115	else
af1e9051	116	alloc_size = rs;
568408e3	117
af1e9051	118	ret->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
0bb0be20	119	ret->dtype.rank = rdim;
93c57576	120	}
c808637e	121
	122	if (shape_empty)
	123	return;
93c57576	124
49ff3ac0	125	if (pad)
	126	{
	127	pdim = GFC_DESCRIPTOR_RANK (pad);
	128	psize = 1;
	129	pempty = 0;
df52c9a4	130	for (index_type n = 0; n < pdim; n++)
49ff3ac0	131	{
49ff3ac0	132	pcount[n] = 0;
827aef63	133	pstride[n] = GFC_DESCRIPTOR_STRIDE(pad,n);
827aef63	134	pextent[n] = GFC_DESCRIPTOR_EXTENT(pad,n);
49ff3ac0	135	if (pextent[n] <= 0)
	136	{
	137	pempty = 1;
	138	pextent[n] = 0;
	139	}
	140
	141	if (psize == pstride[n])
	142	psize *= pextent[n];
	143	else
	144	psize = 0;
	145	}
553877d9	146	pptr = pad->base_addr;
49ff3ac0	147	}
	148	else
	149	{
	150	pdim = 0;
	151	psize = 1;
	152	pempty = 1;
	153	pptr = NULL;
	154	}
	155
d5fc2c84	156	if (unlikely (compile_options.bounds_check))
d5fc2c84	157	{
80726d88	158	index_type ret_extent, source_extent;
	159
	160	rs = 1;
df52c9a4	161	for (index_type n = 0; n < rdim; n++)
80726d88	162	{
80726d88	163	rs *= shape_data[n];
827aef63	164	ret_extent = GFC_DESCRIPTOR_EXTENT(ret,n);
80726d88	165	if (ret_extent != shape_data[n])
	166	runtime_error("Incorrect extent in return value of RESHAPE"
	167	" intrinsic in dimension %ld: is %ld,"
	168	" should be %ld", (long int) n+1,
	169	(long int) ret_extent, (long int) shape_data[n]);
	170	}
	171
aeef0389	172	source_extent = 1;
aeef0389	173	sdim = GFC_DESCRIPTOR_RANK (source);
df52c9a4	174	for (index_type n = 0; n < sdim; n++)
aeef0389	175	{
aeef0389	176	index_type se;
827aef63	177	se = GFC_DESCRIPTOR_EXTENT(source,n);
aeef0389	178	source_extent *= se > 0 ? se : 0;
aeef0389	179	}
80726d88	180
49ff3ac0	181	if (rs > source_extent && (!pad \|\| pempty))
80726d88	182	runtime_error("Incorrect size in SOURCE argument to RESHAPE"
	183	" intrinsic: is %ld, should be %ld",
	184	(long int) source_extent, (long int) rs);
	185
d5fc2c84	186	if (order)
	187	{
	188	int seen[GFC_MAX_DIMENSIONS];
	189	index_type v;
	190
df52c9a4	191	for (index_type n = 0; n < rdim; n++)
d5fc2c84	192	seen[n] = 0;
d5fc2c84	193
df52c9a4	194	for (index_type n = 0; n < rdim; n++)
d5fc2c84	195	{
553877d9	196	v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
d5fc2c84	197
	198	if (v < 0 \|\| v >= rdim)
	199	runtime_error("Value %ld out of range in ORDER argument"
	200	" to RESHAPE intrinsic", (long int) v + 1);
	201
	202	if (seen[v] != 0)
	203	runtime_error("Duplicate value %ld in ORDER argument to"
	204	" RESHAPE intrinsic", (long int) v + 1);
	205
	206	seen[v] = 1;
	207	}
	208	}
	209	}
	210
4ee9c684	211	rsize = 1;
df52c9a4	212	for (index_type n = 0; n < rdim; n++)
4ee9c684	213	{
df52c9a4	214	index_type dim;
4ee9c684	215	if (order)
553877d9	216	dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
4ee9c684	217	else
	218	dim = n;
	219
	220	rcount[n] = 0;
827aef63	221	rstride[n] = GFC_DESCRIPTOR_STRIDE(ret,dim);
827aef63	222	rextent[n] = GFC_DESCRIPTOR_EXTENT(ret,dim);
c808637e	223	if (rextent[n] < 0)
2526e2bf	224	rextent[n] = 0;
4ee9c684	225
c808637e	226	if (rextent[n] != shape_data[dim])
4ee9c684	227	runtime_error ("shape and target do not conform");
	228
	229	if (rsize == rstride[n])
	230	rsize *= rextent[n];
	231	else
	232	rsize = 0;
93c57576	233	if (rextent[n] <= 0)
4ee9c684	234	return;
	235	}
	236
	237	sdim = GFC_DESCRIPTOR_RANK (source);
d0ccf356	238
	239	/* sdim is always > 0; this lets the compiler optimize more and
	240	avoids a warning. */
	241	GFC_ASSERT(sdim>0);
	242
4ee9c684	243	ssize = 1;
e7382835	244	sempty = 0;
df52c9a4	245	for (index_type n = 0; n < sdim; n++)
4ee9c684	246	{
4ee9c684	247	scount[n] = 0;
827aef63	248	sstride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
827aef63	249	sextent[n] = GFC_DESCRIPTOR_EXTENT(source,n);
4ee9c684	250	if (sextent[n] <= 0)
e7382835	251	{
	252	sempty = 1;
	253	sextent[n] = 0;
	254	}
4ee9c684	255
	256	if (ssize == sstride[n])
	257	ssize *= sextent[n];
	258	else
	259	ssize = 0;
	260	}
	261
4ee9c684	262	if (rsize != 0 && ssize != 0 && psize != 0)
4ee9c684	263	{
d8877715	264	rsize *= sizeof (GFC_INTEGER_8);
	265	ssize *= sizeof (GFC_INTEGER_8);
	266	psize *= sizeof (GFC_INTEGER_8);
553877d9	267	reshape_packed ((char )ret->base_addr, rsize, (char )source->base_addr,
553877d9	268	ssize, pad ? (char *)pad->base_addr : NULL, psize);
4ee9c684	269	return;
4ee9c684	270	}
553877d9	271	rptr = ret->base_addr;
553877d9	272	src = sptr = source->base_addr;
4ee9c684	273	rstride0 = rstride[0];
	274	sstride0 = sstride[0];
	275
e7382835	276	if (sempty && pempty)
	277	abort ();
	278
	279	if (sempty)
	280	{
d0b5b6ea	281	/* Pretend we are using the pad array the first time around, too. */
e7382835	282	src = pptr;
d0b5b6ea	283	sptr = pptr;
e7382835	284	sdim = pdim;
df52c9a4	285	for (index_type dim = 0; dim < pdim; dim++)
e7382835	286	{
	287	scount[dim] = pcount[dim];
	288	sextent[dim] = pextent[dim];
	289	sstride[dim] = pstride[dim];
d0b5b6ea	290	sstride0 = pstride[0];
e7382835	291	}
	292	}
	293
4ee9c684	294	while (rptr)
	295	{
	296	/* Select between the source and pad arrays. */
	297	rptr = src;
	298	/* Advance to the next element. */
	299	rptr += rstride0;
	300	src += sstride0;
	301	rcount[0]++;
	302	scount[0]++;
e7382835	303
4ee9c684	304	/* Advance to the next destination element. */
df52c9a4	305	index_type n = 0;
4ee9c684	306	while (rcount[n] == rextent[n])
	307	{
	308	/* When we get to the end of a dimension, reset it and increment
	309	the next dimension. */
	310	rcount[n] = 0;
	311	/* We could precalculate these products, but this is a less
e4f51eaa	312	frequently used path so probably not worth it. */
4ee9c684	313	rptr -= rstride[n] * rextent[n];
	314	n++;
	315	if (n == rdim)
	316	{
	317	/* Break out of the loop. */
	318	rptr = NULL;
	319	break;
	320	}
	321	else
	322	{
	323	rcount[n]++;
	324	rptr += rstride[n];
	325	}
	326	}
	327	/* Advance to the next source element. */
	328	n = 0;
	329	while (scount[n] == sextent[n])
	330	{
	331	/* When we get to the end of a dimension, reset it and increment
	332	the next dimension. */
	333	scount[n] = 0;
	334	/* We could precalculate these products, but this is a less
e4f51eaa	335	frequently used path so probably not worth it. */
4ee9c684	336	src -= sstride[n] * sextent[n];
	337	n++;
	338	if (n == sdim)
	339	{
	340	if (sptr && pad)
	341	{
	342	/* Switch to the pad array. */
	343	sptr = NULL;
	344	sdim = pdim;
df52c9a4	345	for (index_type dim = 0; dim < pdim; dim++)
4ee9c684	346	{
	347	scount[dim] = pcount[dim];
	348	sextent[dim] = pextent[dim];
	349	sstride[dim] = pstride[dim];
	350	sstride0 = sstride[0];
	351	}
	352	}
	353	/* We now start again from the beginning of the pad array. */
	354	src = pptr;
	355	break;
	356	}
	357	else
	358	{
	359	scount[n]++;
	360	src += sstride[n];
	361	}
	362	}
	363	}
	364	}
920e54ef	365
920e54ef	366	#endif