3.1 The C Language

S07: The C Language

Required: PM: Ch 6, pgs 63-80PM: Ch 8.4, pgs 114-118

Recommended: K&R, Chapters 1-4 C programC++ Compiler 6.5 VariablesGlobal Variables ExpressionsOperators Control StatementsFunctions Library Functions

int i;main(){for(;i["]<i;++i){--i;}"];read('-'-'-',i+++"hell\ o, world!\\n",'/'/'/'));}read(j,i,p){write(j/p+p,i---j,i/i);}

-- Dishonorable mention, Obfuscated C Code Contest, 1984. (Author requested anonymity.)

CS 224

BYU CS 224 The C Language 2

Chapter Project HomeworkS00: Introduction

Unit 1: Digital LogicS01: Data TypesS02: Digital Logic

L01: Warm-upL02: FSM

HW01HW02

Unit 2: ISAS03: ISAS04: MicroarchitectureS05: Stacks / InterruptsS06: Assembly

L03: BlinkyL04: MicroarchL05b: Traffic LightL06a: Morse Code

HW03HW04HW05HW06

Unit 3: CS07: C LanguageS08: PointersS09: StructsS10: I/O

L07b: Morse IIL08a: LifeL09a: Pong

HW07HW08HW09HW10

Learning Objectives…

Learning OutcomesAfter completing this section, you should be able to Discuss the advantages of using a

high level language. Explain the difference between a

compiler and an interpreter. Summarize the function of the C

preprocessor. Describe the compile/assembly/linker

process. List the main features of a C

Language program. Describe how C stream I/O works.


Topics Compilers vs. Interpreters C Program

Symbol Table Variables & Operators Scope Expressions Precedence C Compilation

Frames C / Assembler Coding Practices I/O Streams

Terms… Activation Record – A block of memory on the stack that is created when a function is

called and contains all the local variables for a given invocation of a function. Arithmetic Operator – Operator that returns a numerical value. Associativity – The execution order of same precedence operators. Bitwise Operator – Operator that performs bitwise logical operations. Data type – Representation and valid operations of data object. Expression – Combination of variables / operators that returns a single value. Global (static) – Variable permanently assigned to a memory location. Literal – An immutable data object. Local (automatic) – Variable stored in a functions activation record. Logical Operator – Operator that returns a logical (true/false) value. Operator – Performs an operation on operand(s). Scope - Extent of a variable/function’s availability in a program. Precedence – The execution order of operators. Variable - Symbolic name for a memory location that hold a value. Variable Coercion – Forcing mixed data type variables to a common type. Volatile – Variable modifier that prohibits optiminization by compiler.



Levels of AbstractionProblems

Algorithms

Language

Machine (ISA) Architecture

Microarchitecture

Circuits

Devices Transistors

Logic gates, multiplexers, memory, etc.

MSP430 Architecture

Machine code

Assembly code

High Level Languages


High Level Languages The closer a language is to your original specification, the

easier the program is to write. Many, many programming languages

LISP - LISt Processing PROLOG - logic programming MATLAB - matrix and vector manipulations BASIC – interpreter for small computers APL – matrix and vectors FORTRAN – formula translation COBOL – business and accounting PASCAL – procedural Ada – DOD large systems Java – Internet C, C++ ….



High Level Languages Allow us to use symbolic names for values

Programmer simply assigns each value a name Allow us to ignore many memory details.


numberOfDays = 30;switch_A = ON;

printf("Hello World!");

Provide abstraction of underlying hardware Hide low level details (ISA) from programmer Portable software (works on different ISAs)

Provide expressiveness Express complex tasks with smaller amount of code English-like and human constructs if(isCloudy)

get(umbrella);else get(sunglasses);

main(){ readInput(); checkForErrors(); doCalculation(); writeOutput();}

Enhance code readability Can read like a novel… Easier to debug/maintain


High Level Languages Provide safeguards against bugs

Rules can lead to well-formed programs structured programming (no GOTO statements)

Compilers can generate checks array bounds checking data type checking

Many languages provide explicit support for assertions something that should be true - if it isn’t, then error


assert(accountBalance >= 0);

High-level languages make complex programming simpler, while low-level languages tend to produce more efficient code

