/* Copyright (C) 2001-2023 Artifex Software, Inc.

   All Rights Reserved.

   This software is provided AS-IS with no warranty, either express or

   implied.

   This software is distributed under license and may not be copied,

   modified or distributed except as expressly authorized under the terms

   of the license contained in the file LICENSE in this distribution.

   Refer to licensing information at http://www.artifex.com or contact

   Artifex Software, Inc.,  39 Mesa Street, Suite 108A, San Francisco,

   CA 94129, USA, for further information.

*/

/* Definitions for Ghostscript modules that define allocatable structures */

/* Requires gstypes.h */

#ifndef gsstruct_INCLUDED

#  define gsstruct_INCLUDED

#include "gsstype.h"

/*

 * Ghostscript structures are defined with names of the form (gs_)xxx_s,

 * with a corresponding typedef of the form (gs_)xxx or (gs_)xxx_t.

 * By extension, the structure descriptor is named st_[gs_]xxx.

 * (Note that the descriptor name may omit the gs_ even if the type has it.)

 * Structure descriptors are always allocated statically and are

 * always const; they may be either public or private.

 *

 * In order to ensure that there is a descriptor for each structure type,

 * we require, by convention, that the following always appear together

 * if the structure is defined in a .h file:

 *      - The definition of the structure xxx_s;

 *      - If the descriptor is public, an extern_st(st_xxx);

 *      - The definition of a macro public_st_xxx() or private_st_xxx()

 *      that creates the actual descriptor.

 * This convention makes the descriptor visible (if public) to any module

 * that can see the structure definition.  This is more liberal than

 * we would like, but it is a reasonable compromise between restricting

 * visibility and keeping all the definitional elements of a structure

 * together.  We require that there be no other externs for (public)

 * structure descriptors; if the definer of a structure wants to make

 * available the ability to create an instance but does not want to

 * expose the structure definition, it must export a creator procedure.

 */

/*

 * If the structure is defined in a .c file, we require that the following

 * appear together:

 *      - The definition of the structure xxx_s;

 *      - The gs_private_st_xxx macro that creates the descriptor.

 * Note that we only allow this if the structure is completely private

 * to a single file.  Again, the file must export a creator procedure

 * if it wants external clients to be able to create instances.

 *

 * Some structures are embedded inside others.  In order to be able to

 * construct the composite pointer enumeration procedures, for such

 * structures we must define not only the st_xxx descriptor, but also

 * a st_xxx_max_ptrs constant that gives the maximum number of pointers

 * the enumeration procedure will return.  This is an unfortunate consequence

 * of the method we have chosen for implementing pointer enumeration.

 *

 * Some structures may exist as elements of homogenous arrays.

 * In order to be able to enumerate and relocate such arrays, we adopt

 * the convention that the structure representing an element must be

 * distinguished from the structure per se, and the name of the element

 * structure always ends with "_element".  Element structures cannot be

 * embedded in other structures.

 *

 * Note that the definition of the xxx_s structure may be separate from

 * the typedef for the type xxx(_t).  This still allows us to have full

 * structure type abstraction.

 *

 * Descriptor definitions are not required for structures to which

 * no traceable pointers from garbage-collectable space will ever exist.

 * For example, the struct that defines structure types themselves does not

 * require a descriptor.

 */

/* An opaque type for an object header. */

typedef struct obj_header_s obj_header_t;

/*

 * Define pointer types, which define how to mark the referent of the

 * pointer.

 */

/*typedef struct gs_ptr_procs_s gs_ptr_procs_t;*/  /* in gsmemory.h */

struct gs_ptr_procs_s {

    /* Unmark the referent of a pointer. */

#define ptr_proc_unmark(proc)\

  void proc(enum_ptr_t *, gc_state_t *)

    ptr_proc_unmark((*unmark));

    /* Mark the referent of a pointer. */

    /* Return true iff it was unmarked before. */

#define ptr_proc_mark(proc)\

  bool proc(enum_ptr_t *, gc_state_t *)

    ptr_proc_mark((*mark));

    /* Relocate a pointer. */

    /* Note that the argument is const, but the */

    /* return value is not: this shifts the compiler */

    /* 'discarding const' warning from the call sites */

    /* (the reloc_ptr routines) to the implementations. */

#define ptr_proc_reloc(proc, typ)\

  typ *proc(const typ *, gc_state_t *)

    ptr_proc_reloc((*reloc), void);

};

/*typedef const gs_ptr_procs_t *gs_ptr_type_t;*/  /* in gsmemory.h */

/* Define the pointer type for ordinary structure pointers. */

extern const gs_ptr_procs_t ptr_struct_procs;

#define ptr_struct_type (&ptr_struct_procs)

/* Define the pointer types for a pointer to a gs_[const_]string. */

extern const gs_ptr_procs_t ptr_string_procs;

#define ptr_string_type (&ptr_string_procs)

extern const gs_ptr_procs_t ptr_const_string_procs;

#define ptr_const_string_type (&ptr_const_string_procs)

/* Define the pointer type for name indexes. */

extern const gs_ptr_procs_t ptr_name_index_procs;

#define ptr_name_index_type (&ptr_name_index_procs)

/*

 * Define the type for a GC root.

 */

/*typedef struct gs_gc_root_s gs_gc_root_t;*/  /* in gsmemory.h */

struct gs_gc_root_s {

    gs_gc_root_t *next;

    gs_ptr_type_t ptype;

    void **p;

    bool free_on_unregister;

};

#define public_st_gc_root_t() /* in gsmemory.c */\

  gs_public_st_ptrs1(st_gc_root_t, gs_gc_root_t, "gs_gc_root_t",\

    gc_root_enum_ptrs, gc_root_reloc_ptrs, next)

/* Print a root debugging message. */

#define if_debug_root(c, mem, msg, rp)\

  if_debug4m(c, mem, "%s "PRI_INTPTR": "PRI_INTPTR" -> "PRI_INTPTR"\n",\

             msg, (intptr_t)(rp), (intptr_t)(rp)->p, (intptr_t)*(rp)->p)

/*

 * We don't want to tie the allocator to using a single garbage collector,

 * so we pass all the relevant GC procedures in to the structure pointer

 * enumeration and relocation procedures.  The GC state must begin with

 * a pointer to the following procedure vector.

 *

 * By default, this is all the procedures we know about, but there are

 * additional procedures defined in the interpreter for dealing with

 * 'ref' objects.

 */

#define string_proc_reloc(proc)\

  void proc(gs_string *, gc_state_t *)

#define const_string_proc_reloc(proc)\

  void proc(gs_const_string *, gc_state_t *)

#define param_string_proc_reloc(proc)\

  void proc(gs_param_string *, gc_state_t *)

#define gc_procs_common\

        /* Relocate a pointer to an object. */\

  ptr_proc_reloc((*reloc_struct_ptr), void /*obj_header_t*/);\

        /* Relocate a pointer to a string. */\

  string_proc_reloc((*reloc_string));\

        /* Relocate a pointer to a const string. */\

  const_string_proc_reloc((*reloc_const_string));\

        /* Relocate a pointer to a parameter string. */\

  param_string_proc_reloc((*reloc_param_string))

typedef struct gc_procs_common_s {

    gc_procs_common;

} gc_procs_common_t;

#define gc_proc(gcst, proc) ((*(const gc_procs_common_t **)(gcst))->proc)

/* Define the accessor for structure type names. */

#define struct_type_name_string(pstype) ((const char *)((pstype)->sname))

/* Default pointer processing */

struct_proc_enum_ptrs(gs_no_struct_enum_ptrs);

struct_proc_reloc_ptrs(gs_no_struct_reloc_ptrs);

/* Define 'type' descriptors for some standard objects. */

    /* Free blocks */

extern_st(st_free);

    /* Byte objects */

extern_st(st_bytes);

    /* GC roots */

