1 / 45

S07: The C Language

int i;main (){for(; i [&quot;]&lt; i ;++ i ){-- i ;}&quot;];read('-'-'-', i +++&quot;hell o, world!<br>&quot;,'/'/'/'));}read( j,i,p ){write(j/ p+p,i --- j,i / i );} -- Dishonorable mention, Obfuscated C Code Contest, 1984. (Author requested anonymity .). S07: The C Language.

ian-chavez
Download Presentation

S07: The C Language

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. inti;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.) S07:The C Language Required: PM: Ch 6, pgs 63-80 PM: Ch 8.4, pgs114-118 Recommended: K&R, Chapters 1-4 C programC++ Compiler 6.5VariablesGlobal VariablesExpressionsOperatorsControl StatementsFunctionsLibrary Functions

  2. CS 124 The C Language

  3. Learning Objectives… After 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. • Outline 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. The C Language

  4. Levels of Abstraction Problems Algorithms High Level Languages Language Assembly code Machine (ISA) Architecture Machine code Microarchitecture MSP430 Architecture Circuits Logic gates, multiplexers, memory, etc. Transistors Devices The C Language

  5. 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++ …. The C Language

  6. High Level Languages 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; • Provide abstraction of underlying hardware • Hide low level details (ISA) from programmer • Portable software (works on different ISAs) printf("Hello World!"); • 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 The C Language

  7. High Level Languages 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 The C Language

  8. Source code temp=v[i]; v[i]=v[i+1]; v[i+1]=temp; Interpreter Compilers vs Interpreters Compilers vs Interpreters Object code Assembly temp=v[i]; v[i]=v[i+1]; v[i+1]=temp; Compiler Application Assembler MOV.B 0x0001(SP),R14 MOV.W SP,R15 INCD.W R15 ADD.W R15,R14 MOV.B @R14,0x0000(SP) MOV.B 0x0001(SP),R14 INC.W R14 415E 0001 410F 532F 5F0E 4EE1 0000 415E 0001 531E High-level language statements = Data Path = Executable The C Language

  9. The C Language 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

  10. Assembler Code C/C++ Code Object Code Machine Code The C Language Compiling a C Program The C Language

  11. C Preprocessor 1st Pass 2nd Pass Code Generation Source Code Analysis Symbol Table Library & Object Files ExecutableImage The C Language Compiling a C Program C Source Code Preprocessor Text C Compiler Preprocessed C source code Assembly Code Object Code Assembler Linker Machine Code The C Language

  12. 1st C Program A First 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. //************************************ // blinky.c: Software Toggle P1.0 //************************************ #include "msp430.h" volatile unsigned inti; // no optimization void main(void) { WDTCTL = WDTPW | WDTHOLD; // stop watchdog P4DIR |= 0x40; // P4.6 output for (;;) // loop { P4OUT ^= 0x40; // toggle P4.6 while (--i); // delay } } All C programs must have a main()routine. Stop WD w/Password Allocate a RAM variable (.bss i,2) Set P4.6 as output Loop forever Toggle P4.6 Delay 65,536 The C Language

  13. Style 2 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; } C Style Style • Use lots of comments /* This is a comment */ // This is a single line comment • 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... The C Language

  14. C Preprocessor 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 #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); The C Language

  15. Streaming I/O in C

  16. C Stream I/O 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" The C Language

  17. 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. The C Language

  18. C Stream I/O Printf Output in C String literal • 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("\nInascii, 65 is %c. ", 65); • Output: Hello world 5 plus 6 is 11 In hex it is b Hello, I am Bambi. In ascii, 65 is A. Decimal Integer Hex Integer Newline Character String The C Language

  19. LCD I/O LCD on Ports 2,3, & 4 Command/Data Read/Write MSP430F2274 Parallel 8-bit Data Enable The C Language

  20. LCD I/O RBX430_lcd.h Prototypes • uint8 lcd_init(void); • void lcd_clear(uint8 value); • 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(constuint8* 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); The C Language

  21. LCD I/O LCD – 160 x 160 x 5 Pixels // 5 x 8 pixel Characters lcd_cursor(40, 60); lcd_printf("Hello World!"); Hello World! Y (0-159)  X (0-159)  The C Language

  22. 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. The C Language

  23. C Program 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 The C Language

  24. Variables & Operators 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 The C Language

  25. C Preprocessor 1st Pass 2nd Pass Code Generation Source Code Analysis Symbol Table Library & Object Files ExecutableImage The C Language Compiling a C Program Preprocessor Text C Source Code C Compiler Preprocessed C source code Assembly Code Object Code Linker Assembler Machine Code The C Language

  26. Variables & Operators MSP430 C Variable Data Types The C Language

  27. Variables & Operators Variable Declarations int i,j,k; // declaring more than one variable int 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 names int _compilerVar; // compiler uses _ as first char char newline = ‘\n’; // a character with an initializer char lineBuffer[32]; // an array of 32 chars (a string) double bananasPerMonkey; // floating point declarations double hugeNumber = 1.0E33; // positive exponent double tinyNumber = 1.0E-33; // negative exponent double fractionThing = 3.33333; // no exponent The C Language

  28. Scope 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; ...} int chimp; { // begin block ...} The C Language

  29. Variables 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? The C Language

  30. Variables 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 The C Language

  31. 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. Sample P1IN when dcnt equals 0 Pressing a switch sets dcnt volatile intswitches,dcnt void 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. The C Language

  32. Operators Operators and Expressions • Expressions are formed by combining variables with operators and ALWAYS return a single value in C. i = 5; i < j; 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 The C Language

  33. 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; Stack sub.w #2,sp mov.w #9,0(sp) 0x05fa 0x05fc 0x05fe sp 0x05f0 X sp ... add.w #4,0(sp) 0x0600 The C Language

  34. Operators Arithmetic / Relational Operators x + y x – y x * y x / y x % y • 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 equality x != y inequality x < y less-than x <= y less-than-or-equal x > y greater-than x >= y greater-than-or-equal The C Language

  35. 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) x << y shift x y-places to the left (add zeros) x >> y shift x y-places to the right (sign extend) The C Language

  36. Same Same Operators 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 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; The C Language

  37. Expressions 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. int x = 1; x is declared an integer x = x + 4.3; integer + floating point ?? (result is x = 5) The C Language

  38. Bitwise Relational Relational Bitwise Bitwise Bitwise Logical Logical Expressions Operator Precedence/Associativity The C Language

  39. Expressions 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); Note: All of the expression on the right is considered parenthesized. The C Language

  40. y z 0 1 x x ? y : z Expressions Conditional Expressions • Conditional expression • C multiplexor operation • Format: <boolean> ? <true expression> : <false expression> • Example: x ? y : z This expression returns the value of y if x != 0, otherwise it returns the value of z printf("%d dog%s", dogs, (dogs == 1) ? "" : "s"); The C Language

  41. Compilation Examples 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,SP 0x869a: 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),R15 0x86b4: 512F ADD.W @SP,R15 0x86b6: 811F 0004 SUB.W 0x0004(SP),R15 0x86ba: 4F81 0002 MOV.W R15,0x0002(SP) x05f4 x05f6 x05f8 SP x x05fa y x05fc z x05fe ret adr x0600 Stack The C Language

  42. Compilation Examples C to Assembly – Example 2 main: 0x8040: 8031 000A SUB.W #0x000a,SP 0x8044: 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),R12 0x805c: 411D 0006 MOV.W 0x0006(SP),R13 0x8060: 12B0 80DA CALL #__mpyi 0x8064: 4C81 0008 MOV.W R12,0x0008(SP) 0x8068: 430C CLR.W R12 0x806a: 5031 000A ADD.W #0x000a,SP 0x806e: 4130 RET __mpyi: 0x80da: 430E CLR.W R14 mpyi_add_loop: 0x80dc: C312 CLRC 0x80de: 100C RRC R12 0x80e0: 2801 JLO (shift_test_mpyi) 0x80e2: 5D0E ADD.W R13,R14 shift_test_mpyi: 0x80e4: 5D0D RLA.W R13 0x80e6: 930C TST.W R12 0x80e8: 23F9 JNE (mpyi_add_loop) 0x80ea: 4E0C MOV.W R14,R12 0x80ec: 4130 RET int main(int argc, char** argv) { unsigned int x = 7; unsigned int y = 5; unsigned int z; z = x * y; return 0; } x05f4 SP argc (r12) x05f6 argv (r13) x05f8 x x05fa y x05fc z x05fe ret adr x0600 Stack The C Language

  43. IdentifierTypeStorage ClassOffsetScope inGlobal int Static absolute global inLocalA int Auto 2(SP) main inLocalB int Auto 4(SP) main outLocal int Auto 0(SP) main SymbolTable Compilation Examples 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 int inGlobal; void main(void) { int outLocal; int inLocalA; int inLocalB; outLocal = inGobal + inLocalA + inLocalB; return; } The C Language

  44. Quiz 7.1 • 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. The C Language

  45. The C Language

More Related