Docstoc

CSE 341 Programming Languages Spring 1999

Document Sample
CSE 341 Programming Languages Spring 1999 Powered By Docstoc
					Representation, Syntax,
  Paradigms, Types

   •Representation
   •Formal Syntax
   •Paradigms
   •Data Types
   •Type Inference


        CSE 341 -- S. Tanimoto   1
          Syntax and Types
             General Issues
Representation (of data, of computation)
Form (Syntax)
Meaning (Semantics)
Paradigm (General way of thinking)
Naming (names, name spaces, bindings, locality)
Functionality (numeric, data manip, I/O,
communication, synchronization, security)
Correctness (types, exception handling, error
checking, bug avoidance)

                    CSE 341 -- S. Tanimoto        2
                      Syntax and Types
                   Syntax
Syntax: The grammatical form of programs.
vs Semantics: The meaning of the program
Syntax (of textual languages) is typically specified
by production rules for a context-free grammar
using Backus-Naur Form (BNF) or Extended BNF
(EBNF)
In visual languages, syntax is described by a set
of restrictions on how diagrams may be
constructed. (e.g., connection constraints)


                   CSE 341 -- S. Tanimoto              3
                     Syntax and Types
   Syntactic Components
Identifiers and reserved words
Numeric constants
Parentheses, braces and brackets
Expressions
Statements




                 CSE 341 -- S. Tanimoto   4
                   Syntax and Types
  BNF (Backus-Naur Form)
(2.0 * PI) / n
<expression>   ::=        <expression> + <term>
                 |      <expression> - <term>
                 |      <term>
<term>           ::=      <term> * <factor>
                 |      <term> / <factor>
                 |      <factor>
<factor>         ::=      number
                 |        name
                 |        ( <expression> )

                     CSE 341 -- S. Tanimoto       5
                       Syntax and Types
                Extended BNF
Optional constructs written as [ x ]
Zero or more of x written as { x }
Choice (“or”) written using |
Grouping with parentheses ( x | y ) as in { (x | y ) z }


<expression> ::= <term> { (+ | -) <term> }
<term>         ::= <factor> { (* | /) <factor> }
<factor>       ::= ’(’ <expression> ’)’ | name | number

                        CSE 341 -- S. Tanimoto             6
                          Syntax and Types
                   Derivation
E   ::=   E + T    |    E - T           |       T
T   ::=   T * F    |    T / F               |       F
F   ::=   number   |    name        |       ( E )




E                                     F / F + F
E + T                                 25 / F + F
T + T                                 25 / 100 + F
T / F + T                             25 / 100 + total
F / F + T

                       CSE 341 -- S. Tanimoto            7
                         Syntax and Types
    Representation of Data
Constants, Variables
Types, classes
Compounds: arrays, structures.
Non-numeric objects: strings, images, audio.
Values vs references
Machine dependencies: word size, addressing
resolution.
 In C, characters and booleans are actually integers.

                   CSE 341 -- S. Tanimoto               8
                     Syntax and Types
  Representation of Process
Arithmetic and logical expressions
Conditional expressions
Loops
Recursive and nonrecursive functions
Multiple threads of control, forking, joining,
synchronizing
Single-threaded Parallel processing (in Single-
instruction stream/multiple data stream processors)
Throwing and catching of exceptions
Declaration of constraints and rules
                      CSE 341 -- S. Tanimoto          9
                        Syntax and Types
                  Paradigm
General style of thinking that underlies a
programming language
Webster’s New World Dictionary: “a pattern,
example, or model”.


Imperative                       Rule-based
Functional                       Logic
Object-oriented                  Visual data-flow



                   CSE 341 -- S. Tanimoto           10
                     Syntax and Types
     The Imperative Paradigm
An imperative program is a sequence of commands


Read a value from a file.
Evaluate an arithmetic expression.
Assign a value to a variable.
Test a condition and branch if it is true.
Iterate a loop body until a condition is false.
Print a value onto the screen.



                    CSE 341 -- S. Tanimoto        11
                      Syntax and Types
      The Functional Paradigm
An functional program is a collection of function definitions
and function applications.


Define SQR(x): {
  Apply the * function to x and x}


Apply SQR to 7;




                        CSE 341 -- S. Tanimoto            12
                          Syntax and Types
The Object-Oriented Paradigm
An object-oriented program is a collection of object class
definitions, in which both data members and methods are
specified.


Class Student extends Person {
    int student_number;
    int get_student_number() { return student_number; }
    int set_student_number (int num) {
       student_number = num;
}

                       CSE 341 -- S. Tanimoto           13
                         Syntax and Types
    The Rule-Based Paradigm
A rule-based program is a collection of if-then rules.


if name = "" then input name;
if name starts with "A" then print "Early in the
alphabet";




                        CSE 341 -- S. Tanimoto           14
                          Syntax and Types
        The Logic-Programming
              Paradigm
A logic program is a collection of logical propositions and
questions.


If x is a bird or an airplane, then x has wings.
Tweety is a bird.
Does Tweety have wings?




                        CSE 341 -- S. Tanimoto            15
                          Syntax and Types
The Visual Data-Flow Paradigm
A visual data-flow program is a diagram in which boxes
represent operations and arrows indicate the flow of data
from outputs of operations to inputs of other operations.

                             3                  3x2 + 5x + 8

                   *
                                        *
   input                                            +
     x             *                                       +

           5                                        8

                       CSE 341 -- S. Tanimoto                  16
                         Syntax and Types
                   Types
Category or class for a value (or object) that
permits its bits to be interpreted.
Central Processing Unit instruction sets
recognize certain types, such as integers and
floats of different sizes.
A programming language is not limited to the
types that are directly supported by the CPU.




                  CSE 341 -- S. Tanimoto         17
                    Syntax and Types
      Strong vs Weak Typing
Strong typing: (static and usually monomorphic)
 Every variable must have a type.
A variable may receive only values of its type.
Type-related bugs can be reduced.
Type identification tags are not needed a run time.

Weak typing: (dynamic and usually polymorphic)
 Variables need not be declared with particular types.
The type of value held by a variable can change dynamically.
 Values must be tagged during execution with their types.
                        CSE 341 -- S. Tanimoto                 18
                          Syntax and Types
     Coercion and Contagion
Coercion: Any automatic type conversion.
 A value of type A is being assigned to a variable of type B.
 The value is coerced into one of type B.
 double x = 3 * 5;

Contagion:
 Values of lower precision “catch” the precision of their higher
precision co-arguments.
int y = 10 * (3.1415 / 10);              /* result is 3, not 0. */

In Common Lisp, when a rational meets a float, the rule of floating-
point contagion rules.

                          CSE 341 -- S. Tanimoto                   19
                            Syntax and Types
                 Type Inference
With weak typing, type inference is needed. (But ML,
which is strongly typed, also uses a kind of type inference.)

 The resulting type can be determined from the types of the
arguments, and the nature of the operations.
Contagion provides one method for type inference:
With strong typing, means for determining type
equivalence are needed.
int x[10];
int y[10];
Here x and y have structurally equivalent types.
C and C++ recognize structurally equivalent types as equivalent.
In Modula, most structurally equivalent types are not automatically
considered equivalent, but they can be declared equivalent.
                          CSE 341 -- S. Tanimoto                   20
                            Syntax and Types

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:0
posted:4/6/2013
language:Unknown
pages:20