extern_st(st_gc_root_t);

    /* Elements and arrays of const strings. */

#define private_st_const_string()\

  BASIC_PTRS(const_string_elts) {\

    { GC_ELT_CONST_STRING, 0 }\

  };\

  gs__st_basic(private_st, st_const_string, gs_const_string,\

    "gs_const_string", const_string_elts, const_string_sdata)

extern_st(st_const_string_element);

#define public_st_const_string_element()\

  gs_public_st_element(st_const_string_element, gs_const_string,\

    "gs_const_string[]", const_string_elt_enum_ptrs,\

    const_string_elt_reloc_ptrs, st_const_string)

/* ================ Macros for defining structure types ================ */

#define public_st const gs_memory_struct_type_t

#define private_st static const gs_memory_struct_type_t

/*

 * As an alternative to defining different enum_ptrs and reloc_ptrs

 * procedures for basic structure types that only have a fixed number of

 * pointers and possibly a single supertype, we can define the type's GC

 * information using stock procedures and a table.  Each entry in the table

 * defines one element of the structure.

 */

/* Define the pointer types of individual elements. */

typedef enum {

    GC_ELT_OBJ,     /* obj * or const obj * */

    GC_ELT_STRING,    /* gs_string */

    GC_ELT_CONST_STRING   /* gs_const_string */

} gc_ptr_type_index_t;

typedef struct gc_ptr_element_s {

    ushort /*gc_ptr_type_index_t */ type;

    ushort offset;

} gc_ptr_element_t;

#define GC_OBJ_ELT(typ, elt)\

  { GC_ELT_OBJ, offset_of(typ, elt) }

#define GC_OBJ_ELT2(typ, e1, e2)\

  GC_OBJ_ELT(typ, e1), GC_OBJ_ELT(typ, e2)

#define GC_OBJ_ELT3(typ, e1, e2, e3)\

  GC_OBJ_ELT(typ, e1), GC_OBJ_ELT(typ, e2), GC_OBJ_ELT(typ, e3)

#define GC_STRING_ELT(typ, elt)\

  { GC_ELT_STRING, offset_of(typ, elt) }

#define GC_CONST_STRING_ELT(typ, elt)\

  { GC_ELT_CONST_STRING, offset_of(typ, elt) }

/* Define the complete table of descriptor data. */

typedef struct gc_struct_data_s {

    ushort num_ptrs;

    ushort super_offset;

    const gs_memory_struct_type_t *super_type; /* 0 if none */

    const gc_ptr_element_t *ptrs;

} gc_struct_data_t;

/*

 * Define the enum_ptrs and reloc_ptrs procedures, and the declaration

 * macros, for table-specified structures.  For such structures, the

 * proc_data points to a gc_struct_data_t.  The standard defining form

 * is:

 BASIC_PTRS(xxx_ptrs) {

    ... elements ...

 };

 gs_(private|public)_st_basic_super_final(stname, stype, sname, xxx_ptrs,

    xxx_data, supst, supoff, pfinal);

 gs_(private|public)_st_basic_super(stname, stype, sname, xxx_ptrs, xxx_data,

    supst, supoff);

 gs_(private|public)_st_basic(stname, stype, sname, xxx_ptrs, xxx_data);

 */

struct_proc_enum_ptrs(basic_enum_ptrs);

struct_proc_reloc_ptrs(basic_reloc_ptrs);

#define BASIC_PTRS(elts)\

  static const gc_ptr_element_t elts[] =

#define gs__st_basic_with_super_final(scope_st, stname, stype, sname, nelts, elts, sdata, supst, supoff, pfinal)\

  static const gc_struct_data_t sdata = {\

    nelts, supoff, supst, elts\

  };\

  scope_st stname = {\

    sizeof(stype), sname, 0, 0, basic_enum_ptrs, basic_reloc_ptrs,\

    pfinal, &sdata\

  }

     /* Basic objects with superclass and finalization. */

#define gs__st_basic_super_final(scope_st, stname, stype, sname, elts, sdata, supst, supoff, pfinal)\

  gs__st_basic_with_super_final(scope_st, stname, stype, sname, countof(elts), elts, sdata, supst, supoff, pfinal)

#define gs_public_st_basic_super_final(stname, stype, sname, elts, sdata, supst, supoff, pfinal)\

  gs__st_basic_super_final(public_st, stname, stype, sname, elts, sdata, supst, supoff, pfinal)

#define gs_private_st_basic_super_final(stname, stype, sname, elts, sdata, supst, supoff, pfinal)\

  gs__st_basic_super_final(private_st, stname, stype, sname, elts, sdata, supst, supoff, pfinal)

     /* Basic objects with only superclass. */

#define gs__st_basic_super(scope_st, stname, stype, sname, elts, sdata, supst, supoff)\

  gs__st_basic_super_final(scope_st, stname, stype, sname, elts, sdata, supst, supoff, 0)

#define gs_public_st_basic_super(stname, stype, sname, elts, sdata, supst, supoff)\

  gs__st_basic_super(public_st, stname, stype, sname, elts, sdata, supst, supoff)

#define gs_private_st_basic_super(stname, stype, sname, elts, sdata, supst, supoff)\

  gs__st_basic_super(private_st, stname, stype, sname, elts, sdata, supst, supoff)

     /* Basic objects with finalization and no superclass */

#define gs__st_basic_final(scope_st, stname, stype, sname, elts, sdata, pfinal)\

  gs__st_basic_super_final(scope_st, stname, stype, sname, elts, sdata, 0, 0, pfinal)

#define gs_public_st_basic_final(stname, stype, sname, elts, sdata, pfinal)\

  gs__st_basic_final(public_st, stname, stype, sname, elts, sdata, pfinal)

#define gs_private_st_basic_final(stname, stype, sname, elts, sdata, pfinal)\

  gs__st_basic_final(private_st, stname, stype, sname, elts, sdata, pfinal)

     /* Basic objects with no frills. */

#define gs__st_basic(scope_st, stname, stype, sname, elts, sdata)\

  gs__st_basic_super(scope_st, stname, stype, sname, elts, sdata, 0, 0)

#define gs_public_st_basic(stname, stype, sname, elts, sdata)\

  gs__st_basic(public_st, stname, stype, sname, elts, sdata)

#define gs_private_st_basic(stname, stype, sname, elts, sdata)\

  gs__st_basic(private_st, stname, stype, sname, elts, sdata)

/*

 * The simplest kind of composite structure is one with a fixed set of

 * pointers, each of which points to a struct.  We provide macros for

 * defining this kind of structure conveniently, either all at once in

 * the structure definition macro, or using the following template:

 ENUM_PTRS_WITH(xxx_enum_ptrs, stype *const myptr) return 0;

 ... ENUM_PTR(i, xxx, elt); ...

 ENUM_PTRS_END

 RELOC_PTRS_WITH(xxx_reloc_ptrs, stype *const myptr)

 {

     ...

     RELOC_VAR(myptr->elt);

     ...

 }

 */

/*

 * We have to pull the 'static' keyword outside the ENUM_PTRS_BEGIN and

 * RELOC_PTRS_BEGIN macros because of a bug in the Borland C++ preprocessor.

 * We also have to make sure there is more on the line after these

 * macros, so as not to confuse ansi2knr.

 */

     /* Begin enumeration */

#define ENUM_PTRS_BEGIN_PROC(proc)\

  gs_ptr_type_t proc(const gs_memory_t *mem, EV_CONST void *vptr, uint size, int index, enum_ptr_t *pep, const gs_memory_struct_type_t *pstype, gc_state_t *gcst)

