new file mode 100644

@@ -0,0 +1,28 @@

+# see http://www.kernel.org/pub/software/scm/git/docs/gitattributes.html

+# default

+* -text

+

+# binaries

+*.png binary

+*.jpg binary

+*.exe binary

+*.dll binary

+*.exe binary

+*.7z  binary

+*.gz  binary

+*.zip binary

+

+

+

+

+# Standard to msysgit

+*.doc	 diff=astextplain

+*.DOC	 diff=astextplain

+*.docx diff=astextplain

+*.DOCX diff=astextplain

+*.dot  diff=astextplain

+*.DOT  diff=astextplain

+*.pdf  diff=astextplain

+*.PDF	 diff=astextplain

+*.rtf	 diff=astextplain

+*.RTF	 diff=astextplain

new file mode 100644

@@ -0,0 +1,3 @@

+.svn/

+*.el~

+.project

\ No newline at end of file

@@ -12,13 +12,14 @@

 ;;; Dario Guise, Skef Wholey, Michael Parzen, and Dan Kuokka. 

 ;;; Modified to work in CLtL1, CLtL2 and X3J13 compatible lisps by 

 ;;; Mark Kantrowitz on 14-OCT-92. The auto.ops and reactor.ops demo files

-;;; were provided by Michael Mauldin.

+;;; were provided by Michael Mauldin.  In year 2013, ported to modern Common

+;;; Lisp implementations and added support for quicklisp by Xiaofeng Yang.

 ;;; 

 ;;; This code is made available is, and without warranty of any kind by the

 ;;; authors or by Carnegie-Mellon University.

 ;;;

-;;; This code has been tested in Allegro v4.1, Lucid v4.1, IBCL, and

-;;; CMU CL.

+;;; This code has been tested in Clozure CL v1.9, SBCL v1.0.57, CLISP v2.49,

+;;; ECL v12.12.1, ABCL v1.1.1, Lispworks v6.1, MKCL v1.1.3, and Allegro CL v8.2.

 ;;;

 ;;; Source code:

 ;;;    ops.lisp, ops-globals.lisp, ops-backup.lisp, ops-compile.lisp, 

@@ -38,22 +39,11 @@

 ;;; ********************************

 ;;; Usage **************************

 ;;; ********************************

-;;;

-;;; Before loading:

-;;;    Change the global variable *ops-code-directory* to refer to the

-;;;    directory where the OPS5 sources are kept. You may also need to

-;;;    change the definition of OPS-PATHNAME depending on your lisp.

-;;;

 ;;; 

 ;;; To use:

-;;;    1. From Lisp, load the file "ops":

-;;;          (load "ops")

-;;;    2. Go into the OPS package:

-;;;          (in-package "OPS")

-;;;    3. To compile the OPS sources, use compile-ops:

-;;;          (compile-ops)

-;;;    4. To load the OPS sources, use load-ops:

-;;;          (load-ops)

+;;;    1. Clone this project and put into the local-projects directory of quicklisp (e.g. "~/quicklisp/local-projects").

+;;;    2. Use quicklisp to load this project:

+;;;          (ql:quickload "ops5")

 ;;; Now you can load your OPS5 code or start typing in productions.

 ;;; If you want to load in a new set of productions, call (reset-ops)

 ;;; between rule sets. For a nice REP Loop, run (ops).

@@ -79,29 +69,25 @@

 ;;; ********************************

 ;;; Sample Run *********************

 ;;; ********************************

-> (load "ops")

-;;; Loading binary file "ops.hbin"

-#P"/afs/andrew.cmu.edu/scs/cs/15-381/ops5v1/ops.hbin"

-> (in-package "OPS")

-#<Package "OPS" 40242A7E>

-> (load-ops)

-;;; Loading binary file "/afs/andrew.cmu.edu/scs/cs/15-381/ops5/ops-globals.hbin"

-;;; Loading binary file "/afs/andrew.cmu.edu/scs/cs/15-381/ops5/ops-util.hbin"

-;;; Loading binary file "/afs/andrew.cmu.edu/scs/cs/15-381/ops5/ops-backup.hbin"

-;;; Loading binary file "/afs/andrew.cmu.edu/scs/cs/15-381/ops5/ops-compile.hbin"

-;;; Loading binary file "/afs/andrew.cmu.edu/scs/cs/15-381/ops5/ops-main.hbin"

