LIBXML2_LIBS = @LIBXML2_LIBS@

LIBXML2_CFLAGS = @LIBXML2_CFLAGS@

LIBZ = @LIBZ@

## system-specific libs for dynamic modules, else empty

## widget.o if USE_X_TOOLKIT, otherwise empty.

WIDGET_OBJ=@WIDGET_OBJ@

CYGWIN_OBJ=@CYGWIN_OBJ@

## fontset.o fringe.o image.o if we have any window system

LIBGPM = @LIBGPM@

LIBSELINUX_LIBS = @LIBSELINUX_LIBS@

LIBGNUTLS_LIBS = @LIBGNUTLS_LIBS@

RUN_TEMACS = ./temacs

UNEXEC_OBJ = @UNEXEC_OBJ@

CANNOT_DUMP=@CANNOT_DUMP@

doprnt.o intervals.o textprop.o composite.o xml.o $(NOTIFY_OBJ) \

$(XWIDGETS_OBJ) \

profiler.o decompress.o \

$(MSDOS_OBJ) $(MSDOS_X_OBJ) $(NS_OBJ) $(CYGWIN_OBJ) $(FONT_OBJ) \

$(W32_OBJ) $(WINDOW_SYSTEM_OBJ) $(XGSELOBJ)

obj = $(base_obj) $(NS_OBJC_OBJ)

$(WEBKIT_LIBS) \

$(LIB_EACCESS) $(LIB_FDATASYNC) $(LIB_TIMER_TIME) $(DBUS_LIBS) \

$(LIB_EXECINFO) $(XRANDR_LIBS) $(XINERAMA_LIBS) $(XFIXES_LIBS) \

$(LIBS_TERMCAP) $(GETLOADAVG_LIBS) $(SETTINGS_LIBS) $(LIBSELINUX_LIBS) \

$(FREETYPE_LIBS) $(FONTCONFIG_LIBS) $(LIBOTF_LIBS) $(M17N_FLT_LIBS) \

$(NOTIFY_LIBS) $(LIB_MATH) $(LIBZ) $(LIBMODULES)

$(leimdir)/leim-list.el: bootstrap-emacs$(EXEEXT)

ifeq ($(CANNOT_DUMP),yes)

ln -f temacs$(EXEEXT) $@

else

$(PAXCTL_if_present) -zex $@

ln -f $@ bootstrap-emacs$(EXEEXT)

endif

$(ALLOBJS): globals.h

$(MAKE) -C $(lib) all

## We have to create $(etc) here because init_cmdargs tests its

## This goes on to affect various things, and the emacs binary fails

## to start if Vinstallation_directory has the wrong value.

temacs$(EXEEXT): $(LIBXMENU) $(ALLOBJS) \

$(AM_V_CCLD)$(CC) $(ALL_CFLAGS) $(TEMACS_LDFLAGS) $(LDFLAGS) \

$(MKDIR_P) $(etc)

ifneq ($(CANNOT_DUMP),yes)

$(PAXCTL_if_present) -r $@

-rm -f *~ \#*

## FIXME? In out-of-tree builds, should TAGS be generated in srcdir?

## This does not need to depend on ../lisp and ../lwlib TAGS files,

## because etags "--include" only includes a pointer to the file,

## rather than the file contents.

--regex='{c}/[ ]*DEFVAR_[A-Z_ (]+"\([^"]+\)"/\1/' \

--regex='{c}/[ ]*DEFVAR_[A-Z_ (]+"[^"]+",[ ]\([A-Za-z0-9_]+\)/\1/' \

--regex='{objc}/[ ]*DEFVAR_[A-Z_ (]+"\([^"]+\)"/\1/' \

--regex='{objc}/[ ]*DEFVAR_[A-Z_ (]+"[^"]+",[ ]\([A-Za-z0-9_]+\)/\1/' \

## Arrange to make tags tables for ../lisp and ../lwlib,

## which the above TAGS file for the C files includes by reference.

$(MAKE) -C ../lisp TAGS ETAGS="$(ETAGS)"

$(MAKE) -C $(lwlibdir) TAGS ETAGS="$(ETAGS)"

tags: TAGS ../lisp/TAGS $(lwlibdir)/TAGS

ifeq ($(CANNOT_DUMP),yes)

ln -f temacs$(EXEEXT) $@

else

$(PAXCTL_if_present) -zex emacs$(EXEEXT)

mv -f emacs$(EXEEXT) $@

endif

#include <stdio.h>

#include <limits.h> /* For CHAR_BIT. */

#ifdef HAVE_PTHREAD

#include <pthread.h>

#include "dispextern.h"

#include "intervals.h"

#include "puresize.h"

#include "systime.h"

#include "character.h"

#include "buffer.h"

#include "dosfns.h" /* For dos_memory_info. */

#endif

#if (defined ENABLE_CHECKING \

&& defined HAVE_VALGRIND_VALGRIND_H \

&& !defined USE_VALGRIND)

#ifdef DOUG_LEA_MALLOC

/* Specify maximum number of areas to mmap. It would be nice to use a

value that explicitly means "no limit". */

inside glibc's malloc. */

static void *malloc_state_ptr;

/* Restore the dumped malloc state. Because malloc can be invoked

even before main (e.g. by the dynamic linker), the dumped malloc

state must be restored as early as possible using this special hook. */

}

}

# ifndef __MALLOC_HOOK_VOLATILE

# define __MALLOC_HOOK_VOLATILE

# endif

= malloc_initialize_hook;

#endif

/* Mark, unmark, query mark bit of a Lisp string. S must be a pointer

to a struct Lisp_String. */

Malloc

************************************************************************/

/* Function malloc calls this if it finds we are near exhausting storage. */

void

pending_malloc_warning = str;

}

/* Display an already-pending malloc warning. */

unexmacosx.c, so don't use it on Darwin. */

#if ! ADDRESS_SANITIZER && !defined DARWIN_OS

# define USE_ALIGNED_ALLOC 1

# define USE_ALIGNED_ALLOC 1

static void *

aligned_alloc (size_t alignment, size_t size)

{

DEFUN ("make-vector", Fmake_vector, Smake_vector, 2, 2, 0,

doc: /* Return a newly created vector of length LENGTH, with each element being INIT.

See also the function `vector'. */)

{

CHECK_NATNUM (length);

p->contents[i] = init;

}

DEFUN ("vector", Fvector, Svector, 0, MANY, 0,

usage: (vector &rest OBJECTS) */)

(ptrdiff_t nargs, Lisp_Object *args)

{

return val;

}

usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING INTERACTIVE-SPEC &rest ELEMENTS) */)

(ptrdiff_t nargs, Lisp_Object *args)

{

/* We used to purecopy everything here, if purify-flag was set. This worked

OK for Emacs-23, but with Emacs-24's lexical binding code, it can be

just wasteful and other times plainly wrong (e.g. those free vars may want

to be setcar'd). */

make_byte_code (p);

XSETCOMPILED (val, p);

return val;

/* To select a nonfundamental mode,

select the buffer temporarily and then call the mode function. */

Fset_buffer (buffer);

call0 (function);

if (NILP (BVAR (&buffer_defaults, enable_multibyte_characters)))

Fset_buffer_multibyte (Qnil);

if (!pwd)

{

bool

setup_ccl_program (struct ccl_program *ccl, Lisp_Object ccl_prog)

{

if (! NILP (ccl_prog))

{

struct Lisp_Vector *vp;

}

}

ccl->ic = CCL_HEADER_MAIN;

ccl->last_block = false;

ccl->status = 0;

ccl->stack_idx = 0;

/* Here, we just copy the parent's fast_map. It's not accurate,

but at least it works for quickly detecting which character

DOESN'T belong to this charset. */

/* We also copy these for parents. */

charset.min_char = parent_charset->min_char;

else if (EQ (eol_type, Qdos))

{

ptrdiff_t n = 0;

{

}

}

coding->produced -= n;

coding->produced_char -= n;

#ifdef emacs

#define malloc hybrid_malloc

#define realloc hybrid_realloc

#define calloc hybrid_calloc

#define free hybrid_free

#endif

#endif /* HYBRID_MALLOC */

#undef HAVE_RINT

#endif /* HPUX */

#ifdef MSDOS

#ifndef __DJGPP__

You lose; /* Emacs for DOS must be compiled with DJGPP */

default, but we plan to change that, so you should specify a non-nil value

for ID-FORMAT if you use the returned uid or gid.

Elements of the attribute list are:

0. t for directory, string (name linked to) for symbolic link, or nil.

1. Number of links to file.

int width = w->total_cols;

double d = max (0, margin);

d = min (width / 2 - 1, d);

}

return 0;

}