However, well-designed compilers frequently produce code comparable in efficiency to what most low-level programmers can produce by hand with better overall results


Compilers vs Interpreters

temp=v[i];v[i]=v[i+1];v[i+1]=temp;

High-levellanguagestatements

Com

pile

rMOV.B 0x0001(SP),R14MOV.W SP,R15INCD.W R15ADD.W R15,R14MOV.B @R14,0x0000(SP)MOV.B 0x0001(SP),R14INC.W R14

Assembly

Ass

embl

er

415E 0001410F532F5F0E4EE1 0000415E 0001531E

Objectcode

App

licat

ion

= Executable = Data Path

temp=v[i];v[i]=v[i+1];v[i+1]=temp;

Sourcecode

Inte

rpre

ter

Compilers vs Interpreters


The C Programming Language Developed between 1969 and 1973 by Dennis Ritchie at

Bell Labs. C first developed for use in writing compilers and

operating systems (UNIX). A low-level high-level language Many variants of C 1989, the American National Standards Institute standardized C

(ANSI C, most commonly used C) “The C Programming Language” by Kernighan and Ritchie is the

C “Bible” (Also called the “White Book”.) C is one of the most popular programming languages of

all time – very few computer architectures exist for which there is no C.

C is predecessor to most of today’s procedural languages such as C++ and Java.

The C Language


Dennis Ritchie (1940-2011) Dennis Ritchie, the software developer who brought the

world the C programming language and Unix operating system, has died at the age of 70.

Ritchie (known by the username "dmr") was part of a dynamic software development duo with Ken Thompson at Bell Labs,, which they joined in 1967 and 1966, respectively. Ritchie created the C programming language, which replaced the B programming language Thompson invented.

Two years later in 1969, they created Unix, initially designed for minicomputers. Unix was initially written in 1969 in assembly language and later in C. Unix went on to become key software for critical computing infrastructure around the world.

“UNIX is very simple, it just needs a genius to understand its simplicity.”

--Dennis Ritchie


Compiling a C ProgramThe C Language

Object Code

Assembler Code

C/C++ Code

Machine Code



Preprocessor Text

C Source Code

C Preprocessor

Library & ObjectFiles

ExecutableImage

Linker

C Compiler

Source CodeAnalysis

1st Pass

SymbolTable

Assembler

CodeGeneration

2nd Pass

Preprocessed C source code

Assembly CodeObject Code

Machine Code


A First Program

//************************************// blinky.c: Software Toggle P1.0//************************************#include "msp430.h"

volatile unsigned int i; // no optimizationvoid main(void){ WDTCTL = WDTPW | WDTHOLD; // stop watchdog P4DIR |= 0x40; // P4.6 output for (;;) // loop { P4OUT ^= 0x40; // toggle P4.6 while (--i); // delay }}

1st C Program

Tells compiler to use all the definitions found in the msp430.h library. A .h file is called a header file and contains definitions and declarations.All C programs must have a main()

routine.

Stop WD w/Password

Set P4.6 as outputLoop forever

Toggle P4.6Delay 65,536

Allocate a RAM variable(.bss i,2)


Style Use lots of comments

/* This is a comment */ // This is a single line comment

C Style

Indents Each new scope is indented 2 spaces from previous Put { on end of previous line, or start of next line Line matching } up below

Style is something of a personal matter.

Everyone has their own opinions…

What is presented here is similar to that in common use and a good place to start...

if(a < b) { b = a; a = 0; } else { a = b; b = 0; }

Style 1 if(a < b) { b = a; a = 0; } else { a = b; b = 0; }

Style 2


The C Preprocessor #define symbol code

The preprocessor replaces symbol with code everywhere it appears in the program below#define NUMBER_OF_MONKEYS 259#define MAX_LENGTH 80#define PI 3.14159

#include filename.h The preprocessor replaces the #include directive itself with the contents of

header file filename.h#include <stdio.h> /* a system header file */#include "myheader.h" /* a user header file */

Macros

C Preprocessor

#define add(x,y) x+=y#define doLoop(x,y) do {x} while(y);doLoop(add(z,2),z<10) do {z+=2} while(z<10);

A C Program What is a C program?

Functions Global variables

Variables are symbolic names for memory locations that hold values

2 types of variables Local (automatic) Global (static)

