spot.i 12.3 KB
Newer Older
1
// -*- coding: utf-8 -*-
2
3
// Copyright (C) 2009, 2010, 2011, 2012, 2013, 2014  Laboratoire de
// Recherche et Développement de l'Epita (LRDE).
4
// Copyright (C) 2003, 2004, 2005, 2006  Laboratoire d'Informatique
5
6
// de Paris 6 (LIP6), département Systèmes Répartis Coopératifs (SRC),
// Université Pierre et Marie Curie.
Alexandre Duret-Lutz's avatar
Alexandre Duret-Lutz committed
7
8
9
10
11
//
// 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
12
// the Free Software Foundation; either version 3 of the License, or
Alexandre Duret-Lutz's avatar
Alexandre Duret-Lutz committed
13
14
15
16
17
18
19
20
// (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
21
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
Alexandre Duret-Lutz's avatar
Alexandre Duret-Lutz committed
22

23
24
25
26
27
28
%{
  // Workaround for SWIG 2.0.2 using ptrdiff_t but not including cstddef.
  // It matters with g++ 4.6.
#include <cstddef>
%}

29
%module(directors="1") spot
30
31
32
33

%include "std_string.i"
%include "std_list.i"

34
35
36
37
namespace std {
   %template(liststr) list<string>;
};

38
39
%import "buddy.i"

40
%{
41
42
#include <iostream>
#include <fstream>
43
#include <sstream>
44
#include <signal.h>
45

46
#include "misc/version.hh"
47
#include "misc/minato.hh"
48
#include "misc/optionmap.hh"
49
#include "misc/random.hh"
50

51
#include "ltlast/formula.hh"
52
53
54
55
56
57
58
#include "ltlast/refformula.hh"
#include "ltlast/atomic_prop.hh"
#include "ltlast/binop.hh"
#include "ltlast/constant.hh"
#include "ltlast/multop.hh"
#include "ltlast/unop.hh"
#include "ltlast/visitor.hh"
59

60
61
#include "ltlenv/environment.hh"
#include "ltlenv/defaultenv.hh"
62

63
64
65
66
67
68
#include "ltlparse/public.hh"

#include "ltlvisit/dotty.hh"
#include "ltlvisit/dump.hh"
#include "ltlvisit/lunabbrev.hh"
#include "ltlvisit/nenoform.hh"
69
#include "ltlvisit/simplify.hh"
70
#include "ltlvisit/tostring.hh"
71
#include "ltlvisit/tunabbrev.hh"
72
#include "ltlvisit/apcollect.hh"
73

74
75
76
77
78
#include "tgba/bdddict.hh"
#include "tgba/bddprint.hh"
#include "tgba/state.hh"
#include "tgba/succiter.hh"
#include "tgba/tgba.hh"
79
#include "tgba/sba.hh"
80
#include "tgba/statebdd.hh"
81
#include "tgba/taatgba.hh"
82
83
84
85
86
87
88
#include "tgba/tgbabddcoredata.hh"
#include "tgba/succiterconcrete.hh"
#include "tgba/tgbabddconcrete.hh"
#include "tgba/tgbaexplicit.hh"
#include "tgba/tgbaproduct.hh"
#include "tgba/tgbatba.hh"

89
#include "tgbaalgos/dottydec.hh"
90
#include "tgbaalgos/dotty.hh"
91
#include "tgbaalgos/degen.hh"
92
#include "tgbaalgos/dupexp.hh"
93
94
#include "tgbaalgos/emptiness.hh"
#include "tgbaalgos/gtec/gtec.hh"
95
96
97
98
#include "tgbaalgos/lbtt.hh"
#include "tgbaalgos/ltl2taa.hh"
#include "tgbaalgos/ltl2tgba_fm.hh"
#include "tgbaalgos/ltl2tgba_lacim.hh"
99
#include "tgbaalgos/compsusp.hh"
100
#include "tgbaalgos/magic.hh"
101
#include "tgbaalgos/minimize.hh"
102
#include "tgbaalgos/neverclaim.hh"
103
#include "tgbaalgos/rundotdec.hh"
104
#include "tgbaalgos/save.hh"
105
#include "tgbaalgos/safety.hh"
106
#include "tgbaalgos/sccfilter.hh"
107
#include "tgbaalgos/stats.hh"
108
#include "tgbaalgos/isdet.hh"
109
#include "tgbaalgos/simulation.hh"
110
#include "tgbaalgos/postproc.hh"
111

112
113
#include "tgbaparse/public.hh"

114
115
116
117
118
119
120
121
122
#include "ta/ta.hh"
#include "ta/tgta.hh"
#include "ta/taexplicit.hh"
#include "ta/tgtaexplicit.hh"
#include "taalgos/tgba2ta.hh"
#include "taalgos/dotty.hh"
#include "taalgos/stats.hh"
#include "taalgos/minimize.hh"

123
using namespace spot::ltl;
124
using namespace spot;
125
126
%}

