C Basics

Ryan Robucci

Introduction to the C Programming Language

C Basics

Review

Assembler Examples
- AVR Registers
- AVR IO
- AVR Addressing Modes
- Processor Review
- State Machine examples

C History

Began at Bell labs between 1969 and 1973
Strong ties to the development of the UNIX operating system
- C was developed to take advantage of byte-addressability where B could not
First published in 1978
- Called K&R C
  - Maximum early portability
  - A psuedo “standard” before C was standardized

The C Standard

First standardized in 1989 by American National Standards Institute (ANSI)
- Usually referred to C89 or ANSI C
Slightly modified in 1990
- Usually C89 and C90 refer to essentially the same language
ANSI adopted the ISO.IEC 1999 standard in 2000
- Referred to as C99
C standards committee adopted C11 in 2011
- Referred to as C11, and is the current standard
- Many still developed for C99 for compatability

What is C?

Language that “bridges” concepts from high-level programming languages and hardware
- Assembly = low level
- Python = Very high level
  - Abstracts hardware almost completely
C maintains control over much of the processor
- Can suggest which variables are stored in registers
- Don’t have to consider every clock cycle
C can be dangerous
- Type system error checks only at compile-time
- No garbage collector for memory management
  - Programmer must manage heap memory manually

C Resources

C vs. Java

C is a procedural language
- Centers on defining functions that perform single service
  - e.g. getValidInt(), search(), inputPersonData()
- Data is global or passed to functions as parameters
- No classes
Java and C++ are Object Oriented Programming languages
- Centers on defining classes that model “things”
  - e.g. Sphere, Ball, Marble, Person, Student, etc…
  - Classes encapsulate data (instance variables) and code (methods)

Hardware to Application Onion Model

Hardware---Registers programming by rewiringMachine Language e.g. ox001F ox0002 ox0006Add RI,R2 2nd GLAssembler1st GLUnique to the MachineHigh-Level Languagea+=b;C, Pascal3rd GLHigher-Level Language Advanced programming 3rd GLC++, Javaconcepts, e.g OOP4th GL e.g. CASE(ComputerAided Sofware Engineering)Application ProgramsFigure 6.0 FromHardware to Applications*Figure 6.0 From Textbook

Libraries

Library is composed of predefined functions
- As opposed to classes for OOP language
- Examples include:
  - Char/String operations (strcpy, strcmp)
  - Math functions (floor, ceil, sin)
  - Input/Output Functions (printf, scanf)
C/Unix manual – “man” command
- Description of C library functions and unix commands
  - e.g. “man printf” or “man dir”

Hello World

/*
file header block comment
*/
#include <stdio.h>
int main( )
{
// print the greeting ( // allowed with C99 )
printf( “Hello World\n”);
return 0;
}

Compiling on Unix

Traditionally the name of the C compiler that comes with Unix is cc
UMBC GL systems use the “GNU Compiler Collection” gcc to compile C (and C++ programs)
Default name of executable program created by gcc is a.out
- Can specify executable filename using -o command

Compiler Options

-c
- Compile only, don’t link
  - Create a .o file, but no executable
- E.g. gcc –c hello.c
-o fname
- Name the executable filename instead of a.out
- E.g. gcc –o hello hello.c
-Wall
- Report all warnings
-ansi
- Enforce ANSI C standard, disable C99 features

Compilation Flow

Program is executed by calling name of executable at Unix prompt:
E.g.

unix>./hello

Compiler Vocabulary

Preprocessor
- Prepares file for compiler, handles processing macros, source selection, preprocessor directives, and file includes
Compiler
- Converts (nearly) machine independent C code to machine dependent assembly code
Assembler
- Converts assembly language to machine language of an object relocatable file (addresses not all resolved)
Linker
- Combines all object files and resolves addressing issues
Loader
- When executed, loads executable into memory
Cross compiler
- Compiler that runs on one platform but outputs code for another target machine (e.g. AVR is compiled on Intel)

Identifiers

