NOM

Parse::Lex - Générateur d'analyseurs lexicaux (Alpha 1.13).

SYNOPSIS

#!/usr/local/bin/perl

require 5.000;

BEGIN {		
  push(@INC,  ("$ENV{'HOME'}/lib/perl5")); # or PERL5LIB
}
use Parse::Lex;
@token = (
  qw(
     ADDOP    [-+]
     LEFTP    [\(]
     RIGHTP   [\)]
     INTEGER  [1-9][0-9]*
     NEWLINE  \n
     
    ),
  qw(STRING), [qw(\" (?:[^\"\\\\]+|\\\\(?:.|\n))* \")],
  qw(ERROR  .*), sub {
    die qq!can\'t analyze: "$_[1]"!;
  }
 );

Parse::Lex->trace;
$lexer = Parse::Lex->new(@token);
$lexer->from(\*DATA);
print "Tokenization of DATA:\n";

TOKEN:while (1) {
  $token = $lexer->next;
  if (not $lexer->eoi) {
    print "Line $.\t";
    print "Type: ", $token->name, "\t";
    print "Content:->", $token->getstring, "<-\n";
  } else {
    last TOKEN;
  }
}

__END__
1+2-5
"multiline
string with an embedded \" in it"
embedded \" string"
an invalid string with an embedded \" string"

DESCRIPTION

La classe Parse::Lex permet de créer des analyseurs lexicaux. Un analyseur lexical est spécifié au moyen d'un liste de lexèmes passée en argument à la méthode new de la classe Parse::Lex.

Les lexèmes sont des objets de la classe Parse::Token, livré avec Parse::Lex. La définition d'un lexème comporte ordinairement deux arguments : un non symbolique (comme INTEGER), suivi d'une expression régulière. Si une fonction anonyme est donnée en troisième argument, elle est exécutée lorsque le lexème est reconnu.

L'ordre dans lequel l'analyseur lexical examine les expressions régulières est déterminé par l'ordre dans lequel ces expressions sont passées en argument à la méthode new. Le lexème retourné par l'analyseur lexical correspond à la première expression qui s'apparie avec le début du flot de caractères à analyser (la stratégie est différence de celle adoptée par l'analyseur lexical "Lex" qui retourne la plus longue chaîne de toutes celles qu'il est possible de reconnaître). Le lexème est un objet de la classe Parse::Token.

L'analyseur peut être utilisé pour analyser une chaîne de caractères isolée ou un flot de données provenant d'une entrée quelconque. En fin de flot l'analyseur retourne un objet Token dont le nom est EOI (End Of Input).

Méthodes

buffer EXPR

buffer

Retourne le contenu du buffer interne à l'analyseur lexical. Avec une expression en argument, place le résultat de l'expression dans le buffer.

eoi

Retourne vrai lorsqu'il n'y a plus de données à analyser.

every ANON

Analyse le flot à traiter et exécute ANON après la reconnaissance de chaque lexème. Évite de devoir écrire une boucle de lecture. Pour segmenter la chaîne "1+2" on peut par exemple écrire :

use Parse::Lex;

$lexer = Parse::Lex->new(
  qw(
     ADDOP [-+]
     INTEGER \d+
    ));

$lexer->from("1+2");
$lexer->every (sub { 
  print $_[0]->name, "\t";
  print $_[0]->get, "\n";
});

Le premier argument de la fonction anonyme est l'objet Token reconnu.

from EXPR

from permet d'indiquer la source des données à analyser. L'argument de cette méthode est une référence à un filehandle ou une liste de chaînes de caractères. Exemples :

$lexer->from(\*DATA);
$lexer->from('les données à analyser');

flush

Si la conservation des chaînes consommées est activée, flush retourne et vide le buffer contenant les chaînes de caractères reconnues jusqu'ici.

getbuffer

Retourne le contenu du buffer interne à l'analyseur lexical.

hold EXPR

hold

Active/desactive la conservation des chaînes consommées. Retourne la valeur courante. Peut être utilisée comme méthode de classe.

On peut obtenir le contenu du buffer au moyen de la méthode flush qui a également pour effet de vider le buffer.

less EXPR

La valeur de EXPR est placée au début du flot de données.

next

Provoque la recherche du prochain lexème. Retourne l'objet Token reconnu. Retourne l'objet Token::EOI en fin de données.

new

Crée et retourne un nouvel analyseur lexical. L'argument de la méthode est une liste de triplets comportant : le nom symbolique du lexème, l'expression régulière nécessaire à sa reconnaissance et éventuellement une fonction anonyme exécutée lors de la reconnaissance du lexème. Pour chaque triplet, un objet de type Parse::Token est créé.

L'analyseur lexical construit par new cherche tour à tour à apparier chaque expression régulière avec le début du flot de données à analyser. L'ordre examen des expressions régulières est fixé par l'ordre dans lequel elles sont passées en argument à la méthode new.

newset

Peut être utilisé pour créer un ensemble de lexèmes qui ne sont pas dans l'automate d'analyse. On pourra pas exemple écrire :

%keywords = 
  qw (
      PROC  undef
      FUNC  undef
      RETURN undef
      IF    undef
      ELSE  undef
      WHILE undef
      PRINT undef
      READ  undef
     );
$lexer->newset(%keywords);

et installer ces tokens dans une table des symboles de la manière suivante :

foreach $name (keys %keywords) {
  $symbol{"\L$name"} = [${$name}, ''];
}

${$name} est l'objet Token.

Lors de la phase d'analyse lexicale on pourra utiliser les tokens de la manière suivante :

qw(IDENT [a-zA-Z][a-zA-Z0-9]*),  sub {		      
   $symbol{$_[1]} = [] unless defined $symbol{$_[1]};
   my $type = $symbol{$_[1]}[0];
   $lexer->tokenis((not defined $type) ? $VAR : $type);
   $_[1];
 }

Ce qui permet de requalifier IDENT.

readline

Effectue la lecture des données sur l'entrée spécifiée par la méthode from. Retourne le résultat de la lecture.

reset

Vide le buffer interne à l'analyseur lexical et efface tout token déjà reconnu.

setbuffer EXPR

La valeur de EXPR est placée dans le buffer interne à l'analyseur lexical.

skip EXPR

skip

EXPR est une expression régulière définissant le séparateur de lexème (par défaut [ \t]+). Retourne ce séparateur si EXPR est omis. Peut être utilisée comme méthode de classe.

token

Retourne l'objet correspondant au dernier lexème reconnu. En l'absence de token lu, retourne un token spécial dont le nom est default token.

tokenis TOKEN OBJECT

Force le lexème à TOKEN OBJECT. Utile pour requalifier un lexème à l'intérieur de la fonction anonyme associée à ce lexème.

trace

Active/désactive une trace de l'analyse lexicale. Peut être utilisée comme méthode de classe.

EXEMPLES

tokenizer.pl - Segmentation d'un flot de données au moyen de la classe Parse::Lex.

every.pl - Utilisation de la méthode every.

EXTENSIONS

Il serait sans doute intéressant de pouvoir retourner la liste des lexèmes correspondant à l'analyse de tout un flot de caractères.

AUTEUR

Philippe Verdret

AVERTISSEMENT

Je considère que la présente version de Token.pm/Lex.pm est expérimentale. Ce module peut notablement évoluer. J'aimerais recevoir vos remarques et vos suggestions.

REFERENCES

Friedl, J.E.F. Mastering Regular Expressions. O'Reilly & Associates 1996.

Groc, B., & Bouhier, M. - Programmation par la syntaxe. Dunod 1990.

Mason, T & Brown, D. - Lex & Yacc. O'Reilly & Associates, Inc. 1990.

COPYRIGHT

Copyright (c) 1995-1997 Philippe Verdret. All rights reserved. This module is free software; you can redistribute it and/or modify it under the same terms as Perl itself.