1. ISBN 0-321-33025-0 Chapter 5 Names, Bindings, Type Checking, and Scopes

2. 1-2 Chapter 5 Topics Introduction Names Variables The Concept of Binding Type Checking Strong Typing Type Compatibility Scope and Lifetime Referencing Environments Named Constants

3. 1-3 Imperative Languages Imperative languages are abstractions of von Neumann architecture –Memory stores both instructions and data –Processor provides operations for modifying the contents of the memory

4. 1-4 Memory Cells and Variables The abstractions in a language for the memory cells of the machine are variables. –In some cases, the characteristics of the abstractions are very close to the characteristics of the cells; an example of this is an integer variable, which is usually represented directly in one or more bytes of memory. –In other cases, the abstractions are far removed from the organization of the hardware memory, as with a three-dimensional array, which requires a software mapping function to support the abstraction.

5. 1-5 Attributes of Variables A variable can be characterized by a collection of properties, or attributes, the most important of which is type, a fundamental concept in programming languages. The design of the data types of a language requires that a variety of issues be considered. –Among the most important of these issues are the scope and lifetime of variables and type equivalence. Related to the first two are the issues of type checking and initialization.

6. 1-6 C-based Languages In this book, the author uses the phrase C-based languages to refer to C, C++, Java, and C#.

7. 1-7 Name One of the fundamental attributes of variables: names, which have broader use than simply for variables. A name is a string of characters used to identify some entity in a program.

8. 1-8 Other Usage of the Name Attribute of Variables Names are also associated with labels, subprograms, formal parameters, and other program constructs. The term identifier is often used interchangeably with name.

9. 1-9 Design Issues for Names –Are names case sensitive? –Are special words reserved words or keywords?

10. 1-10 Length of Names Length –If too short, they cannot be connotative –Length examples: FORTRAN I : maximum 6 C 89 : –no length limitation on its internal names »Only the first 31 are significant –external names (defined outside functions and handled by linkers) »are restricted to 6 characters. C# and Java : no limit, and all are significant C++ : no limit, but implementers often impose one –They do this so the symbol table in which identifiers are stored during compilation need not be too large, and also to simplify the maintenance of that table.

11. 1-11 Name Forms Names in most programming languages have the same form: a letter followed by a string consisting of letters, digits, and underscore character (_). –In the 1970s and 1980s, underscore characters were widely used to form names. E.g. my_stack –Nowadays, in the C-based languages, underscore form names are largely replaced by camel notation. E.g. myStack

12. 1-12 Embedded Spaces in Names In versions of Fortran prior to Fortran 90, names could have embedded spaces, which were ignored. –For example, the following two names were equivalent: Sum Of Salaries

13. 1-13 Case Sensitivity In many languages, notably the C-based languages, uppercase and lowercase letters in names are distinct –For example, the following three names are distinct in C++ : rose, ROSE, and Rose.

14. 1-14 Drawbacks of Case Sensitivity detriment to readability –Names that look very similar in fact denote different entities. –Case sensitivity violates the design principle that language constructs that look the same should have the same meaning. detriment to writability –The need to remember specific case usage makes it more difficult to write correct programs.

15. 1-15 Special Words Special words in programming languages are used –to make programs more readable by naming actions to be performed. –to separate the syntactic entities of programs. In most languages, special words are classified as reserved words, but in some they are only keywords. –P.S.: In program code examples in this book, special words are presented in boldface.

16. 1-16 Keywords A keyword is a word of a programming language that is special only in certain contexts.

17. 1-17 Example of Keywords Fortran is one of the languages whose special words are keywords. –In Fortran, the word Real, when found at the beginning of a statement and followed by a name, is considered a keyword that indicates the statement is a declarative statement. –However, if the word Real is followed by the assignment operator, it is considered a variable name. –These two uses are illustrated in the following: Real Apple Real = 3.4 Fortran compilers and Fortran program readers must recognize the difference between names and special words by context.

18. 1-18 Reserved Words A reserved word is a special word of a programming language that can NOT be used as a name.

19. 1-19 Advantages of Reserved Words As a language design choice, reserved words are better than keywords because the ability to redefine keywords can lead to readability problems.