127
128
129
130
// For spot::emptiness_check_instantiator::construct and any other
// function that return errors via a "char **err" argument.
%typemap(in, numinputs=0) char** OUTPUT (char* temp)
  "$1 = &temp;";
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
%typemap(argout) char** OUTPUT {
  PyObject *obj = SWIG_FromCharPtr(*$1);
  if (!$result) {
    $result = obj;
  //# If the function returns null_ptr (i.e. Py_None), we
  //# don't want to override it with OUTPUT as in the
  //# default implementation of t_output_helper.
  // } else if ($result == Py_None) {
  //   Py_DECREF($result);
  //   $result = obj;
  } else {
    if (!PyList_Check($result)) {
      PyObject *o2 = $result;
      $result = PyList_New(1);
      PyList_SetItem($result, 0, o2);
    }
    PyList_Append($result,obj);
    Py_DECREF(obj);
  }
 };
151
152
%apply char** OUTPUT { char** err };

153
154
155
156
157
// False and True cannot be redefined in Python3, even in a class.
// Spot uses these in an enum of the constant class.
%rename(FalseVal) False;
%rename(TrueVal) True;

158
%include "misc/version.hh"
159
%include "misc/minato.hh"
160
%include "misc/optionmap.hh"
161
%include "misc/random.hh"
162

163
%include "ltlast/formula.hh"
164
165
166
167
168
169
170
%include "ltlast/refformula.hh"
%include "ltlast/atomic_prop.hh"
%include "ltlast/binop.hh"
%include "ltlast/constant.hh"
%include "ltlast/multop.hh"
%include "ltlast/unop.hh"
%include "ltlast/visitor.hh"
171

172
173
%include "ltlenv/environment.hh"
%include "ltlenv/defaultenv.hh"
174

175
176
177
178
179
180
%include "ltlparse/public.hh"

%include "ltlvisit/dotty.hh"
%include "ltlvisit/dump.hh"
%include "ltlvisit/lunabbrev.hh"
%include "ltlvisit/nenoform.hh"
181
%include "ltlvisit/simplify.hh"
182
%include "ltlvisit/tostring.hh"
183
%include "ltlvisit/tunabbrev.hh"
184
%include "ltlvisit/apcollect.hh"
185

186
%feature("new") spot::emptiness_check::check;
187
188
%feature("new") spot::emptiness_check_instantiator::construct;
%feature("new") spot::emptiness_check_instantiator::instanciate;
189
%feature("new") spot::emptiness_check_result::accepting_run;
190
191
%feature("new") spot::explicit_magic_search;
%feature("new") spot::explicit_se05_search;
192
193
194
%feature("new") spot::ltl_to_taa;
%feature("new") spot::ltl_to_tgba_fm;
%feature("new") spot::ltl_to_tgba_lacim;
195
%feature("new") spot::compsusp;
196
197
%feature("new") spot::minimize_wdba;
%feature("new") spot::minimize_monitor;
198
%feature("new") spot::scc_filter;
199
200
201
202
203
%feature("new") spot::tgba_dupexp_bfs;
%feature("new") spot::tgba_dupexp_dfs;
%feature("new") spot::tgba::get_init_state;
%feature("new") spot::tgba::succ_iter;
%feature("new") spot::tgba_succ_iterator::current_state;
204
%feature("new") spot::simulation;
205
206
%feature("new") spot::cosimulation;
%feature("new") spot::iterated_simulations;
207
%feature("new") spot::degeneralize;
208
%feature("new") spot::tgba_parse;
209
210
%feature("new") spot::tgba_to_ta;
%feature("new") spot::tgba_to_tgta;
211
212
213
214
215
216
%feature("new") spot::postprocessor::run;

// The argument to postprocessor::run() will be deleted.
// Apparently SWIG can only disown arguments based on their
// names...
%apply SWIGTYPE *DISOWN { SWIGTYPE * input_disown };
217

