Github/emacs
2
0
Fork 1
mirror of git://git.sv.gnu.org/emacs.git synced 2026-02-16 17:24:23 +00:00
Code Issues Projects Releases Packages Wiki Activity

Port to stricter C99 platforms.

Browse source 
Especially, C99 prohibits nesting a struct X inside struct Y if
struct X has a flexible array member.
Also, merge from gnulib, incorporating:
2013-11-03 intprops: port to Oracle Studio c99
* lib/intprops.h: Update from gnulib.
* src/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.
* src/dispnew.c: Include tparam.h, for tgetent.
Do not include term.h; no longer needed.
* src/gnutls.c (Fgnutls_boot): Don't continue after calling a _Noreturn.
* src/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.
This commit is contained in:
Paul Eggert 2013-11-03 22:09:03 -08:00
parent 0a749fa0e6
commit 91f2d27289
30 changed files with 251 additions and 180 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
ChangeLog
View file

@ -1,3 +1,10 @@
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.

3
lib/intprops.h
View file

@ -89,7 +89,8 @@
/* 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

34
src/ChangeLog
View file

@ -1,3 +1,37 @@
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.

170
src/alloc.c
View file

@ -1280,28 +1280,32 @@ mark_interval (register INTERVAL i, Lisp_Object dummy)
#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;
unsigned char data[FLEXIBLE_ARRAY_MEMBER];
} sdata;
#endif
unsigned char data[FLEXIBLE_ARRAY_MEMBER];
};
#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
@ -1309,12 +1313,16 @@ typedef union
{
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
@ -1325,13 +1333,11 @@ typedef union
} 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
@ -1347,8 +1353,8 @@ struct sblock
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
@ -1464,7 +1470,7 @@ static ptrdiff_t const STRING_BYTES_MAX =
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)));
@ -1507,7 +1513,7 @@ check_sblock (struct sblock *b)
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. */
@ -1535,7 +1541,7 @@ check_string_bytes (bool all_p)
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);
}
@ -1669,7 +1675,7 @@ allocate_string_data (struct Lisp_String *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
@ -1691,8 +1697,8 @@ allocate_string_data (struct Lisp_String *s,
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;
}
@ -1703,8 +1709,8 @@ allocate_string_data (struct Lisp_String *s,
{
/* 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)
@ -1858,7 +1864,7 @@ free_large_strings (void)
{
next = b->next;
if (b->first_data.string == NULL)
if (b->data[0].string == NULL)
lisp_free (b);
else
{
@ -1885,7 +1891,7 @@ compact_small_strings (void)
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
@ -1895,7 +1901,7 @@ compact_small_strings (void)
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. */
@ -1932,7 +1938,7 @@ compact_small_strings (void)
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);
}
@ -2606,16 +2612,35 @@ DEFUN ("make-list", Fmake_list, Smake_list, 2, 2, 0,
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. */
@ -2663,26 +2688,37 @@ verify (VECTOR_BLOCK_SIZE <= (1 << PSEUDOVECTOR_SIZE_BITS));
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. */
@ -2760,7 +2796,7 @@ allocate_vector_from_block (size_t nbytes)
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;
}
@ -2774,7 +2810,7 @@ allocate_vector_from_block (size_t nbytes)
{
/* 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,
@ -2933,7 +2969,7 @@ sweep_vectors (void)
for (lv = large_vectors; lv; lv = *lvprev)
{
vector = &lv->v;
vector = large_vector_vec (lv);
if (VECTOR_MARKED_P (vector))
{
VECTOR_UNMARK (vector);
@ -2949,11 +2985,11 @@ sweep_vectors (void)
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);
}
}
@ -2987,12 +3023,12 @@ allocate_vectorlike (ptrdiff_t len)
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
@ -3041,7 +3077,7 @@ allocate_pseudovector (int memlen, int lisplen, enum pvec_type tag)
/* 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;
@ -3129,7 +3165,7 @@ See also the function `vector'. */)
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;
@ -3147,7 +3183,7 @@ usage: (vector &rest OBJECTS) */)
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;
}
@ -3156,14 +3192,14 @@ make_byte_code (struct Lisp_Vector *v)
{
/* 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);
}
@ -3198,7 +3234,7 @@ usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING INT
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;
@ -4256,9 +4292,7 @@ live_vector_p (struct mem_node *m, void *p)
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;
@ -5189,7 +5223,7 @@ Does not copy symbols. Copies strings without text properties. */)
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);
@ -5710,7 +5744,7 @@ mark_vectorlike (struct Lisp_Vector *ptr)
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
@ -5727,7 +5761,7 @@ mark_char_table (struct Lisp_Vector *ptr)
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;
@ -5956,10 +5990,10 @@ mark_object (Lisp_Object arg)
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;
}
}

2
src/buffer.c
View file

