root/src/composite.h

INCLUDED FROM

DEFINITIONS

1. composition_registered_p
2. COMPOSITION_ENCODE_RULE_VALID
3. composition_method
4. composition_valid_p
5. lgstring_glyph_addr

     1 /* Header for composite sequence handler.
     2    Copyright (C) 2001-2023 Free Software Foundation, Inc.
     3    Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
     4      National Institute of Advanced Industrial Science and Technology (AIST)
     5      Registration Number H14PRO021
     6    Copyright (C) 2003, 2006
     7      National Institute of Advanced Industrial Science and Technology (AIST)
     8      Registration Number H13PRO009
     9 
    10 This file is part of GNU Emacs.
    11 
    12 GNU Emacs is free software: you can redistribute it and/or modify
    13 it under the terms of the GNU General Public License as published by
    14 the Free Software Foundation, either version 3 of the License, or (at
    15 your option) any later version.
    16 
    17 GNU Emacs is distributed in the hope that it will be useful,
    18 but WITHOUT ANY WARRANTY; without even the implied warranty of
    19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    20 GNU General Public License for more details.
    21 
    22 You should have received a copy of the GNU General Public License
    23 along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
    24 
    25 #ifndef EMACS_COMPOSITE_H
    26 #define EMACS_COMPOSITE_H
    27 
    28 #include "font.h"
    29 #include "dispextern.h"
    30 
    31 INLINE_HEADER_BEGIN
    32 
    33 /* Methods to display a sequence of components of a composition.  */
    34 enum composition_method {
    35   /* Compose relatively without alternate characters.  */
    36   COMPOSITION_RELATIVE,
    37   /* Compose by specified composition rules.  This is not used in
    38      Emacs 21 but we need it to decode files saved in the older
    39      versions of Emacs.  */
    40   COMPOSITION_WITH_RULE,
    41   /* Compose relatively with alternate characters.  */
    42   COMPOSITION_WITH_ALTCHARS,
    43   /* Compose by specified composition rules with alternate characters.  */
    44   COMPOSITION_WITH_RULE_ALTCHARS,
    45   /* This is not a method.  */
    46   COMPOSITION_NO
    47 };
    48 
    49 /* Maximum number of components a single composition can have.  */
    50 #define MAX_COMPOSITION_COMPONENTS 16
    51 
    52 /* These operations access information about a composition that
    53    has `composition' property PROP.  PROP is:
    54         ((LENGTH . COMPONENTS) . MODIFICATION-FUNC)
    55    or
    56         (COMPOSITION-ID . (LENGTH COMPONENTS . MODIFICATION-FUNC))
    57    They don't check validity of PROP.  */
    58 
    59 /* Return true if PROP is already registered.  */
    60 INLINE bool
    61 composition_registered_p (Lisp_Object prop)
    62 {
    63   return FIXNUMP (XCAR (prop));
    64 }
    65 
    66 /* Return ID number of the already registered composition.  */
    67 #define COMPOSITION_ID(prop) XFIXNUM (XCAR (prop))
    68 
    69 /* Return length of the composition.  */
    70 #define COMPOSITION_LENGTH(prop)        \
    71   (composition_registered_p (prop)      \
    72    ? XFIXNUM (XCAR (XCDR (prop)))               \
    73    : XFIXNUM (XCAR (XCAR (prop))))
    74 
    75 /* Return components of the composition.  */
    76 #define COMPOSITION_COMPONENTS(prop)    \
    77   (composition_registered_p (prop)      \
    78    ? XCAR (XCDR (XCDR (prop)))          \
    79    : XCDR (XCAR (prop)))
    80 
    81 /* Return modification function of the composition.  */
    82 #define COMPOSITION_MODIFICATION_FUNC(prop)     \
    83   (composition_registered_p (prop)              \
    84    ? XCDR (XCDR (XCDR (prop)))                  \
    85    : CONSP (prop) ? XCDR (prop) : Qnil)
    86 
    87 /* Return the Nth glyph of composition specified by CMP.  CMP is a
    88    pointer to `struct composition'.  */
    89 #define COMPOSITION_GLYPH(cmp, n)                                       \
    90   XFIXNUM (XVECTOR (XVECTOR (XHASH_TABLE (composition_hash_table)               \
    91                           ->key_and_value)                              \
    92                  ->contents[cmp->hash_index * 2])                       \
    93         ->contents[cmp->method == COMPOSITION_WITH_RULE_ALTCHARS        \
    94                   ? (n) * 2 : (n)])
    95 
    96 /* Return the encoded composition rule to compose the Nth glyph of
    97    rule-base composition specified by CMP.  CMP is a pointer to
    98    `struct composition'. */
    99 #define COMPOSITION_RULE(cmp, n)                                \
   100   XFIXNUM (XVECTOR (XVECTOR (XHASH_TABLE (composition_hash_table)       \
   101                           ->key_and_value)                      \
   102                  ->contents[cmp->hash_index * 2])               \
   103         ->contents[(n) * 2 - 1])
   104 
   105 /* Decode encoded composition rule RULE_CODE into GREF (global
   106    reference point code), NREF (new ref. point code).  Don't check RULE_CODE;
   107    always set GREF and NREF to valid values.  By side effect,
   108    RULE_CODE is modified.  */
   109 
   110 #define COMPOSITION_DECODE_REFS(rule_code, gref, nref)                  \
   111   do {                                                                  \
   112     rule_code &= 0xFF;                                                  \
   113     gref = (rule_code) / 12;                                            \
   114     if (gref > 12) gref = 11;                                           \
   115     nref = (rule_code) % 12;                                            \
   116   } while (false)
   117 
   118 /* Like COMPOSITION_DECODE_REFS (RULE_CODE, GREF, NREF), but also
   119    decode RULE_CODE into XOFF and YOFF (vertical offset).  */
   120 
   121 #define COMPOSITION_DECODE_RULE(rule_code, gref, nref, xoff, yoff)      \
   122   do {                                                                  \
   123     xoff = (rule_code) >> 16;                                           \
   124     yoff = ((rule_code) >> 8) & 0xFF;                                   \
   125     COMPOSITION_DECODE_REFS (rule_code, gref, nref);                    \
   126   } while (false)
   127 
   128 /* True if the global reference point GREF and new reference point NREF are
   129    valid.  */
   130 INLINE bool
   131 COMPOSITION_ENCODE_RULE_VALID (int gref, int nref)
   132 {
   133   return 0 <= gref && gref < 12 && 0 <= nref && nref < 12;
   134 }
   135 
   136 /* Return encoded composition rule for the pair of global reference
   137    point GREF and new reference point NREF.  Arguments must be valid.  */
   138 #define COMPOSITION_ENCODE_RULE(gref, nref)             \
   139   ((gref) * 12 + (nref))
   140 
   141 /* Data structure that records information about a composition
   142    currently used in some buffers or strings.
   143 
   144    When a composition is assigned an ID number (by
   145    get_composition_id), this structure is allocated for the
   146    composition and linked in composition_table[ID].
   147 
   148    Identical compositions appearing at different places have the same
   149    ID, and thus share the same instance of this structure.  */
   150 
   151 struct composition {
   152   /* Number of glyphs of the composition components.  */
   153   int glyph_len;
   154 
   155   /* Width, ascent, and descent pixels of the composition.  */
   156   short pixel_width, ascent, descent;
   157 
   158   short lbearing, rbearing;
   159 
   160   /* How many columns the overall glyphs occupy on the screen.  This
   161      gives an approximate value for column calculation in
   162      Fcurrent_column, and etc.  */
   163   int width;
   164 
   165   /* Method of the composition.  */
   166   enum composition_method method;
   167 
   168   /* Index to the composition hash table.  */
   169   ptrdiff_t hash_index;
   170 
   171   /* For which font we have calculated the remaining members.  The
   172      actual type is device dependent.  */
   173   void *font;
   174 
   175   /* Pointer to an array of x-offset and y-offset (by pixels) of
   176      glyphs.  This points to a sufficient memory space (sizeof (short) *
   177      glyph_len * 2) that is allocated when the composition is
   178      registered in composition_table.  X-offset and Y-offset of Nth
   179      glyph are (2N)th and (2N+1)th elements respectively.  */
   180   short *offsets;
   181 };
   182 
   183 /* Table of pointers to the structure `composition' indexed by
   184    COMPOSITION-ID.  */
   185 extern struct composition **composition_table;
   186 /* Number of the currently registered compositions.  */
   187 extern ptrdiff_t n_compositions;
   188 
   189 /* Mask bits for CHECK_MASK arg to update_compositions.
   190    For a change in the region FROM and TO, check compositions ... */
   191 #define CHECK_HEAD      1       /* adjacent to FROM */
   192 #define CHECK_TAIL      2       /* adjacent to TO */
   193 #define CHECK_INSIDE    4       /* between FROM and TO */
   194 #define CHECK_BORDER    (CHECK_HEAD | CHECK_TAIL)
   195 #define CHECK_ALL       (CHECK_BORDER | CHECK_INSIDE)
   196 
   197 extern Lisp_Object composition_hash_table;
   198 extern ptrdiff_t get_composition_id (ptrdiff_t, ptrdiff_t, ptrdiff_t,
   199                                      Lisp_Object, Lisp_Object);
   200 extern bool find_composition (ptrdiff_t, ptrdiff_t, ptrdiff_t *, ptrdiff_t *,
   201                               Lisp_Object *, Lisp_Object);
   202 extern void update_compositions (ptrdiff_t, ptrdiff_t, int);
   203 extern void make_composition_value_copy (Lisp_Object);
   204 extern void syms_of_composite (void);
   205 extern void compose_text (ptrdiff_t, ptrdiff_t, Lisp_Object, Lisp_Object,
   206                           Lisp_Object);
   207 
   208 /* Return the method of a composition with property PROP.  */
   209 
   210 INLINE enum composition_method
   211 composition_method (Lisp_Object prop)
   212 {
   213   if (composition_registered_p (prop))
   214     return composition_table[COMPOSITION_ID (prop)]->method;
   215   else
   216     {
   217       Lisp_Object temp = XCDR (XCAR (prop));
   218       return (NILP (temp)
   219               ? COMPOSITION_RELATIVE
   220               : FIXNUMP (temp) || STRINGP (temp)
   221               ? COMPOSITION_WITH_ALTCHARS
   222               : COMPOSITION_WITH_RULE_ALTCHARS);
   223     }
   224 }
   225 
   226 /* Given offsets START and END, return true if PROP is a valid composition
   227    property with length END - START.  */
   228 
   229 INLINE bool
   230 composition_valid_p (ptrdiff_t start, ptrdiff_t end, Lisp_Object prop)
   231 {
   232   return (CONSP (prop)
   233           && (composition_registered_p (prop)
   234               ? (COMPOSITION_ID (prop) >= 0
   235                  && COMPOSITION_ID (prop) <= n_compositions
   236                  && CONSP (XCDR (prop)))
   237               : (CONSP (XCAR (prop))
   238                   && (NILP (XCDR (XCAR (prop)))
   239                       || STRINGP (XCDR (XCAR (prop)))
   240                       || VECTORP (XCDR (XCAR (prop)))
   241                       || FIXNUMP (XCDR (XCAR (prop)))
   242                       || CONSP (XCDR (XCAR (prop))))))
   243           && COMPOSITION_LENGTH (prop) == end - start);
   244 }
   245 
   246 /* Macros for lispy glyph-string.  This is completely different from
   247    struct glyph_string.  */
   248 
   249 /* LGSTRING is a string of font glyphs, LGLYPHs.  It is represented as
   250    a Lisp vector, with components shown below.  Once LGSTRING was
   251    processed by a shaping engine, it holds font glyphs for one or more
   252    grapheme clusters.  */
   253 
   254 #define LGSTRING_HEADER(lgs) AREF (lgs, 0)
   255 #define LGSTRING_SET_HEADER(lgs, header) ASET (lgs, 0, header)
   256 
   257 /* LGSTRING_FONT retrieves the font used for LGSTRING, if we are going
   258    to display it on a GUI frame.  On text-mode frames, that slot
   259    stores the coding-system that should be used to write output to the
   260    frame's terminal.  */
   261 #define LGSTRING_FONT(lgs) AREF (LGSTRING_HEADER (lgs), 0)
   262 #define LGSTRING_CHAR(lgs, i) AREF (LGSTRING_HEADER (lgs), (i) + 1)
   263 #define LGSTRING_CHAR_LEN(lgs) (ASIZE (LGSTRING_HEADER (lgs)) - 1)
   264 
   265 #define LGSTRING_SET_FONT(lgs, val) ASET (LGSTRING_HEADER (lgs), 0, (val))
   266 #define LGSTRING_SET_CHAR(lgs, i, c) ASET (LGSTRING_HEADER (lgs), (i) + 1, (c))
   267 
   268 #define LGSTRING_ID(lgs) AREF (lgs, 1)
   269 #define LGSTRING_SET_ID(lgs, id) ASET (lgs, 1, id)
   270 
   271 /* LGSTRING_GLYPH_LEN is the maximum number of LGLYPHs that the
   272    LGSTRING can hold.  This is NOT the actual number of valid LGLYPHs;
   273    to find the latter, walk the glyphs returned by LGSTRING_GLYPH
   274    until the first one that is nil.  */
   275 #define LGSTRING_GLYPH_LEN(lgs) (ASIZE ((lgs)) - 2)
   276 #define LGSTRING_GLYPH(lgs, idx) AREF ((lgs), (idx) + 2)
   277 #define LGSTRING_SET_GLYPH(lgs, idx, val) ASET ((lgs), (idx) + 2, (val))
   278 INLINE Lisp_Object *
   279 lgstring_glyph_addr (Lisp_Object lgs, ptrdiff_t idx)
   280 {
   281   return aref_addr (lgs, idx + 2);
   282 }
   283 
   284 /* Vector size of Lispy glyph.  */
   285 enum lglyph_indices
   286   {
   287     LGLYPH_IX_FROM, LGLYPH_IX_TO,  LGLYPH_IX_CHAR, LGLYPH_IX_CODE,
   288     LGLYPH_IX_WIDTH, LGLYPH_IX_LBEARING, LGLYPH_IX_RBEARING,
   289     LGLYPH_IX_ASCENT, LGLYPH_IX_DESCENT, LGLYPH_IX_ADJUSTMENT,
   290     /* Not an index.  */
   291     LGLYPH_SIZE
   292   };
   293 
   294 /* Each LGLYPH is a single font glyph, whose font code is in
   295    LGLYPH_CODE.
   296    LGLYPH_FROM and LGLYPH_TO are indices into LGSTRING; all the
   297    LGLYPHs that share the same values of LGLYPH_FROM and LGLYPH_TO
   298    belong to the same grapheme cluster.
   299    LGLYPH_CHAR is one of the characters, usually the first one, that
   300    contributed to the glyph (since there isn't a 1:1 correspondence
   301    between composed characters and the font glyphs).  */
   302 #define LGLYPH_NEW() make_nil_vector (LGLYPH_SIZE)
   303 #define LGLYPH_FROM(g) XFIXNUM (AREF ((g), LGLYPH_IX_FROM))
   304 #define LGLYPH_TO(g) XFIXNUM (AREF ((g), LGLYPH_IX_TO))
   305 #define LGLYPH_CHAR(g) XFIXNUM (AREF ((g), LGLYPH_IX_CHAR))
   306 #define LGLYPH_CODE(g)                                          \
   307   (NILP (AREF ((g), LGLYPH_IX_CODE))                            \
   308    ? FONT_INVALID_CODE                                          \
   309    : cons_to_unsigned (AREF (g, LGLYPH_IX_CODE), TYPE_MAXIMUM (unsigned)))
   310 #define LGLYPH_WIDTH(g) XFIXNUM (AREF ((g), LGLYPH_IX_WIDTH))
   311 #define LGLYPH_LBEARING(g) XFIXNUM (AREF ((g), LGLYPH_IX_LBEARING))
   312 #define LGLYPH_RBEARING(g) XFIXNUM (AREF ((g), LGLYPH_IX_RBEARING))
   313 #define LGLYPH_ASCENT(g) XFIXNUM (AREF ((g), LGLYPH_IX_ASCENT))
   314 #define LGLYPH_DESCENT(g) XFIXNUM (AREF ((g), LGLYPH_IX_DESCENT))
   315 #define LGLYPH_ADJUSTMENT(g) AREF ((g), LGLYPH_IX_ADJUSTMENT)
   316 #define LGLYPH_SET_FROM(g, val) ASET ((g), LGLYPH_IX_FROM, make_fixnum (val))
   317 #define LGLYPH_SET_TO(g, val) ASET ((g), LGLYPH_IX_TO, make_fixnum (val))
   318 #define LGLYPH_SET_CHAR(g, val) ASET ((g), LGLYPH_IX_CHAR, make_fixnum (val))
   319 /* Callers must assure that VAL is not negative!  */
   320 #define LGLYPH_SET_CODE(g, val)                                         \
   321   ASET (g, LGLYPH_IX_CODE,                                              \
   322         val == FONT_INVALID_CODE ? Qnil : INT_TO_INTEGER (val))
   323 
   324 #define LGLYPH_SET_WIDTH(g, val) ASET ((g), LGLYPH_IX_WIDTH, make_fixnum (val))
   325 #define LGLYPH_SET_LBEARING(g, val) ASET ((g), LGLYPH_IX_LBEARING, make_fixnum (val))
   326 #define LGLYPH_SET_RBEARING(g, val) ASET ((g), LGLYPH_IX_RBEARING, make_fixnum (val))
   327 #define LGLYPH_SET_ASCENT(g, val) ASET ((g), LGLYPH_IX_ASCENT, make_fixnum (val))
   328 #define LGLYPH_SET_DESCENT(g, val) ASET ((g), LGLYPH_IX_DESCENT, make_fixnum (val))
   329 #define LGLYPH_SET_ADJUSTMENT(g, val) ASET ((g), LGLYPH_IX_ADJUSTMENT, (val))
   330 
   331 #define LGLYPH_XOFF(g) (VECTORP (LGLYPH_ADJUSTMENT (g)) \
   332                         ? XFIXNUM (AREF (LGLYPH_ADJUSTMENT (g), 0)) : 0)
   333 #define LGLYPH_YOFF(g) (VECTORP (LGLYPH_ADJUSTMENT (g)) \
   334                         ? XFIXNUM (AREF (LGLYPH_ADJUSTMENT (g), 1)) : 0)
   335 #define LGLYPH_WADJUST(g) (VECTORP (LGLYPH_ADJUSTMENT (g)) \
   336                            ? XFIXNUM (AREF (LGLYPH_ADJUSTMENT (g), 2)) : 0)
   337 
   338 extern Lisp_Object composition_gstring_put_cache (Lisp_Object, ptrdiff_t);
   339 extern Lisp_Object composition_gstring_from_id (ptrdiff_t);
   340 extern bool composition_gstring_p (Lisp_Object);
   341 extern int composition_gstring_width (Lisp_Object, ptrdiff_t, ptrdiff_t,
   342                                       struct font_metrics *);
   343 extern void composition_gstring_adjust_zero_width (Lisp_Object);
   344 
   345 extern bool find_automatic_composition (ptrdiff_t, ptrdiff_t, ptrdiff_t,
   346                                         ptrdiff_t *, ptrdiff_t *,
   347                                         Lisp_Object *, Lisp_Object);
   348 
   349 extern void composition_compute_stop_pos (struct composition_it *,
   350                                           ptrdiff_t, ptrdiff_t, ptrdiff_t,
   351                                           Lisp_Object, bool);
   352 extern bool composition_reseat_it (struct composition_it *, ptrdiff_t,
   353                                    ptrdiff_t, ptrdiff_t, struct window *,
   354                                    signed char, struct face *, Lisp_Object);
   355 extern int composition_update_it (struct composition_it *,
   356                                   ptrdiff_t, ptrdiff_t, Lisp_Object);
   357 
   358 extern ptrdiff_t composition_adjust_point (ptrdiff_t, ptrdiff_t);
   359 extern Lisp_Object composition_gstring_lookup_cache (Lisp_Object);
   360 
   361 extern void composition_gstring_cache_clear_font (Lisp_Object);
   362 
   363 INLINE_HEADER_END
   364 
   365 #endif /* not EMACS_COMPOSITE_H */