Part i sistem utilities
This presentation is the property of its rightful owner.
Sponsored Links
1 / 28

PART I SISTEM UTILITIES PowerPoint PPT Presentation


  • 73 Views
  • Uploaded on
  • Presentation posted in: General

Ştefan Stăncescu. PART I SISTEM UTILITIES. Lecture 6 Compilers. COMPILERS. “high level language” HLL, w/complex grammar laws, closer to human language HLL mean for man  computer link human language  binary language HLL  binary language

Download Presentation

PART I SISTEM UTILITIES

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Part i sistem utilities

Ştefan Stăncescu

PART ISISTEM UTILITIES

Lecture 6

Compilers


Compilers

COMPILERS

  • “high level language” HLL,

  • w/complex grammar laws,

  • closer to human language

  • HLL mean for man  computer link

  • human language  binary language

  • HLL  binary language

  • COMPILER - Automatic translation machine


Compilers1

COMPILERS

  • Source Code =>in HLL language

  • Object code =>in binary language (machine code)

  • COMPILATION – cf. HLL grammar law

  • lexical laws

  • language elements type and structure

  • syntactic laws

  • composition rules of language elements

  • "semantic" laws (translationprograms)

  • syntactic law correspondent in object code, “semantic programs” for machine


Compilers2

COMPILERS

  • Compiling = review + translate HLL source text

  • lexical laws

  • scanner

  • syntactic laws

  • parser

  •  "semantic" laws

  • object code generator

  • (at the VM – intermediate code - "bytecode“)


Compilers3

COMPILERS

  • SCANER identifies tokens

  • language elements -

  • one or many adjacent single characters separated by characters sp, LF,FF, etc.)

  • words START, STOP, LABEL01

  • operators +*/-

  • special signs(){}//.,


Compilers4

COMPILERS

  • SCANER step I

  • scanning HLL source text

  • determine the token list by boundary

  • identify HLL tokens

  • identify programmer invented tokens

  • create look-up table with

  • numerical symbols for tokens


Compilers5

COMPILERS

  • SCANNER step 2

  • create intermediate source file

  • with replaced tokens with numerical symbols from the look-up table created in step 1


Compilers6

COMPILERS

  • BNF – Bachus-Naur Form

  • syntactic rule REPRESENTATION

  • A rule - law in BNF format 

  •  a valid construction in HLL language

  •  formatted template of

  • a rule applied in a line in source file

  • (and a rule applied for lines in a line list)


Compilers7

COMPILERS

  • Syntactic rule  valid construction in HLL

  • A template have the name of

  • the new built and checked element

  • that can be part of other construction

  • (including one with the same pattern)

  • New build name  “nonterminal” symbol

  • BNF rule form:

  • <nonterminal symbol > :: = building template


Compilers8

COMPILERS

  • Parsing  discovery in HLL source file of

  • successive valid BNF rules (templates) until

  • there are no more undiscovered laws

  • (no more “nonterminal” symbols)

  • Parsing ends only on tokens (“terminal” symbols)

  • Chaining BNF rules (templates) => syntax tree

  • The purpose parsing => the discovery of

  • the syntax tree of the source file


Compilatoare

COMPILATOARE

  • Line in the source file: S = A + B

  • (A, B, S-integer variables - tokens)

  • The code generator must explain

  • to the machine the templates finded

  • The scanner identifies tokens

  • “S” “=““A”“+”“B”

  • tokens “A”, “B”, “S” as variables

  • token “+” operator , token “=“ assign


Compilatoare1

COMPILATOARE

  • The parser verifies also the coherence of variables, if are the same

  • (if all A, B, S integers – OK)

  • if one is different, the templates for “+” and “=“ need conversion to coherent type

  • Ex: if S is real, A,B integer

  • “+” rule OK , result integer

  • “=“ (assignment rule) add

  • format conversion integer => real(float)


Compilers9

COMPILERS

  • I-stparseroperation - structures consistency

  • (conversion, if needed)

  • II-ndparser operation - A+B

  • (result in temporary memory)

  • III-rdparser operation - assigning result to S

  • (S=A+B)

  • Applicable BNF rules:

  • conversion, addition, assignment, in that order


Compilers10

COMPILERS

  • EXAMPLE II (bottom-up parsing)

  • S=A+B*C – D

  • scan theline, discover operations to be performed first

  • result become “nonterminal” symbol <N>

  • => The precedence of operators( + <. * )| ( * .> -)

  • Assuming algebraic expression rules

  • Syntactic algebraic rule of multiplication<product>::=<agent>*<agent>

  • Syntactic law of addition

  • <sum> ::=(<agent>+< agent >)|(< agent >-< agent >)


Compilers11

COMPILERS

  • EXEMPLE II (bottom-up parsing)

  • <N1>::=B*C

  • <N2>::=A+N1

  • <N3>::=N2-D

  • Syntactic tree of expression A+B*C-D


Compilers12

COMPILERS

  • EXEMPLE II (bottom-up parsing)

  • S=A+(B*C-D)

  • S=ATTRIB(N3)

  • N3=SUM(A,N2)

  • N2=SCAD(N1,D)

  • N1=PROD(B,C)

  • Syntactic tree of expression A+B*C-D