-;;; Loading binary file "/afs/andrew.cmu.edu/scs/cs/15-381/ops5/ops-match.hbin"

-;;; Loading binary file "/afs/andrew.cmu.edu/scs/cs/15-381/ops5/ops-io.hbin"

-;;; Loading binary file "/afs/andrew.cmu.edu/scs/cs/15-381/ops5/ops-rhs.hbin"

-NIL

-> (load "../ops/auto.ops")

-;;; Loading source file "../ops/auto.ops"

-;;; Warning: File "../ops/auto.ops" does not begin with IN-PACKAGE.  Loading into package "OPS"

+CL-USER> (ql:quickload "ops5")

+To load "ops5":

+  Load 1 ASDF system:

+    ops5

+; Loading "ops5"

+.........................

+("ops5")

+CL-USER> (in-package "OPS")

+#<Package "OPS">

+OPS> (load (merge-pathnames "../demo/auto.ops" *ops-code-directory*))

+Resetting OPS5 interpreter: 

+             

+   deleting productions, working memory, etc.

+Common Lisp OPS5 interpreter, version 19-OCT-92.

 ******************

-#P"/afs/andrew.cmu.edu/scs/cs/15-381/ops/auto.ops"

-> (make ready)

+#P"/home/nakrakiiya/quicklisp/local-projects/ops5/demo/auto.ops"

+OPS> (make ready)

 NIL

-> (run)

+OPS> (run)

 Automobile Diagnosis 

@@ -128,5 +114,5 @@ end -- explicit halt

   4 mean conflict set size (7 maximum)

  10 mean token memory size (17 maximum)

 NIL

-> 

+OPS> 

 ;;; *EOF*

new file mode 100644

@@ -0,0 +1,51 @@

+;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-

+

+(in-package :asdf)

+

+;; #-(or openmcl mcl sbcl cmu scl clisp lispworks ecl allegro cormanlisp abcl)

+;; (error "Sorry, this Lisp is not yet supported.  Patches welcome!")

+

+(defsystem :ops5

+  :version "19-OCT-92"

+  :description "VPS2 -- Interpreter for OPS5

+

+This Common Lisp version of OPS5 is in the public domain.  It is based

+in part on based on a Franz Lisp implementation done by Charles L. Forgy

+at Carnegie-Mellon University, which was placed in the public domain by

+the author in accordance with CMU policies.  Ported to Common Lisp by 

+George Wood and Jim Kowalski. CMU Common Lisp modifications by

+Dario Guise, Skef Wholey, Michael Parzen, and Dan Kuokka. 

+Modified to work in CLtL1, CLtL2 and X3J13 compatible lisps by 

+Mark Kantrowitz on 14-OCT-92. The auto.ops and reactor.ops demo files

+were provided by Michael Mauldin. In year 2013, ported to modern Common

+Lisp implementations and added support for quicklisp by Xiaofeng Yang.

+

+This code is made available is, and without warranty of any kind by the

+authors or by Carnegie-Mellon University.

+

+Documentation for OPS may be found in the OPS5 User's Manual, July 1981,

+by Forgy, CMU CSD.

+

+This version of OPS5 was obtained by anonymous ftp from 

+   ftp.cs.cmu.edu:/user/ai/areas/expert/systems/ops5/ops5_cl.tgz

+"

+  :author ""

+  :maintainer ""

+  :licence "public domain"

+  :depends-on ()

+  :components

+  ((:module "src"

+            :serial t

+            :components

+            (

+             (:file "ops")			; so that shadowing takes place...

+             (:file "ops-globals")

+             (:file "ops-util")		; macros

+             (:file "ops-compile")

+             (:file "ops-rhs")		; defines macros used in ops-init

+             (:file "ops-main")		; macros

+             (:file "ops-match") 

+             (:file "ops-backup")

+             (:file "ops-io")

+             (:file "ops-init")))))

+             

similarity index 97%

rename from ops-backup.lisp

rename to src/ops-backup.lisp

@@ -21,12 +21,12 @@

 ;;; Internal Global Variables

-(defvar *refracts*)

-(defvar *record*)

-(defvar *record-array*)

-(defvar *recording*)

-(defvar *max-record-index*)

-(defvar *record-index*)

+(defvar *refracts* nil)

+(defvar *record* nil)

+(defvar *record-array* nil)

+(defvar *recording* nil)

+(defvar *max-record-index* nil)

