[SOLVED] CS compiler OSU CSE 2421

OSU CSE 2421
Required Reading:
Computer Systems: A Programmers Perspective, 3rd Edition, Chapter 2 thru Section 2.1.2
J.E.Jones

OSU CSE 2421
<< left-shift>> right-shift
& bitwise AND Bitwise operators
| bitwise OR
^ bitwise exclusive-OR
~ bitwise NOT (complement, not negation)
BITWISE OPERATORS: 0 is 0
1 is 1
&& logical AND
|| logical OR Logical operators ! logical NOT
LOGICAL OPERATORS: 0 is FALSE
Everything else is TRUE Practical Result:
< less than> greater than
<= less than or equal >= greater than or equal == equals
!= does not equal
relational operators
0 if false; 1 if true
Note 1: Bitwise operators evaluate same bit positions in two different operands. Like T/F tables in CSE 2321
Note 2: Logical operators evaluate an expression on each side of the operator, give that expression a value of 1(true) or 0 (false), then perform the logical operation on the whole
Note 3: C has no keywords such as true or false, #defines are used
Note 4: OR, AND, and NOT: Behave differently between bitwise and logical operators.
J. E. Jones

OSU CSE 2421
a & c
a=10=1010b c= 0=0000b –
a=10=1010b c= 1=0001b –
a=10=1010b c= 3=0011b –
Bitwise (each column of bits is individually combined)
0000b 010
0000b 010
0010b 210
a && c
a=True c=False False
a=True c=True True
a=True c=True True
Logical (value expression is combined)
int a = 10; int c = 0;
int a = 10; int c = 1;
int a = 10; int c = 3;
Does this remind anyone of Foundations I? It should.
J. E. Jones

OSU CSE 2421
a | c
a=10=1010b c= 0=0000b –
a=10=1010b c= 1=0001b –
a=10=1010b c= 3=0011b –
Bitwise (each column of bits is individually combined)
1010b 1010
1011b 1110
1011b 1110
a || c
a=True c=False True
a=True c=True True
a=True c=True True
Logical (value
of expression is
combined)
.
int a = 10; int c = 0;
int a = 10; int c = 1;
int a = 10; int c = 3;
J. E. Jones

OSU CSE 2421
a ^ c
a=10=1010b c= 0=0000b –
a=10=1010b c= 1=0001b –
a=10=1010b c= 3=0011b –
Bitwise (each column of bits is individually combined)
1010b
1011b
1001b
int a = 10; int c = 0;
int a = 10; int c = 1;
int a = 10; int c = 3;
1010
910 The C Programming Language does not define a logical exclusive OR
1110
J. E. Jones

OSU CSE 2421
~a
a=10=1010b –
Bitwise (each column of bits is individually changed)
0101b
!a
610 a=True
Logical (value of expression is combined)
False
int a = 10;
J. E. Jones

OSU CSE 2421
When we represent values in binary, we can do what is called shifting bits either to the right or to the left.
Left shift example: Binary value:
0111 0101
01 1101 0100 (fill with 0s)
Left shift 2 places: Bucket
Bit
The Bit Bucket is a fictitious, but often used item
J. E. Jones

OSU CSE 2421
Shifting to the right has 2 options:
Arithmetic shift typically used when interpreting as signed values Logical shift typically used when interpreting as unsigned values
Shift Right Arithmetic
Fills in from the left with copy of Most Significant Bit Preserves the sign of the value
Used when interpreting the value as B2T
Binaryvalue:
Shift Right Arithmetic 1 bit: Shift Right Arithmetic 2 bits:
11110101 1111 1010 1111 1101
1
If the MSB had been 0, then new bits would be 0s
01
Bit Bucket
Shift Right Logical
Fills in from the left with 0s
Used when interpreting the binary value as B2U
1
01
Binaryvalue:
Shift Right Logical 1 bit: Shift Right Logical 2 bits:
11110101 0111 1010 0011 1101
The Bit Bucket is a fictitious, but often used item
J. E. Jones

OSU CSE 2421
Used to compare two values
< <= > >= (Higher precedence than == and !=) == !=
Precedence order is given above, L-R associativity
Arithmetic operators have higher precedence than relational
operators
An expression that is TRUE evaluates to a nonzero number
(generally 1). A FALSE expression evaluates to zero.
For example, the expression (0 == 2) evaluates to 0.
while the expression (2 == 2) evaluates to a 1 (non-zero technically, but usually 1).
J. E. Jones

