alarsyo/spot
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Revert everything related to Damien's work in 2008 (he will commit a new version soon).

Browse source 
Here are the reverted patches:
8c0d1003b0,
25a3114287,
9afbaf6342,
dc0005f4e1,
543190f2bc.
This commit is contained in:
Alexandre Duret-Lutz 2009-03-25 13:58:18 +01:00
parent 3d278663cd
commit b1bfdee870
130 changed files with 912 additions and 5104 deletions
Download patch file Download diff file Expand all files Collapse all files

62
src/eltlparse/Makefile.am
View file

@ -1,62 +0,0 @@
## Copyright (C) 2008 Laboratoire d'Informatique de Paris 6 (LIP6),
## département Systèmes Répartis Coopératifs (SRC), Université Pierre
## et Marie Curie.
##
## This file is part of Spot, a model checking library.
##
## Spot 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 2 of the License, or
## (at your option) any later version.
##
## Spot 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 Spot; see the file COPYING. If not, write to the Free
## Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
## 02111-1307, USA.
AM_CPPFLAGS = -I$(srcdir)/..
AM_CXXFLAGS = #$(WARNING_CXXFLAGS)
eltlparsedir = $(pkgincludedir)/eltlparse
noinst_LTLIBRARIES = libeltlparse.la
ELTLPARSE_YY = eltlparse.yy
FROM_ELTLPARSE_YY_MAIN = eltlparse.cc
FROM_ELTLPARSE_YY_OTHERS = \
stack.hh \
position.hh \
location.hh \
eltlparse.hh
FROM_ELTLPARSE_YY = $(FROM_ELTLPARSE_YY_MAIN) $(FROM_ELTLPARSE_YY_OTHERS)
BUILT_SOURCES = $(FROM_ELTLPARSE_YY)
MAINTAINERCLEANFILES = $(FROM_ELTLPARSE_YY)
$(FROM_ELTLPARSE_YY_MAIN): $(srcdir)/$(ELTLPARSE_YY)
## We must cd into $(srcdir) first because if we tell bison to read
## $(srcdir)/$(ELTLPARSE_YY), it will also use the value of $(srcdir)/
## in the generated include statements.
cd $(srcdir) && \
bison --defines --locations --skeleton=lalr1.cc --report=all \
$(ELTLPARSE_YY) -o $(FROM_ELTLPARSE_YY_MAIN)
$(FROM_ELTLPARSE_YY_OTHERS): $(ELTLPARSE_YY)
@test -f $@ || $(MAKE) $(AM_MAKEFLAGS) $(FROM_ELTLPARSE_YY_MAIN)
EXTRA_DIST = $(ELTLPARSE_YY)
libeltlparse_la_SOURCES = \
fmterror.cc \
$(FROM_ELTLPARSE_YY) \
eltlscan.ll \
parsedecl.hh
eltlparse_HEADERS = \
public.hh \
location.hh \
position.hh

289
src/eltlparse/eltlparse.yy
View file

