©j.tiberghien - ulb-vub version 2003-2004 1 troisième partie chapitre 1 les supports à la...

©J.Tiberghien - ULB-VUB©J.Tiberghien - ULB-VUBVersion 2003-2004 1

Troisième Partie

Chapitre 1

Les supports à la programmation


Programming languages

Machine Language

Assembler

C++

Source

code

Objectcode

High LevelLanguage

Low Level

Languages

HARDWARE


Data Memory

Arithmetic Unit

Control Unit

Program Memory (from 11)

100: ND

102: SC

1:KFL

2:KDA

3:DDA

4 5 6

1 2 3

* 0 #

7 8 9

10 10 0 10011 10 0 10212 40 1 0 1213 22 102 10 10214 20 102 2 102

16 20 101 1 10117 41 101 3 1218 41 2 321 1019 10 1 3

15 10 0 1

20 47 10

Machine Language


Assembler LanguageLabel Operation Operands Comments

ORG 100 First address of data memory

ND DAT 2 Number of entered digits, 2 bytes

SC DAT 2 Secret Code as entered, 2 bytes

KFL EQU 1 Keyboard flag

KDA EQU KFL+1 Keyboard data

DDA EQU 3 Door data

ORG 10 First address of program memory

BGN COPY #0,ND Initialise number of entered digits

COPY #0,SC Initialise secret code

TFL EQ? KFL,#0,TFL Test continuously for key stroke

MUL SC,#10,SC Shift SC one digit to the left

ADD SC,KDA,SC Add newly entered digit to SC

COPY #0,KFL Reset Keyboard flag

ADD ND,#1,ND Increase number of entered digits

NE? ND,#3,TFL Any more digits needed ?

NE? SC,#321,BGN Is the entered secret code correct ?

COPY #1,DDA Open the door

JMP BGN Restart everything

END


KFL =

KDA =

DDA =

4 5 6

1 2 3

* 0 #

7 8 9

Main(){int sc = 0; const int Key = 321; bool *KFL = 1; int *KDA = KFL+1; bool *DDA = 3; while (true) {for (int nd=1;nd<=3;++nd) {while (*KFL == 0); sc = sc*10+*KDA; } if (sc == Key) *DDA = 1; }}

High Level language


HARDWARE

INTERPRETER

Source Code (LLL or HLL)

Translator

Object Code

Transforming Source Code


Translators vs. Interpreters

• Translators– Translate the entire program at once– Program execution very fast– Poor run-time error messages

• Interpreters– Translate and execute statement after

statement– Very slow execution– Good run-time error messages


Macros

…LDA +7,ULDB +5,UMULSTD +2,ULDA +6,ULDB +5,UMULADD +1,USTD +1,ULDA +6,ULDB +5,UMULADD +1,U...

MULB MDEFLDA &1LDB &2MULMEND…MULB+7,U;+5,USTD +2,UMULB+6,U;+5,UADD +1,USTD +1,UMULB+6,U;+5,UADD +1,U...


Macros in HLL