20. 1-20 Drawback Example of Keywords In Fortran, one could have the statements Integer Real Real Integer which declare the program variable Real to be of Integer type and the variable Integer to be of Real type. In addition to the strange appearance of these declaration statements, the appearance of Real and Integer as variable names elsewhere in the program could be misleading to program readers.

21. 1-21 Variables A program variable is an abstraction of a computer memory cell or collection of cells. Variables can be characterized as a sextuple of attributes: –Name –Address –Value –Type –Lifetime –Scope

22. 1-22 Benefits of Using Variables The move from machine languages to assembly languages was largely one of replacing absolute numeric memory addresses with names, making programs far more readable and thus easier to write and maintain. That above step also provided an escape from the problem of manual absolute addressing, because the translator that converted the names to actual addresses also chose those addresses.

23. 1-23 Address The address of a variable is the machine memory address with which it is associated. In many languages, it is possible for the same variable name to be associated with different addresses at different places and at different times in the program.

24. 1-24 How Parameters and Local Variables Are Represented in an Object File? abc(int aa) {int bb; bb=aa; : } abc: function prologue *(%ebp-4)=*(%ebp+8) function epilogue aa return address previous frame point bb ebp a C function equivalent assembly code P.S.: function prologue and function epilogue are added by a compiler

25. 1-25 The Same Names in Different Functions Are Associated with Different Addresses A program can have two subprograms, subl and sub2, each of which defines a variable that uses the same name, say sum. Because these two variables are independent of each other, a reference to sum in subl is unrelated to a reference to sum in sub2.

26. 1-26 The Same Names in Different Executions May Be Associated with Different Addresses If a subprogram has a local variable that is allocated from the run-time stack when the subprogram is called, different calls may result in that variable having different addresses. –These are in a sense different instantiations of the same variable.

27. 1-27 Memory Allocation of Local Variables b return address add_g address of G’s frame point C[0] H’s stack frame G(int a) { int i; H(3); add_g: i++; } H(int b) { char c[100]; int i; while((c[i++]=getch())!=EOF) { } } C[99] G’s stack frame i i stack high address low address

28. 1-28 L-value The address of a variable is sometimes called its L-value, because that is what is required when a variable appears in the left side of an assignment statement.

29. 1-29 Aliases It is possible to have multiple variables that have the same address. When more than one variable name can be used to access a single memory location, the names are called aliases.

30. 1-30 Disadvantages of Aliases Aliasing is a hindrance to readability because it allows a variable to have its value changed by an assignment to a different variable. –For example, if variables total and sum are aliases, any change to total also changes sum and vice versa. –A reader of the program must always remember that total and sum are different names for the same memory cell. –Because there can be any number of aliases in a program, this is very difficult in practice. Aliasing also makes program verification more difficult.

31. 1-31 Ways to Create Aliases Aliases can be created in programs in several different ways. C and C++ : union types. Two pointer variables are aliases whey they point to the same memory location. Reference variables : when a C++ pointer is set to point at a named variable, the pointer, when dereferenced, and the variable’s name are aliases.

32. 1-32 Type The type of a variable determines –the range of values the variable can store and –the set of operations that are defined for values of the type. For example, the type int in Java specifies –a value range of -2147483648 to 2147483647 and –arithmetic operations for addition, subtraction, multiplication, division, and modulus.

33. 1-33 Value The value of a variable is the contents of the memory cell or cells associated with the variable.

34. 1-34 Abstract Cells It is convenient to think of computer memory in terms of abstract cells, rather than physical cells. The physical cells, or individually addressable units, of most contemporary computer memories are byte-sized, with a byte usually being eight bits in length. –This size is too small for most program variables. We define an abstract memory cell to have the size required by the variable with which it is associated.

35. 1-35 Example Although floating-point values may occupy four physical bytes in a particular implementation of a particular language, we think of a floating-point value as occupying a single abstract memory cell. We consider the value of each simple nonstructured type to occupy a single abstract cell. Henceforth, when we use the term memory cell, we mean abstract memory cell.

36. 1-36 r-value A variable's value is sometimes called its r-value because it is what is required when the variable is used on the right side of an assignment statement. To access the r-value, the L-value must be determined first. –Such determinations are not always simple. For example, scoping rules can greatly complicate matters, as is discussed in Section 5.8.

