parser.yy

Go to the documentation of this file.

/*
 *  Copyright 2007 Martin von Gagern
 *
 *
 *  This file is part of mqn2mps.
 *
 *  mqn2mps is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  mqn2mps is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */


/**
 * @file parser.yy
 * Grammar of input file.
 * This grammar is used to generate parser.cc.
 */

/**
 * @file parser.cc
 * Generated yy::parser implementation.
 * This parser is generated by bison, using the grammar from
 * parser.yy.
 */

/**
 * @file parser.hh
 * Generated yy::parser interface.
 * This parser is generated by bison. Its implementation is contained
 * in parser.cc.
 */

/**
 * @file stack.hh
 * Generated class yy::stack interface and implementation.
 */

/**
 * @class yy::stack
 * Generated class used by yy::parser.
 */

/**
 * @namespace yy
 * Common namespace for the generated lexer and parser.
 *
 * The elemnts inside this namespace have been automatically generated
 * from lexer.lex or parser.yy, of from some skeleton files that come
 * with the tools using for this code generation.
 */

/** @cond PARSER */

/* Set everything up for generation of a C++ parser named yy.parser */

%skeleton "lalr1.cc"
%require "2.3b"
%defines
%define "parser_class_name" "parser"

/* The following block is copied verbatim to parser.hh */
%code requires{
#include <vector>
#include <utility>

#include "rational.hh"
#include "field.hh"
#include "constraint.hh"

/**
 * @class yy::parser
 * The parser for the input file format.
 * This parser reads tokens from a yy::lexer one at a time, parses
 * them according to the grammar specified in parser.yy and passes it
 * on to an instance of class driver. The lexer object is not directly
 * passed to the parser, but wrapped inside driver::scan.
 */

// forward declaration of driver class, as it is an argument type
class driver;
}

/* The constructor of the parser will take a driver reference as
   argument. */
%parse-param { driver& theDriver };

/* We want location tracking, and get the file name of the input file
   from the driver. */
%locations
%initial-action { @$.initialize(&theDriver.file); };

/* We want verbose error messages and the ability to trace the parsing
   process for debugging. */
%error-verbose
%debug

/* Union of all possible semantic types. As calling destructors for
   union members can't work, all complex types are represented through
   pointers, and most functions that accept such a pointer will take
   care of the destruction of the object pointet to, once it is no
   longer needed. */
%union {
  std::string                   *s;
  std::vector<std::string>      *sl;
  constraint                    *c;
  std::vector<constraint>       *cl;
  field                         *f;
  std::vector<field>            *fl;
  rational                      *r;
  std::vector<rational>         *rl;
  int                            i;
};

/* The following block is copied verbatim to parser.cc */
%code {
#include "driver.hh"

// we use the driver wrapper around the lexer for scanning
#define yylex theDriver.scan

// two inline function templates for sequence handling

/**
 * Append an item to a sequence.
 * @param sequence pointer to the sequence to which the item will be
 *                 appended, will be returned as well.
 * @param item pointer to the item to be appended, will be deleted.
 * @return a pointer to the modified sequence object.
 */
template<class T> inline std::vector<T>*
append(std::vector<T>* sequence, T* item) {
  std::vector<T>* result = sequence;
  if (item) {
    result->push_back(T());
    std::swap(result->back(), *item);
    delete item;
  }
  return result;
}

/**
 * Create a sequence consisting of a single item.
 * @param item pointer to the initial item of the sequence, will be
 *             deleted.
 * @return a pointer to a new sequence object containing the item.
 */
template<class T> inline std::vector<T>*
singleton(T* item) {
  return append(new std::vector<T>, item);
}

}

/* The terminal that the lexer will recognize, along with a verbose
   name for each */
%token          END     0       "end of file"
%token <s>      WORD            "word"
%token <s>      QSTR            "quoted string"
%token <i>      INT             "integer"

/* The types associated with different nonterminals */
%type <s>       name string qn
%type <sl>      qnl
%type <c>       cs
%type <cl>      csl
%type <f>       vc
%type <fl>      vcl
%type <r>       rational
%type <rl>      rationals
%type <i>       sign denom

/* How to print and delete things in case of tracing or errors */
%printer { debug_stream() << *$$; } WORD QSTR name string qn rational
%printer { debug_stream() <<  $$; } INT denom
%destructor { delete $$; } WORD QSTR name string qn qnl cs csl vc vcl rational

%%
/* Now begins the part of the actual grammar rules */

/* The whole stream should follow the instance rule */
%start instance;

instance: name '{' qns ',' css ',' vcs '}' { theDriver.result(@$, $1); }
;

name:     string '='                    { $$ = $1; }
        | /* empty = "unnamed" */       { $$ = new std::string("unnamed"); }
;

string:   WORD                          { $$ = $1; }
        | QSTR                          { $$ = $1; }
        | '*'                           { $$ = new std::string("*"); }
;

/* quantum numbers */

qns:      '{' qnl '}'                   { theDriver.set_names(@$, $2); }
;

qnl:      qnl ',' qn                    { $$ = append($1,$3); }
        | qn                            { $$ = singleton($1); }
;

qn:       string                        { $$ = $1; }
;

/* constraints */

css:      '{' csl '}'                   { theDriver.set_constraints(@$, $2); }
;

csl:      csl ',' cs                    { $$ = append($1,$3); }
        | cs                            { $$ = singleton($1); }
;

cs:       '{' string ',' rational ',' INT '}' {
                                          $$ = new constraint($2, $4, $6);
                                        }
        | error                         { $$ = 0; }
;

/* vectors (= fields) */

vcs:      '{' vcl '}'                   { theDriver.set_fields(@$, $2); }
;

vcl:      vcl ',' vc                    { $$ = append($1,$3); }
        | vc                            { $$ = singleton($1); }
;

vc:       '{' string ',' rationals '}'  { $$ = theDriver.checked_field(@$, $2, $4); }
        | error                         { $$ = 0; }
;

/* vector elements */

rationals: rationals ',' rational       { $$ = append($1,$3); }
        |  rational                     { $$ = singleton($1); }
;

rational: sign INT denom                { $$ = new rational($1 * $2, $3); }
        | '*'                           { $$ = new rational(); }
;

sign:     '+'                           { $$ =  1; }
        | '-'                           { $$ = -1; }
        | /* empty = + */               { $$ =  1; }
;

denom:    '/' INT                       { $$ = $2; }
        | /* empty = 1 */               { $$ =  1; }
;

%%
/* the epilogue is appended after the other parts of the parser. */

/**
 * Pass error messages on to the driver.
 *
 * @param location the position in the input file where the error
 *                 occurred.
 * @param message a textual description of the error.
 */
void
yy::parser::error (const yy::parser::location_type& location,
                   const std::string& message) {
  theDriver.error(location, message);
}

/** @endcond */

---