Variable declarations include A symbolic name Data type (int, char, double) Scope (code region where the variable is defined)

Variables are stored in memory or in registers. The compiler keeps track of where a variable’s value is currently

stored. Operators manipulate values


C Program

The C Symbol Table The C compiler keeps track of variables in a program

during compilation in a symbol table A symbol table entry is created when a variable is

declared. Specifically, each symbol table entry contains:

Variable name Variable data type (int, float, char, etc.) Variable storage class (auto, static) Where in memory the variable is stored (an offset) An identifier to indicate the variable’s scope

Variables must be declared and in scope before they can be used (referenced) by a program


Variables & Operators



Preprocessor Text

C Source Code

Library & ObjectFiles

ExecutableImage

Linker

C Compiler

Source CodeAnalysis

1st Pass

SymbolTable

Assembler

CodeGeneration

2nd Pass

Preprocessed C source code

Assembly CodeObject Code

Machine Code

C Preprocessor

MSP430 C Variable Data TypesType Size Representation Minimum Maximum

char, signed char 8 bits ASCII -128 127unsigned char bool 8 bits ASCII 0 255short, signed short 16 bits 2's complement -32768 32767unsigned short 16 bits Binary 0 65535int, signed int 16 bits 2's complement -32768 32767unsigned int 16 bits Binary 0 65535long, signed long 32 bits 2's complement -2,147,483,648 2,147,483,647unsigned long 32 bits Binary 0 4,294,967,295enum 16 bits 2's complement -32768 32767float 32 bits IEEE 32-bit 1.175495e-38 3.4028235e+38double 32 bits IEEE 32-bit 1.175495e-38 3.4028235e+38long double 32 bits IEEE 32-bit 1.175495e-38 3.4028235e+38pointers, references 16 bits Binary 0 0xFFFFfunction pointers 16 bits Binary 0 0xFFFF



Variable Declarations


int i,j,k; // declaring more than one variableint i1, i2, i3, c3po; // numbers OK, except for first letter

int bananas = 10; // using an initializer

int monkey_count = 0; // two ways of doing ...int monkeyCount = 0; // ... multi-word names

int ab, Ab, aB, AB; // case sensitive namesint _compilerVar; // compiler uses _ as first char

char newline = ‘\n’; // a character with an initializerchar lineBuffer[32]; // an array of 32 chars (a string)

double bananasPerMonkey; // floating point declarationsdouble hugeNumber = 1.0E33; // positive exponentdouble tinyNumber = 1.0E-33; // negative exponentdouble fractionThing = 3.33333; // no exponent


Scope: Local versus Global

Extent of a variable/function’s availability in a program Local Variables (automatic)

Declared at the beginning of a block Stored in activation record on the stack Scope is from point of declaration to the

end of the block Un-initialized

Global Variables (static) Declared outside of a function Stored in Global Data Section of memory Scope is from point of declaration to the

end of the program May be initialized to zero


