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

* character.c, charset.c, chartab.c: Use bool for booleans.

Browse source 
* character.c (lisp_string_width, string_count_byte8)
(string_escape_byte8):
* charset.c (charset_map_loaded, load_charset_map, read_hex):
(load_charset_map_from_file, map_charset_chars)
(Fdefine_charset_internal, define_charset_internal)
(Fdeclare_equiv_charset, find_charsets_in_text)
(Ffind_charset_region, char_charset, Fiso_charset):
* chartab.c (sub_char_table_ref, sub_char_table_ref_and_range)
(sub_char_table_set, sub_char_table_set_range)
(char_table_set_range, optimize_sub_char_table)
(map_sub_char_table):
Use bool for boolean.
* character.c (str_to_unibyte): Omit last boolean argument; it was
always 0.  All callers changed.
* character.h, charset.h: Adjust to match previous changes.
* character.h (char_printable_p): Remove decl of nonexistent function.
* charset.h (struct charset): Members code_linear_p, iso_chars_96,
ascii_compatible_p, supplementary_p, compact_codes_p, unified_p
are all boolean, so make them single-bit bitfields.
This commit is contained in:
Paul Eggert 2012-08-26 01:41:36 -07:00
parent 6af6451341
commit d5172d4fbc
6 changed files with 74 additions and 56 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
src/ChangeLog
View file

@ -1,5 +1,26 @@
2012-08-26 Paul Eggert <eggert@cs.ucla.edu>
* character.c, charset.c, chartab.c: Use bool for booleans.
* character.c (lisp_string_width, string_count_byte8)
(string_escape_byte8):
* charset.c (charset_map_loaded, load_charset_map, read_hex):
(load_charset_map_from_file, map_charset_chars)
(Fdefine_charset_internal, define_charset_internal)
(Fdeclare_equiv_charset, find_charsets_in_text)
(Ffind_charset_region, char_charset, Fiso_charset):
* chartab.c (sub_char_table_ref, sub_char_table_ref_and_range)
(sub_char_table_set, sub_char_table_set_range)
(char_table_set_range, optimize_sub_char_table)
(map_sub_char_table):
Use bool for boolean.
* character.c (str_to_unibyte): Omit last boolean argument; it was
always 0. All callers changed.
* character.h, charset.h: Adjust to match previous changes.
* character.h (char_printable_p): Remove decl of nonexistent function.
* charset.h (struct charset): Members code_linear_p, iso_chars_96,
ascii_compatible_p, supplementary_p, compact_codes_p, unified_p
are all boolean, so make them single-bit bitfields.
* lisp.h (ASET): Remove attempt to detect side effects.
It was meant to be temporary and it often doesn't work,
because when IDX has side effects the behavior of IDX==IDX

16
src/character.c
View file