Identifier – name of a function or variable
ANSI/ISO C standard
- CASE SENSITIVE
- First character must be alpha or _
- May NOT be a C keyword such as int, return, etc…
- No length limit imposed by standard
  - May have compiler limitation
Good coding practices
- Choose convention for capitalization of variables and functions
- Symbolic constants should be all caps
- Choose descriptive names over short names

Choosing Identifiers example

T1, Temp1, Temperature1
Which of the three above is most useful?
Treat identifiers as documentation
- Something which you would understand 3 years later
- Don’t be lazy with naming, put effort into documentation

Declaring, Defining, Initialization

C allows you to declare and define variables
A declaration puts the variables name in the namespace
- No memory is allocated
- Sets identifier (name) and type
A definition allocates memory
- Amount depends on variable type
An initialization (optional) sets initial value to be
stored in variable
C Declaration Example

In C, combined declaration and definition is typical

char example1; //definition and declaration
int example2 = 5; //def. decl. and init.
void example3(void){ //def. and decl. of a function
 int x = 7;
}

The “extern” keyword may be added to declare that definition will be provided elsewhere
```
extern char example1;
extern int example2;
void example3(void);
```
Line 3: A function which does not provide function definition is sufficient for the compiler. This declaration is called a prototype. From this, the compiler knows how to implement placeholder information for calls, after-which the linker will resolve how to make the calls.

Assignments

Assignments set values to variables

Use equal = character and ends with semicolon ;

E.g.

temperature1 = 3;
temperature2 = temperature1;

Initialization

Refers to the first assignment whether in a declaration or afterward
Until initialization, variables are considered uninitialized
- Contents are unknown/unspecified/garbage
- Exception: All objects with static storage duration (variables declared with static keyword and global variables) are zero-initialized unless they have user-supplied initialization value
  - Still good practice to provide explicit initialization
Initialization is not “free” in terms of run time or program space
- For a register, it is similar to a LDI
  - (some architectures have more efficient commands for setting )

Types

Intrinsic (fundamental, built-in) types
- Integral types
  - E.g. int, char, long
- Floating-Point types
  - E.g. float, double
Type synonyms (aliases) using “Typedef”
- Keyword “typedef” can be used to give new name to
  existing type
- Example:
  typedef unsigned int my_type;
  my_type a=1;
- Useful for Structures (covered later)

Integral Data Types

C data types for storing integers are:
- int (basic integer data type)
- short int (typically abbreviated as short)
- long int (typically abbreviated as long)
- long long int (C99)
- char (C does not have “byte”)
- int should be used unless there is a good reason to use one of the others
Number of bytes
- char is stored in 1 byte
- Number of bytes used by other types depends on machine being used

Integral Type Sizes

C standard is specifically vague regarding size
- A short must not be larger than an int
- An int must not be larger than a long int
- A short int must be at least 16 bits
- An int must be at least 16 bits
- A long int must be at least 32 bits
- A long long int must be at least 64 bits
Check compiler documentation for specific lengths

Integral Specifiers

Each of the integral types may be specified as:
- Signed (positive, negative, or zero)
- Unsigned (positive or zero only) (allows larger numbers)
Signed is default qualifier
Be sure to pay attention to signed vs. unsigned representations when transferring data between systems. Don’t make assumption mistakes.

Fixed-Width Integer Types

To avoid ambiguity of variable sizes on embedded systems, named types that make size apparent should be used
predefined fixed-width integer types:
int8_t - signed char
uint8_t - unsigned char
int16_t - signed int
uint16_t - unsigned int
int32_t - signed long
uint32_t - unsigned long
These are defined in stdint.h, which is included through inttypes.h, using typedef
- ```
#include <inttypes.h>
```
- or minimally
```
#include <stdint.h>
```
- "The <inttypes.h> header (cinttypes in C++) provides features that enhance the functionality of the types defined in the <stdint.h> header. It defines macros for printf format string and scanf format string specifiers corresponding to the types defined in <stdint.h> and several functions for working with the intmax_t and uintmax_t types. This header was added in C99." --https://en.wikipedia.org/wiki/C_data_types#inttypes.h

