UpsPrs.AnalyseurLexical

Définition


/****************************************************************/

Type AnalyseurLexical Defaut Final TailleSegment 2

/* Objet : Definition d'un analyseur lexical.                   */

/****************************************************************/

/*-------------------------------------------------------------*/

/* Heritage des proprietes d'Objet.  */

/*-------------------------------------------------------------*/

Prive :

	
	EstInstanceDe : Type Lecture Public;

/*-------------------------------------------------------------*/

/* Proprietes propres.                                     */

/*-------------------------------------------------------------*/

Prive :

	
   NomAnalyseur : Caractere Lecture Public Trace;
	

   PaquetLexicalGlobal : Nul Ou PaquetLexical Lecture Public;
	

   ChaineGuillemetsReconnue : Booleen Lecture Public;
	

   ChaineApostrophesReconnue : Booleen Lecture Public;
	

   ChaineChevronsReconnue : Booleen Lecture Public;
	

   CommentaireBlocReconnu : Booleen Lecture Public;
	

   CommentaireLigneReconnu : Booleen Lecture Public;
	

   EntierReconnu : Booleen Lecture Public;
	

   ReelReconnu : Booleen Lecture Public;
	

   IdentificateurReconnu : Booleen Lecture Public;
	

   MajusculesIgnorees : Booleen Lecture Public;
	

   CommandesPreprocesseurIgnorees : Booleen Lecture Public;

/*-------------------------------------------------------------*/

/* Heritage des methodes d'Objet.    					      */

/*-------------------------------------------------------------*/

Public :

	
	Fonction Optimiser(Invariant) Identique(O : Nul Ou Objet) Retourner Nul Ou Booleen;
	

	Procedure Convertir(O : Nul Ou Objet);
	

	Fonction Optimiser(Invariant) CreeParLeServeur() Retourner Entier;
	

	Fonction Optimiser(Invariant) CreeParLeProcessus() Retourner Entier;
	

	Fonction Optimiser(Invariant) CreeDansLEntrepot() Retourner Entrepot;
	

	Fonction Cloner(EntrepotCible : Nul Ou Entrepot=Nul, Profondeur : ModeClonage = ClonageObjetSeul) Retourner Nul Ou Objet;
	

	Fonction LirePropriete(NomPropriete : Caractere) Retourner Nul Ou Objet;
	

	Procedure EcrirePropriete(NomPropriete : Caractere, Valeur : Nul Ou Objet);
	

	Fonction IncrementerDecrementerPropriete(NomPropriete : Nul Ou Caractere, Incrementer : Booleen, Prefixe : Booleen) Retourner Nul Ou Objet;
	

	Procedure SupprimerPropriete(NomPropriete : Caractere);
	

	Fonction Optimiser(Invariant) EnumererProprietes(NumeroPropriete : Entier, TypePropriete : Nul Ou Type=? Sortie, PeutEtreNul : Booleen=? Sortie, Aide : Nul Ou Caractere=? Sortie, NomEnumere : Nul Ou Caractere=? Sortie) Retourner Nul Ou Caractere;
	

	Fonction Optimiser(Invariant) Adresse() Retourner Nul Ou Caractere;

Prive :

	
	Fonction Exporter(E : Nul Ou IEchangeElementaire) Retourner Boolean;
	

	Fonction Importer(E : Nul Ou IEchangeElementaire, EntrepotCible : Nul Ou Entrepot=Nul, EstFiltre : Booleen=Faux, V : Entier=0, R : Entier=0, C : Entier=0) Retourner Nul Ou Objet;

/*-------------------------------------------------------------*/

/* Methodes propres.    					      */

/*-------------------------------------------------------------*/

