-
Notifications
You must be signed in to change notification settings - Fork 0
/
p2atom.h
218 lines (201 loc) · 7.87 KB
/
p2atom.h
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
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
/****************************************************************************
*
* Propeller2 assembler atomic data element class
*
* Copyright (C) 2019 Jürgen Buchmüller <pullmoll@t-online.de>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
****************************************************************************/
#pragma once
#include <QVariant>
#include "p2defs.h"
#include "p2union.h"
/**
* @brief The P2Atom class is used to handle expression "atoms" for the Propeller2 assembler.
*
* The data is stored in an array of bytes (QByteArray) which is appended to from
* the basic BYTE, WORD, LONG, or FILE definitions in the source code.
* Also the virtual type QUAD (64 bit unsigned) is accessible for intermediate results.
*
* The data can grow arbitrary large e.g. for strings or FILE contents.
*
* There is a set of operations which can be performed on the atom:
*
* <ul>
* <li>~: one's complement</li>
* <li>-: two's complement (i.e. unary minus)</li>
* <li>!: logical not</li>
* <li>make_bool</li>
* <li>--: unary decrement</li>
* <li>++: unary increment</li>
* <li>* atom: multiplication</li>
* <li>/ atom: division</li>
* <li>% atom: modulo</li>
* <li>+ atom: addition</li>
* <li>- atom: subtraction</li>
* <li><</li><</li> atom: binary shift left</li>
* <li>></li>></li> atom: binary shift right</li>
* <li>&</li> atom: binary AND</li>
* <li>^ atom: binary XOR</li>
* <li>| atom: binary OR</li>
* <li>binary_rev</li>
* </ul>
*/
class P2Atom
{
public:
explicit P2Atom(p2_Union_e type = ut_Invalid);
P2Atom(const P2Atom& other);
P2Atom(bool _bool);
P2Atom(const p2_BYTE _byte);
P2Atom(const p2_WORD _word);
P2Atom(const p2_LONG _long);
P2Atom(const p2_QUAD _quad);
P2Atom(const p2_REAL _real);
P2Atom(const p2_LONG _cog, const p2_LONG _hub, bool hubmode);
void clear(p2_Union_e type = ut_Invalid);
bool isNull() const;
bool isEmpty() const;
bool isZero() const;
bool isValid() const;
int size() const;
int usize() const;
int count() const;
p2_Union_e type() const;
const QString type_name() const;
void set_type(p2_Union_e type);
bool hubmode() const;
void set_hubmode(bool hubmode);
p2_Traits_e traits() const;
bool set_traits(const p2_Traits_e traits);
bool add_trait(const p2_Traits_e trait, bool on);
bool add_trait(const p2_Traits_e trait);
bool add_trait(const p2_LONG trait);
bool remove_trait(const p2_Traits_e trait);
bool remove_trait(const p2_LONG trait);
bool has_trait(const p2_Traits_e trait) const;
bool has_trait(const p2_LONG trait) const;
const P2Union value() const;
void set_value(const P2Union value);
const P2Union index() const;
void set_index(const P2Atom& index);
p2_LONG index_long() const;
void set_int(const int _int);
void set_bool(const bool _bool);
void set_char(const char _char);
void set_byte(const p2_BYTE _byte);
void set_word(const p2_WORD _word);
void set_long(const p2_LONG _long);
void set_addr(const p2_LONG _cog, const p2_LONG _hub, bool hubmode);
void set_quad(const p2_QUAD _quad);
void set_real(const p2_REAL _real);
void set_chars(const p2_CHARS& _chars);
void set_bytes(const p2_BYTES& _bytes);
void set_words(const p2_WORDS& _words);
void set_longs(const p2_LONGS& _longs);
void set_array(const QByteArray& _array);
void add_int(const int _int);
void add_bool(const bool _bool);
void add_char(const char _char);
void add_byte(const p2_BYTE _byte);
void add_word(const p2_WORD _word);
void add_long(const p2_LONG _long);
void add_addr(const p2_LONG _cog, const p2_LONG _hub, bool hubmode);
void add_quad(const p2_QUAD _quad);
void add_real(const p2_REAL _real);
void add_chars(const p2_CHARS& _chars);
void add_bytes(const p2_BYTES& _bytes);
void add_words(const p2_WORDS& _words);
void add_longs(const p2_LONGS& _longs);
void add_array(const QByteArray& get);
QString str(bool with_type = false, p2_FORMAT_e fmt = fmt_hex) const;
bool get_bool() const;
int get_int() const;
p2_BYTE get_byte() const;
p2_WORD get_word() const;
p2_LONG get_long() const;
p2_LONG get_addr() const;
p2_LONG get_addr(bool hub) const;
p2_QUAD get_quad() const;
p2_REAL get_real() const;
QString string(bool expand = false) const;
QByteArray array(bool expand = false) const;
p2_BYTES get_bytes(bool expand = false) const;
p2_WORDS get_words(bool expand = false) const;
p2_LONGS get_longs(bool expand = false) const;
void make_real();
void complement1(bool flag);
void complement2(bool flag);
void logical_not(bool flag);
void make_bool(bool flag);
void unary_dec(const p2_LONG val = 1);
void unary_inc(const p2_LONG val = 1);
void arith_mul(const P2Atom& atom);
void arith_div(const P2Atom& atom);
void arith_mod(const P2Atom& atom);
void arith_add(const P2Atom& atom);
void arith_sub(const P2Atom& atom);
void binary_shl(const P2Atom& atom);
void binary_shr(const P2Atom& atom);
void binary_and(const P2Atom& atom);
void binary_xor(const P2Atom& atom);
void binary_or(const P2Atom& atom);
void binary_rev();
void reverse(const P2Atom& atom);
void encode(const P2Atom& atom);
void decode(const P2Atom& atom);
P2Atom& operator=(const P2Atom& other);
bool operator==(const P2Atom& other);
bool operator!=(const P2Atom& other);
bool operator<(const P2Atom& other);
bool operator<=(const P2Atom& other);
bool operator>(const P2Atom& other);
bool operator>=(const P2Atom& other);
P2Atom& operator~();
P2Atom& operator-();
P2Atom& operator!();
P2Atom& operator++();
P2Atom& operator--();
P2Atom& operator+=(const P2Atom& other);
P2Atom& operator-=(const P2Atom& other);
P2Atom& operator*=(const P2Atom& other);
P2Atom& operator/=(const P2Atom& other);
P2Atom& operator%=(const P2Atom& other);
P2Atom& operator<<=(const P2Atom& other);
P2Atom& operator>>=(const P2Atom& other);
P2Atom& operator&=(const P2Atom& other);
P2Atom& operator^=(const P2Atom& other);
P2Atom& operator|=(const P2Atom& other);
static QByteArray array(const P2Atom& atom);
static QString string(const P2Atom& atom);
private:
P2Traits m_traits; //!< Traits for this atom
P2Union m_value; //!< Actual value of this atom
P2Union m_index; //!< Optional index value of this atom
};
Q_DECLARE_METATYPE(P2Atom)