Changeset 3498

Show
Ignore:
Timestamp:
10/10/04 17:35:15 (4 years ago)
Author:
miyoshi
Message:

* charset.h: Sync up with Emacs CVS HEAD.

* data.c (Faset): Ditto.

* charset.c: Merge codes related with the changes in coding.h.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/2.2/src/ChangeLog.Meadow

    r3497 r3498  
     12004-10-10  MIYOSHI Masanori  <miyoshi@meadowy.org> 
     2 
     3        * charset.h: Sync up with Emacs CVS HEAD. 
     4 
     5        * data.c (Faset): Ditto. 
     6 
     7        * charset.c: Merge codes related with the changes in coding.h. 
     8 
    192004-10-10  MIYOSHI Masanori  <miyoshi@meadowy.org> 
    210 

  • branches/2.2/src/charset.c

    r3472 r3498  
    800800int 
    801801find_charset_in_text (ptr, nchars, nbytes, charsets, table) 
    802      unsigned char *ptr; 
     802     const unsigned char *ptr; 
    803803     int nchars, nbytes, *charsets; 
    804804     Lisp_Object table; 
    …… 
    808808      if (charsets && nbytes > 0) 
    809809        { 
    810           unsigned char *endp = ptr + nbytes; 
     810          const unsigned char *endp = ptr + nbytes; 
    811811          int maskbits = 0; 
    812812 
    …… 
    875875If the current buffer is unibyte, the returned list may contain 
    876876only `ascii', `eight-bit-control', and `eight-bit-graphic'.  */) 
    877   (beg, end, table) 
     877     (beg, end, table) 
    878878     Lisp_Object beg, end, table; 
    879879{ 
    …… 
    14931493void 
    14941494parse_str_as_multibyte (str, len, nchars, nbytes) 
    1495      unsigned char *str; 
     1495     const unsigned char *str; 
    14961496     int len, *nchars, *nbytes; 
    14971497{ 
    1498   unsigned char *endp = str + len; 
     1498  const unsigned char *endp = str + len; 
    14991499  int n, chars = 0, bytes = 0; 
    15001500 

  • branches/2.2/src/charset.h

    r3496 r3498  
    217217 
    218218/* 1 if C is a single byte character, else 0.  */ 
    219 #define SINGLE_BYTE_CHAR_P(c) ((unsigned) (c) < 0x100) 
     219#define SINGLE_BYTE_CHAR_P(c) (((unsigned)(c) & 0xFF) == (c)) 
    220220 
    221221/* 1 if BYTE is an ASCII character in itself, in multibyte mode.  */ 
    …… 
    438438 
    439439#define PARSE_MULTIBYTE_SEQ(str, length, bytes) \ 
    440   (bytes) = BYTES_BY_CHAR_HEAD ((str)[0]) 
     440  ((void)(length), (bytes) = BYTES_BY_CHAR_HEAD ((str)[0])) 
    441441 
    442442#endif /* not BYTE_COMBINING_DEBUG */ 
     443 
     444#define VALID_LEADING_CODE_P(code)      \ 
     445  (! NILP (CHARSET_TABLE_ENTRY (code))) 
    443446 
    444447/* Return 1 iff the byte sequence at unibyte string STR (LENGTH bytes) 
    …… 
    446449   set to the byte length of the multibyte form.  */ 
    447450 
    448 #define UNIBYTE_STR_AS_MULTIBYTE_P(str, length, bytes)  \ 
    449   (((str)[0] < 0x80 || (str)[0] >= 0xA0)                \ 
    450    ? (bytes) = 1                                        \ 
    451    : (((bytes) = BYTES_BY_CHAR_HEAD ((str)[0])),        \ 
    452       ((bytes) > 1 && (bytes) <= (length)               \ 
    453        && (str)[0] != LEADING_CODE_8_BIT_CONTROL        \ 
    454        && !CHAR_HEAD_P ((str)[1])                       \ 
    455        && ((bytes) == 2                                 \ 
    456            || (!CHAR_HEAD_P ((str)[2])                  \ 
    457                && ((bytes) == 3                         \ 
    458                    || !CHAR_HEAD_P ((str)[3]))))))) 
     451#define UNIBYTE_STR_AS_MULTIBYTE_P(str, length, bytes)          \ 
     452  (((str)[0] < 0x80 || (str)[0] >= 0xA0)                        \ 
     453   ? ((bytes) = 1)                                              \ 
     454   : (((bytes) = BYTES_BY_CHAR_HEAD ((str)[0])),                \ 
     455      ((bytes) <= (length)                                      \ 
     456       && !CHAR_HEAD_P ((str)[1])                               \ 
     457       && ((bytes) == 2                                         \ 
     458           ? (str)[0] != LEADING_CODE_8_BIT_CONTROL             \ 
     459           : (!CHAR_HEAD_P ((str)[2])                           \ 
     460              && ((bytes) == 3                                  \ 
     461                  ? (((str)[0] != LEADING_CODE_PRIVATE_11       \ 
     462                      && (str)[0] != LEADING_CODE_PRIVATE_12)   \ 
     463                     || VALID_LEADING_CODE_P (str[1]))          \ 
     464                  : (!CHAR_HEAD_P ((str)[3])                    \ 
     465                     && VALID_LEADING_CODE_P (str[1])))))))) 
     466 
    459467 
    460468/* Return 1 iff the byte sequence at multibyte string STR is valid as 
    …… 
    528536#define CHAR_STRING(c, str)                                               \ 
    529537  (SINGLE_BYTE_CHAR_P (c)                                                 \ 
    530    ? ((ASCII_BYTE_P (c) || c >= 0xA0)                                    \ 
     538   ? ((ASCII_BYTE_P (c) || c >= 0xA0)                     \ 
    531539      ? (*(str) = (unsigned char)(c), 1)                                  \ 
    532       : (*(str) = (unsigned char)LEADING_CODE_8_BIT_CONTROL,              \ 
    533          *((str)+ 1) = c + 0x20, 2))                                      \ 
     540      : (*(str) = (unsigned char)LEADING_CODE_8_BIT_CONTROL, *((str)+ 1) = c + 0x20, 2)) \ 
    534541   : char_to_string (c, (unsigned char *) str)) 
    535542 
    …… 
    575582    if (STRING_MULTIBYTE (STRING))                                         \ 
    576583      {                                                                    \ 
    577         unsigned char *ptr = &XSTRING (STRING)->data[BYTEIDX];                   \ 
    578         int space_left = XSTRING (STRING)->size_byte - BYTEIDX;                  \ 
     584        const unsigned char *ptr = SDATA (STRING) + BYTEIDX;             \ 
     585        int space_left = SBYTES (STRING) - BYTEIDX;                      \ 
    579586        int actual_len;                                                    \ 
    580587                                                                           \ 
    …… 
    583590      }                                                                    \ 
    584591    else                                                                   \ 
    585       OUTPUT = XSTRING (STRING)->data[BYTEIDX++];                        \ 
     592      OUTPUT = SREF (STRING, BYTEIDX++);                                 \ 
    586593  }                                                                        \ 
    587594else 
    …… 
    592599if (1)                                                                        \ 
    593600  {                                                                           \ 
    594     unsigned char *fetch_string_char_ptr = &XSTRING (STRING)->data[BYTEIDX];  \ 
    595     int fetch_string_char_space_left = XSTRING (STRING)->size_byte - BYTEIDX; \ 
     601    const unsigned char *fetch_string_char_ptr = SDATA (STRING) + BYTEIDX;    \ 
     602    int fetch_string_char_space_left = SBYTES (STRING) - BYTEIDX;            \ 
    596603    int actual_len;                                                           \ 
    597604                                                                              \ 
    …… 
    636643   : multibyte_form_length (str, len)) 
    637644 
     645/* If P is before LIMIT, advance P to the next character boundary.  It 
     646   assumes that P is already at a character boundary of the sane 
     647   mulitbyte form whose end address is LIMIT.  */ 
     648 
     649#define NEXT_CHAR_BOUNDARY(p, limit)    \ 
     650  do {                                  \ 
     651    if ((p) < (limit))                  \ 
     652      (p) += BYTES_BY_CHAR_HEAD (*(p)); \ 
     653  } while (0) 
     654 
     655 
     656/* If P is after LIMIT, advance P to the previous character boundary. 
     657   It assumes that P is already at a character boundary of the sane 
     658   mulitbyte form whose beginning address is LIMIT.  */ 
     659 
     660#define PREV_CHAR_BOUNDARY(p, limit)                                    \ 
     661  do {                                                                  \ 
     662    if ((p) > (limit))                                                  \ 
     663      {                                                                 \ 
     664        const unsigned char *p0 = (p);                                  \ 
     665        do {                                                            \ 
     666          p0--;                                                         \ 
     667        } while (p0 >= limit && ! CHAR_HEAD_P (*p0));                   \ 
     668        (p) = (BYTES_BY_CHAR_HEAD (*p0) == (p) - p0) ? p0 : (p) - 1;    \ 
     669      }                                                                 \ 
     670  } while (0) 
     671 
     672 
    638673#ifdef emacs 
    639674 
    …… 
    677712    pos_byte--;                                                         \ 
    678713    if (pos_byte < GPT_BYTE)                                            \ 
    679       p = BEG_ADDR + pos_byte - 1, p_min = BEG_ADDR;                  \ 
     714      p = BEG_ADDR + pos_byte - BEG_BYTE, p_min = BEG_ADDR;           \ 
    680715    else                                                                \ 
    681       p = BEG_ADDR + GAP_SIZE + pos_byte - 1, p_min = GAP_END_ADDR;    \ 
     716      p = BEG_ADDR + GAP_SIZE + pos_byte - BEG_BYTE, p_min = GAP_END_ADDR;\ 
    682717    if (p > p_min && !CHAR_HEAD_P (*p))                                 \ 
    683718      {                                                                 \ 
    684719        unsigned char *pend = p--;                                      \ 
    685720        int len, bytes;                                                 \ 
     721        if (p_min < p - MAX_MULTIBYTE_LENGTH)                           \ 
     722          p_min = p - MAX_MULTIBYTE_LENGTH;                             \ 
    686723        while (p > p_min && !CHAR_HEAD_P (*p)) p--;                     \ 
    687724        len = pend + 1 - p;                                             \ 
    …… 
    757794    if (pos_byte < BUF_GPT_BYTE (buf))                                  \ 
    758795      {                                                                 \ 
    759         p = BUF_BEG_ADDR (buf) + pos_byte - 1;                        \ 
     796        p = BUF_BEG_ADDR (buf) + pos_byte - BEG_BYTE;                 \ 
    760797        p_min = BUF_BEG_ADDR (buf);                                     \ 
    761798      }                                                                 \ 
    762799    else                                                                \ 
    763800      {                                                                 \ 
    764         p = BUF_BEG_ADDR (buf) + BUF_GAP_SIZE (buf) + pos_byte - 1;    \ 
     801        p = BUF_BEG_ADDR (buf) + BUF_GAP_SIZE (buf) + pos_byte - BEG_BYTE;\ 
    765802        p_min = BUF_GAP_END_ADDR (buf);                                 \ 
    766803      }                                                                 \ 
    …… 
    769806        unsigned char *pend = p--;                                      \ 
    770807        int len, bytes;                                                 \ 
     808        if (p_min < p - MAX_MULTIBYTE_LENGTH)                           \ 
     809          p_min = p - MAX_MULTIBYTE_LENGTH;                             \ 
    771810        while (p > p_min && !CHAR_HEAD_P (*p)) p--;                     \ 
    772811        len = pend + 1 - p;                                             \ 
    …… 
    792831extern int char_printable_p P_ ((int c)); 
    793832extern int multibyte_form_length P_ ((const unsigned char *, int)); 
    794 extern void parse_str_as_multibyte P_ ((unsigned char *, int, int *, int *)); 
     833extern void parse_str_as_multibyte P_ ((const unsigned char *, int, int *, 
     834                                        int *)); 
    795835extern int str_as_multibyte P_ ((unsigned char *, int, int, int *)); 
    796836extern int parse_str_to_multibyte P_ ((unsigned char *, int)); 
    …… 
    798838extern int str_as_unibyte P_ ((unsigned char *, int)); 
    799839extern int get_charset_id P_ ((Lisp_Object)); 
    800 extern int find_charset_in_text P_ ((unsigned char *, int, int, int *, 
     840extern int find_charset_in_text P_ ((const unsigned char *, int, int, int *, 
    801841                                    Lisp_Object)); 
    802842extern int strwidth P_ ((unsigned char *, int)); 
    …… 
    806846extern int char_valid_p P_ ((int, int)); 
    807847 
     848EXFUN (Funibyte_char_to_multibyte, 1); 
     849 
    808850extern Lisp_Object Vtranslation_table_vector; 
    809851 
    …… 
    829871 
    830872#endif /* EMACS_CHARSET_H */ 
     873 
     874/* arch-tag: 3b96db55-4961-481d-ac3e-219f46a2b3aa 
     875   (do not change this comment) */ 

  • branches/2.2/src/data.c

    r3488 r3498  
    20142014  else if (STRING_MULTIBYTE (array)) 
    20152015    { 
    2016       int idxval_byte, prev_bytes, new_bytes; 
     2016      int idxval_byte, prev_bytes, new_bytes, nbytes; 
    20172017      unsigned char workbuf[MAX_MULTIBYTE_LENGTH], *p0 = workbuf, *p1; 
    20182018 
    …… 
    20202020        args_out_of_range (array, idx); 
    20212021      CHECK_NUMBER (newelt); 
     2022 
     2023      nbytes = SBYTES (array); 
    20222024 
    20232025      idxval_byte = string_char_to_byte (array, idxval);