Descripción del lenguaje red

Descripción del Lenguaje RED

Definición y Gramática del Lenguaje

rapsware

21/07/2010

Lenguaje de programación 2T, definición y gramática del lenguaje, ejemplos y toda la descripción del lenguaje. Lenguaje de programación básico especialmente desarrollado para personas principiantes en el mundo de la programación, además ofrece características necesarias para desarrollar, pequeñas rutinas de programación de nivel intermedio, y de bastante facilidad.

Lenguaje REDCaracterisiticas Del Lenguaje

Tabla de contenidoDescripción del Lenguaje...................................................................................................................3

Programas......................................................................................................................................3

Estructura básica de un programa.....................................................................................................3

Cabecera........................................................................................................................................3

Diccionario de palabras reservadas....................................................................................................4

Símbolos especiales...........................................................................................................................4

Tipos de Comentarios........................................................................................................................5

Los comentarios en el lenguaje RED, pueden ser puestos en cualquier parte del código, ya sea la final al inicio o en medio del código. Existen dos tipos de comentarios de una sola línea, utilizando las dos plecas (//) antes de escribir el comentario, y todo lo que se escriba después de estos es tomado como comentario, hasta que finalice la línea, cuando se escribe en otra línea ya no es tomado como comentario.................................................................................................................6

Tipos de datos fundamentales y su representación...........................................................................6

Operaciones de entrada y salida básica.............................................................................................7

Entrada...........................................................................................................................................7

Salida..............................................................................................................................................7

Declaración e inicialización de variables............................................................................................7

Para declarar variables utilizamos la siguiente sintaxis:.................................................................9

Nombres de Variables:...................................................................................................................9

Para inicializar las variables recién creadas:...................................................................................9

El bloque principal del programa.....................................................................................................10

Los primeros programas...................................................................................................................10

Tabla de operadores con asociatividad y precedencia.....................................................................10

Estructuras de decisión e iteración..................................................................................................11

Decisión........................................................................................................................................12

Uso del Si..................................................................................................................................12

Iteración.......................................................................................................................................12

Para..........................................................................................................................................12

Ciclo Mientras...........................................................................................................................13

Declaración, definición y uso de métodos y funciones.....................................................................13

Funciones:....................................................................................................................................13


Características especificas del lenguaje............................................................................................15

Definición de Arreglos..................................................................................................................15

Ejemplo de un programa en RED-2T................................................................................................16

Estructura de un Programa en RED..............................................................................................16

Ejemplo de un Programa en RED..................................................................................................17

Gramática del lenguaje....................................................................................................................18

Descripción del LenguajeRED es un lenguaje que permite programar en forma estructurada. Esto significa que es posible dividir al programa implementando funciones, y organizarlo de manera tal que se pueda leer con facilidad. Esto último tiene que ver con una indentación, comentarios, nombres mnemotécnicos, etc. Aunque estas últimas características NO son imprescindibles en un programa RED.

ProgramasRED define un tipo básico de archivo que se puede compilar. Los archivos de código fuente que se escriben con el editor (IDE) conviene que tengan la extensión (.red), al compilar estos programas tendremos archivos .exe

Estructura básica de un programa

CabeceraTodos los programas tienen la misma estructura. Para indicar al compilador que se trata de un programa tenemos que escribir la palabra PROGRAMA seguida de un espacio y un nombre (que puede tener letras y números) y que tiene que terminar en un punto y coma. Por ejemplo:

Programa ejemploNumero6;

Es importante indicar que el nombre que le damos al programa tiene que seguir unas reglas ya que sino en caso contrario no será válido por el compilador:


El primer carácter tiene que ser una letra y no una cifra ya que en caso contrario el compilador se pensaría que es un número. Por ejemplo, no es válido el nombre siguiente:

Programa 6ejemplo;

El único carácter no alfanumérico valido es el guion bajo. No se admiten caracteres como exclamaciones o signos de interrogación, etc.

Tampoco se admiten vocales acentuadas o letras que no pertenezcan al alfabeto ingles. Por ejemplo ÿ y la ῆ no se admiten.

Finalmente, el nombre del programa no tiene que coincidir con otras variables o constantes del programa.

Diccionario de palabras reservadasEsta es una lista de palabras reservadas y estas no pueden redefinirse o ser utilizadas como identificadores. Hay que tener en cuenta que no se pueden emplear las siguientes palabras para nombres de variables ya que son palabras reservadas para RED.

Nombre DescripciónEntero Tipo de dato, que representa los números enterosDecimal Tipo de dato, que representa los números decimalesCarácter Tipo de dato, que representa caracteresLogico Tipo de dato, que representa los datos lógicosVar Prefijo para declarar una variableFuncion Utilizado para declarar funciones en el programaLea Función con la cual obtenemos un valor de el usuarioEscriba Función con la cual escribimos en pantalla algoSi Estructura de decisiónSino Complemento de la estructura de decisiónPara Estructura de iteraciónMientras Estructura de iteración condicionadaRetorne Especifica lo que retorna una funciónPrograma Utilizada para declarar un programa en REDVerdadero Valor lógicoFin Delimita el fin de un programaFalso Valor lógicoInicio Indica el inicio de un programaVacio Tipo utilizado en las funciones donde no necesita que retorne nada

Todas las palabras reservadas dentro del lenguaje RED, pueden ser escritas sin importar si están en mayúsculas o en minúsculas o una combinación de estos, así como las variables, tomando en cuenta que una variable escrita en mayúsculas es la misma que escrita en minúsculas, así como las palabras reservadas.


Símbolos especialesLos símbolos especiales son caracteres no alfabéticos, o pares de estos caracteres, que tienen significados fijos. Los siguientes caracteres son símbolos especiales:

Símbolo Descripción/ Símbolo aritmético utilizado para representar la división* Símbolo aritmético utilizada para representar la multiplicación+ Símbolo aritmético utilizado para representar la suma- Símbolo aritmético utilizado para representar la resta% Símbolo utilizado para representar el MOD= Símbolo utilizado para representar la asignación, Símbolo utilizado para separar los parámetros de las funciones; Símbolo utilizado para representar el fin de línea dentro de un programa: Símbolo utilizado para definir los tipos de datos de las variables< Símbolo utilizado para representar el “menor que”> Símbolo utilizado para representar el “mayor que”

Los siguientes pares de caracteres también son símbolos:

Símbolo Descripción&& Representa el Y lógico|| Representa O lógico“ ” Utilizado para representar cadenas de texto‘ ’ Utilizado para poner caracteres[] Utilizado en los arreglos() Utilizado en la funciones {} Utilizado para definir los límites de funciones y ciclos// Utilizado para comentarios de una sola línea/* Utilizado para comentarios de varias líneas y finaliza con el símbolo */== Representa la igualdad!= Representa la desigualdad<= Representa “menor o igual que” >= Representa “mayor o igual que”


Tipos de ComentariosLos comentarios son ignorados por el compilador, excepto cuando su función es de separadores delimitando tokens adyacentes.

//Comentario de una línea

/*Comentario de varias Líneas*/

Los comentarios en el lenguaje RED, pueden ser puestos en cualquier parte del código, ya sea la final al inicio o en medio del código. Existen dos tipos de comentarios de una sola línea, utilizando las dos plecas (//) antes de escribir el comentario, y todo lo que se escriba después de estos es tomado como comentario, hasta que finalice la línea, cuando se escribe en otra línea ya no es tomado como comentario.

Los comentarios de varias líneas, empiezan con la combinación de símbolos /*, seguido de cualquier combinación de letras y números así como de símbolos, ya que el compilador los omite, estos acepta hasta saltos de línea, hasta que se cierre con la combinación de símbolos */

Tipos de datos fundamentales y su representaciónLos tipos de variables, llamados tipos de datos, se dividen en tres grandes grupos fundamentales:

Numéricos. Enteros o Decimales Alfanuméricos. Caracteres Lógicos. Solo pueden valer verdadero o falso

Nombre Rango DescripciónEntero Números enteros

comprendidosDecimal Representa números

decimalesCaracter [a-zA-Z][0-9] Representa caracteres

alfanumericosLogico Verdadero-Falso Representa valores lógicos

Nota: Existe un tipo especial llamado Vacio, este devuelve un valor indefinido, se utiliza en la funciones donde no necesitamos que devuelva nada, entonces en el tipo a retornar en las funciones se pone vacio.


Operaciones de entrada y salida básica

Entrada

Lea(<tipo>,<variable>);

/*donde variable es cualquier tipo de variable donde se almacena lo que el usuario introducey tipo es uno de los tipos definidos en el lenguaje*/

//Ejemplo

Var entero: num1;Lea(entero,num1);

/*en la variable num1 se almacena lo que el usuario ingrese siempre que sea del tipo definido en la misma función en este caso tendría que ser del tipo entero*/

Salida

Escriba(<Expresion>);

Escriba(“cadena”,<variable>,(3*5+2),función());

/*Donde expresión puede ser una combinación tanto de variables cadenas de texto como de constantes numéricas, las cuales cada una de estas deben estar separadas por comas Ejemplo:

*/

//Ejemplo

Var entero: numero=23;

Escriba(“hola mundo”,numero,(3+5),getedad());

//donde getedad() es una función que retorna un entero

Declaración e inicialización de variablesSi pensamos en muchas formulas matemáticas veremos que emplean variables en su expresión. Por ejemplo el área del triangulo es AT=b*h . Cuando queremos calcular el área de un triangulo dado nos limitamos a sustituir estas variables. En RED, y programación ocurre algo parecido.

RED exige que se declaren las variables que se utilizaran. Las variables pueden modificar su valor a lo largo del programa. Cada variable tiene que ser de un tipo determinado.


Para declarar variables emplearemos la palabra reservada VAR, seguida de un espacio y luego el tipo de dato de la variable seguida de dos puntos y espacio y después el nombre de la variable. Por ejemplo:

Var entero: base;Var entero: altura=10;Var carácter: Lnombre=”a”;

Lo que va después del signo igual recibe el nombre de literal. Un literal es un valor incluido directamente en el código. El primer caso es el numero entero 10, la variable altura vale 10. En el caso de Lnombre representa un carácter con el valor “a”.

La declaración de literales se rige por unas normas sencillas:

Los caracteres siempre empiezan y terminan con las comillas y solo tiene un carácter, en caso contrario el compilador enviara un error.

Los caracteres pueden aceptar más de un carácter en caso de que sea una combinación de tabulación “\t” o salto de línea “\n”, solo en este caso es aceptado más de un carácter.

Los números enteros se escriben de manera normal respetando el tamaño máximo y mínimo establecido.

Los números decimales deben ir acompañados del signo de punto y la cantidad de decimales y enteros que desee, respetando el tamaño máximo y mínimo establecido.

En RED, los nombres de constantes es indiferente de que estén en mayúsculas o minúsculas. Por tanto, en el ejemplo anterior altura, ALTURA, ALtuRa representan lo mismo para el compilador. Hay que ir con cuidado para no duplicar nombres. Por ejemplo, esto es incorrecto:

Var entero: maximo;Var entero: MAXIMO;


Ya que MAXIMO y máximo son lo mismo y se esta redeclarando una variable ya declarada. Esta independencia sintáctica a las mayúsculas está presente en todos los aspectos de RED.

La declaración anterior se podía haber simplificado de la siguiente forma:

Var entero: base, altura;Var caracter: Lnombre;

Podemos declarar dos o más variables del mismo tipo a la vez separándolas entre comas.

Para declarar variables utilizamos la siguiente sintaxis:

Var <tipo>: <nombre>;

Var <tipo>: <nombre1>,<nombre2>,…<nombreN>;

//ejemplo

Var carácter: a, cvar;

Var entero: numero1;

Var lógico: continuar, avance;

Var decimal: real;

Nombres de Variables: Los nombres de variables deben iniciar con una letra seguida de cualquier combinación de

números o letras. Los nombres de variables no deben ser los mismos que las palabras reservadas definidas

en el lenguaje.


Los nombres de variables no deben contener ningún de los símbolos especiales, definidos en el lenguaje, en cambio puede utilizar cualquier otro símbolo.

Para inicializar las variables recién creadas:

<nombreVariable>=<Valor>;

//ejemplo

Numero=34;

A=”b”;

Avance=verdadero;

Real=23.45;

El bloque principal del programaUna vez hemos declarado la etiqueta programa, y las declaraciones de variables solo falta el bloque principal de código del programa. El bloque donde se ejecutaran las ordenes.

Este bloque, a diferencia de los anteriores, no se puede dejar de poner en un programa RED. El bloque principal del programa se define entre las palabras INICIO y FIN. Por ejemplo estas dos líneas ya son un programa valido para el compilador aunque no haga nada:

Iniciofin

Es entre estas dos palabras que incluiremos nuestro código. Todas las órdenes que se incluyen en este bloque reciben el nombre de sentencias.

Los primeros programasVamos a hacer un programa que calcule el área de un triangulo dadas las bases y la altura. El código podría ser el siguiente:


Var entero: base, altura;Var caracter: Lnombre;

Tabla de operadores con asociatividad y precedenciaOperador Asociatividad+ Por la izquierda- Por la izquierda* Por la izquierda/ Por la izquierda% Por la izquierda

Orden de precedencia

Operadores

1 Las operaciones entre paréntesis2 Raíces o potencias3 Multiplicaciones o divisiones4 Sumas o restas5 Si hay dos o más operadores del mismo orden entonces se usa la asociatividad

por la izquierda

Estructuras de decisión e iteraciónAntes de iniciar con las estructuras de decisión e iteración, se deben conocer los operadores de las condiciones que son la base de las siguientes estructuras a ver.

Operador Significado< Menor que> Mayor que<= Menor o igual que>= Mayor o igual que== Igual!= Distinto de


Hay que tener claro que la diferencia entre “=” y”==” es, que el primero compara dos variables y el segundo es una asignación de valores.

A continuación se presenta una tabla con los operadores para cuando hay más de una condición a evaluar.

Operador Significado&& “Y” lógico|| “O” lógico

Decisión

Uso del Si

Si(condicion){Bloque de instrucciones

}Sino{Bloque de instrucciones

}/*donde bloque de instrucciones puede ser un conjunto de ciclos u operaciones y llmados a función etc., además de tener otros ciclos Si*/

//ejemplo

Si(numero < 15 || numero==0){Escriba();

}sino{Si(numero>30 && numero < 45){

Escriba();}sino{

Escriba();}

}


Iteración

Para

Para(<Variable>=<valor inicial> ; <restricción de limite>; <expresión de incremento>){Bloque de instrucciones;

}//el bloque de instrucciones puede contener lo mismo que el bloque de instrucciones que el ciclo Si*/

//ejemplo

Para(i=0;i < 10; i=i+1){Escriba();

}

Ciclo Mientras

Mientras(<Condicion>){Bloque de instrucciones;

}//el bloque de instrucciones puede contener lo mismo que el bloque de instrucciones que el ciclo Si*/

//ejemplo

Mientras(numero !=0){Escriba();

}

Dependiendo de la condición, la instrucción puede variar pero esta instrucción es vital para evitar ciclos infinitos.

Declaración, definición y uso de métodos y funcionesRED por supuesto tiene lo que es el uso de procedimientos y funciones, ahora definiremos por separado cada uno de estos módulos.


Funciones:Una función es un modulo de un programa separado del cuerpo principal, que realiza una tarea específica y que puede regresar un valor o no, a la parte principal del programa u otra función o procedimiento que la invoque.

Declaración y Definición de las Funciones

//Declaración de FunciónFuncion <Tipo> <NombreFuncion>(parámetros);

//Definición de FunciónFuncion <Tipo> <nombre funcion>(parámetros){

Declaracion de variables localesBloque de instrucciones;Retorne <Valor>;

}/* en el caso especial donde no se deba regresar ningún valor donde dice tipo se pone la palabra reservada Vacio, y no se necesita poner Retorne dentro de la función.La declaración de variables se debe de hacer antes de que se inicie el bloque de instrucciones, de lo contrario tirara un error, y estas variables son validas únicamente en la funcion*/

//ejemplo

Función entero getEdad(entero,entero);

Función entero getedad(entero: num1, entero: num2){

Retorne valor;}

Este esquema de la definición y declaración se hace en la sección de Var del programa principal, donde parámetros está definido de la siguiente forma:


(<tipo>:<nombre_var>,<tipo>:<nombrevar2>,…)

//ejemplo

Entero: num1, entero: num2

Uso

Simplemente en el programa principal se hace llamado a función.

//llamado a una función desde el programa principal o desde otra función[<variable>]=<nombrefuncion>(parametros);/*En el caso de retornar algo poner la variable en la que se guardara el valor de retorno de lo contrario solo se llama a la función*/

//ejemplo

Vcadena=getedad(num1,num2);

Características especificas del lenguaje

Definición de ArreglosPara declarar un arreglo se usa el siguiente formato:

Var <Tipo>:<nombre arreglo>[expresion];

/*donde expresion puede ser una constante una combinación de operaciones matematicas o una variable con valores enteros

//ejemplo

Var entero: arreglo[5];

Para asignar un valor a un arreglo es de la siguiente forma:


<nombre arreglo>[constante]=<Valor>;

//donde constante es el índice del arreglo, alque se desean introducir datos, el índice en los arreglos empieza desde 0 hasta el numero antes del que se definió al declarar el arreglo

//ejemplo

Arreglo[i]=23;

Donde constante es una numero entero el cual define la posición del arreglo.

Ejemplo de un programa en RED-2T

Estructura de un Programa en RED

<Nombre de programa>*

<Declaración e inicialización de variables>

<Declaración, definición y uso de métodos y funciones>

<Definición del programa principal>**

<Definición de funciones>

<Definición de procedimientos>

*: El nombre del programa y como inicia todo programa en RED, inicia con la palabra reservada PROGRAMA, y seguido de el nombre para el programa utilizando las mismas reglas que los nombres de variable, luego se finaliza la línea con “;” que indica el fin de la línea.

**: La definición del programa principal es donde inicializamos y utilizamos las variables, constantes funciones y procedimientos, así como de todos los ciclos y demás componentes del lenguaje RED. Este debe de ir siempre en cualquier programa en RED, siempre empieza con la palabra reservada INICIO, y finaliza con la palabra FIN, dentro de estas instrucciones definimos nuestro programa principal.


Ejemplo de un Programa en RED

Programa ejemplo;Var Entero ventero,i;Var Entero arreglo[2];Var Carácter vcaracter;Var Decimal vreal;Funcion Entero Suma(Entero,Entero);Procedimiento Imprime(Entero);Inicio

Para(i=0 Hasta 2){Escriba(“Escriba un numero: ”);Lea(ventero1);arreglo[i]=ventero1;

}Imprime(Suma(arreglo[1],arreglo[2]));Ventero1=arreglo[1];ventero2=arreglo[2];Si(ventero1 > ventero2){

Escriba(“el mayor es: ”,ventero1);}Sino{

Escriba(“El mayor es: ”,ventero2);}

FinFuncion Entero Suma(Entero: num1,Entero: num2){

Retorne num1+num2;}Procedimiento Imprime(Entero: num){

Escriba(num);}


Gramática del lenguaje

1 Gramatica → DeclaracionesDefiniciones

2 Declaraciones → CabeceraCuerpo

3 Cabecera → PROGRAMA ID;4 Cuerpo → DeclaracionVariables

DeclaracionFunciones5 DeclaracionVariables → LineaVar DeclaracionVariables6 LineaVar → VAR Tipo: LVar7 LVar → Lid LVar28 LVar2 → ,LVar | ;9 LId → ID L2Id10

L2Id → = ValorT | [Expresion] | λ

11

ValorT → Expresion | VLogico | VCaracter

12

DeclaracionFunciones → FUNCION vRetorno ID( LParam );

13

vRetorno → Tipo | VACIO

14

cRetorno → RETORNE ValorT ; | λ

15

LParam → L2Param LParam | λ

16

L2Param → Tipo L3Param

17

L3Param → , | λ

18

LParametros → L2Parametros LParametros | λ

19

L2Parametros → Tipo : ID L3Parametros

20

L3Parametros → , | λ

21

Definiciones → PPrincipalDefinicionFunciones

22

PPrincipal → INICIODeclaracionVariablesBloqueInstruccionesFIN

23

DefinicionFunciones → FUNCION vRetorno ID( Lparametros ){


DeclaracionVariablesBloqueInstruccionescRetorno }

24

BloqueInstrucciones → LBloque BloqueInstrucciones | λ

25

LBloque → Asignacion | Lectura | Escritura | Decisión | Iteracion | BloCod | LlamFunc

26

Asignacion → ID TVar DAsignacion ;

27

TVar → = | [ Expresion ]=

28

DAsignacion → ValorT | LlamFunc ;

29

LlamFunc → ID( LisPram )

30

LisParam → ID Lis2Param

31

Lis2Param → ,LisParam | λ

32

Lectura → LEA( Tipo, ID);

33

Escritura → ESCRIBA( LisEsc );

34

LisEsc → Lis Lis2Esc

35

Lis2Esc → ,LisEsc | λ

36

Lis → ValorT | LlamFunc | Cadena

37

BloCod → BLOQUE{DeclaracionVariablesBloqueInstrucciones}

38

Iteracion → CicloMientras | CicloPara

39

CicloMientras → MIENTRAS( Condicion ){BloqueInstrucciones}

40

CicloPara → PARA(ID=Expresion ; ID OperC Expresion ; Asignacion){BloqueInstrucciones}

4 Decisión → IR | IA | BloqueInstrucciones


142

IR → SI( Condicion ){IR}SINO{IR}| λ

43

IA → SI( Condicion ){Decisión} | SI( Condicion ){IR}SINO{IA}

44

Condicion →

45

Tipo → ENTERO | DECIMAL | CARÁCTER | LOGICO

46

OperC →

47

Expresion → Terminal ExpresionP

48

ExpresionP → +Terminal ExpresionP | -Terminal ExpresionP | λ

49

Terminal → Factor TerminalP

50

TerminalP → *Factor TerminalP | /Factor TerminalP | λ

51

Factor → ( Expresion ) | Num | ID

52

VLogico →

53

VCaracter →

54

Num →

Technology

Descripción del lenguaje red