Floating Point Types

C data types for storing floating point values are
- float – smallest floating point type
- double – larger type with larger range of values
- long double – even larger type
Double is typically used for all floating point values unless compelling need to use one of the others
Floating point values may store integer values
C standard is again unspecific on sizes
- Requires
  - long double provides at least as much precision as double
  - double provides at least as much precision as float

Valid floating point declarations:

float avg = 10.6;
double median = 88.54;
double homeCost = 10000;

Character Data Types

C has just one data type for storing characters
- Char – just 1 byte
- Because only 1 byte, C only supports ASCII
  character set
Example assignments:
- char x = 'A';
  - Equivalent to : char x = 65;
  - ASCII character set recognizes A as 65

Const qualifier

Any of the variable types may be qualified as const
const variables may not be modified by your code
- Any attempt to do so will result in compiler error
- Must be initialized when declared
  - E.g.
```
const double PI = 3.14159;
const int myAge = 24;
const float PI; //valid, PI=0
PI = 3.14159; //invalid
```

sizeof()

Because sizes of data types in C standard are vaguely specified, C provides sizeof() operator to
determine size of any data type
sizeof() should be used everywhere the size of a data type is required
- Maintain portability between systems

Variable Declaration

ANSI C requires all variables be declared at the beginning of the “block” in which they are
defined
- Before any executable line of code
C99 allows variables to be declared anywhere in code
- Like java and C++
Regardless, variables must be declared before they can be used

Arithmetic Operators

Arithmetic operators are the same as java
- = : assignment
- +,- : plus, minus
- *,/,% : multiply, divide, modulus
- ++, --: increment, decrement (pre and post)
Combinations are the same
- +=, -= : Plus equal, minus equal
- *=, /=, %=: multiply equal, divide equal, mod
  equal

Boolean Data Type

ANSI has no Boolean type
C99 standard supports boolean data type
To use bool, true, and false you must include stdbool.h

#include <stdbool.h>
bool isRaining = false;
if(isRaining)
 printf(“Bring your umbrella\n”);

Logical Operators and Comparisons

Logical Operators are closely similar in C and python and result in boolean value
- && : and
- || : or
- ==, !=: equal and not equal
- <, <=: less than, less than or equal
- >, >=: greater than, greater than or equal

Integral types may also be treated as boolean
expressions

0 considered false
Any non-zero value is considered true

Common Error: assign instead of equality check

#include <stdio.h>
int main(){
  int a=0;
  if (a=1) printf("oops\n");
}

caught by -Wall option:

gcc -Wall equalitycheck.c

equalitycheck.c: In function ‘main’:
equalitycheck.c:4:7: warning: suggest parentheses around assignment used as truth value [-Wparentheses]
    4 |   if (a=1) printf("oops\n");

More Common Error

Ignoring warnings

Control Structures

Both languages support the following control structures
- For loop
- While loop
- Do-while loop
- Switch statements
- If and if-else statements
Braces ({,}) are used to begin and end blocks

Curly Braces

Used to group multiple statements together
- Control blocks, functions
- Statements execute in order
- create local scope for variables

int main(){
 int i=7;
 int t;
 if(i==7) {
   i=i+j;
   int k; //forbidden by c89 standard (c99 okay)
   k=i*i;
   t=k*2;
 }
}

If - Else block

if (expression) (statement)

e.g.

if(x>3) x+=1; //simple form

if(expression) { //simple form with {} to group
  statement;
  statement;
}
if(expression){ //full if/else form
 statement;
} else {
 statement;
}

If - Else If – Else block

if(expression1) {
 statement 1;
} else if (expression2) {
 statement2;
} else {
 statement3;
}

Spacing Variation (Be Consistent)

K&R style

if(expression) {
 statement;
}else {
 statement;
}

Stroustrup

if (expression)
{
 statement;
}
else {
 statement;
}

Allman

if (expression)
{
 statement;
}
else
{
 statement;
}