@ -4534,7 +4534,7 @@ report_overlay_modification (Lisp_Object start, Lisp_Object end, bool after,
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;

2
src/bytecode.c
View file

@ -550,7 +550,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
#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);

8
src/ccl.c
View file

@ -1094,7 +1094,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
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]);
}
@ -1936,9 +1936,9 @@ setup_ccl_program (struct ccl_program *ccl, Lisp_Object ccl_prog)
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;

2
src/character.h
View file

@ -677,7 +677,7 @@ extern Lisp_Object string_escape_byte8 (Lisp_Object);
/* 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

4
src/chartab.c
View file

@ -1258,7 +1258,7 @@ uniprop_encode_value_character (Lisp_Object table, Lisp_Object value)
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++)
@ -1276,7 +1276,7 @@ uniprop_encode_value_run_length (Lisp_Object table, Lisp_Object value)
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);

2
src/composite.c
View file

@ -266,7 +266,7 @@ get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
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:

8
src/composite.h
View file

@ -88,8 +88,8 @@ composition_registered_p (Lisp_Object prop)
#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
@ -98,8 +98,8 @@ composition_registered_p (Lisp_Object prop)
#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;

5
src/dispnew.c
View file

@ -42,6 +42,7 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include "process.h"
#include "syssignal.h"
#include "tparam.h"
#ifdef HAVE_WINDOW_SYSTEM
#include TERM_HEADER
@ -52,10 +53,6 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#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

2
src/disptab.h
View file

@ -59,7 +59,7 @@ extern Lisp_Object Qdisplay_table;
/* 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

8
src/fns.c
View file

@ -1602,7 +1602,7 @@ changing the value of a sequence `foo'. */)
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);
}
@ -3446,7 +3446,7 @@ larger_vector (Lisp_Object vec, ptrdiff_t incr_min, ptrdiff_t nitems_max)
{
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));
@ -3458,9 +3458,9 @@ larger_vector (Lisp_Object vec, ptrdiff_t incr_min, ptrdiff_t nitems_max)
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;
}

2
src/fontset.c
View file

@ -453,7 +453,7 @@ reorder_font_vector (Lisp_Object font_group, struct font *font)
}
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));
}

10
src/gnutls.c
View file

@ -791,16 +791,10 @@ one trustfile (usually a CA bundle). */)
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);

6
src/indent.c
View file

