Mps: mpslib via client callbacks. mpslib.c

Copied from Perforce
 Change: 143314
 ServerID: perforce.ravenbrook.com

1 files changed, 316 insertions, 0 deletions

diff --git a/mps/code/mpslibcb.c b/mps/code/mpslibcb.c
new file mode 100644
index 00000000000..ec1b154f372
--- /dev/null
+++ b/mps/code/mpslibcb.c
@@ -0,0 +1,316 @@
+/* mpslibcb.c: RAVENBROOK MEMORY POOL SYSTEM LIBRARY INTERFACE (CALLBACK)
+ *
+ * $Header$
+ * Copyright (c) 2005 Ravenbrook Limited.  See end of file for license.
+ *
+ * .purpose: The purpose of this code is
+ *   1. permit the MPS Library Interface to be used conveniently when
+ *      the MPS is packaged as a dynamic library (and in particular a
+ *      Windows DLL).
+ *
+ * .readership: For MPS client application developers and MPS developers.
+ * .sources: <design/lib/>
+ *
+ * .freestanding: This is designed to be deployed in a freestanding
+ * environment, so we can't use strcmp from <string.h>, so we have to
+ * roll our own (in fact we only ever need equality so we define a
+ * simpler interface).
+ */
+
+#include "mpslibcb.h"
+#include "mpslib.h"
+#include "mpm.h"
+
+/* Forward declarations. */
+
+int mps_lib_callback_default_get_EOF(void);
+mps_lib_FILE *mps_lib_callback_default_get_stderr(void);
+mps_lib_FILE *mps_lib_callback_default_get_stdout(void);
+int mps_lib_callback_default_fputc(int c_, mps_lib_FILE *f_);
+int mps_lib_callback_default_fputs(const char *s_, mps_lib_FILE *f_);
+void *mps_lib_callback_default_memset(void *p_, int c_, size_t n_);
+void *mps_lib_callback_default_memcpy(void *p_, const void *q_, size_t n_);
+int mps_lib_callback_default_memcmp(const void *p_, const void *q_, size_t n_);
+mps_clock_t mps_lib_callback_default_clock(void);
+mps_clock_t mps_lib_callback_default_clocks_per_sec(void);
+unsigned long mps_lib_callback_default_telemetry_control(void);
+int mps_lib_callback_streq(const char *, const char *);
+
+#define EQ(p, q) (mps_lib_callback_streq((p), (q)))
+
+struct mps_lib_callback_s
+{
+  int (*lib_get_EOF)(void);
+  mps_lib_FILE * (*lib_get_stderr)(void);
+  mps_lib_FILE * (*lib_get_stdout)(void);
+  int (*lib_fputc)(int, mps_lib_FILE *);
+  int (*lib_fputs)(const char *, mps_lib_FILE *);
+  void (*lib_assert_fail)(const char *);
+  void * (*lib_memset)(void *, int, size_t);
+  void * (*lib_memcpy)(void *, const void *, size_t);
+  int (*lib_memcmp)(const void *, const void *, size_t);
+  mps_clock_t (*clock)(void);
+  mps_clock_t (*clocks_per_sec)(void);
+  unsigned long (*lib_telemetry_control)(void);
+};
+
+/* The default functions are stubs that assert.  Except for the
+ * assert_fail function (which is called when assertions fail) which
+ * will be NULL.  This means: if you provide assert_fail and forget
+ * something else, you'll know about it.  If you do not provide
+ * assert_fail then it will probably stop anyway.
+ *
+ * These functions really do need to fail even if checks are off
+ * (CHECK_NONE), so we reach under the hood of check.h and call ASSERT
+ * directly. */
+  
+struct mps_lib_callback_s mps_lib_callback_global = {
+  mps_lib_callback_default_get_EOF,
+  mps_lib_callback_default_get_stderr,
+  mps_lib_callback_default_get_stdout,
+  mps_lib_callback_default_fputc,
+  mps_lib_callback_default_fputs,
+  NULL, /* assert_fail */
+  mps_lib_callback_default_memset,
+  mps_lib_callback_default_memcpy,
+  mps_lib_callback_default_memcmp,
+  mps_lib_callback_default_clock,
+  mps_lib_callback_default_clocks_per_sec,
+  mps_lib_callback_default_telemetry_control
+};
+
+int mps_lib_callback_register(const char *name, mps_lib_function_t f)
+{
+  if(NULL == name) {
+    return ResFAIL;
+  }
+  if(0) {
+    /* just to make the "else if" neater. */
+  } else if(EQ(name, "mps_lib_get_EOF")) {
+    mps_lib_callback_global.lib_get_EOF = (int(*)(void))f;
+  } else if(EQ(name, "mps_lib_get_stderr")) {
+    mps_lib_callback_global.lib_get_stderr = (mps_lib_FILE *(*)(void))f;
+  } else if(EQ(name, "mps_lib_get_stdout")) {
+    mps_lib_callback_global.lib_get_stdout = (mps_lib_FILE *(*)(void))f;
+  } else if(EQ(name, "mps_lib_fputc")) {
+    mps_lib_callback_global.lib_fputc = (int(*)(int, mps_lib_FILE *))f;
+  } else if(EQ(name, "mps_lib_fputs")) {
+    mps_lib_callback_global.lib_fputs =
+      (int(*)(const char *, mps_lib_FILE *))f;
+  } else if(EQ(name, "mps_lib_assert_fail")) {
+    mps_lib_callback_global.lib_assert_fail = (void(*)(const char *))f;
+  } else if(EQ(name, "mps_lib_memset")) {
+    mps_lib_callback_global.lib_memset = (void *(*)(void *, int, size_t))f;
+  } else if(EQ(name, "mps_lib_memcpy")) {
+    mps_lib_callback_global.lib_memcpy =
+      (void *(*)(void *, const void *, size_t))f;
+  } else if(EQ(name, "mps_lib_memcmp")) {
+    mps_lib_callback_global.lib_memcmp =
+      (int(*)(const void *, const void *, size_t))f;
+  } else if(EQ(name, "mps_clock")) {
+    mps_lib_callback_global.clock = (mps_clock_t(*)(void))f;
+  } else if(EQ(name, "mps_clocks_per_sec")) {
+    mps_lib_callback_global.clocks_per_sec = (mps_clock_t(*)(void))f;
+  } else if(EQ(name, "mps_lib_telemetry_control")) {
+    mps_lib_callback_global.lib_telemetry_control =
+      (unsigned long(*)(void))f;
+  } else {
+    return ResUNIMPL;
+  }
+  return ResOK;
+}
+
+/* Return non-zero if and only if string p equals string q. */
+int mps_lib_callback_streq(const char *p, const char *q)
+{
+  do {
+    if(*p == '\0' && *q == '\0') {
+      return 1;
+    }
+  } while(*p++ == *q++);
+  return 0;
+}
+
+int mps_lib_callback_default_get_EOF(void)
+{
+  ASSERT(0, "mps_lib_get_EOF needs to be provided");
+  return 0;
+}
+
+mps_lib_FILE *mps_lib_callback_default_get_stderr(void)
+{
+  ASSERT(0, "mps_lib_get_stderr needs to be provided");
+  return NULL;
+}
+
+mps_lib_FILE *mps_lib_callback_default_get_stdout(void)
+{
+  ASSERT(0, "mps_lib_get_stdout needs to be provided");
+  return NULL;
+}
+
+int mps_lib_callback_default_fputc(int c_, mps_lib_FILE *f_)
+{
+  UNUSED(c_);
+  UNUSED(f_);
+  ASSERT(0, "mps_lib_fputc needs to be provided");
+  return 0;
+}
+
+int mps_lib_callback_default_fputs(const char *s_, mps_lib_FILE *f_)
+{
+  UNUSED(s_);
+  UNUSED(f_);
+  ASSERT(0, "mps_lib_fputs needs to be provided");
+  return 0;
+}
+
+/* No default implementation for mps_lib_assert_fail */
+
+void *mps_lib_callback_default_memset(void *p_, int c_, size_t n_)
+{
+  UNUSED(p_);
+  UNUSED(c_);
+  UNUSED(n_);
+  ASSERT(0, "mps_lib_memset needs to be provided");
+  return NULL;
+}
+
+void *mps_lib_callback_default_memcpy(void *p_, const void *q_, size_t n_)
+{
+  UNUSED(p_);
+  UNUSED(q_);
+  UNUSED(n_);
+  ASSERT(0, "mps_lib_memcpy needs to be provided");
+  return NULL;
+}
+
+int mps_lib_callback_default_memcmp(const void *p_, const void *q_, size_t n_)
+{
+  UNUSED(p_);
+  UNUSED(q_);
+  UNUSED(n_);
+  ASSERT(0, "mps_lib_memcmp needs to be provided");
+  return 0;
+}
+
+mps_clock_t mps_lib_callback_default_clock(void)
+{
+  ASSERT(0, "mps_clock needs to be provided");
+  return 0;
+}
+
+mps_clock_t mps_lib_callback_default_clocks_per_sec(void)
+{
+  ASSERT(0, "mps_clocks_per_sec needs to be provided");
+  return 0;
+}
+
+unsigned long mps_lib_callback_default_telemetry_control(void)
+{
+  ASSERT(0, "mps_lib_telemetry_control needs to be provided");
+  return 0;
+}
+
+int mps_lib_get_EOF(void)
+{
+  return mps_lib_callback_global.lib_get_EOF();
+}
+
+mps_lib_FILE *mps_lib_get_stderr(void)
+{
+  return mps_lib_callback_global.lib_get_stderr();
+}
+
+mps_lib_FILE *mps_lib_get_stdout(void)
+{
+  return mps_lib_callback_global.lib_get_stdout();
+}
+
+int mps_lib_fputc(int c, mps_lib_FILE *f)
+{
+  return mps_lib_callback_global.lib_fputc(c, f);
+}
+
+int mps_lib_fputs(const char *s, mps_lib_FILE *f)
+{
+  return mps_lib_callback_global.lib_fputs(s, f);
+}
+
+void mps_lib_assert_fail(const char *m)
+{
+  mps_lib_callback_global.lib_assert_fail(m);
+}
+
+void *(mps_lib_memset)(void *p, int c, size_t n)
+{
+  return mps_lib_callback_global.lib_memset(p, c, n);
+}
+
+void *(mps_lib_memcpy)(void *p, const void *q, size_t n)
+{
+  return mps_lib_callback_global.lib_memcpy(p, q, n);
+}
+
+int (mps_lib_memcmp)(const void *p, const void *q, size_t n)
+{
+  return mps_lib_callback_global.lib_memcmp(p, q, n);
+}
+
+mps_clock_t mps_clock(void)
+{
+  return mps_lib_callback_global.clock();
+}
+
+mps_clock_t mps_clocks_per_sec(void)
+{
+  return mps_lib_callback_global.clocks_per_sec();
+}
+
+unsigned long mps_lib_telemetry_control(void)
+{
+  return mps_lib_callback_global.lib_telemetry_control();
+}
+
+
+
+/* C. COPYRIGHT AND LICENSE
+ *
+ * Copyright (C) 2005 Ravenbrook Limited <http://www.ravenbrook.com/>.
+ * All rights reserved.  This is an open source license.  Contact
+ * Ravenbrook for commercial licensing options.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 
+ * 3. Redistributions in any form must be accompanied by information on how
+ * to obtain complete source code for this software and any accompanying
+ * software that uses this software.  The source code must either be
+ * included in the distribution or be available for no more than the cost
+ * of distribution plus a nominal fee, and must be freely redistributable
+ * under reasonable conditions.  For an executable file, complete source
+ * code means the source code for all modules it contains. It does not
+ * include source code for modules or files that typically accompany the
+ * major components of the operating system on which the executable file
+ * runs.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+ * PURPOSE, OR NON-INFRINGEMENT, ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDERS AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */