get rid of metadata struct

1 files changed, 20 insertions, 43 deletions

diff --git a/geoip/ip.lisp b/geoip/ip.lisp
index 7d0b3af..3e3790e 100644
--- a/geoip/ip.lisp
+++ b/geoip/ip.lisp
@@ -55,30 +55,6 @@
   (head-ptr)
   (data-offset 0 :read-only t :type fixnum))
 
-(defstruct maxmind-database-metadata
-  (node-count 0 :read-only t :type fixnum)
-  (record-size 0 :read-only t :type fixnum)
-  (ip-version 0 :read-only t :type fixnum)
-  (database-type nil :read-only t :type string)
-  (languages nil :read-only t :type list)
-  (binary-format-major-version 0 :read-only t :type fixnum)
-  (binary-format-minor-version 0 :read-only t :type fixnum)
-  (build-epoch 0 :read-only t :type fixnum)
-  (description nil :read-only t :type list))
-
-
-(defun make-metadata (data)
-  (make-maxmind-database-metadata
-   :binary-format-major-version (get-in data :binary-format-major-version)
-   :binary-format-minor-version (get-in data :binary-format-minor-version)
-   :build-epoch (get-in data :build-epoch)
-   :database-type (get-in data :database-type)
-   :description (get-in data :description)
-   :ip-version (get-in data :ip-version)
-   :languages (get-in data :languages)
-   :node-count (get-in data :node-count)
-   :record-size (get-in data :record-size)))
-
 (defun metadata-marker-p (ptr offset)
   (loop for i below #.(length +metadata-marker+)
         always (eql (mem-ref ptr :uchar (+ i offset))
@@ -90,12 +66,12 @@
         when (metadata-marker-p ptr offset)
           return (+ offset #.(length +metadata-marker+))))
 
-(defun read-db-char (reader)
+(defun mread-char (reader)
   (with-slots (db-ptr) reader
     (prog1 (mem-ref db-ptr :uchar)
       (incf-pointer db-ptr))))
 
-(defun bytes-from-foreign (reader data-length)
+(defun mread-bytes (reader data-length)
   (let ((bytes (make-array data-length :element-type '(unsigned-byte 8))))
     (with-slots (db-ptr) reader
       (foreign-array-to-lisp db-ptr
@@ -127,17 +103,17 @@
         uval)))
 
 (defun mread-datafield-metadata (reader)
-  (let* ((control-byte (read-db-char reader))
+  (let* ((control-byte (mread-char reader))
          (type (ldb (byte 3 5) control-byte))
          (length (ldb (byte 5 0) control-byte)))
     (when (zerop type)
-      (setf type (+ 7 (read-db-char reader))))
+      (setf type (+ 7 (mread-char reader))))
     (list type
           (cond
             ((or (= type 1) (< length 29))
              length)
             ((= length 29)
-             (+ 29 (read-db-char reader)))
+             (+ 29 (mread-char reader)))
             ((= length 30)
              (+ 285 (mread-unsigned reader 2)))
             ((= length 31)
@@ -158,7 +134,7 @@
   (let ((size-bits (ldb (byte 2 3) length))
         (value-bits (ldb (byte 3 0) length)))
     (ecase size-bits
-      (0 (+ (ash value-bits 8) (read-db-char reader)))
+      (0 (+ (ash value-bits 8) (mread-char reader)))
       (1 (+ (ash value-bits 16) (mread-unsigned reader 2) 2048))
       (2 (+ (ash value-bits 24) (mread-unsigned reader 3) 526336))
       (3 (mread-unsigned reader 4)))))
@@ -177,7 +153,7 @@
       (1 (mread-pointer reader length))
       (2 (mread-uft8 reader length))
       (3 (ieee-floats:decode-float64 (mread-unsigned reader 8)))
-      (4 (bytes-from-foreign reader length))
+      (4 (mread-bytes reader length))
       ((5 6 9 10) (mread-unsigned reader length))
       (7 (mread-map reader length))
       (8 (mread-int32 reader length))
@@ -197,7 +173,7 @@
           (mem-uint (inc-pointer ptr (+ node-offset (* bit record-bytes))) record-bytes)
           ;; Complex case: records share a byte
           (let* ((base-value (mem-uint (inc-pointer ptr (+ node-offset (* bit (1+ record-bytes)))) record-bytes))
-                 (shared-byte (mem-ref (inc-pointer ptr (+ node-offset record-bytes)) :uchar))
+                 (shared-byte (mem-ref ptr :uchar (+ node-offset record-bytes)))
                  (high-bits (if (zerop bit) (ash shared-byte -4) (logand shared-byte #xf))))
             (+ (ash high-bits (* record-bytes 8)) base-value))))))
 
@@ -234,17 +210,18 @@
 (defun mmap->mmdb (file ptr fd size)
   (let* ((metadata-start (find-metadata-start ptr size))
          (db-reader (make-db-reader :db-ptr (inc-pointer ptr metadata-start)))
-         (metadata (make-metadata (mread-data db-reader))))
-    (with-slots (record-size node-count ip-version) metadata
-      (make-maxmind-database
-       :filename file
-       :ptr ptr :fd fd :size size
-       :metadata metadata
-       :node-count node-count
-       :record-size record-size
-       :ip-version ip-version
-       ;; :data-offset (+ 16 (* (/ (* 2 record-size) 8) node-count))
-       :data-offset (+ 16 (/ (* record-size node-count) 4))))))
+         (metadata (mread-data db-reader))
+         (node-count (get-in metadata :node-count))
+         (record-size (get-in metadata :record-size)))
+    (make-maxmind-database
+     :filename file
+     :ptr ptr :fd fd :size size
+     :metadata metadata
+     :node-count node-count
+     :record-size record-size
+     :ip-version (get-in metadata :ip-version)
+     ;; :data-offset (+ 16 (* (/ (* 2 record-size) 8) node-count))
+     :data-offset (+ 16 (/ (* record-size node-count) 4)))))
 
 (defun make-mmdb (file)
   (multiple-value-bind (ptr fd size) (mmap:mmap file)