Parse::RecDescent: if-elsif-else (Allgemeines zu Perl)

[thread]7921[/thread]

Parse::RecDescent: if-elsif-else

Leser: 3

Wildcard

2006-04-24 18:49

User since
2006-04-24
4 Artikel
BenutzerIn
[default_avatar]

Moin zusammen,

ich bin gerade dabei, mich in die Verwendung des Moduls Parse::RecDescent einzuarbeiten und hoffe sehr, dass Ihr mir dabei weiterhelfen könnt.
Ich habe vor, ein Programm in Perl zu implementieren, das in der Lage ist, Code in einer selbst definierten "Sprache" zu interpretieren, dessen Syntax sich an Perl anlehnt.
Also grundsätzlich soetwas wie Variablenzuweisungen (nur skalar), Ausdrücke und verschachtelte if-elsif-else Statements. Diese Elemente stellen nur die Basis dieser selbst definierten "Sprache" dar, die eigentlichen Inhalte sollen dann folgen, wenn ich die Probleme, auf die ich schon bei diesen grundsätzlichen Dingen gestossen bin, gelöst habe. Dies wäre zum Beispiel ein Stück Code:

Code: (dl )

$_errvar2 = 9;

$_errvar3 = $_errvar2;

if (1) {
  $if_var01 = 1;
}

if (1) {
  $if_var02 = 1;
} else {
  $if_var02 = 2;
}

if (0) {
  $if_var11 = 1;
}

if (0) {
  $if_var12 = 1;
} else {
  $if_var12 = 2;
}

Der Parser, den ich bislang mit P::RD zusammengeschustert habe, kann das auch Lesen.
Mein Problem besteht darin, dass ich keine Idee habe, wie ich bei der Auswertung dieses Codes mit P::RD verhindere, dass die Zweige der if-else Anweisungen nicht beachtet/ausgeführt werden, deren entsprechende Bedingungen nicht erfüllt sind. Also z.B. um zu erreichen, dass $if_var02 am Ende 1 ist und nicht 2 bzw. z.B. dass $if_var11 gar nicht angelegt wird.

Der Vollständigkeit halber kopiere ich mal den betreffenden Teil des Parsers unten dran.

Mir wäre sehr geholfen, wenn mir jemand eine Richtung oder eine Idee vermitteln könnte, wie die Auswertung von if-elsif-else mit P::RD zu bewerkstelligen wäre. Andere Kommentare zum Parser sind natürlich auch willkommen.

Munter bleiben!

Wildcard

Code: (dl )

use strict;
use Data::Dumper;
use Parse::RecDescent;

#    $::RD_ERRORS=1;
#    $::RD_WARN=1;
#    $::RD_HINT=1;
#    $::RD_TRACE=1;
#    $::debugging = 1;

our %parse_vars;
my %data_vars;