\<foo> just sets the keymap used for \[cmd]. */

else if (strp[0] == '\\' && (strp[1] == '{' || strp[1] == '<'))

{

/* This is for computing the SHADOWS arg for describe_map_tree. */

Lisp_Object active_maps = Fcurrent_active_maps (Qnil, Qnil);

ptrdiff_t count = SPECPDL_INDEX ();

strp += 2; /* skip \{ or \< */

start = strp;

while ((strp - SDATA (string) < SBYTES (string))

&& *strp != '}' && *strp != '>')

}

/* Now switch to a temp buffer. */

set_buffer_internal (XBUFFER (Vprin1_to_string_buffer));

/* This is for an unusual case where some after-change

function uses 'format' or 'prin1' or something else that

{

/* Get the list of active keymaps that precede this one.

If this one's not active, get nil. */

describe_map_tree (tem, 1, Fnreverse (earlier_maps),

Qnil, 0, 1, 0, 0, 1);

}

Ferase_buffer ();

set_buffer_internal (oldbuf);

unbind_to (count, Qnil);

subst_string:

start = SDATA (tem);

start2_addr = BYTE_POS_ADDR (start2_byte);

memcpy (temp, start1_addr, len1_byte);

memcpy (start1_addr, start2_addr, len2_byte);

memcpy (start1_addr + len2_byte + len_mid, temp, len1_byte);

SAFE_FREE ();

&& INTPTR_MAX == EMACS_INT_MAX)

};

/* Function prototype for module user-pointer finalizers. These

should not throw C++ exceptions, so emacs-module.h declares the

corresponding interfaces with EMACS_NOEXCEPT. There is only C code

static void check_main_thread (void);

static void finalize_environment (struct emacs_env_private *);

static void initialize_environment (emacs_env *, struct emacs_env_private *priv);

static void module_handle_signal (emacs_env *, Lisp_Object);

static void module_handle_throw (emacs_env *, Lisp_Object);

static void module_non_local_exit_signal_1 (emacs_env *, Lisp_Object, Lisp_Object);

static void module_non_local_exit_throw_1 (emacs_env *, Lisp_Object, Lisp_Object);

static void module_out_of_memory (emacs_env *);

static void module_reset_handlerlist (const int *);

/* We used to return NULL when emacs_value was a different type from

Lisp_Object, but nowadays we just use Qnil instead. Although they

return error_retval; \

MODULE_HANDLE_NONLOCAL_EXIT (error_retval)

/* Catch signals and throws only if the code can actually signal or

throw. If checking is enabled, abort if the current thread is not

the Emacs main thread. */

{

Lisp_Object value = HASH_VALUE (h, i);

EMACS_INT refcount = XFASTINT (value) + 1;

value = make_natnum (refcount);

set_hash_value_slot (h, i, value);

}

first arg, because that's what Ffuncall takes. */

Lisp_Object *newargs;

USE_SAFE_ALLOCA;

SAFE_ALLOCA_LISP (newargs, nargs + 1);

newargs[0] = value_to_lisp (fun);

for (ptrdiff_t i = 0; i < nargs; i++)

{

MODULE_FUNCTION_BEGIN (0);

Lisp_Object l = value_to_lisp (n);

return XINT (l);

}

module_make_integer (emacs_env *env, intmax_t n)

{

MODULE_FUNCTION_BEGIN (module_nil);

return lisp_to_value (make_number (n));

}

{

MODULE_FUNCTION_BEGIN (0);

Lisp_Object lisp = value_to_lisp (f);

return XFLOAT_DATA (lisp);

}

{

MODULE_FUNCTION_BEGIN (false);

Lisp_Object lisp_str = value_to_lisp (value);

Lisp_Object lisp_str_utf8 = ENCODE_UTF_8 (lisp_str);

ptrdiff_t raw_size = SBYTES (lisp_str_utf8);

ptrdiff_t required_buf_size = raw_size + 1;

eassert (length != NULL);

if (*length < required_buf_size)

{

*length = required_buf_size;

}

*length = required_buf_size;

module_make_string (emacs_env *env, const char *str, ptrdiff_t length)

{

MODULE_FUNCTION_BEGIN (module_nil);

Lisp_Object lstr = make_unibyte_string (str, length);

return lisp_to_value (code_convert_string_norecord (lstr, Qutf_8, false));

}

{

MODULE_FUNCTION_BEGIN (NULL);

Lisp_Object lisp = value_to_lisp (uptr);

return XUSER_PTR (lisp)->p;

}

{

/* FIXME: This function should return bool because it can fail. */

MODULE_FUNCTION_BEGIN ();

Lisp_Object lisp = value_to_lisp (uptr);

XUSER_PTR (lisp)->p = ptr;

}

{

MODULE_FUNCTION_BEGIN (NULL);

Lisp_Object lisp = value_to_lisp (uptr);

return XUSER_PTR (lisp)->finalizer;

}

/* FIXME: This function should return bool because it can fail. */

MODULE_FUNCTION_BEGIN ();

Lisp_Object lisp = value_to_lisp (uptr);

XUSER_PTR (lisp)->finalizer = fin;

}

/* FIXME: This function should return bool because it can fail. */

MODULE_FUNCTION_BEGIN ();

Lisp_Object lvec = value_to_lisp (vec);

ASET (lvec, i, value_to_lisp (val));

}

{

MODULE_FUNCTION_BEGIN (module_nil);

Lisp_Object lvec = value_to_lisp (vec);

return lisp_to_value (AREF (lvec, i));

}

/* FIXME: Return a sentinel value (e.g., -1) on error. */

MODULE_FUNCTION_BEGIN (0);

Lisp_Object lvec = value_to_lisp (vec);

return ASIZE (lvec);

}

}

}

/* Signal an out-of-memory condition to the caller. */

static void

module_out_of_memory (emacs_env *env)

XCDR (Vmemory_signal_data));

}



/* Value conversion. */

BEWARE: Do not assume NULL is a valid value! */

typedef struct emacs_value_tag *emacs_value;

/* Struct passed to a module init function (emacs_module_init). */

struct emacs_runtime

};

/* Possible Emacs function call outcomes. */

enum emacs_funcall_exit