@ -1,289 +0,0 @@
/* Copyright (C) 2008 Laboratoire d'Informatique de
** Paris 6 (LIP6), département Systèmes Répartis Coopératifs (SRC),
** Université Pierre et Marie Curie.
**
** This file is part of Spot, a model checking library.
**
** Spot 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 2 of the License, or
** (at your option) any later version.
**
** Spot 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 Spot; see the file COPYING. If not, write to the Free
** Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
** 02111-1307, USA.
*/
%{
#include <string>
#include <sstream>
#include <limits>
#include <cerrno>
#include <limits.h>
#include "public.hh"
#include "eltlast/automatop.hh"
// Implementation detail for error handling.
namespace spot
{
namespace eltl
{
struct parse_error_list_t
{
parse_error_list list_;
std::string file_;
};
}
}
#define PARSE_ERROR(Loc, Msg) \
pe.list_.push_back \
(parse_error(Loc, spair(pe.file_, Msg)))
%}
%name-prefix="eltlyy"
%parse-param {spot::eltl::nfamap& nmap}
%parse-param {spot::eltl::parse_error_list_t &pe}
%parse-param {spot::eltl::environment &parse_environment}
%parse-param {spot::eltl::formula* &result}
%lex-param {spot::eltl::parse_error_list_t &pe}
%expect 0
%debug
%error-verbose
%pure-parser
%union
{
int ival;
std::string* sval;
spot::eltl::nfa* nval;
spot::eltl::formula* fval;
}
%{
/* ltlparse.hh and parsedecl.hh include each other recursively.
We mut ensure that YYSTYPE is declared (by the above %union)
before parsedecl.hh uses it. */
#include "parsedecl.hh"
using namespace spot::eltl;
%}
/* All tokens. */
%token <sval> ARG "argument"
ATOMIC_PROP "atomic proposition"
IDENT "identifier"
OP_NOT "not operator"
STATE "state"
%token <ival> OP_OR "or operator"
OP_XOR "xor operator"
OP_AND "and operator"
OP_IMPLIES "implication operator"
OP_EQUIV "equivalent operator"
%token ACC "accept"
EQ "="
LPAREN "("
RPAREN ")"
COMMA ","
END_OF_FILE "end of file"
CONST_TRUE "constant true"
CONST_FALSE "constant false"
/* Priorities. */
/* Logical operators. */
%left OP_OR
%left OP_XOR
%left OP_AND
%left OP_IMPLIES OP_EQUIV
%nonassoc OP_NOT
%type <nval> nfa_def;
%type <fval> subformula;
%type <fval> arg_list;
%destructor { delete $$; } "atomic proposition"
%printer { debug_stream() << *$$; } "atomic proposition"
%%
result: nfa_list subformula
{
result = $2;
YYACCEPT;
}
;
/* NFA definitions. */
nfa_list: /* empty. */
| nfa_list nfa
;
nfa: IDENT "=" "(" nfa_def ")"
{
nmap[*$1] = nfa::ptr($4);
delete $1;
}
;
nfa_def: /* empty. */
{
$$ = new nfa();
}
| nfa_def STATE STATE ARG
{
errno = 0;
long i = strtol($4->c_str(), 0, 10);
if (i > std::numeric_limits<long>::max() ||
i < std::numeric_limits<long>::min() || errno == ERANGE)
{
std::string s = "out of range integer `";
s += *$4;
s += "'";
PARSE_ERROR(@1, s);
delete $2;
delete $3;
delete $4;
YYERROR;
}
$1->add_transition(*$2, *$3, i);
$$ = $1;
}
| nfa_def STATE STATE CONST_TRUE
{
$1->add_transition(*$2, *$3, -1);
$$ = $1;
}
| nfa_def ACC STATE
{
$1->set_final(*$3);
}
;
/* Formulae. */
subformula: ATOMIC_PROP
{
$$ = parse_environment.require(*$1);
if (!$$)
{
std::string s = "unknown atomic proposition `";
s += *$1;
s += "' in environment `";
s += parse_environment.name();
s += "'";
PARSE_ERROR(@1, s);
delete $1;
YYERROR;
}
else
delete $1;
}
| ATOMIC_PROP "(" arg_list ")"
{
nfamap::iterator i = nmap.find(*$1);
if (i == nmap.end())
{
std::string s = "unknown automaton operator `";
s += *$1;
s += "'";
PARSE_ERROR(@1, s);
delete $1;
YYERROR;
}
automatop* res = automatop::instance(i->second, $3);
if (res->size() != i->second->arity())
{
std::ostringstream oss1;
oss1 << res->size();
std::ostringstream oss2;
oss2 << i->second->arity();
std::string s(*$1);
s += " is used with ";
s += oss1.str();
s += " arguments, but has an arity of ";
s += oss2.str();
PARSE_ERROR(@1, s);
delete $1;
YYERROR;
}
$$ = res;
}
| CONST_TRUE
{ $$ = constant::true_instance(); }
| CONST_FALSE
{ $$ = constant::false_instance(); }
| "(" subformula ")"
{ $$ = $2; }
| subformula OP_AND subformula
{ $$ = multop::instance(multop::And, $1, $3); }
| subformula OP_OR subformula
{ $$ = multop::instance(multop::Or, $1, $3); }
| subformula OP_XOR subformula
{ $$ = binop::instance(binop::Xor, $1, $3); }
| subformula OP_IMPLIES subformula
{ $$ = binop::instance(binop::Implies, $1, $3); }
| subformula OP_EQUIV subformula
{ $$ = binop::instance(binop::Equiv, $1, $3); }
;
arg_list: subformula
{ $$ = $1; }
| subformula "," arg_list
{ $$ = automatop::instance($1, $3); }
;
%%
void
eltlyy::parser::error(const location_type& loc, const std::string& s)
{
PARSE_ERROR(loc, s);
}
namespace spot
{
namespace eltl
{
formula*
parse(const std::string& name,
parse_error_list& error_list,
environment& env,
bool debug)
{
if (eltlyyopen(name))
{
error_list.push_back
(parse_error(eltlyy::location(),
spair("-", std::string("Cannot open file ") + name)));
return 0;
}
formula* result = 0;
nfamap nmap;
parse_error_list_t pe;
pe.file_ = name;
eltlyy::parser parser(nmap, pe, env, result);
parser.set_debug_level(debug);
parser.parse();
error_list = pe.list_;
return result;
}
}
}
// Local Variables:
// mode: c++
// End:

