along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include <config.h>
+#include <float.h>
#include <stdio.h>
#include <ctype.h>
#include <setjmp.h>
static Lisp_Object QCuser_spec;
-/* Alist of font registry symbol and the corresponding charsets
+/* Alist of font registry symbols and the corresponding charset
information. The information is retrieved from
Vfont_encoding_alist on demand.
/* Return a Lispy value of a font property value at STR and LEN bytes.
- If STR is "*", it returns nil.
- If FORCE_SYMBOL is zero and all characters in STR are digits, it
- returns an integer. Otherwise, it returns a symbol interned from
+ If STR is "*", return nil.
+ If FORCE_SYMBOL is zero and all characters in STR are digits,
+ return an integer. Otherwise, return a symbol interned from
STR. */
Lisp_Object
-font_intern_prop (const char *str, int len, int force_symbol)
+font_intern_prop (const char *str, ptrdiff_t len, int force_symbol)
{
- int i;
+ ptrdiff_t i;
Lisp_Object tem;
Lisp_Object obarray;
- EMACS_INT nbytes, nchars;
+ ptrdiff_t nbytes, nchars;
if (len == 1 && *str == '*')
return Qnil;
- if (!force_symbol && len >=1 && isdigit (*str))
+ if (!force_symbol && 0 < len && '0' <= *str && *str <= '9')
{
for (i = 1; i < len; i++)
- if (! isdigit (str[i]))
+ if (! ('0' <= str[i] && str[i] <= '9'))
break;
if (i == len)
- return make_number (atoi (str));
+ {
+ EMACS_INT n;
+
+ i = 0;
+ for (n = 0; (n += str[i++] - '0') <= MOST_POSITIVE_FIXNUM; n *= 10)
+ {
+ if (i == len)
+ return make_number (n);
+ if (MOST_POSITIVE_FIXNUM / 10 < n)
+ break;
+ }
+
+ xsignal1 (Qoverflow_error, make_string (str, len));
+ }
}
/* The following code is copied from the function intern (in
- lread.c), and modified to suite our purpose. */
+ lread.c), and modified to suit our purpose. */
obarray = Vobarray;
if (!VECTORP (obarray) || ASIZE (obarray) == 0)
obarray = check_obarray (obarray);
font vector. If VAL is not valid (i.e. not registered in
font_style_table), return -1 if NOERROR is zero, and return a
proper index if NOERROR is nonzero. In that case, register VAL in
- font_style_table if VAL is a symbol, and return a closest index if
+ font_style_table if VAL is a symbol, and return the closest index if
VAL is an integer. */
int
else
{
int i, last_n;
- int numeric = XINT (val);
+ EMACS_INT numeric = XINT (val);
for (i = 0, last_n = -1; i < len; i++)
{
}
\f
-/* Font property value validaters. See the comment of
+/* Font property value validators. See the comment of
font_property_table for the meaning of the arguments. */
static Lisp_Object font_prop_validate (int, Lisp_Object, Lisp_Object);
: FONT_WIDTH_INDEX);
if (INTEGERP (val))
{
- int n = XINT (val);
+ EMACS_INT n = XINT (val);
if (((n >> 4) & 0xF)
>= ASIZE (AREF (font_style_table, prop - FONT_WEIGHT_INDEX)))
val = Qerror;
return val;
}
-/* Structure of known font property keys and validater of the
+/* Structure of known font property keys and validator of the
values. */
static const struct
{
};
-/* Parse P pointing the pixel/point size field of the form
+/* Parse P pointing to the pixel/point size field of the form
`[A B C D]' which specifies a transformation matrix:
A B 0
}
/* Expand a wildcard field in FIELD (the first N fields are filled) to
- multiple fields to fill in all 14 XLFD fields while restring a
+ multiple fields to fill in all 14 XLFD fields while restricting a
field position by its contents. */
static int
if (INTEGERP (val))
{
- int numeric = XINT (val);
+ EMACS_INT numeric = XINT (val);
if (i + 1 == n)
from = to = XLFD_ENCODING_INDEX,
int
font_parse_xlfd (char *name, Lisp_Object font)
{
- int len = strlen (name);
+ ptrdiff_t len = strlen (name);
int i, j, n;
char *f[XLFD_LAST_INDEX + 1];
Lisp_Object val;
char *p;
const char *f[XLFD_REGISTRY_INDEX + 1];
Lisp_Object val;
- int i, j, len = 0;
+ int i, j, len;
font_assert (FONTP (font));
if (NILP (val))
{
if (j == XLFD_REGISTRY_INDEX)
- f[j] = "*-*", len += 4;
+ f[j] = "*-*";
else
- f[j] = "*", len += 2;
+ f[j] = "*";
}
else
{
&& ! strchr (SSDATA (val), '-'))
{
/* Change "jisx0208*" and "jisx0208" to "jisx0208*-*". */
- if (SDATA (val)[SBYTES (val) - 1] == '*')
- {
- f[j] = p = alloca (SBYTES (val) + 3);
- sprintf (p, "%s-*", SDATA (val));
- len += SBYTES (val) + 3;
- }
- else
- {
- f[j] = p = alloca (SBYTES (val) + 4);
- sprintf (p, "%s*-*", SDATA (val));
- len += SBYTES (val) + 4;
- }
+ ptrdiff_t alloc = SBYTES (val) + 4;
+ if (nbytes <= alloc)
+ return -1;
+ f[j] = p = alloca (alloc);
+ sprintf (p, "%s%s-*", SDATA (val),
+ "*" + (SDATA (val)[SBYTES (val) - 1] == '*'));
}
else
- f[j] = SSDATA (val), len += SBYTES (val) + 1;
+ f[j] = SSDATA (val);
}
}
{
val = font_style_symbolic (font, i, 0);
if (NILP (val))
- f[j] = "*", len += 2;
+ f[j] = "*";
else
{
val = SYMBOL_NAME (val);
- f[j] = SSDATA (val), len += SBYTES (val) + 1;
+ f[j] = SSDATA (val);
}
}
font_assert (NUMBERP (val) || NILP (val));
if (INTEGERP (val))
{
- i = XINT (val);
- if (i <= 0)
- i = pixel_size;
- if (i > 0)
+ EMACS_INT v = XINT (val);
+ if (v <= 0)
+ v = pixel_size;
+ if (v > 0)
{
- f[XLFD_PIXEL_INDEX] = p = alloca (22);
- len += sprintf (p, "%d-*", i) + 1;
+ f[XLFD_PIXEL_INDEX] = p =
+ alloca (sizeof "-*" + INT_STRLEN_BOUND (EMACS_INT));
+ sprintf (p, "%"pI"d-*", v);
}
else
- f[XLFD_PIXEL_INDEX] = "*-*", len += 4;
+ f[XLFD_PIXEL_INDEX] = "*-*";
}
else if (FLOATP (val))
{
- i = XFLOAT_DATA (val) * 10;
- f[XLFD_PIXEL_INDEX] = p = alloca (12);
- len += sprintf (p, "*-%d", i) + 1;
+ double v = XFLOAT_DATA (val) * 10;
+ f[XLFD_PIXEL_INDEX] = p = alloca (sizeof "*-" + 1 + DBL_MAX_10_EXP + 1);
+ sprintf (p, "*-%.0f", v);
}
else
- f[XLFD_PIXEL_INDEX] = "*-*", len += 4;
+ f[XLFD_PIXEL_INDEX] = "*-*";
if (INTEGERP (AREF (font, FONT_DPI_INDEX)))
{
- i = XINT (AREF (font, FONT_DPI_INDEX));
- f[XLFD_RESX_INDEX] = p = alloca (22);
- len += sprintf (p, "%d-%d", i, i) + 1;
+ EMACS_INT v = XINT (AREF (font, FONT_DPI_INDEX));
+ f[XLFD_RESX_INDEX] = p =
+ alloca (sizeof "-" + 2 * INT_STRLEN_BOUND (EMACS_INT));
+ sprintf (p, "%"pI"d-%"pI"d", v, v);
}
else
- f[XLFD_RESX_INDEX] = "*-*", len += 4;
+ f[XLFD_RESX_INDEX] = "*-*";
if (INTEGERP (AREF (font, FONT_SPACING_INDEX)))
{
- int spacing = XINT (AREF (font, FONT_SPACING_INDEX));
+ EMACS_INT spacing = XINT (AREF (font, FONT_SPACING_INDEX));
f[XLFD_SPACING_INDEX] = (spacing <= FONT_SPACING_PROPORTIONAL ? "p"
: spacing <= FONT_SPACING_DUAL ? "d"
: spacing <= FONT_SPACING_MONO ? "m"
: "c");
- len += 2;
}
else
- f[XLFD_SPACING_INDEX] = "*", len += 2;
+ f[XLFD_SPACING_INDEX] = "*";
if (INTEGERP (AREF (font, FONT_AVGWIDTH_INDEX)))
{
- f[XLFD_AVGWIDTH_INDEX] = p = alloca (22);
- len += sprintf (p, "%"pI"d",
- XINT (AREF (font, FONT_AVGWIDTH_INDEX))) + 1;
+ f[XLFD_AVGWIDTH_INDEX] = p = alloca (INT_BUFSIZE_BOUND (EMACS_INT));
+ sprintf (p, "%"pI"d", XINT (AREF (font, FONT_AVGWIDTH_INDEX)));
}
else
- f[XLFD_AVGWIDTH_INDEX] = "*", len += 2;
- len++; /* for terminating '\0'. */
- if (len >= nbytes)
- return -1;
- return sprintf (name, "-%s-%s-%s-%s-%s-%s-%s-%s-%s-%s-%s",
+ f[XLFD_AVGWIDTH_INDEX] = "*";
+ len = snprintf (name, nbytes, "-%s-%s-%s-%s-%s-%s-%s-%s-%s-%s-%s",
f[XLFD_FOUNDRY_INDEX], f[XLFD_FAMILY_INDEX],
f[XLFD_WEIGHT_INDEX], f[XLFD_SLANT_INDEX],
f[XLFD_SWIDTH_INDEX], f[XLFD_ADSTYLE_INDEX],
f[XLFD_PIXEL_INDEX], f[XLFD_RESX_INDEX],
f[XLFD_SPACING_INDEX], f[XLFD_AVGWIDTH_INDEX],
f[XLFD_REGISTRY_INDEX]);
+ return len < nbytes ? len : -1;
}
/* Parse NAME (null terminated) and store information in FONT
char *p, *q;
char *size_beg = NULL, *size_end = NULL;
char *props_beg = NULL, *family_end = NULL;
- int len = strlen (name);
+ ptrdiff_t len = strlen (name);
if (len == 0)
return -1;
{
int decimal = 0, size_found = 1;
for (q = p + 1; *q && *q != ':'; q++)
- if (! isdigit(*q))
+ if (! isdigit (*q))
{
if (*q != '.' || decimal)
{
if (*q != '=')
{
/* Must be an enumerated value. */
- int word_len;
+ ptrdiff_t word_len;
p = p + 1;
word_len = q - p;
val = font_intern_prop (p, q - p, 1);
Lisp_Object weight = Qnil, slant = Qnil;
Lisp_Object width = Qnil, size = Qnil;
char *word_start;
- int word_len;
+ ptrdiff_t word_len;
/* Scan backwards from the end, looking for a size. */
for (p = name + len - 1; p >= name; p--)
font_unparse_fcname (Lisp_Object font, int pixel_size, char *name, int nbytes)
{
Lisp_Object family, foundry;
- Lisp_Object tail, val;
+ Lisp_Object val;
int point_size;
- int i, len = 1;
+ int i;
char *p;
+ char *lim;
Lisp_Object styles[3];
const char *style_names[3] = { "weight", "slant", "width" };
- char work[256];
family = AREF (font, FONT_FAMILY_INDEX);
if (! NILP (family))
{
if (SYMBOLP (family))
- {
- family = SYMBOL_NAME (family);
- len += SBYTES (family);
- }
+ family = SYMBOL_NAME (family);
else
family = Qnil;
}
if (XINT (val) != 0)
pixel_size = XINT (val);
point_size = -1;
- len += 21; /* for ":pixelsize=NUM" */
}
else
{
abort ();
pixel_size = -1;
point_size = (int) XFLOAT_DATA (val);
- len += 11; /* for "-NUM" */
}
foundry = AREF (font, FONT_FOUNDRY_INDEX);
if (! NILP (foundry))
{
if (SYMBOLP (foundry))
- {
- foundry = SYMBOL_NAME (foundry);
- len += 9 + SBYTES (foundry); /* ":foundry=NAME" */
- }
+ foundry = SYMBOL_NAME (foundry);
else
foundry = Qnil;
}
for (i = 0; i < 3; i++)
- {
- styles[i] = font_style_symbolic (font, FONT_WEIGHT_INDEX + i, 0);
- if (! NILP (styles[i]))
- len += sprintf (work, ":%s=%s", style_names[i],
- SDATA (SYMBOL_NAME (styles[i])));
- }
+ styles[i] = font_style_symbolic (font, FONT_WEIGHT_INDEX + i, 0);
- if (INTEGERP (AREF (font, FONT_DPI_INDEX)))
- len += sprintf (work, ":dpi=%"pI"d", XINT (AREF (font, FONT_DPI_INDEX)));
- if (INTEGERP (AREF (font, FONT_SPACING_INDEX)))
- len += strlen (":spacing=100");
- if (INTEGERP (AREF (font, FONT_AVGWIDTH_INDEX)))
- len += strlen (":scalable=false"); /* or ":scalable=true" */
- for (tail = AREF (font, FONT_EXTRA_INDEX); CONSP (tail); tail = XCDR (tail))
- {
- Lisp_Object key = XCAR (XCAR (tail)), value = XCDR (XCAR (tail));
-
- len += SBYTES (SYMBOL_NAME (key)) + 1; /* for :KEY= */
- if (STRINGP (value))
- len += SBYTES (value);
- else if (INTEGERP (value))
- len += sprintf (work, "%"pI"d", XINT (value));
- else if (SYMBOLP (value))
- len += (NILP (value) ? 5 : 4); /* for "false" or "true" */
- }
-
- if (len > nbytes)
- return -1;
p = name;
+ lim = name + nbytes;
if (! NILP (family))
- p += sprintf (p, "%s", SDATA (family));
+ {
+ int len = snprintf (p, lim - p, "%s", SSDATA (family));
+ if (! (0 <= len && len < lim - p))
+ return -1;
+ p += len;
+ }
if (point_size > 0)
{
- if (p == name)
- p += sprintf (p, "%d", point_size);
- else
- p += sprintf (p, "-%d", point_size);
+ int len = snprintf (p, lim - p, "-%d" + (p == name), point_size);
+ if (! (0 <= len && len < lim - p))
+ return -1;
+ p += len;
}
else if (pixel_size > 0)
- p += sprintf (p, ":pixelsize=%d", pixel_size);
+ {
+ int len = snprintf (p, lim - p, ":pixelsize=%d", pixel_size);
+ if (! (0 <= len && len < lim - p))
+ return -1;
+ p += len;
+ }
if (! NILP (AREF (font, FONT_FOUNDRY_INDEX)))
- p += sprintf (p, ":foundry=%s",
- SDATA (SYMBOL_NAME (AREF (font, FONT_FOUNDRY_INDEX))));
+ {
+ int len = snprintf (p, lim - p, ":foundry=%s",
+ SSDATA (SYMBOL_NAME (AREF (font,
+ FONT_FOUNDRY_INDEX))));
+ if (! (0 <= len && len < lim - p))
+ return -1;
+ p += len;
+ }
for (i = 0; i < 3; i++)
if (! NILP (styles[i]))
- p += sprintf (p, ":%s=%s", style_names[i],
- SDATA (SYMBOL_NAME (styles[i])));
+ {
+ int len = snprintf (p, lim - p, ":%s=%s", style_names[i],
+ SSDATA (SYMBOL_NAME (styles[i])));
+ if (! (0 <= len && len < lim - p))
+ return -1;
+ p += len;
+ }
+
if (INTEGERP (AREF (font, FONT_DPI_INDEX)))
- p += sprintf (p, ":dpi=%"pI"d", XINT (AREF (font, FONT_DPI_INDEX)));
+ {
+ int len = snprintf (p, lim - p, ":dpi=%"pI"d",
+ XINT (AREF (font, FONT_DPI_INDEX)));
+ if (! (0 <= len && len < lim - p))
+ return -1;
+ p += len;
+ }
+
if (INTEGERP (AREF (font, FONT_SPACING_INDEX)))
- p += sprintf (p, ":spacing=%"pI"d", XINT (AREF (font, FONT_SPACING_INDEX)));
+ {
+ int len = snprintf (p, lim - p, ":spacing=%"pI"d",
+ XINT (AREF (font, FONT_SPACING_INDEX)));
+ if (! (0 <= len && len < lim - p))
+ return -1;
+ p += len;
+ }
+
if (INTEGERP (AREF (font, FONT_AVGWIDTH_INDEX)))
{
- if (XINT (AREF (font, FONT_AVGWIDTH_INDEX)) == 0)
- p += sprintf (p, ":scalable=true");
- else
- p += sprintf (p, ":scalable=false");
+ int len = snprintf (p, lim - p,
+ (XINT (AREF (font, FONT_AVGWIDTH_INDEX)) == 0
+ ? ":scalable=true"
+ : ":scalable=false"));
+ if (! (0 <= len && len < lim - p))
+ return -1;
+ p += len;
}
+
return (p - name);
}
#define LGSTRING_GLYPH_SIZE 8
static int
-check_gstring (gstring)
- Lisp_Object gstring;
+check_gstring (Lisp_Object gstring)
{
Lisp_Object val;
- int i, j;
+ ptrdiff_t i;
+ int j;
CHECK_VECTOR (gstring);
val = AREF (gstring, 0);
}
static void
-check_otf_features (otf_features)
- Lisp_Object otf_features;
+check_otf_features (Lisp_Object otf_features)
{
Lisp_Object val;
Lisp_Object otf_list;
static Lisp_Object
-otf_tag_symbol (tag)
- OTF_Tag tag;
+otf_tag_symbol (OTF_Tag tag)
{
char name[5];
}
static OTF *
-otf_open (file)
- Lisp_Object file;
+otf_open (Lisp_Object file)
{
Lisp_Object val = Fassoc (file, otf_list);
OTF *otf;
(struct font_driver).otf_capability. */
Lisp_Object
-font_otf_capability (font)
- struct font *font;
+font_otf_capability (struct font *font)
{
OTF *otf;
Lisp_Object capability = Fcons (Qnil, Qnil);
FEATURES. */
static void
-generate_otf_features (spec, features)
- Lisp_Object spec;
- char *features;
+generate_otf_features (Lisp_Object spec, char *features)
{
Lisp_Object val;
char *p;
else if (! asterisk)
{
val = SYMBOL_NAME (val);
- p += sprintf (p, "%s", SDATA (val));
+ p += esprintf (p, "%s", SDATA (val));
}
else
{
val = SYMBOL_NAME (val);
- p += sprintf (p, "~%s", SDATA (val));
+ p += esprintf (p, "~%s", SDATA (val));
}
}
if (CONSP (spec))
}
Lisp_Object
-font_otf_DeviceTable (device_table)
- OTF_DeviceTable *device_table;
+font_otf_DeviceTable (OTF_DeviceTable *device_table)
{
int len = device_table->StartSize - device_table->EndSize + 1;
}
Lisp_Object
-font_otf_ValueRecord (value_format, value_record)
- int value_format;
- OTF_ValueRecord *value_record;
+font_otf_ValueRecord (int value_format, OTF_ValueRecord *value_record)
{
Lisp_Object val = Fmake_vector (make_number (8), Qnil);
}
Lisp_Object
-font_otf_Anchor (anchor)
- OTF_Anchor *anchor;
+font_otf_Anchor (OTF_Anchor *anchor)
{
Lisp_Object val;
font-spec. The score value is 32 bit (`unsigned'), and the smaller
the value is, the closer the font is to the font-spec.
- The lowest 2 bits of the score is used for driver type. The font
+ The lowest 2 bits of the score are used for driver type. The font
available by the most preferred font driver is 0.
- Each 7-bit in the higher 28 bits are used for numeric properties
+ The 4 7-bit fields in the higher 28 bits are used for numeric properties
WEIGHT, SLANT, WIDTH, and SIZE. */
/* How many bits to shift to store the difference value of each font
- property in a score. Note that flots for FONT_TYPE_INDEX and
+ property in a score. Note that floats for FONT_TYPE_INDEX and
FONT_REGISTRY_INDEX are not used. */
static int sort_shift_bits[FONT_SIZE_INDEX + 1];
{
/* We use the higher 6-bit for the actual size difference. The
lowest bit is set if the DPI is different. */
- int diff;
- int pixel_size = XINT (spec_prop[FONT_SIZE_INDEX]);
+ EMACS_INT diff;
+ EMACS_INT pixel_size = XINT (spec_prop[FONT_SIZE_INDEX]);
if (CONSP (Vface_font_rescale_alist))
pixel_size *= font_rescale_ratio (entity);
/* All characters in the list must be supported. */
for (; CONSP (val2); val2 = XCDR (val2))
{
- if (! NATNUMP (XCAR (val2)))
+ if (! CHARACTERP (XCAR (val2)))
continue;
if (font_encode_char (font, XFASTINT (XCAR (val2)))
== FONT_INVALID_CODE)
/* At most one character in the vector must be supported. */
for (i = 0; i < ASIZE (val2); i++)
{
- if (! NATNUMP (AREF (val2, i)))
+ if (! CHARACTERP (AREF (val2, i)))
continue;
if (font_encode_char (font, XFASTINT (AREF (val2, i)))
!= FONT_INVALID_CODE)
static Lisp_Object scratch_font_spec, scratch_font_prefer;
/* Check each font-entity in VEC, and return a list of font-entities
- that satisfy this condition:
+ that satisfy these conditions:
(1) matches with SPEC and SIZE if SPEC is not nil, and
(2) doesn't match with any regexps in Vface_ignored_fonts (if non-nil).
*/
attrs[LFACE_FONT_INDEX] = font;
}
-/* Selecte a font from ENTITIES (list of font-entity vectors) that
- supports C and matches best with ATTRS and PIXEL_SIZE. */
+/* Select a font from ENTITIES (list of font-entity vectors) that
+ supports C and is the best match for ATTRS and PIXEL_SIZE. */
static Lisp_Object
font_select_entity (Lisp_Object frame, Lisp_Object entities, Lisp_Object *attrs, int pixel_size, int c)
return font_sort_entities (entities, prefer, frame, c);
}
-/* Return a font-entity satisfying SPEC and best matching with face's
- font related attributes in ATTRS. C, if not negative, is a
+/* Return a font-entity that satisfies SPEC and is the best match for
+ face's font related attributes in ATTRS. C, if not negative, is a
character that the entity must support. */
Lisp_Object
Lisp_Object foundry[3], *family, registry[3], adstyle[3];
int pixel_size;
int i, j, k, l;
+ USE_SAFE_ALLOCA;
registry[0] = AREF (spec, FONT_REGISTRY_INDEX);
if (NILP (registry[0]))
if (! NILP (alters))
{
- family = alloca ((sizeof family[0]) * (XINT (Flength (alters)) + 2));
+ EMACS_INT alterslen = XFASTINT (Flength (alters));
+ SAFE_ALLOCA_LISP (family, alterslen + 2);
for (i = 0; CONSP (alters); i++, alters = XCDR (alters))
family[i] = XCAR (alters);
if (NILP (AREF (spec, FONT_FAMILY_INDEX)))
}
}
}
+
+ SAFE_FREE ();
return Qnil;
}
if (INTEGERP (height))
pt = XINT (height);
else
- abort(); /* We should never end up here. */
+ abort (); /* We should never end up here. */
}
pt /= 10;
#ifdef HAVE_NS
if (size == 0)
{
- Lisp_Object ffsize = get_frame_param(f, Qfontsize);
+ Lisp_Object ffsize = get_frame_param (f, Qfontsize);
size = NUMBERP (ffsize) ? POINT_TO_PIXEL (XINT (ffsize), f->resy) : 0;
}
#endif
}
-/* Find a font satisfying SPEC and best matching with face's
- attributes in ATTRS on FRAME, and return the opened
+/* Find a font that satisfies SPEC and is the best match for
+ face's attributes in ATTRS on FRAME, and return the opened
font-object. */
Lisp_Object
if (NILP (entity))
{
/* No font is listed for SPEC, but each font-backend may have
- the different criteria about "font matching". So, try
- it. */
+ different criteria about "font matching". So, try it. */
entity = font_matching_entity (f, attrs, spec);
if (NILP (entity))
return Qnil;
}
-/* Open a font matching with font-spec SPEC on frame F. If no proper
+/* Open a font that is a match for font-spec SPEC on frame F. If no proper
font is found, return Qnil. */
Lisp_Object
}
-/* Open a font matching with NAME on frame F. If no proper font is
+/* Open a font that matches NAME on frame F. If no proper font is
found, return Qnil. */
Lisp_Object
/* Register font-driver DRIVER. This function is used in two ways.
The first is with frame F non-NULL. In this case, make DRIVER
- available (but not yet activated) on F. All frame creaters
+ available (but not yet activated) on F. All frame creators
(e.g. Fx_create_frame) must call this function at least once with
an available font-driver.
STRING. */
static Lisp_Object
-font_at (int c, EMACS_INT pos, struct face *face, struct window *w,
+font_at (int c, ptrdiff_t pos, struct face *face, struct window *w,
Lisp_Object string)
{
FRAME_PTR f;
{
if (multibyte)
{
- EMACS_INT pos_byte = CHAR_TO_BYTE (pos);
+ ptrdiff_t pos_byte = CHAR_TO_BYTE (pos);
c = FETCH_CHAR (pos_byte);
}
multibyte = STRING_MULTIBYTE (string);
if (multibyte)
{
- EMACS_INT pos_byte = string_char_to_byte (string, pos);
+ ptrdiff_t pos_byte = string_char_to_byte (string, pos);
str = SDATA (string) + pos_byte;
c = STRING_CHAR (str);
if (! face)
{
int face_id;
- EMACS_INT endptr;
+ ptrdiff_t endptr;
if (STRINGP (string))
face_id = face_at_string_position (w, string, pos, 0, -1, -1, &endptr,
#ifdef HAVE_WINDOW_SYSTEM
/* Check how many characters after POS (at most to *LIMIT) can be
- displayed by the same font on the window W. FACE, if non-NULL, is
+ displayed by the same font in the window W. FACE, if non-NULL, is
the face selected for the character at POS. If STRING is not nil,
it is the string to check instead of the current buffer. In that
case, FACE must be not NULL.
It is assured that the current buffer (or STRING) is multibyte. */
Lisp_Object
-font_range (EMACS_INT pos, EMACS_INT *limit, struct window *w, struct face *face, Lisp_Object string)
+font_range (ptrdiff_t pos, ptrdiff_t *limit, struct window *w, struct face *face, Lisp_Object string)
{
- EMACS_INT pos_byte, ignore;
+ ptrdiff_t pos_byte, ignore;
int c;
Lisp_Object font_object = Qnil;
else
FETCH_STRING_CHAR_ADVANCE_NO_CHECK (c, string, pos, pos_byte);
category = CHAR_TABLE_REF (Vunicode_category_table, c);
- if (EQ (category, QCf)
- || CHAR_VARIATION_SELECTOR_P (c))
+ if (INTEGERP (category)
+ && (XINT (category) == UNICODE_CATEGORY_Cf
+ || CHAR_VARIATION_SELECTOR_P (c)))
continue;
if (NILP (font_object))
{
must not have any of the remaining elements.
For instance, if the VALUE is `(thai nil nil (mark))', the font must
-be an OpenType font, and whose GPOS table of `thai' script's default
+be an OpenType font whose GPOS table of `thai' script's default
language system must contain `mark' feature.
usage: (font-spec ARGS...) */)
- (size_t nargs, Lisp_Object *args)
+ (ptrdiff_t nargs, Lisp_Object *args)
{
Lisp_Object spec = font_make_spec ();
- size_t i;
+ ptrdiff_t i;
for (i = 0; i < nargs; i += 2)
{
(Lisp_Object font_spec, Lisp_Object frame, Lisp_Object num, Lisp_Object prefer)
{
Lisp_Object vec, list;
- int n = 0;
+ EMACS_INT n = 0;
if (NILP (frame))
frame = selected_frame;
FONT is a font-spec, font-entity, or font-object.
If the name is too long for XLFD (maximum 255 chars), return nil.
If the 2nd optional arg FOLD-WILDCARDS is non-nil,
-the consecutive wildcards are folded to one. */)
+the consecutive wildcards are folded into one. */)
(Lisp_Object font, Lisp_Object fold_wildcards)
{
char name[256];
font_fill_lglyph_metrics (Lisp_Object glyph, Lisp_Object font_object)
{
struct font *font = XFONT_OBJECT (font_object);
- unsigned code;
- /* ecode used in LGLYPH_SET_CODE to avoid compiler warnings. */
- EMACS_INT ecode = font->driver->encode_char (font, LGLYPH_CHAR (glyph));
+ unsigned code = font->driver->encode_char (font, LGLYPH_CHAR (glyph));
struct font_metrics metrics;
- LGLYPH_SET_CODE (glyph, ecode);
- code = ecode;
+ LGLYPH_SET_CODE (glyph, code);
font->driver->text_extents (font, &code, 1, &metrics);
LGLYPH_SET_LBEARING (glyph, metrics.lbearing);
LGLYPH_SET_RBEARING (glyph, metrics.rbearing);
{
struct font *font;
Lisp_Object font_object, n, glyph;
- int i, j, from, to;
+ ptrdiff_t i, j, from, to;
if (! composition_gstring_p (gstring))
signal_error ("Invalid glyph-string: ", gstring);
if (INTEGERP (n))
break;
gstring = larger_vector (gstring,
- ASIZE (gstring) + LGSTRING_GLYPH_LEN (gstring),
- Qnil);
+ LGSTRING_GLYPH_LEN (gstring), -1);
}
if (i == 3 || XINT (n) == 0)
return Qnil;
for (i = 0; i < 255; i++)
if (variations[i])
{
- Lisp_Object code;
int vs = (i < 16 ? 0xFE00 + i : 0xE0100 + (i - 16));
- /* Stops GCC whining about limited range of data type. */
- EMACS_INT var = variations[i];
-
- if (var > MOST_POSITIVE_FIXNUM)
- code = Fcons (make_number ((variations[i]) >> 16),
- make_number ((variations[i]) & 0xFFFF));
- else
- code = make_number (variations[i]);
+ Lisp_Object code = INTEGER_TO_CONS (variations[i]);
val = Fcons (Fcons (make_number (vs), code), val);
}
return val;
If GSTRING-OUT is too short to hold produced glyphs, no glyphs are
produced in GSTRING-OUT, and the value is nil.
-See the documentation of `font-make-gstring' for the format of
+See the documentation of `composition-get-gstring' for the format of
glyph-string. */)
(Lisp_Object otf_features, Lisp_Object gstring_in, Lisp_Object from, Lisp_Object to, Lisp_Object gstring_out, Lisp_Object index)
{
doc: /* Open FONT-ENTITY. */)
(Lisp_Object font_entity, Lisp_Object size, Lisp_Object frame)
{
- int isize;
+ EMACS_INT isize;
CHECK_FONT_ENTITY (font_entity);
if (NILP (frame))
isize = POINT_TO_PIXEL (XFLOAT_DATA (size), XFRAME (frame)->resy);
else
isize = XINT (size);
+ if (! (INT_MIN <= isize && isize <= INT_MAX))
+ args_out_of_range (font_entity, size);
if (isize == 0)
isize = 120;
}
[ NAME FILENAME PIXEL-SIZE SIZE ASCENT DESCENT SPACE-WIDTH AVERAGE-WIDTH
CAPABILITY ]
-NAME is a string of the font name (or nil if the font backend doesn't
+NAME is the font name, a string (or nil if the font backend doesn't
provide a name).
-FILENAME is a string of the font file (or nil if the font backend
+FILENAME is the font file name, a string (or nil if the font backend
doesn't provide a file name).
PIXEL-SIZE is a pixel size by which the font is opened.
Lisp_Object object)
{
struct font *font;
- int i, len;
+ ptrdiff_t i, len;
Lisp_Object *chars, vec;
USE_SAFE_ALLOCA;
CHECK_FONT_GET_OBJECT (font_object, font);
if (NILP (object))
{
- EMACS_INT charpos, bytepos;
+ ptrdiff_t charpos, bytepos;
validate_region (&from, &to);
if (EQ (from, to))
(Lisp_Object position, Lisp_Object window, Lisp_Object string)
{
struct window *w;
- EMACS_INT pos;
+ ptrdiff_t pos;
if (NILP (string))
{
CHECK_NUMBER_COERCE_MARKER (position);
- pos = XINT (position);
- if (pos < BEGV || pos >= ZV)
+ if (! (BEGV <= XINT (position) && XINT (position) < ZV))
args_out_of_range_3 (position, make_number (BEGV), make_number (ZV));
+ pos = XINT (position);
}
else
{
CHECK_NUMBER (position);
CHECK_STRING (string);
- pos = XINT (position);
- if (pos < 0 || pos >= SCHARS (string))
+ if (! (0 < XINT (position) && XINT (position) < SCHARS (string)))
args_out_of_range (string, position);
+ pos = XINT (position);
}
if (NILP (window))
window = selected_window;
HCoop / bpt / emacs.git / blobdiff