
;----------------------------------------------------------------------------;
;                  Paquet Interpreteur version  pour les tests               ;
;----------------------------------------------------------------------------;

; = EstVrai(Interpreteur);
  = MC(Priorite 1)
 ; = EstFaux(Descend);
;  = PileCreer(PBut.PPaq 100);
; pour indiquer si on parcourt l arbre d evaluation en montee ou en descente;

#Interpreteur

		;-----------------------------------;
		; Traitement de but de type ButSVS ;
		;-----------------------------------;


 $RPaquets

;  cette regle determine l ensemble des paquets associes aux differents ;
;  sousbut et demande leur saturation dans le cas d un but de type;
;  But a sequence de validation statique ButSVS ;

AussitotQue

	Vrai(Interpreteur)
	RE (Question    :q	vrai	   )
	RE (AEmpiler	:sb	:q	   )
 	ME (Priorite	:q	:sb	:pr)
 	RE (InfPrior	:m	vrai	   )
 	Egal(:m 	:pr		   )
 	Plus(:min	1	:m	   )
 	RE(PaquetAssocie	:sb	:pq)
 	RE( Entete	:pq	:e         )
 	Vrai(Descend)

REPETE
	Empiler(PPaq	:pq		)
	Empiler(PBut	:sb		)
	PEmpilerPaquet(	:pq		)
	RD(InfPrior	:m	vrai	)
	RD (AEmpiler	:sb	:q	)
	RA(InfPrior	:min	vrai	)	
	EstVrai(	:e		)
	EstVrai(TraitementButSVS)
	


		;-----------------------------------;
		; Traitement de but de type ButSVD ;
		;-----------------------------------;


$RUniqueButSVD

AussitotQue
	(Existe :q)
	(Soit :e RE(PaquetAssocie	:q  :e))
	(Existe :n)
	EnsCardinal (:e	:n)
	Egal(1 :n)
	Vrai(Interpreteur)
	RE (Question     :q 	vrai )
	RE (But	         :q  	vrai )
	RE(TypeBut       :q 	ButSVD)	 
	Vrai      (Descend     )	; si l'on est en descente ;
ALORS
	RA(UniqueAlternative :q vrai)
	EstFaux(Descend)
   

	

$RMultipleButSVD

AussitotQue
	(Existe :q)
	(Soit :e RE(PaquetAssocie	:q	 :e))
	(Existe :n)
	EnsCardinal (:e	:n)
	Non Egal(1 :n)
	Vrai(Interpreteur)
	RE (Question     :q 	vrai )
	RE (But	         :q  	vrai )
	 
	RE(TypeBut       :q 	ButSVD) ; teste s'il existe  plusieurs paquet ;
	Vrai      (Descend     )	; si l'on est en descente ;
ALORS
	RA(MultipleAlternative  :q vrai)
	EstFaux(Descend)

$RAUButSVD

; cas simple ou volume paquets associes egal 1 ;

AussitotQue
	RE (Question     :q 	vrai )
	RE (But	         :q  	vrai )
	RE(UniqueAlternative 	:q	vrai)
	RE(Entete 	 :paq  	:e )
	RE(PaquetAssocie	:q 	:paq  )
	Non RE(Traite :q vrai)
	Non PilePleine(PPaq)
	Non PilePleine(PBut)
	PileMax   (PBut   :i   )	; soit i l'indice du sommet de pile ;
	
ALORS

	Empiler(PPaq :paq)
	Empiler(PBut :q)
	EstVrai(:e)
	PEmpilerPaquet(:paq)
	EstFaux(Interpreteur)
	RA(Traite :q vrai)
	RA  (Examine :i :paq)		; maj l'ens.des paq.examines au niv i ;
	EstVrai(Descend)
	Oublie()


$RAMButSVD

; cas  ou volume paquets associes different de 1 ;

AussitotQue
	Vrai(Interpreteur)
	Vrai(Descend)
	RE(MultipleAlternative :q	vrai)
	;RE(Heuristique	:q	:paq);	
	RE(Entete 	 :paq  	:e )
	Non RE(Traite :q vrai)
	Non PilePleine(PPaq)
	Non PilePleine(PBut)
	PileMax   (PBut   :i   )	; soit i l'indice du sommet de pile ;
	
ALORS

	Empiler(PPaq :paq)
	Empiler(PBut :q)
	EstVrai(:e)
	PEmpilerPaquet(:paq)
	EstFaux(Interpreteur)
	RA(Traite :q vrai)
	RA  (Examine :i :paq)		; maj l'ens.des paq.examines au niv i ;
	Oublie()



$RButSatisfait

