home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / dtx9202 / grampars / prolog / pl_parse.pro < prev    next >
Encoding:
Text File  |  1992-01-09  |  3.4 KB  |  138 lines
  1.  
  2. ausdruck(e,n,m,[x,y]) :- formel(e,n,m,[x,y]).
  3.  
  4. formel(e,n_,m,[x,y]) :- formel_(v,0,p,n,m,[x,z]),
  5.                         rest-formel(p,e,n_,n,[z,y]).
  6.  
  7. formel_(v,w,p,n_,m,[x,y]) :- primary(f,n,m,[x,z]),
  8.                              rest-formel_(v,w,f,p,n_,n,[z,y]).
  9.  
  10. primary(e,n,m,[x,y]) :-
  11.    wort('(',[x,z]),
  12.    ausdruck(e,n,m,[z,t]),
  13.    wort(')',[t,y]).
  14. primary(p,n,m,[x,y]) :-
  15.    praedikat(p,n,m,[x,y]).
  16. primary(e,n_,m,[x,y]) :-
  17.    quantifizierung(p,e,n,m,[x,z]),
  18.    primary(p,n_,n,[z,y]).
  19. primary([o-a,p],n,m,[x,y]) :-
  20.    wort(a,[x,z]),
  21.    junktor(6,a,o-a),
  22.    primary(p,n,m,[z,y]).
  23.  
  24. rest-formel_(v_,v,p,[o-a,p,p_],n,m,[x,y]) :-
  25.    wort(o,[x,z]),
  26.    junktor(w,o,o-a),
  27.    eval(v,w),
  28.    formel_(v_,w,p_,n,m,[z,y]).
  29. rest-formel_(v,v,e,e,m,m,[x,x]) .
  30.  
  31. rest-formel(p,[o-a,p,p_],n,m,[x,y]) :-
  32.    wort(o,[x,z]),
  33.    junktor(w,o,o-a),
  34.    formel(p_,n,m,[z,y]).
  35. rest-formel(e,e,m,m,[x,x]) .
  36.  
  37. quantifizierung(p-atom,uni(n,p-atom),p,q,[x,y]) :-
  38.    wort(a,[x,z]),
  39.    quantor(k,a,uni),
  40.    wort(v-ar,[z,y]),
  41.    diff-oder-gleich([n,v-ar],q,p).
  42. quantifizierung(p-atom,exi(n,p-atom),p,q,[x,y]) :-
  43.    wort(a,[x,z]),
  44.    quantor(k,a,exi),
  45.    wort(v-ar,[z,y]),
  46.    diff-oder-gleich([n,v-ar],q,p).
  47.  
  48. praedikat([a,a-rg],n,m,[x,y]) :-
  49.    wort(a,[x,u]),
  50.    upletter(a),
  51.    wort('(',[u,v]),
  52.    argumente(a-rg,n,m,[v,w]),
  53.    wort(')',[w,y]).
  54.  
  55. upletter(a) :-
  56.    char-code(a,a_),
  57.    val(inf(a_,91),b),
  58.    val(inf(64,a_),b).
  59.  
  60. /* argumente(n;b,p,q,[x,y]) :-
  61.    wort(a,[x,z]),
  62.    wort(',',[z,v]),
  63.    diff-oder-gleich-argumente([n,a],q,p_),
  64.    argumente(b,p,p_,[v,y]).
  65. argumente(n;nil,p,q,[x,y]) :-
  66.    wort(a,[x,y]),
  67.    diff-oder-gleich-argumente([n,a],q,p).
  68. argumente(nil,p,p,[x,x]) . */
  69.  
  70. junktor(6,'┬',neg) .
  71. junktor(5,'&',konj) .
  72. junktor(4,'#',disj) .
  73. junktor(3,']',re-impl) .
  74. junktor(3,'[',li-impl) .
  75.  
  76. quantor(2,'⌐',uni) .
  77. quantor(1,'¿',exi) .
  78.  
  79. wort(a,[a;x,x]) .
  80.  
  81. eval(w_,w) :-
  82.    val(eql(w_,w),1).
  83. eval(w_,w) :-
  84.    val(inf(w_,w),1).
  85.  
  86. diff-oder-gleich([k_,n],nil,[k_,n];nil) .
  87. diff-oder-gleich([k,n],[k,m];q,[k,m];q) :-
  88.    eq(n,m).
  89. diff-oder-gleich([k,n],[k_,m];q,[k_,m];p) :-
  90.    dif(n,m),
  91.    diff-oder-gleich([k,n],q,p).
  92.  
  93. diff-oder-gleich-argumente([k,n],[k,m];q,[k,m];q) :-
  94.    eq(n,m).
  95. diff-oder-gleich-argumente([k,n],[k_,m];q,[k_,m];p) :-
  96.    dif(n,m),
  97.    diff-oder-gleich-argumente([k,n],q,p).
  98.  
  99. lesen(nil) :- next-char_('.') / in-char_('.').
  100. lesen('⌐';b) :- next-char_('⌐') / in-char_('⌐'), lesen(b).
  101. lesen('¿';b) :- next-char_('¿') / in-char_('¿'), lesen(b).
  102. lesen(a.b) :- in-char_(a) / lesen(b).
  103. lesen(a.b) :- in-integer(a), lesen(b).
  104.  
  105. pl :-
  106.    terminologie,
  107.    repeat,
  108.    line,
  109.    outm('Ausdruck:   '),
  110.    lesen(p),
  111.    analysiere(p,e),
  112.    outm('Semantik:   '),
  113.    outl(e),
  114.    fail.
  115.  
  116. terminologie :-
  117.    line,
  118.    outml('Junktoren:   &  Konjunktion'),
  119.    outml('             #  Adjunktion'),
  120.    outml('             ]  Implikation   (rechts-gerichtet)'),
  121.    outml('             [  Implikation   (links-gerichtet)'),
  122.    outml('             ┬  Negation          (ASCII 194)')
  123.    line
  124.    outml('Quantoren:   ⌐  Allquantor        (ASCII 169)')
  125.    outml('             ¿  Existenzquantor   (ASCII 168)')
  126.    line
  127.    outml('Funktion:    alphabetische GROSSE Einzel-Zeichen oder Zeichenfolgen')
  128.    outml('Atome:       alphabetische kleine Einzel-Zeichen oder Zeichenfolgen').
  129.  
  130. /* repeat .
  131.    repeat :- repeat. */
  132.  
  133. analysiere(p,e) :- ausdruck(e,n,nil,[p,nil]) .
  134. analysiere(p,e) :- outml('...  ist nicht wohlgeformt'), fail.
  135.  
  136.  
  137.  
  138.