static Lisp_Object QCadstyle, QCregistry;
/* Symbols representing keys of font extra info. */
Lisp_Object QCspacing, QCdpi, QCscalable, QCotf, QClang, QCscript, QCavgwidth;
-Lisp_Object QCantialias, QCfont_entity, QCfc_unknown_spec;
+Lisp_Object QCantialias, QCfont_entity;
+static Lisp_Object QCfc_unknown_spec;
/* Symbols representing values of font spacing property. */
-Lisp_Object Qc, Qm, Qp, Qd;
+static Lisp_Object Qc, Qm, Qd;
+Lisp_Object Qp;
/* Special ADSTYLE properties to avoid fonts used for Latin
characters; used in xfont.c and ftfont.c. */
Lisp_Object Qja, Qko;
-Lisp_Object QCuser_spec;
+static Lisp_Object QCuser_spec;
/* Alist of font registry symbol and the corresponding charsets
information. The information is retrieved from
{
Lisp_Object table = AREF (font_style_table, prop - FONT_WEIGHT_INDEX);
int len = ASIZE (table);
- int i, j;
if (SYMBOLP (val))
{
+ int i, j;
char *s;
Lisp_Object args[2], elt;
enum font_property_index prop = (EQ (style, QCweight) ? FONT_WEIGHT_INDEX
: EQ (style, QCslant) ? FONT_SLANT_INDEX
: FONT_WIDTH_INDEX);
- int n;
if (INTEGERP (val))
{
- n = XINT (val);
+ int n = XINT (val);
if (((n >> 4) & 0xF)
>= ASIZE (AREF (font_style_table, prop - FONT_WEIGHT_INDEX)))
val = Qerror;
int
font_unparse_xlfd (Lisp_Object font, int pixel_size, char *name, int nbytes)
{
- char *f[XLFD_REGISTRY_INDEX + 1];
+ char *p;
+ const char *f[XLFD_REGISTRY_INDEX + 1];
Lisp_Object val;
int i, j, len = 0;
/* Change "jisx0208*" and "jisx0208" to "jisx0208*-*". */
if (SDATA (val)[SBYTES (val) - 1] == '*')
{
- f[j] = alloca (SBYTES (val) + 3);
- sprintf (f[j], "%s-*", SDATA (val));
+ f[j] = p = alloca (SBYTES (val) + 3);
+ sprintf (p, "%s-*", SDATA (val));
len += SBYTES (val) + 3;
}
else
{
- f[j] = alloca (SBYTES (val) + 4);
- sprintf (f[j], "%s*-*", SDATA (val));
+ f[j] = p = alloca (SBYTES (val) + 4);
+ sprintf (p, "%s*-*", SDATA (val));
len += SBYTES (val) + 4;
}
}
i = pixel_size;
if (i > 0)
{
- f[XLFD_PIXEL_INDEX] = alloca (22);
- len += sprintf (f[XLFD_PIXEL_INDEX], "%d-*", i) + 1;
+ f[XLFD_PIXEL_INDEX] = p = alloca (22);
+ len += sprintf (p, "%d-*", i) + 1;
}
else
f[XLFD_PIXEL_INDEX] = "*-*", len += 4;
else if (FLOATP (val))
{
i = XFLOAT_DATA (val) * 10;
- f[XLFD_PIXEL_INDEX] = alloca (12);
- len += sprintf (f[XLFD_PIXEL_INDEX], "*-%d", i) + 1;
+ f[XLFD_PIXEL_INDEX] = p = alloca (12);
+ len += sprintf (p, "*-%d", i) + 1;
}
else
f[XLFD_PIXEL_INDEX] = "*-*", len += 4;
if (INTEGERP (AREF (font, FONT_DPI_INDEX)))
{
i = XINT (AREF (font, FONT_DPI_INDEX));
- f[XLFD_RESX_INDEX] = alloca (22);
- len += sprintf (f[XLFD_RESX_INDEX],
- "%d-%d", i, i) + 1;
+ f[XLFD_RESX_INDEX] = p = alloca (22);
+ len += sprintf (p, "%d-%d", i, i) + 1;
}
else
f[XLFD_RESX_INDEX] = "*-*", len += 4;
f[XLFD_SPACING_INDEX] = "*", len += 2;
if (INTEGERP (AREF (font, FONT_AVGWIDTH_INDEX)))
{
- f[XLFD_AVGWIDTH_INDEX] = alloca (11);
- len += sprintf (f[XLFD_AVGWIDTH_INDEX], "%ld",
- (long) XINT (AREF (font, FONT_AVGWIDTH_INDEX))) + 1;
+ f[XLFD_AVGWIDTH_INDEX] = p = alloca (22);
+ len += sprintf (p, "%"pI"d",
+ XINT (AREF (font, FONT_AVGWIDTH_INDEX))) + 1;
}
else
f[XLFD_AVGWIDTH_INDEX] = "*", len += 2;
{
/* Either a fontconfig-style name with no size and property
data, or a GTK-style name. */
- Lisp_Object prop;
Lisp_Object weight = Qnil, slant = Qnil;
Lisp_Object width = Qnil, size = Qnil;
char *word_start;
int word_len;
- int size_found = 0;
/* Scan backwards from the end, looking for a size. */
for (p = name + len - 1; p >= name; p--)
point_size = -1;
len += 21; /* for ":pixelsize=NUM" */
}
- else if (FLOATP (val))
+ else
{
+ if (! FLOATP (val))
+ abort ();
pixel_size = -1;
point_size = (int) XFLOAT_DATA (val);
len += 11; /* for "-NUM" */
}
if (INTEGERP (AREF (font, FONT_DPI_INDEX)))
- len += sprintf (work, ":dpi=%ld", (long)XINT (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)), val = XCDR (XCAR (tail));
+ Lisp_Object key = XCAR (XCAR (tail)), value = XCDR (XCAR (tail));
len += SBYTES (SYMBOL_NAME (key)) + 1; /* for :KEY= */
- if (STRINGP (val))
- len += SBYTES (val);
- else if (INTEGERP (val))
- len += sprintf (work, "%ld", (long) XINT (val));
- else if (SYMBOLP (val))
- len += (NILP (val) ? 5 : 4); /* for "false" or "true" */
+ 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)
p += sprintf (p, ":%s=%s", style_names[i],
SDATA (SYMBOL_NAME (styles[i])));
if (INTEGERP (AREF (font, FONT_DPI_INDEX)))
- p += sprintf (p, ":dpi=%ld", (long) XINT (AREF (font, FONT_DPI_INDEX)));
+ p += sprintf (p, ":dpi=%"pI"d", XINT (AREF (font, FONT_DPI_INDEX)));
if (INTEGERP (AREF (font, FONT_SPACING_INDEX)))
- p += sprintf (p, ":spacing=%ld",
- (long) XINT (AREF (font, FONT_SPACING_INDEX)));
+ p += sprintf (p, ":spacing=%"pI"d", XINT (AREF (font, FONT_SPACING_INDEX)));
if (INTEGERP (AREF (font, FONT_AVGWIDTH_INDEX)))
{
if (XINT (AREF (font, FONT_AVGWIDTH_INDEX)) == 0)
for (i = FONT_WEIGHT_INDEX; i <= FONT_WIDTH_INDEX; i++)
if (! NILP (spec_prop[i]) && ! EQ (AREF (entity, i), spec_prop[i]))
{
- int diff = (XINT (AREF (entity, i)) >> 8) - (XINT (spec_prop[i]) >> 8);
-
+ EMACS_INT diff = ((XINT (AREF (entity, i)) >> 8)
+ - (XINT (spec_prop[i]) >> 8));
if (diff < 0)
diff = - diff;
- if (diff > 0)
- score |= min (diff, 127) << sort_shift_bits[i];
+ score |= min (diff, 127) << sort_shift_bits[i];
}
/* Score the size. Maximum difference is 127. */
unsigned best_score;
Lisp_Object best_entity;
struct frame *f = XFRAME (frame);
- Lisp_Object tail, vec;
+ Lisp_Object tail, vec IF_LINT (= Qnil);
USE_SAFE_ALLOCA;
for (i = FONT_WEIGHT_INDEX; i <= FONT_AVGWIDTH_INDEX; i++)
(2) doesn't match with any regexps in Vface_ignored_fonts (if non-nil).
*/
-Lisp_Object
+static Lisp_Object
font_delete_unmatched (Lisp_Object vec, Lisp_Object spec, int size)
{
Lisp_Object entity, val;
for (i = FONT_FOUNDRY_INDEX; i <= FONT_REGISTRY_INDEX; i++)
ASET (scratch_font_spec, i, AREF (spec, i));
for (i = FONT_WEIGHT_INDEX; i < FONT_EXTRA_INDEX; i++)
- {
- ASET (scratch_font_spec, i, Qnil);
- if (! NILP (AREF (spec, i)))
- need_filtering = 1;
- if (i == FONT_DPI_INDEX)
- /* Skip FONT_SPACING_INDEX */
- i++;
- }
+ if (i != FONT_SPACING_INDEX)
+ {
+ ASET (scratch_font_spec, i, Qnil);
+ if (! NILP (AREF (spec, i)))
+ need_filtering = 1;
+ }
ASET (scratch_font_spec, FONT_SPACING_INDEX, AREF (spec, FONT_SPACING_INDEX));
ASET (scratch_font_spec, FONT_EXTRA_INDEX, AREF (spec, FONT_EXTRA_INDEX));
val = null_vector;
else
val = Fvconcat (1, &val);
- copy = Fcopy_font_spec (scratch_font_spec);
+ copy = copy_font_spec (scratch_font_spec);
ASET (copy, FONT_TYPE_INDEX, driver_list->driver->type);
XSETCDR (cache, Fcons (Fcons (copy, val), XCDR (cache)));
}
struct font_driver_list *driver_list = f->font_driver_list;
Lisp_Object ftype, size, entity;
Lisp_Object frame;
- Lisp_Object work = Fcopy_font_spec (spec);
+ Lisp_Object work = copy_font_spec (spec);
XSETFRAME (frame, f);
ftype = AREF (spec, FONT_TYPE_INDEX);
else
{
entity = driver_list->driver->match (frame, work);
- copy = Fcopy_font_spec (work);
+ copy = copy_font_spec (work);
ASET (copy, FONT_TYPE_INDEX, driver_list->driver->type);
XSETCDR (cache, Fcons (Fcons (copy, entity), XCDR (cache)));
}
Lisp_Object objlist, size, val, font_object;
struct font *font;
int min_width, height;
- int scaled_pixel_size;
+ int scaled_pixel_size = pixel_size;
font_assert (FONT_ENTITY_P (entity));
size = AREF (entity, FONT_SIZE_INDEX);
/* Close FONT_OBJECT that is opened on frame F. */
-void
+static void
font_close_object (FRAME_PTR f, Lisp_Object font_object)
{
struct font *font = XFONT_OBJECT (font_object);
}
-/* Return the specification of FONT_OBJECT. */
-
-Lisp_Object
-font_get_spec (Lisp_Object font_object)
-{
- Lisp_Object spec = font_make_spec ();
- int i;
-
- for (i = 0; i < FONT_SIZE_INDEX; i++)
- ASET (spec, i, AREF (font_object, i));
- ASET (spec, FONT_SIZE_INDEX,
- make_number (XFONT_OBJECT (font_object)->pixel_size));
- return spec;
-}
-
-
/* Create a new font spec from FONT_NAME, and return it. If FONT_NAME
could not be parsed by font_parse_name, return Qnil. */
if (! NILP (Ffont_get (font, QCname)))
{
- font = Fcopy_font_spec (font);
+ font = copy_font_spec (font);
font_put_extra (font, QCname, Qnil);
}
&& prop != FONT_SIZE_INDEX)
return;
if (EQ (font, attrs[LFACE_FONT_INDEX]))
- font = Fcopy_font_spec (font);
+ font = copy_font_spec (font);
ASET (font, prop, Qnil);
if (prop == FONT_FAMILY_INDEX || prop == FONT_FOUNDRY_INDEX)
{
{
Lisp_Object work;
Lisp_Object frame, entities, val;
- Lisp_Object size, foundry[3], *family, registry[3], adstyle[3];
+ Lisp_Object foundry[3], *family, registry[3], adstyle[3];
int pixel_size;
int i, j, k, l;
return Qnil;
}
- work = Fcopy_font_spec (spec);
+ work = copy_font_spec (spec);
ASET (work, FONT_TYPE_INDEX, AREF (spec, FONT_TYPE_INDEX));
XSETFRAME (frame, f);
- size = AREF (spec, FONT_SIZE_INDEX);
pixel_size = font_pixel_size (f, spec);
- if (pixel_size == 0)
+ if (pixel_size == 0 && INTEGERP (attrs[LFACE_HEIGHT_INDEX]))
{
double pt = XINT (attrs[LFACE_HEIGHT_INDEX]);
font_update_drivers (FRAME_PTR f, Lisp_Object new_drivers)
{
Lisp_Object active_drivers = Qnil;
- struct font_driver *driver;
struct font_driver_list *list;
/* At first, turn off non-requested drivers, and turn on requested
drivers. */
for (list = f->font_driver_list; list; list = list->next)
{
- driver = list->driver;
+ struct font_driver *driver = list->driver;
if ((EQ (new_drivers, Qt) || ! NILP (Fmemq (driver->type, new_drivers)))
!= list->on)
{
language system must contain `mark' feature.
usage: (font-spec ARGS...) */)
- (int nargs, Lisp_Object *args)
+ (size_t nargs, Lisp_Object *args)
{
Lisp_Object spec = font_make_spec ();
- int i;
+ size_t i;
for (i = 0; i < nargs; i += 2)
{
return spec;
}
-DEFUN ("copy-font-spec", Fcopy_font_spec, Scopy_font_spec, 1, 1, 0,
- doc: /* Return a copy of FONT as a font-spec. */)
- (Lisp_Object font)
+/* Return a copy of FONT as a font-spec. */
+Lisp_Object
+copy_font_spec (Lisp_Object font)
{
Lisp_Object new_spec, tail, prev, extra;
int i;
return new_spec;
}
-DEFUN ("merge-font-spec", Fmerge_font_spec, Smerge_font_spec, 2, 2, 0,
- doc: /* Merge font-specs FROM and TO, and return a new font-spec.
-Every specified properties in FROM override the corresponding
-properties in TO. */)
- (Lisp_Object from, Lisp_Object to)
+/* Merge font-specs FROM and TO, and return a new font-spec.
+ Every specified property in FROM overrides the corresponding
+ property in TO. */
+Lisp_Object
+merge_font_spec (Lisp_Object from, Lisp_Object to)
{
Lisp_Object extra, tail;
int i;
CHECK_FONT (from);
CHECK_FONT (to);
- to = Fcopy_font_spec (to);
+ to = copy_font_spec (to);
for (i = 0; i < FONT_EXTRA_INDEX; i++)
ASET (to, i, AREF (from, i));
extra = AREF (to, FONT_EXTRA_INDEX);
Lisp_Object object)
{
struct font *font;
- int i, len, c;
+ int i, len;
Lisp_Object *chars, vec;
USE_SAFE_ALLOCA;
bytepos = CHAR_TO_BYTE (charpos);
for (i = 0; charpos < XFASTINT (to); i++)
{
+ int c;
FETCH_CHAR_ADVANCE (c, charpos, bytepos);
chars[i] = make_number (c);
}
if (STRING_MULTIBYTE (object))
for (i = 0; i < len; i++)
{
- c = STRING_CHAR_ADVANCE (p);
+ int c = STRING_CHAR_ADVANCE (p);
chars[i] = make_number (c);
}
else
Lisp_Object g;
int c = XFASTINT (chars[i]);
unsigned code;
- EMACS_INT cod;
struct font_metrics metrics;
- cod = code = font->driver->encode_char (font, c);
+ code = font->driver->encode_char (font, c);
if (code == FONT_INVALID_CODE)
continue;
g = Fmake_vector (make_number (LGLYPH_SIZE), Qnil);
void
font_add_log (const char *action, Lisp_Object arg, Lisp_Object result)
{
- Lisp_Object tail, val;
+ Lisp_Object val;
int i;
if (EQ (Vfont_log, Qt))
}
else if (CONSP (result))
{
+ Lisp_Object tail;
result = Fcopy_sequence (result);
for (tail = result; CONSP (tail); tail = XCDR (tail))
{
HCoop / bpt / emacs.git / blobdiff