From: Stephen Leake <stephen_leake@stephe-leake.org>
To: emacs-devel@gnu.org
Subject: Re: Dynamic loading progress
Date: Sat, 14 Feb 2015 19:02:48 -0600 [thread overview]
Message-ID: <85egpsgf5z.fsf@stephe-leake.org> (raw)
In-Reply-To: <834mqowbnh.fsf@gnu.org> (Eli Zaretskii's message of "Sat, 14 Feb 2015 21:12:02 +0200")
[-- Attachment #1: Type: text/plain, Size: 3439 bytes --]
Eli Zaretskii <eliz@gnu.org> writes:
>> From: Stefan Monnier <monnier@iro.umontreal.ca>
>> Date: Fri, 13 Feb 2015 14:11:33 -0500
>> Cc: Paul Eggert <eggert@cs.ucla.edu>, emacs-devel@gnu.org
>>
>> > I would start by coming up with the minimum set of requirements a
>> > module needs to be able to communicate with Emacs.
>>
>> Easy: take the existing sample modules and see what they need.
>
> No one seems to care, so I will bite the bullet.
I took a stab at creating emacs_module_api.h; attached.
To do this, I replaced "#include <lisp.h>"
in modules/curl/curl.c with "#include <emacs_modules_api.h>", and copied
stuff from lisp.h and other headers to emacs_module_api.h until it
compiled. Note the FIXMEs; I could not figure out what was going on in
some places, so I just kludged it for now.
I don't know if this is useful, but it is my interpretation of what
Stefan proposed; lisp.h would "#include emacs_modules_api.h". (He called
it "emacs.h", but I think including 'modules' in the name is better).
> The below is based
> on looking at the modules branch.
>
> It looks like modules need:
>
> . A function to replace the DEFUN macro and the related defsubr call.
>
> . Some definition of Lisp_Object
>
> This already presents at least 2 problems. The first is 32- vs
> 64-bit issues. We need some way of checking that a 32-bit module
> isn't loaded by a 64-bit Emacs, and vice versa.
Good point. That's a special case of "don't load a module compiled for
processor X in an Emacs compiled for processor Y". gnu binutils has
facilities for that.
> The other problem is more serious: Emacs can be built with or
> without --check-lisp-object-type, and with or without --wide-int;
> how will the module know which implementation to use?
Similar check when the module is loaded. Which means we need some
metainfo for each module, and a standard function to retrieve it.
> . Functions to access values of Lisp objects. We shouldn't rely on C
> macros like XINT and XWINDOW for that, because macros track too
> closely the internals of each object. So I propose to use
> functions that will be exposed via the API.
If we follow Stefan's suggestion, then either this function approach is
not viable, or we need another #ifdef for module vs emacs.
> The above means that most of the C source files under modules/ should
> be thoroughly rewritten.
Yes.
> They are currently written as if the code were an integral part of
> Emacs on one of the Emacs C files. Going that way means that modules
> will have to be recompiled from sources for each Emacs version, and
> practically will have to live in the Emacs tree. Maybe this is what we
> want, I don't know.
This is the model I had in mind. Since I need max speed with mixed
Ada/lisp code, I need tight integration with the core. The people who
need that speed for Ada mode will simply have to recompile the module
for each Emacs release; they are coders, so that's not a problem.
On the other hand, modules for other use cases (I have in mind a spam
filter for Gnus) would not need to be nearly so tightly bound, so a more
limited/safe API would be appropriate.
Rather than splitting out emacs_module_api.h from lisp.h, we could add
__declspec(dllexport) to a subset of the functions in lisp.h; I suspect
that will be a small number. I'll give that a try next.
Is there an equivalent on Linux (I don't recall ever seeing one)?
--
-- Stephe
[-- Attachment #2: emacs_modules_api.h --]
[-- Type: application/octet-stream, Size: 37490 bytes --]
/* Emacs modules API */
/* FIXME: for Windows, add __declspec(dllexport) to all (some?) of these */
/* #ifdef WINDOWS */
/* # ifdef emacs */
/* # define EMACS_EXPORT __declspec(dllexport) */
/* # else */
/* # define EMACS_EXPORT __declspec(dllimport) */
/* # endif */
/* # else */
/* # define EMACS_EXPORT */
/* #endif */
/* FIXME: <stdint.h> vs ../nt/inc/stdint.h:37 */
#include <stdint.h>
/* conf_post.h:35 */
#include <stdbool.h>
/* The type of bool bitfields. Needed to compile Objective-C with
standard GCC. It was also needed to port to pre-C99 compilers,
although we don't care about that any more. */
/* conf_post.h:40 */
#if NS_IMPL_GNUSTEP
typedef unsigned int bool_bf;
#else
typedef bool bool_bf;
#endif
/* When not using Clang, assume its attributes and features are absent. */
/* conf_post.h:62 */
#ifndef __has_attribute
# define __has_attribute(a) false
#endif
#ifndef __has_feature
# define __has_feature(a) false
#endif
/* conf_post.h:226 */
#if (__clang__ \
? __has_attribute (externally_visible) \
: (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)))
#define EXTERNALLY_VISIBLE __attribute__((externally_visible))
#else
#define EXTERNALLY_VISIBLE
#endif
/* FIXME: need to define INLINE */
/* conf_post.h:318 */
#define INLINE /* empty */
/* Define a TYPE constant ID as an externally visible name. Use like this:
DEFINE_GDB_SYMBOL_BEGIN (TYPE, ID)
# define ID (some integer preprocessor expression of type TYPE)
DEFINE_GDB_SYMBOL_END (ID)
This hack is for the benefit of compilers that do not make macro
definitions or enums visible to the debugger. It's used for symbols
that .gdbinit needs. */
/* lisp.h:11 */
#define DECLARE_GDB_SYM(type, id) type const id EXTERNALLY_VISIBLE
#ifdef MAIN_PROGRAM
# define DEFINE_GDB_SYMBOL_BEGIN(type, id) DECLARE_GDB_SYM (type, id)
# define DEFINE_GDB_SYMBOL_END(id) = id;
#else
# define DEFINE_GDB_SYMBOL_BEGIN(type, id) extern DECLARE_GDB_SYM (type, id)
# define DEFINE_GDB_SYMBOL_END(val) ;
#endif
/* Number of bits in a Lisp_Object tag. */
/* lisp.h:70 */
DEFINE_GDB_SYMBOL_BEGIN (int, GCTYPEBITS)
#define GCTYPEBITS 3
DEFINE_GDB_SYMBOL_END (GCTYPEBITS)
/* EMACS_INT - signed integer wide enough to hold an Emacs value
EMACS_INT_MAX - maximum value of EMACS_INT; can be used in #if
pI - printf length modifier for EMACS_INT
EMACS_UINT - unsigned variant of EMACS_INT */
/* lisp.h:87 */
#ifndef EMACS_INT_MAX
# if INTPTR_MAX <= 0
# error "INTPTR_MAX misconfigured"
# elif INTPTR_MAX <= INT_MAX >> NONPOINTER_BITS && !defined WIDE_EMACS_INT
typedef int EMACS_INT;
typedef unsigned int EMACS_UINT;
# define EMACS_INT_MAX INT_MAX
# define pI ""
# elif INTPTR_MAX <= LONG_MAX >> NONPOINTER_BITS && !defined WIDE_EMACS_INT
typedef long int EMACS_INT;
typedef unsigned long EMACS_UINT;
# define EMACS_INT_MAX LONG_MAX
# define pI "l"
/* Check versus LLONG_MAX, not LLONG_MAX >> NONPOINTER_BITS.
In theory this is not safe, but in practice it seems to be OK. */
# elif INTPTR_MAX <= LLONG_MAX
typedef long long int EMACS_INT;
typedef unsigned long long int EMACS_UINT;
# define EMACS_INT_MAX LLONG_MAX
# define pI "ll"
# else
# error "INTPTR_MAX too large"
# endif
#endif
/* Number of bits in some machine integer types. */
/* lisp.h:134 */
enum
{
BITS_PER_CHAR = CHAR_BIT,
BITS_PER_SHORT = CHAR_BIT * sizeof (short),
BITS_PER_LONG = CHAR_BIT * sizeof (long int),
BITS_PER_EMACS_INT = CHAR_BIT * sizeof (EMACS_INT)
};
/* Define Emacs versions of <assert.h>'s 'assert (COND)' and <verify.h>'s
'assume (COND)'. COND should be free of side effects, as it may or
may not be evaluated.
'eassert (COND)' checks COND at runtime if ENABLE_CHECKING is
defined and suppress_checking is false, and does nothing otherwise.
Emacs dies if COND is checked and is false. The suppress_checking
variable is initialized to 0 in alloc.c. Set it to 1 using a
debugger to temporarily disable aborting on detected internal
inconsistencies or error conditions.
In some cases, a good compiler may be able to optimize away the
eassert macro even if ENABLE_CHECKING is true, e.g., if XSTRING (x)
uses eassert to test STRINGP (x), but a particular use of XSTRING
is invoked only after testing that STRINGP (x) is true, making the
test redundant.
eassume is like eassert except that it also causes the compiler to
assume that COND is true afterwards, regardless of whether runtime
checking is enabled. This can improve performance in some cases,
though it can degrade performance in others. It's often suboptimal
for COND to call external functions or access volatile storage. */
/* lisp.h:199 */
#ifndef ENABLE_CHECKING
# define eassert(cond) ((void) (false && (cond))) /* Check COND compiles. */
# define eassume(cond) assume (cond)
#else /* ENABLE_CHECKING */
extern _Noreturn void die (const char *, const char *, int);
extern bool suppress_checking EXTERNALLY_VISIBLE;
# define eassert(cond) \
(suppress_checking || (cond) \
? (void) 0 \
: die (# cond, __FILE__, __LINE__))
# define eassume(cond) \
(suppress_checking \
? assume (cond) \
: (cond) \
? (void) 0 \
: die (# cond, __FILE__, __LINE__))
#endif /* ENABLE_CHECKING */
/* lisp.h:239 */
enum Lisp_Bits
{
/* 2**GCTYPEBITS. This must be a macro that expands to a literal
integer constant, for MSVC. */
#define GCALIGNMENT 8
/* Number of bits in a Lisp_Object value, not counting the tag. */
VALBITS = BITS_PER_EMACS_INT - GCTYPEBITS,
/* Number of bits in a Lisp fixnum tag. */
INTTYPEBITS = GCTYPEBITS - 1,
/* Number of bits in a Lisp fixnum value, not counting the tag. */
FIXNUM_BITS = VALBITS + 1
};
/* The maximum value that can be stored in a EMACS_INT, assuming all
bits other than the type bits contribute to a nonnegative signed value.
This can be used in #if, e.g., '#if USB_TAG' below expands to an
expression involving VAL_MAX. */
/* lisp.h:263 */
#define VAL_MAX (EMACS_INT_MAX >> (GCTYPEBITS - 1))
/* Whether the least-significant bits of an EMACS_INT contain the tag.
On hosts where pointers-as-ints do not exceed VAL_MAX / 2, USE_LSB_TAG is:
a. unnecessary, because the top bits of an EMACS_INT are unused, and
b. slower, because it typically requires extra masking.
So, USE_LSB_TAG is true only on hosts where it might be useful. */
/* lisp.h:270 */
/* FIXME: not working; just set it */
DEFINE_GDB_SYMBOL_BEGIN (bool, USE_LSB_TAG)
#define USE_LSB_TAG 0 /* (VAL_MAX / 2 < INTPTR_MAX) */
DEFINE_GDB_SYMBOL_END (USE_LSB_TAG)
/* FIXME: */
/* #if !USE_LSB_TAG && !defined WIDE_EMACS_INT */
/* # error "USE_LSB_TAG not supported on this platform; please report this." \ */
/* "Try 'configure --with-wide-int' to work around the problem." */
/* error !; */
/* #endif */
/* lisp.h:280 */
#ifndef alignas
# define alignas(alignment) /* empty */
# if USE_LSB_TAG
# error "USE_LSB_TAG requires alignas"
# endif
#endif
/* lisp.h:287 */
#ifdef HAVE_STRUCT_ATTRIBUTE_ALIGNED
# define GCALIGNED __attribute__ ((aligned (GCALIGNMENT)))
#else
# define GCALIGNED /* empty */
#endif
/* Some operations are so commonly executed that they are implemented
as macros, not functions, because otherwise runtime performance would
suffer too much when compiling with GCC without optimization.
There's no need to inline everything, just the operations that
would otherwise cause a serious performance problem.
For each such operation OP, define a macro lisp_h_OP that contains
the operation's implementation. That way, OP can be implemented
via a macro definition like this:
#define OP(x) lisp_h_OP (x)
and/or via a function definition like this:
LISP_MACRO_DEFUN (OP, Lisp_Object, (Lisp_Object x), (x))
which macro-expands to this:
Lisp_Object (OP) (Lisp_Object x) { return lisp_h_OP (x); }
without worrying about the implementations diverging, since
lisp_h_OP defines the actual implementation. The lisp_h_OP macros
are intended to be private to this include file, and should not be
used elsewhere.
FIXME: Remove the lisp_h_OP macros, and define just the inline OP
functions, once most developers have access to GCC 4.8 or later and
can use "gcc -Og" to debug. Maybe in the year 2016. See
Bug#11935.
Commentary for these macros can be found near their corresponding
functions, below. */
#if CHECK_LISP_OBJECT_TYPE
# define lisp_h_XLI(o) ((o).i)
# define lisp_h_XIL(i) ((Lisp_Object) { i })
#else
# define lisp_h_XLI(o) (o)
# define lisp_h_XIL(i) (i)
#endif
#define lisp_h_CHECK_LIST_CONS(x, y) CHECK_TYPE (CONSP (x), Qlistp, y)
#define lisp_h_CHECK_NUMBER(x) CHECK_TYPE (INTEGERP (x), Qintegerp, x)
#define lisp_h_CHECK_SYMBOL(x) CHECK_TYPE (SYMBOLP (x), Qsymbolp, x)
#define lisp_h_CHECK_TYPE(ok, predicate, x) \
((ok) ? (void) 0 : (void) wrong_type_argument (predicate, x))
#define lisp_h_CONSP(x) (XTYPE (x) == Lisp_Cons)
#define lisp_h_EQ(x, y) (XLI (x) == XLI (y))
#define lisp_h_FLOATP(x) (XTYPE (x) == Lisp_Float)
#define lisp_h_INTEGERP(x) ((XTYPE (x) & (Lisp_Int0 | ~Lisp_Int1)) == Lisp_Int0)
#define lisp_h_MARKERP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker)
#define lisp_h_MISCP(x) (XTYPE (x) == Lisp_Misc)
#define lisp_h_NILP(x) EQ (x, Qnil)
#define lisp_h_SET_SYMBOL_VAL(sym, v) \
(eassert ((sym)->redirect == SYMBOL_PLAINVAL), (sym)->val.value = (v))
#define lisp_h_SYMBOL_CONSTANT_P(sym) (XSYMBOL (sym)->constant)
#define lisp_h_SYMBOL_VAL(sym) \
(eassert ((sym)->redirect == SYMBOL_PLAINVAL), (sym)->val.value)
#define lisp_h_SYMBOLP(x) (XTYPE (x) == Lisp_Symbol)
#define lisp_h_VECTORLIKEP(x) (XTYPE (x) == Lisp_Vectorlike)
#define lisp_h_XCAR(c) XCONS (c)->car
#define lisp_h_XCDR(c) XCONS (c)->u.cdr
#define lisp_h_XCONS(a) \
(eassert (CONSP (a)), (struct Lisp_Cons *) XUNTAG (a, Lisp_Cons))
#define lisp_h_XHASH(a) XUINT (a)
#define lisp_h_XPNTR(a) \
(SYMBOLP (a) ? XSYMBOL (a) : (void *) ((intptr_t) (XLI (a) & VALMASK)))
#ifndef GC_CHECK_CONS_LIST
# define lisp_h_check_cons_list() ((void) 0)
#endif
#if USE_LSB_TAG
# define lisp_h_make_number(n) \
XIL ((EMACS_INT) (((EMACS_UINT) (n) << INTTYPEBITS) + Lisp_Int0))
# define lisp_h_XFASTINT(a) XINT (a)
# define lisp_h_XINT(a) (XLI (a) >> INTTYPEBITS)
# define lisp_h_XSYMBOL(a) \
(eassert (SYMBOLP (a)), \
(struct Lisp_Symbol *) ((uintptr_t) XLI (a) - Lisp_Symbol \
+ (char *) lispsym))
# define lisp_h_XTYPE(a) ((enum Lisp_Type) (XLI (a) & ~VALMASK))
# define lisp_h_XUNTAG(a, type) ((void *) (intptr_t) (XLI (a) - (type)))
#endif
/* When compiling via gcc -O0, define the key operations as macros, as
Emacs is too slow otherwise. To disable this optimization, compile
with -DINLINING=false. */
#if (defined __NO_INLINE__ \
&& ! defined __OPTIMIZE__ && ! defined __OPTIMIZE_SIZE__ \
&& ! (defined INLINING && ! INLINING))
# define XLI(o) lisp_h_XLI (o)
# define XIL(i) lisp_h_XIL (i)
# define CHECK_LIST_CONS(x, y) lisp_h_CHECK_LIST_CONS (x, y)
# define CHECK_NUMBER(x) lisp_h_CHECK_NUMBER (x)
# define CHECK_SYMBOL(x) lisp_h_CHECK_SYMBOL (x)
# define CHECK_TYPE(ok, predicate, x) lisp_h_CHECK_TYPE (ok, predicate, x)
# define CONSP(x) lisp_h_CONSP (x)
# define EQ(x, y) lisp_h_EQ (x, y)
# define FLOATP(x) lisp_h_FLOATP (x)
# define INTEGERP(x) lisp_h_INTEGERP (x)
# define MARKERP(x) lisp_h_MARKERP (x)
# define MISCP(x) lisp_h_MISCP (x)
# define NILP(x) lisp_h_NILP (x)
# define SET_SYMBOL_VAL(sym, v) lisp_h_SET_SYMBOL_VAL (sym, v)
# define SYMBOL_CONSTANT_P(sym) lisp_h_SYMBOL_CONSTANT_P (sym)
# define SYMBOL_VAL(sym) lisp_h_SYMBOL_VAL (sym)
# define SYMBOLP(x) lisp_h_SYMBOLP (x)
# define VECTORLIKEP(x) lisp_h_VECTORLIKEP (x)
# define XCAR(c) lisp_h_XCAR (c)
# define XCDR(c) lisp_h_XCDR (c)
# define XCONS(a) lisp_h_XCONS (a)
# define XHASH(a) lisp_h_XHASH (a)
# define XPNTR(a) lisp_h_XPNTR (a)
# ifndef GC_CHECK_CONS_LIST
# define check_cons_list() lisp_h_check_cons_list ()
# endif
# if USE_LSB_TAG
# define make_number(n) lisp_h_make_number (n)
# define XFASTINT(a) lisp_h_XFASTINT (a)
# define XINT(a) lisp_h_XINT (a)
# define XSYMBOL(a) lisp_h_XSYMBOL (a)
# define XTYPE(a) lisp_h_XTYPE (a)
# define XUNTAG(a, type) lisp_h_XUNTAG (a, type)
# endif
#endif
/* Define NAME as a lisp.h inline function that returns TYPE and has
arguments declared as ARGDECLS and passed as ARGS. ARGDECLS and
ARGS should be parenthesized. Implement the function by calling
lisp_h_NAME ARGS. */
/* lisp.h:423 */
#define LISP_MACRO_DEFUN(name, type, argdecls, args) \
INLINE type (name) argdecls { return lisp_h_##name args; }
/* Lisp integers use 2 tags, to give them one extra bit, thus
extending their range from, e.g., -2^28..2^28-1 to -2^29..2^29-1. */
/* lisp.h:437 */
#define INTMASK (EMACS_INT_MAX >> (INTTYPEBITS - 1))
/* Idea stolen from GDB. Pedantic GCC complains about enum bitfields,
MSVC doesn't support them, and xlc and Oracle Studio c99 complain
vociferously about them. */
/* lisp.h:443 */
#if (defined __STRICT_ANSI__ || defined _MSC_VER || defined __IBMC__ \
|| (defined __SUNPRO_C && __STDC__))
#define ENUM_BF(TYPE) unsigned int
#else
#define ENUM_BF(TYPE) enum TYPE
#endif
/* lisp.h:451 */
enum Lisp_Type
{
/* Symbol. XSYMBOL (object) points to a struct Lisp_Symbol. */
Lisp_Symbol = 0,
/* Miscellaneous. XMISC (object) points to a union Lisp_Misc,
whose first member indicates the subtype. */
Lisp_Misc = 1,
/* Integer. XINT (obj) is the integer value. */
Lisp_Int0 = 2,
Lisp_Int1 = USE_LSB_TAG ? 6 : 3,
/* String. XSTRING (object) points to a struct Lisp_String.
The length of the string, and its contents, are stored therein. */
Lisp_String = 4,
/* Vector of Lisp objects, or something resembling it.
XVECTOR (object) points to a struct Lisp_Vector, which contains
the size and contents. The size field also contains the type
information, if it's not a real vector object. */
Lisp_Vectorlike = 5,
/* Cons. XCONS (object) points to a struct Lisp_Cons. */
Lisp_Cons = USE_LSB_TAG ? 3 : 6,
Lisp_Float = 7
};
/* This is the set of data types that share a common structure.
The first member of the structure is a type code from this set.
The enum values are arbitrary, but we'll use large numbers to make it
more likely that we'll spot the error if a random word in memory is
mistakenly interpreted as a Lisp_Misc. */
/* lisp.h:485 */
enum Lisp_Misc_Type
{
Lisp_Misc_Free = 0x5eab,
Lisp_Misc_Marker,
Lisp_Misc_Overlay,
Lisp_Misc_Save_Value,
/* Currently floats are not a misc type,
but let's define this in case we want to change that. */
Lisp_Misc_Float,
#ifdef HAVE_LTDL
Lisp_Misc_Module,
#endif
/* This is not a type code. It is for range checking. */
Lisp_Misc_Limit
};
/* If you want to define a new Lisp data type, here are some
instructions. See the thread at
http://lists.gnu.org/archive/html/emacs-devel/2012-10/msg00561.html
for more info.
First, there are already a couple of Lisp types that can be used if
your new type does not need to be exposed to Lisp programs nor
displayed to users. These are Lisp_Save_Value, a Lisp_Misc
subtype; and PVEC_OTHER, a kind of vectorlike object. The former
is suitable for temporarily stashing away pointers and integers in
a Lisp object. The latter is useful for vector-like Lisp objects
that need to be used as part of other objects, but which are never
shown to users or Lisp code (search for PVEC_OTHER in xterm.c for
an example).
These two types don't look pretty when printed, so they are
unsuitable for Lisp objects that can be exposed to users.
To define a new data type, add one more Lisp_Misc subtype or one
more pseudovector subtype. Pseudovectors are more suitable for
objects with several slots that need to support fast random access,
while Lisp_Misc types are for everything else. A pseudovector object
provides one or more slots for Lisp objects, followed by struct
members that are accessible only from C. A Lisp_Misc object is a
wrapper for a C struct that can contain anything you like.
Explicit freeing is discouraged for Lisp objects in general. But if
you really need to exploit this, use Lisp_Misc (check free_misc in
alloc.c to see why). There is no way to free a vectorlike object.
To add a new pseudovector type, extend the pvec_type enumeration;
to add a new Lisp_Misc, extend the Lisp_Misc_Type enumeration.
For a Lisp_Misc, you will also need to add your entry to union
Lisp_Misc (but make sure the first word has the same structure as
the others, starting with a 16-bit member of the Lisp_Misc_Type
enumeration and a 1-bit GC markbit) and make sure the overall size
of the union is not increased by your addition.
For a new pseudovector, it's highly desirable to limit the size
of your data type by VBLOCK_BYTES_MAX bytes (defined in alloc.c).
Otherwise you will need to change sweep_vectors (also in alloc.c).
Then you will need to add switch branches in print.c (in
print_object, to print your object, and possibly also in
print_preprocess) and to alloc.c, to mark your object (in
mark_object) and to free it (in gc_sweep). The latter is also the
right place to call any code specific to your data type that needs
to run when the object is recycled -- e.g., free any additional
resources allocated for it that are not Lisp objects. You can even
make a pointer to the function that frees the resources a slot in
your object -- this way, the same object could be used to represent
several disparate C structures. */
/* lisp.h:567 */
#ifdef CHECK_LISP_OBJECT_TYPE
typedef struct { EMACS_INT i; } Lisp_Object;
#define LISP_INITIALLY(i) {i}
#undef CHECK_LISP_OBJECT_TYPE
enum CHECK_LISP_OBJECT_TYPE { CHECK_LISP_OBJECT_TYPE = true };
#else /* CHECK_LISP_OBJECT_TYPE */
/* If a struct type is not wanted, define Lisp_Object as just a number. */
typedef EMACS_INT Lisp_Object;
#define LISP_INITIALLY(i) (i)
enum CHECK_LISP_OBJECT_TYPE { CHECK_LISP_OBJECT_TYPE = false };
#endif /* CHECK_LISP_OBJECT_TYPE */
/* lisp.h:582 */
/* lisp.h:612 */
INLINE bool STRINGP (Lisp_Object);
/* lisp.h:621 */
INLINE void *(XUNTAG) (Lisp_Object, int);
/* lisp.h:649 */
enum symbol_redirect
{
SYMBOL_PLAINVAL = 4,
SYMBOL_VARALIAS = 1,
SYMBOL_LOCALIZED = 2,
SYMBOL_FORWARDED = 3
};
/* lisp.h:657 */
struct Lisp_Symbol
{
bool_bf gcmarkbit : 1;
/* Indicates where the value can be found:
0 : it's a plain var, the value is in the `value' field.
1 : it's a varalias, the value is really in the `alias' symbol.
2 : it's a localized var, the value is in the `blv' object.
3 : it's a forwarding variable, the value is in `forward'. */
ENUM_BF (symbol_redirect) redirect : 3;
/* Non-zero means symbol is constant, i.e. changing its value
should signal an error. If the value is 3, then the var
can be changed, but only by `defconst'. */
unsigned constant : 2;
/* Interned state of the symbol. This is an enumerator from
enum symbol_interned. */
unsigned interned : 2;
/* True means that this variable has been explicitly declared
special (with `defvar' etc), and shouldn't be lexically bound. */
bool_bf declared_special : 1;
/* True if pointed to from purespace and hence can't be GC'd. */
bool_bf pinned : 1;
/* The symbol's name, as a Lisp string. */
Lisp_Object name;
/* Value of the symbol or Qunbound if unbound. Which alternative of the
union is used depends on the `redirect' field above. */
union {
Lisp_Object value;
struct Lisp_Symbol *alias;
struct Lisp_Buffer_Local_Value *blv;
union Lisp_Fwd *fwd;
} val;
/* Function value of the symbol or Qnil if not fboundp. */
Lisp_Object function;
/* The symbol's property list. */
Lisp_Object plist;
/* Next symbol in obarray bucket, if the symbol is interned. */
struct Lisp_Symbol *next;
};
/* lisp.h:710 */
#define EXFUN(fnname, maxargs) \
extern Lisp_Object fnname DEFUN_ARGS_ ## maxargs
/* Note that the weird token-substitution semantics of ANSI C makes
this work for MANY and UNEVALLED. */
#define DEFUN_ARGS_MANY (ptrdiff_t, Lisp_Object *)
#define DEFUN_ARGS_UNEVALLED (Lisp_Object)
#define DEFUN_ARGS_0 (void)
#define DEFUN_ARGS_1 (Lisp_Object)
#define DEFUN_ARGS_2 (Lisp_Object, Lisp_Object)
#define DEFUN_ARGS_3 (Lisp_Object, Lisp_Object, Lisp_Object)
#define DEFUN_ARGS_4 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
#define DEFUN_ARGS_5 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
Lisp_Object)
#define DEFUN_ARGS_6 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
Lisp_Object, Lisp_Object)
#define DEFUN_ARGS_7 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
Lisp_Object, Lisp_Object, Lisp_Object)
#define DEFUN_ARGS_8 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
/* Yield an integer that contains TAG along with PTR. */
#define TAG_PTR(tag, ptr) \
((USE_LSB_TAG ? (tag) : (EMACS_UINT) (tag) << VALBITS) + (uintptr_t) (ptr))
/* Yield an integer that contains a symbol tag along with OFFSET.
OFFSET should be the offset in bytes from 'lispsym' to the symbol. */
/* lisp.h:737 */
#define TAG_SYMOFFSET(offset) \
TAG_PTR (Lisp_Symbol, \
((uintptr_t) (offset) >> (USE_LSB_TAG ? 0 : GCTYPEBITS)))
/* lisp.h:754 */
/* FIXME: need to define Qt etc, EXFUNs from globals.h */
struct Lisp_Symbol alignas (GCALIGNMENT) lispsym[1131];
#define iQnil 0
#define Qnil builtin_lisp_symbol (iQnil)
#define iQt 955
#define Qt builtin_lisp_symbol (iQt)
EXFUN (Fprovide, 2);
/* Convert a Lisp_Object to the corresponding EMACS_INT and vice versa.
At the machine level, these operations are no-ops. */
/* lisp.h:758 */
LISP_MACRO_DEFUN (XLI, EMACS_INT, (Lisp_Object o), (o))
LISP_MACRO_DEFUN (XIL, Lisp_Object, (EMACS_INT i), (i))
/* In a pseudovector, the size field actually contains a word with one
PSEUDOVECTOR_FLAG bit set, and one of the following values extracted
with PVEC_TYPE_MASK to indicate the actual type. */
/* lisp.h:776 */
enum pvec_type
{
PVEC_NORMAL_VECTOR,
PVEC_FREE,
PVEC_PROCESS,
PVEC_FRAME,
PVEC_WINDOW,
PVEC_BOOL_VECTOR,
PVEC_BUFFER,
PVEC_HASH_TABLE,
PVEC_TERMINAL,
PVEC_WINDOW_CONFIGURATION,
PVEC_SUBR,
PVEC_OTHER,
/* These should be last, check internal_equal to see why. */
PVEC_COMPILED,
PVEC_CHAR_TABLE,
PVEC_SUB_CHAR_TABLE,
PVEC_FONT /* Should be last because it's used for range checking. */
};
/* lisp.h:787 */
enum More_Lisp_Bits
{
/* For convenience, we also store the number of elements in these bits.
Note that this size is not necessarily the memory-footprint size, but
only the number of Lisp_Object fields (that need to be traced by GC).
The distinction is used, e.g., by Lisp_Process, which places extra
non-Lisp_Object fields at the end of the structure. */
PSEUDOVECTOR_SIZE_BITS = 12,
PSEUDOVECTOR_SIZE_MASK = (1 << PSEUDOVECTOR_SIZE_BITS) - 1,
/* To calculate the memory footprint of the pseudovector, it's useful
to store the size of non-Lisp area in word_size units here. */
PSEUDOVECTOR_REST_BITS = 12,
PSEUDOVECTOR_REST_MASK = (((1 << PSEUDOVECTOR_REST_BITS) - 1)
<< PSEUDOVECTOR_SIZE_BITS),
/* Used to extract pseudovector subtype information. */
PSEUDOVECTOR_AREA_BITS = PSEUDOVECTOR_SIZE_BITS + PSEUDOVECTOR_REST_BITS,
PVEC_TYPE_MASK = 0x3f << PSEUDOVECTOR_AREA_BITS
};
/* Mask for the value (as opposed to the type bits) of a Lisp object. */
DEFINE_GDB_SYMBOL_BEGIN (EMACS_INT, VALMASK)
/* lisp.h:827 */
# define VALMASK (USE_LSB_TAG ? - (1 << GCTYPEBITS) : VAL_MAX)
DEFINE_GDB_SYMBOL_END (VALMASK)
/* lisp.h:833 */
#if USE_LSB_TAG
LISP_MACRO_DEFUN (make_number, Lisp_Object, (EMACS_INT n), (n))
LISP_MACRO_DEFUN (XINT, EMACS_INT, (Lisp_Object a), (a))
LISP_MACRO_DEFUN (XFASTINT, EMACS_INT, (Lisp_Object a), (a))
LISP_MACRO_DEFUN (XSYMBOL, struct Lisp_Symbol *, (Lisp_Object a), (a))
LISP_MACRO_DEFUN (XTYPE, enum Lisp_Type, (Lisp_Object a), (a))
LISP_MACRO_DEFUN (XUNTAG, void *, (Lisp_Object a, int type), (a, type))
#else /* ! USE_LSB_TAG */
/* Although compiled only if ! USE_LSB_TAG, the following functions
also work when USE_LSB_TAG; this is to aid future maintenance when
the lisp_h_* macros are eventually removed. */
/* Make a Lisp integer representing the value of the low order
bits of N. */
INLINE Lisp_Object
make_number (EMACS_INT n)
{
EMACS_INT int0 = Lisp_Int0;
if (USE_LSB_TAG)
{
EMACS_UINT u = n;
n = u << INTTYPEBITS;
n += int0;
}
else
{
n &= INTMASK;
n += (int0 << VALBITS);
}
return XIL (n);
}
/* Extract A's value as a signed integer. */
INLINE EMACS_INT
XINT (Lisp_Object a)
{
EMACS_INT i = XLI (a);
if (! USE_LSB_TAG)
{
EMACS_UINT u = i;
i = u << INTTYPEBITS;
}
return i >> INTTYPEBITS;
}
/* Like XINT (A), but may be faster. A must be nonnegative.
If ! USE_LSB_TAG, this takes advantage of the fact that Lisp
integers have zero-bits in their tags. */
INLINE EMACS_INT
XFASTINT (Lisp_Object a)
{
EMACS_INT int0 = Lisp_Int0;
EMACS_INT n = USE_LSB_TAG ? XINT (a) : XLI (a) - (int0 << VALBITS);
eassert (0 <= n);
return n;
}
/* Extract A's value as a symbol. */
INLINE struct Lisp_Symbol *
XSYMBOL (Lisp_Object a)
{
uintptr_t i = (uintptr_t) XUNTAG (a, Lisp_Symbol);
if (! USE_LSB_TAG)
i <<= GCTYPEBITS;
void *p = (char *) lispsym + i;
return p;
}
/* Extract A's type. */
INLINE enum Lisp_Type
XTYPE (Lisp_Object a)
{
EMACS_UINT i = XLI (a);
return USE_LSB_TAG ? i & ~VALMASK : i >> VALBITS;
}
/* Extract A's pointer value, assuming A's type is TYPE. */
INLINE void *
XUNTAG (Lisp_Object a, int type)
{
intptr_t i = USE_LSB_TAG ? XLI (a) - type : XLI (a) & VALMASK;
return (void *) i;
}
#endif /* ! USE_LSB_TAG */
/* lisp.h:920 */
/* lisp.h:975 */
INLINE struct Lisp_String *
XSTRING (Lisp_Object a)
{
eassert (STRINGP (a));
return XUNTAG (a, Lisp_String);
}
/* lisp.h:1061 */
INLINE Lisp_Object
make_lisp_symbol (struct Lisp_Symbol *sym)
{
Lisp_Object a = XIL (TAG_SYMOFFSET ((char *) sym - (char *) lispsym));
eassert (XSYMBOL (a) == sym);
return a;
}
/* lisp.h:1070 */
INLINE Lisp_Object
builtin_lisp_symbol (int index)
{
return make_lisp_symbol (lispsym + index);
}
/* See the macros in intervals.h. */
/* lisp.h:1149 */
typedef struct interval *INTERVAL;
/* In a string or vector, the sign bit of the `size' is the gc mark bit. */
/* lisp.h:1233 */
struct GCALIGNED Lisp_String
{
ptrdiff_t size;
ptrdiff_t size_byte;
INTERVAL intervals; /* Text properties in this string. */
unsigned char *data;
};
/* lisp.h:1285 */
INLINE unsigned char *
SDATA (Lisp_Object string)
{
return XSTRING (string)->data;
}
INLINE char *
SSDATA (Lisp_Object string)
{
/* Avoid "differ in sign" warnings. */
return (char *) SDATA (string);
}
/* Header of vector-like objects. This documents the layout constraints on
vectors and pseudovectors (objects of PVEC_xxx subtype). It also prevents
compilers from being fooled by Emacs's type punning: XSETPSEUDOVECTOR
and PSEUDOVECTORP cast their pointers to struct vectorlike_header *,
because when two such pointers potentially alias, a compiler won't
incorrectly reorder loads and stores to their size fields. See
Bug#8546. */
/* lisp.h:1344 */
struct vectorlike_header
{
/* The only field contains various pieces of information:
- The MSB (ARRAY_MARK_FLAG) holds the gcmarkbit.
- The next bit (PSEUDOVECTOR_FLAG) indicates whether this is a plain
vector (0) or a pseudovector (1).
- If PSEUDOVECTOR_FLAG is 0, the rest holds the size (number
of slots) of the vector.
- If PSEUDOVECTOR_FLAG is 1, the rest is subdivided into three fields:
- a) pseudovector subtype held in PVEC_TYPE_MASK field;
- b) number of Lisp_Objects slots at the beginning of the object
held in PSEUDOVECTOR_SIZE_MASK field. These objects are always
traced by the GC;
- c) size of the rest fields held in PSEUDOVECTOR_REST_MASK and
measured in word_size units. Rest fields may also include
Lisp_Objects, but these objects usually needs some special treatment
during GC.
There are some exceptions. For PVEC_FREE, b) is always zero. For
PVEC_BOOL_VECTOR and PVEC_SUBR, both b) and c) are always zero.
Current layout limits the pseudovectors to 63 PVEC_xxx subtypes,
4095 Lisp_Objects in GC-ed area and 4095 word-sized other slots. */
ptrdiff_t size;
};
/* This structure describes a built-in function.
It is generated by the DEFUN macro only.
defsubr makes it into a Lisp object. */
/* lisp.h:1670 */
struct Lisp_Subr
{
struct vectorlike_header header;
union {
Lisp_Object (*a0) (void);
Lisp_Object (*a1) (Lisp_Object);
Lisp_Object (*a2) (Lisp_Object, Lisp_Object);
Lisp_Object (*a3) (Lisp_Object, Lisp_Object, Lisp_Object);
Lisp_Object (*a4) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
Lisp_Object (*a5) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
Lisp_Object (*a6) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
Lisp_Object (*a7) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
Lisp_Object (*a8) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
Lisp_Object (*aUNEVALLED) (Lisp_Object args);
Lisp_Object (*aMANY) (ptrdiff_t, Lisp_Object *);
} function;
short min_args, max_args;
const char *symbol_name;
const char *intspec;
Lisp_Object doc;
};
INLINE struct Lisp_Save_Value *XSAVE_VALUE (Lisp_Object);
/* Types of data which may be saved in a Lisp_Save_Value. */
/* lisp.h:2045 */
enum
{
SAVE_UNUSED,
SAVE_INTEGER,
SAVE_FUNCPOINTER,
SAVE_POINTER,
SAVE_OBJECT
};
/* Number of bits needed to store one of the above values. */
enum { SAVE_SLOT_BITS = 3 };
/* Number of slots in a save value where save_type is nonzero. */
enum { SAVE_VALUE_SLOTS = 4 };
/* Bit-width and values for struct Lisp_Save_Value's save_type member. */
enum { SAVE_TYPE_BITS = SAVE_VALUE_SLOTS * SAVE_SLOT_BITS + 1 };
enum Lisp_Save_Type
{
SAVE_TYPE_INT_INT = SAVE_INTEGER + (SAVE_INTEGER << SAVE_SLOT_BITS),
SAVE_TYPE_INT_INT_INT
= (SAVE_INTEGER + (SAVE_TYPE_INT_INT << SAVE_SLOT_BITS)),
SAVE_TYPE_OBJ_OBJ = SAVE_OBJECT + (SAVE_OBJECT << SAVE_SLOT_BITS),
SAVE_TYPE_OBJ_OBJ_OBJ = SAVE_OBJECT + (SAVE_TYPE_OBJ_OBJ << SAVE_SLOT_BITS),
SAVE_TYPE_OBJ_OBJ_OBJ_OBJ
= SAVE_OBJECT + (SAVE_TYPE_OBJ_OBJ_OBJ << SAVE_SLOT_BITS),
SAVE_TYPE_PTR_INT = SAVE_POINTER + (SAVE_INTEGER << SAVE_SLOT_BITS),
SAVE_TYPE_PTR_OBJ = SAVE_POINTER + (SAVE_OBJECT << SAVE_SLOT_BITS),
SAVE_TYPE_PTR_PTR = SAVE_POINTER + (SAVE_POINTER << SAVE_SLOT_BITS),
SAVE_TYPE_FUNCPTR_PTR_OBJ
= SAVE_FUNCPOINTER + (SAVE_TYPE_PTR_OBJ << SAVE_SLOT_BITS),
/* This has an extra bit indicating it's raw memory. */
SAVE_TYPE_MEMORY = SAVE_TYPE_PTR_INT + (1 << (SAVE_TYPE_BITS - 1))
};
/* Special object used to hold a different values for later use.
This is mostly used to package C integers and pointers to call
record_unwind_protect when two or more values need to be saved.
For example:
...
struct my_data *md = get_my_data ();
ptrdiff_t mi = get_my_integer ();
record_unwind_protect (my_unwind, make_save_ptr_int (md, mi));
...
Lisp_Object my_unwind (Lisp_Object arg)
{
struct my_data *md = XSAVE_POINTER (arg, 0);
ptrdiff_t mi = XSAVE_INTEGER (arg, 1);
...
}
If ENABLE_CHECKING is in effect, XSAVE_xxx macros do type checking of the
saved objects and raise eassert if type of the saved object doesn't match
the type which is extracted. In the example above, XSAVE_INTEGER (arg, 2)
and XSAVE_OBJECT (arg, 0) are wrong because nothing was saved in slot 2 and
slot 0 is a pointer. */
typedef void (*voidfuncptr) (void);
/* lisp.h:2110 */
struct Lisp_Save_Value
{
ENUM_BF (Lisp_Misc_Type) type : 16; /* = Lisp_Misc_Save_Value */
bool_bf gcmarkbit : 1;
unsigned spacer : 32 - (16 + 1 + SAVE_TYPE_BITS);
/* V->data may hold up to SAVE_VALUE_SLOTS entries. The type of
V's data entries are determined by V->save_type. E.g., if
V->save_type == SAVE_TYPE_PTR_OBJ, V->data[0] is a pointer,
V->data[1] is an integer, and V's other data entries are unused.
If V->save_type == SAVE_TYPE_MEMORY, V->data[0].pointer is the address of
a memory area containing V->data[1].integer potential Lisp_Objects. */
ENUM_BF (Lisp_Save_Type) save_type : SAVE_TYPE_BITS;
union {
void *pointer;
voidfuncptr funcpointer;
ptrdiff_t integer;
Lisp_Object object;
} data[SAVE_VALUE_SLOTS];
};
/* Return the type of V's Nth saved value. */
INLINE int
save_type (struct Lisp_Save_Value *v, int n)
{
eassert (0 <= n && n < SAVE_VALUE_SLOTS);
return (v->save_type >> (SAVE_SLOT_BITS * n) & ((1 << SAVE_SLOT_BITS) - 1));
}
/* Get and set the Nth saved pointer. */
/* lisp.h:2143 */
INLINE void *
XSAVE_POINTER (Lisp_Object obj, int n)
{
eassert (save_type (XSAVE_VALUE (obj), n) == SAVE_POINTER);
return XSAVE_VALUE (obj)->data[n].pointer;
}
/* Define a built-in function for calling from Lisp.
`lname' should be the name to give the function in Lisp,
as a null-terminated C string.
`fnname' should be the name of the function in C.
By convention, it starts with F.
`sname' should be the name for the C constant structure
that records information on this function for internal use.
By convention, it should be the same as `fnname' but with S instead of F.
It's too bad that C macros can't compute this from `fnname'.
`minargs' should be a number, the minimum number of arguments allowed.
`maxargs' should be a number, the maximum number of arguments allowed,
or else MANY or UNEVALLED.
MANY means pass a vector of evaluated arguments,
in the form of an integer number-of-arguments
followed by the address of a vector of Lisp_Objects
which contains the argument values.
UNEVALLED means pass the list of unevaluated arguments
`intspec' says how interactive arguments are to be fetched.
If the string starts with a `(', `intspec' is evaluated and the resulting
list is the list of arguments.
If it's a string that doesn't start with `(', the value should follow
the one of the doc string for `interactive'.
A null string means call interactively with no arguments.
`doc' is documentation for the user. */
/* This version of DEFUN declares a function prototype with the right
arguments, so we can catch errors with maxargs at compile-time. */
/* lisp.h:2812 */
#ifdef _MSC_VER
#define DEFUN(lname, fnname, sname, minargs, maxargs, intspec, doc) \
Lisp_Object fnname DEFUN_ARGS_ ## maxargs ; \
static struct Lisp_Subr alignas (GCALIGNMENT) sname = \
{ { (PVEC_SUBR << PSEUDOVECTOR_AREA_BITS) \
| (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)) }, \
{ (Lisp_Object (__cdecl *)(void))fnname }, \
minargs, maxargs, lname, intspec, 0}; \
Lisp_Object fnname
#else /* not _MSC_VER */
#define DEFUN(lname, fnname, sname, minargs, maxargs, intspec, doc) \
static struct Lisp_Subr alignas (GCALIGNMENT) sname = \
{ { PVEC_SUBR << PSEUDOVECTOR_AREA_BITS }, \
{ .a ## maxargs = fnname }, \
minargs, maxargs, lname, intspec, 0}; \
Lisp_Object fnname
#endif
/* defsubr (Sname);
is how we define the symbol for function `name' at start-up time. */
/* lisp.h:2839 */
extern void defsubr (struct Lisp_Subr *);
/* lisp.h:3777 */
extern Lisp_Object make_string (const char *, ptrdiff_t);
/* lisp.h:3881 */
extern Lisp_Object make_save_ptr (void *);
/* Defined in lread.c. */
/* lisp.h:3960 */
extern Lisp_Object intern_1 (const char *, ptrdiff_t);
/* lisp.h:3987 */
INLINE Lisp_Object
intern (const char *str)
{
return intern_1 (str, strlen (str));
}
/* end of file */
next prev parent reply other threads:[~2015-02-15 1:02 UTC|newest]
Thread overview: 765+ messages / expand[flat|nested] mbox.gz Atom feed top
2014-07-02 20:54 Dynamic loading progress Aurélien Aptel
2014-07-02 21:33 ` Andreas Schwab
2014-07-03 17:09 ` Aurélien Aptel
2014-07-03 17:43 ` Dmitry Antipov
2014-07-03 19:44 ` Stefan Monnier
2014-07-04 1:26 ` Stefan Monnier
2014-07-06 15:14 ` Aurélien Aptel
2014-07-07 1:19 ` Stefan Monnier
2014-07-09 21:02 ` Aurélien Aptel
2014-07-09 22:18 ` Stefan Monnier
2014-07-10 17:21 ` Aurélien Aptel
2014-07-10 18:04 ` Stefan Monnier
2014-07-11 9:01 ` Aurélien Aptel
2014-07-11 13:27 ` Stefan Monnier
2014-09-24 14:20 ` Ted Zlatanov
2014-09-24 17:27 ` Stefan Monnier
2014-09-25 12:41 ` Ted Zlatanov
2014-10-09 17:08 ` Aurélien Aptel
2014-10-09 17:11 ` Aurélien Aptel
2014-10-09 17:27 ` Eli Zaretskii
2014-10-09 19:42 ` Stefan Monnier
2014-10-09 21:17 ` Eli Zaretskii
2014-10-10 0:53 ` Stefan Monnier
2014-10-10 6:32 ` Eli Zaretskii
2014-10-10 12:54 ` Stefan Monnier
2014-10-10 15:05 ` Aurélien Aptel
2014-10-10 15:50 ` Eli Zaretskii
2014-10-10 18:42 ` Stefan Monnier
2014-10-10 19:58 ` Eli Zaretskii
2014-10-11 5:14 ` Stefan Monnier
2014-10-13 17:46 ` Aurélien Aptel
2014-10-14 18:11 ` Stefan Monnier
2014-10-16 23:09 ` Aurélien Aptel
2014-10-17 0:32 ` Stefan Monnier
2014-10-18 21:06 ` Stephen Leake
2014-12-27 21:57 ` Stephen Leake
2015-01-13 14:28 ` Ted Zlatanov
2015-01-13 15:39 ` Stephen Leake
2015-01-17 0:10 ` Stephen Leake
2015-01-31 18:57 ` Aurélien Aptel
2015-01-31 19:30 ` Eli Zaretskii
2015-02-04 21:58 ` Aurélien Aptel
2015-02-04 22:03 ` Aurélien Aptel
2015-02-05 0:24 ` Stephen J. Turnbull
2015-02-05 3:50 ` Eli Zaretskii
2015-02-09 0:04 ` Aurélien Aptel
2015-02-09 0:34 ` Paul Eggert
2015-02-09 4:17 ` Stefan Monnier
2015-02-09 6:26 ` Paul Eggert
2015-02-09 9:58 ` Aurélien Aptel
2015-02-09 15:45 ` Eli Zaretskii
2015-02-09 16:01 ` Aurélien Aptel
2015-02-10 6:58 ` Paul Eggert
2015-02-10 20:40 ` Stefan Monnier
2015-02-10 22:24 ` Paul Eggert
2015-02-11 1:45 ` Stefan Monnier
2015-02-11 15:36 ` Ted Zlatanov
2015-02-13 2:40 ` Paul Eggert
2015-02-13 8:37 ` Eli Zaretskii
2015-02-13 12:17 ` Daniel Colascione
2015-02-13 15:01 ` Eli Zaretskii
2015-02-13 15:06 ` Daniel Colascione
2015-02-13 15:49 ` Eli Zaretskii
2015-02-13 15:58 ` Daniel Colascione
2015-02-13 16:10 ` Eli Zaretskii
2015-02-13 16:20 ` Daniel Colascione
2015-02-13 16:55 ` Eli Zaretskii
2015-02-13 17:08 ` Paul Eggert
2015-02-13 17:44 ` Daniel Colascione
2015-02-13 19:11 ` Eli Zaretskii
2015-02-13 17:38 ` Daniel Colascione
2015-02-13 21:48 ` Stephen Leake
2015-02-14 8:39 ` Eli Zaretskii
2015-02-14 12:18 ` Stephen J. Turnbull
2015-02-14 12:37 ` Eli Zaretskii
2015-02-14 14:38 ` Stefan Monnier
2015-02-14 14:58 ` Eli Zaretskii
2015-02-15 18:36 ` Stefan Monnier
2015-02-15 18:55 ` Eli Zaretskii
2015-02-15 22:36 ` Stefan Monnier
2015-02-14 16:48 ` Stephen J. Turnbull
2015-02-14 17:22 ` Eli Zaretskii
2015-02-15 8:03 ` Stephen J. Turnbull
2015-02-15 12:46 ` Steinar Bang
2015-02-15 17:33 ` Eli Zaretskii
2015-02-15 18:47 ` Stefan Monnier
2015-02-15 19:00 ` Eli Zaretskii
2015-02-15 22:40 ` Stefan Monnier
2015-02-14 15:32 ` Stephen Leake
2015-02-14 16:02 ` Eli Zaretskii
2015-02-14 16:45 ` Eli Zaretskii
2015-02-15 0:39 ` Stephen Leake
2015-02-15 13:54 ` Daniel Colascione
2015-02-15 18:08 ` Stephen Leake
2015-02-15 18:43 ` Stefan Monnier
2015-02-15 18:56 ` Eli Zaretskii
2015-02-16 4:52 ` Stephen J. Turnbull
2015-02-16 13:44 ` Aurélien Aptel
2015-02-15 19:27 ` joakim
2015-02-15 22:39 ` Stefan Monnier
2015-02-16 13:53 ` joakim
2015-02-15 0:35 ` Stephen Leake
2015-02-13 19:11 ` Stefan Monnier
2015-02-14 19:12 ` Eli Zaretskii
2015-02-14 19:25 ` Eli Zaretskii
2015-02-15 1:02 ` Stephen Leake [this message]
2015-02-15 17:32 ` Eli Zaretskii
2015-02-15 19:09 ` Stephen Leake
2015-02-15 19:27 ` implementing curl module with opaque emacs types Stephen Leake
2015-02-15 19:47 ` Eli Zaretskii
2015-02-17 19:33 ` Stephen Leake
2015-02-15 19:28 ` Dynamic loading progress Eli Zaretskii
2015-02-15 19:30 ` Stefan Monnier
2015-02-16 15:25 ` Stephen Leake
2015-02-16 19:02 ` Stefan Monnier
2015-04-20 23:21 ` Ted Zlatanov
2015-04-21 14:06 ` Stefan Monnier
2015-04-21 14:19 ` Ted Zlatanov
2015-02-15 9:21 ` Stephen J. Turnbull
2015-02-15 17:34 ` Eli Zaretskii
2015-02-11 9:19 ` Aurélien Aptel
2015-02-11 9:43 ` Aurélien Aptel
2015-02-11 10:01 ` Aurélien Aptel
2015-02-11 15:35 ` Stefan Monnier
2015-02-11 16:08 ` Aurélien Aptel
2015-02-11 19:17 ` Stefan Monnier
2015-02-11 13:26 ` Paul Eggert
2015-02-10 14:56 ` Ted Zlatanov
2015-02-11 9:55 ` Aurélien Aptel
2015-02-11 16:05 ` Ted Zlatanov
2015-02-11 16:24 ` Aurélien Aptel
2015-02-11 21:17 ` Ted Zlatanov
2015-02-12 0:22 ` Aurélien Aptel
2015-02-12 10:07 ` Stephen Leake
2015-02-12 10:51 ` Stephen Leake
2015-02-12 18:02 ` Stephen Leake
2015-02-14 0:49 ` Davis Herring
2015-02-12 20:09 ` Stephen Leake
2015-02-12 20:34 ` Eli Zaretskii
2015-02-12 21:51 ` Aurélien Aptel
2015-02-12 21:55 ` Aurélien Aptel
2015-02-13 8:29 ` Eli Zaretskii
2015-02-13 19:09 ` Stefan Monnier
2015-02-13 8:27 ` Eli Zaretskii
2015-02-13 21:11 ` Stephen Leake
2015-02-13 21:09 ` Stephen Leake
2015-02-14 9:31 ` Eli Zaretskii
2015-02-14 15:13 ` Stephen Leake
2015-02-14 15:51 ` Eli Zaretskii
2015-02-15 1:04 ` Stephen Leake
2015-02-15 13:50 ` Daniel Colascione
2015-02-15 17:00 ` Eli Zaretskii
2015-02-15 17:04 ` Daniel Colascione
2015-02-15 17:28 ` Eli Zaretskii
2015-02-15 17:31 ` Daniel Colascione
2015-02-15 18:00 ` Eli Zaretskii
2015-02-15 18:01 ` Daniel Colascione
2015-02-15 18:29 ` Eli Zaretskii
2015-02-15 20:20 ` Daniel Colascione
2015-02-16 14:05 ` Aurélien Aptel
2015-02-16 16:15 ` Eli Zaretskii
2015-02-16 15:43 ` Eli Zaretskii
2015-02-16 18:22 ` Daniel Colascione
2015-02-16 19:09 ` Stefan Monnier
2015-02-16 19:29 ` Eli Zaretskii
2015-02-16 20:01 ` Daniel Colascione
2015-02-17 15:43 ` Eli Zaretskii
2015-02-17 17:46 ` Aurélien Aptel
2015-02-17 17:50 ` Aurélien Aptel
2015-02-17 18:04 ` Daniel Colascione
2015-02-18 3:29 ` Stefan Monnier
2015-02-28 18:20 ` Aurélien Aptel
2015-03-04 13:48 ` Stephen Leake
2015-03-04 22:34 ` Stefan Monnier
2015-03-04 22:39 ` Daniel Colascione
2015-03-05 13:12 ` Aurélien Aptel
2015-03-05 17:37 ` Paul Eggert
2015-03-05 18:19 ` Aurélien Aptel
2015-04-20 23:38 ` Ted Zlatanov
2015-04-21 8:58 ` Aurélien Aptel
2015-04-21 14:14 ` Ted Zlatanov
2015-04-22 16:25 ` Stephen Leake
2015-04-22 17:15 ` Stefan Monnier
2015-05-03 10:43 ` Ted Zlatanov
2015-05-03 10:55 ` Ted Zlatanov
2015-05-03 23:44 ` Stephen Leake
2015-05-04 10:09 ` Ted Zlatanov
2015-05-04 0:16 ` Stefan Monnier
2015-05-04 10:03 ` Ted Zlatanov
2015-08-19 14:27 ` Ted Zlatanov
2015-08-20 15:19 ` Stephen Leake
2015-08-23 19:12 ` Aurélien Aptel
2015-08-23 22:26 ` Stefan Monnier
2015-08-23 22:45 ` Aurélien Aptel
2015-08-23 23:37 ` Paul Eggert
2015-08-24 19:11 ` Stefan Monnier
2015-08-24 2:13 ` Tom Tromey
2015-08-24 19:13 ` Stefan Monnier
2015-08-24 20:19 ` Paul Eggert
2015-08-25 4:35 ` David Kastrup
2015-08-25 22:03 ` Stefan Monnier
2015-08-27 2:29 ` Paul Eggert
2015-08-27 10:17 ` Aurélien Aptel
2015-09-12 19:38 ` Aurélien Aptel
2015-09-12 20:42 ` Stefan Monnier
2015-09-12 23:11 ` Aurélien Aptel
2015-09-13 12:54 ` Philipp Stephani
2015-09-13 13:14 ` Stefan Monnier
2015-09-13 13:19 ` Philipp Stephani
2015-09-13 20:31 ` Stefan Monnier
2015-09-13 20:33 ` Daniel Colascione
2015-09-14 1:58 ` Stefan Monnier
2015-09-14 2:08 ` Daniel Colascione
2015-09-14 4:18 ` Stefan Monnier
2015-09-14 4:37 ` Daniel Colascione
2015-09-14 12:14 ` Stefan Monnier
2015-09-14 14:36 ` Stephen Leake
2015-09-14 15:17 ` Eli Zaretskii
2015-09-14 15:14 ` Daniel Colascione
2015-09-14 17:48 ` Stefan Monnier
2015-09-14 18:05 ` Daniel Colascione
2015-09-15 0:55 ` Stefan Monnier
2015-09-15 1:06 ` Daniel Colascione
2015-09-24 12:45 ` Aurélien Aptel
2015-09-24 13:58 ` Stefan Monnier
2015-09-26 14:56 ` Aurélien Aptel
2015-09-28 3:01 ` Stefan Monnier
2015-09-28 10:13 ` Aurélien Aptel
2015-09-28 21:59 ` Davis Herring
2015-09-28 15:57 ` Stephen Leake
2015-09-28 15:42 ` Philipp Stephani
2015-09-28 16:12 ` Aurélien Aptel
2015-09-28 19:39 ` Stefan Monnier
2015-09-28 19:41 ` Daniel Colascione
2015-09-29 5:04 ` Stefan Monnier
2015-10-04 4:30 ` Tom Tromey
2015-10-04 14:11 ` Aurélien Aptel
2015-10-04 14:22 ` Aurélien Aptel
2015-09-28 15:35 ` Philipp Stephani
2015-09-28 17:04 ` Philipp Stephani
2015-09-28 19:30 ` Stefan Monnier
2015-10-04 13:25 ` Aurélien Aptel
2015-10-04 14:38 ` Philipp Stephani
2015-09-28 15:25 ` Philipp Stephani
2015-09-28 19:26 ` Stefan Monnier
2015-09-28 19:31 ` Daniel Colascione
2015-09-28 19:28 ` Daniel Colascione
2015-09-28 20:09 ` Philipp Stephani
2015-09-28 20:10 ` Daniel Colascione
2015-09-29 5:00 ` Stefan Monnier
2015-09-15 2:56 ` Stephen J. Turnbull
2015-09-15 3:00 ` Daniel Colascione
2015-09-15 8:16 ` Stephen J. Turnbull
2015-09-15 8:45 ` David Kastrup
2015-09-15 13:18 ` Daniel Colascione
2015-09-15 13:33 ` David Kastrup
2015-09-15 13:39 ` Daniel Colascione
2015-09-15 13:43 ` David Kastrup
2015-09-15 16:11 ` Stephen J. Turnbull
2015-09-15 7:45 ` Michael Albinus
2015-09-28 15:12 ` Philipp Stephani
2015-09-28 19:20 ` Stefan Monnier
2015-09-14 3:43 ` Stephen J. Turnbull
2015-09-14 3:54 ` Daniel Colascione
2015-09-14 4:24 ` Stefan Monnier
2015-09-28 15:21 ` Philipp Stephani
2015-09-28 19:23 ` Stefan Monnier
2015-09-14 7:27 ` Stephen J. Turnbull
2015-09-14 14:45 ` Stephen Leake
2015-09-15 1:46 ` Stephen J. Turnbull
2015-09-28 15:19 ` Philipp Stephani
2015-09-29 1:55 ` Stephen J. Turnbull
2015-09-29 9:11 ` David Kastrup
2015-09-30 6:06 ` Stephen J. Turnbull
2015-09-30 6:24 ` David Kastrup
2015-09-29 21:04 ` Davis Herring
2015-09-30 6:07 ` Stephen J. Turnbull
2015-09-30 6:56 ` Herring, Davis
2015-09-30 7:26 ` Daniel Colascione
2015-09-30 8:52 ` Stefan Monnier
2015-10-04 8:34 ` Philipp Stephani
2015-10-04 17:24 ` Stefan Monnier
2015-09-30 17:16 ` Stephen J. Turnbull
2015-09-30 17:32 ` Davis Herring
2015-03-05 13:17 ` Aurélien Aptel
2015-03-06 5:14 ` Stefan Monnier
2015-03-06 18:22 ` Daniel Colascione
2015-03-10 1:26 ` Stefan Monnier
2015-03-05 17:19 ` Stephen Leake
2015-03-05 22:32 ` Stephen Leake
2015-03-13 16:47 ` Stephen Leake
2015-03-13 18:37 ` Ivan Shmakov
2015-03-15 10:46 ` Stephen Leake
2015-03-16 18:02 ` Stephen Leake
2015-03-17 9:28 ` Aurélien Aptel
2015-03-17 9:52 ` Eli Zaretskii
2015-03-17 10:51 ` Aurélien Aptel
2015-03-17 11:08 ` Eli Zaretskii
2015-03-17 16:37 ` Stefan Monnier
2015-03-17 17:08 ` Eli Zaretskii
2015-03-17 14:50 ` Stephen Leake
2015-03-24 21:08 ` Stephen Leake
2015-05-06 4:11 ` Dynamic loading progress; funcall of goto-char fails Stephen Leake
2015-05-06 4:21 ` Daniel Colascione
2015-05-06 8:15 ` Stephen Leake
2015-02-17 18:06 ` Dynamic loading progress Eli Zaretskii
2015-02-17 18:20 ` Steinar Bang
2015-02-18 0:55 ` Stephen J. Turnbull
2015-09-13 13:04 ` Philipp Stephani
2015-09-13 14:15 ` Daniel Colascione
2015-09-13 14:27 ` Philipp Stephani
2015-09-13 14:31 ` Daniel Colascione
2015-09-28 15:05 ` Philipp Stephani
2015-10-04 8:57 ` Philipp Stephani
2015-10-04 9:00 ` Eli Zaretskii
2015-10-04 9:10 ` Daniel Colascione
2015-10-04 9:41 ` Philipp Stephani
2015-10-04 17:48 ` Philipp Stephani
2015-10-04 19:20 ` Paul Eggert
2015-10-04 19:25 ` Daniel Colascione
2015-10-04 19:55 ` Paul Eggert
2015-10-04 19:57 ` Daniel Colascione
2015-10-04 20:19 ` Paul Eggert
2015-10-04 19:34 ` Daniel Colascione
2015-10-04 19:47 ` Philipp Stephani
2015-10-04 21:12 ` Aurélien Aptel
2015-10-05 5:50 ` Eli Zaretskii
2015-10-14 22:28 ` Philipp Stephani
2015-10-15 2:43 ` Eli Zaretskii
2015-10-15 7:00 ` Andreas Schwab
2015-10-15 10:13 ` Aurélien Aptel
2015-10-15 15:38 ` Eli Zaretskii
2015-10-15 15:56 ` Andreas Schwab
2015-10-15 16:01 ` Eli Zaretskii
2015-10-15 16:07 ` Andreas Schwab
2015-10-15 16:31 ` Eli Zaretskii
2015-10-15 17:03 ` Andreas Schwab
2015-10-15 17:07 ` Eli Zaretskii
2015-10-15 23:07 ` Philipp Stephani
2015-10-16 6:49 ` Eli Zaretskii
2015-10-14 22:25 ` Philipp Stephani
2015-10-14 23:48 ` Aurélien Aptel
2015-10-15 0:25 ` Philipp Stephani
2015-10-15 10:44 ` Aurélien Aptel
2015-10-15 15:41 ` Eli Zaretskii
2015-10-16 0:55 ` Juanma Barranquero
2015-10-16 5:42 ` martin rudalics
2015-10-16 7:10 ` Making --with-wide-int the default (was: Dynamic loading progress) Eli Zaretskii
2015-10-16 7:34 ` Making --with-wide-int the default martin rudalics
2015-10-16 8:10 ` Eli Zaretskii
2015-10-16 7:09 ` Making --with-wide-int the default (was: Dynamic loading progress) Eli Zaretskii
2015-10-16 7:26 ` Juanma Barranquero
2015-10-16 8:17 ` Eli Zaretskii
2015-10-16 8:03 ` Making --with-wide-int the default Paul Eggert
2015-10-16 8:15 ` Eli Zaretskii
2015-10-16 8:27 ` Paul Eggert
2015-10-16 8:31 ` David Kastrup
2015-10-16 9:12 ` Eli Zaretskii
2015-10-16 9:24 ` David Kastrup
2015-10-16 9:26 ` David Kastrup
2015-10-16 10:12 ` Eli Zaretskii
2015-10-16 10:28 ` David Kastrup
2015-10-16 13:22 ` Eli Zaretskii
2015-10-16 15:29 ` Paul Eggert
2015-11-11 18:43 ` Eli Zaretskii
2015-11-12 8:23 ` martin rudalics
2015-11-12 16:19 ` Eli Zaretskii
2015-11-12 18:00 ` martin rudalics
2015-11-12 22:31 ` Richard Stallman
2015-11-13 7:43 ` Eli Zaretskii
2015-11-13 7:52 ` Paul Eggert
2015-11-13 8:05 ` martin rudalics
2015-11-13 8:24 ` Eli Zaretskii
2015-11-13 9:11 ` David Kastrup
2015-11-13 9:30 ` Eli Zaretskii
2015-11-13 11:52 ` David Kastrup
2015-11-13 18:56 ` Eli Zaretskii
2015-11-13 22:03 ` Richard Stallman
2015-11-14 8:43 ` Eli Zaretskii
2015-11-14 8:54 ` martin rudalics
2015-11-14 17:38 ` Ulrich Mueller
2015-11-15 20:14 ` Eli Zaretskii
2015-11-15 20:50 ` David Kastrup
2015-11-15 21:06 ` Eli Zaretskii
2015-11-15 22:19 ` David Kastrup
2015-11-16 16:38 ` Eli Zaretskii
2015-11-15 21:04 ` Ulrich Mueller
2015-11-15 21:13 ` Eli Zaretskii
2015-11-15 21:36 ` David Kastrup
2015-11-15 7:05 ` Paul Eggert
2015-11-16 9:00 ` David Kastrup
2015-11-16 16:19 ` Eli Zaretskii
2015-11-15 16:01 ` David Kastrup
2015-11-15 19:36 ` Eli Zaretskii
2015-11-15 20:42 ` David Kastrup
2015-11-15 21:02 ` Eli Zaretskii
2015-11-16 23:17 ` Paul Eggert
2015-11-17 1:34 ` Random832
2015-11-17 3:42 ` Eli Zaretskii
2015-11-17 6:32 ` Paul Eggert
2015-11-17 9:08 ` Ulrich Mueller
2015-11-17 18:42 ` Paul Eggert
2015-11-17 20:32 ` Ulrich Mueller
2015-11-18 16:32 ` Achim Gratz
2015-11-18 17:10 ` David Kastrup
2015-11-18 17:38 ` Eli Zaretskii
2015-11-17 22:58 ` Richard Stallman
2015-11-17 12:13 ` David Kastrup
2015-11-17 18:32 ` Paul Eggert
2015-11-17 2:47 ` Tom Tromey
2015-11-20 2:20 ` Stefan Monnier
2015-11-20 8:44 ` Eli Zaretskii
2015-11-20 16:27 ` John Wiegley
2015-11-12 16:29 ` Juanma Barranquero
2015-10-16 8:28 ` Juanma Barranquero
2015-10-16 8:40 ` Paul Eggert
2015-10-16 8:18 ` David Kastrup
2015-10-16 8:49 ` Paul Eggert
2015-10-16 9:00 ` David Kastrup
2015-10-16 9:06 ` Eli Zaretskii
2015-10-16 9:18 ` David Kastrup
2015-10-16 10:09 ` Eli Zaretskii
2015-10-16 10:27 ` David Kastrup
2015-10-16 13:20 ` Eli Zaretskii
2015-10-16 14:03 ` David Kastrup
2015-10-16 16:01 ` Eli Zaretskii
2015-10-16 16:28 ` David Kastrup
2015-10-16 15:53 ` Stephen J. Turnbull
2015-10-16 16:01 ` David Kastrup
2015-10-15 23:11 ` Dynamic loading progress Philipp Stephani
2015-10-15 23:15 ` Philipp Stephani
2015-10-19 22:38 ` Philipp Stephani
2015-10-20 1:58 ` Daniel Colascione
2015-10-20 3:05 ` Tom Tromey
2015-10-20 3:13 ` Daniel Colascione
2015-10-20 3:32 ` Tom Tromey
2015-10-20 3:38 ` Daniel Colascione
2015-10-20 15:48 ` Stephen Leake
2015-10-20 18:52 ` Philipp Stephani
2015-10-22 12:57 ` Aurélien Aptel
2015-10-22 17:56 ` Aurélien Aptel
2015-10-22 18:03 ` Eli Zaretskii
2015-10-22 22:49 ` Philipp Stephani
2015-10-22 22:52 ` Daniel Colascione
2015-10-23 7:05 ` Eli Zaretskii
2015-10-23 7:17 ` Daniel Colascione
2015-10-23 7:00 ` Eli Zaretskii
2015-10-25 16:26 ` Aurélien Aptel
2015-10-25 16:31 ` Philipp Stephani
2015-10-25 18:45 ` Aurélien Aptel
2015-10-25 20:13 ` Philipp Stephani
2015-10-25 20:40 ` Philipp Stephani
2015-10-25 20:55 ` Aurélien Aptel
2015-10-28 13:47 ` Aurélien Aptel
2015-11-06 15:52 ` Ted Zlatanov
2015-11-06 15:55 ` Eli Zaretskii
2015-11-06 16:22 ` Ted Zlatanov
2015-11-07 1:53 ` Feature freezes and Emacs 25 (was: Dynamic loading progress) John Wiegley
2015-11-07 8:32 ` Feature freezes and Emacs 25 David Kastrup
2015-11-07 8:46 ` Eli Zaretskii
2015-11-07 8:33 ` Feature freezes and Emacs 25 (was: Dynamic loading progress) Eli Zaretskii
2015-11-09 21:55 ` Feature freezes and Emacs 25 John Wiegley
2015-11-09 22:08 ` Dmitry Gutov
2015-11-10 18:17 ` Richard Stallman
2015-11-10 18:23 ` Dmitry Gutov
2015-11-11 16:58 ` Richard Stallman
2015-11-09 23:59 ` Xue Fuqiao
2015-11-10 0:07 ` John Wiegley
2015-11-10 8:41 ` Xue Fuqiao
2015-11-10 13:25 ` Xue Fuqiao
2015-11-10 17:42 ` Nicolas Petton
2015-11-10 17:50 ` Eli Zaretskii
2015-11-10 18:13 ` Drew Adams
2015-11-11 16:57 ` Richard Stallman
2015-11-11 1:53 ` Xue Fuqiao
2015-11-11 19:59 ` Glenn Morris
2015-11-12 8:53 ` Xue Fuqiao
2015-11-15 2:42 ` Glenn Morris
2015-11-16 10:38 ` Juanma Barranquero
2015-11-16 16:54 ` John Wiegley
2015-11-18 18:12 ` Glenn Morris
2015-11-18 18:36 ` Glenn Morris
2015-11-18 22:06 ` John Wiegley
2015-11-10 9:41 ` Nicolas Petton
2015-11-10 14:22 ` John Wiegley
2015-11-10 16:38 ` Eli Zaretskii
2015-11-10 17:34 ` Nicolas Petton
2015-11-10 17:39 ` Nicolas Petton
2015-11-10 18:01 ` Eli Zaretskii
2015-11-11 16:47 ` Nicolas Petton
2015-11-10 16:24 ` Eli Zaretskii
2015-11-11 0:17 ` Juri Linkov
2015-11-11 1:16 ` John Wiegley
2015-11-12 0:43 ` Juri Linkov
2015-11-12 1:05 ` John Wiegley
2015-11-12 4:01 ` Artur Malabarba
2015-11-12 16:48 ` John Wiegley
2015-11-12 17:33 ` Eli Zaretskii
2015-11-12 19:01 ` Artur Malabarba
2015-11-15 1:51 ` Xue Fuqiao
2015-11-16 16:12 ` Eli Zaretskii
2015-11-16 23:59 ` Xue Fuqiao
2015-11-17 3:43 ` Eli Zaretskii
2015-11-18 0:47 ` Xue Fuqiao
2015-11-12 21:38 ` Design of commands operating on rectangular regions (was: Feature freezes and Emacs 25) Juri Linkov
2015-11-20 19:10 ` Design of commands operating on rectangular regions John Wiegley
2015-11-20 19:19 ` Drew Adams
2015-11-23 0:07 ` Juri Linkov
2015-11-23 1:53 ` Drew Adams
2015-11-22 23:57 ` Juri Linkov
2015-11-11 1:21 ` Feature freezes and Emacs 25 Drew Adams
2015-11-07 10:59 ` Phillip Lord
2015-11-07 14:20 ` kqueue in Emacs 25.1? (was: Feature freezes and Emacs 25) Michael Albinus
2015-11-07 14:39 ` Eli Zaretskii
2015-11-07 14:53 ` kqueue in Emacs 25.1? Michael Albinus
2015-11-07 15:26 ` Eli Zaretskii
2015-11-09 22:31 ` John Wiegley
2015-11-10 13:56 ` Michael Albinus
2015-11-10 14:32 ` Wolfgang Jenkner
2015-11-10 14:52 ` Michael Albinus
2015-11-11 11:41 ` Michael Albinus
2015-11-11 15:11 ` Wolfgang Jenkner
2015-11-11 15:44 ` Michael Albinus
2015-11-11 16:02 ` Wolfgang Jenkner
2015-11-11 16:48 ` Michael Albinus
2015-11-11 15:37 ` Wolfgang Jenkner
2015-11-11 15:52 ` Michael Albinus
2015-11-12 17:59 ` Michael Albinus
2015-11-12 18:34 ` Wolfgang Jenkner
2015-11-13 10:09 ` Michael Albinus
2015-11-13 13:00 ` Wolfgang Jenkner
2015-11-13 14:57 ` Wolfgang Jenkner
2015-11-13 16:23 ` Michael Albinus
2015-11-16 11:58 ` Michael Albinus
2015-11-17 3:50 ` John Wiegley
2015-11-17 9:37 ` Michael Albinus
2015-11-25 14:35 ` kqueue in Emacs 25? Michael Albinus
2015-11-25 18:53 ` John Wiegley
2015-11-07 14:52 ` kqueue in Emacs 25.1? Wolfgang Jenkner
2015-11-07 15:02 ` Wolfgang Jenkner
2015-11-08 6:33 ` Paul Eggert
2015-11-08 12:38 ` Wolfgang Jenkner
2015-11-07 18:57 ` Michael Albinus
2015-11-07 22:22 ` Wolfgang Jenkner
2015-11-06 21:52 ` Dynamic loading progress John Wiegley
2015-11-07 8:35 ` Eli Zaretskii
2015-11-07 13:33 ` Ted Zlatanov
2015-11-07 13:48 ` Eli Zaretskii
2015-11-07 14:01 ` Ted Zlatanov
2015-11-07 17:47 ` Aurélien Aptel
2015-11-08 11:16 ` Philipp Stephani
2015-11-08 12:54 ` Steinar Bang
2015-11-08 13:39 ` Philipp Stephani
2015-11-08 13:08 ` Ted Zlatanov
2015-11-08 13:42 ` Philipp Stephani
2015-11-08 20:38 ` Ted Zlatanov
2015-11-09 10:40 ` Aurélien Aptel
2015-11-09 10:48 ` Aurélien Aptel
2015-11-09 10:57 ` Yuri Khan
2015-11-09 11:46 ` Ted Zlatanov
2015-11-09 12:27 ` Aurélien Aptel
2015-11-09 13:18 ` Steinar Bang
2015-11-09 13:47 ` Steinar Bang
2015-11-09 14:26 ` Aurélien Aptel
2015-11-09 14:52 ` Aurélien Aptel
2015-11-09 19:58 ` Aurélien Aptel
2015-11-10 20:07 ` Philipp Stephani
2015-11-09 13:38 ` Ted Zlatanov
2015-11-09 16:16 ` Philipp Stephani
2015-11-11 11:22 ` Ted Zlatanov
2015-11-11 13:57 ` Philipp Stephani
2015-11-13 1:29 ` Aurélien Aptel
2015-11-13 11:35 ` Ted Zlatanov
2015-11-13 15:39 ` Freeze is almost here (was: Dynamic loading progress) John Wiegley
2015-11-13 16:43 ` Juanma Barranquero
2015-11-13 19:24 ` Eli Zaretskii
2015-11-13 19:37 ` Eli Zaretskii
2015-11-13 20:05 ` Freeze is almost here Achim Gratz
2015-11-13 20:17 ` Eli Zaretskii
2015-11-13 20:36 ` Achim Gratz
2015-11-13 20:46 ` Eli Zaretskii
2015-11-13 21:46 ` Dmitry Gutov
2015-11-14 11:27 ` Artur Malabarba
2015-11-14 11:55 ` Eli Zaretskii
2015-11-14 12:34 ` Artur Malabarba
2015-11-14 17:08 ` Dmitry Gutov
2015-11-13 20:05 ` Freeze is almost here (was: Dynamic loading progress) Eli Zaretskii
2015-11-13 20:31 ` Eli Zaretskii
2015-11-13 22:57 ` Freeze is almost here John Wiegley
2015-11-14 8:42 ` Eli Zaretskii
2015-11-14 15:59 ` John Wiegley
2015-11-15 9:53 ` Steinar Bang
2015-11-16 9:28 ` Steinar Bang
2015-11-16 16:54 ` John Wiegley
2015-11-13 21:34 ` Andreas Schwab
2015-11-14 8:03 ` Eli Zaretskii
2015-11-14 8:16 ` Andreas Schwab
2015-11-14 8:27 ` Eli Zaretskii
2015-11-14 10:06 ` Andreas Schwab
2015-11-14 8:45 ` David Engster
2015-11-14 9:15 ` Eli Zaretskii
2015-11-14 12:54 ` David Engster
2015-11-14 12:57 ` David Engster
2015-11-14 13:36 ` Eli Zaretskii
2015-11-14 14:37 ` David Engster
2015-11-14 15:02 ` Eli Zaretskii
2015-11-14 13:33 ` Eli Zaretskii
2015-11-14 14:42 ` David Engster
2015-11-14 15:01 ` Eli Zaretskii
2015-11-14 0:56 ` Freeze is almost here (was: Dynamic loading progress) Xue Fuqiao
2015-11-14 6:06 ` Freeze is almost here John Wiegley
2015-11-14 8:22 ` Eli Zaretskii
2015-11-16 0:10 ` Dynamic loading progress Aurélien Aptel
2015-11-17 2:23 ` raman
2015-11-17 8:26 ` Steinar Bang
2015-11-17 11:08 ` Aurélien Aptel
2015-11-18 19:38 ` Ted Zlatanov
2015-11-18 20:58 ` Eli Zaretskii
2015-11-18 22:05 ` John Wiegley
2015-11-19 2:19 ` Ted Zlatanov
2015-11-19 3:39 ` Eli Zaretskii
2015-11-19 15:26 ` Eli Zaretskii
2015-11-19 15:55 ` Paul Eggert
2015-11-19 16:27 ` Eli Zaretskii
2015-11-19 16:37 ` Paul Eggert
2015-11-19 17:04 ` Eli Zaretskii
2015-11-19 17:26 ` Eli Zaretskii
2015-11-19 17:32 ` Paul Eggert
2015-11-19 17:50 ` Eli Zaretskii
2015-11-19 17:57 ` Stephen Leake
2015-11-19 18:06 ` Eli Zaretskii
2015-11-19 18:53 ` Paul Eggert
2015-11-19 20:27 ` Eli Zaretskii
2015-11-19 20:31 ` John Wiegley
2015-11-19 22:45 ` Philipp Stephani
2015-11-19 22:55 ` Paul Eggert
2015-11-19 23:08 ` Philipp Stephani
2015-11-19 23:50 ` Paul Eggert
2015-11-19 23:55 ` Philipp Stephani
2015-11-19 23:58 ` Paul Eggert
2015-11-20 19:23 ` Philipp Stephani
2015-11-20 21:04 ` Paul Eggert
2015-11-20 22:44 ` Philipp Stephani
2015-11-20 10:11 ` Eli Zaretskii
2015-11-20 20:00 ` Philipp Stephani
2015-11-19 22:41 ` Philipp Stephani
2015-11-19 23:51 ` Paul Eggert
2015-11-19 23:57 ` Philipp Stephani
2015-11-20 0:03 ` Paul Eggert
2015-11-20 19:29 ` Philipp Stephani
2015-11-20 20:47 ` Paul Eggert
2015-11-20 22:36 ` Philipp Stephani
2015-11-20 23:06 ` Paul Eggert
2015-11-21 8:54 ` Philipp Stephani
2015-11-21 23:25 ` Paul Eggert
2015-11-22 9:15 ` Philipp Stephani
2015-11-22 18:37 ` Paul Eggert
2015-11-22 19:17 ` Philipp Stephani
2015-11-20 9:53 ` Eli Zaretskii
2015-11-20 11:59 ` Eli Zaretskii
2015-11-20 15:52 ` Eli Zaretskii
2015-11-20 20:39 ` Paul Eggert
2015-11-20 21:22 ` Eli Zaretskii
2015-11-20 22:46 ` Philipp Stephani
2015-11-20 18:44 ` Paul Eggert
2015-11-20 18:50 ` Eli Zaretskii
2015-11-20 19:13 ` Paul Eggert
2015-11-20 20:05 ` Philipp Stephani
2015-11-20 20:32 ` Paul Eggert
2015-11-20 20:45 ` Philipp Stephani
2015-11-20 20:59 ` Paul Eggert
2015-11-20 22:42 ` Philipp Stephani
2015-11-20 23:44 ` Paul Eggert
2015-11-21 8:34 ` Philipp Stephani
2015-11-23 17:06 ` Ted Zlatanov
2015-11-20 19:58 ` Philipp Stephani
2015-11-20 21:56 ` Eli Zaretskii
2015-11-20 23:22 ` Philipp Stephani
2015-11-20 23:29 ` Paul Eggert
2015-11-21 0:08 ` Philipp Stephani
2015-11-21 0:28 ` Paul Eggert
2015-11-21 8:33 ` Philipp Stephani
2015-11-21 23:10 ` Paul Eggert
2015-11-22 9:03 ` Philipp Stephani
2015-11-22 16:23 ` Eli Zaretskii
2015-11-22 16:27 ` Philipp Stephani
2015-11-22 16:56 ` Eli Zaretskii
2015-11-22 17:18 ` Philipp Stephani
2015-11-22 17:27 ` Philipp Stephani
2015-11-22 18:50 ` Paul Eggert
2015-11-22 19:19 ` Philipp Stephani
2015-11-22 19:26 ` Eli Zaretskii
2015-11-22 19:58 ` Philipp Stephani
2015-11-23 18:17 ` Eli Zaretskii
2015-11-23 2:47 ` Tom Tromey
2015-11-23 3:46 ` Eli Zaretskii
2015-11-23 16:29 ` Paul Eggert
2015-11-23 16:35 ` Eli Zaretskii
2015-11-21 8:35 ` Eli Zaretskii
2015-11-21 9:19 ` Philipp Stephani
2015-11-21 9:33 ` Eli Zaretskii
2015-11-21 9:01 ` Philipp Stephani
2015-11-21 9:29 ` Eli Zaretskii
2015-11-21 10:31 ` Philipp Stephani
2015-11-21 10:45 ` David Kastrup
2015-11-21 11:10 ` Eli Zaretskii
2015-11-21 12:11 ` Philipp Stephani
2015-11-21 13:23 ` Eli Zaretskii
2015-11-22 9:25 ` Philipp Stephani
2015-11-22 14:56 ` Philipp Stephani
2015-11-22 18:04 ` Eli Zaretskii
2015-11-22 19:10 ` Philipp Stephani
2015-11-22 19:43 ` Eli Zaretskii
2015-11-22 17:35 ` Eli Zaretskii
2015-11-22 18:19 ` Philipp Stephani
2015-11-22 19:12 ` David Kastrup
2015-11-22 19:20 ` Eli Zaretskii
2015-11-22 19:37 ` Philipp Stephani
2015-11-22 19:49 ` David Kastrup
2015-11-22 19:50 ` Eli Zaretskii
2015-11-22 20:59 ` David Kastrup
2015-11-23 3:29 ` Eli Zaretskii
2015-11-22 21:10 ` Philipp Stephani
2015-11-23 3:31 ` Eli Zaretskii
2015-11-23 18:10 ` Eli Zaretskii
2015-11-19 22:14 ` Philipp Stephani
2015-11-23 16:57 ` Ted Zlatanov
2015-11-19 22:12 ` Philipp Stephani
2015-11-20 7:50 ` Eli Zaretskii
2015-11-20 22:10 ` Philipp Stephani
2015-11-20 23:46 ` Paul Eggert
2015-11-21 7:53 ` Eli Zaretskii
2015-11-21 8:30 ` Philipp Stephani
2015-11-21 9:06 ` Eli Zaretskii
2015-11-21 9:25 ` Philipp Stephani
2015-11-21 9:51 ` Eli Zaretskii
2015-11-21 10:33 ` Philipp Stephani
2015-11-21 10:53 ` Eli Zaretskii
2015-11-17 17:10 ` John Wiegley
2015-11-18 0:17 ` Xue Fuqiao
2015-11-18 1:20 ` Xue Fuqiao
2015-11-18 3:08 ` John Wiegley
2015-11-09 13:16 ` Steinar Bang
2015-11-10 9:35 ` Suggestion to enable git rerere by default Nicolas Richard
2015-11-10 11:12 ` Artur Malabarba
2015-11-10 13:01 ` Nicolas Richard
2015-11-09 22:10 ` Dynamic loading progress John Wiegley
2015-11-10 1:40 ` Ted Zlatanov
2015-11-08 11:02 ` Philipp Stephani
2015-11-08 12:51 ` Steinar Bang
2015-11-08 13:35 ` Philipp Stephani
2015-10-14 22:34 ` Philipp Stephani
2015-10-14 22:38 ` Daniel Colascione
2015-10-14 23:32 ` Aurélien Aptel
2015-10-15 1:05 ` Philipp Stephani
2015-10-15 10:50 ` Aurélien Aptel
2015-10-15 19:25 ` Stephen Leake
2015-02-15 18:24 ` Andreas Schwab
2015-02-15 18:39 ` Stefan Monnier
2015-02-12 21:39 ` Aurélien Aptel
2015-02-13 21:29 ` Stephen Leake
2015-02-04 12:11 ` Ted Zlatanov
2015-02-04 15:22 ` Stefan Monnier
2015-02-04 21:49 ` Aurélien Aptel
2015-02-04 23:00 ` Ted Zlatanov
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=85egpsgf5z.fsf@stephe-leake.org \
--to=stephen_leake@stephe-leake.org \
--cc=emacs-devel@gnu.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
Code repositories for project(s) associated with this external index
https://git.savannah.gnu.org/cgit/emacs.git
https://git.savannah.gnu.org/cgit/emacs/org-mode.git
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.