Versión preliminar de informe de TDL.

diff --git a/ejemplos/align.d b/ejemplos/align.d
new file mode 100644 (file)
index 0000000..6a3447f
--- /dev/null
+++ b/ejemplos/align.d
@@ -0,0 +1,27 @@
+
+align (1) byte a, b, c, d;
+align (4) byte e, f, g, h;
+
+struct S
+{
+       byte a;
+       byte[3] b;
+       byte[3] c;
+       byte d;
+}
+
+align (1)
+struct SA
+{
+       byte a;
+       byte[3] b;
+       byte[3] c;
+       byte d;
+}
+
+S s;
+SA sa;
+bit z;
+
+void main() {s.a=1;}
+

diff --git a/ejemplos/cadena_estatica.d b/ejemplos/cadena_estatica.d
new file mode 100644 (file)
index 0000000..99cb767
--- /dev/null
+++ b/ejemplos/cadena_estatica.d
@@ -0,0 +1,20 @@
+
+int main(char[][] args)
+{
+       int i = 0;
+       void f()
+       {
+               printf("f(): %d\n", i);
+       }
+       void g()
+       {
+               int i = 1;
+               f();
+               printf("g(): %d\n", i);
+       }
+       f();
+       i = 2;
+       g();
+       return 0;
+}
+

diff --git a/ejemplos/enum.d b/ejemplos/enum.d
new file mode 100644 (file)
index 0000000..db8a6dd
--- /dev/null
+++ b/ejemplos/enum.d
@@ -0,0 +1,9 @@
+
+enum Dias { DOMINGO, LUNES, MARTES, MIERCOLES, JUEVES, VIERNES, SABADO }
+
+void main()
+{
+       Dias d = Dias.MARTES;
+       printf("%d\n", cast(int)(d));
+}
+

diff --git a/ejemplos/imaginario.d b/ejemplos/imaginario.d
new file mode 100644 (file)
index 0000000..cb33390
--- /dev/null
+++ b/ejemplos/imaginario.d
@@ -0,0 +1,8 @@
+
+void main()
+{
+       ifloat i = 1.0i;
+       cfloat z = 3.0 + 1.2i;
+       printf("i = %i, z = %c\n", i, z);
+}
+

diff --git a/ejemplos/struct.d b/ejemplos/struct.d
new file mode 100644 (file)
index 0000000..bbf0c38
--- /dev/null
+++ b/ejemplos/struct.d
@@ -0,0 +1,20 @@
+
+struct Fecha
+{
+       uint dia = 1;
+       uint mes = 1;
+       uint anio = 2005;
+       void print()
+       {
+               printf("dia: %d, mes: %d, anio: %d\n", dia, mes, anio);
+       }
+}
+
+void main()
+{
+       Fecha f;
+       f.dia = 30;
+       f.mes = 5;
+       f.print();
+}
+

