CSE 341 Programming Languages Spring 1999 by yurtgc548

VIEWS: 0 PAGES: 20

									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

								
To top