37. 1-37 Binding and Binding Time In a general sense, a binding is an association, such as between an attribute and an entity or between an operation and a symbol. The time at which a binding takes place is called binding time.

38. 1-38 Possible Binding Time Bindings can take place at: –language design time, –language implementation time, –compile time, –link time, –load time, –run time.

39. 1-39 Different Language Syntactic Unit Has Different Binding Time for Different Attribute The asterisk symbol ( * ) is usually bound to the multiplication operation at language design time. A data type, such as int in C, is bound to a range of possible values at language implementation time. A variable in a Java program is bound to a particular data type at compile time. A variable may be bound to a storage cell when the program is loaded into memory. –e.g.: global variables and static variables. –That same binding does not happen until run time in some cases, as with variables declared in Java method. A call to a library subprogram is bound to the subprogram code at link time.

40. 1-40 Example Consider the following C assignment statement count = count + 5; Some of the bindings and their binding times for the parts of this assignment statement are as follows: –The type of count is bound at compile time –The set of possible values of count is bound at compiler design time/language implementation time. –The meaning of the operator symbol + is bound at compile time, when the types of its operands have been determined. The symbol + may have different usage in a programming Language, such as addition of integers or addition of floating point numbers. –The value of count is bound at execution time with this assignment

41. 1-41 Static Binding A binding is static if it first occurs before run time and remains unchanged throughout program execution.

42. 1-42 Dynamic Binding If a binding first occurs during run time or can change in the course of program execution, it is called dynamic.

43. 1-43 Type Bindings Before a variable can be referenced in a program, it must be bound to a data type. Two important aspects of type bindings are –how the type is specified. –when the binding takes place. Types can be specified statically through some form of –explicit declaration –implicit declaration Both explicit and implicit declarations create static bindings to types.

44. 1-44 Explicit Declarations An explicit declaration is a statement in a program that lists variable names and specifies that they are a particular type. –Most programming languages designed since the mid-1960s require explicit declarations of ALL variables ( Perl, JavaScript, Ruby, and ML are some exceptions).

45. 1-45 An implicit declaration is a means of associating variables with types through default conventions instead of declaration statements. –In this case, the FIRST appearance of a variable name in a program constitutes its implicit declaration. –Several widely used languages whose initial designs were done before the late 1960s – notably Fortran, PL/I, and BASIC – have implicit declarations. Implicit Declarations

46. 1-46 Implicit Declaration Example In Fortran, an identifier that appears in a program that is not explicitly declared is implicitly declared according to the following convention: –If the identifier begins with one of the letters I, J, K, L, M, or N, or their lowercase versions, it is implicitly declared to be Integer type. –In all other cases, it is implicitly declared to be Real type.

47. 1-47 Drawbacks of Implicit Declarations Although they are a minor convenience to programmers, implicit declarations can be detrimental to reliability because they prevent the compilation process from detecting some typographical and programmer errors. –For example, in Fortran, variables that are accidentally left undeclared by the programmer are given default types and unexpected attributes, which could cause subtle errors that are difficult to diagnose.

48. 1-48 Disable Implicit Declarations in Fortran Many Fortran programmers now include the declaration – Implicit none – in their programs. This declaration instructs the compiler to no implicitly declare any variables.

49. 1-49 Method to Avoid Implicit Declarations Some of the problems with implicit declarations can be avoided by requiring names for specific types to begin with particular special characters. For example, in Perl, –any name that begins with $ is a scalar, which can store either a string or a numeric value.scalar –any name beginning with @ is an array –The above rules create different name spaces for different type variables. In this scenario, the names @apple and %apple are unrelated, because each is from a different name space. –Furthermore, a program reader always knows the type of a variable when reading its name.

50. 1-50 Declarations and Definitions In C and C++, one must sometimes distinguish between declarations and definitions. Declarations specify types and other attributes but do not cause allocation of storage. Definitions specify attributes and cause storage allocation,

51. 1-51 Number of Declarations and Definitions For a specific name, a C program can have ANY number of compatible declarations, but only a SINGLE definition. One purpose of variable declarations in C is to provide the type of a variable defined external to a function but used in the function. It tells the compiler the type of a variable and that it is defined elsewhere.

