+2013-11-04 Paul Eggert <eggert@cs.ucla.edu>
+
+ Port to stricter C99 platforms.
+ Merge from gnulib, incorporating:
+ 2013-11-03 intprops: port to Oracle Studio c99
+ * lib/intprops.h: Update from gnulib.
+
2013-11-02 Glenn Morris <rgm@gnu.org>
* Makefile.in (check): Depend on all.
/* Return 1 if the __typeof__ keyword works. This could be done by
'configure', but for now it's easier to do it by hand. */
-#if 2 <= __GNUC__ || defined __IBM__TYPEOF__ || 0x5110 <= __SUNPRO_C
+#if (2 <= __GNUC__ || defined __IBM__TYPEOF__ \
+ || (0x5110 <= __SUNPRO_C && !__STDC__))
# define _GL_HAVE___TYPEOF__ 1
#else
# define _GL_HAVE___TYPEOF__ 0
+2013-11-04 Paul Eggert <eggert@cs.ucla.edu>
+
+ Port to stricter C99 platforms.
+ Especially, C99 prohibits nesting a struct X inside struct Y if
+ struct X has a flexible array member.
+ * alloc.c (struct sdata): New type.
+ (sdata): Implement in terms of struct sdata.
+ Remove u member; all uses replaced by next_vector, set_next_vector.
+ (SDATA_SELECTOR, SDATA_DATA, SDATA_DATA_OFFSET): Adjust to sdata change.
+ (SDATA_DATA_OFFSET): Now a constant, not a macro.
+ (struct sblock): Rename first_data member to data, which is now
+ a flexible array member. All uses changed.
+ (next_vector, set_next_vector, large_vector_vec): New functions.
+ (vector_alignment): New constant.
+ (roundup_size): Make it a multiple of ALIGNOF_STRUCT_LISP_VECTOR, too.
+ (struct large-vector): Now merely a NEXT member, since the old approach
+ ran afoul of stricter C99. All uses changed to use
+ large_vector_vec or large_vector_offset.
+ (large_vector_offset): New constant.
+ * dispnew.c: Include tparam.h, for tgetent.
+ Do not include term.h; no longer needed.
+ * gnutls.c (Fgnutls_boot): Don't continue after calling a _Noreturn.
+ * lisp.h (ENUM_BF) [__SUNPRO_C && __STDC__]: Use unsigned int.
+ (struct Lisp_Vector): Use a flexible array member for contents,
+ instead of a union with a member that is an array of size 1.
+ All uses changed.
+ (ALIGNOF_STRUCT_LISP_VECTOR): New constant, to make up for the
+ fact that the struct no longer contains a union.
+ (struct Lisp_Misc_Any, struct Lisp_Marker, struct Lisp_Overlay)
+ (struct Lisp_Save_Value, struct Lisp_Free):
+ Use unsigned, not int, for spacers, to avoid c99 warning.
+ (union specbinding): Use unsigned, not bool, for bitfield, as
+ bool is not portable to pre-C99 hosts.
+
2013-11-04 Glenn Morris <rgm@gnu.org>
* emacs.c (usage_message): Mention that `-L :...' appends.
#define LARGE_STRING_BYTES 1024
-/* Struct or union describing string memory sub-allocated from an sblock.
- This is where the contents of Lisp strings are stored. */
+/* The SDATA typedef is a struct or union describing string memory
+ sub-allocated from an sblock. This is where the contents of Lisp
+ strings are stored. */
-#ifdef GC_CHECK_STRING_BYTES
-
-typedef struct
+struct sdata
{
/* Back-pointer to the string this sdata belongs to. If null, this
- structure is free, and the NBYTES member of the union below
+ structure is free, and NBYTES (in this structure or in the union below)
contains the string's byte size (the same value that STRING_BYTES
would return if STRING were non-null). If non-null, STRING_BYTES
(STRING) is the size of the data, and DATA contains the string's
contents. */
struct Lisp_String *string;
+#ifdef GC_CHECK_STRING_BYTES
ptrdiff_t nbytes;
+#endif
+
unsigned char data[FLEXIBLE_ARRAY_MEMBER];
-} sdata;
+};
+
+#ifdef GC_CHECK_STRING_BYTES
+typedef struct sdata sdata;
#define SDATA_NBYTES(S) (S)->nbytes
#define SDATA_DATA(S) (S)->data
-#define SDATA_SELECTOR(member) member
#else
{
struct Lisp_String *string;
- /* When STRING is non-null. */
- struct
- {
- struct Lisp_String *string;
- unsigned char data[FLEXIBLE_ARRAY_MEMBER];
- } u;
+ /* When STRING is nonnull, this union is actually of type 'struct sdata',
+ which has a flexible array member. However, if implemented by
+ giving this union a member of type 'struct sdata', the union
+ could not be the last (flexible) member of 'struct sblock',
+ because C99 prohibits a flexible array member from having a type
+ that is itself a flexible array. So, comment this member out here,
+ but remember that the option's there when using this union. */
+#if 0
+ struct sdata u;
+#endif
/* When STRING is null. */
struct
} sdata;
#define SDATA_NBYTES(S) (S)->n.nbytes
-#define SDATA_DATA(S) (S)->u.data
-#define SDATA_SELECTOR(member) u.member
+#define SDATA_DATA(S) ((struct sdata *) (S))->data
#endif /* not GC_CHECK_STRING_BYTES */
-#define SDATA_DATA_OFFSET offsetof (sdata, SDATA_SELECTOR (data))
-
+enum { SDATA_DATA_OFFSET = offsetof (struct sdata, data) };
/* Structure describing a block of memory which is sub-allocated to
obtain string data memory for strings. Blocks for small strings
of the sblock if there isn't any space left in this block. */
sdata *next_free;
- /* Start of data. */
- sdata first_data;
+ /* String data. */
+ sdata data[FLEXIBLE_ARRAY_MEMBER];
};
/* Number of Lisp strings in a string_block structure. The 1020 is
min (STRING_BYTES_BOUND,
((SIZE_MAX - XMALLOC_OVERRUN_CHECK_OVERHEAD
- GC_STRING_EXTRA
- - offsetof (struct sblock, first_data)
+ - offsetof (struct sblock, data)
- SDATA_DATA_OFFSET)
& ~(sizeof (EMACS_INT) - 1)));
end = b->next_free;
- for (from = &b->first_data; from < end; from = from_end)
+ for (from = b->data; from < end; from = from_end)
{
/* Compute the next FROM here because copying below may
overwrite data we need to compute it. */
for (b = large_sblocks; b; b = b->next)
{
- struct Lisp_String *s = b->first_data.string;
+ struct Lisp_String *s = b->data[0].string;
if (s)
string_bytes (s);
}
if (nbytes > LARGE_STRING_BYTES)
{
- size_t size = offsetof (struct sblock, first_data) + needed;
+ size_t size = offsetof (struct sblock, data) + needed;
#ifdef DOUG_LEA_MALLOC
/* Prevent mmap'ing the chunk. Lisp data may not be mmap'ed
mallopt (M_MMAP_MAX, MMAP_MAX_AREAS);
#endif
- b->next_free = &b->first_data;
- b->first_data.string = NULL;
+ b->next_free = b->data;
+ b->data[0].string = NULL;
b->next = large_sblocks;
large_sblocks = b;
}
{
/* Not enough room in the current sblock. */
b = lisp_malloc (SBLOCK_SIZE, MEM_TYPE_NON_LISP);
- b->next_free = &b->first_data;
- b->first_data.string = NULL;
+ b->next_free = b->data;
+ b->data[0].string = NULL;
b->next = NULL;
if (current_sblock)
{
next = b->next;
- if (b->first_data.string == NULL)
+ if (b->data[0].string == NULL)
lisp_free (b);
else
{
to, and TB_END is the end of TB. */
tb = oldest_sblock;
tb_end = (sdata *) ((char *) tb + SBLOCK_SIZE);
- to = &tb->first_data;
+ to = tb->data;
/* Step through the blocks from the oldest to the youngest. We
expect that old blocks will stabilize over time, so that less
end = b->next_free;
eassert ((char *) end <= (char *) b + SBLOCK_SIZE);
- for (from = &b->first_data; from < end; from = from_end)
+ for (from = b->data; from < end; from = from_end)
{
/* Compute the next FROM here because copying below may
overwrite data we need to compute it. */
tb->next_free = to;
tb = tb->next;
tb_end = (sdata *) ((char *) tb + SBLOCK_SIZE);
- to = &tb->first_data;
+ to = tb->data;
to_end = (sdata *) ((char *) to + nbytes + GC_STRING_EXTRA);
}
Vector Allocation
***********************************************************************/
+/* Sometimes a vector's contents are merely a pointer internally used
+ in vector allocation code. Usually you don't want to touch this. */
+
+static struct Lisp_Vector *
+next_vector (struct Lisp_Vector *v)
+{
+ return XUNTAG (v->contents[0], 0);
+}
+
+static void
+set_next_vector (struct Lisp_Vector *v, struct Lisp_Vector *p)
+{
+ v->contents[0] = make_lisp_ptr (p, 0);
+}
+
/* This value is balanced well enough to avoid too much internal overhead
for the most common cases; it's not required to be a power of two, but
it's expected to be a mult-of-ROUNDUP_SIZE (see below). */
#define VECTOR_BLOCK_SIZE 4096
-/* Align allocation request sizes to be a multiple of ROUNDUP_SIZE. */
enum
{
- roundup_size = COMMON_MULTIPLE (word_size, USE_LSB_TAG ? GCALIGNMENT : 1)
+ /* Alignment of struct Lisp_Vector objects. */
+ vector_alignment = COMMON_MULTIPLE (ALIGNOF_STRUCT_LISP_VECTOR,
+ USE_LSB_TAG ? GCALIGNMENT : 1),
+
+ /* Vector size requests are a multiple of this. */
+ roundup_size = COMMON_MULTIPLE (vector_alignment, word_size)
};
/* Verify assumptions described above. */
eassert ((nbytes) % roundup_size == 0); \
(tmp) = VINDEX (nbytes); \
eassert ((tmp) < VECTOR_MAX_FREE_LIST_INDEX); \
- v->u.next = vector_free_lists[tmp]; \
+ set_next_vector (v, vector_free_lists[tmp]); \
vector_free_lists[tmp] = (v); \
total_free_vector_slots += (nbytes) / word_size; \
} while (0)
/* This internal type is used to maintain the list of large vectors
- which are allocated at their own, e.g. outside of vector blocks. */
+ which are allocated at their own, e.g. outside of vector blocks.
+
+ struct large_vector itself cannot contain a struct Lisp_Vector, as
+ the latter contains a flexible array member and C99 does not allow
+ such structs to be nested. Instead, each struct large_vector
+ object LV is followed by a struct Lisp_Vector, which is at offset
+ large_vector_offset from LV, and whose address is therefore
+ large_vector_vec (&LV). */
struct large_vector
{
- union {
- struct large_vector *vector;
-#if USE_LSB_TAG
- /* We need to maintain ROUNDUP_SIZE alignment for the vector member. */
- unsigned char c[vroundup_ct (sizeof (struct large_vector *))];
-#endif
- } next;
- struct Lisp_Vector v;
+ struct large_vector *next;
};
+enum
+{
+ large_vector_offset = ROUNDUP (sizeof (struct large_vector), vector_alignment)
+};
+
+static struct Lisp_Vector *
+large_vector_vec (struct large_vector *p)
+{
+ return (struct Lisp_Vector *) ((char *) p + large_vector_offset);
+}
+
/* This internal type is used to maintain an underlying storage
for small vectors. */
if (vector_free_lists[index])
{
vector = vector_free_lists[index];
- vector_free_lists[index] = vector->u.next;
+ vector_free_lists[index] = next_vector (vector);
total_free_vector_slots -= nbytes / word_size;
return vector;
}
{
/* This vector is larger than requested. */
vector = vector_free_lists[index];
- vector_free_lists[index] = vector->u.next;
+ vector_free_lists[index] = next_vector (vector);
total_free_vector_slots -= nbytes / word_size;
/* Excess bytes are used for the smaller vector,
for (lv = large_vectors; lv; lv = *lvprev)
{
- vector = &lv->v;
+ vector = large_vector_vec (lv);
if (VECTOR_MARKED_P (vector))
{
VECTOR_UNMARK (vector);
else
total_vector_slots
+= header_size / word_size + vector->header.size;
- lvprev = &lv->next.vector;
+ lvprev = &lv->next;
}
else
{
- *lvprev = lv->next.vector;
+ *lvprev = lv->next;
lisp_free (lv);
}
}
else
{
struct large_vector *lv
- = lisp_malloc ((offsetof (struct large_vector, v.u.contents)
+ = lisp_malloc ((large_vector_offset + header_size
+ len * word_size),
MEM_TYPE_VECTORLIKE);
- lv->next.vector = large_vectors;
+ lv->next = large_vectors;
large_vectors = lv;
- p = &lv->v;
+ p = large_vector_vec (lv);
}
#ifdef DOUG_LEA_MALLOC
/* Only the first lisplen slots will be traced normally by the GC. */
for (i = 0; i < lisplen; ++i)
- v->u.contents[i] = Qnil;
+ v->contents[i] = Qnil;
XSETPVECTYPESIZE (v, tag, lisplen, memlen - lisplen);
return v;
p = allocate_vector (XFASTINT (length));
sizei = XFASTINT (length);
for (i = 0; i < sizei; i++)
- p->u.contents[i] = init;
+ p->contents[i] = init;
XSETVECTOR (vector, p);
return vector;
register struct Lisp_Vector *p = XVECTOR (val);
for (i = 0; i < nargs; i++)
- p->u.contents[i] = args[i];
+ p->contents[i] = args[i];
return val;
}
{
/* Don't allow the global zero_vector to become a byte code object. */
eassert(0 < v->header.size);
- if (v->header.size > 1 && STRINGP (v->u.contents[1])
- && STRING_MULTIBYTE (v->u.contents[1]))
+ if (v->header.size > 1 && STRINGP (v->contents[1])
+ && STRING_MULTIBYTE (v->contents[1]))
/* BYTECODE-STRING must have been produced by Emacs 20.2 or the
earlier because they produced a raw 8-bit string for byte-code
and now such a byte-code string is loaded as multibyte while
raw 8-bit characters converted to multibyte form. Thus, now we
must convert them back to the original unibyte form. */
- v->u.contents[1] = Fstring_as_unibyte (v->u.contents[1]);
+ v->contents[1] = Fstring_as_unibyte (v->contents[1]);
XSETPVECTYPE (v, PVEC_COMPILED);
}
to be setcar'd). */
for (i = 0; i < nargs; i++)
- p->u.contents[i] = args[i];
+ p->contents[i] = args[i];
make_byte_code (p);
XSETCOMPILED (val, p);
return val;
vector = ADVANCE (vector, vector_nbytes (vector));
}
}
- else if (m->type == MEM_TYPE_VECTORLIKE
- && (char *) p == ((char *) m->start
- + offsetof (struct large_vector, v)))
+ else if (m->type == MEM_TYPE_VECTORLIKE && p == large_vector_vec (m->start))
/* This memory node corresponds to a large vector. */
return 1;
return 0;
size &= PSEUDOVECTOR_SIZE_MASK;
vec = XVECTOR (make_pure_vector (size));
for (i = 0; i < size; i++)
- vec->u.contents[i] = Fpurecopy (AREF (obj, i));
+ vec->contents[i] = Fpurecopy (AREF (obj, i));
if (COMPILEDP (obj))
{
XSETPVECTYPE (vec, PVEC_COMPILED);
The distinction is used e.g. by Lisp_Process which places extra
non-Lisp_Object fields at the end of the structure... */
for (i = 0; i < size; i++) /* ...and then mark its elements. */
- mark_object (ptr->u.contents[i]);
+ mark_object (ptr->contents[i]);
}
/* Like mark_vectorlike but optimized for char-tables (and
VECTOR_MARK (ptr);
for (i = 0; i < size; i++)
{
- Lisp_Object val = ptr->u.contents[i];
+ Lisp_Object val = ptr->contents[i];
if (INTEGERP (val) || (SYMBOLP (val) && XSYMBOL (val)->gcmarkbit))
continue;
VECTOR_MARK (ptr);
for (i = 0; i < size; i++)
if (i != COMPILED_CONSTANTS)
- mark_object (ptr->u.contents[i]);
+ mark_object (ptr->contents[i]);
if (size > COMPILED_CONSTANTS)
{
- obj = ptr->u.contents[COMPILED_CONSTANTS];
+ obj = ptr->contents[COMPILED_CONSTANTS];
goto loop;
}
}
Lisp_Object *copy = alloca (size * sizeof *copy);
ptrdiff_t i;
- memcpy (copy, XVECTOR (last_overlay_modification_hooks)->u.contents,
+ memcpy (copy, XVECTOR (last_overlay_modification_hooks)->contents,
size * word_size);
gcpro1.var = copy;
gcpro1.nvars = size;
#ifdef BYTE_CODE_SAFE
bytestr_length = SBYTES (bytestr);
#endif
- vectorp = XVECTOR (vector)->u.contents;
+ vectorp = XVECTOR (vector)->contents;
stack.byte_string = bytestr;
stack.pc = stack.byte_string_start = SDATA (bytestr);
ccl_prog_stack_struct[stack_idx].ic = ic;
ccl_prog_stack_struct[stack_idx].eof_ic = eof_ic;
stack_idx++;
- ccl_prog = XVECTOR (AREF (slot, 1))->u.contents;
+ ccl_prog = XVECTOR (AREF (slot, 1))->contents;
ic = CCL_HEADER_MAIN;
eof_ic = XFASTINT (ccl_prog[CCL_HEADER_EOF]);
}
return -1;
vp = XVECTOR (ccl_prog);
ccl->size = vp->header.size;
- ccl->prog = vp->u.contents;
- ccl->eof_ic = XINT (vp->u.contents[CCL_HEADER_EOF]);
- ccl->buf_magnification = XINT (vp->u.contents[CCL_HEADER_BUF_MAG]);
+ ccl->prog = vp->contents;
+ ccl->eof_ic = XINT (vp->contents[CCL_HEADER_EOF]);
+ ccl->buf_magnification = XINT (vp->contents[CCL_HEADER_BUF_MAG]);
if (ccl->idx >= 0)
{
Lisp_Object slot;
/* Return a translation table of id number ID. */
#define GET_TRANSLATION_TABLE(id) \
- (XCDR (XVECTOR (Vtranslation_table_vector)->u.contents[(id)]))
+ (XCDR (XVECTOR (Vtranslation_table_vector)->contents[(id)]))
INLINE_HEADER_END
static Lisp_Object
uniprop_encode_value_run_length (Lisp_Object table, Lisp_Object value)
{
- Lisp_Object *value_table = XVECTOR (XCHAR_TABLE (table)->extras[4])->u.contents;
+ Lisp_Object *value_table = XVECTOR (XCHAR_TABLE (table)->extras[4])->contents;
int i, size = ASIZE (XCHAR_TABLE (table)->extras[4]);
for (i = 0; i < size; i++)
static Lisp_Object
uniprop_encode_value_numeric (Lisp_Object table, Lisp_Object value)
{
- Lisp_Object *value_table = XVECTOR (XCHAR_TABLE (table)->extras[4])->u.contents;
+ Lisp_Object *value_table = XVECTOR (XCHAR_TABLE (table)->extras[4])->contents;
int i, size = ASIZE (XCHAR_TABLE (table)->extras[4]);
CHECK_NUMBER (value);
composition_table = xpalloc (composition_table, &composition_table_size,
1, -1, sizeof *composition_table);
- key_contents = XVECTOR (key)->u.contents;
+ key_contents = XVECTOR (key)->contents;
/* Check if the contents of COMPONENTS are valid if COMPONENTS is a
vector or a list. It should be a sequence of:
#define COMPOSITION_GLYPH(cmp, n) \
XINT (XVECTOR (XVECTOR (XHASH_TABLE (composition_hash_table) \
->key_and_value) \
- ->u.contents[cmp->hash_index * 2]) \
- ->u.contents[cmp->method == COMPOSITION_WITH_RULE_ALTCHARS \
+ ->contents[cmp->hash_index * 2]) \
+ ->contents[cmp->method == COMPOSITION_WITH_RULE_ALTCHARS \
? (n) * 2 : (n)])
/* Return the encoded composition rule to compose the Nth glyph of
#define COMPOSITION_RULE(cmp, n) \
XINT (XVECTOR (XVECTOR (XHASH_TABLE (composition_hash_table) \
->key_and_value) \
- ->u.contents[cmp->hash_index * 2]) \
- ->u.contents[(n) * 2 - 1])
+ ->contents[cmp->hash_index * 2]) \
+ ->contents[(n) * 2 - 1])
/* Decode encoded composition rule RULE_CODE into GREF (global
reference point code), NREF (new ref. point code). Don't check RULE_CODE;
#include "process.h"
#include "syssignal.h"
+#include "tparam.h"
#ifdef HAVE_WINDOW_SYSTEM
#include TERM_HEADER
#include <fpending.h>
#include <timespec.h>
-#if defined (HAVE_TERM_H) && defined (GNU_LINUX)
-#include <term.h> /* for tgetent */
-#endif
-
#ifdef WINDOWSNT
#include "w32.h"
#endif
/* Return the current base (for indexing) of the GLYPH table,
or 0 if the table isn't currently valid. */
#define GLYPH_TABLE_BASE \
- ((VECTORP (Vglyph_table)) ? XVECTOR (Vglyph_table)->u.contents : 0)
+ ((VECTORP (Vglyph_table)) ? XVECTOR (Vglyph_table)->contents : 0)
/* Given BASE and LEN returned by the two previous macros,
return nonzero if the GLYPH code G should be output as a single
for (i = n = 0; i < ASIZE (seq); ++i)
if (NILP (Fequal (AREF (seq, i), elt)))
- p->u.contents[n++] = AREF (seq, i);
+ p->contents[n++] = AREF (seq, i);
XSETVECTOR (seq, p);
}
{
struct Lisp_Vector *v;
ptrdiff_t i, incr, incr_max, old_size, new_size;
- ptrdiff_t C_language_max = min (PTRDIFF_MAX, SIZE_MAX) / sizeof *v->u.contents;
+ ptrdiff_t C_language_max = min (PTRDIFF_MAX, SIZE_MAX) / sizeof *v->contents;
ptrdiff_t n_max = (0 <= nitems_max && nitems_max < C_language_max
? nitems_max : C_language_max);
eassert (VECTORP (vec));
memory_full (SIZE_MAX);
new_size = old_size + incr;
v = allocate_vector (new_size);
- memcpy (v->u.contents, XVECTOR (vec)->u.contents, old_size * sizeof *v->u.contents);
+ memcpy (v->contents, XVECTOR (vec)->contents, old_size * sizeof *v->contents);
for (i = old_size; i < new_size; ++i)
- v->u.contents[i] = Qnil;
+ v->contents[i] = Qnil;
XSETVECTOR (vec, v);
return vec;
}
}
if (score_changed)
- qsort (XVECTOR (vec)->u.contents, size, word_size,
+ qsort (XVECTOR (vec)->contents, size, word_size,
fontset_compare_rfontdef);
XSETCAR (font_group, make_number (charset_ordered_list_tick));
}
CHECK_LIST (proplist);
if (NILP (Fgnutls_available_p ()))
- {
- error ("GnuTLS not available");
- return gnutls_make_error (GNUTLS_EMACS_ERROR_NOT_LOADED);
- }
+ error ("GnuTLS not available");
if (!EQ (type, Qgnutls_x509pki) && !EQ (type, Qgnutls_anon))
- {
- error ("Invalid GnuTLS credential type");
- return gnutls_make_error (GNUTLS_EMACS_ERROR_INVALID_TYPE);
- }
+ error ("Invalid GnuTLS credential type");
hostname = Fplist_get (proplist, QCgnutls_bootprop_hostname);
priority_string = Fplist_get (proplist, QCgnutls_bootprop_priority);
for (i = 0; i < 256; i++)
if (character_width (i, disptab)
- != XFASTINT (widthtab->u.contents[i]))
+ != XFASTINT (widthtab->contents[i]))
return 0;
return 1;
eassert (widthtab->header.size == 256);
for (i = 0; i < 256; i++)
- XSETFASTINT (widthtab->u.contents[i], character_width (i, disptab));
+ XSETFASTINT (widthtab->contents[i], character_width (i, disptab));
}
/* Allocate or free the width run cache, as requested by the
width_run_cache_on_off ();
if (dp == buffer_display_table ())
width_table = (VECTORP (BVAR (current_buffer, width_table))
- ? XVECTOR (BVAR (current_buffer, width_table))->u.contents
+ ? XVECTOR (BVAR (current_buffer, width_table))->contents
: 0);
else
/* If the window has its own display table, we can't use the width
if (! (VECTORP (timer) && ASIZE (timer) == 9))
return 0;
- vector = XVECTOR (timer)->u.contents;
+ vector = XVECTOR (timer)->contents;
if (! NILP (vector[0]))
return 0;
discard any previously made item. */
for (i = 0; i < ntool_bar_items; i += TOOL_BAR_ITEM_NSLOTS)
{
- Lisp_Object *v = XVECTOR (tool_bar_items_vector)->u.contents + i;
+ Lisp_Object *v = XVECTOR (tool_bar_items_vector)->contents + i;
if (EQ (key, v[TOOL_BAR_ITEM_KEY]))
{
/* Append entries from tool_bar_item_properties to the end of
tool_bar_items_vector. */
vcopy (tool_bar_items_vector, ntool_bar_items,
- XVECTOR (tool_bar_item_properties)->u.contents, TOOL_BAR_ITEM_NSLOTS);
+ XVECTOR (tool_bar_item_properties)->contents, TOOL_BAR_ITEM_NSLOTS);
ntool_bar_items += TOOL_BAR_ITEM_NSLOTS;
}
doc: /* Return vector of last 300 events, not counting those from keyboard macros. */)
(void)
{
- Lisp_Object *keys = XVECTOR (recent_keys)->u.contents;
+ Lisp_Object *keys = XVECTOR (recent_keys)->contents;
Lisp_Object val;
if (total_keys < NUM_RECENT_KEYS)
(void)
{
return make_event_array (this_command_key_count,
- XVECTOR (this_command_keys)->u.contents);
+ XVECTOR (this_command_keys)->contents);
}
DEFUN ("this-command-keys-vector", Fthis_command_keys_vector, Sthis_command_keys_vector, 0, 0, 0,
(void)
{
return Fvector (this_command_key_count,
- XVECTOR (this_command_keys)->u.contents);
+ XVECTOR (this_command_keys)->contents);
}
DEFUN ("this-single-command-keys", Fthis_single_command_keys,
{
return Fvector (this_command_key_count
- this_single_command_key_start,
- (XVECTOR (this_command_keys)->u.contents
+ (XVECTOR (this_command_keys)->contents
+ this_single_command_key_start));
}
The value is always a vector. */)
(void)
{
- return Fvector (raw_keybuf_count, XVECTOR (raw_keybuf)->u.contents);
+ return Fvector (raw_keybuf_count, XVECTOR (raw_keybuf)->contents);
}
DEFUN ("reset-this-command-lengths", Freset_this_command_lengths,
#define case_Lisp_Int case Lisp_Int0: case Lisp_Int1
/* Idea stolen from GDB. Pedantic GCC complains about enum bitfields,
- MSVC doesn't support them, and xlc complains vociferously about them. */
-#if defined __STRICT_ANSI__ || defined _MSC_VER || defined __IBMC__
+ MSVC doesn't support them, and xlc and Oracle Studio c99 complain
+ vociferously about them. */
+#if (defined __STRICT_ANSI__ || defined _MSC_VER || defined __IBMC__ \
+ || (defined __SUNPRO_C && __STDC__))
#define ENUM_BF(TYPE) unsigned int
#else
#define ENUM_BF(TYPE) enum TYPE
ptrdiff_t size;
};
-/* Regular vector is just a header plus array of Lisp_Objects... */
+/* A regular vector is just a header plus an array of Lisp_Objects. */
struct Lisp_Vector
{
struct vectorlike_header header;
- union {
- /* ...but sometimes there is also a pointer internally used in
- vector allocation code. Usually you don't want to touch this. */
- struct Lisp_Vector *next;
+ Lisp_Object contents[FLEXIBLE_ARRAY_MEMBER];
+ };
- /* We can't use FLEXIBLE_ARRAY_MEMBER here. */
- Lisp_Object contents[1];
- } u;
+/* C11 prohibits alignof (struct Lisp_Vector), so compute it manually. */
+enum
+ {
+ ALIGNOF_STRUCT_LISP_VECTOR
+ = alignof (union { struct vectorlike_header a; Lisp_Object b; })
};
-/* A boolvector is a kind of vectorlike, with contents are like a string. */
+/* A boolvector is a kind of vectorlike, with contents like a string. */
struct Lisp_Bool_Vector
{
enum
{
- header_size = offsetof (struct Lisp_Vector, u.contents),
+ header_size = offsetof (struct Lisp_Vector, contents),
bool_header_size = offsetof (struct Lisp_Bool_Vector, data),
word_size = sizeof (Lisp_Object)
};
INLINE Lisp_Object
AREF (Lisp_Object array, ptrdiff_t idx)
{
- return XVECTOR (array)->u.contents[idx];
+ return XVECTOR (array)->contents[idx];
}
INLINE Lisp_Object *
aref_addr (Lisp_Object array, ptrdiff_t idx)
{
- return & XVECTOR (array)->u.contents[idx];
+ return & XVECTOR (array)->contents[idx];
}
INLINE ptrdiff_t
ASET (Lisp_Object array, ptrdiff_t idx, Lisp_Object val)
{
eassert (0 <= idx && idx < ASIZE (array));
- XVECTOR (array)->u.contents[idx] = val;
+ XVECTOR (array)->contents[idx] = val;
}
INLINE void
/* Like ASET, but also can be used in the garbage collector:
sweep_weak_table calls set_hash_key etc. while the table is marked. */
eassert (0 <= idx && idx < (ASIZE (array) & ~ARRAY_MARK_FLAG));
- XVECTOR (array)->u.contents[idx] = val;
+ XVECTOR (array)->contents[idx] = val;
}
/* If a struct is made to look like a vector, this macro returns the length
{
ENUM_BF (Lisp_Misc_Type) type : 16; /* = Lisp_Misc_??? */
unsigned gcmarkbit : 1;
- int spacer : 15;
+ unsigned spacer : 15;
};
struct Lisp_Marker
{
ENUM_BF (Lisp_Misc_Type) type : 16; /* = Lisp_Misc_Marker */
unsigned gcmarkbit : 1;
- int spacer : 13;
+ unsigned spacer : 13;
/* This flag is temporarily used in the functions
decode/encode_coding_object to record that the marker position
must be adjusted after the conversion. */
{
ENUM_BF (Lisp_Misc_Type) type : 16; /* = Lisp_Misc_Overlay */
unsigned gcmarkbit : 1;
- int spacer : 15;
+ unsigned spacer : 15;
struct Lisp_Overlay *next;
Lisp_Object start;
Lisp_Object end;
{
ENUM_BF (Lisp_Misc_Type) type : 16; /* = Lisp_Misc_Save_Value */
unsigned gcmarkbit : 1;
- int spacer : 32 - (16 + 1 + SAVE_TYPE_BITS);
+ unsigned spacer : 32 - (16 + 1 + SAVE_TYPE_BITS);
/* V->data may hold up to SAVE_VALUE_SLOTS entries. The type of
V's data entries are determined by V->save_type. E.g., if
{
ENUM_BF (Lisp_Misc_Type) type : 16; /* = Lisp_Misc_Free */
unsigned gcmarkbit : 1;
- int spacer : 15;
+ unsigned spacer : 15;
union Lisp_Misc *chain;
};
} let;
struct {
ENUM_BF (specbind_tag) kind : CHAR_BIT;
- bool debug_on_exit : 1;
+ unsigned debug_on_exit : 1;
Lisp_Object function;
Lisp_Object *args;
ptrdiff_t nargs;
vcopy (Lisp_Object v, ptrdiff_t offset, Lisp_Object *args, ptrdiff_t count)
{
eassert (0 <= offset && 0 <= count && offset + count <= ASIZE (v));
- memcpy (XVECTOR (v)->u.contents + offset, args, count * sizeof *args);
+ memcpy (XVECTOR (v)->contents + offset, args, count * sizeof *args);
}
/* Functions to modify hash tables. */
vector = Fmake_vector (len, Qnil);
size = ASIZE (vector);
- ptr = XVECTOR (vector)->u.contents;
+ ptr = XVECTOR (vector)->contents;
for (i = 0; i < size; i++)
{
item = Fcar (tem);
and then the scan code. */)
(void)
{
- Lisp_Object val, *keys = XVECTOR (recent_doskeys)->u.contents;
+ Lisp_Object val, *keys = XVECTOR (recent_doskeys)->contents;
if (total_doskeys < NUM_RECENT_DOSKEYS)
return Fvector (total_doskeys, keys);
for (i = 0; i < nargs; i++)
{
- if (! RANGED_INTEGERP (0, p->u.contents[i], 65535))
+ if (! RANGED_INTEGERP (0, p->contents[i], 65535))
return Qnil;
if (nargs <= 5 /* IPv4 */
&& i < 4 /* host, not port */
- && XINT (p->u.contents[i]) > 255)
+ && XINT (p->contents[i]) > 255)
return Qnil;
- args[i+1] = p->u.contents[i];
+ args[i+1] = p->contents[i];
}
return Fformat (nargs+1, args);
len = sizeof (sin->sin_addr) + 1;
address = Fmake_vector (make_number (len), Qnil);
p = XVECTOR (address);
- p->u.contents[--len] = make_number (ntohs (sin->sin_port));
+ p->contents[--len] = make_number (ntohs (sin->sin_port));
cp = (unsigned char *) &sin->sin_addr;
break;
}
len = sizeof (sin6->sin6_addr)/2 + 1;
address = Fmake_vector (make_number (len), Qnil);
p = XVECTOR (address);
- p->u.contents[--len] = make_number (ntohs (sin6->sin6_port));
+ p->contents[--len] = make_number (ntohs (sin6->sin6_port));
for (i = 0; i < len; i++)
- p->u.contents[i] = make_number (ntohs (ip6[i]));
+ p->contents[i] = make_number (ntohs (ip6[i]));
return address;
}
#endif
i = 0;
while (i < len)
- p->u.contents[i++] = make_number (*cp++);
+ p->contents[i++] = make_number (*cp++);
return address;
}
{
struct sockaddr_in *sin = (struct sockaddr_in *) sa;
len = sizeof (sin->sin_addr) + 1;
- hostport = XINT (p->u.contents[--len]);
+ hostport = XINT (p->contents[--len]);
sin->sin_port = htons (hostport);
cp = (unsigned char *)&sin->sin_addr;
sa->sa_family = family;
struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) sa;
uint16_t *ip6 = (uint16_t *)&sin6->sin6_addr;
len = sizeof (sin6->sin6_addr) + 1;
- hostport = XINT (p->u.contents[--len]);
+ hostport = XINT (p->contents[--len]);
sin6->sin6_port = htons (hostport);
for (i = 0; i < len; i++)
- if (INTEGERP (p->u.contents[i]))
+ if (INTEGERP (p->contents[i]))
{
- int j = XFASTINT (p->u.contents[i]) & 0xffff;
+ int j = XFASTINT (p->contents[i]) & 0xffff;
ip6[i] = ntohs (j);
}
sa->sa_family = family;
}
for (i = 0; i < len; i++)
- if (INTEGERP (p->u.contents[i]))
- *cp++ = XFASTINT (p->u.contents[i]) & 0xff;
+ if (INTEGERP (p->contents[i]))
+ *cp++ = XFASTINT (p->contents[i]) & 0xff;
}
#ifdef DATAGRAM_SOCKETS
any = 1;
for (n = 0; n < 6; n++)
- p->u.contents[n] = make_number (((unsigned char *)&rq.ifr_hwaddr.sa_data[0])[n]);
+ p->contents[n] = make_number (((unsigned char *)
+ &rq.ifr_hwaddr.sa_data[0])
+ [n]);
elt = Fcons (make_number (rq.ifr_hwaddr.sa_family), hwaddr);
}
#elif defined (HAVE_GETIFADDRS) && defined (LLADDR)
memcpy (linkaddr, LLADDR (sdl), sdl->sdl_alen);
for (n = 0; n < 6; n++)
- p->u.contents[n] = make_number (linkaddr[n]);
+ p->contents[n] = make_number (linkaddr[n]);
elt = Fcons (make_number (it->ifa_addr->sa_family), hwaddr);
break;
Lisp_Object pane_name;
Lisp_Object menu_object;
- first_item = XVECTOR (menu_items)->u.contents;
+ first_item = XVECTOR (menu_items)->contents;
if (EQ (first_item[0], Qt))
pane_name = first_item[MENU_ITEMS_PANE_NAME];
else if (EQ (first_item[0], Qquote))
/* Hardware address and its family. */
for (n = 0; n < adapter->AddressLength; n++)
- p->u.contents[n] = make_number ((int) adapter->Address[n]);
+ p->contents[n] = make_number ((int) adapter->Address[n]);
/* Windows does not support AF_LINK or AF_PACKET family
of addresses. Use an arbitrary family number that is
identical to what GNU/Linux returns. */
/* Save the frame's previous menu bar contents data. */
if (previous_menu_items_used)
- memcpy (previous_items, XVECTOR (f->menu_bar_vector)->u.contents,
+ memcpy (previous_items, XVECTOR (f->menu_bar_vector)->contents,
previous_menu_items_used * word_size);
/* Fill in menu_items with the current menu bar contents.
};
#define SAVED_WINDOW_N(swv,n) \
- ((struct saved_window *) (XVECTOR ((swv)->u.contents[(n)])))
+ ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
DEFUN ("window-configuration-p", Fwindow_configuration_p, Swindow_configuration_p, 1, 1, 0,
doc: /* Return t if OBJECT is a window-configuration object. */)
if (it->dp && VECTORP (DISP_INVIS_VECTOR (it->dp)))
{
struct Lisp_Vector *v = XVECTOR (DISP_INVIS_VECTOR (it->dp));
- it->dpvec = v->u.contents;
- it->dpend = v->u.contents + v->header.size;
+ it->dpvec = v->contents;
+ it->dpend = v->contents + v->header.size;
}
else
{
if (v->header.size)
{
it->dpvec_char_len = it->len;
- it->dpvec = v->u.contents;
- it->dpend = v->u.contents + v->header.size;
+ it->dpvec = v->contents;
+ it->dpend = v->contents + v->header.size;
it->current.dpvec_index = 0;
it->dpvec_face_id = -1;
it->saved_face_id = it->face_id;
if (VECTORP (XCDR (hot_spot)))
{
struct Lisp_Vector *v = XVECTOR (XCDR (hot_spot));
- Lisp_Object *poly = v->u.contents;
+ Lisp_Object *poly = v->contents;
ptrdiff_t n = v->header.size;
ptrdiff_t i;
int inside = 0;
vec = Fvconcat (ndrivers, drivers);
nfonts = ASIZE (vec);
- qsort (XVECTOR (vec)->u.contents, nfonts, word_size,
+ qsort (XVECTOR (vec)->contents, nfonts, word_size,
compare_fonts_by_sort_order);
result = Qnil;
if (!NILP (lface))
{
eassert (LFACEP (lface));
- check_lface_attrs (XVECTOR (lface)->u.contents);
+ check_lface_attrs (XVECTOR (lface)->contents);
}
}
lface = lface_from_face_name_no_resolve (f, face_name, signal_p);
if (! NILP (lface))
- memcpy (attrs, XVECTOR (lface)->u.contents,
+ memcpy (attrs, XVECTOR (lface)->contents,
LFACE_VECTOR_SIZE * sizeof *attrs);
return !NILP (lface);
copy = Finternal_make_lisp_face (to, new_frame);
}
- vcopy (copy, 0, XVECTOR (lface)->u.contents, LFACE_VECTOR_SIZE);
+ vcopy (copy, 0, XVECTOR (lface)->contents, LFACE_VECTOR_SIZE);
/* Changing a named face means that all realized faces depending on
that face are invalid. Since we cannot tell which realized faces
f = XFRAME (frame);
if (! FONT_OBJECT_P (value))
{
- Lisp_Object *attrs = XVECTOR (lface)->u.contents;
+ Lisp_Object *attrs = XVECTOR (lface)->contents;
Lisp_Object font_object;
font_object = font_load_for_lface (f, attrs, value);
the font to nil so that the font selector doesn't think that
the attribute is mandatory. Also, clear the average
width. */
- font_clear_prop (XVECTOR (lface)->u.contents, prop_index);
+ font_clear_prop (XVECTOR (lface)->contents, prop_index);
}
/* Changing a named face means that all realized faces depending on
reflected in changed `font' frame parameters. */
if (FRAMEP (frame)
&& (prop_index || EQ (attr, QCfont))
- && lface_fully_specified_p (XVECTOR (lface)->u.contents))
+ && lface_fully_specified_p (XVECTOR (lface)->contents))
set_font_frame_param (frame, lface);
else
#endif /* HAVE_WINDOW_SYSTEM */
{
if (FONT_SPEC_P (font))
{
- font = font_load_for_lface (f, XVECTOR (lface)->u.contents, font);
+ font = font_load_for_lface (f, XVECTOR (lface)->contents, font);
if (NILP (font))
return;
ASET (lface, LFACE_FONT_INDEX, font);
the local frame is defined from default specs in `face-defface-spec'
and those should be overridden by global settings. Hence the strange
"global before local" priority. */
- lvec = XVECTOR (local_lface)->u.contents;
- gvec = XVECTOR (global_lface)->u.contents;
+ lvec = XVECTOR (local_lface)->contents;
+ gvec = XVECTOR (global_lface)->contents;
for (i = 1; i < LFACE_VECTOR_SIZE; ++i)
if (IGNORE_DEFFACE_P (gvec[i]))
ASET (local_lface, i, Qunspecified);
lface1 = lface_from_face_name (f, face1, 1);
lface2 = lface_from_face_name (f, face2, 1);
- equal_p = lface_equal_p (XVECTOR (lface1)->u.contents,
- XVECTOR (lface2)->u.contents);
+ equal_p = lface_equal_p (XVECTOR (lface1)->contents,
+ XVECTOR (lface2)->contents);
return equal_p ? Qt : Qnil;
}
Lisp_Object lface;
lface = Fmake_vector (make_number (LFACE_VECTOR_SIZE),
Qunspecified);
- merge_face_ref (XFRAME (selected_frame), plist, XVECTOR (lface)->u.contents,
+ merge_face_ref (XFRAME (selected_frame), plist, XVECTOR (lface)->contents,
1, 0);
return lface;
}
ASET (lface, LFACE_STIPPLE_INDEX, Qnil);
/* Realize the face; it must be fully-specified now. */
- eassert (lface_fully_specified_p (XVECTOR (lface)->u.contents));
+ eassert (lface_fully_specified_p (XVECTOR (lface)->contents));
check_lface (lface);
- memcpy (attrs, XVECTOR (lface)->u.contents, sizeof attrs);
+ memcpy (attrs, XVECTOR (lface)->contents, sizeof attrs);
face = realize_face (c, attrs, DEFAULT_FACE_ID);
#ifdef HAVE_WINDOW_SYSTEM
if (num_fonts > 0)
{
char **indices = alloca (sizeof (char *) * num_fonts);
- Lisp_Object *props = XVECTOR (xfont_scratch_props)->u.contents;
+ Lisp_Object *props = XVECTOR (xfont_scratch_props)->contents;
Lisp_Object scripts = Qnil;
for (i = 0; i < ASIZE (xfont_scratch_props); i++)
/* Save the frame's previous menu bar contents data. */
if (previous_menu_items_used)
- memcpy (previous_items, XVECTOR (f->menu_bar_vector)->u.contents,
+ memcpy (previous_items, XVECTOR (f->menu_bar_vector)->contents,
previous_menu_items_used * word_size);
/* Fill in menu_items with the current menu bar contents.
Lisp_Object pane_name;
Lisp_Object menu_object;
- first_item = XVECTOR (menu_items)->u.contents;
+ first_item = XVECTOR (menu_items)->contents;
if (EQ (first_item[0], Qt))
pane_name = first_item[MENU_ITEMS_PANE_NAME];
else if (EQ (first_item[0], Qquote))