๐ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด - ๊ตฌ๋ฌธ๋ก ๊ณผ ์๋ฏธ๋ก
@ ๊ตฌ๋ฌธ๋ก ๊ณผ ์๋ฏธ๋ก
๐ซ Syntax, Semantics
Syntax ๊ตฌ๋ฌธ๋ก (ํํ, ๋ชจ์, ๋ฌธ๋ฒ)
โ The Form
of expressions, statements, and program units
Semantic ์๋ฏธ๋ก
โ The Meaning
of expressions, statements, and program units
i.e. while (bool) statement
โ ์ ๋ช
๋ น์ด์ ๋ฌธ๋ฒ
๊ทธ๋ฆฌ๊ณ ์๋ฏธ
๐ซ ์ธ์ด ๊ธฐ์ ์ ๋ฌธ์ ์ - Programming Language Description
ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ฅผ ๊ฐ๋ช ํ๊ฒ/์ดํดํ๊ธฐ ์ฝ๊ฒ ๊ธฐ์ ํ๋ ๊ฒ์ ํ์์ ์ด์ง๋ง, ์ด๋ ต๋ค.
์ Why, ์ธ์ด ๊ธฐ์ ๋ ์๊ฐ ๋ค์ํจ
- ์ด๊ธฐ ํ๊ฐ์ : ์ธ์ด ๊ธฐ์ ์ ๋ช ๋ฃ์ฑ ์ค์
- ๊ตฌํ์ : ์ธ์ด ๊ธฐ์ ์ ์์ ์ฑ๊ณผ ์ ํ์ฑ ์ค์
- ์ฌ์ฉ์ : ์ธ์ด ์ฐธ๊ณ ๋ฉ๋ด์ผ์ ์ ๊ณต
๐ซง Syntax์ Semantics๋ ์๋ก ๋ฐ์ ํ ๊ด๋ จ
์ธ์ด ์ค๊ณ๊ฐ ์๋์๋ค๋ฉด,
๋ฌธ์ฅ์ ๋ฌธ๋ฒ(Syntax)์์ ์๋ฏธ(Semantics)๊ฐ ๊ณง๋ฐ๋ก ๋ณด์ฌ์ผ
๐ซง Syntax๋ฅผย ๊ธฐ์ ํ๋ ๊ฒ์ด Semantics๋ฅผ ๊ธฐ์ ํ๋ ๊ฒ๋ณด๋ค ์ฝ๋ค
@ ์ ์ : ๋ช ํํ๊ณ ๊ณตํต์ ์ผ๋ก ๋ฐ์๋ค์ฌ์ง๋ ๊ธฐ์ ์์(๋ฐฉ๋ฒ)
์ธ์ด์ Syntax : ์ ์์ด ์์
์ธ์ด์ย Semantics : ์ ์์ด ์์
๐ซ Syntax ์ ์์ ๋ฌธ์ ์ (ํด๊ฒฐ ๊ณผ์ )
@ ์ปดํ์ผ๋ฌ ๋ง๋ค ๋, Lex (Lexeme ๊ตฌ๋ถํด์ฃผ๋) & Yacc (Parser)
๐ซง Lexeme, Token
- Lexeme - ์ดํ ํญ๋ชฉ
- (ํ์์ ๋ฌธ๋ฒ์ผ๋ก) ์ฝ๋ ์ต์ ๊ตฌ๋ถ ๋จ์ (Syntax ๊ธฐ์ค)
- ์ธ์ด์ ํ์์ (Formal) ๊ธฐ์ (Description)์์ Lexeme์ ํฌํจ๋์ง ์์
- โ ์ธ์ด์ Syntax (ํน์ Grammar)์ ๊ธฐ์ ์ ํฌํจ๋์ง ์์
- Token
- ์๋ฏธ์ ์ผ๋ก ๊ตฌ๋ถ๋๋ ์ต์ ๋จ์
- ์ดํ ํญ๋ชฉ์ ๋ํ ํ ๋ถ๋ฅ
- i.e. C, 6๊ฐ์ ํ ํฐ (Identifier, Keyword, Constant, String literal, Operator, Separator)
์ดํ ํญ๋ชฉ โ ๊ทธ๋ฃน๋ค โ ๋ํ(๋ถ๋ฅ) by ํ ํฐ
i.e. x + y = 10 Lexeme
- Token
x, y - Identifier
+ - Addition Operator
= - Equal Sign
10 - Int Literal
@ Parse ํธ๋ฆฌ๋ฅผ ๋ง๋๋๋ฐ, ์ ๋ง๋ค์ด์ง๋ฉด ๋ฌธ๋ฒ ์ค๋ฅ
ํ๋ก๊ทธ๋๋ฐ ์ธ์ด ์ ์ ๋ฐฉ๋ฒ โ ์ธ์ด ์ธ์๊ธฐ, ์ธ์ด ์์ฑ๊ธฐ
์ธ์ด ์ธ์๊ธฐ โ ์ ์๋ ๋ฌธ๋ฒ์ผ๋ก๋ถํฐ ์ธ์ด L์ ์ ์ํ๊ณ โ ์ฃผ์ด์ง ๋ฌธ์์ด์ด L์ ํฌํจ๋๋์ง ํ๋จ โ ์ปดํ์ผ๋ฌ์ ์ดํ ๋ถ์๊ธฐ(Lexical Analyzer)์ ๊ตฌ๋ฌธ ๋ถ์๊ธฐ(parser)์์ ์ฌ์ฉ
์ธ์ด ์์ฑ๊ธฐ
โ ์ ์๋ ๋ฌธ๋ฒ์ผ๋ก๋ถํฐ ์ธ์ด L์ ์์ฑํ๋ ์ฅ์น
๐ซ ๊ตฌ๋ฌธ ๊ธฐ์ ์ ํ์์ ๋ฐฉ๋ฒ
@ Syntax Description, Formal
Grammar : ๊ตฌ๋ฌธ ๊ธฐ์ ์ ํ์์ ์ธ์ด ์์ฑ ๋งค์ปค๋์ฆ
Chomsky Hierarchy
Type-0, Unrestricted Grammar
Type-1, Context Sensitive Grammar
Type-2, Context Free Grammar
Type-3, Regular Grammar
๐ซง ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ๋ฌธ๋งฅ ์์ ๋ฌธ๋ฒ Context-Free
- ํ ํฐ๋ค์ ํํ๋ ์ ๊ท๋ฌธ๋ฒ์ผ๋ก ๊ธฐ์ ๊ฐ๋ฅ Regular Grammar
- by Lex(Lexeme Analyzer Program)
- Syntax๋ ๋ช ๊ฐ์ง ์ฌํญ๋ง ์ ์ธํ๋ฉด Context-Free ๋ฌธ๋ฒ์ผ๋ก ๊ธฐ์ ๊ฐ๋ฅ
@ Meta Language - ๋ค๋ฅธ ์ธ์ด๋ฅผ ๊ธฐ์ ํ๋ ์ธ์ด
- BNF, Backus-Nour Form ํ์
- ๋ฉํ ์ธ์ด, ๊ตฌ๋ฌธ ๊ตฌ์กฐ ์ถ์ํ
- Context-Free ๋ฌธ๋ฒ๊ณผ ๊ฑฐ์ ๋์ผ
- Bakus : John Bakus, ALGOL 58 ๊ธฐ์
- Nour : Peter Naur, ALGOL 60 ๊ธฐ์ ์ํด ์์
@ LHS - Left Hand Side
@ RHS - Right Hand Side
i.e. <assign> โ <var> = <expression>
- Rule ๊ท์น, Production ์์ฑ
- LHS โ RHS, ์ฐ๊ฒฐ(์ ๋) ํ๋ ๊ฒ
- LHS : ์ ์ํ๋ ค๋ ์ถ์ํ
- RHS : ์ ์ - Token, ์ดํํญ๋ชฉ, ๋ค๋ฅธ ์ถ์ํ
@ Terminal ๋๋, ๋ณํ์ง ์๋
Nonterminal Symbol : ์ถ์ํ๋ ๋์, ์ฌ๋ฌ ์ ์ ๊ฐ๋ฅ
Terminal Symbol : ๊ท์น์ ํฌํจ๋ ์ดํ ํญ๋ชฉ๊ณผ ํ ํฐ
i.e.
<if_stmt> โ
if (<logic_expr>) <stmt> | if (<logic_expr>) <stmt> else <stmt>
๊ฐ๋ณ ๊ธธ์ด์ ๋ฆฌ์คํธ๋ฅผ ํํํ ๋ (BNF์์๋) Recursive ์ฌ๊ท ์ฌ์ฉ
i.e. <ident_list> โ identifier | identifier,
๐ซ ๋ฌธ๋ฒ๊ณผ ์ ๋
@ U ์ค๊ฐ๊ณ ์ฌ ์ถ์ : ๋ฌธ๋ฒ์ด ๋ชจํธํ๋ค๋ ๊ฒ์ ์ด๋ค ์๋ฏธ์ธ์ง, ์ฃผ์ด์ง ๋ฌธ๋ฒ๊ณผ ๋ฌธ์ฅ์ ๊ฐ์ง๊ณ ์ค๋ช ํ์์ค.
๋ฌธ๋ฒ : ์ธ์ด๋ฅผ ์ ์ํ๊ธฐ ์ํ ์์ฑ ์ฅ์น
- ์ ๋(๋์ฒด) Derivation
- ๋ฌธ์ฅ์ ์์ฑํ๊ธฐ ์ํด ์ผ๋ จ์ ๊ท์น์ ์ ์ฉํ๋ ๊ฒ
- ์์๊ธฐํธ Start Symbol
- ์ต์ด์ ์์์ ์ ๋ํ๋ด๋ ํน์ ๋ ผํฐ๋ฏธ๋
- ํ๋ก๊ทธ๋จ ์ ์ฒด๋ฅผ ๋ํ๋, ์ผ๋ฐ์ ์ผ๋ก <program>
์์ ๊ธฐํธ๋ถํฐ ์ ์๋ ๋ฌธ๋ฒ์ ์ด์ฉํ์ฌ ๋ฌธ์ฅ ์ ๋
Loop Until ์ด๋ ํ ๋
ผํฐ๋ฏธ๋๋ ํฌํจํ์ง ์์ ๋๊น์ง
i.e.
์ฃผ์ด์ง ๋ฐฐ์ ๋ฌธ : begin A = B + C; B = C end
<program> โ begin <stmt_list> end
<stmt_list> โ <stmt> | <stmt> ; <stmt_list>
<stmt> โ <var> = <expression>
<var> โ A | B | C
<expression> โ <var> + <var>, <var> | <var> | <var>
์ฃผ์ด์ง ๋ฐฐ์ ๋ฌธ : begin A = B * A + C end
<assign> โ <id> = <expr>
<id> โ A | B | C
<expr> โ <id> + <expr> | <id> * <expr> | (<expr>) | <id>
์ต์ข๋จ ์ ๋ - Leftmost Derivation
โ ์ผ์ชฝ ๋
ผํฐ๋ฏธ๋๋ถํฐ ์ ๋(๋์ฒด)
Parse Tree
โ Subtree๋ ๋ฌธ์ฅ์ ํฌํจ๋ ์ถ์ํ์ ์ฌ๋ก
๋ฌธ๋ฒ์ ๋ชจํธ์ฑ
โ ๋ฌธ์ฅ์ Parse Tree ์ > 1 (์ด๋ค ์ ๋๋ ๊ฐ์)
์ปดํ์ผ๋ฌ๋ ๊ตฌ๋ฌธ ๊ตฌ์กฐ๋ก ์๋ฏธ๋ฅผ ํ์
ํ๊ธฐ ๋๋ฌธ์,
๋ฌธ์ฅ์ด ์ฌ๋ฌ ํ์ค ํธ๋ฆฌ๋ก ๊ตฌ์ถ๋๋ฉด ์๋ฏธ๋ฅผ ๊ฒฐ์ ๋ถ๊ฐ๋ฅ
- ํด๊ฒฐ์ฑ
- ํ์ ์ค๊ณ์๊ฐ ๋น๋ฌธ๋ฒ์ ์ฌ๋ฐ๋ฅธ ํ์ค ํธ๋ฆฌ๋ฅผ ๊ตฌ์ฑ
- ์ฌ์์ฑ
- ์ฐ์ฐ์ ์ฐ์ ์์ : ๋ฎ์ ๊ณณ์ ์์นํ ํญ๋ชฉ๋ค๋ก ๋จผ์ ๊ณ์ฐ
- ์ฐ์ฐ์ ๊ฒฐํฉ ๊ท์น :
- ๋์ผ ์ฐ์ ์์ ์ฐ์ฐ์๋ค ์ค ์ด๋ค ์ฐ์ฐ์๊ฐ ๋จผ์ ๊ณ์ฐ๋๋์ง
- i.e. A + B - C, ์ข๊ฒฐํฉ ์ฐ์ โ +
์ข๊ฒฐํฉ ๊ท์น
์ข์ํ์ ํํ์ ์ข๊ฒฐํฉ ๊ท์น์ ๊ธฐ์ ํ๋ค
LHS๊ฐ RHS ์์ ์์น์ ๋ํ๋๋ ๊ฒฝ์ฐ
์ค์ํ ๊ตฌ๋ฌธ๋ถ์ ์๊ณ ๋ฆฌ๋ฌ์ ํ์ฉํ์ง ์์ ์ข์ํ ์ ๊ฑฐํ๋์ง, ๋น๋ฌธ๋ฒ์ ์์๋ก ์ปดํ์ผ๋ฌ์์ ์ง์
์ฐ๊ฒฐํฉ ๊ท์น ์ฐ์ํ์ ํํ์ ์ฐ๊ฒฐํฉ ๊ท์น์ ๊ธฐ์ ํ๋ค
LHS๊ฐ RHS์ ์ค๋ฅธ์ชฝ ๋์ผ๋ก ๋ํ๋๋ ๊ฒฝ์ฐ
<factor>โ <exp> ** <factor> | <exp>
<exp> โ (<expr>) | id
- is then else๋ฅผ ์ํ ๋ชจํธํ์ง ์์ ๋ฌธ๋ฒ
- Dangling Else
i.e. Ada BNF ๊ท์น
<if_stmt> โ
if (<logic_expr>) <stmt> | if (<logic_expr>) <stmt> else <stmt>
โ <stmt> โ <if_stmt> ์ ๋ชจํธ์ฑ ๋ฐ์
if (<logic_expr>) if (<logic_expr>) <stmt> else <stmt>
So, ๋ง์ ์ธ์ด์์, else ๋ฌธ์ ์ด์ ์ ๋งค์นญ๋์ง ์์ ๊ฐ์ฅ ๊ฐ๊น์ด if/then์ ๋งค์นญ
โ ๋ฌธ๋ฒ์ผ๋ก๋ matched, unmatched๋ก ๋๋ ์ ์์ฑ
- ํ์ฅ BNF (EBNF)
- ์์ ๋ฅ๋ ฅ ๊ทธ๋๋ก,๊ฐ๋ ์ฑ๊ณผ ์์ฑ๋ ฅ โ
- ~๊ฐ ์๊ฒผ๋ค
ํ์ดํ ๋์ ์ ์ฝ๋ก ์ด ์ฌ์ฉ๋๊ณ , RHS๋ ๋ค์ ์ค์ ํํ ์์ง๋ฐ(|)๋ฅผ ์ฌ์ฉํ์ฌ ์ฌ๋ฌ ๊ฐ์ RHS๋ฅผย ๊ตฌ๋ณํ๋ ๋์ ์, ๊ฐ RHS๋ฅผ ๋จ์ํ ๋ณ๊ฐ์ ์ค๋ก ํํ ๋๊ดํธ๋ฅผ ์ด์ฉํ์ฌ ์ ํ ์ฌํญ์ ๋ํ๋ด๋ ๋์ ์ ์๋ซ์ฒจ์ย opt๊ฐ ์ฌ์ฉ ์๊ดํธ ์์ ํฌํจ๋ ์์๋ค์ ๋ฆฌ์คํธ์์ ์ ํ ์ฌํญ์ ํํํ๊ธฐ ์ํด | ๊ธฐํธ๋ฅผ ์ฌ์ฉํ๋ ๋์ ์ ๋จ์ด โone ofโ๊ฐ ์ฌ์ฉ
- ๋ฌธ๋ฒ๊ณผ ์ธ์๊ธฐ
- ๋ฌธ๋งฅ ์์ ๋ฌธ๋ฒ์ด ์ฃผ์ด์ง ๊ฒฝ์ฐ, ํด๋น ์ธ์ด๋ฅผ ์ธ์ํ๋ ์ธ์๊ธฐ ๊ตฌ์ถ ๊ฐ๋ฅ
- Yacc : ๊ตฌ๋ฌธ ๋ถ์ ์์ฑ๊ธฐ
- ๋ฌธ๋งฅ ์์ ๋ฌธ๋ฒ์ด ์ฃผ์ด์ง ๊ฒฝ์ฐ, ํด๋น ์ธ์ด๋ฅผ ์ธ์ํ๋ ์ธ์๊ธฐ ๊ตฌ์ถ ๊ฐ๋ฅ