OSU CSE 2421
ANSI C does not have a distinct Boolean type
int is used instead (usually, but other types are possible)
0 is treated as FALSE
Non-zero is treated as TRUE i = 0;
while (i 10) {
i = i + 1; }
As long as (i-10) 0, it is considered TRUE, and the body of the while loop will execute.
(Later versions of C have Boolean type)
J. E. Jones

OSU CSE 2421
ANSI C does not have a distinct Boolean type
int is used instead (usually, but other types are possible)
0 is treated as FALSE
Non-zero is treated as TRUE i = 0;
while (i 10) {
}
i = i + 3; /* what happens here? */
As long as (i-10) 0, it is considered TRUE, and the body of the while loop will execute.
(Later versions of C have Boolean type)
J. E. Jones

OSU CSE 2421
Short-Circuit Evaluation: Relational statements stop evaluating once a statements value is definitive
In (x && y), if 1st condition evaluates to false (e.g., if expression x==0), evaluation stops
It does not matter what the outcome of the y expression is because (x && y) will always evaluate to false. y is not evaluated or compared (i.e., instructions in y expression are not executed)
Same for OR if first expression evaluates to 1 (TRUE).
This can cause buggy code (or not!)
This is a valid way to write code
There are many arguments made that it can be a correct and expedient way to write some code
Be very cautious
J. E. Jones

OSU CSE 2421
Short-Circuit Evaluation:
func1(float a, float b){
if ((b != 0.0f) && (a/b < 0.5f)){printf( The result of func1 is %f.4
, ((a*b) + (a/b))); }else {printf( The result of func1 is undefined.
);}return; }In this example, short-circuit evaluation saves your bacon!Without short-circuit, this code will seg fault when b=0.0f and a/b is computed.NOTE: (b !=0.0f) and (a/b< 0.5f) are logical expressions and have values of TRUE or FALSE.J. E. Jones OSU CSE 2421 Short-Circuit Evaluation:func1(int a, int b){int func_result = 1;if ((b == 0) && ((func_result = (++a*b+3)))){printf( The result of func1 is %d
, a*func_result); }return;In this example, short-circuit evaluation might cause you problems because the variable a and func_result sometimes change value in the 2nd expression.NOTE: (b==0) and ((func_result = (++a*b+))) are logical expressions and have values of TRUE or FALSE.J. E. Jones OSU CSE 2421 Type casting EXPLICIT You purposely convert a variable from one data type to another data type inyour code Syntax: (type-name) variable Type combination and promotion – IMPLICIT type casting (a32)=9732=65(ifusedasachar=a) Smaller type (char) is promoted to be the same size as the larger type (int),remember that constants default to int. Determined at compile time type of the whole expression is based purelyon the types of the values in the expressions Does not lose information convert from type to compatible larger type Whether the casting is implicit or explicit, the compiler will create separate storage for the cast value, and any operands that are necessary to determine it. [See next slide for example]32J. E. Jones OSU CSE 2421The usual arithmetic conversions are implicitly performed to cast values of distinct types to a common type.-Compiler first performs integer promotion (promotion of char to int)-short data type is ignored-If operands still have different types, then any variables or constants in operand expressions are converted to the type that appears highest in the following hierarchy (except any variables that were already of that type; for those, no conversion is necessary)J. E. Jones OSU CSE 2421 The following code is supposed to scale a homework score in the range 0-20 to be in the range 0-100.cnvt_score(){int score;/* score gets set in the range 0<=score <=20 */ score = (score / 20) * 100; /*convert toreturn(score); }Does this work?percentage*/J. E. Jones OSU CSE 2421 This does not work! Unfortunately, score will almost always be set to 0 for this code because the integer division in the expression (score/20) will be 0 for every value of score less than 20. Thefixistoforcethequotienttobecomputedasafloating-point number even though it will truncate to an int when assigned to scorescore = ((double)score / 20) * 100; /*OK double floating-point division with explicit cast */score = (score / 20.0) * 100; /*OK double floating-point division with implicit casting because float (double) constant 20.0 */score = (int)(score / 20.0) * 100; /*NO — the (int)cast truncates the floating quotient back to 0 if score < 20 prior to multiplication */35J. E. Jones