1 Portability The material for this lecture is drawn, in part, from The Practice of Programming...
-
date post
19-Dec-2015 -
Category
Documents
-
view
212 -
download
0
Transcript of 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming...
![Page 1: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/1.jpg)
1
Portability
The material for this lecture is drawn, in part, fromThe Practice of Programming (Kernighan & Pike) Chapter 8
Professor Jennifer Rexford
http://www.cs.princeton.edu/~jrex
![Page 2: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/2.jpg)
2
Goals of this Lecture
• Learn to write code that works with multiple:• Hardware platforms• Operating systems• Compilers• Human cultures
• Why?• Moving existing code to a new context is easier/cheaper
than writing new code for the new context• Code that is portable is (by definition) easier to move;
portability reduces software costs• Relative to other high-level languages (e.g., Java), C is
notoriously non-portable
![Page 3: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/3.jpg)
3
The Real World is Heterogeneous
• Multiple kinds of hardware• 32-bit Intel Architecture• 64-bit IA, PowerPC, Sparc, MIPS, Arms, …
• Multiple operating systems• Linux• Windows, Mac, Sun, AIX, …
• Multiple character sets• ASCII• Latin-1, Unicode, …
• Multiple human alphabets and languages
![Page 4: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/4.jpg)
4
Portability
• Goal: Run program on any system• No modifications to source code required• Program continues to perform correctly
Ideally, the program performs well too
![Page 5: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/5.jpg)
5
C is Notoriously Non-Portable
• Recall C design goals…• Create Unix operating system and associated software• Reasonably “high level”, but…• Close to the hardware for efficiency
• So C90 is underspecified• Compiler designer has freedom to reflect the design of
the underlying hardware
• But hardware systems differ!• So C compilers differ
• Extra care is required to write portable C code
![Page 6: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/6.jpg)
6
General Heuristics
Some general portability heuristics…
![Page 7: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/7.jpg)
7
Intersection
(1) Program to the intersection• Use only features that are common to all target
environments• I.e., program to the intersection of features, not the
union
• When that’s not possible…
![Page 8: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/8.jpg)
8
Encapsulation
(2) Encapsulate• Localize and encapsulate features that are not in the
intersection• Use parallel source code files -- so non-intersection
code can be chosen at link-time• Use parallel data files – so non-intersection data (e.g.
textual messages) can be chosen at run-time
• When that’s not possible, as a last resort…
![Page 9: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/9.jpg)
9
Conditional Compilation
(3) Use conditional compilation
• And above all…
#ifdef __UNIX__ /* Unix-specific code */#endif…#ifdef __WINDOWS__ /* MS Windows-specific code */#endif…
![Page 10: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/10.jpg)
10
Test!!!
(4) Test the program with multiple:• Hardware (Intel, MIPS, SPARC, …)• Operating systems (Linux, Solaris, MS Windows, …)• Compilers (GNU, MS Visual Studio, …)• Cultures (United States, Europe, Asia, …)
![Page 11: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/11.jpg)
11
Hardware Differences
• Some hardware differences, and corresponding portability heuristics…
![Page 12: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/12.jpg)
12
Natural Word Size
• Obstacle: Natural word size• In some systems, natural word size is 4 bytes• In some (esp. older) systems, natural word size is 2
bytes• In some (esp. newer) systems, natural word size is 8
bytes
• C90 intentionally does not specify sizeof(int); depends upon natural word size of underlying hardware
![Page 13: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/13.jpg)
13
Natural Word Size (cont.)
(5) Don’t assume data type sizes• Not portable:
• Portable:
int *p;…p = malloc(4);…
int *p;…p = malloc(sizeof(int));…
![Page 14: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/14.jpg)
14
Right Shift
• Obstacle: Right shift operation• In some systems, right shift operation is logical
Right shift of a negative signed int fills with zeroes
• In some systems, right shift operation is arithmetic Right shift of a negative signed int fills with ones
• C90 intentionally does not specify semantics of right shift; depends upon right shift operator of underlying hardware
![Page 15: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/15.jpg)
15
Right Shift (cont.)
(6) Don’t right-shift signed ints
Not portable:
Portable:
…-3 >> 1…
Logical shift => 2147483646Arithmetic shift => -2
…/* Don't do that!!! */…
![Page 16: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/16.jpg)
16
Byte Order
• Obstacle: Byte order• Some systems (e.g. Intel) use little endian byte order
Least significant byte of a multi-byte entity is storedat lowest memory address
• Some systems (e.g. SPARC) use big endian byte order Most significant byte of a
multi-byte entity is storedat lowest memory address
00000101000000000000000000000000
1000100110021003
The int 5 at address 1000:
00000000000000000000000000000101
1000100110021003
The int 5 at address 1000:
![Page 17: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/17.jpg)
17
Byte Order (cont.)
(7) Don’t rely on byte order in code• Not portable:
• Portable:
int i = 5;char c;…c = *(char*)&i; /* Silly, but legal */
Little endian: c = 5Big endian: c = 0;
int i = 5;char c;…/* Don't do that! Or... */c = (char)i;
![Page 18: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/18.jpg)
18
Byte Order (cont.)
(8) Use text for data exchange• Not portable:
unsigned short s = 5;FILE *f = fopen("myfile", "w");fwrite(&s, sizeof(unsigned short), 1, f);
00000101 00000000
Run on a littleendian computer
Run on a bigendian computer:Reads 1280!!!
fwrite()writesraw data to a file
unsigned short s;FILE *f = fopen("myfile", "r");fread(&s, sizeof(unsigned short), 1, f);
fread() reads raw data from a file
myfile
![Page 19: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/19.jpg)
19
Byte Order (cont.)
• Portable:
unsigned short s = 5;FILE *f = fopen("myfile", "w");fprintf(f, "%hu", s);
00110101
fprintf() convertsraw data to ASCII text
Run on a big orlittle endiancomputer
Run on a big orlittle endiancomputer:Reads 5
myfile
unsigned short s;FILE *f = fopen("myfile", "r");fscanf(f, "%hu", &s);
fscanf()reads ASCIItext and converts to raw data
ASCII code for ‘5’
![Page 20: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/20.jpg)
20
Byte Order (cont.)
If you must exchange raw data…
(9) Write and read one byte at a time
unsigned short s = 5;FILE *f = fopen("myfile", "w");fputc(s >> 8, f); /* high-order byte */fputc(s & 0xFF, f); /* low-order byte */
00000000 00000101
Run on a big orlittle endiancomputer
Run on a big orlittle endiancomputer:Reads 5
unsigned short s;FILE *f = fopen("myfile", "r");s = fgetc(f) << 8; /* high-order byte */s |= fgetc(f) & 0xFF; /* low-order byte */
myfileDecide on big-endian dataexchange format
![Page 21: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/21.jpg)
21
OS Differences
• Some operating system differences, and corresponding portability heuristics…
![Page 22: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/22.jpg)
22
End-of-Line Characters
• Obstacle: Representation of “end-of-line”• Unix (including Mac OS/X) represents end-of-line as 1
byte: 00001010 (binary)• Mac OS/9 represents end-of-line as 1 byte: 00001101
(binary)• MS Windows represents end-of-line as 2 bytes:
00001101 00001010 (binary)
![Page 23: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/23.jpg)
23
End-of-Line Characters (cont.)
(10) Use binary mode for textual data exchange• Not portable:
Trouble if read via fgetc() on “wrong” operating system
FILE *f = fopen("myfile", "w");fputc('\n', f);
00001010 00001101 00001101 00001010
Run on Unix Run on Mac OS/9 Run on MS Windows
\n \r \r \n
Open the filein ordinarytext mode
![Page 24: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/24.jpg)
24
End-of-Line Characters (cont.)
• Portable:
No problem if read via fgetc() in binary mode on “wrong” operating system
I.e., there is no “wrong” operating system!
FILE *f = fopen("myfile", "wb");fputc('\n', f);
00001010
Run on Unix,Mac OS/9, orMS Windows
\n
Open the filein binary mode
![Page 25: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/25.jpg)
25
Data Alignment
• Obstacle: Data alignment• Some hardware requires data to be aligned on particular boundaries• Some operating systems impose additional constraints:
• Moreover…• If a structure must begin on an x-byte boundary, then it also must
end on an x-byte boundary Implication: Some structures must contain padding
OS char short int double
Linux 1 2 4 4
MS Windows 1 2 4 8
Start address must be evenly divisible by:
![Page 26: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/26.jpg)
26
Data Alignment (cont.)
(11) Don’t rely on data alignment• Not portable:
struct S { int i; double d;}…struct S *p;…p = (struct S*)malloc(sizeof(int)+sizeof(double));
Windows: ipad
d
Linux: i
d
Allocates 12 bytes;too few bytes onMS Windows
![Page 27: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/27.jpg)
27
Data Alignment (cont.)
• Portable:
struct S { int i; double d;}…struct S *p;…p = (struct S*)malloc(sizeof(struct S));
Windows: ipad
d
Linux: i
d
Allocates• 12 bytes on Linux• 16 bytes on MS Windows
![Page 28: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/28.jpg)
28
Character Codes
• Obstacle: Character codes• Some operating systems (e.g. IBM OS/390) use the
EBCDIC character code• Some systems (e.g. Unix, MS Windows) use the ASCII
character code
![Page 29: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/29.jpg)
29
Character Codes (cont.)
(12) Don’t assume ASCII• Not portable:
• A little better:
• Portable:
if ((c >= 65) && (c <= 90)) …
if ((c >= 'A') && (c <= 'Z')) …
#include <ctype.h>…if (isupper(c)) …
Assumes ASCII
Assumes that uppercase charcodes arecontiguous; nottrue in EBCDIC
For ASCII: (c >= 'A') && (c <= 'Z')For EBCDIC: ((c >= 'A') && (c <= 'I')) || ((c >= 'J') && (c <= 'R')) || ((c >= 'S') && (c <= 'Z'))
![Page 30: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/30.jpg)
30
Compiler Differences
• Compilers may differ because they:• Implement underspecified features of the C90 standard
in different ways, or• Extend the C90 standard
• Some compiler differences, and corresponding portability heuristics…
![Page 31: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/31.jpg)
31
Compiler Extensions
• Obstacle: Non-standard extensions• Some compilers offer non-standard extensions
![Page 32: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/32.jpg)
32
Compiler Extensions
(13) Stick to the standard language• For now, stick to C90 (not C99)• Not portable:
• Portable:
…for (int i = 0; i < 10; i++) …
int i;…for (i = 0; i < 10; i++) …
Many systems allowdefinition of loop controlvariable within forstatement, but a C90compiler reports error
![Page 33: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/33.jpg)
33
Evaluation Order
• Obstacle: Evaluation order• C90 specifies that side effects and function calls must be
completed at “;”• But multiple side effects within the same expression can
have unpredictable results
![Page 34: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/34.jpg)
34
Evaluation Order (cont.)
(14) Don’t assume order of evaluation
• Not portable:
• Portable (either of these, as intended):
strings[i] = names[++i];
i++;strings[i] = names[i];
strings[i] = names[i+1];i++;
i is incremented beforeindexing names; but has ibeen incremented beforeindexing strings?C90 doesn’t say
![Page 35: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/35.jpg)
35
Evaluation Order (cont.)
• Not portable:
• Portable (either of these, as intended):
printf("%c %c\n", getchar(), getchar());
i = getchar();j = getchar();printf("%c %c\n", i, j);
i = getchar();j = getchar();printf("%c %c\n", j, i);
Which call of getchar()is executed first? C90 doesn’t say
![Page 36: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/36.jpg)
36
Char Signedness
• Obstacle: Char signedness• C90 does not specify signedness of char• On some systems, char means signed char• On other systems, char means unsigned char
![Page 37: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/37.jpg)
37
Char Signedness (cont.)
(15) Don’t assume signedness of char• If necessary, specify “signed char” or “unsigned char”• Not portable:
• Portable:
int a[256];char c;c = (char)255;…… a[c] …
int a[256];unsigned char c;c = 255;…… a[c] …
If char is unsigned, then a[c] is a[255] => fineIf char is signed, then a[c] is a[-1] => out of bounds
![Page 38: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/38.jpg)
38
Char Signedness (cont.)
• Not portable:
• Portable:
int i;char s[MAX+1];for (i = 0; i < MAX; i++) if ((s[i] = getchar()) == '\n') || (s[i] == EOF)) break;s[i] = ‘\0’;
If char is unsigned, thenthis always is FALSE
int c, i;char s[MAX+1];for (i = 0; i < MAX; i++) { if ((c = getchar()) == '\n') || (c == EOF)) break; s[i] = c;}s[i] = ‘\0’;
![Page 39: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/39.jpg)
39
Library Differences
• Some library differences, and corresponding portability heuristics…
![Page 40: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/40.jpg)
40
Library Extensions
• Obstacle: Non-standard functions• “Standard” libraries bundled with some development
environments (e.g. GNU, MS Visual Studio) offer non-standard functions
![Page 41: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/41.jpg)
41
Library Extensions
(16) Stick to the standard library functions• For now, stick to the C90 standard library functions• Not portable:
• Portable:
char *s = "hello";char *copy;…copy = strdup(s);…
char *s = "hello";char *copy;…copy = (char*)malloc(strlen(s) + 1);strcpy(copy, s);…
strdup() is available inmany “standard” libraries,but is not defined in C90
![Page 42: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/42.jpg)
42
Cultural Differences
• Some cultural differences, and corresponding portability heuristics…
![Page 43: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/43.jpg)
43
Character Code Size
• Obstacle: Character code size• United States
Alphabet requires 7 bits => 1 byte per character Popular character code: ASCII
• Western Europe Alphabets require 8 bits => 1 byte per character Popular character code: Latin-1
• China, Japan, Korea, etc. Alphabets require 16 bits => 2 bytes per character Popular character code: Unicode
![Page 44: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/44.jpg)
44
Character Code Size
(17) Don’t assume 1-byte character code size• Not portable:
• Portable: C90 has no good solution C99 has “wide character” data type, constants, and associated
functions
But then beware of byte-order portability problems! Future is not promising
char c = 'a';
#include <stddef.h>…wchar_t c = L'\x3B1'; /* Greek lower case alpha */
![Page 45: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/45.jpg)
45
Human Language
• Obstacle: Humans speak different natural languages!
![Page 46: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/46.jpg)
46
Human Language (cont.)
(18) Don’t assume English
• Not portable:
• Can’t avoid natural language! So…
/* somefile.c */
…printf("Bad input");…
![Page 47: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/47.jpg)
47
Human Language (cont.)
• Encapsulate code
Choose appropriate“message.c” file atlink-time
/* somefile.c */
#include "messages.h"…printf(getMsg(5));…
/* englishmessages.c */char *getMsg(int msgNum) { switch(msgNum) { … case 5: return "Bad input"; … }}
/* spanishmessages.c */char *getMsg(int msgNum) { switch(msgNum) { … case 5: return "Mala entrada"; … }}
/* messages.h */char *getMsg(int msgNum);
Me
ss
age
s m
od
ule
,w
ith
mu
ltip
le im
ple
men
tati
on
s
![Page 48: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/48.jpg)
48
Human Language (cont.)
• Maybe even better: encapsulate data
Choose appropriate “message.txt” file at run-time
/* messages.c */
enum {MSG_COUNT = 100};char *getMsg(int msgNum) { static char *msg[MSG_COUNT]; static int firstCall = 1; if (firstCall) { <Read all messages from appropriate messages.txt file into msg> firstCall = 0; } return msg[msgNum];}
/* englishmessages.txt */
…Bad input…
/* spanishmessages.txt */
…Mala entrada…
/* messages.h */char *getMsg(int msgNum);
Me
ss
age
s m
od
ule
![Page 49: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/49.jpg)
49
Summary
• General heuristics(1) Program to the intersection(2) Encapsulate(3) Use conditional compilation (as a last resort)(4) Test!!!
![Page 50: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/50.jpg)
50
Summary (cont.)
• Heuristics related to hardware differences(5) Don’t assume data type sizes(6) Don’t right-shift signed ints(7) Don’t rely on byte order in code(8) Use text for data exchange(9) Write and read 1 byte at a time
• Heuristics related to OS differences(10) Use binary mode for textual data exchange(11) Don’t rely on data alignment(12) Don’t assume ASCII
![Page 51: 1 Portability The material for this lecture is drawn, in part, from The Practice of Programming (Kernighan & Pike) Chapter 8 Professor Jennifer Rexford.](https://reader030.fdocuments.us/reader030/viewer/2022032800/56649d3f5503460f94a18454/html5/thumbnails/51.jpg)
51
Summary (cont.)
• Heuristics related to compiler differences(13) Stick to the standard language(14) Don’t assume evaluation order(15) Don’t assume signedness of char
• Heuristic related to library differences(16) Stick to the standard library
• Heuristics related to cultural differences(17) Don’t assume 1-byte char code size(18) Don’t assume English