From f850cd8117d0ff998ce5a2a0af2943c7abdd287d Mon Sep 17 00:00:00 2001
From: ueno <ueno>
Date: Fri, 28 Apr 2006 06:59:43 +0000
Subject: [PATCH] * epg.el: Typecheck when access to object's slots.

---
 ChangeLog |    4 +
 epg.el    |  254 ++++++++++++++++++++++++++++++++++++++++++++-----------------
 2 files changed, 189 insertions(+), 69 deletions(-)

diff --git a/ChangeLog b/ChangeLog
index e35d288..c3015b1 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,7 @@
+2006-04-28  Daiki Ueno  <ueno@unixuser.org>
+
+	* epg.el: Added typecheck to accessors to objects.
+
 2006-04-26  Daiki Ueno  <ueno@unixuser.org>
 
 	* epg.el (epg-status-GET_HIDDEN): Pass epg-context as the first
diff --git a/epg.el b/epg.el
index fb1f183..88dd489 100644
--- a/epg.el
+++ b/epg.el
@@ -145,274 +145,390 @@
 
 (defun epg-make-data-from-file (file)
   "Make a data object from FILE."
-  (vector file nil))
+  (cons 'epg-data (vector file nil)))
 
 (defun epg-make-data-from-string (string)
   "Make a data object from STRING."
-  (vector nil string))
+  (cons 'epg-data (vector nil string)))
 
 (defun epg-data-file (data)
   "Return the file of DATA."
-  (aref data 0))
+  (unless (eq (car data) 'epg-data)
+    (signal 'wrong-type-argument (list 'epg-data-p data)))
+  (aref (cdr data) 0))
 
 (defun epg-data-string (data)
   "Return the string of DATA."
-  (aref data 1))
+  (unless (eq (car data) 'epg-data)
+    (signal 'wrong-type-argument (list 'epg-data-p data)))
+  (aref (cdr data) 1))
 
 (defun epg-make-context (&optional protocol armor textmode include-certs
 				   cipher-algorithm digest-algorithm
 				   compress-algorithm)
   "Return a context object."
-  (vector protocol armor textmode include-certs
-	  cipher-algorithm digest-algorithm compress-algorithm
-	  #'epg-passphrase-callback-function
-	  #'epg-progress-callback-function
-	  nil nil nil nil))
+  (cons 'epg-context
+	(vector protocol armor textmode include-certs
+		cipher-algorithm digest-algorithm compress-algorithm
+		#'epg-passphrase-callback-function
+		#'epg-progress-callback-function
+		nil nil nil nil)))
 
 (defun epg-context-protocol (context)
   "Return the protocol used within CONTEXT."
-  (aref context 0))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 0))
 
 (defun epg-context-armor (context)
   "Return t if the output shouled be ASCII armored in CONTEXT."
-  (aref context 1))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 1))
 
 (defun epg-context-textmode (context)
   "Return t if canonical text mode should be used in CONTEXT."
-  (aref context 2))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 2))
 
 (defun epg-context-include-certs (context)
   "Return how many certificates should be included in an S/MIME signed
 message."
-  (aref context 3))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 3))
 
 (defun epg-context-cipher-algorithm (context)
   "Return the cipher algorithm in CONTEXT."
-  (aref context 4))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 4))
 
 (defun epg-context-digest-algorithm (context)
   "Return the digest algorithm in CONTEXT."
-  (aref context 5))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 5))
 
 (defun epg-context-compress-algorithm (context)
   "Return the compress algorithm in CONTEXT."
-  (aref context 6))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 6))
 
 (defun epg-context-passphrase-callback (context)
   "Return the function used to query passphrase."
-  (aref context 7))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 7))
 
 (defun epg-context-progress-callback (context)
   "Return the function which handles progress update."
-  (aref context 8))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 8))
 
 (defun epg-context-signers (context)
   "Return the list of key-id for singning."
-  (aref context 9))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 9))
 
 (defun epg-context-process (context)
   "Return the process object of `epg-gpg-program'.
 This function is for internal use only."
-  (aref context 10))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 10))
 
 (defun epg-context-output-file (context)
   "Return the output file of `epg-gpg-program'.
 This function is for internal use only."
-  (aref context 11))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 11))
 
 (defun epg-context-result (context)
   "Return the result of the previous cryptographic operation."
-  (aref context 12))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 12))
 
 (defun epg-context-set-protocol (context protocol)
   "Set the protocol used within CONTEXT."
-  (aset context 0 protocol))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 0 protocol))
 
 (defun epg-context-set-armor (context armor)
   "Specify if the output shouled be ASCII armored in CONTEXT."
-  (aset context 1 armor))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 1 armor))
 
 (defun epg-context-set-textmode (context textmode)
   "Specify if canonical text mode should be used in CONTEXT."
-  (aset context 2 textmode))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 2 textmode))
 
 (defun epg-context-set-include-certs (context include-certs)
  "Set how many certificates should be included in an S/MIME signed message."
-  (aset context 3 include-certs))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 3 include-certs))
 
 (defun epg-context-set-cipher-algorithm (context cipher-algorithm)
  "Set the cipher algorithm in CONTEXT."
-  (aset context 4 cipher-algorithm))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 4 cipher-algorithm))
 
 (defun epg-context-set-digest-algorithm (context digest-algorithm)
  "Set the digest algorithm in CONTEXT."
-  (aset context 5 digest-algorithm))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 5 digest-algorithm))
 
 (defun epg-context-set-compress-algorithm (context compress-algorithm)
  "Set the compress algorithm in CONTEXT."
-  (aset context 6 compress-algorithm))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 6 compress-algorithm))
 
 (defun epg-context-set-passphrase-callback (context
 						 passphrase-callback)
   "Set the function used to query passphrase."
-  (aset context 7 passphrase-callback))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 7 passphrase-callback))
 
 (defun epg-context-set-progress-callback (context progress-callback)
   "Set the function which handles progress update."
-  (aset context 8 progress-callback))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 8 progress-callback))
 
 (defun epg-context-set-signers (context signers)
  "Set the list of key-id for singning."
-  (aset context 9 signers))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 9 signers))
 
 (defun epg-context-set-process (context process)
   "Set the process object of `epg-gpg-program'.
 This function is for internal use only."
-  (aset context 10 process))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 10 process))
 
 (defun epg-context-set-output-file (context output-file)
   "Set the output file of `epg-gpg-program'.
 This function is for internal use only."
-  (aset context 11 output-file))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 11 output-file))
 
 (defun epg-context-set-result (context result)
   "Set the result of the previous cryptographic operation."
-  (aset context 12 result))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 12 result))
 
 (defun epg-make-signature (status key-id user-id)
   "Return a signature object."
-  (vector status key-id user-id nil nil))
+  (cons 'epg-signature (vector status key-id user-id nil nil)))
 
 (defun epg-signature-status (signature)
   "Return the status code of SIGNATURE."
-  (aref signature 0))
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aref (cdr signature) 0))
 
 (defun epg-signature-key-id (signature)
   "Return the key-id of SIGNATURE."
-  (aref signature 1))
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aref (cdr signature) 1))
 
 (defun epg-signature-user-id (signature)
   "Return the user-id of SIGNATURE."
-  (aref signature 2))
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aref (cdr signature) 2))
   
 (defun epg-signature-validity (signature)
   "Return the validity of SIGNATURE."
-  (aref signature 3))
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aref (cdr signature) 3))
 
 (defun epg-signature-fingerprint (signature)
   "Return the fingerprint of SIGNATURE."
-  (aref signature 4))
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aref (cdr signature) 4))
 
 (defun epg-signature-set-status (signature status)
  "Set the status code of SIGNATURE."
-  (aset signature 0 status))
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aset (cdr signature) 0 status))
 
 (defun epg-signature-set-key-id (signature key-id)
  "Set the key-id of SIGNATURE."
-  (aset signature 1 key-id))
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aset (cdr signature) 1 key-id))
 
 (defun epg-signature-set-user-id (signature user-id)
  "Set the user-id of SIGNATURE."
-  (aset signature 2 user-id))
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aset (cdr signature) 2 user-id))
   
 (defun epg-signature-set-validity (signature validity)
  "Set the validity of SIGNATURE."
-  (aset signature 3 validity))
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aset (cdr signature) 3 validity))
 
 (defun epg-signature-set-fingerprint (signature fingerprint)
  "Set the fingerprint of SIGNATURE."
-  (aset signature 4 fingerprint))
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aset (cdr signature) 4 fingerprint))
 
 (defun epg-make-key (owner-trust)
   "Return a key object."
-  (vector owner-trust nil nil))
+  (cons 'epg-key (vector owner-trust nil nil)))
 
 (defun epg-key-owner-trust (key)
   "Return the owner trust of KEY."
-  (aref key 0))
+  (unless (eq (car key) 'epg-key)
+    (signal 'wrong-type-argument (list 'epg-key-p key)))
+  (aref (cdr key) 0))
 
 (defun epg-key-sub-key-list (key)
   "Return the sub key list of KEY."
-  (aref key 1))
+  (unless (eq (car key) 'epg-key)
+    (signal 'wrong-type-argument (list 'epg-key-p key)))
+  (aref (cdr key) 1))
 
 (defun epg-key-user-id-list (key)
   "Return the user ID list of KEY."
-  (aref key 2))
+  (unless (eq (car key) 'epg-key)
+    (signal 'wrong-type-argument (list 'epg-key-p key)))
+  (aref (cdr key) 2))
 
 (defun epg-key-set-sub-key-list (key sub-key-list)
   "Set the sub key list of KEY."
-  (aset key 1 sub-key-list))
+  (unless (eq (car key) 'epg-key)
+    (signal 'wrong-type-argument (list 'epg-key-p key)))
+  (aset (cdr key) 1 sub-key-list))
 
 (defun epg-key-set-user-id-list (key user-id-list)
   "Set the user ID list of KEY."
-  (aset key 2 user-id-list))
+  (unless (eq (car key) 'epg-key)
+    (signal 'wrong-type-argument (list 'epg-key-p key)))
+  (aset (cdr key) 2 user-id-list))
 
 (defun epg-make-sub-key (validity capability secret algorithm length id
 				  creation-time expiration-time)
   "Return a sub key object."
-  (vector validity capability secret algorithm length id creation-time
-	  expiration-time nil))
+  (cons 'epg-sub-key
+	(vector validity capability secret algorithm length id creation-time
+		expiration-time nil)))
 
 (defun epg-sub-key-validity (sub-key)
   "Return the validity of SUB-KEY."
-  (aref sub-key 0))
+  (unless (eq (car sub-key) 'epg-sub-key)
+    (signal 'wrong-type-argument (list 'epg-sub-key-p sub-key)))
+  (aref (cdr sub-key) 0))
 
 (defun epg-sub-key-capability (sub-key)
   "Return the capability of SUB-KEY."
-  (aref sub-key 1))
+  (unless (eq (car sub-key) 'epg-sub-key)
+    (signal 'wrong-type-argument (list 'epg-sub-key-p sub-key)))
+  (aref (cdr sub-key) 1))
 
 (defun epg-sub-key-secret (sub-key)
   "Return non-nil if SUB-KEY is a secret key."
-  (aref sub-key 2))
+  (unless (eq (car sub-key) 'epg-sub-key)
+    (signal 'wrong-type-argument (list 'epg-sub-key-p sub-key)))
+  (aref (cdr sub-key) 2))
 
 (defun epg-sub-key-algorithm (sub-key)
   "Return the algorithm of SUB-KEY."
-  (aref sub-key 3))
+  (unless (eq (car sub-key) 'epg-sub-key)
+    (signal 'wrong-type-argument (list 'epg-sub-key-p sub-key)))
+  (aref (cdr sub-key) 3))
 
 (defun epg-sub-key-length (sub-key)
   "Return the length of SUB-KEY."
-  (aref sub-key 4))
+  (unless (eq (car sub-key) 'epg-sub-key)
+    (signal 'wrong-type-argument (list 'epg-sub-key-p sub-key)))
+  (aref (cdr sub-key) 4))
 
 (defun epg-sub-key-id (sub-key)
   "Return the ID of SUB-KEY."
-  (aref sub-key 5))
+  (unless (eq (car sub-key) 'epg-sub-key)
+    (signal 'wrong-type-argument (list 'epg-sub-key-p sub-key)))
+  (aref (cdr sub-key) 5))
 
 (defun epg-sub-key-creation-time (sub-key)
   "Return the creation time of SUB-KEY."
-  (aref sub-key 6))
+  (unless (eq (car sub-key) 'epg-sub-key)
+    (signal 'wrong-type-argument (list 'epg-sub-key-p sub-key)))
+  (aref (cdr sub-key) 6))
 
 (defun epg-sub-key-expiration-time (sub-key)
   "Return the expiration time of SUB-KEY."
-  (aref sub-key 7))
+  (unless (eq (car sub-key) 'epg-sub-key)
+    (signal 'wrong-type-argument (list 'epg-sub-key-p sub-key)))
+  (aref (cdr sub-key) 7))
 
 (defun epg-sub-key-fingerprint (sub-key)
   "Return the fingerprint of SUB-KEY."
-  (aref sub-key 8))
+  (unless (eq (car sub-key) 'epg-sub-key)
+    (signal 'wrong-type-argument (list 'epg-sub-key-p sub-key)))
+  (aref (cdr sub-key) 8))
 
 (defun epg-sub-key-set-fingerprint (sub-key fingerprint)
   "Set the fingerprint of SUB-KEY.
 This function is for internal use only."
-  (aset sub-key 8 fingerprint))
+  (unless (eq (car sub-key) 'epg-sub-key)
+    (signal 'wrong-type-argument (list 'epg-sub-key-p sub-key)))
+  (aset (cdr sub-key) 8 fingerprint))
 
 (defun epg-make-user-id (validity name)
   "Return a user ID object."
-  (vector validity name nil))
+  (cons 'epg-user-id (vector validity name nil)))
 
 (defun epg-user-id-validity (user-id)
   "Return the validity of USER-ID."
-  (aref user-id 0))
+  (unless (eq (car user-id) 'epg-user-id)
+    (signal 'wrong-type-argument (list 'epg-user-id-p user-id)))
+  (aref (cdr user-id) 0))
 
 (defun epg-user-id-name (user-id)
   "Return the name of USER-ID."
-  (aref user-id 1))
+  (unless (eq (car user-id) 'epg-user-id)
+    (signal 'wrong-type-argument (list 'epg-user-id-p user-id)))
+  (aref (cdr user-id) 1))
 
 (defun epg-user-id-signature-list (user-id)
   "Return the signature list of USER-ID."
-  (aref user-id 2))
+  (unless (eq (car user-id) 'epg-user-id)
+    (signal 'wrong-type-argument (list 'epg-user-id-p user-id)))
+  (aref (cdr user-id) 2))
 
 (defun epg-user-id-set-signature-list (user-id signature-list)
   "Set the signature list of USER-ID."
-  (aset user-id 2 signature-list))
+  (unless (eq (car user-id) 'epg-user-id)
+    (signal 'wrong-type-argument (list 'epg-user-id-p user-id)))
+  (aset (cdr user-id) 2 signature-list))
 
 (defun epg-context-result-for (context name)
   (cdr (assq name (epg-context-result context))))
-- 
1.7.10.4