52. 1-52 Function Definition and Function Prototype The idea in previous slides carries over to the functions in C and C++, where prototypes declare names and interfaces, but not the code of functions. Function definitions, on the other hand, are complete.

53. 1-53 Dynamic Type Binding With dynamic type binding: –the type is not specified by a declaration statement, nor can it be determined by the spelling of its name. –the variable is bound to a type when it is assigned a value in an assignment statement. When the assignment statement is executed, the variable being assigned is bound to the type of the value of the expression on the right side of the assignment.

54. 1-54 The Primary Advantage of Dynamic Variable Type Binding A great deal of programming flexibility.

55. 1-55 Creation of Generic Programs A program to process a list of data in a language that uses dynamic type binding can be written as a generic program, meaning that it is capable of dealing with data of any numeric type. Whatever type data is input will be acceptable, because the variables in which the data is to be stored can be bound to the correct type when the data is assigned to the variables after input. By contrast, because of static binding of types, one cannot write a C++ or Java program to process a list of data without knowing the type of that data.

56. 1-56 Example of Dynamic Binding In PHP, and JavaScript, the binding of a variable to a type is dynamic. –For example, a JavaScript script may contain the following statement: list = [10.2, 3.5] Regardless of the previous type of the variable named list, this assignment causes it to become a single-dimensioned array of numeric elements of length 2. –If the statement list = 47 followed the assignment above, list would become a numeric scalar variable.

57. 1-57 Dynamic Binding Is Less Reliable in Error Detection Dynamic type binding causes programs to be less reliable, because the error detection capability of the compiler is diminished relative to a compiler for a language with static type bindings.

58. 1-58 Dynamic Binding Results in Weak Type- related Error Detection Dynamic type binding allows any variable to be assigned a value of any type. Incorrect types of right sides of assignments are not detected as errors; rather the type of the left side is simply changed to the incorrect type.

59. 1-59 Example of Drawbacks of Dynamic Type Binding Suppose –that in a particular JavaScript program, i and x are currently storing scalar numeric values, and y is currently storing an array. –that the program needs the assignment statement i = x; but because of a keying error, it has the assignment statement i = y; In Javascript (or any other language that uses dynamic type binding), no error is detected in this statement by the interpreter - i is simply changed to an array. But later uses of i will expect it to be a scalar, and correct results will be impossible. In a language with static type binding, the compiler would detect the error in the assignment i = y, and the program would not get to execution.

60. 1-60 Disadvantages of Dynamic Binding in terms of Cost Perhaps the greatest disadvantage of dynamic type binding is cost. The cost of implementing dynamic attribute binding is considerable, particularly in execution time. Type checking must be done at run time. Furthermore, every variable must have a run-time descriptor associated with it to maintain the current type. The storage used for the value of a variable must be of varying size, because different type values require different amounts of storage.

61. 1-61 Implementation Concerns Languages that have dynamic type binding for variables are usually implemented using pure interpreters rather than compilers. Up to date computers do not have instructions whose operand types are not known at compile time. –Therefore, a compiler cannot build machine instructions for the expression A + B if the types of A and B are not known at compile time. Pure interpretation typically takes at least ten times as long as to execute equivalent machine code.

62. 1-62 Type Inference ML is a programming language that supports both functional and imperative programming (Milner et al., 1990). ML employs an interesting type inference mechanism, in which the types of most expressions can be determined without requiring the programmer to specify the types of the variables.

63. 1-63 General Syntax of a ML Function fun function_name(formal parameters) = expression; The value of the expression is returned by the function.

64. 1-64 Example (1) The function declaration fun circumf(r) = 3.14159 * r * r; specifies a function that takes a floating- point argument ( real in ML ) and produces a floating-point result. The types are inferred from the type of the constant in the expression.

65. 1-65 Example (2) Likewise, in the function fun times10(x) = 10 * x; the argument and functional value are inferred to be of type int.

66. 1-66 Example (3) Consider the following ML function: fun square(x) = x * x; –ML determines the type of both the parameter and the return value from the * operator in the function definition. Because this is an arithmetic operator, the type of the parameter and the function are assumed to be numeric. –In ML, the default numeric type to be int. So, it is inferred that the type of the parameter and the return value of square is int.