my $grammar = q {

code:            line(s) eofile            {$item[1]}
               | {print STDERR "\n ERROR! (Line $thisparser->{errors}->[0]->[1]): $thisparser->{errors}->[0]->[0]\n";
                  $thisparser->{errors} = undef}

line:           description_statement(s)

description_statement:   assignment_statement
                       | conditional_description_statement

conditional_description_statement:  if_description_statement
                                    elsif_description_statement(s?)
                                    else_description_statement(?)

if_description_statement:     'if' '(' expression ')' '{' description_statement(s) '}'     {print STDERR "if branch on line $thisline\n";
                                                                                            $return = $item[7]; 1;
                                                                                           }
elsif_description_statement:  'elsif' '(' expression ')' '{' description_statement(s) '}'  {print STDERR "elsif branch on line $thisline\n";
                                                                                            $return = $item[7]; 1;
                                                                                           }
else_description_statement:   'else' '{' description_statement(s) '}'                      {print STDERR "else branch on line $thisline\n";
                                                                                            $return = $item[3]; 1;
                                                                                           }

assignment_statement:  variable '='  expression ';'            {$main::parse_vars{$item[1]} = $item[-2]}
                     | <error>

expression:            unary_expression bin_num_op expression  {my $res = eval "@item[1..$#item]";
                                                                print "exec: $item[2] operation, result = $res\n" if ($::debugging);
                                                                $res
                                                               }
                     | unary_expression bin_str_op expression  {my $res = '"'.eval("@item[1..$#item]").'"';
                                                                print "exec: $item[2] operation, result = $res\n" if ($::debugging);
                                                                $res
                                                               }
                     | unary_expression


unary_expression:      primary
                     | variable                                {$main::parse_vars{$item[1]} ||= 0}
                     | '+' expression                          {$item[2]}
                     | '-' expression                          {$item[2] * -1}
                     | '~' expression                          {~$item[2]}
                     | '!' expression                          {!$item[2]}
                     | paren_expression                        {$item[1]}

paren_expression :     '(' expression ')'                      {$item[2]}
                     | <error>

primary:        number                       {$item[1]}
              | string_literal               {$item[1]}

number:         binary_number                {$item[1]}
              | hex_number                   {$item[1]}
              | decimal_number               {$item[1]}

decimal_number: /\d+/                        {eval $item[1]}
binary_number : /0b[01_]+/i                  {eval lc($item[1])}
hex_number    : /0x[a-f0-9_]+/i              {eval lc($item[1])}

string_literal: { extract_delimited($text,'"') }
                { my $str_lit = $item[1];
                  # variable interpolation
                  $str_lit =~ s/([^\\\])(\$)\{?(\w+)\}?/$1$main::parse_vars{"$2$3"}/g;
                  '"'.eval($str_lit).'"';
                }

simple_identifier:    m{[a-zA-Z_]\w*}              {$item[1]}

variable:            '$' '{' <commit> simple_identifier '}'   {"$item[1]$item[4]"}
                   | '$'     <commit> simple_identifier       {"$item[1]$item[3]"}
                   | <error?>

bin_num_op:  '||'
           | '&&'
           | '|'
           | '^'
           | '&'
           | '=='
           | '!='
           | '<=>'
           | 'eq'
           | 'ne'
           | 'cmp'
           | '<<'
           | '>>'
           | '<='
           | '>='
           | '<'
           | '>'
           | 'lt'
           | 'le'
           | 'gt'
           | 'ge'
           | '+'
           | '-'
           | '*'
           | '/'
           | '%'
           | '**'

bin_str_op:  '.'
           | 'x'

eofile:    /^\Z/

};

my $parser=Parse::RecDescent->new($grammar);

my $document = q(
$_errvar2 = 9;

$_errvar3 = $_errvar2;

if (1) {
  $if_var01 = 1;
}

if (1) {
  $if_var02 = 1;
} else {
  $if_var02 = 2;
}

if (0) {
  $if_var11 = 1;
}

if (0) {
  $if_var12 = 1;
} else {
  $if_var12 = 2;
}

if (1) {
  $if_var3 = 1;
} elsif (2) {
  $if_var3 = 2;
} else {
  $if_var3 = 3;
}

if (1) {
  $if_var4 = 1;
} elsif (2) {
  $if_var4 = 2;
} elsif (3) {
  $if_var4 = 3;
} elsif (4) {
  $if_var4 = 4;
} else {
  $if_var4 = 5;
}


if (1) {
  if ($_errvar2 == 13) {
    $if_var6 = 1;
  } else {
    $if_var6 = 2;
  }
} else {
  $if_var6 = 3;
}
);

my $parse_res = $parser->code($document);
defined($parse_res) || die "\n ERROR! Syntax errors in document\n\n";

%data_vars = %parse_vars;
undef(%parse_vars);
print Data::Dumper->Dump([\%data_vars]);

Crian

2006-04-24 18:59

User since
2003-08-04
5866 Artikel
ModeratorIn

Wenn du einfach ein abgespecktes Perl verwenden willst, jag doch den Code durch eval.

s--Pevna-;s.([a-z]).chr((ord($1)-84)%26+97).gee; s^([A-Z])^chr((ord($1)-52)%26+65)^gee;print;

use strict; use warnings; Link zu meiner Perlseite

Wildcard

2006-04-24 19:19

User since
2006-04-24
4 Artikel
BenutzerIn
[default_avatar]