+(defvar *record-index* nil)

similarity index 98%

rename from ops-compile.lisp

rename to src/ops-compile.lisp

@@ -23,27 +23,27 @@

 ;;; External global variables

-(defvar *real-cnt*)

-(defvar *virtual-cnt*)

-(defvar *last-node*)

-(defvar *first-node*)

-(defvar *pcount*)

+(defvar *real-cnt* nil)

+(defvar *virtual-cnt* nil)

+(defvar *last-node* nil)

+(defvar *first-node* nil)

+(defvar *pcount* nil)

 ;;; Internal global variables

-(defvar *matrix*)

-(defvar *curcond*)

-(defvar *feature-count*)

-(defvar *ce-count*)

-(defvar *vars*)

-(defvar *ce-vars*)

-(defvar *rhs-bound-vars*)

-(defvar *rhs-bound-ce-vars*)

-(defvar *last-branch*)

-(defvar *subnum*)

-(defvar *cur-vars*)

-(defvar *action-type*)

+(defvar *matrix* nil)

+(defvar *curcond* nil)

+(defvar *feature-count* nil)

+(defvar *ce-count* nil)

+(defvar *vars* nil)

+(defvar *ce-vars* nil)

+(defvar *rhs-bound-vars* nil)

+(defvar *rhs-bound-ce-vars* nil)

+(defvar *last-branch* nil)

+(defvar *subnum* nil)

+(defvar *cur-vars* nil)

+(defvar *action-type* nil)

similarity index 94%

rename from ops-globals.lisp

rename to src/ops-globals.lisp

@@ -18,11 +18,11 @@

 ;;; Global variables also used by OPS modules.

-(defvar *halt-flag*)

-(defvar *cycle-count*)

-(defvar *p-name*)

-(defvar *ptrace*)

-(defvar *wtrace*)

+(defvar *halt-flag* nil)

+(defvar *cycle-count* nil)

+(defvar *p-name* nil)

+(defvar *ptrace* nil)

+(defvar *wtrace* nil)

 ;;; Hash Tables.

similarity index 97%

rename from ops-init.lisp

rename to src/ops-init.lisp

@@ -44,7 +44,7 @@

   "Clears the state of OPS to allow a new rule set to be loaded."

   ;; Tell the user what we're doing.