67. 1-67 Example (4) If square were called with a floating-point value, as in square(2.75); it would cause an error, because ML does not coerce real values to int type.

68. 1-68 Example (5) If we wanted square to accept real parameters, it could be rewritten as fun square(x) : real = x * x; Because ML does not allow overloaded functions, this version could no coexist with earlier int version.

69. 1-69 Allocation and Deallocation of Memory Cells The memory cell to which a variable is bound somehow must be taken from a pool of available memory. This process is called allocation. Deallocation is the process of placing a memory cell that has been unbound from a variable back into the pool of available memory.

70. 1-70 The Lifetime of a Variable The lifetime of a variable is the time during which the variable is bound to a specific memory location. So the lifetime of a variable begins when it is bound to a specific cell and ends when it is unbound from that cell.

71. 1-71 Categories of Scalar Variables

72. 1-72 Categories of Scalar Variables It is convenient to separate scalar (unstructured) variables into four categories, according to their lifetimes: –static, –stack-dynamic, –explicit heap-dynamic, –implicit heap-dynamic.

73. 1-73 Static Variables Static variables are those that are bound to memory cells before program execution begins and remain bound to those same memory cells until program execution terminates.

74. 1-74 Applications of Static Variables Globally accessible variables are often used throughout the execution of a program, thus making it necessary to have them bound to the same storage during that execution. Sometimes it is convenient to have variables that are declared in subprograms be history-sensitive, that is, have them retain values between separate executions of the subprogram. –This is a characteristic of a variable that is statically bound to storage.

75. 1-75 Advantages of Static Variables Another advantage of static variables is efficiency. –All addressing of static variables can be direct ; other kinds of variables often require indirect addressing, which is slower. –Furthermore, no run-time overhead is incurred for allocation and deallocation of static variables, although this time is often neglibible.

76. 1-76 Disadvantages of Static Variables reduced flexibility –in a language that has only variables that are statically bound to storage, recursive subprograms can not supported. storage cannot be shared among variables –For example, suppose a program has two subprograms, both of which require large unrelated arrays. Further suppose that the two subprograms are never active at the same time If the arrays are static, they cannot share the same storage for their arrays.

77. 1-77 Example C and C++ allow programmers to include the static specifier on a variable definition in a function, making the variables it defines static.

78. 1-78 Elaboration of the Declaration Statements of Stack-Dynamic Variables Stack-dynamic variables are those whose storage bindings are created when their declaration statements are elaborated, but whose types are statically bound. Elaboration of such a declaration refers to the storage allocation and binding process indicated by the declaration, which takes place when execution reaches the code to which the declaration is attached. Elaboration occurs during run time.

79. 1-79 Memory Allocation of Stack-Dynamic Variables Occur during Run-time b return address add_g address of G’s frame point C[0] H’s stack frame G(int a) { int i; H(3); add_g: i++; } H(int b) { char c[100]; int i; while((c[i++]=getch())!=EOF) { } } C[99] G’s stack frame i i stack high address low address

80. 1-80 Example The variable declarations that appear at the beginning of a Java method are elaborated when the method is called. The variables defined by those declarations are deallocated when the method completes its execution.

81. 1-81 The Location That Stores Stack- Dynamic Variables As their name indicates, stack-dynamic variables are allocated from the run-time stack.

82. 1-82 Storage Binding of a Variable May Occur before Its Declaration Some languages – for example, C and Java –allow variable declarations to occur anywhere a statement can appear. In some implementations of these languages, all of the stack-dynamic variables declared in a function or method (not including those declared in nested blocks) may be bound to storage at the beginning of execution of the function or method, even though the declarations of some of these variables do not appear at the beginning.

83. 1-83 Stack-Dynamic Variables and Recursive Programs To be useful, at least in most cases, recursive subprograms require some form of dynamic local storage so that each active copy of the recursive subprogram has its own version of the local variables. These needs are conveniently met by stack- dynamic variables.

84. 1-84 Memory Sharing The introduction of stack-dynamic variables allows all subprograms to share the same memory space for their locals.

