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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
/*
* $Id: sig_integer.c,v 1.16 2009-05-21 16:38:07 vrsieh Exp $
*
* Copyright (C) 2007-2009 FAUmachine Team <info@faumachine.org>.
* This program is free software. You can redistribute it and/or modify it
* under the terms of the GNU General Public License, either version 2 of
* the License, or (at your option) any later version. See COPYING.
*/
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "sig_integer.h"
static void
sig_integer_flush(struct sig_integer *b)
{
int new_val;
unsigned int nr;
if (0 < b->out_count) {
new_val = b->out[0].out;
} else {
new_val = 0;
}
for (nr = 0; nr < b->in_count; nr++) {
void (*func)(void *, int);
func = b->in[nr].f->set;
if (func
/* && b->in[nr].in != new_val */) {
b->in[nr].in = new_val;
func(b->in[nr].s, new_val);
}
}
}
void
sig_integer_set(struct sig_integer *b, void *s, int val)
{
unsigned int nr;
again: ;
for (nr = 0; ; nr++) {
if (nr == b->out_count) {
fprintf(stderr, "WARNING: late registration of integer driver of %p!\n", s);
sig_integer_connect_out(b, s, 0);
goto again;
}
assert(nr < b->out_count);
if (b->out[nr].s == s) {
b->out[nr].out = val;
break;
}
}
sig_integer_flush(b);
}
void
sig_integer_connect_in(
struct sig_integer *b,
void *s,
const struct sig_integer_funcs *f
)
{
assert(b);
assert(b->type == SIG_GEN_INTEGER);
assert(b->in_count < sizeof(b->in) / sizeof(b->in[0]));
assert(s);
assert(f);
b->in[b->in_count].s = s;
b->in[b->in_count].f = f;
b->in[b->in_count].in = 0;
b->in_count++;
sig_integer_flush(b);
}
void
sig_integer_connect_out(struct sig_integer *b, void *s, int val)
{
assert(b);
assert(b->type == SIG_GEN_INTEGER);
assert(b->out_count < sizeof(b->out) / sizeof(b->out[0]));
// assert(s);
if (! s) {
fprintf(stderr, "WARNING: %s: s is NULL pointer!\n",
__FUNCTION__);
}
b->out[b->out_count].s = s;
b->out[b->out_count].out = val;
b->out_count++;
sig_integer_flush(b);
}
struct sig_integer *
sig_integer_create(const char *name)
{
struct sig_integer *b;
b = malloc(sizeof(*b));
assert(b);
memset(b, 0, sizeof(*b));
b->type = SIG_GEN_INTEGER;
b->in_count = 0;
b->out_count = 0;
return b;
}
void
sig_integer_destroy(struct sig_integer *sig)
{
assert(sig);
assert(sig->type == SIG_GEN_INTEGER);
free(sig);
}
|