218
219
220
221
222
223
224
// Help SWIG with namespace lookups.
#define ltl spot::ltl
%include "tgba/bdddict.hh"
%include "tgba/bddprint.hh"
%include "tgba/state.hh"
%include "tgba/succiter.hh"
%include "tgba/tgba.hh"
225
%include "tgba/sba.hh"
226
%include "tgba/statebdd.hh"
227
%include "tgba/taatgba.hh"
228
229
230
231
232
233
234
%include "tgba/tgbabddcoredata.hh"
%include "tgba/succiterconcrete.hh"
%include "tgba/tgbabddconcrete.hh"
%include "tgba/tgbaexplicit.hh"
%include "tgba/tgbaproduct.hh"
%include "tgba/tgbatba.hh"

235
236
237
238
239
240
%template(explicit_graph__string_tgba)
  spot::explicit_graph<state_explicit_string, tgba>;
%template(explicit_graph__number_tgba)
  spot::explicit_graph<state_explicit_number, tgba>;
%template(explicit_graph__formula_tgba)
  spot::explicit_graph<state_explicit_formula, tgba>;
241
242

%template(explicit_string_tgba)
243
  spot::tgba_explicit<state_explicit_string>;
244
%template(explicit_number_tgba)
245
  spot::tgba_explicit<state_explicit_number>;
246
247
%template(explicit_formula_tgba)
  spot::tgba_explicit<state_explicit_formula>;
248
249
250
251
252
253
254
255
256
257

%template(explicit_string__tgba)
  spot::explicit_conf<tgba_explicit<state_explicit_string>,
                      state_explicit_string>;
%template(explicit_number__tgba)
  spot::explicit_conf<tgba_explicit<state_explicit_number>,
		      state_explicit_number>;
%template(explicit_formula__tgba)
  spot::explicit_conf<tgba_explicit<state_explicit_formula>,
		      state_explicit_formula>;
258

259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
%template(explicit_graph__string_sba)
  spot::explicit_graph<state_explicit_string, sba>;
%template(explicit_graph__number_sba)
  spot::explicit_graph<state_explicit_number, sba>;
%template(explicit_graph__formula_sba)
  spot::explicit_graph<state_explicit_formula, sba>;

%template(explicit_string_sba)
  spot::sba_explicit<state_explicit_string>;
%template(explicit_number_sba)
  spot::sba_explicit<state_explicit_number>;
%template(explicit_formula_sba)
  spot::sba_explicit<state_explicit_formula>;

%template(explicit_string__sba)
  spot::explicit_conf<sba_explicit<state_explicit_string>,
                      state_explicit_string>;
%template(explicit_number__sba)
  spot::explicit_conf<sba_explicit<state_explicit_number>,
		      state_explicit_number>;
%template(explicit_formula__sba)
  spot::explicit_conf<sba_explicit<state_explicit_formula>,
		      state_explicit_formula>;

283
%include "tgbaalgos/degen.hh"
284
%include "tgbaalgos/dottydec.hh"
285
%include "tgbaalgos/dotty.hh"
286
%include "tgbaalgos/dupexp.hh"
287
288
%include "tgbaalgos/emptiness.hh"
%include "tgbaalgos/gtec/gtec.hh"
289
290
291
292
%include "tgbaalgos/lbtt.hh"
%include "tgbaalgos/ltl2taa.hh"
%include "tgbaalgos/ltl2tgba_fm.hh"
%include "tgbaalgos/ltl2tgba_lacim.hh"
293
%include "tgbaalgos/compsusp.hh"
294
%include "tgbaalgos/magic.hh"
295
%include "tgbaalgos/minimize.hh"
296
%include "tgbaalgos/neverclaim.hh"
297
%include "tgbaalgos/rundotdec.hh"
298
%include "tgbaalgos/save.hh"
299
%include "tgbaalgos/safety.hh"
300
%include "tgbaalgos/sccfilter.hh"
301
%include "tgbaalgos/stats.hh"
302
%include "tgbaalgos/isdet.hh"
303
%include "tgbaalgos/simulation.hh"
304
%include "tgbaalgos/postproc.hh"
305
306
307

%include "tgbaparse/public.hh"

308
309
310
311
312
313
314
315
316
317
318
%include "ta/ta.hh"
%include "ta/tgta.hh"
%include "ta/taexplicit.hh"
%include "ta/tgtaexplicit.hh"
%include "taalgos/tgba2ta.hh"
%include "taalgos/dotty.hh"
%include "taalgos/stats.hh"
%include "taalgos/minimize.hh"



