1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
/* dctrl-tools - Debian control file inspection tools
Copyright © 2003, 2004, 2008, 2010, 2011 Antti-Juhani Kaijanaho
This program 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.
This program 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, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <ctype.h>
#include <stdlib.h>
#include <regex.h>
#include <string.h>
#include "atom.h"
#include "fsaf.h"
#include "msg.h"
#include "util.h"
#include "predicate.h"
#include "strutil.h"
#include "version.h"
void init_predicate(struct predicate * p)
{
p->num_atoms = 0;
p->proglen = 0;
p->atoms = malloc(MAX_ATOMS * sizeof p->atoms[0]);
if (p->atoms == 0) enomem(0);
}
void addinsn(struct predicate * p, int insn)
{
if (insn == I_NOP) return;
if (p->proglen >= MAX_OPS) {
message(L_FATAL, 0, _("predicate is too complex"));
fail();
}
p->program[p->proglen++] = insn;
}
bool check_predicate(struct predicate * p)
{
size_t sp = 0;
/* Simulate the program. */
for (size_t i = 0; i < p->proglen; i++) {
switch (p->program[i]) {
case I_NOP: break;
case I_NEG:
if (sp == 0) return false;
break;
case I_AND: case I_OR:
if (sp < 2) return false;
--sp;
break;
default:
++sp;
}
}
if (sp != 1) return false;
return true;
}
bool does_para_satisfy(struct predicate * p, para_t * para)
{
bool sat_atom[MAX_ATOMS];
bool stack[MAX_OPS];
size_t sp = 0;
/* Verify atoms. */
for (size_t i = 0; i < p->num_atoms; i++) {
sat_atom[i] = atom_verify(&p->atoms[i], para);
}
/* Run the program. */
for (size_t i = 0; i < p->proglen; i++) {
switch (p->program[i]) {
case I_NOP: break;
case I_NEG:
assert(sp >= 1);
stack[sp-1] = !stack[sp-1];
break;
case I_AND:
assert(sp >= 2);
stack[sp-2] = stack[sp-2] && stack[sp-1];
--sp;
break;
case I_OR:
assert(sp >= 2);
stack[sp-2] = stack[sp-2] || stack[sp-1];
--sp;
break;
default:
{
int atom = p->program[i] - I_PUSH(0);
assert(atom <= p->num_atoms);
stack[sp] = sat_atom[atom];
++sp;
}
}
}
assert(sp == 1);
return stack[0];
}
|
