1 /*****************************************************************************
2
3 Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
4 more contributor license agreements. See the NOTICE file distributed
5 with this work for additional information regarding copyright ownership.
6 Accellera licenses this file to you under the Apache License, Version 2.0
7 (the "License"); you may not use this file except in compliance with the
8 License. You may obtain a copy of the License at
9
10 http://www.apache.org/licenses/LICENSE-2.0
11
12 Unless required by applicable law or agreed to in writing, software
13 distributed under the License is distributed on an "AS IS" BASIS,
14 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
15 implied. See the License for the specific language governing
16 permissions and limitations under the License.
17
18 *****************************************************************************/
19
20 /*****************************************************************************
21
22 sc_unsigned.h -- Arbitrary precision unsigned arithmetic.
23
24 This file includes the definitions of sc_unsigned_bitref,
25 sc_unsigned_subref, and sc_unsigned classes. The first two classes
26 are proxy classes to reference one bit and a range of bits of a
27 sc_unsigned number, respectively.
28
29 An sc_signed number has the sign-magnitude representation
30 internally. However, its interface guarantees a 2's-complement
31 representation. The sign-magnitude representation is chosen
32 because of its efficiency: The sc_signed and sc_unsigned types are
33 optimized for arithmetic rather than bitwise operations. For
34 arithmetic operations, the sign-magnitude representation performs
35 better.
36
37 It is also important to note that an sc_unsigned number with n
38 bits is equivalent to an sc_signed non-negative number with n + 1
39 bits.
40
41 The implementations of sc_signed and sc_unsigned classes are
42 almost identical: Most of the member and friend functions are
43 defined in sc_nbcommon.cpp and sc_nbfriends.cpp so that they can
44 be shared by both of these classes. These functions are chosed by
45 defining a few macros before including them such as IF_SC_SIGNED
46 and CLASS_TYPE. Our implementation choices are mostly dictated by
47 performance considerations in that we tried to provide the most
48 efficient sc_signed and sc_unsigned types without compromising
49 their interface.
50
51 For the behavior of operators, we have two semantics: the old and
52 new. The most important difference between these two semantics is
53 that the old semantics is closer to C/C++ semantics in that the
54 result type of a binary operator on unsigned and signed arguments
55 is unsigned; the new semantics, on the other hand, requires the
56 result type be signed. The new semantics is required by the VSIA
57 C/C++ data types standard. We have implemented the new semantics.
58
59 Original Author: Ali Dasdan, Synopsys, Inc.
60
61 *****************************************************************************/
62
63 /*****************************************************************************
64
65 MODIFICATION LOG - modifiers, enter your name, affiliation, date and
66 changes you are making here.
67
68 Name, Affiliation, Date:
69 Description of Modification:
70
71 *****************************************************************************/
72
73 // $Log: sc_unsigned.h,v $
74 // Revision 1.4 2011/08/24 22:05:46 acg
75 // Torsten Maehne: initialization changes to remove warnings.
76 //
77 // Revision 1.3 2011/02/18 20:19:15 acg
78 // Andy Goodrich: updating Copyright notice.
79 //
80 // Revision 1.2 2009/02/28 00:26:26 acg
81 // Andy Goodrich: bug fixes.
82 //
83 // Revision 1.1.1.1 2006/12/15 20:20:05 acg
84 // SystemC 2.3
85 //
86 // Revision 1.5 2006/05/08 17:50:02 acg
87 // Andy Goodrich: Added David Long's declarations for friend operators,
88 // functions, and methods, to keep the Microsoft compiler happy.
89 //
90 // Revision 1.4 2006/03/13 20:25:27 acg
91 // Andy Goodrich: Addition of function declarations, e.g., xor_signed_friend()
92 // to keep gcc 4.x happy.
93 //
94 // Revision 1.3 2006/01/13 18:49:32 acg
95 // Added $Log command so that CVS check in comments are reproduced in the
96 // source.
97 //
98
99 #ifndef SC_UNSIGNED_H
100 #define SC_UNSIGNED_H
101
102
103 #include "sysc/kernel/sc_object.h"
104 #include "sysc/datatypes/misc/sc_value_base.h"
105 #include "sysc/utils/sc_temporary.h"
106 #include "sysc/datatypes/int/sc_length_param.h"
107 #include "sysc/datatypes/int/sc_nbdefs.h"
108 #include "sysc/datatypes/int/sc_nbutils.h"
109 #include "sysc/datatypes/int/sc_nbexterns.h"
110 #include "sysc/utils/sc_temporary.h"
111
112
113 namespace sc_dt
114 {
115
116 // classes defined in this module
117 class sc_unsigned_bitref_r;
118 class sc_unsigned_bitref;
119 class sc_unsigned_subref_r;
120 class sc_unsigned_subref;
121 class sc_concatref;
122 class sc_unsigned;
123
124 // forward class declarations
125 class sc_bv_base;
126 class sc_lv_base;
127 class sc_int_base;
128 class sc_uint_base;
129 class sc_int_subref_r;
130 class sc_uint_subref_r;
131 class sc_signed;
132 class sc_signed_subref_r;
133 class sc_fxval;
134 class sc_fxval_fast;
135 class sc_fxnum;
136 class sc_fxnum_fast;
137
138 } // namespace sc_dt
139
140 // extern template instantiations
141 namespace sc_core {
142 SC_API_TEMPLATE_DECL_ sc_vpool<sc_dt::sc_unsigned_bitref>;
143 SC_API_TEMPLATE_DECL_ sc_vpool<sc_dt::sc_unsigned_subref>;
144 SC_API_TEMPLATE_DECL_ sc_vpool<sc_dt::sc_unsigned>;
145 } // namespace sc_core
146
147 namespace sc_dt {
148
149 // Helper function declarions
150 int compare_unsigned(small_type us,
151 int unb,
152 int und,
153 const sc_digit *ud,
154 small_type vs,
155 int vnb,
156 int vnd,
157 const sc_digit *vd,
158 small_type if_u_signed=0,
159 small_type if_v_signed=0);
160
161 sc_unsigned add_unsigned_friend(small_type us,
162 int unb,
163 int und,
164 const sc_digit *ud,
165 small_type vs,
166 int vnb,
167 int vnd,
168 const sc_digit *vd);
169
170 sc_unsigned sub_unsigned_friend(small_type us,
171 int unb,
172 int und,
173 const sc_digit *ud,
174 small_type vs,
175 int vnb,
176 int vnd,
177 const sc_digit *vd);
178
179 sc_unsigned mul_unsigned_friend(small_type s,
180 int unb,
181 int und,
182 const sc_digit *ud,
183 int vnb,
184 int vnd,
185 const sc_digit *vd);
186
187 sc_unsigned div_unsigned_friend(small_type s,
188 int unb,
189 int und,
190 const sc_digit *ud,
191 int vnb,
192 int vnd,
193 const sc_digit *vd);
194
195 sc_unsigned mod_unsigned_friend(small_type us,
196 int unb,
197 int und,
198 const sc_digit *ud,
199 int vnb,
200 int vnd,
201 const sc_digit *vd);
202
203 sc_unsigned and_unsigned_friend(small_type us,
204 int unb,
205 int und,
206 const sc_digit *ud,
207 small_type vs,
208 int vnb,
209 int vnd,
210 const sc_digit *vd);
211
212
213 sc_unsigned or_unsigned_friend(small_type us,
214 int unb,
215 int und,
216 const sc_digit *ud,
217 small_type vs,
218 int vnb,
219 int vnd,
220 const sc_digit *vd);
221
222 sc_unsigned xor_unsigned_friend(small_type us,
223 int unb,
224 int und,
225 const sc_digit *ud,
226 small_type vs,
227 int vnb,
228 int vnd,
229 const sc_digit *vd);
230
231 // friend operator declarations
232 // ARITHMETIC OPERATORS:
233
234 // ADDition operators:
235
236 SC_API sc_signed operator + (const sc_unsigned& u, const sc_signed& v);
237 SC_API sc_signed operator + (const sc_signed& u, const sc_unsigned& v);
238
239 SC_API sc_unsigned operator + (const sc_unsigned& u, const sc_unsigned& v);
240 SC_API sc_signed operator + (const sc_unsigned& u, int64 v);
241 SC_API sc_unsigned operator + (const sc_unsigned& u, uint64 v);
242 SC_API sc_signed operator + (const sc_unsigned& u, long v);
243 SC_API sc_unsigned operator + (const sc_unsigned& u, unsigned long v);
244 SC_API sc_signed operator + (const sc_unsigned& u, int v);
245 inline sc_unsigned operator + (const sc_unsigned& u, unsigned int v);
246
247 SC_API sc_signed operator + (int64 u, const sc_unsigned& v);
248 SC_API sc_unsigned operator + (uint64 u, const sc_unsigned& v);
249 SC_API sc_signed operator + (long u, const sc_unsigned& v);
250 SC_API sc_unsigned operator + (unsigned long u, const sc_unsigned& v);
251 SC_API sc_signed operator + (int u, const sc_unsigned& v);
252 inline sc_unsigned operator + (unsigned int u, const sc_unsigned& v);
253
254 SC_API sc_unsigned operator + (const sc_unsigned& u, const sc_uint_base& v);
255 SC_API sc_signed operator + (const sc_unsigned& u, const sc_int_base& v);
256 SC_API sc_unsigned operator + (const sc_uint_base& u, const sc_unsigned& v);
257 SC_API sc_signed operator + (const sc_int_base& u, const sc_unsigned& v);
258
259 // SUBtraction operators:
260
261 SC_API sc_signed operator - (const sc_unsigned& u, const sc_signed& v);
262 SC_API sc_signed operator - (const sc_signed& u, const sc_unsigned& v);
263
264 SC_API sc_signed operator - (const sc_unsigned& u, const sc_unsigned& v);
265 SC_API sc_signed operator - (const sc_unsigned& u, int64 v);
266 SC_API sc_signed operator - (const sc_unsigned& u, uint64 v);
267 SC_API sc_signed operator - (const sc_unsigned& u, long v);
268 SC_API sc_signed operator - (const sc_unsigned& u, unsigned long v);
269 SC_API sc_signed operator - (const sc_unsigned& u, int v);
270 SC_API sc_signed operator - (const sc_unsigned& u, unsigned int v);
271
272 SC_API sc_signed operator - (int64 u, const sc_unsigned& v);
273 SC_API sc_signed operator - (uint64 u, const sc_unsigned& v);
274 SC_API sc_signed operator - (long u, const sc_unsigned& v);
275 SC_API sc_signed operator - (unsigned long u, const sc_unsigned& v);
276 SC_API sc_signed operator - (int u, const sc_unsigned& v);
277 SC_API sc_signed operator - (unsigned int u, const sc_unsigned& v);
278
279 SC_API sc_signed operator - (const sc_unsigned& u, const sc_uint_base& v);
280 SC_API sc_signed operator - (const sc_unsigned& u, const sc_int_base& v);
281 SC_API sc_signed operator - (const sc_uint_base& u, const sc_unsigned& v);
282 SC_API sc_signed operator - (const sc_int_base& u, const sc_unsigned& v);
283
284 // MULtiplication operators:
285
286 SC_API sc_signed operator * (const sc_unsigned& u, const sc_signed& v);
287 SC_API sc_signed operator * (const sc_signed& u, const sc_unsigned& v);
288
289 SC_API sc_unsigned operator * (const sc_unsigned& u, const sc_unsigned& v);
290 SC_API sc_signed operator * (const sc_unsigned& u, int64 v);
291 SC_API sc_unsigned operator * (const sc_unsigned& u, uint64 v);
292 SC_API sc_signed operator * (const sc_unsigned& u, long v);
293 SC_API sc_unsigned operator * (const sc_unsigned& u, unsigned long v);
294 SC_API sc_signed operator * (const sc_unsigned& u, int v);
295 inline sc_unsigned operator * (const sc_unsigned& u, unsigned int v);
296
297 SC_API sc_signed operator * (int64 u, const sc_unsigned& v);
298 SC_API sc_unsigned operator * (uint64 u, const sc_unsigned& v);
299 SC_API sc_signed operator * (long u, const sc_unsigned& v);
300 SC_API sc_unsigned operator * (unsigned long u, const sc_unsigned& v);
301 SC_API sc_signed operator * (int u, const sc_unsigned& v);
302 inline sc_unsigned operator * (unsigned int u, const sc_unsigned& v);
303
304 SC_API sc_unsigned operator * (const sc_unsigned& u, const sc_uint_base& v);
305 SC_API sc_signed operator * (const sc_unsigned& u, const sc_int_base& v);
306 SC_API sc_unsigned operator * (const sc_uint_base& u, const sc_unsigned& v);
307 SC_API sc_signed operator * (const sc_int_base& u, const sc_unsigned& v);
308
309 // DIVision operators:
310
311 SC_API sc_signed operator / (const sc_unsigned& u, const sc_signed& v);
312 SC_API sc_signed operator / (const sc_signed& u, const sc_unsigned& v);
313
314 SC_API sc_unsigned operator / (const sc_unsigned& u, const sc_unsigned& v);
315 SC_API sc_signed operator / (const sc_unsigned& u, int64 v);
316 SC_API sc_unsigned operator / (const sc_unsigned& u, uint64 v);
317 SC_API sc_signed operator / (const sc_unsigned& u, long v);
318 SC_API sc_unsigned operator / (const sc_unsigned& u, unsigned long v);
319 SC_API sc_signed operator / (const sc_unsigned& u, int v);
320 inline sc_unsigned operator / (const sc_unsigned& u, unsigned int v);
321
322 SC_API sc_signed operator / (int64 u, const sc_unsigned& v);
323 SC_API sc_unsigned operator / (uint64 u, const sc_unsigned& v);
324 SC_API sc_signed operator / (long u, const sc_unsigned& v);
325 SC_API sc_unsigned operator / (unsigned long u, const sc_unsigned& v);
326 SC_API sc_signed operator / (int u, const sc_unsigned& v);
327 inline sc_unsigned operator / (unsigned int u, const sc_unsigned& v);
328
329 SC_API sc_unsigned operator / (const sc_unsigned& u, const sc_uint_base& v);
330 SC_API sc_signed operator / (const sc_unsigned& u, const sc_int_base& v);
331 SC_API sc_unsigned operator / (const sc_uint_base& u, const sc_unsigned& v);
332 SC_API sc_signed operator / (const sc_int_base& u, const sc_unsigned& v);
333
334 // MODulo operators:
335
336 SC_API sc_signed operator % (const sc_unsigned& u, const sc_signed& v);
337 SC_API sc_signed operator % (const sc_signed& u, const sc_unsigned& v);
338
339 SC_API sc_unsigned operator % (const sc_unsigned& u, const sc_unsigned& v);
340 SC_API sc_signed operator % (const sc_unsigned& u, int64 v);
341 SC_API sc_unsigned operator % (const sc_unsigned& u, uint64 v);
342 SC_API sc_signed operator % (const sc_unsigned& u, long v);
343 SC_API sc_unsigned operator % (const sc_unsigned& u, unsigned long v);
344 SC_API sc_signed operator % (const sc_unsigned& u, int v);
345 inline sc_unsigned operator % (const sc_unsigned& u, unsigned int v);
346
347 SC_API sc_signed operator % (int64 u, const sc_unsigned& v);
348 SC_API sc_unsigned operator % (uint64 u, const sc_unsigned& v);
349 SC_API sc_signed operator % (long u, const sc_unsigned& v);
350 SC_API sc_unsigned operator % (unsigned long u, const sc_unsigned& v);
351 SC_API sc_signed operator % (int u, const sc_unsigned& v);
352 inline sc_unsigned operator % (unsigned int u, const sc_unsigned& v);
353
354 SC_API sc_unsigned operator % (const sc_unsigned& u, const sc_uint_base& v);
355 SC_API sc_signed operator % (const sc_unsigned& u, const sc_int_base& v);
356 SC_API sc_unsigned operator % (const sc_uint_base& u, const sc_unsigned& v);
357 SC_API sc_signed operator % (const sc_int_base& u, const sc_unsigned& v);
358
359 // BITWISE OPERATORS:
360
361 // Bitwise AND operators:
362
363 SC_API sc_signed operator & (const sc_unsigned& u, const sc_signed& v);
364 SC_API sc_signed operator & (const sc_signed& u, const sc_unsigned& v);
365
366 SC_API sc_unsigned operator & (const sc_unsigned& u, const sc_unsigned& v);
367 SC_API sc_signed operator & (const sc_unsigned& u, int64 v);
368 SC_API sc_unsigned operator & (const sc_unsigned& u, uint64 v);
369 SC_API sc_signed operator & (const sc_unsigned& u, long v);
370 SC_API sc_unsigned operator & (const sc_unsigned& u, unsigned long v);
371 SC_API sc_signed operator & (const sc_unsigned& u, int v);
372 inline sc_unsigned operator & (const sc_unsigned& u, unsigned int v);
373
374 SC_API sc_signed operator & (int64 u, const sc_unsigned& v);
375 SC_API sc_unsigned operator & (uint64 u, const sc_unsigned& v);
376 SC_API sc_signed operator & (long u, const sc_unsigned& v);
377 SC_API sc_unsigned operator & (unsigned long u, const sc_unsigned& v);
378 SC_API sc_signed operator & (int u, const sc_unsigned& v);
379 inline sc_unsigned operator & (unsigned int u, const sc_unsigned& v);
380
381 SC_API sc_unsigned operator & (const sc_unsigned& u, const sc_uint_base& v);
382 SC_API sc_signed operator & (const sc_unsigned& u, const sc_int_base& v);
383 SC_API sc_unsigned operator & (const sc_uint_base& u, const sc_unsigned& v);
384 SC_API sc_signed operator & (const sc_int_base& u, const sc_unsigned& v);
385
386 // Bitwise OR operators:
387
388 SC_API sc_signed operator | (const sc_unsigned& u, const sc_signed& v);
389 SC_API sc_signed operator | (const sc_signed& u, const sc_unsigned& v);
390
391 SC_API sc_unsigned operator | (const sc_unsigned& u, const sc_unsigned& v);
392 SC_API sc_signed operator | (const sc_unsigned& u, int64 v);
393 SC_API sc_unsigned operator | (const sc_unsigned& u, uint64 v);
394 SC_API sc_signed operator | (const sc_unsigned& u, long v);
395 SC_API sc_unsigned operator | (const sc_unsigned& u, unsigned long v);
396 SC_API sc_signed operator | (const sc_unsigned& u, int v);
397 inline sc_unsigned operator | (const sc_unsigned& u, unsigned int v);
398
399 SC_API sc_signed operator | (int64 u, const sc_unsigned& v);
400 SC_API sc_unsigned operator | (uint64 u, const sc_unsigned& v);
401 SC_API sc_signed operator | (long u, const sc_unsigned& v);
402 SC_API sc_unsigned operator | (unsigned long u, const sc_unsigned& v);
403 SC_API sc_signed operator | (int u, const sc_unsigned& v);
404 inline sc_unsigned operator | (unsigned int u, const sc_unsigned& v);
405
406 SC_API sc_unsigned operator | (const sc_unsigned& u, const sc_uint_base& v);
407 SC_API sc_signed operator | (const sc_unsigned& u, const sc_int_base& v);
408 SC_API sc_unsigned operator | (const sc_uint_base& u, const sc_unsigned& v);
409 SC_API sc_signed operator | (const sc_int_base& u, const sc_unsigned& v);
410
411 // Bitwise XOR operators:
412
413 SC_API sc_signed operator ^ (const sc_unsigned& u, const sc_signed& v);
414 SC_API sc_signed operator ^ (const sc_signed& u, const sc_unsigned& v);
415
416 SC_API sc_unsigned operator ^ (const sc_unsigned& u, const sc_unsigned& v);
417 SC_API sc_signed operator ^ (const sc_unsigned& u, int64 v);
418 SC_API sc_unsigned operator ^ (const sc_unsigned& u, uint64 v);
419 SC_API sc_signed operator ^ (const sc_unsigned& u, long v);
420 SC_API sc_unsigned operator ^ (const sc_unsigned& u, unsigned long v);
421 SC_API sc_signed operator ^ (const sc_unsigned& u, int v);
422 inline sc_unsigned operator ^ (const sc_unsigned& u, unsigned int v);
423
424 SC_API sc_signed operator ^ (int64 u, const sc_unsigned& v);
425 SC_API sc_unsigned operator ^ (uint64 u, const sc_unsigned& v);
426 SC_API sc_signed operator ^ (long u, const sc_unsigned& v);
427 SC_API sc_unsigned operator ^ (unsigned long u, const sc_unsigned& v);
428 SC_API sc_signed operator ^ (int u, const sc_unsigned& v);
429 inline sc_unsigned operator ^ (unsigned int u, const sc_unsigned& v);
430
431 SC_API sc_unsigned operator ^ (const sc_unsigned& u, const sc_uint_base& v);
432 SC_API sc_signed operator ^ (const sc_unsigned& u, const sc_int_base& v);
433 SC_API sc_unsigned operator ^ (const sc_uint_base& u, const sc_unsigned& v);
434 SC_API sc_signed operator ^ (const sc_int_base& u, const sc_unsigned& v);
435
436 // SHIFT OPERATORS:
437
438 // LEFT SHIFT operators:
439
440 SC_API sc_unsigned operator << (const sc_unsigned& u, const sc_signed& v);
441 SC_API sc_signed operator << (const sc_signed& u, const sc_unsigned& v);
442
443 SC_API sc_unsigned operator << (const sc_unsigned& u, const sc_unsigned& v);
444 SC_API sc_unsigned operator << (const sc_unsigned& u, int64 v);
445 SC_API sc_unsigned operator << (const sc_unsigned& u, uint64 v);
446 SC_API sc_unsigned operator << (const sc_unsigned& u, long v);
447 SC_API sc_unsigned operator << (const sc_unsigned& u, unsigned long v);
448 inline sc_unsigned operator << (const sc_unsigned& u, int v);
449 inline sc_unsigned operator << (const sc_unsigned& u, unsigned int v);
450
451 SC_API sc_unsigned operator << (const sc_unsigned& u, const sc_uint_base& v);
452 SC_API sc_unsigned operator << (const sc_unsigned& u, const sc_int_base& v);
453
454 // RIGHT SHIFT operators:
455
456 SC_API sc_unsigned operator >> (const sc_unsigned& u, const sc_signed& v);
457 SC_API sc_signed operator >> (const sc_signed& u, const sc_unsigned& v);
458
459 SC_API sc_unsigned operator >> (const sc_unsigned& u, const sc_unsigned& v);
460 SC_API sc_unsigned operator >> (const sc_unsigned& u, int64 v);
461 SC_API sc_unsigned operator >> (const sc_unsigned& u, uint64 v);
462 SC_API sc_unsigned operator >> (const sc_unsigned& u, long v);
463 SC_API sc_unsigned operator >> (const sc_unsigned& u, unsigned long v);
464 inline sc_unsigned operator >> (const sc_unsigned& u, int v);
465 inline sc_unsigned operator >> (const sc_unsigned& u, unsigned int v);
466
467 SC_API sc_unsigned operator >> ( const sc_unsigned& , const sc_uint_base& );
468 SC_API sc_unsigned operator >> ( const sc_unsigned&, const sc_int_base& );
469
470 // Unary arithmetic operators
471 SC_API sc_unsigned operator + (const sc_unsigned& u);
472 SC_API sc_signed operator - (const sc_unsigned& u);
473
474 // LOGICAL OPERATORS:
475
476 // Logical EQUAL operators:
477
478 SC_API bool operator == (const sc_unsigned& u, const sc_signed& v);
479 SC_API bool operator == (const sc_signed& u, const sc_unsigned& v);
480
481 SC_API bool operator == (const sc_unsigned& u, const sc_unsigned& v);
482 SC_API bool operator == (const sc_unsigned& u, int64 v);
483 SC_API bool operator == (const sc_unsigned& u, uint64 v);
484 SC_API bool operator == (const sc_unsigned& u, long v);
485 SC_API bool operator == (const sc_unsigned& u, unsigned long v);
486 inline bool operator == (const sc_unsigned& u, int v);
487 inline bool operator == (const sc_unsigned& u, unsigned int v);
488
489 SC_API bool operator == (int64 u, const sc_unsigned& v);
490 SC_API bool operator == (uint64 u, const sc_unsigned& v);
491 SC_API bool operator == (long u, const sc_unsigned& v);
492 SC_API bool operator == (unsigned long u, const sc_unsigned& v);
493 inline bool operator == (int u, const sc_unsigned& v);
494 inline bool operator == (unsigned int u, const sc_unsigned& v) ;
495
496 SC_API bool operator == (const sc_unsigned& u, const sc_uint_base& v);
497 SC_API bool operator == (const sc_unsigned& u, const sc_int_base& v);
498 SC_API bool operator == (const sc_uint_base& u, const sc_unsigned& v);
499 SC_API bool operator == (const sc_int_base& u, const sc_unsigned& v);
500
501 // Logical NOT_EQUAL operators:
502
503 SC_API bool operator != (const sc_unsigned& u, const sc_signed& v);
504 SC_API bool operator != (const sc_signed& u, const sc_unsigned& v);
505
506 SC_API bool operator != (const sc_unsigned& u, const sc_unsigned& v);
507 SC_API bool operator != (const sc_unsigned& u, int64 v);
508 SC_API bool operator != (const sc_unsigned& u, uint64 v);
509 SC_API bool operator != (const sc_unsigned& u, long v);
510 SC_API bool operator != (const sc_unsigned& u, unsigned long v);
511 inline bool operator != (const sc_unsigned& u, int v);
512 inline bool operator != (const sc_unsigned& u, unsigned int v);
513
514 SC_API bool operator != (int64 u, const sc_unsigned& v);
515 SC_API bool operator != (uint64 u, const sc_unsigned& v);
516 SC_API bool operator != (long u, const sc_unsigned& v);
517 SC_API bool operator != (unsigned long u, const sc_unsigned& v);
518 inline bool operator != (int u, const sc_unsigned& v);
519 inline bool operator != (unsigned int u, const sc_unsigned& v);
520
521 SC_API bool operator != (const sc_unsigned& u, const sc_uint_base& v);
522 SC_API bool operator != (const sc_unsigned& u, const sc_int_base& v);
523 SC_API bool operator != (const sc_uint_base& u, const sc_unsigned& v);
524 SC_API bool operator != (const sc_int_base& u, const sc_unsigned& v);
525
526 // Logical LESS_THAN operators:
527
528 SC_API bool operator < (const sc_unsigned& u, const sc_signed& v);
529 SC_API bool operator < (const sc_signed& u, const sc_unsigned& v);
530
531 SC_API bool operator < (const sc_unsigned& u, const sc_unsigned& v);
532 SC_API bool operator < (const sc_unsigned& u, int64 v);
533 SC_API bool operator < (const sc_unsigned& u, uint64 v);
534 SC_API bool operator < (const sc_unsigned& u, long v);
535 SC_API bool operator < (const sc_unsigned& u, unsigned long v);
536 inline bool operator < (const sc_unsigned& u, int v);
537 inline bool operator < (const sc_unsigned& u, unsigned int v);
538
539 SC_API bool operator < (int64 u, const sc_unsigned& v);
540 SC_API bool operator < (uint64 u, const sc_unsigned& v);
541 SC_API bool operator < (long u, const sc_unsigned& v);
542 SC_API bool operator < (unsigned long u, const sc_unsigned& v);
543 inline bool operator < (int u, const sc_unsigned& v);
544 inline bool operator < (unsigned int u, const sc_unsigned& v);
545
546 SC_API bool operator < (const sc_unsigned& u, const sc_uint_base& v);
547 SC_API bool operator < (const sc_unsigned& u, const sc_int_base& v);
548 SC_API bool operator < (const sc_uint_base& u, const sc_unsigned& v);
549 SC_API bool operator < (const sc_int_base& u, const sc_unsigned& v);
550
551 // Logical LESS_THAN_AND_EQUAL operators:
552
553 SC_API bool operator <= (const sc_unsigned& u, const sc_signed& v);
554 SC_API bool operator <= (const sc_signed& u, const sc_unsigned& v);
555
556 SC_API bool operator <= (const sc_unsigned& u, const sc_unsigned& v);
557 SC_API bool operator <= (const sc_unsigned& u, int64 v);
558 SC_API bool operator <= (const sc_unsigned& u, uint64 v);
559 SC_API bool operator <= (const sc_unsigned& u, long v);
560 SC_API bool operator <= (const sc_unsigned& u, unsigned long v);
561 inline bool operator <= (const sc_unsigned& u, int v);
562 inline bool operator <= (const sc_unsigned& u, unsigned int v);
563
564 SC_API bool operator <= (int64 u, const sc_unsigned& v);
565 SC_API bool operator <= (uint64 u, const sc_unsigned& v);
566 SC_API bool operator <= (long u, const sc_unsigned& v);
567 SC_API bool operator <= (unsigned long u, const sc_unsigned& v);
568 inline bool operator <= (int u, const sc_unsigned& v);
569 inline bool operator <= (unsigned int u, const sc_unsigned& v);
570
571 SC_API bool operator <= (const sc_unsigned& u, const sc_uint_base& v);
572 SC_API bool operator <= (const sc_unsigned& u, const sc_int_base& v);
573 SC_API bool operator <= (const sc_uint_base& u, const sc_unsigned& v);
574 SC_API bool operator <= (const sc_int_base& u, const sc_unsigned& v);
575
576 // Logical GREATER_THAN operators:
577
578 SC_API bool operator > (const sc_unsigned& u, const sc_signed& v);
579 SC_API bool operator > (const sc_signed& u, const sc_unsigned& v);
580
581 SC_API bool operator > (const sc_unsigned& u, const sc_unsigned& v);
582 SC_API bool operator > (const sc_unsigned& u, int64 v);
583 SC_API bool operator > (const sc_unsigned& u, uint64 v);
584 SC_API bool operator > (const sc_unsigned& u, long v);
585 SC_API bool operator > (const sc_unsigned& u, unsigned long v);
586 inline bool operator > (const sc_unsigned& u, int v);
587 inline bool operator > (const sc_unsigned& u, unsigned int v);
588
589 SC_API bool operator > (int64 u, const sc_unsigned& v);
590 SC_API bool operator > (uint64 u, const sc_unsigned& v);
591 SC_API bool operator > (long u, const sc_unsigned& v);
592 SC_API bool operator > (unsigned long u, const sc_unsigned& v);
593 inline bool operator > (int u, const sc_unsigned& v);
594 inline bool operator > (unsigned int u, const sc_unsigned& v);
595
596 SC_API bool operator > (const sc_unsigned& u, const sc_uint_base& v);
597 SC_API bool operator > (const sc_unsigned& u, const sc_int_base& v);
598 SC_API bool operator > (const sc_uint_base& u, const sc_unsigned& v);
599 SC_API bool operator > (const sc_int_base& u, const sc_unsigned& v);
600
601 // Logical GREATER_THAN_AND_EQUAL operators:
602
603 SC_API bool operator >= (const sc_unsigned& u, const sc_signed& v);
604 SC_API bool operator >= (const sc_signed& u, const sc_unsigned& v);
605
606 SC_API bool operator >= (const sc_unsigned& u, const sc_unsigned& v);
607 SC_API bool operator >= (const sc_unsigned& u, int64 v);
608 SC_API bool operator >= (const sc_unsigned& u, uint64 v);
609 SC_API bool operator >= (const sc_unsigned& u, long v);
610 SC_API bool operator >= (const sc_unsigned& u, unsigned long v);
611 inline bool operator >= (const sc_unsigned& u, int v);
612 inline bool operator >= (const sc_unsigned& u, unsigned int v);
613
614 SC_API bool operator >= (int64 u, const sc_unsigned& v);
615 SC_API bool operator >= (uint64 u, const sc_unsigned& v);
616 SC_API bool operator >= (long u, const sc_unsigned& v);
617 SC_API bool operator >= (unsigned long u, const sc_unsigned& v);
618 inline bool operator >= (int u, const sc_unsigned& v);
619 inline bool operator >= (unsigned int u, const sc_unsigned& v);
620
621 SC_API bool operator >= (const sc_unsigned& u, const sc_uint_base& v);
622 SC_API bool operator >= (const sc_unsigned& u, const sc_int_base& v);
623 SC_API bool operator >= (const sc_uint_base& u, const sc_unsigned& v);
624 SC_API bool operator >= (const sc_int_base& u, const sc_unsigned& v);
625
626 // Bitwise NOT operator (unary).
627 SC_API sc_unsigned operator ~ (const sc_unsigned& u);
628
629 // ----------------------------------------------------------------------------
630 // CLASS : sc_unsigned_bitref_r
631 //
632 // Proxy class for sc_unsigned bit selection (r-value only).
633 // ----------------------------------------------------------------------------
634
635 class SC_API sc_unsigned_bitref_r : public sc_value_base
636 {
637 friend class sc_unsigned;
638
639 protected:
640
641 // construction and initialization:
642
sc_unsigned_bitref_r()643 sc_unsigned_bitref_r() : sc_value_base(), m_index(0), m_obj_p(0)
644 {}
645
initialize(const sc_unsigned * obj_p,int index_)646 void initialize( const sc_unsigned* obj_p, int index_ )
647 {
648 m_obj_p = const_cast<sc_unsigned*>( obj_p );
649 m_index = index_;
650 }
651
652 public:
653
654 // destructor
655
~sc_unsigned_bitref_r()656 virtual ~sc_unsigned_bitref_r()
657 {}
658
659 // copy constructor
660
sc_unsigned_bitref_r(const sc_unsigned_bitref_r & a)661 sc_unsigned_bitref_r( const sc_unsigned_bitref_r& a )
662 : sc_value_base(a), m_index( a.m_index ), m_obj_p( a.m_obj_p )
663 {}
664
665 // capacity
666
length()667 int length() const
668 { return 1; }
669
670
671 // implicit conversion to bool
672
673 operator uint64 () const;
674 bool operator ! () const;
675 bool operator ~ () const;
676
677
678 // explicit conversions
679
value()680 uint64 value() const
681 { return operator uint64(); }
682
to_bool()683 bool to_bool() const
684 { return operator uint64(); }
685
686
687 // concatenation support
688
concat_length(bool * xz_present_p)689 virtual int concat_length(bool* xz_present_p) const
690 { if ( xz_present_p ) *xz_present_p = false; return 1; }
concat_get_uint64()691 virtual uint64 concat_get_uint64() const
692 { return (uint64)operator uint64(); }
concat_get_ctrl(sc_digit * dst_p,int low_i)693 virtual bool concat_get_ctrl( sc_digit* dst_p, int low_i ) const
694 {
695 int bit_mask = 1 << (low_i % BITS_PER_DIGIT);
696 int word_i = low_i / BITS_PER_DIGIT;
697 dst_p[word_i] &= ~bit_mask;
698 return false;
699 }
concat_get_data(sc_digit * dst_p,int low_i)700 virtual bool concat_get_data( sc_digit* dst_p, int low_i ) const
701 {
702 int bit_mask = 1 << (low_i % BITS_PER_DIGIT);
703 bool result; // True if non-zero.
704 int word_i = low_i / BITS_PER_DIGIT;
705 if ( operator uint64() )
706 {
707 dst_p[word_i] |= bit_mask;
708 result = true;
709 }
710 else
711 {
712 dst_p[word_i] &= ~bit_mask;
713 result = false;
714 }
715 return result;
716 }
717
718 // other methods
719
720 void print( ::std::ostream& os = ::std::cout ) const
721 { os << to_bool(); }
722
723 protected:
724
725 int m_index;
726 sc_unsigned* m_obj_p;
727
728 private:
729
730 // disabled
731 const sc_unsigned_bitref_r& operator = ( const sc_unsigned_bitref_r& );
732 };
733
734
735
736 inline
737 ::std::ostream&
738 operator << ( ::std::ostream&, const sc_unsigned_bitref_r& );
739
740
741 // ----------------------------------------------------------------------------
742 // CLASS : sc_unsigned_bitref
743 //
744 // Proxy class for sc_unsigned bit selection (r-value and l-value).
745 // ----------------------------------------------------------------------------
746
747 class SC_API sc_unsigned_bitref
748 : public sc_unsigned_bitref_r
749 {
750 friend class sc_unsigned;
751 friend class sc_core::sc_vpool<sc_unsigned_bitref>;
752
753
754 protected: // construction
755
sc_unsigned_bitref()756 sc_unsigned_bitref() : sc_unsigned_bitref_r()
757 {}
758
759 public:
760
761 // copy constructor
762
sc_unsigned_bitref(const sc_unsigned_bitref & a)763 sc_unsigned_bitref( const sc_unsigned_bitref& a )
764 : sc_unsigned_bitref_r( a )
765 {}
766
767
768 // assignment operators
769
770 const sc_unsigned_bitref& operator = ( const sc_unsigned_bitref_r& );
771 const sc_unsigned_bitref& operator = ( const sc_unsigned_bitref& );
772 const sc_unsigned_bitref& operator = ( bool );
773
774 const sc_unsigned_bitref& operator &= ( bool );
775 const sc_unsigned_bitref& operator |= ( bool );
776 const sc_unsigned_bitref& operator ^= ( bool );
777
778 // concatenation methods
779
780 virtual void concat_set(int64 src, int low_i);
781 virtual void concat_set(const sc_signed& src, int low_i);
782 virtual void concat_set(const sc_unsigned& src, int low_i);
783 virtual void concat_set(uint64 src, int low_i);
784
785
786 // other methods
787
788 void scan( ::std::istream& is = ::std::cin );
789
790 protected:
791 static sc_core::sc_vpool<sc_unsigned_bitref> m_pool;
792 };
793
794
795
796 inline
797 ::std::istream&
798 operator >> ( ::std::istream&, sc_unsigned_bitref& );
799
800
801 // ----------------------------------------------------------------------------
802 // CLASS : sc_unsigned_subref_r
803 //
804 // Proxy class for sc_unsigned part selection (r-value only).
805 // ----------------------------------------------------------------------------
806
807 class SC_API sc_unsigned_subref_r : public sc_value_base
808 {
809 friend class sc_signed;
810 friend class sc_unsigned;
811 friend class sc_unsigned_signal;
812
813 protected:
814
815 // constructor
816
sc_unsigned_subref_r()817 sc_unsigned_subref_r() : sc_value_base(), m_left(0), m_obj_p(0), m_right(0)
818 {}
819
initialize(const sc_unsigned * obj_p,int left_,int right_)820 void initialize( const sc_unsigned* obj_p, int left_, int right_ )
821 {
822 m_obj_p = const_cast<sc_unsigned*>( obj_p );
823 m_left = left_;
824 m_right = right_;
825 }
826
827 public:
828
829 // destructor
830
~sc_unsigned_subref_r()831 virtual ~sc_unsigned_subref_r()
832 {}
833
834
835 // copy constructor
836
sc_unsigned_subref_r(const sc_unsigned_subref_r & a)837 sc_unsigned_subref_r( const sc_unsigned_subref_r& a )
838 : sc_value_base(a), m_left( a.m_left ), m_obj_p( a.m_obj_p ),
839 m_right( a.m_right )
840 {}
841
842
843 // capacity
844
length()845 int length() const
846 { return m_left >= m_right ? (m_left-m_right+1) : (m_right-m_left+1 ); }
847
848
849 // implicit conversion to sc_unsigned
850
851 operator sc_unsigned () const;
852
853
854 // explicit conversions
855
856 int to_int() const;
857 unsigned int to_uint() const;
858 long to_long() const;
859 unsigned long to_ulong() const;
860 int64 to_int64() const;
861 uint64 to_uint64() const;
862 double to_double() const;
863
864
865 // explicit conversion to character string
866
867 const std::string to_string( sc_numrep numrep = SC_DEC ) const;
868 const std::string to_string( sc_numrep numrep, bool w_prefix ) const;
869
870
871 // concatenation support
872
concat_length(bool * xz_present_p)873 virtual int concat_length(bool* xz_present_p) const
874 {
875 if ( xz_present_p ) *xz_present_p = false;
876 return m_left - m_right + 1;
877 }
878 virtual uint64 concat_get_uint64() const;
879 virtual bool concat_get_ctrl( sc_digit* dst_p, int low_i ) const;
880 virtual bool concat_get_data( sc_digit* dst_p, int low_i ) const;
881
882 // reduce methods
883
884 bool and_reduce() const;
885 bool nand_reduce() const;
886 bool or_reduce() const;
887 bool nor_reduce() const;
888 bool xor_reduce() const ;
889 bool xnor_reduce() const;
890
891 // other methods
892
893 void print( ::std::ostream& os = ::std::cout ) const
894 { os << to_string(sc_io_base(os,SC_DEC),sc_io_show_base(os)); }
895
896 protected:
897
898 int m_left; // Left-most bit in this part selection.
899 sc_unsigned* m_obj_p; // Target of this part selection.
900 int m_right; // Right-most bit in this part selection.
901
902 private:
903
904 // disabled
905 const sc_unsigned_subref_r& operator = ( const sc_unsigned_subref_r& );
906 };
907
908
909
910 inline
911 ::std::ostream&
912 operator << ( ::std::ostream&, const sc_unsigned_subref_r& );
913
914
915 // ----------------------------------------------------------------------------
916 // CLASS : sc_unsigned_subref
917 //
918 // Proxy class for sc_unsigned part selection (r-value and l-value).
919 // ----------------------------------------------------------------------------
920
921 class SC_API sc_unsigned_subref
922 : public sc_unsigned_subref_r
923 {
924 friend class sc_unsigned;
925 friend class sc_core::sc_vpool<sc_unsigned_subref>;
926
927
928 // constructor
929
930 protected:
sc_unsigned_subref()931 sc_unsigned_subref() : sc_unsigned_subref_r()
932 {}
933
934 public:
935
936 // copy constructor
937
sc_unsigned_subref(const sc_unsigned_subref & a)938 sc_unsigned_subref( const sc_unsigned_subref& a )
939 : sc_unsigned_subref_r( a )
940 {}
941
942 // assignment operators
943
944 const sc_unsigned_subref& operator = ( const sc_unsigned_subref_r& a );
945 const sc_unsigned_subref& operator = ( const sc_unsigned_subref& a );
946 const sc_unsigned_subref& operator = ( const sc_unsigned& a );
947
948 template<class T>
949 const sc_unsigned_subref& operator = ( const sc_generic_base<T>& a );
950 const sc_unsigned_subref& operator = ( const sc_signed_subref_r& a );
951 const sc_unsigned_subref& operator = ( const sc_signed& a );
952
953 const sc_unsigned_subref& operator = ( const char* a );
954 const sc_unsigned_subref& operator = ( unsigned long a );
955 const sc_unsigned_subref& operator = ( long a );
956
957 const sc_unsigned_subref& operator = ( unsigned int a )
958 { return operator = ( (unsigned long) a ); }
959
960 const sc_unsigned_subref& operator = ( int a )
961 { return operator = ( (long) a ); }
962
963 const sc_unsigned_subref& operator = ( uint64 a );
964 const sc_unsigned_subref& operator = ( int64 a );
965 const sc_unsigned_subref& operator = ( double a );
966 const sc_unsigned_subref& operator = ( const sc_int_base& a );
967 const sc_unsigned_subref& operator = ( const sc_uint_base& a );
968
969 // concatenation methods
970
971 virtual void concat_set(int64 src, int low_i);
972 virtual void concat_set(const sc_signed& src, int low_i);
973 virtual void concat_set(const sc_unsigned& src, int low_i);
974 virtual void concat_set(uint64 src, int low_i);
975
976 // other methods
977
978 void scan( ::std::istream& is = ::std::cin );
979
980 protected:
981 static sc_core::sc_vpool<sc_unsigned_subref> m_pool;
982 };
983
984
985
986 inline
987 ::std::istream&
988 operator >> ( ::std::istream&, sc_unsigned_subref& );
989
990
991 // ----------------------------------------------------------------------------
992 // CLASS : sc_unsigned
993 //
994 // Arbitrary precision unsigned number.
995 // ----------------------------------------------------------------------------
996
997 class SC_API sc_unsigned : public sc_value_base
998 {
999 friend class sc_concatref;
1000 friend class sc_unsigned_bitref_r;
1001 friend class sc_unsigned_bitref;
1002 friend class sc_unsigned_subref_r;
1003 friend class sc_unsigned_subref;
1004 friend class sc_signed;
1005 friend class sc_signed_subref;
1006 friend class sc_signed_subref_r;
1007
1008 // Needed for types using sc_unsigned.
1009 typedef bool elemtype;
1010
1011 void invalid_init( const char* type_name, int nb ) const;
1012
1013 public:
1014
1015 // constructors
1016
1017 explicit sc_unsigned( int nb = sc_length_param().len() );
1018 sc_unsigned( const sc_unsigned& v );
1019 sc_unsigned( const sc_signed& v );
1020 template<class T>
1021 explicit sc_unsigned( const sc_generic_base<T>& v );
1022 explicit sc_unsigned( const sc_bv_base& v );
1023 explicit sc_unsigned( const sc_lv_base& v );
1024 explicit sc_unsigned( const sc_int_subref_r& v );
1025 explicit sc_unsigned( const sc_uint_subref_r& v );
1026 explicit sc_unsigned( const sc_signed_subref_r& v );
1027 explicit sc_unsigned( const sc_unsigned_subref_r& v );
1028
1029
1030
1031 // assignment operators
1032
1033 const sc_unsigned& operator = (const sc_unsigned& v);
1034 const sc_unsigned& operator = (const sc_unsigned_subref_r& a );
1035
1036 template<class T>
1037 const sc_unsigned& operator = ( const sc_generic_base<T>& a )
1038 { a->to_sc_unsigned(*this); return *this; }
1039
1040 const sc_unsigned& operator = (const sc_signed& v);
1041 const sc_unsigned& operator = (const sc_signed_subref_r& a );
1042
1043 const sc_unsigned& operator = ( const char* v);
1044 const sc_unsigned& operator = ( int64 v);
1045 const sc_unsigned& operator = ( uint64 v);
1046 const sc_unsigned& operator = ( long v);
1047 const sc_unsigned& operator = ( unsigned long v);
1048
1049 const sc_unsigned& operator = ( int v)
1050 { return operator=((long) v); }
1051
1052 const sc_unsigned& operator = ( unsigned int v)
1053 { return operator=((unsigned long) v); }
1054
1055 const sc_unsigned& operator = ( double v);
1056 const sc_unsigned& operator = ( const sc_int_base& v);
1057 const sc_unsigned& operator = ( const sc_uint_base& v);
1058
1059 const sc_unsigned& operator = ( const sc_bv_base& );
1060 const sc_unsigned& operator = ( const sc_lv_base& );
1061
1062 #ifdef SC_INCLUDE_FX
1063 const sc_unsigned& operator = ( const sc_fxval& );
1064 const sc_unsigned& operator = ( const sc_fxval_fast& );
1065 const sc_unsigned& operator = ( const sc_fxnum& );
1066 const sc_unsigned& operator = ( const sc_fxnum_fast& );
1067 #endif
1068
1069
1070 // destructor
1071
~sc_unsigned()1072 virtual ~sc_unsigned()
1073 {
1074 # ifndef SC_MAX_NBITS
1075 delete [] digit;
1076 # endif
1077 }
1078
1079 // Concatenation support:
1080
get_raw()1081 sc_digit* get_raw() const { return digit; }
concat_length(bool * xz_present_p)1082 virtual int concat_length(bool* xz_present_p) const
1083 { if ( xz_present_p ) *xz_present_p = false; return nbits-1; }
1084 virtual bool concat_get_ctrl( sc_digit* dst_p, int low_i ) const;
1085 virtual bool concat_get_data( sc_digit* dst_p, int low_i ) const;
1086 virtual uint64 concat_get_uint64() const;
1087 virtual void concat_set(int64 src, int low_i);
1088 virtual void concat_set(const sc_signed& src, int low_i);
1089 virtual void concat_set(const sc_unsigned& src, int low_i);
1090 virtual void concat_set(uint64 src, int low_i);
1091
1092 // Increment operators.
1093
1094 sc_unsigned& operator ++ ();
1095 const sc_unsigned operator ++ (int);
1096
1097 // Decrement operators.
1098
1099 sc_unsigned& operator -- ();
1100 const sc_unsigned operator -- (int);
1101
1102
1103 // bit selection
1104
check_index(int i)1105 inline void check_index( int i ) const
1106 { if ( (i < 0) || (i >= nbits-1) ) invalid_index(i); }
1107
1108 void invalid_index( int i ) const;
1109
1110 sc_unsigned_bitref& operator [] ( int i )
1111 {
1112 check_index(i);
1113 sc_unsigned_bitref* result_p =
1114 sc_unsigned_bitref::m_pool.allocate();
1115 result_p->initialize( this, i );
1116 return *result_p;
1117 }
1118
1119 const sc_unsigned_bitref_r& operator [] ( int i ) const
1120 {
1121 check_index(i);
1122 sc_unsigned_bitref* result_p =
1123 sc_unsigned_bitref::m_pool.allocate();
1124 result_p->initialize( this, i );
1125 return *result_p;
1126 }
1127
bit(int i)1128 sc_unsigned_bitref& bit( int i )
1129 {
1130 check_index(i);
1131 sc_unsigned_bitref* result_p =
1132 sc_unsigned_bitref::m_pool.allocate();
1133 result_p->initialize( this, i );
1134 return *result_p;
1135 }
1136
bit(int i)1137 const sc_unsigned_bitref_r& bit( int i ) const
1138 {
1139 check_index(i);
1140 sc_unsigned_bitref* result_p =
1141 sc_unsigned_bitref::m_pool.allocate();
1142 result_p->initialize( this, i );
1143 return *result_p;
1144 }
1145
1146
1147 // part selection
1148
1149 // Subref operators. Help access the range of bits from the ith to
1150 // jth. These indices have arbitrary precedence with respect to each
1151 // other, i.e., we can have i <= j or i > j. Note the equivalence
1152 // between range(i, j) and operator (i, j). Also note that
1153 // operator (i, i) returns an unsigned number that corresponds to the
1154 // bit operator [i], so these two forms are not the same.
1155
check_range(int l,int r)1156 inline void check_range( int l, int r ) const
1157 {
1158 if ( l < r )
1159 {
1160 if ( (l < 0) || (r >= nbits-1) ) invalid_range(l,r);
1161 }
1162 else
1163 {
1164 if ( (r < 0) || (l >= nbits-1) ) invalid_range(l,r);
1165 }
1166 }
1167
1168 void invalid_range( int l, int r ) const;
1169
range(int i,int j)1170 sc_unsigned_subref& range( int i, int j )
1171 {
1172 check_range(i,j);
1173 sc_unsigned_subref* result_p =
1174 sc_unsigned_subref::m_pool.allocate();
1175 result_p->initialize( this, i, j );
1176 return *result_p;
1177 }
1178
range(int i,int j)1179 const sc_unsigned_subref_r& range( int i, int j ) const
1180 {
1181 check_range(i,j);
1182 sc_unsigned_subref* result_p =
1183 sc_unsigned_subref::m_pool.allocate();
1184 result_p->initialize( this, i, j );
1185 return *result_p;
1186 }
1187
operator()1188 sc_unsigned_subref& operator () ( int i, int j )
1189 {
1190 check_range(i,j);
1191 sc_unsigned_subref* result_p =
1192 sc_unsigned_subref::m_pool.allocate();
1193 result_p->initialize( this, i, j );
1194 return *result_p;
1195 }
1196
operator()1197 const sc_unsigned_subref_r& operator () ( int i, int j ) const
1198 {
1199 check_range(i,j);
1200 sc_unsigned_subref* result_p =
1201 sc_unsigned_subref::m_pool.allocate();
1202 result_p->initialize( this, i, j );
1203 return *result_p;
1204 }
1205
1206 // explicit conversions
1207
1208 int to_int() const;
1209 unsigned int to_uint() const;
1210 long to_long() const;
1211 unsigned long to_ulong() const;
1212 int64 to_int64() const;
1213 uint64 to_uint64() const;
1214 double to_double() const;
1215
1216 #ifdef SC_DT_DEPRECATED
to_signed()1217 int to_signed() const
1218 { return to_int(); }
1219
to_unsigned()1220 unsigned int to_unsigned() const
1221 { return to_uint(); }
1222 #endif
1223
1224 // explicit conversion to character string
1225
1226 const std::string to_string( sc_numrep numrep = SC_DEC ) const;
1227 const std::string to_string( sc_numrep numrep, bool w_prefix ) const;
1228
1229 // Print functions. dump prints the internals of the class.
1230
1231 void print( ::std::ostream& os = ::std::cout ) const
1232 { os << to_string(sc_io_base(os,SC_DEC),sc_io_show_base(os)); }
1233
1234 void scan( ::std::istream& is = ::std::cin );
1235
1236 void dump( ::std::ostream& os = ::std::cout ) const;
1237
1238
1239 // Functions to find various properties.
length()1240 int length() const { return nbits - 1; } // Bit width.
1241 bool iszero() const; // Is the number zero?
sign()1242 bool sign() const { return 0; } // Sign.
1243
1244 // reduce methods
1245
1246 bool and_reduce() const;
1247
nand_reduce()1248 bool nand_reduce() const
1249 { return ( ! and_reduce() ); }
1250
1251 bool or_reduce() const;
1252
nor_reduce()1253 bool nor_reduce() const
1254 { return ( ! or_reduce() ); }
1255
1256 bool xor_reduce() const;
1257
xnor_reduce()1258 bool xnor_reduce() const
1259 { return ( ! xor_reduce() ); }
1260
1261
1262 // Functions to access individual bits.
1263 bool test(int i) const; // Is the ith bit 0 or 1?
1264 void set(int i); // Set the ith bit to 1.
1265 void clear(int i); // Set the ith bit to 0.
set(int i,bool v)1266 void set(int i, bool v) // Set the ith bit to v.
1267 { if (v) set(i); else clear(i); }
invert(int i)1268 void invert(int i) // Negate the ith bit.
1269 { if (test(i)) clear(i); else set(i); }
1270
1271 // Make the number equal to its mirror image.
1272 void reverse();
1273
1274 // Get/set a packed bit representation of the number.
1275 void get_packed_rep(sc_digit *buf) const;
1276 void set_packed_rep(sc_digit *buf);
1277
1278 /*
1279 The comparison of the old and new semantics are as follows:
1280
1281 Let s = sc_signed,
1282 u = sc_unsigned,
1283 un = { uint64, unsigned long, unsigned int },
1284 sn = { int64, long, int, char* }, and
1285 OP = { +, -, *, /, % }.
1286
1287 Old semantics: New semantics:
1288 u OP u -> u u OP u -> u
1289 s OP u -> u s OP u -> s
1290 u OP s -> u u OP s -> s
1291 s OP s -> s s OP s -> s
1292
1293 u OP un = un OP u -> u u OP un = un OP u -> u
1294 u OP sn = sn OP u -> u u OP sn = sn OP u -> s
1295
1296 s OP un = un OP s -> s s OP un = un OP s -> s
1297 s OP sn = sn OP s -> s s OP sn = sn OP s -> s
1298
1299 In the new semantics, the result is u if both operands are u; the
1300 result is s otherwise. The only exception is subtraction. The result
1301 of a subtraction is always s.
1302
1303 The old semantics is like C/C++ semantics on integer types; the
1304 new semantics is due to the VSIA C/C++ data types standard.
1305 */
1306
1307 // ARITHMETIC OPERATORS:
1308
1309 // ADDition operators:
1310
1311 friend SC_API sc_signed operator + (const sc_unsigned& u, const sc_signed& v);
1312 friend SC_API sc_signed operator + (const sc_signed& u, const sc_unsigned& v);
1313
1314 friend SC_API sc_unsigned operator + (const sc_unsigned& u, const sc_unsigned& v);
1315 friend SC_API sc_signed operator + (const sc_unsigned& u, int64 v);
1316 friend SC_API sc_unsigned operator + (const sc_unsigned& u, uint64 v);
1317 friend SC_API sc_signed operator + (const sc_unsigned& u, long v);
1318 friend SC_API sc_unsigned operator + (const sc_unsigned& u, unsigned long v);
1319 friend SC_API sc_signed operator + (const sc_unsigned& u, int v);
1320 friend sc_unsigned operator + (const sc_unsigned& u, unsigned int v)
1321 { return operator+(u, (unsigned long) v); }
1322
1323 friend SC_API sc_signed operator + (int64 u, const sc_unsigned& v);
1324 friend SC_API sc_unsigned operator + (uint64 u, const sc_unsigned& v);
1325 friend SC_API sc_signed operator + (long u, const sc_unsigned& v);
1326 friend SC_API sc_unsigned operator + (unsigned long u, const sc_unsigned& v);
1327 friend SC_API sc_signed operator + (int u, const sc_unsigned& v);
1328 friend sc_unsigned operator + (unsigned int u, const sc_unsigned& v)
1329 { return operator+((unsigned long) u, v); }
1330
1331 const sc_unsigned& operator += (const sc_signed& v);
1332 const sc_unsigned& operator += (const sc_unsigned& v);
1333 const sc_unsigned& operator += (int64 v);
1334 const sc_unsigned& operator += (uint64 v);
1335 const sc_unsigned& operator += (long v);
1336 const sc_unsigned& operator += (unsigned long v);
1337 const sc_unsigned& operator += (int v)
1338 { return operator+=((long) v); }
1339 const sc_unsigned& operator += (unsigned int v)
1340 { return operator+=((unsigned long) v); }
1341
1342 friend SC_API sc_unsigned operator + (const sc_unsigned& u, const sc_uint_base& v);
1343 friend SC_API sc_signed operator + (const sc_unsigned& u, const sc_int_base& v);
1344 friend SC_API sc_unsigned operator + (const sc_uint_base& u, const sc_unsigned& v);
1345 friend SC_API sc_signed operator + (const sc_int_base& u, const sc_unsigned& v);
1346 const sc_unsigned& operator += (const sc_int_base& v);
1347 const sc_unsigned& operator += (const sc_uint_base& v);
1348
1349 // SUBtraction operators:
1350
1351 friend SC_API sc_signed operator - (const sc_unsigned& u, const sc_signed& v);
1352 friend SC_API sc_signed operator - (const sc_signed& u, const sc_unsigned& v);
1353
1354 friend SC_API sc_signed operator - (const sc_unsigned& u, const sc_unsigned& v);
1355 friend SC_API sc_signed operator - (const sc_unsigned& u, int64 v);
1356 friend SC_API sc_signed operator - (const sc_unsigned& u, uint64 v);
1357 friend SC_API sc_signed operator - (const sc_unsigned& u, long v);
1358 friend SC_API sc_signed operator - (const sc_unsigned& u, unsigned long v);
1359 friend SC_API sc_signed operator - (const sc_unsigned& u, int v);
1360 friend SC_API sc_signed operator - (const sc_unsigned& u, unsigned int v);
1361
1362 friend SC_API sc_signed operator - (int64 u, const sc_unsigned& v);
1363 friend SC_API sc_signed operator - (uint64 u, const sc_unsigned& v);
1364 friend SC_API sc_signed operator - (long u, const sc_unsigned& v);
1365 friend SC_API sc_signed operator - (unsigned long u, const sc_unsigned& v);
1366 friend SC_API sc_signed operator - (int u, const sc_unsigned& v);
1367 friend SC_API sc_signed operator - (unsigned int u, const sc_unsigned& v);
1368
1369 const sc_unsigned& operator -= (const sc_signed& v);
1370 const sc_unsigned& operator -= (const sc_unsigned& v);
1371 const sc_unsigned& operator -= (int64 v);
1372 const sc_unsigned& operator -= (uint64 v);
1373 const sc_unsigned& operator -= (long v);
1374 const sc_unsigned& operator -= (unsigned long v);
1375 const sc_unsigned& operator -= (int v)
1376 { return operator-=((long) v); }
1377 const sc_unsigned& operator -= (unsigned int v)
1378 { return operator-=((unsigned long) v); }
1379
1380 friend SC_API sc_signed operator - (const sc_unsigned& u, const sc_uint_base& v);
1381 friend SC_API sc_signed operator - (const sc_unsigned& u, const sc_int_base& v);
1382 friend SC_API sc_signed operator - (const sc_uint_base& u, const sc_unsigned& v);
1383 friend SC_API sc_signed operator - (const sc_int_base& u, const sc_unsigned& v);
1384 const sc_unsigned& operator -= (const sc_int_base& v);
1385 const sc_unsigned& operator -= (const sc_uint_base& v);
1386
1387 // MULtiplication operators:
1388
1389 friend SC_API sc_signed operator * (const sc_unsigned& u, const sc_signed& v);
1390 friend SC_API sc_signed operator * (const sc_signed& u, const sc_unsigned& v);
1391
1392 friend SC_API sc_unsigned operator * (const sc_unsigned& u, const sc_unsigned& v);
1393 friend SC_API sc_signed operator * (const sc_unsigned& u, int64 v);
1394 friend SC_API sc_unsigned operator * (const sc_unsigned& u, uint64 v);
1395 friend SC_API sc_signed operator * (const sc_unsigned& u, long v);
1396 friend SC_API sc_unsigned operator * (const sc_unsigned& u, unsigned long v);
1397 friend SC_API sc_signed operator * (const sc_unsigned& u, int v);
1398 friend sc_unsigned operator * (const sc_unsigned& u, unsigned int v)
1399 { return operator*(u, (unsigned long) v); }
1400
1401 friend SC_API sc_signed operator * (int64 u, const sc_unsigned& v);
1402 friend SC_API sc_unsigned operator * (uint64 u, const sc_unsigned& v);
1403 friend SC_API sc_signed operator * (long u, const sc_unsigned& v);
1404 friend SC_API sc_unsigned operator * (unsigned long u, const sc_unsigned& v);
1405 friend SC_API sc_signed operator * (int u, const sc_unsigned& v);
1406 friend sc_unsigned operator * (unsigned int u, const sc_unsigned& v)
1407 { return operator*((unsigned long) u, v); }
1408
1409 const sc_unsigned& operator *= (const sc_signed& v);
1410 const sc_unsigned& operator *= (const sc_unsigned& v);
1411 const sc_unsigned& operator *= (int64 v);
1412 const sc_unsigned& operator *= (uint64 v);
1413 const sc_unsigned& operator *= (long v);
1414 const sc_unsigned& operator *= (unsigned long v);
1415 const sc_unsigned& operator *= (int v)
1416 { return operator*=((long) v); }
1417 const sc_unsigned& operator *= (unsigned int v)
1418 { return operator*=((unsigned long) v); }
1419
1420 friend SC_API sc_unsigned operator * (const sc_unsigned& u, const sc_uint_base& v);
1421 friend SC_API sc_signed operator * (const sc_unsigned& u, const sc_int_base& v);
1422 friend SC_API sc_unsigned operator * (const sc_uint_base& u, const sc_unsigned& v);
1423 friend SC_API sc_signed operator * (const sc_int_base& u, const sc_unsigned& v);
1424 const sc_unsigned& operator *= (const sc_int_base& v);
1425 const sc_unsigned& operator *= (const sc_uint_base& v);
1426
1427 // DIVision operators:
1428
1429 friend SC_API sc_signed operator / (const sc_unsigned& u, const sc_signed& v);
1430 friend SC_API sc_signed operator / (const sc_signed& u, const sc_unsigned& v);
1431
1432 friend SC_API sc_unsigned operator / (const sc_unsigned& u, const sc_unsigned& v);
1433 friend SC_API sc_signed operator / (const sc_unsigned& u, int64 v);
1434 friend SC_API sc_unsigned operator / (const sc_unsigned& u, uint64 v);
1435 friend SC_API sc_signed operator / (const sc_unsigned& u, long v);
1436 friend SC_API sc_unsigned operator / (const sc_unsigned& u, unsigned long v);
1437 friend SC_API sc_signed operator / (const sc_unsigned& u, int v);
1438 friend sc_unsigned operator / (const sc_unsigned& u, unsigned int v)
1439 { return operator/(u, (unsigned long) v); }
1440
1441 friend SC_API sc_signed operator / (int64 u, const sc_unsigned& v);
1442 friend SC_API sc_unsigned operator / (uint64 u, const sc_unsigned& v);
1443 friend SC_API sc_signed operator / (long u, const sc_unsigned& v);
1444 friend SC_API sc_unsigned operator / (unsigned long u, const sc_unsigned& v);
1445 friend SC_API sc_signed operator / (int u, const sc_unsigned& v);
1446 friend sc_unsigned operator / (unsigned int u, const sc_unsigned& v)
1447 { return operator/((unsigned long) u, v); }
1448
1449 const sc_unsigned& operator /= (const sc_signed& v);
1450 const sc_unsigned& operator /= (const sc_unsigned& v);
1451 const sc_unsigned& operator /= (int64 v);
1452 const sc_unsigned& operator /= (uint64 v);
1453 const sc_unsigned& operator /= (long v);
1454 const sc_unsigned& operator /= (unsigned long v);
1455 const sc_unsigned& operator /= (int v)
1456 { return operator/=((long) v); }
1457 const sc_unsigned& operator /= (unsigned int v)
1458 { return operator/=((unsigned long) v); }
1459
1460 friend SC_API sc_unsigned operator / (const sc_unsigned& u, const sc_uint_base& v);
1461 friend SC_API sc_signed operator / (const sc_unsigned& u, const sc_int_base& v);
1462 friend SC_API sc_unsigned operator / (const sc_uint_base& u, const sc_unsigned& v);
1463 friend SC_API sc_signed operator / (const sc_int_base& u, const sc_unsigned& v);
1464 const sc_unsigned& operator /= (const sc_int_base& v);
1465 const sc_unsigned& operator /= (const sc_uint_base& v);
1466
1467 // MODulo operators:
1468
1469 friend SC_API sc_signed operator % (const sc_unsigned& u, const sc_signed& v);
1470 friend SC_API sc_signed operator % (const sc_signed& u, const sc_unsigned& v);
1471
1472 friend SC_API sc_unsigned operator % (const sc_unsigned& u, const sc_unsigned& v);
1473 friend SC_API sc_signed operator % (const sc_unsigned& u, int64 v);
1474 friend SC_API sc_unsigned operator % (const sc_unsigned& u, uint64 v);
1475 friend SC_API sc_signed operator % (const sc_unsigned& u, long v);
1476 friend SC_API sc_unsigned operator % (const sc_unsigned& u, unsigned long v);
1477 friend SC_API sc_signed operator % (const sc_unsigned& u, int v);
1478 friend sc_unsigned operator % (const sc_unsigned& u, unsigned int v)
1479 { return operator%(u, (unsigned long) v); }
1480
1481 friend SC_API sc_signed operator % (int64 u, const sc_unsigned& v);
1482 friend SC_API sc_unsigned operator % (uint64 u, const sc_unsigned& v);
1483 friend SC_API sc_signed operator % (long u, const sc_unsigned& v);
1484 friend SC_API sc_unsigned operator % (unsigned long u, const sc_unsigned& v);
1485 friend SC_API sc_signed operator % (int u, const sc_unsigned& v);
1486 friend sc_unsigned operator % (unsigned int u, const sc_unsigned& v)
1487 { return operator%((unsigned long) u, v); }
1488
1489 const sc_unsigned& operator %= (const sc_signed& v);
1490 const sc_unsigned& operator %= (const sc_unsigned& v);
1491 const sc_unsigned& operator %= (int64 v);
1492 const sc_unsigned& operator %= (uint64 v);
1493 const sc_unsigned& operator %= (long v);
1494 const sc_unsigned& operator %= (unsigned long v);
1495 const sc_unsigned& operator %= (int v)
1496 { return operator%=((long) v); }
1497 const sc_unsigned& operator %= (unsigned int v)
1498 { return operator%=((unsigned long) v); }
1499
1500 friend SC_API sc_unsigned operator % (const sc_unsigned& u, const sc_uint_base& v);
1501 friend SC_API sc_signed operator % (const sc_unsigned& u, const sc_int_base& v);
1502 friend SC_API sc_unsigned operator % (const sc_uint_base& u, const sc_unsigned& v);
1503 friend SC_API sc_signed operator % (const sc_int_base& u, const sc_unsigned& v);
1504 const sc_unsigned& operator %= (const sc_int_base& v);
1505 const sc_unsigned& operator %= (const sc_uint_base& v);
1506
1507 // BITWISE OPERATORS:
1508
1509 // Bitwise AND operators:
1510
1511 friend SC_API sc_signed operator & (const sc_unsigned& u, const sc_signed& v);
1512 friend SC_API sc_signed operator & (const sc_signed& u, const sc_unsigned& v);
1513
1514 friend SC_API sc_unsigned operator & (const sc_unsigned& u, const sc_unsigned& v);
1515 friend SC_API sc_signed operator & (const sc_unsigned& u, int64 v);
1516 friend SC_API sc_unsigned operator & (const sc_unsigned& u, uint64 v);
1517 friend SC_API sc_signed operator & (const sc_unsigned& u, long v);
1518 friend SC_API sc_unsigned operator & (const sc_unsigned& u, unsigned long v);
1519 friend SC_API sc_signed operator & (const sc_unsigned& u, int v);
1520 friend sc_unsigned operator & (const sc_unsigned& u, unsigned int v)
1521 { return operator&(u, (unsigned long) v); }
1522
1523 friend SC_API sc_signed operator & (int64 u, const sc_unsigned& v);
1524 friend SC_API sc_unsigned operator & (uint64 u, const sc_unsigned& v);
1525 friend SC_API sc_signed operator & (long u, const sc_unsigned& v);
1526 friend SC_API sc_unsigned operator & (unsigned long u, const sc_unsigned& v);
1527 friend SC_API sc_signed operator & (int u, const sc_unsigned& v);
1528 friend sc_unsigned operator & (unsigned int u, const sc_unsigned& v)
1529 { return operator&((unsigned long) u, v); }
1530
1531 const sc_unsigned& operator &= (const sc_signed& v);
1532 const sc_unsigned& operator &= (const sc_unsigned& v);
1533 const sc_unsigned& operator &= (int64 v);
1534 const sc_unsigned& operator &= (uint64 v);
1535 const sc_unsigned& operator &= (long v);
1536 const sc_unsigned& operator &= (unsigned long v);
1537 const sc_unsigned& operator &= (int v)
1538 { return operator&=((long) v); }
1539 const sc_unsigned& operator &= (unsigned int v)
1540 { return operator&=((unsigned long) v); }
1541
1542 friend SC_API sc_unsigned operator & (const sc_unsigned& u, const sc_uint_base& v);
1543 friend SC_API sc_signed operator & (const sc_unsigned& u, const sc_int_base& v);
1544 friend SC_API sc_unsigned operator & (const sc_uint_base& u, const sc_unsigned& v);
1545 friend SC_API sc_signed operator & (const sc_int_base& u, const sc_unsigned& v);
1546 const sc_unsigned& operator &= (const sc_int_base& v);
1547 const sc_unsigned& operator &= (const sc_uint_base& v);
1548
1549 // Bitwise OR operators:
1550
1551 friend SC_API sc_signed operator | (const sc_unsigned& u, const sc_signed& v);
1552 friend SC_API sc_signed operator | (const sc_signed& u, const sc_unsigned& v);
1553
1554 friend SC_API sc_unsigned operator | (const sc_unsigned& u, const sc_unsigned& v);
1555 friend SC_API sc_signed operator | (const sc_unsigned& u, int64 v);
1556 friend SC_API sc_unsigned operator | (const sc_unsigned& u, uint64 v);
1557 friend SC_API sc_signed operator | (const sc_unsigned& u, long v);
1558 friend SC_API sc_unsigned operator | (const sc_unsigned& u, unsigned long v);
1559 friend SC_API sc_signed operator | (const sc_unsigned& u, int v);
1560 friend sc_unsigned operator | (const sc_unsigned& u, unsigned int v)
1561 { return operator|(u, (unsigned long) v); }
1562
1563 friend SC_API sc_signed operator | (int64 u, const sc_unsigned& v);
1564 friend SC_API sc_unsigned operator | (uint64 u, const sc_unsigned& v);
1565 friend SC_API sc_signed operator | (long u, const sc_unsigned& v);
1566 friend SC_API sc_unsigned operator | (unsigned long u, const sc_unsigned& v);
1567 friend SC_API sc_signed operator | (int u, const sc_unsigned& v);
1568 friend sc_unsigned operator | (unsigned int u, const sc_unsigned& v)
1569 { return operator|((unsigned long) u, v); }
1570
1571 const sc_unsigned& operator |= (const sc_signed& v);
1572 const sc_unsigned& operator |= (const sc_unsigned& v);
1573 const sc_unsigned& operator |= (int64 v);
1574 const sc_unsigned& operator |= (uint64 v);
1575 const sc_unsigned& operator |= (long v);
1576 const sc_unsigned& operator |= (unsigned long v);
1577 const sc_unsigned& operator |= (int v)
1578 { return operator|=((long) v); }
1579 const sc_unsigned& operator |= (unsigned int v)
1580 { return operator|=((unsigned long) v); }
1581
1582 friend SC_API sc_unsigned operator | (const sc_unsigned& u, const sc_uint_base& v);
1583 friend SC_API sc_signed operator | (const sc_unsigned& u, const sc_int_base& v);
1584 friend SC_API sc_unsigned operator | (const sc_uint_base& u, const sc_unsigned& v);
1585 friend SC_API sc_signed operator | (const sc_int_base& u, const sc_unsigned& v);
1586 const sc_unsigned& operator |= (const sc_int_base& v);
1587 const sc_unsigned& operator |= (const sc_uint_base& v);
1588
1589 // Bitwise XOR operators:
1590
1591 friend SC_API sc_signed operator ^ (const sc_unsigned& u, const sc_signed& v);
1592 friend SC_API sc_signed operator ^ (const sc_signed& u, const sc_unsigned& v);
1593
1594 friend SC_API sc_unsigned operator ^ (const sc_unsigned& u, const sc_unsigned& v);
1595 friend SC_API sc_signed operator ^ (const sc_unsigned& u, int64 v);
1596 friend SC_API sc_unsigned operator ^ (const sc_unsigned& u, uint64 v);
1597 friend SC_API sc_signed operator ^ (const sc_unsigned& u, long v);
1598 friend SC_API sc_unsigned operator ^ (const sc_unsigned& u, unsigned long v);
1599 friend SC_API sc_signed operator ^ (const sc_unsigned& u, int v);
1600 friend sc_unsigned operator ^ (const sc_unsigned& u, unsigned int v)
1601 { return operator^(u, (unsigned long) v); }
1602
1603 friend SC_API sc_signed operator ^ (int64 u, const sc_unsigned& v);
1604 friend SC_API sc_unsigned operator ^ (uint64 u, const sc_unsigned& v);
1605 friend SC_API sc_signed operator ^ (long u, const sc_unsigned& v);
1606 friend SC_API sc_unsigned operator ^ (unsigned long u, const sc_unsigned& v);
1607 friend SC_API sc_signed operator ^ (int u, const sc_unsigned& v);
1608 friend sc_unsigned operator ^ (unsigned int u, const sc_unsigned& v)
1609 { return operator^((unsigned long) u, v); }
1610
1611 const sc_unsigned& operator ^= (const sc_signed& v);
1612 const sc_unsigned& operator ^= (const sc_unsigned& v);
1613 const sc_unsigned& operator ^= (int64 v);
1614 const sc_unsigned& operator ^= (uint64 v);
1615 const sc_unsigned& operator ^= (long v);
1616 const sc_unsigned& operator ^= (unsigned long v);
1617 const sc_unsigned& operator ^= (int v)
1618 { return operator^=((long) v); }
1619 const sc_unsigned& operator ^= (unsigned int v)
1620 { return operator^=((unsigned long) v); }
1621
1622 friend SC_API sc_unsigned operator ^ (const sc_unsigned& u, const sc_uint_base& v);
1623 friend SC_API sc_signed operator ^ (const sc_unsigned& u, const sc_int_base& v);
1624 friend SC_API sc_unsigned operator ^ (const sc_uint_base& u, const sc_unsigned& v);
1625 friend SC_API sc_signed operator ^ (const sc_int_base& u, const sc_unsigned& v);
1626 const sc_unsigned& operator ^= (const sc_int_base& v);
1627 const sc_unsigned& operator ^= (const sc_uint_base& v);
1628
1629 // SHIFT OPERATORS:
1630
1631 // LEFT SHIFT operators:
1632
1633 friend SC_API sc_unsigned operator << (const sc_unsigned& u, const sc_signed& v);
1634 friend SC_API sc_signed operator << (const sc_signed& u, const sc_unsigned& v);
1635
1636 friend SC_API sc_unsigned operator << (const sc_unsigned& u, const sc_unsigned& v);
1637 friend SC_API sc_unsigned operator << (const sc_unsigned& u, int64 v);
1638 friend SC_API sc_unsigned operator << (const sc_unsigned& u, uint64 v);
1639 friend SC_API sc_unsigned operator << (const sc_unsigned& u, long v);
1640 friend SC_API sc_unsigned operator << (const sc_unsigned& u, unsigned long v);
1641 friend sc_unsigned operator << (const sc_unsigned& u, int v)
1642 { return operator<<(u, (long) v); }
1643 friend sc_unsigned operator << (const sc_unsigned& u, unsigned int v)
1644 { return operator<<(u, (unsigned long) v); }
1645
1646 const sc_unsigned& operator <<= (const sc_signed& v);
1647 const sc_unsigned& operator <<= (const sc_unsigned& v);
1648 const sc_unsigned& operator <<= (int64 v);
1649 const sc_unsigned& operator <<= (uint64 v);
1650 const sc_unsigned& operator <<= (long v);
1651 const sc_unsigned& operator <<= (unsigned long v);
1652 const sc_unsigned& operator <<= (int v)
1653 { return operator<<=((long) v); }
1654 const sc_unsigned& operator <<= (unsigned int v)
1655 { return operator<<=((unsigned long) v); }
1656
1657 friend SC_API sc_unsigned operator << (const sc_unsigned& u, const sc_uint_base& v);
1658 friend SC_API sc_unsigned operator << (const sc_unsigned& u, const sc_int_base& v);
1659 const sc_unsigned& operator <<= (const sc_int_base& v);
1660 const sc_unsigned& operator <<= (const sc_uint_base& v);
1661
1662 // RIGHT SHIFT operators:
1663
1664 friend SC_API sc_unsigned operator >> (const sc_unsigned& u, const sc_signed& v);
1665 friend SC_API sc_signed operator >> (const sc_signed& u, const sc_unsigned& v);
1666
1667 friend SC_API sc_unsigned operator >> (const sc_unsigned& u, const sc_unsigned& v);
1668 friend SC_API sc_unsigned operator >> (const sc_unsigned& u, int64 v);
1669 friend SC_API sc_unsigned operator >> (const sc_unsigned& u, uint64 v);
1670 friend SC_API sc_unsigned operator >> (const sc_unsigned& u, long v);
1671 friend SC_API sc_unsigned operator >> (const sc_unsigned& u, unsigned long v);
1672 friend sc_unsigned operator >> (const sc_unsigned& u, int v)
1673 { return operator>>(u, (long) v); }
1674 friend sc_unsigned operator >> (const sc_unsigned& u, unsigned int v)
1675 { return operator>>(u, (unsigned long) v); }
1676
1677 const sc_unsigned& operator >>= (const sc_signed& v);
1678 const sc_unsigned& operator >>= (const sc_unsigned& v);
1679 const sc_unsigned& operator >>= (int64 v);
1680 const sc_unsigned& operator >>= (uint64 v);
1681 const sc_unsigned& operator >>= (long v);
1682 const sc_unsigned& operator >>= (unsigned long v);
1683 const sc_unsigned& operator >>= (int v)
1684 { return operator>>=((long) v); }
1685 const sc_unsigned& operator >>= (unsigned int v)
1686 { return operator>>=((unsigned long) v); }
1687
1688 friend SC_API sc_unsigned operator >> ( const sc_unsigned& , const sc_uint_base& );
1689 friend SC_API sc_unsigned operator >> ( const sc_unsigned&, const sc_int_base& );
1690 const sc_unsigned& operator >>= (const sc_int_base& v);
1691 const sc_unsigned& operator >>= (const sc_uint_base& v);
1692
1693 // Unary arithmetic operators
1694 friend SC_API sc_unsigned operator + (const sc_unsigned& u);
1695 friend SC_API sc_signed operator - (const sc_unsigned& u);
1696
1697 // LOGICAL OPERATORS:
1698
1699 // Logical EQUAL operators:
1700
1701 friend SC_API bool operator == (const sc_unsigned& u, const sc_signed& v);
1702 friend SC_API bool operator == (const sc_signed& u, const sc_unsigned& v);
1703
1704 friend SC_API bool operator == (const sc_unsigned& u, const sc_unsigned& v);
1705 friend SC_API bool operator == (const sc_unsigned& u, int64 v);
1706 friend SC_API bool operator == (const sc_unsigned& u, uint64 v);
1707 friend SC_API bool operator == (const sc_unsigned& u, long v);
1708 friend SC_API bool operator == (const sc_unsigned& u, unsigned long v);
1709 friend bool operator == (const sc_unsigned& u, int v)
1710 { return operator==(u, (long) v); }
1711 friend bool operator == (const sc_unsigned& u, unsigned int v)
1712 { return operator==(u, (unsigned long) v); }
1713
1714 friend SC_API bool operator == (int64 u, const sc_unsigned& v);
1715 friend SC_API bool operator == (uint64 u, const sc_unsigned& v);
1716 friend SC_API bool operator == (long u, const sc_unsigned& v);
1717 friend SC_API bool operator == (unsigned long u, const sc_unsigned& v);
1718 friend bool operator == (int u, const sc_unsigned& v)
1719 { return operator==((long) u, v); }
1720 friend bool operator == (unsigned int u, const sc_unsigned& v)
1721 { return operator==((unsigned long) u, v); }
1722
1723 friend SC_API bool operator == (const sc_unsigned& u, const sc_uint_base& v);
1724 friend SC_API bool operator == (const sc_unsigned& u, const sc_int_base& v);
1725 friend SC_API bool operator == (const sc_uint_base& u, const sc_unsigned& v);
1726 friend SC_API bool operator == (const sc_int_base& u, const sc_unsigned& v);
1727
1728 // Logical NOT_EQUAL operators:
1729
1730 friend SC_API bool operator != (const sc_unsigned& u, const sc_signed& v);
1731 friend SC_API bool operator != (const sc_signed& u, const sc_unsigned& v);
1732
1733 friend SC_API bool operator != (const sc_unsigned& u, const sc_unsigned& v);
1734 friend SC_API bool operator != (const sc_unsigned& u, int64 v);
1735 friend SC_API bool operator != (const sc_unsigned& u, uint64 v);
1736 friend SC_API bool operator != (const sc_unsigned& u, long v);
1737 friend SC_API bool operator != (const sc_unsigned& u, unsigned long v);
1738 friend bool operator != (const sc_unsigned& u, int v)
1739 { return operator!=(u, (long) v); }
1740 friend bool operator != (const sc_unsigned& u, unsigned int v)
1741 { return operator!=(u, (unsigned long) v); }
1742
1743 friend SC_API bool operator != (int64 u, const sc_unsigned& v);
1744 friend SC_API bool operator != (uint64 u, const sc_unsigned& v);
1745 friend SC_API bool operator != (long u, const sc_unsigned& v);
1746 friend SC_API bool operator != (unsigned long u, const sc_unsigned& v);
1747 friend bool operator != (int u, const sc_unsigned& v)
1748 { return operator!=((long) u, v); }
1749 friend bool operator != (unsigned int u, const sc_unsigned& v)
1750 { return operator!=((unsigned long) u, v); }
1751
1752 friend SC_API bool operator != (const sc_unsigned& u, const sc_uint_base& v);
1753 friend SC_API bool operator != (const sc_unsigned& u, const sc_int_base& v);
1754 friend SC_API bool operator != (const sc_uint_base& u, const sc_unsigned& v);
1755 friend SC_API bool operator != (const sc_int_base& u, const sc_unsigned& v);
1756
1757 // Logical LESS_THAN operators:
1758
1759 friend SC_API bool operator < (const sc_unsigned& u, const sc_signed& v);
1760 friend SC_API bool operator < (const sc_signed& u, const sc_unsigned& v);
1761
1762 friend SC_API bool operator < (const sc_unsigned& u, const sc_unsigned& v);
1763 friend SC_API bool operator < (const sc_unsigned& u, int64 v);
1764 friend SC_API bool operator < (const sc_unsigned& u, uint64 v);
1765 friend SC_API bool operator < (const sc_unsigned& u, long v);
1766 friend SC_API bool operator < (const sc_unsigned& u, unsigned long v);
1767 friend bool operator < (const sc_unsigned& u, int v)
1768 { return operator<(u, (long) v); }
1769 friend bool operator < (const sc_unsigned& u, unsigned int v)
1770 { return operator<(u, (unsigned long) v); }
1771
1772 friend SC_API bool operator < (int64 u, const sc_unsigned& v);
1773 friend SC_API bool operator < (uint64 u, const sc_unsigned& v);
1774 friend SC_API bool operator < (long u, const sc_unsigned& v);
1775 friend SC_API bool operator < (unsigned long u, const sc_unsigned& v);
1776 friend bool operator < (int u, const sc_unsigned& v)
1777 { return operator<((long) u, v); }
1778 friend bool operator < (unsigned int u, const sc_unsigned& v)
1779 { return operator<((unsigned long) u, v); }
1780
1781 friend SC_API bool operator < (const sc_unsigned& u, const sc_uint_base& v);
1782 friend SC_API bool operator < (const sc_unsigned& u, const sc_int_base& v);
1783 friend SC_API bool operator < (const sc_uint_base& u, const sc_unsigned& v);
1784 friend SC_API bool operator < (const sc_int_base& u, const sc_unsigned& v);
1785
1786 // Logical LESS_THAN_AND_EQUAL operators:
1787
1788 friend SC_API bool operator <= (const sc_unsigned& u, const sc_signed& v);
1789 friend SC_API bool operator <= (const sc_signed& u, const sc_unsigned& v);
1790
1791 friend SC_API bool operator <= (const sc_unsigned& u, const sc_unsigned& v);
1792 friend SC_API bool operator <= (const sc_unsigned& u, int64 v);
1793 friend SC_API bool operator <= (const sc_unsigned& u, uint64 v);
1794 friend SC_API bool operator <= (const sc_unsigned& u, long v);
1795 friend SC_API bool operator <= (const sc_unsigned& u, unsigned long v);
1796 friend bool operator <= (const sc_unsigned& u, int v)
1797 { return operator<=(u, (long) v); }
1798 friend bool operator <= (const sc_unsigned& u, unsigned int v)
1799 { return operator<=(u, (unsigned long) v); }
1800
1801 friend SC_API bool operator <= (int64 u, const sc_unsigned& v);
1802 friend SC_API bool operator <= (uint64 u, const sc_unsigned& v);
1803 friend SC_API bool operator <= (long u, const sc_unsigned& v);
1804 friend SC_API bool operator <= (unsigned long u, const sc_unsigned& v);
1805 friend bool operator <= (int u, const sc_unsigned& v)
1806 { return operator<=((long) u, v); }
1807 friend bool operator <= (unsigned int u, const sc_unsigned& v)
1808 { return operator<=((unsigned long) u, v); }
1809
1810 friend SC_API bool operator <= (const sc_unsigned& u, const sc_uint_base& v);
1811 friend SC_API bool operator <= (const sc_unsigned& u, const sc_int_base& v);
1812 friend SC_API bool operator <= (const sc_uint_base& u, const sc_unsigned& v);
1813 friend SC_API bool operator <= (const sc_int_base& u, const sc_unsigned& v);
1814
1815 // Logical GREATER_THAN operators:
1816
1817 friend SC_API bool operator > (const sc_unsigned& u, const sc_signed& v);
1818 friend SC_API bool operator > (const sc_signed& u, const sc_unsigned& v);
1819
1820 friend SC_API bool operator > (const sc_unsigned& u, const sc_unsigned& v);
1821 friend SC_API bool operator > (const sc_unsigned& u, int64 v);
1822 friend SC_API bool operator > (const sc_unsigned& u, uint64 v);
1823 friend SC_API bool operator > (const sc_unsigned& u, long v);
1824 friend SC_API bool operator > (const sc_unsigned& u, unsigned long v);
1825 friend bool operator > (const sc_unsigned& u, int v)
1826 { return operator>(u, (long) v); }
1827 friend bool operator > (const sc_unsigned& u, unsigned int v)
1828 { return operator>(u, (unsigned long) v); }
1829
1830 friend SC_API bool operator > (int64 u, const sc_unsigned& v);
1831 friend SC_API bool operator > (uint64 u, const sc_unsigned& v);
1832 friend SC_API bool operator > (long u, const sc_unsigned& v);
1833 friend SC_API bool operator > (unsigned long u, const sc_unsigned& v);
1834 friend bool operator > (int u, const sc_unsigned& v)
1835 { return operator>((long) u, v); }
1836 friend bool operator > (unsigned int u, const sc_unsigned& v)
1837 { return operator>((unsigned long) u, v); }
1838
1839 friend SC_API bool operator > (const sc_unsigned& u, const sc_uint_base& v);
1840 friend SC_API bool operator > (const sc_unsigned& u, const sc_int_base& v);
1841 friend SC_API bool operator > (const sc_uint_base& u, const sc_unsigned& v);
1842 friend SC_API bool operator > (const sc_int_base& u, const sc_unsigned& v);
1843
1844 // Logical GREATER_THAN_AND_EQUAL operators:
1845
1846 friend SC_API bool operator >= (const sc_unsigned& u, const sc_signed& v);
1847 friend SC_API bool operator >= (const sc_signed& u, const sc_unsigned& v);
1848
1849 friend SC_API bool operator >= (const sc_unsigned& u, const sc_unsigned& v);
1850 friend SC_API bool operator >= (const sc_unsigned& u, int64 v);
1851 friend SC_API bool operator >= (const sc_unsigned& u, uint64 v);
1852 friend SC_API bool operator >= (const sc_unsigned& u, long v);
1853 friend SC_API bool operator >= (const sc_unsigned& u, unsigned long v);
1854 friend bool operator >= (const sc_unsigned& u, int v)
1855 { return operator>=(u, (long) v); }
1856 friend bool operator >= (const sc_unsigned& u, unsigned int v)
1857 { return operator>=(u, (unsigned long) v); }
1858
1859 friend SC_API bool operator >= (int64 u, const sc_unsigned& v);
1860 friend SC_API bool operator >= (uint64 u, const sc_unsigned& v);
1861 friend SC_API bool operator >= (long u, const sc_unsigned& v);
1862 friend SC_API bool operator >= (unsigned long u, const sc_unsigned& v);
1863 friend bool operator >= (int u, const sc_unsigned& v)
1864 { return operator>=((long) u, v); }
1865 friend bool operator >= (unsigned int u, const sc_unsigned& v)
1866 { return operator>=((unsigned long) u, v); }
1867
1868 friend SC_API bool operator >= (const sc_unsigned& u, const sc_uint_base& v);
1869 friend SC_API bool operator >= (const sc_unsigned& u, const sc_int_base& v);
1870 friend SC_API bool operator >= (const sc_uint_base& u, const sc_unsigned& v);
1871 friend SC_API bool operator >= (const sc_int_base& u, const sc_unsigned& v);
1872
1873 // Bitwise NOT operator (unary).
1874 friend SC_API sc_unsigned operator ~ (const sc_unsigned& u);
1875
1876 // Helper functions.
1877 friend int compare_unsigned(small_type us,
1878 int unb,
1879 int und,
1880 const sc_digit *ud,
1881 small_type vs,
1882 int vnb,
1883 int vnd,
1884 const sc_digit *vd,
1885 small_type if_u_signed,
1886 small_type if_v_signed);
1887
1888 friend sc_unsigned add_unsigned_friend(small_type us,
1889 int unb,
1890 int und,
1891 const sc_digit *ud,
1892 small_type vs,
1893 int vnb,
1894 int vnd,
1895 const sc_digit *vd);
1896
1897 friend sc_unsigned sub_unsigned_friend(small_type us,
1898 int unb,
1899 int und,
1900 const sc_digit *ud,
1901 small_type vs,
1902 int vnb,
1903 int vnd,
1904 const sc_digit *vd);
1905
1906 friend sc_unsigned mul_unsigned_friend(small_type s,
1907 int unb,
1908 int und,
1909 const sc_digit *ud,
1910 int vnb,
1911 int vnd,
1912 const sc_digit *vd);
1913
1914 friend sc_unsigned div_unsigned_friend(small_type s,
1915 int unb,
1916 int und,
1917 const sc_digit *ud,
1918 int vnb,
1919 int vnd,
1920 const sc_digit *vd);
1921
1922 friend sc_unsigned mod_unsigned_friend(small_type us,
1923 int unb,
1924 int und,
1925 const sc_digit *ud,
1926 int vnb,
1927 int vnd,
1928 const sc_digit *vd);
1929
1930 friend sc_unsigned and_unsigned_friend(small_type us,
1931 int unb,
1932 int und,
1933 const sc_digit *ud,
1934 small_type vs,
1935 int vnb,
1936 int vnd,
1937 const sc_digit *vd);
1938
1939 friend sc_unsigned or_unsigned_friend(small_type us,
1940 int unb,
1941 int und,
1942 const sc_digit *ud,
1943 small_type vs,
1944 int vnb,
1945 int vnd,
1946 const sc_digit *vd);
1947
1948 friend sc_unsigned xor_unsigned_friend(small_type us,
1949 int unb,
1950 int und,
1951 const sc_digit *ud,
1952 small_type vs,
1953 int vnb,
1954 int vnd,
1955 const sc_digit *vd);
1956
1957 public:
1958 static sc_core::sc_vpool<sc_unsigned> m_pool;
1959
1960 private:
1961
1962 small_type sgn; // Shortened as s.
1963 int nbits; // Shortened as nb.
1964 int ndigits; // Shortened as nd.
1965
1966 #ifdef SC_MAX_NBITS
1967 sc_digit digit[DIV_CEIL(SC_MAX_NBITS)]; // Shortened as d.
1968 #else
1969 sc_digit *digit; // Shortened as d.
1970 #endif
1971
1972 // Private constructors:
1973
1974 // Create a copy of v with sign s.
1975 sc_unsigned(const sc_unsigned& v, small_type s);
1976 sc_unsigned(const sc_signed& v, small_type s);
1977
1978 // Create an unsigned number with the given attributes.
1979 sc_unsigned(small_type s, int nb, int nd,
1980 sc_digit *d, bool alloc = true);
1981
1982 // Create an unsigned number using the bits u[l..r].
1983 sc_unsigned(const sc_signed* u, int l, int r);
1984 sc_unsigned(const sc_unsigned* u, int l, int r);
1985
1986 // Private member functions. The called functions are inline functions.
1987
default_sign()1988 small_type default_sign() const
1989 { return SC_POS; }
1990
num_bits(int nb)1991 int num_bits(int nb) const { return nb + 1; }
1992
1993 bool check_if_outside(int bit_num) const;
1994
copy_digits(int nb,int nd,const sc_digit * d)1995 void copy_digits(int nb, int nd, const sc_digit *d)
1996 { copy_digits_unsigned(sgn, nbits, ndigits, digit, nb, nd, d); }
1997
makezero()1998 void makezero()
1999 { sgn = make_zero(ndigits, digit); }
2000
2001 // Conversion functions between 2's complement (2C) and
2002 // sign-magnitude (SM):
convert_2C_to_SM()2003 void convert_2C_to_SM()
2004 { sgn = convert_unsigned_2C_to_SM(nbits, ndigits, digit); }
2005
convert_SM_to_2C_to_SM()2006 void convert_SM_to_2C_to_SM()
2007 { sgn = convert_unsigned_SM_to_2C_to_SM(sgn, nbits, ndigits, digit); }
2008
convert_SM_to_2C()2009 void convert_SM_to_2C()
2010 { convert_unsigned_SM_to_2C(sgn, ndigits, digit); }
2011
2012 };
2013
2014
2015
2016 inline
2017 ::std::ostream&
2018 operator << ( ::std::ostream&, const sc_unsigned& );
2019
2020 inline
2021 ::std::istream&
2022 operator >> ( ::std::istream&, sc_unsigned& );
2023
2024
2025 // IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
2026
2027 // ----------------------------------------------------------------------------
2028 // CLASS : sc_unsigned_bitref_r
2029 //
2030 // Proxy class for sc_unsigned bit selection (r-value only).
2031 // ----------------------------------------------------------------------------
2032
2033
2034 inline
2035 ::std::ostream&
2036 operator << ( ::std::ostream& os, const sc_unsigned_bitref_r& a )
2037 {
2038 a.print( os );
2039 return os;
2040 }
2041
2042
2043 // ----------------------------------------------------------------------------
2044 // CLASS : sc_unsigned_bitref
2045 //
2046 // Proxy class for sc_unsigned bit selection (r-value and l-value).
2047 // ----------------------------------------------------------------------------
2048
2049 template<class T>
2050 inline const sc_unsigned_subref& sc_unsigned_subref::operator = (
2051 const sc_generic_base<T>& a )
2052 {
2053 sc_unsigned temp( length() );
2054 a->to_sc_unsigned(temp);
2055 return *this = temp;
2056 }
2057
2058 inline
2059 ::std::istream&
2060 operator >> ( ::std::istream& is, sc_unsigned_bitref& a )
2061 {
2062 a.scan( is );
2063 return is;
2064 }
2065
2066
2067 // ----------------------------------------------------------------------------
2068 // CLASS : sc_unsigned_subref_r
2069 //
2070 // Proxy class for sc_unsigned part selection (r-value only).
2071 // ----------------------------------------------------------------------------
2072
2073 // reduce methods
2074
and_reduce()2075 inline bool sc_unsigned_subref_r::and_reduce() const
2076 {
2077 const sc_unsigned* target_p = m_obj_p;
2078 for ( int i = m_right; i <= m_left; i++ )
2079 if ( !target_p->test(i) ) return false;
2080 return true;
2081 }
2082
nand_reduce()2083 inline bool sc_unsigned_subref_r::nand_reduce() const
2084 {
2085 return !and_reduce();
2086 }
2087
or_reduce()2088 inline bool sc_unsigned_subref_r::or_reduce() const
2089 {
2090 const sc_unsigned* target_p = m_obj_p;
2091 for ( int i = m_right; i <= m_left; i++ )
2092 if ( target_p->test(i) ) return true;
2093 return false;
2094 }
2095
nor_reduce()2096 inline bool sc_unsigned_subref_r::nor_reduce() const
2097 {
2098 return !or_reduce();
2099 }
2100
xor_reduce()2101 inline bool sc_unsigned_subref_r::xor_reduce() const
2102 {
2103 int odd;
2104 const sc_unsigned* target_p = m_obj_p;
2105 odd = 0;
2106 for ( int i = m_right; i <= m_left; i++ )
2107 if ( target_p->test(i) ) odd = ~odd;
2108 return odd ? true : false;
2109 }
2110
xnor_reduce()2111 inline bool sc_unsigned_subref_r::xnor_reduce() const
2112 {
2113 return !xor_reduce();
2114 }
2115
2116
2117 inline
2118 ::std::ostream&
2119 operator << ( ::std::ostream& os, const sc_unsigned_subref_r& a )
2120 {
2121 a.print( os );
2122 return os;
2123 }
2124
2125
2126 // ----------------------------------------------------------------------------
2127 // CLASS : sc_unsigned_subref
2128 //
2129 // Proxy class for sc_unsigned part selection (r-value and l-value).
2130 // ----------------------------------------------------------------------------
2131
2132 // assignment operators
2133
2134 inline
2135 const sc_unsigned_subref&
2136 sc_unsigned_subref::operator = ( const char* a )
2137 {
2138 sc_unsigned aa( length() );
2139 return ( *this = aa = a );
2140 }
2141
2142
2143 inline
2144 ::std::istream&
2145 operator >> ( ::std::istream& is, sc_unsigned_subref& a )
2146 {
2147 a.scan( is );
2148 return is;
2149 }
2150
2151
2152
2153 // ----------------------------------------------------------------------------
2154 // CLASS : sc_unsigned
2155 //
2156 // Arbitrary precision signed number.
2157 // ----------------------------------------------------------------------------
2158
2159 template<class T>
sc_unsigned(const sc_generic_base<T> & v)2160 sc_unsigned::sc_unsigned( const sc_generic_base<T>& v )
2161 {
2162 int nb = v->length();
2163 sgn = default_sign();
2164 if( nb > 0 ) {
2165 nbits = num_bits( nb );
2166 } else {
2167 invalid_init( "sc_generic_base<T>", nb );
2168 sc_core::sc_abort(); // can't recover from here
2169 }
2170 ndigits = DIV_CEIL(nbits);
2171 # ifdef SC_MAX_NBITS
2172 test_bound(nb);
2173 # else
2174 digit = new sc_digit[ndigits];
2175 # endif
2176 makezero();
2177 v->to_sc_unsigned(*this);
2178 }
2179
2180
2181 inline
2182 ::std::ostream&
2183 operator << ( ::std::ostream& os, const sc_unsigned& a )
2184 {
2185 a.print( os );
2186 return os;
2187 }
2188
2189 inline
2190 ::std::istream&
2191 operator >> ( ::std::istream& is, sc_unsigned& a )
2192 {
2193 a.scan( is );
2194 return is;
2195 }
2196
2197 } // namespace sc_dt
2198
2199 #endif
2200