AussitotQue

	Vrai(Interpreteur)
	RE (Question    :q vrai)
	PileSommet(PPaq :q)
	PileSommet(PBut :q)		
	RE(Reussite 	:q vrai)
	RE(PaquetAssocie :q 	:paq  )
ALORS
	Depiler(PBut)
	Depiler(PPaq)
        RD(Question :q vrai)
        RD(Traite :q vrai) 
        PDebutEnsemble()
	;Imprime(Le but :q est satisfait );
        PFinEnsemble()
	PTermine(:paq)
	EstVrai(Descend)
	Oublie() 

= RA(InfPrior 1 vrai)


$RTraitSVS

; pour un but de type ButSVS on determine ses sous-buts;

AussitotQue

	Vrai(Interpreteur)
 	RE(Question	:q	vrai)
	RE(But		:q	vrai)
 	RE(TypeBut	:q	ButSVS)
	Vrai      (Descend     )	; si l'on est en descente ;
 	RE(SousBut	:q	:sb)
	
ALORS
 	RA(AEmpiler	:sb	:q)
 	Oublie()


$REmpilerSousButs

AussitotQue
	Vrai(Interpreteur)
	Vrai(Descend)
	Vrai(TraitementButSVS)
	RE (AEmpiler	:sb	:q   )
	
ALORS
   	EstFaux(Interpreteur)
	RA(Traite :q vrai)
 	Oublie()



		;----------------------------;
		; Traitement de fin de paquet;
		;----------------------------;


;---------------------------------------------------;
; fin d un paquet d un sous-but par un paquet actif ;
;---------------------------------------------------;
$ RFinPaquet
SI
 Vrai (Interpreteur  )		; si l'interpreteur est actif ;
 Faux (Descend     )		; si l'on est en remontee ;	
 PileMax (PBut      :i)		; soit i l'indice du sommet de pile ;
 PileLast(PPaq      :p)		; soit p le paquet precedent ;
 RE(Entete :p :e)		; soit e l'entete du paquet p ;
ALORS
 Depiler(PBut      )		; depile le but que l'on vient de traiter ;
 Depiler(PPaq      )		; depile le paquet associe;
 RD (Examine :i :p)       ;  Samia detruit l'ens.des paq.examines au niveau i ;
 EstVrai(:e        )		; reactive le paquet precedant p ;
 EstFaux(Interpreteur)		; l'interpreteur n'est plus actif ;

;---------------------------------------------------;
;     fin d un paquet active par l interpreteur     ;
;---------------------------------------------------;

$ RFinPaquetSVD1

SiPasAutre
 Vrai    (Interpreteur  )	; si l'interprete est actif ;
 RE(Traite :q vrai)
 RE(UniqueAlternative :q vrai)
 Faux    (Descend     )		; si l'on est en remontee ;
 RE(Reussite	:paq 	:r)		; si l'on n'est pas sur un echec ;
 RE(Question :q vrai)
 RE(PaquetAssocie :q :paq)
 Non PileVide(PPaq)
 Non PileVide(PBut)
ALORS
 Depiler(PBut      )		; depile le but que l'on vient de traiter ;
 Depiler(PPaq      )		; depile le dernier paquet ;
 EstVrai(Interpreteur)		; l'interpreteur n'est plus actif ;
 PDebutEnsemble()
 Imprime (Resultat :paq :r)     ; pour la regle d'initialisation des par ;
 PFinEnsemble()
 RD( Question :q vrai)
 RD( Traite :q vrai)
 RD(UniqueAlternative :q vrai)
 EstVrai(Descend)
 PTermine (:q)



$RFinPaquetReussiSVDn

SiPasAutre
 Vrai    (Interpreteur  )	; si l'interprete est actif ;
 RE(Traite :q vrai)
 RE(MultipleAlternative :q vrai)
 Faux    (Descend     )		; si l'on est en remontee ;
 RE(Reussite	:paq 	vrai)		; si l'on n'est pas sur un echec ;
 RE(Question :q vrai)
 RE(PaquetAssocie :q :paq)
 Non PileVide(PPaq)
 Non PileVide(PBut)
ALORS
 Depiler(PBut      )		; depile le but que l'on vient de traiter ;
 Depiler(PPaq      )		; depile le dernier paquet ;
 EstVrai(Interpreteur)	
 PDebutEnsemble()               ; l'interpreteur n'est plus actif ;
 Imprime (Resultat :paq vrai)
 PFinEnsemble()
 RD( Question :q vrai)
 RD( Traite :q vrai)    ; pour la regle d'initialisation des par ; 
 EstVrai(Descend)
 PTermine (:q)
 

;---------------------------------------------------------;
; fin  echec partiel d un paquet active par l interpreteur;
;---------------------------------------------------------;

