CMPE-013/L
Computer Systems
and “C” Programming
Gabriel Hugh Elkaim
Spring 2012
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
About: Me
• Faculty at UCSC since 2003
• Undergraduate from
Princeton in Aerospace Eng.
• Masters and PhD from
Stanford in Aero/Astro
• Built a robotic winged
catamaran for my PhD
thesis
• Consulted on many
embedded projects
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
CMPE-013 Website
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
CMPE-013/L Info
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
CMPE-013/L Syllabus
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
CMPE-013/L Extended Course Description
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
CMPE-013/L Books
•
[K&R]: “The C Programming Language, 2nd Edition”
by Kernighan and Ritchie, Prentice-Hall, 1988, ISBN10: 0131103628.
•
[Notes]: “Notes to accompany K&R,” by Steve
Summit available on the class website and at:
http://www.eskimo.com/~scs/cclass/krnotes/top.ht
ml
• “Programming 16-Bit PIC Microcontrollers in C:
Learning to Fly the PIC24,” by Lucio Di Jasio, Newnes
Press, 2007, ISBN: 9780750682923
• “The Cartoon Guide to Computer Science” by Larry
Gonick, Barnes and Noble Books, 1983.
http://www.soe.ucsc.edu/classes/cmpe013/Spring1
1/Gonick/
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
CMPE-013/L Attendance
• Highly Recommended
– Material builds up quickly
– Videos available, but not the same as being there
• In class quizzes
– No excuses accepted post-quiz.
• At least one lab section per week
– Easier to get through the labs with help
– TA/Tutors will be available then
– Required for your “signed up” section
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Academic Honesty
• Cheating is presenting someone else’s work as your
own
• All code turned in will be run against a code-checker
• Anyone caught cheating will immediately fail the
class and the lab, and be reported to their college
• Copying each other’s code is never acceptable.
• Don’t do it—not worth it.
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
CMPE-013/L Grading
• Lecture and Lab are one and the same: CMPE-013
and CMPE-013L will get the same grade, same
evaluation.
• In class quizzes (once per week): 30%
• Programming assignments (one per week): 70%
• No midterm, no final
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
CMPE-013/L Lab Work
• All programs we are using can be loaded onto your
own PC for use at any time—they are all free.
• We’re using microchip’s MPLAB IDE and C30
compiler (modern toolchain)
• Using Proteus VSM simulator to simulate an
expensive development kit (Explorer16)
• You can buy the actual Explorer16 from Microchip if
you want to (~$150).
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Microstick and Explorer16
Microstick + FTDI ~ $35
Gabriel Hugh Elkaim – Spring 2012
Explorer16 + PicKIT ~ $150
CMPE-013/L: “C” Programming
Reading Assignment for Thur
• Introduction to Programming
• Math Refresher
• Compiler Steps
• Compiler Errors
• Preface and Introduction of K & R
• Summit Notes on Preface and Introduction
• Check out Webpage and Forum
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Lab 0: “Hello World”
• Due on Monday, 09-Apr-2012 at 11:55PM
• Sign-off’s by TA and Tutor in Section
• Code submitted electronically
• Full lab on Website and eCommons
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
What is a Computer?
• Computer
– A computer is a machine that manipulates data based on a list of
instructions called program.
– A computer consists of hardware and software.
• Computer Hardware
– Computer hardware is the physical part of a computer.
– A typical computer consists of central processing unit (CPU), main
memory and external memory , and input and output devices.
– A CPU consists of control unit (CU), arithmetic and logic unit
(ALU), and registers.
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Samples of Computer Hardware
A single board computer and a tiny computer.
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
The von Newmann Computer Architecture
Both programs and data are stored in the same memory
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Major Components of a Computer
1.
Input devices
•
2.
Output devices
•
3.
Outputs information (to screen, printer, control other devices)
Main memory
•
4.
Obtains information from input devices (keyboard, mouse)
Installs programs and data for rapid access
CPU:
4.1 Arithmetic and logic unit (ALU)
•
Performs arithmetic calculations and logic decisions
4.2 Control unit (CU)
•
Supervises and coordinates activities of the computer
4.3 Registers
Fast memory
5. External memory
•
Store programs and data permanently (hard disks, CDs, USB)
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Hardware Trends
Moore’s Law (1965):
The number of transistors that can be inexpensively placed
on an integrated circuit increases exponentially, doubling
approximately every two years.
Based on Moore’s law, every two years, the following approximately
double:
– CPU speed at which computers execute their programs.
– The amount of main memory.
– The amount of secondary memory.
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Computer Software
Computer software refers to a collection of computer programs that can
be loaded into main memory and executed in the CPU of a computer.
Computer software can be classified as operating system and
application software.
An operating system is a software program for management and
coordination of activities and sharing the resources of a computer.
Application software refers to programs developed to assist users in
completing specific tasks.
A process: a running program.
Software is harder than hardware.
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Interaction of Users and Computer
Hardware through Software
Two interface methods:
(1) Command shell
(2) Graphical user interface (GUI)
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Computer Programming Languages
Three types of programming languages
1. Machine code or machine languages
A sequence of 0’s and 1’s giving machine specific instructions
Example: 00011001
2. Assembly language
Using meaningful symbols to represent machine code.
Example: add hl,de
Assembler: Assembly code  machine code
Disassembler: machine code  assembly code
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Computer Programming Languages
3. High-level languages
Similar to everyday English and use mathematical notations
(processed by compilers or interpreters)
Example of a C statement:
a = a + 8;
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Computer Programming Languages
3. High-level languages
Similar to everyday English and use mathematical notations
(processed by compilers or interpreters)
Example of a C statement:
a = a + 8;
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Comparison of High-Level Language with
Machine Code and Assembly Code
The memory addresses, machine code, and assembly code
corresponding to a C statement a = a + 8 for the Rabbit
3000 8-bit microprocessor.
Memory address Machine code
Assembly code
------------------------------------------------------------------------------------0X1EA1
000100010000100000000000
ld de,0x0008
0X1EA4
1100010000000000
ld hl,(sp+0)
0X1EA6
00011001
add hl,de
0X1EA7
1101010000000000
ld (sp+0),hl
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
10 Reasons to Learn C
http://iel.ucdavis.edu/publication/WhyC.html
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
C is one of foundations for modern information technology and computer
science.
C is the most commonly used programming languages in industry.
C is a standardized programming language with international standards.
Writing computer programs is essential to solving complex science and
engineering problems.
Computer programming is becoming a necessary skill for many professions.
Computer programming can develop student's critical thinking capabilities.
C is one of the most commonly used programming languages in colleges and
universities.
C is the language of choice for programming embedded and mechatronic systems
with hardware interface.
C excels as a model programming language.
Once you have learned C, you can pick up other languages without much
difficulty by yourself because all other modern languages borrowed heavily from
C.
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Structured Programming in C
– A disciplined approach to writing programs in C.
– Clear, easy to test and debug, and easy to modify.
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
History of C
• C
–
–
–
–
–
Invented by Ritchie based on B, a simplified version of BCPL.
Used to develop Unix operating system and Unix commands
Most system software such as OS are written in C or C++
Replacement for assembly language for hardware interface.
By late 1970's C had evolved to “K & R C“
• C Standards
– 1st C standard created in 1989 by ANSI, ratified by ISO in 1990.
It is called C89. Some call it C90.
– 2nd C standard was ratified in 1999, called C99.
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Just the Facts
• C was developed in 1972 in order to write the UNIX
operating system
• C is more "low level" than other high level languages
(good for MCU programming)
• C is supported by compilers for a wide variety of
MCU architectures
• C can do almost anything assembly language can do
• C is usually easier and faster for writing code than
assembly language
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Busting the Myths (1.2)
The truth shall set you free…
• C is not as portable between architectures or
compilers as everyone claims
– ANSI language features ARE portable
– Processor specific libraries are NOT portable
– Processor specific code (peripherals, I/O, interrupts,
special features) are NOT portable
• C is NOT as efficient as assembly
– A good assembly programmer can usually do better than
the compiler, no matter what the optimization level – C
WILL use more memory
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Busting the Myths (2.2)
The truth shall set you free…
• There is NO SUCH THING as self documenting code –
despite what many C proponents will tell you
– C makes it possible to write very confusing code – just
search the net for obfuscated C code contests…
(www.ioccc.org)
– Not every line needs to be commented, but most blocks of
code should be
• Because of many shortcuts available, C is not always
friendly to new users – hence the need for
comments!
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
What we will cover in 13/L (1.3)
• “C” programming
– Using C in an Embedded
Environment
– Comments
– Variables, Identifiers and
Data Types
– Literal Constants
– Symbolic Constants
– printf() Library Function
– Operators
Gabriel Hugh Elkaim – Spring 2012
– Expressions and
Statements
– Making Decisions
– Loops
– Functions
– Multi-File Projects &
Storage Class Specifiers
CMPE-013/L: “C” Programming
What we will cover in 13/L (2.3)
• “C” programming (con’t) • Advanced Techniques
–
–
–
–
–
–
–
–
Arrays
Data Pointers
Function Pointers
Structures
Unions
Bit Fields
Enumerations
Macros with #define
Gabriel Hugh Elkaim – Spring 2012
–
–
–
–
–
–
–
State Machines
Recursion
Interrupts
Program decomposition
Abstraction
Scope
Static / Dynamic
Memory allocation
CMPE-013/L: “C” Programming
What we will cover in 13/L (3.3)
• Embedded “C” on a
microcontroller
– Specific issues with
uControllers
– Peripheral usage
– Reading documentation
Gabriel Hugh Elkaim – Spring 2012
• Testing and Debugging
– Commenting
– Test harnesses
– Incremental
development
– Issues with embedded
debugging
CMPE-013/L: “C” Programming
Key things we’ll enforce (1.2)
• Clean and clear style
– More important to adhere to established
guidelines than use the “right” style
– We’ll use (modified) Linux style guide
• Modularity and decomposition
– Code is segmented by functionality
– Proper use of .h and .c files
– Good use of functions for clean implementation
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Key things we’ll enforce (2.2)
• State Machines / Event Driven Programming
– Best way to design reactive systems
– Makes debugging much easier
• Incremental build and test
–
–
–
–
Every bit of code has a unit test
Unit test is designed with code block
Use of pseudo-code and comments
End to end code checks
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Concept of Ugly/Beautiful
•
Ugly Dog
• Beautiful Dog
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Concept of Ugly/Beautiful
•
Ugly Car
• Beautiful Car
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Concept of Ugly/Beautiful
•
Ugly Building
• Beautiful Building
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Concept of Ugly/Beautiful
•
•
Ugly Man
Beautiful Man
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Concept of Ugly/Beautiful
•
•
Ugly Woman
Beautiful Woman
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Concept of Ugly/Beautiful
/****************************************************************************
Function: RC_Init
Parameters
RCpins: an unsigned short with a 1 in each position to set the pin as an RC
servo pin, should be a bitwise OR of the #define'd RC_PORTxxx pins.
Returns
char: SUCCESS or ERROR
Description
Initializes the RC_Servo subsystem, sets each pin as a digital output, and
sets the uptime for each pin at 1.5msec, with a period of 20msec.
Notes: Uses TIMER4 with a rollover.
Author: Gabriel Hugh Elkaim, 2011.12.15 16:42
****************************************************************************/
char RC_Init(unsigned short int RCpins) {
char i, curPin;
unsigned short int CurrentTime;
dbprintf("\nInitializing the RC Servo Module.");
// Check if inputs are in range, and if already initialized
if ((RCpins == 0x000) || (RCpins > 0x2FF) || (RCstate != off)) {
return ERROR;
}
RCstate = init;
// Go through input and set each RC pin direction and force to low
for (i = 0; i < RCPINCOUNT; i++) {
curPin = (1 << i);
if (RCpins & curPin) {
RCpinMap[numRCPins] = i;
numRCPins++;
RC_upTime[i] = SERVOCENTER;
*RC_TRISCLR[i] = rcBitsMap[i]; // Sets pin direction to output
*RC_LATCLR[i] = rcBitsMap[i]; // Forces pin to low state
dbprintf("\nEnabling pin: 0x%X", curPin);
}
}
// Set up Timer #4 to overflow at more than 2msec, enable and set interrupt
OpenTimer4(T4_ON | T4_IDLE_STOP | T4_GATE_OFF | T4_PS_1_2 |
T4_32BIT_MODE_OFF | T4_SOURCE_INT, SERVOCENTER * uSEC);
ConfigIntTimer4(T4_INT_ON | T4_INT_PRIOR_4 | T4_INT_SUB_PRIOR_0);
mT4IntEnable(1);
RCstate = first;
return SUCCESS;
}
Gabriel Hugh Elkaim – Spring 2012
typedef char C;typedef long I;
typedef struct a{I t,r,d[3],p[2];}*A;
#define P printf
#define R return
#define V1(f) A f(w)A w;
#define V2(f) A f(a,w)A a,w;
#define DO(n,x) {I i=0,_n=(n);for(;i<_n;++i){x;}}
I *ma(n){R(I*)malloc(n*4);}mv(d,s,n)I *d,*s;{DO(n,d[i]=s[i]);}
tr(r,d)I *d;{I z=1;DO(r,z=z*d[i]);R z;}
A ga(t,r,d)I *d;{A z=(A)ma(5+tr(r,d));z->t=t,z->r=r,mv(z->d,d,r);
R z;}
V1(iota){I n=*w->p;A z=ga(0,1,&n);DO(n,z->p[i]=i);R z;}
V2(plus){I r=w->r,*d=w->d,n=tr(r,d);A z=ga(0,r,d);
DO(n,z->p[i]=a->p[i]+w->p[i]);R z;}
V2(from){I r=w->r-1,*d=w->d+1,n=tr(r,d);
A z=ga(w->t,r,d);mv(z->p,w->p+(n**a->p),n);R z;}
V1(box){A z=ga(1,0,0);*z->p=(I)w;R z;}
V2(cat){I an=tr(a->r,a->d),wn=tr(w->r,w->d),n=an+wn;
A z=ga(w->t,1,&n);mv(z->p,a->p,an);mv(z->p+an,w->p,wn);R z;}
V2(find){}
V2(rsh){I r=a->r?*a->d:1,n=tr(r,a->p),wn=tr(w->r,w->d);
A z=ga(w->t,r,a->p);mv(z->p,w->p,wn=n>wn?wn:n);
if(n-=wn)mv(z->p+wn,z->p,n);R z;}
V1(sha){A z=ga(0,1,&w->r);mv(z->p,w->d,w->r);R z;}
V1(id){R w;}V1(size){A z=ga(0,0,0);*z->p=w->r?*w->d:1;R z;}
pi(i){P("%d ",i);}nl(){P("\n");}
pr(w)A w;{I r=w->r,*d=w->d,n=tr(r,d);DO(r,pi(d[i]));nl();
if(w->t)DO(n,P("< ");pr(w->p[i]))else DO(n,pi(w->p[i]));nl();}
C vt[]="+{~<#,";
A(*vd[])()={0,plus,from,find,0,rsh,cat},
(*vm[])()={0,id,size,iota,box,sha,0};
I st[26]; qp(a){R a>='a'&&a<='z';}qv(a){R a<'a';}
A ex(e)I *e;{I a=*e;
if(qp(a)){if(e[1]=='=')R st[a-'a']=ex(e+2);a= st[ a-'a'];}
R qv(a)?(*vm[a])(ex(e+1)):e[1]?(*vd[e[1]])(a,ex(e+2)):(A)a;}
noun(c){A z;if(c<'0'||c>'9')R 0;z=ga(0,0,0);*z->p=c-'0';R z;}
verb(c){I i=0;for(;vt[i];)if(vt[i++]==c)R i;R 0;}
I *wd(s)C *s;{I a,n=strlen(s),*e=ma(n+1);C c;
DO(n,e[i]=(a=noun(c=s[i]))?a:(a=verb(c))?a:c);e[n]=0;R e;}
main(){C s[99];while(gets(s))pr(ex(wd(s)));}
CMPE-013/L: “C” Programming
Concept of Ugly/Beautiful
• Code can be ugly or beautiful
• We will strive to write beautiful code
• While you might not recognize it, yet, you will
by the end of this quarter.
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Software Architecture
• Often orthogonal to Project Management
• Can be the success or failure of a project
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Flow Chart and Pseudo-Code
• Pseudo-code is plain
English that explains in
coarse steps what the
code should do
– Not syntax specific
– Forms the basis for
your top-level
comment
– Hides details of
programming language
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Style Examples
• Adherence to a specific style
– Variables in camelCase with leading lower case
– Functions in CamelCase with leading Upper case
– #define (literal constants) are in UPPERCASE
• Exception: macros can look like functions if they act like one
– Variable and Function names are descriptive
• Eg: backingUpState = TRUE;
– Correct use of white space and indentation
– Correct placement of braces {}
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Development Tools Data Flow
C Source Files
C Compiler
.c
Assembly Source Files
(.asm or .s)
Assembly Source Files
(.asm or .s)
.s
Assembler
.s
Archiver
(Librarian)
Object File Libraries
(Archives)
(.lib or .a)
.o
Object
Files
Linker Script
(.lkr or .gld)
Executable
.hex
Linker
.a
Gabriel Hugh Elkaim – Spring 2012
Compiler
Driver
Program
.map
Memory Map
MPLAB® IDE
.cof
.gld
Debug Tool
COFF
Debug File
CMPE-013/L: “C” Programming
Development Tools Data Flow
C Compiler
C Source File
Preprocessor
.c
.h
C Header File
Compiler
Assembly Source File
Gabriel Hugh Elkaim – Spring 2012
.s
CMPE-013/L: “C” Programming
C Runtime Environment (1.2)
• C Compiler sets up a runtime environment
–
–
–
–
Allocates space for stack
Initialize stack pointer
Allocates space for heap
Copies values from Flash/ROM to variables in
RAM that were declared with initial values
– Clear uninitialized RAM
– Disable all interrupts
– Call main() function (where your code starts)
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
C Runtime Environment (2.2)
• Runtime environment setup code is
automatically linked into application by most
PIC® compiler suites
• Usually comes from:
– C30: crt0.s / crt0.o (crt = C RunTime)
• User modifiable if absolutely necessary
• Details will be covered in lab sections
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Fundamentals of C
A Simple C Program
Example
Preprocessor
Directives
Header File
#include <stdio.h>
#define PI 3.14159
int main(void)
{
float radius, area;
Constant Declaration
(Text Substitution Macro)
Variable Declarations
//Calculate area of circle
radius = 12.0;
area = PI * radius * radius;
printf("Area = %f", area);
Function
Comment
}
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Questions?
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming
Gabriel Hugh Elkaim – Spring 2012
CMPE-013/L: “C” Programming