mod-test.c 14.8 KB
Newer Older
1 2
/* Test GNU Emacs modules.

Paul Eggert's avatar
Paul Eggert committed
3
Copyright 2015-2019 Free Software Foundation, Inc.
4 5 6 7 8

This file is part of GNU Emacs.

GNU Emacs is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
9 10
the Free Software Foundation, either version 3 of the License, or (at
your option) any later version.
11 12 13 14 15 16 17

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
18
along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
19

20 21
#include "config.h"

22
#include <assert.h>
23 24
#include <errno.h>
#include <limits.h>
25
#include <stdio.h>
26
#include <stdlib.h>
27 28 29
#include <string.h>
#include <time.h>

30 31 32 33 34 35 36
#ifdef HAVE_GMP
#include <gmp.h>
#else
#include "mini-gmp.h"
#define EMACS_MODULE_HAVE_MPZ_T
#endif

37
#define EMACS_MODULE_GMP
38
#include <emacs-module.h>
39

40 41
#include "timespec.h"

42 43
int plugin_is_GPL_compatible;

44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67
#if INTPTR_MAX <= 0
# error "INTPTR_MAX misconfigured"
#elif INTPTR_MAX <= INT_MAX || INTPTR_MAX <= LONG_MAX
# define pT "ld"
# define pZ "lu"
# define T_TYPE long
# define Z_TYPE unsigned long
#elif INTPTR_MAX <= INT64_MAX
# ifdef __MINGW32__
#  define pT "lld"
#  define pZ "llu"
#  define T_TYPE long long
#  define Z_TYPE unsigned long long
# else
#  define pT "ld"
#  define pZ "lu"
#  define T_TYPE long
#  define Z_TYPE unsigned long
# endif
#else
# error "INTPTR_MAX too large"
#endif


68 69
/* Always return symbol 't'.  */
static emacs_value
70 71
Fmod_test_return_t (emacs_env *env, ptrdiff_t nargs, emacs_value args[],
		    void *data)
72 73 74 75
{
  return env->intern (env, "t");
}

76
/* Expose simple sum function.  */
77 78
static intmax_t
sum (intmax_t a, intmax_t b)
79 80 81 82
{
  return a + b;
}

83
static emacs_value
84
Fmod_test_sum (emacs_env *env, ptrdiff_t nargs, emacs_value args[], void *data)
85
{
86 87
  assert (nargs == 2);

88 89
  intmax_t a = env->extract_integer (env, args[0]);
  intmax_t b = env->extract_integer (env, args[1]);
90

91
  intmax_t r = sum (a, b);
92 93 94 95 96

  return env->make_integer (env, r);
}


97 98
/* Signal '(error 56).  */
static emacs_value
99 100
Fmod_test_signal (emacs_env *env, ptrdiff_t nargs, emacs_value args[],
		  void *data)
101 102
{
  assert (env->non_local_exit_check (env) == emacs_funcall_exit_return);
103 104
  env->non_local_exit_signal (env, env->intern (env, "error"),
			      env->make_integer (env, 56));
105
  return NULL;
106 107 108
}


109 110
/* Throw '(tag 65).  */
static emacs_value
111 112
Fmod_test_throw (emacs_env *env, ptrdiff_t nargs, emacs_value args[],
		 void *data)
113 114
{
  assert (env->non_local_exit_check (env) == emacs_funcall_exit_return);
115 116
  env->non_local_exit_throw (env, env->intern (env, "tag"),
			     env->make_integer (env, 65));
117
  return NULL;
118 119 120
}


121 122 123
/* Call argument function, catch all non-local exists and return
   either normal result or a list describing the non-local exit.  */
static emacs_value
124 125
Fmod_test_non_local_exit_funcall (emacs_env *env, ptrdiff_t nargs,
				  emacs_value args[], void *data)