$ RFinPaquetEchecSVDn
SI
 (Existe :q)
 (Existe ! :paq)
 (Existe ! :i)
 (Existe ! :e)
 Vrai      (Interpreteur    )	; si l'interprete est actif ;
 Faux      (Descend       )	; si l'on est en remontee ;
 RE (Reussite :q 	Faux )	; si l'on est sur un echec ;
 PileSommet(PBut     :q   )	; soit b le but en sommet de pile ;
 RE(PaquetAssocie      :q :paq)	; teste s'il existe un paquet p ;
 non RE    (Examine  :i :paq)	; pas encore lance au niveau i ;
 PileMax   (PBut     :i   )	; pour traiter le but b ;
 RE        (Entete   :paq :e)	; soit e l'entete associee au paquet p ;
ALORS
 Depiler(PPaq         )		; depile le paquet ayant rendu l'echec ;
 Empiler(PPaq    :paq   )	; et empile le nouveau paquet que l'on essaye ; 
 RA     (Examine :i :paq)		; maj l'ens.des paq.examines au niveau i ;
 EstVrai(:e           )		; active le nouveau paquet empile ;
 EstFaux(Interpreteur   )	; l'interprete n'est plus actif ;
 PEmpilerPaquet(:paq)


;----------------------------------------------------------------------------;
;          Declarations de paquet de faits de l interpreteur                 ;
;----------------------------------------------------------------------------;



;------------------------------------;
; Faits decrivant l'application RPAS ;
;------------------------------------;

; Declaration du Meta-But RPAS et des buts associes;

; Buts: Traduction, Correspondance;

;          *** TRADUCTION *** 		;

= RA (But traduction	 vrai)                  

= RA (TypeBut traduction	 ButSVS)
                   
= RA (SousBut traduction   tradcanport.liencanport.inscaligne.
			  tradprocessus.instports.instprocessus    )
			  
= RA( PaquetAssocie	tradcanport	tradcanport	)
= RA( PaquetAssocie	liencanport	liencanport	)
= RA( PaquetAssocie	inscaligne	inscaligne	)
= RA( PaquetAssocie	tradprocessus	tradprocessus	)
= RA( PaquetAssocie	instports	instports	)
= RA( PaquetAssocie	instprocessus	instprocessus	)
			  
= MA( Priorite 		traduction      tradcanport     6)      
= MA( Priorite 		traduction      liencanport     5)
= MA( Priorite 		traduction      inscaligne      4)
= MA( Priorite 		traduction      tradprocessus   3)      
= MA( Priorite 		traduction      instports       2)
= MA( Priorite 		traduction      instprocessus   1)

= RA( Entete		TradCanPort	traductiontest	)
= RA( Entete		LienCanPort 	traductiontest)
= RA( Entete		InsCaLigne 	traductiontest)
= RA( Entete		TradProcessus 	traductiontest)
= RA( Entete		InstPorts  	traductiontest)
= RA( Entete		InstProcessus	traductiontest	)


;          *** CORRESPONDANCE ***                ;

=RA (But correspondance	 vrai) 
=RA (TypeBut 		Correspondance	ButSVD)
=RA (PaquetAssocie	Correspondance	correspondance)
=RA (Entete		correspondance	correspondancetest )


;----------------------------------------------;
; Faits decrivants l'application RdpOrdinaires ;
;----------------------------------------------;

; Declaration des Meta-Buts de RdpOrdinaires et sous buts associes;

; Meta-but : Reduction, SousClasses, Simulation ;
 
= RA ( But		reduction		Vrai)
= RA ( But		sousclasse		Vrai)
= RA ( But		simulation		Vrai)
= RA ( But 		vivacite		Vrai)
= RA ( But 		graphe			Vrai)
= RA ( But 		medium			Vrai)

= RA ( TypeBut		sousclasse 		ButSVD )
= RA ( TypeBut		simulation		ButSVD )
= RA ( TypeBut 		reduction		ButSVD )
= RA ( TypeBut 		vivacite		ButSVD )
= RA ( TypeBut 		graphe			ButSVD )
= RA ( TypeBut 		medium			ButSVD )


= RA ( PaquetAssocie	sousclasse		sousclasse)
= RA ( PaquetAssocie	simulation		simulation)
= RA ( PaquetAssocie 	reduction		reduction)
= RA ( PaquetAssocie 	vivacite		vivacite)
= RA ( PaquetAssocie 	graphe			graphe)
= RA ( PaquetAssocie 	medium			medium)
 
= RA ( Entete		vivacite		vivacitetest)
= RA ( Entete		sousclasse		sousclassetest)
= RA ( Entete  		simulation		simulationtest)
= RA ( Entete  		graphe			graphetest)
= RA ( Entete  		medium			mediumtest)
= RA ( Entete		reduction		reductiontest)