/* The Program: */ main(void){# include “one”}

/* file one */ printf(“ from 1.\n”);# include “two”

/* file two */ printf(“ from 2.\n”);

from 1. from 2.


Macro Expanders

Source

Object

Macro Expander

Main module Macro Library

AssemblerCompiler

Expanded Source Code


Macros vs. Functions

• MACROS

– Static Expansion

– Waste of memory

– Fast

– Powerful parameter

passing, even in

assembler

• FUNCTIONS

– Dynamic Expansion

– Save memory space

– Slow

– Programmer friendly

parameter passing not

available in assembler


HARDWARE

INTERPRETER

Source Code (HLL)

COMPILER

Object Code

Translating HLLs


Syntax and Semantics

• Syntax = form

• Semantics = meaning

• Example– My beer is on the table

• Syntax : OK

• Semantics : OK

– My table is on the beer• Syntax : OK

• Semantics : You had too many beers !!!


Syntax Definition :Backus Naur Formalism (BNF)

• Terminal Symbols– Appear literally in program text– Examples : “a”, “3”, “END”, “>”, “:=”

• Non-terminal Symbols– Name given to set of terminal symbols– Written between < and >– Defined by a metalinguistic expression– Examples : <Letter> , <Digit>,<Expression>,<ifstatement>

• Metalinguistic expression– Formal definition (::=) of a non-terminal symbol– Contains terminal and non-terminal symbols – Expresses juxtaposition or choice (the | operator)– Example : <Digit> ::= 0|1|2|3|4|5|6|7|8|9


BNF Examples (1)

<UpperCaseLetter> ::= A|B|C|D|E| |X|Y|Z

<LowerCaseLetter> ::= a|b|c|d|e| |x|y|z

<Letter> ::= <UpperCaseLetter> | <LowerCaseLetter>

<Digit> ::= 1|2|3|4|5|6|7|8|9|0

<CardinalNumber> ::= <Digit> | <Digit><CardinalNumber>

<IntegerNumber> ::= <CardinalNumber>

| + <CardinalNumber>

| - <CardinalNumber>

<Identifier> ::= <Letter> | <Identifier><Letter>| <Identifier> <Digit>



Is 123 a <CardinalNumber> ?

Is it a <Digit> ?

Certainly not



Is it a <Digit> followed by a <CardinalNumber> ?







Is it a <Digit> ?

Certainly not








Is it a <Digit> ?

YES








Is it a <Digit> ?

YES

As a consequence, 3 is a <CardinalNumber>








Is it a <Digit> ?

YES





<Identifier> ::= <Letter> | <Identifier><Letter> | <Identifier>

<Digit>

• Correct identifiers– Length, Width, Cost, ...– MySalary, NumberOfStudents, Year1, …– X1, Y2, A1, A5, …

• Incorrect identifiers– My Salary, Number-of-students, …

– 1stYear, ...


Syntax Definition

BNFNon-recursive

BNFSyntax

diagram

Definition

Choice

0 or 1occurrence

0, 1 or manyoccurrences

::= ::= Diagram

[]

{}


Syntax Definition

BNFNon-recursive

BNFSyntax

diagram

Definition

Choice

0 or 1occurrence


::= ::= Diagram

[ ]

{}


<UpperCaseLetter> ::= A|B|C|D|E| |X|Y|Z

<LowerCaseLetter> ::= a|b|c|d|e| |x|y|z

<Letter> ::= <UpperCaseLetter> | <LowerCaseLetter>

<Digit> ::= 1|2|3|4|5|6|7|8|9|0

<CardinalNumber> ::= <Digit> {<Digit>}

<IntegerNumber> ::= [+|-]<CardinalNumber>

<Identifier> ::= <Letter> {<Letter>|<Digit>}

BNF Examples (2)


Backus Naur Formalism (BNF)

• Terminal Symbols

• Non-terminal Symbols

• Metalinguistic expression– Railroad diagrams with semaphores requiring specific

symbols to grant passage.– The defined non-terminal symbol leaves all its symbols, in

the order of occurrence, at appropriate semaphores and reaches the exit with none left.

Terminal symbol

Non-terminal symbol


Syntax Definition

BNFNon-recursive

BNFSyntax

diagram

Definition

Choice

0 or 1occurrence


::= ::= Diagram

[]

{}


Syntax DiagramsExamples

•UpperCaseLetter

A B C D E V W X Y Z

•Letter

•LowerCaseLetter

a b c d e v w x y z

UpperCaseLetter

LowerCaseLetter



Digit

0 1 2 3 4 5 6 7 8 9

CardinalNumber<CardinalNumber> ::= <Digit> {<Digit>}

<Digit> ::= 0|1|2|3|4|5|6|7|8|9

Digit

Digit

Digit



IntegerNumber

<IntegerNumber> ::= [ + | - ] <CardinalNumber>

CardinalNumber+

-



Identifier

<Identifier> ::= <Letter> {<Letter>|<Digit>}

Letter

Digit

Letter


Source Code (HLL)

The COMPILER

Object Code

HARDWARE

COMPILER = Lexical analyzerSyntax analyzerCode generatorCode optimizer


The Lexical Analyzer

• Recognizes lexical tokens such as:

– Identifiers

– Numbers :

• -200, 6.3E23, …

– Reserved words :

• for; if;

– Multi-character symbols :

• /*; */; == ; != ; ...

• Prepares the symbol table with all identifiers


The Syntax Analyzer

(= syntax parser)• Recognizes non-terminal symbols such as:

– a program :– a variable declaration :– a function declaration :– an expression

• Can be generated automatically by a parser generator, starting from the BNF syntax definitions

• Represents a program by a syntactical tree and a symbol table.


Error detection and correction

• Both the lexical and syntactical analyzer should check the source code against syntax errors.

• When an error has been found, the syntax analyzer should– generate an error message and stopor– generate an error message – try to correct by guessing the programmers intentions– resume the syntax analysis

• A compiler should never generate any code as long as syntax errors are present in the source code, even if the syntax analyzer has corrected them in order to continue the analysis.


Multi-pass compiler

Source

Object

Lexical analysis

SymboltableInt.1

Int.1

Int.1

Syntax analysis

Code generation

Optimization


Single - pass compiler

Source

Object

SymboltableSyntax analysis

Code generation

Lexical analysis


Interpreters

Source

SymboltableSyntax analysis

Simulated code execution

Lexical analysis

©j.tiberghien - ulb-vub version 2003-2004 1 troisième partie chapitre 1 les supports à la...

Documents