Syntax and Semantics

Transcription

1 Syntax and Semantics Syntax - The form or structure of the expressions, statements, and program units Semantics - The meaning of the expressions, statements, and program units Syntax Example: simple C if statement if (<expr> ) <true-statement> else <false-statement> Semantics Example: if the expression evaluated to true (nonzero) execute the true statement (or block) otherwise execute the false statement (or block) Semantics should follow from syntax, the form of statements should be clear and imply what the statements do or how they should be used.

2 Describing Syntax 1.A sentence is a string of characters over some of language is a set of sentences 2.A lexeme is the lowest level syntactic unit of a language Ex: *,+,=, sum, begin 3.A token is a category of lexemes units Ex: identifier Example: index= 2* count+17; Lexemes Tokens Index identifier = equal_sign 2 int_literal * Mult_op

3 Formal Definition of Languages a) Recognizers: A recognition device reads input strings of the language and decides whether the input strings belong to the language or not Example: syntax analysis part of a compiler b)generators: A device that generates sentences of a language. if the syntax of a particular sentence is correct by comparing it to the structure of the generator

4 Formal Methods of Describing Syntax (Backus-Naur form ) Context-Free Grammars: it is Developed by Noam Chomsky in the mid- 1950s Language generators used to describe syntax of natural languages Define a class of languages called context-free languages Backus-Naur Form (1959) Invented by John Backus to describe Algol 58 BNF is equivalent to context-free grammars. He is a number of ACM-GAMM group at an international conference Slight modification was done by peter naur,used Algol 60 knowns as Backus-Naur Form (1960) Extended BNF - Improves readability and writability of BNF A metalanguage is a language used to describe another language.

5 Formal Methods of Describing Syntax In BNF, abstractions are used to represent classes of syntactic structures-they act like syntactic variables (also called non terminal symbols) <while_stmt> while ( <logic_expr> ) <stmt> This is a rule or production and it describes the structure of a while statement A rule has a left-hand side (LHS) and a right-hand side (RHS), and consists of terminal and nonterminal symbols A grammar is a finite non-empty set of rules Be careful with BNF you will find that people are loose with it and instead of < > you may find italics for non-terminals. You may also see it extended with common regular expression constructs.

6 Formal Methods of Describing Syntax (Fundamentals) An abstraction called as nonterminal symbol can have more than one RHS. Lexemes and tokens of rules are called as terminals EX1: <if-stmt> if <exp> then <stmt> <if-stmt> if <exp> then <stmt> else <stmt> It can also be represented as EX1: <if-stmt> if <exp> then <stmt> if <exp> then <stmt> else <stmt> Here different definitions are separated by the symbol it indicates logical OR

7 DESCRIBING LISTS Syntactic lists are described using recursion (LHS appears on RHS) <ident_list> ident ident, <ident_list> (comma is terminal) A derivation is a repeated application of rules, starting with the start symbol and ending with a sentence (all terminal symbols)

8 Formal Methods of Describing Syntax Every string of symbols in the derivation is a sentential form finally ending up in a sentence which is a sentential form that has only terminal symbols A leftmost derivation is one in which the leftmost nonterminal in each sentential form is the one that is expanded, rightmost is the opposite. You could also do one that is not so consistent. Derivation order should have no effect on the language generated by a grammar. Exhaustively choosing all combos in rules should generate the whole language, but most programming language grammars are infinite and all sentences could not be generated in finite time.

9 Formal Methods of Describing Syntax (Grammars and Derivations) <sentence> <noun-phrase> <verb-phrase>. <noun-phrase> <article> <noun> <article> a the <noun> girl dog <verb-phrase> <verb> <noun-phrase> <verb> sees pets -An example derivation (left most): (=> reads as derives) <sentence> => <noun-phrase> <verb-phrase>. => <article> <noun> <verb-phrase>. => the <noun> <verb-phrase> => the girl <verb-phrase>. => the girl <verb> <noun-phrase>. => the girl sees <noun-phrase>. = > the girl sees <article> <noun>. = > the girl sees a <noun>. = > the girl sees a dog.

10 Context Free Grammar In a context-free grammar we find that replacements do not have any context which they cannot occur. For example :imagine that pets as a verb should be allowed in the case that i) girl is the subject ii) The dog pets the girl = wrong iii) The girl pets the dog = ok Adding more productions you might be able to work around simple issues, but be careful we are starting to confuse syntax and semantics and there are some things that will not be possible It does not matter how many productions we add.

