Elementos Basicos de la Programacion Imperativa

Notación BNF

• Metasímbolo de definición. ::=. Indica que el elemento a su izquierda puede desarrollarse según el esquema de la derecha.
• Metasímbolo de alternativa. | . Indica que puede elegirse uno y solo uno de los elementos separados por este metasímbolo
• Metasímbolo de repetición. {}. Indican que los elementos incluidos dentro de ellos se pueden repetir cero o mas veces.
• Metasímbolo de opción []. Indica que los elementos incluidos dentro de ellos pueden ser utilizados o no.
• Metasímbolo de agrupación (). Agrupan los elementos incluidos en su interior.

Elemento_no_terminal: Este estilo se emplea para escribir el nombre de un elemento gramatical que habrá de ser definido por algún regla. Cualquier elemento a la izquierda del metasímbolo ::= será no terminal y aparecerá con este estilo.

Elemento_terminal: Este estilo se emplea para representar los elementos que forman parte del lenguaje Modula-2, es decir, que constituyen el texto de un programa. Si aparecen en una regla deberán escribirse exactamente como se indica.

Valores y tipos:

• Valores numéricos enteros:
  • valor_entero ::= [+ | - ] secuencia_de_dígitos
  • secuencia_de_dígitos ::= dígito {dígito}
  • dígito ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
• Valores numéricos reales:
  • valor_real ::= valor_entero.[secuencia_dígitos][escala]
  • escala::= E valor _entero
• Caracteres:
  • Identificador ::= letras {letra | dígito}
  • letra::= {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}
  • dígito::= {1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 0}

  Tipos predefinidos:

  • INTEGER
    • Los valores de este tipo son los valores numéricos enteros positivos y negativos.
    • Coincide con el concepto matemático de números enteros.
    • El rango depende del computador concreto utilizado, SIEMPRE simétrico entorno al cero.
    • Dentro de dicho rango la representación es exacta
    • Los rangos son:
      • 2^15 = 32768
      • 2^31 = 2147483648
      • Valor mínimo; MIN (INTEGER)
      • Valor máximo; MAX (INTEGER)
    • Operadores:
      • Suma de enteros A + B
      • Resta de enteros A - B
      • Multiplicación de enteros A {*} B
      • División de enteros A DIV B
      • Resto de entero A MOD B
      • Identidad de un entero + A
      • Cambio de signo de un entero - A
    • La division se realiza entre 2 numeros enteros y obtiene el cociente entero truncado al valor mas proximo a cero
    • MOD puede estar SOLO definido para divisores positivos.
    • El resultado es el resto de la division de enteros realizadas con DIV
  • CARDINAL
    • Representa valores numéricos enteros no negativos
    • No es muy utilizada por los lenguajes de programación. Modula-2 permite el doble de valores positivos
    • Forma general del rango es: 0, MAX (CARDINAL)
    • Emplea los mismos operadores que para los enteros
    • Las operaciones entre cardinales SOLO se da entre cardinales.
    • Si queremos realizar operaciones combinadas es necesario que previamente se realice una conversión de la representación delos datos al tipo adecuado.
    • En algunas versiones de Modula-2, FLOAT y TRUNC solo realzan las conversiones entre valores de los tipos REAL y CARDINAL, en lugar de REAL e INTEGER.
      • FLOAT (45) Representa el valor real 45.0
      • TRUNC (34.7) Representa el valor entero 34
  • REAL:
    • Representa los valores numéricos reales positivos y negativos.
    • Esta representación puede no ser exacta, así que solo se puede considerar valido dentro de un rango.
    • El rango como la precisión depende del computador concreto utilizado, aunque nunca será posible una representación de valores irracionales (e, pi) o cuya precisión sea superior a la disponible en el computador que utilizamos.
    • Operaciones:
      • Suma de reales A + B
      • Resta de reales A - B
      • Multiplicación de reales A * B
      • División de reales A / B
      • Identidad de reales + A
      • Cambio de signo de reales - A
    • Las operaciones entre reales dan como resultado un real con la precisión del computador
  • CHAR:
    • Este tipo incluye como valores todos los caracteres disponibles en un computador.
    • La tabla de caracteres ASCII incluye caracteres alfabéticos, numéricos, de puntuación y puede incluir también caracteres de control (salto de línea).
    • Para representar estos caracteres se utiliza la notación CHR (x) siendo x el código del carácter equivalente a su posición dentro de la tabla de todos los caracteres.
      • CHR (10); Representa el salto de línea. Posición 10 de la tabla
      • CHR (13); Representa el retorno de carro. Posición 13 de la tabla
    • En sentido inverso, la posición que ocupa un determinado carácter c dentro de la tabla se expresa como ORD(c).
      • ORD (A); Vale 65 (65 posición de la taba ASCII)
      • ORD (Z); Vale 90 (90 posición de la tabla ASCII)
    • De forma inmediata podemos decir:
      • CHR (ORD (c) ) = c
      • ORD (CHR (x) ) = x
    • La mayoría de las tablas de códigos de carácteres poseen las siguientes características:
      • Los caracteres correspondientes a las letras mayúsculas de la A a la Z están ordenados en posiciones consecutivas y crecientes según el orden alfabético
      • Los caracteres correspondientes a las letras minúsculas de la a a la z están ordenados en posiciones consecutivas y crecientes según el orden alfabético
      • Los caracteres correspondientes a los dígitos del 0 al 9 están ordenados en posiciones consecutivas y crecientes.
      • Esto facilita el obtener por calculo el valor numérico equivalente al carácter de un dígito decimal, o la letra mayúscula correspondiente a una minúscula o viceversa.

  Operaciones de escritura simple:
  En todas las versiones de Modula-2 deben estar disponibles ciertos módulos estándar, con la definición de operaciones de escritura normalizadas. En este apartado describiremos operaciones disponibles en los módulos llamados InOut y RealInOut.

  • WriteInt;
    • Pertenece al módulo InOut.
    • WriteInt (valor_entero, espacios_reservados);
    • Escribe un valor entero
  • WriteCard;
    • Pertenece al módulo InOut.
    • WriteCard (valor_cardinal, espacios_reservados);
    • Escribe un valor cardinal
  • WriteReal;
    • Pertenece al módulo RealInOut.
    • WriteReal (valor_real, espacios_reservados);
    • Escribe un valor real
  • Write;
    • Pertenece al módulo InOut
    • Escribe un carácter
    • Write ( carácter );
  • WriteString;
    • Pertenece al módulo InOut
    • Escribe una ristra
    • WriteString (Ristra);
  • WriteLn;
    • Pertenece al módulo InOut
    • Provoca un salto de línea
    • WriteLn;

  Estructura de un programa completo:
  
