bug#14409: emacs 24.3 -- windows

unofficial mirror of bug-gnu-emacs@gnu.org 
 help / color / mirror / code / Atom feed

* bug#14409: emacs 24.3 -- windows
@ 2013-05-16  2:31 Frank P Esposito
  2013-05-16  5:33 ` Eli Zaretskii
  2017-08-09 23:13 ` npostavs
  0 siblings, 2 replies; 6+ messages in thread
From: Frank P Esposito @ 2013-05-16  2:31 UTC (permalink / raw)
  To: 14409

[-- Attachment #1: Type: text/plain, Size: 137213 bytes --]

Hello --

You need to fix the code, or  update the readme / install (text) files to
note that this version of emacs  DOES NOT COMPILE with versions of visual
studio that ARE NOT C99 compliant.

there are references to  defines that are  part of stdint.h (C99) --  you
need to define them or not use them


it seems that there is new code in  "charset.c charset.h" that have very
complex macros that are imbedded in other complex macros
that expand to something  like (see below)  which is impossible to debug --
this is causing the error

coding.c
coding.c(2604) : error C2065: 'value' : undeclared identifier
coding.c(2604) : error C2143: syntax error : missing ':' before ')'
coding.c(2604) : error C2059: syntax error : ')'
coding.c(2604) : error C2059: syntax error : ')'
coding.c(2604) : error C2059: syntax error : ')'
coding.c(2604) : fatal error C1013: compiler limit : too many open
parentheses

this error message was generated by visual studio .net 2003 (vc 7.1)
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 13.10.6030 for 80x86
Copyright (C) Microsoft Corporation 1984-2002. All rights reserved.


I would be willing work to get this cleaned up  -- VC 7.1 supports inline
functions

Thanks

Frank Esposito

++++++++++++++

expanded macros


        charset = (charset_table + (preferred_charset_id));
        do { ptrdiff_t offset; charset_map_loaded = 0; result = (((((sizeof
((c) + 0)) > (sizeof ((0x80) + 0)) ? (sizeof ((c) + 0)) : (sizeof ((0x80) +
0))) <= sizeof (unsigned) ? ((c) + (unsigned) 0) < ((0x80) + (unsigned) 0)
: ((c) + (unsigned long) 0) < ((0x80) + (unsigned long) 0)) &&
(charset)->ascii_compatible_p) || ((((charset)->unified_p) ||
(charset)->method == CHARSET_METHOD_SUBSET || (charset)->method ==
CHARSET_METHOD_SUPERSET) ? encode_char ((charset), (c)) !=
(charset)->invalid_code : ((((c)) < 0x10000 ? (charset)->fast_map[((c)) >>
10] & (1 << ((((c)) >> 7) & 7)) : (charset)->fast_map[(((c)) >> 15) + 62] &
(1 << ((((c)) >> 12) & 7))) && ((charset)->method == CHARSET_METHOD_OFFSET
? (c) >= (charset)->min_char && (c) <= (charset)->max_char :
((charset)->method == CHARSET_METHOD_MAP && (charset)->compact_codes_p &&
((((enum Lisp_Type) ((EMACS_UINT) ((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) (((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))) ? ! ((value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii) & (2147483647L >> (3
- 1))) | DATA_SEG_BITS))))->contents[((c))] : char_table_ref (((((((void)
(0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))),
(((c))))) : char_table_ref (((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))),
(((c))))) : char_table_ref ((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1
)) | DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])),
((c))))) == ((uintptr_t) (((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii)) >> VALBITS)) ==
Lisp_Vectorlike) && ((((struct vectorlike_header *) ((uintptr_t)
((((((void) (0 && (((((enum Lisp_Type) ((EMACS_UINT) (((((((void) (0 &&
((((enum Lisp_Type) ((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii) & (2147483647L >> (3
- 1))) | DATA_SEG_BITS)))->size & ((2147483647 - 2147483647 / 2) |
PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) | ((PVEC_SUB_CHAR_TABLE)
<< PSEUDOVECTOR_SIZE_BITS))))))), ((struct Lisp_Sub_Char_Table *)
((uintptr_t) ((((((void) (0 && (((((enum Lisp_Type) ((EMACS_UINT)
(((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((((void) (0 &&
((((enum Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_
t) (((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii) & (2147483647L >> (3
- 1))) | DATA_SEG_BITS))))->contents[((c))]) == (Qnil)) ? (((void) (0 &&
(((((enum Lisp_Type) ((EMACS_UINT) (((((void) (0 && (((((enum Lisp_Type)
((EMACS_UINT) (((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii)) >> VALBITS)) ==
Lisp_Vectorlike) && ((((struct vectorlike_header *) ((uintptr_t)
((((((void) (0 && (((((enum Lisp_Type) ((EMACS_UINT) (((((((void) (0 &&
((((enum Lisp_Type) ((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) (
(uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii) & (2147483647L >> (3
- 1))) | DATA_SEG_BITS)))->size & ((2147483647 - 2147483647 / 2) |
PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) | ((PVEC_SUB_CHAR_TABLE)
<< PSEUDOVECTOR_SIZE_BITS))))))), ((struct Lisp_Sub_Char_Table *)
((uintptr_t) ((((((void) (0 && (((((enum Lisp_Type) ((EMACS_UINT)
(((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((((void) (0 &&
((((enum Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii) & (2147483647L >> (3
- 1))) | DATA_SEG_BITS))))->contents[((c))] : char_table_ref (((((((void)
(0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))),
(((c))))) : char_table_ref (((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))),
(((c))))) : char_table_ref ((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])),
((c)))))) : encode_char ((charset), (c)) != (charset)->invalid_code)))); if
(charset_map_loaded && (offset = coding_change_destination (coding))) { dst
+= offset; dst_end += offset; } } while (0);
        if (result)
    code = (((!!sizeof (struct { unsigned int _gl_verify_error_if_negative:
(sizeof (c) <= sizeof (int)) ? 1 : -1; })) ? (((((sizeof ((c) + 0)) >
(sizeof ((0x80) + 0)) ? (sizeof ((c) + 0)) : (sizeof ((0x80) + 0))) <=
sizeof (unsigned) ? ((c) + (unsigned) 0) < ((0x80) + (unsigned) 0) : ((c) +
(unsigned long) 0) < ((0x80) + (unsigned long) 0)) &&
(charset)->ascii_compatible_p ? (unsigned) (c) : ((charset)->unified_p ||
(charset)->method == CHARSET_METHOD_SUBSET || (charset)->method ==
CHARSET_METHOD_SUPERSET) ? encode_char (charset, c) : (c) <
(charset)->min_char || (c) > (charset)->max_char ? (charset)->invalid_code
: (charset)->method == CHARSET_METHOD_OFFSET ? ((charset)->code_linear_p ?
(unsigned) ((c) - (charset)->code_offset) + (charset)->min_code :
encode_char (charset, c)) : (charset)->method == CHARSET_METHOD_MAP ?
(((charset)->compact_codes_p && ((((enum Lisp_Type) ((EMACS_UINT)
((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((((void) (0 &&
((((enum Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) (((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))) ? (charset_work =
((((sizeof ((c) + 0)) > (sizeof ((0x80) + 0)) ? (sizeof ((c) + 0)) :
(sizeof ((0x80) + 0))) <= sizeof (unsigned) ? ((c) + (unsigned) 0) <
((0x80) + (unsigned) 0) : ((c) + (unsigned long) 0) < ((0x80) + (unsigned
long) 0)) ? (! (((((void) (0 && (((((enum Lisp_Type) ((EMACS_UINT)
(((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((((void) (0 &&
((((enum Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii) == (Qnil)) ? (!
((((enum Lisp_Type) ((EMACS_UINT) (((((void) (0 && (((((enum Lisp_Type)
((EMACS_UINT) (((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct
sp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii)) >> VALBITS)) ==
Lisp_Vectorlike) && ((((struct vectorlike_header *) ((uintptr_t)
((((((void) (0 && (((((enum Lisp_Type) ((EMACS_UINT) (((((((void) (0 &&
((((enum Lisp_Type) ((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii) & (2147483647L >> (3
- 1))) | DATA_SEG_BITS)))->size & ((2147483647 - 2147483647 / 2) |
PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) | ((PVEC_SUB_CHAR_TABLE)
<< PSEUDOVECTOR_SIZE_BITS)))) ? (((void) (0 && (((((enum Lisp_Type)
((EMACS_UINT) (((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])
)) & (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii : ! (((((void) (0
&& (((((enum Lisp_Type) ((EMACS_UINT) (((((void) (0 && (((((enum Lisp_Type)
((EMACS_UINT) (((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii)) >> VALBITS)) ==
Lisp_Vectorlike) && ((((struct vectorlike_header *) ((uintptr_t)
((((((void) (0 && (((((enum Lisp_Type) ((EMACS_UINT) (((((((void) (0 &&
((((enum Lisp_Type) ((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii) & (2147483647L >> (3
- 1))) | DATA_SEG_BITS)))->size & ((2147483647 - 2147483647 / 2) |
PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) | ((PVEC_SUB_CHAR_TABLE)
<< PSEUDOVECTOR_SIZE_BITS))))))), ((struct Lisp_Sub_Char_Table *)
((uintptr_t) ((((((void) (0 && (((((enum Lisp_Type) ((EMACS_UINT)
(((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((((void) (0 &&
((((enum Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vec
torlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii) & (2147483647L >> (3
- 1))) | DATA_SEG_BITS))))->contents[(c)]) == (Qnil)) ? (((void) (0 &&
(((((enum Lisp_Type) ((EMACS_UINT) (((((void) (0 && (((((enum Lisp_Type)
((EMACS_UINT) (((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii)) >> VALBITS)) ==
Lisp_Vectorlike) && ((((struct vectorlike_header *) ((uintptr_t)
((((((void) (0 && (((((enum Lisp_Type) ((EMACS_UINT) (((((((void) (0 &&
((((enum Lisp_Type) ((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((E
MACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii) & (2147483647L >> (3
- 1))) | DATA_SEG_BITS)))->size & ((2147483647 - 2147483647 / 2) |
PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) | ((PVEC_SUB_CHAR_TABLE)
<< PSEUDOVECTOR_SIZE_BITS))))))), ((struct Lisp_Sub_Char_Table *)
((uintptr_t) ((((((void) (0 && (((((enum Lisp_Type) ((EMACS_UINT)
(((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((((void) (0 &&
((((enum Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii) & (2147483647L >> (3
- 1))) | DATA_SEG_BITS))))->contents[(c)] : char_table_ref (((((((void) (0
&& ((((enum Lisp_Type) ((EMACS_UINT) ((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))),
((c)))) : char_table_ref (((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))),
((c)))) : char_table_ref ((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])),
(c))), (((charset_work) == (Qnil)) ? (charset)->invalid_code : (unsigned)
((charset_work) + 0))) : encode_char (charset, c)) : encode_char (charset,
c))) : (((((sizeof ((c) + 0)) > (sizeof ((0x80) + 0)) ? (sizeof ((c) + 0))
: (sizeof ((0x80) + 0))) <= sizeof (unsigned) ? ((c) + (unsigned) 0) <
((0x80) + (unsigned) 0) : ((c) + (unsigned long) 0) < ((0x80) + (unsigned
long) 0)) && (charset)->ascii_compatible_p ? (unsigned) (c) :
((charset)->unified_p || (charset)->method == CHARSET_METHOD_SUBSET ||
(charset)->method == CHARSET_METHOD_SUPERSET) ? encode_char (charset, c) :
(c) < (charset)->min_char || (c) > (charset)->max_char ?
(charset)->invalid_code : (charset)->method == CHARSET_METHOD_OFFSET ?
((charset)->code_linear_p ? (unsigned) ((c) - (charset)->code_offset) +
(charset)->min_code : encode_char (charset, c)) : (charset)->method ==
CHARSET_METHOD_MAP ? (((charset)->compact_codes_p && ((((enum Lisp_Type)
((EMACS_UINT) ((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lis
p_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 &&
((((enum Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) (((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))) ? (charset_work =
((((sizeof ((c) + 0)) > (sizeof ((0x80) + 0)) ? (sizeof ((c) + 0)) :
(sizeof ((0x80) + 0))) <= sizeof (unsigned) ? ((c) + (unsigned) 0) <
((0x80) + (unsigned) 0) : ((c) + (unsigned long) 0) < ((0x80) + (unsigned
long) 0)) ? (! (((((void) (0 && (((((enum Lisp_Type) ((EMACS_UINT)
(((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((((void) (0 &&
((((enum Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii) == (Qnil)) ? (!
((((enum Lisp_Type) ((EMACS_UINT) (((((void) (0 && (((((enum Lisp_Type)
((EMACS_UINT) (((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct
 Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii)) >> VALBITS)) ==
Lisp_Vectorlike) && ((((struct vectorlike_header *) ((uintptr_t)
((((((void) (0 && (((((enum Lisp_Type) ((EMACS_UINT) (((((((void) (0 &&
((((enum Lisp_Type) ((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii) & (2147483647L >> (3
- 1))) | DATA_SEG_BITS)))->size & ((2147483647 - 2147483647 / 2) |
PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) | ((PVEC_SUB_CHAR_TABLE)
<< PSEUDOVECTOR_SIZE_BITS)))) ? (((void) (0 && (((((enum Lisp_Type)
((EMACS_UINT) (((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii : ! (((((void) (0 &&
(((((enum Lisp_Type) ((EMACS_UINT) (((((void) (0 && (((((enum Lisp_Type)
((EMACS_UINT) (((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enu
m Lisp_Type) ((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii)) >> VALBITS)) ==
Lisp_Vectorlike) && ((((struct vectorlike_header *) ((uintptr_t)
((((((void) (0 && (((((enum Lisp_Type) ((EMACS_UINT) (((((((void) (0 &&
((((enum Lisp_Type) ((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii) & (2147483647L >> (3
- 1))) | DATA_SEG_BITS)))->size & ((2147483647 - 2147483647 / 2) |
PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) | ((PVEC_SUB_CHAR_TABLE)
<< PSEUDOVECTOR_SIZE_BITS))))))), ((struct Lisp_Sub_Char_Table *)
((uintptr_t) ((((((void) (0 && (((((enum Lisp_Type) ((EMACS_UINT)
(((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((((void) (0 &&
((((enum Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((u
intptr_t) (((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii) & (2147483647L >> (3
- 1))) | DATA_SEG_BITS))))->contents[(c)]) == (Qnil)) ? (((void) (0 &&
(((((enum Lisp_Type) ((EMACS_UINT) (((((void) (0 && (((((enum Lisp_Type)
((EMACS_UINT) (((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii)) >> VALBITS)) ==
Lisp_Vectorlike) && ((((struct vectorlike_header *) ((uintptr_t)
((((((void) (0 && (((((enum Lisp_Type) ((EMACS_UINT) (((((((void) (0 &&
((((enum Lisp_Type) ((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii) & (2147483647L >> (3
- 1))) | DATA_SEG_BITS)))->size & ((2147483647 - 2147483647 / 2) |
PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) | ((PVEC_SUB_CHAR_TABLE)
<< PSEUDOVECTOR_SIZE_BITS))))))), ((struct Lisp_Sub_Char_Table *)
((uintptr_t) ((((((void) (0 && (((((enum Lisp_Type) ((EMACS_UINT)
(((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((((void) (0 &&
((((enum Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (st
ruct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))))
>> VALBITS)) == Lisp_Vectorlike) && ((((struct vectorlike_header *)
((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->size & ((2147483647 -
2147483647 / 2) | PVEC_TYPE_MASK)) == ((2147483647 - 2147483647 / 2) |
((PVEC_CHAR_TABLE) << PSEUDOVECTOR_SIZE_BITS))))))), (struct
Lisp_Char_Table *) ((uintptr_t) ((((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])))
& (2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->ascii) & (2147483647L >> (3
- 1))) | DATA_SEG_BITS))))->contents[(c)] : char_table_ref (((((((void) (0
&& ((((enum Lisp_Type) ((EMACS_UINT) ((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1]))))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT) ((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) ==
Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t) (((((((struct
Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) & (2147483647L >>
(3 - 1))) | DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1)))
| DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))),
((c)))) : char_table_ref (((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder]))),
((c)))) : char_table_ref ((((((void) (0 && ((((enum Lisp_Type)
((EMACS_UINT) ((((((((void) (0 && ((((enum Lisp_Type) ((EMACS_UINT)
((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value))) >>
VALBITS)) == Lisp_Vectorlike)))), (struct Lisp_Vector *) ((uintptr_t)
(((((((struct Lisp_Hash_Table *) ((uintptr_t) (((Vcharset_hash_table) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS))))->key_and_value)) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[2 *
((charset)->hash_index) + 1]))))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((((void) (0 && ((((enum
Lisp_Type) ((EMACS_UINT) ((((((struct Lisp_Hash_Table *) ((uintptr_t)
(((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value))) >> VALBITS)) == Lisp_Vectorlike)))),
(struct Lisp_Vector *) ((uintptr_t) (((((((struct Lisp_Hash_Table *)
((uintptr_t) (((Vcharset_hash_table) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS))))->key_and_value)) & (2147483647L >> (3 - 1))) |
DATA_SEG_BITS)))->contents[2 * ((charset)->hash_index) + 1])))) &
(2147483647L >> (3 - 1))) | DATA_SEG_BITS)))->contents[charset_encoder])),
(c))), (((charset_work) == (Qnil)) ? (charset)->invalid_code : (unsigned)
((charset_work) + 0))) : encode_char (charset, c)) : encode_char (charset,
c)))));

[-- Attachment #2: Type: text/html, Size: 153585 bytes --]

^ permalink raw reply	[flat|nested] 6+ messages in thread

* bug#14409: emacs 24.3 -- windows
  2013-05-16  2:31 bug#14409: emacs 24.3 -- windows Frank P Esposito
@ 2013-05-16  5:33 ` Eli Zaretskii
       [not found]   ` <CAFqEa-DnAzTTHDfSpt_OPxZ50UcV+7UPEvV49S_p1X=Fd7curA@mail.gmail.com>
                     ` (2 more replies)
  2017-08-09 23:13 ` npostavs
  1 sibling, 3 replies; 6+ messages in thread
From: Eli Zaretskii @ 2013-05-16  5:33 UTC (permalink / raw)
  To: Frank P Esposito; +Cc: 14409

> Date: Wed, 15 May 2013 22:31:48 -0400
> From: Frank P Esposito <fpesposito@gmail.com>
> 
> You need to fix the code, or  update the readme / install (text) files to
> note that this version of emacs  DOES NOT COMPILE with versions of visual
> studio that ARE NOT C99 compliant.

There was no intent to break compilation with Studio 2003.  It's just
that the number of people who use that seems to be vanishingly small,
and in particular none of them tried the pretest version and reported
problems.

> there are references to  defines that are  part of stdint.h (C99) --  you
> need to define them or not use them

We have a replacement stdint.h in nt/inc.  If something is missing
from there, please tell what that is.

> it seems that there is new code in  "charset.c charset.h" that have very
> complex macros that are imbedded in other complex macros
> that expand to something  like (see below)  which is impossible to debug --
> this is causing the error
> 
> coding.c
> coding.c(2604) : error C2065: 'value' : undeclared identifier
> coding.c(2604) : error C2143: syntax error : missing ':' before ')'
> coding.c(2604) : error C2059: syntax error : ')'
> coding.c(2604) : error C2059: syntax error : ')'
> coding.c(2604) : error C2059: syntax error : ')'
> coding.c(2604) : fatal error C1013: compiler limit : too many open
> parentheses

This is about CODING_CHAR_CHARSET, right?  But then I don't understand
the expansion you are showing, which starts with this:

>         charset = (charset_table + (preferred_charset_id));
>         do { ptrdiff_t offset; charset_map_loaded = 0; result = (((((sizeof
> ((c) + 0)) > (sizeof ((0x80) + 0)) ? (sizeof ((c) + 0)) : (sizeof ((0x80) +
> 0))) <= sizeof (unsigned) ? ((c) + (unsigned) 0) < ((0x80) + (unsigned) 0)
> : ((c) + (unsigned long) 0) < ((0x80) + (unsigned long) 0)) &&

I see no "result = ...", or anything that could expand into it, the
definition of CODING_CHAR_CHARSET.  What am I missing?

> I would be willing work to get this cleaned up  -- VC 7.1 supports inline
> functions

Please do, and thanks.  Just one request: try to keep the
MSVC-specific stuff separate, preferably somewhere under the nt/
directory (e.g., nt/inc/ms-w32.h) or in a clearly #ifdef'ed section at
the beginning of a .c or .h file in src/, so that these changes don't
make reading of the code harder.

Thanks.

^ permalink raw reply	[flat|nested] 6+ messages in thread

* bug#14409: emacs 24.3 -- windows
       [not found]   ` <CAFqEa-DnAzTTHDfSpt_OPxZ50UcV+7UPEvV49S_p1X=Fd7curA@mail.gmail.com>
@ 2013-05-16 17:37     ` Eli Zaretskii
  0 siblings, 0 replies; 6+ messages in thread
From: Eli Zaretskii @ 2013-05-16 17:37 UTC (permalink / raw)
  To: Frank P Esposito; +Cc: 14409


[Please keep the bug address on the CC list.]

> Date: Thu, 16 May 2013 10:45:44 -0400
> From: Frank P Esposito <fpesposito@gmail.com>
> 
> There is an option for MS C   “/P” which will save the pre-processor output
> to a “*.i” file –
> When I open the *.i file, – I think it was actually in the codeset.i file
> – there were lines of expanded macros – so what I included in the email
> probable was not all the expanded code –

I guess you mean charset.i.  Anyway, I will need your help with
finding out what exactly causes Studio 2003 to fail, as I don't have
that installed.  Please find out what part of the macro-expanded
source causes trouble and post it here.

> As noted, Its not clear to me how this would be any faster than using
> inline functions if supported by the compiler — as to the error  – are the
> later version of MS/C compilers support this level of open  parentheses?

Evidently, yes, because a couple of people who regularly build Emacs
with newer versions of MSVC didn't complain.

> I found a reference to SIZE_MAX which is defined in stdint.h (C99) and I
> see that the stdint.h in the nt section does not have this define.

I now added SIZE_MAX to nt/inc/stdint.h.

> It is not clear to me the best way to handle the macros.  The tedious part
> if trying to figure out the data type of the variables not defined in the
> macro

Why is the data type important?

> – what is the thinking for making loops in the form
> 
> do { ...... } while(0)
> 
> why not just { .... }

Because the former can be followed by a semi-colon in any context,
like in an if or a while, while the latter will cause compilation
errors.

> There was an issue with linking – I had to set USE_CRT_DLL=0 then the test
> for this in the make file was incorrect (nmake.defs line 119)  – I was
> missing the $ before the name for the test

Please tell the details about this, I don't think I understand
completely what was the problem.






^ permalink raw reply	[flat|nested] 6+ messages in thread

* bug#14409: emacs 24.3 -- windows
       [not found]   ` <CAFqEa-Af=1qxv-R73CKVAJteD2mG8GG3zzUGCOxgLPBh6k_zWw@mail.gmail.com>
@ 2013-05-16 18:42     ` Eli Zaretskii
  0 siblings, 0 replies; 6+ messages in thread
From: Eli Zaretskii @ 2013-05-16 18:42 UTC (permalink / raw)
  To: Frank P Esposito; +Cc: 14409


Once again, please keep the bug address on the list of addressees.

> Date: Thu, 16 May 2013 14:34:06 -0400
> From: Frank P Esposito <fpesposito@gmail.com>
> 
> nt\nmake.defs the text starting at line 119 or so,
> 
> 
> USE_CRT_DLL     = 1
> 
> !if USE_CRT_DLL
> libc            = msvcrt$(D).lib
> 
> 
> I think if the “!if” is checking for the value of  USE_CRT_DLL so it should
> read
> 
> !if $(USE_CRT_DLL)

Ah, OK.  This is already fixed in the development sources.

> I will also get you some more info on the linking issues

Thanks.

> for the macros vs inline function. If I have a define
> 
> #define MYFUNC( foo, bar )
> 
> and want to turn this is a a function signature I need to know the
> datatypes of
> foo and bar for the prototype, ie
> 
> void INLINE *f_myfunc( void *foo, void *bar ) { .... }
> #define MYFUNC( foo,bar ) f_myfunc( foo, bar )

I understand.  But I would like to avoid converting macros into
functions, as much as possible.  Let's first try to understand what
exactly the compiler doesn't like.

> About where the macro is failing, I guess that the old ms/c
> compilers have a limit to how complex the such expression can be, so
> if the project notes that visual c is supported from version 2, then
> the code would have to be written to the least common interface

Again, I'd like to see the macro that fails to compile, so far you
have shown me an expansion that I cannot compare with the original
source.

> Was there any thought on using open watcom c/c++

With GCC for Windows available, why would we go for Watcom?






^ permalink raw reply	[flat|nested] 6+ messages in thread

* bug#14409: emacs 24.3 -- windows
  2013-05-16  5:33 ` Eli Zaretskii
       [not found]   ` <CAFqEa-DnAzTTHDfSpt_OPxZ50UcV+7UPEvV49S_p1X=Fd7curA@mail.gmail.com>
       [not found]   ` <CAFqEa-Af=1qxv-R73CKVAJteD2mG8GG3zzUGCOxgLPBh6k_zWw@mail.gmail.com>
@ 2013-05-31  3:26   ` Frank P Esposito
  2 siblings, 0 replies; 6+ messages in thread
From: Frank P Esposito @ 2013-05-31  3:26 UTC (permalink / raw)
  To: Eli Zaretskii; +Cc: 14409

[-- Attachment #1: Type: text/plain, Size: 2699 bytes --]

Hello --

Were you able to debug the expanded macros with the i-files I sent to you?

here is a link to the i-file (in a zip)

http://db.tt/VYWpHtIP

Frank Esposito



On Thu, May 16, 2013 at 1:33 AM, Eli Zaretskii <eliz@gnu.org> wrote:

> > Date: Wed, 15 May 2013 22:31:48 -0400
> > From: Frank P Esposito <fpesposito@gmail.com>
> >
> > You need to fix the code, or  update the readme / install (text) files to
> > note that this version of emacs  DOES NOT COMPILE with versions of visual
> > studio that ARE NOT C99 compliant.
>
> There was no intent to break compilation with Studio 2003.  It's just
> that the number of people who use that seems to be vanishingly small,
> and in particular none of them tried the pretest version and reported
> problems.
>
> > there are references to  defines that are  part of stdint.h (C99) --  you
> > need to define them or not use them
>
> We have a replacement stdint.h in nt/inc.  If something is missing
> from there, please tell what that is.
>
> > it seems that there is new code in  "charset.c charset.h" that have very
> > complex macros that are imbedded in other complex macros
> > that expand to something  like (see below)  which is impossible to debug
> --
> > this is causing the error
> >
> > coding.c
> > coding.c(2604) : error C2065: 'value' : undeclared identifier
> > coding.c(2604) : error C2143: syntax error : missing ':' before ')'
> > coding.c(2604) : error C2059: syntax error : ')'
> > coding.c(2604) : error C2059: syntax error : ')'
> > coding.c(2604) : error C2059: syntax error : ')'
> > coding.c(2604) : fatal error C1013: compiler limit : too many open
> > parentheses
>
> This is about CODING_CHAR_CHARSET, right?  But then I don't understand
> the expansion you are showing, which starts with this:
>
> >         charset = (charset_table + (preferred_charset_id));
> >         do { ptrdiff_t offset; charset_map_loaded = 0; result =
> (((((sizeof
> > ((c) + 0)) > (sizeof ((0x80) + 0)) ? (sizeof ((c) + 0)) : (sizeof
> ((0x80) +
> > 0))) <= sizeof (unsigned) ? ((c) + (unsigned) 0) < ((0x80) + (unsigned)
> 0)
> > : ((c) + (unsigned long) 0) < ((0x80) + (unsigned long) 0)) &&
>
> I see no "result = ...", or anything that could expand into it, the
> definition of CODING_CHAR_CHARSET.  What am I missing?
>
> > I would be willing work to get this cleaned up  -- VC 7.1 supports inline
> > functions
>
> Please do, and thanks.  Just one request: try to keep the
> MSVC-specific stuff separate, preferably somewhere under the nt/
> directory (e.g., nt/inc/ms-w32.h) or in a clearly #ifdef'ed section at
> the beginning of a .c or .h file in src/, so that these changes don't
> make reading of the code harder.
>
> Thanks.
>

[-- Attachment #2: Type: text/html, Size: 3526 bytes --]

^ permalink raw reply	[flat|nested] 6+ messages in thread

* bug#14409: emacs 24.3 -- windows
  2013-05-16  2:31 bug#14409: emacs 24.3 -- windows Frank P Esposito
  2013-05-16  5:33 ` Eli Zaretskii
@ 2017-08-09 23:13 ` npostavs
  1 sibling, 0 replies; 6+ messages in thread
From: npostavs @ 2017-08-09 23:13 UTC (permalink / raw)
  To: Frank P Esposito; +Cc: 14409

tags 14409 wontfix
close 14409
quit

Frank P Esposito <fpesposito@gmail.com> writes:

> You need to fix the code, or update the readme / install (text) files
> to note that this version of emacs DOES NOT COMPILE with versions of
> visual studio that ARE NOT C99 compliant.

Emacs no longer supports building with Visual Studio.





^ permalink raw reply	[flat|nested] 6+ messages in thread

end of thread, other threads:[~2017-08-09 23:13 UTC | newest]

Thread overview: 6+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2013-05-16  2:31 bug#14409: emacs 24.3 -- windows Frank P Esposito
2013-05-16  5:33 ` Eli Zaretskii
     [not found]   ` <CAFqEa-DnAzTTHDfSpt_OPxZ50UcV+7UPEvV49S_p1X=Fd7curA@mail.gmail.com>
2013-05-16 17:37     ` Eli Zaretskii
     [not found]   ` <CAFqEa-Af=1qxv-R73CKVAJteD2mG8GG3zzUGCOxgLPBh6k_zWw@mail.gmail.com>
2013-05-16 18:42     ` Eli Zaretskii
2013-05-31  3:26   ` Frank P Esposito
2017-08-09 23:13 ` npostavs

Code repositories for project(s) associated with this public inbox

	https://git.savannah.gnu.org/cgit/emacs.git

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).