4534 lines
97 KiB
C
4534 lines
97 KiB
C
/* bld.c -- Implementation File (module.c template V1.0)
|
||
Copyright (C) 1995, 1996 Free Software Foundation, Inc.
|
||
Contributed by James Craig Burley.
|
||
|
||
This file is part of GNU Fortran.
|
||
|
||
GNU Fortran 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, or (at your option)
|
||
any later version.
|
||
|
||
GNU Fortran 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 GNU Fortran; see the file COPYING. If not, write to
|
||
the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
|
||
02111-1307, USA.
|
||
|
||
Related Modules:
|
||
None
|
||
|
||
Description:
|
||
The primary "output" of the FFE includes ffebld objects, which
|
||
connect expressions, operators, and operands together, along with
|
||
connecting lists of expressions together for argument or dimension
|
||
lists.
|
||
|
||
Modifications:
|
||
30-Aug-92 JCB 1.1
|
||
Change names of some things for consistency.
|
||
*/
|
||
|
||
/* Include files. */
|
||
|
||
#include "proj.h"
|
||
#include "bld.h"
|
||
#include "bit.h"
|
||
#include "info.h"
|
||
#include "lex.h"
|
||
#include "malloc.h"
|
||
#include "target.h"
|
||
#include "where.h"
|
||
#include "real.h"
|
||
|
||
/* Externals defined here. */
|
||
|
||
const ffebldArity ffebld_arity_op_[(int) FFEBLD_op]
|
||
=
|
||
{
|
||
#define FFEBLD_OP(KWD,NAME,ARITY) ARITY,
|
||
#include "bld-op.def"
|
||
#undef FFEBLD_OP
|
||
};
|
||
struct _ffebld_pool_stack_ ffebld_pool_stack_;
|
||
|
||
/* Simple definitions and enumerations. */
|
||
|
||
|
||
/* Internal typedefs. */
|
||
|
||
|
||
/* Private include files. */
|
||
|
||
|
||
/* Internal structure definitions. */
|
||
|
||
|
||
/* Static objects accessed by functions in this module. */
|
||
|
||
#if FFEBLD_BLANK_
|
||
static struct _ffebld_ ffebld_blank_
|
||
=
|
||
{
|
||
0,
|
||
{FFEINFO_basictypeNONE, FFEINFO_kindtypeNONE, 0, FFEINFO_kindNONE,
|
||
FFEINFO_whereNONE, FFETARGET_charactersizeNONE},
|
||
{NULL, NULL}
|
||
};
|
||
#endif
|
||
#if FFETARGET_okCHARACTER1
|
||
static ffebldConstant ffebld_constant_character1_;
|
||
#endif
|
||
#if FFETARGET_okCHARACTER2
|
||
static ffebldConstant ffebld_constant_character2_;
|
||
#endif
|
||
#if FFETARGET_okCHARACTER3
|
||
static ffebldConstant ffebld_constant_character3_;
|
||
#endif
|
||
#if FFETARGET_okCHARACTER4
|
||
static ffebldConstant ffebld_constant_character4_;
|
||
#endif
|
||
#if FFETARGET_okCHARACTER5
|
||
static ffebldConstant ffebld_constant_character5_;
|
||
#endif
|
||
#if FFETARGET_okCHARACTER6
|
||
static ffebldConstant ffebld_constant_character6_;
|
||
#endif
|
||
#if FFETARGET_okCHARACTER7
|
||
static ffebldConstant ffebld_constant_character7_;
|
||
#endif
|
||
#if FFETARGET_okCHARACTER8
|
||
static ffebldConstant ffebld_constant_character8_;
|
||
#endif
|
||
#if FFETARGET_okCOMPLEX1
|
||
static ffebldConstant ffebld_constant_complex1_;
|
||
#endif
|
||
#if FFETARGET_okCOMPLEX2
|
||
static ffebldConstant ffebld_constant_complex2_;
|
||
#endif
|
||
#if FFETARGET_okCOMPLEX3
|
||
static ffebldConstant ffebld_constant_complex3_;
|
||
#endif
|
||
#if FFETARGET_okCOMPLEX4
|
||
static ffebldConstant ffebld_constant_complex4_;
|
||
#endif
|
||
#if FFETARGET_okCOMPLEX5
|
||
static ffebldConstant ffebld_constant_complex5_;
|
||
#endif
|
||
#if FFETARGET_okCOMPLEX6
|
||
static ffebldConstant ffebld_constant_complex6_;
|
||
#endif
|
||
#if FFETARGET_okCOMPLEX7
|
||
static ffebldConstant ffebld_constant_complex7_;
|
||
#endif
|
||
#if FFETARGET_okCOMPLEX8
|
||
static ffebldConstant ffebld_constant_complex8_;
|
||
#endif
|
||
#if FFETARGET_okINTEGER1
|
||
static ffebldConstant ffebld_constant_integer1_;
|
||
#endif
|
||
#if FFETARGET_okINTEGER2
|
||
static ffebldConstant ffebld_constant_integer2_;
|
||
#endif
|
||
#if FFETARGET_okINTEGER3
|
||
static ffebldConstant ffebld_constant_integer3_;
|
||
#endif
|
||
#if FFETARGET_okINTEGER4
|
||
static ffebldConstant ffebld_constant_integer4_;
|
||
#endif
|
||
#if FFETARGET_okINTEGER5
|
||
static ffebldConstant ffebld_constant_integer5_;
|
||
#endif
|
||
#if FFETARGET_okINTEGER6
|
||
static ffebldConstant ffebld_constant_integer6_;
|
||
#endif
|
||
#if FFETARGET_okINTEGER7
|
||
static ffebldConstant ffebld_constant_integer7_;
|
||
#endif
|
||
#if FFETARGET_okINTEGER8
|
||
static ffebldConstant ffebld_constant_integer8_;
|
||
#endif
|
||
#if FFETARGET_okLOGICAL1
|
||
static ffebldConstant ffebld_constant_logical1_;
|
||
#endif
|
||
#if FFETARGET_okLOGICAL2
|
||
static ffebldConstant ffebld_constant_logical2_;
|
||
#endif
|
||
#if FFETARGET_okLOGICAL3
|
||
static ffebldConstant ffebld_constant_logical3_;
|
||
#endif
|
||
#if FFETARGET_okLOGICAL4
|
||
static ffebldConstant ffebld_constant_logical4_;
|
||
#endif
|
||
#if FFETARGET_okLOGICAL5
|
||
static ffebldConstant ffebld_constant_logical5_;
|
||
#endif
|
||
#if FFETARGET_okLOGICAL6
|
||
static ffebldConstant ffebld_constant_logical6_;
|
||
#endif
|
||
#if FFETARGET_okLOGICAL7
|
||
static ffebldConstant ffebld_constant_logical7_;
|
||
#endif
|
||
#if FFETARGET_okLOGICAL8
|
||
static ffebldConstant ffebld_constant_logical8_;
|
||
#endif
|
||
#if FFETARGET_okREAL1
|
||
static ffebldConstant ffebld_constant_real1_;
|
||
#endif
|
||
#if FFETARGET_okREAL2
|
||
static ffebldConstant ffebld_constant_real2_;
|
||
#endif
|
||
#if FFETARGET_okREAL3
|
||
static ffebldConstant ffebld_constant_real3_;
|
||
#endif
|
||
#if FFETARGET_okREAL4
|
||
static ffebldConstant ffebld_constant_real4_;
|
||
#endif
|
||
#if FFETARGET_okREAL5
|
||
static ffebldConstant ffebld_constant_real5_;
|
||
#endif
|
||
#if FFETARGET_okREAL6
|
||
static ffebldConstant ffebld_constant_real6_;
|
||
#endif
|
||
#if FFETARGET_okREAL7
|
||
static ffebldConstant ffebld_constant_real7_;
|
||
#endif
|
||
#if FFETARGET_okREAL8
|
||
static ffebldConstant ffebld_constant_real8_;
|
||
#endif
|
||
static ffebldConstant ffebld_constant_hollerith_;
|
||
static ffebldConstant ffebld_constant_typeless_[FFEBLD_constTYPELESS_LAST
|
||
- FFEBLD_constTYPELESS_FIRST + 1];
|
||
|
||
static const char *const ffebld_op_string_[]
|
||
=
|
||
{
|
||
#define FFEBLD_OP(KWD,NAME,ARITY) NAME,
|
||
#include "bld-op.def"
|
||
#undef FFEBLD_OP
|
||
};
|
||
|
||
/* Static functions (internal). */
|
||
|
||
|
||
/* Internal macros. */
|
||
|
||
#define integerdefault_ CATX(integer,FFETARGET_ktINTEGERDEFAULT)
|
||
#define logicaldefault_ CATX(logical,FFETARGET_ktLOGICALDEFAULT)
|
||
#define realdefault_ CATX(real,FFETARGET_ktREALDEFAULT)
|
||
#define realdouble_ CATX(real,FFETARGET_ktREALDOUBLE)
|
||
#define realquad_ CATX(real,FFETARGET_ktREALQUAD)
|
||
|
||
/* ffebld_constant_cmp -- Compare two constants a la strcmp
|
||
|
||
ffebldConstant c1, c2;
|
||
if (ffebld_constant_cmp(c1,c2) == 0)
|
||
// they're equal, else they're not.
|
||
|
||
Returns -1 if c1 < c2, 0 if c1 == c2, +1 if c1 == c2. */
|
||
|
||
int
|
||
ffebld_constant_cmp (ffebldConstant c1, ffebldConstant c2)
|
||
{
|
||
if (c1 == c2)
|
||
return 0;
|
||
|
||
assert (ffebld_constant_type (c1) == ffebld_constant_type (c2));
|
||
|
||
switch (ffebld_constant_type (c1))
|
||
{
|
||
#if FFETARGET_okINTEGER1
|
||
case FFEBLD_constINTEGER1:
|
||
return ffetarget_cmp_integer1 (ffebld_constant_integer1 (c1),
|
||
ffebld_constant_integer1 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER2
|
||
case FFEBLD_constINTEGER2:
|
||
return ffetarget_cmp_integer2 (ffebld_constant_integer2 (c1),
|
||
ffebld_constant_integer2 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER3
|
||
case FFEBLD_constINTEGER3:
|
||
return ffetarget_cmp_integer3 (ffebld_constant_integer3 (c1),
|
||
ffebld_constant_integer3 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER4
|
||
case FFEBLD_constINTEGER4:
|
||
return ffetarget_cmp_integer4 (ffebld_constant_integer4 (c1),
|
||
ffebld_constant_integer4 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER5
|
||
case FFEBLD_constINTEGER5:
|
||
return ffetarget_cmp_integer5 (ffebld_constant_integer5 (c1),
|
||
ffebld_constant_integer5 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER6
|
||
case FFEBLD_constINTEGER6:
|
||
return ffetarget_cmp_integer6 (ffebld_constant_integer6 (c1),
|
||
ffebld_constant_integer6 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER7
|
||
case FFEBLD_constINTEGER7:
|
||
return ffetarget_cmp_integer7 (ffebld_constant_integer7 (c1),
|
||
ffebld_constant_integer7 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER8
|
||
case FFEBLD_constINTEGER8:
|
||
return ffetarget_cmp_integer8 (ffebld_constant_integer8 (c1),
|
||
ffebld_constant_integer8 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL1
|
||
case FFEBLD_constLOGICAL1:
|
||
return ffetarget_cmp_logical1 (ffebld_constant_logical1 (c1),
|
||
ffebld_constant_logical1 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL2
|
||
case FFEBLD_constLOGICAL2:
|
||
return ffetarget_cmp_logical2 (ffebld_constant_logical2 (c1),
|
||
ffebld_constant_logical2 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL3
|
||
case FFEBLD_constLOGICAL3:
|
||
return ffetarget_cmp_logical3 (ffebld_constant_logical3 (c1),
|
||
ffebld_constant_logical3 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL4
|
||
case FFEBLD_constLOGICAL4:
|
||
return ffetarget_cmp_logical4 (ffebld_constant_logical4 (c1),
|
||
ffebld_constant_logical4 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL5
|
||
case FFEBLD_constLOGICAL5:
|
||
return ffetarget_cmp_logical5 (ffebld_constant_logical5 (c1),
|
||
ffebld_constant_logical5 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL6
|
||
case FFEBLD_constLOGICAL6:
|
||
return ffetarget_cmp_logical6 (ffebld_constant_logical6 (c1),
|
||
ffebld_constant_logical6 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL7
|
||
case FFEBLD_constLOGICAL7:
|
||
return ffetarget_cmp_logical7 (ffebld_constant_logical7 (c1),
|
||
ffebld_constant_logical7 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL8
|
||
case FFEBLD_constLOGICAL8:
|
||
return ffetarget_cmp_logical8 (ffebld_constant_logical8 (c1),
|
||
ffebld_constant_logical8 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL1
|
||
case FFEBLD_constREAL1:
|
||
return ffetarget_cmp_real1 (ffebld_constant_real1 (c1),
|
||
ffebld_constant_real1 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL2
|
||
case FFEBLD_constREAL2:
|
||
return ffetarget_cmp_real2 (ffebld_constant_real2 (c1),
|
||
ffebld_constant_real2 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL3
|
||
case FFEBLD_constREAL3:
|
||
return ffetarget_cmp_real3 (ffebld_constant_real3 (c1),
|
||
ffebld_constant_real3 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL4
|
||
case FFEBLD_constREAL4:
|
||
return ffetarget_cmp_real4 (ffebld_constant_real4 (c1),
|
||
ffebld_constant_real4 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL5
|
||
case FFEBLD_constREAL5:
|
||
return ffetarget_cmp_real5 (ffebld_constant_real5 (c1),
|
||
ffebld_constant_real5 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL6
|
||
case FFEBLD_constREAL6:
|
||
return ffetarget_cmp_real6 (ffebld_constant_real6 (c1),
|
||
ffebld_constant_real6 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL7
|
||
case FFEBLD_constREAL7:
|
||
return ffetarget_cmp_real7 (ffebld_constant_real7 (c1),
|
||
ffebld_constant_real7 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL8
|
||
case FFEBLD_constREAL8:
|
||
return ffetarget_cmp_real8 (ffebld_constant_real8 (c1),
|
||
ffebld_constant_real8 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER1
|
||
case FFEBLD_constCHARACTER1:
|
||
return ffetarget_cmp_character1 (ffebld_constant_character1 (c1),
|
||
ffebld_constant_character1 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER2
|
||
case FFEBLD_constCHARACTER2:
|
||
return ffetarget_cmp_character2 (ffebld_constant_character2 (c1),
|
||
ffebld_constant_character2 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER3
|
||
case FFEBLD_constCHARACTER3:
|
||
return ffetarget_cmp_character3 (ffebld_constant_character3 (c1),
|
||
ffebld_constant_character3 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER4
|
||
case FFEBLD_constCHARACTER4:
|
||
return ffetarget_cmp_character4 (ffebld_constant_character4 (c1),
|
||
ffebld_constant_character4 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER5
|
||
case FFEBLD_constCHARACTER5:
|
||
return ffetarget_cmp_character5 (ffebld_constant_character5 (c1),
|
||
ffebld_constant_character5 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER6
|
||
case FFEBLD_constCHARACTER6:
|
||
return ffetarget_cmp_character6 (ffebld_constant_character6 (c1),
|
||
ffebld_constant_character6 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER7
|
||
case FFEBLD_constCHARACTER7:
|
||
return ffetarget_cmp_character7 (ffebld_constant_character7 (c1),
|
||
ffebld_constant_character7 (c2));
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER8
|
||
case FFEBLD_constCHARACTER8:
|
||
return ffetarget_cmp_character8 (ffebld_constant_character8 (c1),
|
||
ffebld_constant_character8 (c2));
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad constant type" == NULL);
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
/* ffebld_constant_is_magical -- Determine if integer is "magical"
|
||
|
||
ffebldConstant c;
|
||
if (ffebld_constant_is_magical(c))
|
||
// it is 2**(n-1), where n is # bits in ffetargetIntegerDefault type
|
||
// (this test is important for 2's-complement machines only). */
|
||
|
||
bool
|
||
ffebld_constant_is_magical (ffebldConstant c)
|
||
{
|
||
switch (ffebld_constant_type (c))
|
||
{
|
||
case FFEBLD_constINTEGERDEFAULT:
|
||
return ffetarget_integerdefault_is_magical (ffebld_constant_integer1 (c));
|
||
|
||
default:
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
/* Determine if constant is zero. Used to ensure step count
|
||
for DO loops isn't zero, also to determine if values will
|
||
be binary zeros, so not entirely portable at this point. */
|
||
|
||
bool
|
||
ffebld_constant_is_zero (ffebldConstant c)
|
||
{
|
||
switch (ffebld_constant_type (c))
|
||
{
|
||
#if FFETARGET_okINTEGER1
|
||
case FFEBLD_constINTEGER1:
|
||
return ffebld_constant_integer1 (c) == 0;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER2
|
||
case FFEBLD_constINTEGER2:
|
||
return ffebld_constant_integer2 (c) == 0;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER3
|
||
case FFEBLD_constINTEGER3:
|
||
return ffebld_constant_integer3 (c) == 0;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER4
|
||
case FFEBLD_constINTEGER4:
|
||
return ffebld_constant_integer4 (c) == 0;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER5
|
||
case FFEBLD_constINTEGER5:
|
||
return ffebld_constant_integer5 (c) == 0;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER6
|
||
case FFEBLD_constINTEGER6:
|
||
return ffebld_constant_integer6 (c) == 0;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER7
|
||
case FFEBLD_constINTEGER7:
|
||
return ffebld_constant_integer7 (c) == 0;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER8
|
||
case FFEBLD_constINTEGER8:
|
||
return ffebld_constant_integer8 (c) == 0;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL1
|
||
case FFEBLD_constLOGICAL1:
|
||
return ffebld_constant_logical1 (c) == 0;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL2
|
||
case FFEBLD_constLOGICAL2:
|
||
return ffebld_constant_logical2 (c) == 0;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL3
|
||
case FFEBLD_constLOGICAL3:
|
||
return ffebld_constant_logical3 (c) == 0;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL4
|
||
case FFEBLD_constLOGICAL4:
|
||
return ffebld_constant_logical4 (c) == 0;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL5
|
||
case FFEBLD_constLOGICAL5:
|
||
return ffebld_constant_logical5 (c) == 0;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL6
|
||
case FFEBLD_constLOGICAL6:
|
||
return ffebld_constant_logical6 (c) == 0;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL7
|
||
case FFEBLD_constLOGICAL7:
|
||
return ffebld_constant_logical7 (c) == 0;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL8
|
||
case FFEBLD_constLOGICAL8:
|
||
return ffebld_constant_logical8 (c) == 0;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL1
|
||
case FFEBLD_constREAL1:
|
||
return ffetarget_iszero_real1 (ffebld_constant_real1 (c));
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL2
|
||
case FFEBLD_constREAL2:
|
||
return ffetarget_iszero_real2 (ffebld_constant_real2 (c));
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL3
|
||
case FFEBLD_constREAL3:
|
||
return ffetarget_iszero_real3 (ffebld_constant_real3 (c));
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL4
|
||
case FFEBLD_constREAL4:
|
||
return ffetarget_iszero_real4 (ffebld_constant_real4 (c));
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL5
|
||
case FFEBLD_constREAL5:
|
||
return ffetarget_iszero_real5 (ffebld_constant_real5 (c));
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL6
|
||
case FFEBLD_constREAL6:
|
||
return ffetarget_iszero_real6 (ffebld_constant_real6 (c));
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL7
|
||
case FFEBLD_constREAL7:
|
||
return ffetarget_iszero_real7 (ffebld_constant_real7 (c));
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL8
|
||
case FFEBLD_constREAL8:
|
||
return ffetarget_iszero_real8 (ffebld_constant_real8 (c));
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX1
|
||
case FFEBLD_constCOMPLEX1:
|
||
return ffetarget_iszero_real1 (ffebld_constant_complex1 (c).real)
|
||
&& ffetarget_iszero_real1 (ffebld_constant_complex1 (c).imaginary);
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX2
|
||
case FFEBLD_constCOMPLEX2:
|
||
return ffetarget_iszero_real2 (ffebld_constant_complex2 (c).real)
|
||
&& ffetarget_iszero_real2 (ffebld_constant_complex2 (c).imaginary);
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX3
|
||
case FFEBLD_constCOMPLEX3:
|
||
return ffetarget_iszero_real3 (ffebld_constant_complex3 (c).real)
|
||
&& ffetarget_iszero_real3 (ffebld_constant_complex3 (c).imaginary);
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX4
|
||
case FFEBLD_constCOMPLEX4:
|
||
return ffetarget_iszero_real4 (ffebld_constant_complex4 (c).real)
|
||
&& ffetarget_iszero_real4 (ffebld_constant_complex4 (c).imaginary);
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX5
|
||
case FFEBLD_constCOMPLEX5:
|
||
return ffetarget_iszero_real5 (ffebld_constant_complex5 (c).real)
|
||
&& ffetarget_iszero_real5 (ffebld_constant_complex5 (c).imaginary);
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX6
|
||
case FFEBLD_constCOMPLEX6:
|
||
return ffetarget_iszero_real6 (ffebld_constant_complex6 (c).real)
|
||
&& ffetarget_iszero_real6 (ffebld_constant_complex6 (c).imaginary);
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX7
|
||
case FFEBLD_constCOMPLEX7:
|
||
return ffetarget_iszero_real7 (ffebld_constant_complex7 (c).real)
|
||
&& ffetarget_iszero_real7 (ffebld_constant_complex7 (c).imaginary);
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX8
|
||
case FFEBLD_constCOMPLEX8:
|
||
return ffetarget_iszero_real8 (ffebld_constant_complex8 (c).real)
|
||
&& ffetarget_iszero_real8 (ffebld_constant_complex8 (c).imaginary);
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER1
|
||
case FFEBLD_constCHARACTER1:
|
||
return ffetarget_iszero_character1 (ffebld_constant_character1 (c));
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER2 || FFETARGET_okCHARACTER3 /* ... */
|
||
#error "no support for these!!"
|
||
#endif
|
||
|
||
case FFEBLD_constHOLLERITH:
|
||
return ffetarget_iszero_hollerith (ffebld_constant_hollerith (c));
|
||
|
||
case FFEBLD_constBINARY_MIL:
|
||
case FFEBLD_constBINARY_VXT:
|
||
case FFEBLD_constOCTAL_MIL:
|
||
case FFEBLD_constOCTAL_VXT:
|
||
case FFEBLD_constHEX_X_MIL:
|
||
case FFEBLD_constHEX_X_VXT:
|
||
case FFEBLD_constHEX_Z_MIL:
|
||
case FFEBLD_constHEX_Z_VXT:
|
||
return ffetarget_iszero_typeless (ffebld_constant_typeless (c));
|
||
|
||
default:
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
/* ffebld_constant_new_character1 -- Return character1 constant object from token
|
||
|
||
See prototype. */
|
||
|
||
#if FFETARGET_okCHARACTER1
|
||
ffebldConstant
|
||
ffebld_constant_new_character1 (ffelexToken t)
|
||
{
|
||
ffetargetCharacter1 val;
|
||
|
||
ffetarget_character1 (&val, t, ffebld_constant_pool());
|
||
return ffebld_constant_new_character1_val (val);
|
||
}
|
||
|
||
#endif
|
||
/* ffebld_constant_new_character1_val -- Return an character1 constant object
|
||
|
||
See prototype. */
|
||
|
||
#if FFETARGET_okCHARACTER1
|
||
ffebldConstant
|
||
ffebld_constant_new_character1_val (ffetargetCharacter1 val)
|
||
{
|
||
ffebldConstant c;
|
||
ffebldConstant nc;
|
||
int cmp;
|
||
|
||
ffetarget_verify_character1 (ffebld_constant_pool(), val);
|
||
|
||
for (c = (ffebldConstant) &ffebld_constant_character1_;
|
||
c->next != NULL;
|
||
c = c->next)
|
||
{
|
||
malloc_verify_kp (ffebld_constant_pool(),
|
||
c->next,
|
||
sizeof (*(c->next)));
|
||
ffetarget_verify_character1 (ffebld_constant_pool(),
|
||
ffebld_constant_character1 (c->next));
|
||
cmp = ffetarget_cmp_character1 (val,
|
||
ffebld_constant_character1 (c->next));
|
||
if (cmp == 0)
|
||
return c->next;
|
||
if (cmp > 0)
|
||
break;
|
||
}
|
||
|
||
nc = malloc_new_kp (ffebld_constant_pool(),
|
||
"FFEBLD_constCHARACTER1",
|
||
sizeof (*nc));
|
||
nc->next = c->next;
|
||
nc->consttype = FFEBLD_constCHARACTER1;
|
||
nc->u.character1 = val;
|
||
#ifdef FFECOM_constantHOOK
|
||
nc->hook = FFECOM_constantNULL;
|
||
#endif
|
||
c->next = nc;
|
||
|
||
return nc;
|
||
}
|
||
|
||
#endif
|
||
/* ffebld_constant_new_complex1 -- Return complex1 constant object from token
|
||
|
||
See prototype. */
|
||
|
||
#if FFETARGET_okCOMPLEX1
|
||
ffebldConstant
|
||
ffebld_constant_new_complex1 (ffebldConstant real,
|
||
ffebldConstant imaginary)
|
||
{
|
||
ffetargetComplex1 val;
|
||
|
||
val.real = ffebld_constant_real1 (real);
|
||
val.imaginary = ffebld_constant_real1 (imaginary);
|
||
return ffebld_constant_new_complex1_val (val);
|
||
}
|
||
|
||
#endif
|
||
/* ffebld_constant_new_complex1_val -- Return a complex1 constant object
|
||
|
||
See prototype. */
|
||
|
||
#if FFETARGET_okCOMPLEX1
|
||
ffebldConstant
|
||
ffebld_constant_new_complex1_val (ffetargetComplex1 val)
|
||
{
|
||
ffebldConstant c;
|
||
ffebldConstant nc;
|
||
int cmp;
|
||
|
||
for (c = (ffebldConstant) &ffebld_constant_complex1_;
|
||
c->next != NULL;
|
||
c = c->next)
|
||
{
|
||
cmp = ffetarget_cmp_real1 (val.real, ffebld_constant_complex1 (c->next).real);
|
||
if (cmp == 0)
|
||
cmp = ffetarget_cmp_real1 (val.imaginary,
|
||
ffebld_constant_complex1 (c->next).imaginary);
|
||
if (cmp == 0)
|
||
return c->next;
|
||
if (cmp > 0)
|
||
break;
|
||
}
|
||
|
||
nc = malloc_new_kp (ffebld_constant_pool(),
|
||
"FFEBLD_constCOMPLEX1",
|
||
sizeof (*nc));
|
||
nc->next = c->next;
|
||
nc->consttype = FFEBLD_constCOMPLEX1;
|
||
nc->u.complex1 = val;
|
||
#ifdef FFECOM_constantHOOK
|
||
nc->hook = FFECOM_constantNULL;
|
||
#endif
|
||
c->next = nc;
|
||
|
||
return nc;
|
||
}
|
||
|
||
#endif
|
||
/* ffebld_constant_new_complex2 -- Return complex2 constant object from token
|
||
|
||
See prototype. */
|
||
|
||
#if FFETARGET_okCOMPLEX2
|
||
ffebldConstant
|
||
ffebld_constant_new_complex2 (ffebldConstant real,
|
||
ffebldConstant imaginary)
|
||
{
|
||
ffetargetComplex2 val;
|
||
|
||
val.real = ffebld_constant_real2 (real);
|
||
val.imaginary = ffebld_constant_real2 (imaginary);
|
||
return ffebld_constant_new_complex2_val (val);
|
||
}
|
||
|
||
#endif
|
||
/* ffebld_constant_new_complex2_val -- Return a complex2 constant object
|
||
|
||
See prototype. */
|
||
|
||
#if FFETARGET_okCOMPLEX2
|
||
ffebldConstant
|
||
ffebld_constant_new_complex2_val (ffetargetComplex2 val)
|
||
{
|
||
ffebldConstant c;
|
||
ffebldConstant nc;
|
||
int cmp;
|
||
|
||
for (c = (ffebldConstant) &ffebld_constant_complex2_;
|
||
c->next != NULL;
|
||
c = c->next)
|
||
{
|
||
cmp = ffetarget_cmp_real2 (val.real, ffebld_constant_complex2 (c->next).real);
|
||
if (cmp == 0)
|
||
cmp = ffetarget_cmp_real2 (val.imaginary,
|
||
ffebld_constant_complex2 (c->next).imaginary);
|
||
if (cmp == 0)
|
||
return c->next;
|
||
if (cmp > 0)
|
||
break;
|
||
}
|
||
|
||
nc = malloc_new_kp (ffebld_constant_pool(),
|
||
"FFEBLD_constCOMPLEX2",
|
||
sizeof (*nc));
|
||
nc->next = c->next;
|
||
nc->consttype = FFEBLD_constCOMPLEX2;
|
||
nc->u.complex2 = val;
|
||
#ifdef FFECOM_constantHOOK
|
||
nc->hook = FFECOM_constantNULL;
|
||
#endif
|
||
c->next = nc;
|
||
|
||
return nc;
|
||
}
|
||
|
||
#endif
|
||
/* ffebld_constant_new_hollerith -- Return hollerith constant object from token
|
||
|
||
See prototype. */
|
||
|
||
ffebldConstant
|
||
ffebld_constant_new_hollerith (ffelexToken t)
|
||
{
|
||
ffetargetHollerith val;
|
||
|
||
ffetarget_hollerith (&val, t, ffebld_constant_pool());
|
||
return ffebld_constant_new_hollerith_val (val);
|
||
}
|
||
|
||
/* ffebld_constant_new_hollerith_val -- Return an hollerith constant object
|
||
|
||
See prototype. */
|
||
|
||
ffebldConstant
|
||
ffebld_constant_new_hollerith_val (ffetargetHollerith val)
|
||
{
|
||
ffebldConstant c;
|
||
ffebldConstant nc;
|
||
int cmp;
|
||
|
||
for (c = (ffebldConstant) &ffebld_constant_hollerith_;
|
||
c->next != NULL;
|
||
c = c->next)
|
||
{
|
||
cmp = ffetarget_cmp_hollerith (val, ffebld_constant_hollerith (c->next));
|
||
if (cmp == 0)
|
||
return c->next;
|
||
if (cmp > 0)
|
||
break;
|
||
}
|
||
|
||
nc = malloc_new_kp (ffebld_constant_pool(),
|
||
"FFEBLD_constHOLLERITH",
|
||
sizeof (*nc));
|
||
nc->next = c->next;
|
||
nc->consttype = FFEBLD_constHOLLERITH;
|
||
nc->u.hollerith = val;
|
||
#ifdef FFECOM_constantHOOK
|
||
nc->hook = FFECOM_constantNULL;
|
||
#endif
|
||
c->next = nc;
|
||
|
||
return nc;
|
||
}
|
||
|
||
/* ffebld_constant_new_integer1 -- Return integer1 constant object from token
|
||
|
||
See prototype.
|
||
|
||
Parses the token as a decimal integer constant, thus it must be an
|
||
FFELEX_typeNUMBER. */
|
||
|
||
#if FFETARGET_okINTEGER1
|
||
ffebldConstant
|
||
ffebld_constant_new_integer1 (ffelexToken t)
|
||
{
|
||
ffetargetInteger1 val;
|
||
|
||
assert (ffelex_token_type (t) == FFELEX_typeNUMBER);
|
||
|
||
ffetarget_integer1 (&val, t);
|
||
return ffebld_constant_new_integer1_val (val);
|
||
}
|
||
|
||
#endif
|
||
/* ffebld_constant_new_integer1_val -- Return an integer1 constant object
|
||
|
||
See prototype. */
|
||
|
||
#if FFETARGET_okINTEGER1
|
||
ffebldConstant
|
||
ffebld_constant_new_integer1_val (ffetargetInteger1 val)
|
||
{
|
||
ffebldConstant c;
|
||
ffebldConstant nc;
|
||
int cmp;
|
||
|
||
for (c = (ffebldConstant) &ffebld_constant_integer1_;
|
||
c->next != NULL;
|
||
c = c->next)
|
||
{
|
||
cmp = ffetarget_cmp_integer1 (val, ffebld_constant_integer1 (c->next));
|
||
if (cmp == 0)
|
||
return c->next;
|
||
if (cmp > 0)
|
||
break;
|
||
}
|
||
|
||
nc = malloc_new_kp (ffebld_constant_pool(),
|
||
"FFEBLD_constINTEGER1",
|
||
sizeof (*nc));
|
||
nc->next = c->next;
|
||
nc->consttype = FFEBLD_constINTEGER1;
|
||
nc->u.integer1 = val;
|
||
#ifdef FFECOM_constantHOOK
|
||
nc->hook = FFECOM_constantNULL;
|
||
#endif
|
||
c->next = nc;
|
||
|
||
return nc;
|
||
}
|
||
|
||
#endif
|
||
/* ffebld_constant_new_integer2_val -- Return an integer2 constant object
|
||
|
||
See prototype. */
|
||
|
||
#if FFETARGET_okINTEGER2
|
||
ffebldConstant
|
||
ffebld_constant_new_integer2_val (ffetargetInteger2 val)
|
||
{
|
||
ffebldConstant c;
|
||
ffebldConstant nc;
|
||
int cmp;
|
||
|
||
for (c = (ffebldConstant) &ffebld_constant_integer2_;
|
||
c->next != NULL;
|
||
c = c->next)
|
||
{
|
||
cmp = ffetarget_cmp_integer2 (val, ffebld_constant_integer2 (c->next));
|
||
if (cmp == 0)
|
||
return c->next;
|
||
if (cmp > 0)
|
||
break;
|
||
}
|
||
|
||
nc = malloc_new_kp (ffebld_constant_pool(),
|
||
"FFEBLD_constINTEGER2",
|
||
sizeof (*nc));
|
||
nc->next = c->next;
|
||
nc->consttype = FFEBLD_constINTEGER2;
|
||
nc->u.integer2 = val;
|
||
#ifdef FFECOM_constantHOOK
|
||
nc->hook = FFECOM_constantNULL;
|
||
#endif
|
||
c->next = nc;
|
||
|
||
return nc;
|
||
}
|
||
|
||
#endif
|
||
/* ffebld_constant_new_integer3_val -- Return an integer3 constant object
|
||
|
||
See prototype. */
|
||
|
||
#if FFETARGET_okINTEGER3
|
||
ffebldConstant
|
||
ffebld_constant_new_integer3_val (ffetargetInteger3 val)
|
||
{
|
||
ffebldConstant c;
|
||
ffebldConstant nc;
|
||
int cmp;
|
||
|
||
for (c = (ffebldConstant) &ffebld_constant_integer3_;
|
||
c->next != NULL;
|
||
c = c->next)
|
||
{
|
||
cmp = ffetarget_cmp_integer3 (val, ffebld_constant_integer3 (c->next));
|
||
if (cmp == 0)
|
||
return c->next;
|
||
if (cmp > 0)
|
||
break;
|
||
}
|
||
|
||
nc = malloc_new_kp (ffebld_constant_pool(),
|
||
"FFEBLD_constINTEGER3",
|
||
sizeof (*nc));
|
||
nc->next = c->next;
|
||
nc->consttype = FFEBLD_constINTEGER3;
|
||
nc->u.integer3 = val;
|
||
#ifdef FFECOM_constantHOOK
|
||
nc->hook = FFECOM_constantNULL;
|
||
#endif
|
||
c->next = nc;
|
||
|
||
return nc;
|
||
}
|
||
|
||
#endif
|
||
/* ffebld_constant_new_integer4_val -- Return an integer4 constant object
|
||
|
||
See prototype. */
|
||
|
||
#if FFETARGET_okINTEGER4
|
||
ffebldConstant
|
||
ffebld_constant_new_integer4_val (ffetargetInteger4 val)
|
||
{
|
||
ffebldConstant c;
|
||
ffebldConstant nc;
|
||
int cmp;
|
||
|
||
for (c = (ffebldConstant) &ffebld_constant_integer4_;
|
||
c->next != NULL;
|
||
c = c->next)
|
||
{
|
||
cmp = ffetarget_cmp_integer4 (val, ffebld_constant_integer4 (c->next));
|
||
if (cmp == 0)
|
||
return c->next;
|
||
if (cmp > 0)
|
||
break;
|
||
}
|
||
|
||
nc = malloc_new_kp (ffebld_constant_pool(),
|
||
"FFEBLD_constINTEGER4",
|
||
sizeof (*nc));
|
||
nc->next = c->next;
|
||
nc->consttype = FFEBLD_constINTEGER4;
|
||
nc->u.integer4 = val;
|
||
#ifdef FFECOM_constantHOOK
|
||
nc->hook = FFECOM_constantNULL;
|
||
#endif
|
||
c->next = nc;
|
||
|
||
return nc;
|
||
}
|
||
|
||
#endif
|
||
/* ffebld_constant_new_integerbinary -- Return binary constant object from token
|
||
|
||
See prototype.
|
||
|
||
Parses the token as a binary integer constant, thus it must be an
|
||
FFELEX_typeNUMBER. */
|
||
|
||
ffebldConstant
|
||
ffebld_constant_new_integerbinary (ffelexToken t)
|
||
{
|
||
ffetargetIntegerDefault val;
|
||
|
||
assert ((ffelex_token_type (t) == FFELEX_typeNAME)
|
||
|| (ffelex_token_type (t) == FFELEX_typeNUMBER));
|
||
|
||
ffetarget_integerbinary (&val, t);
|
||
return ffebld_constant_new_integerdefault_val (val);
|
||
}
|
||
|
||
/* ffebld_constant_new_integerhex -- Return hex constant object from token
|
||
|
||
See prototype.
|
||
|
||
Parses the token as a hex integer constant, thus it must be an
|
||
FFELEX_typeNUMBER. */
|
||
|
||
ffebldConstant
|
||
ffebld_constant_new_integerhex (ffelexToken t)
|
||
{
|
||
ffetargetIntegerDefault val;
|
||
|
||
assert ((ffelex_token_type (t) == FFELEX_typeNAME)
|
||
|| (ffelex_token_type (t) == FFELEX_typeNUMBER));
|
||
|
||
ffetarget_integerhex (&val, t);
|
||
return ffebld_constant_new_integerdefault_val (val);
|
||
}
|
||
|
||
/* ffebld_constant_new_integeroctal -- Return octal constant object from token
|
||
|
||
See prototype.
|
||
|
||
Parses the token as a octal integer constant, thus it must be an
|
||
FFELEX_typeNUMBER. */
|
||
|
||
ffebldConstant
|
||
ffebld_constant_new_integeroctal (ffelexToken t)
|
||
{
|
||
ffetargetIntegerDefault val;
|
||
|
||
assert ((ffelex_token_type (t) == FFELEX_typeNAME)
|
||
|| (ffelex_token_type (t) == FFELEX_typeNUMBER));
|
||
|
||
ffetarget_integeroctal (&val, t);
|
||
return ffebld_constant_new_integerdefault_val (val);
|
||
}
|
||
|
||
/* ffebld_constant_new_logical1 -- Return logical1 constant object from token
|
||
|
||
See prototype.
|
||
|
||
Parses the token as a decimal logical constant, thus it must be an
|
||
FFELEX_typeNUMBER. */
|
||
|
||
#if FFETARGET_okLOGICAL1
|
||
ffebldConstant
|
||
ffebld_constant_new_logical1 (bool truth)
|
||
{
|
||
ffetargetLogical1 val;
|
||
|
||
ffetarget_logical1 (&val, truth);
|
||
return ffebld_constant_new_logical1_val (val);
|
||
}
|
||
|
||
#endif
|
||
/* ffebld_constant_new_logical1_val -- Return a logical1 constant object
|
||
|
||
See prototype. */
|
||
|
||
#if FFETARGET_okLOGICAL1
|
||
ffebldConstant
|
||
ffebld_constant_new_logical1_val (ffetargetLogical1 val)
|
||
{
|
||
ffebldConstant c;
|
||
ffebldConstant nc;
|
||
int cmp;
|
||
|
||
for (c = (ffebldConstant) &ffebld_constant_logical1_;
|
||
c->next != NULL;
|
||
c = c->next)
|
||
{
|
||
cmp = ffetarget_cmp_logical1 (val, ffebld_constant_logical1 (c->next));
|
||
if (cmp == 0)
|
||
return c->next;
|
||
if (cmp > 0)
|
||
break;
|
||
}
|
||
|
||
nc = malloc_new_kp (ffebld_constant_pool(),
|
||
"FFEBLD_constLOGICAL1",
|
||
sizeof (*nc));
|
||
nc->next = c->next;
|
||
nc->consttype = FFEBLD_constLOGICAL1;
|
||
nc->u.logical1 = val;
|
||
#ifdef FFECOM_constantHOOK
|
||
nc->hook = FFECOM_constantNULL;
|
||
#endif
|
||
c->next = nc;
|
||
|
||
return nc;
|
||
}
|
||
|
||
#endif
|
||
/* ffebld_constant_new_logical2_val -- Return a logical2 constant object
|
||
|
||
See prototype. */
|
||
|
||
#if FFETARGET_okLOGICAL2
|
||
ffebldConstant
|
||
ffebld_constant_new_logical2_val (ffetargetLogical2 val)
|
||
{
|
||
ffebldConstant c;
|
||
ffebldConstant nc;
|
||
int cmp;
|
||
|
||
for (c = (ffebldConstant) &ffebld_constant_logical2_;
|
||
c->next != NULL;
|
||
c = c->next)
|
||
{
|
||
cmp = ffetarget_cmp_logical2 (val, ffebld_constant_logical2 (c->next));
|
||
if (cmp == 0)
|
||
return c->next;
|
||
if (cmp > 0)
|
||
break;
|
||
}
|
||
|
||
nc = malloc_new_kp (ffebld_constant_pool(),
|
||
"FFEBLD_constLOGICAL2",
|
||
sizeof (*nc));
|
||
nc->next = c->next;
|
||
nc->consttype = FFEBLD_constLOGICAL2;
|
||
nc->u.logical2 = val;
|
||
#ifdef FFECOM_constantHOOK
|
||
nc->hook = FFECOM_constantNULL;
|
||
#endif
|
||
c->next = nc;
|
||
|
||
return nc;
|
||
}
|
||
|
||
#endif
|
||
/* ffebld_constant_new_logical3_val -- Return a logical3 constant object
|
||
|
||
See prototype. */
|
||
|
||
#if FFETARGET_okLOGICAL3
|
||
ffebldConstant
|
||
ffebld_constant_new_logical3_val (ffetargetLogical3 val)
|
||
{
|
||
ffebldConstant c;
|
||
ffebldConstant nc;
|
||
int cmp;
|
||
|
||
for (c = (ffebldConstant) &ffebld_constant_logical3_;
|
||
c->next != NULL;
|
||
c = c->next)
|
||
{
|
||
cmp = ffetarget_cmp_logical3 (val, ffebld_constant_logical3 (c->next));
|
||
if (cmp == 0)
|
||
return c->next;
|
||
if (cmp > 0)
|
||
break;
|
||
}
|
||
|
||
nc = malloc_new_kp (ffebld_constant_pool(),
|
||
"FFEBLD_constLOGICAL3",
|
||
sizeof (*nc));
|
||
nc->next = c->next;
|
||
nc->consttype = FFEBLD_constLOGICAL3;
|
||
nc->u.logical3 = val;
|
||
#ifdef FFECOM_constantHOOK
|
||
nc->hook = FFECOM_constantNULL;
|
||
#endif
|
||
c->next = nc;
|
||
|
||
return nc;
|
||
}
|
||
|
||
#endif
|
||
/* ffebld_constant_new_logical4_val -- Return a logical4 constant object
|
||
|
||
See prototype. */
|
||
|
||
#if FFETARGET_okLOGICAL4
|
||
ffebldConstant
|
||
ffebld_constant_new_logical4_val (ffetargetLogical4 val)
|
||
{
|
||
ffebldConstant c;
|
||
ffebldConstant nc;
|
||
int cmp;
|
||
|
||
for (c = (ffebldConstant) &ffebld_constant_logical4_;
|
||
c->next != NULL;
|
||
c = c->next)
|
||
{
|
||
cmp = ffetarget_cmp_logical4 (val, ffebld_constant_logical4 (c->next));
|
||
if (cmp == 0)
|
||
return c->next;
|
||
if (cmp > 0)
|
||
break;
|
||
}
|
||
|
||
nc = malloc_new_kp (ffebld_constant_pool(),
|
||
"FFEBLD_constLOGICAL4",
|
||
sizeof (*nc));
|
||
nc->next = c->next;
|
||
nc->consttype = FFEBLD_constLOGICAL4;
|
||
nc->u.logical4 = val;
|
||
#ifdef FFECOM_constantHOOK
|
||
nc->hook = FFECOM_constantNULL;
|
||
#endif
|
||
c->next = nc;
|
||
|
||
return nc;
|
||
}
|
||
|
||
#endif
|
||
/* ffebld_constant_new_real1 -- Return real1 constant object from token
|
||
|
||
See prototype. */
|
||
|
||
#if FFETARGET_okREAL1
|
||
ffebldConstant
|
||
ffebld_constant_new_real1 (ffelexToken integer, ffelexToken decimal,
|
||
ffelexToken fraction, ffelexToken exponent, ffelexToken exponent_sign,
|
||
ffelexToken exponent_digits)
|
||
{
|
||
ffetargetReal1 val;
|
||
|
||
ffetarget_real1 (&val,
|
||
integer, decimal, fraction, exponent, exponent_sign, exponent_digits);
|
||
return ffebld_constant_new_real1_val (val);
|
||
}
|
||
|
||
#endif
|
||
/* ffebld_constant_new_real1_val -- Return an real1 constant object
|
||
|
||
See prototype. */
|
||
|
||
#if FFETARGET_okREAL1
|
||
ffebldConstant
|
||
ffebld_constant_new_real1_val (ffetargetReal1 val)
|
||
{
|
||
ffebldConstant c;
|
||
ffebldConstant nc;
|
||
int cmp;
|
||
|
||
for (c = (ffebldConstant) &ffebld_constant_real1_;
|
||
c->next != NULL;
|
||
c = c->next)
|
||
{
|
||
cmp = ffetarget_cmp_real1 (val, ffebld_constant_real1 (c->next));
|
||
if (cmp == 0)
|
||
return c->next;
|
||
if (cmp > 0)
|
||
break;
|
||
}
|
||
|
||
nc = malloc_new_kp (ffebld_constant_pool(),
|
||
"FFEBLD_constREAL1",
|
||
sizeof (*nc));
|
||
nc->next = c->next;
|
||
nc->consttype = FFEBLD_constREAL1;
|
||
nc->u.real1 = val;
|
||
#ifdef FFECOM_constantHOOK
|
||
nc->hook = FFECOM_constantNULL;
|
||
#endif
|
||
c->next = nc;
|
||
|
||
return nc;
|
||
}
|
||
|
||
#endif
|
||
/* ffebld_constant_new_real2 -- Return real2 constant object from token
|
||
|
||
See prototype. */
|
||
|
||
#if FFETARGET_okREAL2
|
||
ffebldConstant
|
||
ffebld_constant_new_real2 (ffelexToken integer, ffelexToken decimal,
|
||
ffelexToken fraction, ffelexToken exponent, ffelexToken exponent_sign,
|
||
ffelexToken exponent_digits)
|
||
{
|
||
ffetargetReal2 val;
|
||
|
||
ffetarget_real2 (&val,
|
||
integer, decimal, fraction, exponent, exponent_sign, exponent_digits);
|
||
return ffebld_constant_new_real2_val (val);
|
||
}
|
||
|
||
#endif
|
||
/* ffebld_constant_new_real2_val -- Return an real2 constant object
|
||
|
||
See prototype. */
|
||
|
||
#if FFETARGET_okREAL2
|
||
ffebldConstant
|
||
ffebld_constant_new_real2_val (ffetargetReal2 val)
|
||
{
|
||
ffebldConstant c;
|
||
ffebldConstant nc;
|
||
int cmp;
|
||
|
||
for (c = (ffebldConstant) &ffebld_constant_real2_;
|
||
c->next != NULL;
|
||
c = c->next)
|
||
{
|
||
cmp = ffetarget_cmp_real2 (val, ffebld_constant_real2 (c->next));
|
||
if (cmp == 0)
|
||
return c->next;
|
||
if (cmp > 0)
|
||
break;
|
||
}
|
||
|
||
nc = malloc_new_kp (ffebld_constant_pool(),
|
||
"FFEBLD_constREAL2",
|
||
sizeof (*nc));
|
||
nc->next = c->next;
|
||
nc->consttype = FFEBLD_constREAL2;
|
||
nc->u.real2 = val;
|
||
#ifdef FFECOM_constantHOOK
|
||
nc->hook = FFECOM_constantNULL;
|
||
#endif
|
||
c->next = nc;
|
||
|
||
return nc;
|
||
}
|
||
|
||
#endif
|
||
/* ffebld_constant_new_typeless_bm -- Return typeless constant object from token
|
||
|
||
See prototype.
|
||
|
||
Parses the token as a decimal integer constant, thus it must be an
|
||
FFELEX_typeNUMBER. */
|
||
|
||
ffebldConstant
|
||
ffebld_constant_new_typeless_bm (ffelexToken t)
|
||
{
|
||
ffetargetTypeless val;
|
||
|
||
ffetarget_binarymil (&val, t);
|
||
return ffebld_constant_new_typeless_val (FFEBLD_constBINARY_MIL, val);
|
||
}
|
||
|
||
/* ffebld_constant_new_typeless_bv -- Return typeless constant object from token
|
||
|
||
See prototype.
|
||
|
||
Parses the token as a decimal integer constant, thus it must be an
|
||
FFELEX_typeNUMBER. */
|
||
|
||
ffebldConstant
|
||
ffebld_constant_new_typeless_bv (ffelexToken t)
|
||
{
|
||
ffetargetTypeless val;
|
||
|
||
ffetarget_binaryvxt (&val, t);
|
||
return ffebld_constant_new_typeless_val (FFEBLD_constBINARY_VXT, val);
|
||
}
|
||
|
||
/* ffebld_constant_new_typeless_hxm -- Return typeless constant object from token
|
||
|
||
See prototype.
|
||
|
||
Parses the token as a decimal integer constant, thus it must be an
|
||
FFELEX_typeNUMBER. */
|
||
|
||
ffebldConstant
|
||
ffebld_constant_new_typeless_hxm (ffelexToken t)
|
||
{
|
||
ffetargetTypeless val;
|
||
|
||
ffetarget_hexxmil (&val, t);
|
||
return ffebld_constant_new_typeless_val (FFEBLD_constHEX_X_MIL, val);
|
||
}
|
||
|
||
/* ffebld_constant_new_typeless_hxv -- Return typeless constant object from token
|
||
|
||
See prototype.
|
||
|
||
Parses the token as a decimal integer constant, thus it must be an
|
||
FFELEX_typeNUMBER. */
|
||
|
||
ffebldConstant
|
||
ffebld_constant_new_typeless_hxv (ffelexToken t)
|
||
{
|
||
ffetargetTypeless val;
|
||
|
||
ffetarget_hexxvxt (&val, t);
|
||
return ffebld_constant_new_typeless_val (FFEBLD_constHEX_X_VXT, val);
|
||
}
|
||
|
||
/* ffebld_constant_new_typeless_hzm -- Return typeless constant object from token
|
||
|
||
See prototype.
|
||
|
||
Parses the token as a decimal integer constant, thus it must be an
|
||
FFELEX_typeNUMBER. */
|
||
|
||
ffebldConstant
|
||
ffebld_constant_new_typeless_hzm (ffelexToken t)
|
||
{
|
||
ffetargetTypeless val;
|
||
|
||
ffetarget_hexzmil (&val, t);
|
||
return ffebld_constant_new_typeless_val (FFEBLD_constHEX_Z_MIL, val);
|
||
}
|
||
|
||
/* ffebld_constant_new_typeless_hzv -- Return typeless constant object from token
|
||
|
||
See prototype.
|
||
|
||
Parses the token as a decimal integer constant, thus it must be an
|
||
FFELEX_typeNUMBER. */
|
||
|
||
ffebldConstant
|
||
ffebld_constant_new_typeless_hzv (ffelexToken t)
|
||
{
|
||
ffetargetTypeless val;
|
||
|
||
ffetarget_hexzvxt (&val, t);
|
||
return ffebld_constant_new_typeless_val (FFEBLD_constHEX_Z_VXT, val);
|
||
}
|
||
|
||
/* ffebld_constant_new_typeless_om -- Return typeless constant object from token
|
||
|
||
See prototype.
|
||
|
||
Parses the token as a decimal integer constant, thus it must be an
|
||
FFELEX_typeNUMBER. */
|
||
|
||
ffebldConstant
|
||
ffebld_constant_new_typeless_om (ffelexToken t)
|
||
{
|
||
ffetargetTypeless val;
|
||
|
||
ffetarget_octalmil (&val, t);
|
||
return ffebld_constant_new_typeless_val (FFEBLD_constOCTAL_MIL, val);
|
||
}
|
||
|
||
/* ffebld_constant_new_typeless_ov -- Return typeless constant object from token
|
||
|
||
See prototype.
|
||
|
||
Parses the token as a decimal integer constant, thus it must be an
|
||
FFELEX_typeNUMBER. */
|
||
|
||
ffebldConstant
|
||
ffebld_constant_new_typeless_ov (ffelexToken t)
|
||
{
|
||
ffetargetTypeless val;
|
||
|
||
ffetarget_octalvxt (&val, t);
|
||
return ffebld_constant_new_typeless_val (FFEBLD_constOCTAL_VXT, val);
|
||
}
|
||
|
||
/* ffebld_constant_new_typeless_val -- Return a typeless constant object
|
||
|
||
See prototype. */
|
||
|
||
ffebldConstant
|
||
ffebld_constant_new_typeless_val (ffebldConst type, ffetargetTypeless val)
|
||
{
|
||
ffebldConstant c;
|
||
ffebldConstant nc;
|
||
int cmp;
|
||
|
||
for (c = (ffebldConstant) &ffebld_constant_typeless_[type
|
||
- FFEBLD_constTYPELESS_FIRST];
|
||
c->next != NULL;
|
||
c = c->next)
|
||
{
|
||
cmp = ffetarget_cmp_typeless (val, ffebld_constant_typeless (c->next));
|
||
if (cmp == 0)
|
||
return c->next;
|
||
if (cmp > 0)
|
||
break;
|
||
}
|
||
|
||
nc = malloc_new_kp (ffebld_constant_pool(),
|
||
"FFEBLD_constTYPELESS",
|
||
sizeof (*nc));
|
||
nc->next = c->next;
|
||
nc->consttype = type;
|
||
nc->u.typeless = val;
|
||
#ifdef FFECOM_constantHOOK
|
||
nc->hook = FFECOM_constantNULL;
|
||
#endif
|
||
c->next = nc;
|
||
|
||
return nc;
|
||
}
|
||
|
||
/* ffebld_constantarray_get -- Get a value from an array of constants
|
||
|
||
See prototype. */
|
||
|
||
ffebldConstantUnion
|
||
ffebld_constantarray_get (ffebldConstantArray array, ffeinfoBasictype bt,
|
||
ffeinfoKindtype kt, ffetargetOffset offset)
|
||
{
|
||
ffebldConstantUnion u;
|
||
|
||
switch (bt)
|
||
{
|
||
case FFEINFO_basictypeINTEGER:
|
||
switch (kt)
|
||
{
|
||
#if FFETARGET_okINTEGER1
|
||
case FFEINFO_kindtypeINTEGER1:
|
||
u.integer1 = *(array.integer1 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER2
|
||
case FFEINFO_kindtypeINTEGER2:
|
||
u.integer2 = *(array.integer2 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER3
|
||
case FFEINFO_kindtypeINTEGER3:
|
||
u.integer3 = *(array.integer3 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER4
|
||
case FFEINFO_kindtypeINTEGER4:
|
||
u.integer4 = *(array.integer4 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER5
|
||
case FFEINFO_kindtypeINTEGER5:
|
||
u.integer5 = *(array.integer5 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER6
|
||
case FFEINFO_kindtypeINTEGER6:
|
||
u.integer6 = *(array.integer6 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER7
|
||
case FFEINFO_kindtypeINTEGER7:
|
||
u.integer7 = *(array.integer7 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER8
|
||
case FFEINFO_kindtypeINTEGER8:
|
||
u.integer8 = *(array.integer8 + offset);
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad INTEGER kindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeLOGICAL:
|
||
switch (kt)
|
||
{
|
||
#if FFETARGET_okLOGICAL1
|
||
case FFEINFO_kindtypeLOGICAL1:
|
||
u.logical1 = *(array.logical1 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL2
|
||
case FFEINFO_kindtypeLOGICAL2:
|
||
u.logical2 = *(array.logical2 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL3
|
||
case FFEINFO_kindtypeLOGICAL3:
|
||
u.logical3 = *(array.logical3 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL4
|
||
case FFEINFO_kindtypeLOGICAL4:
|
||
u.logical4 = *(array.logical4 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL5
|
||
case FFEINFO_kindtypeLOGICAL5:
|
||
u.logical5 = *(array.logical5 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL6
|
||
case FFEINFO_kindtypeLOGICAL6:
|
||
u.logical6 = *(array.logical6 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL7
|
||
case FFEINFO_kindtypeLOGICAL7:
|
||
u.logical7 = *(array.logical7 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL8
|
||
case FFEINFO_kindtypeLOGICAL8:
|
||
u.logical8 = *(array.logical8 + offset);
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad LOGICAL kindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeREAL:
|
||
switch (kt)
|
||
{
|
||
#if FFETARGET_okREAL1
|
||
case FFEINFO_kindtypeREAL1:
|
||
u.real1 = *(array.real1 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL2
|
||
case FFEINFO_kindtypeREAL2:
|
||
u.real2 = *(array.real2 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL3
|
||
case FFEINFO_kindtypeREAL3:
|
||
u.real3 = *(array.real3 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL4
|
||
case FFEINFO_kindtypeREAL4:
|
||
u.real4 = *(array.real4 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL5
|
||
case FFEINFO_kindtypeREAL5:
|
||
u.real5 = *(array.real5 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL6
|
||
case FFEINFO_kindtypeREAL6:
|
||
u.real6 = *(array.real6 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL7
|
||
case FFEINFO_kindtypeREAL7:
|
||
u.real7 = *(array.real7 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL8
|
||
case FFEINFO_kindtypeREAL8:
|
||
u.real8 = *(array.real8 + offset);
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad REAL kindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeCOMPLEX:
|
||
switch (kt)
|
||
{
|
||
#if FFETARGET_okCOMPLEX1
|
||
case FFEINFO_kindtypeREAL1:
|
||
u.complex1 = *(array.complex1 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX2
|
||
case FFEINFO_kindtypeREAL2:
|
||
u.complex2 = *(array.complex2 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX3
|
||
case FFEINFO_kindtypeREAL3:
|
||
u.complex3 = *(array.complex3 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX4
|
||
case FFEINFO_kindtypeREAL4:
|
||
u.complex4 = *(array.complex4 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX5
|
||
case FFEINFO_kindtypeREAL5:
|
||
u.complex5 = *(array.complex5 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX6
|
||
case FFEINFO_kindtypeREAL6:
|
||
u.complex6 = *(array.complex6 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX7
|
||
case FFEINFO_kindtypeREAL7:
|
||
u.complex7 = *(array.complex7 + offset);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX8
|
||
case FFEINFO_kindtypeREAL8:
|
||
u.complex8 = *(array.complex8 + offset);
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad COMPLEX kindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeCHARACTER:
|
||
switch (kt)
|
||
{
|
||
#if FFETARGET_okCHARACTER1
|
||
case FFEINFO_kindtypeCHARACTER1:
|
||
u.character1.length = 1;
|
||
u.character1.text = array.character1 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER2
|
||
case FFEINFO_kindtypeCHARACTER2:
|
||
u.character2.length = 1;
|
||
u.character2.text = array.character2 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER3
|
||
case FFEINFO_kindtypeCHARACTER3:
|
||
u.character3.length = 1;
|
||
u.character3.text = array.character3 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER4
|
||
case FFEINFO_kindtypeCHARACTER4:
|
||
u.character4.length = 1;
|
||
u.character4.text = array.character4 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER5
|
||
case FFEINFO_kindtypeCHARACTER5:
|
||
u.character5.length = 1;
|
||
u.character5.text = array.character5 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER6
|
||
case FFEINFO_kindtypeCHARACTER6:
|
||
u.character6.length = 1;
|
||
u.character6.text = array.character6 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER7
|
||
case FFEINFO_kindtypeCHARACTER7:
|
||
u.character7.length = 1;
|
||
u.character7.text = array.character7 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER8
|
||
case FFEINFO_kindtypeCHARACTER8:
|
||
u.character8.length = 1;
|
||
u.character8.text = array.character8 + offset;
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad CHARACTER kindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
default:
|
||
assert ("bad basictype" == NULL);
|
||
break;
|
||
}
|
||
|
||
return u;
|
||
}
|
||
|
||
/* ffebld_constantarray_new -- Make an array of constants
|
||
|
||
See prototype. */
|
||
|
||
ffebldConstantArray
|
||
ffebld_constantarray_new (ffeinfoBasictype bt,
|
||
ffeinfoKindtype kt, ffetargetOffset size)
|
||
{
|
||
ffebldConstantArray ptr;
|
||
|
||
switch (bt)
|
||
{
|
||
case FFEINFO_basictypeINTEGER:
|
||
switch (kt)
|
||
{
|
||
#if FFETARGET_okINTEGER1
|
||
case FFEINFO_kindtypeINTEGER1:
|
||
ptr.integer1 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetInteger1),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER2
|
||
case FFEINFO_kindtypeINTEGER2:
|
||
ptr.integer2 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetInteger2),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER3
|
||
case FFEINFO_kindtypeINTEGER3:
|
||
ptr.integer3 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetInteger3),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER4
|
||
case FFEINFO_kindtypeINTEGER4:
|
||
ptr.integer4 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetInteger4),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER5
|
||
case FFEINFO_kindtypeINTEGER5:
|
||
ptr.integer5 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetInteger5),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER6
|
||
case FFEINFO_kindtypeINTEGER6:
|
||
ptr.integer6 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetInteger6),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER7
|
||
case FFEINFO_kindtypeINTEGER7:
|
||
ptr.integer7 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetInteger7),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER8
|
||
case FFEINFO_kindtypeINTEGER8:
|
||
ptr.integer8 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetInteger8),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad INTEGER kindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeLOGICAL:
|
||
switch (kt)
|
||
{
|
||
#if FFETARGET_okLOGICAL1
|
||
case FFEINFO_kindtypeLOGICAL1:
|
||
ptr.logical1 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetLogical1),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL2
|
||
case FFEINFO_kindtypeLOGICAL2:
|
||
ptr.logical2 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetLogical2),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL3
|
||
case FFEINFO_kindtypeLOGICAL3:
|
||
ptr.logical3 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetLogical3),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL4
|
||
case FFEINFO_kindtypeLOGICAL4:
|
||
ptr.logical4 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetLogical4),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL5
|
||
case FFEINFO_kindtypeLOGICAL5:
|
||
ptr.logical5 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetLogical5),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL6
|
||
case FFEINFO_kindtypeLOGICAL6:
|
||
ptr.logical6 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetLogical6),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL7
|
||
case FFEINFO_kindtypeLOGICAL7:
|
||
ptr.logical7 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetLogical7),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL8
|
||
case FFEINFO_kindtypeLOGICAL8:
|
||
ptr.logical8 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetLogical8),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad LOGICAL kindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeREAL:
|
||
switch (kt)
|
||
{
|
||
#if FFETARGET_okREAL1
|
||
case FFEINFO_kindtypeREAL1:
|
||
ptr.real1 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetReal1),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL2
|
||
case FFEINFO_kindtypeREAL2:
|
||
ptr.real2 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetReal2),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL3
|
||
case FFEINFO_kindtypeREAL3:
|
||
ptr.real3 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetReal3),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL4
|
||
case FFEINFO_kindtypeREAL4:
|
||
ptr.real4 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetReal4),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL5
|
||
case FFEINFO_kindtypeREAL5:
|
||
ptr.real5 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetReal5),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL6
|
||
case FFEINFO_kindtypeREAL6:
|
||
ptr.real6 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetReal6),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL7
|
||
case FFEINFO_kindtypeREAL7:
|
||
ptr.real7 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetReal7),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL8
|
||
case FFEINFO_kindtypeREAL8:
|
||
ptr.real8 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetReal8),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad REAL kindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeCOMPLEX:
|
||
switch (kt)
|
||
{
|
||
#if FFETARGET_okCOMPLEX1
|
||
case FFEINFO_kindtypeREAL1:
|
||
ptr.complex1 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetComplex1),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX2
|
||
case FFEINFO_kindtypeREAL2:
|
||
ptr.complex2 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetComplex2),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX3
|
||
case FFEINFO_kindtypeREAL3:
|
||
ptr.complex3 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetComplex3),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX4
|
||
case FFEINFO_kindtypeREAL4:
|
||
ptr.complex4 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetComplex4),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX5
|
||
case FFEINFO_kindtypeREAL5:
|
||
ptr.complex5 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetComplex5),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX6
|
||
case FFEINFO_kindtypeREAL6:
|
||
ptr.complex6 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetComplex6),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX7
|
||
case FFEINFO_kindtypeREAL7:
|
||
ptr.complex7 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetComplex7),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX8
|
||
case FFEINFO_kindtypeREAL8:
|
||
ptr.complex8 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size *= sizeof (ffetargetComplex8),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad COMPLEX kindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeCHARACTER:
|
||
switch (kt)
|
||
{
|
||
#if FFETARGET_okCHARACTER1
|
||
case FFEINFO_kindtypeCHARACTER1:
|
||
ptr.character1 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size
|
||
*= sizeof (ffetargetCharacterUnit1),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER2
|
||
case FFEINFO_kindtypeCHARACTER2:
|
||
ptr.character2 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size
|
||
*= sizeof (ffetargetCharacterUnit2),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER3
|
||
case FFEINFO_kindtypeCHARACTER3:
|
||
ptr.character3 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size
|
||
*= sizeof (ffetargetCharacterUnit3),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER4
|
||
case FFEINFO_kindtypeCHARACTER4:
|
||
ptr.character4 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size
|
||
*= sizeof (ffetargetCharacterUnit4),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER5
|
||
case FFEINFO_kindtypeCHARACTER5:
|
||
ptr.character5 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size
|
||
*= sizeof (ffetargetCharacterUnit5),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER6
|
||
case FFEINFO_kindtypeCHARACTER6:
|
||
ptr.character6 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size
|
||
*= sizeof (ffetargetCharacterUnit6),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER7
|
||
case FFEINFO_kindtypeCHARACTER7:
|
||
ptr.character7 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size
|
||
*= sizeof (ffetargetCharacterUnit7),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER8
|
||
case FFEINFO_kindtypeCHARACTER8:
|
||
ptr.character8 = malloc_new_zkp (ffebld_constant_pool(),
|
||
"ffebldConstantArray",
|
||
size
|
||
*= sizeof (ffetargetCharacterUnit8),
|
||
0);
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad CHARACTER kindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
default:
|
||
assert ("bad basictype" == NULL);
|
||
break;
|
||
}
|
||
|
||
return ptr;
|
||
}
|
||
|
||
/* ffebld_constantarray_preparray -- Prepare for copy between arrays
|
||
|
||
See prototype.
|
||
|
||
Like _prepare, but the source is an array instead of a single-value
|
||
constant. */
|
||
|
||
void
|
||
ffebld_constantarray_preparray (void **aptr, void **cptr, size_t *size,
|
||
ffebldConstantArray array, ffeinfoBasictype abt, ffeinfoKindtype akt,
|
||
ffetargetOffset offset, ffebldConstantArray source_array,
|
||
ffeinfoBasictype cbt, ffeinfoKindtype ckt)
|
||
{
|
||
switch (abt)
|
||
{
|
||
case FFEINFO_basictypeINTEGER:
|
||
switch (akt)
|
||
{
|
||
#if FFETARGET_okINTEGER1
|
||
case FFEINFO_kindtypeINTEGER1:
|
||
*aptr = array.integer1 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER2
|
||
case FFEINFO_kindtypeINTEGER2:
|
||
*aptr = array.integer2 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER3
|
||
case FFEINFO_kindtypeINTEGER3:
|
||
*aptr = array.integer3 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER4
|
||
case FFEINFO_kindtypeINTEGER4:
|
||
*aptr = array.integer4 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER5
|
||
case FFEINFO_kindtypeINTEGER5:
|
||
*aptr = array.integer5 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER6
|
||
case FFEINFO_kindtypeINTEGER6:
|
||
*aptr = array.integer6 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER7
|
||
case FFEINFO_kindtypeINTEGER7:
|
||
*aptr = array.integer7 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER8
|
||
case FFEINFO_kindtypeINTEGER8:
|
||
*aptr = array.integer8 + offset;
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad INTEGER akindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeLOGICAL:
|
||
switch (akt)
|
||
{
|
||
#if FFETARGET_okLOGICAL1
|
||
case FFEINFO_kindtypeLOGICAL1:
|
||
*aptr = array.logical1 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL2
|
||
case FFEINFO_kindtypeLOGICAL2:
|
||
*aptr = array.logical2 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL3
|
||
case FFEINFO_kindtypeLOGICAL3:
|
||
*aptr = array.logical3 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL4
|
||
case FFEINFO_kindtypeLOGICAL4:
|
||
*aptr = array.logical4 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL5
|
||
case FFEINFO_kindtypeLOGICAL5:
|
||
*aptr = array.logical5 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL6
|
||
case FFEINFO_kindtypeLOGICAL6:
|
||
*aptr = array.logical6 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL7
|
||
case FFEINFO_kindtypeLOGICAL7:
|
||
*aptr = array.logical7 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL8
|
||
case FFEINFO_kindtypeLOGICAL8:
|
||
*aptr = array.logical8 + offset;
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad LOGICAL akindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeREAL:
|
||
switch (akt)
|
||
{
|
||
#if FFETARGET_okREAL1
|
||
case FFEINFO_kindtypeREAL1:
|
||
*aptr = array.real1 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL2
|
||
case FFEINFO_kindtypeREAL2:
|
||
*aptr = array.real2 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL3
|
||
case FFEINFO_kindtypeREAL3:
|
||
*aptr = array.real3 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL4
|
||
case FFEINFO_kindtypeREAL4:
|
||
*aptr = array.real4 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL5
|
||
case FFEINFO_kindtypeREAL5:
|
||
*aptr = array.real5 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL6
|
||
case FFEINFO_kindtypeREAL6:
|
||
*aptr = array.real6 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL7
|
||
case FFEINFO_kindtypeREAL7:
|
||
*aptr = array.real7 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL8
|
||
case FFEINFO_kindtypeREAL8:
|
||
*aptr = array.real8 + offset;
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad REAL akindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeCOMPLEX:
|
||
switch (akt)
|
||
{
|
||
#if FFETARGET_okCOMPLEX1
|
||
case FFEINFO_kindtypeREAL1:
|
||
*aptr = array.complex1 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX2
|
||
case FFEINFO_kindtypeREAL2:
|
||
*aptr = array.complex2 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX3
|
||
case FFEINFO_kindtypeREAL3:
|
||
*aptr = array.complex3 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX4
|
||
case FFEINFO_kindtypeREAL4:
|
||
*aptr = array.complex4 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX5
|
||
case FFEINFO_kindtypeREAL5:
|
||
*aptr = array.complex5 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX6
|
||
case FFEINFO_kindtypeREAL6:
|
||
*aptr = array.complex6 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX7
|
||
case FFEINFO_kindtypeREAL7:
|
||
*aptr = array.complex7 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX8
|
||
case FFEINFO_kindtypeREAL8:
|
||
*aptr = array.complex8 + offset;
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad COMPLEX akindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeCHARACTER:
|
||
switch (akt)
|
||
{
|
||
#if FFETARGET_okCHARACTER1
|
||
case FFEINFO_kindtypeCHARACTER1:
|
||
*aptr = array.character1 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER2
|
||
case FFEINFO_kindtypeCHARACTER2:
|
||
*aptr = array.character2 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER3
|
||
case FFEINFO_kindtypeCHARACTER3:
|
||
*aptr = array.character3 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER4
|
||
case FFEINFO_kindtypeCHARACTER4:
|
||
*aptr = array.character4 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER5
|
||
case FFEINFO_kindtypeCHARACTER5:
|
||
*aptr = array.character5 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER6
|
||
case FFEINFO_kindtypeCHARACTER6:
|
||
*aptr = array.character6 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER7
|
||
case FFEINFO_kindtypeCHARACTER7:
|
||
*aptr = array.character7 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER8
|
||
case FFEINFO_kindtypeCHARACTER8:
|
||
*aptr = array.character8 + offset;
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad CHARACTER akindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
default:
|
||
assert ("bad abasictype" == NULL);
|
||
break;
|
||
}
|
||
|
||
switch (cbt)
|
||
{
|
||
case FFEINFO_basictypeINTEGER:
|
||
switch (ckt)
|
||
{
|
||
#if FFETARGET_okINTEGER1
|
||
case FFEINFO_kindtypeINTEGER1:
|
||
*cptr = source_array.integer1;
|
||
*size = sizeof (*source_array.integer1);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER2
|
||
case FFEINFO_kindtypeINTEGER2:
|
||
*cptr = source_array.integer2;
|
||
*size = sizeof (*source_array.integer2);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER3
|
||
case FFEINFO_kindtypeINTEGER3:
|
||
*cptr = source_array.integer3;
|
||
*size = sizeof (*source_array.integer3);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER4
|
||
case FFEINFO_kindtypeINTEGER4:
|
||
*cptr = source_array.integer4;
|
||
*size = sizeof (*source_array.integer4);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER5
|
||
case FFEINFO_kindtypeINTEGER5:
|
||
*cptr = source_array.integer5;
|
||
*size = sizeof (*source_array.integer5);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER6
|
||
case FFEINFO_kindtypeINTEGER6:
|
||
*cptr = source_array.integer6;
|
||
*size = sizeof (*source_array.integer6);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER7
|
||
case FFEINFO_kindtypeINTEGER7:
|
||
*cptr = source_array.integer7;
|
||
*size = sizeof (*source_array.integer7);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER8
|
||
case FFEINFO_kindtypeINTEGER8:
|
||
*cptr = source_array.integer8;
|
||
*size = sizeof (*source_array.integer8);
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad INTEGER ckindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeLOGICAL:
|
||
switch (ckt)
|
||
{
|
||
#if FFETARGET_okLOGICAL1
|
||
case FFEINFO_kindtypeLOGICAL1:
|
||
*cptr = source_array.logical1;
|
||
*size = sizeof (*source_array.logical1);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL2
|
||
case FFEINFO_kindtypeLOGICAL2:
|
||
*cptr = source_array.logical2;
|
||
*size = sizeof (*source_array.logical2);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL3
|
||
case FFEINFO_kindtypeLOGICAL3:
|
||
*cptr = source_array.logical3;
|
||
*size = sizeof (*source_array.logical3);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL4
|
||
case FFEINFO_kindtypeLOGICAL4:
|
||
*cptr = source_array.logical4;
|
||
*size = sizeof (*source_array.logical4);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL5
|
||
case FFEINFO_kindtypeLOGICAL5:
|
||
*cptr = source_array.logical5;
|
||
*size = sizeof (*source_array.logical5);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL6
|
||
case FFEINFO_kindtypeLOGICAL6:
|
||
*cptr = source_array.logical6;
|
||
*size = sizeof (*source_array.logical6);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL7
|
||
case FFEINFO_kindtypeLOGICAL7:
|
||
*cptr = source_array.logical7;
|
||
*size = sizeof (*source_array.logical7);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL8
|
||
case FFEINFO_kindtypeLOGICAL8:
|
||
*cptr = source_array.logical8;
|
||
*size = sizeof (*source_array.logical8);
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad LOGICAL ckindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeREAL:
|
||
switch (ckt)
|
||
{
|
||
#if FFETARGET_okREAL1
|
||
case FFEINFO_kindtypeREAL1:
|
||
*cptr = source_array.real1;
|
||
*size = sizeof (*source_array.real1);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL2
|
||
case FFEINFO_kindtypeREAL2:
|
||
*cptr = source_array.real2;
|
||
*size = sizeof (*source_array.real2);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL3
|
||
case FFEINFO_kindtypeREAL3:
|
||
*cptr = source_array.real3;
|
||
*size = sizeof (*source_array.real3);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL4
|
||
case FFEINFO_kindtypeREAL4:
|
||
*cptr = source_array.real4;
|
||
*size = sizeof (*source_array.real4);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL5
|
||
case FFEINFO_kindtypeREAL5:
|
||
*cptr = source_array.real5;
|
||
*size = sizeof (*source_array.real5);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL6
|
||
case FFEINFO_kindtypeREAL6:
|
||
*cptr = source_array.real6;
|
||
*size = sizeof (*source_array.real6);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL7
|
||
case FFEINFO_kindtypeREAL7:
|
||
*cptr = source_array.real7;
|
||
*size = sizeof (*source_array.real7);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL8
|
||
case FFEINFO_kindtypeREAL8:
|
||
*cptr = source_array.real8;
|
||
*size = sizeof (*source_array.real8);
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad REAL ckindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeCOMPLEX:
|
||
switch (ckt)
|
||
{
|
||
#if FFETARGET_okCOMPLEX1
|
||
case FFEINFO_kindtypeREAL1:
|
||
*cptr = source_array.complex1;
|
||
*size = sizeof (*source_array.complex1);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX2
|
||
case FFEINFO_kindtypeREAL2:
|
||
*cptr = source_array.complex2;
|
||
*size = sizeof (*source_array.complex2);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX3
|
||
case FFEINFO_kindtypeREAL3:
|
||
*cptr = source_array.complex3;
|
||
*size = sizeof (*source_array.complex3);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX4
|
||
case FFEINFO_kindtypeREAL4:
|
||
*cptr = source_array.complex4;
|
||
*size = sizeof (*source_array.complex4);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX5
|
||
case FFEINFO_kindtypeREAL5:
|
||
*cptr = source_array.complex5;
|
||
*size = sizeof (*source_array.complex5);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX6
|
||
case FFEINFO_kindtypeREAL6:
|
||
*cptr = source_array.complex6;
|
||
*size = sizeof (*source_array.complex6);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX7
|
||
case FFEINFO_kindtypeREAL7:
|
||
*cptr = source_array.complex7;
|
||
*size = sizeof (*source_array.complex7);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX8
|
||
case FFEINFO_kindtypeREAL8:
|
||
*cptr = source_array.complex8;
|
||
*size = sizeof (*source_array.complex8);
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad COMPLEX ckindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeCHARACTER:
|
||
switch (ckt)
|
||
{
|
||
#if FFETARGET_okCHARACTER1
|
||
case FFEINFO_kindtypeCHARACTER1:
|
||
*cptr = source_array.character1;
|
||
*size = sizeof (*source_array.character1);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER2
|
||
case FFEINFO_kindtypeCHARACTER2:
|
||
*cptr = source_array.character2;
|
||
*size = sizeof (*source_array.character2);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER3
|
||
case FFEINFO_kindtypeCHARACTER3:
|
||
*cptr = source_array.character3;
|
||
*size = sizeof (*source_array.character3);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER4
|
||
case FFEINFO_kindtypeCHARACTER4:
|
||
*cptr = source_array.character4;
|
||
*size = sizeof (*source_array.character4);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER5
|
||
case FFEINFO_kindtypeCHARACTER5:
|
||
*cptr = source_array.character5;
|
||
*size = sizeof (*source_array.character5);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER6
|
||
case FFEINFO_kindtypeCHARACTER6:
|
||
*cptr = source_array.character6;
|
||
*size = sizeof (*source_array.character6);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER7
|
||
case FFEINFO_kindtypeCHARACTER7:
|
||
*cptr = source_array.character7;
|
||
*size = sizeof (*source_array.character7);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER8
|
||
case FFEINFO_kindtypeCHARACTER8:
|
||
*cptr = source_array.character8;
|
||
*size = sizeof (*source_array.character8);
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad CHARACTER ckindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
default:
|
||
assert ("bad cbasictype" == NULL);
|
||
break;
|
||
}
|
||
}
|
||
|
||
/* ffebld_constantarray_prepare -- Prepare for copy between value and array
|
||
|
||
See prototype.
|
||
|
||
Like _put, but just returns the pointers to the beginnings of the
|
||
array and the constant and returns the size (the amount of info to
|
||
copy). The idea is that the caller can use memcpy to accomplish the
|
||
same thing as _put (though slower), or the caller can use a different
|
||
function that swaps bytes, words, etc for a different target machine.
|
||
Also, the type of the array may be different from the type of the
|
||
constant; the array type is used to determine the meaning (scale) of
|
||
the offset field (to calculate the array pointer), the constant type is
|
||
used to determine the constant pointer and the size (amount of info to
|
||
copy). */
|
||
|
||
void
|
||
ffebld_constantarray_prepare (void **aptr, void **cptr, size_t *size,
|
||
ffebldConstantArray array, ffeinfoBasictype abt, ffeinfoKindtype akt,
|
||
ffetargetOffset offset, ffebldConstantUnion *constant,
|
||
ffeinfoBasictype cbt, ffeinfoKindtype ckt)
|
||
{
|
||
switch (abt)
|
||
{
|
||
case FFEINFO_basictypeINTEGER:
|
||
switch (akt)
|
||
{
|
||
#if FFETARGET_okINTEGER1
|
||
case FFEINFO_kindtypeINTEGER1:
|
||
*aptr = array.integer1 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER2
|
||
case FFEINFO_kindtypeINTEGER2:
|
||
*aptr = array.integer2 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER3
|
||
case FFEINFO_kindtypeINTEGER3:
|
||
*aptr = array.integer3 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER4
|
||
case FFEINFO_kindtypeINTEGER4:
|
||
*aptr = array.integer4 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER5
|
||
case FFEINFO_kindtypeINTEGER5:
|
||
*aptr = array.integer5 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER6
|
||
case FFEINFO_kindtypeINTEGER6:
|
||
*aptr = array.integer6 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER7
|
||
case FFEINFO_kindtypeINTEGER7:
|
||
*aptr = array.integer7 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER8
|
||
case FFEINFO_kindtypeINTEGER8:
|
||
*aptr = array.integer8 + offset;
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad INTEGER akindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeLOGICAL:
|
||
switch (akt)
|
||
{
|
||
#if FFETARGET_okLOGICAL1
|
||
case FFEINFO_kindtypeLOGICAL1:
|
||
*aptr = array.logical1 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL2
|
||
case FFEINFO_kindtypeLOGICAL2:
|
||
*aptr = array.logical2 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL3
|
||
case FFEINFO_kindtypeLOGICAL3:
|
||
*aptr = array.logical3 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL4
|
||
case FFEINFO_kindtypeLOGICAL4:
|
||
*aptr = array.logical4 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL5
|
||
case FFEINFO_kindtypeLOGICAL5:
|
||
*aptr = array.logical5 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL6
|
||
case FFEINFO_kindtypeLOGICAL6:
|
||
*aptr = array.logical6 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL7
|
||
case FFEINFO_kindtypeLOGICAL7:
|
||
*aptr = array.logical7 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL8
|
||
case FFEINFO_kindtypeLOGICAL8:
|
||
*aptr = array.logical8 + offset;
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad LOGICAL akindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeREAL:
|
||
switch (akt)
|
||
{
|
||
#if FFETARGET_okREAL1
|
||
case FFEINFO_kindtypeREAL1:
|
||
*aptr = array.real1 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL2
|
||
case FFEINFO_kindtypeREAL2:
|
||
*aptr = array.real2 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL3
|
||
case FFEINFO_kindtypeREAL3:
|
||
*aptr = array.real3 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL4
|
||
case FFEINFO_kindtypeREAL4:
|
||
*aptr = array.real4 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL5
|
||
case FFEINFO_kindtypeREAL5:
|
||
*aptr = array.real5 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL6
|
||
case FFEINFO_kindtypeREAL6:
|
||
*aptr = array.real6 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL7
|
||
case FFEINFO_kindtypeREAL7:
|
||
*aptr = array.real7 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL8
|
||
case FFEINFO_kindtypeREAL8:
|
||
*aptr = array.real8 + offset;
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad REAL akindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeCOMPLEX:
|
||
switch (akt)
|
||
{
|
||
#if FFETARGET_okCOMPLEX1
|
||
case FFEINFO_kindtypeREAL1:
|
||
*aptr = array.complex1 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX2
|
||
case FFEINFO_kindtypeREAL2:
|
||
*aptr = array.complex2 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX3
|
||
case FFEINFO_kindtypeREAL3:
|
||
*aptr = array.complex3 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX4
|
||
case FFEINFO_kindtypeREAL4:
|
||
*aptr = array.complex4 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX5
|
||
case FFEINFO_kindtypeREAL5:
|
||
*aptr = array.complex5 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX6
|
||
case FFEINFO_kindtypeREAL6:
|
||
*aptr = array.complex6 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX7
|
||
case FFEINFO_kindtypeREAL7:
|
||
*aptr = array.complex7 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX8
|
||
case FFEINFO_kindtypeREAL8:
|
||
*aptr = array.complex8 + offset;
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad COMPLEX akindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeCHARACTER:
|
||
switch (akt)
|
||
{
|
||
#if FFETARGET_okCHARACTER1
|
||
case FFEINFO_kindtypeCHARACTER1:
|
||
*aptr = array.character1 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER2
|
||
case FFEINFO_kindtypeCHARACTER2:
|
||
*aptr = array.character2 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER3
|
||
case FFEINFO_kindtypeCHARACTER3:
|
||
*aptr = array.character3 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER4
|
||
case FFEINFO_kindtypeCHARACTER4:
|
||
*aptr = array.character4 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER5
|
||
case FFEINFO_kindtypeCHARACTER5:
|
||
*aptr = array.character5 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER6
|
||
case FFEINFO_kindtypeCHARACTER6:
|
||
*aptr = array.character6 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER7
|
||
case FFEINFO_kindtypeCHARACTER7:
|
||
*aptr = array.character7 + offset;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER8
|
||
case FFEINFO_kindtypeCHARACTER8:
|
||
*aptr = array.character8 + offset;
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad CHARACTER akindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
default:
|
||
assert ("bad abasictype" == NULL);
|
||
break;
|
||
}
|
||
|
||
switch (cbt)
|
||
{
|
||
case FFEINFO_basictypeINTEGER:
|
||
switch (ckt)
|
||
{
|
||
#if FFETARGET_okINTEGER1
|
||
case FFEINFO_kindtypeINTEGER1:
|
||
*cptr = &constant->integer1;
|
||
*size = sizeof (constant->integer1);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER2
|
||
case FFEINFO_kindtypeINTEGER2:
|
||
*cptr = &constant->integer2;
|
||
*size = sizeof (constant->integer2);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER3
|
||
case FFEINFO_kindtypeINTEGER3:
|
||
*cptr = &constant->integer3;
|
||
*size = sizeof (constant->integer3);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER4
|
||
case FFEINFO_kindtypeINTEGER4:
|
||
*cptr = &constant->integer4;
|
||
*size = sizeof (constant->integer4);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER5
|
||
case FFEINFO_kindtypeINTEGER5:
|
||
*cptr = &constant->integer5;
|
||
*size = sizeof (constant->integer5);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER6
|
||
case FFEINFO_kindtypeINTEGER6:
|
||
*cptr = &constant->integer6;
|
||
*size = sizeof (constant->integer6);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER7
|
||
case FFEINFO_kindtypeINTEGER7:
|
||
*cptr = &constant->integer7;
|
||
*size = sizeof (constant->integer7);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER8
|
||
case FFEINFO_kindtypeINTEGER8:
|
||
*cptr = &constant->integer8;
|
||
*size = sizeof (constant->integer8);
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad INTEGER ckindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeLOGICAL:
|
||
switch (ckt)
|
||
{
|
||
#if FFETARGET_okLOGICAL1
|
||
case FFEINFO_kindtypeLOGICAL1:
|
||
*cptr = &constant->logical1;
|
||
*size = sizeof (constant->logical1);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL2
|
||
case FFEINFO_kindtypeLOGICAL2:
|
||
*cptr = &constant->logical2;
|
||
*size = sizeof (constant->logical2);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL3
|
||
case FFEINFO_kindtypeLOGICAL3:
|
||
*cptr = &constant->logical3;
|
||
*size = sizeof (constant->logical3);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL4
|
||
case FFEINFO_kindtypeLOGICAL4:
|
||
*cptr = &constant->logical4;
|
||
*size = sizeof (constant->logical4);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL5
|
||
case FFEINFO_kindtypeLOGICAL5:
|
||
*cptr = &constant->logical5;
|
||
*size = sizeof (constant->logical5);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL6
|
||
case FFEINFO_kindtypeLOGICAL6:
|
||
*cptr = &constant->logical6;
|
||
*size = sizeof (constant->logical6);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL7
|
||
case FFEINFO_kindtypeLOGICAL7:
|
||
*cptr = &constant->logical7;
|
||
*size = sizeof (constant->logical7);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL8
|
||
case FFEINFO_kindtypeLOGICAL8:
|
||
*cptr = &constant->logical8;
|
||
*size = sizeof (constant->logical8);
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad LOGICAL ckindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeREAL:
|
||
switch (ckt)
|
||
{
|
||
#if FFETARGET_okREAL1
|
||
case FFEINFO_kindtypeREAL1:
|
||
*cptr = &constant->real1;
|
||
*size = sizeof (constant->real1);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL2
|
||
case FFEINFO_kindtypeREAL2:
|
||
*cptr = &constant->real2;
|
||
*size = sizeof (constant->real2);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL3
|
||
case FFEINFO_kindtypeREAL3:
|
||
*cptr = &constant->real3;
|
||
*size = sizeof (constant->real3);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL4
|
||
case FFEINFO_kindtypeREAL4:
|
||
*cptr = &constant->real4;
|
||
*size = sizeof (constant->real4);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL5
|
||
case FFEINFO_kindtypeREAL5:
|
||
*cptr = &constant->real5;
|
||
*size = sizeof (constant->real5);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL6
|
||
case FFEINFO_kindtypeREAL6:
|
||
*cptr = &constant->real6;
|
||
*size = sizeof (constant->real6);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL7
|
||
case FFEINFO_kindtypeREAL7:
|
||
*cptr = &constant->real7;
|
||
*size = sizeof (constant->real7);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL8
|
||
case FFEINFO_kindtypeREAL8:
|
||
*cptr = &constant->real8;
|
||
*size = sizeof (constant->real8);
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad REAL ckindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeCOMPLEX:
|
||
switch (ckt)
|
||
{
|
||
#if FFETARGET_okCOMPLEX1
|
||
case FFEINFO_kindtypeREAL1:
|
||
*cptr = &constant->complex1;
|
||
*size = sizeof (constant->complex1);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX2
|
||
case FFEINFO_kindtypeREAL2:
|
||
*cptr = &constant->complex2;
|
||
*size = sizeof (constant->complex2);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX3
|
||
case FFEINFO_kindtypeREAL3:
|
||
*cptr = &constant->complex3;
|
||
*size = sizeof (constant->complex3);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX4
|
||
case FFEINFO_kindtypeREAL4:
|
||
*cptr = &constant->complex4;
|
||
*size = sizeof (constant->complex4);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX5
|
||
case FFEINFO_kindtypeREAL5:
|
||
*cptr = &constant->complex5;
|
||
*size = sizeof (constant->complex5);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX6
|
||
case FFEINFO_kindtypeREAL6:
|
||
*cptr = &constant->complex6;
|
||
*size = sizeof (constant->complex6);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX7
|
||
case FFEINFO_kindtypeREAL7:
|
||
*cptr = &constant->complex7;
|
||
*size = sizeof (constant->complex7);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX8
|
||
case FFEINFO_kindtypeREAL8:
|
||
*cptr = &constant->complex8;
|
||
*size = sizeof (constant->complex8);
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad COMPLEX ckindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeCHARACTER:
|
||
switch (ckt)
|
||
{
|
||
#if FFETARGET_okCHARACTER1
|
||
case FFEINFO_kindtypeCHARACTER1:
|
||
*cptr = ffetarget_text_character1 (constant->character1);
|
||
*size = ffetarget_length_character1 (constant->character1);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER2
|
||
case FFEINFO_kindtypeCHARACTER2:
|
||
*cptr = ffetarget_text_character2 (constant->character2);
|
||
*size = ffetarget_length_character2 (constant->character2);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER3
|
||
case FFEINFO_kindtypeCHARACTER3:
|
||
*cptr = ffetarget_text_character3 (constant->character3);
|
||
*size = ffetarget_length_character3 (constant->character3);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER4
|
||
case FFEINFO_kindtypeCHARACTER4:
|
||
*cptr = ffetarget_text_character4 (constant->character4);
|
||
*size = ffetarget_length_character4 (constant->character4);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER5
|
||
case FFEINFO_kindtypeCHARACTER5:
|
||
*cptr = ffetarget_text_character5 (constant->character5);
|
||
*size = ffetarget_length_character5 (constant->character5);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER6
|
||
case FFEINFO_kindtypeCHARACTER6:
|
||
*cptr = ffetarget_text_character6 (constant->character6);
|
||
*size = ffetarget_length_character6 (constant->character6);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER7
|
||
case FFEINFO_kindtypeCHARACTER7:
|
||
*cptr = ffetarget_text_character7 (constant->character7);
|
||
*size = ffetarget_length_character7 (constant->character7);
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER8
|
||
case FFEINFO_kindtypeCHARACTER8:
|
||
*cptr = ffetarget_text_character8 (constant->character8);
|
||
*size = ffetarget_length_character8 (constant->character8);
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad CHARACTER ckindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
default:
|
||
assert ("bad cbasictype" == NULL);
|
||
break;
|
||
}
|
||
}
|
||
|
||
/* ffebld_constantarray_put -- Put a value into an array of constants
|
||
|
||
See prototype. */
|
||
|
||
void
|
||
ffebld_constantarray_put (ffebldConstantArray array, ffeinfoBasictype bt,
|
||
ffeinfoKindtype kt, ffetargetOffset offset, ffebldConstantUnion constant)
|
||
{
|
||
switch (bt)
|
||
{
|
||
case FFEINFO_basictypeINTEGER:
|
||
switch (kt)
|
||
{
|
||
#if FFETARGET_okINTEGER1
|
||
case FFEINFO_kindtypeINTEGER1:
|
||
*(array.integer1 + offset) = constant.integer1;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER2
|
||
case FFEINFO_kindtypeINTEGER2:
|
||
*(array.integer2 + offset) = constant.integer2;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER3
|
||
case FFEINFO_kindtypeINTEGER3:
|
||
*(array.integer3 + offset) = constant.integer3;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER4
|
||
case FFEINFO_kindtypeINTEGER4:
|
||
*(array.integer4 + offset) = constant.integer4;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER5
|
||
case FFEINFO_kindtypeINTEGER5:
|
||
*(array.integer5 + offset) = constant.integer5;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER6
|
||
case FFEINFO_kindtypeINTEGER6:
|
||
*(array.integer6 + offset) = constant.integer6;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER7
|
||
case FFEINFO_kindtypeINTEGER7:
|
||
*(array.integer7 + offset) = constant.integer7;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okINTEGER8
|
||
case FFEINFO_kindtypeINTEGER8:
|
||
*(array.integer8 + offset) = constant.integer8;
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad INTEGER kindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeLOGICAL:
|
||
switch (kt)
|
||
{
|
||
#if FFETARGET_okLOGICAL1
|
||
case FFEINFO_kindtypeLOGICAL1:
|
||
*(array.logical1 + offset) = constant.logical1;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL2
|
||
case FFEINFO_kindtypeLOGICAL2:
|
||
*(array.logical2 + offset) = constant.logical2;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL3
|
||
case FFEINFO_kindtypeLOGICAL3:
|
||
*(array.logical3 + offset) = constant.logical3;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL4
|
||
case FFEINFO_kindtypeLOGICAL4:
|
||
*(array.logical4 + offset) = constant.logical4;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL5
|
||
case FFEINFO_kindtypeLOGICAL5:
|
||
*(array.logical5 + offset) = constant.logical5;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL6
|
||
case FFEINFO_kindtypeLOGICAL6:
|
||
*(array.logical6 + offset) = constant.logical6;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL7
|
||
case FFEINFO_kindtypeLOGICAL7:
|
||
*(array.logical7 + offset) = constant.logical7;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okLOGICAL8
|
||
case FFEINFO_kindtypeLOGICAL8:
|
||
*(array.logical8 + offset) = constant.logical8;
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad LOGICAL kindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeREAL:
|
||
switch (kt)
|
||
{
|
||
#if FFETARGET_okREAL1
|
||
case FFEINFO_kindtypeREAL1:
|
||
*(array.real1 + offset) = constant.real1;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL2
|
||
case FFEINFO_kindtypeREAL2:
|
||
*(array.real2 + offset) = constant.real2;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL3
|
||
case FFEINFO_kindtypeREAL3:
|
||
*(array.real3 + offset) = constant.real3;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL4
|
||
case FFEINFO_kindtypeREAL4:
|
||
*(array.real4 + offset) = constant.real4;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL5
|
||
case FFEINFO_kindtypeREAL5:
|
||
*(array.real5 + offset) = constant.real5;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL6
|
||
case FFEINFO_kindtypeREAL6:
|
||
*(array.real6 + offset) = constant.real6;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL7
|
||
case FFEINFO_kindtypeREAL7:
|
||
*(array.real7 + offset) = constant.real7;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okREAL8
|
||
case FFEINFO_kindtypeREAL8:
|
||
*(array.real8 + offset) = constant.real8;
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad REAL kindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeCOMPLEX:
|
||
switch (kt)
|
||
{
|
||
#if FFETARGET_okCOMPLEX1
|
||
case FFEINFO_kindtypeREAL1:
|
||
*(array.complex1 + offset) = constant.complex1;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX2
|
||
case FFEINFO_kindtypeREAL2:
|
||
*(array.complex2 + offset) = constant.complex2;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX3
|
||
case FFEINFO_kindtypeREAL3:
|
||
*(array.complex3 + offset) = constant.complex3;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX4
|
||
case FFEINFO_kindtypeREAL4:
|
||
*(array.complex4 + offset) = constant.complex4;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX5
|
||
case FFEINFO_kindtypeREAL5:
|
||
*(array.complex5 + offset) = constant.complex5;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX6
|
||
case FFEINFO_kindtypeREAL6:
|
||
*(array.complex6 + offset) = constant.complex6;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX7
|
||
case FFEINFO_kindtypeREAL7:
|
||
*(array.complex7 + offset) = constant.complex7;
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCOMPLEX8
|
||
case FFEINFO_kindtypeREAL8:
|
||
*(array.complex8 + offset) = constant.complex8;
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad COMPLEX kindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case FFEINFO_basictypeCHARACTER:
|
||
switch (kt)
|
||
{
|
||
#if FFETARGET_okCHARACTER1
|
||
case FFEINFO_kindtypeCHARACTER1:
|
||
memcpy (array.character1 + offset,
|
||
ffetarget_text_character1 (constant.character1),
|
||
ffetarget_length_character1 (constant.character1));
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER2
|
||
case FFEINFO_kindtypeCHARACTER2:
|
||
memcpy (array.character2 + offset,
|
||
ffetarget_text_character2 (constant.character2),
|
||
ffetarget_length_character2 (constant.character2));
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER3
|
||
case FFEINFO_kindtypeCHARACTER3:
|
||
memcpy (array.character3 + offset,
|
||
ffetarget_text_character3 (constant.character3),
|
||
ffetarget_length_character3 (constant.character3));
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER4
|
||
case FFEINFO_kindtypeCHARACTER4:
|
||
memcpy (array.character4 + offset,
|
||
ffetarget_text_character4 (constant.character4),
|
||
ffetarget_length_character4 (constant.character4));
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER5
|
||
case FFEINFO_kindtypeCHARACTER5:
|
||
memcpy (array.character5 + offset,
|
||
ffetarget_text_character5 (constant.character5),
|
||
ffetarget_length_character5 (constant.character5));
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER6
|
||
case FFEINFO_kindtypeCHARACTER6:
|
||
memcpy (array.character6 + offset,
|
||
ffetarget_text_character6 (constant.character6),
|
||
ffetarget_length_character6 (constant.character6));
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER7
|
||
case FFEINFO_kindtypeCHARACTER7:
|
||
memcpy (array.character7 + offset,
|
||
ffetarget_text_character7 (constant.character7),
|
||
ffetarget_length_character7 (constant.character7));
|
||
break;
|
||
#endif
|
||
|
||
#if FFETARGET_okCHARACTER8
|
||
case FFEINFO_kindtypeCHARACTER8:
|
||
memcpy (array.character8 + offset,
|
||
ffetarget_text_character8 (constant.character8),
|
||
ffetarget_length_character8 (constant.character8));
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
assert ("bad CHARACTER kindtype" == NULL);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
default:
|
||
assert ("bad basictype" == NULL);
|
||
break;
|
||
}
|
||
}
|
||
|
||
/* ffebld_init_0 -- Initialize the module
|
||
|
||
ffebld_init_0(); */
|
||
|
||
void
|
||
ffebld_init_0 ()
|
||
{
|
||
assert (FFEBLD_op == ARRAY_SIZE (ffebld_op_string_));
|
||
assert (FFEBLD_op == ARRAY_SIZE (ffebld_arity_op_));
|
||
}
|
||
|
||
/* ffebld_init_1 -- Initialize the module for a file
|
||
|
||
ffebld_init_1(); */
|
||
|
||
void
|
||
ffebld_init_1 ()
|
||
{
|
||
#if FFEBLD_whereconstCURRENT_ == FFEBLD_whereconstFILE_
|
||
int i;
|
||
|
||
#if FFETARGET_okCHARACTER1
|
||
ffebld_constant_character1_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCHARACTER2
|
||
ffebld_constant_character2_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCHARACTER3
|
||
ffebld_constant_character3_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCHARACTER4
|
||
ffebld_constant_character4_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCHARACTER5
|
||
ffebld_constant_character5_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCHARACTER6
|
||
ffebld_constant_character6_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCHARACTER7
|
||
ffebld_constant_character7_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCHARACTER8
|
||
ffebld_constant_character8_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCOMPLEX1
|
||
ffebld_constant_complex1_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCOMPLEX2
|
||
ffebld_constant_complex2_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCOMPLEX3
|
||
ffebld_constant_complex3_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCOMPLEX4
|
||
ffebld_constant_complex4_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCOMPLEX5
|
||
ffebld_constant_complex5_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCOMPLEX6
|
||
ffebld_constant_complex6_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCOMPLEX7
|
||
ffebld_constant_complex7_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCOMPLEX8
|
||
ffebld_constant_complex8_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okINTEGER1
|
||
ffebld_constant_integer1_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okINTEGER2
|
||
ffebld_constant_integer2_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okINTEGER3
|
||
ffebld_constant_integer3_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okINTEGER4
|
||
ffebld_constant_integer4_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okINTEGER5
|
||
ffebld_constant_integer5_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okINTEGER6
|
||
ffebld_constant_integer6_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okINTEGER7
|
||
ffebld_constant_integer7_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okINTEGER8
|
||
ffebld_constant_integer8_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okLOGICAL1
|
||
ffebld_constant_logical1_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okLOGICAL2
|
||
ffebld_constant_logical2_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okLOGICAL3
|
||
ffebld_constant_logical3_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okLOGICAL4
|
||
ffebld_constant_logical4_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okLOGICAL5
|
||
ffebld_constant_logical5_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okLOGICAL6
|
||
ffebld_constant_logical6_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okLOGICAL7
|
||
ffebld_constant_logical7_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okLOGICAL8
|
||
ffebld_constant_logical8_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okREAL1
|
||
ffebld_constant_real1_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okREAL2
|
||
ffebld_constant_real2_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okREAL3
|
||
ffebld_constant_real3_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okREAL4
|
||
ffebld_constant_real4_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okREAL5
|
||
ffebld_constant_real5_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okREAL6
|
||
ffebld_constant_real6_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okREAL7
|
||
ffebld_constant_real7_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okREAL8
|
||
ffebld_constant_real8_ = NULL;
|
||
#endif
|
||
ffebld_constant_hollerith_ = NULL;
|
||
for (i = FFEBLD_constTYPELESS_FIRST; i <= FFEBLD_constTYPELESS_LAST; ++i)
|
||
ffebld_constant_typeless_[i - FFEBLD_constTYPELESS_FIRST] = NULL;
|
||
#endif
|
||
}
|
||
|
||
/* ffebld_init_2 -- Initialize the module
|
||
|
||
ffebld_init_2(); */
|
||
|
||
void
|
||
ffebld_init_2 ()
|
||
{
|
||
#if FFEBLD_whereconstCURRENT_ == FFEBLD_whereconstPROGUNIT_
|
||
int i;
|
||
#endif
|
||
|
||
ffebld_pool_stack_.next = NULL;
|
||
ffebld_pool_stack_.pool = ffe_pool_program_unit ();
|
||
#if FFEBLD_whereconstCURRENT_ == FFEBLD_whereconstPROGUNIT_
|
||
#if FFETARGET_okCHARACTER1
|
||
ffebld_constant_character1_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCHARACTER2
|
||
ffebld_constant_character2_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCHARACTER3
|
||
ffebld_constant_character3_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCHARACTER4
|
||
ffebld_constant_character4_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCHARACTER5
|
||
ffebld_constant_character5_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCHARACTER6
|
||
ffebld_constant_character6_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCHARACTER7
|
||
ffebld_constant_character7_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCHARACTER8
|
||
ffebld_constant_character8_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCOMPLEX1
|
||
ffebld_constant_complex1_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCOMPLEX2
|
||
ffebld_constant_complex2_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCOMPLEX3
|
||
ffebld_constant_complex3_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCOMPLEX4
|
||
ffebld_constant_complex4_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCOMPLEX5
|
||
ffebld_constant_complex5_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCOMPLEX6
|
||
ffebld_constant_complex6_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCOMPLEX7
|
||
ffebld_constant_complex7_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okCOMPLEX8
|
||
ffebld_constant_complex8_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okINTEGER1
|
||
ffebld_constant_integer1_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okINTEGER2
|
||
ffebld_constant_integer2_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okINTEGER3
|
||
ffebld_constant_integer3_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okINTEGER4
|
||
ffebld_constant_integer4_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okINTEGER5
|
||
ffebld_constant_integer5_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okINTEGER6
|
||
ffebld_constant_integer6_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okINTEGER7
|
||
ffebld_constant_integer7_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okINTEGER8
|
||
ffebld_constant_integer8_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okLOGICAL1
|
||
ffebld_constant_logical1_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okLOGICAL2
|
||
ffebld_constant_logical2_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okLOGICAL3
|
||
ffebld_constant_logical3_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okLOGICAL4
|
||
ffebld_constant_logical4_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okLOGICAL5
|
||
ffebld_constant_logical5_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okLOGICAL6
|
||
ffebld_constant_logical6_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okLOGICAL7
|
||
ffebld_constant_logical7_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okLOGICAL8
|
||
ffebld_constant_logical8_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okREAL1
|
||
ffebld_constant_real1_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okREAL2
|
||
ffebld_constant_real2_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okREAL3
|
||
ffebld_constant_real3_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okREAL4
|
||
ffebld_constant_real4_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okREAL5
|
||
ffebld_constant_real5_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okREAL6
|
||
ffebld_constant_real6_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okREAL7
|
||
ffebld_constant_real7_ = NULL;
|
||
#endif
|
||
#if FFETARGET_okREAL8
|
||
ffebld_constant_real8_ = NULL;
|
||
#endif
|
||
ffebld_constant_hollerith_ = NULL;
|
||
for (i = FFEBLD_constTYPELESS_FIRST; i <= FFEBLD_constTYPELESS_LAST; ++i)
|
||
ffebld_constant_typeless_[i - FFEBLD_constTYPELESS_FIRST] = NULL;
|
||
#endif
|
||
}
|
||
|
||
/* ffebld_list_length -- Return # of opITEMs in list
|
||
|
||
ffebld list; // Must be NULL or opITEM
|
||
ffebldListLength length;
|
||
length = ffebld_list_length(list);
|
||
|
||
Returns 0 if list is NULL, 1 if it's ffebld_trail is NULL, and so on. */
|
||
|
||
ffebldListLength
|
||
ffebld_list_length (ffebld list)
|
||
{
|
||
ffebldListLength length;
|
||
|
||
for (length = 0; list != NULL; ++length, list = ffebld_trail (list))
|
||
;
|
||
|
||
return length;
|
||
}
|
||
|
||
/* ffebld_new_accter -- Create an ffebld object that is an array
|
||
|
||
ffebld x;
|
||
ffebldConstantArray a;
|
||
ffebit b;
|
||
x = ffebld_new_accter(a,b); */
|
||
|
||
ffebld
|
||
ffebld_new_accter (ffebldConstantArray a, ffebit b)
|
||
{
|
||
ffebld x;
|
||
|
||
x = ffebld_new ();
|
||
#if FFEBLD_BLANK_
|
||
*x = ffebld_blank_;
|
||
#endif
|
||
x->op = FFEBLD_opACCTER;
|
||
x->u.accter.array = a;
|
||
x->u.accter.bits = b;
|
||
x->u.accter.pad = 0;
|
||
return x;
|
||
}
|
||
|
||
/* ffebld_new_arrter -- Create an ffebld object that is an array
|
||
|
||
ffebld x;
|
||
ffebldConstantArray a;
|
||
ffetargetOffset size;
|
||
x = ffebld_new_arrter(a,size); */
|
||
|
||
ffebld
|
||
ffebld_new_arrter (ffebldConstantArray a, ffetargetOffset size)
|
||
{
|
||
ffebld x;
|
||
|
||
x = ffebld_new ();
|
||
#if FFEBLD_BLANK_
|
||
*x = ffebld_blank_;
|
||
#endif
|
||
x->op = FFEBLD_opARRTER;
|
||
x->u.arrter.array = a;
|
||
x->u.arrter.size = size;
|
||
x->u.arrter.pad = 0;
|
||
return x;
|
||
}
|
||
|
||
/* ffebld_new_conter_with_orig -- Create an ffebld object that is a constant
|
||
|
||
ffebld x;
|
||
ffebldConstant c;
|
||
x = ffebld_new_conter_with_orig(c,NULL); */
|
||
|
||
ffebld
|
||
ffebld_new_conter_with_orig (ffebldConstant c, ffebld o)
|
||
{
|
||
ffebld x;
|
||
|
||
x = ffebld_new ();
|
||
#if FFEBLD_BLANK_
|
||
*x = ffebld_blank_;
|
||
#endif
|
||
x->op = FFEBLD_opCONTER;
|
||
x->u.conter.expr = c;
|
||
x->u.conter.orig = o;
|
||
x->u.conter.pad = 0;
|
||
return x;
|
||
}
|
||
|
||
/* ffebld_new_item -- Create an ffebld item object
|
||
|
||
ffebld x,y,z;
|
||
x = ffebld_new_item(y,z); */
|
||
|
||
ffebld
|
||
ffebld_new_item (ffebld head, ffebld trail)
|
||
{
|
||
ffebld x;
|
||
|
||
x = ffebld_new ();
|
||
#if FFEBLD_BLANK_
|
||
*x = ffebld_blank_;
|
||
#endif
|
||
x->op = FFEBLD_opITEM;
|
||
x->u.item.head = head;
|
||
x->u.item.trail = trail;
|
||
#ifdef FFECOM_itemHOOK
|
||
x->u.item.hook = FFECOM_itemNULL;
|
||
#endif
|
||
return x;
|
||
}
|
||
|
||
/* ffebld_new_labter -- Create an ffebld object that is a label
|
||
|
||
ffebld x;
|
||
ffelab l;
|
||
x = ffebld_new_labter(c); */
|
||
|
||
ffebld
|
||
ffebld_new_labter (ffelab l)
|
||
{
|
||
ffebld x;
|
||
|
||
x = ffebld_new ();
|
||
#if FFEBLD_BLANK_
|
||
*x = ffebld_blank_;
|
||
#endif
|
||
x->op = FFEBLD_opLABTER;
|
||
x->u.labter = l;
|
||
return x;
|
||
}
|
||
|
||
/* ffebld_new_labtok -- Create object that is a label's NUMBER token
|
||
|
||
ffebld x;
|
||
ffelexToken t;
|
||
x = ffebld_new_labter(c);
|
||
|
||
Like the other ffebld_new_ functions, the
|
||
supplied argument is stored exactly as is: ffelex_token_use is NOT
|
||
called, so the token is "consumed", if one is indeed supplied (it may
|
||
be NULL). */
|
||
|
||
ffebld
|
||
ffebld_new_labtok (ffelexToken t)
|
||
{
|
||
ffebld x;
|
||
|
||
x = ffebld_new ();
|
||
#if FFEBLD_BLANK_
|
||
*x = ffebld_blank_;
|
||
#endif
|
||
x->op = FFEBLD_opLABTOK;
|
||
x->u.labtok = t;
|
||
return x;
|
||
}
|
||
|
||
/* ffebld_new_none -- Create an ffebld object with no arguments
|
||
|
||
ffebld x;
|
||
x = ffebld_new_none(FFEBLD_opWHATEVER); */
|
||
|
||
ffebld
|
||
ffebld_new_none (ffebldOp o)
|
||
{
|
||
ffebld x;
|
||
|
||
x = ffebld_new ();
|
||
#if FFEBLD_BLANK_
|
||
*x = ffebld_blank_;
|
||
#endif
|
||
x->op = o;
|
||
return x;
|
||
}
|
||
|
||
/* ffebld_new_one -- Create an ffebld object with one argument
|
||
|
||
ffebld x,y;
|
||
x = ffebld_new_one(FFEBLD_opWHATEVER,y); */
|
||
|
||
ffebld
|
||
ffebld_new_one (ffebldOp o, ffebld left)
|
||
{
|
||
ffebld x;
|
||
|
||
x = ffebld_new ();
|
||
#if FFEBLD_BLANK_
|
||
*x = ffebld_blank_;
|
||
#endif
|
||
x->op = o;
|
||
x->u.nonter.left = left;
|
||
#ifdef FFECOM_nonterHOOK
|
||
x->u.nonter.hook = FFECOM_nonterNULL;
|
||
#endif
|
||
return x;
|
||
}
|
||
|
||
/* ffebld_new_symter -- Create an ffebld object that is a symbol
|
||
|
||
ffebld x;
|
||
ffesymbol s;
|
||
ffeintrinGen gen; // Generic intrinsic id, if any
|
||
ffeintrinSpec spec; // Specific intrinsic id, if any
|
||
ffeintrinImp imp; // Implementation intrinsic id, if any
|
||
x = ffebld_new_symter (s, gen, spec, imp); */
|
||
|
||
ffebld
|
||
ffebld_new_symter (ffesymbol s, ffeintrinGen gen, ffeintrinSpec spec,
|
||
ffeintrinImp imp)
|
||
{
|
||
ffebld x;
|
||
|
||
x = ffebld_new ();
|
||
#if FFEBLD_BLANK_
|
||
*x = ffebld_blank_;
|
||
#endif
|
||
x->op = FFEBLD_opSYMTER;
|
||
x->u.symter.symbol = s;
|
||
x->u.symter.generic = gen;
|
||
x->u.symter.specific = spec;
|
||
x->u.symter.implementation = imp;
|
||
x->u.symter.do_iter = FALSE;
|
||
return x;
|
||
}
|
||
|
||
/* ffebld_new_two -- Create an ffebld object with two arguments
|
||
|
||
ffebld x,y,z;
|
||
x = ffebld_new_two(FFEBLD_opWHATEVER,y,z); */
|
||
|
||
ffebld
|
||
ffebld_new_two (ffebldOp o, ffebld left, ffebld right)
|
||
{
|
||
ffebld x;
|
||
|
||
x = ffebld_new ();
|
||
#if FFEBLD_BLANK_
|
||
*x = ffebld_blank_;
|
||
#endif
|
||
x->op = o;
|
||
x->u.nonter.left = left;
|
||
x->u.nonter.right = right;
|
||
#ifdef FFECOM_nonterHOOK
|
||
x->u.nonter.hook = FFECOM_nonterNULL;
|
||
#endif
|
||
return x;
|
||
}
|
||
|
||
/* ffebld_pool_pop -- Pop ffebld's pool stack
|
||
|
||
ffebld_pool_pop(); */
|
||
|
||
void
|
||
ffebld_pool_pop ()
|
||
{
|
||
ffebldPoolstack_ ps;
|
||
|
||
assert (ffebld_pool_stack_.next != NULL);
|
||
ps = ffebld_pool_stack_.next;
|
||
ffebld_pool_stack_.next = ps->next;
|
||
ffebld_pool_stack_.pool = ps->pool;
|
||
malloc_kill_ks (malloc_pool_image (), ps, sizeof (*ps));
|
||
}
|
||
|
||
/* ffebld_pool_push -- Push ffebld's pool stack
|
||
|
||
ffebld_pool_push(); */
|
||
|
||
void
|
||
ffebld_pool_push (mallocPool pool)
|
||
{
|
||
ffebldPoolstack_ ps;
|
||
|
||
ps = malloc_new_ks (malloc_pool_image (), "Pool stack", sizeof (*ps));
|
||
ps->next = ffebld_pool_stack_.next;
|
||
ps->pool = ffebld_pool_stack_.pool;
|
||
ffebld_pool_stack_.next = ps;
|
||
ffebld_pool_stack_.pool = pool;
|
||
}
|
||
|
||
/* ffebld_op_string -- Return short string describing op
|
||
|
||
ffebldOp o;
|
||
ffebld_op_string(o);
|
||
|
||
Returns a short string (uppercase) containing the name of the op. */
|
||
|
||
const char *
|
||
ffebld_op_string (ffebldOp o)
|
||
{
|
||
if (o >= ARRAY_SIZE (ffebld_op_string_))
|
||
return "?\?\?";
|
||
return ffebld_op_string_[o];
|
||
}
|
||
|
||
/* ffebld_size_max -- Return maximum possible size of CHARACTER-type expr
|
||
|
||
ffetargetCharacterSize sz;
|
||
ffebld b;
|
||
sz = ffebld_size_max (b);
|
||
|
||
Like ffebld_size_known, but if that would return NONE and the expression
|
||
is opSUBSTR, opCONVERT, opPAREN, or opCONCATENATE, returns ffebld_size_max
|
||
of the subexpression(s). */
|
||
|
||
ffetargetCharacterSize
|
||
ffebld_size_max (ffebld b)
|
||
{
|
||
ffetargetCharacterSize sz;
|
||
|
||
recurse: /* :::::::::::::::::::: */
|
||
|
||
sz = ffebld_size_known (b);
|
||
|
||
if (sz != FFETARGET_charactersizeNONE)
|
||
return sz;
|
||
|
||
switch (ffebld_op (b))
|
||
{
|
||
case FFEBLD_opSUBSTR:
|
||
case FFEBLD_opCONVERT:
|
||
case FFEBLD_opPAREN:
|
||
b = ffebld_left (b);
|
||
goto recurse; /* :::::::::::::::::::: */
|
||
|
||
case FFEBLD_opCONCATENATE:
|
||
sz = ffebld_size_max (ffebld_left (b))
|
||
+ ffebld_size_max (ffebld_right (b));
|
||
return sz;
|
||
|
||
default:
|
||
return sz;
|
||
}
|
||
}
|