From: tomo Date: Tue, 2 May 2000 08:52:38 +0000 (+0000) Subject: Initial revision X-Git-Tag: r21-2-28~2^2 X-Git-Url: http://git.chise.org/gitweb/?p=chise%2Fxemacs-chise.git.1;a=commitdiff_plain;h=0a31b4cd1c88c4ab50576b268b724d0774375aa4 Initial revision --- diff --git a/nt/Xpm.def b/nt/Xpm.def new file mode 100644 index 0000000..c355aa0 --- /dev/null +++ b/nt/Xpm.def @@ -0,0 +1,50 @@ +; Export definition file for XPM port to Win32 +; Copyright (C) 2000 Kirill 'Big K' Katsnelson +; +; This file is part of XEmacs. +; +; XEmacs is free software; you can redistribute it and/or modify it +; under the terms of the GNU General Public License as published by the +; Free Software Foundation; either version 2, or (at your option) any +; later version. +; +; XEmacs 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 +; along with XEmacs; see the file COPYING. If not, write to +; the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +; Boston, MA 02111-1307, USA. +; +; Synched up with: Not in FSF. +; + +LIBRARY Xpm.dll +EXPORTS + XpmCreateImageFromData + XpmCreateDataFromImage + XpmReadFileToImage + XpmWriteFileFromImage + XpmCreateImageFromBuffer + XpmReadFileToBuffer + XpmWriteFileFromBuffer + XpmReadFileToData + XpmWriteFileFromData + XpmAttributesSize + XpmFreeAttributes + XpmFreeExtensions + XpmFreeXpmImage + XpmFreeXpmInfo + XpmGetErrorString + XpmLibraryVersion + XpmReadFileToXpmImage + XpmWriteFileFromXpmImage + XpmCreateImageFromXpmImage + XpmCreateXpmImageFromImage + XpmCreateDataFromXpmImage + XpmCreateXpmImageFromData + XpmCreateXpmImageFromBuffer + XpmCreateBufferFromXpmImage + XpmFree diff --git a/src/m/iris6d.h b/src/m/iris6d.h new file mode 100644 index 0000000..caae6dc --- /dev/null +++ b/src/m/iris6d.h @@ -0,0 +1,152 @@ +/* machine description file for Iris-4D machines. Use with s/irix*.h. + Copyright (C) 1987 Free Software Foundation, Inc. + +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 +the Free Software Foundation; either version 2, or (at your option) +any later version. + +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 +along with XEmacs; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +/* Synched up with: FSF 19.31. */ + +/* Define WORD_MACHINE if addresses and such have + * to be corrected before they can be used as byte counts. */ + +#undef WORD_MACHINE + +/* Now define a symbol for the cpu type, if your compiler + does not define it automatically: + Ones defined so far include vax, m68000, ns16000, pyramid, + orion, tahoe, APOLLO and many others */ + +#ifndef mips +#define mips +#endif + +#ifndef IRIS_4D +#define IRIS_4D +#endif + +/* Define EXPLICIT_SIGN_EXTEND if XINT must explicitly sign-extend + the bit field into an int. In other words, if bit fields + are always unsigned. + + If you use NO_UNION_TYPE, this flag does not matter. */ + +#define EXPLICIT_SIGN_EXTEND + +/* jg@genmagic.genmagic.com (John Giannandrea) says this is unnecessary. */ +#if 0 +/* Data type of load average, as read out of kmem. */ + +#define LOAD_AVE_TYPE long /* This doesn't quite work on the 4D */ + +/* Convert that into an integer that is 100 for a load average of 1.0 */ + +#define LOAD_AVE_CVT(x) (int)(((double)(x)*100)/1024.0) + +/* s-iris3-6.h uses /vmunix */ + +#undef KERNEL_FILE +#define KERNEL_FILE "/unix" +#endif + +/* Define CANNOT_DUMP on machines where unexec does not work. + Then the function dump-emacs will not be defined + and temacs will do (load "loadup") automatically unless told otherwise. */ + +#undef CANNOT_DUMP + +/* Define VIRT_ADDR_VARIES if the virtual addresses of + pure and impure space as loaded can vary, and even their + relative order cannot be relied on. + + Otherwise Emacs assumes that text space precedes data space, + numerically. */ + +/* #define VIRT_ADDR_VARIES */ + +/* Define C_ALLOCA if this machine does not support a true alloca + and the one written in C should be used instead. + Define HAVE_ALLOCA to say that the system provides a properly + working alloca function and it should be used. + Define neither one if an assembler-language alloca + in the file alloca.s should be used. */ + +/* #define C_ALLOCA */ /* Sjoerd.Mullender@cwi.nl says no need. */ +/* #define HAVE_ALLOCA */ + +/* Define NO_REMAP if memory segmentation makes it not work well + to change the boundary between the text section and data section + when Emacs is dumped. If you define this, the preloaded Lisp + code will not be sharable; but that's better than failing completely. */ + +#define NO_REMAP + +/* This machine requires completely different unexec code + which lives in a separate file. Specify the file name. */ + +#ifdef USG5_4 +#undef UNEXEC +#define UNEXEC "unexelfsgi.o" +#else +#define UNEXEC "unexmips.o" +#endif + +#define TEXT_START 0x400000 + +/* + * DATA_SEG_BITS forces extra bits to be or'd in with any pointers which + * were stored in a Lisp_Object (as Emacs uses fewer than 32 bits for + * the value field of a LISP_OBJECT). + */ + +#define DATA_START 0x10000000 +#define DATA_SEG_BITS 0x10000000 + +#undef LIBS_MACHINE +/* -lsun in case using Yellow Pages for passwords. */ +#define LIBS_DEBUG + +/* Define this if you have a fairly recent system, + in which crt1.o and crt1.n should be used. */ +#define HAVE_CRTN + +#ifndef USG5_4 +#ifdef HAVE_CRTN +/* Must define START-FILES so that the linker can find /usr/lib/crt0.o. */ +#define START_FILES "pre-crt0.o /usr/lib/crt1.o" +#define LIB_STANDARD "-lc /usr/lib/crtn.o" +#else +#define START_FILES "pre-crt0.o /usr/lib/crt0.o" +/* The entry-point label (start of text segment) is `start', not `__start'. */ +#define DEFAULT_ENTRY_ADDRESS start +#define LIB_STANDARD "-lc" +#endif +#endif + +/* Use terminfo instead of termcap. */ + +#define TERMINFO + +/* Letter to use in finding device name of first pty, + if system supports pty's. 'a' means it is /dev/ptya0 */ + +#undef FIRST_PTY_LETTER +#define FIRST_PTY_LETTER 'q' + +/* Define STACK_DIRECTION for alloca.c */ + +#undef STACK_DIRECTION +#define STACK_DIRECTION -1 diff --git a/src/tests.c b/src/tests.c new file mode 100644 index 0000000..20359a4 --- /dev/null +++ b/src/tests.c @@ -0,0 +1,436 @@ +/* C support for testing XEmacs - see tests/automated/c-tests.el + Copyright (C) 2000 Martin Buchholz + +This file is part of XEmacs. + +XEmacs is free software; you can redistribute it and/or modify it +under the terms of the GNU General Public License as published by the +Free Software Foundation; either version 2, or (at your option) any +later version. + +XEmacs 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 +along with XEmacs; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +/* Author: Martin Buchholz + + This file provides support for running tests for XEmacs that cannot + be written entirely in Lisp. These tests are run automatically via + tests/automated/c-tests.el, or can be run by hand using M-x */ + + +#include +#include "lisp.h" +#include "buffer.h" +#include "lstream.h" +#include "opaque.h" + +static Lisp_Object Vtest_function_list; + + +DEFUN ("test-data-format-conversion", Ftest_data_format_conversion, 0, 0, "", /* +Test TO_EXTERNAL_FORMAT() and TO_INTERNAL_FORMAT() +*/ + ()) +{ + void *ptr; size_t len; + Lisp_Object string, opaque; + + Bufbyte int_foo[] = "\n\nfoo\nbar"; + Extbyte ext_unix[]= "\n\nfoo\nbar"; + + Extbyte ext_dos[] = "\r\n\r\nfoo\r\nbar"; + Extbyte ext_mac[] = "\r\rfoo\rbar"; + Lisp_Object opaque_dos = make_opaque (ext_dos, sizeof (ext_dos) - 1); + Lisp_Object string_foo = make_string (int_foo, sizeof (int_foo) - 1); + + Extbyte ext_latin[] = "f\372b\343\340"; + Bufbyte int_latin1[] = "f\201\372b\201\343\201\340"; + Bufbyte int_latin2[] = "f\202\372b\202\343\202\340"; +#ifdef MULE + Extbyte ext_latin12[]= "f\033-A\372b\343\340\033-B"; + Extbyte ext_tilde[] = "f~b~~"; + Lisp_Object string_latin2 = make_string (int_latin2, sizeof (int_latin2) - 1); +#endif + Lisp_Object opaque_latin = make_opaque (ext_latin, sizeof (ext_latin) - 1); + Lisp_Object opaque0_latin = make_opaque (ext_latin, sizeof (ext_latin)); + Lisp_Object string_latin1 = make_string (int_latin1, sizeof (int_latin1) - 1); + + /* Check for expected strings before and after conversion. + Conversions depend on whether MULE is defined, + and on whether FILE_CODING is defined. */ +#ifdef MULE +#define DFC_CHECK_DATA_COND_MULE(ptr,len, \ + constant_string_mule, \ + constant_string_non_mule) \ + DFC_CHECK_DATA (ptr, len, constant_string_mule) +#define DFC_CHECK_DATA_COND_MULE_NUL(ptr,len, \ + constant_string_mule, \ + constant_string_non_mule) \ + DFC_CHECK_DATA_NUL (ptr, len, constant_string_mule) +#else +#define DFC_CHECK_DATA_COND_MULE(ptr,len, \ + constant_string_mule, \ + constant_string_non_mule) \ + DFC_CHECK_DATA (ptr, len, constant_string_non_mule) +#define DFC_CHECK_DATA_COND_MULE_NUL(ptr,len, \ + constant_string_mule, \ + constant_string_non_mule) \ + DFC_CHECK_DATA_NUL (ptr, len, constant_string_non_mule) +#endif + +#ifdef FILE_CODING +#define DFC_CHECK_DATA_COND_EOL(ptr,len, \ + constant_string_eol, \ + constant_string_non_eol) \ + DFC_CHECK_DATA (ptr, len, constant_string_eol) +#define DFC_CHECK_DATA_COND_EOL_NUL(ptr,len, \ + constant_string_eol, \ + constant_string_non_eol) \ + DFC_CHECK_DATA_NUL (ptr, len, constant_string_eol) +#else +#define DFC_CHECK_DATA_COND_EOL(ptr,len, \ + constant_string_eol, \ + constant_string_non_eol) \ + DFC_CHECK_DATA (ptr, len, constant_string_non_eol) +#define DFC_CHECK_DATA_COND_EOL_NUL(ptr,len, \ + constant_string_eol, \ + constant_string_non_eol) \ + DFC_CHECK_DATA_NUL (ptr, len, constant_string_non_eol) +#endif + + /* Check for expected strings before and after conversion. */ +#define DFC_CHECK_DATA(ptr,len, constant_string) do { \ + assert ((len) == sizeof (constant_string) - 1); \ + assert (!memcmp (ptr, constant_string, len)); \ + } while (0) + + /* Macro version that includes the trailing NULL byte. */ +#define DFC_CHECK_DATA_NUL(ptr,len,constant_string) do {\ + assert ((len) == sizeof (constant_string)); \ + assert (!memcmp (ptr, constant_string, len)); \ + } while (0) + +#ifdef MULE + ptr = NULL, len = rand(); + TO_EXTERNAL_FORMAT (DATA, (int_latin2, sizeof (int_latin2)), + ALLOCA, (ptr, len), + Fget_coding_system (intern ("iso-8859-2"))); + DFC_CHECK_DATA_NUL (ptr, len, ext_latin); + + ptr = NULL, len = rand(); + TO_EXTERNAL_FORMAT (LISP_STRING, string_latin2, + ALLOCA, (ptr, len), + Fget_coding_system (intern ("iso-8859-2"))); + DFC_CHECK_DATA (ptr, len, ext_latin); + + ptr = NULL, len = rand(); + TO_EXTERNAL_FORMAT (LISP_STRING, string_latin1, + ALLOCA, (ptr, len), + Fget_coding_system (intern ("iso-8859-2"))); + DFC_CHECK_DATA (ptr, len, ext_latin12); + + ptr = NULL, len = rand(); + TO_EXTERNAL_FORMAT (DATA, (int_latin2, sizeof (int_latin2) - 1), + MALLOC, (ptr, len), + Fget_coding_system (intern ("iso-8859-2"))); + DFC_CHECK_DATA (ptr, len, ext_latin); + xfree (ptr); + + TO_EXTERNAL_FORMAT (DATA, (int_latin2, sizeof (int_latin2) - 1), + LISP_OPAQUE, opaque, + Fget_coding_system (intern ("iso-8859-2"))); + DFC_CHECK_DATA (XOPAQUE_DATA (opaque), XOPAQUE_SIZE (opaque), ext_latin); + + ptr = NULL, len = rand(); + TO_INTERNAL_FORMAT (DATA, (ext_latin, sizeof (ext_latin) - 1), + ALLOCA, (ptr, len), + intern ("iso-8859-2")); + DFC_CHECK_DATA (ptr, len, int_latin2); + + ptr = NULL, len = rand(); + TO_INTERNAL_FORMAT (DATA, (ext_latin, sizeof (ext_latin) - 1), + MALLOC, (ptr, len), + intern ("iso-8859-2")); + DFC_CHECK_DATA (ptr, len, int_latin2); + xfree (ptr); + + TO_INTERNAL_FORMAT (DATA, (ext_latin, sizeof (ext_latin) - 1), + LISP_STRING, string, + intern ("iso-8859-2")); + DFC_CHECK_DATA (XSTRING_DATA (string), XSTRING_LENGTH (string), int_latin2); + + TO_INTERNAL_FORMAT (LISP_OPAQUE, opaque_latin, + LISP_STRING, string, + intern ("iso-8859-2")); + DFC_CHECK_DATA (XSTRING_DATA (string), XSTRING_LENGTH (string), int_latin2); + + TO_INTERNAL_FORMAT (LISP_OPAQUE, opaque0_latin, + LISP_STRING, string, + intern ("iso-8859-2")); + DFC_CHECK_DATA_NUL (XSTRING_DATA (string), XSTRING_LENGTH (string), int_latin2); + + TO_INTERNAL_FORMAT (LISP_OPAQUE, opaque0_latin, + LISP_BUFFER, Fcurrent_buffer(), + intern ("iso-8859-2")); + DFC_CHECK_DATA_NUL (BUF_BYTE_ADDRESS (current_buffer, BUF_PT (current_buffer)), + sizeof (int_latin2), int_latin2); + + TO_INTERNAL_FORMAT (LISP_OPAQUE, opaque_latin, + LISP_BUFFER, Fcurrent_buffer(), + intern ("iso-8859-1")); + DFC_CHECK_DATA (BUF_BYTE_ADDRESS (current_buffer, BUF_PT (current_buffer)), + sizeof (int_latin1) - 1, int_latin1); + + TO_INTERNAL_FORMAT (DATA, (ext_latin12, sizeof (ext_latin12) - 1), + ALLOCA, (ptr, len), + intern ("iso-8859-2")); + DFC_CHECK_DATA (ptr, len, int_latin1); + +#endif /* MULE */ + + ptr = NULL, len = rand(); + TO_EXTERNAL_FORMAT (DATA, (int_latin1, sizeof (int_latin1) - 1), + ALLOCA, (ptr, len), + Qbinary); + DFC_CHECK_DATA_COND_MULE (ptr, len, ext_latin, int_latin1); + + ptr = NULL, len = rand(); + TO_EXTERNAL_FORMAT (DATA, (int_latin1, sizeof (int_latin1)), + ALLOCA, (ptr, len), + Qbinary); + DFC_CHECK_DATA_COND_MULE_NUL (ptr, len, ext_latin, int_latin1); + + ptr = NULL, len = rand(); + TO_EXTERNAL_FORMAT (DATA, (int_latin2, sizeof (int_latin2) - 1), + ALLOCA, (ptr, len), + Fget_coding_system (Qbinary)); + DFC_CHECK_DATA_COND_MULE (ptr, len, ext_tilde, int_latin2); + + ptr = NULL, len = rand(); + TO_EXTERNAL_FORMAT (DATA, (int_latin1, sizeof (int_latin1) - 1), + ALLOCA, (ptr, len), + intern ("iso-8859-1")); + DFC_CHECK_DATA_COND_MULE (ptr, len, ext_latin, int_latin1); + + + ptr = NULL, len = rand(); + TO_EXTERNAL_FORMAT (LISP_STRING, string_latin1, + ALLOCA, (ptr, len), + Qbinary); + DFC_CHECK_DATA_COND_MULE (ptr, len, ext_latin, int_latin1); + + ptr = NULL, len = rand(); + TO_EXTERNAL_FORMAT (LISP_STRING, string_latin1, + ALLOCA, (ptr, len), + Fget_coding_system (Qbinary)); + DFC_CHECK_DATA_COND_MULE (ptr, len, ext_latin, int_latin1); + + ptr = NULL, len = rand(); + TO_EXTERNAL_FORMAT (LISP_STRING, string_latin1, + ALLOCA, (ptr, len), + intern ("iso-8859-1")); + DFC_CHECK_DATA_COND_MULE (ptr, len, ext_latin, int_latin1); + + ptr = NULL, len = rand(); + TO_EXTERNAL_FORMAT (DATA, (int_latin1, sizeof (int_latin1) - 1), + MALLOC, (ptr, len), + Qbinary); + DFC_CHECK_DATA_COND_MULE (ptr, len, ext_latin, int_latin1); + xfree (ptr); + + ptr = NULL, len = rand(); + TO_EXTERNAL_FORMAT (DATA, (int_latin2, sizeof (int_latin2)), + MALLOC, (ptr, len), + Fget_coding_system (Qbinary)); + DFC_CHECK_DATA_COND_MULE_NUL (ptr, len, ext_tilde, int_latin2); + xfree (ptr); + + ptr = NULL, len = rand(); + TO_EXTERNAL_FORMAT (DATA, (int_latin1, sizeof (int_latin1) - 1), + MALLOC, (ptr, len), + intern ("iso-8859-1")); + DFC_CHECK_DATA_COND_MULE (ptr, len, ext_latin, int_latin1); + xfree (ptr); + + TO_EXTERNAL_FORMAT (DATA, (int_latin1, sizeof (int_latin1) - 1), + LISP_OPAQUE, opaque, + Qbinary); + DFC_CHECK_DATA_COND_MULE (XOPAQUE_DATA (opaque), + XOPAQUE_SIZE (opaque), ext_latin, int_latin1); + + TO_EXTERNAL_FORMAT (DATA, (int_latin2, sizeof (int_latin2)), + LISP_OPAQUE, opaque, + Fget_coding_system (Qbinary)); + DFC_CHECK_DATA_COND_MULE_NUL (XOPAQUE_DATA (opaque), + XOPAQUE_SIZE (opaque), ext_tilde, int_latin2); + + TO_EXTERNAL_FORMAT (DATA, (int_latin1, sizeof (int_latin1) - 1), + LISP_OPAQUE, opaque, + intern ("iso-8859-1")); + DFC_CHECK_DATA_COND_MULE (XOPAQUE_DATA (opaque), + XOPAQUE_SIZE (opaque), ext_latin, int_latin1); + + ptr = NULL, len = rand(); + TO_INTERNAL_FORMAT (DATA, (ext_latin, sizeof (ext_latin) - 1), + ALLOCA, (ptr, len), + Qbinary); + DFC_CHECK_DATA_COND_MULE (ptr, len, int_latin1, ext_latin); + + ptr = NULL, len = rand(); + TO_INTERNAL_FORMAT (DATA, (ext_latin, sizeof (ext_latin)), + ALLOCA, (ptr, len), + intern ("iso-8859-1")); + DFC_CHECK_DATA_COND_MULE_NUL (ptr, len, int_latin1, ext_latin); + + ptr = NULL, len = rand(); + TO_INTERNAL_FORMAT (DATA, (ext_latin, sizeof (ext_latin)), + MALLOC, (ptr, len), + intern ("iso-8859-1")); + DFC_CHECK_DATA_COND_MULE_NUL (ptr, len, int_latin1, ext_latin); + xfree (ptr); + + ptr = NULL, len = rand(); + TO_INTERNAL_FORMAT (DATA, (ext_latin, sizeof (ext_latin)), + MALLOC, (ptr, len), + Qnil); + DFC_CHECK_DATA_COND_MULE_NUL (ptr, len, int_latin1, ext_latin); + xfree (ptr); + + TO_INTERNAL_FORMAT (DATA, (ext_latin, sizeof (ext_latin) - 1), + LISP_STRING, string, + intern ("iso-8859-1")); + DFC_CHECK_DATA_COND_MULE (XSTRING_DATA (string), + XSTRING_LENGTH (string), int_latin1, ext_latin); + + TO_INTERNAL_FORMAT (LISP_OPAQUE, opaque_latin, + LISP_STRING, string, + intern ("iso-8859-1")); + DFC_CHECK_DATA_COND_MULE (XSTRING_DATA (string), + XSTRING_LENGTH (string), int_latin1, ext_latin); + + TO_INTERNAL_FORMAT (LISP_OPAQUE, opaque0_latin, + LISP_STRING, string, + intern ("iso-8859-1")); + DFC_CHECK_DATA_COND_MULE_NUL (XSTRING_DATA (string), + XSTRING_LENGTH (string), int_latin1, ext_latin); + + + ptr = NULL, len = rand(); + TO_EXTERNAL_FORMAT (DATA, (int_foo, sizeof (int_foo)), + MALLOC, (ptr, len), + Fget_coding_system (Qbinary)); + DFC_CHECK_DATA_COND_EOL_NUL (ptr, len, ext_unix, int_foo); + xfree (ptr); + + ptr = NULL, len = rand(); + TO_EXTERNAL_FORMAT (DATA, (int_foo, sizeof (int_foo) - 1), + LISP_OPAQUE, opaque, + intern ("raw-text-mac")); + DFC_CHECK_DATA_COND_EOL (XOPAQUE_DATA (opaque), + XOPAQUE_SIZE (opaque), ext_mac, int_foo); + + ptr = NULL, len = rand(); + TO_EXTERNAL_FORMAT (LISP_STRING, string_foo, + ALLOCA, (ptr, len), + intern ("raw-text-dos")); + DFC_CHECK_DATA_COND_EOL (ptr, len, ext_dos, int_foo); + + ptr = NULL, len = rand(); + TO_EXTERNAL_FORMAT (DATA, (int_foo, sizeof (int_foo) - 1), + ALLOCA, (ptr, len), + intern ("raw-text-unix")); + DFC_CHECK_DATA_COND_EOL (ptr, len, ext_unix, int_foo); + + ptr = NULL, len = rand(); + TO_EXTERNAL_FORMAT (LISP_STRING, string_foo, + MALLOC, (ptr, len), + intern ("no-conversion-mac")); + DFC_CHECK_DATA_COND_EOL (ptr, len, ext_mac, int_foo); + xfree (ptr); + + ptr = NULL, len = rand(); + TO_EXTERNAL_FORMAT (DATA, (int_foo, sizeof (int_foo) - 1), + ALLOCA, (ptr, len), + Fget_coding_system (intern ("no-conversion-dos"))); + DFC_CHECK_DATA_COND_EOL (ptr, len, ext_dos, int_foo); + + ptr = NULL, len = rand(); + TO_EXTERNAL_FORMAT (DATA, (int_foo, sizeof (int_foo)), + ALLOCA, (ptr, len), + intern ("no-conversion-unix")); + DFC_CHECK_DATA_COND_EOL_NUL (ptr, len, ext_unix, int_foo); + +#ifdef FILE_CODING + TO_INTERNAL_FORMAT (LISP_OPAQUE, opaque_dos, + LISP_BUFFER, Fcurrent_buffer(), + intern ("undecided")); + DFC_CHECK_DATA (BUF_BYTE_ADDRESS (current_buffer, BUF_PT (current_buffer)), + sizeof (int_foo) - 1, int_foo); + +#endif /* FILE_CODING */ + + TO_INTERNAL_FORMAT (DATA, (ext_mac, sizeof (ext_mac) - 1), + LISP_STRING, string, + intern ("iso-8859-1")); + DFC_CHECK_DATA_COND_EOL (XSTRING_DATA (string), + XSTRING_LENGTH (string), int_foo, ext_mac); + + { + Lisp_Object stream = + make_fixed_buffer_input_stream (ext_dos, sizeof (ext_dos) - 1); + TO_INTERNAL_FORMAT (LISP_LSTREAM, stream, + LISP_STRING, string, + intern ("iso-8859-1")); + DFC_CHECK_DATA_COND_EOL (XSTRING_DATA (string), + XSTRING_LENGTH (string), int_foo, ext_dos); + } + + TO_INTERNAL_FORMAT (DATA, (ext_unix, sizeof (ext_unix) - 1), + LISP_STRING, string, + intern ("no-conversion")); + DFC_CHECK_DATA_COND_EOL (XSTRING_DATA (string), + XSTRING_LENGTH (string), int_foo, ext_unix); + + + ptr = NULL, len = rand(); + TO_EXTERNAL_FORMAT (LISP_OPAQUE, opaque_dos, + ALLOCA, (ptr, len), + Qbinary); + DFC_CHECK_DATA (ptr, len, ext_dos); + + return intern ("PASS"); +} + + + +#define TESTS_DEFSUBR(Fname) do { \ + DEFSUBR (Fname); \ + Vtest_function_list = \ + Fcons (intern (subr_name (&S##Fname)), \ + Vtest_function_list); \ +} while (0) + +void +syms_of_tests (void) +{ + Vtest_function_list = Qnil; + + TESTS_DEFSUBR (Ftest_data_format_conversion); + /* Add other test functions here with TESTS_DEFSUBR */ +} + +void +vars_of_tests (void) +{ + DEFVAR_LISP ("test-function-list", &Vtest_function_list /* +List of all test functions defined in tests.c. +For use by the automated test suite. See tests/automated/c-tests. +*/ ); +}