126 127
{
  assert (nargs == 1);
Paul Eggert's avatar
Paul Eggert committed
128
  emacs_value result = env->funcall (env, args[0], 0, NULL);
129
  emacs_value non_local_exit_symbol, non_local_exit_data;
130 131 132
  enum emacs_funcall_exit code
    = env->non_local_exit_get (env, &non_local_exit_symbol,
			       &non_local_exit_data);
133 134 135 136 137 138 139
  switch (code)
    {
    case emacs_funcall_exit_return:
      return result;
    case emacs_funcall_exit_signal:
      {
        env->non_local_exit_clear (env);
Paul Eggert's avatar
Paul Eggert committed
140
        emacs_value Flist = env->intern (env, "list");
141 142
        emacs_value list_args[] = {env->intern (env, "signal"),
				   non_local_exit_symbol, non_local_exit_data};
143 144 145 146 147
        return env->funcall (env, Flist, 3, list_args);
      }
    case emacs_funcall_exit_throw:
      {
        env->non_local_exit_clear (env);
Paul Eggert's avatar
Paul Eggert committed
148
        emacs_value Flist = env->intern (env, "list");
149 150
        emacs_value list_args[] = {env->intern (env, "throw"),
				   non_local_exit_symbol, non_local_exit_data};
151 152 153
        return env->funcall (env, Flist, 3, list_args);
      }
    }
154 155

  /* Never reached.  */
156 157 158 159
  return env->intern (env, "nil");;
}


Paul Eggert's avatar
Paul Eggert committed
160
/* Return a global reference.  */
161
static emacs_value
162
Fmod_test_globref_make (emacs_env *env, ptrdiff_t nargs, emacs_value args[],
163
			void *data)
164
{
165 166
  /* Make a big string and make it global.  */
  char str[26 * 100];
167
  for (int i = 0; i < sizeof str; i++)
168
    str[i] = 'a' + (i % 26);
169

170 171
  /* We don't need to null-terminate str.  */
  emacs_value lisp_str = env->make_string (env, str, sizeof str);
172 173 174
  return env->make_global_ref (env, lisp_str);
}

175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192
/* Create a few global references from arguments and free them.  */
static emacs_value
Fmod_test_globref_free (emacs_env *env, ptrdiff_t nargs, emacs_value args[],
			void *data)
{
  emacs_value refs[10];
  for (int i = 0; i < 10; i++)
    {
      refs[i] = env->make_global_ref (env, args[i % nargs]);
    }
  for (int i = 0; i < 10; i++)
    {
      env->free_global_ref (env, refs[i]);
    }
  return env->intern (env, "ok");
}


193

194 195 196
/* Return a copy of the argument string where every 'a' is replaced
   with 'b'.  */
static emacs_value
197
Fmod_test_string_a_to_b (emacs_env *env, ptrdiff_t nargs, emacs_value args[],
198
			 void *data)
199 200
{
  emacs_value lisp_str = args[0];
201
  ptrdiff_t size = 0;
202 203 204 205 206 207
  char * buf = NULL;

  env->copy_string_contents (env, lisp_str, buf, &size);
  buf = malloc (size);
  env->copy_string_contents (env, lisp_str, buf, &size);

208
  for (ptrdiff_t i = 0; i + 1 < size; i++)
209 210 211
    if (buf[i] == 'a')
      buf[i] = 'b';

212
  return env->make_string (env, buf, size - 1);
213 214 215
}


216
/* Embedded pointers in lisp objects.  */
217

218
/* C struct (pointer to) that will be embedded.  */
219 220 221 222 223 224
struct super_struct
{
  int amazing_int;
  char large_unused_buffer[512];
};

225 226 227
/* Return a new user-pointer to a super_struct, with amazing_int set
   to the passed parameter.  */
static emacs_value
228
Fmod_test_userptr_make (emacs_env *env, ptrdiff_t nargs, emacs_value args[],
229
			void *data)