Compilers13

COMPILERS

  • STANDARD PROGRAM IN PASCAL SIMPLIFIED LANGUAGE

  • 1 MEDIA ANALYSIS PROGRAM

  • 2VAR

  • 3NRCRT, I: INTEGER;

  • 3SARITM, SARMON, DIF: REAL

  • 4BEGIN

  • 5 SARITM:=0;

  • 6 SARMON:=0;

  • 7FORI:=0TO100DO

  • 8BEGIN

  • 9READ (NRCRT);

  • 10SARITM:= SARITM + NRCRT;

  • 11SARMON:= SARMON + 1 DIV NRCRT;

  • 12END;

  • 13DIF:=SARITM DIV 100 – 100 DIV SARMON;

  • 14 WRITE(DIF);

  • 15END.


Compilers14

COMPILERS

  • GRAMMAR (BNF) PASCAL SIMPLIFIED LANGUAGE

  • 1.<prog>::= PROGRAM <prog-name> VAR <dec-list> BEGIN <stmt-list> END.

  • 2.<prog_name>::=id

  • 3.<dec_list>::=<dec> | <dec_list> ; <dec>

  • 4.<dec>::=<id_list> : <type>

  • 5.<type>::=INTEGER | REAL

  • 6.<id_list>::=id | <id_list> , id

  • 7.<stmt_list>::=<stmt> | <stmst_list> ; <stmt>

  • 8.<stmt>::=<assign> | <read> | <write> | <for>

  • 9.<assign>::=id := <exp>

  • 10.<exp>::=<term> | <exp> + <term> | <exp> - <term>

  • 11.<term>::=<factor> | <term> * <factor> | <term> DIV <factor>

  • 12.<factor>::=id | int | (<exp>)

  • 13.<read>::=READ(id_list)

  • 14.<write>::=WRITE(id_list)

  • 15.<for>::=FOR <index_exp> DO <body> ;

  • 16.<index_exp>::=id:= <exp> TO <exp>

  • 17.<body>::=<stmt> | BEGIN <stmt_list> END


Compilers15

COMPILERS


Compilers fisier elaborat de scaner

COMPILERS Fisier elaborat de scaner


Compilers16

COMPILERS

  • STANDARD

  • 9.READ (NRCRT);

  • BNF:

  • 13.<read>::=READ(id_list)

  • 6.<id_list>::=id | <id_list>) ; id


Compilers17

COMPILERS

  • STANDARD

  • 15.DIF:=SARITM DIV 100 – 100 DIV SARMON;

  • BNF:

  • 9.<assign> ::=id := <exp>

  • 10.<exp> ::=<term> | <exp> - <term>

  • 11.<term> ::=<factor> | <term> DIV <factor>

  • 12.<factor> ::=id | int| (<exp>)


Compilers18

COMPILERS


Compilers19

COMPILERS


Compilers20

COMPILERS

  • PROGRAM .=. VAR

  • BEGIN <. FOR

  • ; .> END.

  • Vide pairs - grammatical errors

  • Precedence relations– only one

  • (consistency grammar)


Compilers21

COMPILERS

  • Generating semantic programs

  • DIF:=SARITM DIV 100 – 100 DIV SARMON

  • id1 := id2 DIV int - int DIV id4

  • id1 := exp1 - exp2

  • id1 := exp3

  • DIVSARITM#100i1

  • DIV#100SARMONi2

  • -i1i2i3

  • :=i4,DIF


Compilers22

COMPILERS

  • (1):=#0,SARITM{SARITM:=0}

  • (2):=#0,SARMON{SARMON:=0}

  • (3):=#1,I{FOR i=1 to 100}

  • (4)JGTI#100(15)

  • (5)CALLX READ{READ(NRCRT)}

  • (6)PARAMNRCRT

  • (7)+SARITMNRCRTi1{SARITM:=SARITM+NRCRT}

  • (8):=i1,SARITM

  • (9)DIV#1NRCRTi2{SARMON:=SARMON+1 DIV NRCRT)

  • (10)+SARMONi2i3

  • (11):=i3,SARMON

  • (12)+I#1i4{sfîrşit FOR}

  • (13):=i4,I

  • (14)J(4)

  • (15)DIVSARITM#100i6{DIF :=SARITM DIV 100 -100 DIV SARMON}

  • (16)DIV#100SARMONi7

  • (17)-i6i7i8

  • (18):=i8,DIF

  • (19)CALLX WRITE

  • (20)PARAMDIF


Compilers23

COMPILERS

  • 1.L.L. Beck, „System Software: An introduction to systems programming”, Addison Wesley. 3’rd edition, 1997.

  • 2.A. V. Aho, M. S. Lam, R. Sethi, and J. D. Ullman, „Compilers: Principles, Techniques, and Tools”, 2'nd Edition. Addison-Wesley, 2007

  • 3.Wirth Niklaus ""Compiler Construction", Addison-Wesley, 1996, 176 pages. Revised November 2005

  • 4.Knuth, Donald E. "Backus Normal Form vs. Backus Naur Form", Communications of the ACM 7 (12), 1964, p735–736.


  • Login