@ -427,7 +427,7 @@ lisp_string_width (Lisp_Object string, ptrdiff_t precision,
/* This set multibyte to 0 even if STRING is multibyte when it
contains only ascii and eight-bit-graphic, but that's
intentional. */
int multibyte = len < SBYTES (string);
bool multibyte = len < SBYTES (string);
unsigned char *str = SDATA (string);
ptrdiff_t i = 0, i_byte = 0;
ptrdiff_t width = 0;
@ -765,13 +765,10 @@ str_as_unibyte (unsigned char *str, ptrdiff_t bytes)
corresponding byte and store in DST. CHARS is the number of
characters in SRC. The value is the number of bytes stored in DST.
Usually, the value is the same as CHARS, but is less than it if SRC
contains a non-ASCII, non-eight-bit character. If ACCEPT_LATIN_1
is nonzero, a Latin-1 character is accepted and converted to a byte
of that character code.
Note: Currently the arg ACCEPT_LATIN_1 is not used. */
contains a non-ASCII, non-eight-bit character. */
ptrdiff_t
str_to_unibyte (const unsigned char *src, unsigned char *dst, ptrdiff_t chars, int accept_latin_1)
str_to_unibyte (const unsigned char *src, unsigned char *dst, ptrdiff_t chars)
{
ptrdiff_t i;
@ -781,8 +778,7 @@ str_to_unibyte (const unsigned char *src, unsigned char *dst, ptrdiff_t chars, i
if (CHAR_BYTE8_P (c))
c = CHAR_TO_BYTE8 (c);
else if (! ASCII_CHAR_P (c)
&& (! accept_latin_1 || c >= 0x100))
else if (! ASCII_CHAR_P (c))
return i;
*dst++ = c;
}
@ -793,7 +789,7 @@ str_to_unibyte (const unsigned char *src, unsigned char *dst, ptrdiff_t chars, i
static ptrdiff_t
string_count_byte8 (Lisp_Object string)
{
int multibyte = STRING_MULTIBYTE (string);
bool multibyte = STRING_MULTIBYTE (string);
ptrdiff_t nbytes = SBYTES (string);
unsigned char *p = SDATA (string);
unsigned char *pend = p + nbytes;
@ -825,7 +821,7 @@ string_escape_byte8 (Lisp_Object string)
{
ptrdiff_t nchars = SCHARS (string);
ptrdiff_t nbytes = SBYTES (string);
int multibyte = STRING_MULTIBYTE (string);
bool multibyte = STRING_MULTIBYTE (string);
ptrdiff_t byte8_count;
const unsigned char *src, *src_end;
unsigned char *dst;

3
src/character.h
View file

@ -676,7 +676,6 @@ extern int string_char (const unsigned char *,
const unsigned char **, int *);
extern int translate_char (Lisp_Object, int c);
extern int char_printable_p (int c);
extern void parse_str_as_multibyte (const unsigned char *,
ptrdiff_t, ptrdiff_t *, ptrdiff_t *);
extern ptrdiff_t count_size_as_multibyte (const unsigned char *, ptrdiff_t);
@ -685,7 +684,7 @@ extern ptrdiff_t str_as_multibyte (unsigned char *, ptrdiff_t, ptrdiff_t,
extern ptrdiff_t str_to_multibyte (unsigned char *, ptrdiff_t, ptrdiff_t);
extern ptrdiff_t str_as_unibyte (unsigned char *, ptrdiff_t);
extern ptrdiff_t str_to_unibyte (const unsigned char *, unsigned char *,
ptrdiff_t, int);
ptrdiff_t);
extern ptrdiff_t strwidth (const char *, ptrdiff_t);
extern ptrdiff_t c_string_width (const unsigned char *, ptrdiff_t, int,
ptrdiff_t *, ptrdiff_t *);

32
src/charset.c
View file

@ -215,7 +215,7 @@ static struct
/* Set to 1 to warn that a charset map is loaded and thus a buffer
text and a string data may be relocated. */
int charset_map_loaded;
bool charset_map_loaded;
struct charset_map_entries
{
@ -256,7 +256,7 @@ load_charset_map (struct charset *charset, struct charset_map_entries *entries,
{
Lisp_Object vec IF_LINT (= Qnil), table IF_LINT (= Qnil);
unsigned max_code = CHARSET_MAX_CODE (charset);
int ascii_compatible_p = charset->ascii_compatible_p;
bool ascii_compatible_p = charset->ascii_compatible_p;
int min_char, max_char, nonascii_min_char;
int i;
unsigned char *fast_map = charset->fast_map;
@ -423,7 +423,7 @@ load_charset_map (struct charset *charset, struct charset_map_entries *entries,
paying attention to comment character '#'. */
static inline unsigned
read_hex (FILE *fp, int *eof, int *overflow)
read_hex (FILE *fp, bool *eof, bool *overflow)
{
int c;
unsigned n;
@ -512,7 +512,7 @@ load_charset_map_from_file (struct charset *charset, Lisp_Object mapfile, int co
{
unsigned from, to, c;
int idx;
int eof = 0, overflow = 0;
bool eof = 0, overflow = 0;
from = read_hex (fp, &eof, &overflow);
if (eof)
@ -717,10 +717,8 @@ map_charset_chars (void (*c_function)(Lisp_Object, Lisp_Object), Lisp_Object fun
Lisp_Object arg, struct charset *charset, unsigned from, unsigned to)
{
Lisp_Object range;
int partial;
partial = (from > CHARSET_MIN_CODE (charset)
|| to < CHARSET_MAX_CODE (charset));
bool partial = (from > CHARSET_MIN_CODE (charset)
|| to < CHARSET_MAX_CODE (charset));
if (CHARSET_METHOD (charset) == CHARSET_METHOD_OFFSET)
{
@ -855,7 +853,7 @@ usage: (define-charset-internal ...) */)
struct charset charset;
int id;
int dimension;
int new_definition_p;
bool new_definition_p;
int nchars;
if (nargs != charset_arg_max)
@ -1250,7 +1248,7 @@ define_charset_internal (Lisp_Object name,
const char *code_space_chars,
unsigned min_code, unsigned max_code,
int iso_final, int iso_revision, int emacs_mule_id,
int ascii_compatible, int supplementary,
bool ascii_compatible, bool supplementary,
int code_offset)
{
const unsigned char *code_space = (const unsigned char *) code_space_chars;
@ -1448,7 +1446,7 @@ if CHARSET is designated instead. */)
(Lisp_Object dimension, Lisp_Object chars, Lisp_Object final_char, Lisp_Object charset)
{
int id;
int chars_flag;
bool chars_flag;
CHECK_CHARSET_GET_ID (charset, id);
check_iso_charset_parameter (dimension, chars, final_char);
@ -1499,7 +1497,9 @@ string_xstring_p (Lisp_Object string)
It may lookup a translation table TABLE if supplied. */
static void
find_charsets_in_text (const unsigned char *ptr, ptrdiff_t nchars, ptrdiff_t nbytes, Lisp_Object charsets, Lisp_Object table, int multibyte)
find_charsets_in_text (const unsigned char *ptr, ptrdiff_t nchars,
ptrdiff_t nbytes, Lisp_Object charsets,
Lisp_Object table, bool multibyte)
{
const unsigned char *pend = ptr + nbytes;
@ -1549,7 +1549,7 @@ only `ascii', `eight-bit-control', and `eight-bit-graphic'. */)
ptrdiff_t from, from_byte, to, stop, stop_byte;
int i;
Lisp_Object val;
int multibyte = ! NILP (BVAR (current_buffer, enable_multibyte_characters));
bool multibyte = ! NILP (BVAR (current_buffer, enable_multibyte_characters));
validate_region (&beg, &end);
from = XFASTINT (beg);
@ -1735,7 +1735,7 @@ decode_char (struct charset *charset, unsigned int code)
/* Variable used temporarily by the macro ENCODE_CHAR. */
Lisp_Object charset_work;
/* Return a code-point of CHAR in CHARSET. If CHAR doesn't belong to
/* Return a code-point of C in CHARSET. If C doesn't belong to
CHARSET, return CHARSET_INVALID_CODE (CHARSET). If STRICT is true,
use CHARSET's strict_max_char instead of max_char. */
@ -1978,7 +1978,7 @@ is specified. */)
struct charset *
char_charset (int c, Lisp_Object charset_list, unsigned int *code_return)
{
int maybe_null = 0;
bool maybe_null = 0;
if (NILP (charset_list))
charset_list = Vcharset_ordered_list;
@ -2106,7 +2106,7 @@ DIMENSION, CHARS, and FINAL-CHAR. */)
(Lisp_Object dimension, Lisp_Object chars, Lisp_Object final_char)
{
int id;
int chars_flag;
bool chars_flag;
check_iso_charset_parameter (dimension, chars, final_char);
chars_flag = XFASTINT (chars) == 96;

39
src/charset.h
View file

@ -173,12 +173,24 @@ struct charset
check if a code-point is in a valid range. */
unsigned char *code_space_mask;
/* 1 if there's no gap in code-points. */
int code_linear_p;
/* True if there's no gap in code-points. */
unsigned code_linear_p : 1;
/* If the charset is treated as 94-chars in ISO-2022, the value is 0.
If the charset is treated as 96-chars in ISO-2022, the value is 1. */
int iso_chars_96;
/* True if the charset is treated as 96 chars in ISO-2022
as opposed to 94 chars. */
unsigned iso_chars_96 : 1;
/* True if the charset is compatible with ASCII. */
unsigned ascii_compatible_p : 1;
/* True if the charset is supplementary. */
unsigned supplementary_p : 1;
/* True if all the code points are representable by Lisp_Int. */
unsigned compact_codes_p : 1;
/* True if the charset is unified with Unicode. */
unsigned unified_p : 1;
/* ISO final byte of the charset: 48..127. It may be -1 if the
charset doesn't conform to ISO-2022. */
@ -192,15 +204,6 @@ struct charset
version. Otherwise, -1. */
int emacs_mule_id;
/* Nonzero if the charset is compatible with ASCII. */
int ascii_compatible_p;
/* Nonzero if the charset is supplementary. */
int supplementary_p;
/* Nonzero if all the code points are representable by Lisp_Int. */
int compact_codes_p;
/* The method for encoding/decoding characters of the charset. */
enum charset_method method;
@ -239,8 +242,6 @@ struct charset
/* Offset value to calculate a character code from code-point, and
visa versa. */
int code_offset;
int unified_p;
};
/* Hash table of charset symbols vs. the corresponding attribute
@ -456,7 +457,7 @@ extern Lisp_Object charset_work;
/* Set to 1 when a charset map is loaded to warn that a buffer text
and a string data may be relocated. */
extern int charset_map_loaded;
extern bool charset_map_loaded;
/* Set CHARSET to the charset highest priority of C, CODE to the
@ -474,10 +475,10 @@ extern int charset_map_loaded;
macro ISO_CHARSET_TABLE (DIMENSION, CHARS, FINAL_CHAR). */
extern int iso_charset_table[ISO_MAX_DIMENSION][ISO_MAX_CHARS][ISO_MAX_FINAL];
/* A charset of type iso2022 who has DIMENSION, CHARS, and FINAL
/* A charset of type iso2022 who has DIMENSION, CHARS_96, and FINAL
(final character). */
#define ISO_CHARSET_TABLE(dimension, chars_96, final) \
iso_charset_table[(dimension) - 1][(chars_96)][(final)]
iso_charset_table[(dimension) - 1][chars_96][final]
/* Nonzero if the charset who has FAST_MAP may contain C. */
#define CHARSET_FAST_MAP_REF(c, fast_map) \

19
src/chartab.c
View file

@ -200,7 +200,7 @@ copy_char_table (Lisp_Object table)
}
static Lisp_Object
sub_char_table_ref (Lisp_Object table, int c, int is_uniprop)
sub_char_table_ref (Lisp_Object table, int c, bool is_uniprop)
{
struct Lisp_Sub_Char_Table *tbl = XSUB_CHAR_TABLE (table);
int depth = XINT (tbl->depth);
@ -245,7 +245,7 @@ char_table_ref (Lisp_Object table, int c)
static Lisp_Object
sub_char_table_ref_and_range (Lisp_Object table, int c, int *from, int *to,
Lisp_Object defalt, int is_uniprop)
Lisp_Object defalt, bool is_uniprop)
{
struct Lisp_Sub_Char_Table *tbl = XSUB_CHAR_TABLE (table);
int depth = XINT (tbl->depth);
@ -320,7 +320,7 @@ char_table_ref_and_range (Lisp_Object table, int c, int *from, int *to)
struct Lisp_Char_Table *tbl = XCHAR_TABLE (table);
int chartab_idx = CHARTAB_IDX (c, 0, 0), idx;
Lisp_Object val;
int is_uniprop = UNIPROP_TABLE_P (table);
bool is_uniprop = UNIPROP_TABLE_P (table);
val = tbl->contents[chartab_idx];
if (*from < 0)
@ -382,7 +382,7 @@ char_table_ref_and_range (Lisp_Object table, int c, int *from, int *to)
static void
sub_char_table_set (Lisp_Object table, int c, Lisp_Object val, int is_uniprop)
sub_char_table_set (Lisp_Object table, int c, Lisp_Object val, bool is_uniprop)
{
struct Lisp_Sub_Char_Table *tbl = XSUB_CHAR_TABLE (table);
int depth = XINT ((tbl)->depth);
@ -438,7 +438,7 @@ char_table_set (Lisp_Object table, int c, Lisp_Object val)
static void
sub_char_table_set_range (Lisp_Object table, int from, int to, Lisp_Object val,
int is_uniprop)
bool is_uniprop)
{
struct Lisp_Sub_Char_Table *tbl = XSUB_CHAR_TABLE (table);
int depth = XINT ((tbl)->depth);
@ -484,7 +484,7 @@ char_table_set_range (Lisp_Object table, int from, int to, Lisp_Object val)
char_table_set (table, from, val);
else
{
int is_uniprop = UNIPROP_TABLE_P (table);
bool is_uniprop = UNIPROP_TABLE_P (table);
int lim = CHARTAB_IDX (to, 0, 0);
int i, c;
@ -683,7 +683,8 @@ optimize_sub_char_table (Lisp_Object table, Lisp_Object test)
struct Lisp_Sub_Char_Table *tbl = XSUB_CHAR_TABLE (table);
int depth = XINT (tbl->depth);
Lisp_Object elt, this;
int i, optimizable;
int i;
bool optimizable;
elt = XSUB_CHAR_TABLE (table)->contents[0];
if (SUB_CHAR_TABLE_P (elt))
@ -762,7 +763,7 @@ map_sub_char_table (void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object),
int chars_in_block;
int from = XINT (XCAR (range)), to = XINT (XCDR (range));
int i, c;
int is_uniprop = UNIPROP_TABLE_P (top);
bool is_uniprop = UNIPROP_TABLE_P (top);
uniprop_decoder_t decoder = UNIPROP_GET_DECODER (top);
if (SUB_CHAR_TABLE_P (table))
@ -811,7 +812,7 @@ map_sub_char_table (void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object),
this = XCHAR_TABLE (top)->defalt;
if (!EQ (val, this))
{
int different_value = 1;
bool different_value = 1;
if (NILP (val))
{