11 Formal Methods of Describing Syntax (Continued) A Grammar: <program> <stmts_list> <stmts_list> <stmt> <stmt> ; <stmts_list> <stmt> <var> = <expr> <var> a b c d <expr> <term> + <term> <term> - <term> <term> <var> const An example derivation: <program>=> <var> = <expr> => a = <expr> => a = <term> + <term> => a = <var> + <term> => a = b + <term> => a = b + const

12 Formal Methods of Describing Syntax (Continued) An another example grammar: <expr> <expr> + <expr> <expr> * <expr> (<expr> ) <number> <number> <number> <digit> <digit> <digit> An example derivation: <number> => <number> <digit> => <number> <digit> <digit> => <digit> <digit> <digit> => 2 <digit> <digit> => 23 <digit> => 234

13 Parse Tree The hierarchical syntactic structure of the sentence of language is called as parse tree Internal node is labeled with non terminal Symbol and leaf node with terminal symbol

14 Ambiguity Two different derivations can lead to the same the parse treeis called as Ambiguity. This is good because the grammar is unambiguous Example: Given 234 we have different derivations number => number digit number =>number digit => number 4 => number digit digit => number digit 4 => digit digit digit => number 3 4 => 2 digit digit => digit 3 4 => 2 3 digit => 234 => 234

15 Extended BNF (EBNF) 1. Optional parts are placed in brackets ([]) <proc_call> -> ident [ ( <expr_list>)] 2. Put alternative parts of RHSs in parentheses and separate them with vertical bars <term> -> <term> (+ -) const 3. Put repetitions (0 or more) in braces ({}) 4. EBNF: <ident> -> letter {letter digit} It is represented as follows <expr> <term> {(+ -) <term>} <term> <factor> {(* /) <factor>}

16 BACKUS NAUR FORM(BNF) The previous example is represented in BNF <expr> <expr> + <term> <expr> - <term> <term> <term> <term> * <factor> <term> / <factor> <factor>

17 Attribute Grammars Primary value of AGs: 1. Static semantics specification 2. Compiler design (static semantics checking) Def: An attribute grammar is a cfg G = (S, N, T, P) with the following additions: 1. For each grammar symbol x there is a set A(x) of attribute values 2. Each rule has a set of functions that define certain attributes of the nonterminals in the rule 3. Each rule has a set of predicates to check for attribute consistency

18 ATTRIBUTE GRAMMARDEFINED Let X0 X1... Xn be a rule. Functions of the form S(X0) = f(a(x1),... A(Xn)) define synthesized attributes Functions of the form I(Xj) = f(a(x0),..., A(Xn)), for i <= j <= n, define inherited attributes Initially, there are intrinsic attributes on the leaves Example: expressions of the form id + id id's can be either int_type or real_type types of the two id's must be the same type of the expression must match it's expected

19 Attribute Grammars <assign> <var>=<expr> <expr> <var> + <var> <var> id <id> A B C. Attributes: actual_type - synthesized for <var> and <expr> expected_type - inherited for <expr>

20 Attribute Grammars 1.If all attributes were inherited, the tree could be decorated in top- down order. 2. If all attributes were synthesized, the tree could be decorated in bottom-up order. 3. In many cases, both kinds of attributes are used, and it is some combination of top-down and bottom-up that must be used. 4. Rules are given below 1. <expr>.expected_type inherited from parent 2. <var>[1].actual_type lookup (A) var>[2].actual_type lookup (B) 3. <expr>.actual_type <var>[1].actual_type

21 Complete Attribute Grammar The Attribute Grammar: 1. Syntax rule: <expr> <var>[1] + <var>[2] Semantic rules: <expr>.actual_type <var>[1].actual_type=int and<var>[2].actual_type=int Predicate: <expr>.actual_type=<expr>.expected_type. 2. Syntax rule: <expr> <var> Semantic rules: <expr>.actual_type <var>[1].actual_type. Predicate: <expr>.actual_type=<expr>.expected_type. 3. Syntax rule: <var> id (i.e A B C) Semantic rule:<var>.actual_type lookup (<var>.string)