{ // begin block int chimp; ...}

Scope

int chimp;{ // begin block ...}

Literals/ Constants Literal Values

Unnamed constant values used in programs area = 3.14159 * radius * radius;

Constant Variables Variable declarations prefixed with the const qualifier Immutable named variables const double pi = 3.14159;

Symbolic Values Created using preprocessor directive #define #define PI 3.14159

How are the above the same? How are the above different?


Variables

Quiz 7.1 Expand the following C pre-processor macros:


#define MASK(bit) (0x80 >> ((bit)%8))#define SET_CELL(a2d,row,col) a2d[row][(col)/8] |= MASK(col)#define CLEAR_CELL(a2d,row,col) a2d[row][(col)/8] &= ~ MASK(col)#define TEST_CELL(a1d,col) (a1d[(col)/8] & MASK(col))

1. SET_CELL(life,row,col+1);

2. CLEAR_CELL(life,row,col);

3. if (TEST_CELL(temp,col)) { ... };

Variable Usage Make your variable names meaningful Common naming conventions

Hungarian notation (prefix hints) gVariable, hMyRoutine

UpperCamelCase / lowerCamelCase for most identifiers MyInputByte, buzzerCounter

Underscores last_variable_used, number_of_days

all-upper-case for constants #define TRUE 1

Names beginning with underscore are reserved for compilers/libraries

__reserved, _Reserved Encapsulate your variables

Avoid global variables - explicitly pass parameters to functions Keep the scope as small as you can


Variables

volatile volatile proceeding a variable name instructs the compiler to

prohibit caching the variable’s contents when optimizing code. always re-read the variable’s value when accessing the variable. not use computer registers to store a variable’s content.


volatile int switches,dcntvoid main(void){

if (switches & 0x01) {...}}

#pragma vector=PORT1_VECTOR__interrupt void Port_1_ISR(void){ P1IFG &= ~0x0f; // P1.0-3 IFG cleared dcnt = DEBOUNCE_CNT; // enable debounce}

#pragma vector = WDT_VECTOR__interrupt void WDT_ISR(void){ if (dcnt && (--dcnt == 0)) switches = (P1IN ^ 0x0f) & 0x0f;}

Inform the compiler that integers switches and

dcnt are not to be optimized.

Pressing a switch sets

dcnt

Sample P1IN when dcnt equals 0

Variables

Operators and Expressions Expressions are formed by combining variables with operators and

ALWAYS return a single value in C.i = 5 * x + 100;a = (a < b);

Operators Assignment –

changes the values of variables Arithmetic –

add, subtract, multiply, divide Bitwise –

AND, OR, XOR, NOT, and shifts on Integers Relational –

equality, inequality, less-than, etc. Logical –

AND, OR, NOT on Booleans Increment/Decrement


C supports a rich set of operators that allow the

programmer to manipulate variables

Operators

The Assignment Operator The operator symbol is the equal sign

The expression on the right-hand side is evaluated and assigned to the left-hand variable


{ int x = 9;

x = x + 4;

}add.w #4,0(sp) sp X

Stack

0x05fa0x05fc0x05fe0x05f0

0x0600...

sub.w #2,spmov.w #9,0(sp)

Operators

sp

Arithmetic / Relational Operators Arithmetic Operators

Add (+), subtract (–), multiply (*), divide (/) Integer; 5/3 = 1 (truncated to int) Floating point : 5.0 / 3.0 = 1.66666666

Modulus (%) Integer; remainder after integer division; 5 % 3 = 2

Relational operators return Boolean values: 0 if relation is FALSE 1 if relation is TRUE Comparisons

x == y equalityx != y inequalityx < y less-thanx <= y less-than-or-equalx > y greater-thanx >= y greater-than-or-equal


x + yx – yx * yx / yx % y

Operators

Bitwise Operators Perform bitwise logical operations across individual bits of a value.

AND & OR | XOR ^ NOT ~

(1’s complement) Shifts are bitwise operators

SHIFT LEFT << SHIFT RIGHT >>


x : 1 0 1 0 (binary) y : 1 1 0 0 (binary)x & y : 1 0 0 0 (binary)x | y : 1 1 1 0 (binary)x ^ y : 0 1 1 0 (binary) ~x : 0 1 0 1 (binary)

Operators

x << y shift x y-places to the left (add zeros)x >> y shift x y-places to the right (sign extend)

Logical Operators Logical operators evaluate to Boolean

AND && OR | | NOT !

Don’t confuse with Bitwise operators Operate on Boolean inputs and produce Boolean outputs Boolean inputs (how values are interpreted):

Value not equal to zero TRUE Value equal to zero FALSE


10 && 20 110 && 0 0

Operators

if( 'a' <= x <= 'z' ) statement; // wrong!if(('a' <= x) && (x <= 'z')) statement;

if(!x) statement;if(x == 0) statement;if(x) statement;if(x != 0) statement;

Same

Same

Order of Evaluation Variable Coercion

When executing expressions of mixed types, C automatically converts integer to floating point and back again as needed.

Avoid the use of forced data conversion as operators may yield unanticipated results.

Order of expression evaluation: Precedence – higher precedence operators evaluate first. Associativity – operators of same precedence evaluate left to right

(with a few exceptions). Parentheses override all other evaluation rules.


Expressions

int x = 1; x is declared an integerx = x + 4.3; integer + floating point ?? (result is x = 5)

Operator Precedence/Associativity


OPERATORS ASSOCIATIVITY( ) [ ] -> . left to right! ~ ++ -- + - * & (type) sizeof right to left* / % left to right+ - left to right<< >> left to right< <= > >= left to right== != left to right& left to right^ left to right| left to right&& left to right|| left to right?: right to left= += -= *= /= %= &= ^= |= <<= >>= right to left, left to right

LogicalLogical

RelationalRelational

BitwiseBitwiseBitwise

Bitwise

Expressions

Unary operators associate right to left.

Quiz 7.2 Evaluate the variable result for the following:


1. int a = 1, b = 2, c = 3, d = 4, e = 5;int result = a * b + c / d * e;

2. int a = 6, b = 5, c = 4, d = 3;int result = c + (d = b * a);

3. int w = 5, x = 4, y = 3, z = 2;int result = w % x / y * z;

Combined Assignment Operators Arithmetic and bitwise operators can be combined with

the assignment operator.


x += y; x = x + (y);x -= y; x = x – (y);x *= y; x = x * (y);x /= y; x = x / (y);x %= y; x = x % (y);x &= y; x = x & (y);x |= y; x = x | (y);x ^= y; x = x ^ (y);x <<= y; x = x << (y);x >>= y; x = x >> (y);

Expressions

Note: All of the expression on

the right is considered

parenthesized.

Conditional Expressions Conditional expression

C multiplexor operation Format: <boolean> ? <true expression> : <false expression> Example:


Expressions

printf("%d dog%s", dogs, (dogs == 1) ? "" : "s");

This expression returns the value of y if x != 0, otherwise it returns the value of z

x ? y : z x

y z

0

x ? y : z

1

Quiz 7.3 What is the output?


main(){ int i = 5,j = 10; i = i &= j && 10; printf("%d %d",i,j);}

main(){ int i = 4,j = 7; j = j || i++ && printf("Hello"); printf("%d %d", i, j);}

1.

2.

0x000a (x)

C to Assembly – Example 1


{ int x = 10; int y = 20; int z = 30; x = x + 4; y = x + y - z;}

0x8696: 8031 0006 SUB.W #0x0006,SP0x869a: 40B1 000A 0000 MOV.W #0x000a,0x0000(SP)0x86a0: 40B1 0014 0002 MOV.W #0x0014,0x0002(SP)0x86a6: 40B1 001E 0004 MOV.W #0x001e,0x0004(SP)0x86ac: 52A1 0000 ADD.W #4,0x0000(SP)0x86b0: 411F 0002 MOV.W 0x0002(SP),R150x86b4: 512F ADD.W @SP,R150x86b6: 811F 0004 SUB.W 0x0004(SP),R150x86ba: 4F81 0002 MOV.W R15,0x0002(SP)0x86be: 5031 0006 ADD.W #0x0006,SP

SP

Stack

x0600x05fex05fcx05fax05f8x05f6

0x0014 (y)0x001e (z)

Compilation Examples

SP

0x000e (x)

C to Assembly – Example 2


int main(int argc, char** argv){

unsigned int x = 7;unsigned int y = 5;unsigned int z;

z = x * y;return 0;

}

main:0x8040: 8031 000A SUB.W #0x000a,SP0x8044: 4D81 0002 MOV.W R13,0x0002(SP)0x8048: 4C81 0000 MOV.W R12,0x0000(SP)0x804c: 40B1 0007 0004 MOV.W #0x0007,0x0004(SP)0x8052: 40B1 0005 0006 MOV.W #0x0005,0x0006(SP)0x8058: 411C 0004 MOV.W 0x0004(SP),R120x805c: 411D 0006 MOV.W 0x0006(SP),R130x8060: 12B0 80DA CALL #__mpyi0x8064: 4C81 0008 MOV.W R12,0x0008(SP)0x8068: 430C CLR.W R120x806a: 5031 000A ADD.W #0x000a,SP0x806e: 4130 RET

__mpyi:0x80da: 430E CLR.W R14 mpyi_add_loop:0x80dc: C312 CLRC0x80de: 100C RRC R120x80e0: 2801 JLO (shift_test_mpyi)0x80e2: 5D0E ADD.W R13,R14 shift_test_mpyi:0x80e4: 5D0D RLA.W R130x80e6: 930C TST.W R120x80e8: 23F9 JNE (mpyi_add_loop)0x80ea: 4E0C MOV.W R14,R120x80ec: 4130 RET

SP

Stack

x0600x05fex05fcx05fa

x05f4

x05f8x05f6

ret adr

argc (r12)argv (r13)

z0x0005 (y)0x0007 (x)


SP

C to Assembly– Example 3


main: SUB.W #0x0006,SP MOV.W 0x0002(SP),R15 ADD.W &inGlobal,R15 ADD.W 0x0004(SP),R15 MOV.W R15,0x0000(SP) ADD.W #0x0006,SP RET

Identifier Type Storage Class Offset ScopeinGlobal int Static absolute globalinLocalA int Auto 2(SP) main

inLocalB int Auto 4(SP) mainoutLocal int Auto 0(SP) main

SymbolTable

int inGlobal;void main(void){ int outLocal; int inLocalA; int inLocalB; outLocal = inGobal + inLocalA + inLocalB; return;}


Quiz 7.4 Fill in the resulting values for x, y, and z after evaluating the construct. Assume for each row, x, y, and z are initialized to 10, 20, and 30 respectively.


x=10 y=20 z=301) if (x = y) y = 100;

2) if (x < 10) y = 1;else if (x < 20) y = 5;else if (x < 30) y = 10;

