( EXPERT-2 DIRECTORY     <10/12/83>145) EXIT                                                                            SCREEN      CONTENTS                                                              6         IMPLEMENTATION NOTES          8         MVP-FORTH LOAD SCREEN         9         PADS LOAD SCREEN             10 --> 49  EXPERT SOURCE                50 --> 51  NOTES                        55 --> 56  TESTRULE NOTES               60 --> 65  ANIMALS RULE BASE            70 -->     CIRCUITS RULE BASE                                                                                                                                                                                                                                                                                                                                                                                                                                                   ( MVP-FORTH )                                                                  ( EXPERT-2 NOTES         <10/12/83>146) EXIT                                                                            THE "ALLOT" ON SCREEN 10 SETS THE       AMOUNT OF SPACE FOR THE RULE BASE.      IF YOU RUN OUT OF MEMORY JUST ALLOT     MORE SPACE FOR THE RULES.                                                       MVP-FORTH ON AN APPLE II WITH RAM CARD  OR APPLE IIE CAN USE THE HIGH MEMORY    FOR THE RULE BASE. SIMPLY COPY THE      MONITOR TO THE RAM CARD AREA AND POINT  "STRINGSTART" TO HEX D000.                                                      HEX                                     : COPYMON ( COPY MON TO RAM )              C081 C@ DROP                            F800 F800 800 CMOVE                     C083 DUP C@ DROP C@ DROP ;                                                   COPYMON                                 D000 CONSTANT STRINGSTART               DECIMAL                                                          ( MVP-FORTH )                                                                  ( EXPERT-2 NOTES         <10/12/83>147) EXIT                                                                            THE SAME PROCEEDURE CAN BE USED WITH    PADS, BUT THE RULE BASE WILL BE OVER    WRITTEN IF THE VIRTUAL SYSTEM IS USED   DURING USE OR COMPILATION OF EXPERT.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ( MVP-FORTH )                                                                  ( MVP-APPLE LOAD SCREEN  < 0/ 0/ 0>008)                                                                                 ( LOAD SCREEN FOR MVP-FORTH APPLE II )                                          40 ' C/L ! ( SET 40 CHAR/LINE )                                                 : -->                                     ?LOADING 0 >IN !                        1 BLK +! BLK @ . ;                                                                                                    10 LOAD                                                                         EXIT                                                                                                                                                                                                                                                                                                                                                                                             ( MVP-FORTH )                                                                  ( MVP-PADS LOAD SCREEN   <10/ 9/83>009)                                                                                 ( LOAD SCREEN FOR APPLE PADS )                                                                                          : ERASE 0 FILL ;                                                                -->                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ( EXPERT-2 VARIABLES     <10/ 4/83>010) : TASK ;                                                                                                                VARIABLE STRINGSTART 3000  ALLOT        ( THIS BUFFER IS INCLUDED IN THE  )     ( DICTIONARY. IT MAY BE CHANGED   )     ( AS NEEDED FOR SIZE OF RULE BASE )                                             0 CONSTANT FALSE                        1 CONSTANT TRUE                                                                 VARIABLE RULESTK                        ( RULESTK HOLDS POINTER TO RULES  )                                             VARIABLE #RULES                         ( #RULES IS INCREMENTED WHILE     )     ( COMPILING RULES.                )                                             VARIABLE SCOUNT                         ( SCOUNT USED BY RULE COMPILER    )                                             -->                                                                                                                                             ( EXPERT-2 RULE# SUBHYP^ <10/ 9/83>011)                                         VARIABLE RULE#   40 ALLOT               ( A STACK FOR RULES BEING TESTED   )    ( USED BY ASK                      )                                            VARIABLE SUBHYP^                        ( THE '^' CONNOTES A POINTER       )                                            VARIABLE CURHYP                         ( POINTS TO CURRENT HYPOTHESIS     )                                            VARIABLE STRINGS                        ( CONTAINS START ADDRESS OF STRING )    ( SPACE AVAILABLE.                 )                                            VARIABLE $FLAG                          ( FOR STRING COMPILER              )                                            -->                                                                                                                                                                                      ( MVP-FORTH )                                                                  ( EXPERT-2 KNOWNTRUE     <10/ 9/83>012)                                         VARIABLE KNOWNTRUE   254 ALLOT          ( TRUE FACTS WILL BE PUSHED ON THE )    ( KNOWNTRUE STACK                  )                                            VARIABLE KNOWNFALSE  254 ALLOT          ( FALSE FACTS WILL BE PUSHED ON THE)    ( KNOWNFALSE STACK                 )                                            VARIABLE HYPSTACK    254 ALLOT                                                  VARIABLE 'VERIFY                        ( THE VARIABLE IS USED TO VECTOR  )     ( THE EXECUTION OF VERIFY.        )                                             -->                                                                                                                                                                                                                                                                                                              ( MVP-FORTH )                                                                  ( EXPERT-2 REMEMBER?     <10/ 9/83>013)                                         : REMEMBER? ( FACT, STK BASE --- TF )      BEGIN DDUP @ DUP 0=                           NOT ROT ROT = NOT AND             WHILE 2+ REPEAT                         SWAP DROP @ ;                                                                ( REMEMBER? CHECKS TO SEE IF A FACT  )  ( IS ALREADY ON THE REFERENCED STACK )                                          -->                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     ( MVP-FORTH )                                                                   ( EXPERT-2 PUSH          <10/ 9/83>014)                                         : PUSH ( FACT^, STK ADDR --- TF )          DDUP REMEMBER?                          IF DDROP TRUE                           ELSE                                      BEGIN  DUP @                            WHILE  2+                               REPEAT ! FALSE                        THEN ;                                                                                                               -->                                                                             ( PUSH PUSHES A FACT ON A REFERENCED )  ( STACK. IF ALREADY THERE, RETURNS   )  ( A TRUE FLAG, OTHERWISE RETURNS A   )  ( FALSE FLAG.                        )                                                                                                                                                                                                                                   ( MVP-FORTH )                                                                  ( EXPERT-2 NOTES         <10/ 9/83>015)                                         -->                                                                             RULES ARE COMPILED THUSLY:              START COMPILING AT "HERE". ANTECENDENTS FIRST.                                  LF <BYTE> POINTER <WORD> -ANTECEDENT1   LF <BYTE> POINTER <WORD> -ANTECEDENT2   "  "      "       "      "              LF <BYTE> POINTER <WORD> -ANTECEDENTN   XX <BYTE> 00      <WORD> -ENDFLAG            NOW CONSEQUENTS                    LF <BYTE> POINTER <WORD> -CONSEQUENT1   LF <BYTE> POINTER <WORD> -CONSEQUENT2   "  "      "       "      "              LF <BYTE> POINTER <WORD> -CONSEQUENTN   XX <BYTE> 00      <WORD> -ENDFLAG                                               NOTE XX IS UNIMPORTANT. FUTURE USES     MAY MAKE USE OF XX FOR VARIOUS FLAGS.                                                                                                            ( MVP-FORTH )                                                                  ( EXPERT-2 VERIFY SUPPORT<10/ 9/83>016)                                         : GETLOGIC ( RULEADDR --- RULEADDR, 1F)    DUP 1- C@ ;                          ( ON ENTRY  TOS^ ANY POINTER. LEAVE   ) ( POINTER ON STACK & ITS LOGIC FLAG   )                                         : FINDTHEN ( ^1ST IF --- ^1ST THEN )       BEGIN DUP @                             WHILE 3 +                               REPEAT 3 + ;                         ( ON ENTRY, TOS IS ANTECEDENT POINTER ) ( ZIP THROUGH ANTECEDENTS. LEAVE      ) ( POINTER TO FIRST CONSEQUENT ON STK  )                                         -->                                                                                                                                                                                                                                                                                                                                                      ( MVP-FORTH )                                                                  ( EXPERT-2 VERIFY SUPPORT<10/ 9/83>017)                                         : STRING?  ( --- )                         GETLOGIC  DUP 0= SWAP 1 = OR ;                                               : RULE#PUSH ( R# --- )                     RULE# @ 2+ DUP ROT SWAP ! RULE# ! ;                                          : RULE#DROP ( --- )                        RULE# DUP @ = NOT                       IF -2 RULE# +!                          THEN ;                                                                       -->                                                                                                                                                                                                                                                                                                                                                                                                                                      ( MVP-FORTH )                                                                  ( EXPERT-2 VERIFY SUPPORT<10/ 9/83>018)                                         : <FINDRULES                                ( --- -1, R#, R#, .... R# )            -1 ( LEAVE END-FLAG )                   RULESTK @ 1+ ( ^1ST IF POINTER )        #RULES @ 0                              DO FINDTHEN                              BEGIN DUP @ SUBHYP^ @ @ =                 IF ( FOUND A RULE ) I SWAP                FINDTHEN ( ^NEXT IF FIELD )             TRUE ( KILL UNTIL )                   ELSE ( NOT RULE YET )                     3 + DUP @ NOT                           IF ( OUT OF THENS )                       3 + TRUE                              ELSE FALSE  ( TRY AGAIN )               THEN                                  THEN                                  UNTIL                                  LOOP DROP ;                                                                  -->                                                              ( MVP-FORTH )                                                                  ( EXPERT-2 VERIFY SUPPORT<10/ 9/83>019)                                         -->                                                                             <FINDRULES COLLECTS RULES TO TEST;      LEAVES STACK WITH:                        -1 R# R# R# ..... R#                                                          IF NO RULES ARE FOUND, TOS= -1                                                  <FINDRULES IS BACKWARD CHAINING.                                                FINDRULES> IS FORWARD CHAINING.                                                                                                                                                                                                                                                                                                                                                                                                                                                  ( MVP-FORTH )                                                                  ( EXPERT-2 VERIFY SUPPORT<10/ 9/83>020)                                                                                 -->                                     ( NOT IMPLEMENTED. POSSIBLE DEFINITION                                          : FINDRULES>                              SUBHYP^ ! -1 RULESTK @ 1+               #RULES @ 0                              DO BEGIN DUP @ SUBHYP^ @ @ =             IF I SWAP FINDTHEN TRUE                 ELSE 3 + DUP @ NOT                       IF 3 + TRUE                             ELSE FALSE                              THEN                                   THEN                                    UNTIL                                  LOOP DROP ;                                                                                                                                                                                                                                                            ( MVP-FORTH )                                                                  ( EXPERT-2 VERIFY SUPPORT<10/ 9/83>021)                                         : FINDIF ( R# --- ^1ST, IF )               RULESTK @ 1+ SWAP ?DUP                    IF ( R# > 0 )  0                          DO FINDTHEN ( ^1ST THEN )                  FINDTHEN ( ^1ST IF, NEXT R )         LOOP                                  THEN ;                                                                     -->                                                                             FINDIF TURNS A RULE # ( R# ) INTO       ADDRESS OF FIRST ANTECEDENT POINTER     FIELD.                                                                                                                                                                                                                                                                                                                                                                                           ( MVP-FORTH )                                                                  ( EXPERT-2 VERIFY SUPPORT<10/ 9/83>022)                                         : RUNEON  ( CFA^ --- CFA^ TF )             GETLOGIC DUP 2 = SWAP 3 = OR              IF ( EQN ) DUP @ EXECUTE ( ---TF )        SWAP GETLOGIC 2 = ROT XOR NOT         ELSE ( BECAUSE ) TRUE ( TRY NEXT )      THEN ;                                                                     -->                                     RUNON EXECUTES FORTH WORDS COMPILED BY  "IFRUN", IFNOTRUN, ANDRUN, ANDNOTRUN,   THENRUN, AND BECAUSERUN.                                                        RUNEON FIRST CHECKS TO BE SURE CFA IS   NOT ^ TO BECAUSE CLAUSE.                                                        RUNEONS MUST RETURN A TF. RUNEON THEN   CORRECTS THE TF FOR VALUE OF 1F.        BECAUSE CLAUSE LEAVES TRUE FOR RULECK   WHICH FOLLOWS IN TRYRULE+.                                                                                                                       ( MVP-FORTH )                                                                  ( EXPERT-2 VERIFY SUPPORT<10/ 9/83>023)                                           ( FACT^, TF --- F,T OR FACT^,F )      : RULECK                                   IF 3 + FALSE                               ( FACT WAS TRUE, TRY NEXT )          ELSE DROP FALSE TRUE ( FALSE, EXIT )    THEN ;                                                                       -->                                                                             IF EQN-->T, AND 1F=+, THEN TRUE         IF EQN-->F, AND 1F=+, THEN FALSE        IF EQN-->T, AND 1F=-, THEN FALSE        IF EQN-->F, AND 1F=-, THEN TRUE                                                                                                                                                                                                                                                                                                                                                                  ( MVP-FORTH )                                                                  ( EXPERT-2 VERIFY SUPPORT<10/ 9/83>024)                                         : VERIFY ( HYP^ --- TF )                   'VERIFY @ EXECUTE ;                                                          -->                                                                             THIS IS A VECTORED IMPLEMENTATION OF    "VERIFY". IT ALLOWS FORWARD REFERENCING OF THE ACTUAL DEFINITION TO THE         PRIMITIVE <VERIFY>.                                                             VERIFY CALLS FOR STRINGS AND REPORTS    TRUTH. TESTIF+ THEN CHSCKS LOGIC FLAG.                                                                                                                                                                                                                                                                                                                                                                                                   ( MVP-FORTH )                                                                  ( EXPERT-2 VERIFY-SUPPORT<10/ 9/83>025)                                         : TESTIF+ ( R# --- TF )                    FINDIF                                   BEGIN  DUP @ 0=                          IF  DROP TRUE TRUE                        ( NO MORE IF'S, ALL FOUND TRUE )      ELSE STRING?                             IF  DUP VERIFY                            ( IF^ IF^ --- IF^ TF )                  SWAP GETLOGIC 0=                        ROT XOR NOT                           ELSE  ( EQN ) RUNEON ( CFA, TF )        THEN RULECK                            THEN                                   UNTIL RULE#DROP ;                                                           -->                                                                                                                                                                                                                                                                      ( MVP-FORTH )                                                                  ( EXPERT-2 VERIFY SUPPORT<10/ 9/83>026)                                         : XCALL ( STACK POINTER --- TF )           BEGIN  DUP @ DUP                         IF SUBHYP^ @ @ =                         IF  DROP TRUE FALSE ( FOUND )           ELSE TRUE   ( NOT FOUND YET )           THEN                                   ELSE DROP DROP FALSE FALSE                   ( NOT FOUND ANYWHERE )             THEN                                   WHILE 2+                                REPEAT  ;                                                                    -->                                     XCALL SUPPORTS RECALL BY CHECKING FOR   LAST ENTRY ON STACK POINTER EQUAL.                                              EXITS TRUE IF FOUND, FALSE IF NOT       FOUND.                                                                                                                                                                                   ( MVP-FORTH )                                                                  ( EXPERT-2 VERIFY SUPPORT<10/ 9/83>027)                                         : RECALL ( FACT^ --- TF, TRUE IF FOUND)    SUBHYP^ !                               KNOWNTRUE XCALL                          IF TRUE TRUE  ( FOUND TRUE )            ELSE     ( NOT FOUND TRUE )              KNOWNFALSE XCALL                         IF FALSE TRUE ( FOUND FALSE )           ELSE FALSE ( NOT FOUND ANYWHERE )       THEN                                  THEN ;                                                                      -->                                                                                                                                                                                                                                                                                                                                                                                                                                      ( MVP-FORTH )                                                                  ( EXPERT-2  I/O          <10/ 9/83>028)                                         : .$  ( STRING ADDRESS --- )               COUNT TYPE ;                                                                 : S.  CR 2 SPACES .$ ;                                                          : .$$  DUP @ .$ ;                                                               : .NFA  DUP @ NFA ID. ;                                                         -->                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ( MVP-FORTH )                                                                  ( EXPERT-2  I/O          <10/ 7/83>029)                                         : T1 CR                                   ." IS THIS TRUE? (Y,N,W=WHY)" S. ;    : T2 CR ." I CONCLUDE " S. CR ;         : T3 CR ." I DEDUCE " S. CR ;           : T4 CR ." CANNOT PROVE ANYTHING " CR ; : T5 CR ." I AM TRYING TO PROVE" S. ;   : T6 CR ." I AM TESTING RULE # " . ;    : T7 ." IF " 0 ;                        : T8 ." IFNOT " 0 ;                     : T9 ." IFRUN " 1 ;                     : T10 ." IFNOTRUN " 1 ;                 : T11 ." BECAUSE " 0 ;                  : T12 ." BECAUSERUN " 1 ;               : T13 ." THEN " 0 ;                     : T14 ." THENRUN " 1 ;                                                          -->                                                                                                                                                                                                                              ( MVP-FORTH )                                                                  ( EXPERT-2  I/O          <10/ 7/83>030)                                         : CASE:                                    CREATE ] SMUDGE                         DOES> SWAP 2* + @ EXECUTE ;                                                  : NOP ;                                                                         CASE: ?.    .$$ .NFA ;                                                          CASE: IF?T   T7 T8 T9 T10 T11 T12 ;                                             CASE: THEN?T                                  T13 NOP T14 NOP                         T11 T12 ;                                                                 -->                                                                                                                                                                                                                                                                                                              ( MVP-FORTH )                                                                  ( EXPERT-2 USER SUPPORT  <10/ 7/83>031)                                         : TELLWHY                                  CR CURHYP  @ T5 CR                      RULE# @ @ DUP T6                        FINDIF CR                               BEGIN  GETLOGIC IF?T ?. CR                3 + DUP @ 0=                          UNTIL 3 + ( IF'S DONE )                 BEGIN  GETLOGIC THEN?T ?. CR              3 + DUP @ 0=                          UNTIL DROP ;                                                                 -->                                     OPTIONAL, CAN ADD DISPLAY OF KNOWNTRUE  AND KNOWNFALSE STACKS.                                                                                                                                                                                                                                                                                                                                   ( MVP-FORTH )                                                                  ( EXPERT-2 FACTS SUPPORT <10/ 7/83>032)                                         : REMEMBERTRUE ( FACT^ --- )               KNOWNTRUE PUSH DROP ;                                                        : REMEMBERFALSE ( FACT^ --- )              KNOWNFALSE PUSH DROP ;                                                       ( REMEMBERTRUE AND REMEMBERFALSE ARE  ) ( METHODS BY WHICH EXPERT REMEMBERS   ) ( OR LEARNS FACTS.                    )                                         : UNLEARN ( --- )                          RULE# DUP ! ( INIT STACK )              KNOWNTRUE  256 ERASE                    KNOWNFALSE 256 ERASE ;               -->                                     UNLEARN CLEARS ALL POINTERS TO FACTS    WHICH HAVE BEEN LEARNED.                                                                                                                                                                                                         ( MVP-FORTH )                                                                  ( EXPERT-2 VERIFY SUPPORT<10/ 7/83>033)                                         : ASK  ( FACT^ --- TF )                    BEGIN DUP @ T1 ( ASK OPERATOR )          KEY ( XKEY ) DUP 2 SPACES EMIT          DUP CR 87 ( ASCII W ) = ( WHY? )         IF DROP TELLWHY FALSE                   ELSE 89 ( ASCII Y ) = ( IS TRUE )         IF @ REMEMBERTRUE TRUE                  ELSE @ REMEMBERFALSE FALSE              THEN TRUE ( KILL UNTIL )              THEN                                  UNTIL ;                                                                      -->                                                                                                                                                                                                                                                                                                                                                                                              ( MVP-FORTH )                                                                  ( EXPERT-2 VERIFY SUPPORT<10/ 7/83>034)                                         : USETHEN ( R# --- )                       FINDIF ( R# --- ^1ST IF )               FINDTHEN ( ^1ST THEN )                  BEGIN DUP @                             WHILE DUP STRING?                        IF  ( STRING )                            DUP @ KNOWNTRUE PUSH NOT                 IF DUP @ T3  ( TELL )                   THEN                                 ELSE   ( EQN? )                           RUNEON DROP  ( DROP TF )              THEN  3 +                              REPEAT  DROP ;                                                               -->                                                                                                                                                                                                                                                                                                              ( MVP-FORTH )                                                                  ( EXPERT-2 VERIFY SUPPORT<10/ 7/83>035)                                         -->                                                                             USETHEN PUSHES ALL STRING "THENS" TO    "KNOWNTRUE", EXECUTES ALL "THENRUN"     EQUATIONS AND IGNORES ANY "BECAUSE"     CLAUSES OR EQUATIONS.                                                           ON ENTRY, TOS IS RULE #.                                                        NOTE: ALL "THENRUN'S" LIKE "IFRUN'S"    MUST RETURN WITH A TF. THIS CAN BE      CHANGED BY DROPING THE "DROP" AFTER     "RUNEON" IN "USETHEN".                                                                                                                                                                                                                                                                                                                                                                           ( MVP-FORTH )                                                                  ( EXPERT-2 VERIFY SUPPORT<10/ 7/83>036)                                         : TRYRULE+  ( R# --- TF )                  DUP DUP RULE#PUSH                       TESTIF+                                   IF USETHEN TRUE                         ELSE DROP FALSE                         THEN ;                                                                     -->                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ( MVP-FORTH )                                                                  ( EXPERT-2 VERIFY SUPPORT<10/ 7/83>037)                                         : <VERIFY>  ( HYP^ --- TF )                DUP RECALL NOT ( --- TF, TRUE---F )      IF <FINDRULES DUP -1 = ( RULES? )        IF ( NO RULES ) DROP ASK                ELSE  ( SOME RULES TO TEST )             BEGIN  DUP -1 =                          IF DROP @ REMEMBERFALSE                    FALSE TRUE ( OUT OF RULES )          ELSE TRYRULE+ ( --- TF )                 IF  ( FOUND TRUE )                       BEGIN -1 = UNTIL ( DROP R'S )           DROP TRUE TRUE                         ELSE FALSE                              THEN                                   THEN                                   UNTIL THEN                            ELSE SWAP DROP THEN ; ( --- TF )                                            ' <VERIFY> CFA 'VERIFY !                                                        -->                                                              ( MVP-FORTH )                                                                  ( EXPERT-2 INFERENCE MACHINE  7/83>038)                                         : DIAGNOSE  UNLEARN                        HYPSTACK 2-                               BEGIN                                     2+ DUP @ 0= NOT                          IF DUP @ DUP @ CURHYP !                    VERIFY ?DUP                          ELSE DROP ( OUT OF HYPS )                  FALSE TRUE                           THEN                                 UNTIL                                 IF ( SUCCESS ) DROP CURHYP @ T2         ELSE T4                                 THEN ;                                                                       -->                                                                                                                                                                                                                                                                                                              ( MVP-FORTH )                                                                  ( EXPERT-2 RULE COMPILER <10/ 7/83>039)                                         : $= ( ADDR1 ADDR2 --- TF )                TRUE $FLAG ! DUP C@ SCOUNT @ = NOT       IF DDROP FALSE EXIT THEN               DUP C@ 0 ( 255 BYTE STRING MAX )         DO 1+ SWAP 1+ OVER C@ OVER C@              = NOT                                   IF FALSE $FLAG ! LEAVE THEN          LOOP DDROP $FLAG @ ;                                                        -->                                                                             $= IS HIGH LEVEL STRING COMPARISON.                                                                                                                                                                                                                                                                                                                                                                                                      ( MVP-FORTH )                                                                  ( EXPERT-2 RULE COMPILER <10/ 9/83>040)                                         : FINDCLAUSE  ( ADDR --- F, OR AD, T )     STRINGSTART                             BEGIN DUP C@ ( CT > 0 ? )                 IF DDUP $=                                IF ( FOUND ) SWAP DROP TRUE TRUE        ELSE COUNT + FALSE ( NOT YET )          THEN                                  ELSE DDROP FALSE TRUE ( NOWHERE )       THEN                                  UNTIL ;                                                                      -->                                     FINDCLAUSE SIMPLY CHECKS TO SEE IF A    STRING BEING COMPILED FROM RULES        ALREADY EXISTS IN STRING ARRAY WHICH    BEGINS AT "STRINGSTART".                IF STRING ALREADY EXISTS, LEAVE ADDRESS WHERE FOUND AND TRUE, ELSE LEAVE FALSE.                                                                                                                                                  ( MVP-FORTH )                                                                  ( EXPERT-2 RULE COMPILER <10/ 9/83>041)                                         : ADD , ;                               : ADD0 0 C, ;   ( STRING+ )             : ADD1 1 C, ;   ( STRING- )             : ADD2 2 C, ;   ( EQN   + )             : ADD3 3 C, ;   ( EQN   - )             : ADD4 4 C, ;   ( BECAUSE STRING )      : ADD5 5 C, ;   ( BECAUSE EQN    )                                              -->                                                                             ADD(N) COMPILES LOGIC FLAG.                                                                                                                                                                                                                                                                                                                                                                                                                                                      ( MVP-FORTH )                                                                  ( EXPERT-2 RULE COMPILER <10/ 9/83>042)                                         : GETCLAUSE ( --- STRINGADDRESS )          C/L >IN @ OVER MOD - BLK @ BLOCK        >IN @ + SWAP DUP >IN +! -TRAILING       DUP SCOUNT ! ( SAVE COUNT )             DDUP OVER CR 6 U.R 4 SPACES TYPE        30 OVER - SPACES OVER ( ADDRESS )       1- FINDCLAUSE                             IF ( FOUND ) SWAP DROP                     SWAP DROP ( KILL ADDRESS )           ELSE DUP STRINGS @ C! ( COUNT )           STRINGS @ 1+                            SWAP CMOVE ( STRING )                   STRINGS @ DUP COUNT + STRINGS !       THEN ;                             -->                                     GETCLAUSE GETS REST OF LINE IN INPUT    STREAM. CMOVES STRING TO STRING AREA    AND LEAVES STRING ADDRESS FOR COMPILING IN RULE FIELD.                                                                                                                                   ( MVP-FORTH )                                                                  ( EXPERT-2 RULE-COMPILER <10/ 9/83>043)                                         -->                                                                             STRINGS ARE LIMITED TO "C/L"            LONG-INCLUDING THE OPERATOR ( IF, THEN, ETC ). ON APPLE II C/L=40. IT IS        POSSIBLE TO CHANGE "GETCLAUSE" TO       COMPILE LONGER STRINGS                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ( MVP-FORTH )                                                                 ( EXPERT-2 RULE-COMPILER <10/ 9/83>044)                                         VOCABULARY RULE IMMEDIATE               RULE DEFINITIONS                                                                VARIABLE -FINISHED?                     VARIABLE -IF-FINISHED?                                                          : ANDIF  1 -IF-FINISHED? ! ADD0 ( 1F )     GETCLAUSE ADD ; IMMEDIATE                                                    : ANDIFRUN  1 -IF-FINISHED? ! ADD2        [COMPILE] '  CFA ADD ; IMMEDIATE                                              : AND [COMPILE] ANDIF ; IMMEDIATE                                               -->                                                                                                                                                                                                                                                                                                              ( MVP-FORTH )                                                                  ( EXPERT-2 RULE COMPILER <10/ 9/83>045)                                         : <IF> ( FORTH ) -FINISHED? @              IF ADD0 0 ADD                              ( END FLAG FOR "THEN" )                 0 -FINISHED? !                       THEN 1 #RULES +! ;                                                           -->                                                                             IF THIS "IF" FOLLOWS A "THEN", THEN     COMPILE AN END FLAG FOR THE PREVIOUS    CONSEQUENT FIELD. IF THIS IS THE FIRST  "IF" (ANTECEDENT) FIELD, DO NOT COMPILE A FLAG.                                                                                                                                                                                                                                                                                                                                                                                          ( MVP-FORTH )                                                                  ( EXPERT-2 RULE COMPILER <10/ 9/83>046)                                         : ANDNOT 1 -IF-FINISHED? ! ADD1            GETCLAUSE ADD ; IMMEDIATE                                                    : IFNOT  <IF> [COMPILE] ANDNOT ;           IMMEDIATE                                                                    : ANDNOTRUN 1 -IF-FINISHED? ! ADD3         [COMPILE] ['] CFA ADD ; IMMEDIATE                                            : IFNOTRUN <IF> [COMPILE] ANDNOTRUN        ; IMMEDIATE                                                                  : IF <IF> [COMPILE] ANDIF ; IMMEDIATE                                           : IFRUN <IF> [COMPILE] ANDIFRUN ;          IMMEDIATE                                                                    -->                                                                                                                                                                                      ( MVP-FORTH )                                                                  ( EXPERT-2 RULE COMPILER <10/ 9/83>047)                                         : <THEN> 1 -FINISHED? ! -IF-FINISHED?      @ [ FORTH ]                               IF ADD0 0 ADD THEN ; RULE          ( ADD ENDFLAG FOR END OF "IF'S"    )                                            : ANDTHEN ADD0 GETCLAUSE ADD ;             IMMEDIATE                                                                    : THEN <THEN>                              [COMPILE] ANDTHEN ; IMMEDIATE                                                : ANDTHENRUN ADD2 [COMPILE] [']            CFA ADD ; IMMEDIATE                                                          : THENRUN <THEN>                           [COMPILE] ANDTHENRUN ; IMMEDIATE                                             -->                                                                                                                                                                                      ( MVP-FORTH )                                                                  ( EXPERT-2 RULE COMPILER <10/ 9/83>048)                                         : THENHYP <THEN> ADD0 HERE GETCLAUSE       ADD HYPSTACK PUSH DROP ; IMMEDIATE                                           : BECAUSRUN 1 -IF-FINISHED? ! ADD5         [COMPILE] ['] CFA ADD ; IMMEDIATE                                            : ANDRUN [COMPILE] ANDIFRUN ; IMMEDIATE                                         : BECAUSE 1 -IF-FINISHED? ! ADD4           GETCLAUSE ADD ; IMMEDIATE                                                    : DONE                                     -FINISHED? @ [ FORTH ]                    IF ADD0 0 ADD ( LAST END FLAG )         THEN FORTH ;                                                               -->                                                                                                                                                                                                                              ( MVP-FORTH )                                                                  ( EXPERT-2 RULE COMPILER <10/ 9/83>049)                                         FORTH DEFINITIONS                                                                                                       : RULES [COMPILE] RULE HERE                RULESTK ! 0 #RULES !                    STRINGSTART STRINGS !                   HYPSTACK 256 ERASE                      RULE 0 -FINISHED? ! ;                                                        EXIT                                                                            "RULES" STARTS THE RULE COMPILING AT    STRINGSTART. THIS IS A MEMORY LOCATION  THAT MUST BE SELECTED TO ALLOW ENOUGH   BUFFER SPACE TO CONTAIN THE PROGRAMS    RULES.                                                                                                                                                                                                                                                                   ( MVP-FORTH )                                                                  ( EXPERT-2               <10/ 9/83>050)                                         EXIT                                                                            TO COMPILE EXPERT:                                                              LOAD MVP-FORTH                                                                  COMPILE EXPERT                           LOAD SCREEN 8 (148) FOR MVP-FORTH       LOAD SCREEN 9 (149) FOR APPLE PADS                                             COMPILE RULES                            LOAD SCREEN 60 (200) FOR ANIMALS                                                                                       RUN EXPERT:                             TYPE                                       DIAGNOSE                             AND ANSWER QUESTIONS.                                                                                                                                                                    ( MVP-FORTH )                                                                  ( EXPERT-2  NOTES        <10/ 9/83>051)                                         EXIT                                                                            TO GENERATE RULE BASE:                                                          1. USE FORTH EDITOR OF YOUR CHOICE.                                             2. SELECT BLOCKS OF YOUR CHOICE.                                                3. CLEAR SCREENS WITH "CLEAR" OR "WIPE"                                         4. START RULE BASE WITH                     : WALL ;   ( OR OTHER FENCE )          THIS GIVES YOU SOMETHING TO "FORGET"    IF YOU WANT TO LOAD A DIFFERENT RULE    BASE AFTER RUNNING ONE BY USING          "FORGET WALL" AND LOADING THE OTHER    RULE BASE.                                                                          FORGET WALL                                                                                                                               ( MVP-FORTH )                                                                  ( EXPERT-2 USER NOTES    <11/11/83>052) EXIT                                                                            RULE BASE GENERATION.                                                           1) USE PARENTHESES ( AND ) WITH A SPACE    AFTER THE FIRST "(" TO GENERATE         COMMENTS. TYPICAL COMMENTS MIGHT BE:    ( ANIMAL RULES ) AT LINE 0 OF A           SCREEN AS A SCREEN IDENTIFIER.        ( RULE 0 ) FOR THE FIRST RULE.          ( RULE 1 ) FOR THE SECOND RULE.                                              2) ACTUAL RULES START AFTER USE OF THE     WORD "RULES".                                                                3) RUN-TIME EQUATIONS ARE COMPILED         BEFORE "RULES"- TO ALLOW RULES TO       CALL THESE RUN-TIME EQUATIONS.                                               4) RULES END WITH THE WORD "DONE".                                                                                                               ( MVP-FORTH )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ( EXPERT-2 USER NOTES    <11/11/83>055)                                         ( SAMPLE RULE BASE: )                                                           : WALL ;                                                                        : TESTWORD                                 CR ." ENTER A NUMBER (1 TO 10) "        KEY 53 >  ( ASCII 5 )  CR                 IF TRUE ." T "                             ( RETURN TRUE IF > 5 )               ELSE FALSE                                 ( OTHERWISE RETURN FALSE )           THEN ;                                                                                                             -->                                                                                                                                                                                                                                                                                                              ( MVP-FORTH )                                                                  ( EXPERT-2 USER NOTES    <11/11/83>056)                                         RULES                                                                           IF WE ARE READY TO BEGIN                ANDIFRUN TESTWORD                       BECAUSE A NUMBER > 5 IS NEEDED          THEN A NUMBER > 5 IS AVAILABLE                                                  IF A NUMBER > 5 IS AVAILABLE            THENHYP ALL CONDITIONS ARE SATISFIED                                            DONE                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ( MVP-FORTH )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ( ANIMALS   RULE BASE    <10/ 9/83>060)                                         : WALL ;    ( SOMETHING TO FORGET )                                             RULES                                                                           ( RULE 0 )                              IFNOT ANIMAL IS BIRD                    ANDIF ANIMAL HAS HAIR                   THEN ANIMAL IS MAMMAL                   BECAUSE HAIRY MILK-GIVERS ARE MAMMALS                                           ( RULE 1 )                              IFNOT ANIMAL IS BIRD                    ANDIF ANIMAL GIVES MILK                 THEN ANIMAL IS MAMMAL                                                                                                   -->                                                                                                                                                                                                                              ( MVP-FORTH )                                                                  ( ANIMAL GAME            <10/ 9/83>061)                                         ( RULE 2 )                              IF ANIMAL HAS FEATHERS                  THEN ANIMAL IS BIRD                     BECAUSE BIRDS WITHOUT FEATHERS?                                                 ( RULE 3 )                              IF ANIMAL FLIES                         AND ANIMAL LAYS EGGS                    THEN ANIMAL IS BIRD                                                             ( RULE 4 )                              IFNOT ANIMAL IS UNGULATE                AND ANIMAL EATS MEAT                    THEN ANIMAL IS CARNIVORE                                                        -->                                                                                                                                                                                                                                                                                                                                                     ( ANIMAL GAME            <10/ 9/83>062)                                         ( RULE 5 )                              IFNOT ANIMAL IS UNGULATE                AND ANIMAL HAS POINTED TEETH            AND ANIMAL HAS CLAWS                    AND ANIMAL HAS FORWARD EYES             THEN ANIMAL IS CARNIVORE                                                        ( RULE 6 )                              IF ANIMAL IS MAMMAL                     AND ANIMAL HAS HOOFS                    BECAUSE UNGULATES HAVE HOOVES           THEN ANIMAL IS UNGULATE                                                         ( RULE 7 )                              IF ANIMAL IS MAMMAL                     AND ANIMAL CHEWS CUD                    BECAUSE UNGULATES CHEW CUD              THEN ANIMAL IS UNGULATE                 ANDTHEN ANIMAL IS EVEN TOED                                                     -->                                                              ( MVP-FORTH )                                                                  ( ANIMALS GAME           <10/ 9/83>063)                                         ( RULE 8 )                              IF ANIMAL IS MAMMAL                     AND ANIMAL IS CARNIVORE                 AND ANIMAL HAS TAWNY COLOR              AND ANIMAL HAS DARK SPOTS               THENHYP ANIMAL IS CHEETAH                                                       ( RULE 9 )                              IF ANIMAL IS MAMMAL                     AND ANIMAL IS CARNIVORE                 AND ANIMAL HAS TAWNY COLOR              AND ANIMAL HAS DARK STRIPES             THENHYP ANIMAL IS TIGER                                                         ( RULE 10 )                             IF ANIMAL IS UNGULATE                   AND ANIMAL HAS LONG NECK                AND ANIMAL HAS LONG LEGS                AND ANIMAL HAS DARK SPOTS               THENHYP ANIMAL IS GIRAFFE                                                       -->                      ( MVP-FORTH )                                                                  ( ANIMAL GAME            <10/ 9/83>064)                                         ( RULE 11 )                             IF ANIMAL IS UNGULATE                   AND ANIMAL HAS BLACK STRIPES            THENHYP ANIMAL IS ZEEBRA                                                        ( RULE 12 )                             IF ANIMAL IS BIRD                       ANDNOT ANIMAL FLIES                     ANDNOT ANIMAL SWIMS                     AND ANIMAL HAS LONG NECK                AND ANIMAL IS BLACK AND WHITE           THENHYP ANIMAL IS OSTRICH                                                       ( RULE 13 )                             IF ANIMAL IS BIRD                       ANDNOT ANIMAL FLIES                     AND ANIMAL SWIMS                        BECAUSE PENGUIN IS A BIRD THAT SWIMS    AND ANIMAL IS BLACK AND WHITE           THENHYP ANIMAL IS PENGUIN                                                       -->                      ( MVP-FORTH )                                                                  ( ANIMAL GAME            <10/ 9/83>065)                                         ( RULE 14 )                             IF ANIMAL IS BIRD                       AND ANIMAL FLIES                        AND ANIMAL FLIES WELL                   THENHYP ANIMAL IS ALBATROSS                                                     DONE                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ( MVP-FORTH )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ( DIAGNOSTIC ROUTINE     <10/12/83>210)                                         FORGET WALL : WALL ;  RULES                                                     IFNOT  E IS TRUE                        ANDNOT F IS TRUE                        THEN CHIP 3 IS BAD                      IFNOT  C IS TRUE                        AND    E IS TRUE                        THEN CHIP 2 IS BAD                      IFNOT  D IS TRUE                        AND    E IS TRUE                        THEN CHIP 2 IS BAD                      IF     E IS TRUE                        AND    F IS TRUE                        THENHYP CHIP 3 IS BAD                                                           -->                                                                                                                                                                                                                                                                      ( MVP-FORTH )                                                                  ( DIAGNOSTIC ROUTINE     <10/12/83>211)                                         IFNOT E IS TRUE                         AND   C IS TRUE                         AND   D IS TRUE                         THENHYP CHIP 2 IS BAD                   IFNOT C IS TRUE                         AND   A IS TRUE                         AND   B IS TRUE                         THENHYP CHIP 1 IS BAD                                                           DONE                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     ( MVP-FORTH )