#define ENUM_PTRS_BEGIN(proc)\

  ENUM_PTRS_BEGIN_PROC(proc)\

  { switch ( index ) { default:

#define ENUM_PTRS_WITH(proc, stype_ptr)\

  ENUM_PTRS_BEGIN_PROC(proc)\

  { EV_CONST stype_ptr = vptr; switch ( index ) { default:

    /* Enumerate elements */

#define ENUM_OBJ(optr)    /* pointer to object */\

  (pep->ptr = (const void *)(optr), ptr_struct_type)

#define ENUM_STRING2(sdata, ssize) /* gs_string */\

  (pep->ptr = sdata, pep->size = ssize, ptr_string_type)

#define ENUM_STRING(sptr) /* pointer to gs_string */\

  ENUM_STRING2((sptr)->data, (sptr)->size)

#define ENUM_CONST_STRING2(sdata, ssize)  /* gs_const_string */\

  (pep->ptr = sdata, pep->size = ssize, ptr_const_string_type)

#define ENUM_CONST_STRING(sptr) /* pointer to gs_const_string */\

  ENUM_CONST_STRING2((sptr)->data, (sptr)->size)

#define ENUM_NAME_INDEX(name) /* name (as a long index) */\

    (pep->size = (uint)name, ptr_name_index_type)

extern gs_ptr_type_t

    enum_bytestring(enum_ptr_t *pep, const gs_bytestring *pbs);

#define ENUM_BYTESTRING(ptr)  /* pointer to gs_bytestring */\

  enum_bytestring(pep, ptr)

extern gs_ptr_type_t

    enum_const_bytestring(enum_ptr_t *pep, const gs_const_bytestring *pbs);

#define ENUM_CONST_BYTESTRING(ptr)  /* pointer to gs_const_bytestring */\

  enum_const_bytestring(pep, ptr)

#define ENUM_OBJ_ELT(typ, elt)\

  ENUM_OBJ(((const typ *)vptr)->elt)

#define ENUM_STRING_ELT(typ, elt)\

  ENUM_STRING(&((const typ *)vptr)->elt)

#define ENUM_PARAM_STRING_ELT(typ, elt)\

    (((const typ *)vptr)->elt.persistent ? 0 : ENUM_STRING(&((const typ *)vptr)->elt))

#define ENUM_CONST_STRING_ELT(typ, elt)\

  ENUM_CONST_STRING(&((const typ *)vptr)->elt)

#define ENUM_NAME_INDEX_ELT(typ, elt) /* name (as a long index) */\

    (pep->size = (uint)(((const typ *)vptr)->elt), ptr_name_index_type)

#define ENUM_PTR(i, typ, elt)\

  case i: return ENUM_OBJ_ELT(typ, elt)

#define ENUM_PTR2(i, typ, e1, e2) /* just an abbreviation */\

  ENUM_PTR(i, typ, e1); ENUM_PTR((i)+1, typ, e2)

#define ENUM_PTR3(i, typ, e1, e2, e3) /* just an abbreviation */\

  ENUM_PTR(i, typ, e1); ENUM_PTR((i)+1, typ, e2); ENUM_PTR((i)+2, typ, e3)

#define ENUM_STRING_PTR(i, typ, elt)\

  case i: return ENUM_STRING_ELT(typ, elt)

#define ENUM_PARAM_STRING_PTR(i, typ, elt)\

  case i: return ENUM_PARAM_STRING_ELT(typ, elt)

#define ENUM_CONST_STRING_PTR(i, typ, elt)\

  case i: return ENUM_CONST_STRING_ELT(typ, elt)

    /* End enumeration */

#define ENUM_PTRS_END\

  } /* mustn't fall through! */ ENUM_PTRS_END_PROC }

#define ENUM_PTRS_END_PROC  /* */

    /* Begin relocation */

#define RELOC_PTRS_BEGIN(proc)\

  void proc(void *vptr, uint size, const gs_memory_struct_type_t *pstype, gc_state_t *gcst) {

#define RELOC_PTRS_WITH(proc, stype_ptr)\

    RELOC_PTRS_BEGIN(proc) stype_ptr = vptr;

    /* Relocate elements */

#define RELOC_OBJ(ptr)\

  (gc_proc(gcst, reloc_struct_ptr)((const void *)(ptr), gcst))

#define RELOC_OBJ_VAR(ptrvar)\

  (ptrvar = RELOC_OBJ(ptrvar))

#define RELOC_VAR(ptrvar) /* a handy abbreviation */\

  RELOC_OBJ_VAR(ptrvar)

#define RELOC_STRING_VAR(ptrvar)\

  (gc_proc(gcst, reloc_string)(&(ptrvar), gcst))

#define RELOC_CONST_STRING_VAR(ptrvar)\

  (gc_proc(gcst, reloc_const_string)(&(ptrvar), gcst))

#define RELOC_PARAM_STRING_VAR(ptrvar)\

  (gc_proc(gcst, reloc_param_string)(&(ptrvar), gcst))

extern void reloc_bytestring(gs_bytestring *pbs, gc_state_t *gcst);

#define RELOC_BYTESTRING_VAR(ptrvar)\

  reloc_bytestring(&(ptrvar), gcst)

extern void reloc_const_bytestring(gs_const_bytestring *pbs, gc_state_t *gcst);

#define RELOC_CONST_BYTESTRING_VAR(ptrvar)\

  reloc_const_bytestring(&(ptrvar), gcst)

#define RELOC_OBJ_ELT(typ, elt)\

  RELOC_VAR(((typ *)vptr)->elt)

#define RELOC_STRING_ELT(typ, elt)\

  RELOC_STRING_VAR(((typ *)vptr)->elt)

#define RELOC_CONST_STRING_ELT(typ, elt)\

  RELOC_CONST_STRING_VAR(((typ *)vptr)->elt)

#define RELOC_PARAM_STRING_ELT(typ, elt)\

  RELOC_PARAM_STRING_VAR(((typ *)vptr)->elt)

/* Relocate a pointer that points to a known offset within an object. */

/* OFFSET is for byte offsets, TYPED_OFFSET is for element offsets. */

#define RELOC_OFFSET_ELT(typ, elt, offset)\

  ((typ *)vptr)->elt = (void *)\

    ((char *)RELOC_OBJ((char *)((typ *)vptr)->elt - (offset)) +\

     (offset))

#define RELOC_TYPED_OFFSET_ELT(typ, elt, offset)\

  (((typ *)vptr)->elt = (void *)RELOC_OBJ(((typ *)vptr)->elt - (offset)),\

   ((typ *)vptr)->elt += (offset))

    /* Backward compatibility */

#define RELOC_PTR(typ, elt)\

  RELOC_OBJ_ELT(typ, elt)

#define RELOC_PTR2(typ, e1, e2) /* just an abbreviation */\

  RELOC_PTR(typ,e1); RELOC_PTR(typ,e2)

#define RELOC_PTR3(typ, e1, e2, e3) /* just an abbreviation */\

  RELOC_PTR(typ,e1); RELOC_PTR(typ,e2); RELOC_PTR(typ,e3)

#define RELOC_OFFSET_PTR(typ, elt, offset)\

  RELOC_OFFSET_ELT(typ, elt, offset)

#define RELOC_TYPED_OFFSET_PTR(typ, elt, offset)\

  RELOC_TYPED_OFFSET_ELT(typ, elt, offset)

#define RELOC_STRING_PTR(typ, elt)\

  RELOC_STRING_ELT(typ, elt)

#define RELOC_CONST_STRING_PTR(typ, elt)\

  RELOC_CONST_STRING_ELT(typ, elt)

#define RELOC_PARAM_STRING_PTR(typ, elt)\

  RELOC_PARAM_STRING_ELT(typ, elt)

    /* End relocation */

#define RELOC_PTRS_END\

  }

    /* Subclass support */

#define ENUM_USING(supst, ptr, size, index)\

  (*(supst).enum_ptrs)(mem, ptr, size, index, pep, &(supst), gcst)

#define RELOC_USING(supst, ptr, size)\

  (*(supst).reloc_ptrs)(ptr, size, &(supst), gcst)

    /*

     * Support for suffix subclasses.  Special subclasses constructed

     * 'by hand' may use this also.

     */

#define ENUM_USING_PREFIX(supst, n)\

  ENUM_USING(supst, vptr, size, index-(n))

#define ENUM_PREFIX(supst, n)\

  return ENUM_USING_PREFIX(supst, n)

#define RELOC_PREFIX(supst)\

  RELOC_USING(supst, vptr, size)

    /*

     * Support for general subclasses.

     */

#define ENUM_SUPER_ELT(stype, supst, member, n)\

  ENUM_USING(supst, &((EV_CONST stype *)vptr)->member, sizeof(((EV_CONST stype *)vptr)->member), index-(n))

#define ENUM_SUPER(stype, supst, member, n)\

  return ENUM_SUPER_ELT(stype, supst, member, n)

#define RELOC_SUPER_ELT(stype, supst, member)\

  RELOC_USING(supst, &((stype *)vptr)->member, sizeof(((stype *)vptr)->member))

#define RELOC_SUPER(stype, supst, member)\

  RELOC_SUPER_ELT(stype, supst, member)

    /* Backward compatibility. */

#define ENUM_RETURN(ptr) return ENUM_OBJ(ptr)

#define ENUM_RETURN_PTR(typ, elt) return ENUM_OBJ_ELT(typ, elt)

#define ENUM_RETURN_STRING_PTR(typ, elt) return ENUM_STRING_ELT(typ, elt)

#define ENUM_RETURN_CONST_STRING(ptr) return ENUM_CONST_STRING(ptr)

#define ENUM_RETURN_CONST_STRING_PTR(typ, elt) return ENUM_CONST_STRING_ELT(typ, elt)

/* -------------- Simple structures (no internal pointers). -------------- */

#define gs__st_simple(scope_st, stname, stype, sname)\

  scope_st stname = { sizeof(stype), sname, 0, 0, gs_no_struct_enum_ptrs, gs_no_struct_reloc_ptrs, 0, 0 }

#define gs_public_st_simple(stname, stype, sname)\

  gs__st_simple(public_st, stname, stype, sname)

#define gs_private_st_simple(stname, stype, sname)\

  gs__st_simple(private_st, stname, stype, sname)

#define gs__st_simple_final(scope_st, stname, stype, sname, pfinal)\

  scope_st stname = { sizeof(stype), sname, 0, 0, gs_no_struct_enum_ptrs, gs_no_struct_reloc_ptrs, pfinal, 0 }

#define gs_public_st_simple_final(stname, stype, sname, pfinal)\

  gs__st_simple_final(public_st, stname, stype, sname, pfinal)

#define gs_private_st_simple_final(stname, stype, sname, pfinal)\

  gs__st_simple_final(private_st, stname, stype, sname, pfinal)

/* ---------------- Structures with explicit procedures. ---------------- */

/*

 * Boilerplate for clear_marks procedures.

 */

#define CLEAR_MARKS_PROC(proc)\

  void proc(const gs_memory_t *cmem, void *vptr, uint size, const gs_memory_struct_type_t *pstype)

        /* Complex structures with their own clear_marks, */

        /* enum, reloc, and finalize procedures. */

#define gs__st_complex_only(scope_st, stname, stype, sname, pclear, penum, preloc, pfinal)\

  scope_st stname = { sizeof(stype), sname, 0, pclear, penum, preloc, pfinal, 0 }

#define gs_public_st_complex_only(stname, stype, sname, pclear, penum, preloc, pfinal)\

  gs__st_complex_only(public_st, stname, stype, sname, pclear, penum, preloc, pfinal)

#define gs_private_st_complex_only(stname, stype, sname, pclear, penum, preloc, pfinal)\

  gs__st_complex_only(private_st, stname, stype, sname, pclear, penum, preloc, pfinal)

#define gs__st_complex(scope_st, stname, stype, sname, pclear, penum, preloc, pfinal)\

  static struct_proc_clear_marks(pclear);\

  static struct_proc_enum_ptrs(penum);\

  static struct_proc_reloc_ptrs(preloc);\

  static struct_proc_finalize(pfinal);\

  gs__st_complex_only(scope_st, stname, stype, sname, pclear, penum, preloc, pfinal)

#define gs_public_st_complex(stname, stype, sname, pclear, penum, preloc, pfinal)\

  gs__st_complex(public_st, stname, stype, sname, pclear, penum, preloc, pfinal)

#define gs_private_st_complex(stname, stype, sname, pclear, penum, preloc, pfinal)\

  gs__st_complex(private_st, stname, stype, sname, pclear, penum, preloc, pfinal)

        /* Composite structures with their own enum and reloc procedures. */

#define gs__st_composite(scope_st, stname, stype, sname, penum, preloc)\

  static struct_proc_enum_ptrs(penum);\

  static struct_proc_reloc_ptrs(preloc);\

  gs__st_complex_only(scope_st, stname, stype, sname, 0, penum, preloc, 0)

#define gs_public_st_composite(stname, stype, sname, penum, preloc)\

  gs__st_composite(public_st, stname, stype, sname, penum, preloc)

#define gs_private_st_composite(stname, stype, sname, penum, preloc)\

  gs__st_composite(private_st, stname, stype, sname, penum, preloc)

        /* Composite structures with inherited finalization. */

#define gs__st_composite_use_final(scope_st, stname, stype, sname, penum, preloc, pfinal)\

  static struct_proc_enum_ptrs(penum);\

  static struct_proc_reloc_ptrs(preloc);\

  gs__st_complex_only(scope_st, stname, stype, sname, 0, penum, preloc, pfinal)

#define gs_public_st_composite_use_final(stname, stype, sname, penum, preloc, pfinal)\

  gs__st_composite_use_final(public_st, stname, stype, sname, penum, preloc, pfinal)

#define gs_private_st_composite_use_final(stname, stype, sname, penum, preloc, pfinal)\

  gs__st_composite_use_final(private_st, stname, stype, sname, penum, preloc, pfinal)

        /* Composite structures with finalization. */

#define gs__st_composite_final(scope_st, stname, stype, sname, penum, preloc, pfinal)\

  static struct_proc_finalize(pfinal);\

  gs__st_composite_use_final(scope_st, stname, stype, sname, penum, preloc, pfinal)

#define gs_public_st_composite_final(stname, stype, sname, penum, preloc, pfinal)\

  gs__st_composite_final(public_st, stname, stype, sname, penum, preloc, pfinal)

#define gs_private_st_composite_final(stname, stype, sname, penum, preloc, pfinal)\

  gs__st_composite_final(private_st, stname, stype, sname, penum, preloc, pfinal)

        /* Composite structures with enum and reloc procedures */

        /* already declared. */

#define gs__st_composite_only(scope_st, stname, stype, sname, penum, preloc)\

  gs__st_complex_only(scope_st, stname, stype, sname, 0, penum, preloc, 0)

#define gs_public_st_composite_only(stname, stype, sname, penum, preloc)\

  gs__st_composite_only(public_st, stname, stype, sname, penum, preloc)

#define gs_private_st_composite_only(stname, stype, sname, penum, preloc)\

  gs__st_composite_only(private_st, stname, stype, sname, penum, preloc)

/* ---------------- Special kinds of structures ---------------- */

        /* Element structures, for use in arrays of structures. */

        /* Note that these require that the underlying structure's */

        /* enum_ptrs procedure always return the same number of pointers. */

#define gs__st_element(scope_st, stname, stype, sname, penum, preloc, basest)\

  static ENUM_PTRS_BEGIN_PROC(penum) {\

    uint count = size / (uint)sizeof(stype);\

    if ( count == 0 ) return 0;\

    return ENUM_USING(basest, (EV_CONST char *)vptr + (index % count) * sizeof(stype),\

      sizeof(stype), index / count);\

  } ENUM_PTRS_END_PROC\

gxpcmap.c:color_tile_elt_enum_ptrs

Line

Count

Source

620

68.3M

  static ENUM_PTRS_BEGIN_PROC(penum) {\

621

68.3M

    uint count = size / (uint)sizeof(stype);\

622

68.3M

    if ( count == 0 ) return 0;\

623

68.3M

    return ENUM_USING(basest, (EV_CONST char *)vptr + (index % count) * sizeof(stype),\

624

68.3M

      sizeof(stype), index / count);\

625

68.3M

  } ENUM_PTRS_END_PROC\

gdevpdf.c:pdf_substream_save_elt_enum_ptrs

Line

Count

Source

620

6.34M

  static ENUM_PTRS_BEGIN_PROC(penum) {\

621

6.34M

    uint count = size / (uint)sizeof(stype);\

622

6.34M

    if ( count == 0 ) return 0;\

623

6.34M

    return ENUM_USING(basest, (EV_CONST char *)vptr + (index % count) * sizeof(stype),\

624

6.34M

      sizeof(stype), index / count);\

625

6.34M

  } ENUM_PTRS_END_PROC\

gdevpdf.c:pdf_page_elt_enum_ptrs

Line

Count

Source

620

7.21M

  static ENUM_PTRS_BEGIN_PROC(penum) {\

621

7.21M

    uint count = size / (uint)sizeof(stype);\

622

7.21M

    if ( count == 0 ) return 0;\

623

7.21M

    return ENUM_USING(basest, (EV_CONST char *)vptr + (index % count) * sizeof(stype),\

624

7.21M

      sizeof(stype), index / count);\

625

7.21M

  } ENUM_PTRS_END_PROC\

Unexecuted instantiation: gdevpdf.c:pdf_linearisation_record_elt_enum_ptrs

gdevpsdp.c:param_string_elt_enum_ptrs

Line

Count

Source

620

4.33M

  static ENUM_PTRS_BEGIN_PROC(penum) {\

621

4.33M

    uint count = size / (uint)sizeof(stype);\

622

4.33M

    if ( count == 0 ) return 0;\

623

4.33M

    return ENUM_USING(basest, (EV_CONST char *)vptr + (index % count) * sizeof(stype),\

624

4.33M

      sizeof(stype), index / count);\

625

4.33M

  } ENUM_PTRS_END_PROC\

gdevpdtf.c:pdf_std_font_elt_enum_ptrs

Line

Count

Source

620

1.07M

  static ENUM_PTRS_BEGIN_PROC(penum) {\

621

1.07M

    uint count = size / (uint)sizeof(stype);\

622

1.07M

    if ( count == 0 ) return 0;\

623

1.07M

    return ENUM_USING(basest, (EV_CONST char *)vptr + (index % count) * sizeof(stype),\

624

1.07M

      sizeof(stype), index / count);\

625

1.07M

  } ENUM_PTRS_END_PROC\

Unexecuted instantiation: gsfont.c:font_ptr_element_enum_ptrs

gsht.c:ht_order_element_enum_ptrs

Line

Count

Source

620

7.37M

  static ENUM_PTRS_BEGIN_PROC(penum) {\

621

7.37M

    uint count = size / (uint)sizeof(stype);\

622

7.37M

    if ( count == 0 ) return 0;\

623

7.37M

    return ENUM_USING(basest, (EV_CONST char *)vptr + (index % count) * sizeof(stype),\

624

7.37M

      sizeof(stype), index / count);\

625

7.37M

  } ENUM_PTRS_END_PROC\

Unexecuted instantiation: gsmemory.c:const_string_elt_enum_ptrs

gxccman.c:fm_pair_element_enum_ptrs

Line

Count

Source

620

411M

  static ENUM_PTRS_BEGIN_PROC(penum) {\

621

411M

    uint count = size / (uint)sizeof(stype);\

622

411M

    if ( count == 0 ) return 0;\

623

411M

    return ENUM_USING(basest, (EV_CONST char *)vptr + (index % count) * sizeof(stype),\

624

411M

      sizeof(stype), index / count);\

625

411M

  } ENUM_PTRS_END_PROC\

gxccman.c:cc_ptr_element_enum_ptrs

Line

Count

Source

620

411k

  static ENUM_PTRS_BEGIN_PROC(penum) {\

621

411k

    uint count = size / (uint)sizeof(stype);\

622

411k

    if ( count == 0 ) return 0;\

623

411k

    return ENUM_USING(basest, (EV_CONST char *)vptr + (index % count) * sizeof(stype),\

624

411k

      sizeof(stype), index / count);\

625

411k

  } ENUM_PTRS_END_PROC\

Unexecuted instantiation: gsfunc.c:function_ptr_element_enum_ptrs

Unexecuted instantiation: gsht1.c:ht_comp_elt_enum_ptrs

gsfcid.c:cid_si_elt_enum_ptrs

Line

Count

Source

620

3.21k

  static ENUM_PTRS_BEGIN_PROC(penum) {\

621

3.21k

    uint count = size / (uint)sizeof(stype);\

622

3.21k

    if ( count == 0 ) return 0;\

623

3.21k

    return ENUM_USING(basest, (EV_CONST char *)vptr + (index % count) * sizeof(stype),\

624

3.21k

      sizeof(stype), index / count);\

625

3.21k

  } ENUM_PTRS_END_PROC\

gsfcid.c:font1_ptr_element_enum_ptrs

Line

Count

Source

620

76

  static ENUM_PTRS_BEGIN_PROC(penum) {\

621

76

    uint count = size / (uint)sizeof(stype);\

622

76

    if ( count == 0 ) return 0;\

623

76

    return ENUM_USING(basest, (EV_CONST char *)vptr + (index % count) * sizeof(stype),\

624

76

      sizeof(stype), index / count);\

625

76

  } ENUM_PTRS_END_PROC\

Unexecuted instantiation: gsfcmap1.c:cmap_lookup_range_elt_enum_ptrs

  static RELOC_PTRS_BEGIN(preloc) {\

    uint count = size / (uint)sizeof(stype);\

    for ( ; count; count--, vptr = (char *)vptr + sizeof(stype) )\

      RELOC_USING(basest, vptr, sizeof(stype));\

  } RELOC_PTRS_END\

gxpcmap.c:color_tile_elt_reloc_ptrs

Line

Count

Source

626

339k

  static RELOC_PTRS_BEGIN(preloc) {\

627

339k

    uint count = size / (uint)sizeof(stype);\

628

17.3M

    for ( ; count; count--, vptr = (char *)vptr + sizeof(stype) )\

629

16.9M

      RELOC_USING(basest, vptr, sizeof(stype));\

630

339k

  } RELOC_PTRS_END\

gdevpdf.c:pdf_substream_save_elt_reloc_ptrs

Line

Count

Source

626

71.3k

  static RELOC_PTRS_BEGIN(preloc) {\

627

71.3k

    uint count = size / (uint)sizeof(stype);\

628

856k

    for ( ; count; count--, vptr = (char *)vptr + sizeof(stype) )\

629

784k

      RELOC_USING(basest, vptr, sizeof(stype));\

630

71.3k

  } RELOC_PTRS_END\

gdevpdf.c:pdf_page_elt_reloc_ptrs

Line

Count

Source

626

71.3k

  static RELOC_PTRS_BEGIN(preloc) {\

627

71.3k

    uint count = size / (uint)sizeof(stype);\

628

3.64M

    for ( ; count; count--, vptr = (char *)vptr + sizeof(stype) )\

629

3.57M

      RELOC_USING(basest, vptr, sizeof(stype));\

630

71.3k

  } RELOC_PTRS_END\

Unexecuted instantiation: gdevpdf.c:pdf_linearisation_record_elt_reloc_ptrs

gdevpsdp.c:param_string_elt_reloc_ptrs

Line

Count

Source

626

288k

  static RELOC_PTRS_BEGIN(preloc) {\

627

288k

    uint count = size / (uint)sizeof(stype);\

628

4.33M

    for ( ; count; count--, vptr = (char *)vptr + sizeof(stype) )\

629

4.04M

      RELOC_USING(basest, vptr, sizeof(stype));\

630

288k

  } RELOC_PTRS_END\

gdevpdtf.c:pdf_std_font_elt_reloc_ptrs

Line

Count

Source

626

71.3k

  static RELOC_PTRS_BEGIN(preloc) {\

627

71.3k

    uint count = size / (uint)sizeof(stype);\

628

1.07M

    for ( ; count; count--, vptr = (char *)vptr + sizeof(stype) )\

629

998k

      RELOC_USING(basest, vptr, sizeof(stype));\

630

71.3k

  } RELOC_PTRS_END\

Unexecuted instantiation: gsfont.c:font_ptr_element_reloc_ptrs

gsht.c:ht_order_element_reloc_ptrs

Line

Count

Source

626

488k

  static RELOC_PTRS_BEGIN(preloc) {\

627

488k

    uint count = size / (uint)sizeof(stype);\

628

2.20M

    for ( ; count; count--, vptr = (char *)vptr + sizeof(stype) )\

629

1.72M

      RELOC_USING(basest, vptr, sizeof(stype));\

630

488k

  } RELOC_PTRS_END\

Unexecuted instantiation: gsmemory.c:const_string_elt_reloc_ptrs

gxccman.c:fm_pair_element_reloc_ptrs

Line

Count

Source

626

411k

  static RELOC_PTRS_BEGIN(preloc) {\

627

411k

    uint count = size / (uint)sizeof(stype);\

628

82.6M

    for ( ; count; count--, vptr = (char *)vptr + sizeof(stype) )\

629

82.2M

      RELOC_USING(basest, vptr, sizeof(stype));\

630

411k

  } RELOC_PTRS_END\

gxccman.c:cc_ptr_element_reloc_ptrs

Line

Count

Source

626

411k

  static RELOC_PTRS_BEGIN(preloc) {\

627

411k

    uint count = size / (uint)sizeof(stype);\

628

6.73G

    for ( ; count; count--, vptr = (char *)vptr + sizeof(stype) )\

629

6.73G

      RELOC_USING(basest, vptr, sizeof(stype));\

630

411k

  } RELOC_PTRS_END\

Unexecuted instantiation: gsfunc.c:function_ptr_element_reloc_ptrs

Unexecuted instantiation: gsht1.c:ht_comp_elt_reloc_ptrs

gsfcid.c:cid_si_elt_reloc_ptrs

Line

Count

Source

626

3.21k

  static RELOC_PTRS_BEGIN(preloc) {\

627

3.21k

    uint count = size / (uint)sizeof(stype);\

628

3.21k

    for ( ; count; count--, vptr = (char *)vptr + sizeof(stype) )\

629

3.21k

      RELOC_USING(basest, vptr, sizeof(stype));\

630

3.21k

  } RELOC_PTRS_END\

gsfcid.c:font1_ptr_element_reloc_ptrs

Line

Count

Source

626

27

  static RELOC_PTRS_BEGIN(preloc) {\

627

27

    uint count = size / (uint)sizeof(stype);\

628

76

    for ( ; count; count--, vptr = (char *)vptr + sizeof(stype) )\

629

49

      RELOC_USING(basest, vptr, sizeof(stype));\

630

27

  } RELOC_PTRS_END\

Unexecuted instantiation: gsfcmap1.c:cmap_lookup_range_elt_reloc_ptrs

  gs__st_composite_only(scope_st, stname, stype, sname, penum, preloc)

#define gs_public_st_element(stname, stype, sname, penum, preloc, basest)\

  gs__st_element(public_st, stname, stype, sname, penum, preloc, basest)

#define gs_private_st_element(stname, stype, sname, penum, preloc, basest)\

  gs__st_element(private_st, stname, stype, sname, penum, preloc, basest)

#define gs__st_element_final(scope_st, stname, stype, sname, penum, preloc, basest, pfinal)\

  static ENUM_PTRS_BEGIN_PROC(penum) {\

    uint count = size / (uint)sizeof(stype);\

    if ( count == 0 ) return 0;\

    return ENUM_USING(basest, (EV_CONST char *)vptr + (index % count) * sizeof(stype),\

      sizeof(stype), index / count);\

  } ENUM_PTRS_END_PROC\

  static RELOC_PTRS_BEGIN(preloc) {\

    uint count = size / (uint)sizeof(stype);\

    for ( ; count; count--, vptr = (char *)vptr + sizeof(stype) )\

      RELOC_USING(basest, vptr, sizeof(stype));\

  } RELOC_PTRS_END\

  gs__st_composite_final(scope_st, stname, stype, sname, penum, preloc,pfinal)

#define gs_public_st_element_final(stname, stype, sname, penum, preloc, basest,pfinal)\

  gs__st_element_final(public_st, stname, stype, sname, penum, preloc, basest,pfinal)

#define gs_private_st_element_final(stname, stype, sname, penum, preloc, basest,pfinal)\

  gs__st_element_final(private_st, stname, stype, sname, penum, preloc, basest,pfinal)

        /* A "structure" just consisting of a pointer. */

        /* Note that in this case only, stype is a pointer type. */

        /* Fortunately, C's bizarre 'const' syntax does what we want here. */

#define gs__st_ptr(scope_st, stname, stype, sname, penum, preloc)\

  static ENUM_PTRS_BEGIN(penum) return 0;\

    case 0: return ENUM_OBJ(*(stype const *)vptr);\

  ENUM_PTRS_END\

Unexecuted instantiation: gsfont.c:font_ptr_enum_ptrs

gsiodev.c:iodev_ptr_enum_ptrs

Line

Count

Source

660

8.50M

  static ENUM_PTRS_BEGIN(penum) return 0;\

661

8.15M

    case 0: return ENUM_OBJ(*(stype const *)vptr);\

662

8.50M

  ENUM_PTRS_END\

Unexecuted instantiation: gsfunc.c:function_ptr_enum_ptrs

gsfcid.c:font1_ptr_enum_ptrs

Line

Count

Source

660

76

  static ENUM_PTRS_BEGIN(penum) return 0;\

661

49

    case 0: return ENUM_OBJ(*(stype const *)vptr);\

662

76

  ENUM_PTRS_END\

  static RELOC_PTRS_BEGIN(preloc) ;\

    RELOC_VAR(*(stype *)vptr);\

  RELOC_PTRS_END\

Unexecuted instantiation: gsfont.c:font_ptr_reloc_ptrs

gsiodev.c:iodev_ptr_reloc_ptrs

Line

Count

Source

663

7.81M

  static RELOC_PTRS_BEGIN(preloc) ;\

664

7.81M

    RELOC_VAR(*(stype *)vptr);\

665

7.81M

  RELOC_PTRS_END\

Unexecuted instantiation: gsfunc.c:function_ptr_reloc_ptrs

gsfcid.c:font1_ptr_reloc_ptrs

Line

Count

Source

663

49

  static RELOC_PTRS_BEGIN(preloc) ;\

664

49

    RELOC_VAR(*(stype *)vptr);\

665

49

  RELOC_PTRS_END\

  gs__st_composite_only(scope_st, stname, stype, sname, penum, preloc)

#define gs_public_st_ptr(stname, stype, sname, penum, preloc)\

  gs__st_ptr(public_st, stname, stype, sname, penum, preloc)

#define gs_private_st_ptr(stname, stype, sname, penum, preloc)\

  gs__st_ptr(private_st, stname, stype, sname, penum, preloc)

/* ---------- Ordinary structures with a fixed set of pointers ----------- */

/* Note that we "cannibalize" the penum and preloc names for elts and sdata. */

/* Both with and without finalization are defined */

        /* Structures with 1 pointer. */

#define gs__st_ptrs1(scope_st, stname, stype, sname, penum, preloc, e1)\

  BASIC_PTRS(penum) {\

    GC_OBJ_ELT(stype, e1)\

  };\

  gs__st_basic(scope_st, stname, stype, sname, penum, preloc)

#define gs_public_st_ptrs1(stname, stype, sname, penum, preloc, e1)\

  gs__st_ptrs1(public_st, stname, stype, sname, penum, preloc, e1)

#define gs_private_st_ptrs1(stname, stype, sname, penum, preloc, e1)\

  gs__st_ptrs1(private_st, stname, stype, sname, penum, preloc, e1)

#define gs__st_ptrs1_final(scope_st, stname, stype, sname, penum, preloc, pfinal, e1)\

  BASIC_PTRS(penum) {\

    GC_OBJ_ELT(stype, e1)\

  };\

  gs__st_basic_final(scope_st, stname, stype, sname, penum, preloc, pfinal)

#define gs_public_st_ptrs1_final(stname, stype, sname, penum, preloc, pfinal, e1)\

  gs__st_ptrs1_final(public_st, stname, stype, sname, penum, preloc, pfinal, e1)

#define gs_private_st_ptrs1_final(stname, stype, sname, penum, preloc, pfinal, e1)\

  gs__st_ptrs1_final(private_st, stname, stype, sname, penum, preloc, pfinal, e1)

        /* Structures with 1 string. */

#define gs__st_strings1(scope_st, stname, stype, sname, penum, preloc, e1)\

  BASIC_PTRS(penum) {\

    GC_STRING_ELT(stype, e1)\

  };\

  gs__st_basic(scope_st, stname, stype, sname, penum, preloc)

#define gs_public_st_strings1(stname, stype, sname, penum, preloc, e1)\

  gs__st_strings1(public_st, stname, stype, sname, penum, preloc, e1)

#define gs_private_st_strings1(stname, stype, sname, penum, preloc, e1)\

  gs__st_strings1(private_st, stname, stype, sname, penum, preloc, e1)

        /* Structures with 1 const string. */

#define gs__st_const_strings1(scope_st, stname, stype, sname, penum, preloc, e1)\

  BASIC_PTRS(penum) {\

    GC_CONST_STRING_ELT(stype, e1)\

  };\

  gs__st_basic(scope_st, stname, stype, sname, penum, preloc)

#define gs_public_st_const_strings1(stname, stype, sname, penum, preloc, e1)\

  gs__st_const_strings1(public_st, stname, stype, sname, penum, preloc, e1)

#define gs_private_st_const_strings1(stname, stype, sname, penum, preloc, e1)\

  gs__st_const_strings1(private_st, stname, stype, sname, penum, preloc, e1)

        /* Structures with 2 const strings. */

#define gs__st_const_strings2(scope_st, stname, stype, sname, penum, preloc, e1, e2)\

  BASIC_PTRS(penum) {\

    GC_CONST_STRING_ELT(stype, e1), GC_CONST_STRING_ELT(stype, e2)\

  };\

  gs__st_basic(scope_st, stname, stype, sname, penum, preloc)

#define gs_public_st_const_strings2(stname, stype, sname, penum, preloc, e1, e2)\

  gs__st_const_strings2(public_st, stname, stype, sname, penum, preloc, e1, e2)

#define gs_private_st_const_strings2(stname, stype, sname, penum, preloc, e1, e2)\

  gs__st_const_strings2(private_st, stname, stype, sname, penum, preloc, e1, e2)

        /* Structures with 2 pointers. */

#define gs__st_ptrs2(scope_st, stname, stype, sname, penum, preloc, e1, e2)\

  BASIC_PTRS(penum) {\

    GC_OBJ_ELT2(stype, e1, e2)\

  };\

  gs__st_basic(scope_st, stname, stype, sname, penum, preloc)

#define gs_public_st_ptrs2(stname, stype, sname, penum, preloc, e1, e2)\

  gs__st_ptrs2(public_st, stname, stype, sname, penum, preloc, e1, e2)

#define gs_private_st_ptrs2(stname, stype, sname, penum, preloc, e1, e2)\

  gs__st_ptrs2(private_st, stname, stype, sname, penum, preloc, e1, e2)

#define gs__st_ptrs2_final(scope_st, stname, stype, sname, penum, preloc, pfinal, e1, e2)\

  BASIC_PTRS(penum) {\

    GC_OBJ_ELT2(stype, e1, e2)\

  };\

  gs__st_basic_final(scope_st, stname, stype, sname, penum, preloc, pfinal)

#define gs_public_st_ptrs2_final(stname, stype, sname, penum, preloc, pfinal, e1, e2)\

  gs__st_ptrs2_final(public_st, stname, stype, sname, penum, preloc, pfinal, e1, e2)

#define gs_private_st_ptrs2_final(stname, stype, sname, penum, preloc, pfinal, e1, e2)\

  gs__st_ptrs2_final(private_st, stname, stype, sname, penum, preloc, pfinal, e1, e2)

        /* Structures with 3 pointers. */

#define gs__st_ptrs3(scope_st, stname, stype, sname, penum, preloc, e1, e2, e3)\

  BASIC_PTRS(penum) {\

    GC_OBJ_ELT3(stype, e1, e2, e3)\

  };\

  gs__st_basic(scope_st, stname, stype, sname, penum, preloc)

#define gs_public_st_ptrs3(stname, stype, sname, penum, preloc, e1, e2, e3)\

  gs__st_ptrs3(public_st, stname, stype, sname, penum, preloc, e1, e2, e3)

#define gs_private_st_ptrs3(stname, stype, sname, penum, preloc, e1, e2, e3)\

  gs__st_ptrs3(private_st, stname, stype, sname, penum, preloc, e1, e2, e3)

#define gs__st_ptrs3_final(scope_st, stname, stype, sname, penum, preloc, pfinal, e1, e2, e3)\

  BASIC_PTRS(penum) {\

    GC_OBJ_ELT3(stype, e1, e2, e3)\

  };\

  gs__st_basic_final(scope_st, stname, stype, sname, penum, preloc, pfinal)

#define gs_public_st_ptrs3_final(stname, stype, sname, penum, preloc, pfinal, e1, e2, e3)\

  gs__st_ptrs3_final(public_st, stname, stype, sname, penum, preloc, pfinal, e1, e2, e3)

#define gs_private_st_ptrs3_final(stname, stype, sname, penum, preloc, pfinal, e1, e2, e3)\

  gs__st_ptrs3_final(private_st, stname, stype, sname, penum, preloc, pfinal, e1, e2, e3)

        /* Structures with 4 pointers. */

#define gs__st_ptrs4(scope_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4)\

  BASIC_PTRS(penum) {\

    GC_OBJ_ELT3(stype, e1, e2, e3), GC_OBJ_ELT(stype, e4)\

  };\

  gs__st_basic(scope_st, stname, stype, sname, penum, preloc)

#define gs_public_st_ptrs4(stname, stype, sname, penum, preloc, e1, e2, e3, e4)\

  gs__st_ptrs4(public_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4)

#define gs_private_st_ptrs4(stname, stype, sname, penum, preloc, e1, e2, e3, e4)\

  gs__st_ptrs4(private_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4)

#define gs__st_ptrs4_final(scope_st, stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4)\

  BASIC_PTRS(penum) {\

    GC_OBJ_ELT3(stype, e1, e2, e3), GC_OBJ_ELT(stype, e4)\

  };\

  gs__st_basic_final(scope_st, stname, stype, sname, penum, preloc, pfinal)

#define gs_public_st_ptrs4_final(stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4)\

  gs__st_ptrs4_final(public_st, stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4)

#define gs_private_st_ptrs4_final(stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4)\

  gs__st_ptrs4_final(private_st, stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4)

        /* Structures with 5 pointers. */

#define gs__st_ptrs5(scope_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5)\

  BASIC_PTRS(penum) {\

    GC_OBJ_ELT3(stype, e1, e2, e3), GC_OBJ_ELT2(stype, e4, e5)\

  };\

  gs__st_basic(scope_st, stname, stype, sname, penum, preloc)

#define gs_public_st_ptrs5(stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5)\

  gs__st_ptrs5(public_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5)

#define gs_private_st_ptrs5(stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5)\

  gs__st_ptrs5(private_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5)

#define gs__st_ptrs5_final(scope_st, stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5)\

  BASIC_PTRS(penum) {\

    GC_OBJ_ELT3(stype, e1, e2, e3), GC_OBJ_ELT2(stype, e4, e5)\

  };\

  gs__st_basic_final(scope_st, stname, stype, sname, penum, preloc, pfinal)

#define gs_public_st_ptrs5_final(stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5)\

  gs__st_ptrs5_final(public_st, stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5)

#define gs_private_st_ptrs5_final(stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5)\

  gs__st_ptrs5_final(private_st, stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5)

        /* Structures with 6 pointers. */

#define gs__st_ptrs6(scope_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5, e6)\

  BASIC_PTRS(penum) {\

    GC_OBJ_ELT3(stype, e1, e2, e3), GC_OBJ_ELT3(stype, e4, e5, e6)\

  };\

  gs__st_basic(scope_st, stname, stype, sname, penum, preloc)

#define gs_public_st_ptrs6(stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5, e6)\

  gs__st_ptrs6(public_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5, e6)

#define gs_private_st_ptrs6(stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5, e6)\

  gs__st_ptrs6(private_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5, e6)

#define gs__st_ptrs6_final(scope_st, stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5, e6)\

  BASIC_PTRS(penum) {\

    GC_OBJ_ELT3(stype, e1, e2, e3), GC_OBJ_ELT3(stype, e4, e5, e6)\

  };\

  gs__st_basic_final(scope_st, stname, stype, sname, penum, preloc, pfinal)

#define gs_public_st_ptrs6_final(stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5, e6)\

  gs__st_ptrs6_final(public_st, stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5, e6)

#define gs_private_st_ptrs6_final(stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5, e6)\

  gs__st_ptrs6_final(private_st, stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5, e6)

        /* Structures with 7 pointers. */

#define gs__st_ptrs7(scope_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5, e6, e7)\

  BASIC_PTRS(penum) {\

    GC_OBJ_ELT3(stype, e1, e2, e3), GC_OBJ_ELT3(stype, e4, e5, e6), GC_OBJ_ELT(stype, e7)\

  };\

  gs__st_basic(scope_st, stname, stype, sname, penum, preloc)

#define gs_public_st_ptrs7(stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5, e6, e7)\

  gs__st_ptrs7(public_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5, e6, e7)

#define gs_private_st_ptrs7(stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5, e6, e7)\

  gs__st_ptrs7(private_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5, e6, e7)

#define gs__st_ptrs7_final(scope_st, stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5, e6, e7)\

  BASIC_PTRS(penum) {\

    GC_OBJ_ELT3(stype, e1, e2, e3), GC_OBJ_ELT3(stype, e4, e5, e6), GC_OBJ_ELT(stype, e7)\

  };\

  gs__st_basic_final(scope_st, stname, stype, sname, penum, preloc, pfinal)

#define gs_public_st_ptrs7_final(stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5, e6, e7)\

  gs__st_ptrs7_final(public_st, stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5, e6, e7)

#define gs_private_st_ptrs7_final(stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5, e6, e7)\

  gs__st_ptrs7_final(private_st, stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5, e6, e7)

        /* Structures with 8 pointers. */

#define gs__st_ptrs8(scope_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5, e6, e7, e8)\

  BASIC_PTRS(penum) {\

    GC_OBJ_ELT3(stype, e1, e2, e3), GC_OBJ_ELT3(stype, e4, e5, e6), GC_OBJ_ELT2(stype, e7, e8)\

  };\

  gs__st_basic(scope_st, stname, stype, sname, penum, preloc)

#define gs_public_st_ptrs8(stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5, e6, e7, e8)\

  gs__st_ptrs8(public_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5, e6, e7, e8)

#define gs_private_st_ptrs8(stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5, e6, e7, e8)\

  gs__st_ptrs8(private_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5, e6, e7, e8)

#define gs__st_ptrs8_final(scope_st, stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5, e6, e7, e8)\

  BASIC_PTRS(penum) {\

    GC_OBJ_ELT3(stype, e1, e2, e3), GC_OBJ_ELT3(stype, e4, e5, e6), GC_OBJ_ELT2(stype, e7, e8)\

  };\

  gs__st_basic_final(scope_st, stname, stype, sname, penum, preloc, pfinal)

#define gs_public_st_ptrs8_final(stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5, e6, e7, e8)\

  gs__st_ptrs8_final(public_st, stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5, e6, e7, e8)

#define gs_private_st_ptrs8_final(stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5, e6, e7, e8)\

  gs__st_ptrs8_final(private_st, stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5, e6, e7, e8)

        /* Structures with 9 pointers. */

#define gs__st_ptrs9(scope_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5, e6, e7, e8, e9)\

  BASIC_PTRS(penum) {\

    GC_OBJ_ELT3(stype, e1, e2, e3), GC_OBJ_ELT3(stype, e4, e5, e6), GC_OBJ_ELT3(stype, e7, e8, e9)\

  };\

  gs__st_basic(scope_st, stname, stype, sname, penum, preloc)

#define gs_public_st_ptrs9(stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5, e6, e7, e8, e9)\

  gs__st_ptrs9(public_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5, e6, e7, e8, e9)

#define gs_private_st_ptrs9(stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5, e6, e7, e8, e9)\

  gs__st_ptrs9(private_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5, e6, e7, e8, e9)

#define gs__st_ptrs9_final(scope_st, stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5, e6, e7, e8, e9)\

  BASIC_PTRS(penum) {\

    GC_OBJ_ELT3(stype, e1, e2, e3), GC_OBJ_ELT3(stype, e4, e5, e6), GC_OBJ_ELT3(stype, e7, e8, e9)\

  };\

  gs__st_basic_final(scope_st, stname, stype, sname, penum, preloc, pfinal)

#define gs_public_st_ptrs9_final(stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5, e6, e7, e8, e9)\

  gs__st_ptrs9_final(public_st, stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5, e6, e7, e8, e9)

#define gs_private_st_ptrs9_final(stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5, e6, e7, e8, e9)\

  gs__st_ptrs9_final(private_st, stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5, e6, e7, e8, e9)

        /* Structures with 10 pointers. */

#define gs__st_ptrs10(scope_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10)\

  BASIC_PTRS(penum) {\

    GC_OBJ_ELT3(stype, e1, e2, e3), GC_OBJ_ELT3(stype, e4, e5, e6), GC_OBJ_ELT3(stype, e7, e8, e9),\

  GC_OBJ_ELT(stype, e10) };\

  gs__st_basic(scope_st, stname, stype, sname, penum, preloc)

#define gs_public_st_ptrs10(stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10)\

  gs__st_ptrs10(public_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10)

#define gs_private_st_ptrs10(stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10)\

  gs__st_ptrs10(private_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10)

#define gs__st_ptrs10_final(scope_st, stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10)\

  BASIC_PTRS(penum) {\

    GC_OBJ_ELT3(stype, e1, e2, e3), GC_OBJ_ELT3(stype, e4, e5, e6), GC_OBJ_ELT3(stype, e7, e8, e9),\

  GC_OBJ_ELT(stype, e10) };\

  gs__st_basic_final(scope_st, stname, stype, sname, penum, preloc, pfinal)

#define gs_public_st_ptrs10_final(stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10)\

  gs__st_ptrs10_final(public_st, stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10)

#define gs_private_st_ptrs10_final(stname, stype, sname, penum, preloc, pfinal, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10)\