22 SEMANTICS Semantics is the field concerned with the rigorous mathematical study of the meaning of programming languages. (Effects of each statement towards its values and variables) Semantics describes the processes a computer follows when executing a program in that specific language. This can be shown by describing the relationship between the input and output of a program, or an explanation of how the program will execute on a certain platform, hence creating a model of computation.

23 SEMANTICS Various kinds of semantics: I. Operational semantics II. Denotation semantics III. Axiomatic semantics a)operational semantics: It defines the program in terms of how it is executed. It describes each and individual units of a program to show how to execute and performs its computation. The aim of program meaning is whatever happens when the program is compiled and run on machine M

24 SEMANTICS b)denotational semantics: Meanings are modelled by mathematical objects that represent the effect of executing the constructs. Thus only the effect is of interest, not how it is obtained. It can be expressed as a collection of function operation on the program state. c)axiomatic semantics: Specific properties of the effect of executing the constructs are expressed as assertions.the semantics of a program written in the language is then derived from semantics of its compositing parts(assignment, loop,etc) Logical properties to update the program during run/ hold some property before a program is run. eg : If P&Q, P<Q, then the value stored in a variable MIN is p.

25 Example Binary Number The syntax of a binary number is: <bin_num> 0 1 <bin_num> 0 <bin_num> 1 To describe the meaning of a binary number using denotational semantics we associate the actual meaning with each rule that has a single terminal symbol in its RHS. The syntactic entities in this case are 0 and 1. The objects are the decimal equivalent.

26 Denotational Semantics: Program Constructs Let the state of a program be represented as a set of ordered pairs as follows: s = {<i 1, v 1 >, <i 2, v 2 >,, <i n, v n >} Each i is a variable and the associated v is its current value. Any of the v s can have the special value undef. Let VARMAP be a function that, when given a variable name and a state, returns the current value of the variable VARMAP(i j, s) = v j The state changes are used to define the meanings of programs and program constructs. Some constructs, such as expressions, are mapped to values, not states.

27 Denotational Semantics: Expressions We assume here that we deal with only simple expressions: Only + and * operators. An expression can have at most one operator. The only operands are scalar variables and integer literals. No parenthesis. The value of an expression is integer

28 Denotational Semantics: Expressions The BNF description of these expressions: <expr> <dec_num> <var> <binary_exp> <inary_exp> <left_exp> <operator> <right_exp> <left_exp> <dec_num> <var> <right_exp> <dec_num> <var> <operator> + * The only error we consider in expressions is that a variable has an undefined value. Let Z be the set of integers, and let error be the error value. Then Z U {error} is the set of values to which an expression can evaluate.

29 Denotational Semantics: Expressions The DS of expressions are (dot notation refer to child nodes of a node) M e (<expr>, s) = case <expr> of <dec_num> = M dec (<dec_num>, s) <var> = if VARMAP(<var>, s) == undef then error else VARMAP(<var>, s) <binary_expr> = if (M e (<binary_expr>.<left_expr>, s) == undefor M e (<binary_expr>.<right_expr>, s) = undef) then error else if (<binary_expr>.<operator> == + then M e (<binary_expr>.<left_expr>, s) + M e (<binary_expr>.<right_expr>, s) else M e (<binary_expr>.<left_expr>, s)* M e (<binary_expr>.<right_expr>, s)

30 Assignment Statements An assignment statement is an expression evaluation plus the setting of the left-side variable to the expression s value. Maps state sets to state sets M a (x := E, s) = if M e (E, s) == error then error else s = {<i 1,v 1 >, <i 2,v 2 >,..., <i n,v n >}, where for j = 1, 2,..., n, v j = VARMAP(i j, s) if i j <> x = M e (E, s) if i j == x

31 Logical Pretest Loops Assume we have two mapping functions, M sl and M b M sl Maps statement list to states. M b Maps boolean expression to boolean value. The DS of a simple loop are: M l (while B do L, s) = if M b (B, s) == undef then error else if M b (B, s) == false then s else if M sl (L, s) == error then error else M l (while B do L, M sl (L, s))

32 Loop Meaning The meaning of the loop is the value of the program variables after the statements in the loop have been executed the prescribed number of times, assuming there have been no errors In essence, the loop has been converted from iteration to recursion, where the recursive control is mathematically defined by other recursive state mapping functions