187
src/eltlparse/eltlscan.ll
View file

@ -1,187 +0,0 @@
/* Copyright (C) 2008 Laboratoire d'Informatique de Paris 6 (LIP6),
** département Systèmes Répartis Coopératifs (SRC), Université Pierre
** et Marie Curie.
**
** This file is part of Spot, a model checking library.
**
** Spot 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 2 of the License, or
** (at your option) any later version.
**
** Spot 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 Spot; see the file COPYING. If not, write to the Free
** Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
** 02111-1307, USA.
*/
%option noyywrap
%option prefix="eltlyy"
%option outfile="lex.yy.c"
%{
#include <string>
#include <stack>
#include "eltlparse/parsedecl.hh"
#define YY_USER_ACTION \
yylloc->columns(yyleng);
// Flex uses `0' for end of file. 0 is not a token_type.
#define yyterminate() return token::END_OF_FILE
// Stack for handling include files.
typedef std::pair<YY_BUFFER_STATE, std::string> state;
std::stack<state> include;
#define ERROR(Msg) \
pe.list_.push_back \
(spot::eltl::parse_error(*yylloc, spot::eltl::spair(pe.file_, Msg)))
typedef eltlyy::parser::token token;
%}
eol \n|\r|\n\r|\r\n
%s formula
%x incl
%%
%{
yylloc->step();
%}
/* Rules for the automaton definitions part. */
<INITIAL>"=" return token::EQ;
<IINTIAL>"accept" return token::ACC;
<INITIAL>[tT][rR][uU][eE] {
return token::CONST_TRUE;
}
<INITIAL>"(" return token::LPAREN;
<INITIAL>")" return token::RPAREN;
<INITIAL>"%" BEGIN(formula);
<INITIAL>"include" BEGIN(incl);
<INITIAL>[a-zA-Z][a-zA-Z0-9_]* {
yylval->sval = new std::string(yytext, yyleng);
return token::IDENT;
}
<INITIAL>[0-9]+ {
yylval->sval = new std::string(yytext, yyleng);
return token::STATE;
}
<INITIAL>$[0-9]+ {
yylval->sval = new std::string(++yytext, --yyleng);
return token::ARG;
}
<INITIAL><<EOF>> {
if (include.empty())
yyterminate();
state s = include.top();
include.pop();
pe.file_ = s.second;
yy_delete_buffer(YY_CURRENT_BUFFER);
yy_switch_to_buffer(s.first);
}
/* Rules for the include part. */
<incl>[ \t]*
<incl>[^ \t\n]+ {
FILE* tmp = fopen(yytext, "r");
if (!tmp)
ERROR(std::string("cannot open file ") + yytext);
else
{
include.push(make_pair(YY_CURRENT_BUFFER, pe.file_));
pe.file_ = std::string(yytext);
yy_switch_to_buffer(yy_create_buffer(tmp, YY_BUF_SIZE));
}
BEGIN(INITIAL);
}
/* Rules for the formula part. */
<formula>"(" return token::LPAREN;
<formula>")" return token::RPAREN;
<formula>"!" return token::OP_NOT;
<formula>"," return token::COMMA;
<formula>"1"|[tT][rR][uU][eE] {
return token::CONST_TRUE;
}
<formula>"0"|[fF][aA][lL][sS][eE] {
return token::CONST_FALSE;
}
/* & and | come from Spin. && and || from LTL2BA.
/\, \/, and xor are from LBTT.
*/
<formula>"||"|"|"|"+"|"\\/" {
return token::OP_OR;
}
<formula>"&&"|"&"|"."|"*"|"/\\" {
return token::OP_AND;
}
<formula>"^"|"xor" return token::OP_XOR;
<formula>"=>"|"->" return token::OP_IMPLIES;
<formula>"<=>"|"<->" return token::OP_EQUIV;
<formula>[a-zA-Z][a-zA-Z0-9_]* {
yylval->sval = new std::string(yytext, yyleng);
return token::ATOMIC_PROP;
}
/* Global rules. */
/* discard whitespace */
{eol} yylloc->lines(yyleng); yylloc->step();
[ \t]+ yylloc->step();
. return *yytext;
%{
/* Dummy use of yyunput to shut up a gcc warning. */
(void) &yyunput;
%}
%%
namespace spot
{
namespace eltl
{
int
eltlyyopen(const std::string &name)
{
if (name == "-")
yyin = stdin;
else
{
yyin = fopen(name.c_str(), "r");
if (!yyin)
return 1;
}
return 0;
}
void
eltlyyclose()
{
fclose(yyin);
}
}
}