3) switch ('a') { case 'a': y++; z *= 5; case 'b': --y; z /= 10;}

4) for (x=1; x<y; x++, y--) z = x + y;

5) while (!z) { z %= y;}

6) do { x = --y; z = x++;}while (z);

Streaming I/O in C


C I/O I/O facilities are not part of the C language itself

Nonetheless, programs do interact with their environment! Most digital I/O handled directly by C program

#include "msp430.h" SPR’s, Ports, A/D, transponder, switches, LED’s, etc

The ANSI standard defines a set of I/O library functions for portability

Programs that confine their system interactions to facilities provided by the standard library can be moved from one system to another without change.

The properties of the C I/O library functions are specified in header files

#include <stdio.h> (C standard library) #include "RBX430_lcd.h"

C Stream I/O


C Data Streams C I/O is character based, using streams.

I/O streams must be opened / closed. In standard C there are 3 streams automatically opened before

main() is called: stdin is the input stream stdout is the output stream stderr stream for error messages

printf function outputs formatted values to stdout stream The printf function requires a format string followed by optional

parameters:printf( "format string...", parameters... );

The format string contains two object types: Ordinary characters that are copied to the output stream Conversion specifications which cause conversion and printing of the

next argument in the argument list.

C Stream I/O


Printf Output in C printf( format_string, parameters )

