-buttons
provided in the notes to obtain a detailed description of a term.
,
data structures, software engineering, computer architecture and hardware
issues, etc.
Programming languages follow simple syntactic conventions (as opposed
to natural languages), see also BNF
syntax. Programming languages are compiled into machine code
(also known as object code) by a compiler
and linker,
or interpreted by an interpreter,
or executed by a hybrid compiler/interpreter.
Programming languages can be classified as imperative
or declarative.
This classification is further subdivided as follows:
| declarative:
implicit solution
"what the computer should do" |
functional
(e.g. Lisp,
Scheme,
ML,
Haskell)
logic
(e.g. Prolog)
dataflow |
| imperative:
explicit solution
"how the computer should do it" |
procedural
("von Neumann", e.g. Fortran,
Pascal,
Basic,
C)
object-oriented
(Smalltalk,
Eiffel,
C++,
C#,
Java) |
allow a programming problem to be stated without certain explicit details
by which the calculation should proceed. Imperative languages are procedural
languages (e.g. Fortran,
Pascal,
Basic,
C)
and (most) object-oriented
languages (Smalltalk,
Eiffel,
C++,
C#,
Java).
is used in declarative programming, possibly in combination with higher-order
functions.
Declarative languages are the functional
languages (e.g. Lisp,
Scheme,
ML,
Haskell),
logic
languages (e.g. Prolog),
and dataflow
languages.
.
The computational model is based on recursive functions and a program is
considered a function thats maps inputs to outputs. Through the process
of top-down refinement, a program is defined in terms of simpler functions.
Example languages in this category are Lisp,
Scheme,
ML,
and Haskell.
Functional program example (Haskell):
gcd a b | a == b = a | a > b = gcd (a-b) b | a < b = gcd a (b-a)
for
example, is based on propositional logic. The computational model consists
of an inference process on a database to find values that satisfy certain
constraints and relationships.
Logic program example (Prolog):
gcd(A, A, A). % note: if the first two arguments are the same, the third argument (GCD) is A gcd(A, B, G) :- A > B, N is A-B, gcd(N, B, G). gcd(A, B, G) :- A < B, N is B-A, gcd(A, N, G).
is gaining more popularity, the procedural languages are still the most
familiar and successful languages. The basic mode of operation is the modification
of variables which is sometimes referred to as computing via side effects:
procedural languages are based on statements that influence subsequent
computation by chaning the value of memory. The success of these languages
can be mainly contributed to the efficiency of the language implementation
in our current computer architectures, called the von Neumann computer
architectures. This common architecture exhibits a central processing unit
(CPU) and memory which are connected by a bus.
Example procedural languages are Fortran 77,
Basic,
Pascal,
Ada,
and C.
Procedural program example (C):
int gcd(int a, int b)
{ while (a != b)
if (a > b) a = a-b; else b = b-a;
return a;
}
),
is that object-oriented languages put objects and their interactions on
the forefront rather than computation as the operation of a processor on
a monolithic memory. Each object has an internal state and executable functions
to manage that state.
Example object-oriented languages are Smalltalk,
Eiffel,
C++,
C#,
Java.
is considered the most important safety issue of a programming language
as typing errors are always detected. Among other things are the safety
issues dealing with the use of a progamming language on the Internet,
such as in Java and C# which have elaborate authentication schemes. Languages
such as C and C++ are not safe, because the compiler and runtime environment
cannot guarantee type safety. For example, pointer casts can be used to
change the type of the data pointed to without actually converting the
data.
Here is an example of a safe cast to convert an integer to a float:
int n = 5; float f = (float)n;This is an example of an unsafe cast, which is prohibited in type-safe languages:
int n = 5; float *fp = (float*)&n;Such casts, whether explicit as above or implicit, can lead to disaster. Type-safe languages usually do not support pointer arithmetic to prevent accessing data of the ''wrong'' type.
,
Java,
and Haskell
are strongly typed languages. C
and C++
are not, e.g. because void pointers can point to any type of object that
can be manipulated, see the example in.
Pascal
is "almost" strongly typed. The exception is the use of a variant record
(union) without discriminator. The variant record can hold alternative
types of objects during the execution of a program.
.
and/or by an operating system (OS)) into main memory for execution. See
also assembly language
Assembly is translated into machine code (object code) by an assembler.
programs (mnemonic instructions) to machine code (or object code).
.
The abbreviations usually consist of the name for the instruction followed by operands which are register names such as 'sp' (stack pointer) and 'a0' (address register 0), memory references such as 'A' (local label) and 'putint' (function label), and memory offsets such as '20(sp)' (20 bytes/words from the location pointed to be the stack pointer ).
Example MIPS assembly program to compute GCD (from textbook page 1):
addiu sp,sp,-32 sw ra,20(sp) jal getint nop jal getint sw v0,28(sp) lw a0,28(sp) move v1,v0 beq a0,v0,D slt at,v1,a0 A: beq at,zero,B nop b C subu a0,a0,v1 B: subu v1,v1,a0 C: bne a0,v1,A slt at,v1,a0 D: jal putint nop lw ra,20(sp) addiu sp,sp,32 jr ra move v0,zeroExample MIPS R4000 machine code of the above assembly program (from textbook page 1):
27bdffd0 afbf0014 0c1002a8 00000000 0c1002a8 afa2001c 8fa4001c 00401825 10820008 0064082a 10200003 00000000 10000002 00832023 00641823 1483fffa 0064082a 0c1002b2 00000000 8fbf0014 27bd0020 03e00008 00001025
Structured languages, such as Pascal
and Ada,
force the programmer to write a structured program. However, unstructured
languages such as Fortran 77,
Cobol,
and Basic
require discipline on the part of the programmer to follow.
Here is an example of a non-structured program in C
that counts the number of goto's in a file whose filename is given
as an argument on the command line. This program can be used to measure
the "spaghettiness" of a C program:
#include <stdio.h>
#include <malloc.h>
main(togo,toog)
int togo;
char *toog[];
{char *ogto, tgoo[80];FILE *ogot; int oogt=0, ootg, otog=79,
ottg=1;if ( togo== ottg) goto gogo; goto goog; ggot:
if ( fgets( tgoo, otog, ogot)) goto gtgo; goto gott;
gtot: exit(); ogtg: ++oogt; goto ogoo; togg: if ( ootg > 0)
goto oggt; goto ggot; ogog: if ( !ogot) goto gogo;
goto ggto; gtto: printf( "%d goto \'s\n", oogt); goto
gtot; oggt: if ( !memcmp( ogto, "goto", 4)) goto otgg;
goto gooo; gogo: exit( ottg); tggo: ootg= strlen(tgoo);
goto tgog; oogo: --ootg; goto togg; gooo: ++ogto; goto
oogo; gott: fclose( ogot); goto gtto; otgg: ogto= ogto +3;
goto ogtg; tgog: ootg-=4;goto togg; gtgo: ogto= tgoo;
goto tggo; ogoo: ootg-=3;goto gooo; goog: ogot= fopen(
toog[ ottg], "r"); goto ogog; ggto: ogto= tgoo; goto
ggot;}
Fortran and Basic programs developed in the early days of computing were
difficult to read and understand, somewhat similar to this example in terms
of the choice in variable names (limit 6 characters in Fortran and 2 in
Basic) and the frequent use of goto.
in a block or compound statement. For example, the following C fragment
declares a temporary integer variable n
to be used in the loop to copy a file from standard input to standard output:
{ int n;
while ((n = getchar()) != EOF)
putchar(n);
}
Variable n has a local scope
limited to the block and it's value is only accessible within the block.
In C, C++, Java, and C#, a block is opened with { and closed with }. Pascal and Ada use begin and end keywords to delimit a block.
The use of blocks is so common today that we don't tend to think of
it as something special.
languages but can also be adopted in procedural
or functional
languages. In fact, most object oriented languages were designed as an
extension of a procedural language (e.g. C++ and object-oriented Pascal
dialects) and the concept of a class is largely based on the concept of
an abstract data type.
is not supported.
The following Modula-2 example stack abstraction is from the textbook page 124:
CONST stack_size = ... TYPE element = ... ... MODULE stack; IMPORT element, stack_size; EXPORT push, pop; TYPE stack_index = [1..stack_size]; VAR s : ARRAY stack_index OF element; top : stack_index; PROCEDURE error; ... PROCEDURE push (elem : element); BEGIN IF top = stack_size THEN error; ELSE s[top] := elem; top := top + 1; END; END push; PROCEDURE pop () : element BEGIN IF top = 1 THEN error; ELSE top := top - 1; RETURN s[top]; END; END pop; BEGIN top := 1; END stack;
(ADTs) with inheritance.
ADTs are limited to packages that encapsulate a data type declaration with
a set of operations.
The following is an example stack template class in C++:
template <class element> class stack
{ private:
int top;
element[] s;
public:
stack(int size)
{ s = new element[size]; top = 0; };
~stack()
{ delete[] s; };
void push(element elem)
{ s[top++] = elem; };
void pop(void)
{ top--; };
element top(void)
{ return s[top-1]; };
};
inherits structure and properties from a base class. Some object oriented
languages support multiple inheritance. Single inheritance is simpler to
implement and avoids possible ambiguity problems caused by multiple inheritance.
Therefore, newer languages such as Java and C# support single inheritance.
.
Over 40 organizations outside DoD with over 200 participants collaborated
(and competed with different designs) in the final design of Ada. Originally
intended to be the standard language for all software commissioned by the
US Department of Defense. Prototypes designed by teams at several sites;
final '83 language developed by a team at Honeywell's Systems and Research
Center in Minneapolis and Alsys Corp. in France, led by Jean Ichbiah.
Example program in Ada:
with TEXT_IO;
use TEXT_IO;
procedure AVEX is
package INT_IO is new INTEGER_IO (INTEGER);
use INT_IO;
type INT_LIST_TYPE is array (1..99) of INTEGER;
INT_LIST : INT_LIST_TYPE;
LIST_LEN, SUM, AVERAGE : INTEGER;
begin
SUM := 0;
-- read the length of the input list
GET (LIST_LEN);
if (LIST_LEN > 0) and (LIST_LEN < 100) then
-- read the input into an array
for COUNTER := 1 .. LIST_LEN loop
GET (INT_LIST(COUNTER));
SUM := SUM + INT_LIST(COUNTER);
end loop;
-- compute the average
AVERAGE := SUM / LIST_LEN;
-- write the input values > average
for counter := 1 .. LIST_LEN loop
if (INT_LIST(COUNTER) > AVERAGE) then
PUT (INT_LIST(COUNTER));
NEW_LINE;
end if
end loop;
else
PUT_LINE ("Error in input list length");
end if;
end AVEX;
language. The design of Algol 60 is a landmark of clarity and conciseness
and made a first use of Backus-Naur form (BNF)
for formally defining the grammar. All subsequent imperative programming
languages are based on Algol 60, and these languages are sometimes referred
to as "Algol-like" languages. Strangely, it lacks input/output statements
and has no character set. Algol 60 never gained wide acceptance in the
US, partly because of the intrenchment of Fortran and lack of support by
IBM. Besides block-structures, Algol 60 has recursion
and stack-dynamic arrays.
Example Algol 60 program:
comment avex program
begin
integer array intlist [1:99];
integer listlen, counter, sum, average;
sum := 0;
comment read the length of the input list
readint (listlen);
if (listlen > 0) L (listlen < 100) then
begin
comment read the input into an array
for counter := 1 step 1 until listlen do
begin
readint (intlist[counter]);
sum := sum + intlist[counter]
end;
comment compute the average
average := sum / listlen;
comment write the input values > average
for counter := 1 step 1 until listlen do
if intlist[counter] > average then
printint (intlist[counter])
end
else
printstring ("Error in input list length")
end
,
proposed by Niklaus Wirth and C. A. R. Hoare. The precursor to Pascal.
Introduced the case statement.
Example APL program:
(2=(+/[2]0=(iN°.|(iN)))/iN
This program computes prime numbers in the range 1 to N.
Example QuickBasic program:
REM avex program DIM intlist(99) sum = 0 REM read the length of the input list INPUT listlen IF listlen > 0 AND listlen < 100 THEN REM read the input into an array FOR counter = 1 TO listlen INPUT intlist(counter) sum = sum + intlist(counter) NEXT counter REM compute the average average = sum / listlen REM write the input values > average FOR counter = 1 TO listlen IF intlist(counter) > average THEN PRINT intlist(counter); NEXT counter ELSE PRINT "Error in input list length" END IF END
Example program in C:
main()
{ int intlist[99], listlen, counter, sum, average;
sum = 0;
/* read the length of the list */
scanf("%d", &listlen);
if (listlen > 0 && listlen < 100)
{ /* read the input into an array */
for (counter = 0; counter < listlen; counter++)
{ scanf("%d", &intlist[counter]);
sum += intlist[counter];
}
/* compute the average */
average = sum / listlen;
/* write the input values > average */
for (counter = 0; counter < listlen; counter++)
if (intlist[counter] > average)
printf("%d\n", intlist[counter]);
}
else
printf("Error in input list length\n");
}
main()
{ std::vector<int> intlist;
int listlen;
/* read the length of the list */
std::cin >> listlen;
if (listlen > 0 && listlen < 100)
{ int sum = 0;
/* read the input into an STL vector */
for (int counter = 0; counter < listlen; counter++)
{ int value;
std::cin >> value;
intlist.push_back(value);
sum += value;
}
/* compute the average */
int average = sum / listlen;
/* write the input values > average */
for (std::vector<int>::const_iterator it = intlist.begin(); it != intlist.end(); ++it)
if ((*it) > average)
std::cout << (*it) << std::endl;
}
else
std::cerr << "Error in input list length" << std::endl;
}
.
C# is part of Microsoft's VisualStudio.NET, a development environment
for Internet-based computing. C# uses the Common Lanuage Runtime (CLR)
to manage objects that can be shared among different languages (C#,
VisualBasic, C++, Haskell). Objects can be exchanged over the Web and remote
methods can be invoked using SOAP (Simple Object Access Protocol).
Division name Contains IDENTIFICATION Program identification. ENVIRONMENT Types of computers used. DATA Buffers, constants, work areas. PROCEDURE The processing parts (program logic).Example COBOL program to convert Fahrenheit to Celcius:
IDENTIFICATION DIVISION. PROGRAM-ID. EXAMPLE. ENVIRONMENT DIVISION. CONFIGURATION SECTION. SOURCE-COMPUTER. IBM-370. OBJECT-COMPUTER. IBM-370. DATA DIVISION. WORKING-STORAGE SECTION. 77 FAHR PICTURE 999. 77 CENT PICTURE 999. PROCEDURE DIVISION. DISPLAY 'Enter Fahrenheit ' UPON CONSOLE. ACCEPT FAHR FROM CONSOLE. COMPUTE CENT = (FAHR- 32) * 5 / 9. DISPLAY 'Celsius is ' CENT UPON CONSOLE. GOBACK.
).
The leading notation for object-oriented functional programming.
,
automatic garbage collection,
and powerful mechanisms for re-naming of data members and methods in derived
classes.
,
and to facilitate formal verification of programs. Has closed scopes and
module types.
.
It was originally designed to express mathematical formulas. Fortran 77
is still widely used for scientific, engineering, and numerical problems,
mainly because very good compilers exist. These compilers are very effective
in optimizing code, because of the maturity of the compilers and due to
the lack of pointers and recursion
in Fortran 77. Fortran 77 has limited type checking and lacks records,
unions, dynamic allocation, case-statements, and while-loops.
Variable names are upper case and the name length is limited to 6 characters.
Fortran 77 is not structured
and not object-oriented.
More recent Fortran dialects such as Fortran 90
are better structured and support modern programming constructs.
Example Fortran 77 program:
PROGRAM AVEX INTEGER INTLST(99) C variable names that start with I,J,K,L,N,M are integers ISUM = 0 C read the length of the list READ (*, *) LSTLEN IF ((LSTLEN .GT. 0) .AND. (LSTLEN .LT. 100)) THEN C read the input in an array DO 100 ICTR = 1, LSTLEN READ (*, *) INTLST(ICTR) ISUM = ISUM + INTLST(ICTR) 100 CONTINUE C compute the average IAVE = ISUM / LSTLEN C write the input values > average DO 110 ICTR = 1, LSTLEN IF (INTLST(ICTR) .GT. IAVE) THEN WRITE (*, *) INTLST(ICTR) END IF 110 CONTINUE ELSE WRITE (*, *) 'ERROR IN LIST LENGTH' END IF END
,
pointers, records, dynamic allocation, a module facility, and new control
flow constructs are added. Also array operations are added that operate
on arrays and array slices. Array operations on distributed arrays in HPF
can be parallelized.
Example Fortran 90 program:
PROGRAM AVEX INTEGER INT_LIST(1:99) INTEGER LIST_LEN, COUNTER, AVERAGE C read the length of the list READ (*, *) LISTLEN IF ((LIST_LEN > 0) .AND. (LIST_LEN < 100)) THEN C read the input in an array DO COUNTER = 1, LIST_LEN READ (*, *) INT_LIST(COUNTER) END DO C compute the average AVERAGE = SUM(INT_LIST(1:LIST_LEN)) / LIST_LEN C write the input values > average DO COUNTER = 1, LIST_LEN IF (INT_LIST(COUNTER) > AVERAGE) THEN WRITE (*, *) INT_LIST(1:LIST_LEN) END IF END DO ELSE WRITE (*, *) 'ERROR IN LIST LENGTH' END IF END
.
Designed by a committee of researchers beginning in 1987. Includes curried
functions, higher-order functions,
non-strict semantics, static polymorphic typing, pattern matching, list
comprehensions, modules, monadic I/O, and layout (indentation)-based syntactic
grouping.
Example Haskell program:
sum [] = 0 sum (a:x) = a + sum x
avex [] = [] avex (a:x) = [n | n <- a:x, n > sum (a:x) / length (a:x)]
,
threads, and extensive pre-defined libraries for graphics, communication,
etc. Heavily used for transmission of program fragments, called applets,
over the Internet. The language is designed to be translated into intermediate
Java byte code that can be transmitted over the Internet. Java byte code
is executed by the Java virtual machine (JVM)
or compiled into native machine code by a just-in-time (JIT) compiler.
Java is a safe language.
Example Java program:
import java.io;
class Avex
{ public static void main(String args[]) throws IOException
{ DataInputStream in = new DataInputStream(System.in);
int listlen, counter, sum = 0, average;
int [] intlist = int[100];
// read the length of the list
listlen = Integer.parseInt(in.readLine());
if (listlen > 0 && listlen < 100)
{ // read the input into an array
for (counter = 0; counter < listlen; counter++)
{ intlist[counter] = Integer.valueOf(in.readline()).intValue();
sum += intlist[counter];
}
// compute the average
average = sum / listlen;
// write the input values > average
for (counter = 0; counter < listlen; counter++)
{ if (intlist[counter] > average)
System.out.println(intlist[counter] + "\n");
}
}
else
System.out.println("Error in input length\n");
}
}
.
Many dialects exists, among which Common Lisp and Scheme
are the most popular. Lisp is the dominant language used in Artificial
Intelligence. The emphasis is on symbolic computation rather than numeric.
Lisp is very powerful for symbolic computation with lists and Lisp often
used in artificial intelligence. As a functional language,
all control is performed by recursion
and conditional expressions. Lisp was the first language with implicit
memory management (automatic allocate and deallocate) by "garbage collection".
Lisp heavily influenced functional programming languages (e.g. ML,
Miranda,
Haskell)
in several respects; has type inference and automatic currying. Unlike
ML, provides list comprehensions, and uses lazy evaluation for all arguments.
Like Haskell,
it uses indentation and line breaks for syntactic grouping.
,
but no real concurrency. Both languages provide mechanisms for module-as-manager
style data abstractions.
developed by Luca Cardelli, Jim Donahue, Mick Jordan, Bill Kalsow, and
Greg Nelson at the Digital Systems Research Center and the Olivetti Research
Center in the late 1980's. Intended to provide a level of support for large,
reliable, and maintainable systems comparable to that of Ada,
but in a simpler and more elegant form.
,
augmented with a mechanism for type extension.
,
which was widely perceived as bloated. It is noted for its structured programming
and was heavily used in the 70s and 80s, particularly for teaching. Pascal
has had strong influence on subsequent high-level languages, such as Ada,
ML,
Modula-2
and Modula-3.
Example Pascal program:
program avex(input, output);
type
intlisttype = array [1..99] of integer;
var
intlist : intlisttype;
listlen, counter, sum, average : integer;
begin
sum := 0;
(* read the length of the input list *)
readln(listlen);
if ((listlen > 0) and (listlen < 100)) then
begin
(* read the input into an array *)
for counter := 1 to listlen do
begin
readln(intlist[counter]);
sum := sum + intlist[counter]
end;
(* compute the average *)
average := sum / listlen;
(* write the input values > average *)
for counter := 1 to listlen do
if (intlist[counter] > average) then
writeln(intlist[counter])
end
else
writeln('Error in input list length')
end.
,
COBOL,
and Algol.
Very complicated and poorly designed language that is kept alive by IBM.
The first language that adopted exception handling
and pointer types.
Example PL/I program:
AVEX: PROCEDURE OPTIONS (MAIN);
DECLARE INTLIST (1:99) FIXED;
DECLARE (LISTLEN, COUNTER, SUM, AVERAGE) FIXED;
SUM = 0;
/* read the input list length */
GET LIST (LISTLEN);
IF (LISTLEN > 0) & (LISTLEN < 100) THEN
DO;
/* read the input into an array */
DO COUNTER = 1 TO LISTLEN;
GET LIST (INTLIST(COUNTER));
SUM = SUM + INTLIST(COUNTER);
END;
/* compute the average */
AVERAGE = SUM / LISTLEN;
/* write the input values > average */
DO COUNTER = 1 TO LISTLEN;
IF INTLIST(COUNTER) > AVERAGE THEN
PUT LIST (INTLIST(COUNTER));
END;
ELSE
PUT SKIP LIST ('ERROR IN INPUT LIST LENGTH');
END AVEX;
Example Prolog program:
avex(IntList, GreaterThanAveList) :- sum(IntList, Sum), length(IntList, ListLen), Average is Sum / ListLen, filtergreater(IntList, Average, GreaterThanAveList).
% sum(+IntList, -Sum) % recursively sums integers of IntList sum([Int | IntList], Sum) :- sum(IntList, ListSum), Sum is Int + ListSum. sum([], 0).
% filtergreater(+IntList, +Int, -GreaterThanIntList) % recursively remove integers smaller or equal to Int from IntList filtergreater([AnInt | IntList], Int, [AnInt | GreaterThanIntList]) :- AnInt > Int, !, filtergreater(IntList, Int, GreaterThanIntList). filtergreater([AnInt | IntList], Int, GreaterThanIntList) :- filtergreater(IntList, Int, GreaterThanIntList). filtergreater([], Int, []).The following example illustrates a more "traditional" use of Prolog to infer information from a database of facts:
rainy(rochester). % fact: rochester is rainy rainy(seattle). % fact: seattle is rainy cold(rochester). % fact: rochester is cold snowy(X) :- rainy(X), cold(X). % rule: X is snowy if X is rainy and coldWith this program loaded, we can query the system interactively:
?- rainy(X). % user question X = rochester % system answer(s) X = seattle
?- snowy(X). X = rochester
.
Developed in the mid 1970's by Guy Steele and Gerald Sussman. Standardized
by the IEEE and ANSI. Has static scoping and true first-class functions.
Scheme is widely used for teaching.
Example Scheme program:
(DEFINE (avex lis) (filtergreater lis (/ (sum lis) (length lis))) )
(DEFINE (sum lis) (COND ((NULL? lis) 0) (ELSE (+ (CAR lis) (sum (CDR lis)))) ) )
(DEFINE (filtergreater lis num) (COND ((NULL? lis) '()) ((> (CAR lis) num) (CONS (CAR lis) (filtergreater (CDR lis) num))) (ELSE (filtergreater (CDR lis) num) ) )
with classes and coroutines.
The name of the language reflects its suitability for discrete-event simulation
Example Smalltalk-80 program:
class name Avex superclass Object instance variable names intlist
"Class methods" "Create an instance" new ^ super new
"Instance methods" "Initialize" initialize intlist <- Array new: 0
"Add int to list" add: n | oldintlist | oldintlist <- intlist. intlist <- Array new: intlist size + 1. intlist <- replaceFrom: 1 to: intlist size with: oldintlist. ^ intlist at: intlist size put: n
"Calculate average" average | sum | sum <- 0. 1 to: intlist size do: [:index | sum <- sum + intlist at: index]. ^ sum // intlist size
"Filter greater than average" filtergreater: n | oldintlist i | oldintlist <- intlist. i <- 1. 1 to: oldintlist size do: [:index | (oldintlist at: index) > n ifTrue: [oldintlist at: i put: (oldintlist at: index)]] intlist <- Array new: oldintlist size. intlist replaceFrom: 1 to: oldintlist size with: oldintlistExample Smalltalk-80 session:
av <- Avex new av initialize av add: 1 1 av add: 2 2 av add: 3 3 av filtergreater: av average av at: 1 3
is a direct realization of lambda calculus as a programming language.
A lambda expression is recursively defined as
Some examples:
f a denotes the application of a function symbol f to an argument a.
l v . v is a lambda abstraction that denotes the identity function: argument v takes a value and the function returns the (unchanged) value. The application of this function to an expression a, for example, is written (l v . v) a and this evaluates to a (argument v takes a and the function returns the value of v).
l v. f v is a lambda abstraction that, when applied to a value, applies f to it. For example, (lv. f v) a results in f a.
l f. f a is a lambda abstraction that, when applied to a function name, applies this function to a. For example, (l f. f a) g results in g a.
as possible. Implicit garbage collection operates on the background of
a running program to clean up unused heap space.
.
of a programming language. A regular expression is one of
identifier -> letter (letter | digit)*
digit -> 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
letter -> a | b | c | d | e | f | g | h | i | j | k | l | m | n | o | p | q | r | s | t | u | v | w | x | y | z | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | _For compiler design, tools exist that generate efficient scanners
automatically from regular expressions (e.g. flex).
of
a grammar is a token
e.g. specific programming language keyword or identifierdenotes
a syntactic category, e.g. a collection of program statements.An LL grammar cannot have left-recursive productions,
because a recursive descent parser would recursively call itself forever
without consuming any input characters.
The following grammar is not LL(1)
<A> -> <B> <C> <A> -> a
<B> -> a b <B> -> b
<C> -> cIt is not LL(1) because the subroutine for nonterminal A cannot decide which production to use when it sees an a on the input:
proc A if next_token="a" ?? cannot decide whether the first or second production for <A> applies here ??The grammar is LL(2), because the token after next token can be used to determine which production should be applied:
proc A
if next_token="a" and token_after_next_token="b"
B()
C()
else if next_token="b"
B()
C()
else
match("a");
.
The grammar for simple expressions below is ambiguous:
<expression> -> identifier | unsigned_integer | - <expression> | ( <expression> ) | <expression> <operator> <expression>
<operator> -> + | - | * | /because we find two distinct (left-most) derivations for the string a-b+1:
<expression> => <expression> <operator> <expression> => <expression> <operator> <expression> <operator> <expression> => identifier <operator> <expression> <operator> <expression> => identifier - <expression> <operator> <expression> => identifier - identifier <operator> <expression> => identifier - identifier + <expression> => identifier - identifier + unsigned_integer (a) - (b) + (1)and
<expression> => <expression> <operator> <expression> => identifier <operator> <expression> => identifier - <expression> => identifier - <expression> <operator> <expression> => identifier - identifier <operator> <expression> => identifier - identifier + <expression> => identifier - identifier + unsigned_integer (a) - (b) + (1)The simple expression grammar below is unambiguous:
<expression> -> <term> | <expression> <add_op> <term>
<term> -> <factor> | <term> <mult_op> <factor>
<factor> -> identifier | unsigned_integer | - <factor> | ( <expression> )
<add_op> -> + | -
<mult_op> -> * | /We find only one derivation for all strings in the language defined by the grammar. For example, the left-most derivation of a-b+1 is:
<expression> => <expression> <add_op> <term> => <expression> <add_op> <term> <add_op> <term> => <term> <add_op> <term> <add_op> <term> => <factor> <add_op> <term> <add_op> <term> => identifier <add_op> <term> <add_op> <term> => identifier - <term> <add_op> <term> => identifier - <factor> <add_op> <term> => identifier - identifier <add_op> <term> => identifier - identifier + <term> => identifier - identifier + <factor> => identifier - identifier + unsigned_integer (a) - (b) + (1)
<stmt> -> if <expr> then <stmt> | if <expr> then <stmt> else <stmt>because we find two distinct derivations of the string
if C1 then if C2 then S1 else S2(where C1 and C2 are some expressions, S1 and S2 are some statements):
<stmt> => if <expr> then <stmt> => if <expr> then if <expr> then <stmt> else <stmt>and another derivation
<stmt> => if <expr> then <stmt> else <stmt> => if <expr> then if <expr> then <stmt> else <stmt>An anuambiguous grammar for if-then-else is (you don't need to memorize this):
<stmt> -> <balanced_stmt> | <unbalanced_stmt>
<balanced_stmt> -> if <expr> then <balanced_stmt> else <balanced_stmt> | <other_stmt>
<unbalanced_stmt> -> if <expr> then | if <expr> then <balanced_stmt> else <unbalanced_stmt>which is an LR grammar
,
but not an LL grammar
and no pure top-down parser
can be used to parse program fragments with the unambiguous if-then-else
grammar.
that operate on the attribute values.
Example
grammar production semantic rule
<number1> -> <number2> <digit> number1.value := 10*number2.value + digit.value <number> -> <digit> number.value := digit.value <digit> -> 0 digit.value := 0 | 1 digit.value := 1 | 2 digit.value := 2 | 3 digit.value := 3 | 4 digit.value := 4 | 5 digit.value := 5 | 6 digit.value := 6 | 7 digit.value := 7 | 8 digit.value := 8 | 9 digit.value := 9In this example, the nonterminals <number> and <digit> have an attribute 'value' that holds the value of the numeric representation defined by the grammar. When the semantic rules are applied on the syntactic representation of the input, the rules compute the value of the input. When the values computed are used to check the validity of the input, then the semantic rules are used to enforce semantic checks
.
Note: the nonterminal <number> has subscripts in the first production
to distinguish the nonterminal on the left hand side and right hand side
of the production.
are performed by the compiler at compile time. Dynamic semantic checksare
performed at run time. A compiler cannot always ensure that certain constraints
on programming constructs are met at compile time, for example, whether
the index value of an array is out of bounds. A compiler may generate run
time checks in the target code to enforce these constraints at run time.
of a compiler produces for further analysis by the parser. Example tokens
are programming language keywords, operators, identifiers, numbers, and
punctuation. Tokens are also called terminals
in the context of grammars.
,
e.g. a keyword or operator.
grammar productions are of the form
<nonterminal> -> sequence of (non)terminalsProductions provide descriptions of the syntax for a syntactic category denoted by a nonterminal.
A production is immediately left recursive if it is of the form
<A> -> <A> ...and a production is immediately right recursive if it is of the form
<A> -> ... <A>where <A> is some nonterminal.
Productions can be left or right recursive through other productions. For example
<A> -> <B> ...
<B> -> <A> ...
as a tree: the nodes are the nonterminals,
the children of a node are the symbols (terminals and nonterminals) of
a right-hand side of a production
for the nonterminal at the node, and the leaves are the terminals.
Given the grammar
<id_list> -> identifier <id_list_tail> <id_list_tail> -> , identifier <id_list_tail> | ;The parse tree of "A,B,C;" is
 |
the result would be different after reordering. Arithmetic operators in
a programming language are typically left associative with the notable
exception of exponentiation (^) which is right associative. However, this
rule of thumb is not universal.
Associativity can be captured in a grammar. For a left associative binary operator op we have a production of the form
<expr> -> <term> | <expr> op <term>and for a right associative operator <op> we have a production of the form
<expr> -> <term> | <term> op <expr>Note that the production for a left associative operator is left recursive
and therefore has to be rewritten for a recursive descent parser:
<expr> -> <term> <more_terms>
<more_terms> -> op <term> <more_terms> | e
The relative precedences between operators can be captured in a grammar. A nonterminal is introduced for every group of operators with identical precedence. The nonterminal of the group of operators with lowest precedence is the nonterminal for the expression as a whole. Productions for (left associative) binary operators with lowest to highest precedences are written of the form
<expr> -> <expr1> | <expr> <lowest_op> <expr1>
<expr1> -> <expr2> | <expr1> <one_but_lowest_op> <expr2>
...
<expr9> -> <term> | <expr9> <highest_op> <term>
<term> -> identifier | number | - <term> | ( <expr> )where <lowest_op> is a nonterminal denoting all operators with the same lowest precedence, etc.
breaks up the character stream of a source program into tokens.
The process of scanning comprises the lexical analysis phase of a compiler.
The purpose of scanning is to simplify the task of the parser of the compiler.
Comments and white space are removed, keywords are recognized and represented
as tokens,
identifers for names of variables and functions are stored in a symbol
table and tagged with source file and line numbers.
Example scanner written in Java:
import java.io.*;
public class Scanner
{ public static void main(String argv[]) throws IOException
{ FileInputStream stream = new FileInputStream(argv[0]);
InputStreamReader reader = new InputStreamReader(stream);
StreamTokenizer tokens = new StreamTokenizer(reader);
int next = 0;
while ((next = tokens.nextToken()) != tokens.TT_EOF)
{ switch (next)
{ case tokens.TT_WORD:
System.out.println("WORD: " + tokens.sval);
break;
case tokens.TT_NUMBER:
System.out.println("NUMBER: " + tokens.nval);
break;
default:
switch ((char)next)
{ case '"':
System.out.println("STRING: " + tokens.sval);
break;
case '\'':
System.out.println("CHAR: " + tokens.sval);
break;
default:
System.out.println("PUNCT: " + (char)next);
}
}
}
stream.close();
}
}
Get Java source. Save it with file name "Scanner.java",
compile it with "javac Scanner.java", and run it with "Scanner Scanner.java",
where the scanner is applied to itself.
representation of a stream of tokens.
The grammar of a programming language defines the parse tree structure
produced by a parser given a syntactically valid program fragment.
.
based on recursive functions.
Consider for example, the following LL(1) grammar
<expr> -> <term> <term_tail>
<term_tail> -> <add_op> <term> <term_tail> | e
<term> -> <factor> <factor_tail>
<factor_tail> -> <mult_op> <factor> <factor_tail> | e
<factor> -> ( <expr> ) | - <factor> | identifier | unsigned_integer
<add_op> -> + | -
<mult_op> -> * | /For this LL(1) grammar a recursive descent parser in Java is:
import java.io.*;
public class CalcParser
{ private static StreamTokenizer tokens;
private static int ahead;
public static void main(String argv[]) throws IOException
{ InputStreamReader reader = new InputStreamReader(System.in);
tokens = new StreamTokenizer(reader);
tokens.ordinaryChar('.');
tokens.ordinaryChar('-');
tokens.ordinaryChar('/');
get();
expr();
if (ahead == (int)'$')
System.out.println("Syntax ok");
else
System.out.println("Syntax error");
}
private static void get() throws IOException
{ ahead = tokens.nextToken();
}
private static void expr() throws IOException
{ term();
term_tail();
}
private static void term_tail() throws IOException
{ if (ahead == (int)'+' || ahead == (int)'-')
{ add_op();
term();
term_tail();
}
}
private static void term() throws IOException
{ factor();
factor_tail();
}
private static void factor_tail() throws IOException
{ if (ahead == (int)'*' || ahead == (int)'/')
{ mult_op();
factor();
factor_tail();
}
}
private static void factor() throws IOException
{ if (ahead == (int)'(')
{ get();
expr();
if (ahead == (int)')')
get();
else System.out.println("closing ) expected");
}
else if (ahead == (int)'-')
{ get();
factor();
}
else if (ahead == tokens.TT_WORD)
get();
else if (ahead == tokens.TT_NUMBER)
get();
else System.out.println("factor expected");
}
private static void add_op() throws IOException
{ if (ahead == (int)'+' || ahead == (int)'-')
get();
}
private static void mult_op() throws IOException
{ if (ahead == (int)'*' || ahead == (int)'/')
get();
}
}
Get Java source.This parser does not construct
a parse tree but verifies if a string terminated with a $ is an expression.
To run the example, save the source with file name "Calc.java", compile
it with "javac Calc.java" and run it with "java Calc".
To run the example, save the CalcAST class source with file name "Calc.java",
save the AST class source with file name "AST.java", compile it with "javac
AST.java CalcAST.java" and run it with "java CalcAST".
,
machine code, or code for a virtual machine.
)
into machine code for a particular platform. The translation is done just
before the program is executed. Just-in-time compilers are available for
many types of machines to translate Java byte code into native machine
code.
For more information about the Java Virtual Machine, see the Java Virtual Machine Specification.
and static library routines together to produce a binary executable program.
to a source program. In C and C++ for example, #define macros
are expanded and header files are incuded in the source for the first phase
of compiler analysis (lexical analysis by the scanner).
when the subroutine is called. For example, in the C program fragment
main(int argc, char argv[])
{ ... }
both argc and argv are formal parameters in main's
definition.
Also known as dummy arguments in Fortran.
Example of a function with a side effect:
sum = 0;
int accumulate(int value)
{ sum += value;
return sum;
}
Example of a non-referentially transparent expression (where 'accumulate'
and 'sum' are defined in)
is:
accumulate(2) + sumThis expression uses a function with a side effect. The value of this expression is undetermined in C and C++, because these languages allow different operator evaluation orders, which means that the value of 'sum' may or may not have been updated through the 'accumulate' call.