[cl-net-snmp-cvs] r38 - in trunk: . asn.1

16 Sep 2007

Author: ctian
Date: Sun Sep 16 04:11:39 2007
New Revision: 38
Added:
   trunk/asn.1/mib-parse.lisp
Modified:
   trunk/asn.1/asn.1-domain.lisp
   trunk/asn.1/asn.1.tab
   trunk/asn.1/asn.1.zb
   trunk/asn.1/mib.lisp
   trunk/asn.1/stream-test.lisp
   trunk/net-snmp.asd
Log:
Comment Local Changes
Modified: trunk/asn.1/asn.1-domain.lisp
==============================================================================

--- trunk/asn.1/asn.1-domain.lisp	(original)
+++ trunk/asn.1/asn.1-domain.lisp	Sun Sep 16 04:11:39 2007
@@ -4,351 +4,304 @@
 (REQUIRE "zebu-package")
 (USE-PACKAGE "ZEBU")
-(DEFSTRUCT (OBJ-ID-COMPONENTS-LIST
-            (:INCLUDE KB-DOMAIN)
-            (:PRINT-FUNCTION
-             (LAMBDA
-                 (ITEM STREAM LEVEL &AUX
-                  (%R (OBJ-ID-COMPONENTS-LIST--LIST ITEM)))
-               (DECLARE (IGNORE LEVEL))
-               (FORMAT STREAM
-                       "~a"
-                       (LET ((OBJ-ID-COMPONENTS+ %R))
-                         (IF (NULL OBJ-ID-COMPONENTS+)
-                             ""
-                           (ZEBU::KB-SEQUENCE-PRINT OBJ-ID-COMPONENTS+
-                                                    NIL
-                                                    NIL)))))))
+(DEFSTRUCT
+    (OBJ-ID-COMPONENTS-LIST (:INCLUDE KB-DOMAIN)
+     (:PRINT-FUNCTION
+      (LAMBDA (ITEM STREAM LEVEL &AUX (%R (OBJ-ID-COMPONENTS-LIST--LIST ITEM)))
+        (DECLARE (IGNORE LEVEL))
+        (FORMAT STREAM "~a"
+                (LET ((OBJ-ID-COMPONENTS+ %R))
+                  (IF (NULL OBJ-ID-COMPONENTS+) ""
+                      (ZEBU::KB-SEQUENCE-PRINT OBJ-ID-COMPONENTS+ NIL
+                                               NIL)))))))
   (-LIST NIL :TYPE (OR NULL KB-SEQUENCE)))
-(DEFSTRUCT (ASSIGNMENT-LIST
-            (:INCLUDE KB-DOMAIN)
-            (:PRINT-FUNCTION
-             (LAMBDA
-                 (ITEM STREAM LEVEL &AUX
-                  (%R (ASSIGNMENT-LIST--LIST ITEM)))
-               (DECLARE (IGNORE LEVEL))
-               (FORMAT STREAM
-                       "~a"
-                       (LET ((ASSIGNMENT+ %R))
-                         (IF (NULL ASSIGNMENT+)
-                             ""
-                           (ZEBU::KB-SEQUENCE-PRINT ASSIGNMENT+
-                                                    NIL
-                                                    NIL)))))))
-  (-LIST NIL :TYPE (OR NULL KB-SEQUENCE)))
-
-(DEFSTRUCT (ASSIGNMENT
-            (:INCLUDE KB-DOMAIN)
-            (:PRINT-FUNCTION
-             (LAMBDA
-                 (ITEM STREAM LEVEL &AUX (%R (ASSIGNMENT--VALUE ITEM)))
-               (DECLARE (IGNORE LEVEL))
-               (FORMAT STREAM
-                       "~a"
-                       (LET ((SPECIAL-ASSIGNMENT %R))
-                         (ZEBU::KB-SEQUENCE-PRINT SPECIAL-ASSIGNMENT
-                                                  NIL
-                                                  NIL))))))
+(DEFSTRUCT
+    (ASSIGNMENT (:INCLUDE KB-DOMAIN)
+     (:PRINT-FUNCTION
+      (LAMBDA (ITEM STREAM LEVEL &AUX (%R (ASSIGNMENT--VALUE ITEM)))
+        (DECLARE (IGNORE LEVEL))
+        (FORMAT STREAM "~a"
+                (LET ((SPECIAL-ASSIGNMENT %R))
+                  (ZEBU::KB-SEQUENCE-PRINT SPECIAL-ASSIGNMENT NIL NIL))))))
   -TYPE
   -VALUE)
-(DEFSTRUCT (MODULE-BODY
-            (:INCLUDE KB-DOMAIN)
-            (:PRINT-FUNCTION
-             (LAMBDA
-                 (ITEM STREAM LEVEL &AUX (%R ITEM)
-                  (%S (MODULE-BODY--ASSIGNMENT-LIST ITEM)))
-               (DECLARE (IGNORE LEVEL))
-               (FORMAT STREAM
-                       "~a ~a ~a"
-                       (LET ((EXPORTS NIL))
-                         (ZEBU::KB-SEQUENCE-PRINT EXPORTS NIL NIL))
-                       NIL
-                       %S))))
+(DEFSTRUCT
+    (ASSIGNMENT-LIST (:INCLUDE KB-DOMAIN)
+     (:PRINT-FUNCTION
+      (LAMBDA (ITEM STREAM LEVEL &AUX (%R (ASSIGNMENT-LIST--LIST ITEM)))
+        (DECLARE (IGNORE LEVEL))
+        (FORMAT STREAM "~a"
+                (LET ((ASSIGNMENT+ %R))
+                  (IF (NULL ASSIGNMENT+) ""
+                      (ZEBU::KB-SEQUENCE-PRINT ASSIGNMENT+ NIL NIL)))))))
+  (-LIST NIL :TYPE (OR NULL KB-SEQUENCE)))
+
+(DEFSTRUCT
+    (MODULE-BODY (:INCLUDE KB-DOMAIN)
+     (:PRINT-FUNCTION
+      (LAMBDA
+          (ITEM STREAM LEVEL
+           &AUX (%R ITEM) (%S (MODULE-BODY--ASSIGNMENT-LIST ITEM)))
+        (DECLARE (IGNORE LEVEL))
+        (FORMAT STREAM "~a ~a ~a"
+                (LET ((EXPORTS NIL))
+                  (ZEBU::KB-SEQUENCE-PRINT EXPORTS NIL NIL))
+                NIL %S))))
   -ASSIGNMENT-LIST)
-(DEFSTRUCT (MODULE-DEFINITION
-            (:INCLUDE KB-DOMAIN)
-            (:PRINT-FUNCTION
-             (LAMBDA
-                 (ITEM STREAM LEVEL &AUX
-                  (%R (MODULE-DEFINITION--IDENTIFIER ITEM))
-                  (%S (MODULE-DEFINITION--BODY ITEM)))
-               (DECLARE (IGNORE LEVEL))
-               (FORMAT STREAM "~a DEFINITIONS::=BEGIN ~a END" %R %S))))
+(DEFSTRUCT
+    (MODULE-DEFINITION (:INCLUDE KB-DOMAIN)
+     (:PRINT-FUNCTION
+      (LAMBDA
+          (ITEM STREAM LEVEL
+           &AUX (%R (MODULE-DEFINITION--IDENTIFIER ITEM))
+           (%S (MODULE-DEFINITION--BODY ITEM)))
+        (DECLARE (IGNORE LEVEL))
+        (FORMAT STREAM "~a DEFINITIONS::=BEGIN ~a END" %R %S))))
   -IDENTIFIER
   -BODY)
-(DEFUN SYMBOL+,1$234 (SYMBOL) (MAKE-KB-SEQUENCE :FIRST SYMBOL))
+(DEFUN |SYMBOL+,1$18| (SYMBOL) (MAKE-KB-SEQUENCE :FIRST SYMBOL))
-(DEFUN SYMBOL+,1$235 (SYMBOL DUMMY SYMBOL+,1$)
+(DEFUN |SYMBOL+,1$19| (SYMBOL DUMMY |SYMBOL+,1$|)
   (DECLARE (IGNORE DUMMY))
-  (MAKE-KB-SEQUENCE :FIRST SYMBOL :REST SYMBOL+,1$))
+  (MAKE-KB-SEQUENCE :FIRST SYMBOL :REST |SYMBOL+,1$|))
-(DEFUN ASSIGNMENT+236 (ASSIGNMENT) (MAKE-KB-SEQUENCE :FIRST ASSIGNMENT))
+(DEFUN ASSIGNMENT+20 (ASSIGNMENT) (MAKE-KB-SEQUENCE :FIRST ASSIGNMENT))
-(DEFUN ASSIGNMENT+237 (ASSIGNMENT ASSIGNMENT+)
+(DEFUN ASSIGNMENT+21 (ASSIGNMENT ASSIGNMENT+)
   (MAKE-KB-SEQUENCE :FIRST ASSIGNMENT :REST ASSIGNMENT+))
-(DEFUN OBJ-ID-COMPONENTS+238 (OBJ-ID-COMPONENTS)
+(DEFUN OBJ-ID-COMPONENTS+22 (OBJ-ID-COMPONENTS)
   (MAKE-KB-SEQUENCE :FIRST OBJ-ID-COMPONENTS))
-(DEFUN OBJ-ID-COMPONENTS+239 (OBJ-ID-COMPONENTS OBJ-ID-COMPONENTS+)
+(DEFUN OBJ-ID-COMPONENTS+23 (OBJ-ID-COMPONENTS OBJ-ID-COMPONENTS+)
   (MAKE-KB-SEQUENCE :FIRST OBJ-ID-COMPONENTS :REST OBJ-ID-COMPONENTS+))
-(DEFUN GARBAGE+240 (GARBAGE) (MAKE-KB-SEQUENCE :FIRST GARBAGE))
+(DEFUN GARBAGE+24 (GARBAGE) (MAKE-KB-SEQUENCE :FIRST GARBAGE))
-(DEFUN GARBAGE+241 (GARBAGE GARBAGE+)
+(DEFUN GARBAGE+25 (GARBAGE GARBAGE+)
   (MAKE-KB-SEQUENCE :FIRST GARBAGE :REST GARBAGE+))
-(DEFUN OBJ-ID-COMPONENTS-LIST242 (OBJ-ID-COMPONENTS+)
+(DEFUN OBJ-ID-COMPONENTS-LIST26 (OBJ-ID-COMPONENTS+)
   (MAKE-OBJ-ID-COMPONENTS-LIST :-LIST OBJ-ID-COMPONENTS+))
-(DEFUN ASSIGNMENT243 (SPECIAL-ASSIGNMENT)
+(DEFUN ASSIGNMENT27 (SPECIAL-ASSIGNMENT)
   (MAKE-ASSIGNMENT :-TYPE :SPECIAL :-VALUE SPECIAL-ASSIGNMENT))
-(DEFUN ASSIGNMENT244 (TYPE-ASSIGNMENT)
+(DEFUN ASSIGNMENT28 (TYPE-ASSIGNMENT)
   (MAKE-ASSIGNMENT :-TYPE :TYPE :-VALUE TYPE-ASSIGNMENT))
-(DEFUN ASSIGNMENT245 (VALUE-ASSIGNMENT)
+(DEFUN ASSIGNMENT29 (VALUE-ASSIGNMENT)
   (MAKE-ASSIGNMENT :-TYPE :VALUE :-VALUE VALUE-ASSIGNMENT))
-(DEFUN ASSIGNMENT-LIST246 (ASSIGNMENT+)
+(DEFUN ASSIGNMENT-LIST30 (ASSIGNMENT+)
   (MAKE-ASSIGNMENT-LIST :-LIST ASSIGNMENT+))
-(DEFUN MODULE-BODY247 (EXPORTS IMPORTS ASSIGNMENT-LIST)
+(DEFUN MODULE-BODY31 (EXPORTS IMPORTS ASSIGNMENT-LIST)
   (MAKE-MODULE-BODY :-ASSIGNMENT-LIST ASSIGNMENT-LIST))
-(DEFUN MODULE-DEFINITION248
+(DEFUN MODULE-DEFINITION32
        (MODULE-IDENTIFIER DUMMY DUMMY1 DUMMY2 MODULE-BODY DUMMY3)
   (DECLARE (IGNORE DUMMY3 DUMMY2 DUMMY1 DUMMY))
-  (MAKE-MODULE-DEFINITION :-IDENTIFIER
-                          MODULE-IDENTIFIER
-                          :-BODY
-                          MODULE-BODY))
+  (MAKE-MODULE-DEFINITION :-IDENTIFIER MODULE-IDENTIFIER :-BODY MODULE-BODY))
(EVAL-WHEN (COMPILE)
   (UNLESS (MEMBER "zebu-regex" *MODULES* :TEST #'EQUAL)
     (WARN "Load the Zebu Compiler!")))
 (DECLAIM (SPECIAL ZEBU::*REGEX-GROUPS* ZEBU::*REGEX-GROUPINGS*))
-(DEFUN A-NUMBER
-       (STRING &OPTIONAL (ZEBU::START 0) (ZEBU::END (LENGTH STRING)))
-  (WHEN (PROGN
-          (SETF ZEBU::*REGEX-GROUPINGS* 1)
-          (BLOCK ZEBU::FINAL-RETURN
-            (BLOCK ZEBU::COMPARE
-              (LET ((ZEBU::INDEX ZEBU::START) (LENGTH ZEBU::END))
-                (SETF (SVREF ZEBU::*REGEX-GROUPS* 0)
-                      (LIST ZEBU::INDEX NIL))
-                (LET ((ZEBU::OINDEX ZEBU::INDEX))
-                  (BLOCK ZEBU::COMPARE
-                    (DO ()
-                        (NIL)
-                      (LET ((ZEBU::RANGE
-                             #*0000000000000000000000000000000000000000000000001111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
-                        (IF (>= ZEBU::INDEX LENGTH)
-                            (RETURN-FROM ZEBU::COMPARE NIL))
-                        (IF (= 1
-                               (SBIT
-                                ZEBU::RANGE
-                                (CHAR-CODE (CHAR STRING ZEBU::INDEX))))
-                            (INCF ZEBU::INDEX)
-                          (RETURN-FROM ZEBU::COMPARE NIL)))))
-                  (DO ((ZEBU::START ZEBU::INDEX (1- ZEBU::START)))
-                      ((< ZEBU::START ZEBU::OINDEX) NIL)
-                    (LET ((ZEBU::INDEX ZEBU::START))
-                      (BLOCK ZEBU::COMPARE
-                        (LET ((ZEBU::RANGE
-                               #*0000000000000000000000000000000000000000000000001111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
-                          (IF (>= ZEBU::INDEX LENGTH)
-                              (RETURN-FROM ZEBU::COMPARE NIL))
-                          (IF (= 1
-                                 (SBIT
-                                  ZEBU::RANGE
-                                  (CHAR-CODE
-                                   (CHAR STRING ZEBU::INDEX))))
-                              (INCF ZEBU::INDEX)
-                            (RETURN-FROM ZEBU::COMPARE NIL)))
-                        (SETF (CADR (SVREF ZEBU::*REGEX-GROUPS* 0))
-                              ZEBU::INDEX)
-                        (RETURN-FROM ZEBU::FINAL-RETURN T)))))))))
+(DEFUN A-NUMBER (STRING &OPTIONAL (ZEBU::START 0) (ZEBU::END (LENGTH STRING)))
+  (WHEN
+      (PROGN
+       (SETF ZEBU::*REGEX-GROUPINGS* 1)
+       (BLOCK ZEBU::FINAL-RETURN
+         (BLOCK ZEBU::COMPARE
+           (LET ((ZEBU::INDEX ZEBU::START) (LENGTH ZEBU::END))
+             (SETF (SVREF ZEBU::*REGEX-GROUPS* 0) (LIST ZEBU::INDEX NIL))
+             (LET ((ZEBU::OINDEX ZEBU::INDEX))
+               (BLOCK ZEBU::COMPARE
+                 (DO ()
+                     (NIL)
+                   (LET ((ZEBU::RANGE
+                          #*0000000000000000000000000000000000000000000000001111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
+                     (IF (>= ZEBU::INDEX LENGTH)
+                         (RETURN-FROM ZEBU::COMPARE NIL))
+                     (IF
+                      (= 1
+                         (SBIT ZEBU::RANGE
+                               (CHAR-CODE (CHAR STRING ZEBU::INDEX))))
+                      (INCF ZEBU::INDEX) (RETURN-FROM ZEBU::COMPARE NIL)))))
+               (DO ((ZEBU::START ZEBU::INDEX (1- ZEBU::START)))
+                   ((< ZEBU::START ZEBU::OINDEX) NIL)
+                 (LET ((ZEBU::INDEX ZEBU::START))
+                   (BLOCK ZEBU::COMPARE
+                     (LET ((ZEBU::RANGE
+                            #*0000000000000000000000000000000000000000000000001111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
+                       (IF (>= ZEBU::INDEX LENGTH)
+                           (RETURN-FROM ZEBU::COMPARE NIL))
+                       (IF
+                        (= 1
+                           (SBIT ZEBU::RANGE
+                                 (CHAR-CODE (CHAR STRING ZEBU::INDEX))))
+                        (INCF ZEBU::INDEX) (RETURN-FROM ZEBU::COMPARE NIL)))
+                     (SETF (CADR (SVREF ZEBU::*REGEX-GROUPS* 0)) ZEBU::INDEX)
+                     (RETURN-FROM ZEBU::FINAL-RETURN T)))))))))
     (SECOND (SVREF ZEBU::*REGEX-GROUPS* 0))))
(DEFUN VALUE-REFERENCE
        (STRING &OPTIONAL (ZEBU::START 0) (ZEBU::END (LENGTH STRING)))
-  (WHEN (PROGN
-          (SETF ZEBU::*REGEX-GROUPINGS* 1)
-          (BLOCK ZEBU::FINAL-RETURN
-            (BLOCK ZEBU::COMPARE
-              (LET ((ZEBU::INDEX ZEBU::START) (LENGTH ZEBU::END))
-                (SETF (SVREF ZEBU::*REGEX-GROUPS* 0)
-                      (LIST ZEBU::INDEX NIL))
-                (LET ((ZEBU::RANGE
-                       #*0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000111111111111111111111111110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
-                  (IF (>= ZEBU::INDEX LENGTH)
-                      (RETURN-FROM ZEBU::COMPARE NIL))
-                  (IF (= 1
+  (WHEN
+      (PROGN
+       (SETF ZEBU::*REGEX-GROUPINGS* 1)
+       (BLOCK ZEBU::FINAL-RETURN
+         (BLOCK ZEBU::COMPARE
+           (LET ((ZEBU::INDEX ZEBU::START) (LENGTH ZEBU::END))
+             (SETF (SVREF ZEBU::*REGEX-GROUPS* 0) (LIST ZEBU::INDEX NIL))
+             (LET ((ZEBU::RANGE
+                    #*0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000111111111111111111111111110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
+               (IF (>= ZEBU::INDEX LENGTH) (RETURN-FROM ZEBU::COMPARE NIL))
+               (IF
+                (= 1 (SBIT ZEBU::RANGE (CHAR-CODE (CHAR STRING ZEBU::INDEX))))
+                (INCF ZEBU::INDEX) (RETURN-FROM ZEBU::COMPARE NIL)))
+             (LET ((ZEBU::OINDEX ZEBU::INDEX))
+               (BLOCK ZEBU::COMPARE
+                 (DO ()
+                     (NIL)
+                   (LET ((ZEBU::RANGE
+                          #*0000000000000000000000000000000000000000000001001111111111000000011111111111111111111111111000000111111111111111111111111110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
+                     (IF (>= ZEBU::INDEX LENGTH)
+                         (RETURN-FROM ZEBU::COMPARE NIL))
+                     (IF
+                      (= 1
                          (SBIT ZEBU::RANGE
                                (CHAR-CODE (CHAR STRING ZEBU::INDEX))))
-                      (INCF ZEBU::INDEX)
-                    (RETURN-FROM ZEBU::COMPARE NIL)))
-                (LET ((ZEBU::OINDEX ZEBU::INDEX))
-                  (BLOCK ZEBU::COMPARE
-                    (DO ()
-                        (NIL)
-                      (LET ((ZEBU::RANGE
-                             #*0000000000000000000000000000000000000000000001001111111111000000011111111111111111111111111000000111111111111111111111111110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
-                        (IF (>= ZEBU::INDEX LENGTH)
-                            (RETURN-FROM ZEBU::COMPARE NIL))
-                        (IF (= 1
-                               (SBIT
-                                ZEBU::RANGE
-                                (CHAR-CODE (CHAR STRING ZEBU::INDEX))))
-                            (INCF ZEBU::INDEX)
-                          (RETURN-FROM ZEBU::COMPARE NIL)))))
-                  (DO ((ZEBU::START ZEBU::INDEX (1- ZEBU::START)))
-                      ((< ZEBU::START ZEBU::OINDEX) NIL)
-                    (LET ((ZEBU::INDEX ZEBU::START))
-                      (BLOCK ZEBU::COMPARE
-                        (LET ((ZEBU::RANGE
-                               #*0000000000000000000000000000000000000000000001001111111111000000011111111111111111111111111000000111111111111111111111111110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
-                          (IF (>= ZEBU::INDEX LENGTH)
-                              (RETURN-FROM ZEBU::COMPARE NIL))
-                          (IF (= 1
-                                 (SBIT
-                                  ZEBU::RANGE
-                                  (CHAR-CODE
-                                   (CHAR STRING ZEBU::INDEX))))
-                              (INCF ZEBU::INDEX)
-                            (RETURN-FROM ZEBU::COMPARE NIL)))
-                        (SETF (CADR (SVREF ZEBU::*REGEX-GROUPS* 0))
-                              ZEBU::INDEX)
-                        (RETURN-FROM ZEBU::FINAL-RETURN T)))))))))
+                      (INCF ZEBU::INDEX) (RETURN-FROM ZEBU::COMPARE NIL)))))
+               (DO ((ZEBU::START ZEBU::INDEX (1- ZEBU::START)))
+                   ((< ZEBU::START ZEBU::OINDEX) NIL)
+                 (LET ((ZEBU::INDEX ZEBU::START))
+                   (BLOCK ZEBU::COMPARE
+                     (LET ((ZEBU::RANGE
+                            #*0000000000000000000000000000000000000000000001001111111111000000011111111111111111111111111000000111111111111111111111111110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
+                       (IF (>= ZEBU::INDEX LENGTH)
+                           (RETURN-FROM ZEBU::COMPARE NIL))
+                       (IF
+                        (= 1
+                           (SBIT ZEBU::RANGE
+                                 (CHAR-CODE (CHAR STRING ZEBU::INDEX))))
+                        (INCF ZEBU::INDEX) (RETURN-FROM ZEBU::COMPARE NIL)))
+                     (SETF (CADR (SVREF ZEBU::*REGEX-GROUPS* 0)) ZEBU::INDEX)
+                     (RETURN-FROM ZEBU::FINAL-RETURN T)))))))))
     (SECOND (SVREF ZEBU::*REGEX-GROUPS* 0))))
(DEFUN TYPE-REFERENCE
        (STRING &OPTIONAL (ZEBU::START 0) (ZEBU::END (LENGTH STRING)))
-  (WHEN (PROGN
-          (SETF ZEBU::*REGEX-GROUPINGS* 1)
-          (BLOCK ZEBU::FINAL-RETURN
-            (BLOCK ZEBU::COMPARE
-              (LET ((ZEBU::INDEX ZEBU::START) (LENGTH ZEBU::END))
-                (SETF (SVREF ZEBU::*REGEX-GROUPS* 0)
-                      (LIST ZEBU::INDEX NIL))
-                (LET ((ZEBU::RANGE
-                       #*0000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
-                  (IF (>= ZEBU::INDEX LENGTH)
-                      (RETURN-FROM ZEBU::COMPARE NIL))
-                  (IF (= 1
+  (WHEN
+      (PROGN
+       (SETF ZEBU::*REGEX-GROUPINGS* 1)
+       (BLOCK ZEBU::FINAL-RETURN
+         (BLOCK ZEBU::COMPARE
+           (LET ((ZEBU::INDEX ZEBU::START) (LENGTH ZEBU::END))
+             (SETF (SVREF ZEBU::*REGEX-GROUPS* 0) (LIST ZEBU::INDEX NIL))
+             (LET ((ZEBU::RANGE
+                    #*0000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
+               (IF (>= ZEBU::INDEX LENGTH) (RETURN-FROM ZEBU::COMPARE NIL))
+               (IF
+                (= 1 (SBIT ZEBU::RANGE (CHAR-CODE (CHAR STRING ZEBU::INDEX))))
+                (INCF ZEBU::INDEX) (RETURN-FROM ZEBU::COMPARE NIL)))
+             (LET ((ZEBU::OINDEX ZEBU::INDEX))
+               (BLOCK ZEBU::COMPARE
+                 (DO ()
+                     (NIL)
+                   (LET ((ZEBU::RANGE
+                          #*0000000000000000000000000000000000000000000001001111111111000000011111111111111111111111111000000111111111111111111111111110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
+                     (IF (>= ZEBU::INDEX LENGTH)
+                         (RETURN-FROM ZEBU::COMPARE NIL))
+                     (IF
+                      (= 1
                          (SBIT ZEBU::RANGE
                                (CHAR-CODE (CHAR STRING ZEBU::INDEX))))
-                      (INCF ZEBU::INDEX)
-                    (RETURN-FROM ZEBU::COMPARE NIL)))
-                (LET ((ZEBU::OINDEX ZEBU::INDEX))
-                  (BLOCK ZEBU::COMPARE
-                    (DO ()
-                        (NIL)
-                      (LET ((ZEBU::RANGE
-                             #*0000000000000000000000000000000000000000000001001111111111000000011111111111111111111111111000000111111111111111111111111110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
-                        (IF (>= ZEBU::INDEX LENGTH)
-                            (RETURN-FROM ZEBU::COMPARE NIL))
-                        (IF (= 1
-                               (SBIT
-                                ZEBU::RANGE
-                                (CHAR-CODE (CHAR STRING ZEBU::INDEX))))
-                            (INCF ZEBU::INDEX)
-                          (RETURN-FROM ZEBU::COMPARE NIL)))))
-                  (DO ((ZEBU::START ZEBU::INDEX (1- ZEBU::START)))
-                      ((< ZEBU::START ZEBU::OINDEX) NIL)
-                    (LET ((ZEBU::INDEX ZEBU::START))
-                      (BLOCK ZEBU::COMPARE
-                        (SETF (CADR (SVREF ZEBU::*REGEX-GROUPS* 0))
-                              ZEBU::INDEX)
-                        (RETURN-FROM ZEBU::FINAL-RETURN T)))))))))
+                      (INCF ZEBU::INDEX) (RETURN-FROM ZEBU::COMPARE NIL)))))
+               (DO ((ZEBU::START ZEBU::INDEX (1- ZEBU::START)))
+                   ((< ZEBU::START ZEBU::OINDEX) NIL)
+                 (LET ((ZEBU::INDEX ZEBU::START))
+                   (BLOCK ZEBU::COMPARE
+                     (SETF (CADR (SVREF ZEBU::*REGEX-GROUPS* 0)) ZEBU::INDEX)
+                     (RETURN-FROM ZEBU::FINAL-RETURN T)))))))))
     (SECOND (SVREF ZEBU::*REGEX-GROUPS* 0))))
(DEFUN MODULE-REFERENCE
        (STRING &OPTIONAL (ZEBU::START 0) (ZEBU::END (LENGTH STRING)))
-  (WHEN (PROGN
-          (SETF ZEBU::*REGEX-GROUPINGS* 1)
-          (BLOCK ZEBU::FINAL-RETURN
-            (BLOCK ZEBU::COMPARE
-              (LET ((ZEBU::INDEX ZEBU::START) (LENGTH ZEBU::END))
-                (SETF (SVREF ZEBU::*REGEX-GROUPS* 0)
-                      (LIST ZEBU::INDEX NIL))
-                (LET ((ZEBU::RANGE
-                       #*0000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
-                  (IF (>= ZEBU::INDEX LENGTH)
-                      (RETURN-FROM ZEBU::COMPARE NIL))
-                  (IF (= 1
+  (WHEN
+      (PROGN
+       (SETF ZEBU::*REGEX-GROUPINGS* 1)
+       (BLOCK ZEBU::FINAL-RETURN
+         (BLOCK ZEBU::COMPARE
+           (LET ((ZEBU::INDEX ZEBU::START) (LENGTH ZEBU::END))
+             (SETF (SVREF ZEBU::*REGEX-GROUPS* 0) (LIST ZEBU::INDEX NIL))
+             (LET ((ZEBU::RANGE
+                    #*0000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
+               (IF (>= ZEBU::INDEX LENGTH) (RETURN-FROM ZEBU::COMPARE NIL))
+               (IF
+                (= 1 (SBIT ZEBU::RANGE (CHAR-CODE (CHAR STRING ZEBU::INDEX))))
+                (INCF ZEBU::INDEX) (RETURN-FROM ZEBU::COMPARE NIL)))
+             (LET ((ZEBU::OINDEX ZEBU::INDEX))
+               (BLOCK ZEBU::COMPARE
+                 (DO ()
+                     (NIL)
+                   (LET ((ZEBU::RANGE
+                          #*0000000000000000000000000000000000000000000001001111111111000000011111111111111111111111111000000111111111111111111111111110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
+                     (IF (>= ZEBU::INDEX LENGTH)
+                         (RETURN-FROM ZEBU::COMPARE NIL))
+                     (IF
+                      (= 1
                          (SBIT ZEBU::RANGE
                                (CHAR-CODE (CHAR STRING ZEBU::INDEX))))
-                      (INCF ZEBU::INDEX)
-                    (RETURN-FROM ZEBU::COMPARE NIL)))
-                (LET ((ZEBU::OINDEX ZEBU::INDEX))
-                  (BLOCK ZEBU::COMPARE
-                    (DO ()
-                        (NIL)
-                      (LET ((ZEBU::RANGE
-                             #*0000000000000000000000000000000000000000000001001111111111000000011111111111111111111111111000000111111111111111111111111110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
-                        (IF (>= ZEBU::INDEX LENGTH)
-                            (RETURN-FROM ZEBU::COMPARE NIL))
-                        (IF (= 1
-                               (SBIT
-                                ZEBU::RANGE
-                                (CHAR-CODE (CHAR STRING ZEBU::INDEX))))
-                            (INCF ZEBU::INDEX)
-                          (RETURN-FROM ZEBU::COMPARE NIL)))))
-                  (DO ((ZEBU::START ZEBU::INDEX (1- ZEBU::START)))
-                      ((< ZEBU::START ZEBU::OINDEX) NIL)
-                    (LET ((ZEBU::INDEX ZEBU::START))
-                      (BLOCK ZEBU::COMPARE
-                        (SETF (CADR (SVREF ZEBU::*REGEX-GROUPS* 0))
-                              ZEBU::INDEX)
-                        (RETURN-FROM ZEBU::FINAL-RETURN T)))))))))
+                      (INCF ZEBU::INDEX) (RETURN-FROM ZEBU::COMPARE NIL)))))
+               (DO ((ZEBU::START ZEBU::INDEX (1- ZEBU::START)))
+                   ((< ZEBU::START ZEBU::OINDEX) NIL)
+                 (LET ((ZEBU::INDEX ZEBU::START))
+                   (BLOCK ZEBU::COMPARE
+                     (SETF (CADR (SVREF ZEBU::*REGEX-GROUPS* 0)) ZEBU::INDEX)
+                     (RETURN-FROM ZEBU::FINAL-RETURN T)))))))))
     (SECOND (SVREF ZEBU::*REGEX-GROUPS* 0))))
-(DEFUN ANY-THING
-       (STRING &OPTIONAL (ZEBU::START 0) (ZEBU::END (LENGTH STRING)))
-  (WHEN (PROGN
-          (SETF ZEBU::*REGEX-GROUPINGS* 1)
-          (BLOCK ZEBU::FINAL-RETURN
-            (BLOCK ZEBU::COMPARE
-              (LET ((ZEBU::INDEX ZEBU::START) (LENGTH ZEBU::END))
-                (SETF (SVREF ZEBU::*REGEX-GROUPS* 0)
-                      (LIST ZEBU::INDEX NIL))
-                (LET ((ZEBU::OINDEX ZEBU::INDEX))
-                  (BLOCK ZEBU::COMPARE
-                    (DO ()
-                        (NIL)
-                      (LET ((ZEBU::RANGE
-                             #*1111111111111111111111111111111101111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111))
-                        (IF (>= ZEBU::INDEX LENGTH)
-                            (RETURN-FROM ZEBU::COMPARE NIL))
-                        (IF (= 1
-                               (SBIT
-                                ZEBU::RANGE
-                                (CHAR-CODE (CHAR STRING ZEBU::INDEX))))
-                            (INCF ZEBU::INDEX)
-                          (RETURN-FROM ZEBU::COMPARE NIL)))))
-                  (DO ((ZEBU::START ZEBU::INDEX (1- ZEBU::START)))
-                      ((< ZEBU::START ZEBU::OINDEX) NIL)
-                    (LET ((ZEBU::INDEX ZEBU::START))
-                      (BLOCK ZEBU::COMPARE
-                        (LET ((ZEBU::RANGE
-                               #*1111111111111111111111111111111101111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111))
-                          (IF (>= ZEBU::INDEX LENGTH)
-                              (RETURN-FROM ZEBU::COMPARE NIL))
-                          (IF (= 1
-                                 (SBIT
-                                  ZEBU::RANGE
-                                  (CHAR-CODE
-                                   (CHAR STRING ZEBU::INDEX))))
-                              (INCF ZEBU::INDEX)
-                            (RETURN-FROM ZEBU::COMPARE NIL)))
-                        (SETF (CADR (SVREF ZEBU::*REGEX-GROUPS* 0))
-                              ZEBU::INDEX)
-                        (RETURN-FROM ZEBU::FINAL-RETURN T)))))))))
+(DEFUN ANY-THING (STRING &OPTIONAL (ZEBU::START 0) (ZEBU::END (LENGTH STRING)))
+  (WHEN
+      (PROGN
+       (SETF ZEBU::*REGEX-GROUPINGS* 1)
+       (BLOCK ZEBU::FINAL-RETURN
+         (BLOCK ZEBU::COMPARE
+           (LET ((ZEBU::INDEX ZEBU::START) (LENGTH ZEBU::END))
+             (SETF (SVREF ZEBU::*REGEX-GROUPS* 0) (LIST ZEBU::INDEX NIL))
+             (LET ((ZEBU::OINDEX ZEBU::INDEX))
+               (BLOCK ZEBU::COMPARE
+                 (DO ()
+                     (NIL)
+                   (LET ((ZEBU::RANGE
+                          #*1111111111111111111111111111111101111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111))
+                     (IF (>= ZEBU::INDEX LENGTH)
+                         (RETURN-FROM ZEBU::COMPARE NIL))
+                     (IF
+                      (= 1
+                         (SBIT ZEBU::RANGE
+                               (CHAR-CODE (CHAR STRING ZEBU::INDEX))))
+                      (INCF ZEBU::INDEX) (RETURN-FROM ZEBU::COMPARE NIL)))))
+               (DO ((ZEBU::START ZEBU::INDEX (1- ZEBU::START)))
+                   ((< ZEBU::START ZEBU::OINDEX) NIL)
+                 (LET ((ZEBU::INDEX ZEBU::START))
+                   (BLOCK ZEBU::COMPARE
+                     (LET ((ZEBU::RANGE
+                            #*1111111111111111111111111111111101111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111))
+                       (IF (>= ZEBU::INDEX LENGTH)
+                           (RETURN-FROM ZEBU::COMPARE NIL))
+                       (IF
+                        (= 1
+                           (SBIT ZEBU::RANGE
+                                 (CHAR-CODE (CHAR STRING ZEBU::INDEX))))
+                        (INCF ZEBU::INDEX) (RETURN-FROM ZEBU::COMPARE NIL)))
+                     (SETF (CADR (SVREF ZEBU::*REGEX-GROUPS* 0)) ZEBU::INDEX)
+                     (RETURN-FROM ZEBU::FINAL-RETURN T)))))))))
     (SECOND (SVREF ZEBU::*REGEX-GROUPS* 0))))
Modified: trunk/asn.1/asn.1.tab
==============================================================================
--- trunk/asn.1/asn.1.tab	(original)
+++ trunk/asn.1/asn.1.tab	Sun Sep 16 04:11:39 2007
@@ -1,6 +1,6 @@
-(:FILE "/home/binghe/cl-net-snmp/asn.1/asn.1.zb" :NAME "ASN.1" :DOMAIN-FILE "asn.1-domain.lisp" :PACKAGE "ASN.1" :GRAMMAR "zebu-mg" :IDENTIFIER-START-CHARS "abcdefghijklmnopqrstuvwxyz" :IDENTIFIER-CONTINUE-CHARS "-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890" :LEX-CATS ((A-NUMBER "[0-9]+") (VALUE-REFERENCE "[a-z][a-zA-Z0-9-]+") (TYPE-REFERENCE "[A-Z][a-zA-Z0-9-]*") (MODULE-REFERENCE "[A-Z][a-zA-Z0-9-]*") (ANY-THING "[^ ]+")) :DOMAIN (KB-DOMAIN :SUBTYPE (OBJ-ID-COMPONENTS-LIST :SLOTS ((-LIST KB-SEQUENCE))) :SUBTYPE (ASSIGNMENT-LIST :SLOTS ((-LIST KB-SEQUENCE))) :SUBTYPE (ASSIGNMENT :SLOTS (-TYPE -VALUE)) :SUBTYPE (MODULE-BODY :SLOTS (-ASSIGNMENT-LIST)) :SUBTYPE (MODULE-DEFINITION :SLOTS (-IDENTIFIER -BODY))) :DOMAIN-FILE "/home/binghe/cl-net-snmp/asn.1/asn.1-domain.lisp")
-#75(ZEBU::THE-EMPTY-STRING ZEBU::AUGMENTED-START ZEBU::THE-END-G-SYMBOL MODULE-DEFINITION MODULE-IDENTIFIER "DEFINITIONS" "::=" "BEGIN" MODULE-BODY "END" MODULE-REFERENCE EXPORTS IMPORTS ASSIGNMENT-LIST "EXPORTS" SYMBOLS-EXPORTED ";" "ALL" SYMBOL+,1$ SYMBOL REFERENCE TYPE-REFERENCE VALUE-REFERENCE ASSIGNMENT+ ASSIGNMENT SPECIAL-ASSIGNMENT TYPE-ASSIGNMENT VALUE-ASSIGNMENT TYPE VALUE BUILTIN-TYPE OBJECT-IDENTIFIER-TYPE CHOICE-TYPE OCTET-STRING-TYPE INTEGER-TYPE TAGGED-TYPE "OBJECT" "IDENTIFIER" BUILTIN-VALUE OBJECT-IDENTIFIER-VALUE "{" OBJ-ID-COMPONENTS-LIST "}" OBJ-ID-COMPONENTS+ OBJ-ID-COMPONENTS NAME-AND-NUMBER-FORM NAME-FORM NUMBER-FORM IDENTIFIER "(" ")" A-NUMBER "OBJECT-TYPE" "MACRO" GARBAGE+ GARBAGE ANY-THING "CHOICE" "OCTET" "STRING" STRING-OPTIONS "SIZE" "INTEGER" ".." TAG "IMPLICIT" "EXPLICIT" "[" CLASS CLASS-NUMBER "]" "UNIVERSAL" "APPLICATION" "PRIVATE" "," )
+(:FILE "/home/binghe/lisp/cl-net-snmp/trunk/asn.1/asn.1.zb" :NAME "ASN.1" :DOMAIN-FILE "asn.1-domain.lisp" :PACKAGE "ASN.1" :GRAMMAR "zebu-mg" :IDENTIFIER-START-CHARS "abcdefghijklmnopqrstuvwxyz" :IDENTIFIER-CONTINUE-CHARS "-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890" :LEX-CATS ((A-NUMBER "[0-9]+") (VALUE-REFERENCE "[a-z][a-zA-Z0-9-]+") (TYPE-REFERENCE "[A-Z][a-zA-Z0-9-]*") (MODULE-REFERENCE "[A-Z][a-zA-Z0-9-]*") (ANY-THING "[^ ]+")) :DOMAIN (KB-DOMAIN :SUBTYPE (OBJ-ID-COMPONENTS-LIST :SLOTS ((-LIST KB-SEQUENCE))) :SUBTYPE (ASSIGNMENT :SLOTS (-TYPE -VALUE)) :SUBTYPE (ASSIGNMENT-LIST :SLOTS ((-LIST KB-SEQUENCE))) :SUBTYPE (MODULE-BODY :SLOTS (-ASSIGNMENT-LIST)) :SUBTYPE (MODULE-DEFINITION :SLOTS (-IDENTIFIER -BODY))) :DOMAIN-FILE "/home/binghe/lisp/cl-net-snmp/trunk/asn.1/asn.1-domain.lisp")
+#75(ZEBU::THE-EMPTY-STRING ZEBU::AUGMENTED-START ZEBU::THE-END-G-SYMBOL MODULE-DEFINITION MODULE-IDENTIFIER "DEFINITIONS" "::=" "BEGIN" MODULE-BODY "END" MODULE-REFERENCE EXPORTS IMPORTS ASSIGNMENT-LIST "EXPORTS" SYMBOLS-EXPORTED ";" "ALL" |SYMBOL+,1$| SYMBOL REFERENCE TYPE-REFERENCE VALUE-REFERENCE ASSIGNMENT+ ASSIGNMENT SPECIAL-ASSIGNMENT TYPE-ASSIGNMENT VALUE-ASSIGNMENT TYPE VALUE BUILTIN-TYPE OBJECT-IDENTIFIER-TYPE CHOICE-TYPE OCTET-STRING-TYPE INTEGER-TYPE TAGGED-TYPE "OBJECT" "IDENTIFIER" BUILTIN-VALUE OBJECT-IDENTIFIER-VALUE "{" OBJ-ID-COMPONENTS-LIST "}" OBJ-ID-COMPONENTS+ OBJ-ID-COMPONENTS NAME-AND-NUMBER-FORM NAME-FORM NUMBER-FORM IDENTIFIER "(" ")" A-NUMBER "OBJECT-TYPE" "MACRO" GARBAGE+ GARBAGE ANY-THING "CHOICE" "OCTET" "STRING" STRING-OPTIONS "SIZE" "INTEGER" ".." TAG "IMPLICIT" "EXPLICIT" "[" CLASS CLASS-NUMBER "]" "UNIVERSAL" "APPLICATION" "PRIVATE" "," )
#35(5 6 7 9 10 14 16 17 21 22 36 37 40 42 48 49 50 51 52 53 56 57 58 59 61 62 63 65 66 67 70 71 72 73 74 )
@@ -222,16 +222,16 @@
2
-#37((MODULE-DEFINITION . #S(ZEBU::ZB-RULE :-NAME MODULE-DEFINITION :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (MODULE-IDENTIFIER "DEFINITIONS" "::=" "BEGIN" MODULE-BODY "END") :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE MODULE-DEFINITION :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL -IDENTIFIER :-VALUE MODULE-IDENTIFIER) #S(ZEBU::LABEL-VALUE-PAIR :-LABEL -BODY :-VALUE MODULE-BODY))) :-BUILD-FN MODULE-DEFINITION248))))
+#37((MODULE-DEFINITION . #S(ZEBU::ZB-RULE :-NAME MODULE-DEFINITION :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (MODULE-IDENTIFIER "DEFINITIONS" "::=" "BEGIN" MODULE-BODY "END") :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE MODULE-DEFINITION :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL -IDENTIFIER :-VALUE MODULE-IDENTIFIER) #S(ZEBU::LABEL-VALUE-PAIR :-LABEL -BODY :-VALUE MODULE-BODY))) :-BUILD-FN MODULE-DEFINITION32))))
 (MODULE-IDENTIFIER . #S(ZEBU::ZB-RULE :-NAME MODULE-IDENTIFIER :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (MODULE-REFERENCE) :-SEMANTICS NIL :-BUILD-FN IDENTITY))))
-(MODULE-BODY . #S(ZEBU::ZB-RULE :-NAME MODULE-BODY :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (EXPORTS IMPORTS ASSIGNMENT-LIST) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE MODULE-BODY :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL -ASSIGNMENT-LIST :-VALUE ASSIGNMENT-LIST))) :-BUILD-FN MODULE-BODY247) #S(ZEBU::PRODUCTION-RHS :-SYNTAX NIL :-SEMANTICS NIL :-BUILD-FN IDENTITY*))))
+(MODULE-BODY . #S(ZEBU::ZB-RULE :-NAME MODULE-BODY :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (EXPORTS IMPORTS ASSIGNMENT-LIST) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE MODULE-BODY :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL -ASSIGNMENT-LIST :-VALUE ASSIGNMENT-LIST))) :-BUILD-FN MODULE-BODY31) #S(ZEBU::PRODUCTION-RHS :-SYNTAX NIL :-SEMANTICS NIL :-BUILD-FN IDENTITY*))))
 (EXPORTS . #S(ZEBU::ZB-RULE :-NAME EXPORTS :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX ("EXPORTS" SYMBOLS-EXPORTED ";") :-SEMANTICS NIL :-BUILD-FN IDENTITY*) #S(ZEBU::PRODUCTION-RHS :-SYNTAX ("EXPORTS" "ALL" ";") :-SEMANTICS NIL :-BUILD-FN IDENTITY*) #S(ZEBU::PRODUCTION-RHS :-SYNTAX NIL :-SEMANTICS NIL :-BUILD-FN IDENTITY*))))
-(SYMBOLS-EXPORTED . #S(ZEBU::ZB-RULE :-NAME SYMBOLS-EXPORTED :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (SYMBOL+,1$) :-SEMANTICS NIL :-BUILD-FN IDENTITY) #S(ZEBU::PRODUCTION-RHS :-SYNTAX NIL :-SEMANTICS NIL :-BUILD-FN IDENTITY*))))
+(SYMBOLS-EXPORTED . #S(ZEBU::ZB-RULE :-NAME SYMBOLS-EXPORTED :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (|SYMBOL+,1$|) :-SEMANTICS NIL :-BUILD-FN IDENTITY) #S(ZEBU::PRODUCTION-RHS :-SYNTAX NIL :-SEMANTICS NIL :-BUILD-FN IDENTITY*))))
 (SYMBOL . #S(ZEBU::ZB-RULE :-NAME SYMBOL :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (REFERENCE) :-SEMANTICS NIL :-BUILD-FN IDENTITY))))
 (IMPORTS . #S(ZEBU::ZB-RULE :-NAME IMPORTS :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (TYPE-REFERENCE) :-SEMANTICS NIL :-BUILD-FN IDENTITY) #S(ZEBU::PRODUCTION-RHS :-SYNTAX NIL :-SEMANTICS NIL :-BUILD-FN IDENTITY*))))
 (REFERENCE . #S(ZEBU::ZB-RULE :-NAME REFERENCE :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (TYPE-REFERENCE) :-SEMANTICS NIL :-BUILD-FN IDENTITY) #S(ZEBU::PRODUCTION-RHS :-SYNTAX (VALUE-REFERENCE) :-SEMANTICS NIL :-BUILD-FN IDENTITY))))
-(ASSIGNMENT-LIST . #S(ZEBU::ZB-RULE :-NAME ASSIGNMENT-LIST :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (ASSIGNMENT+) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE ASSIGNMENT-LIST :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL -LIST :-VALUE ASSIGNMENT+))) :-BUILD-FN ASSIGNMENT-LIST246))))
-(ASSIGNMENT . #S(ZEBU::ZB-RULE :-NAME ASSIGNMENT :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (SPECIAL-ASSIGNMENT) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE ASSIGNMENT :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL -TYPE :-VALUE :SPECIAL) #S(ZEBU::LABEL-VALUE-PAIR :-LABEL -VALUE :-VALUE SPECIAL-ASSIGNMENT))) :-BUILD-FN ASSIGNMENT243) #S(ZEBU::PRODUCTION-RHS :-SYNTAX (TYPE-ASSIGNMENT) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE ASSIGNMENT :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL -TYPE :-VALUE :TYPE) #S(ZEBU::LABEL-VALUE-PAIR :-LABEL -VALUE :-VALUE TYPE-ASSIGNMENT))) :-BUILD-FN ASSIGNMENT244) #S(ZEBU::PRODUCTION-RHS :-SYNTAX (VALUE-ASSIGNMENT) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE ASSIGNMENT :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL -TYPE :-VALUE :VALUE) #S(ZEBU::LABEL-VALUE-PAIR :-LABEL -VALUE :-VALUE VALUE-ASSIGNMENT))) :-BUILD-FN ASSIGNMENT245))))
+(ASSIGNMENT-LIST . #S(ZEBU::ZB-RULE :-NAME ASSIGNMENT-LIST :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (ASSIGNMENT+) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE ASSIGNMENT-LIST :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL -LIST :-VALUE ASSIGNMENT+))) :-BUILD-FN ASSIGNMENT-LIST30))))
+(ASSIGNMENT . #S(ZEBU::ZB-RULE :-NAME ASSIGNMENT :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (SPECIAL-ASSIGNMENT) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE ASSIGNMENT :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL -TYPE :-VALUE :SPECIAL) #S(ZEBU::LABEL-VALUE-PAIR :-LABEL -VALUE :-VALUE SPECIAL-ASSIGNMENT))) :-BUILD-FN ASSIGNMENT27) #S(ZEBU::PRODUCTION-RHS :-SYNTAX (TYPE-ASSIGNMENT) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE ASSIGNMENT :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL -TYPE :-VALUE :TYPE) #S(ZEBU::LABEL-VALUE-PAIR :-LABEL -VALUE :-VALUE TYPE-ASSIGNMENT))) :-BUILD-FN ASSIGNMENT28) #S(ZEBU::PRODUCTION-RHS :-SYNTAX (VALUE-ASSIGNMENT) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE ASSIGNMENT :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL -TYPE :-VALUE :VALUE) #S(ZEBU::LABEL-VALUE-PAIR :-LABEL -VALUE :-VALUE VALUE-ASSIGNMENT))) :-BUILD-FN ASSIGNMENT29))))
 (TYPE-ASSIGNMENT . #S(ZEBU::ZB-RULE :-NAME TYPE-ASSIGNMENT :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (TYPE-REFERENCE "::=" TYPE) :-SEMANTICS NIL :-BUILD-FN IDENTITY*))))
 (VALUE-ASSIGNMENT . #S(ZEBU::ZB-RULE :-NAME VALUE-ASSIGNMENT :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (VALUE-REFERENCE TYPE "::=" VALUE) :-SEMANTICS NIL :-BUILD-FN IDENTITY*))))
 (TYPE . #S(ZEBU::ZB-RULE :-NAME TYPE :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (BUILTIN-TYPE) :-SEMANTICS NIL :-BUILD-FN IDENTITY))))
@@ -240,7 +240,7 @@
 (VALUE . #S(ZEBU::ZB-RULE :-NAME VALUE :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (BUILTIN-VALUE) :-SEMANTICS NIL :-BUILD-FN IDENTITY))))
 (BUILTIN-VALUE . #S(ZEBU::ZB-RULE :-NAME BUILTIN-VALUE :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (OBJECT-IDENTIFIER-VALUE) :-SEMANTICS NIL :-BUILD-FN IDENTITY))))
 (OBJECT-IDENTIFIER-VALUE . #S(ZEBU::ZB-RULE :-NAME OBJECT-IDENTIFIER-VALUE :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX ("{" OBJ-ID-COMPONENTS-LIST "}") :-SEMANTICS NIL :-BUILD-FN IDENTITY*))))
-(OBJ-ID-COMPONENTS-LIST . #S(ZEBU::ZB-RULE :-NAME OBJ-ID-COMPONENTS-LIST :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (OBJ-ID-COMPONENTS+) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE OBJ-ID-COMPONENTS-LIST :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL -LIST :-VALUE OBJ-ID-COMPONENTS+))) :-BUILD-FN OBJ-ID-COMPONENTS-LIST242))))
+(OBJ-ID-COMPONENTS-LIST . #S(ZEBU::ZB-RULE :-NAME OBJ-ID-COMPONENTS-LIST :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (OBJ-ID-COMPONENTS+) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE OBJ-ID-COMPONENTS-LIST :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL -LIST :-VALUE OBJ-ID-COMPONENTS+))) :-BUILD-FN OBJ-ID-COMPONENTS-LIST26))))
 (OBJ-ID-COMPONENTS . #S(ZEBU::ZB-RULE :-NAME OBJ-ID-COMPONENTS :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (NAME-AND-NUMBER-FORM) :-SEMANTICS NIL :-BUILD-FN IDENTITY) #S(ZEBU::PRODUCTION-RHS :-SYNTAX (NAME-FORM) :-SEMANTICS NIL :-BUILD-FN IDENTITY) #S(ZEBU::PRODUCTION-RHS :-SYNTAX (NUMBER-FORM) :-SEMANTICS NIL :-BUILD-FN IDENTITY))))
 (NAME-AND-NUMBER-FORM . #S(ZEBU::ZB-RULE :-NAME NAME-AND-NUMBER-FORM :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (IDENTIFIER "(" NUMBER-FORM ")") :-SEMANTICS NIL :-BUILD-FN IDENTITY*))))
 (NAME-FORM . #S(ZEBU::ZB-RULE :-NAME NAME-FORM :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (IDENTIFIER) :-SEMANTICS NIL :-BUILD-FN IDENTITY))))
@@ -255,8 +255,8 @@
 (TAG . #S(ZEBU::ZB-RULE :-NAME TAG :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX ("[" CLASS CLASS-NUMBER "]") :-SEMANTICS NIL :-BUILD-FN IDENTITY*))))
 (CLASS-NUMBER . #S(ZEBU::ZB-RULE :-NAME CLASS-NUMBER :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (A-NUMBER) :-SEMANTICS NIL :-BUILD-FN IDENTITY))))
 (CLASS . #S(ZEBU::ZB-RULE :-NAME CLASS :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX ("UNIVERSAL") :-SEMANTICS NIL :-BUILD-FN IDENTITY) #S(ZEBU::PRODUCTION-RHS :-SYNTAX ("APPLICATION") :-SEMANTICS NIL :-BUILD-FN IDENTITY) #S(ZEBU::PRODUCTION-RHS :-SYNTAX ("PRIVATE") :-SEMANTICS NIL :-BUILD-FN IDENTITY) #S(ZEBU::PRODUCTION-RHS :-SYNTAX NIL :-SEMANTICS NIL :-BUILD-FN IDENTITY*))))
-(GARBAGE+ . #S(ZEBU::ZB-RULE :-NAME GARBAGE+ :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (GARBAGE) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE KB-SEQUENCE :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL FIRST :-VALUE GARBAGE))) :-BUILD-FN GARBAGE+240) #S(ZEBU::PRODUCTION-RHS :-SYNTAX (GARBAGE GARBAGE+) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE KB-SEQUENCE :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL FIRST :-VALUE GARBAGE) #S(ZEBU::LABEL-VALUE-PAIR :-LABEL REST :-VALUE GARBAGE+))) :-BUILD-FN GARBAGE+241))))
-(OBJ-ID-COMPONENTS+ . #S(ZEBU::ZB-RULE :-NAME OBJ-ID-COMPONENTS+ :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (OBJ-ID-COMPONENTS) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE KB-SEQUENCE :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL FIRST :-VALUE OBJ-ID-COMPONENTS))) :-BUILD-FN OBJ-ID-COMPONENTS+238) #S(ZEBU::PRODUCTION-RHS :-SYNTAX (OBJ-ID-COMPONENTS OBJ-ID-COMPONENTS+) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE KB-SEQUENCE :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL FIRST :-VALUE OBJ-ID-COMPONENTS) #S(ZEBU::LABEL-VALUE-PAIR :-LABEL REST :-VALUE OBJ-ID-COMPONENTS+))) :-BUILD-FN OBJ-ID-COMPONENTS+239))))
-(ASSIGNMENT+ . #S(ZEBU::ZB-RULE :-NAME ASSIGNMENT+ :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (ASSIGNMENT) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE KB-SEQUENCE :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL FIRST :-VALUE ASSIGNMENT))) :-BUILD-FN ASSIGNMENT+236) #S(ZEBU::PRODUCTION-RHS :-SYNTAX (ASSIGNMENT ASSIGNMENT+) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE KB-SEQUENCE :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL FIRST :-VALUE ASSIGNMENT) #S(ZEBU::LABEL-VALUE-PAIR :-LABEL REST :-VALUE ASSIGNMENT+))) :-BUILD-FN ASSIGNMENT+237))))
-(SYMBOL+,1$ . #S(ZEBU::ZB-RULE :-NAME SYMBOL+,1$ :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (SYMBOL) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE KB-SEQUENCE :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL FIRST :-VALUE SYMBOL))) :-BUILD-FN SYMBOL+,1$234) #S(ZEBU::PRODUCTION-RHS :-SYNTAX (SYMBOL "," SYMBOL+,1$) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE KB-SEQUENCE :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL FIRST :-VALUE SYMBOL) #S(ZEBU::LABEL-VALUE-PAIR :-LABEL REST :-VALUE SYMBOL+,1$))) :-BUILD-FN SYMBOL+,1$235))))
+(GARBAGE+ . #S(ZEBU::ZB-RULE :-NAME GARBAGE+ :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (GARBAGE) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE KB-SEQUENCE :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL FIRST :-VALUE GARBAGE))) :-BUILD-FN GARBAGE+24) #S(ZEBU::PRODUCTION-RHS :-SYNTAX (GARBAGE GARBAGE+) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE KB-SEQUENCE :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL FIRST :-VALUE GARBAGE) #S(ZEBU::LABEL-VALUE-PAIR :-LABEL REST :-VALUE GARBAGE+))) :-BUILD-FN GARBAGE+25))))
+(OBJ-ID-COMPONENTS+ . #S(ZEBU::ZB-RULE :-NAME OBJ-ID-COMPONENTS+ :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (OBJ-ID-COMPONENTS) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE KB-SEQUENCE :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL FIRST :-VALUE OBJ-ID-COMPONENTS))) :-BUILD-FN OBJ-ID-COMPONENTS+22) #S(ZEBU::PRODUCTION-RHS :-SYNTAX (OBJ-ID-COMPONENTS OBJ-ID-COMPONENTS+) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE KB-SEQUENCE :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL FIRST :-VALUE OBJ-ID-COMPONENTS) #S(ZEBU::LABEL-VALUE-PAIR :-LABEL REST :-VALUE OBJ-ID-COMPONENTS+))) :-BUILD-FN OBJ-ID-COMPONENTS+23))))
+(ASSIGNMENT+ . #S(ZEBU::ZB-RULE :-NAME ASSIGNMENT+ :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (ASSIGNMENT) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE KB-SEQUENCE :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL FIRST :-VALUE ASSIGNMENT))) :-BUILD-FN ASSIGNMENT+20) #S(ZEBU::PRODUCTION-RHS :-SYNTAX (ASSIGNMENT ASSIGNMENT+) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE KB-SEQUENCE :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL FIRST :-VALUE ASSIGNMENT) #S(ZEBU::LABEL-VALUE-PAIR :-LABEL REST :-VALUE ASSIGNMENT+))) :-BUILD-FN ASSIGNMENT+21))))
+(|SYMBOL+,1$| . #S(ZEBU::ZB-RULE :-NAME |SYMBOL+,1$| :-PRODUCTIONS (#S(ZEBU::PRODUCTION-RHS :-SYNTAX (SYMBOL) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE KB-SEQUENCE :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL FIRST :-VALUE SYMBOL))) :-BUILD-FN |SYMBOL+,1$18|) #S(ZEBU::PRODUCTION-RHS :-SYNTAX (SYMBOL "," |SYMBOL+,1$|) :-SEMANTICS #S(ZEBU::FEAT-TERM :-TYPE KB-SEQUENCE :-SLOTS (#S(ZEBU::LABEL-VALUE-PAIR :-LABEL FIRST :-VALUE SYMBOL) #S(ZEBU::LABEL-VALUE-PAIR :-LABEL REST :-VALUE |SYMBOL+,1$|))) :-BUILD-FN |SYMBOL+,1$19|))))
 )
\ No newline at end of file
Modified: trunk/asn.1/asn.1.zb
==============================================================================
--- trunk/asn.1/asn.1.zb	(original)
+++ trunk/asn.1/asn.1.zb	Sun Sep 16 04:11:39 2007
@@ -23,6 +23,7 @@
 Assignment-List := kb-domain: [(-list kb-sequence)];
 Assignment := kb-domain: [(-type) (-value)];
 Obj-Id-Components-List := kb-domain: [(-list kb-sequence)];
+Value-Assignment := kb-domain: [];
;; Rule Definitions
 Module-Definition -->
Added: trunk/asn.1/mib-parse.lisp
==============================================================================
--- (empty file)
+++ trunk/asn.1/mib-parse.lisp	Sun Sep 16 04:11:39 2007
@@ -0,0 +1,16 @@
+(in-package :asn.1)
+
+(defun parse-oid-def (syntax-tree)
+  (let ((module (car syntax-tree)))
+    (let ((assignment-list (Assignment-List--list
+                            (Module-Body--assignment-list
+                             (Module-Definition--body module)))))
+      (labels ((iter (kb-seq acc)
+		 (if (null (kb-sequence-rest kb-seq))
+		     (nreverse (cons (kb-sequence-first kb-seq) acc))
+		     (iter (kb-sequence-rest kb-seq)
+			   (cons (kb-sequence-first kb-seq) acc)))))
+	(delete-if-not #'(lambda (x) (eq (car x) :value))
+		       (mapcar #'(lambda (x) (cons (assignment--type x)
+						   (assignment--value x)))
+			       (iter assignment-list nil)))))))
Modified: trunk/asn.1/mib.lisp
==============================================================================
--- trunk/asn.1/mib.lisp	(original)
+++ trunk/asn.1/mib.lisp	Sun Sep 16 04:11:39 2007
@@ -69,9 +69,3 @@
         (zb:*comment-brackets* '(("/*" . "*/"))))
     (zb:file-parser file :grammar (zb:find-grammar "ASN.1") :verbose nil)))
-(defun parse-oid-def (syntax-tree)
-  (let ((module (car syntax-tree)))
-    (let ((assignment-list (Assignment-List--list
-                            (Module-Body--assignment-list
-                             (Module-Definition--body module)))))
-      assignment-list)))
Modified: trunk/asn.1/stream-test.lisp
==============================================================================
--- trunk/asn.1/stream-test.lisp	(original)
+++ trunk/asn.1/stream-test.lisp	Sun Sep 16 04:11:39 2007
@@ -42,3 +42,6 @@
               (make-pathname :name name :type "asn"
                              :directory '(:relative "asn.1" "test"))
               (asdf:component-pathname (asdf:find-system :net-snmp)))))
+
+(defun test-parse (name)
+  (parse-oid-def (parse-mib (mib-pathname name))))
Modified: trunk/net-snmp.asd
==============================================================================
--- trunk/net-snmp.asd	(original)
+++ trunk/net-snmp.asd	Sun Sep 16 04:11:39 2007
@@ -11,11 +11,13 @@
   :author "Chun Tian (binghe) binghe.lisp@gmail.com"
   :depends-on (:cffi
                :ironclad
-               :net-telent-date)
+               :net-telent-date
+	       :zebu)
   :components ((:module asn.1 :components ((:file "package")
                                            (:file "ber" :depends-on ("package"))
                                            (:file "oid" :depends-on ("ber"))
-                                           (:file "mib" :depends-on ("oid"))))
+                                           (:file "mib" :depends-on ("oid"))
+					   (:file "mib-parse" :depends-on ("mib"))))
                (:file "package")
                (:file "constants" :depends-on ("package"))
           (:file "typedefs" :depends-on ("constants"))

    

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

[cl-net-snmp-cvs] r38 - in trunk: . asn.1