GRAMÁTICA “RESTRINGIDA” DE C++

Notación BNF

<programa> ::= [ <directivas> ]

[ <constantes> ]
[ <tipos> ]
[ <constantes> ]
[ <subalgoritmos> ]
<principal>
<directivas> ::= { <inclusion> } { <utilizacion> }
<inclusion> ::= #include ’<’ biblioteca standard ’>’
| #include " biblioteca usuario "
<utilizacion> ::= using namespace <ident> ;
<constantes> ::= { const <tipo> <ident> = <exprcte > ; }
<tipos> ::= { <def tipo> }
<subalgoritmos> ::= { <dcl func> | <dcl proc> }
<variables> ::= { <tipo> <ident> { , <ident> } ; }
<dcl func> ::= <tipo> <ident> ’(’ [ <args> ] ’)’ <cuerpo func>
<dcl proc> ::= void <ident> ’(’ [ <args> ] ’)’ <cuerpo>
<args> ::= <argm> { , <argm> }
<argm> ::= [ const ] <tipo> [ & ] <ident>
<principal> ::= int main ’(’ [ <args> ] ’)’ <cuerpo func>
<def tipo> ::= <enumerado> | <puntero> | <registro> | <array > | <tipo ident>
<enumerado> ::= enum <ident> ’{’ <ident> { , <ident> } ’}’ ;
<puntero> ::= typedef ( struct <ident> | <tipo> ) * <ident> ;
<registro> ::= struct <ident> ’{’ { <tipo> <ident> { , <ident> } ; } ’}’ ;
<array > ::= typedef <tipo> <ident> ’[’ <exprord cte
> ’]’ ;
<tipo ident> ::= typedef <tipo> <ident> ;
<tipo> ::= <tipos predef > | <ident>
<tipos predef > ::= bool | char | unsigned | int | float | double | string

1
 <cuerpo> ::= ’{’
[ <variables> ]
<sentencias>
’}’
<cuerpo func> ::= ’{’
[ <variables> ]
<sentencias>
return <expr > ;
’}’
<sentencias> ::= { <asignacion> | <incr decr > | <seleccion> | <iteracion> | <llamada proc> | <ent sal> }
<asignacion> ::= <cual ident> = <expr > ;
<incr decr > ::= ++ <cual ident> ;
| -- <cual ident> ;
| <cual ident> ( += | -= | *= | /= | %= ) <expr > ;
<seleccion> ::= <si> | <caso>
<iteracion> ::= <para> | <mientras> | <repetir >
<llamada proc> ::= <ident> ’(’ [ <expr > { , <expr > } ] ’)’ ;
<ent sal> ::= <leer > | <escribir >
<leer > ::= cin { ’>>’ <cual ident> } ;
<escribir > ::= cout { ’<<’ <expr > } ;
<si> ::= if ’(’ <exprbool > ’)’ ’{’
<sentencias>
{ ’}’ else if ’(’ <exprbool > ’)’ ’{’
<sentencias> }
[ ’}’ else ’{’
<sentencias> ]
’}’
<caso> ::= switch ’(’ <exprord > ’)’ ’{’
{ case <exprord cte
> : { case <exprord cte
>: }
<sentencias>
break ; }
[ default :
<sentencias>
break ; ]
’}’
<para> ::= for ’(’ [ <tipo> ] <asignacion> ; <exprbool > ; <incr decr > ’)’ ’{’
<sentencias>
’}’
<mientras> ::= while ’(’ <exprbool > ’)’ ’{’
<sentencias>
’}’
<repetir > ::= do ’{’
<sentencias>
’}’ while ’(’ <exprbool > ’)’ ;

2
 <expr > ::= <expr and> { ’||’ <expr and> }
<expr and> ::= <expr rel> { && <expr rel> }
<expr rel> ::= <expr arit> [ ( > | >= | < | <= | = | ! = ) <expr arit> ]
<expr arit> ::= <termino> { ( + | - ) <termino> }
<termino> ::= <factor > { ( * | / | % ) <factor > }
<factor > ::= ’(’ <expr > ’)’ | ( - | ! )<factor > | <llamada func> | <conv tipo>
| <cual ident> | <numero> | <caracter cte> | <cadena cte> | true | false
<cual ident> ::= [ * ] <ident> { ’[’ <cual ident> ’]’ | .<ident> | ’− >’<ident> }
<llamada func> ::= <ident> ’(’ [ <expr > { , <expr > } ] ’)’
<conv tipo> ::= <tipo> ’(’ <expr > ’)’

<ident> ::= <letra> { <letra> | <digito> | }

<numero> ::= <natural> | <real>
<natural> ::= <digito> { <digito> }
<real> ::= <natural> ( <escala> | .<natural> [ <escala> ] )
<escala> ::= E [ - ] <natural>
<digito> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<letra> ::= <minusculas> | <mayusculas>
<minusculas> ::= a | b | c | d | e | f | g | h | i | j | k | l | m | n | o | p | q | r | s | t | u | v | w | x | y | z
<mayusculas> ::= A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z
<caracter cte> ::= ’<caracter >’
<cadena cte> ::= "{ <caracter > }"
<comentario> ::= // hasta fin de linea

Restricciones semánticas:

• <exprcte > una expresión evaluable en tiempo de compilación.

• <exprord cte
> una expresión evaluable en tiempo de compilación de tipo ordinal.

• <exprbool > una expresión de tipo booleano.

• <exprord > una expresión de tipo ordinal.

• Los operadores !, ’||’, && se aplican a expresiones de tipo booleano.

• El operador / se aplica a expresiones de tipo entero, natural o real y

produce un resultado del mismo tipo que los operandos.

• El operador % se aplica a expresiones de tipo entero o natural.

• Los operadores binarios +, - y * se aplican a expresiones de tipo entero, natural o real.

• El operador ’[]’ se aplica a identificadores de tipo array o string.

• El operador unario prefijo * se aplica a identificadores de tipo puntero.

• El operador ’− >’ se aplica a identificadores de tipo puntero a registro.

• El operador . se aplica a identificadores de tipo registro.