There are many spacing styles for logic blocks. Pick one and be consistent.

https://en.wikipedia.org/wiki/Indentation_style

Liunx indent

indent (sudo apt install indent)- changes the appearance of a C program by inserting or deleting whitespace.
Can manipulate many aspects of indentation, braces, line spacing, etc...
Example KR Style:

indent -kr orig.c -o indented.c

Example Allman/BSD style (from https://en.wikipedia.org/wiki/Indent_(Unix)):

indent -st -bap -bli0 -i4 -l79 -ncs -npcs -npsl -fca -lc79 -fc1 -ts4 orig.c -o indented.c

Switch

switch (expression) {
 case const-expression-1:
   statement;
   break;
 case const-expression-2:
   statement;
   break;
 case <const-expression-3>: //combined case 3 and 4
 case <const-expression-4>:
   statement;
   break;
 case <const-expression-5>: //no break mistake? maybe
   statement;
 case <const-expression-6>:
   statement;
   break;
 default: // optional
 statement;
}

note fall-through of execution into next case if break; is not provided

Omitting the break statements is a common error

compiles, but leads to inadvertent fall-through behavior. This behavior is just like the assembly jump tables it implements.

While – Do While

while(expression){ //executes 0 or more times
 statement;
}

do{ //executes 1 or more times
 statement;
} while(expression)

For loops

for(initialization; continuation; action){
 statement;
}

for(; continuation; action){
 statement;
}

Initialization, continuation and action are all optional.
May optionally declare a variable in initialization (C99 standard)
Continuation condition must be satisfied for every execution of statement, including the first iteration
Action is code performed after the statement is executed

int i = 99;
for(; i!=0;){
 statement;
 i-=1;
}

for (int i = 99; i!=0; i=i-1){
 statement;
}

These are equivalent.
The second one is much more readable.
The second one also uses the C99 variable declaration inside the for loop.

Break and Continue

while(expression){
 statement;
 statement;
 if(condition)
   break;
 statement;
 statement;
}
//control jumps here on break.

Continue

while(expression){
 statement;
 if(condition)
   continue;
 statement;
 statement;

 //control jumps here on continue
}

goto label1; //unconditional jump
int n=99; //declares variable, and represents and initialization
label1:
//here n is not initialized to 99

A common practice is to avoid goto, break (except for when used with case) and continue
- it seems more natural to examine control flow when these are not used
  - e.g. regularly identifying the conditions under which a statement is executed is easier if one can focus on understanding the embedding of the statement into bodies of if-else trees, case, and loops.
- Arguments for good uses goto, continue, break may be valid, but use selectively and consider the alternative

Conditional Expression

Also called the Ternary Operatory

?: (tri-nary “hook colon”)

C:
```
int larger=(x>y ? x:y);
```
Python:
```
larger=x if x>y else y
```

Syntax: expression1?expression2:expression3
- Use this sparingly since it can make code less readable

Other Operators

These operators are very similar in C and Java
<<,>>,&,|,^ : bit operators
<<=,>>=,&=,|=,^= : bit equal operators
[] : brackets (for arrays)
() : parenthesis for functions and type casting
^ : binary XOR

Arrays

C supports arrays as basic data structure
Indexing starts with 0
ANSI C requires size of array be a constant
Declaring and initializing arrays:

int grades[30];
int areas[10] = {1,2,3};
long widths[12] = {0};
int IQs[] = {120, 121, 99, 154};

Arrays defined using a Variable for Size

C99 syntax allows size of array to be a variable

int numStudents = 30;
int grades[numStudents];

Multi-Dimensional Arrays

C supports multi-dimensional array
Subscripting provided for each dimension
For 2-d arrays:
- First dimension is number of “rows”
- Second is number of “columns” in each row

int board[4][5]; // 4 rows, 5 columns
int x = board[0][0]; //1st row, 1st column
int y = board[3][4]; //4th (last) row, 5th (last) column

#define

The #define directive can be used to give names to
important constants
- Makes your code more readable and changeable
The compiler’s preprocessor replaces all instances of
the #define name with the text it represents
Note, no terminating semi-colon

#define PI 3.14159
…
 double area = PI * radius * radius;

Use of #define vs. const

#define
- Pro – no run-time data memory is used for the constant
- Con – cannot be seen when code is compiled
  - Removed by pre-compiler
- Con – not real variables, have no type
const variables
- Pro – real variables with a type
- Pro – Can be examined by debugger
- Con – occupy up data memory

Good practice involves a generous use of parenthesis with #define

#define NUMBER (2)

Examples:

Ex 1
```
const int NUMBER = -42;
int main(){
int x = -NUMBER;
}
```
- If replaced with
  #define NUMBER -42
  , will throw compiler error
  (-- is a decrement operator)
- Safe: #define NUMBER (-42)
Ex 2
```
#define NUMBER 5+2
int x = 3 * NUMBER;
```
Value of x
- is 17 with #define,
- is 21 with const
  (int x = 3 * 5 + 2) vs (int x = 3 * 7)
  Safe: #define NUMBER (5+2)

Ex 3: be careful with semicolons

#define NUMBER 5+2;
int x = NUMBER * 3;

Compiler error

int x = 5 + 2; * 3;

Longer Example

File: constvsdefine.c

#include <stdio.h>

#define NEG_ONE_DEFINE (-1)
const int NEG_ONE_CONST = -1;
const unsigned int MAGIC = -1;

#include <stdint.h>

int main(){

  uint32_t u32=0;
  int32_t i32;

  i32=NEG_ONE_DEFINE;
  u32=NEG_ONE_CONST;

  if (u32>NEG_ONE_DEFINE){
  }

  if (u32>NEG_ONE_CONST){
  }

  if (MAGIC > 1){
    printf("magic\n");
  }

  i32=1;
  if (MAGIC>i32){
    printf("more magic\n");
  }

  u32=NEG_ONE_DEFINE;

  return 0;
}

robucci@sensi:~$ gcc -std=c11 -Wall -Wall -Wextra -Wconversion -Wsign-conversion constvsdefine.c 
constvsdefine.c:5:28: warning: unsigned conversion from ‘int’ to ‘unsigned int’ changes value from ‘-1’ to ‘4294967295’ [-Wsign-conversion]
    5 | const unsigned int MAGIC = -1;
      |                            ^
constvsdefine.c: In function ‘main’:
constvsdefine.c:15:7: warning: conversion to ‘uint32_t’ {aka ‘unsigned int’} from ‘int’ may change the sign of the result [-Wsign-conversion]
  15 |   u32=NEG_ONE_CONST;
      |       ^~~~~~~~~~~~~
constvsdefine.c:17:10: warning: comparison of integer expressions of different signedness: ‘uint32_t’ {aka ‘unsigned int’} and ‘int’ [-Wsign-compare]
  17 |   if (u32>NEG_ONE_DEFINE){
      |          ^
constvsdefine.c:20:10: warning: comparison of integer expressions of different signedness: ‘uint32_t’ {aka ‘unsigned int’} and ‘int’ [-Wsign-compare]
  20 |   if (u32>NEG_ONE_CONST){
      |          ^
constvsdefine.c:28:12: warning: comparison of integer expressions of different signedness: ‘unsigned int’ and ‘int32_t’ {aka ‘int’} [-Wsign-compare]
  28 |   if (MAGIC>i32){
      |            ^
constvsdefine.c:3:24: warning: unsigned conversion from ‘int’ to ‘uint32_t’ {aka ‘unsigned int’} changes value from ‘-1’ to ‘4294967295’ [-Wsign-conversion]
    3 | #define NEG_ONE_DEFINE (-1)
      |                        ^
constvsdefine.c:32:7: note: in expansion of macro ‘NEG_ONE_DEFINE’
  32 |   u32=NEG_ONE_DEFINE;
      |       ^~~~~~~~~~~~~~

Note attribution of line 32 expansion issue to line 3, whereas line 5 is flagged in at the onset

robucci@sensi:~$ ./a.out 
magic
more magic

Options to view preprossor Output

using the --save-temps outputs a .i
adding the -E option to the previous gcc to stop after preprocessing prints output

Customized output:

gcc -E -x c -P -C -traditional constvsdefine.c > preprocessoroutput.c

tail of preprocessoroutput.c:

int main(){

  uint32_t u32=0;
  int32_t i32;

  i32=(-1);
  u32=NEG_ONE_CONST;

  if (u32>(-1)){
  }

  if (u32>NEG_ONE_CONST){
  }

  if (MAGIC > 1){
    printf("magic\n");
  }

  i32=1;
  if (MAGIC>i32){
    printf("more magic\n");
  }

  u32=(-1);

  return 0;
}

Enumeration Constants

C provides the enum as a list of named constant
integer values (starting at 0 by default)
Behaves like integers
Names in enum must be distinct
Often better alternative to #defines
Example
- enum months{ JAN=1, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC};
- enum months thisMonth
- thisMonth=SEP; //ok
- thisMonth=42; //unfortunately, also ok

C Functions

C Functions (no explicit procedures)
- Have a name
- Have a return type (a void return type represents a procedure)
- May have parameters
Before a function may be called, its “prototype” must be known to the compiler
- Verify that function is being called correctly
- Accomplished by:
  - Providing entire function prior to calling function in code
  - Provide function prototype prior to calling in code and providing function elsewhere

C Functions

Unlike Java, a function is C is uniquely identified by its name
- No concept of method overloading
- There can only be one main() function in a C application
UMBC coding standards dictate function names begin with UPPERCASE letter
- E.g. AddThreeNumbers() instead of addThreeNumbers

Simple C Program

#include <stdio.h>
typedef double Radius;
#define PI (3.1415)

/* given the radius, calculates the area of a circle */
double CircleArea( Radius radius ){
 return ( PI * radius * radius );
}

// given the radius, calculates the circumference of a circle
double Circumference( Radius radius ){
 return (2 * PI * radius );
}

int main( ){
 Radius radius = 4.5;
 double area = circleArea( radius );
 double circumference = Circumference( radius ); // print the results
 return 0;
}

Simple C Program with prototypes

#include <stdio.h>

typedef double Radius;

#define PI (3.1415)

/* function prototypes */
double CircleArea( Radius radius );
double Circumference( Radius radius );

int main( ){
 Radius radius = 4.5;
 double area = circleArea( radius );
 double circumference = Circumference( radius );
 //print the results here
 return 0;
}

/* given the radius, calculates the area of a circle */
double CircleArea( Radius radius ){
 return ( PI * radius * radius );
}

// given radius, calcs circumference of circle
double Circumference( Radius radius ){
 return (2 * PI * radius );
}

• includes

• typedefs

• defines

• function 
   prototypes


• main







• function 
   definitions

C Basics

Table of Contents

Review

C History

The C Standard

What is C?

C Resources

C vs. Java

Hardware to Application Onion Model

Libraries

Hello World

Compiling on Unix

Compiler Options

Compilation Flow

Compiler Vocabulary

Identifiers

Choosing Identifiers example

Declaring, Defining, Initialization

Assignments

Initialization

Types

Integral Data Types

Integral Type Sizes

Integral Specifiers

Fixed-Width Integer Types

Floating Point Types

Character Data Types

Const qualifier

sizeof()

Variable Declaration

Arithmetic Operators

Boolean Data Type

Logical Operators and Comparisons

Control Structures

Curly Braces

If - Else block

If - Else If – Else block

Spacing Variation (Be Consistent)

Switch

While – Do While

For loops

Break and Continue

Conditional Expression

Other Operators

Arrays

Arrays defined using a Variable for Size

Multi-Dimensional Arrays

#define

Use of #define vs. const

Options to view preprossor Output

Enumeration Constants

C Functions

C Functions

Simple C Program

Simple C Program with prototypes