emacs: src/xfaces.c comparison

comparison src/xfaces.c @ 30235:5a0d447b7eea

check default_face before dereferencing

author	Sam Steingold <sds@gnu.org>
date	Fri, 14 Jul 2000 20:29:04 +0000
parents	8d8aa26c6884
children	626d55ea66ef

comparison

equal deleted inserted replaced

-:1cd3b42b273e
+:5a0d447b7eea
 When using Emacs with X, the display style of characters can be
 changed by defining `faces'.  Each face can specify the following
 display attributes:
 1. Font family name.
 2. Relative proportionate width, aka character set width or set
 width (swidth), e.g. `semi-compressed'.
 3. Font height in 1/10pt.
 4. Font weight, e.g. `bold'.
 5. Font slant, e.g. `italic'.
 6. Foreground color.
 7. Background color.
 8. Whether or not characters should be underlined, and in what color.
 9. Whether or not characters should be displayed in inverse video.
 attributes mentioned above.
 There is also a global face alist `Vface_new_frame_defaults'.  Face
 definitions from this list are used to initialize faces of newly
 created frames.
 A face doesn't have to specify all attributes.  Those not specified
 have a value of `unspecified'.  Faces specifying all attributes but
 the 14th are called `fully-specified'.
 sure that the default face is always fully-specified, face merging
 always results in a fully-specified face.
 Face realization.
 After all face attributes for a character have been determined by
 merging faces of that character, that face is `realized'.  The
 realization process maps face attributes to what is physically
 available on the system where Emacs runs.  The result is a
 `realized face' in form of a struct face which is stored in the
 2. Setting face-alternative-font-family-alist allows the user to
 specify alternative font families to try if a family specified by a
 face doesn't exist.
 Character compositition.
 Usually, the realization process is already finished when Emacs
 actually reflects the desired glyph matrix on the screen.  However,
 on displaying a composition (sequence of characters to be composed
 on the screen), a suitable font for the components of the
 composition is selected and realized while drawing them on the
 screen, i.e.  the realization process is delayed but in principle
 the same.
 Initialization of basic faces.
 The faces `default', `modeline' are considered `basic faces'.
 When redisplay happens the first time for a newly created frame,
 basic faces are realized for CHARSET_ASCII.  Frame parameters are
 /* Value is the number of elements of VECTOR.  */
 #define DIM(VECTOR) (sizeof (VECTOR) / sizeof *(VECTOR))
 /* Make a copy of string S on the stack using alloca.  Value is a pointer
 to the copy.  */
 #define STRDUPA(S) strcpy ((char *) alloca (strlen ((S)) + 1), (S))
 /* Make a copy of the contents of Lisp string S on the stack using
 alloca.  Value is a pointer to the copy.  */
 #define LSTRDUPA(S) STRDUPA (XSTRING ((S))->data)
 /* Size of hash table of realized faces in face caches (should be a
 prime number).  */
 #define FACE_CACHE_BUCKETS_SIZE 1001
 /* A definition of XColor for non-X frames.  */
 ()
 {
 int i, n;
 fputc ('\n', stderr);
 for (i = n = 0; i < sizeof color_count / sizeof color_count[0]; ++i)
 if (color_count[i])
 {
 	fprintf (stderr, "%3d: %5d", i, color_count[i]);
 	++n;
 Lisp_Object frame;
 int nparam;
 {
 if (NILP (frame))
 frame = selected_frame;
 CHECK_LIVE_FRAME (frame, nparam);
 return XFRAME (frame);
 }
 struct frame *f;
 {
 /* Make a face cache, if F doesn't have one.  */
 if (FRAME_FACE_CACHE (f) == NULL)
 FRAME_FACE_CACHE (f) = make_face_cache (f);
 #ifdef HAVE_WINDOW_SYSTEM
 /* Make the image cache.  */
 if (FRAME_WINDOW_P (f))
 {
 if (FRAME_X_IMAGE_CACHE (f) == NULL)
 	FRAME_X_IMAGE_CACHE (f) = make_image_cache ();
 ++FRAME_X_IMAGE_CACHE (f)->refcount;
 }
 #endif /* HAVE_WINDOW_SYSTEM */
 /* Realize basic faces.  Must have enough information in frame
 parameters to realize basic faces at this point.  */
 #ifdef HAVE_X_WINDOWS
 if (!FRAME_X_P (f) || FRAME_X_WINDOW (f))
 #endif
 #ifdef WINDOWSNT
 void
 free_frame_faces (f)
 struct frame *f;
 {
 struct face_cache *face_cache = FRAME_FACE_CACHE (f);
 if (face_cache)
 {
 free_face_cache (face_cache);
 FRAME_FACE_CACHE (f) = NULL;
 }
 (WIDTH + 7)/8 bytes.")
 (object)
 Lisp_Object object;
 {
 int pixmap_p = 0;
 if (STRINGP (object))
 /* If OBJECT is a string, it's a file name.  */
 pixmap_p = 1;
 else if (CONSP (object))
 {
 	 HEIGHT must be integers > 0, and DATA must be string large
 	 enough to hold a bitmap of the specified size.  */
 Lisp_Object width, height, data;
 height = width = data = Qnil;
 if (CONSP (object))
 	{
 	  width = XCAR (object);
 	  object = XCDR (object);
 	  if (CONSP (object))
 int
 frame_update_line_height (f)
 struct frame *f;
 {
 int line_height, changed_p;
 line_height = FONT_HEIGHT (FRAME_FONT (f));
 changed_p = line_height != FRAME_LINE_HEIGHT (f);
 FRAME_LINE_HEIGHT (f) = line_height;
 return changed_p;
 }
 struct face *face;
 int c;
 {
 struct font_info *font_info = NULL;
 char *font_name;
 face->font_info_id = -1;
 face->font = NULL;
 font_name = choose_face_font (f, face->lface, face->fontset, c);
 if (!font_name)
 		  < max (color.green, color.blue) / 20)
 	      && (abs (color.blue - color.red)
 		  < max (color.blue, color.red) / 20));
 else
 gray_p = 0;
 return gray_p;
 }
 /* Return non-zero if color COLOR_NAME can be displayed on frame F.
 struct face *face;
 Lisp_Object name;
 enum lface_attribute_index target_index;
 {
 XColor color;
 xassert (STRINGP (name));
 xassert (target_index == LFACE_FOREGROUND_INDEX
 	   || target_index == LFACE_BACKGROUND_INDEX
 	   || target_index == LFACE_UNDERLINE_INDEX
 	   || target_index == LFACE_OVERLINE_INDEX
 	   || target_index == LFACE_STRIKE_THROUGH_INDEX
 	   || target_index == LFACE_BOX_INDEX);
 /* if the color map is full, defined_color will return a best match
 to the values in an existing cell. */
 if (!defined_color (f, XSTRING (name)->data, &color, 1))
 {
 add_to_log ("Unable to load color \"%s\"", name, Qnil);
 switch (target_index)
 	{
 	case LFACE_FOREGROUND_INDEX:
 	  face->foreground_defaulted_p = 1;
 	  color.pixel = FRAME_FOREGROUND_PIXEL (f);
 	  break;
 	case LFACE_BACKGROUND_INDEX:
 	  face->background_defaulted_p = 1;
 	  color.pixel = FRAME_BACKGROUND_PIXEL (f);
 	  break;
 	case LFACE_UNDERLINE_INDEX:
 	  face->underline_defaulted_p = 1;
 	  color.pixel = FRAME_FOREGROUND_PIXEL (f);
 	  break;
 	case LFACE_OVERLINE_INDEX:
 	  face->overline_color_defaulted_p = 1;
 	  color.pixel = FRAME_FOREGROUND_PIXEL (f);
 	  break;
 	case LFACE_STRIKE_THROUGH_INDEX:
 	  face->strike_through_color_defaulted_p = 1;
 	  color.pixel = FRAME_FOREGROUND_PIXEL (f);
 	  break;
 	case LFACE_BOX_INDEX:
 	  face->box_color_defaulted_p = 1;
 	  color.pixel = FRAME_FOREGROUND_PIXEL (f);
 	  break;
 }
 #if GLYPH_DEBUG
 else
 ++ncolors_allocated;
 #endif
 return color.pixel;
 }
 #ifdef HAVE_WINDOW_SYSTEM
 struct frame *f;
 struct face *face;
 {
 #ifdef HAVE_X_WINDOWS
 BLOCK_INPUT;
 if (!face->foreground_defaulted_p)
 {
 x_free_colors (f, &face->foreground, 1);
 IF_DEBUG (--ncolors_allocated);
 }
 if (!face->background_defaulted_p)
 {
 x_free_colors (f, &face->background, 1);
 IF_DEBUG (--ncolors_allocated);
 }
 XLFD_REGISTRY,
 XLFD_ENCODING,
 XLFD_LAST
 };
 /* An enumerator for each possible slant value of a font.  Taken from
 the XLFD specification.  */
 enum xlfd_slant
 {
 XLFD_SLANT_UNKNOWN,
 while (low <= high)
 {
 mid = (low + high) / 2;
 cmp = strcmp (table[mid].name, s);
 if (cmp < 0)
 	low = mid + 1;
 else if (cmp > 0)
 	high = mid - 1;
 else
 struct font_name *font;
 {
 return xlfd_symbolic_value (swidth_table, DIM (swidth_table),
 			      font, XLFD_SWIDTH, Qnormal);
 }
 /* Look up the entry of SYMBOL in the vector TABLE which has DIM
 entries.  Value is a pointer to the matching table entry or null if
 no element of TABLE contains SYMBOL.  */
 Lisp_Object symbol;
 {
 int i;
 xassert (SYMBOLP (symbol));
 for (i = 0; i < dim; ++i)
 if (EQ (*table[i].symbol, symbol))
 break;
 return i < dim ? table + i : NULL;
 while (i < XLFD_LAST)
 	{
 	  font->fields[i] = p;
 	  ++i;
 	  while (*p && *p != '-')
 	    ++p;
 	  if (*p != '-')
 	    break;
 	  *p++ = 0;
 	}
 }
 success_p = i == XLFD_LAST;
 }
 /* Build an XLFD font name from font name fields in FONT.  Value is a
 pointer to the font name, which is allocated via xmalloc.  */
 static char *
 build_font_name (font)
 struct font_name *font;
 {
 int i;
 scalable fonts.
 For all fonts found, set FONTS[i].name to the name of the font,
 allocated via xmalloc, and split font names into fields.  Ignore
 fonts that we can't parse.  Value is the number of fonts found.
 This is similar to x_list_fonts.  The differences are:
 1. It avoids consing.
 2. It never calls XLoadQueryFont.  */
 BLOCK_INPUT;
 XFreeFontNames (names);
 UNBLOCK_INPUT;
 #endif
 }
 /* If no fonts found, try patterns from Valternate_fontname_alist.  */
 if (n == 0 && try_alternatives_p)
 {
 Lisp_Object list = Valternate_fontname_alist;
 if (CONSP (list))
 	{
 	  Lisp_Object patterns = XCAR (list);
 	  Lisp_Object name;
 	  while (CONSP (patterns)
 		 /* If list is screwed up, give up.  */
 		 && (name = XCAR (patterns),
 		     STRINGP (name))
 		 /* Ignore patterns equal to PATTERN because we tried that
 						scalable_fonts_p),
 			 n == 0)))
 	    patterns = XCDR (patterns);
 	}
 }
 return n;
 }
 /* Determine the first font matching PATTERN on frame F.  Return in
 *FONT the matching font name, split into fields.  Value is non-zero
 if a match was found.  */
 nfonts = x_face_list_fonts (f, pattern, fonts, nfonts, 1, 0);
 if (nfonts > 0)
 {
 bcopy (&fonts[0], font, sizeof *font);
 fonts[0].name = NULL;
 free_font_names (fonts, nfonts);
 }
 return nfonts > 0;
 char *pattern;
 int (*cmpfn) P_ ((const void *, const void *));
 struct font_name **fonts;
 {
 int nfonts;
 /* Get the list of fonts matching pattern.  100 should suffice.  */
 nfonts = DEFAULT_FONT_LIST_LIMIT;
 if (INTEGERP (Vfont_list_limit) && XINT (Vfont_list_limit) > 0)
 nfonts = XFASTINT (Vfont_list_limit);
 *fonts = (struct font_name *) xmalloc (nfonts * sizeof **fonts);
 #if SCALABLE_FONTS
 nfonts = x_face_list_fonts (f, pattern, *fonts, nfonts, 1, 1);
 #else
 nfonts = x_face_list_fonts (f, pattern, *fonts, nfonts, 1, 0);
 #endif
 /* Sort the resulting array and return it in *FONTS.  If no
 fonts were found, make sure to set *FONTS to null.  */
 if (nfonts)
 sort_fonts (f, *fonts, nfonts, cmpfn);
 else
 {
 so we can use strcmp here.  */
 cmp = strcmp (x->fields[XLFD_FAMILY], y->fields[XLFD_FAMILY]);
 if (cmp == 0)
 {
 int i;
 for (i = 0; i < DIM (font_sort_order) && cmp == 0; ++i)
 	{
 	  int j = font_sort_order[i];
 	  cmp = x->numeric[j] - y->numeric[j];
 	}
 if (NILP (pattern))
 {
 family_str = (NILP (family) ? "*" : (char *) XSTRING (family)->data);
 registry_str = (NILP (registry) ? "*" : (char *) XSTRING (registry)->data);
 pattern_str = (char *) alloca (strlen (family_str)
 				     + strlen (registry_str)
 				     + 10);
 strcpy (pattern_str, index (family_str, '-') ? "-" : "-*-");
 strcat (pattern_str, family_str);
 	    strcat (pattern_str, "*-*");
 	}
 }
 else
 pattern_str = (char *) XSTRING (pattern)->data;
 return sorted_font_list (f, pattern_str, cmp_font_names, fonts);
 }
 /* Remove elements from LIST whose cars are `equal'.  Called from
 static void
 remove_duplicates (list)
 Lisp_Object list;
 {
 Lisp_Object tail = list;
 while (!NILP (tail) && !NILP (XCDR (tail)))
 {
 Lisp_Object next = XCDR (tail);
 if (!NILP (Fequal (XCAR (next), XCAR (tail))))
 	XCDR (tail) = XCDR (next);
 Lisp_Object result;
 struct gcpro gcpro1;
 if (!NILP (family))
 CHECK_STRING (family, 1);
 result = Qnil;
 GCPRO1 (result);
 nfonts = font_list (f, Qnil, family, Qnil, &fonts);
 for (i = nfonts - 1; i >= 0; --i)
 {
 ASET (v, 6, build_string (tem));
 sprintf (tem, "%s-%s", fonts[i].fields[XLFD_REGISTRY],
 	       fonts[i].fields[XLFD_ENCODING]);
 ASET (v, 7, build_string (tem));
 xfree (tem);
 result = Fcons (v, result);
 }
 remove_duplicates (result);
 free_font_names (fonts, nfonts);
 fonts until we have them all.  */
 for (limit = 500;;)
 {
 specbind (intern ("font-list-limit"), make_number (limit));
 nfonts = font_list (f, Qnil, Qnil, Qnil, &fonts);
 if (nfonts == limit)
 	{
 	  free_font_names (fonts, nfonts);
 	  limit *= 2;
 	}
 else
 	break;
 }
 result = Qnil;
 GCPRO1 (result);
 for (i = nfonts - 1; i >= 0; --i)
 result = Fcons (Fcons (build_string (fonts[i].fields[XLFD_FAMILY]),
 			   xlfd_fixed_p (fonts + i) ? Qt : Qnil),
 int size;
 int maxnames;
 check_x ();
 CHECK_STRING (pattern, 0);
 if (NILP (maximum))
 maxnames = 2000;
 else
 {
 CHECK_NATNUM (maximum, 0);
 #define LFACEP(LFACE)					\
 (VECTORP (LFACE)					\
 && XVECTOR (LFACE)->size == LFACE_VECTOR_SIZE	\
 && EQ (XVECTOR (LFACE)->contents[0], Qface))
 #if GLYPH_DEBUG
 /* Check consistency of Lisp face attribute vector ATTRS.  */
 static void
 static Lisp_Object
 resolve_face_name (face_name)
 Lisp_Object face_name;
 {
 Lisp_Object aliased;
 if (STRINGP (face_name))
 face_name = intern (XSTRING (face_name)->data);
 for (;;)
 {
 	return 0 if MAY_FAIL_P is non-zero, otherwise abort.
 If the fullname is not in a valid XLFD format,
 	return 0 if MAY_FAIL_P is non-zero, otherwise set normal values
 	in LFACE and return 1.
 Otherwise, return 1.  */
 static int
 set_lface_from_font_name (f, lface, fontname, force_p, may_fail_p)
 struct frame *f;
 Lisp_Object lface;
 Lisp_Object fontname;
 have_xlfd_p = split_font_name (f, &font, 1);
 /* Set attributes only if unspecified, otherwise face defaults for
 new frames would never take effect.  If we couldn't get a font
 name conforming to XLFD, set normal values.  */
 if (force_p || UNSPECIFIEDP (LFACE_FAMILY (lface)))
 {
 Lisp_Object val;
 if (have_xlfd_p)
 	{
 if (force_p || UNSPECIFIEDP (LFACE_SLANT (lface)))
 LFACE_SLANT (lface)
 = have_xlfd_p ? xlfd_symbolic_slant (&font) : Qnormal;
 LFACE_FONT (lface) = fontname;
 return 1;
 }
 #endif /* HAVE_WINDOW_SYSTEM */
 (BACKGROUND-COLOR . COLOR) where COLOR is a color name.  This is
 for compatibility with 20.2.
 Face specifications earlier in lists take precedence over later
 specifications.  */
 static void
 merge_face_vector_with_property (f, to, prop)
 struct frame *f;
 Lisp_Object *to;
 Lisp_Object prop;
 {
 if (CONSP (prop))
 {
 Lisp_Object first = XCAR (prop);
 if (EQ (first, Qforeground_color)
 	  || EQ (first, Qbackground_color))
 	{
 	  /* One of (FOREGROUND-COLOR . COLOR) or (BACKGROUND-COLOR
 	     . COLOR).  COLOR must be a string.  */
 struct frame *f;
 int i;
 CHECK_SYMBOL (face, 0);
 global_lface = lface_from_face_name (NULL, face, 0);
 if (!NILP (frame))
 {
 CHECK_LIVE_FRAME (frame, 1);
 f = XFRAME (frame);
 lface = lface_from_face_name (f, face, 0);
 if (NILP (global_lface))
 {
 global_lface = Fmake_vector (make_number (LFACE_VECTOR_SIZE),
 				   Qunspecified);
 XVECTOR (global_lface)->contents[0] = Qface;
 Vface_new_frame_defaults = Fcons (Fcons (face, global_lface),
 					Vface_new_frame_defaults);
 /* Assign the new Lisp face a unique ID.  The mapping from Lisp
 	 face id to Lisp face is given by the vector lface_id_to_name.
 	 The mapping from Lisp face to Lisp face id is given by the
 	 property `face' of the Lisp face name.  */
 if (next_lface_id == lface_id_to_name_size)
 	  int new_size = max (50, 2 * lface_id_to_name_size);
 	  int sz = new_size * sizeof *lface_id_to_name;
 	  lface_id_to_name = (Lisp_Object *) xrealloc (lface_id_to_name, sz);
 	  lface_id_to_name_size = new_size;
 	}
 lface_id_to_name[next_lface_id] = face;
 Fput (face, Qface, make_number (next_lface_id));
 ++next_lface_id;
 }
 else if (f == NULL)
 for (i = 1; i < LFACE_VECTOR_SIZE; ++i)
 XVECTOR (global_lface)->contents[i] = Qunspecified;
 /* Add a frame-local definition.  */
 if (f)
 {
 if (NILP (lface))
 	{
 Otherwise check for the existence of a global face.")
 (face, frame)
 Lisp_Object face, frame;
 {
 Lisp_Object lface;
 if (!NILP (frame))
 {
 CHECK_LIVE_FRAME (frame, 1);
 lface = lface_from_face_name (XFRAME (frame), face, 0);
 }
 Value is TO.")
 (from, to, frame, new_frame)
 Lisp_Object from, to, frame, new_frame;
 {
 Lisp_Object lface, copy;
 CHECK_SYMBOL (from, 0);
 CHECK_SYMBOL (to, 1);
 if (NILP (new_frame))
 new_frame = frame;
 CHECK_LIVE_FRAME (frame, 2);
 CHECK_LIVE_FRAME (new_frame, 3);
 lface = lface_from_face_name (XFRAME (frame), from, 1);
 copy = Finternal_make_lisp_face (to, new_frame);
 }
 bcopy (XVECTOR (lface)->contents, XVECTOR (copy)->contents,
 	 LFACE_VECTOR_SIZE * sizeof (Lisp_Object));
 return to;
 }
 DEFUN ("internal-set-lisp-face-attribute", Finternal_set_lisp_face_attribute,
 Lisp_Object old_value = Qnil;
 /* Set 1 if ATTR is QCfont.  */
 int font_attr_p = 0;
 /* Set 1 if ATTR is one of font-related attributes other than QCfont.  */
 int font_related_attr_p = 0;
 CHECK_SYMBOL (face, 0);
 CHECK_SYMBOL (attr, 1);
 face = resolve_face_name (face);
 lface = lface_from_face_name (NULL, face, 1);
 else
 {
 if (NILP (frame))
 	frame = selected_frame;
 CHECK_LIVE_FRAME (frame, 3);
 lface = lface_from_face_name (XFRAME (frame), face, 0);
 /* If a frame-local face doesn't exist yet, create one.  */
 if (NILP (lface))
 	lface = Finternal_make_lisp_face (face, frame);
 }
 	     && !EQ (value, Qnil))
 	    /* Underline color.  */
 	    || (STRINGP (value)
 		&& XSTRING (value)->size == 0))
 	  signal_error ("Invalid face underline", value);
 old_value = LFACE_UNDERLINE (lface);
 LFACE_UNDERLINE (lface) = value;
 }
 else if (EQ (attr, QCoverline))
 {
 	     && !EQ (value, Qnil))
 	    /* Overline color.  */
 	    || (STRINGP (value)
 		&& XSTRING (value)->size == 0))
 	  signal_error ("Invalid face overline", value);
 old_value = LFACE_OVERLINE (lface);
 LFACE_OVERLINE (lface) = value;
 }
 else if (EQ (attr, QCstrike_through))
 {
 	     && !EQ (value, Qnil))
 	    /* Strike-through color.  */
 	    || (STRINGP (value)
 		&& XSTRING (value)->size == 0))
 	  signal_error ("Invalid face strike-through", value);
 old_value = LFACE_STRIKE_THROUGH (lface);
 LFACE_STRIKE_THROUGH (lface) = value;
 }
 else if (EQ (attr, QCbox))
 {
 int valid_p;
 /* Allow t meaning a simple box of width 1 in foreground color
 of the face.  */
 if (EQ (value, Qt))
 	value = make_number (1);
 else if (STRINGP (value))
 	valid_p = XSTRING (value)->size > 0;
 else if (CONSP (value))
 	{
 	  Lisp_Object tem;
 	  tem = value;
 	  while (CONSP (tem))
 	    {
 	      Lisp_Object k, v;
 	      tem = XCDR (tem);
 	      if (!CONSP (tem))
 		break;
 	      v = XCAR (tem);
 	      tem = XCDR (tem);
 	      if (EQ (k, QCline_width))
 		{
 		  if (!INTEGERP (v) || XINT (v) <= 0)
 		    break;
 		}
 else
 	valid_p = 0;
 if (!valid_p)
 	signal_error ("Invalid face box", value);
 old_value = LFACE_BOX (lface);
 LFACE_BOX (lface) = value;
 }
 else if (EQ (attr, QCinverse_video)
 	   || EQ (attr, QCreverse_video))
 CHECK_STRING (value, 3);
 if (EQ (frame, Qt))
 	f = SELECTED_FRAME ();
 else
 	f = check_x_frame (frame);
 /* VALUE may be a fontset name or an alias of fontset.  In such
 a case, use the base fontset name.  */
 tmp = Fquery_fontset (value, Qnil);
 if (!NILP (tmp))
 	value = tmp;
 && NILP (Fequal (old_value, value)))
 {
 Lisp_Object param;
 param = Qnil;
 if (EQ (face, Qdefault))
 	{
 	  /* Changed font-related attributes of the `default' face are
 	     reflected in changed `font' frame parameters. */
 	  if ((font_related_attr_p || font_attr_p)
 if (!NILP (param))
 	Fmodify_frame_parameters (frame, Fcons (Fcons (param, value), Qnil));
 }
 #endif /* HAVE_WINDOW_SYSTEM */
 return face;
 }
 #ifdef HAVE_WINDOW_SYSTEM
 /* If there are no faces yet, give up.  This is the case when called
 from Fx_create_frame, and we do the necessary things later in
 face-set-after-frame-defaults.  */
 if (NILP (f->face_alist))
 return;
 if (EQ (param, Qforeground_color))
 {
 lface = lface_from_face_name (f, Qdefault, 1);
 LFACE_FOREGROUND (lface) = (STRINGP (new_value)
 				  ? new_value : Qunspecified);
 /* Changing the background color might change the background
 	 mode, so that we have to load new defface specs.  Call
 	 frame-update-face-colors to do that.  */
 XSETFRAME (frame, f);
 call1 (Qframe_update_face_colors, frame);
 lface = lface_from_face_name (f, Qdefault, 1);
 LFACE_BACKGROUND (lface) = (STRINGP (new_value)
 				  ? new_value : Qunspecified);
 realize_basic_faces (f);
 }
 /* Return resource string VALUE as a boolean value, i.e. nil, or t.
 If VALUE is "on" or "true", return t.  If VALUE is "off" or
 "false", return nil.  Otherwise, if SIGNAL_P is non-zero, signal an
 error; if SIGNAL_P is zero, return 0.  */
 static Lisp_Object
 face_boolean_x_resource_value (value, signal_p)
 Lisp_Object value;
 int signal_p;
 {
 Lisp_Object result = make_number (0);
 xassert (STRINGP (value));
 if (xstricmp (XSTRING (value)->data, "on") == 0
 || xstricmp (XSTRING (value)->data, "true") == 0)
 result = Qt;
 else if (xstricmp (XSTRING (value)->data, "off") == 0
 	   || xstricmp (XSTRING (value)->data, "false") == 0)
 Widget w;
 XtPointer p;
 {
 Widget submenu = 0;
 struct x_resources *res = (struct x_resources *) p;
 XtSetValues (w, res->av, res->ac);
 XtVaGetValues (w, XmNsubMenuId, &submenu, NULL);
 if (submenu)
 {
 XtSetValues (submenu, res->av, res->ac);
 ++ac;
 #endif
 }
 xassert (ac <= sizeof av / sizeof *av);
 if (ac)
 {
 struct x_resources res;
 XtSetValues (widget, av, ac);
 res.av = av, res.ac = ac;
 XtApplyToWidgets (widget, xm_apply_resources, &res);
 if (fl)
 	XmFontListFree (fl);
 }
 if (ac)
 {
 struct x_resources res;
 XtSetValues (widget, av, ac);
 /* We must do children here in case we're handling a pop-up menu
 	 in which case WIDGET is a popup shell.  XtApplyToWidgets
 	 is a function from lwlib.  */
 /* Realized faces may have been removed on frame F, e.g. because of
 face attribute changes.  Recompute them, if necessary, since we
 will need the `menu' face.  */
 if (f->face_cache->used == 0)
 recompute_basic_faces (f);
 #ifdef USE_LUCID
 xl_set_menu_resources_from_menu_face (f, widget);
 #endif
 #ifdef USE_MOTIF
 xm_set_menu_resources_from_menu_face (f, widget);
 frames).  If FRAME is omitted or nil, use the selected frame.")
 (symbol, keyword, frame)
 Lisp_Object symbol, keyword, frame;
 {
 Lisp_Object lface, value = Qnil;
 CHECK_SYMBOL (symbol, 0);
 CHECK_SYMBOL (keyword, 1);
 if (EQ (frame, Qt))
 lface = lface_from_face_name (NULL, symbol, 1);
 Value is nil if ATTR doesn't have a discrete set of valid values.")
 (attr)
 Lisp_Object attr;
 {
 Lisp_Object result = Qnil;
 CHECK_SYMBOL (attr, 0);
 if (EQ (attr, QCweight)
 || EQ (attr, QCslant)
 || EQ (attr, QCwidth))
 {
 /* Extract permissible symbols from tables.  */
 struct table_entry *table;
 int i, dim;
 if (EQ (attr, QCweight))
 	table = weight_table, dim = DIM (weight_table);
 else if (EQ (attr, QCslant))
 	table = slant_table, dim = DIM (slant_table);
 else
 else if (EQ (attr, QCinverse_video) || EQ (attr, QCreverse_video))
 result = Fcons (Qt, Fcons (Qnil, Qnil));
 return result;
 }
 DEFUN ("internal-merge-in-global-face", Finternal_merge_in_global_face,
 Sinternal_merge_in_global_face, 2, 2, 0,
 "Add attributes from frame-default definition of FACE to FACE on FRAME.")
 (face, frame)
 Lisp_Object face, frame;
 {
 Lisp_Object global_lface, local_lface;
 /* The following function is implemented for compatibility with 20.2.
 The function is used in x-resolve-fonts when it is asked to
 return fonts with the same size as the font of a face.  This is
 done in fontset.el.  */
 DEFUN ("face-font", Fface_font, Sface_font, 1, 2, 0,
 "Return the font name of face FACE, or nil if it is unspecified.\n\
 If the optional argument FRAME is given, report on face FACE in that frame.\n\
 If FRAME is t, report on the defaults for face FACE (for new frames).\n\
 The font default for a face is either nil, or a list\n\
 of the form (bold), (italic) or (bold italic).\n\
 Lisp_Object lface = lface_from_face_name (NULL, face, 1);
 if (!UNSPECIFIEDP (LFACE_WEIGHT (lface))
 	  && !EQ (LFACE_WEIGHT (lface), Qnormal))
 	result = Fcons (Qbold, result);
 if (!NILP (LFACE_SLANT (lface))
 	  && !EQ (LFACE_SLANT (lface), Qnormal))
 	result = Fcons (Qitalic, result);
 return result;
 }
 else
 {
 struct frame *f = frame_or_selected_frame (frame, 1);
 	    case Lisp_String:
 	      equal_p = (XSTRING (a)->size == XSTRING (b)->size
 			 && bcmp (XSTRING (a)->data, XSTRING (b)->data,
 				  XSTRING (a)->size) == 0);
 	      break;
 	    case Lisp_Int:
 	    case Lisp_Symbol:
 	      equal_p = 0;
 	      break;
 	    default:
 	      equal_p = !NILP (Fequal (a, b));
 	      break;
 	    }
 	}
 }
 return equal_p;
 }
 DEFUN ("internal-lisp-face-equal-p", Finternal_lisp_face_equal_p,
 Lisp_Object face1, face2, frame;
 {
 int equal_p;
 struct frame *f;
 Lisp_Object lface1, lface2;
 if (EQ (frame, Qt))
 f = NULL;
 else
 /* Don't use check_x_frame here because this function is called
 before X frames exist.  At that time, if FRAME is nil,
 equal_p = lface_equal_p (XVECTOR (lface1)->contents,
 			   XVECTOR (lface2)->contents);
 return equal_p ? Qt : Qnil;
 }
 DEFUN ("internal-lisp-face-empty-p", Finternal_lisp_face_empty_p,
 Sinternal_lisp_face_empty_p, 1, 2, 0,
 "True if FACE has no attribute specified.\n\
 If the optional argument FRAME is given, report on face FACE in that frame.\n\
 If FRAME is t, report on the defaults for face FACE (for new frames).\n\
 if (NILP (frame))
 frame = selected_frame;
 CHECK_LIVE_FRAME (frame, 0);
 f = XFRAME (frame);
 if (EQ (frame, Qt))
 lface = lface_from_face_name (NULL, face, 1);
 else
 lface = lface_from_face_name (f, face, 1);
 for (i = 1; i < LFACE_VECTOR_SIZE; ++i)
 if (!UNSPECIFIEDP (XVECTOR (lface)->contents[i]))
 break;
 return i == LFACE_VECTOR_SIZE ? Qt : Qnil;
 }
 DEFUN ("frame-face-alist", Fframe_face_alist, Sframe_face_alist,
 0, 1, 0,
 "Return an alist of frame-local faces defined on FRAME.\n\
 For internal use only.")
 (frame)
 Lisp_Object frame;
 {
 	  if (face->gc)
 	    {
 	      x_free_gc (f, face->gc);
 	      face->gc = 0;
 	    }
 	  free_face_colors (f, face);
 	  x_destroy_bitmap (f, face->stipple);
 	}
 #endif /* HAVE_WINDOW_SYSTEM */
 struct frame *f;
 struct face *face;
 {
 #ifdef HAVE_WINDOW_SYSTEM
 xassert (FRAME_WINDOW_P (f));
 if (face->gc == 0)
 {
 XGCValues xgcv;
 unsigned long mask = GCForeground | GCBackground | GCGraphicsExposures;
 for (i = 0; i < c->used; ++i)
 	{
 	  free_realized_face (f, c->faces_by_id[i]);
 	  c->faces_by_id[i] = NULL;
 	}
 c->used = 0;
 size = FACE_CACHE_BUCKETS_SIZE * sizeof *c->buckets;
 bzero (c->buckets, size);
 /* Must do a thorough redisplay the next time.  Mark current
 /* We must block input here because we can't process X events safely
 while only some faces are freed, or when the frame's current
 matrix still references freed faces.  */
 BLOCK_INPUT;
 for (i = 0; i < cache->used; i++)
 {
 face = cache->faces_by_id[i];
 if (face
 	  && face != face->ascii_face
 	{
 	  uncache_face (cache, face);
 	  free_realized_face (f, face);
 	}
 }
 /* Must do a thorough redisplay the next time.  Mark current
 matrices as invalid because they will reference faces freed
 above.  This function is also called when a frame is destroyed.
 In this case, the root window of F is nil.  */
 if (WINDOWP (f->root_window))
 {
 clear_current_matrices (f);
 ++windows_or_buffers_changed;
 }
 UNBLOCK_INPUT;
 }
 /* Free all realized faces on FRAME or on all frames if FRAME is nil.
 slot as FACE->id.  */
 for (i = 0; i < c->used; ++i)
 if (c->faces_by_id[i] == NULL)
 break;
 face->id = i;
 /* Maybe enlarge C->faces_by_id.  */
 if (i == c->used && c->used == c->size)
 {
 int new_size = 2 * c->size;
 int sz = new_size * sizeof *c->faces_by_id;
 	  ++n;
 xassert (n == 1);
 }
 #endif /* GLYPH_DEBUG */
 c->faces_by_id[i] = face;
 if (i == c->used)
 ++c->used;
 }
 uncache_face (c, face)
 struct face_cache *c;
 struct face *face;
 {
 int i = face->hash % FACE_CACHE_BUCKETS_SIZE;
 if (face->prev)
 face->prev->next = face->next;
 else
 c->buckets[i] = face->next;
 if (face->next)
 face->next->prev = face->prev;
 c->faces_by_id[face->id] = NULL;
 if (face->id == c->used)
 --c->used;
 }
 check_lface_attrs (attr);
 /* Look up ATTR in the face cache.  */
 hash = lface_hash (attr);
 i = hash % FACE_CACHE_BUCKETS_SIZE;
 for (face = cache->buckets[i]; face; face = face->next)
 if (face->hash == hash
 	&& (!FRAME_WINDOW_P (f)
 	    || FACE_SUITABLE_FOR_CHAR_P (face, c))
 	&& lface_equal_p (face->lface, attr))
 #if 0
 if (FRAME_WINDOW_P (f))
 xassert (FACE_SUITABLE_FOR_CHAR_P (face, c));
 #endif
 #endif /* GLYPH_DEBUG */
 return face->id;
 }
 /* Return the face id of the realized face for named face SYMBOL on
 ascii_face_of_lisp_face (f, lface_id)
 struct frame *f;
 int lface_id;
 {
 int face_id;
 if (lface_id >= 0 && lface_id < lface_id_to_name_size)
 {
 Lisp_Object face_name = lface_id_to_name[lface_id];
 face_id = lookup_named_face (f, face_name, 0);
 }
 return face_id;
 /* Try in increments of 1/2 pt.  */
 delta = steps < 0 ? 5 : -5;
 steps = abs (steps);
 face = FACE_FROM_ID (f, face_id);
 bcopy (face->lface, attrs, sizeof attrs);
 pt = last_pt = XFASTINT (attrs[LFACE_HEIGHT_INDEX]);
 new_face_id = face_id;
 last_height = FONT_HEIGHT (face->font);
 return new_face_id;
 #else /* not HAVE_WINDOW_SYSTEM */
 return face_id;
 #endif /* not HAVE_WINDOW_SYSTEM */
 }
 /* Return a face for charset ASCII that is like the face with id
 face = FACE_FROM_ID (f, face_id);
 bcopy (face->lface, attrs, sizeof attrs);
 attrs[LFACE_HEIGHT_INDEX] = make_number (height);
 face_id = lookup_face (f, attrs, 0, NULL);
 #endif /* HAVE_WINDOW_SYSTEM */
 return face_id;
 }
 /* Return the face id of the realized face for named face SYMBOL on
 frame F suitable for displaying character C, and use attributes of
 Lisp_Object order;
 {
 Lisp_Object list;
 int i;
 int indices[4];
 CHECK_LIST (order, 0);
 bzero (indices, sizeof indices);
 i = 0;
 for (list = order;
 if (bcmp (indices, font_sort_order, sizeof indices) != 0)
 {
 bcopy (indices, font_sort_order, sizeof font_sort_order);
 free_all_realized_faces (Qnil);
 }
 return Qnil;
 }
 DEFUN ("internal-set-alternative-font-family-alist",
 int *values;
 struct font_name *font1, *font2;
 int compare_pt_p;
 {
 int i;
 for (i = 0; i < 4; ++i)
 {
 int xlfd_idx = font_sort_order[i];
 if (compare_pt_p || xlfd_idx != XLFD_POINT_SIZE)
 	{
 	  int delta1 = abs (values[i] - font1->numeric[xlfd_idx]);
 	  int delta2 = abs (values[i] - font2->numeric[xlfd_idx]);
 	  if (delta1 > delta2)
 	    return 0;
 	  else if (delta1 < delta2)
 	    return 1;
 	  else
 		  && font2->numeric[xlfd_idx] < values[i])
 		return 1;
 	    }
 	}
 }
 return 0;
 }
 #if SCALABLE_FONTS
 exact_face_match_p (specified, font)
 int *specified;
 struct font_name *font;
 {
 int i;
 for (i = 0; i < 4; ++i)
 if (specified[i] != font->numeric[font_sort_order[i]])
 break;
 return i == 4;
 else
 {
 pt = specified_pt;
 pixel_value = resy / 720.0 * pt;
 }
 /* Set point size of the font.  */
 sprintf (point_size, "%d", (int) pt);
 font->fields[XLFD_POINT_SIZE] = point_size;
 font->numeric[XLFD_POINT_SIZE] = pt;
 /* Set pixel size.  */
 sprintf (pixel_size, "%d", pixel_value);
 font->fields[XLFD_PIXEL_SIZE] = pixel_size;
 font->numeric[XLFD_PIXEL_SIZE] = pixel_value;
 /* If font doesn't specify its resolution, use the
 resolution of the display.  */
 if (font->numeric[XLFD_RESY] == 0)
 {
 char buffer[20];
 sprintf (buffer, "%d", (int) resy);
 font->fields[XLFD_RESY] = buffer;
 font->numeric[XLFD_RESY] = resy;
 }
 if (strcmp (font->fields[XLFD_RESX], "0") == 0)
 {
 char buffer[20];
 int resx = FRAME_X_DISPLAY_INFO (f)->resx;
 sprintf (buffer, "%d", resx);
 if (EQ (Vscalable_fonts_allowed, Qt))
 return 1;
 else if (CONSP (Vscalable_fonts_allowed))
 {
 Lisp_Object tail, regexp;
 for (tail = Vscalable_fonts_allowed; CONSP (tail); tail = XCDR (tail))
 	{
 	  regexp = XCAR (tail);
 	  if (STRINGP (regexp)
 	      && fast_c_string_match_ignore_case (regexp, name) >= 0)
 	    return 1;
 	}
 }
 return 0;
 }
 #endif /* SCALABLE_FONTS != 0 */
 /* Make specified font attributes available in `specified',
 indexed by sort order.  */
 for (i = 0; i < DIM (font_sort_order); ++i)
 {
 int xlfd_idx = font_sort_order[i];
 if (xlfd_idx == XLFD_SWIDTH)
 	specified[i] = face_numeric_swidth (attrs[LFACE_SWIDTH_INDEX]);
 else if (xlfd_idx == XLFD_POINT_SIZE)
 	specified[i] = pt = XFASTINT (attrs[LFACE_HEIGHT_INDEX]);
 else if (xlfd_idx == XLFD_WEIGHT)
 #if SCALABLE_FONTS
 /* Set to 1 */
 exact_p = 0;
 /* Start with the first non-scalable font in the list.  */
 for (i = 0; i < nfonts; ++i)
 if (!font_scalable_p (fonts + i))
 break;
 /* Find the best match among the non-scalable fonts.  */
 if (i < nfonts)
 {
 best = fonts + i;
 for (i = 1; i < nfonts; ++i)
 	if (!font_scalable_p (fonts + i)
 	    && better_font_p (specified, fonts + i, best, 1))
 	  {
 	    best = fonts + i;
 	    exact_p = exact_face_match_p (specified, best);
 	    if (exact_p)
 	      break;
 	  }
 }
 else
 best = NULL;
 /* Unless we found an exact match among non-scalable fonts, see if
 if (!exact_p)
 {
 /* A scalable font is better if
 	 1. its weight, slant, swidth attributes are better, or.
 	 2. the best non-scalable font doesn't have the required
 	 point size, and the scalable fonts weight, slant, swidth
 	 isn't worse.  */
 int non_scalable_has_exact_height_p;
 if (best && best->numeric[XLFD_POINT_SIZE] == pt)
 	non_scalable_has_exact_height_p = 1;
 else
 	non_scalable_has_exact_height_p = 0;
 for (i = 0; i < nfonts; ++i)
 	if (font_scalable_p (fonts + i))
 	  {
 	    if (best == NULL
 		|| better_font_p (specified, fonts + i, best, 0)
 if (font_scalable_p (best))
 font_name = build_scalable_font_name (f, best, pt);
 else
 font_name = build_font_name (best);
 #else /* !SCALABLE_FONTS */
 /* Find the best non-scalable font.  */
 best = fonts;
 for (i = 1; i < nfonts; ++i)
 {
 xassert (!font_scalable_p (fonts + i));
 if (better_font_p (specified, fonts + i, best, 1))
 	best = fonts + i;
 }
 font_name = build_font_name (best);
 #endif /* !SCALABLE_FONTS */
 /* Free font_name structures.  */
 free_font_names (fonts, nfonts);
 return font_name;
 }
 /* Try to get a list of fonts on frame F with font family FAMILY and
 {
 int nfonts;
 if (NILP (family) && STRINGP (attrs[LFACE_FAMILY_INDEX]))
 family = attrs[LFACE_FAMILY_INDEX];
 nfonts = font_list (f, pattern, family, registry, fonts);
 if (nfonts == 0 && !NILP (family))
 {
 Lisp_Object alter;
 /* Try alternative font families from
 	 Vface_alternative_font_family_alist.  */
 alter = Fassoc (family, Vface_alternative_font_family_alist);
 if (CONSP (alter))
 	for (alter = XCDR (alter);
 	     alter = XCDR (alter))
 	  {
 	    if (STRINGP (XCAR (alter)))
 	      nfonts = font_list (f, Qnil, XCAR (alter), registry, fonts);
 	  }
 /* Try font family of the default face or "fixed".  */
 if (nfonts == 0)
 	{
 	  struct face *dflt = FACE_FROM_ID (f, DEFAULT_FACE_ID);
 	  if (dflt)
 	    family = dflt->lface[LFACE_FAMILY_INDEX];
 	  else
 	    family = build_string ("fixed");
 	  nfonts = font_list (f, Qnil, family, registry, fonts);
 	}
 /* Try any family with the given registry.  */
 if (nfonts == 0)
 	nfonts = font_list (f, Qnil, Qnil, registry, fonts);
 }
 face_fontset (attrs)
 Lisp_Object *attrs;
 {
 Lisp_Object name;
 int fontset;
 name = attrs[LFACE_FONT_INDEX];
 if (!STRINGP (name))
 return -1;
 return fs_query_fontset (name, 0);
 }
 {
 Lisp_Object pattern;
 char *font_name = NULL;
 struct font_name *fonts;
 int nfonts;
 /* Get (foundry and) family name and registry (and encoding) name of
 a font for C.  */
 pattern = fontset_font_pattern (f, fontset, c);
 if (NILP (pattern))
 {
 character.  */
 if (STRINGP (attrs[LFACE_FAMILY_INDEX])
 && SINGLE_BYTE_CHAR_P (c))
 XCAR (pattern) = Qnil;
 /* Get a list of fonts matching that pattern and choose the
 best match for the specified face attributes from it.  */
 nfonts = try_font_list (f, attrs, Qnil, XCAR (pattern), XCDR (pattern),
 			  &fonts);
 font_name = best_matching_font (f, attrs, fonts, nfonts);
 return font_name;
 int success_p = 0;
 /* Block input there so that we won't be surprised by an X expose
 event, for instance without having the faces set up.  */
 BLOCK_INPUT;
 if (realize_default_face (f))
 {
 realize_named_face (f, Qmode_line, MODE_LINE_FACE_ID);
 realize_named_face (f, Qtool_bar, TOOL_BAR_FACE_ID);
 realize_named_face (f, Qfringe, BITMAP_AREA_FACE_ID);
 LFACE_SWIDTH (lface) = Qnormal;
 LFACE_HEIGHT (lface) = make_number (1);
 LFACE_WEIGHT (lface) = Qnormal;
 LFACE_SLANT (lface) = Qnormal;
 }
 if (UNSPECIFIEDP (LFACE_UNDERLINE (lface)))
 LFACE_UNDERLINE (lface) = Qnil;
 if (UNSPECIFIEDP (LFACE_OVERLINE (lface)))
 LFACE_OVERLINE (lface) = Qnil;
 if (UNSPECIFIEDP (LFACE_STRIKE_THROUGH (lface)))
 LFACE_STRIKE_THROUGH (lface) = Qnil;
 if (UNSPECIFIEDP (LFACE_BOX (lface)))
 LFACE_BOX (lface) = Qnil;
 if (UNSPECIFIEDP (LFACE_INVERSE (lface)))
 LFACE_INVERSE (lface) = Qnil;
 if (UNSPECIFIEDP (LFACE_FOREGROUND (lface)))
 {
 /* This function is called so early that colors are not yet
 	 set in the frame parameter list.  */
 Lisp_Object color = Fassq (Qforeground_color, f->param_alist);
 if (CONSP (color) && STRINGP (XCDR (color)))
 	LFACE_FOREGROUND (lface) = XCDR (color);
 else if (FRAME_WINDOW_P (f))
 	return 0;
 else if (FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f))
 	LFACE_FOREGROUND (lface) = build_string (unspecified_fg);
 else
 	abort ();
 }
 if (UNSPECIFIEDP (LFACE_BACKGROUND (lface)))
 {
 /* This function is called so early that colors are not yet
 	 set in the frame parameter list.  */
 Lisp_Object color = Fassq (Qbackground_color, f->param_alist);
 else if (FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f))
 	LFACE_BACKGROUND (lface) = build_string (unspecified_bg);
 else
 	abort ();
 }
 if (UNSPECIFIEDP (LFACE_STIPPLE (lface)))
 LFACE_STIPPLE (lface) = Qnil;
 /* Realize the face; it must be fully-specified now.  */
 xassert (lface_fully_specified_p (XVECTOR (lface)->contents));
 int c;
 struct face *base_face;
 int former_face_id;
 {
 struct face *face;
 /* LFACE must be fully specified.  */
 xassert (cache != NULL);
 check_lface_attrs (attrs);
 if (former_face_id >= 0 && cache->used > former_face_id)
 face->gc = 0;
 /* Don't try to free the colors copied bitwise from BASE_FACE.  */
 face->foreground_defaulted_p = 1;
 face->background_defaulted_p = 1;
 face->underline_defaulted_p = 1;
 face->overline_color_defaulted_p = 1;
 face->strike_through_color_defaulted_p = 1;
 face->box_color_defaulted_p = 1;
 /* to force realize_face to load font */
 face->font = NULL;
 return face;
 }
 	 registry and encoding of a font.  It may also determine
 	 foundry and family.  The other fields of font name pattern
 	 are constructed from ATTRS.  */
 int fontset = face_fontset (attrs);
-if (fontset == -1)
+if ((fontset == -1) && default_face)
 	fontset = default_face->fontset;
 face->fontset = make_fontset_for_ascii_face (f, fontset);
 face->font = NULL;	/* to force realize_face to load font */
 }
 /* Load colors, and set remaining attributes.  */
 load_face_colors (f, face, attrs);
 /* Set up box.  */
 box = attrs[LFACE_BOX_INDEX];
 if (STRINGP (box))
 	    }
 	}
 }
 /* Text underline, overline, strike-through.  */
 if (EQ (attrs[LFACE_UNDERLINE_INDEX], Qt))
 {
 /* Use default color (same as foreground color).  */
 face->underline_p = 1;
 face->underline_defaulted_p = 1;
 face->underline_color = 0;
 }
 Lisp_Object frame;
 int face_colors_defaulted = 0;
 /* Frame must be a termcap frame.  */
 xassert (FRAME_TERMCAP_P (cache->f) || FRAME_MSDOS_P (cache->f));
 /* Allocate a new realized face.  */
 face = make_realized_face (attrs);
 face->font_name = FRAME_MSDOS_P (cache->f) ? "ms-dos" : "tty";
 /* Map face attributes to TTY appearances.  We map slant to
 dimmed text because we want italic text to appear differently
 and because dimmed text is probably used infrequently.  */
 weight = face_numeric_weight (attrs[LFACE_WEIGHT_INDEX]);
 slant = face_numeric_slant (attrs[LFACE_SLANT_INDEX]);
 {
 int face_id;
 if (NILP (current_buffer->enable_multibyte_characters))
 ch = -1;
 if (NILP (prop))
 {
 struct face *face = FACE_FROM_ID (f, DEFAULT_FACE_ID);
 face_id = FACE_FOR_CHAR (f, face, ch);
 }
 }
 *endptr = endpos;
 default_face = FACE_FROM_ID (f, DEFAULT_FACE_ID);
 /* Optimize common cases where we can use the default face.  */
 if (noverlays == 0
 && NILP (prop)
 && !(pos >= region_beg && pos < region_end))
 return DEFAULT_FACE_ID;
 /* If in the region, merge in the region face.  */
 if (pos >= region_beg && pos < region_end)
 {
 Lisp_Object region_face = lface_from_face_name (f, Qregion, 0);
 merge_face_vectors (XVECTOR (region_face)->contents, attrs);
 if (region_end < endpos)
 	endpos = region_end;
 }
 *endptr = endpos;
 REGION_BEG and REGION_END give the start and end positions of the
 region; both are -1 if no region is visible.  BASE_FACE_ID is the
 id of the basic face to merge with.  It is usually equal to
 DEFAULT_FACE_ID but can be MODE_LINE_FACE_ID or HEADER_LINE_FACE_ID
 for strings displayed in the mode or top line.
 Set *ENDPTR to the next position where to check for faces in
 STRING; -1 if the face is constant from POS to the end of the
 string.
 Value is the id of the face to use.  The face returned is suitable
 Lisp_Object n;
 {
 if (NILP (n))
 {
 int i;
 fprintf (stderr, "font selection order: ");
 for (i = 0; i < DIM (font_sort_order); ++i)
 	fprintf (stderr, "%d ", font_sort_order[i]);
 fprintf (stderr, "\n");
 fprintf (stderr, "alternative fonts: ");
 debug_print (Vface_alternative_font_family_alist);
 fprintf (stderr, "\n");
 for (i = 0; i < FRAME_FACE_CACHE (SELECTED_FRAME ())->used; ++i)
 	Fdump_face (make_number (i));
 }
 else
 {
 face = FACE_FROM_ID (SELECTED_FRAME (), XINT (n));
 if (face == NULL)
 	error ("Not a valid face");
 dump_realized_face (face);
 }
 return Qnil;
 }
 DEFUN ("show-face-resources", Fshow_face_resources, Sshow_face_resources,
 staticpro (&Qface);
 Qbitmap_spec_p = intern ("bitmap-spec-p");
 staticpro (&Qbitmap_spec_p);
 Qframe_update_face_colors = intern ("frame-update-face-colors");
 staticpro (&Qframe_update_face_colors);
 /* Lisp face attribute keywords.  */
 QCfamily = intern (":family");
 staticpro (&QCfamily);
 QCheight = intern (":height");
 staticpro (&QCheight);
 QCslant = intern (":slant");
 staticpro (&QCslant);
 QCunderline = intern (":underline");
 staticpro (&QCunderline);
 QCinverse_video = intern (":inverse-video");
 staticpro (&QCinverse_video);
 QCreverse_video = intern (":reverse-video");
 staticpro (&QCreverse_video);
 QCforeground = intern (":foreground");
 staticpro (&QCforeground);
 QCbackground = intern (":background");
 Vfont_list_limit = make_number (DEFAULT_FONT_LIST_LIMIT);
 DEFVAR_LISP ("face-new-frame-defaults", &Vface_new_frame_defaults,
 "List of global face definitions (for internal use only.)");
 Vface_new_frame_defaults = Qnil;
 DEFVAR_LISP ("face-default-stipple", &Vface_default_stipple,
 "*Default stipple pattern used on monochrome displays.\n\
 This stipple pattern is used on monochrome displays\n\
 instead of shades of gray for a face background color.\n\
 See `set-face-stipple' for possible values for this variable.");
 DEFVAR_LISP ("face-alternative-font-family-alist",
 	       &Vface_alternative_font_family_alist, "");
 Vface_alternative_font_family_alist = Qnil;
 #if SCALABLE_FONTS
 DEFVAR_LISP ("scalable-fonts-allowed", &Vscalable_fonts_allowed,
 "Allowed scalable fonts.\n\
 A value of nil means don't allow any scalable fonts.\n\
 A value of t means allow any scalable font.\n\
 Otherwise, value must be a list of regular expressions.  A font may be\n\

Mercurial > emacs

comparison src/xfaces.c @ 30235:5a0d447b7eea