230
{
231
  struct super_struct *p = calloc (1, sizeof *p);
232
  p->amazing_int = env->extract_integer (env, args[0]);
233
  return env->make_user_ptr (env, free, p);
234 235
}

236 237
/* Return the amazing_int of a passed 'user-pointer to a super_struct'.  */
static emacs_value
238 239
Fmod_test_userptr_get (emacs_env *env, ptrdiff_t nargs, emacs_value args[],
		       void *data)
240 241 242 243 244 245
{
  struct super_struct *p = env->get_user_ptr (env, args[0]);
  return env->make_integer (env, p->amazing_int);
}


246 247
/* Fill vector in args[0] with value in args[1].  */
static emacs_value
248 249
Fmod_test_vector_fill (emacs_env *env, ptrdiff_t nargs, emacs_value args[],
		       void *data)
250 251 252
{
  emacs_value vec = args[0];
  emacs_value val = args[1];
253 254
  ptrdiff_t size = env->vec_size (env, vec);
  for (ptrdiff_t i = 0; i < size; i++)
255 256 257 258 259
    env->vec_set (env, vec, i, val);
  return env->intern (env, "t");
}


260 261 262
/* Return whether all elements of vector in args[0] are 'eq' to value
   in args[1].  */
static emacs_value
263 264
Fmod_test_vector_eq (emacs_env *env, ptrdiff_t nargs, emacs_value args[],
		     void *data)
265 266 267
{
  emacs_value vec = args[0];
  emacs_value val = args[1];
268 269
  ptrdiff_t size = env->vec_size (env, vec);
  for (ptrdiff_t i = 0; i < size; i++)
270 271 272 273 274
    if (!env->eq (env, env->vec_get (env, vec, i), val))
        return env->intern (env, "nil");
  return env->intern (env, "t");
}

275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
static emacs_value invalid_stored_value;

/* The next two functions perform a possibly-invalid operation: they
   store a value in a static variable and load it.  This causes
   undefined behavior if the environment that the value was created
   from is no longer live.  The module assertions check for this
   error.  */

static emacs_value
Fmod_test_invalid_store (emacs_env *env, ptrdiff_t nargs, emacs_value *args,
                         void *data)
{
  return invalid_stored_value = env->make_integer (env, 123);
}

static emacs_value
Fmod_test_invalid_load (emacs_env *env, ptrdiff_t nargs, emacs_value *args,
                        void *data)
{
  return invalid_stored_value;
}

297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314
/* An invalid finalizer: Finalizers are run during garbage collection,
   where Lisp code can’t be executed.  -module-assertions tests for
   this case.  */

static emacs_env *current_env;

static void
invalid_finalizer (void *ptr)
{
  current_env->intern (current_env, "nil");
}

static emacs_value
Fmod_test_invalid_finalizer (emacs_env *env, ptrdiff_t nargs, emacs_value *args,
                             void *data)
{
  current_env = env;
  env->make_user_ptr (env, invalid_finalizer, NULL);
315
  return env->intern (env, "nil");
316 317
}

318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375
static void
signal_wrong_type_argument (emacs_env *env, const char *predicate,
                            emacs_value arg)
{
  emacs_value symbol = env->intern (env, "wrong-type-argument");
  emacs_value elements[2] = {env->intern (env, predicate), arg};
  emacs_value data = env->funcall (env, env->intern (env, "list"), 2, elements);
  env->non_local_exit_signal (env, symbol, data);
}

static void
signal_errno (emacs_env *env, const char *function)
{
  const char *message = strerror (errno);
  emacs_value message_value = env->make_string (env, message, strlen (message));
  emacs_value symbol = env->intern (env, "file-error");
  emacs_value elements[2]
    = {env->make_string (env, function, strlen (function)), message_value};
  emacs_value data = env->funcall (env, env->intern (env, "list"), 2, elements);
  env->non_local_exit_signal (env, symbol, data);
}

