xref: /gem5/src/systemc/tests/systemc/misc/unit/data/user_guide/ch9/int_datatype/int_datatype.cpp

/*****************************************************************************

  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;
}