diff options
Diffstat (limited to 'src/systemc/tests/systemc/misc/unit/data/user_guide/ch9')
15 files changed, 3337 insertions, 0 deletions
diff --git a/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/c_array_datatype/c_array_datatype.cpp b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/c_array_datatype/c_array_datatype.cpp new file mode 100644 index 000000000..db29e9061 --- /dev/null +++ b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/c_array_datatype/c_array_datatype.cpp @@ -0,0 +1,110 @@ +/***************************************************************************** + + Licensed to Accellera Systems Initiative Inc. (Accellera) under one or + more contributor license agreements. See the NOTICE file distributed + with this work for additional information regarding copyright ownership. + Accellera licenses this file to you under the Apache License, Version 2.0 + (the "License"); you may not use this file except in compliance with the + License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied. See the License for the specific language governing + permissions and limitations under the License. + + *****************************************************************************/ + +/***************************************************************************** + + c_array_datatype.cpp -- + + Original Author: Martin Janssen, Synopsys, Inc., 2002-02-15 + + *****************************************************************************/ + +/***************************************************************************** + + MODIFICATION LOG - modifiers, enter your name, affiliation, date and + changes you are making here. + + Name, Affiliation, Date: + Description of Modification: + + *****************************************************************************/ + +/* Main file for "C array" data type */ + +#include "systemc.h" + +int sc_main(int ac, char *av[]) +{ + +// 1. DECLARATION SYNTAX + int a[4] = { 0, 23, -534, 23423 }; + long b[4] = { 0, 23, -534, 23423 }; + short c[4] = { 0, 23, -534, 23423 }; + char d[9] = { 'U', 'X', '0', '1', 'Z', 'W', 'L', 'H', '-' }; + + unsigned int e[4] = { 0, 23, 534, 23423 }; + unsigned long f[4] = { 0, 23, 534, 23423 }; + unsigned short g[4] = { 0, 23, 534, 23423 }; + unsigned char h[9] = { 'U', 'X', '0', '1', 'Z', 'W', 'L', 'H', '-' }; + + float i[4] = { 0, 4.89, -345.6778, 543222.898394322 }; + double j[4] = { 0, 4.89, -345.6778, 543222.898394322 }; +// type 'long double' is non-portable +// long double k[4] = { 0, 4.89, -345.6778, 543222.898394322 }; + + bool l[4] = { 0, 1, true, false }; + + sc_logic m[9] = { sc_logic('U'), sc_logic('X'), sc_logic('0'), sc_logic('1'), + sc_logic('Z'), sc_logic('W'), sc_logic('L'), sc_logic('H'), sc_logic('-') }; + + +// 2. TYPE CONVERSION + + // No type conversion because assignment of arrays is illegal + +// 3. OPERATORS +// Supported operators: [] + + cout.precision(15); + cout << "\nINT \t\t" + << a[0] << "\t" << a[1] << "\t" << a[2] << "\t" << a[3] + << "\nLONG \t\t" + << b[0] << "\t" << b[1] << "\t" << b[2] << "\t" << b[3] + << "\nSHORT \t\t" + << c[0] << "\t" << c[1] << "\t" << c[2] << "\t" << c[3] + << "\nCHAR \t\t" + << d[0] << "\t" << d[1] << "\t" << d[2] << "\t" + << d[3] << "\t" << d[4] << "\t" << d[5] << "\t" + << d[6] << "\t" << d[7] << "\t" << d[8] + << "\n\nUNSIGNED INT \t" + << e[0] << "\t" << e[1] << "\t" << e[2] << "\t" << e[3] + << "\nUNSIGNED LONG \t" + << f[0] << "\t" << f[1] << "\t" << f[2] << "\t" << f[3] + << "\nUNSIGNED SHORT \t" + << g[0] << "\t" << g[1] << "\t" << g[2] << "\t" << g[3] + << "\nUNSIGNED CHAR \t" + << h[0] << "\t" << h[1] << "\t" << h[2] << "\t" + << h[3] << "\t" << h[4] << "\t" << h[5] << "\t" + << h[6] << "\t" << h[7] << "\t" << h[8] + << "\n\nFLOAT \t\t" + << i[0] << "\t" << i[1] << "\t" << i[2] << "\t" << i[3] + << "\nDOUBLE \t\t" + << j[0] << "\t" << j[1] << "\t" << j[2] << "\t" << j[3] +// type 'long double' is non-portable +// << "\nLONG DOUBLE \t" +// << k[0] << "\t" << k[1] << "\t" << k[2] << "\t" << k[3] + << "\n\nBOOL \t\t" + << l[0] << "\t" << l[1] << "\t" << l[2] << "\t" << l[3] + << "\nSTD_ULOGIC \t" + << m[0] << "\t" << m[1] << "\t" << m[2] << "\t" + << m[3] << "\t" << m[4] << "\t" << m[5] << "\t" + << m[6] << "\t" << m[7] << "\t" << m[8] + << endl; + return 0; +} diff --git a/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/c_array_datatype/golden/c_array_datatype.log b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/c_array_datatype/golden/c_array_datatype.log new file mode 100644 index 000000000..3e0671235 --- /dev/null +++ b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/c_array_datatype/golden/c_array_datatype.log @@ -0,0 +1,17 @@ +SystemC Simulation + +INT 0 23 -534 23423 +LONG 0 23 -534 23423 +SHORT 0 23 -534 23423 +CHAR U X 0 1 Z W L H - + +UNSIGNED INT 0 23 534 23423 +UNSIGNED LONG 0 23 534 23423 +UNSIGNED SHORT 0 23 534 23423 +UNSIGNED CHAR U X 0 1 Z W L H - + +FLOAT 0 4.8899998664856 -345.677795410156 543222.875 +DOUBLE 0 4.89 -345.6778 543222.898394322 + +BOOL 0 1 1 0 +STD_ULOGIC X X 0 1 Z X X X X diff --git a/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/int_datatype/golden/int_datatype.log b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/int_datatype/golden/int_datatype.log new file mode 100644 index 000000000..dcaba007d --- /dev/null +++ b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/int_datatype/golden/int_datatype.log @@ -0,0 +1,46 @@ +SystemC Simulation +int <= int +--------------------- +A = 5 5 +B = -12 -12 + +op1 operator op2 result [All operands are int] +---------------------------------------------------------------- +13 * 3 = 39 +13 / 3 = 4 +13 % 3 = 1 +13 + 3 = 16 +13 - 3 = 10 +!(13) = 0 +13 && 3 = 1 +13 || 3 = 1 +13 < 3 = 0 +13 <= 3 = 0 +13 > 3 = 1 +13 >= 3 = 1 +13 += 3 = 16 +13 -= 3 = 10 +13 *= 3 = 39 +13 /= 3 = 4 +13 %= 3 = 1 +13 <<= 3 = 104 +13 >>= 3 = 1 +13 &= 3 = 1 +13 ^= 3 = 14 +13 |= 3 = 15 + ()++ 3 = 3 + ++() 3 = 4 + ()-- 3 = 3 + --() 3 = 2 +13 > ?: 3 = 1 +13 < ?: 3 = 0 +13 , 3 = 3 +~(13) = 4294967282 +13 << 3 = 104 +13 >> 3 = 1 +13 & 3 = 1 +13 ^ 3 = 14 +13 | 3 = 15 +13 == 3 -> false +13 != 3 -> true +0 = 0 diff --git a/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/int_datatype/int_datatype.cpp b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/int_datatype/int_datatype.cpp new file mode 100644 index 000000000..c1a8fb6cc --- /dev/null +++ b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/int_datatype/int_datatype.cpp @@ -0,0 +1,217 @@ +/***************************************************************************** + + Licensed to Accellera Systems Initiative Inc. (Accellera) under one or + more contributor license agreements. See the NOTICE file distributed + with this work for additional information regarding copyright ownership. + Accellera licenses this file to you under the Apache License, Version 2.0 + (the "License"); you may not use this file except in compliance with the + License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied. See the License for the specific language governing + permissions and limitations under the License. + + *****************************************************************************/ + +/***************************************************************************** + + int_datatype.cpp -- + + Original Author: Martin Janssen, Synopsys, Inc., 2002-02-15 + + *****************************************************************************/ + +/***************************************************************************** + + MODIFICATION LOG - modifiers, enter your name, affiliation, date and + changes you are making here. + + Name, Affiliation, Date: + Description of Modification: + + *****************************************************************************/ + +/* Main file for "int" data type */ + +#include "systemc.h" + +int sc_main(int ac, char *av[]) +{ + +// 1. DECLARATION SYNTAX + int a; + int b; + +// 2. TYPE CONVERSION + + // int <- int + a = 5; + b = -12; + + cout << "int \t<=\t int" + << "\n---------------------" + << "\nA = " << a << "\t\t 5" + << "\nB = " << b << "\t\t -12" + << "\n" << endl; + + // **** ADD MORE TYPE CONVERSIONS ***** + +// 3. OPERATORS +// Supported operators: ! && || ~ & ^ | + - * / % << >> +// &= ^= |= += -= *= /= %= <<= >>= +// = == != < <= > >= << >> +// ()++ ++() ()-- --() ?: , + +#define VAL1 13 +#define VAL2 3 + + unsigned int op1 = VAL1; + unsigned int op2 = VAL2; + unsigned int r1, r2, r3, r4, r5, r6, r7, r8, r9; + unsigned int r10, r11, r12, r13, r14, r15, r16, r17, r18, r19; + unsigned int r20, r21, r22, r23, r24, r25, r26, r27, r28, r29; + unsigned int r30, r31, r32, r33, r34, r35; + + r1 = op1 * op2; // Multiplication + + r2 = op1 / op2; // Division + + r3 = op1 % op2; // Modulus + + r4 = op1 + op2; // Addition + + r5 = op1 - op2; // Subtraction + + r6 = !op1; // Logical NOT + + r7 = op1 && op2; // Logical AND + + r8 = op1 || op2; // Logical OR + + r9 = op1 < op2; // Less than + + r10 = op1 <= op2; // Less than or equal + + r11 = op1 > op2; // Greater than + + r12 = op1 >= op2; // Greater than or equal + + r13 = op1 += op2; // Compound addition + op1 = VAL1; op2 = VAL2; + + r14 = op1 -= op2; // Compound subtraction + op1 = VAL1; op2 = VAL2; + + r15 = op1 *= op2; // Compound multiplication + op1 = VAL1; op2 = VAL2; + + r16 = op1 /= op2; // Compound division + op1 = VAL1; op2 = VAL2; + + r17 = op1 %= op2; // Compound modulus + op1 = VAL1; op2 = VAL2; + + r18 = op1 <<= op2; // Compound shift left + op1 = VAL1; op2 = VAL2; + + r19 = op1 >>= op2; // Compound shift right + op1 = VAL1; op2 = VAL2; + + r20 = op1 &= op2; // Compound bitwise AND + op1 = VAL1; op2 = VAL2; + + r21 = op1 ^= op2; // Compound bitwise XOR + op1 = VAL1; op2 = VAL2; + + r22 = op1 |= op2; // Compound bitwise OR + op1 = VAL1; op2 = VAL2; + + r23 = op2++; // Postfix increment + op1 = VAL1; op2 = VAL2; + + r24 = ++op2; // Prefix increment + op1 = VAL1; op2 = VAL2; + + r25 = op2--; // Postfix decrement + op1 = VAL1; op2 = VAL2; + + r26 = --op2; // Prefix decrement + op1 = VAL1; op2 = VAL2; + + r27 = (op1 > op2) ? true : false; // Arithmetic if + r28 = (op1 < op2) ? true : false; // Arithmetic if + + r29 = op1, r29 = op2; // Comma + + r30 = ~op1; // Bitwise NOT + + r31 = op1 << op2; // Left shift + op1 = VAL1; op2 = VAL2; + + r32 = op1 >> op2; // Right shift + op1 = VAL1; op2 = VAL2; + + r33 = op1 & op2; // Bitwise AND + + r34 = op1 ^ op2; // Bitwise XOR + + r35 = op1 | op2; // Bitwise OR + + cout << "op1 \t operator \t op2 \t result [All operands are int]" + << "\n----------------------------------------------------------------" + << "\n" << op1 << "\t * \t\t " << op2 << "\t = " << r1 + << "\n" << op1 << "\t / \t\t " << op2 << "\t = " << r2 + << "\n" << op1 << "\t % \t\t " << op2 << "\t = " << r3 + << "\n" << op1 << "\t + \t\t " << op2 << "\t = " << r4 + << "\n" << op1 << "\t - \t\t " << op2 << "\t = " << r5 + << "\n!(" << op1 << ") \t\t\t\t = " << r6 + << "\n" << op1 << "\t && \t\t " << op2 << "\t = " << r7 + << "\n" << op1 << "\t || \t\t " << op2 << "\t = " << r8 + << "\n" << op1 << "\t < \t\t " << op2 << "\t = " << r9 + << "\n" << op1 << "\t <= \t\t " << op2 << "\t = " << r10 + << "\n" << op1 << "\t > \t\t " << op2 << "\t = " << r11 + << "\n" << op1 << "\t >= \t\t " << op2 << "\t = " << r12 + << "\n" << op1 << "\t += \t\t " << op2 << "\t = " << r13 + << "\n" << op1 << "\t -= \t\t " << op2 << "\t = " << r14 + << "\n" << op1 << "\t *= \t\t " << op2 << "\t = " << r15 + << "\n" << op1 << "\t /= \t\t " << op2 << "\t = " << r16 + << "\n" << op1 << "\t %= \t\t " << op2 << "\t = " << r17 + << "\n" << op1 << "\t <<=\t\t " << op2 << "\t = " << r18 + << "\n" << op1 << "\t >>=\t\t " << op2 << "\t = " << r19 + << "\n" << op1 << "\t &= \t\t " << op2 << "\t = " << r20 + << "\n" << op1 << "\t ^= \t\t " << op2 << "\t = " << r21 + << "\n" << op1 << "\t |= \t\t " << op2 << "\t = " << r22 + << "\n" << "\t ()++ \t " << op2 << "\t = " << r23 + << "\n" << "\t ++() \t " << op2 << "\t = " << r24 + << "\n" << "\t ()-- \t " << op2 << "\t = " << r25 + << "\n" << "\t --() \t " << op2 << "\t = " << r26 + << "\n" << op1 << "\t > ?: \t " << op2 << "\t = " << r27 + << "\n" << op1 << "\t < ?: \t " << op2 << "\t = " << r28 + << "\n" << op1 << "\t , \t\t " << op2 << "\t = " << r29 + << "\n~(" << op1 << ") \t\t\t\t = " << r30 + << "\n" << op1 << "\t << \t\t " << op2 << "\t = " << r31 + << "\n" << op1 << "\t >> \t\t " << op2 << "\t = " << r32 + << "\n" << op1 << "\t & \t\t " << op2 << "\t = " << r33 + << "\n" << op1 << "\t ^ \t\t " << op2 << "\t = " << r34 + << "\n" << op1 << "\t | \t\t " << op2 << "\t = " << r35 + << endl; + + if (op1 == op2) // Equality + cout << op1 << "\t == \t\t " << op2 << "\t -> true" << endl; + else + cout << op1 << "\t == \t\t " << op2 << "\t -> false" << endl; + + if (op1 != op2) // Inequality + cout << op1 << "\t != \t\t " << op2 << "\t -> true" << endl; + else + cout << op1 << "\t != \t\t " << op2 << "\t -> false" << endl; + + op1 = op2 = 0; // Assignment operator concatenation + cout << op1 << "\t = \t\t " << op2 << endl; + sc_start(0, SC_NS); + return 0; +} diff --git a/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_datatype/golden/std_ulogic_da b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_datatype/golden/std_ulogic_da new file mode 100644 index 000000000..989b39e58 --- /dev/null +++ b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_datatype/golden/std_ulogic_da @@ -0,0 +1,106 @@ +SystemC Simulation + +std_ulogic <= std_ulogic +------------------------------------------- +UNINITIALIZED = X 'U' +UNKNOWN = X 'X' +ZERO = 0 '0' +ONE = 1 '1' +TRISTATE = Z 'Z' +WEAK-UNKNOWN = X 'W' +WEAK-ZERO = X 'L' +WEAK-ONE = X 'H' +DONT-CARE = X '-' +TRUE = 1 true +FALSE = 0 false + +std_ulogic <= literals +------------------------- +A = 1 true +B = 0 false +C = 1 1 +D = 0 0 + +std_ulogic <= bool +--------------------- +TRUE = 1 1 +FALSE = 0 0 +1 = 1 1 +0 = 0 0 + +std_ulogic <= char +--------------------- +SC1 = X 'U' +SC2 = X 'u' +SC3 = X 'X' +SC4 = X 'x' +SC5 = 0 '0' +SC6 = 1 '1' +SC7 = Z 'Z' +SC8 = Z 'z' +SC9 = X 'W' +SC10 = X 'w' +SC11 = X 'L' +SC12 = X 'l' +SC13 = X 'H' +SC14 = X 'h' +SC15 = X '-' +SC16 = X 'D' +SC17 = X 'd' +SC18 = X 'B' +SC19 = X 'F' + +op1 operator op2 result [All operands are std_ulogic] +---------------------------------------------------------------- +1 &= 1 = 1 +1 ^= 1 = 0 +1 |= 1 = 1 +~(1) = 0 +1 & 1 = 1 +1 ^ 1 = 0 +1 | 1 = 1 +1 == 1 -> true +1 != 1 -> false +0 = 0 + ++-------------------------+ +| AND (&) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | 0 | X | X | ++-------------------------+ +| 0 | 0 | 0 | 0 | 0 | ++-------------------------+ +| 1 | X | 0 | 1 | X | ++-------------------------+ +| Z | X | 0 | X | X | ++-------------------------+ + ++-------------------------+ +| OR (|) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | X | 1 | X | ++-------------------------+ +| 0 | X | 0 | 1 | X | ++-------------------------+ +| 1 | 1 | 1 | 1 | 1 | ++-------------------------+ +| Z | X | X | 1 | X | ++-------------------------+ + ++-------------------------+ +| XOR (^) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | X | X | X | ++-------------------------+ +| 0 | X | 0 | 1 | X | ++-------------------------+ +| 1 | X | 1 | 0 | X | ++-------------------------+ +| Z | X | X | X | X | ++-------------------------+ + ++-------------------------+ +| NOT (~) | X | 0 | 1 | Z | ++-------------------------+ +| | X | 1 | 0 | X | ++-------------------------+ diff --git a/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_datatype/golden/std_ulogic_datatype.log b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_datatype/golden/std_ulogic_datatype.log new file mode 100644 index 000000000..989b39e58 --- /dev/null +++ b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_datatype/golden/std_ulogic_datatype.log @@ -0,0 +1,106 @@ +SystemC Simulation + +std_ulogic <= std_ulogic +------------------------------------------- +UNINITIALIZED = X 'U' +UNKNOWN = X 'X' +ZERO = 0 '0' +ONE = 1 '1' +TRISTATE = Z 'Z' +WEAK-UNKNOWN = X 'W' +WEAK-ZERO = X 'L' +WEAK-ONE = X 'H' +DONT-CARE = X '-' +TRUE = 1 true +FALSE = 0 false + +std_ulogic <= literals +------------------------- +A = 1 true +B = 0 false +C = 1 1 +D = 0 0 + +std_ulogic <= bool +--------------------- +TRUE = 1 1 +FALSE = 0 0 +1 = 1 1 +0 = 0 0 + +std_ulogic <= char +--------------------- +SC1 = X 'U' +SC2 = X 'u' +SC3 = X 'X' +SC4 = X 'x' +SC5 = 0 '0' +SC6 = 1 '1' +SC7 = Z 'Z' +SC8 = Z 'z' +SC9 = X 'W' +SC10 = X 'w' +SC11 = X 'L' +SC12 = X 'l' +SC13 = X 'H' +SC14 = X 'h' +SC15 = X '-' +SC16 = X 'D' +SC17 = X 'd' +SC18 = X 'B' +SC19 = X 'F' + +op1 operator op2 result [All operands are std_ulogic] +---------------------------------------------------------------- +1 &= 1 = 1 +1 ^= 1 = 0 +1 |= 1 = 1 +~(1) = 0 +1 & 1 = 1 +1 ^ 1 = 0 +1 | 1 = 1 +1 == 1 -> true +1 != 1 -> false +0 = 0 + ++-------------------------+ +| AND (&) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | 0 | X | X | ++-------------------------+ +| 0 | 0 | 0 | 0 | 0 | ++-------------------------+ +| 1 | X | 0 | 1 | X | ++-------------------------+ +| Z | X | 0 | X | X | ++-------------------------+ + ++-------------------------+ +| OR (|) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | X | 1 | X | ++-------------------------+ +| 0 | X | 0 | 1 | X | ++-------------------------+ +| 1 | 1 | 1 | 1 | 1 | ++-------------------------+ +| Z | X | X | 1 | X | ++-------------------------+ + ++-------------------------+ +| XOR (^) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | X | X | X | ++-------------------------+ +| 0 | X | 0 | 1 | X | ++-------------------------+ +| 1 | X | 1 | 0 | X | ++-------------------------+ +| Z | X | X | X | X | ++-------------------------+ + ++-------------------------+ +| NOT (~) | X | 0 | 1 | Z | ++-------------------------+ +| | X | 1 | 0 | X | ++-------------------------+ diff --git a/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_datatype/std_ulogic_datatype.cpp b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_datatype/std_ulogic_datatype.cpp new file mode 100644 index 000000000..3822e98f8 --- /dev/null +++ b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_datatype/std_ulogic_datatype.cpp @@ -0,0 +1,542 @@ +/***************************************************************************** + + Licensed to Accellera Systems Initiative Inc. (Accellera) under one or + more contributor license agreements. See the NOTICE file distributed + with this work for additional information regarding copyright ownership. + Accellera licenses this file to you under the Apache License, Version 2.0 + (the "License"); you may not use this file except in compliance with the + License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied. See the License for the specific language governing + permissions and limitations under the License. + + *****************************************************************************/ + +/***************************************************************************** + + std_ulogic_datatype.cpp -- + + Original Author: Martin Janssen, Synopsys, Inc., 2002-02-15 + + *****************************************************************************/ + +/***************************************************************************** + + MODIFICATION LOG - modifiers, enter your name, affiliation, date and + changes you are making here. + + Name, Affiliation, Date: + Description of Modification: + + *****************************************************************************/ + +/* Main file for "std_ulogic" data type */ + +#include "systemc.h" + +typedef sc_logic std_ulogic; + +int sc_main(int ac, char *av[]) +{ + +// 1. DECLARATION SYNTAX + std_ulogic s1; + std_ulogic s2, s3, s4, s5, s6, s7, s8, s9, s10, s11; + + +// 2. TYPE CONVERSION + + // std_ulogic <- std_ulogic + s1 = 'U'; + s2 = 'X'; + s3 = '0'; + s4 = '1'; + s5 = 'Z'; + s6 = 'W'; + s7 = 'L'; + s8 = 'H'; + s9 = '-'; + s10 = true; + s11 = false; + + cout << "\nstd_ulogic \t<=\t\t std_ulogic" + << "\n-------------------------------------------" + << "\nUNINITIALIZED \t= " << s1 << "\t\t 'U'" + << "\nUNKNOWN \t= " << s2 << "\t\t 'X'" + << "\nZERO \t\t= " << s3 << "\t\t '0'" + << "\nONE \t\t= " << s4 << "\t\t '1'" + << "\nTRISTATE \t= " << s5 << "\t\t 'Z'" + << "\nWEAK-UNKNOWN \t= " << s6 << "\t\t 'W'" + << "\nWEAK-ZERO \t= " << s7 << "\t\t 'L'" + << "\nWEAK-ONE \t= " << s8 << "\t\t 'H'" + << "\nDONT-CARE \t= " << s9 << "\t\t '-'" + << "\nTRUE \t\t= " << s10 << "\t\t true" + << "\nFALSE \t\t= " << s11 << "\t\t false" + << "\n" << endl; + + // std_ulogic <- literals + std_ulogic a, b, c, d; + + a = true; + b = false; + c = 1; + d = 0; + + cout << "std_ulogic <=\t literals" + << "\n-------------------------" + << "\nA = " << a << "\t\t true" + << "\nB = " << b << "\t\t false" + << "\nC = " << c << "\t\t 1" + << "\nD = " << d << "\t\t 0" + << "\n" << endl; + + // std_ulogic <- bool + std_ulogic su1, su2, su3, su4; + bool b1, b2, b3, b4; + + b1 = true; + b2 = false; + b3 = 1; + b4 = 0; + + su1 = b1; + su2 = b2; + su3 = b3; + su4 = b4; + + cout << "std_ulogic <=\t bool" + << "\n---------------------" + << "\nTRUE \t= " << su1 << "\t " << b1 + << "\nFALSE \t= " << su2 << "\t " << b2 + << "\n1 \t= " << su3 << "\t " << b3 + << "\n0 \t= " << su4 << "\t " << b4 + << "\n" << endl; + + // std_ulogic <- char + std_ulogic sc1, sc2, sc3, sc4, sc5, sc6, sc7, sc8, sc9; + std_ulogic sc10, sc11, sc12, sc13, sc14, sc15, sc16, sc17, sc18, sc19; + char c1, c2, c3, c4, c5, c6, c7, c8, c9; + char c10, c11, c12, c13, c14, c15, c16, c17, c18, c19; + + c1 = 'U'; + c2 = 'u'; + c3 = 'X'; + c4 = 'x'; + c5 = '0'; + c6 = '1'; + c7 = 'Z'; + c8 = 'z'; + c9 = 'W'; + c10 = 'w'; + c11 = 'L'; + c12 = 'l'; + c13 = 'H'; + c14 = 'h'; + c15 = '-'; + c16 = 'D'; + c17 = 'd'; + c18 = 'B'; + c19 = 'F'; + + sc1 = c1; + sc2 = c2; + sc3 = c3; + sc4 = c4; + sc5 = c5; + sc6 = c6; + sc7 = c7; + sc8 = c8; + sc9 = c9; + sc10 = c10; + sc11 = c11; + sc12 = c12; + sc13 = c13; + sc14 = c14; + sc15 = c15; + sc16 = c16; + sc17 = c17; + sc18 = c18; + sc19 = c19; + + cout << "std_ulogic <=\t char" + << "\n---------------------" + << "\nSC1 \t= " << sc1 << "\t '" << c1 << "'" + << "\nSC2 \t= " << sc2 << "\t '" << c2 << "'" + << "\nSC3 \t= " << sc3 << "\t '" << c3 << "'" + << "\nSC4 \t= " << sc4 << "\t '" << c4 << "'" + << "\nSC5 \t= " << sc5 << "\t '" << c5 << "'" + << "\nSC6 \t= " << sc6 << "\t '" << c6 << "'" + << "\nSC7 \t= " << sc7 << "\t '" << c7 << "'" + << "\nSC8 \t= " << sc8 << "\t '" << c8 << "'" + << "\nSC9 \t= " << sc9 << "\t '" << c9 << "'" + << "\nSC10 \t= " << sc10 << "\t '" << c10 << "'" + << "\nSC11 \t= " << sc11 << "\t '" << c11 << "'" + << "\nSC12 \t= " << sc12 << "\t '" << c12 << "'" + << "\nSC13 \t= " << sc13 << "\t '" << c13 << "'" + << "\nSC14 \t= " << sc14 << "\t '" << c14 << "'" + << "\nSC15 \t= " << sc15 << "\t '" << c15 << "'" + << "\nSC16 \t= " << sc16 << "\t '" << c16 << "'" + << "\nSC17 \t= " << sc17 << "\t '" << c17 << "'" + << "\nSC18 \t= " << sc18 << "\t '" << c18 << "'" + << "\nSC19 \t= " << sc19 << "\t '" << c19 << "'" + << "\n" << endl; + + +// 3. OPERATORS +// Supported operators: ~ & ^ | &= ^= |= == != = + +#define VAL1 '1' +#define VAL2 '1' + + std_ulogic op1 = sc_logic(VAL1); + std_ulogic op2 = sc_logic(VAL2); + std_ulogic r1, r2, r3, r4, r5, r6, r7, r8, r9; + std_ulogic r10, r11, r12, r13, r14, r15, r16, r17, r18, r19; + std_ulogic r20, r21, r22, r23, r24, r25, r26, r27, r28, r29; + std_ulogic r30, r31, r32, r33, r34, r35; + +// r1 = op1 * op2; // Multiplication + +// r2 = op1 / op2; // Division + +// r3 = op1 % op2; // Modulus + +// r4 = op1 + op2; // Addition + +// r5 = op1 - op2; // Subtraction + +// r6 = !op1; // Logical NOT + +// r7 = op1 && op2; // Logical AND + +// r8 = op1 || op2; // Logical OR + +// r9 = op1 < op2; // Less than + +// r10 = op1 <= op2; // Less than or equal + +// r11 = op1 > op2; // Greater than + +// r12 = op1 >= op2; // Greater than or equal + +// r13 = op1 += op2; // Compound addition +// op1 = VAL1; op2 = VAL2; + +// r14 = op1 -= op2; // Compound subtraction +// op1 = VAL1; op2 = VAL2; + +// r15 = op1 *= op2; // Compound multiplication +// op1 = VAL1; op2 = VAL2; + +// r16 = op1 /= op2; // Compound division +// op1 = VAL1; op2 = VAL2; + +// r17 = op1 %= op2; // Compound modulus +// op1 = VAL1; op2 = VAL2; + +// r18 = op1 <<= op2; // Compound shift left +// op1 = VAL1; op2 = VAL2; + +// r19 = op1 >>= op2; // Compound shift right +// op1 = VAL1; op2 = VAL2; + + r20 = op1 &= op2; // Compound bitwise AND + op1 = VAL1; op2 = VAL2; + + r21 = op1 ^= op2; // Compound bitwise XOR + op1 = VAL1; op2 = VAL2; + + r22 = op1 |= op2; // Compound bitwise OR + op1 = VAL1; op2 = VAL2; + +// r23 = op2++; // Postfix increment +// op1 = VAL1; op2 = VAL2; + +// r24 = ++op2; // Prefix increment +// op1 = VAL1; op2 = VAL2; + +// r25 = op2--; // Postfix decrement +// op1 = VAL1; op2 = VAL2; + +// r26 = --op2; // Prefix decrement +// op1 = VAL1; op2 = VAL2; + +// r27 = (op1 > op2) ? true : false; // Arithmetic if +// r28 = (op1 < op2) ? true : false; // Arithmetic if + +// r29 = op1, r29 = op2; // Comma + + r30 = ~op1; // Bitwise NOT + +// r31 = op1 << op2; // Left shift +// op1 = VAL1; op2 = VAL2; + +// r32 = op1 >> op2; // Right shift +// op1 = VAL1; op2 = VAL2; + + r33 = op1 & op2; // Bitwise AND + + r34 = op1 ^ op2; // Bitwise XOR + + r35 = op1 | op2; // Bitwise OR + + cout << "op1 \t operator \t op2 \t result [All operands are std_ulogic]" + << "\n----------------------------------------------------------------" +// << "\n" << op1 << "\t * \t\t " << op2 << "\t = " << r1 +// << "\n" << op1 << "\t / \t\t " << op2 << "\t = " << r2 +// << "\n" << op1 << "\t % \t\t " << op2 << "\t = " << r3 +// << "\n" << op1 << "\t + \t\t " << op2 << "\t = " << r4 +// << "\n" << op1 << "\t - \t\t " << op2 << "\t = " << r5 +// << "\n!(" << op1 << ") \t\t\t\t = " << r6 +// << "\n" << op1 << "\t && \t\t " << op2 << "\t = " << r7 +// << "\n" << op1 << "\t || \t\t " << op2 << "\t = " << r8 +// << "\n" << op1 << "\t < \t\t " << op2 << "\t = " << r9 +// << "\n" << op1 << "\t <= \t\t " << op2 << "\t = " << r10 +// << "\n" << op1 << "\t > \t\t " << op2 << "\t = " << r11 +// << "\n" << op1 << "\t >= \t\t " << op2 << "\t = " << r12 +// << "\n" << op1 << "\t += \t\t " << op2 << "\t = " << r13 +// << "\n" << op1 << "\t -= \t\t " << op2 << "\t = " << r14 +// << "\n" << op1 << "\t *= \t\t " << op2 << "\t = " << r15 +// << "\n" << op1 << "\t /= \t\t " << op2 << "\t = " << r16 +// << "\n" << op1 << "\t %= \t\t " << op2 << "\t = " << r17 +// << "\n" << op1 << "\t <<=\t\t " << op2 << "\t = " << r18 +// << "\n" << op1 << "\t >>=\t\t " << op2 << "\t = " << r19 + << "\n" << op1 << "\t &= \t\t " << op2 << "\t = " << r20 + << "\n" << op1 << "\t ^= \t\t " << op2 << "\t = " << r21 + << "\n" << op1 << "\t |= \t\t " << op2 << "\t = " << r22 +// << "\n" << "\t ()++ \t " << op2 << "\t = " << r23 +// << "\n" << "\t ++() \t " << op2 << "\t = " << r24 +// << "\n" << "\t ()-- \t " << op2 << "\t = " << r25 +// << "\n" << "\t --() \t " << op2 << "\t = " << r26 +// << "\n" << op1 << "\t > ?: \t " << op2 << "\t = " << r27 +// << "\n" << op1 << "\t < ?: \t " << op2 << "\t = " << r28 +// << "\n" << op1 << "\t , \t\t " << op2 << "\t = " << r29 + << "\n~(" << op1 << ") \t\t\t\t = " << r30 +// << "\n" << op1 << "\t << \t\t " << op2 << "\t = " << r31 +// << "\n" << op1 << "\t >> \t\t " << op2 << "\t = " << r32 + << "\n" << op1 << "\t & \t\t " << op2 << "\t = " << r33 + << "\n" << op1 << "\t ^ \t\t " << op2 << "\t = " << r34 + << "\n" << op1 << "\t | \t\t " << op2 << "\t = " << r35 + << endl; + + if (op1 == op2) // Equality + cout << op1 << "\t == \t\t " << op2 << "\t -> true" << endl; + else + cout << op1 << "\t == \t\t " << op2 << "\t -> false" << endl; + + if (op1 != op2) // Inequality + cout << op1 << "\t != \t\t " << op2 << "\t -> true" << endl; + else + cout << op1 << "\t != \t\t " << op2 << "\t -> false" << endl; + + op1 = op2 = 0; // Assignment operator concatenation + cout << op1 << "\t = \t\t " << op2 << endl; + +// 4. OPERATOR DEFINITIONS +// & | ^ ~ + std_ulogic v1, v2, v3, v4, v5, v6, v7, v8, v9; + std_ulogic uu, ux, u0, u1, uz, uw, ul, uh, ud; + std_ulogic xu, xx, x0, x1, xz, xw, xl, xh, xd; + std_ulogic _0u, _0x, _00, _01, _0z, _0w, _0l, _0h, _0d; + std_ulogic _1u, _1x, _10, _11, _1z, _1w, _1l, _1h, _1d; + std_ulogic zu, zx, z0, z1, zz, zw, zl, zh, zd; + std_ulogic wu, wx, w0, w1, wz, ww, wl, wh, wd; + std_ulogic lu, lx, l0, l1, lz, lw, ll, lh, ld; + std_ulogic hu, hx, h0, h1, hz, hw, hl, hh, hd; + std_ulogic du, dx, d0, d1, dz, dw, dl, dh, dd; + + v1 = 'U'; + v2 = 'X'; + v3 = '0'; + v4 = '1'; + v5 = 'Z'; + v6 = 'W'; + v7 = 'L'; + v8 = 'H'; + v9 = '-'; + + uu = v1 & v1; ux = v1 & v2; u0 = v1 & v3; + u1 = v1 & v4; uz = v1 & v5; uw = v1 & v6; + ul = v1 & v7; uh = v1 & v8; ud = v1 & v9; + + xu = v2 & v1; xx = v2 & v2; x0 = v2 & v3; + x1 = v2 & v4; xz = v2 & v5; xw = v2 & v6; + xl = v2 & v7; xh = v2 & v8; xd = v2 & v9; + + _0u = v3 & v1; _0x = v3 & v2; _00 = v3 & v3; + _01 = v3 & v4; _0z = v3 & v5; _0w = v3 & v6; + _0l = v3 & v7; _0h = v3 & v8; _0d = v3 & v9; + + _1u = v4 & v1; _1x = v4 & v2; _10 = v4 & v3; + _11 = v4 & v4; _1z = v4 & v5; _1w = v4 & v6; + _1l = v4 & v7; _1h = v4 & v8; _1d = v4 & v9; + + zu = v5 & v1; zx = v5 & v2; z0 = v5 & v3; + z1 = v5 & v4; zz = v5 & v5; zw = v5 & v6; + zl = v5 & v7; zh = v5 & v8; zd = v5 & v9; + + wu = v6 & v1; wx = v6 & v2; w0 = v6 & v3; + w1 = v6 & v4; wz = v6 & v5; ww = v6 & v6; + wl = v6 & v7; wh = v6 & v8; wd = v6 & v9; + + lu = v7 & v1; lx = v7 & v2; l0 = v7 & v3; + l1 = v7 & v4; lz = v7 & v5; lw = v7 & v6; + ll = v7 & v7; lh = v7 & v8; ld = v7 & v9; + + hu = v8 & v1; hx = v8 & v2; h0 = v8 & v3; + h1 = v8 & v4; hz = v8 & v5; hw = v8 & v6; + hl = v8 & v7; hh = v8 & v8; hd = v8 & v9; + + du = v9 & v1; dx = v9 & v2; d0 = v9 & v3; + d1 = v9 & v4; dz = v9 & v5; dw = v9 & v6; + dl = v9 & v7; dh = v9 & v8; dd = v9 & v9; + + cout << "\n+-------------------------+" + << "\n| AND (&) | X | 0 | 1 | Z |" + << "\n+-------------------------+" + << "\n| X | " << xx << " | " << x0 << " | " + << x1 << " | " << xz << " | " + << "\n+-------------------------+" + << "\n| 0 | " << _0x << " | " << _00 << " | " + << _01 << " | " << _0z << " | " + << "\n+-------------------------+" + << "\n| 1 | " << _1x << " | " << _10 << " | " + << _11 << " | " << _1z << " | " + << "\n+-------------------------+" + << "\n| Z | " << zx << " | " << z0 << " | " + << z1 << " | " << zz << " | " + << "\n+-------------------------+" + << endl; + + uu = v1 | v1; ux = v1 | v2; u0 = v1 | v3; + u1 = v1 | v4; uz = v1 | v5; uw = v1 | v6; + ul = v1 | v7; uh = v1 | v8; ud = v1 | v9; + + xu = v2 | v1; xx = v2 | v2; x0 = v2 | v3; + x1 = v2 | v4; xz = v2 | v5; xw = v2 | v6; + xl = v2 | v7; xh = v2 | v8; xd = v2 | v9; + + _0u = v3 | v1; _0x = v3 | v2; _00 = v3 | v3; + _01 = v3 | v4; _0z = v3 | v5; _0w = v3 | v6; + _0l = v3 | v7; _0h = v3 | v8; _0d = v3 | v9; + + _1u = v4 | v1; _1x = v4 | v2; _10 = v4 | v3; + _11 = v4 | v4; _1z = v4 | v5; _1w = v4 | v6; + _1l = v4 | v7; _1h = v4 | v8; _1d = v4 | v9; + + zu = v5 | v1; zx = v5 | v2; z0 = v5 | v3; + z1 = v5 | v4; zz = v5 | v5; zw = v5 | v6; + zl = v5 | v7; zh = v5 | v8; zd = v5 | v9; + + wu = v6 | v1; wx = v6 | v2; w0 = v6 | v3; + w1 = v6 | v4; wz = v6 | v5; ww = v6 | v6; + wl = v6 | v7; wh = v6 | v8; wd = v6 | v9; + + lu = v7 | v1; lx = v7 | v2; l0 = v7 | v3; + l1 = v7 | v4; lz = v7 | v5; lw = v7 | v6; + ll = v7 | v7; lh = v7 | v8; ld = v7 | v9; + + hu = v8 | v1; hx = v8 | v2; h0 = v8 | v3; + h1 = v8 | v4; hz = v8 | v5; hw = v8 | v6; + hl = v8 | v7; hh = v8 | v8; hd = v8 | v9; + + du = v9 | v1; dx = v9 | v2; d0 = v9 | v3; + d1 = v9 | v4; dz = v9 | v5; dw = v9 | v6; + dl = v9 | v7; dh = v9 | v8; dd = v9 | v9; + + cout << "\n+-------------------------+" + << "\n| OR (|) | X | 0 | 1 | Z |" + << "\n+-------------------------+" + << "\n| X | " << xx << " | " << x0 << " | " + << x1 << " | " << xz << " | " + << "\n+-------------------------+" + << "\n| 0 | " << _0x << " | " << _00 << " | " + << _01 << " | " << _0z << " | " + << "\n+-------------------------+" + << "\n| 1 | " << _1x << " | " << _10 << " | " + << _11 << " | " << _1z << " | " + << "\n+-------------------------+" + << "\n| Z | " << zx << " | " << z0 << " | " + << z1 << " | " << zz << " | " + << "\n+-------------------------+" + << endl; + + uu = v1 ^ v1; ux = v1 ^ v2; u0 = v1 ^ v3; + u1 = v1 ^ v4; uz = v1 ^ v5; uw = v1 ^ v6; + ul = v1 ^ v7; uh = v1 ^ v8; ud = v1 ^ v9; + + xu = v2 ^ v1; xx = v2 ^ v2; x0 = v2 ^ v3; + x1 = v2 ^ v4; xz = v2 ^ v5; xw = v2 ^ v6; + xl = v2 ^ v7; xh = v2 ^ v8; xd = v2 ^ v9; + + _0u = v3 ^ v1; _0x = v3 ^ v2; _00 = v3 ^ v3; + _01 = v3 ^ v4; _0z = v3 ^ v5; _0w = v3 ^ v6; + _0l = v3 ^ v7; _0h = v3 ^ v8; _0d = v3 ^ v9; + + _1u = v4 ^ v1; _1x = v4 ^ v2; _10 = v4 ^ v3; + _11 = v4 ^ v4; _1z = v4 ^ v5; _1w = v4 ^ v6; + _1l = v4 ^ v7; _1h = v4 ^ v8; _1d = v4 ^ v9; + + zu = v5 ^ v1; zx = v5 ^ v2; z0 = v5 ^ v3; + z1 = v5 ^ v4; zz = v5 ^ v5; zw = v5 ^ v6; + zl = v5 ^ v7; zh = v5 ^ v8; zd = v5 ^ v9; + + wu = v6 ^ v1; wx = v6 ^ v2; w0 = v6 ^ v3; + w1 = v6 ^ v4; wz = v6 ^ v5; ww = v6 ^ v6; + wl = v6 ^ v7; wh = v6 ^ v8; wd = v6 ^ v9; + + lu = v7 ^ v1; lx = v7 ^ v2; l0 = v7 ^ v3; + l1 = v7 ^ v4; lz = v7 ^ v5; lw = v7 ^ v6; + ll = v7 ^ v7; lh = v7 ^ v8; ld = v7 ^ v9; + + hu = v8 ^ v1; hx = v8 ^ v2; h0 = v8 ^ v3; + h1 = v8 ^ v4; hz = v8 ^ v5; hw = v8 ^ v6; + hl = v8 ^ v7; hh = v8 ^ v8; hd = v8 ^ v9; + + du = v9 ^ v1; dx = v9 ^ v2; d0 = v9 ^ v3; + d1 = v9 ^ v4; dz = v9 ^ v5; dw = v9 ^ v6; + dl = v9 ^ v7; dh = v9 ^ v8; dd = v9 ^ v9; + + cout << "\n+-------------------------+" + << "\n| XOR (^) | X | 0 | 1 | Z |" + << "\n+-------------------------+" + << "\n| X | " << xx << " | " << x0 << " | " + << x1 << " | " << xz << " | " + << "\n+-------------------------+" + << "\n| 0 | " << _0x << " | " << _00 << " | " + << _01 << " | " << _0z << " | " + << "\n+-------------------------+" + << "\n| 1 | " << _1x << " | " << _10 << " | " + << _11 << " | " << _1z << " | " + << "\n+-------------------------+" + << "\n| Z | " << zx << " | " << z0 << " | " + << z1 << " | " << zz << " | " + << "\n+-------------------------+" + << endl; + + std_ulogic nu, nx, n0, n1, nz, nw, nl, nh, nd; + + nu = ~v1; + nx = ~v2; + n0 = ~v3; + n1 = ~v4; + nz = ~v5; + nw = ~v6; + nl = ~v7; + nh = ~v8; + nd = ~v9; + + cout << "\n+-------------------------+" + << "\n| NOT (~) | X | 0 | 1 | Z |" + << "\n+-------------------------+" + << "\n| | " << nx << " | " << n0 << " | " + << n1 << " | " << nz << " | " + << "\n+-------------------------+" + << endl; + return 0; +} diff --git a/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_vector_datatype/golden/std_ul b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_vector_datatype/golden/std_ul new file mode 100644 index 000000000..7947cc42e --- /dev/null +++ b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_vector_datatype/golden/std_ul @@ -0,0 +1,203 @@ +SystemC Simulation + +INTEGER SIZE = 4 bytes +SHORT INTEGER SIZE = 2 bytes +LONG INTEGER SIZE = 4 bytes +UNSIGNED LONG SIZE = 4 bytes +SIGNED LONG SIZE = 4 bytes + +std_ulogic_vector <= C++ string +------------------------------------------- +A = 01XZXXXXX "01XZUWLH-" +B = XX0XX1XXX "ZZ1XX0UU1WWW" +BIG = 11110000111100001111000011110000111100001111000011110000111100001111 + "11110000111100001111000011110000111100001111000011110000111100001111" +HUGE = 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111 + +std_ulogic_vector <= std_ulogic_vector +-------------------------------------------------- +C = XX0XX1XXX ZZ1XX0XX1XXX +BIG2 = 11110000111100001111000011110000111100001111000011110000111100001111 + "11110000111100001111000011110000111100001111000011110000111100001111" + +std_ulogic_vector <= C++ array of bool +-------------------------------------------------- +D = XXXXZX10X -, L, H, W, Z, X, 1, 0, U +E = 10011XXXX X, X, 1, 1, 0, 0, 1, 1, X, X, U, U +BIG3 = 11110000111100001111000011110000111100001111000011110000111100001111 + "11110000111100001111000011110000111100001111000011110000111100001111 + 000011110000" + +std_ulogic_vector <= bool_vector +-------------------------------------------- +F = 1010 "1010" + +std_ulogic_vector <= unsigned long +---------------------------------------------- +H = 1001 ...10001001 (137) +I = 00000000000000000000000010001001 ...10001001 (137) +J = 0000000000000000000000000000000010001001 ...10001001 (137) + +std_ulogic_vector <= sc_unsigned +-------------------------------------------- +K = 0011 11 (3) +L = 1101 1101 (13) +M = 1001 10001001 (137) + +std_ulogic_vector <= signed long +-------------------------------------------- +N = 01001 ...010001001 (137) +O = 00000000000000000000000010001001 ...010001001 (137) +P = 0000000000000000000000000000000010001001 ...010001001 (137) +Q = 10111 ...101110111 (-137) +R = 11111111111111111111111101110111 ...101110111 (-137) +S = 1111111111111111111111111111111101110111 ...101110111 (-137) + +std_ulogic_vector <= sc_signed +------------------------------------------ +T = 00011 011 (3) +U = 01101 01101 (13) +V = 01001 010001001 (137) +W = 11101 101 (-3) +X = 10011 10011 (-13) +Y = 10111 101110111 (-137) + +std_ulogic_vector <= to_uint() +----------------------------------------------------------------- +TU1 = 1001 9 +TU2 = 10000000000000000000000000000001 2147483649 +TU3 = 0000000110000000000000000000000000000001 2147483649 +TU4 = 1101 1 (01) +TU4 = 1101 13 (1101) +TU4 = 1101 13 (00001101) + +std_ulogic_vector <= to_int() +----------------------------------------------------------------- +TS1 = 1001 -7 +TS2 = 11111111111111111111101111111001 -1031 +TS3 = 0000000111111111111111111111101111111001 -1031 +TS4 = 11001 1 (001) +TS4 = 11001 -7 (11001) +TS4 = 11001 -7 (111111001) + +std_ulogic_vector <= Typecast sc_unsigned +----------------------------------------------------------------- +TCU1 = 1101 1 (01) +TCU1 = 1101 13 (1101) +TCU1 = 1101 13 (00001101) + +std_ulogic_vector <= Typecast sc_signed +----------------------------------------------------------------- +TCS1 = 11001 1 (001) +TCS1 = 11001 -7 (11001) +TCS1 = 11001 25 (000011001) + +std_ulogic_vector <= to_string() +-------------------------------------------- +TSTR = XXZ01XXXX XXZ01XXXX + +range() tests +----------------------------------------------------------------- +INITIAL 4-BIT 1000 +INITIAL 9-BIT XXZ01XXXX + +LVALUE RISE 1 0 0 0 +LVALUE FALL 0 0 0 1 +LVALUE SUB RISE 0 1 0 0 +LVALUE SUB FALL X X X X 1 0 Z X X +LVALUE BIT 1 1 0 1 + +RVALUE RISE 1 0 0 0 +RVALUE FALL 0 0 0 1 +RVALUE SUB FALL X X X X 1 0 Z X X +RVALUE SUB RISE 1 0 0 0 +RVALUE BIT [] 1 0 1 1 +RVALUE BIT 0 0 1 0 + +op1 operator op2 result [All operands are std_ulogic_vector] +---------------------------------------------------------------- +1010 &= 1000 = 1000 +1010 ^= 1000 = 0010 +1010 |= 1000 = 1010 +~(1010) = 0101 +1010 & 1000 = 1000 +1010 ^ 1000 = 0010 +1010 | 1000 = 1010 + +1010 &= 111011 = 1010 +1010 ^= 111011 = 0001 +1010 |= 111011 = 1011 +1010 & 111011 = 1010 +1010 ^ 111011 = 0001 +1010 | 111011 = 1011 + +1010 and_reduce() = 0 +1010 or_reduce() = 1 +1010 xor_reduce() = 0 + +1010 == 1000 -> false +1010 != 1000 -> true + +1111 = 1111 + ++-------------------------+ +| AND (&) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | 0 | X | X | ++-------------------------+ +| 0 | 0 | 0 | 0 | 0 | ++-------------------------+ +| 1 | X | 0 | 1 | X | ++-------------------------+ +| Z | X | 0 | X | X | ++-------------------------+ + ++-------------------------+ +| OR (|) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | X | 1 | X | ++-------------------------+ +| 0 | X | 0 | 1 | X | ++-------------------------+ +| 1 | 1 | 1 | 1 | 1 | ++-------------------------+ +| Z | X | X | 1 | X | ++-------------------------+ + ++-------------------------+ +| XOR (^) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | X | X | X | ++-------------------------+ +| 0 | X | 0 | 1 | X | ++-------------------------+ +| 1 | X | 1 | 0 | X | ++-------------------------+ +| Z | X | X | X | X | ++-------------------------+ + ++-------------------------+ +| NOT (~) | X | 0 | 1 | Z | ++-------------------------+ +| | X | 1 | 0 | X | ++-------------------------+ diff --git a/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_vector_datatype/golden/std_ulogic_vector_datatype.log b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_vector_datatype/golden/std_ulogic_vector_datatype.log new file mode 100644 index 000000000..7947cc42e --- /dev/null +++ b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_vector_datatype/golden/std_ulogic_vector_datatype.log @@ -0,0 +1,203 @@ +SystemC Simulation + +INTEGER SIZE = 4 bytes +SHORT INTEGER SIZE = 2 bytes +LONG INTEGER SIZE = 4 bytes +UNSIGNED LONG SIZE = 4 bytes +SIGNED LONG SIZE = 4 bytes + +std_ulogic_vector <= C++ string +------------------------------------------- +A = 01XZXXXXX "01XZUWLH-" +B = XX0XX1XXX "ZZ1XX0UU1WWW" +BIG = 11110000111100001111000011110000111100001111000011110000111100001111 + "11110000111100001111000011110000111100001111000011110000111100001111" +HUGE = 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111 + +std_ulogic_vector <= std_ulogic_vector +-------------------------------------------------- +C = XX0XX1XXX ZZ1XX0XX1XXX +BIG2 = 11110000111100001111000011110000111100001111000011110000111100001111 + "11110000111100001111000011110000111100001111000011110000111100001111" + +std_ulogic_vector <= C++ array of bool +-------------------------------------------------- +D = XXXXZX10X -, L, H, W, Z, X, 1, 0, U +E = 10011XXXX X, X, 1, 1, 0, 0, 1, 1, X, X, U, U +BIG3 = 11110000111100001111000011110000111100001111000011110000111100001111 + "11110000111100001111000011110000111100001111000011110000111100001111 + 000011110000" + +std_ulogic_vector <= bool_vector +-------------------------------------------- +F = 1010 "1010" + +std_ulogic_vector <= unsigned long +---------------------------------------------- +H = 1001 ...10001001 (137) +I = 00000000000000000000000010001001 ...10001001 (137) +J = 0000000000000000000000000000000010001001 ...10001001 (137) + +std_ulogic_vector <= sc_unsigned +-------------------------------------------- +K = 0011 11 (3) +L = 1101 1101 (13) +M = 1001 10001001 (137) + +std_ulogic_vector <= signed long +-------------------------------------------- +N = 01001 ...010001001 (137) +O = 00000000000000000000000010001001 ...010001001 (137) +P = 0000000000000000000000000000000010001001 ...010001001 (137) +Q = 10111 ...101110111 (-137) +R = 11111111111111111111111101110111 ...101110111 (-137) +S = 1111111111111111111111111111111101110111 ...101110111 (-137) + +std_ulogic_vector <= sc_signed +------------------------------------------ +T = 00011 011 (3) +U = 01101 01101 (13) +V = 01001 010001001 (137) +W = 11101 101 (-3) +X = 10011 10011 (-13) +Y = 10111 101110111 (-137) + +std_ulogic_vector <= to_uint() +----------------------------------------------------------------- +TU1 = 1001 9 +TU2 = 10000000000000000000000000000001 2147483649 +TU3 = 0000000110000000000000000000000000000001 2147483649 +TU4 = 1101 1 (01) +TU4 = 1101 13 (1101) +TU4 = 1101 13 (00001101) + +std_ulogic_vector <= to_int() +----------------------------------------------------------------- +TS1 = 1001 -7 +TS2 = 11111111111111111111101111111001 -1031 +TS3 = 0000000111111111111111111111101111111001 -1031 +TS4 = 11001 1 (001) +TS4 = 11001 -7 (11001) +TS4 = 11001 -7 (111111001) + +std_ulogic_vector <= Typecast sc_unsigned +----------------------------------------------------------------- +TCU1 = 1101 1 (01) +TCU1 = 1101 13 (1101) +TCU1 = 1101 13 (00001101) + +std_ulogic_vector <= Typecast sc_signed +----------------------------------------------------------------- +TCS1 = 11001 1 (001) +TCS1 = 11001 -7 (11001) +TCS1 = 11001 25 (000011001) + +std_ulogic_vector <= to_string() +-------------------------------------------- +TSTR = XXZ01XXXX XXZ01XXXX + +range() tests +----------------------------------------------------------------- +INITIAL 4-BIT 1000 +INITIAL 9-BIT XXZ01XXXX + +LVALUE RISE 1 0 0 0 +LVALUE FALL 0 0 0 1 +LVALUE SUB RISE 0 1 0 0 +LVALUE SUB FALL X X X X 1 0 Z X X +LVALUE BIT 1 1 0 1 + +RVALUE RISE 1 0 0 0 +RVALUE FALL 0 0 0 1 +RVALUE SUB FALL X X X X 1 0 Z X X +RVALUE SUB RISE 1 0 0 0 +RVALUE BIT [] 1 0 1 1 +RVALUE BIT 0 0 1 0 + +op1 operator op2 result [All operands are std_ulogic_vector] +---------------------------------------------------------------- +1010 &= 1000 = 1000 +1010 ^= 1000 = 0010 +1010 |= 1000 = 1010 +~(1010) = 0101 +1010 & 1000 = 1000 +1010 ^ 1000 = 0010 +1010 | 1000 = 1010 + +1010 &= 111011 = 1010 +1010 ^= 111011 = 0001 +1010 |= 111011 = 1011 +1010 & 111011 = 1010 +1010 ^ 111011 = 0001 +1010 | 111011 = 1011 + +1010 and_reduce() = 0 +1010 or_reduce() = 1 +1010 xor_reduce() = 0 + +1010 == 1000 -> false +1010 != 1000 -> true + +1111 = 1111 + ++-------------------------+ +| AND (&) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | 0 | X | X | ++-------------------------+ +| 0 | 0 | 0 | 0 | 0 | ++-------------------------+ +| 1 | X | 0 | 1 | X | ++-------------------------+ +| Z | X | 0 | X | X | ++-------------------------+ + ++-------------------------+ +| OR (|) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | X | 1 | X | ++-------------------------+ +| 0 | X | 0 | 1 | X | ++-------------------------+ +| 1 | 1 | 1 | 1 | 1 | ++-------------------------+ +| Z | X | X | 1 | X | ++-------------------------+ + ++-------------------------+ +| XOR (^) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | X | X | X | ++-------------------------+ +| 0 | X | 0 | 1 | X | ++-------------------------+ +| 1 | X | 1 | 0 | X | ++-------------------------+ +| Z | X | X | X | X | ++-------------------------+ + ++-------------------------+ +| NOT (~) | X | 0 | 1 | Z | ++-------------------------+ +| | X | 1 | 0 | X | ++-------------------------+ diff --git a/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_vector_datatype/golden/std_ulogic_vector_datatype.log.bsd64 b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_vector_datatype/golden/std_ulogic_vector_datatype.log.bsd64 new file mode 100644 index 000000000..d168d15ca --- /dev/null +++ b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_vector_datatype/golden/std_ulogic_vector_datatype.log.bsd64 @@ -0,0 +1,203 @@ +SystemC Simulation + +INTEGER SIZE = 4 bytes +SHORT INTEGER SIZE = 2 bytes +LONG INTEGER SIZE = 8 bytes +UNSIGNED LONG SIZE = 8 bytes +SIGNED LONG SIZE = 8 bytes + +std_ulogic_vector <= C++ string +------------------------------------------- +A = 01XZXXXXX "01XZUWLH-" +B = XX0XX1XXX "ZZ1XX0UU1WWW" +BIG = 11110000111100001111000011110000111100001111000011110000111100001111 + "11110000111100001111000011110000111100001111000011110000111100001111" +HUGE = 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111 + +std_ulogic_vector <= std_ulogic_vector +-------------------------------------------------- +C = XX0XX1XXX ZZ1XX0XX1XXX +BIG2 = 11110000111100001111000011110000111100001111000011110000111100001111 + "11110000111100001111000011110000111100001111000011110000111100001111" + +std_ulogic_vector <= C++ array of bool +-------------------------------------------------- +D = XXXXZX10X -, L, H, W, Z, X, 1, 0, U +E = 10011XXXX X, X, 1, 1, 0, 0, 1, 1, X, X, U, U +BIG3 = 11110000111100001111000011110000111100001111000011110000111100001111 + "11110000111100001111000011110000111100001111000011110000111100001111 + 000011110000" + +std_ulogic_vector <= bool_vector +-------------------------------------------- +F = 1010 "1010" + +std_ulogic_vector <= unsigned long +---------------------------------------------- +H = 1001 ...10001001 (137) +I = 00000000000000000000000010001001 ...10001001 (137) +J = 0000000000000000000000000000000010001001 ...10001001 (137) + +std_ulogic_vector <= sc_unsigned +-------------------------------------------- +K = 0011 11 (3) +L = 1101 1101 (13) +M = 1001 10001001 (137) + +std_ulogic_vector <= signed long +-------------------------------------------- +N = 01001 ...010001001 (137) +O = 00000000000000000000000010001001 ...010001001 (137) +P = 0000000000000000000000000000000010001001 ...010001001 (137) +Q = 10111 ...101110111 (-137) +R = 11111111111111111111111101110111 ...101110111 (-137) +S = 1111111111111111111111111111111101110111 ...101110111 (-137) + +std_ulogic_vector <= sc_signed +------------------------------------------ +T = 00011 011 (3) +U = 01101 01101 (13) +V = 01001 010001001 (137) +W = 11101 101 (-3) +X = 10011 10011 (-13) +Y = 10111 101110111 (-137) + +std_ulogic_vector <= to_uint() +----------------------------------------------------------------- +TU1 = 1001 9 +TU2 = 10000000000000000000000000000001 2147483649 +TU3 = 0000000110000000000000000000000000000001 2147483649 +TU4 = 1101 1 (01) +TU4 = 1101 13 (1101) +TU4 = 1101 13 (00001101) + +std_ulogic_vector <= to_int() +----------------------------------------------------------------- +TS1 = 1001 -7 +TS2 = 11111111111111111111101111111001 -1031 +TS3 = 0000000111111111111111111111101111111001 -1031 +TS4 = 11001 1 (001) +TS4 = 11001 -7 (11001) +TS4 = 11001 -7 (111111001) + +std_ulogic_vector <= Typecast sc_unsigned +----------------------------------------------------------------- +TCU1 = 1101 1 (01) +TCU1 = 1101 13 (1101) +TCU1 = 1101 13 (00001101) + +std_ulogic_vector <= Typecast sc_signed +----------------------------------------------------------------- +TCS1 = 11001 1 (001) +TCS1 = 11001 -7 (11001) +TCS1 = 11001 25 (000011001) + +std_ulogic_vector <= to_string() +-------------------------------------------- +TSTR = XXZ01XXXX XXZ01XXXX + +range() tests +----------------------------------------------------------------- +INITIAL 4-BIT 1000 +INITIAL 9-BIT XXZ01XXXX + +LVALUE RISE 1 0 0 0 +LVALUE FALL 0 0 0 1 +LVALUE SUB RISE 0 1 0 0 +LVALUE SUB FALL X X X X 1 0 Z X X +LVALUE BIT 1 1 0 1 + +RVALUE RISE 1 0 0 0 +RVALUE FALL 0 0 0 1 +RVALUE SUB FALL X X X X 1 0 Z X X +RVALUE SUB RISE 1 0 0 0 +RVALUE BIT [] 1 0 1 1 +RVALUE BIT 0 0 1 0 + +op1 operator op2 result [All operands are std_ulogic_vector] +---------------------------------------------------------------- +1010 &= 1000 = 1000 +1010 ^= 1000 = 0010 +1010 |= 1000 = 1010 +~(1010) = 0101 +1010 & 1000 = 1000 +1010 ^ 1000 = 0010 +1010 | 1000 = 1010 + +1010 &= 111011 = 1010 +1010 ^= 111011 = 0001 +1010 |= 111011 = 1011 +1010 & 111011 = 1010 +1010 ^ 111011 = 0001 +1010 | 111011 = 1011 + +1010 and_reduce() = 0 +1010 or_reduce() = 1 +1010 xor_reduce() = 0 + +1010 == 1000 -> false +1010 != 1000 -> true + +1111 = 1111 + ++-------------------------+ +| AND (&) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | 0 | X | X | ++-------------------------+ +| 0 | 0 | 0 | 0 | 0 | ++-------------------------+ +| 1 | X | 0 | 1 | X | ++-------------------------+ +| Z | X | 0 | X | X | ++-------------------------+ + ++-------------------------+ +| OR (|) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | X | 1 | X | ++-------------------------+ +| 0 | X | 0 | 1 | X | ++-------------------------+ +| 1 | 1 | 1 | 1 | 1 | ++-------------------------+ +| Z | X | X | 1 | X | ++-------------------------+ + ++-------------------------+ +| XOR (^) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | X | X | X | ++-------------------------+ +| 0 | X | 0 | 1 | X | ++-------------------------+ +| 1 | X | 1 | 0 | X | ++-------------------------+ +| Z | X | X | X | X | ++-------------------------+ + ++-------------------------+ +| NOT (~) | X | 0 | 1 | Z | ++-------------------------+ +| | X | 1 | 0 | X | ++-------------------------+ diff --git a/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_vector_datatype/golden/std_ulogic_vector_datatype.log.cygwin64 b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_vector_datatype/golden/std_ulogic_vector_datatype.log.cygwin64 new file mode 100644 index 000000000..d168d15ca --- /dev/null +++ b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_vector_datatype/golden/std_ulogic_vector_datatype.log.cygwin64 @@ -0,0 +1,203 @@ +SystemC Simulation + +INTEGER SIZE = 4 bytes +SHORT INTEGER SIZE = 2 bytes +LONG INTEGER SIZE = 8 bytes +UNSIGNED LONG SIZE = 8 bytes +SIGNED LONG SIZE = 8 bytes + +std_ulogic_vector <= C++ string +------------------------------------------- +A = 01XZXXXXX "01XZUWLH-" +B = XX0XX1XXX "ZZ1XX0UU1WWW" +BIG = 11110000111100001111000011110000111100001111000011110000111100001111 + "11110000111100001111000011110000111100001111000011110000111100001111" +HUGE = 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111 + +std_ulogic_vector <= std_ulogic_vector +-------------------------------------------------- +C = XX0XX1XXX ZZ1XX0XX1XXX +BIG2 = 11110000111100001111000011110000111100001111000011110000111100001111 + "11110000111100001111000011110000111100001111000011110000111100001111" + +std_ulogic_vector <= C++ array of bool +-------------------------------------------------- +D = XXXXZX10X -, L, H, W, Z, X, 1, 0, U +E = 10011XXXX X, X, 1, 1, 0, 0, 1, 1, X, X, U, U +BIG3 = 11110000111100001111000011110000111100001111000011110000111100001111 + "11110000111100001111000011110000111100001111000011110000111100001111 + 000011110000" + +std_ulogic_vector <= bool_vector +-------------------------------------------- +F = 1010 "1010" + +std_ulogic_vector <= unsigned long +---------------------------------------------- +H = 1001 ...10001001 (137) +I = 00000000000000000000000010001001 ...10001001 (137) +J = 0000000000000000000000000000000010001001 ...10001001 (137) + +std_ulogic_vector <= sc_unsigned +-------------------------------------------- +K = 0011 11 (3) +L = 1101 1101 (13) +M = 1001 10001001 (137) + +std_ulogic_vector <= signed long +-------------------------------------------- +N = 01001 ...010001001 (137) +O = 00000000000000000000000010001001 ...010001001 (137) +P = 0000000000000000000000000000000010001001 ...010001001 (137) +Q = 10111 ...101110111 (-137) +R = 11111111111111111111111101110111 ...101110111 (-137) +S = 1111111111111111111111111111111101110111 ...101110111 (-137) + +std_ulogic_vector <= sc_signed +------------------------------------------ +T = 00011 011 (3) +U = 01101 01101 (13) +V = 01001 010001001 (137) +W = 11101 101 (-3) +X = 10011 10011 (-13) +Y = 10111 101110111 (-137) + +std_ulogic_vector <= to_uint() +----------------------------------------------------------------- +TU1 = 1001 9 +TU2 = 10000000000000000000000000000001 2147483649 +TU3 = 0000000110000000000000000000000000000001 2147483649 +TU4 = 1101 1 (01) +TU4 = 1101 13 (1101) +TU4 = 1101 13 (00001101) + +std_ulogic_vector <= to_int() +----------------------------------------------------------------- +TS1 = 1001 -7 +TS2 = 11111111111111111111101111111001 -1031 +TS3 = 0000000111111111111111111111101111111001 -1031 +TS4 = 11001 1 (001) +TS4 = 11001 -7 (11001) +TS4 = 11001 -7 (111111001) + +std_ulogic_vector <= Typecast sc_unsigned +----------------------------------------------------------------- +TCU1 = 1101 1 (01) +TCU1 = 1101 13 (1101) +TCU1 = 1101 13 (00001101) + +std_ulogic_vector <= Typecast sc_signed +----------------------------------------------------------------- +TCS1 = 11001 1 (001) +TCS1 = 11001 -7 (11001) +TCS1 = 11001 25 (000011001) + +std_ulogic_vector <= to_string() +-------------------------------------------- +TSTR = XXZ01XXXX XXZ01XXXX + +range() tests +----------------------------------------------------------------- +INITIAL 4-BIT 1000 +INITIAL 9-BIT XXZ01XXXX + +LVALUE RISE 1 0 0 0 +LVALUE FALL 0 0 0 1 +LVALUE SUB RISE 0 1 0 0 +LVALUE SUB FALL X X X X 1 0 Z X X +LVALUE BIT 1 1 0 1 + +RVALUE RISE 1 0 0 0 +RVALUE FALL 0 0 0 1 +RVALUE SUB FALL X X X X 1 0 Z X X +RVALUE SUB RISE 1 0 0 0 +RVALUE BIT [] 1 0 1 1 +RVALUE BIT 0 0 1 0 + +op1 operator op2 result [All operands are std_ulogic_vector] +---------------------------------------------------------------- +1010 &= 1000 = 1000 +1010 ^= 1000 = 0010 +1010 |= 1000 = 1010 +~(1010) = 0101 +1010 & 1000 = 1000 +1010 ^ 1000 = 0010 +1010 | 1000 = 1010 + +1010 &= 111011 = 1010 +1010 ^= 111011 = 0001 +1010 |= 111011 = 1011 +1010 & 111011 = 1010 +1010 ^ 111011 = 0001 +1010 | 111011 = 1011 + +1010 and_reduce() = 0 +1010 or_reduce() = 1 +1010 xor_reduce() = 0 + +1010 == 1000 -> false +1010 != 1000 -> true + +1111 = 1111 + ++-------------------------+ +| AND (&) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | 0 | X | X | ++-------------------------+ +| 0 | 0 | 0 | 0 | 0 | ++-------------------------+ +| 1 | X | 0 | 1 | X | ++-------------------------+ +| Z | X | 0 | X | X | ++-------------------------+ + ++-------------------------+ +| OR (|) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | X | 1 | X | ++-------------------------+ +| 0 | X | 0 | 1 | X | ++-------------------------+ +| 1 | 1 | 1 | 1 | 1 | ++-------------------------+ +| Z | X | X | 1 | X | ++-------------------------+ + ++-------------------------+ +| XOR (^) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | X | X | X | ++-------------------------+ +| 0 | X | 0 | 1 | X | ++-------------------------+ +| 1 | X | 1 | 0 | X | ++-------------------------+ +| Z | X | X | X | X | ++-------------------------+ + ++-------------------------+ +| NOT (~) | X | 0 | 1 | Z | ++-------------------------+ +| | X | 1 | 0 | X | ++-------------------------+ diff --git a/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_vector_datatype/golden/std_ulogic_vector_datatype.log.linux64 b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_vector_datatype/golden/std_ulogic_vector_datatype.log.linux64 new file mode 100644 index 000000000..d168d15ca --- /dev/null +++ b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_vector_datatype/golden/std_ulogic_vector_datatype.log.linux64 @@ -0,0 +1,203 @@ +SystemC Simulation + +INTEGER SIZE = 4 bytes +SHORT INTEGER SIZE = 2 bytes +LONG INTEGER SIZE = 8 bytes +UNSIGNED LONG SIZE = 8 bytes +SIGNED LONG SIZE = 8 bytes + +std_ulogic_vector <= C++ string +------------------------------------------- +A = 01XZXXXXX "01XZUWLH-" +B = XX0XX1XXX "ZZ1XX0UU1WWW" +BIG = 11110000111100001111000011110000111100001111000011110000111100001111 + "11110000111100001111000011110000111100001111000011110000111100001111" +HUGE = 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111 + +std_ulogic_vector <= std_ulogic_vector +-------------------------------------------------- +C = XX0XX1XXX ZZ1XX0XX1XXX +BIG2 = 11110000111100001111000011110000111100001111000011110000111100001111 + "11110000111100001111000011110000111100001111000011110000111100001111" + +std_ulogic_vector <= C++ array of bool +-------------------------------------------------- +D = XXXXZX10X -, L, H, W, Z, X, 1, 0, U +E = 10011XXXX X, X, 1, 1, 0, 0, 1, 1, X, X, U, U +BIG3 = 11110000111100001111000011110000111100001111000011110000111100001111 + "11110000111100001111000011110000111100001111000011110000111100001111 + 000011110000" + +std_ulogic_vector <= bool_vector +-------------------------------------------- +F = 1010 "1010" + +std_ulogic_vector <= unsigned long +---------------------------------------------- +H = 1001 ...10001001 (137) +I = 00000000000000000000000010001001 ...10001001 (137) +J = 0000000000000000000000000000000010001001 ...10001001 (137) + +std_ulogic_vector <= sc_unsigned +-------------------------------------------- +K = 0011 11 (3) +L = 1101 1101 (13) +M = 1001 10001001 (137) + +std_ulogic_vector <= signed long +-------------------------------------------- +N = 01001 ...010001001 (137) +O = 00000000000000000000000010001001 ...010001001 (137) +P = 0000000000000000000000000000000010001001 ...010001001 (137) +Q = 10111 ...101110111 (-137) +R = 11111111111111111111111101110111 ...101110111 (-137) +S = 1111111111111111111111111111111101110111 ...101110111 (-137) + +std_ulogic_vector <= sc_signed +------------------------------------------ +T = 00011 011 (3) +U = 01101 01101 (13) +V = 01001 010001001 (137) +W = 11101 101 (-3) +X = 10011 10011 (-13) +Y = 10111 101110111 (-137) + +std_ulogic_vector <= to_uint() +----------------------------------------------------------------- +TU1 = 1001 9 +TU2 = 10000000000000000000000000000001 2147483649 +TU3 = 0000000110000000000000000000000000000001 2147483649 +TU4 = 1101 1 (01) +TU4 = 1101 13 (1101) +TU4 = 1101 13 (00001101) + +std_ulogic_vector <= to_int() +----------------------------------------------------------------- +TS1 = 1001 -7 +TS2 = 11111111111111111111101111111001 -1031 +TS3 = 0000000111111111111111111111101111111001 -1031 +TS4 = 11001 1 (001) +TS4 = 11001 -7 (11001) +TS4 = 11001 -7 (111111001) + +std_ulogic_vector <= Typecast sc_unsigned +----------------------------------------------------------------- +TCU1 = 1101 1 (01) +TCU1 = 1101 13 (1101) +TCU1 = 1101 13 (00001101) + +std_ulogic_vector <= Typecast sc_signed +----------------------------------------------------------------- +TCS1 = 11001 1 (001) +TCS1 = 11001 -7 (11001) +TCS1 = 11001 25 (000011001) + +std_ulogic_vector <= to_string() +-------------------------------------------- +TSTR = XXZ01XXXX XXZ01XXXX + +range() tests +----------------------------------------------------------------- +INITIAL 4-BIT 1000 +INITIAL 9-BIT XXZ01XXXX + +LVALUE RISE 1 0 0 0 +LVALUE FALL 0 0 0 1 +LVALUE SUB RISE 0 1 0 0 +LVALUE SUB FALL X X X X 1 0 Z X X +LVALUE BIT 1 1 0 1 + +RVALUE RISE 1 0 0 0 +RVALUE FALL 0 0 0 1 +RVALUE SUB FALL X X X X 1 0 Z X X +RVALUE SUB RISE 1 0 0 0 +RVALUE BIT [] 1 0 1 1 +RVALUE BIT 0 0 1 0 + +op1 operator op2 result [All operands are std_ulogic_vector] +---------------------------------------------------------------- +1010 &= 1000 = 1000 +1010 ^= 1000 = 0010 +1010 |= 1000 = 1010 +~(1010) = 0101 +1010 & 1000 = 1000 +1010 ^ 1000 = 0010 +1010 | 1000 = 1010 + +1010 &= 111011 = 1010 +1010 ^= 111011 = 0001 +1010 |= 111011 = 1011 +1010 & 111011 = 1010 +1010 ^ 111011 = 0001 +1010 | 111011 = 1011 + +1010 and_reduce() = 0 +1010 or_reduce() = 1 +1010 xor_reduce() = 0 + +1010 == 1000 -> false +1010 != 1000 -> true + +1111 = 1111 + ++-------------------------+ +| AND (&) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | 0 | X | X | ++-------------------------+ +| 0 | 0 | 0 | 0 | 0 | ++-------------------------+ +| 1 | X | 0 | 1 | X | ++-------------------------+ +| Z | X | 0 | X | X | ++-------------------------+ + ++-------------------------+ +| OR (|) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | X | 1 | X | ++-------------------------+ +| 0 | X | 0 | 1 | X | ++-------------------------+ +| 1 | 1 | 1 | 1 | 1 | ++-------------------------+ +| Z | X | X | 1 | X | ++-------------------------+ + ++-------------------------+ +| XOR (^) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | X | X | X | ++-------------------------+ +| 0 | X | 0 | 1 | X | ++-------------------------+ +| 1 | X | 1 | 0 | X | ++-------------------------+ +| Z | X | X | X | X | ++-------------------------+ + ++-------------------------+ +| NOT (~) | X | 0 | 1 | Z | ++-------------------------+ +| | X | 1 | 0 | X | ++-------------------------+ diff --git a/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_vector_datatype/golden/std_ulogic_vector_datatype.log.linuxaarch64 b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_vector_datatype/golden/std_ulogic_vector_datatype.log.linuxaarch64 new file mode 100644 index 000000000..d168d15ca --- /dev/null +++ b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_vector_datatype/golden/std_ulogic_vector_datatype.log.linuxaarch64 @@ -0,0 +1,203 @@ +SystemC Simulation + +INTEGER SIZE = 4 bytes +SHORT INTEGER SIZE = 2 bytes +LONG INTEGER SIZE = 8 bytes +UNSIGNED LONG SIZE = 8 bytes +SIGNED LONG SIZE = 8 bytes + +std_ulogic_vector <= C++ string +------------------------------------------- +A = 01XZXXXXX "01XZUWLH-" +B = XX0XX1XXX "ZZ1XX0UU1WWW" +BIG = 11110000111100001111000011110000111100001111000011110000111100001111 + "11110000111100001111000011110000111100001111000011110000111100001111" +HUGE = 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111 + +std_ulogic_vector <= std_ulogic_vector +-------------------------------------------------- +C = XX0XX1XXX ZZ1XX0XX1XXX +BIG2 = 11110000111100001111000011110000111100001111000011110000111100001111 + "11110000111100001111000011110000111100001111000011110000111100001111" + +std_ulogic_vector <= C++ array of bool +-------------------------------------------------- +D = XXXXZX10X -, L, H, W, Z, X, 1, 0, U +E = 10011XXXX X, X, 1, 1, 0, 0, 1, 1, X, X, U, U +BIG3 = 11110000111100001111000011110000111100001111000011110000111100001111 + "11110000111100001111000011110000111100001111000011110000111100001111 + 000011110000" + +std_ulogic_vector <= bool_vector +-------------------------------------------- +F = 1010 "1010" + +std_ulogic_vector <= unsigned long +---------------------------------------------- +H = 1001 ...10001001 (137) +I = 00000000000000000000000010001001 ...10001001 (137) +J = 0000000000000000000000000000000010001001 ...10001001 (137) + +std_ulogic_vector <= sc_unsigned +-------------------------------------------- +K = 0011 11 (3) +L = 1101 1101 (13) +M = 1001 10001001 (137) + +std_ulogic_vector <= signed long +-------------------------------------------- +N = 01001 ...010001001 (137) +O = 00000000000000000000000010001001 ...010001001 (137) +P = 0000000000000000000000000000000010001001 ...010001001 (137) +Q = 10111 ...101110111 (-137) +R = 11111111111111111111111101110111 ...101110111 (-137) +S = 1111111111111111111111111111111101110111 ...101110111 (-137) + +std_ulogic_vector <= sc_signed +------------------------------------------ +T = 00011 011 (3) +U = 01101 01101 (13) +V = 01001 010001001 (137) +W = 11101 101 (-3) +X = 10011 10011 (-13) +Y = 10111 101110111 (-137) + +std_ulogic_vector <= to_uint() +----------------------------------------------------------------- +TU1 = 1001 9 +TU2 = 10000000000000000000000000000001 2147483649 +TU3 = 0000000110000000000000000000000000000001 2147483649 +TU4 = 1101 1 (01) +TU4 = 1101 13 (1101) +TU4 = 1101 13 (00001101) + +std_ulogic_vector <= to_int() +----------------------------------------------------------------- +TS1 = 1001 -7 +TS2 = 11111111111111111111101111111001 -1031 +TS3 = 0000000111111111111111111111101111111001 -1031 +TS4 = 11001 1 (001) +TS4 = 11001 -7 (11001) +TS4 = 11001 -7 (111111001) + +std_ulogic_vector <= Typecast sc_unsigned +----------------------------------------------------------------- +TCU1 = 1101 1 (01) +TCU1 = 1101 13 (1101) +TCU1 = 1101 13 (00001101) + +std_ulogic_vector <= Typecast sc_signed +----------------------------------------------------------------- +TCS1 = 11001 1 (001) +TCS1 = 11001 -7 (11001) +TCS1 = 11001 25 (000011001) + +std_ulogic_vector <= to_string() +-------------------------------------------- +TSTR = XXZ01XXXX XXZ01XXXX + +range() tests +----------------------------------------------------------------- +INITIAL 4-BIT 1000 +INITIAL 9-BIT XXZ01XXXX + +LVALUE RISE 1 0 0 0 +LVALUE FALL 0 0 0 1 +LVALUE SUB RISE 0 1 0 0 +LVALUE SUB FALL X X X X 1 0 Z X X +LVALUE BIT 1 1 0 1 + +RVALUE RISE 1 0 0 0 +RVALUE FALL 0 0 0 1 +RVALUE SUB FALL X X X X 1 0 Z X X +RVALUE SUB RISE 1 0 0 0 +RVALUE BIT [] 1 0 1 1 +RVALUE BIT 0 0 1 0 + +op1 operator op2 result [All operands are std_ulogic_vector] +---------------------------------------------------------------- +1010 &= 1000 = 1000 +1010 ^= 1000 = 0010 +1010 |= 1000 = 1010 +~(1010) = 0101 +1010 & 1000 = 1000 +1010 ^ 1000 = 0010 +1010 | 1000 = 1010 + +1010 &= 111011 = 1010 +1010 ^= 111011 = 0001 +1010 |= 111011 = 1011 +1010 & 111011 = 1010 +1010 ^ 111011 = 0001 +1010 | 111011 = 1011 + +1010 and_reduce() = 0 +1010 or_reduce() = 1 +1010 xor_reduce() = 0 + +1010 == 1000 -> false +1010 != 1000 -> true + +1111 = 1111 + ++-------------------------+ +| AND (&) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | 0 | X | X | ++-------------------------+ +| 0 | 0 | 0 | 0 | 0 | ++-------------------------+ +| 1 | X | 0 | 1 | X | ++-------------------------+ +| Z | X | 0 | X | X | ++-------------------------+ + ++-------------------------+ +| OR (|) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | X | 1 | X | ++-------------------------+ +| 0 | X | 0 | 1 | X | ++-------------------------+ +| 1 | 1 | 1 | 1 | 1 | ++-------------------------+ +| Z | X | X | 1 | X | ++-------------------------+ + ++-------------------------+ +| XOR (^) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | X | X | X | ++-------------------------+ +| 0 | X | 0 | 1 | X | ++-------------------------+ +| 1 | X | 1 | 0 | X | ++-------------------------+ +| Z | X | X | X | X | ++-------------------------+ + ++-------------------------+ +| NOT (~) | X | 0 | 1 | Z | ++-------------------------+ +| | X | 1 | 0 | X | ++-------------------------+ diff --git a/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_vector_datatype/golden/std_ulogic_vector_datatype.log.macosx64 b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_vector_datatype/golden/std_ulogic_vector_datatype.log.macosx64 new file mode 100644 index 000000000..d168d15ca --- /dev/null +++ b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_vector_datatype/golden/std_ulogic_vector_datatype.log.macosx64 @@ -0,0 +1,203 @@ +SystemC Simulation + +INTEGER SIZE = 4 bytes +SHORT INTEGER SIZE = 2 bytes +LONG INTEGER SIZE = 8 bytes +UNSIGNED LONG SIZE = 8 bytes +SIGNED LONG SIZE = 8 bytes + +std_ulogic_vector <= C++ string +------------------------------------------- +A = 01XZXXXXX "01XZUWLH-" +B = XX0XX1XXX "ZZ1XX0UU1WWW" +BIG = 11110000111100001111000011110000111100001111000011110000111100001111 + "11110000111100001111000011110000111100001111000011110000111100001111" +HUGE = 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111000011110000111100001111000011110000111100001111000011110000 + 1111 + +std_ulogic_vector <= std_ulogic_vector +-------------------------------------------------- +C = XX0XX1XXX ZZ1XX0XX1XXX +BIG2 = 11110000111100001111000011110000111100001111000011110000111100001111 + "11110000111100001111000011110000111100001111000011110000111100001111" + +std_ulogic_vector <= C++ array of bool +-------------------------------------------------- +D = XXXXZX10X -, L, H, W, Z, X, 1, 0, U +E = 10011XXXX X, X, 1, 1, 0, 0, 1, 1, X, X, U, U +BIG3 = 11110000111100001111000011110000111100001111000011110000111100001111 + "11110000111100001111000011110000111100001111000011110000111100001111 + 000011110000" + +std_ulogic_vector <= bool_vector +-------------------------------------------- +F = 1010 "1010" + +std_ulogic_vector <= unsigned long +---------------------------------------------- +H = 1001 ...10001001 (137) +I = 00000000000000000000000010001001 ...10001001 (137) +J = 0000000000000000000000000000000010001001 ...10001001 (137) + +std_ulogic_vector <= sc_unsigned +-------------------------------------------- +K = 0011 11 (3) +L = 1101 1101 (13) +M = 1001 10001001 (137) + +std_ulogic_vector <= signed long +-------------------------------------------- +N = 01001 ...010001001 (137) +O = 00000000000000000000000010001001 ...010001001 (137) +P = 0000000000000000000000000000000010001001 ...010001001 (137) +Q = 10111 ...101110111 (-137) +R = 11111111111111111111111101110111 ...101110111 (-137) +S = 1111111111111111111111111111111101110111 ...101110111 (-137) + +std_ulogic_vector <= sc_signed +------------------------------------------ +T = 00011 011 (3) +U = 01101 01101 (13) +V = 01001 010001001 (137) +W = 11101 101 (-3) +X = 10011 10011 (-13) +Y = 10111 101110111 (-137) + +std_ulogic_vector <= to_uint() +----------------------------------------------------------------- +TU1 = 1001 9 +TU2 = 10000000000000000000000000000001 2147483649 +TU3 = 0000000110000000000000000000000000000001 2147483649 +TU4 = 1101 1 (01) +TU4 = 1101 13 (1101) +TU4 = 1101 13 (00001101) + +std_ulogic_vector <= to_int() +----------------------------------------------------------------- +TS1 = 1001 -7 +TS2 = 11111111111111111111101111111001 -1031 +TS3 = 0000000111111111111111111111101111111001 -1031 +TS4 = 11001 1 (001) +TS4 = 11001 -7 (11001) +TS4 = 11001 -7 (111111001) + +std_ulogic_vector <= Typecast sc_unsigned +----------------------------------------------------------------- +TCU1 = 1101 1 (01) +TCU1 = 1101 13 (1101) +TCU1 = 1101 13 (00001101) + +std_ulogic_vector <= Typecast sc_signed +----------------------------------------------------------------- +TCS1 = 11001 1 (001) +TCS1 = 11001 -7 (11001) +TCS1 = 11001 25 (000011001) + +std_ulogic_vector <= to_string() +-------------------------------------------- +TSTR = XXZ01XXXX XXZ01XXXX + +range() tests +----------------------------------------------------------------- +INITIAL 4-BIT 1000 +INITIAL 9-BIT XXZ01XXXX + +LVALUE RISE 1 0 0 0 +LVALUE FALL 0 0 0 1 +LVALUE SUB RISE 0 1 0 0 +LVALUE SUB FALL X X X X 1 0 Z X X +LVALUE BIT 1 1 0 1 + +RVALUE RISE 1 0 0 0 +RVALUE FALL 0 0 0 1 +RVALUE SUB FALL X X X X 1 0 Z X X +RVALUE SUB RISE 1 0 0 0 +RVALUE BIT [] 1 0 1 1 +RVALUE BIT 0 0 1 0 + +op1 operator op2 result [All operands are std_ulogic_vector] +---------------------------------------------------------------- +1010 &= 1000 = 1000 +1010 ^= 1000 = 0010 +1010 |= 1000 = 1010 +~(1010) = 0101 +1010 & 1000 = 1000 +1010 ^ 1000 = 0010 +1010 | 1000 = 1010 + +1010 &= 111011 = 1010 +1010 ^= 111011 = 0001 +1010 |= 111011 = 1011 +1010 & 111011 = 1010 +1010 ^ 111011 = 0001 +1010 | 111011 = 1011 + +1010 and_reduce() = 0 +1010 or_reduce() = 1 +1010 xor_reduce() = 0 + +1010 == 1000 -> false +1010 != 1000 -> true + +1111 = 1111 + ++-------------------------+ +| AND (&) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | 0 | X | X | ++-------------------------+ +| 0 | 0 | 0 | 0 | 0 | ++-------------------------+ +| 1 | X | 0 | 1 | X | ++-------------------------+ +| Z | X | 0 | X | X | ++-------------------------+ + ++-------------------------+ +| OR (|) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | X | 1 | X | ++-------------------------+ +| 0 | X | 0 | 1 | X | ++-------------------------+ +| 1 | 1 | 1 | 1 | 1 | ++-------------------------+ +| Z | X | X | 1 | X | ++-------------------------+ + ++-------------------------+ +| XOR (^) | X | 0 | 1 | Z | ++-------------------------+ +| X | X | X | X | X | ++-------------------------+ +| 0 | X | 0 | 1 | X | ++-------------------------+ +| 1 | X | 1 | 0 | X | ++-------------------------+ +| Z | X | X | X | X | ++-------------------------+ + ++-------------------------+ +| NOT (~) | X | 0 | 1 | Z | ++-------------------------+ +| | X | 1 | 0 | X | ++-------------------------+ diff --git a/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_vector_datatype/std_ulogic_vector_datatype.cpp b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_vector_datatype/std_ulogic_vector_datatype.cpp new file mode 100644 index 000000000..f35433774 --- /dev/null +++ b/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/std_ulogic_vector_datatype/std_ulogic_vector_datatype.cpp @@ -0,0 +1,772 @@ +/***************************************************************************** + + Licensed to Accellera Systems Initiative Inc. (Accellera) under one or + more contributor license agreements. See the NOTICE file distributed + with this work for additional information regarding copyright ownership. + Accellera licenses this file to you under the Apache License, Version 2.0 + (the "License"); you may not use this file except in compliance with the + License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied. See the License for the specific language governing + permissions and limitations under the License. + + *****************************************************************************/ + +/***************************************************************************** + + std_ulogic_vector_datatype.cpp -- + + Original Author: Martin Janssen, Synopsys, Inc., 2002-02-15 + + *****************************************************************************/ + +/***************************************************************************** + + MODIFICATION LOG - modifiers, enter your name, affiliation, date and + changes you are making here. + + Name, Affiliation, Date: + Description of Modification: + + *****************************************************************************/ + +/* Main file for "std_ulogic_vector" data type */ + +#include "systemc.h" + +typedef sc_logic std_ulogic; + +#define std_ulogic_vector sc_lv +#define bool_vector sc_bv + +int sc_main(int ac, char *av[]) +{ + +// 0. SIZE OF TYPES + int integer; + short short_integer; + long long_integer; + unsigned long unsigned_long; + signed long signed_long; + + cout << "\nINTEGER SIZE \t\t= " << sizeof integer << " bytes" + << "\nSHORT INTEGER SIZE \t= " << sizeof short_integer << " bytes" + << "\nLONG INTEGER SIZE \t= " << sizeof long_integer << " bytes" + << "\nUNSIGNED LONG SIZE \t= " << sizeof unsigned_long << " bytes" + << "\nSIGNED LONG SIZE \t= " << sizeof signed_long << " bytes" + << "\n" << endl; + +// 1. DECLARATION SYNTAX + std_ulogic_vector<9> a; + std_ulogic_vector<9> b; + std_ulogic_vector<68> big; + std_ulogic_vector<1284> huge_; + +// 2. TYPE CONVERSION + + // std_ulogic_vector <- C++ string + a = "01XZUWLH-"; + b = "ZZ1XX0UU1WWW"; + big = "11110000111100001111000011110000111100001111000011110000111100001111"; + huge_ = "111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111000011110000111100001111"; + + cout << "std_ulogic_vector \t<=\t C++ string" + << "\n-------------------------------------------" + << "\nA = " << a << "\t\t \"01XZUWLH-\" " + << "\nB = " << b << "\t\t \"ZZ1XX0UU1WWW\" " + << "\nBIG = " << big << "\n " + <<"\"11110000111100001111000011110000111100001111000011110000111100001111\"" + << "\nHUGE = " << huge_.range(0,63) << "\n " + << huge_.range(64,127) << "\n " + << huge_.range(128,191) << "\n " + << huge_.range(192,255) << "\n " + << huge_.range(256,319) << "\n " + << huge_.range(320,383) << "\n " + << huge_.range(384,447) << "\n " + << huge_.range(448,511) << "\n " + << huge_.range(512,575) << "\n " + << huge_.range(576,639) << "\n " + << huge_.range(640,703) << "\n " + << huge_.range(704,767) << "\n " + << huge_.range(768,831) << "\n " + << huge_.range(832,895) << "\n " + << huge_.range(896,959) << "\n " + << huge_.range(960,1023) << "\n " + << huge_.range(1024,1087) << "\n " + << huge_.range(1088,1151) << "\n " + << huge_.range(1152,1215) << "\n " + << huge_.range(1216,1279) << "\n " + << huge_.range(1280,1283) + << "\n" << endl; + + // std_ulogic_vector <- std_ulogic_vector + std_ulogic_vector<9> c; + std_ulogic_vector<68> big2; + + c = b; + big2 = big; + + cout << "std_ulogic_vector \t<=\t std_ulogic_vector" + << "\n--------------------------------------------------" + << "\nC = " << c << "\t\t ZZ1XX0XX1XXX" + << "\nBIG2 = " << big2 << "\n " + <<"\"11110000111100001111000011110000111100001111000011110000111100001111\"" + << "\n" << endl; + + // std_ulogic_vector <- C++ array of std_ulogic + std_ulogic_vector<9> d; + std_ulogic_vector<9> e; + std_ulogic_vector<68> big3; + std_ulogic cb1[9] = { sc_logic( 'U' ), sc_logic( 0 ) , sc_logic( 1 ), + sc_logic( 'X' ), sc_logic( 'Z' ), sc_logic( 'W' ), + sc_logic( 'H' ), sc_logic( 'L' ), sc_logic( '-' ) }; + std_ulogic cb2[12] = { sc_logic( 'U' ), sc_logic( 'U' ), sc_logic( 'X' ), + sc_logic( 'X' ), sc_logic( 1 ) , sc_logic( 1 ), + sc_logic( 0 ) , sc_logic( 0 ) , sc_logic( 1 ), + sc_logic( 1 ) , sc_logic( 'X' ), sc_logic( 'X' ) }; + std_ulogic cb3[80] = { sc_logic( 1 ), sc_logic( 1 ), sc_logic( 1 ), + sc_logic( 1 ), sc_logic( 0 ), sc_logic( 0 ), + sc_logic( 0 ), sc_logic( 0 ), sc_logic( 1 ), + sc_logic( 1 ), sc_logic( 1 ), sc_logic( 1 ), + sc_logic( 0 ), sc_logic( 0 ), sc_logic( 0 ), + sc_logic( 0 ), sc_logic( 1 ), sc_logic( 1 ), + sc_logic( 1 ), sc_logic( 1 ), sc_logic( 0 ), + sc_logic( 0 ), sc_logic( 0 ), sc_logic( 0 ), + sc_logic( 1 ), sc_logic( 1 ), sc_logic( 1 ), + sc_logic( 1 ), sc_logic( 0 ), sc_logic( 0 ), + sc_logic( 0 ), sc_logic( 0 ), sc_logic( 1 ), + sc_logic( 1 ), sc_logic( 1 ), sc_logic( 1 ), + sc_logic( 0 ), sc_logic( 0 ), sc_logic( 0 ), + sc_logic( 0 ), sc_logic( 1 ), sc_logic( 1 ), + sc_logic( 1 ), sc_logic( 1 ), sc_logic( 0 ), + sc_logic( 0 ), sc_logic( 0 ), sc_logic( 0 ), + sc_logic( 1 ), sc_logic( 1 ), sc_logic( 1 ), + sc_logic( 1 ), sc_logic( 0 ), sc_logic( 0 ), + sc_logic( 0 ), sc_logic( 0 ), sc_logic( 1 ), + sc_logic( 1 ), sc_logic( 1 ), sc_logic( 1 ), + sc_logic( 0 ), sc_logic( 0 ), sc_logic( 0 ), + sc_logic( 0 ), sc_logic( 1 ), sc_logic( 1 ), + sc_logic( 1 ), sc_logic( 1 ), sc_logic( 0 ), + sc_logic( 0 ), sc_logic( 0 ), sc_logic( 0 ), + sc_logic( 1 ), sc_logic( 1 ), sc_logic( 1 ), + sc_logic( 1 ), sc_logic( 0 ), sc_logic( 0 ), + sc_logic( 0 ), sc_logic( 0 ) }; + + d = cb1; + e = cb2; + big3 = cb3; + + cout << "std_ulogic_vector \t<=\t C++ array of bool" + << "\n--------------------------------------------------" + << "\nD = " << d << "\t\t -, L, H, W, Z, X, 1, 0, U" + << "\nE = " << e << "\t\t X, X, 1, 1, 0, 0, 1, 1, X, X, U, U" + << "\nBIG3 = " << big3 << "\n " + <<"\"11110000111100001111000011110000111100001111000011110000111100001111" + <<"\n 000011110000\"" + << "\n" << endl; + + // std_ulogic_vector <- bool_vector + std_ulogic_vector<4> f; + bool_vector<4> sv1; + + sv1 = "1010"; + + f = sv1; + + cout << "std_ulogic_vector \t<=\t bool_vector" + << "\n--------------------------------------------" + << "\nF = " << f << "\t\t \"1010\" " + << "\n" << endl; + + // std_ulogic_vector <- unsigned long + std_ulogic_vector<4> h; + std_ulogic_vector<32> i; + std_ulogic_vector<40> j; + unsigned long ul1 = 137; // ...10001001 + unsigned long ul2 = 137; // ...10001001 + unsigned long ul3 = 137; // ...10001001 + + h = ul1; + i = ul2; + j = ul3; + + cout << "std_ulogic_vector \t<=\t unsigned long" + << "\n----------------------------------------------" + << "\nH = " << h << "\t\t\t\t\t ...10001001 (137)" + << "\nI = " << i << "\t\t ...10001001 (137)" + << "\nJ = " << j << "\t ...10001001 (137)" + << "\n" << endl; + + // std_ulogic_vector <- sc_unsigned + std_ulogic_vector<4> k; + std_ulogic_vector<4> l; + std_ulogic_vector<4> m; + sc_biguint<2> scu1; + sc_biguint<4> scu2; + sc_biguint<8> scu3; + + scu1 = 3; // .........11 + scu2 = 13; // .......1101 + scu3 = 137; // ...10001001 + + k = scu1; + l = scu2; + m = scu3; + + cout << "std_ulogic_vector \t<=\t sc_unsigned" + << "\n--------------------------------------------" + << "\nK = " << k << "\t\t 11 (3)" + << "\nL = " << l << "\t\t 1101 (13)" + << "\nM = " << m << "\t\t 10001001 (137)" + << "\n" << endl; + + // std_ulogic_vector <- signed long + std_ulogic_vector<5> n; + std_ulogic_vector<32> o; + std_ulogic_vector<40> p; + std_ulogic_vector<5> q; + std_ulogic_vector<32> r; + std_ulogic_vector<40> s; + signed long sl1 = 137; // ...010001001 + signed long sl2 = 137; // ...010001001 + signed long sl3 = 137; // ...010001001 + signed long sl4 = -137; // ...101110111 + signed long sl5 = -137; // ...101110111 + signed long sl6 = -137; // ...101110111 + + n = sl1; + o = sl2; + p = sl3; + q = sl4; + r = sl5; + s = sl6; + + cout << "std_ulogic_vector \t<=\t signed long" + << "\n--------------------------------------------" + << "\nN = " << n << "\t\t\t\t\t ...010001001 (137)" + << "\nO = " << o << "\t\t ...010001001 (137)" + << "\nP = " << p << "\t ...010001001 (137)" + << "\nQ = " << q << "\t\t\t\t\t ...101110111 (-137)" + << "\nR = " << r << "\t\t ...101110111 (-137)" + << "\nS = " << s << "\t ...101110111 (-137)" + << "\n" << endl; + + // std_ulogic_vector <- sc_signed + std_ulogic_vector<5> t; + std_ulogic_vector<5> u; + std_ulogic_vector<5> v; + std_ulogic_vector<5> w; + std_ulogic_vector<5> x; + std_ulogic_vector<5> y; + sc_bigint<3> scs1; + sc_bigint<5> scs2; + sc_bigint<9> scs3; + sc_bigint<3> scs4; + sc_bigint<5> scs5; + sc_bigint<9> scs6; + + scs1 = 3; // ........011 + scs2 = 13; // ......01101 + scs3 = 137; // ..010001001 + scs4 = -3; // ........101 + scs5 = -13; // ......10011 + scs6 = -137; // ..101110111 + + t = scs1; + u = scs2; + v = scs3; + w = scs4; + x = scs5; + y = scs6; + + cout << "std_ulogic_vector \t<=\t sc_signed" + << "\n------------------------------------------" + << "\nT = " << t << "\t\t 011 (3)" + << "\nU = " << u << "\t\t 01101 (13)" + << "\nV = " << v << "\t\t 010001001 (137)" + << "\nW = " << w << "\t\t 101 (-3)" + << "\nX = " << x << "\t\t 10011 (-13)" + << "\nY = " << y << "\t\t 101110111 (-137)" + << "\n" << endl; + + // std_ulogic_vector .to_uint() + std_ulogic_vector<4> tu1; + std_ulogic_vector<32> tu2; + std_ulogic_vector<40> tu3; + std_ulogic_vector<4> tu4; + sc_biguint<2> tu5; + sc_biguint<4> tu6; + sc_biguint<8> tu7; + + tu1 = "1001"; // 9 + tu2 = "10000000000000000000000000000001"; // 2147483649 + tu3 = "0000000110000000000000000000000000000001"; // 6442450945 + tu4 = "1101"; + tu5 = tu4.to_uint(); + tu6 = tu4.to_uint(); + tu7 = tu4.to_uint(); + + cout << "std_ulogic_vector \t\t<=\t\t to_uint()" + << "\n-----------------------------------------------------------------" + << "\nTU1 = \t\t\t\t " << tu1 << "\t " << tu1.to_uint() + << "\nTU2 = " << tu2 << "\t " << tu2.to_uint() + << "\nTU3 = " << tu3 << "\t " << tu3.to_uint() + << "\nTU4 = " << tu4 << " \t\t\t\t\t " << tu5 << "\t (" + << tu5[1] << tu5[0] << ")" + << "\nTU4 = " << tu4 << " \t\t\t\t\t " << tu6 << "\t (" + << tu6[3] << tu6[2] << tu6[1] << tu6[0] << ")" + << "\nTU4 = " << tu4 << " \t\t\t\t\t " << tu7 << "\t(" + << tu7[7] << tu7[6] << tu7[5] << tu7[4] + << tu7[3] << tu7[2] << tu7[1] << tu7[0] << ")" + << "\n" << endl; + + // std_ulogic_vector .to_int() + std_ulogic_vector<4> ts1; + std_ulogic_vector<32> ts2; + std_ulogic_vector<40> ts3; + std_ulogic_vector<5> ts4; + sc_bigint<3> ts5; + sc_bigint<5> ts6; + sc_bigint<9> ts7; + + ts1 = "1001"; // -7 + ts2 = "11111111111111111111101111111001"; // -1031 + ts3 = "0000000111111111111111111111101111111001"; // 8589933561 + ts4 = "11001"; + ts5 = ts4.to_int(); + ts6 = ts4.to_int(); + ts7 = ts4.to_int(); + + cout << "std_ulogic_vector \t\t<=\t\t to_int()" + << "\n-----------------------------------------------------------------" + << "\nTS1 = \t\t\t\t " << ts1 << "\t " << ts1.to_int() + << "\nTS2 = " << ts2 << "\t " << ts2.to_int() + << "\nTS3 = " << ts3 << "\t " << ts3.to_int() + << "\nTS4 = " << ts4 << " \t\t\t\t\t " << ts5 << "\t (" + << ts5[2] << ts5[1] << ts5[0] << ")" + << "\nTS4 = " << ts4 << " \t\t\t\t\t " << ts6 << "\t (" + << ts6[4] << ts6[3] << ts6[2] << ts6[1] << ts6[0] << ")" + << "\nTS4 = " << ts4 << " \t\t\t\t\t " << ts7 << "\t(" + << ts7[8] << ts7[7] << ts7[6] << ts7[5] + << ts7[4] << ts7[3] << ts7[2] << ts7[1] << ts7[0] << ")" + << "\n" << endl; + + // std_ulogic_vector Typecasted to sc_unsigned + std_ulogic_vector<4> tcu1; + sc_biguint<2> tcu2; + sc_biguint<4> tcu3; + sc_biguint<8> tcu4; + + tcu1 = "1101"; + tcu2 = tcu1; + tcu3 = tcu1; + tcu4 = tcu1; + + cout << "std_ulogic_vector \t\t<=\t\t Typecast sc_unsigned" + << "\n-----------------------------------------------------------------" + << "\nTCU1 = " << tcu1 << " \t\t\t\t\t " << tcu2 << "\t (" + << tcu2[1] << tcu2[0] << ")" + << "\nTCU1 = " << tcu1 << " \t\t\t\t\t " << tcu3 << "\t (" + << tcu3[3] << tcu3[2] << tcu3[1] << tcu3[0] << ")" + << "\nTCU1 = " << tcu1 << " \t\t\t\t\t " << tcu4 << "\t(" + << tcu4[7] << tcu4[6] << tcu4[5] << tcu4[4] + << tcu4[3] << tcu4[2] << tcu4[1] << tcu4[0] << ")" + << "\n" << endl; + + // std_ulogic_vector Typecasted to sc_signed + std_ulogic_vector<5> tcs1; + sc_bigint<3> tcs2; + sc_bigint<5> tcs3; + sc_bigint<9> tcs4; + + tcs1 = "11001"; + tcs2 = sc_bigint<3>(tcs1); + tcs3 = sc_bigint<5>(tcs1); + tcs4 = sc_bigint<9>(tcs1); + + cout << "std_ulogic_vector \t\t<=\t\t Typecast sc_signed" + << "\n-----------------------------------------------------------------" + << "\nTCS1 = " << tcs1 << " \t\t\t\t\t " << tcs2 << "\t (" + << tcs2[2] << tcs2[1] << tcs2[0] << ")" + << "\nTCS1 = " << tcs1 << " \t\t\t\t\t " << tcs3 << "\t (" + << tcs3[4] << tcs3[3] << tcs3[2] << tcs3[1] << tcs3[0] << ")" + << "\nTCS1 = " << tcs1 << " \t\t\t\t\t " << tcs4 << "\t(" + << tcs4[8] << tcs4[7] << tcs4[6] << tcs4[5] + << tcs4[4] << tcs4[3] << tcs4[2] << tcs4[1] << tcs4[0] << ")" + << "\n" << endl; + + // std_ulogic_vector .to_string() + std_ulogic_vector<9> tstr; + std::string str; + + tstr = "UXZ01WLH-"; + str = tstr.to_string(); + + cout << "std_ulogic_vector \t<=\t to_string()" + << "\n--------------------------------------------" + << "\nTSTR = " << tstr << " \t\t " << str + << endl; + + +// 3. OPERATORS +// Supported operators: ~ & ^ | &= ^= |= = [] range() +// and_reduce() or_reduce() xor_reduce() + std_ulogic_vector<4> ra; + std_ulogic_vector<4> rb; + std_ulogic_vector<4> rc; + std_ulogic_vector<9> rd; + std_ulogic_vector<4> re; + std_ulogic_vector<4> rf; + std_ulogic_vector<4> rg; + std_ulogic_vector<9> rh; + std_ulogic_vector<4> ri; + std_ulogic_vector<4> rj; + std_ulogic_vector<4> rl; + + std_ulogic_vector<4> rdata4; + std_ulogic_vector<9> rdata9; + + rdata4 = "1000"; + rdata9 = "UXZ01WHL-"; + + ra.range(0,3) = rdata4; + rb.range(3,0) = rdata4; + ( rc.range(1,3), rc.range(0,0) ) = rdata4; + ( rd.range(8,6), rd.range(5,0) ) = rdata9; + re = "1111"; + re.range(2,2) = std_ulogic_vector<1>( rdata4[1] ); + + rf = rdata4.range(0,3); + rg = rdata4.range(3,0); + rh = ( rdata9.range(8,6), rdata9.range(5,0) ); + ri = ( rdata4.range(0,1), rdata4.range(2,3) ); + rj = "1111"; + rj[1] = rdata4.range(2,2)[0]; + rl = ( rdata4.range(1,1), rdata4.range(3,3), + rdata4.range(0,0), rdata4.range(2,2) ); + + cout.precision(15); + cout << "\nrange() tests" + << "\n-----------------------------------------------------------------" + << "\nINITIAL 4-BIT \t" << rdata4 + << "\nINITIAL 9-BIT \t" << rdata9 << "\n" + << "\nLVALUE RISE \t" + << ra[0] << "\t" << ra[1] << "\t" << ra[2] << "\t" << ra[3] + << "\nLVALUE FALL \t" + << rb[0] << "\t" << rb[1] << "\t" << rb[2] << "\t" << rb[3] + << "\nLVALUE SUB RISE " + << rc[0] << "\t" << rc[1] << "\t" << rc[2] << "\t" << rc[3] + << "\nLVALUE SUB FALL " + << rd[0] << "\t" << rd[1] << "\t" << rd[2] << "\t" + << rd[3] << "\t" << rd[4] << "\t" << rd[5] << "\t" + << rd[6] << "\t" << rd[7] << "\t" << rd[8] + << "\nLVALUE BIT \t" + << re[0] << "\t" << re[1] << "\t" << re[2] << "\t" << re[3] + << "\n\nRVALUE RISE \t" + << rf[0] << "\t" << rf[1] << "\t" << rf[2] << "\t" << rf[3] + << "\nRVALUE FALL \t" + << rg[0] << "\t" << rg[1] << "\t" << rg[2] << "\t" << rg[3] + << "\nRVALUE SUB FALL " + << rh[0] << "\t" << rh[1] << "\t" << rh[2] << "\t" + << rh[3] << "\t" << rh[4] << "\t" << rh[5] << "\t" + << rh[6] << "\t" << rh[7] << "\t" << rh[8] + << "\nRVALUE SUB RISE " + << ri[0] << "\t" << ri[1] << "\t" << ri[2] << "\t" << ri[3] + << "\nRVALUE BIT [] \t" + << rj[0] << "\t" << rj[1] << "\t" << rj[2] << "\t" << rj[3] + << "\nRVALUE BIT \t" + << rl[0] << "\t" << rl[1] << "\t" << rl[2] << "\t" << rl[3] + << endl; + +#define VAL1 "1010" +#define VAL2 "1000" +#define VAL3 "111011" + + std_ulogic_vector<4> op1; + op1 = VAL1; + std_ulogic_vector<4> op2; + op2 = VAL2; + std_ulogic_vector<4> r1, r2, r3, r4, r5, r6, r7, r8; + std_ulogic_vector<4> r9, r10, r11, r12, r13, r14; + std_ulogic_vector<4> r15, r16, r17, r18, r19; + std_ulogic_vector<4> r20, r21, r22, r23, r24; + std_ulogic_vector<4> r25, r26, r27, r28, r29; + std_ulogic_vector<4> r30, r31, r32, r33, r34, r35; + std_ulogic_vector<4> r36, r37, r38, r39, r40, r41; + std_ulogic r42, r43, r44; + +// r1 = op1 * op2; // Multiplication + +// r2 = op1 / op2; // Division + +// r3 = op1 % op2; // Modulus + +// r4 = op1 + op2; // Addition + +// r5 = op1 - op2; // Subtraction + +// r6 = !op1; // Logical NOT + +// r7 = op1 && op2; // Logical AND + +// r8 = op1 || op2; // Logical OR + +// r9 = op1 < op2; // Less than + +// r10 = op1 <= op2; // Less than or equal + +// r11 = op1 > op2; // Greater than + +// r12 = op1 >= op2; // Greater than or equal + +// r13 = op1 += op2; // Compound addition +// op1 = VAL1; op2 = VAL2; + +// r14 = op1 -= op2; // Compound subtraction +// op1 = VAL1; op2 = VAL2; + +// r15 = op1 *= op2; // Compound multiplication +// op1 = VAL1; op2 = VAL2; + +// r16 = op1 /= op2; // Compound division +// op1 = VAL1; op2 = VAL2; + +// r17 = op1 %= op2; // Compound modulus +// op1 = VAL1; op2 = VAL2; + +// r18 = op1 <<= op2; // Compound shift left +// op1 = VAL1; op2 = VAL2; + +// r19 = op1 >>= op2; // Compound shift right +// op1 = VAL1; op2 = VAL2; + + r20 = op1 &= op2; // Compound bitwise AND + op1 = VAL1; op2 = VAL2; + r36 = op1 &= VAL3; + op1 = VAL1; + + r21 = op1 ^= op2; // Compound bitwise XOR + op1 = VAL1; op2 = VAL2; + r37 = op1 ^= VAL3; + op1 = VAL1; + + r22 = op1 |= op2; // Compound bitwise OR + op1 = VAL1; op2 = VAL2; + r38 = op1 |= VAL3; + op1 = VAL1; + +// r23 = op2++; // Postfix increment +// op1 = VAL1; op2 = VAL2; + +// r24 = ++op2; // Prefix increment +// op1 = VAL1; op2 = VAL2; + +// r25 = op2--; // Postfix decrement +// op1 = VAL1; op2 = VAL2; + +// r26 = --op2; // Prefix decrement +// op1 = VAL1; op2 = VAL2; + +// r27 = (op1 > op2) ? true : false; // Arithmetic if +// r28 = (op1 < op2) ? true : false; // Arithmetic if + +// r29 = op1, r29 = op2; // Comma + + r30 = ~op1; // Bitwise NOT + +// r31 = op1 << op2; // Left shift +// op1 = VAL1; op2 = VAL2; + +// r32 = op1 >> op2; // Right shift +// op1 = VAL1; op2 = VAL2; + + r33 = op1 & op2; // Bitwise AND + r39 = op1 & VAL3; + + r34 = op1 ^ op2; // Bitwise XOR + r40 = op1 ^ VAL3; + + r35 = op1 | op2; // Bitwise OR + r41 = op1 | VAL3; + + r42 = and_reduce(op1); // AND reduction + + r43 = or_reduce(op1); // OR reduction + + r44 = xor_reduce(op1); // XOR reduction + +cout << "\nop1\t operator\t op2\t result [All operands are std_ulogic_vector]" + << "\n----------------------------------------------------------------" +// << "\n" << op1 << "\t * \t\t " << op2 << "\t = " << r1 +// << "\n" << op1 << "\t / \t\t " << op2 << "\t = " << r2 +// << "\n" << op1 << "\t % \t\t " << op2 << "\t = " << r3 +// << "\n" << op1 << "\t + \t\t " << op2 << "\t = " << r4 +// << "\n" << op1 << "\t - \t\t " << op2 << "\t = " << r5 +// << "\n!(" << op1 << ") \t\t\t\t = " << r6 +// << "\n" << op1 << "\t && \t\t " << op2 << "\t = " << r7 +// << "\n" << op1 << "\t || \t\t " << op2 << "\t = " << r8 +// << "\n" << op1 << "\t < \t\t " << op2 << "\t = " << r9 +// << "\n" << op1 << "\t <= \t\t " << op2 << "\t = " << r10 +// << "\n" << op1 << "\t > \t\t " << op2 << "\t = " << r11 +// << "\n" << op1 << "\t >= \t\t " << op2 << "\t = " << r12 +// << "\n" << op1 << "\t += \t\t " << op2 << "\t = " << r13 +// << "\n" << op1 << "\t -= \t\t " << op2 << "\t = " << r14 +// << "\n" << op1 << "\t *= \t\t " << op2 << "\t = " << r15 +// << "\n" << op1 << "\t /= \t\t " << op2 << "\t = " << r16 +// << "\n" << op1 << "\t %= \t\t " << op2 << "\t = " << r17 +// << "\n" << op1 << "\t <<=\t\t " << op2 << "\t = " << r18 +// << "\n" << op1 << "\t >>=\t\t " << op2 << "\t = " << r19 + << "\n" << op1 << "\t &= \t\t " << op2 << "\t = " << r20 + << "\n" << op1 << "\t ^= \t\t " << op2 << "\t = " << r21 + << "\n" << op1 << "\t |= \t\t " << op2 << "\t = " << r22 +// << "\n" << "\t ()++ \t " << op2 << "\t = " << r23 +// << "\n" << "\t ++() \t " << op2 << "\t = " << r24 +// << "\n" << "\t ()-- \t " << op2 << "\t = " << r25 +// << "\n" << "\t --() \t " << op2 << "\t = " << r26 +// << "\n" << op1 << "\t > ?: \t " << op2 << "\t = " << r27 +// << "\n" << op1 << "\t < ?: \t " << op2 << "\t = " << r28 +// << "\n" << op1 << "\t , \t\t " << op2 << "\t = " << r29 + << "\n~(" << op1 << ") \t\t\t = " << r30 +// << "\n" << op1 << "\t << \t\t " << op2 << "\t = " << r31 +// << "\n" << op1 << "\t >> \t\t " << op2 << "\t = " << r32 + << "\n" << op1 << "\t & \t\t " << op2 << "\t = " << r33 + << "\n" << op1 << "\t ^ \t\t " << op2 << "\t = " << r34 + << "\n" << op1 << "\t | \t\t " << op2 << "\t = " << r35 + << "\n\n" << op1 << "\t &= \t\t " << VAL3 << "\t = " << r36 + << "\n" << op1 << "\t ^= \t\t " << VAL3 << "\t = " << r37 + << "\n" << op1 << "\t |= \t\t " << VAL3 << "\t = " << r38 + << "\n" << op1 << "\t & \t\t " << VAL3 << "\t = " << r39 + << "\n" << op1 << "\t ^ \t\t " << VAL3 << "\t = " << r40 + << "\n" << op1 << "\t | \t\t " << VAL3 << "\t = " << r41 + << "\n\n" << op1 << "\t and_reduce() \t = " << r42 + << "\n" << op1 << "\t or_reduce() \t = " << r43 + << "\n" << op1 << "\t xor_reduce() \t = " << r44 + << endl; + + if (op1 == op2) // Equality + cout << "\n" << op1 << "\t == \t\t " << op2 << "\t -> true" << endl; + else + cout << "\n" << op1 << "\t == \t\t " << op2 << "\t -> false" << endl; + + if (op1 != op2) // Inequality + cout << op1 << "\t != \t\t " << op2 << "\t -> true" << endl; + else + cout << op1 << "\t != \t\t " << op2 << "\t -> false" << endl; + + op1 = op2 = "1111"; // Assignment operator concatenation + cout << "\n" << op1 << "\t = \t\t " << op2 << endl; + + +// 4. OPERATOR DEFINITIONS +// & | ^ ~ + std_ulogic_vector<9> suv; + std_ulogic_vector<9> vu; + std_ulogic_vector<9> vx; + std_ulogic_vector<9> v0; + std_ulogic_vector<9> v1; + std_ulogic_vector<9> vz; + std_ulogic_vector<9> vw; + std_ulogic_vector<9> vl; + std_ulogic_vector<9> vh; + std_ulogic_vector<9> vd; + std_ulogic_vector<9> bang; + + suv = "UX01ZWLH-"; + + vu = "UUUUUUUUU" & suv; + vx = "XXXXXXXXX" & suv; + v0 = "000000000" & suv; + v1 = "111111111" & suv; + vz = "ZZZZZZZZZ" & suv; + vw = "WWWWWWWWW" & suv; + vl = "LLLLLLLLL" & suv; + vh = "HHHHHHHHH" & suv; + vd = "---------" & suv; + + cout << "\n+-------------------------+" + << "\n| AND (&) | X | 0 | 1 | Z |" + << "\n+-------------------------+" + << "\n| X | " << vx[7] << " | " << vx[6] << " | " + << vx[5] << " | " << vx[4] << " | " + << "\n+-------------------------+" + << "\n| 0 | " << v0[7] << " | " << v0[6] << " | " + << v0[5] << " | " << v0[4] << " | " + << "\n+-------------------------+" + << "\n| 1 | " << v1[7] << " | " << v1[6] << " | " + << v1[5] << " | " << v1[4] << " | " + << "\n+-------------------------+" + << "\n| Z | " << vz[7] << " | " << vz[6] << " | " + << vz[5] << " | " << vz[4] << " | " + << "\n+-------------------------+" + << endl; + + vu = "UUUUUUUUU" | suv; + vx = "XXXXXXXXX" | suv; + v0 = "000000000" | suv; + v1 = "111111111" | suv; + vz = "ZZZZZZZZZ" | suv; + vw = "WWWWWWWWW" | suv; + vl = "LLLLLLLLL" | suv; + vh = "HHHHHHHHH" | suv; + vd = "---------" | suv; + + cout << "\n+-------------------------+" + << "\n| OR (|) | X | 0 | 1 | Z |" + << "\n+-------------------------+" + << "\n| X | " << vx[7] << " | " << vx[6] << " | " + << vx[5] << " | " << vx[4] << " | " + << "\n+-------------------------+" + << "\n| 0 | " << v0[7] << " | " << v0[6] << " | " + << v0[5] << " | " << v0[4] << " | " + << "\n+-------------------------+" + << "\n| 1 | " << v1[7] << " | " << v1[6] << " | " + << v1[5] << " | " << v1[4] << " | " + << "\n+-------------------------+" + << "\n| Z | " << vz[7] << " | " << vz[6] << " | " + << vz[5] << " | " << vz[4] << " | " + << "\n+-------------------------+" + << endl; + + vu = "UUUUUUUUU" ^ suv; + vx = "XXXXXXXXX" ^ suv; + v0 = "000000000" ^ suv; + v1 = "111111111" ^ suv; + vz = "ZZZZZZZZZ" ^ suv; + vw = "WWWWWWWWW" ^ suv; + vl = "LLLLLLLLL" ^ suv; + vh = "HHHHHHHHH" ^ suv; + vd = "---------" ^ suv; + + cout << "\n+-------------------------+" + << "\n| XOR (^) | X | 0 | 1 | Z |" + << "\n+-------------------------+" + << "\n| X | " << vx[7] << " | " << vx[6] << " | " + << vx[5] << " | " << vx[4] << " | " + << "\n+-------------------------+" + << "\n| 0 | " << v0[7] << " | " << v0[6] << " | " + << v0[5] << " | " << v0[4] << " | " + << "\n+-------------------------+" + << "\n| 1 | " << v1[7] << " | " << v1[6] << " | " + << v1[5] << " | " << v1[4] << " | " + << "\n+-------------------------+" + << "\n| Z | " << vz[7] << " | " << vz[6] << " | " + << vz[5] << " | " << vz[4] << " | " + << "\n+-------------------------+" + << endl; + + bang = ~suv; + + cout << "\n+-------------------------+" + << "\n| NOT (~) | X | 0 | 1 | Z |" + << "\n+-------------------------+" + << "\n| | " << bang[7] << " | " << bang[6] << " | " + << bang[5] << " | " << bang[4] << " | " + << "\n+-------------------------+" + << endl; + return 0; +} |