« back to all changes in this revision
Viewing changes to src/fweelin_datatypes.h
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: Bazaar Package Importer
- Author(s): Paul Brossier
- Date: 2005-08-06 15:11:54 UTC
- Revision ID: james.westby@ubuntu.com-20050806151154-nvhhuxtyvgweh75u
Tags: upstream-0.5pre4
Import upstream version 0.5pre4
- files added:
- data
- scripts
- src
added
removed
src/fweelin_datatypes.h
1
#ifndef __FWEELIN_DATATYPES_H
2
#define __FWEELIN_DATATYPES_H
3
4
enum CoreDataType {
5
T_char,
6
T_int,
7
T_long,
8
T_float,
9
T_range,
10
T_variable,
11
T_variableref,
12
T_invalid
13
};
14
15
CoreDataType GetCoreDataType(char *name);
16
17
class Range {
18
public:
19
Range(int lo, int hi) : lo(lo), hi(hi) {};
20
21
int lo,
22
hi;
23
};
24
25
// Flexible data type configuration variable-
26
// Used in parsing and evaluating expressions from config file
27
28
#define CFG_VAR_SIZE 16 // Number of data bytes in one variable
29
class UserVariable {
30
31
public:
32
UserVariable() : name(0), value(data), next(0) {};
33
~UserVariable() {
34
if (name != 0)
35
delete[] name;
36
};
37
38
// Ensures that the precision of this variable is at least that of src
39
// If not, reconfigures this variable to match src..
40
// For ex, if this is T_char and src is T_float, this becomes T_float
41
void RaisePrecision (UserVariable &src) {
42
switch (src.type) {
43
case T_char :
44
break;
45
case T_int :
46
if (type == T_char) {
47
int tmp = (int) *this;
48
type = T_int;
49
*this = tmp;
50
}
51
break;
52
case T_long :
53
if (type == T_char || type == T_int) {
54
long tmp = (long) *this;
55
type = T_long;
56
*this = tmp;
57
}
58
break;
59
case T_float :
60
if (type == T_char || type == T_int || type == T_long) {
61
float tmp = (float) *this;
62
type = T_float;
63
*this = tmp;
64
}
65
break;
66
default :
67
break;
68
}
69
};
70
71
char operator == (UserVariable &cmp) {
72
RaisePrecision(cmp);
73
// Special case if one variable is range and one is scalar-- then
74
// we check if the scalar is within the range
75
if (type == T_range && cmp.type != T_range) {
76
int v = (int) cmp;
77
Range r(*((int *) value),*(((int *) value)+1));
78
return (v >= r.lo && v <= r.hi);
79
}
80
if (cmp.type == T_range && type != T_range) {
81
int v = (int) *this;
82
Range r(*((int *) cmp.value),*(((int *) cmp.value)+1));
83
return (v >= r.lo && v <= r.hi);
84
}
85
switch (type) {
86
case T_char :
87
return (*((char *) value) == (char) cmp);
88
case T_int :
89
return (*((int *) value) == (int) cmp);
90
case T_long :
91
return (*((long *) value) == (long) cmp);
92
case T_float :
93
return (*((float *) value) == (float) cmp);
94
case T_range :
95
{
96
Range r = (Range) cmp;
97
return (*((int *) value) == r.lo &&
98
*(((int *) value)+1) == r.hi);
99
}
100
case T_variable :
101
case T_variableref :
102
printf(" UserVariable: WARNING: Compare T_variable or T_variableref "
103
" not implemented!\n");
104
return 0;
105
case T_invalid :
106
printf(" UserVariable: WARNING: Can't compare invalid variable!\n");
107
return 0;
108
}
109
110
return 0;
111
};
112
113
char operator != (UserVariable &cmp) {
114
return !(operator == (cmp));
115
};
116
117
void operator += (UserVariable &src) {
118
RaisePrecision(src);
119
switch (type) {
120
case T_char :
121
*((char *) value) += (char) src;
122
break;
123
case T_int :
124
*((int *) value) += (int) src;
125
break;
126
case T_long :
127
*((long *) value) += (long) src;
128
break;
129
case T_float :
130
*((float *) value) += (float) src;
131
break;
132
case T_range :
133
{
134
Range r = (Range) src;
135
*((int *) value) += r.lo;
136
*(((int *) value)+1) += r.hi;
137
}
138
break;
139
case T_variable :
140
case T_variableref :
141
printf(" UserVariable: WARNING: Algebra on T_variable or T_variableref "
142
" not possible!\n");
143
break;
144
case T_invalid :
145
printf(" UserVariable: WARNING: Can't operate on invalid variable!\n");
146
break;
147
}
148
};
149
150
void operator -= (UserVariable &src) {
151
RaisePrecision(src);
152
switch (type) {
153
case T_char :
154
*((char *) value) -= (char) src;
155
break;
156
case T_int :
157
*((int *) value) -= (int) src;
158
break;
159
case T_long :
160
*((long *) value) -= (long) src;
161
break;
162
case T_float :
163
*((float *) value) -= (float) src;
164
break;
165
case T_range :
166
{
167
Range r = (Range) src;
168
*((int *) value) -= r.lo;
169
*(((int *) value)+1) -= r.hi;
170
}
171
break;
172
case T_variable :
173
case T_variableref :
174
printf(" UserVariable: WARNING: Algebra on T_variable or T_variableref "
175
" not possible!\n");
176
break;
177
case T_invalid :
178
printf(" UserVariable: WARNING: Can't operate on invalid variable!\n");
179
break;
180
}
181
};
182
183
void operator *= (UserVariable &src) {
184
RaisePrecision(src);
185
switch (type) {
186
case T_char :
187
*((char *) value) *= (char) src;
188
break;
189
case T_int :
190
*((int *) value) *= (int) src;
191
break;
192
case T_long :
193
*((long *) value) *= (long) src;
194
break;
195
case T_float :
196
*((float *) value) *= (float) src;
197
break;
198
case T_range :
199
{
200
Range r = (Range) src;
201
*((int *) value) *= r.lo;
202
*(((int *) value)+1) *= r.hi;
203
}
204
break;
205
case T_variable :
206
case T_variableref :
207
printf(" UserVariable: WARNING: Algebra on T_variable or T_variableref "
208
" not possible!\n");
209
break;
210
case T_invalid :
211
printf(" UserVariable: WARNING: Can't operate on invalid variable!\n");
212
break;
213
}
214
};
215
216
void operator /= (UserVariable &src) {
217
switch (type) {
218
case T_char :
219
case T_int :
220
case T_long :
221
case T_float :
222
{
223
// Special case- when dividing a scalar by another scalar, the
224
// result is always evaluated to a float!!
225
float t = (float) src;
226
227
// Convert this variable to a float
228
if (t != 0) {
229
*((float *) value) = (float) *this / t;
230
type = T_float;
231
}
232
}
233
break;
234
case T_range :
235
{
236
Range r = (Range) src;
237
if (r.lo != 0)
238
*((int *) value) /= r.lo;
239
if (r.hi != 0)
240
*(((int *) value)+1) /= r.hi;
241
}
242
break;
243
case T_variable :
244
case T_variableref :
245
printf(" UserVariable: WARNING: Algebra on T_variable or T_variableref "
246
" not possible!\n");
247
break;
248
case T_invalid :
249
printf(" UserVariable: WARNING: Can't operate on invalid variable!\n");
250
break;
251
}
252
};
253
254
UserVariable & operator = (char src) {
255
*((char *) value) = src;
256
return *this;
257
};
258
UserVariable & operator = (int src) {
259
*((int *) value) = src;
260
return *this;
261
};
262
UserVariable & operator = (long src) {
263
*((long *) value) = src;
264
return *this;
265
};
266
UserVariable & operator = (float src) {
267
*((float *) value) = src;
268
return *this;
269
};
270
UserVariable & operator = (Range src) {
271
*((int *) value) = src.lo;
272
*(((int *) value)+1) = src.hi;
273
return *this;
274
};
275
276
operator char () {
277
switch (type) {
278
case T_char : return *((char *) value);
279
case T_int : return (char) *((int *) value);
280
case T_long : return (char) *((long *) value);
281
case T_float : return (char) *((float *) value);
282
case T_range :
283
printf(" UserVariable: WARNING: Can't convert range to scalar!\n");
284
return 0;
285
case T_variable :
286
case T_variableref :
287
printf(" UserVariable: WARNING: Can't convert T_variable or "
288
"T_variableref!\n");
289
return 0;
290
case T_invalid :
291
printf(" UserVariable: WARNING: Can't convert invalid variable!\n");
292
return 0;
293
}
294
};
295
operator int () {
296
switch (type) {
297
case T_char : return (int) *((char *) value);
298
case T_int : return *((int *) value);
299
case T_long : return (int) *((long *) value);
300
case T_float : return (int) *((float *) value);
301
case T_range :
302
printf(" UserVariable: WARNING: Can't convert range to scalar!\n");
303
return 0;
304
case T_variable :
305
case T_variableref :
306
printf(" UserVariable: WARNING: Can't convert T_variable or "
307
"T_variableref!\n");
308
return 0;
309
case T_invalid :
310
printf(" UserVariable: WARNING: Can't convert invalid variable!\n");
311
return 0;
312
}
313
};
314
operator long () {
315
switch (type) {
316
case T_char : return (long) *((char *) value);
317
case T_int : return (long) *((int *) value);
318
case T_long : return *((long *) value);
319
case T_float : return (long) *((float *) value);
320
case T_range :
321
printf(" UserVariable: WARNING: Can't convert range to scalar!\n");
322
return 0;
323
case T_variable :
324
case T_variableref :
325
printf(" UserVariable: WARNING: Can't convert T_variable or "
326
"T_variableref!\n");
327
return 0;
328
case T_invalid :
329
printf(" UserVariable: WARNING: Can't convert invalid variable!\n");
330
return 0;
331
}
332
};
333
operator float () {
334
switch (type) {
335
case T_char : return (float) *((char *) value);
336
case T_int : return (float) *((int *) value);
337
case T_long : return (float) *((long *) value);
338
case T_float : return *((float *) value);
339
case T_range :
340
printf(" UserVariable: WARNING: Can't convert range to scalar!\n");
341
return 0;
342
case T_variable :
343
case T_variableref :
344
printf(" UserVariable: WARNING: Can't convert T_variable or "
345
"T_variableref!\n");
346
return 0;
347
case T_invalid :
348
printf(" UserVariable: WARNING: Can't convert invalid variable!\n");
349
return 0;
350
}
351
352
return 0;
353
};
354
operator Range () {
355
switch (type) {
356
case T_char : return Range(*((char *) value), *((char *) value));
357
case T_int : return Range(*((int *) value), *((int *) value));
358
case T_long : return Range(*((long *) value), *((long *) value));
359
case T_float : return Range((int) *((float *) value),
360
(int) *((float *) value));
361
case T_range : return Range(*((int *) value),*(((int *) value)+1));
362
case T_variable :
363
case T_variableref :
364
printf(" UserVariable: WARNING: Can't convert T_variable or "
365
"T_variableref!\n");
366
return Range(0,0);
367
case T_invalid :
368
printf(" UserVariable: WARNING: Can't convert invalid variable!\n");
369
return Range(0,0);
370
}
371
};
372
373
void operator = (UserVariable &src) {
374
// Assignment operator does not copy name to avoid memory alloc
375
// problems
376
type = src.type;
377
memcpy(data,src.data,CFG_VAR_SIZE);
378
if (src.value == src.data)
379
value = data;
380
else
381
value = src.value; // System variable, copy data ptr directly
382
};
383
384
// Sets this UserVariable from src, converting from src type to this
385
void SetFrom(UserVariable &src) {
386
switch (type) {
387
case T_char :
388
*this = (char) src;
389
break;
390
case T_int :
391
*this = (int) src;
392
break;
393
case T_long :
394
*this = (long) src;
395
break;
396
case T_float :
397
*this = (float) src;
398
break;
399
case T_range :
400
*this = (Range) src;
401
break;
402
case T_variable :
403
case T_variableref :
404
case T_invalid :
405
printf(" UserVariable: WARNING: Can't set from invalid variable!\n");
406
break;
407
}
408
}
409
410
// Dump UserVariable to string str (maxlen is maximum length)
411
// or stdout if str = 0
412
void Print(char *str = 0, int maxlen = 0);
413
414
char IsSystemVariable() { return (value != data); };
415
416
char *name;
417
CoreDataType type;
418
char data[CFG_VAR_SIZE];
419
420
// System variables are a special type of variable that is created by the
421
// core FreeWheeling system and not the user.
422
//
423
// A system variable is essentially a pointer to an internal data value
424
// inside FreeWheeling. It can be read by the configuration system like
425
// any other user variable, but it accesses directly into FreeWheeling's
426
// internal memory and so it has a mind of its own
427
//
428
// If value points to the data array, this is a user variable
429
// If value does not point to data, this is a system variable
430
char *value;
431
432
UserVariable *next;
433
};
434
435
#endif
Loggerhead is a web-based interface for Breezy
Version: 2.0.1