/* A long-running operation that occasionally calls `should_quit' or
   `process_input'.  */

static emacs_value
Fmod_test_sleep_until (emacs_env *env, ptrdiff_t nargs, emacs_value *args,
                       void *data)
{
  assert (nargs == 2);
  const double until_seconds = env->extract_float (env, args[0]);
  if (env->non_local_exit_check (env))
    return NULL;
  if (until_seconds <= 0)
    {
      signal_wrong_type_argument (env, "cl-plusp", args[0]);
      return NULL;
    }
  const bool process_input = env->is_not_nil (env, args[1]);
  const struct timespec until = dtotimespec (until_seconds);
  const struct timespec amount = make_timespec(0,  10000000);
  while (true)
    {
      const struct timespec now = current_timespec ();
      if (timespec_cmp (now, until) >= 0)
        break;
      if (nanosleep (&amount, NULL) && errno != EINTR)
        {
          signal_errno (env, "nanosleep");
          return NULL;
        }
      if ((process_input
           && env->process_input (env) == emacs_process_input_quit)
          || env->should_quit (env))
        return NULL;
    }
  return env->intern (env, "finished");
}
376

377 378 379 380 381 382 383 384 385 386 387 388
static emacs_value
Fmod_test_add_nanosecond (emacs_env *env, ptrdiff_t nargs, emacs_value *args,
                          void *data)
{
  assert (nargs == 1);
  struct timespec time = env->extract_time (env, args[0]);
  assert (time.tv_nsec >= 0);
  assert (time.tv_nsec < 2000000000);  /* possible leap second */
  time.tv_nsec++;
  return env->make_time (env, time);
}

389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404
static emacs_value
Fmod_test_nanoseconds (emacs_env *env, ptrdiff_t nargs, emacs_value *args, void *data) {
  assert (nargs == 1);
  struct timespec time = env->extract_time (env, args[0]);
  struct emacs_mpz nanoseconds;
  assert (LONG_MIN <= time.tv_sec && time.tv_sec <= LONG_MAX);
  mpz_init_set_si (nanoseconds.value, time.tv_sec);
  static_assert (1000000000 <= ULONG_MAX, "unsupported architecture");
  mpz_mul_ui (nanoseconds.value, nanoseconds.value, 1000000000);
  assert (0 <= time.tv_nsec && time.tv_nsec <= ULONG_MAX);
  mpz_add_ui (nanoseconds.value, nanoseconds.value, time.tv_nsec);
  emacs_value result = env->make_big_integer (env, &nanoseconds);
  mpz_clear (nanoseconds.value);
  return result;
}

405 406 407 408 409 410 411 412 413 414 415 416 417 418 419
static emacs_value
Fmod_test_double (emacs_env *env, ptrdiff_t nargs, emacs_value *args,
                  void *data)
{
  assert (nargs == 1);
  emacs_value arg = args[0];
  struct emacs_mpz value;
  mpz_init (value.value);
  env->extract_big_integer (env, arg, &value);
  mpz_mul_ui (value.value, value.value, 2);
  emacs_value result = env->make_big_integer (env, &value);
  mpz_clear (value.value);
  return result;
}

420
/* Lisp utilities for easier readability (simple wrappers).  */
421

422 423 424
/* Provide FEATURE to Emacs.  */
static void
provide (emacs_env *env, const char *feature)
425 426 427 428 429 430 431 432
{
  emacs_value Qfeat = env->intern (env, feature);
  emacs_value Qprovide = env->intern (env, "provide");
  emacs_value args[] = { Qfeat };

  env->funcall (env, Qprovide, 1, args);
}

433 434 435
/* Bind NAME to FUN.  */
static void
bind_function (emacs_env *env, const char *name, emacs_value Sfun)
436
{
437
  emacs_value Qdefalias = env->intern (env, "defalias");
438 439 440
  emacs_value Qsym = env->intern (env, name);
  emacs_value args[] = { Qsym, Sfun };

441
  env->funcall (env, Qdefalias, 2, args);
442 443
}