85. 1-85 Disadvantages of Stack-Dynamic Variables the run-time overhead of allocation and deallocation. –however the overhead is not significant, because all of the stack-dynamic variables that are declared at the beginning of a subprogram are allocated and deallocated togerher. slower accesses –Indirect addressing is required subprograms cannot be history sensitive.

86. 1-86 Examples of Stack-Dynamic Variables In Java, C++ and C#, local variables defined in methods are by default stack-dynamic. In Pascal and Ada, all non-heap variables defined in subprograms are stack-dynamic.

87. 1-87 Explicit Heap-Dynamic Variables Explicit heap-dynamic variables are nameless (abstract) memory cells that are allocated and deallocated by explicit run-time instructions specified by the programmer. These variables, which are allocated from and deallocated to the heap, can only be referenced through pointers or reference variables. –The pointer or reference variable that is used to access an explicit heap-dynamic variable is created as nay other scalar variable.

88. 1-88 Properties of a Heap The heap is a collection of storage cells whose organization is highly disorganized because of the unpredictability of its use.

89. 1-89 Creating an Explicit Heap-Dynamic Variable An explicit heap-dynamic variable is created: –by an operator (for example, in Ada and C++ ) or –by a call to a system subprogram provided for that purpose (for example, malloc() in C ).

90. 1-90 Allocation Operator in C++ In C++, the allocation operator, named new, uses a type name as its operand. When executed, an explicit heap-dynamic variable of the operand type is created and a pointer to it is returned. –Because an explicit heap-dynamic variable is bound to a type at compile time, that binding is static. –However, such variables are bound to storage at the time they are created, which is during run time.

91. 1-91 Deleting a Heap-Dynamic Variables In addition to a subprogram or operator for creating explicit heap-dynamic variables, some languages include a means of destroying them.

92. 1-92 Example of Explicit Heap-dynamic Variables What follows is a C++ code segment: int *intnode; //create a pointer... intnode = new int; // create the heap-dynamic variable delete intnode; // deallocate the heap-dynamic variable // to which intnode points In this example, an explicit heap-dynamic variable of int type is created by the new operator. This variable can then be referenced through the pointer, intnode. Later, the variable is deallocated by the delete operator.

93. 1-93 Java Objects Java, all data except the primitive scalars are objects. Java objects are explicit heap-dynamic and are accessed through reference variables. Java has no way of explicitly destroying a heap-dynamic variable; rather, implicit garbage collection is used.

94. 1-94 Applications of Explicit Heap-Dynamic Variables Explicit heap-dynamic variables are often used for dynamic structures, such as linked lists and trees, that need to grow and/or shrink during execution. Such structures can be built conveniently using pointers or references and explicit heap-dynamic variables.

95. 1-95 Disadvantages of Explicit Heap- Dynamic Variables the difficulty of using pointer reference variables correctly. the cost of references to the variables, allocations, and deallocations. the complexity of storage management implementation.

96. 1-96 Implicit Heap-dynamic Variables Implicit heap-dynamic variables are bound to heap storage only when they are assigned values. In fact, all their attributes are bound every time they are assigned.

97. 1-97 Example For example, a JavaScript script may contain the following statement to assign a value to the implicit heap-dynamic variable list : – list = [10.2, 3.5] Regardless of the previous type of the variable named list, this assignment causes it to become a single-dimensioned array of numeric elements of length 2. –If the statement list = 47 followed the assignment above, list would become a numeric scalar variable.

98. 1-98 Advantages The advantage of such variables is that they have the highest degree of flexibility, allowing highly generic code to be written.

99. 1-99 Disadvantages the run-time overhead of maintaining all the dynamic attributes, which could include array subscript types and ranges, among others. the loss of some error detection by the compiler, as discussed in Section 5.4.2.2.

100. 1-100 Type Checking

101. 1-101 Generalize the Concepts of Functions and Assignment Statements Subprograms are thought of as operators –their parameters are their operands. The assignment symbol is thought of as a binary operator –with its target variable and its expression being the operands.

102. 1-102 Type Checking Type checking is the activity of ensuring that the operands of an operator are of COMPATIBLE types.

