Please enable JavaScript.

Coggle requires JavaScript to display documents.

ADPROC (Expressions (Expressions have a side effect if the return a value…

- - - - Leftmost Derivation
    - - Recursive decent parser RDP
        
        Based on BNF
        
        Collection of subprograms, many of which are recursive
        
        Subprogram for each non-terminal in the grammar
        
        Upon receiving a token:
        
        if it is a terminal of current rule make call for to lex() to get nextToken
        
        If it is a nonterminal symbol of the RHS of the current rule, call associated parsing subprogram
        
        if it is neither there is a syntax error
        
        Left recursion
        
        Leads to non-terminating recusion
        
        left- recursion grammar can be transformed into one that is not
      - LL (1) Parser
        
        Driven by parsing table
        
        left to right scan
        
        leftmost derivation
        
        '1' means one input symbol of lookshead
        
        Uses a stack to store symbols on the rhs of production in right to left order.
        
        Leftmost symbol on top of stack
        
        Parsing table stores the actions the parser should take
        
        Col 1: nonterinmal symbol grammar
        
        Row 1: terminal symbols. $ is the end of input
        
        entries give the rules of choice based on current input and current non-term symbol
- - - - has a type of elements
      - type of indices (usually integers)
      - Number of elements (index range)
      - Dynamic arrays allow for more suitable sized arrays
        
        stack arrays, size is set at run-time
        
        heap-dynamic lives on the heap and can change size
      - Heterogeneous
        
        Elements need NOT be the same type
      - 2D array is also a rectangular array with equal number of elements in all rows and columns
      - Jagged array is a 2d array with unequal elements in every row and col
        
        More memory efficient and flexible
    - - composed of a number of named elements
      - records can be memory inefficient and in flexible
      - fixed set of fields
    - - records in C are called structs
      - similar to classes, without constructors
    - - allows alternative choices
      - c languages have unions instead
        
        designed to store data of different types in the same memory space
  - - - Control process
        
        subprograms/functions
        
        necessary for modularity
        
        each module can be used separately from the system
      - Data abstraction
        
        separation between abstract properties and concrete details
        
        abstract properties are those that are visible to the code that make use of the data type
    - - a set of data
      - necessary operation
    - - hash table
      - binary search tree
      - linear list of pairs
    - - E.g. a list
        
        Data: Collection of items
        
        Operations: add/remove, sort
    - - Basic info should not be difficult to obtain
      - Set of operations should be adequate
      - Each operation should have a well-defined purpose
      - Have a few simple operation that can be combined to complex ones
- - - - selection (choosing from two control flow paths)
      - pre-test logical loop (the condition is tested before the body of loop is executed, e.g., while() loop)
- - - - N = Finite set of non terminal symbols
      - P = Context free productions of the form A --> a
      - S = Start symbol
      - T = Finite non-empty set of terminal symbols
    - - in BNF , non-terminal symbols are given descriptive names within <>
    - - Starting with S, repeatedly apply production rules until obtain a string of only of terminal symbols, which in a sentence
      - Derivation
      - Sentential form
      - Notation
        
        Produces
        
        derives
    - - To avoid: addition of extra non-terminals and rules
    - - Some aspects cannot be captured
      - context sensitive properties are resolved by semantic analyser
- - - - name
      - address
      - value - contents of memory cell
      - type
      - life time
      - scope
    - - Explicit
        
        declares variable with type
      - Implicit
        
        Variable is given default type through conventions
        
        Another kind is type inference
        
        An initial value must be given
  - - - Static
        
        Occurs before run time and remains unchanged throughout
        
        If all binding are static, errors can be picked up this is strongly typed
      - If declarations always carry type info, binding can happen in compile type
      - Dynamic
        
        Occurs during execution or changes during execution
        
        Gives flexibility : :check:
        
        High cost :red_cross:
        
        Type error detection is hard :red_cross:
        
        Leads to weak typing