{

#include "composite.h"

#include "dispextern.h"

#include "regex.h"

#include "syntax.h"

#include "sysselect.h"

#include "systime.h"

bool initialized;

/* Set to true if this instance of Emacs might dump. */

bool might_dump;

#ifdef DARWIN_OS

extern void unexec_init_emacs_zone (void);

#endif

/* If true, Emacs should not attempt to use a window-specific code,

but instead should use the virtual terminal under which it was started. */

bool inhibit_window_system;

/* True means remove site-lisp directories from load-path. */

bool no_site_lisp;

/* Name for the server started by the daemon.*/

static char *daemon_name;

--display, -d DISPLAY use X server DISPLAY\n\

",

"\

--no-desktop do not load a saved desktop\n\

--no-init-file, -q load neither ~/.emacs nor default.el\n\

--no-loadup, -nl do not load loadup.el into bare Emacs\n\

{

signal (sig, SIG_DFL);

{

}

/* Signal the same code; this time it will really be fatal.

filename_from_ansi (ch_to_dir, newdir);

ch_to_dir = newdir;

#endif

if (chdir (ch_to_dir) != 0)

{

fprintf (stderr, "%s: Can't chdir to %s: %s\n",

no_site_lisp

= argmatch (argv, argc, "-nsl", "--no-site-lisp", 11, NULL, &skip_args);

#ifdef HAVE_NS

ns_pool = ns_alloc_autorelease_pool ();

#ifdef NS_IMPL_GNUSTEP

{ "-help", "--help", 90, 0 },

{ "-nl", "--no-loadup", 70, 0 },

{ "-nsl", "--no-site-lisp", 65, 0 },

/* -d must come last before the options handled in startup.el. */

{ "-d", "--display", 60, 1 },

{ "-display", 0, 60, 1 },

tem = Vpurify_flag;

Vpurify_flag = Qnil;

fflush (stdout);

/* Tell malloc where start of impure now is. */

/* Also arrange for warnings when nearly out of space. */

`ms-dos' compiled as an MS-DOS application.

`windows-nt' compiled as a native W32 application.

`cygwin' compiled using the Cygwin library.

Vsystem_type = intern_c_string (SYSTEM_TYPE);

/* See configure.ac for the possible SYSTEM_TYPEs. */

}

{

char buf[4000];

ptrdiff_t size = sizeof buf;

if (buffer != buf)

xfree (buffer);

}

struct utmp ut, *utp;

if (filename)

setutent ();

#include <config.h>

#include <unistd.h>

#include <intprops.h>

#include <vla.h>

#include "lisp.h"

#include "character.h"

return i1 < SCHARS (string2) ? Qt : Qnil;

}

DEFUN ("string-collate-lessp", Fstring_collate_lessp, Sstring_collate_lessp, 2, 4, 0,

doc: /* Return t if first arg string is less than second in collation order.

Symbols are also allowed; their print names are used instead.

(register Lisp_Object elt, Lisp_Object list)

{

register Lisp_Object tail;

{

register Lisp_Object tem;

CHECK_LIST_CONS (tail, list);

if (!FLOATP (elt))

return Fmemq (elt, list);

{

register Lisp_Object tem;

CHECK_LIST_CONS (tail, list);

{

Lisp_Object tail, prev;

{

CHECK_LIST_CONS (tail, seq);

defsubr (&Sstring_equal);

defsubr (&Scompare_strings);

defsubr (&Sstring_lessp);

defsubr (&Sstring_collate_lessp);

defsubr (&Sstring_collate_equalp);

defsubr (&Sappend);

An element of a base fontset is a vector of FONT-DEFs which themselves

are vectors of the form [ FONT-SPEC ENCODING REPERTORY ].

Each RFONT-DEFn (i.e. Realized FONT-DEF) has this form:

[ FACE-ID FONT-DEF FONT-OBJECT SORTING-SCORE ]

The value nil means that we have not yet generated the above vector

from the base of the fontset.

The value 0 means that no font is available for the corresponding

range of characters in this fontset, but may be available in the

A fontset has 8 extra slots.

if (! NILP (encoding))

{

Lisp_Object tail;

for (tail = Vcharset_ordered_list;

}

else

{

Lisp_Object lang = Ffont_get (font_spec, QClang);

if (! NILP (lang)

XSETCAR (font_group, make_number (low_tick_bits));

}

static Lisp_Object

fontset_get_font_group (Lisp_Object fontset, int c)

else

font_group = FONTSET_FALLBACK (fontset);

if (! NILP (font_group))

return font_group;

base_fontset = FONTSET_BASE (fontset);

if (NILP (base_fontset))

font_group = Qnil;

else if (c >= 0)

font_group = char_table_ref_and_range (base_fontset, c, &from, &to);

else

font_group = FONTSET_FALLBACK (base_fontset);

if (NILP (font_group))

{

font_group = make_number (0);

if (c >= 0)

char_table_set_range (fontset, from, to, font_group);

return font_group;

}

if (!VECTORP (font_group))

return font_group;

font_group = Fcopy_sequence (font_group);

for (i = 0; i < ASIZE (font_group); i++)

if (! NILP (AREF (font_group, i)))

}

/* Return RFONT-DEF (vector) in the realized fontset FONTSET for the

possibility that the default fontset or the fallback font groups

have a proper font, and return Qt if not.

If a font is found but is not yet opened, open it (if FACE is not

NULL) or return Qnil (if FACE is NULL).

preference.

If FALLBACK, search only fallback fonts. */

static Lisp_Object

{

Lisp_Object vec, font_group;

int i, charset_matched = 0, found_index;

/* We have just created the font-group,

or the charset priorities were changed. */

reorder_font_vector (font_group, face->ascii_face->font);

first. */

for (i = 0; i < ASIZE (vec); i++)

{

break;

repertory = FONT_DEF_REPERTORY (RFONT_DEF_FONT_DEF (rfont_def));

{

charset_matched = i;

break;

}

}

for (i = 0; i < ASIZE (vec); i++)

{

Lisp_Object font_def;

{

if (charset_matched > 0)

{

found_index = charset_matched;

/* Make this negative so that we don't come here in the

next loop. */

charset_matched = - charset_matched;

/* We must try the first element in the next loop. */

}

}

else if (i == - charset_matched)

if (NILP (font_object))

{

/* Something strange happened, perhaps because of a

that this spec is unusable. It may be better to find

another font of the same spec, but currently we don't

RFONT_DEF_SET_FACE (rfont_def, -1);

continue;

}

i = found_index;

}

FONTSET_SET (fontset, make_number (c), make_number (0));

return Qnil;

}

static Lisp_Object

fontset_font (Lisp_Object fontset, int c, struct face *face, int id)

{

|| new_pixel_height != old_pixel_height);

unblock_input ();

}

/* Allocate basically initialized frame. */

in a more readable form. */);

frame_size_history = Qnil;

staticpro (&Vframe_list);

defsubr (&Sframep);

cleared. */

bool_bf explicit_name : 1;

/* True if the mouse has moved on this display device

since the last time we checked. */

are frozen on frame F. */

#define FRAME_WINDOWS_FROZEN(f) (f)->frozen_window_starts

/* The minibuffer window of frame F, if it has one; otherwise nil. */

#define FRAME_MINIBUF_WINDOW(f) f->minibuffer_window

#define USE_PTHREAD

#endif

#include <string.h>

#include <limits.h>

#include <stdint.h>

#include <unistd.h>

#ifdef USE_PTHREAD

#endif

#ifdef emacs

#endif

/* If HYBRID_MALLOC is defined, then temacs will use malloc,

however, will use the system malloc, realloc.... In other source

files, malloc, realloc... are renamed hybrid_malloc,

hybrid_realloc... via macros in conf_post.h. hybrid_malloc and

#undef malloc

#undef realloc

#undef calloc

#undef free

#define malloc gmalloc

#define realloc grealloc

#define calloc gcalloc

#define aligned_alloc galigned_alloc

#define free gfree

#endif

#ifdef __cplusplus

{

#endif

/* Allocate SIZE bytes of memory. */

extern void *malloc (size_t size) ATTRIBUTE_MALLOC_SIZE ((1));

extern void *realloc (void *ptr, size_t size) ATTRIBUTE_ALLOC_SIZE ((2));

/* Allocate NMEMB elements of SIZE bytes each, all initialized to 0. */

extern void *calloc (size_t nmemb, size_t size) ATTRIBUTE_MALLOC_SIZE ((1,2));

extern void free (void *ptr);

/* Allocate SIZE bytes allocated to ALIGNMENT bytes. */

extern void *aligned_alloc (size_t, size_t);

extern void *memalign (size_t, size_t);

extern int posix_memalign (void **, size_t, size_t);

#endif

/* The allocator divides the heap into blocks of fixed size; large

requests receive one or more whole blocks, and small requests

receive a fragment of a block. Fragment sizes are powers of two,

#define UNLOCK_ALIGNED_BLOCKS()

#endif

/* Nonzero if `malloc' has been called and done its initialization. */

extern int __malloc_initialized;

/* Function called to initialize malloc data structures. */

extern int __malloc_initialize (void);

/* Return values for `mprobe': these are the kinds of inconsistencies that

`mcheck' enables detection of. */

/* Pick up the current statistics. */

extern struct mstats mstats (void);

#ifdef __cplusplus

}

#include <errno.h>

/* Pointer to the base of the first block. */

char *_heapbase;

/* Block information table. Allocated with align/__free (not malloc/free). */

malloc_info *_heapinfo;

/* Search index in the info table. */

size_t _heapindex;

/* Are you experienced? */

int __malloc_initialized;

size_t __malloc_extra_blocks;

#if defined GC_MALLOC_CHECK && defined GC_PROTECT_MALLOC_STATE

if (!__malloc_initialized && !__malloc_initialize ())

return NULL;

NULL-check and the use.

Note: Strictly speaking, this is not a right solution. We should

use mutexes to access non-read-only variables that are shared

among multiple threads. We just leave it for compatibility with

return (hook != NULL ? *hook : _malloc_internal) (size);

}



/* On some ANSI C systems, some libc functions call _malloc, _free

and _realloc. Make them use the GNU functions. */

The author may be reached (Email) at the address mike@ai.mit.edu,

