}
DEF_GNUTLS_FN (gnutls_alert_description_t, gnutls_alert_get,
- (gnutls_session_t));
+ (gnutls_session_t));
DEF_GNUTLS_FN (const char *, gnutls_alert_get_name,
- (gnutls_alert_description_t));
+ (gnutls_alert_description_t));
DEF_GNUTLS_FN (int, gnutls_alert_send_appropriate, (gnutls_session_t, int));
DEF_GNUTLS_FN (int, gnutls_anon_allocate_client_credentials,
- (gnutls_anon_client_credentials_t *));
+ (gnutls_anon_client_credentials_t *));
DEF_GNUTLS_FN (void, gnutls_anon_free_client_credentials,
- (gnutls_anon_client_credentials_t));
+ (gnutls_anon_client_credentials_t));
DEF_GNUTLS_FN (int, gnutls_bye, (gnutls_session_t, gnutls_close_request_t));
DEF_GNUTLS_FN (int, gnutls_certificate_allocate_credentials,
- (gnutls_certificate_credentials_t *));
+ (gnutls_certificate_credentials_t *));
DEF_GNUTLS_FN (void, gnutls_certificate_free_credentials,
- (gnutls_certificate_credentials_t));
+ (gnutls_certificate_credentials_t));
DEF_GNUTLS_FN (const gnutls_datum_t *, gnutls_certificate_get_peers,
- (gnutls_session_t, unsigned int *));
+ (gnutls_session_t, unsigned int *));
DEF_GNUTLS_FN (void, gnutls_certificate_set_verify_flags,
- (gnutls_certificate_credentials_t, unsigned int));
+ (gnutls_certificate_credentials_t, unsigned int));
DEF_GNUTLS_FN (int, gnutls_certificate_set_x509_crl_file,
- (gnutls_certificate_credentials_t, const char *,
- gnutls_x509_crt_fmt_t));
+ (gnutls_certificate_credentials_t, const char *,
+ gnutls_x509_crt_fmt_t));
DEF_GNUTLS_FN (int, gnutls_certificate_set_x509_key_file,
- (gnutls_certificate_credentials_t, const char *, const char *,
- gnutls_x509_crt_fmt_t));
+ (gnutls_certificate_credentials_t, const char *, const char *,
+ gnutls_x509_crt_fmt_t));
DEF_GNUTLS_FN (int, gnutls_certificate_set_x509_trust_file,
- (gnutls_certificate_credentials_t, const char *,
- gnutls_x509_crt_fmt_t));
+ (gnutls_certificate_credentials_t, const char *,
+ gnutls_x509_crt_fmt_t));
DEF_GNUTLS_FN (gnutls_certificate_type_t, gnutls_certificate_type_get,
- (gnutls_session_t));
+ (gnutls_session_t));
DEF_GNUTLS_FN (int, gnutls_certificate_verify_peers2,
- (gnutls_session_t, unsigned int *));
+ (gnutls_session_t, unsigned int *));
DEF_GNUTLS_FN (int, gnutls_credentials_set,
- (gnutls_session_t, gnutls_credentials_type_t, void *));
+ (gnutls_session_t, gnutls_credentials_type_t, void *));
DEF_GNUTLS_FN (void, gnutls_deinit, (gnutls_session_t));
DEF_GNUTLS_FN (void, gnutls_dh_set_prime_bits,
- (gnutls_session_t, unsigned int));
+ (gnutls_session_t, unsigned int));
DEF_GNUTLS_FN (int, gnutls_error_is_fatal, (int));
DEF_GNUTLS_FN (int, gnutls_global_init, (void));
DEF_GNUTLS_FN (void, gnutls_global_set_log_function, (gnutls_log_func));
DEF_GNUTLS_FN (int, gnutls_handshake, (gnutls_session_t));
DEF_GNUTLS_FN (int, gnutls_init, (gnutls_session_t *, gnutls_connection_end_t));
DEF_GNUTLS_FN (int, gnutls_priority_set_direct,
- (gnutls_session_t, const char *, const char **));
+ (gnutls_session_t, const char *, const char **));
DEF_GNUTLS_FN (size_t, gnutls_record_check_pending, (gnutls_session_t));
DEF_GNUTLS_FN (ssize_t, gnutls_record_recv, (gnutls_session_t, void *, size_t));
DEF_GNUTLS_FN (ssize_t, gnutls_record_send,
- (gnutls_session_t, const void *, size_t));
+ (gnutls_session_t, const void *, size_t));
DEF_GNUTLS_FN (const char *, gnutls_strerror, (int));
DEF_GNUTLS_FN (void, gnutls_transport_set_errno, (gnutls_session_t, int));
DEF_GNUTLS_FN (void, gnutls_transport_set_lowat, (gnutls_session_t, int));
DEF_GNUTLS_FN (void, gnutls_transport_set_ptr2,
- (gnutls_session_t, gnutls_transport_ptr_t,
- gnutls_transport_ptr_t));
+ (gnutls_session_t, gnutls_transport_ptr_t,
+ gnutls_transport_ptr_t));
DEF_GNUTLS_FN (void, gnutls_transport_set_pull_function,
- (gnutls_session_t, gnutls_pull_func));
+ (gnutls_session_t, gnutls_pull_func));
DEF_GNUTLS_FN (void, gnutls_transport_set_push_function,
- (gnutls_session_t, gnutls_push_func));
+ (gnutls_session_t, gnutls_push_func));
DEF_GNUTLS_FN (int, gnutls_x509_crt_check_hostname,
- (gnutls_x509_crt_t, const char *));
+ (gnutls_x509_crt_t, const char *));
DEF_GNUTLS_FN (void, gnutls_x509_crt_deinit, (gnutls_x509_crt_t));
DEF_GNUTLS_FN (int, gnutls_x509_crt_import,
- (gnutls_x509_crt_t, const gnutls_datum_t *,
- gnutls_x509_crt_fmt_t));
+ (gnutls_x509_crt_t, const gnutls_datum_t *,
+ gnutls_x509_crt_fmt_t));
DEF_GNUTLS_FN (int, gnutls_x509_crt_init, (gnutls_x509_crt_t *));
static int
max_log_level = global_gnutls_log_level;
GNUTLS_LOG2 (1, max_log_level, "GnuTLS library loaded:",
- SDATA (Fget (Qgnutls_dll, QCloaded_from)));
+ SDATA (Fget (Qgnutls_dll, QCloaded_from)));
return 1;
}
{
#ifdef WINDOWSNT
/* On W32 we cannot transfer socket handles between different runtime
- libraries, so we tell GnuTLS to use our special push/pull
- functions. */
+ libraries, so we tell GnuTLS to use our special push/pull
+ functions. */
fn_gnutls_transport_set_ptr2 (state,
- (gnutls_transport_ptr_t) proc,
- (gnutls_transport_ptr_t) proc);
+ (gnutls_transport_ptr_t) proc,
+ (gnutls_transport_ptr_t) proc);
fn_gnutls_transport_set_push_function (state, &emacs_gnutls_push);
fn_gnutls_transport_set_pull_function (state, &emacs_gnutls_pull);
/* For non blocking sockets or other custom made pull/push
- functions the gnutls_transport_set_lowat must be called, with
- a zero low water mark value. (GnuTLS 2.10.4 documentation)
+ functions the gnutls_transport_set_lowat must be called, with
+ a zero low water mark value. (GnuTLS 2.10.4 documentation)
- (Note: this is probably not strictly necessary as the lowat
- value is only used when no custom pull/push functions are
- set.) */
+ (Note: this is probably not strictly necessary as the lowat
+ value is only used when no custom pull/push functions are
+ set.) */
fn_gnutls_transport_set_lowat (state, 0);
#else
/* This is how GnuTLS takes sockets: as file descriptors passed
- in. For an Emacs process socket, infd and outfd are the
- same but we use this two-argument version for clarity. */
+ in. For an Emacs process socket, infd and outfd are the
+ same but we use this two-argument version for clarity. */
fn_gnutls_transport_set_ptr2 (state,
- (gnutls_transport_ptr_t) (long) proc->infd,
- (gnutls_transport_ptr_t) (long) proc->outfd);
+ (gnutls_transport_ptr_t) (long) proc->infd,
+ (gnutls_transport_ptr_t) (long) proc->outfd);
#endif
proc->gnutls_initstage = GNUTLS_STAGE_TRANSPORT_POINTERS_SET;
rtnval = fn_gnutls_record_send (state, buf, nbyte);
if (rtnval < 0)
- {
- if (rtnval == GNUTLS_E_AGAIN || rtnval == GNUTLS_E_INTERRUPTED)
- continue;
- else
- break;
- }
+ {
+ if (rtnval == GNUTLS_E_AGAIN || rtnval == GNUTLS_E_INTERRUPTED)
+ continue;
+ else
+ break;
+ }
buf += rtnval;
nbyte -= rtnval;
if (EQ (type, Qgnutls_x509pki))
{
- GNUTLS_LOG (2, max_log_level, "deallocating x509 credentials");
- x509_cred = XPROCESS (proc)->gnutls_x509_cred;
- fn_gnutls_certificate_free_credentials (x509_cred);
+ GNUTLS_LOG (2, max_log_level, "deallocating x509 credentials");
+ x509_cred = XPROCESS (proc)->gnutls_x509_cred;
+ fn_gnutls_certificate_free_credentials (x509_cred);
}
else if (EQ (type, Qgnutls_anon))
{
- GNUTLS_LOG (2, max_log_level, "deallocating anon credentials");
- anon_cred = XPROCESS (proc)->gnutls_anon_cred;
- fn_gnutls_anon_free_client_credentials (anon_cred);
+ GNUTLS_LOG (2, max_log_level, "deallocating anon credentials");
+ anon_cred = XPROCESS (proc)->gnutls_anon_cred;
+ fn_gnutls_anon_free_client_credentials (anon_cred);
}
else
{
- error ("unknown credential type");
- ret = GNUTLS_EMACS_ERROR_INVALID_TYPE;
+ error ("unknown credential type");
+ ret = GNUTLS_EMACS_ERROR_INVALID_TYPE;
}
if (GNUTLS_INITSTAGE (proc) >= GNUTLS_STAGE_INIT)
{
- GNUTLS_LOG (1, max_log_level, "deallocating x509 credentials");
- Fgnutls_deinit (proc);
+ GNUTLS_LOG (1, max_log_level, "deallocating x509 credentials");
+ Fgnutls_deinit (proc);
}
}
fn_gnutls_certificate_allocate_credentials (&x509_cred);
if (NUMBERP (verify_flags))
- {
- gnutls_verify_flags = XINT (verify_flags);
- GNUTLS_LOG (2, max_log_level, "setting verification flags");
- }
+ {
+ gnutls_verify_flags = XINT (verify_flags);
+ GNUTLS_LOG (2, max_log_level, "setting verification flags");
+ }
else if (NILP (verify_flags))
- {
- /* The default is already GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT. */
- GNUTLS_LOG (2, max_log_level, "using default verification flags");
- }
+ {
+ /* The default is already GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT. */
+ GNUTLS_LOG (2, max_log_level, "using default verification flags");
+ }
else
- {
- /* The default is already GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT. */
- GNUTLS_LOG (2, max_log_level, "ignoring invalid verify-flags");
- }
+ {
+ /* The default is already GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT. */
+ GNUTLS_LOG (2, max_log_level, "ignoring invalid verify-flags");
+ }
fn_gnutls_certificate_set_verify_flags (x509_cred, gnutls_verify_flags);
}
else if (EQ (type, Qgnutls_anon))
for (tail = trustfiles; !NILP (tail); tail = Fcdr (tail))
{
Lisp_Object trustfile = Fcar (tail);
- if (STRINGP (trustfile))
- {
- GNUTLS_LOG2 (1, max_log_level, "setting the trustfile: ",
- SSDATA (trustfile));
- ret = fn_gnutls_certificate_set_x509_trust_file
- (x509_cred,
- SSDATA (trustfile),
- file_format);
-
- if (ret < GNUTLS_E_SUCCESS)
- return gnutls_make_error (ret);
- }
- else
- {
- error ("Sorry, GnuTLS can't use non-string trustfile %s",
- SDATA (trustfile));
- }
- }
+ if (STRINGP (trustfile))
+ {
+ GNUTLS_LOG2 (1, max_log_level, "setting the trustfile: ",
+ SSDATA (trustfile));
+ ret = fn_gnutls_certificate_set_x509_trust_file
+ (x509_cred,
+ SSDATA (trustfile),
+ file_format);
+
+ if (ret < GNUTLS_E_SUCCESS)
+ return gnutls_make_error (ret);
+ }
+ else
+ {
+ error ("Sorry, GnuTLS can't use non-string trustfile %s",
+ SDATA (trustfile));
+ }
+ }
for (tail = crlfiles; !NILP (tail); tail = Fcdr (tail))
{
Lisp_Object crlfile = Fcar (tail);
- if (STRINGP (crlfile))
- {
- GNUTLS_LOG2 (1, max_log_level, "setting the CRL file: ",
- SSDATA (crlfile));
- ret = fn_gnutls_certificate_set_x509_crl_file
- (x509_cred,
- SSDATA (crlfile),
- file_format);
-
- if (ret < GNUTLS_E_SUCCESS)
- return gnutls_make_error (ret);
- }
- else
- {
- error ("Sorry, GnuTLS can't use non-string CRL file %s",
- SDATA (crlfile));
- }
- }
+ if (STRINGP (crlfile))
+ {
+ GNUTLS_LOG2 (1, max_log_level, "setting the CRL file: ",
+ SSDATA (crlfile));
+ ret = fn_gnutls_certificate_set_x509_crl_file
+ (x509_cred,
+ SSDATA (crlfile),
+ file_format);
+
+ if (ret < GNUTLS_E_SUCCESS)
+ return gnutls_make_error (ret);
+ }
+ else
+ {
+ error ("Sorry, GnuTLS can't use non-string CRL file %s",
+ SDATA (crlfile));
+ }
+ }
for (tail = keylist; !NILP (tail); tail = Fcdr (tail))
{
Lisp_Object keyfile = Fcar (Fcar (tail));
Lisp_Object certfile = Fcar (Fcdr (tail));
- if (STRINGP (keyfile) && STRINGP (certfile))
- {
- GNUTLS_LOG2 (1, max_log_level, "setting the client key file: ",
- SSDATA (keyfile));
- GNUTLS_LOG2 (1, max_log_level, "setting the client cert file: ",
- SSDATA (certfile));
- ret = fn_gnutls_certificate_set_x509_key_file
- (x509_cred,
- SSDATA (certfile),
- SSDATA (keyfile),
- file_format);
-
- if (ret < GNUTLS_E_SUCCESS)
- return gnutls_make_error (ret);
- }
- else
- {
- if (STRINGP (keyfile))
- error ("Sorry, GnuTLS can't use non-string client cert file %s",
- SDATA (certfile));
- else
- error ("Sorry, GnuTLS can't use non-string client key file %s",
- SDATA (keyfile));
- }
- }
+ if (STRINGP (keyfile) && STRINGP (certfile))
+ {
+ GNUTLS_LOG2 (1, max_log_level, "setting the client key file: ",
+ SSDATA (keyfile));
+ GNUTLS_LOG2 (1, max_log_level, "setting the client cert file: ",
+ SSDATA (certfile));
+ ret = fn_gnutls_certificate_set_x509_key_file
+ (x509_cred,
+ SSDATA (certfile),
+ SSDATA (keyfile),
+ file_format);
+
+ if (ret < GNUTLS_E_SUCCESS)
+ return gnutls_make_error (ret);
+ }
+ else
+ {
+ if (STRINGP (keyfile))
+ error ("Sorry, GnuTLS can't use non-string client cert file %s",
+ SDATA (certfile));
+ else
+ error ("Sorry, GnuTLS can't use non-string client key file %s",
+ SDATA (keyfile));
+ }
+ }
}
GNUTLS_INITSTAGE (proc) = GNUTLS_STAGE_FILES;
{
priority_string_ptr = SSDATA (priority_string);
GNUTLS_LOG2 (1, max_log_level, "got non-default priority string:",
- priority_string_ptr);
+ priority_string_ptr);
}
else
{
GNUTLS_LOG2 (1, max_log_level, "using default priority string:",
- priority_string_ptr);
+ priority_string_ptr);
}
GNUTLS_LOG (1, max_log_level, "setting the priority string");
ret = fn_gnutls_priority_set_direct (state,
- priority_string_ptr,
- NULL);
+ priority_string_ptr,
+ NULL);
if (ret < GNUTLS_E_SUCCESS)
return gnutls_make_error (ret);
if (XINT (loglevel) > 0 && peer_verification & GNUTLS_CERT_INVALID)
message ("%s certificate could not be verified.",
- c_hostname);
+ c_hostname);
if (peer_verification & GNUTLS_CERT_REVOKED)
GNUTLS_LOG2 (1, max_log_level, "certificate was revoked (CRL):",
- c_hostname);
+ c_hostname);
if (peer_verification & GNUTLS_CERT_SIGNER_NOT_FOUND)
GNUTLS_LOG2 (1, max_log_level, "certificate signer was not found:",
- c_hostname);
+ c_hostname);
if (peer_verification & GNUTLS_CERT_SIGNER_NOT_CA)
GNUTLS_LOG2 (1, max_log_level, "certificate signer is not a CA:",
- c_hostname);
+ c_hostname);
if (peer_verification & GNUTLS_CERT_INSECURE_ALGORITHM)
GNUTLS_LOG2 (1, max_log_level,
- "certificate was signed with an insecure algorithm:",
- c_hostname);
+ "certificate was signed with an insecure algorithm:",
+ c_hostname);
if (peer_verification & GNUTLS_CERT_NOT_ACTIVATED)
GNUTLS_LOG2 (1, max_log_level, "certificate is not yet activated:",
- c_hostname);
+ c_hostname);
if (peer_verification & GNUTLS_CERT_EXPIRED)
GNUTLS_LOG2 (1, max_log_level, "certificate has expired:",
- c_hostname);
+ c_hostname);
if (peer_verification != 0)
{
if (NILP (verify_hostname_error))
{
- GNUTLS_LOG2 (1, max_log_level, "certificate validation failed:",
- c_hostname);
+ GNUTLS_LOG2 (1, max_log_level, "certificate validation failed:",
+ c_hostname);
}
else
{
- error ("Certificate validation failed %s, verification code %d",
- c_hostname, peer_verification);
+ error ("Certificate validation failed %s, verification code %d",
+ c_hostname, peer_verification);
}
}
ret = fn_gnutls_x509_crt_init (&gnutls_verify_cert);
if (ret < GNUTLS_E_SUCCESS)
- return gnutls_make_error (ret);
+ return gnutls_make_error (ret);
gnutls_verify_cert_list =
- fn_gnutls_certificate_get_peers (state, &gnutls_verify_cert_list_size);
+ fn_gnutls_certificate_get_peers (state, &gnutls_verify_cert_list_size);
if (NULL == gnutls_verify_cert_list)
- {
- error ("No x509 certificate was found!\n");
- }
+ {
+ error ("No x509 certificate was found!\n");
+ }
/* We only check the first certificate in the given chain. */
ret = fn_gnutls_x509_crt_import (gnutls_verify_cert,
- &gnutls_verify_cert_list[0],
- GNUTLS_X509_FMT_DER);
+ &gnutls_verify_cert_list[0],
+ GNUTLS_X509_FMT_DER);
if (ret < GNUTLS_E_SUCCESS)
- {
- fn_gnutls_x509_crt_deinit (gnutls_verify_cert);
- return gnutls_make_error (ret);
- }
+ {
+ fn_gnutls_x509_crt_deinit (gnutls_verify_cert);
+ return gnutls_make_error (ret);
+ }
if (!fn_gnutls_x509_crt_check_hostname (gnutls_verify_cert, c_hostname))
- {
- if (NILP (verify_hostname_error))
- {
- GNUTLS_LOG2 (1, max_log_level, "x509 certificate does not match:",
- c_hostname);
- }
- else
- {
- fn_gnutls_x509_crt_deinit (gnutls_verify_cert);
- error ("The x509 certificate does not match \"%s\"",
- c_hostname);
- }
- }
+ {
+ if (NILP (verify_hostname_error))
+ {
+ GNUTLS_LOG2 (1, max_log_level, "x509 certificate does not match:",
+ c_hostname);
+ }
+ else
+ {
+ fn_gnutls_x509_crt_deinit (gnutls_verify_cert);
+ error ("The x509 certificate does not match \"%s\"",
+ c_hostname);
+ }
+ }
fn_gnutls_x509_crt_deinit (gnutls_verify_cert);
}
state = XPROCESS (proc)->gnutls_state;
ret = fn_gnutls_bye (state,
- NILP (cont) ? GNUTLS_SHUT_RDWR : GNUTLS_SHUT_WR);
+ NILP (cont) ? GNUTLS_SHUT_RDWR : GNUTLS_SHUT_WR);
return gnutls_make_error (ret);
}
DEFSYM (Qgnutls_e_interrupted, "gnutls-e-interrupted");
Fput (Qgnutls_e_interrupted, Qgnutls_code,
- make_number (GNUTLS_E_INTERRUPTED));
+ make_number (GNUTLS_E_INTERRUPTED));
DEFSYM (Qgnutls_e_again, "gnutls-e-again");
Fput (Qgnutls_e_again, Qgnutls_code,
- make_number (GNUTLS_E_AGAIN));
+ make_number (GNUTLS_E_AGAIN));
DEFSYM (Qgnutls_e_invalid_session, "gnutls-e-invalid-session");
Fput (Qgnutls_e_invalid_session, Qgnutls_code,
- make_number (GNUTLS_E_INVALID_SESSION));
+ make_number (GNUTLS_E_INVALID_SESSION));
DEFSYM (Qgnutls_e_not_ready_for_handshake, "gnutls-e-not-ready-for-handshake");
Fput (Qgnutls_e_not_ready_for_handshake, Qgnutls_code,
- make_number (GNUTLS_E_APPLICATION_ERROR_MIN));
+ make_number (GNUTLS_E_APPLICATION_ERROR_MIN));
defsubr (&Sgnutls_get_initstage);
defsubr (&Sgnutls_errorp);
struct named_merge_point;
static void map_tty_color (struct frame *, struct face *,
- enum lface_attribute_index, int *);
+ enum lface_attribute_index, int *);
static Lisp_Object resolve_face_name (Lisp_Object, int);
static void set_font_frame_param (Lisp_Object, Lisp_Object);
static int get_lface_attributes (struct frame *, Lisp_Object, Lisp_Object *,
- int, struct named_merge_point *);
+ int, struct named_merge_point *);
static ptrdiff_t load_pixmap (struct frame *, Lisp_Object,
unsigned *, unsigned *);
static struct frame *frame_or_selected_frame (Lisp_Object, int);
static void free_face_colors (struct frame *, struct face *);
static int face_color_gray_p (struct frame *, const char *);
static struct face *realize_face (struct face_cache *, Lisp_Object *,
- int);
+ int);
static struct face *realize_non_ascii_face (struct frame *, Lisp_Object,
- struct face *);
+ struct face *);
static struct face *realize_x_face (struct face_cache *, Lisp_Object *);
static struct face *realize_tty_face (struct face_cache *, Lisp_Object *);
static int realize_basic_faces (struct frame *);
static void free_face_cache (struct face_cache *);
static int face_fontset (Lisp_Object *);
static void merge_face_vectors (struct frame *, Lisp_Object *, Lisp_Object*,
- struct named_merge_point *);
+ struct named_merge_point *);
static int merge_face_ref (struct frame *, Lisp_Object, Lisp_Object *,
- int, struct named_merge_point *);
+ int, struct named_merge_point *);
static int set_lface_from_font (struct frame *, Lisp_Object, Lisp_Object,
- int);
+ int);
static Lisp_Object lface_from_face_name (struct frame *, Lisp_Object, int);
static struct face *make_realized_face (Lisp_Object *);
static void cache_face (struct face_cache *, struct face *, unsigned);
is called. */
void
-x_free_dpy_colors (Display *dpy, Screen *screen, Colormap cmap, long unsigned int *pixels, int npixels)
+x_free_dpy_colors (Display *dpy, Screen *screen, Colormap cmap,
+ long unsigned int *pixels, int npixels)
{
struct x_display_info *dpyinfo = x_display_info_for_display (dpy);
int class = dpyinfo->visual->class;
static inline GC
x_create_gc (struct frame *f,
- unsigned long mask,
- XGCValues *xgcv)
+ unsigned long mask,
+ XGCValues *xgcv)
{
GC gc = xmalloc (sizeof (*gc));
if (gc)
if (!FRAME_NS_P (f) || FRAME_NS_WINDOW (f))
#endif
if (!realize_basic_faces (f))
- abort ();
+ abort ();
}
if these pointers are not null. */
static ptrdiff_t
-load_pixmap (FRAME_PTR f, Lisp_Object name, unsigned int *w_ptr, unsigned int *h_ptr)
+load_pixmap (FRAME_PTR f, Lisp_Object name, unsigned int *w_ptr,
+ unsigned int *h_ptr)
{
ptrdiff_t bitmap_id;
returned in it. */
static int
-tty_lookup_color (struct frame *f, Lisp_Object color, XColor *tty_color, XColor *std_color)
+tty_lookup_color (struct frame *f, Lisp_Object color, XColor *tty_color,
+ XColor *std_color)
{
Lisp_Object frame, color_desc;
This does the right thing for any type of frame. */
static int
-defined_color (struct frame *f, const char *color_name, XColor *color_def, int alloc)
+defined_color (struct frame *f, const char *color_name, XColor *color_def,
+ int alloc)
{
if (!FRAME_WINDOW_P (f))
return tty_defined_color (f, color_name, color_def, alloc);
color. */
static int
-face_color_supported_p (struct frame *f, const char *color_name, int background_p)
+face_color_supported_p (struct frame *f, const char *color_name,
+ int background_p)
{
Lisp_Object frame;
XColor not_used;
these colors. */
unsigned long
-load_color (struct frame *f, struct face *face, Lisp_Object name, enum lface_attribute_index target_index)
+load_color (struct frame *f, struct face *face, Lisp_Object name,
+ enum lface_attribute_index target_index)
{
XColor color;
The optional fifth argument WIDTH, if specified, is a number of columns
occupied by a character of a font. In that case, return only fonts
the WIDTH times as wide as FACE on FRAME. */)
- (Lisp_Object pattern, Lisp_Object face, Lisp_Object frame, Lisp_Object maximum, Lisp_Object width)
+ (Lisp_Object pattern, Lisp_Object face, Lisp_Object frame,
+ Lisp_Object maximum, Lisp_Object width)
{
struct frame *f;
int size, avgwidth IF_LINT (= 0);
signal an error if FACE_NAME is not a valid face name. If SIGNAL_P
is zero, value is nil if FACE_NAME is not a valid face name. */
static inline Lisp_Object
-lface_from_face_name_no_resolve (struct frame *f, Lisp_Object face_name, int signal_p)
+lface_from_face_name_no_resolve (struct frame *f, Lisp_Object face_name,
+ int signal_p)
{
Lisp_Object lface;
Otherwise, value is zero if FACE_NAME is not a face. */
static inline int
-get_lface_attributes_no_remap (struct frame *f, Lisp_Object face_name, Lisp_Object *attrs, int signal_p)
+get_lface_attributes_no_remap (struct frame *f, Lisp_Object face_name,
+ Lisp_Object *attrs, int signal_p)
{
Lisp_Object lface;
Otherwise, value is zero if FACE_NAME is not a face. */
static inline int
-get_lface_attributes (struct frame *f, Lisp_Object face_name, Lisp_Object *attrs, int signal_p, struct named_merge_point *named_merge_points)
+get_lface_attributes (struct frame *f, Lisp_Object face_name,
+ Lisp_Object *attrs, int signal_p,
+ struct named_merge_point *named_merge_points)
{
Lisp_Object face_remapping;
for (i = 1; i < LFACE_VECTOR_SIZE; ++i)
if (i != LFACE_FONT_INDEX && i != LFACE_INHERIT_INDEX)
if ((UNSPECIFIEDP (attrs[i]) || IGNORE_DEFFACE_P (attrs[i])))
- break;
+ break;
return i == LFACE_VECTOR_SIZE;
}
of FORCE_P. */
static int
-set_lface_from_font (struct frame *f, Lisp_Object lface, Lisp_Object font_object, int force_p)
+set_lface_from_font (struct frame *f, Lisp_Object lface,
+ Lisp_Object font_object, int force_p)
{
Lisp_Object val;
struct font *font = XFONT_OBJECT (font_object);
other places. */
static inline void
-merge_face_vectors (struct frame *f, Lisp_Object *from, Lisp_Object *to, struct named_merge_point *named_merge_points)
+merge_face_vectors (struct frame *f, Lisp_Object *from, Lisp_Object *to,
+ struct named_merge_point *named_merge_points)
{
int i;
merging succeeded. */
static int
-merge_named_face (struct frame *f, Lisp_Object face_name, Lisp_Object *to, struct named_merge_point *named_merge_points)
+merge_named_face (struct frame *f, Lisp_Object face_name, Lisp_Object *to,
+ struct named_merge_point *named_merge_points)
{
struct named_merge_point named_merge_point;
specifications. */
static int
-merge_face_ref (struct frame *f, Lisp_Object face_ref, Lisp_Object *to, int err_msgs, struct named_merge_point *named_merge_points)
+merge_face_ref (struct frame *f, Lisp_Object face_ref, Lisp_Object *to,
+ int err_msgs, struct named_merge_point *named_merge_points)
{
int ok = 1; /* Succeed without an error? */
The value of that attribute will be inherited from some other
face during face merging. See internal_merge_in_global_face. */
if (UNSPECIFIEDP (value))
- value = Qignore_defface;
+ value = Qignore_defface;
}
else
{
{
/* The default face must have an absolute size. */
if (!INTEGERP (value) || XINT (value) <= 0)
- signal_error ("Default face height not absolute and positive", value);
+ signal_error ("Default face height not absolute and positive",
+ value);
}
else
{
make_number (10),
Qnil);
if (!INTEGERP (test) || XINT (test) <= 0)
- signal_error ("Face height does not produce a positive integer", value);
+ signal_error ("Face height does not produce a positive integer",
+ value);
}
}
int valid_p;
/* Allow t meaning a simple box of width 1 in foreground color
- of the face. */
+ of the face. */
if (EQ (value, Qt))
value = make_number (1);
has been assigned the value NEW_VALUE. */
void
-update_face_from_frame_parameter (struct frame *f, Lisp_Object param, Lisp_Object new_value)
+update_face_from_frame_parameter (struct frame *f, Lisp_Object param,
+ Lisp_Object new_value)
{
Lisp_Object face = Qnil;
Lisp_Object lface;
xassert (lface_fully_specified_p (lface1)
&& lface_fully_specified_p (lface2));
return (xstrcasecmp (SSDATA (lface1[LFACE_FAMILY_INDEX]),
- SSDATA (lface2[LFACE_FAMILY_INDEX])) == 0
+ SSDATA (lface2[LFACE_FAMILY_INDEX])) == 0
&& xstrcasecmp (SSDATA (lface1[LFACE_FOUNDRY_INDEX]),
SSDATA (lface2[LFACE_FOUNDRY_INDEX])) == 0
&& EQ (lface1[LFACE_HEIGHT_INDEX], lface2[LFACE_HEIGHT_INDEX])
|| (STRINGP (lface1[LFACE_FONTSET_INDEX])
&& STRINGP (lface2[LFACE_FONTSET_INDEX])
&& ! xstrcasecmp (SSDATA (lface1[LFACE_FONTSET_INDEX]),
- SSDATA (lface2[LFACE_FONTSET_INDEX]))))
+ SSDATA (lface2[LFACE_FONTSET_INDEX]))))
);
}
/* This formula is from a paper title `Colour metric' by Thiadmer Riemersma.
Quoting from that paper:
- This formula has results that are very close to L*u*v* (with the
- modified lightness curve) and, more importantly, it is a more even
- algorithm: it does not have a range of colours where it suddenly
- gives far from optimal results.
+ This formula has results that are very close to L*u*v* (with the
+ modified lightness curve) and, more importantly, it is a more even
+ algorithm: it does not have a range of colours where it suddenly
+ gives far from optimal results.
See <http://www.compuphase.com/cmetric.htm> for more info. */
default face. FACE_ID is assumed to be already realized. */
int
-lookup_derived_face (struct frame *f, Lisp_Object symbol, int face_id, int signal_p)
+lookup_derived_face (struct frame *f, Lisp_Object symbol, int face_id,
+ int signal_p)
{
Lisp_Object attrs[LFACE_VECTOR_SIZE];
Lisp_Object symbol_attrs[LFACE_VECTOR_SIZE];
\(2) `close in spirit' to what the attributes specify, if not exact. */
static int
-x_supports_face_attributes_p (struct frame *f, Lisp_Object *attrs, struct face *def_face)
+x_supports_face_attributes_p (struct frame *f, Lisp_Object *attrs,
+ struct face *def_face)
{
Lisp_Object *def_attrs = def_face->lface;
substitution of a `dim' face for italic. */
static int
-tty_supports_face_attributes_p (struct frame *f, Lisp_Object *attrs, struct face *def_face)
+tty_supports_face_attributes_p (struct frame *f, Lisp_Object *attrs,
+ struct face *def_face)
{
int weight;
Lisp_Object val, fg, bg;
/* See if the capabilities we selected above are supported, with the
given colors. */
if (test_caps != 0 &&
- ! tty_capable_p (FRAME_TTY (f), test_caps, fg_tty_color.pixel, bg_tty_color.pixel))
+ ! tty_capable_p (FRAME_TTY (f), test_caps, fg_tty_color.pixel,
+ bg_tty_color.pixel))
return 0;
{
FRAME_FACE_CACHE (f)->menu_face_changed_p = 0;
#ifdef USE_X_TOOLKIT
- if (FRAME_WINDOW_P (f))
- x_update_menu_appearance (f);
+ if (FRAME_WINDOW_P (f))
+ x_update_menu_appearance (f);
#endif
}
if (FRAME_X_P (f) && face->font != FRAME_FONT (f))
{
/* This can happen when making a frame on a display that does
- not support the default font. */
+ not support the default font. */
if (!face->font)
- return 0;
+ return 0;
/* Otherwise, the font specified for the frame was not
- acceptable as a font for the default face (perhaps because
- auto-scaled fonts are rejected), so we must adjust the frame
- font. */
+ acceptable as a font for the default face (perhaps because
+ auto-scaled fonts are rejected), so we must adjust the frame
+ font. */
x_set_font (f, LFACE_FONT (lface), Qnil);
}
#endif /* HAVE_X_WINDOWS */
no-font. */
static struct face *
-realize_non_ascii_face (struct frame *f, Lisp_Object font_object, struct face *base_face)
+realize_non_ascii_face (struct frame *f, Lisp_Object font_object,
+ struct face *base_face)
{
struct face_cache *cache = FRAME_FACE_CACHE (f);
struct face *face;
else if (INTEGERP (box))
{
/* Simple box of specified line width in foreground color of the
- face. */
+ face. */
xassert (XINT (box) != 0);
face->box = FACE_SIMPLE_BOX;
face->box_line_width = XINT (box);
default foreground/background colors. */
static void
-map_tty_color (struct frame *f, struct face *face, enum lface_attribute_index idx, int *defaulted)
+map_tty_color (struct frame *f, struct face *face,
+ enum lface_attribute_index idx, int *defaulted)
{
Lisp_Object frame, color, def;
int foreground_p = idx == LFACE_FOREGROUND_INDEX;
face->lface[idx] = tty_color_name (f, pixel);
*defaulted = 1;
}
- }
+ }
#endif /* MSDOS */
}
`my-mode-default', and then in the mode setup function, do:
(set (make-local-variable 'face-remapping-alist)
- '((default my-mode-default)))).
+ '((default my-mode-default)))).
Because Emacs normally only redraws screen areas when the underlying
buffer contents change, you may need to call `redraw-display' after
projects / emacs.git / commitdiff