444 445 446
/* Module init function.  */
int
emacs_module_init (struct emacs_runtime *ert)
447
{
448 449 450 451 452
  /* Check that EMACS_MAJOR_VERSION is defined and an integral
     constant.  */
  char dummy[EMACS_MAJOR_VERSION];
  assert (27 <= sizeof dummy);

453
  if (ert->size < sizeof *ert)
454
    {
455 456 457
      fprintf (stderr, "Runtime size of runtime structure (%"pT" bytes) "
               "smaller than compile-time size (%"pZ" bytes)",
               (T_TYPE) ert->size, (Z_TYPE) sizeof (*ert));
458 459
      return 1;
    }
460

461 462
  emacs_env *env = ert->get_environment (ert);

Philipp Stephani's avatar
Philipp Stephani committed
463
  if (env->size < sizeof *env)
464
    {
465 466 467
      fprintf (stderr, "Runtime size of environment structure (%"pT" bytes) "
               "smaller than compile-time size (%"pZ" bytes)",
               (T_TYPE) env->size, (Z_TYPE) sizeof (*env));
468 469
      return 2;
    }
470

471
#define DEFUN(lsym, csym, amin, amax, doc, data) \
472 473
  bind_function (env, lsym, \
		 env->make_function (env, amin, amax, csym, doc, data))
474 475

  DEFUN ("mod-test-return-t", Fmod_test_return_t, 1, 1, NULL, NULL);
476
  DEFUN ("mod-test-sum", Fmod_test_sum, 2, 2, "Return A + B\n\n(fn a b)", NULL);
477 478
  DEFUN ("mod-test-signal", Fmod_test_signal, 0, 0, NULL, NULL);
  DEFUN ("mod-test-throw", Fmod_test_throw, 0, 0, NULL, NULL);
479 480
  DEFUN ("mod-test-non-local-exit-funcall", Fmod_test_non_local_exit_funcall,
	 1, 1, NULL, NULL);
481
  DEFUN ("mod-test-globref-make", Fmod_test_globref_make, 0, 0, NULL, NULL);
482
  DEFUN ("mod-test-globref-free", Fmod_test_globref_free, 4, 4, NULL, NULL);
483 484 485 486 487
  DEFUN ("mod-test-string-a-to-b", Fmod_test_string_a_to_b, 1, 1, NULL, NULL);
  DEFUN ("mod-test-userptr-make", Fmod_test_userptr_make, 1, 1, NULL, NULL);
  DEFUN ("mod-test-userptr-get", Fmod_test_userptr_get, 1, 1, NULL, NULL);
  DEFUN ("mod-test-vector-fill", Fmod_test_vector_fill, 2, 2, NULL, NULL);
  DEFUN ("mod-test-vector-eq", Fmod_test_vector_eq, 2, 2, NULL, NULL);
488 489
  DEFUN ("mod-test-invalid-store", Fmod_test_invalid_store, 0, 0, NULL, NULL);
  DEFUN ("mod-test-invalid-load", Fmod_test_invalid_load, 0, 0, NULL, NULL);
490 491
  DEFUN ("mod-test-invalid-finalizer", Fmod_test_invalid_finalizer, 0, 0,
         NULL, NULL);
492
  DEFUN ("mod-test-sleep-until", Fmod_test_sleep_until, 2, 2, NULL, NULL);
493
  DEFUN ("mod-test-add-nanosecond", Fmod_test_add_nanosecond, 1, 1, NULL, NULL);
494
  DEFUN ("mod-test-nanoseconds", Fmod_test_nanoseconds, 1, 1, NULL, NULL);
495
  DEFUN ("mod-test-double", Fmod_test_double, 1, 1, NULL, NULL);
496 497 498 499 500 501

#undef DEFUN

  provide (env, "mod-test");
  return 0;
}