arch/nios2nommu/scripts/PTF/PTFParser.yp

   1 %{#
   2 # Altera PTF file parser
   3 #
   4 # Copyright (c) 2004 Microtronix Datacom Ltd.
   5 #
   6
   7 package PTFParser;
   8
   9 use PTF::PTFSection;
  10
  11 %}
  12
  13 %%
  14 section: section_title '{' section_element '}' {
  15                         my $sectionStack = $_[0]->YYData->{sectionStack};
  16                         pop @{$sectionStack};
  17                 }
  18 ;
  19
  20 section_title: IDENTIFIER section_name {
  21                         my $section = PTFSection->new (type => $_[1], name => $_[2]);
  22                         my $sectionStack = $_[0]->YYData->{sectionStack};
  23
  24                         if (scalar(@{$sectionStack}) == 0) {
  25                                 $_[0]->YYData->{root} = $section;
  26                         } else {
  27                                 my $parent = $sectionStack->[$#{$sectionStack}];
  28                                 $parent->addSection ($section);
  29                         }
  30
  31                         push @{$sectionStack}, $section;
  32                 }
  33 ;
  34
  35 section_name: # empty string
  36         | IDENTIFIER
  37         | NUMBER
  38         | STRING_LITERAL
  39 ;
  40
  41 section_element: # empty element
  42         | assignment section_element
  43         | section section_element
  44 ;
  45
  46 assignment: assignment_name '=' assignment_value ';' {
  47                         my $sectionStack = $_[0]->YYData->{sectionStack};
  48                         my $parent= $sectionStack->[$#{$sectionStack}];
  49                         $parent->addAssignment ($_[1], $_[3]);
  50                 }
  51 ;
  52
  53 assignment_name: IDENTIFIER
  54         | HIERARCHICAL_NAME
  55 ;
  56
  57 assignment_value: STRING_LITERAL
  58         | NUMBER
  59 ;
  60
  61 %%
  62
  63 sub _Error {
  64 # TODO: update this error function to be more useful
  65         exists $_[0]->YYData->{ERRMSG}
  66     and do {
  67         print $_[0]->YYData->{ERRMSG};
  68         delete $_[0]->YYData->{ERRMSG};
  69         return;
  70     };
  71     print "Syntax error on line $_[0]->YYData->{line}.\n";
  72 }
  73
  74 sub _Lexer {
  75         my($parser)=shift;
  76
  77         if (! $parser->YYData->{INPUT}) {
  78                 if ($parser->YYData->{INPUT} = <PTFFILE>) {
  79                         $parser->YYData->{line} += 1;
  80                 } else {
  81                         return ('', undef);
  82                 }
  83         }
  84
  85         $parser->YYData->{INPUT} and
  86                 $parser->YYData->{INPUT} =~ s/^\s*//;
  87
  88         while (1) {
  89
  90                 # skip blank lines
  91                 if ($parser->YYData->{INPUT} =~ s/^[ \t\r\n]*$//) {
  92                         if ($parser->YYData->{INPUT} = <PTFFILE>) {
  93                                 $parser->YYData->{line} += 1;
  94                         } else {
  95                                 return ('', undef);
  96                         }
  97                         $parser->YYData->{INPUT} and
  98                                 $parser->YYData->{INPUT} =~ s/^\s*//;
  99                         next;
 100                 }
 101
 102                 # Skip comments
 103                 if ($parser->YYData->{INPUT} =~ s/^#.*//) {
 104                         if ($parser->YYData->{INPUT} = <PTFFILE>) {
 105                                 $parser->YYData->{line} += 1;
 106                         } else {
 107                                 return ('', undef);
 108                         }
 109                         $parser->YYData->{INPUT} and
 110                                 $parser->YYData->{INPUT} =~ s/^\s*//;
 111                         next;
 112                 }
 113
 114                 # Don't continue if the line length is 0;
 115                 if (length $parser->YYData->{INPUT} == 0) {
 116                         if ($parser->YYData->{INPUT} = <PTFFILE>) {
 117                                 $parser->YYData->{line} += 1;
 118                         } else {
 119                                 return ('', undef);
 120                         }
 121                         $parser->YYData->{INPUT} and
 122                                 $parser->YYData->{INPUT} =~ s/^\s*//;
 123                         next;
 124                 }
 125
 126                 # tokenize input
 127                 $parser->YYData->{INPUT} =~ s/^([a-zA-Z_][a-zA-Z_0-9\/]*)//
 128                         and return('IDENTIFIER',$1);
 129                 $parser->YYData->{INPUT} =~ s/^"([^"\\]*(\\.[^"\\]*)*)"//
 130                         and return('STRING_LITERAL',$1);
 131                 $parser->YYData->{INPUT} =~ s/^"([^"\\]*(\\.[^"\\]*)*)//
 132                         and do {
 133                                 my $literal = $1;
 134
 135                                 do {
 136                                         if ($parser->YYData->{INPUT} = <PTFFILE>) {
 137                                                 $parser->YYData->{line} += 1;
 138                                         } else {
 139                                                 return ('', undef);
 140                                         }
 141
 142                                         $parser->YYData->{INPUT} =~ s/([^"\\]*(\\.[^"\\]*)*)"//
 143                                                 and do {
 144                                                         $literal .= $1;
 145                                                         return ('STRING_LITERAL', $literal);
 146                                                 };
 147
 148                                         $parser->YYData->{INPUT} =~ s/([^"\\]*(\\.[^"\\]*)*)//
 149                                                 and $literal .= $1;
 150                                 } while (1);
 151                         };
 152                 $parser->YYData->{INPUT} =~ s/^([0-9]+)//
 153                         and return('NUMBER',$1);
 154                 $parser->YYData->{INPUT} =~ s/^([\$]{1,2}[a-zA-Z0-9 \/_]+)//
 155                         and return('HIERARCHICAL_NAME',$1);
 156                 $parser->YYData->{INPUT} =~ s/^(.)//
 157                         and return($1,$1);
 158         }
 159 }
 160
 161 sub readPTF {
 162         my $self = shift;
 163         my $filename = shift;
 164
 165         # store information for later use
 166         $self->YYData->{line} = 0;
 167         $self->YYData->{sectionStack} = [];
 168         undef $self->YYData->{root};
 169
 170         open (PTFFILE, $filename) or return undef;
 171         $self->YYParse (
 172                 yylex => \&_Lexer,
 173                 yyerror => \&_Error,
 174                 );
 175         close PTFFILE;
 176
 177         return $self->YYData->{root};
 178 }