printf("Hello World");printf("\n%d plus %d is %d", x, y, x+y);printf("\nIn hex it is %x", x+y);printf("\nHello, I am %s. ", myname);printf("\nIn ascii, 65 is %c. ", 65);

Output:Hello world

5 plus 6 is 11In hex it is bHello, I am Bambi.In ascii, 65 is A.

String literal

DecimalInteger

HexInteger

StringCharacterNewline

C Stream I/O


RBX430_lcd.h Prototypes uint8 lcd_init(void); void lcd_clear(void); void lcd_backlight(uint8 backlight); void lcd_volume(uint8 volume); uint16 lcd_mode(int16 mode); uint8 lcd_cursor(uint16 x, uint16 y); uint16 lcd_printf(const char* fmt, ...); uint8 lcd_image(const uint8* image, int16 x, int16 y); uint8 lcd_bitImage(const uint8* image,

int16 x, int16 y, uint8 flag); uint8 lcd_wordImage(const uint16* image,

int16 x, int16 y, uint8 flag); uint8 lcd_blank(int16 x, int16 y, uint16 w, uint16 h); uint8 lcd_point(int16 x, int16 y, uint8 flag); void lcd_circle(int16 x, int16 y, uint16 r, uint8 pen); void lcd_rectangle(int16 x, int16 y,

uint16 w, uint16 h, uint8 pen);

LCD I/O


LCD – 160 x 160 x 5 PixelsY

(0-1

59)

Hello World!

lcd_init();lcd_clear();// 5 x 8 pixel Characterslcd_cursor(40, 60);lcd_printf("Hello World!");

X (0-159)

LCD I/O

The C Language 48BYU CS 224

Documents

3.1 The C Language