Public :

	
   Constructeur Habilitation Optimiser(NulAbsorbant) (Nom : Nul Ou Caractere, ReconnaitreChaineGuillemets : Booleen, 
   

      ReconnaitreChaineApostrophes  : Booleen, ReconnaitreChaineChevrons  : Booleen,
      ReconnaitreCommentaireBloc : Booleen, ReconnaitreCommentaireLigne : Booleen, ReconnaitreEntier : Booleen, ReconnaitreReel : Booleen, ReconnaitreIdentificateur : Booleen, 
      IgnorerMajuscules : Booleen, IgnorerCommandesPreprocesseur : Booleen,
      LireCommentaireIdentifiant : Nul Ou Fonction(Identifiant : Entier, Liaison : Booleen) Retourner Nul Ou Caractere=Nul,
      ConserverInclusion : Nul Ou Fonction(NumeroLigne : Entier, NomFichierSource : Caractere, ArreterAnalyse : Booleen Sortie) Retourner Booleen=Nul,
      ConserverPragma : Nul Ou Procedure(Pragma : Caractere)=Nul);
   
	
   Operateur Optimiser(Invariant, NulAbsorbant) ==(A : Nul Ou AnalyseurLexical) Retourner Nul Ou Booleen;
	

   Operateur Optimiser(Invariant, NulAbsorbant) !=(A : Nul Ou AnalyseurLexical) Retourner Nul Ou Booleen;
	

   Procedure Optimiser(NulAbsorbant) AjouterSeparateur(Separateur : Nul Ou Caractere, Conserver : Booleen=Faux);
	

   Procedure Optimiser(NulAbsorbant) SupprimerSeparateur(Separateur : Nul Ou Caractere);
	

   Procedure AutoriserChainesChevrons(Autoriser : Booleen);
	

   Procedure Optimiser(NulAbsorbant) AjouterElementLexical(Symbole : Nul Ou Caractere, Identifiant : Entier, Position : PositionElementLexical=PositionLibre, Paquet : Nul Ou PaquetLexical=Nul, Valeur : Nul Ou Objet=Nul);
	

   Procedure Optimiser(NulAbsorbant) ChercherElementLexical(Symbole : Nul Ou Caractere, Paquet : Nul Ou PaquetLexical, Identifiant : Entier Sortie, Valeur : Nul Ou Objet=Nul Sortie);
	

   Procedure SupprimerElementLexical(Identifiant : Entier, Paquet : Nul Ou PaquetLexical=Nul);
	

   Procedure Optimiser(NulAbsorbant) SupprimerElementLexical(Symbole : Nul Ou Caractere, Paquet : Nul Ou PaquetLexical=Nul);
	

   Procedure Optimiser(NulAbsorbant) DebuterAnalyse(F : Nul Ou IFlux, NomFichierSource : Caractere, 
   

      EnvoyerErreur : Nul Ou Procedure(MessageErreur : Caractere, NomFichierSource : Caractere, NumeroLigne : Entier, NumeroColonne : Entier));
   
	
   Fonction LireElementLexicalSuivant() Retourner Entier;
	

   Fonction LireSymboleLexical() Retourner Nul Ou Objet;
	

   Fonction LireValeurLexicale() Retourner Nul Ou Objet;
	

   Procedure FixerLigneColonne(NumeroLigne : Entier, NumeroColonne : Entier);
	

   Procedure LireLigneColonne(NumeroLigne : Entier Sortie, NumeroColonne : Entier Sortie);
   Procedure TerminerAnalyse();

Prive :

	
   Destructeur(MettreEnAnteMemoire : Booleen) Retourner Booleen;

Fin Type

Le type AnalyseurLexical modélise un analyseur lexical i.e. un automate reconnaissant des éléments lexicaux.

Le type AnalyseurLexical possède un constructeur explicite dont le paramètre Nom représente le nom de l'analyseur.

Egalement :

Le paramètre ReconnaitreChaineGuillemets doit avoir pour valeur Vrai si les chaînes entre guillemets " doivent être reconnues.
Le paramètre ReconnaitreChaineApostrophes doit avoir pour valeur Vrai si les chaînes entre apostropes ' doivent être reconnues.
Le paramètre ReconnaitreChaineChevrons doit avoir pour valeur Vrai si les chaînes entre chevrons < et > doivent être reconnues.
Le paramètre ReconnaitreCommentaireBloc doit avoir pour valeur Vrai si les commentaires entre /* et */ doivent être reconnus.
Le paramètre ReconnaitreCommentaireLigne doit avoir pour valeur Vrai si les commentaires débutant par // doivent être reconnus.
Le paramètre ReconnaitreEntier doit avoir pour valeur Vrai si les constantes entières doivent être reconnues.
Le paramètre ReconnaitreReel doit avoir pour valeur Vrai si les constantes réelles doivent être reconnues.
Le paramètre ReconnaitreIdentificateur doit avoir pour valeur Vrai si les identificateurs doivent être reconnus.
Le paramètre IgnorerMajuscules doit avoir pour valeur Vrai si la différence entre les majuscules et les minuscules est ignorée pour les identificateurs.
Le paramètre IgnorerMajuscules doit avoir pour valeur Vrai si les ordres de pré-traitement commençant par dièse # doivent être ignorés.