diff --git a/presentacion_d.lyx b/presentacion_d.lyx
new file mode 100644 (file)
index 0000000..e59d805
--- /dev/null
+++ b/presentacion_d.lyx
@@ -0,0 +1,516 @@
+#LyX 1.3 created this file. For more info see http://www.lyx.org/
+\lyxformat 221
+\textclass article
+\language spanish
+\inputencoding latin1
+\fontscheme palatino
+\graphics default
+\paperfontsize default
+\spacing single 
+\papersize a4paper
+\paperpackage widemarginsa4
+\use_geometry 0
+\use_amsmath 0
+\use_natbib 0
+\use_numerical_citations 0
+\paperorientation portrait
+\secnumdepth 3
+\tocdepth 3
+\paragraph_separation indent
+\defskip medskip
+\quotes_language english
+\quotes_times 2
+\papercolumns 1
+\papersides 1
+\paperpagestyle default
+
+\layout Title
+
+Teoría de Lenguaje
+\newline 
+Lenguaje D
+\layout Author
+
+Leandro Lucarella (77891)
+\layout Date
+
+30 de Mayo de 2005
+\layout Section
+
+Introducción
+\layout Standard
+
+El lenguaje de programación D fue concebido en el año 1999 como una reingeniería
+ de C y C++, que apunta a un lenguaje compilado de alto rendimiento pero
+ con un nivel un poco más alto que C o C++.
+ D pretende ser compatible con C (al menos a nivel de código objeto), pero
+ 
+\series bold 
+no
+\series default 
+ con C++.
+\layout Standard
+
+Una de las cosas más importantes que elimina D es el preprocesador de C,
+ poniendo la funcionalidad necesaria directamente en el compilador (incluyendo
+ manejo de módulos, compilación condicional, etc.).
+\layout Standard
+
+El lenguaje sigue, al día de hoy, sin estar completamente definido y con
+ algunas cosas sin implementar.
+\layout Section
+
+Sistema de tipos
+\layout Subsection
+
+Tipos básicos
+\layout Standard
+
+D tiene una gran variedad de tipos básicos, ya que, además de poseer todos
+ los tipos básicos para poder desarrollar a bajo nivel como en C, dispone
+ de números complejos y otros tipos no tan comunes.
+\layout Standard
+
+Entre los tipos compatibles con C se encuentra:
+\layout Description
+
+Vacío 
+\family typewriter 
+void
+\layout Description
+
+Signados 
+\family typewriter 
+char wchar byte short int long
+\layout Description
+
+No\SpecialChar ~
+signados 
+\family typewriter 
+char wchar ubyte ushort uint ulong
+\layout Description
+
+Punto\SpecialChar ~
+flotante 
+\family typewriter 
+float double
+\layout Standard
+
+
+\family typewriter 
+char
+\family default 
+ y 
+\family typewriter 
+wchar
+\family default 
+ no tienen su contraparte signada, ya que son para uso explícito de variables
+ de caracter (UTF-8 y UTF-16 respectivamente).
+ Además agrega algunos nuevos tipos: 
+\family typewriter 
+bit
+\family default 
+ (análogo a 
+\family typewriter 
+bool
+\family default 
+ de C++), 
+\family typewriter 
+cent
+\family default 
+ y 
+\family typewriter 
+ucent
+\family default 
+ (128 bits, reservado para uso futuro); 
+\family typewriter 
+real
+\family default 
+ (tipo de punto flotante más grande representable por la arquitectura, en
+ Intel es de 80 bits) y 
+\family typewriter 
+dchar
+\family default 
+ (UTF-32).
+\layout Standard
+
+Finalmente agrega el tipo básico imaginario, cuyos tipos son iguales que
+ los 
+\emph on 
+racionales
+\emph default 
+ (de punto flotante) pero anteponiendo una 
+\family typewriter 
+i
+\family default 
+: 
+\family typewriter 
+ifloat idouble ireal
+\family default 
+.
+ Combinando 
+\emph on 
+racionales
+\emph default 
+ con imaginarios se pueden forma complejos, cuyos variaciones son de la
+ misma forma, sólo que se antepone una 
+\family typewriter 
+c
+\family default 
+ en vez de una 
+\family typewriter 
+i
+\family default 
+:
+\family typewriter 
+ cfloat cdouble creal
+\family default 
+.
+\layout Subsection
+
+Tipos derivados
+\layout Standard
+
+De los tipos básicos pueden derivarse otros tipos.
+ Esto tipos son punteros, array y funciones, siendo estas últimas tal vez
+ un caso muy particular.
+ Los array tal vez podrían considerarse tipos compuestos, pero como la variable
+ en sí es un puntero, en realidad no lo es.
+ Es decir, para obtener un elemento del array hay que aplicar aritmética
+ de punteros, ya sea 
+\emph on 
+explícitamente
+\emph default 
+ o 
+\emph on 
+implícitamente
+\emph default 
+ utilizando el operador corchetes.
+\layout Subsection
+
+Tipos de usuario
+\layout Standard
+
+D dispone de varias formas de definir tipos de usuario, entre ellos varios
+ que provienen de C.
+ Veamos cada uno.
+\layout Subsubsection
+
+alias
+\layout Standard
+
+Un alias es la forma más primitiva de tipo de usuario, simplemente es otra
+ forma de escribir un tipo ya definido (es análogo al typedef de C).
+ Ejemplo:
+\layout LyX-Code
+
+alias int tipo;
+\layout LyX-Code
+
+int i = 1;
+\layout LyX-Code
+
+tipo t = i; // Correcto (semánticamente son los dos int)
+\layout Standard
+
+A partir de ahora puedo hacer referencia a 
+\family typewriter 
+int
+\family default 
+ llamándolo 
+\family typewriter 
+tipo
+\family default 
+.
+ Es decir, son semánticamente idénticos.
+\layout Subsubsection
+
+typedef
+\layout Standard
+
+typedef es similar al alias, con la salvedad de que define un tipo semánticament
+e distinto (por más que la estructura en memoria y la forma de manejarlo
+ sea idéntica).
+ Como concecuencia de esto, se efectua chequeo de tipos y, por ejemplo,
+ no puedo asignar a una variable de un tipo que es un typedef de otro:
+\layout LyX-Code
+
+typedef int tipo;
+\layout LyX-Code
+
+int i = 1;
+\layout LyX-Code
+
+// No compila porque se está asignando un int a un tipo
+\layout LyX-Code
+
+// tipo t = i;
+\layout LyX-Code
+
+tipo t = cast(tipo)(i); // Correcto (conversión explícita)
+\layout Subsubsection
+
+enum
+\layout Standard
+
+Enum es en realidad un 
+\family typewriter 
+int
+\family default 
+ que puede tener sólo un número predefinido de valores, que además son represent
+ados simbólicamente.
+\layout LyX-Code
+
+enum Dias { DOMINGO, LUNES, MARTES, MIERCOLES, JUEVES, VIERNES, SABADO }
+\layout LyX-Code
+
+Dias d = Dias.MARTES;
+\layout Subsubsection
+
+union
+\layout Standard
+
+Union es otro tipo de dato definido por el usuario proveniente de C, que
+ permite ver una misma 
+\emph on 
+celda
+\emph default 
+ de memoria de distintas formas.
+\layout LyX-Code
+
+union Celda
+\layout LyX-Code
+
+{
+\layout LyX-Code
+
+    int i;
+\layout LyX-Code
+
+    real r;
+\layout LyX-Code
+
+}
+\layout LyX-Code
+
+Celda c;
+\layout LyX-Code
+
+c.i = 1;
+\layout LyX-Code
+
+c.r += 2.5;
+\layout Standard
+
+Tanto 
+\family typewriter 
+r
+\family default 
+ como 
+\family typewriter 
+i
+\family default 
+ se guarda en la misma celda de memoria, por lo que se utilizan como mecanismos
+ alternativos para operar en ella, usando semántica de uno u otro tipo.
+ Esto es particularmente útil para aplicaciones de bajo nivel, donde el
+ espacio en memoria es muy reducido.
+ Esta técnica permite tener una variable cuyo tipo es, en cierto modo, variable.
+\layout Subsubsection
+
+struct
+\layout Standard
+
+El struct es muy similar al de C, con algunos agregados, como la posibilidad
+ de tener funciones miembro, inicializadores, etc.
+ No es más que el agrupamiento de un conjunto de variables, a las que se
+ accede a través de un identificador:
+\layout LyX-Code
+
+struct Fecha
+\layout LyX-Code
+
+{ 
+\layout LyX-Code
+
+    uint dia = 1;
+\layout LyX-Code
+
+    uint mes = 1;
+\layout LyX-Code
+
+    uint anio = 2005;
+\layout LyX-Code
+
+    void print()
+\layout LyX-Code
+
+    {
+\layout LyX-Code
+
+        printf("dia: %d, mes: %d, anio: %d
+\backslash 
+n", dia, mes, anio);
+\layout LyX-Code
+
+    }
+\layout LyX-Code
+
+}
+\layout LyX-Code
+
+Fecha f;
+\layout LyX-Code
+
+f.dia = 30;
+\layout LyX-Code
+
+f.mes = 5;
+\layout LyX-Code
+
+f.print();
+\layout Subsubsection
+
+class
+\layout Standard
+
+Las clases son la forma en la que D implementa la orientación a objetos,
+ que veremos en detalle más adelante.
+ Por ahora sólo adelantaremos que es muy similar a un struct, sólo que guarda
+ algo más de información de control (como la tabla virtual) para poder implement
+ar polimorfismo y herencia.
+\layout Section
+
+Expresiones
+\layout Subsection
+
+Operaciones
+\layout Standard
+
+D provee operaciones las operaciones básicas que provee prácticamente cualquier
+ lenguaje: asignación, comparación, incremento, decremento, suma, resta,
+ multiplicación, división, resto, algebra booleana (and, or, xor, not),
+ shifting.
+ También provee llamadas a funciones.
+ Los procedimientos son un caso particular de funciones que no devuelven
+ nada (void).
+\layout Standard
+
+Además de esto, provee operaciones propias de un lenguaje imperativo de
+ bajo nivel: aritmética de punteros, operador [] como método alternativo
+ para acceder a una posición de un array, desreferenciamiento, obtención
+ de una dirección de memoria de una variable, etc.
+ También incluye un operador para comparar si 2 referencias referencian
+ al mismo objeto y algunas operaciones propias de los arrays, como para
+ saber si un elemento está dentro del array o concatenación de arrays y
+ slicing.
+\layout Standard
+
+Finalmente provee un operador de resolución de scope, para acceder a variables
+ definidas dentro de tipos compuestos (como estructuras o uniones) o módulos.
+\layout Subsection
+
+Variables
+\layout Comment
+
+Si hay o no variables sin nombre
+\layout Standard
+
+El lenguaje cuenta con tipado débil, con conversiones implícitas, por ejemplo,
+ entre punteros.
+\layout Subsection
+
+Representación de la memoria
+\layout Standard
+
+La representación en memoria es muy similar a cualquier lenguaje imperativo
+ compilado, como C o C++.
+ Cada tipo de variable ocupa una cierta cantidad de bytes y se almacenan
+ en memoria de forma contigua (al menos lógicamente), según la alineación
+ de la arquitectura para la que fue compilado.
+ Esto trae el clásico problema de los 
+\emph on 
+huecos
+\emph default 
+ que pueden quedar, para que cada variable ocupe un múltiplo de palabras
+ de la arquitectura, para manejarla con mayor eficiencia, por lo que el
+ compilador provee formas de especificar la alineación a usar.
+\layout Standard
+
+Las variables globales (que incluye a las estáticas) se almacenan en tiempo
+ de compilación (estáticamente) dentro del código del programa, en el área
+ de datos.
+ Las variables locales a las funciones se almacenan en una pila de ejecución,
+ por lo tanto debe tener una pila por cada hilo de ejecución.
+ Por último hay un área de memoria 
+\emph on 
+libre
+\emph default 
+ que se le pide al sistema operativo a medida que se nececesita (heap).
+ Una particularidad extra de D es que los tipos definidos por el usuario
+ de tipo 
+\series bold 
+class
+\series default 
+, se almacenan en el heap.
+ En el stack y en el área de datos del programa sólo pueden guardarse referencia
+s (punteros) a instancias de una clase (en realidad hay excepciones, ya
+ que se puede pedir memoria del stack 
+\emph on 
+a mano
+\emph default 
+ e inicializar el objeto en esa memoria, pero no es el caso general).
+\layout Subsection
+
+Modelo de ejecución
+\layout Standard
+
+D es un lenguaje imperativo compilado, por lo que d
+\layout Subsection
+
+Punteros
+\layout Subsection
+
+Recolección de basura
+\layout Subsection
+
+Instrucciones
+\layout Subsection
+
+Rutinas
+\layout Subsubsection
+
+Pasaje de parámetros
+\layout Standard
+
+Por copia en demanda (copy on write) y objetos por referencia.
+\layout Subsubsection
+
+Anidamiento
+\layout Section
+
+Estructura del programa
+\layout Subsection
+
+Módulos, espacios de nombres, Interfaces
+\layout Section
+
+Orientación a objetos
+\layout Subsection
+
+TAD's
+\layout Subsection
+
+Polimorfismo
+\layout Comment
+
+Si hay orientación a objetos y describir cómo es.
+\layout Section
+
+Paralelismo / Concurrencia
+\layout Section
+
+¿Para qué no sirve este lenguaje?
+\layout Section
+
+¿Para qué sí sirve este lenguaje? 
+\the_end