or (US mail) as Mike Haertel c/o Free Software Foundation. */

/* Debugging hook for free. */

/* List of blocks allocated by aligned_alloc. */

struct alignlist *_aligned_blocks = NULL;

/* Return memory to the heap.

Like `_free_internal' but don't lock mutex. */

}

/* Return memory to the heap.

void

_free_internal (void *ptr)

{

void

free (void *ptr)

{

if (hook != NULL)

(*hook) (ptr);

_free_internal (ptr);

}

/* Define the `cfree' alias for `free'. */

#ifdef weak_alias

weak_alias (free, cfree)

free (ptr);

}

#endif

/* Change the size of a block allocated by `malloc'.

Copyright 1990, 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.

Written May 1989 by Mike Haertel.

#endif

/* Debugging hook for realloc. */

/* Resize the given region to the new size, returning a pointer

to the (possibly moved) region. This is optimized for speed;

if (!__malloc_initialized && !__malloc_initialize ())

return NULL;

return (hook != NULL ? *hook : _realloc_internal) (ptr, size);

}

/* Copyright (C) 1991, 1992, 1994 Free Software Foundation, Inc.

/* Allocate INCREMENT more bytes of data space,

and return the start of data space, or NULL on errors.

If INCREMENT is negative, shrink data space. */

{

void *result;

if (!DUMPED)

{

return bss_sbrk (increment);

return NULL;

return result;

}

/* Copyright (C) 1991, 92, 93, 94, 95, 96 Free Software Foundation, Inc.

This library is free software; you can redistribute it and/or

You should have received a copy of the GNU General Public

License along with this library. If not, see <http://www.gnu.org/licenses/>. */

void *

aligned_alloc (size_t alignment, size_t size)

{

void *result;

size_t adj, lastadj;

/* Allocate a block with enough extra space to pad the block with up to

(ALIGNMENT - 1) bytes if necessary. */

return result;

}

/* An obsolete alias for aligned_alloc, for any old libraries that use

this alias. */

/* If HYBRID_MALLOC is defined, we may want to use the system

posix_memalign below. */

int

posix_memalign (void **memptr, size_t alignment, size_t size)

{

The author may be reached (Email) at the address mike@ai.mit.edu,

or (US mail) as Mike Haertel c/o Free Software Foundation. */

/* Allocate SIZE bytes on a page boundary. */

extern void *valloc (size_t);

extern int getpagesize (void);

static size_t pagesize;

return aligned_alloc (pagesize, size);

}

#undef malloc

#undef realloc

#endif

}

#endif

void *

hybrid_realloc (void *ptr, size_t size)

{

return result;

}

#else /* ! HYBRID_MALLOC */

void *

else

hdr = NULL;

free (hdr);

}

static void *

{

struct hdr *hdr;

hdr = malloc (sizeof *hdr + size + 1);

if (hdr == NULL)

return NULL;

memset ((char *) ptr + size, FREEFLOOD, osize - size);

}

hdr = realloc (hdr, sizeof *hdr + size + 1);

if (hdr == NULL)

return NULL;

/* These hooks may not be safely inserted if malloc is already in use. */

if (!__malloc_initialized && !mcheck_used)

{

mcheck_used = 1;

}

message ("gnutls.c: [%d] %s %d", level, string, extra);

}

static int

emacs_gnutls_handshake (struct Lisp_Process *proc)

{

gnutls_session_t state = proc->gnutls_state;

if (proc->gnutls_initstage < GNUTLS_STAGE_HANDSHAKE_CANDO)

return -1;

proc->gnutls_initstage = GNUTLS_STAGE_TRANSPORT_POINTERS_SET;

}

}

ptrdiff_t

ssize_t rtnval;

gnutls_session_t state = proc->gnutls_state;

if (proc->gnutls_initstage != GNUTLS_STAGE_READY)

{

}

rtnval = gnutls_record_recv (state, buf, nbyte);

if (rtnval >= 0)

return rtnval;

CHECK_PROCESS (proc);

return Qnil;

log_level = XPROCESS (proc)->gnutls_log_level;

GNUTLS_INITSTAGE (proc) = GNUTLS_STAGE_INIT - 1;

}

return Qt;

}

DEFUN ("gnutls-get-initstage", Fgnutls_get_initstage, Sgnutls_get_initstage, 1, 1, 0,

doc: /* Return the GnuTLS init stage of process PROC.

See also `gnutls-boot'. */)

attributes: const)

(Lisp_Object err)

{

return Qt;

}

CHECK_PROCESS (proc);

return Qnil;

/* Then collect any warnings already computed by the handshake. */

}

#endif

DEFUN ("gnutls-boot", Fgnutls_boot, Sgnutls_boot, 3, 3, 0,

doc: /* Initialize GnuTLS client for process PROC with TYPE+PROPLIST.

Currently only client mode is supported. Return a success/failure

:min-prime-bits is the minimum accepted number of bits the client will

accept in Diffie-Hellman key exchange.

The debug level will be set for this process AND globally for GnuTLS.

So if you set it higher or lower at any point, it affects global

debugging.

{

int ret = GNUTLS_E_SUCCESS;

int max_log_level = 0;

gnutls_session_t state;

gnutls_certificate_credentials_t x509_cred = NULL;

gnutls_anon_client_credentials_t anon_cred = NULL;

Lisp_Object global_init;

char const *priority_string_ptr = "NORMAL"; /* default priority string. */

char *c_hostname;

/* Placeholders for the property list elements. */

/* Lisp_Object callbacks; */

Lisp_Object loglevel;

Lisp_Object hostname;

Lisp_Object prime_bits;

CHECK_PROCESS (proc);

CHECK_SYMBOL (type);

CHECK_LIST (proplist);

if (NILP (Fgnutls_available_p ()))

if (!EQ (type, Qgnutls_x509pki) && !EQ (type, Qgnutls_anon))

hostname = Fplist_get (proplist, QCgnutls_bootprop_hostname);

priority_string = Fplist_get (proplist, QCgnutls_bootprop_priority);

keylist = Fplist_get (proplist, QCgnutls_bootprop_keylist);

crlfiles = Fplist_get (proplist, QCgnutls_bootprop_crlfiles);

loglevel = Fplist_get (proplist, QCgnutls_bootprop_loglevel);

prime_bits = Fplist_get (proplist, QCgnutls_bootprop_min_prime_bits);

{

}

c_hostname = SSDATA (hostname);

state = XPROCESS (proc)->gnutls_state;

else

{

emacs_gnutls_deinit (proc);

}

}

else

{

emacs_gnutls_deinit (proc);

}

}

else

{

emacs_gnutls_deinit (proc);

}

}

}

return gnutls_make_error (ret);

}

GNUTLS_INITSTAGE (proc) = GNUTLS_STAGE_CRED_SET;

ret = emacs_gnutls_handshake (XPROCESS (proc));

if (ret < GNUTLS_E_SUCCESS)

return gnutls_make_error (ret);

}

DEFUN ("gnutls-bye", Fgnutls_bye,

DEFSYM (QCgnutls_bootprop_crlfiles, ":crlfiles");

DEFSYM (QCgnutls_bootprop_min_prime_bits, ":min-prime-bits");

DEFSYM (QCgnutls_bootprop_loglevel, ":loglevel");

DEFSYM (QCgnutls_bootprop_verify_flags, ":verify-flags");

DEFSYM (QCgnutls_bootprop_verify_error, ":verify-error");

make_number (GNUTLS_E_APPLICATION_ERROR_MIN));

defsubr (&Sgnutls_get_initstage);

defsubr (&Sgnutls_errorp);

defsubr (&Sgnutls_error_fatalp);

defsubr (&Sgnutls_error_string);

#include "lisp.h"

typedef enum