eval() ist ohnehin vorgesehen, um den Teil, der identisch Perl sein wird, zu bewerten. Das ist in meinem Code-Beispiel bei der Bewertung von Ausdrücken auch zu sehen. Das Problem ist eben, dass das nur ein geringer Teil der Geschichte ist und am Ende soetwas herauskommen soll:

Code: (dl )

$var = 0x3000;
if ($var <= 0x100) {
  description {
    base = $var;
    id   = "uniqe_identifier";
    text = "This is the first element with base = $var\n";
  }
} elsif ($var <= 0x200) {
  $basevar = $var - 0xF;
  description {
    base = $basevar;
    id   = "uniqe_identifier";
    text = "This is the first element with base = $basevar\n";
  }
} else {
  $basevar = $var - 0x1F;
  description {
    base = $basevar;
    id   = "uniqe_identifier";
    text = "This is the first element with base = $basevar\n";
  }
}

Also neu definierte Sprachelemente, die an sich nicht Perl sind aber vermischt werden können mit den ensprechenden Programmier-Statements.

Wildcard

2006-04-25 11:31

User since
2006-04-24
4 Artikel
BenutzerIn
[default_avatar]

Moin,

ich weiss, das hier sieht so aus, als wenn ich mich mit mir selbst unterhalte ... anyway.
Nach weiterem Suchen nach Tips zu meinem Problem im Web bin ich auf einen Hinweis gestossen, dass Mr Conway zu seinem Modul P::RD im CPAN zahlreiche Demos bereitgestellt hat.
Und siehe da, unter http://search.cpan.org/src/DCONWAY/Parse-RecDescent-1.94/demo/
gibt es sogar ein Bespiel für eine einfache Programmiersprache mit Bearbeitung eines if-else Konstrukts. Das ist zumindest schon mal ein Startpunkt, von dem aus ich jetzt weiterarbeiten kann.
Und vielleicht hilft dieser Hinweis ja auch noch anderen ...

Munter bleiben!

renee

2006-04-25 11:51

User since
2003-08-04
14371 Artikel
ModeratorIn

Was ich echt toll von Dir finden würde: Du scheinst Dich ja doch relativ gut mit CPAN:

Parse::RecDescent auszukennen. Ich habe es bisher nur für Kleinigkeiten eingesetzt. Würdest Du vielleicht einen kleinen Artikel zu dem Modul in unser Wiki schreiben?

OTRS-Erweiterungen (http://feature-addons.de/)
Frankfurt Perlmongers (http://frankfurt.pm/)
--

Unterlagen OTRS-Workshop 2012: http://otrs.perl-services.de/workshop.html
Perl-Entwicklung: http://perl-services.de/

Wildcard

2006-04-26 09:53

User since
2006-04-24
4 Artikel
BenutzerIn
[default_avatar]

Moin,

ich fühle mich durchaus geschmeichelt. Allerdings wage ich nicht zu behaupten, ein Experte für P::RD zu sein, ich beginne gerade zu verstehen, wie das Dingen funktioniert. Die Mächtigkeit sowie die Feinheiten haben sich mir noch nicht unbedingt erschlossen.
Von daher wäre ein Artikel, den ich hier verfassen könnte, lediglich von anderen Web-Resourcen zusammenkopiert und damit wenig fundiert.
Das was grundsätzlich zur Funktionsweise von P::RD zu schreiben wäre, ist ohnehin ziemlich vollständig unter CPAN:

Parse::RecDescent zu finden.

Munter bleiben!

Dubu

2006-04-26 14:22

User since
2003-08-04
2145 Artikel
ModeratorIn + EditorIn

user image

Expertenwissen ist gar nicht nötig.
Aber wenn du das, was du selber beim Experimentieren herausfindest, auch im Wiki dokumentierst, hilft es vielleicht jemand anderem.

Auch dass P::RD gut dokumentiert ist, ist kein Gegenargument, denn diese Doku ist nur in Englisch und nicht jeder kann/mag englische Doku lesen. Deshalb bemühen wir uns hier ja auch, schrittweise die Original-Perl-Doku ins Deutsche zu übersetzen. :)

View all threads created 2006-04-24 18:49.