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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
// Union value class -*- c++ -*-
#ifndef UNIONVALUE_H_
# define UNIONVALUE_H_
# ifdef __GNUC__
# pragma interface
# endif // __GNUC__
# include "Value.h"
/** @file UnionValue.h
* Union value
*/
/* Copyright 1999-2002 Marko Mkel (msmakela@tcs.hut.fi).
This file is part of MARIA, a reachability analyzer and model checker
for high-level Petri nets.
MARIA 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, or (at your option)
any later version.
MARIA 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.
The GNU General Public License is often shipped with GNU software, and
is generally kept in a file called COPYING or LICENSE. If you do not
have a copy of the license, write to the Free Software Foundation,
59 Temple Place, Suite 330, Boston, MA 02111 USA. */
/** Union value */
class UnionValue : public Value
{
public:
/** Constructor
* @param type the union type
* @param i index of the selected component
* @param value value of the selected component
*/
UnionValue (const class Type& type,
card_t i,
class Value& value);
private:
/** Copy constructor */
UnionValue (const class UnionValue& old);
/** Assignment operator */
class UnionValue& operator= (const class UnionValue& old);
public:
/** Destructor */
~UnionValue ();
/** Virtual copy constructor */
class Value* copy () const { return new class UnionValue (*this); }
/** Determine the kind of the value */
enum Kind getKind () const { return vUnion; }
/** Determine the index of the present component */
card_t getIndex () const { return myIndex; }
/** Determine the value of the present component */
const class Value& getValue () const { return *myValue; }
/** Less-than comparison */
bool operator< (const class UnionValue& other) const;
/** Equality comparison */
bool operator== (const class UnionValue& other) const;
/** Difference operator
* @param other value to be substracted from this (may not be less)
* @return the difference
*/
card_t operator- (const class UnionValue& other) const;
/** Reset the value to the first value */
void bottom ();
/** Reset the value to the last value */
void top ();
/** Get the next value
* @return false if the value wrapped around; otherwise true
*/
bool increment ();
/** Get the previous value
* @return false if the value wrapped around; otherwise true
*/
bool decrement ();
/** Convert the value to another type if possible
* @param type type to be casted to
* @return the converted value, or NULL
*/
class Value* cast (const class Type& type);
/** Display this object
* @param printer The printer object
*/
void display (const class Printer& printer) const;
# ifdef EXPR_COMPILE
/** Dump this value in C notation
* @param out the output stream
*/
void compile (class StringBuffer& out) const;
/** Generate C assignment statements for initializing this value
* @param name name of the lvalue
* @param indent indentation level (0=generate a compound statement)
* @param out output stream for the generated code
*/
void compileInit (const char* name,
unsigned indent,
class StringBuffer& out) const;
/** Generate equality or inequality comparison expression
* @param out output stream
* @param indent indentation level
* @param var C expression to be compared
* @param equal type of comparison: true=equality, false=inequality
* @param first flag: first component (no indenting)
* @param last flag: last component (no expression chaining)
* @return true if any code was generated
*/
bool compileEqual (class StringBuffer& out,
unsigned indent,
const char* var,
bool equal,
bool first,
bool last) const;
/** Generate ordering comparison expression
* @param out output stream
* @param indent indentation level
* @param var C expression to be compared
* @param less comparison type: true=less, false=greater
* @param equal comparison type: true=equal, false=unequal
* @param first flag: first component (no indentation)
* @param last flag: last component (no expression chaining)
* @return number of parentheses left open
*/
unsigned compileOrder (class StringBuffer& out,
unsigned indent,
const char* var,
bool less,
bool equal,
bool first,
bool last) const;
# endif // EXPR_COMPILE
private:
/** Index of the referenced union component */
card_t myIndex;
/** Value of the component */
class Value* myValue;
};
#endif // UNIONVALUE_H_
|