A chaque élément lexical est associé un identifiant sous forme d'un nombre entier supérieure ou égal à 65536. Pour les éléments lexicaux standard, il existe les constantes ElementChaineApostrophes, ElementChaineChevrons, ElementChaineGuillemets, ElementCommentaireBloc, ElementCommentaireLigne ElementEntier, ElementIdentifiant et ElementReel.

Pour les mots-clés ou les familles d'identifiants telles les variables, il est nécessaire de les déclarer par l'appel à la méthode AjouterElementLexical.

A chaque élément lexical reconnu suite à l'appel à la méthode LireElementLexicalSuivant, le contexte lexical comporte :

L'identifiant de l'élément lexical.
Le symbole de l'élément lexical - une chaîne de caractères, une constante entière, une constante réelle ou un libellé pour un identifiant ou un mot-clé.
La valeur de l'élément lexical - un objet quelconque propre à la sémantique du programme.

Quant un identifiant est reconnu, l'analyseur lexical recherche parmi les paquets lexicaux sélectionnés rattachés à cet analyseur s'il existe un symbole correspondant. L'identifiant et la valeur correspondants y sont alors associés.

Le constructeur explicite du type AnalyseurLexical possède des fonctions de rappel optionnelles dont voici la signification :

LireCommentaireIdentifiant.
Cette fonction doit décoder un identifiant en un libellé compréhensible par un humain dans le but de construire un message d'erreur.
- Identifiant.
  Identifiant à décoder.
- Liaison.
  Si Vrai, le libellé doit commencer par un mot de liaison tel du, de la ou des.
ConserverInclusion.
Cette fonction doit retourner Vrai si l'inclusion #include doit être traitée.
- NumeroLigne.
  Numéro de la ligne dans le fichier source comportant le #include.
- NomFichierSource.
  Nom du fichier source comportant le #include.
- ArreterAnalyse.
  Si Vrai, l'analyse doit s'arrêter, par exemple pour une dépendance non chargée.
ConserverPragma.
Cette procédure permet de capturer les directives de compilation #pragma incluse dans le fichier source.
- Pragma.
  Directive de compilation.

Deux tâches ne peuvent utiliser simultanément un analyseur lexical. Les accès sont sérialisés par l'usage d'une synchronisation.

Opérateurs

Le type AnalyseurLexical possède les opérateurs standards suivants :

= pour respectivement l'affectation d'un analyseur lexical dans un autre.
== pour respectivement l'égalité entre deux analyseurs lexicaux.
!= pour respectivement l'inégalité entre deux analyseurs lexicaux.

Exemple

Pour un exemple complet, merci de se référer à Analyse et interprétation du contenu d'un flux.

Variable /******/


	MonAnalyseurLexicalA : Nul Ou AnalyseurLexical;

	MonAnalyseurLexicalB : Nul Ou AnalyseurLexical;




/****************************************************************/

Fonction LireCommentaireIdentifiant(Identifiant : Entier, Liaison : Booleen) Retourner Nul Ou Caractere

/* Objet : Lit le commentaire de l'identifiant. */

/****************************************************************/

Debut

...

Fin Fonction



/****************************************************************/

Fonction ConserverInclusion(NumeroLigne : Entier, NomFichierSource : Caractere, ArreterAnalyse : Booleen Sortie) Retourner Booleen/* Objet : Si Vrai, on conserve l'inclusion. */

/****************************************************************/

Debut

...

Fin Fonction



/****************************************************************/

Procedure ConserverPragma(Pragma : Caractere)

/* Objet : Conserve le pragma. */

/****************************************************************/

Debut
...

Fin Procedure



Principal

/*******/

Debut

...

MonAnalyseurLexicalA=AnalyseurLexical("MonAnalyseurLexical", Vrai, Vrai, Vrai, Vrai, Vrai, Vrai, Vrai, Vrai, Vrai, Vrai, LireCommentaireIdentifiant, ConserverInclusion, ConserverPragma);

...

Si MonAnalyseurLexicalA==MonAnalyseurLexicalB Alors

/* Egalité entre deux analyseurs lexicaux. */

	...

Fin Si

Si MonAnalyseurLexicalA!=MonAnalyseurLexicalB Alors

/* Inégalité entre deux analyseurs lexicaux. */

	...

Fin Si

Voir aussi

PaquetLexical pour connaître la définition d'un paquet lexical.

Traduction


-	-	-	-	-	-	-	-	-