48
src/eltlparse/fmterror.cc
View file

@ -1,48 +0,0 @@
// Copyright (C) 2008 Laboratoire d'Informatique de Paris 6 (LIP6),
// département Systèmes Répartis Coopératifs (SRC), Université Pierre
// et Marie Curie.
//
// This file is part of Spot, a model checking library.
//
// Spot 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 2 of the License, or
// (at your option) any later version.
//
// Spot 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 Spot; see the file COPYING. If not, write to the Free
// Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
// 02111-1307, USA.
#include <ostream>
#include "public.hh"
namespace spot
{
namespace eltl
{
bool
format_parse_errors(std::ostream& os,
parse_error_list& error_list)
{
bool printed = false;
spot::eltl::parse_error_list::iterator it;
for (it = error_list.begin(); it != error_list.end(); ++it)
{
if (it->second.first != "-")
{
os << it->second.first << ": ";
os << it->first << ": ";
}
os << it->second.second << std::endl;
printed = true;
}
return printed;
}
}
}

43
src/eltlparse/parsedecl.hh
View file

@ -1,43 +0,0 @@
// Copyright (C) 2008 Laboratoire d'Informatique de Paris 6 (LIP6),
// département Systèmes Répartis Coopératifs (SRC), Université Pierre
// et Marie Curie.
//
// This file is part of Spot, a model checking library.
//
// Spot 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 2 of the License, or
// (at your option) any later version.
//
// Spot 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 Spot; see the file COPYING. If not, write to the Free
// Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
// 02111-1307, USA.
#ifndef SPOT_ELTLPARSE_PARSEDECL_HH
# define SPOT_ELTLPARSE_PARSEDECL_HH
#include "eltlparse.hh"
#include "location.hh"
# define YY_DECL \
int eltlyylex (eltlyy::parser::semantic_type *yylval, \
eltlyy::location *yylloc, \
spot::eltl::parse_error_list_t &pe)
YY_DECL;
namespace spot
{
namespace eltl
{
int eltlyyopen(const std::string& name);
void eltlyyclose();
}
}
#endif // SPOT_ELTLPARSE_PARSEDECL_HH

83
src/eltlparse/public.hh
View file

@ -1,83 +0,0 @@
// Copyright (C) 2003, 2004, 2005, 2006, 2008 Laboratoire
// d'Informatique de Paris 6 (LIP6), département Systèmes Répartis
// Coopératifs (SRC), Université Pierre et Marie Curie.
//
// This file is part of Spot, a model checking library.
//
// Spot 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 2 of the License, or
// (at your option) any later version.
//
// Spot 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 Spot; see the file COPYING. If not, write to the Free
// Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
// 02111-1307, USA.
#ifndef SPOT_ELTLPARSE_PUBLIC_HH
# define SPOT_ELTLPARSE_PUBLIC_HH
# include "eltlast/formula.hh"
// Unfortunately Bison 2.3 uses the same guards in all parsers :(
# undef BISON_LOCATION_HH
# undef BISON_POSITION_HH
# include "eltlparse/location.hh"
# include "eltlenv/defaultenv.hh"
# include "eltlast/nfa.hh"
# include <string>
# include <list>
# include <map>
# include <utility>
# include <iosfwd>
namespace spot
{
namespace eltl
{
/// \addtogroup eltl_io
/// @{
typedef std::pair<std::string, std::string> spair;
/// \brief A parse diagnostic <location, <file, message>>.
typedef std::pair<eltlyy::location, spair> parse_error;
/// \brief A list of parser diagnostics, as filled by parse.
typedef std::list<parse_error> parse_error_list;
///
typedef std::map<std::string, nfa::ptr> nfamap;
/// \brief Build a formula from a text file.
/// \param name The name of the file to parse.
/// \param error_list A list that will be filled with
/// parse errors that occured during parsing.
/// \param env The environment into which parsing should take place.
/// \param debug When true, causes the parser to trace its execution.
/// \return A pointer to the tgba built from \a filename, or
/// 0 if the file could not be opened.
///
/// \warning This function is not reentrant.
formula* parse(const std::string& name,
parse_error_list& error_list,
environment& env = default_environment::instance(),
bool debug = false);
/// \brief Format diagnostics produced by spot::eltl::parse.
/// \param os Where diagnostics should be output.
/// \param eltl_string The string that were parsed.
/// \param error_list The error list filled by spot::eltl::parse while
/// parsing \a eltl_string.
/// \return \c true iff any diagnostic was output.
bool
format_parse_errors(std::ostream& os,
parse_error_list& error_list);
/// @}
}
}
#endif // SPOT_ELTLPARSE_PUBLIC_HH