MODULE EscribirHola;
(* Este programa escribe Hola*)

  FROM InOut IMPORT WriteString, WriteLn;
  BEGIN

  WriteString ('Hola');

  WriteLn;
END EscribirHola.


  El texto del programa comienza con una cabecera en la que después de la palabra MODULE, se pone el nombre que le damos al módulo de programa.

  A continuación se declara la lista de elementos importados de otros módulos. Esta lista de importados puede estar vacía si no se necesita ninguna colaboración de otros módulos.

  En la lista de importados se indica desde que modulo se importan los elementos y la lista de elementos que se quieren importar, usando las palabras inglesas, FROM e IMPORT.

  La parte final del programa contiene las sentencias ejecutables correspondiente a las acciones a realizar, escritas entre las palabras inglesas BEGIN y END.

  Las diferentes partes del programa se separan una de otra mediante (. Al final del texto del programa se repite el nombre del módulo como comprobación y se acaba con un (.)

  Descripción formal de la estructura de un programa:

  • Módulo_programa ::= Cabecera_programa Bloque Nombre_programa
  • Cabecera_programa ::= MODULE Nombre_programa; {Lista_importados;}
  • Lista_importados ::= FROM Nombre_módulo IMPORT Lista_elementos}}
  • Lista_elementos ::= Nombre_elemento {, Nombre_elemento}

  La estructura de un bloque solamente puede indicarse de momento en forma simplificada, ya que solo se han visto los elementos mínimos necesarios para escribir un programa.

  • Bloque ::= Parte_ejecutiva END
  • Parte_ejecutiva ::= BEGIN Secuencia_de_sentencias
  • Secuencia_de_sentencias ::= Sentencia {; Sentencia}
  • Uso Comentarios:
    • Cabeceras de programas
      **********************************
      * Aquí metes lo que te de la gana
      * como cabecera del programa
      **********************************

    • Cabeceras de sección
      (*===========================
      Comentario de Sección
      ============================*)

    • Comentarios-orden
      (*-- Aquí cuentas lo que esta haciendo la orden siguiente --*)

    • Comentarios al margen
      (* A la izquierda tienes el código que estas utilizando y esto a la dcha*)

  Descripción formal de la estructura de un programa

  • Bloque ::= Parte_declarativa Parte_ejecutiva END
  • Parte_declarativa ::= {Declaración}
  • Declaración ::= Declaración_de_constantes | Declaración_de_variables
  • Parte_ejecutiva ::= BEGIN Secuencia_de_sentencias
  • Secuencia_de_sentencias ::= Sentencia {Sentencias;}