{

#endif

extern Lisp_Object emacs_gnutls_deinit (Lisp_Object);

extern Lisp_Object emacs_gnutls_global_init (void);

#endif

{

Lisp_Object value;

int desired_width, desired_height;

/* If width and/or height is set in the display spec assume we want

to scale to those values. If either h or w is unspecified, the

unspecified should be calculated from the specified to preserve

aspect ratio. */

value = image_spec_value (spec, QCwidth, NULL);

value = image_spec_value (spec, QCheight, NULL);

if (desired_width == -1)

{

/* h known, calculate w. */

desired_width = scale_image_size (desired_height, height, width);

*d_width = desired_width;

*d_height = desired_height;

}

return 0;

}

if (ino < 0 || ino >= MagickGetNumberImages (image_wand))

{

image_error ("Invalid image number `%s' in image `%s'", image, img->spec);

eassert (gdk_pixbuf_get_has_alpha (pixbuf));

eassert (gdk_pixbuf_get_bits_per_sample (pixbuf) == 8);

{

unsigned char *data = (unsigned char *) xmalloc (width*height*4);

uint32_t bgcolor = get_spec_bg_or_alpha_as_argb (img, f);

create_cairo_image_surface (img, data, width, height);

g_object_unref (pixbuf);

#else

#ifdef COLOR_TABLE_SUPPORT

#endif /* COLOR_TABLE_SUPPORT */

#endif /* ! USE_CAIRO */

return 1;

DEFSYM (QCcrop, ":crop");

DEFSYM (QCrotation, ":rotation");

DEFSYM (QCmatrix, ":matrix");

DEFSYM (QCcolor_adjustment, ":color-adjustment");

DEFSYM (QCmask, ":mask");

}

#endif

#if defined HAVE_INOTIFY || defined HAVE_KQUEUE || defined HAVE_GFILENOTIFY

case FILE_NOTIFY_EVENT:

{

is used. Note that [Enter] is not echoed by dos. */

cursor_to (SELECTED_FRAME (), 0, 0);

#endif

/* It doesn't work to autosave while GC is in progress;

the code used for auto-saving doesn't cope with the mark bit. */

if (!gc_in_progress)

variable are `sigusr1' and `sigusr2'. */);

Vdebug_on_event = intern_c_string ("sigusr2");

/* Create the initial keyboard. Qt means 'unset'. */

initial_kboard = allocate_kboard (Qt);

}

#include "keyboard.h"

#include "process.h"



/* File handle for kqueue. */

static int kqueuefd = -1;

(Lisp_Object file, Lisp_Object flags, Lisp_Object callback)

{

Lisp_Object watch_object, dir_list;

u_short fflags = 0;

struct kevent kev;

/* Check parameters. */

CHECK_STRING (file);

if (! FUNCTIONP (callback))

wrong_type_argument (Qinvalid_function, callback);

if (kqueuefd < 0)

{

/* Create kqueue descriptor. */

#include "lisp.h"

char my_edata[] = "End of Emacs initialized data";

/* Help unexec locate the end of the .bss area used by Emacs (which

isn't always a separate section in NT executables). */

extern _Noreturn void wrong_choice (Lisp_Object, Lisp_Object);

/* Defined in emacs.c. */

extern bool might_dump;

/* True means Emacs has already been initialized.

Used during startup to detect startup of dumped Emacs. */

extern bool initialized;

#if defined REL_ALLOC && !defined SYSTEM_MALLOC && !defined HYBRID_MALLOC

extern void refill_memory_reserve (void);

#endif

extern void alloc_unexec_pre (void);

extern void alloc_unexec_post (void);

extern const char *pending_malloc_warning;

extern Lisp_Object zero_vector;

extern Lisp_Object *stack_base;

INLINE void (check_cons_list) (void) { lisp_h_check_cons_list (); }

#endif

#ifdef REL_ALLOC

/* Defined in ralloc.c. */

extern void *r_alloc (void **, size_t) ATTRIBUTE_ALLOC_SIZE ((2));

extern _Noreturn void error (const char *, ...) ATTRIBUTE_FORMAT_PRINTF (1, 2);

extern _Noreturn void verror (const char *, va_list)

ATTRIBUTE_FORMAT_PRINTF (1, 0);

extern void un_autoload (Lisp_Object);

extern Lisp_Object call_debugger (Lisp_Object arg);

extern void *near_C_stack_top (void);

/* True means remove site-lisp directories from load-path. */

extern bool no_site_lisp;

/* Pipe used to send exit notification to the daemon parent at

startup. On Windows, we use a kernel event instead. */

#ifndef WINDOWSNT

struct terminal;

/* Defined in sysdep.c. */

extern void stuff_char (char c);

extern void init_foreground_group (void);

extern void sys_subshell (void);

# include <sys/stropts.h>

#endif

#ifdef HAVE_UTIL_H

#include <util.h>

#endif

#endif

#endif

#ifdef WINDOWSNT

extern int sys_select (int, fd_set *, fd_set *, fd_set *,

struct timespec *, void *);

/* Indexed by descriptor, gives the process (if any) for that descriptor. */

static Lisp_Object chan_process[FD_SETSIZE];

/* Alist of elements (NAME . PROCESS). */

static Lisp_Object Vprocess_alist;

/* Table of `partner address' for datagram sockets. */

static struct sockaddr_and_len {

struct sockaddr *sa;

} datagram_address[FD_SETSIZE];

#define DATAGRAM_CHAN_P(chan) (datagram_address[chan].sa != 0)

#define DATAGRAM_CONN_P(proc) \

p->sentinel = NILP (val) ? Qinternal_default_process_sentinel : val;

}

static void

pset_tty_name (struct Lisp_Process *p, Lisp_Object val)

{

p->tty_name = val;

#ifdef HAVE_GNUTLS

p->gnutls_initstage = GNUTLS_STAGE_EMPTY;

#endif

/* If name is already in use, modify it until it is unused. */

deactivate_process (proc);

}



DEFUN ("processp", Fprocessp, Sprocessp, 1, 1, 0,

doc: /* Return t if OBJECT is a process. */)

process = get_process (process);

p = XPROCESS (process);

p->raw_status_new = 0;

if (NETCONN1_P (p) || SERIALCONN1_P (p) || PIPECONN1_P (p))

{

return XPROCESS (process)->mark;

}

DEFUN ("set-process-filter", Fset_process_filter, Sset_process_filter,

2, 2, 0,

doc: /* Give PROCESS the filter function FILTER; nil means default.

- if `default-enable-multibyte-characters' is nil, it is a unibyte

string (the result of converting the decoded input multibyte

string to unibyte with `string-make-unibyte'). */)

{

CHECK_PROCESS (process);

/* Don't signal an error if the process's input file descriptor

is closed. This could make debugging Lisp more difficult,

if (NILP (filter))

filter = Qinternal_default_process_filter;

if (p->infd >= 0)

if (NETCONN1_P (p) || SERIALCONN1_P (p) || PIPECONN1_P (p))

pset_childp (p, Fplist_put (p->childp, QCfilter, filter));

setup_process_coding_systems (process);

CHECK_RANGED_INTEGER (height, 0, USHRT_MAX);

CHECK_RANGED_INTEGER (width, 0, USHRT_MAX);

|| (set_window_size (XPROCESS (process)->infd,

XINT (height), XINT (width))

< 0))

connection. If KEY is t, the complete contact information for the

connection is returned, else the specific value for the keyword KEY is

returned. See `make-network-process' or `make-serial-process' for a

{

Lisp_Object contact;

contact = XPROCESS (process)->childp;

#ifdef DATAGRAM_SOCKETS

if (DATAGRAM_CONN_P (process)

&& (EQ (key, Qt) || EQ (key, QCremote)))

contact = Fplist_put (contact, QCremote,

DEFUN ("set-process-plist", Fset_process_plist, Sset_process_plist,

2, 2, 0,

{

CHECK_PROCESS (process);

CHECK_LIST (plist);

An 8 or 9 element vector represents an IPv6 address (with port number).

If optional second argument OMIT-PORT is non-nil, don't include a port

number in the string, even when present in ADDRESS.

(Lisp_Object address, Lisp_Object omit_port)

{

if (NILP (address))

The address family of sa is not included in the result. */

Lisp_Object

{

Lisp_Object address;

unsigned char *cp;

/* Workaround for a bug in getsockname on BSD: Names bound to

sockets in the UNIX domain are inaccessible; getsockname returns

/* Get family and required size for sockaddr structure to hold ADDRESS. */

get_lisp_to_sockaddr_size (Lisp_Object address, int *familyp)

{

if (VECTORP (address))

{

#ifdef DATAGRAM_SOCKETS

DEFUN ("process-datagram-address", Fprocess_datagram_address, Sprocess_datagram_address,

1, 1, 0,

(Lisp_Object process)

{

int channel;

CHECK_PROCESS (process);

if (!DATAGRAM_CONN_P (process))

return Qnil;

DEFUN ("set-process-datagram-address", Fset_process_datagram_address, Sset_process_datagram_address,

2, 2, 0,

doc: /* Set the datagram address for PROCESS to ADDRESS.

(Lisp_Object process, Lisp_Object address)

{

int channel;

CHECK_PROCESS (process);

if (!DATAGRAM_CONN_P (process))

return Qnil;

/* Set option OPT to value VAL on socket S.

Signals an error if setting a known option fails.

*/

doc: /* For network process PROCESS set option OPTION to value VALUE.

See `make-network-process' for a list of options and values.

If optional fourth arg NO-ERROR is non-nil, don't signal an error if

(Lisp_Object process, Lisp_Object option, Lisp_Object value, Lisp_Object no_error)

{

int s;

if (!NETCONN1_P (p))

error ("Process is not a network process");

s = p->infd;

if (s < 0)

error ("Process is not running");

return proc;

}

/* Create a network stream/datagram client/server process. Treated

exactly like a normal process when reading and writing. Primary

differences are in status display and process deletion. A network

:service SERVICE -- SERVICE is name of the service desired, or an

integer specifying a port number to connect to. If SERVICE is t,

:type TYPE -- TYPE is the type of connection. The default (nil) is a

stream type connection, `datagram' creates a datagram type connection,

is a cons (DECODING . ENCODING), DECODING is used for reading, and

ENCODING is used for writing.

:noquery BOOL -- Query the user unless BOOL is non-nil, and process is

running when Emacs is exited.

:plist PLIST -- Install PLIST as the new process's initial plist.

:server QLEN -- if QLEN is non-nil, create a server process for the

specified FAMILY, SERVICE, and connection type (stream or datagram).

If QLEN is an integer, it is used as the max. length of the server's

Lisp_Object proc;

Lisp_Object contact;

struct Lisp_Process *p;

const char *portstring;

#ifdef HAVE_LOCAL_SOCKETS

struct sockaddr_un address_un;

#endif

Lisp_Object tem;

Lisp_Object name, buffer, host, service, address;

Lisp_Object filter, sentinel;

int socktype;

int family = -1;

if (nargs == 0)

return Qnil;

else

error ("Unsupported connection type");

name = Fplist_get (contact, QCname);

buffer = Fplist_get (contact, QCbuffer);

filter = Fplist_get (contact, QCfilter);

CHECK_STRING (name);

/* :local ADDRESS or :remote ADDRESS */

if (!NILP (address))

{

host = service = Qnil;

error ("Malformed :address");

goto open_socket;

}

tem = Fplist_get (contact, QCfamily);

if (NILP (tem))

{

family = AF_UNSPEC;

#else

family = AF_INET;

else

error ("Unknown address family");

/* :service SERVICE -- string, integer (port number), or t (random port). */

service = Fplist_get (contact, QCservice);

/* :host HOST -- hostname, ip address, or 'local for localhost. */

host = Fplist_get (contact, QChost);

{

if (EQ (host, Qlocal))

/* Depending on setup, "localhost" may map to different IPv4 and/or

host = Qnil;

}

CHECK_STRING (service);

if (sizeof address_un.sun_path <= SBYTES (service))

error ("Service name too long");

goto open_socket;

}

#endif

}

#endif

if (!NILP (host))

{

/* SERVICE can either be a string or int.

Convert to a C string for later use by getaddrinfo. */

if (EQ (service, Qt))

else if (INTEGERP (service))

{

portstring = portbuf;

}

else

{

CHECK_STRING (service);

portstring = SSDATA (service);

}

if (ret)

goto open_socket;

}

if (!NILP (host))

{

immediate_quit = 1;

QUIT;

{

}

#else

#endif

{

}

}

{

{

{

}

}

}

{

}

if (!NILP (buffer))

buffer = Fget_buffer_create (buffer);

proc = make_process (name);

p = XPROCESS (proc);

pset_childp (p, contact);

pset_plist (p, Fcopy_sequence (Fplist_get (contact, QCplist)));

pset_type (p, Qnetwork);

if ((tem = Fplist_get (contact, QCstop), !NILP (tem)))

pset_command (p, Qt);

p->pid = 0;

unbind_to (count, Qnil);

{

}

#endif

return proc;

}

exec_sentinel (proc, concat3 (open_from, host_string, nl));

}

/* This variable is different from waiting_for_input in keyboard.c.

It is used to communicate to a lisp process-filter/sentinel (via the

function Fwaiting_for_user_input_p below) whether Emacs was waiting

struct timespec got_output_end_time = invalid_timespec ();

enum { MINIMUM = -1, TIMEOUT, INFINITY } wait;

int got_some_output = -1;

ptrdiff_t count = SPECPDL_INDEX ();

/* Close to the current time if known, an invalid timespec otherwise. */

if (! NILP (wait_for_cell) && ! NILP (XCAR (wait_for_cell)))

break;

/* Compute time from now till when time limit is up. */

/* Exit if already run out. */

if (wait == TIMEOUT)

if (timeout.tv_sec > 0 || timeout.tv_nsec > 0)

now = invalid_timespec ();

#if defined (HAVE_NS)

nfds = ns_select

#elif defined (HAVE_GLIB)

}

else

{

if (0 <= p->infd && !EQ (p->filter, Qt)

&& !EQ (p->command, Qt))

{

ssize_t rv;

struct coding_system *coding;

if (p->raw_status_new)

update_status (p);

if (! EQ (p->status, Qrun))

Called from program, takes three arguments, PROCESS, START and END.

If the region is more than 500 characters long,

it is sent in several bunches. This may happen even for shorter regions.

(Lisp_Object process, Lisp_Object start, Lisp_Object end)

{

Lisp_Object proc = get_process (process);

if (XINT (start) < GPT && XINT (end) > GPT)

move_gap_both (XINT (start), start_byte);

send_process (proc, (char *) BYTE_POS_ADDR (start_byte),

end_byte - start_byte, Fcurrent_buffer ());

nil, indicating the current buffer's process.

If STRING is more than 500 characters long,

it is sent in several bunches. This may happen even for shorter strings.

(Lisp_Object process, Lisp_Object string)

{

CHECK_STRING (string);

send_process (proc, SSDATA (string),

SBYTES (string), string);

return Qnil;

{

/* Initialize in case ioctl doesn't exist or gives an error,

in a way that will cause returning t. */

if (!EQ (p->type, Qreal))

error ("Process %s is not a subprocess",

error ("Process %s is not active",

SDATA (p->name));

if (gid == p->pid)

return Qnil;

break;

case SIGTSTP:

sig_char = &t.c_cc[VSWTCH];

#else

sig_char = &t.c_cc[VSUSP];

struct coding_system *coding = NULL;

int outfd;

return process;

outfd = XPROCESS (proc)->outfd;

if (outfd >= 0)

coding = proc_encode_coding_system[outfd];

Sset_process_coding_system, 1, 3, 0,

doc: /* Set coding systems of PROCESS to DECODING and ENCODING.

DECODING will be used to decode subprocess output and ENCODING to

{

CHECK_PROCESS (process);

Fcheck_coding_system (decoding);

Fcheck_coding_system (encoding);

encoding = coding_inherit_eol_type (encoding, Qnil);

pset_decode_coding_system (p, decoding);

pset_encode_coding_system (p, encoding);

setup_process_coding_systems (process);

return Qnil;

suppressed. */)

(Lisp_Object process, Lisp_Object flag)

{

CHECK_PROCESS (process);

if (NILP (flag))

pset_decode_coding_system

(p, raw_text_coding_system (p->decode_coding_system));

setup_process_coding_systems (process);

return Qnil;

doc: /* Return t if a multibyte string is given to PROCESS's filter.*/)

(Lisp_Object process)

{

CHECK_PROCESS (process);

if (p->infd < 0)

return Qnil;

return (CODING_FOR_UNIBYTE (coding) ? Qnil : Qt);

}

DEFSYM (QCserver, ":server");

DEFSYM (QCnowait, ":nowait");

DEFSYM (QCsentinel, ":sentinel");

DEFSYM (QClog, ":log");

DEFSYM (QCnoquery, ":noquery");

DEFSYM (QCstop, ":stop");

#ifdef HAVE_GNUTLS

Lisp_Object gnutls_cred_type;

#endif

/* Pipe process attached to the standard error of this process. */

flag indicates that `raw_status' contains a new status that still

needs to be synced to `status'. */

bool_bf raw_status_new : 1;

int raw_status;

#ifdef HAVE_GNUTLS

gnutls_initstage_t gnutls_initstage;

int gnutls_log_level;

int gnutls_handshakes_tried;

bool_bf gnutls_p : 1;

#endif

};

p->childp = val;

}

#ifdef HAVE_GNUTLS

INLINE void

pset_gnutls_cred_type (struct Lisp_Process *p, Lisp_Object val)

extern void record_deleted_pid (pid_t, Lisp_Object);

struct sockaddr;

extern void hold_keyboard_input (void);

extern void unhold_keyboard_input (void);

extern bool kbd_on_hold_p (void);

rather than all of them. This means allowing for a possible

hole between the first bloc and the end of malloc storage. */

#include <config.h>

#include <stddef.h>

#include "getpagesize.h"

/* The hook `malloc' uses for the function which gets more space

from the system. */

extern void *(*__morecore) (ptrdiff_t);

#endif

if (p == pend)

{

/* End of pattern means we might have succeeded. */

DEBUG_PRINT ("end of pattern ... ");

longest match, try backtracking. */

if (d != end_match_2)

{

DEBUG_PRINT ("backtracking.\n");

nfailure_points_pushed - nfailure_points_popped);

DEBUG_PRINT ("%u registers pushed.\n", num_regs_pushed);

DEBUG_PRINT ("Returning %td from re_match_2.\n", dcnt);

along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */

#include <config.h>

#include <stdio.h>

#include "lisp.h"

#include <unistd.h>

#include <stdlib.h> /* for exit */

char bss_sbrk_buffer[STATIC_HEAP_SIZE];

char *max_bss_sbrk_ptr;

void *

bss_sbrk (ptrdiff_t request_size)

{

if (!bss_sbrk_ptr)

{

max_bss_sbrk_ptr = bss_sbrk_ptr = bss_sbrk_buffer;

#ifdef CYGWIN

#endif

}

{

exit (-1);

return 0;

}

{

exit (-1);

return 0;

}

{

}

}

POS and LIMIT are character positions in the current buffer.

If POS is less than LIMIT, POS is at the first character of a word,

If POS is not less than LIMIT, POS is at the last character of a word,

character of that word.

In both cases, LIMIT bounds the search. */);

#include <config.h>

#include <execinfo.h>

#include "sysstdio.h"

#ifdef HAVE_PWD_H

#include <utimens.h>

#include "lisp.h"

#include "sysselect.h"

#include "blockinput.h"

1800, 2400, 4800, 9600, 19200, 38400

};

char *

{

char *buf;

char *pwd = getenv ("PWD");

struct stat dotstat, pwdstat;

}

return buf;

}



/* Discard pending input on all input descriptors. */

void

init_system_name (void)

{

char *hostname_alloc = NULL;

char *hostname;

#ifndef HAVE_GETHOSTNAME

static bool

stack_overflow (siginfo_t *siginfo)

{

/* In theory, a more-accurate heuristic can be obtained by using

GNU/Linux pthread_getattr_np along with POSIX pthread_attr_getstack

and pthread_attr_getguardsize to find the location and size of the

#define DOTEXE ".exe"

/*

** header for Windows executable files

*/

int ret;

int ret2;

infile = add_exe_suffix_if_necessary (infile, infile_buffer);

outfile = add_exe_suffix_if_necessary (outfile, outfile_buffer);

ret = emacs_close (fd_in);

assert (ret == 0);

fixup_executable (fd_out);

ret = emacs_close (fd_out);

assert (ret == 0);

|| !strcmp (old_section_names + new_shdr->sh_name, ".sdata")

|| !strcmp (old_section_names + new_shdr->sh_name, ".lit4")

|| !strcmp (old_section_names + new_shdr->sh_name, ".lit8")

|| !strcmp (old_section_names + new_shdr->sh_name, ".sdata1")

|| !strcmp (old_section_names + new_shdr->sh_name, ".data1"))

src = (caddr_t) old_shdr->sh_addr;

|| !strcmp (old_section_names + shdr->sh_name, ".sdata")

|| !strcmp (old_section_names + shdr->sh_name, ".lit4")

|| !strcmp (old_section_names + shdr->sh_name, ".lit8")

|| !strcmp (old_section_names + shdr->sh_name, ".sdata1")

|| !strcmp (old_section_names + shdr->sh_name, ".data1"))

{

# endif

#endif

extern void *(*__morecore) (ptrdiff_t);

/* From ralloc.c. */

#ifdef REL_ALLOC

int (PASCAL *pfn_sendto) (SOCKET s, const char * buf, int len, int flags,

const struct sockaddr * to, int tolen);

/* SetHandleInformation is only needed to make sockets non-inheritable. */

BOOL (WINAPI *pfn_SetHandleInformation) (HANDLE object, DWORD mask, DWORD flags);

#ifndef HANDLE_FLAG_INHERIT

LOAD_PROC (sendto);

#undef LOAD_PROC

/* specify version 1.1 of winsock */

if (pfn_WSAStartup (0x101, &winsockData) == 0)

{

}

int

sys_shutdown (int s, int how)

{

if (winsock_lib == NULL)

unsigned long nblock = 0;

if (winsock_lib == NULL) emacs_abort ();

/* TODO: implement select() properly so non-blocking I/O works. */

/* For now, make sure the write blocks. */

if (fd_info[fd].flags & FILE_NDELAY)

nchars = pfn_send (SOCK_HANDLE (fd), buffer, count, 0);

/* Set the socket back to non-blocking if it was before,

for other operations that support it. */

if (fd_info[fd].flags & FILE_NDELAY)

nblock = 1;

pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);

}

}

else

{



/* Emulation of SIOCGIFCONF and getifaddrs, see process.c. */

/* Return information about network interface IFNAME, or about all

interfaces (if IFNAME is nil). */

/* Setup w32_display_info structure for this frame. */

w32_initialize_display_info (build_string ("Console"));

}

/* Added by Kevin Gallo */

#include <config.h>

#include <signal.h>

#include <stdio.h>

#include "coding.h"

#include "w32common.h"

#ifdef WINDOWSNT

#include <mbstring.h>

#include "w32.h"

#endif

#include <commctrl.h>

#include <commdlg.h>

#include <shellapi.h>

static unsigned int sound_type = 0xFFFFFFFF;

#define MB_EMACS_SILENT (0xFFFFFFFF - 1)

/* Let the user specify a display with a frame.

nil stands for the selected frame--or, if that is not a w32 frame,

the first display on the list. */

post_msg (wmsg);

}

/* GetKeyState and MapVirtualKey on Windows 95 do not actually distinguish

between left and right keys as advertised. We test for this

support dynamically, and set a flag when the support is absent. If

else

return (GetKeyState (vkey) & 0x1);

}

if (!modifiers_recorded)

return (GetKeyState (vkey) & 0x8000);

/* List of special key combinations which w32 would normally capture,

but Emacs should grab instead. Not directly visible to lisp, to

simplify synchronization. Each item is an integer encoding a virtual

static Lisp_Object w32_grabbed_keys;

#define HOTKEY(vk, mods) make_number (((vk) & 255) | ((mods) << 8))

switch (wParam)

{

case VK_LWIN:

{

/* Prevent system from acting on keyup (which opens the

Start menu if no other key was pressed) by simulating a

return 0;

break;

case VK_RWIN:

{

if (GetAsyncKeyState (wParam) & 1)

{

case WM_SETFOCUS:

dpyinfo->faked_key = 0;

reset_modifiers ();

goto command;

case WM_KILLFOCUS:

button_state = 0;

ReleaseCapture ();

/* Relinquish the system caret. */

my_post_msg (&wmsg, hwnd, msg, wParam, lParam);

goto dflt;

case WM_DESTROY:

CoUninitialize ();

return 0;

case WM_CLOSE:

wmsg.dwModifiers = w32_get_modifiers ();

my_post_msg (&wmsg, hwnd, msg, wParam, lParam);

Tool tips

***********************************************************************/

static void compute_tip_xy (struct frame *, Lisp_Object, Lisp_Object,

Lisp_Object, int, int, int *, int *);

/* Create a frame for a tooltip on the display described by DPYINFO.

Note that functions called here, esp. x_default_parameter can

signal errors, for instance when a specified color name is

when this happens. */

static Lisp_Object

{

struct frame *f;

Lisp_Object frame;

ptrdiff_t count = SPECPDL_INDEX ();

struct kboard *kb;

bool face_change_before = face_change;

int x_width = 0, x_height = 0;

/* Use this general default value to start with until we know if

frame = Qnil;

/* Make a frame without minibuffer nor mode-line. */

f = make_frame (false);

XSETFRAME (frame, f);

record_unwind_protect (unwind_create_tip_frame, frame);

/* By setting the output method, we're essentially saying that

{

fset_name (f, name);

f->explicit_name = true;

specbind (Qx_resource_name, name);

}

parms = Fcons (Fcons (Qinternal_border_width, value),

parms);

}

x_default_parameter (f, parms, Qinternal_border_width, make_number (1),

"internalBorderWidth", "internalBorderWidth",

RES_TYPE_NUMBER);

/* Also do the stuff which must be set before the window exists. */

x_default_parameter (f, parms, Qforeground_color, build_string ("black"),

"foreground", "Foreground", RES_TYPE_STRING);

f->fringe_cols = 0;

f->left_fringe_width = 0;

f->right_fringe_width = 0;

block_input ();

my_create_tip_window (f);

SET_FRAME_LINES (f, 0);

adjust_frame_size (f, width * FRAME_COLUMN_WIDTH (f),

height * FRAME_LINE_HEIGHT (f), 0, true, Qtip_frame);

/* Add `tooltip' frame parameter's default value. */

if (NILP (Fframe_parameter (frame, Qtooltip)))

Fmodify_frame_parameters (frame, Fcons (Fcons (Qtooltip, Qt), Qnil));

Lisp_Object fg = Fframe_parameter (frame, Qforeground_color);

Lisp_Object colors = Qnil;

call2 (Qface_set_after_frame_default, frame, Qnil);

if (!EQ (bg, Fframe_parameter (frame, Qbackground_color)))

*root_x = min_x;

}

DEFUN ("x-show-tip", Fx_show_tip, Sx_show_tip, 1, 6, 0,

doc: /* Show STRING in a \"tooltip\" window on frame FRAME.

Text larger than the specified size is clipped. */)

(Lisp_Object string, Lisp_Object frame, Lisp_Object parms, Lisp_Object timeout, Lisp_Object dx, Lisp_Object dy)

{

struct window *w;

int root_x, root_y;

struct buffer *old_buffer;

struct text_pos pos;

int i, width, height;

int old_windows_or_buffers_changed = windows_or_buffers_changed;

ptrdiff_t count = SPECPDL_INDEX ();

specbind (Qinhibit_redisplay, Qt);

if (NILP (last_show_tip_args))

last_show_tip_args = Fmake_vector (make_number (3), Qnil);

{

Lisp_Object last_string = AREF (last_show_tip_args, 0);

Lisp_Object last_frame = AREF (last_show_tip_args, 1);

Lisp_Object last_parms = AREF (last_show_tip_args, 2);

&& !NILP (Fequal (last_parms, parms)))

{

/* Only DX and DY have changed. */

if (!NILP (tip_timer))

{

Lisp_Object timer = tip_timer;

tip_timer = Qnil;

call1 (Qcancel_timer, timer);

}

block_input ();

/* Put tooltip in topmost group and in position. */

root_x, root_y, 0, 0,

SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOOWNERZORDER);

/* Ensure tooltip is on top of other topmost windows (eg menus). */

0, 0, 0, 0,

SWP_NOMOVE | SWP_NOSIZE

| SWP_NOACTIVATE | SWP_NOOWNERZORDER);

unblock_input ();

goto start_timer;

}

ASET (last_show_tip_args, 0, string);

ASET (last_show_tip_args, 1, frame);

ASET (last_show_tip_args, 2, parms);

/* Block input until the tip has been fully drawn, to avoid crashes

when drawing tips in menus. */

block_input ();

w->left_col = 0;

w->top_line = 0;

w->pixel_left = 0;

w->pixel_top = 0;

if (CONSP (Vx_max_tooltip_size)

{

w->total_cols = XFASTINT (XCAR (Vx_max_tooltip_size));

w->total_lines = XFASTINT (XCDR (Vx_max_tooltip_size));

w->total_lines = 40;

}

old_buffer = current_buffer;

bset_truncate_lines (current_buffer, Qnil);

clear_glyph_matrix (w->desired_matrix);

clear_glyph_matrix (w->current_matrix);

SET_TEXT_POS (pos, BEGV, BEGV_BYTE);

{

RECT rect;

rect.left = rect.top = 0;

rect.right = width;

rect.bottom = height;

root_x, root_y,

rect.bottom - rect.top, SWP_NOACTIVATE | SWP_NOOWNERZORDER);

/* Ensure tooltip is on top of other topmost windows (eg menus). */

0, 0, 0, 0,

SWP_NOMOVE | SWP_NOSIZE

| SWP_NOACTIVATE | SWP_NOOWNERZORDER);

/* Let redisplay know that we have made the frame visible already. */

}

w->must_be_updated_p = true;

update_single_window (w);

set_buffer_internal_1 (old_buffer);

windows_or_buffers_changed = old_windows_or_buffers_changed;

start_timer:

Value is t if tooltip was open, nil otherwise. */)

(void)

{

}



/***********************************************************************

&& strcmp (lispy_function_keys[i], key) == 0)

return i;

return -1;

}

/* Convert a one-element vector style key sequence to a hot key

definition. */

static Lisp_Object

{

/* Copied from Fdefine_key and store_in_keymap. */

register Lisp_Object c;

int vk_code;

int lisp_modifiers;

int w32_modifiers;

CHECK_VECTOR (key);

c = Fcar (c);

if (!SYMBOLP (c))

emacs_abort ();

}

else if (INTEGERP (c))

{

#define MOD_WIN 0x0008

#endif

}

DEFUN ("w32-register-hot-key", Fw32_register_hot_key,

Sw32_register_hot_key, 1, 1, 0,

doc: /* Register KEY as a hot-key combination.

(Lisp_Object key)

{

{

/* Reuse an empty slot if possible. */

Lisp_Object item = Fmemq (Qnil, w32_grabbed_keys);

Lisp_Object item;

if (!INTEGERP (key))

item = Fmemq (key, w32_grabbed_keys);

DEFSYM (Qmm_size, "mm-size");

DEFSYM (Qframes, "frames");

DEFSYM (Qtip_frame, "tip-frame");

DEFSYM (Qunicode_sip, "unicode-sip");

#if defined WINDOWSNT && !defined HAVE_DBUS

DEFSYM (QCicon, ":icon");

If you set this to nil, the left \"Windows\" key is processed by Emacs

according to the value of `w32-lwindow-modifier', which see.

Vw32_pass_lwindow_to_system = Qt;

DEFVAR_LISP ("w32-pass-rwindow-to-system",

If you set this to nil, the right \"Windows\" key is processed by Emacs

according to the value of `w32-rwindow-modifier', which see.

Vw32_pass_rwindow_to_system = Qt;

DEFVAR_LISP ("w32-phantom-key-code",

Phantom key presses are generated in order to stop the system from

acting on \"Windows\" key events when `w32-pass-lwindow-to-system' or

/* Although 255 is technically not a valid key code, it works and

means that this hack won't interfere with any real key code. */

XSETINT (Vw32_phantom_key_code, 255);

doc: /* Modifier to use for the left \"Windows\" key.

The value can be hyper, super, meta, alt, control or shift for the

respective modifier, or nil to appear as the `lwindow' key.

Vw32_lwindow_modifier = Qnil;

DEFVAR_LISP ("w32-rwindow-modifier",

doc: /* Modifier to use for the right \"Windows\" key.

The value can be hyper, super, meta, alt, control or shift for the

respective modifier, or nil to appear as the `rwindow' key.

Vw32_rwindow_modifier = Qnil;

DEFVAR_LISP ("w32-apps-modifier",

This variable has effect only on Windows Vista and later. */);

w32_disable_new_uniscribe_apis = 0;

#if 0 /* TODO: Port to W32 */

defsubr (&Sx_change_window_property);

defsubr (&Sx_delete_window_property);

#include "termchar.h" /* for Mouse_HLInfo, tty_display_info */

#include "w32term.h"

#include "w32inevt.h"

/* stdin, from w32console.c */

extern HANDLE keyboard_handle;

switch (event->wVirtualKeyCode)

{