@ -118,7 +118,7 @@ disptab_matches_widthtab (struct Lisp_Char_Table *disptab, struct Lisp_Vector *w
for (i = 0; i < 256; i++)
if (character_width (i, disptab)
!= XFASTINT (widthtab->u.contents[i]))
!= XFASTINT (widthtab->contents[i]))
return 0;
return 1;
@ -138,7 +138,7 @@ recompute_width_table (struct buffer *buf, struct Lisp_Char_Table *disptab)
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
@ -1136,7 +1136,7 @@ compute_motion (ptrdiff_t from, ptrdiff_t frombyte, EMACS_INT fromvpos,
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

16
src/keyboard.c
View file

@ -4357,7 +4357,7 @@ decode_timer (Lisp_Object timer, struct timespec *result)
if (! (VECTORP (timer) && ASIZE (timer) == 9))
return 0;
vector = XVECTOR (timer)->u.contents;
vector = XVECTOR (timer)->contents;
if (! NILP (vector[0]))
return 0;
@ -7987,7 +7987,7 @@ process_tool_bar_item (Lisp_Object key, Lisp_Object def, Lisp_Object data, void
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]))
{
@ -8311,7 +8311,7 @@ append_tool_bar_item (void)
/* 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;
}
@ -9915,7 +9915,7 @@ DEFUN ("recent-keys", Frecent_keys, Srecent_keys, 0, 0, 0,
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)
@ -9941,7 +9941,7 @@ See also `this-command-keys-vector'. */)
(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,
@ -9953,7 +9953,7 @@ See also `this-command-keys'. */)
(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,
@ -9968,7 +9968,7 @@ The value is always a vector. */)
{
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));
}
@ -9982,7 +9982,7 @@ shows the events before all translations (except for input methods).
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,

50
src/lisp.h
View file

@ -406,8 +406,10 @@ enum enum_USE_LSB_TAG { USE_LSB_TAG = 0 };
#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
@ -1175,22 +1177,22 @@ struct vectorlike_header
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;
/* We can't use FLEXIBLE_ARRAY_MEMBER here. */
Lisp_Object contents[1];
} u;
Lisp_Object contents[FLEXIBLE_ARRAY_MEMBER];
};
/* A boolvector is a kind of vectorlike, with contents are like a string. */
/* 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 like a string. */
struct Lisp_Bool_Vector
{
@ -1216,7 +1218,7 @@ bool_vector_size (Lisp_Object a)
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)
};
@ -1226,13 +1228,13 @@ enum
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
@ -1245,7 +1247,7 @@ INLINE void
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
@ -1254,7 +1256,7 @@ gc_aset (Lisp_Object array, ptrdiff_t idx, Lisp_Object val)
/* 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
@ -1758,14 +1760,14 @@ struct Lisp_Misc_Any /* Supertype of all Misc types. */
{
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. */
@ -1819,7 +1821,7 @@ struct Lisp_Overlay
{
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;
@ -1897,7 +1899,7 @@ struct Lisp_Save_Value
{
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
@ -1973,7 +1975,7 @@ struct Lisp_Free
{
ENUM_BF (Lisp_Misc_Type) type : 16; /* = Lisp_Misc_Free */
unsigned gcmarkbit : 1;
int spacer : 15;
unsigned spacer : 15;
union Lisp_Misc *chain;
};
@ -2737,7 +2739,7 @@ union specbinding
} 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;
@ -3089,7 +3091,7 @@ INLINE void
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. */

2
src/lread.c
View file

@ -3462,7 +3462,7 @@ read_vector (Lisp_Object readcharfun, bool bytecodeflag)
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);

2
src/msdos.c
View file

@ -2387,7 +2387,7 @@ Each input key receives two values in this vector: first the ASCII code,
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);

32
src/process.c
View file

@ -1333,15 +1333,15 @@ Returns nil if format of ADDRESS is invalid. */)
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);
@ -1983,7 +1983,7 @@ conv_sockaddr_to_lisp (struct sockaddr *sa, int len)
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;
}
@ -1995,9 +1995,9 @@ conv_sockaddr_to_lisp (struct sockaddr *sa, int len)
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
@ -2022,7 +2022,7 @@ conv_sockaddr_to_lisp (struct sockaddr *sa, int len)
i = 0;
while (i < len)
p->u.contents[i++] = make_number (*cp++);
p->contents[i++] = make_number (*cp++);
return address;
}
@ -2093,7 +2093,7 @@ conv_lisp_to_sockaddr (int family, Lisp_Object address, struct sockaddr *sa, int
{
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;
@ -2104,12 +2104,12 @@ conv_lisp_to_sockaddr (int family, Lisp_Object address, struct sockaddr *sa, int
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;
@ -2140,8 +2140,8 @@ conv_lisp_to_sockaddr (int family, Lisp_Object address, struct sockaddr *sa, int
}
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
@ -3723,7 +3723,9 @@ network_interface_info (Lisp_Object ifname)
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)
@ -3746,7 +3748,7 @@ network_interface_info (Lisp_Object ifname)
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;

2
src/term.c
View file

@ -3478,7 +3478,7 @@ tty_menu_help_callback (char const *help_string, int pane, int item)
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))

2
src/w32.c
View file

@ -7621,7 +7621,7 @@ network_interface_get_info (Lisp_Object ifname)
/* 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. */

2
src/w32menu.c
View file

@ -326,7 +326,7 @@ set_frame_menubar (struct frame *f, bool first_time, bool deep_p)
/* 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.

2
src/window.c
View file

@ -5405,7 +5405,7 @@ struct saved_window
};
#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. */)

10
src/xdisp.c
View file

@ -4412,8 +4412,8 @@ setup_for_ellipsis (struct it *it, int len)
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
{
@ -6714,8 +6714,8 @@ get_next_display_element (struct it *it)
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;
@ -27585,7 +27585,7 @@ on_hot_spot_p (Lisp_Object hot_spot, int x, int y)
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;

30
src/xfaces.c
View file

@ -1569,7 +1569,7 @@ the face font sort order. */)
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;
@ -1839,7 +1839,7 @@ check_lface (Lisp_Object lface)
if (!NILP (lface))
{
eassert (LFACEP (lface));
check_lface_attrs (XVECTOR (lface)->u.contents);
check_lface_attrs (XVECTOR (lface)->contents);
}
}
@ -2016,7 +2016,7 @@ get_lface_attributes_no_remap (struct frame *f, Lisp_Object face_name,
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);
@ -2706,7 +2706,7 @@ The value is TO. */)
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
@ -3126,7 +3126,7 @@ FRAME 0 means change the face on all frames, and change the default
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);
@ -3194,7 +3194,7 @@ FRAME 0 means change the face on all frames, and change the default
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
@ -3224,7 +3224,7 @@ FRAME 0 means change the face on all frames, and change the default
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 */
@ -3404,7 +3404,7 @@ set_font_frame_param (Lisp_Object frame, Lisp_Object lface)
{
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);
@ -3763,8 +3763,8 @@ Default face attributes override any local face attributes. */)
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);
@ -3948,8 +3948,8 @@ If FRAME is omitted or nil, use the selected frame. */)
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;
}
@ -4691,7 +4691,7 @@ DEFUN ("face-attributes-as-vector", Fface_attributes_as_vector,
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;
}
@ -5377,9 +5377,9 @@ realize_default_face (struct frame *f)
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

2
src/xfont.c
View file

@ -384,7 +384,7 @@ xfont_list_pattern (Display *display, const char *pattern,
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++)

4
src/xmenu.c
View file

@ -847,7 +847,7 @@ set_frame_menubar (struct frame *f, bool first_time, bool deep_p)
/* 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.
@ -2086,7 +2086,7 @@ menu_help_callback (char const *help_string, int pane, int item)
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))