grammar

   1
   2 parse_start   : nil item(s? /[ \t\n]*/) nil eof
   3     { $return = $item[2] }
   4
   5 nil           : /[ \t\n]*/
   6 eof           : /^\Z/
   7
   8 version       : number_part
   9                 letter_part(?)
  10                 release_part(s?)
  11                 revision_part(?)
  12                 ranged_part(?)
  13     { $return = {
  14         head     => 'version',
  15         number   => $item[1],
  16         extra    => $item[2][0],
  17         release  => $item[3],
  18         revision => int($item[4][0] or 0),
  19         ranged   => defined($item[5][0]) ? 1 : 0 }}
  20
  21 number_part   : integer(s /\./)
  22     { $return = $item[1] }
  23 letter_part   : /[a-z]/
  24 release_part  : '_' release_spec integer(?)
  25     { $return = [
  26         $item[2], int($item[3][0] or 0) ] }
  27 release_spec  : 'alpha'
  28               | 'beta'
  29               | 'pre'
  30               | 'rc'
  31               | 'p'
  32 revision_part : '-r' integer
  33 ranged_part   : '*'
  34
  35 integer       : /\d+/
  36
  37 category      : /[+\w][-+\w.]*/
  38 package       : /[+\w]+(?:-[+A-Za-z_][+\w]*)*/
  39
  40 name          : category '/' package
  41     { $return = {
  42         head     => 'name',
  43         category => $item[1],
  44         package  => $item[3] }}
  45
  46 slot_spec     : ':' slot
  47     { $return = $item[2] }
  48 slot          : /[+\w][-+\w.]*/
  49 flag          : /[\w][-+\w.@]*/
  50
  51 parse_pkg     : package '-' version
  52     { $return = {
  53         name    => $item[1],
  54         version => $item[3] }}
  55
  56 compare       : '<=' | '<' | '>=' | '>' | '=' | '~'
  57
  58 ext_atom      : ('!!' | '!' | '') compare name '-' version slot_spec(?) use_spec(?)
  59     { $return = {
  60         head    => 'ext-atom',
  61         bool    => (not $item[1]) ? 1 : 0,
  62         cmp     => $item[2],
  63         name    => $item[3],
  64         version => $item[5],
  65         slot    => $item[6][0] || '0',
  66         use     => $item[7][0] || [] }}
  67
  68 std_atom       : ('!!' | '!' | '') name slot_spec(?) use_spec(?)
  69     { $return = {
  70         head    => 'std-atom',
  71         bool    => (not $item[1]) ? 1 : 0,
  72         name    => $item[2],
  73         slot    => $item[3][0] || '0',
  74         use     => $item[4][0] || [] }}
  75
  76 atom          : ext_atom | std_atom
  77
  78 item          : atom | all_of | any_of | use_cond
  79
  80 list_elem     : item whitespace
  81     { $return = $item[1] }
  82 list_spec     : '(' whitespace list_elem(s?) ')'
  83     { $return = $item[3] }
  84
  85 all_of        :                 list_spec
  86     { $return = {
  87         head => 'all-of',
  88         tail => $item[1] }}
  89 any_of        : '||' whitespace list_spec
  90     { $return = {
  91         head => 'any-of',
  92         tail => $item[3] }}
  93
  94 use_cond      : ('!' | '') flag '?' whitespace list_spec
  95     { $return = {
  96         head => 'use-cond',
  97         bool => ($item[1] eq '!') ? 0 : 1,
  98         flag => $item[2],
  99         tail => $item[5] }}
 100
 101 use_spec      : '[' use_item(s? /,/) ']'
 102     { $return = $item[2] }
 103 use_item      : ('!' | '') flag ('=' | '?')
 104     { $return = {
 105         head => 'use-spec',
 106         bool => ($item[1] eq '!') ? 0 : 1,
 107         flag => $item[2],
 108         type => $item[3] }}
 109               | ('-' | '') flag
 110     { $return = {
 111         head => 'use-spec',
 112         bool => ($item[1] eq '-') ? 0 : 1,
 113         flag => $item[2] }}
 114
 115 whitespace    : /[ \t\n]+/
 116