Add s-expression parsing to libopen-axiom-core.a

1 files changed, 314 insertions, 0 deletions

diff --git a/src/utils/storage.cxx b/src/utils/storage.cxx
new file mode 100644
index 00000000..80cfea0d
--- /dev/null
+++ b/src/utils/storage.cxx
@@ -0,0 +1,314 @@
+// Copyright (C) 2010-2013, Gabriel Dos Reis.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     - Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//
+//     - 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.
+//
+//     - Neither the name of The Numerical Algorithms Group Ltd. nor the
+//       names of its contributors may be used to endorse or promote products
+//       derived from this software without specific prior written permission.
+//
+// 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 AND FITNESS FOR A
+// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+// OR 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.
+
+// --%: Gabriel Dos Reis.
+
+#include <open-axiom/storage>
+#include <open-axiom/FileMapping>
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+#  include <sys/stat.h>
+#endif
+#include <sys/types.h>
+#ifdef HAVE_FCNTL_H
+#  include <fcntl.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#  include <unistd.h>
+#endif
+#ifdef HAVE_SYS_MMAN_H
+#  include <sys/mman.h>
+#endif
+#ifdef OPENAXIOM_MS_WINDOWS_HOST
+#  include <windows.h>
+#endif
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+
+namespace OpenAxiom {
+   // ----------------
+   // -- SystemError --
+   // ----------------
+   SystemError::SystemError(const std::string& s) : text(s) { }
+
+   SystemError::~SystemError() { }
+
+   const std::string&
+   SystemError::message() const {
+      return text;
+   }
+
+   void
+   filesystem_error(const std::string& s) {
+      throw SystemError(s);
+   }
+
+   namespace Memory {
+      // Return storage page allocation unit in byte count.
+      size_t page_size() {
+#if defined(OPENAXIOM_MS_WINDOWS_HOST)
+         SYSTEM_INFO si = { };
+         GetSystemInfo(&si);
+         return si.dwPageSize;
+#elif defined(HAVE_UNISTD_H)
+         return sysconf(_SC_PAGESIZE);
+#else
+         // Well, we have to return a number.
+         return 4096;
+#endif         
+      }
+
+      // Subroutine of os_acquire_raw_memory.  Attempt to acquire
+      // storage from the host OS.  Return null on failure.
+      static inline Pointer
+      os_allocate_read_write_raw_memory(size_t nbytes) {
+#if defined(OPENAXIOM_MS_WINDOWS_HOST)
+         return VirtualAlloc(Pointer(), nbytes,
+                             MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
+#elif defined(HAVE_SYS_MMAN_H)
+         Pointer p = mmap(Pointer(), nbytes, PROT_READ | PROT_WRITE,
+                          MAP_PRIVATE | OPENAXIOM_MM_ANONYMOUS_MAP_FLAG,
+                          -1, 0);
+         return p == MAP_FAILED ? Pointer() : p;
+#else         
+         return malloc(byte_count);
+#endif         
+      }
+
+      Pointer
+      os_acquire_raw_memory(size_t nbytes) {
+         Pointer p = os_allocate_read_write_raw_memory(nbytes);
+         if (p == nullptr)
+            throw SystemError("cannot acquire more memory");
+         return memset(p, nbytes, 0);
+      }
+
+      void
+      os_release_raw_memory(Pointer p, size_t n) {
+#if defined(OPENAXIOM_MS_WINDOWS_HOST)
+         VirtualFree(p, 0, MEM_RELEASE);
+#elif defined(HAVE_SYS_MMAN_H)
+         munmap(p, n);
+#else
+         free(p);
+#endif            
+      }
+
+      // -------------
+      // -- Storage --
+      // -------------
+      struct Storage::Handle {
+         size_t extent;         // count of allocated bytes
+         void* start;           // beginning of usable address.
+      };
+
+      static inline Pointer
+      storage_end(Storage::Handle* h) {
+         return Storage::byte_address(h) + h->extent;
+      }
+
+      // Acquire storage chunk of at least `n' bytes.
+      // The result is a pointer to a storage object.  That object
+      // `result' is constructed such that `begin(result)' points
+      // to the next allocatable address.
+      template<typename T>
+      static T*
+      acquire_storage_with_header(size_t n) {
+         n = Storage::round_up(n, page_size());
+         T* h = static_cast<T*>(os_acquire_raw_memory(n));
+         h->extent = n;
+         h->start = h + 1;
+         return h;
+      }
+
+      void
+      Storage::release(Handle* h) {
+         os_release_raw_memory(h, h->extent);
+      }
+
+      Pointer
+      Storage::begin(Handle* h) {
+         return h->start;
+      }
+
+      // -------------------------
+      // -- SinglyLinkedStorage --
+      // -------------------------
+      struct OneWayLinkHeader : Storage::Handle {
+         Handle* previous;
+      };
+      
+      SinglyLinkedStorage::Handle*&
+      SinglyLinkedStorage::previous(Handle* h) {
+         return static_cast<OneWayLinkHeader*>(h)->previous;
+      }
+
+      // -------------------------
+      // -- DoublyLinkedStorage --
+      // -------------------------
+      struct TwoWayLinkHeader : Storage::Handle {
+         Handle* previous;
+         Handle* next;
+      };
+
+      static inline TwoWayLinkHeader*
+      two_way_link(Storage::Handle* h) {
+         return static_cast<TwoWayLinkHeader*>(h);
+      }
+
+      DoublyLinkedStorage::Handle*&
+      DoublyLinkedStorage::previous(Handle* h) {
+         return two_way_link(h)->previous;
+      }
+
+      DoublyLinkedStorage::Handle*&
+      DoublyLinkedStorage::next(Handle* h) {
+         return two_way_link(h)->next;
+      }
+
+      DoublyLinkedStorage::Handle*
+      DoublyLinkedStorage::acquire(size_t n, size_t a) {
+         // Add enough padding space for specified alignment.
+         const size_t overhead = round_up(sizeof (TwoWayLinkHeader), a);
+         TwoWayLinkHeader* h =
+            acquire_storage_with_header<TwoWayLinkHeader>(overhead + n);
+         h->start = byte_address (h) + overhead;
+         h->previous = nullptr;
+         h->next = nullptr;
+         return h;
+      }
+
+      // ------------------
+      // -- BlockStorage --
+      // ------------------
+      struct BlockHeader : OneWayLinkHeader {
+         Byte* available;
+      };
+
+      static inline BlockHeader*
+      block_header(BlockStorage::Handle* h) {
+         return static_cast<BlockHeader*>(h);
+      }
+
+      BlockStorage::Handle*
+      BlockStorage::acquire(size_t n, size_t a) {
+         const size_t overhead = round_up(sizeof (BlockHeader), a);
+         BlockHeader* h =
+            acquire_storage_with_header<BlockHeader>(overhead + n);
+         // Remember the next available address to allocate from.
+         h->available = byte_address(h) + overhead;
+         // That is also where the actual object storage starts.
+         h->start = h->available;
+         h->previous = nullptr;
+         return h;
+      }
+
+      Pointer
+      BlockStorage::next_address(Handle* h) {
+         return block_header(h)->available;
+      }
+
+      size_t
+      BlockStorage::room(Handle* h) {
+         return byte_address(storage_end(h)) - block_header(h)->available;
+      }
+
+      Pointer
+      BlockStorage::book(Handle* h, size_t n) {
+         BlockHeader* block = block_header(h);
+         void* const p = block->available;
+         block->available += n;
+         return p;
+      }
+      
+
+      // -----------------
+      // -- FileMapping --
+      // -----------------
+      FileMapping::FileMapping(std::string path)
+            : start(), extent() {
+#if defined(OPENAXIOM_MS_WINDOWS_HOST)
+         HANDLE file = CreateFile(path.c_str(), GENERIC_READ, 0, 0,
+                                  OPEN_EXISTING,
+                                  FILE_ATTRIBUTE_NORMAL, 0);
+         if (file == INVALID_HANDLE_VALUE)
+            filesystem_error("could not access file " + path);
+         HANDLE mapping = CreateFileMapping(file, 0, PAGE_READONLY, 0, 0, 0);
+         if (mapping == 0)
+            filesystem_error("could not map file " + path);
+         start = static_cast<Byte*>
+            (MapViewOfFile(mapping, FILE_MAP_READ, 0, 0, 0));
+         extent = GetFileSize(file, 0);
+         CloseHandle(mapping);
+         CloseHandle(file);
+#elif defined(HAVE_SYS_STAT_H) && defined(HAVE_SYS_MMAN_H) && defined(HAVE_FCNTL_H)
+         struct stat s;
+         errno = 0;
+         if (stat(path.c_str(), &s) < 0)
+            filesystem_error("could not access file " + path);
+         else if (!S_ISREG(s.st_mode))
+            filesystem_error(path + " is not a regular file");
+         int fd = open(path.c_str(), O_RDONLY);
+         if (fd < 0)
+            filesystem_error("could not open " + path);
+         start = static_cast<Byte*>
+            (mmap(Pointer(), s.st_size, PROT_READ, MAP_PRIVATE, fd, 0));
+         close(fd);
+         if (start == MAP_FAILED)
+            filesystem_error("could not map file " + path);
+         extent = s.st_size;
+#else
+#  error "Don't know how to map a file on this platform"         
+#endif  // OPENAXIOM_MS_WINDOWS_HOST
+      }
+
+      FileMapping::FileMapping(FileMapping&& f)
+            : start(f.start), extent(f.extent) {
+         f.start = nullptr;
+         f.extent = 0;
+      }
+
+      FileMapping::~FileMapping() {
+         if (start != nullptr) {
+#if defined(OPENAXIOM_MS_WINDOWS_HOST)
+            UnmapViewOfFile(start);
+#elif defined(HAVE_SYS_MMAN_H)
+            munmap(start, extent);
+#else
+#  error "Don't know how to unmap a file on this platform"
+#endif
+         }
+      }
+   }
+}