Con GOTO ya hemos visto lo mínimo que se despacha y en su día enumeré los cinco elementos que voy a incluir en Plancton pero no van a ser los únicos, también caerán el proto-polimorfismo y la proto-encapsulación, que más tarde definiré.
Últimamente ando muy pendiente de mi proyecto de final de carrera y estoy asqueado con C y C++. Un petardazo con un puntero a null y ponte a buscar donde petardea. El problema es que tienes que estar muy sobrio para encontrar el error, tambien mi C/C++ es una basura y estoy manejando un API (OpenCV) que jamás había usado antes, continuamente ves que el código esta bien escrito y es cierto pero una mala inicialización hace que todo se vaya al garete y pierdas un buen rato intentando averiguar que coño pasa. La mejor solución para estos problemas son las excepciones con sus bellísimos stacktrace. Si quiero que mi lenguaje sea fácil de programar, tengo que hacer fácil la depuración de errores cuando uno se ha tomado 3 o 4 cervezas con lo que habrá en mi lenguaje excepciones.
Empecemos a definir nuestro lenguaje de programación
Tipos de datos:
En las variables es donde se almacenan las cosas, básicamente necesitamos guardar numeros y textos. Con lo que vamos a tener 2 tipos de datos a los que llamaré num y text. Qué importancia tiene definir tipos.
Al definir un tipo estamos definiendo que datos entran en esa variable y que operaciones vamos a hacer con élla por ejemplo no es lo mismo sumar dos números que dos textos, en el segundo tipo de datos se hace una concatenación.
También habrán estructuras de datos en las que se guardará por ejemplo la información de un dni con lo que internamente tendrán text, num y otras estructuras, el usuario tendrá que definirlas con la palabra struct antes de usarlas por ejemplo voy a definir la estructura fecha y dni.
struct fecha{
num dia;
num mes;
num año;
}
struct dni{
num id;
text nombre;
text apellido1;
text apellido2;
fecha nacimiento;
}
Después si se quiere acceder a los campos se hace de la siguiente forma en fecha mi_fecha.dia. Si queremos acceder al año del dni sería mi_dni.nacimiento.año.
En las estructuras también implementaré herencia que ya explicaré mas adelante y por supesto todos los tipos de datos tendrán sus respectivas operaciones habituales.
No se permiten variables globales, todas tendrán que estar dentro de una función y la definición del tipo tendrá que estar fuera de las funciones.
Estructuras de control selectivas:
Sirven para "decidir un camino" si se cumple una condición lógica usaré el clásico if(), else if(), else nada más para no liar al personal. Por ejemplo:
Si mi variable es igual a 3, imprime "hola" si es mayor que 3, imprime "adios" y en otro caso imprime "tu puta madre".
if(X=3){
print("hola");
} else if(X>3){
print("adios");
} else {
print("tu puta madre");
}
Otro ejemplo: Si mi variable multiplicada por 2 y divida por 4 vale 0, imprimir "hola que tal", en otro caso imprimo "ja, no" y a mi variable le sumo 2 y se lo asigno a ella misma.
if(X*2/4){
print("hola que tal");
}else{
print("ja, no");
X=X+2;
}
También se puede usar solo la sentencia if o la sentencia if con else if.
Estructuras de control repetitivas:
Estos son los bucles, hago continuamente una serie de operaciones varias veces mientras se cumple una condición, cuando se rompe la condición continuo por fuera del bucle. Para los bucles solo usaré el while(){}
por ejemplo mientras x sea menor que y imprimo "tu puta madre".
while(X<Y){
print("tu puta madre");
X=X+1;
}
Esta instrucción X=X+1; es muy importante para controlar la salida del bucle, si no nunca saldriamos de él hasta que apagásemos el ordenador.
Hablemos de las funciones:
Las funciones permiten recopilar código para reutilizarlo y en general están muy relacionadas con la herencia, el polimorfismo y la encapsulación, pero aquí solo voy a explicar como se definen y se usan y cuando explique esos elementos expondré mas formas de uso.
Para definir una función hay que poner el tipo de salida si tienen el nombre y los tipos de entrada que tiene con los nombres de las variables que entran, por ejemplo:
text mi_funcion(text nombre, num edad){
instruccion 1;
instruccion 2;
instruccion 3;
return nombre;
}
Esta función devuelve un text (nombre) y entran, un text guardado en la variable nombre y un num guardado en edad, importante poner un return si se devuelve algo y que la variable que se devuelve sea del mismo tipo que el de salida. Si por ejemplo no se devuelve nada, simplemente se modifican los valores de entrada, no habría que poner return ni tipo de salida.
El programa que hagamos se ejecutará en una función principal a la que llamaré main que tendrá la siguiente forma text main (text args[]) que no voy a explicar por qué tiene esa forma, simplemente hay que tener fe.
Y por último la herencia:
Entendiéndose por herencia la importación de otras funciones y tipos de datos predefinidos. Para ello vamos a usar la palabra import seguido de la ruta del fichero acompañado de un as mas un alias, si estamos windows sería.
Import c:/plancton/libs/ArrayList.ptn as ArrayList
Después para usar las funciones y tipos de datos se haría de la siguiente forma. Si en ArrayList.ptn está definida la funcion void add(list l, struct str) se pondría alias.función:
ArrayList.add( lista, mi_str);
Si es un tipo de dato sería alias.tipoDato por ejemplo si está definido list sería:
ArrayList.list lista;
Con todo esto ya tenemos un lenguaje de programación básico, un pequeño gatito que ronronea que más adelante lo haré crecer y le pondré polimorfismo, encapsulación, excepciones, herencia de la buena, garras y dientes.También junto al gatito voy a deasrrollar un pequeño IDE para poder empezar a chapurrear código y algunas librerías como la entrada/salida estándar, los arrays, las listas, etc... y conforme se estabilice el parser le iré añadiendo más características al lenguaje.
