Annexe 3 : la représentation textuelle

Les contextes

ctx1

(def ctx1
   ((def NOM () ("1"))
    (def RANG
       ((def borne () ("LM1"))
        (def RGPHY () ("H"))
        (def CONV-RGLOG () ("RG1({RGLOG})"))
        (def NUM-LOG () ("1"))
        (ref fic ((comm)))))
    (def OBJ
       ((def val
           ((def test () ("X1C")))
           ("X1"))
        (def aux
           ((def test () ("Y1C")))
           ("Y1"))))))

ctx2

(def ctx2
   ((def NOM () ("2"))
    (def RANG
       ((def borne () ("LM2"))
        (def CONV-RGLOG () ("TX2({RGLOG})"))
        (ref tab ((comm)))))
    (def OBJ
       ((def val
           ((def test () ("{val}")))
           ("X2"))
        (def aux
           ((def test () ("{val}")))
           ("Y2"))))))

ctx3

(def ctx3
   ((def NOM () ("3"))
    (def RANG
       ((def borne () ("LM3({CLE-LOG})"))
        (def RGPHY () ("H"))
        (def CONV-RGLOG () ("RG3({RGLOG})"))
        (def NUM-LOG () ("3"))
        (ref fic ((comm)))))
    (def OBJ
       ((def val
           ((def cle () ("X3NB"))
            (def test () ("X3C")))
           ("X3"))
        (def aux
           ((def cle () ("Y3NB"))
            (def test () ("Y3C")))
           ("Y3"))))))

ctx4

(def ctx4
   ((def NOM () ("4"))
    (def RANG
       ((def borne () ("LM4"))
        (def RGPHY () ("H"))
        (def CONV-RGLOG () ("RG4({RGLOG})"))
        (def NUM-LOG () ("4"))
        (ref fic ((comm)))))
    (def OBJ
       ((def val
           ((def test1 () ("X4C1"))
            (def test2 () ("X4C2"))
            (def test3 () ("X4C3")))
           ("X4"))
        (def aux
           ((def test1 () ("Y3C1"))
            (def test2 () ("Y3C2"))
            (def test3 () ("Y4C3")))
           ("Y4"))))))

La recherche générique

(def Rechercher
   ((def schema
       ((def fin ()
           ("MEN={CR}
             RETURN")))
       ("140   {CLE}={CLE-ORIGINE}
         145   IF {CLE}={CLE-MAX} GOTO 147
               {CLE}={CLE}+1
               {lect ((RANG)
                      (def RGLOG () ("{CLE}"))
                      (def VAL   () ("{aux((OBJ))}")))}
               {proc-test}
               {fin ((def CR () ("0")))}
         147   {CLE}={CLE}+1
         148   {fin ((def CR () ("1")))}"))
    (def proc-test ()
       ("IF {test-aux}<{test-val} GOTO 145
         IF {test-aux}>{test-val} GOTO 148
         {suite}"))
    (def test-val () ("{test((val((OBJ))))}"))
    (def test-aux () ("{test((aux((OBJ))))}"))
    (def suite () ())
    (def CLE-ORIGINE () ("0"))
    (def CLE-MAX () ("{borne((RANG))}"))
    (def CLE () ("M"))))

Les recherches contextuelles

rech1

(schema
   ((ctx1)
    (Rechercher)))

rech2

(schema
   ((ctx2)
    (Rechercher)))

rech3

(schema
   ((ctx3)
    (def CLE-ORIGINE ()
       ("{borne
            ((def CLE-LOG () ({cle((val((OBJ))))}-64)))}"))
    (def CLE-MAX ()
       ("{borne
            ((def CLE-LOG () ({cle((val((OBJ))))}-63)))}"))
    (Rechercher)))

rech4

(schema
   ((ctx4)
    (def test-val () ("{test1((val((OBJ))))}"))
    (def test-aux () ("{test1((aux((OBJ))))}"))
    (def suite ()
       ("{proc-test
            ((def test-val () ("{test2((val((OBJ))))}"))
             (def test-aux () ("{test2((aux((OBJ))))}"))
             (def suite ()
                ("{proc-test
                     ((def test-val () ("{test3((val((OBJ))))}"))
                      (def test-aux () ("{test3((aux((OBJ))))}"))
                      (def suite () ())))}")))}"))
    (Rechercher)))