103. 1-103 Compatible Types A compatible type is one that is –either legal for the operator –or is allowed under language rules to be implicitly converted by compiler-generated code (or the interpreter) to a legal type. This automatic conversion is called a coercion.

104. 1-104 Example If an int variable and a float variable are added in Java, the value of the int variable is coerced to float and a floating-point add is done.

105. 1-105 Type Errors A type error is the application of an operator to an operand of an inappropriate type.

106. 1-106 Example of Type Errors In the original version of C, if an int value was passed to a function that expected a float value, a type error would occur (because compilers for that language did not check the types of parameters.) –Integer Signed Attacks

107. 1-107 Example of Integer Signed Attacks static char data[256]; int store_data(char *buf, int len) { if (len > 256 ) return -1; return memcpy(data, buf, len); } P.S.: memcpy requires an unsigned integer for the length parameter; therefore, the signed variable len would be promoted to an unsigned integer, lose its negative sign, and could wrap around and become a very large positive number, cause memcpy() to read past the bounds of buf.

108. 1-108 Static Type Checking If all bindings of variables to types are static in a language, then type checking can nearly always be done statically.

109. 1-109 Dynamic Type Checking Dynamic type binding requires type checking at run time, which is called dynamic type checking. –Some languages, such as JavaScript and PHP, because of their dynamic type binding, allow only dynamic type checking.

110. 1-110 Pros and Cons of Static Type Checking It is better to detect errors at compile time than at run time, because the earlier correction is usually less costly. The penalty for static checking is reduced programmer flexibility.

111. 1-111 Type Checking for Memory Cells That Can Store Values of Different Types Type checking is complicated when a language allows a memory cell to store values of different types at different times during execution. –Such memory cells can be created with Ada variant records, Fortran EQUIVALENCE, and C and C++ unions.

112. 1-112 Type Checking for Variables That Can Store Values of Different Types Must Be Dynamic For variables that can store values of different types, type checking, if done, MUST be dynamic and requires the run-time system to maintain the type of the current value of such memory cells. So even though all variables are statically bond to types in languages such as C++, not all type errors can be detected by static type checking. –For example, the type of a statically bond C++ variable may be union.

113. 1-113 Strongly Typed Programming Languages A programming language is strongly typed if type errors are always detected. The above requires that the types of all operands can be determined either at compile time or at run time.

114. 1-114 The Importance of Strongly Typed Languages The importance of strong typing lies in its ability to detect ALL misuses of variables that result in type errors. A strongly typed language also allows the detection, at run time, of uses of the incorrect type values in variables that can store values of more than one type.

115. 1-115 Fortran 95 Is Not Strongly Typed In Fortran 95 the use of Equivalence between variables of different types allows a variable of one type to refer to a value of a different type, without the system being able to check the type of the value when one of the Equivalence d variables is referenced or assigned.

116. 1-116 Explanation: Fortran 95 Is Not Strongly Typed Integer A Real R Equivalence (A,R) A=123 A R 123 123 is not a real number; hence, a type error occurs.

117. 1-117 C and C++ Are Not Strongly Typed Languages C and C++ are not strongly typed languages because –both allow functions for which parameters are not type checked. –Furthermore, the union types of these languages are not type checked.

118. 1-118 Coercion Rules vs. Type Checking The coercion rules of a language have an important effect on the value of type checking. –For example, Expressions are strongly typed in Java. However, an arithmetic operator with one floating- point operand and one integer operand is legal. The value of the integer operand is coerced to floating-point, and a floating-point operation takes place. Even though the above is what is usually intended by the programmer, the coercion also results in a loss of part of the reason for strong typing – error detection (see next slide).

119. 1-119 Suppose a program written in a strongly typed language had the int variables a and b and the float variable d. Now, if a programmer meant to type a + b, but mistakenly typed a + d, the error would not be detected by the compiler. The value of a would simply be coerced to float. The above coercion weaken the value of strong typing. The Value of Strong Typing Is Weakened by Coercion

120. 1-120 Coercion Reduces Reliability Languages with a great deal of coercion, like Fortran, C, and C++, are significantly less reliable than those with little coercion, such as Ada. Java and C# has half as many assignment type coercions as C++, so its error detection is better than that of C++, but still not nearly as effective as that of Ada.