319
#undef ltl
320
321
322
323
324

%extend spot::ltl::formula {

  // When comparing formula, make sure Python compare our
  // pointers, not the pointers to its wrappers.
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341

  // __cmp__ is for Python 2.0
  int __cmp__(const spot::ltl::formula* b) { return self - b; }
  // These are for Python 2.1+ or 3.x.  They more closely match
  // the logic in Spot.
  bool __lt__(const spot::ltl::formula* b)
  { spot::ltl::formula_ptr_less_than lt; return lt(self, b); }
  bool __le__(const spot::ltl::formula* b)
  { spot::ltl::formula_ptr_less_than lt; return !lt(b, self); }
  bool __eq__(const spot::ltl::formula* b) { return self == b; }
  bool __ne__(const spot::ltl::formula* b) { return self != b; }
  bool __gt__(const spot::ltl::formula* b)
  { spot::ltl::formula_ptr_less_than lt; return lt(b, self); }
  bool __ge__(const spot::ltl::formula* b)
  { spot::ltl::formula_ptr_less_than lt; return !lt(self, b); }

  size_t __hash__() { return self->hash(); }
342
343
344
345
346
347
348
349

  std::string
  __str__(void)
  {
    return spot::ltl::to_string(self);
  }

}
350

351
%nodefaultctor std::ostream;
352
353
354
355
356
357
358
359
namespace std {
  class ostream {};
  class ofstream : public ostream
  {
  public:
     ofstream(const char *fn);
     ~ofstream();
  };
360
361
362
363
364
  class ostringstream : public ostream
  {
  public:
     ostringstream();
     std::string str() const;
365
     ~ostringstream();
366
  };
367
368
}

369
370
%feature("new") minimize_obligation_new;

371
372
%inline %{

373
374
375
376
377
378
379
380
381
382
383
384
385
// A variant of minimize_obligation() that always return a new object.
const spot::tgba*
minimize_obligation_new(const spot::tgba* a, const spot::ltl::formula* f)
{
  const tgba* res = spot::minimize_obligation(a, f);
  // Return 0 if the output is the same as the input, otherwise
  // it is hard for swig to know if the output is "new" or not.
  if (res == a)
    return 0;
  else
    return res;
}

386
387
388
389
390
391
void
tgba_enable_utf8(spot::tgba* a)
{
  if (spot::tgba_explicit_formula* tef =
      dynamic_cast<spot::tgba_explicit_formula*>(a))
    tef->enable_utf8();
Alexandre Duret-Lutz's avatar
Alexandre Duret-Lutz committed
392
393
394
  else if (spot::sba_explicit_formula* sef =
	   dynamic_cast<spot::sba_explicit_formula*>(a))
    sef->enable_utf8();
395
396
}

397
spot::ltl::parse_error_list
398
399
400
401
402
403
empty_parse_error_list()
{
  parse_error_list l;
  return l;
}

404
405
406
407
408
409
410
spot::tgba_parse_error_list
empty_tgba_parse_error_list()
{
  tgba_parse_error_list l;
  return l;
}

411
std::ostream&
412
413
414
415
416
get_cout()
{
  return std::cout;
}

417
418
419
420
421
422
void
nl_cout()
{
  std::cout << std::endl;
}

423
std::ostream&
424
425
426
427
428
get_cerr()
{
  return std::cerr;
}

429
430
431
432
433
434
void
nl_cerr()
{
  std::cerr << std::endl;
}

435
void
436
437
438
439
print_on(std::ostream& on, const std::string& what)
{
  on << what;
}
440

441
442
443
444
445
446
447
448
449
int
unblock_signal(int signum)
{
  sigset_t set;
  sigemptyset(&set);
  sigaddset(&set, signum);
  return sigprocmask(SIG_UNBLOCK, &set, 0);
}

450
%}
451
452
453
454
455
456
457
458
459

%extend spot::ltl::parse_error_list {

bool
__nonzero__()
{
  return !self->empty();
}

460
461
462
463
464
465
bool
__bool__()
{
  return !self->empty();
}

466
}
467
468
469
470
471
472
473
474
475

%extend spot::tgba_parse_error_list {

bool
__nonzero__()
{
  return !self->empty();
}

476
477
478
479
480
481
bool
__bool__()
{
  return !self->empty();
}

482
}