-  (format t "~&Resetting OPS5 interpreter: ~

+  (format t "~&Resetting OPS5 interpreter: 

              ~&   deleting productions, working memory, etc.")

   (remove *)

   (ops-init)

similarity index 99%

rename from ops-io.lisp

rename to src/ops-io.lisp

@@ -22,11 +22,11 @@

 ;;; Internal global variables.

-(defvar *write-file*)

-(defvar *trace-file*)

-(defvar *accept-file*)

-(defvar *ppline*)

-(defvar *filters*)

+(defvar *write-file* nil)

+(defvar *trace-file* nil)

+(defvar *accept-file* nil)

+(defvar *ppline* nil)

+(defvar *filters* nil)

similarity index 98%

rename from ops-main.lisp

rename to src/ops-main.lisp

@@ -24,21 +24,21 @@

 ;;; Global variables used in this module only.

-(defvar *limit-token*)

-(defvar *total-wm*)

-(defvar *max-token*)

-(defvar *total-token*)

-(defvar *brkpts*)

-(defvar *phase*)

-(defvar *break-flag*)

-(defvar *remaining-cycles*)

-(defvar *conflict-set*)

-(defvar *max-cs*)

-(defvar *total-cs*)

-(defvar *limit-cs*)

-(defvar *strategy*)

-(defvar *class-list*)

-(defvar *buckets*)

+(defvar *limit-token* nil)

+(defvar *total-wm* nil)

+(defvar *max-token* nil)

+(defvar *total-token* nil)

+(defvar *brkpts* nil)

+(defvar *phase* nil)

+(defvar *break-flag* nil)

+(defvar *remaining-cycles* nil)

+(defvar *conflict-set* nil)

+(defvar *max-cs* nil)

+(defvar *total-cs* nil)

+(defvar *limit-cs* nil)

+(defvar *strategy* nil)

+(defvar *class-list* nil)

+(defvar *buckets* nil)

similarity index 98%

rename from ops-match.lisp

rename to src/ops-match.lisp

@@ -23,17 +23,17 @@

 ;;; External global variables

-(defvar *current-token*)

+(defvar *current-token* nil)

 ;;; Internal global variables

-(defvar *alpha-data-part*)

-(defvar *alpha-flag-part*)

-(defvar *flag-part*)

-(defvar *data-part*)

-(defvar *sendtocall*)

-(defvar *side*)

+(defvar *alpha-data-part* nil)

+(defvar *alpha-flag-part* nil)

+(defvar *flag-part* nil)

+(defvar *data-part* nil)

+(defvar *sendtocall* nil)

+(defvar *side* nil)

 (proclaim '(special *c1* *c2* *c3* *c4* *c5* *c6* *c7* *c8* *c9*

 	   *c10* *c11* *c12* *c13* *c14* *c15* *c16* *c17* *c18* *c19*

 	   *c20* *c21* *c22* *c23* *c24* *c25* *c26* *c27* *c28* *c29*

similarity index 97%

rename from ops-rhs.lisp

rename to src/ops-rhs.lisp

@@ -24,29 +24,29 @@

 ;;; External global variables

-(defvar *size-result-array*)

-(defvar *in-rhs*)

-(defvar *current-wm*)

-(defvar *max-wm*)

-(defvar *action-count*)

-(defvar *critical*)

+(defvar *size-result-array* nil)

+(defvar *in-rhs* nil)

+(defvar *current-wm* nil)

+(defvar *max-wm* nil)

+(defvar *action-count* nil)

+(defvar *critical* nil)

 ;;; Internal global variables

-(defvar *wmpart-list*)

-(defvar *wm-filter*)

-(defvar *wm*)

-(defvar *old-wm*)

-(defvar *result-array*)

-(defvar *variable-memory*)

-(defvar *last*)

-(defvar *max-index*)

-(defvar *next-index*)

-(defvar *data-matched*)

-(defvar *ce-variable-memory*)

-(defvar *rest*)

-(defvar *build-trace*)

+(defvar *wmpart-list* nil)

+(defvar *wm-filter* nil)

+(defvar *wm* nil)

+(defvar *old-wm* nil)

+(defvar *result-array* nil)

+(defvar *variable-memory* nil)

+(defvar *last* nil)

+(defvar *max-index* nil)

+(defvar *next-index* nil)

+(defvar *data-matched* nil)

+(defvar *ce-variable-memory* nil)

+(defvar *rest* nil)

+(defvar *build-trace* nil)

 ;;;; Functions for RHS evaluation

similarity index 100%

rename from ops-util.lisp

rename to src/ops-util.lisp

similarity index 68%

rename from ops.lisp

rename to src/ops.lisp

@@ -43,47 +43,9 @@

 ;;; Source Directory ***************

 ;;; ********************************

-(defparameter *ops-code-directory* ""

-  "Directory where OPS5 source code is stored.")

-

-(defun ops-pathname (filename)

-  (concatenate 'string *ops-code-directory* filename))

-

-(defun load-ops-file (filename)

-  (load (ops-pathname filename)))

-

-(defun compile-load (filename)

-  (let ((pname (ops-pathname filename)))

-    (compile-file (concatenate 'string pname ".lisp"))

-    (load pname)))

-

-;;; ********************************

-;;; OPS Loading, Compilation, Init *

-;;; ********************************

-

-(defun load-ops ()

-  (load-ops-file "ops-globals")

-  (load-ops-file "ops-util")

-  (load-ops-file "ops-backup")

-  (load-ops-file "ops-compile")

-  (load-ops-file "ops-main")

-  (load-ops-file "ops-match")

-  (load-ops-file "ops-io")

-  (load-ops-file "ops-rhs")

-  (load-ops-file "ops-init")

-  (ops-init))

-

-(defun compile-ops ()

-  (load-ops-file "ops")			; so that shadowing takes place...

-  (compile-load "ops-globals")

-  (compile-load "ops-util")		; macros

-  (compile-load "ops-compile")

-  (compile-load "ops-rhs")		; defines macros used in ops-init

-  (compile-load "ops-main")		; macros

-  (compile-load "ops-match") 

-  (compile-load "ops-backup")

-  (compile-load "ops-io")

-  (compile-load "ops-init"))

+(defparameter *ops-code-directory* #.(or *compile-file-pathname*

+                                         *load-pathname*)

+              "Directory where OPS5 source code is stored.")

 ;;; ********************************

 ;;; REP Loop ***********************