Lenguaje programación limbo

Lenguaje programación limbo
José Marı́a Cañas Plaza
[email protected]
Octubre 2003
Índice
1
Índice
Introducción
Tipos de datos
Estructuras de control
Hebras
Canales
c
2003
GSyC
Lenguaje programación limbo
Introducción
2
Introducción
similar a C en el flujo de control
similar a Pascal en las estructuras de datos
sensible a mayúsculas
fuertemente tipado
no es orientado a objetos
lenguaje modular: módulos
c
2003
GSyC
Lenguaje programación limbo
Introducción (cont.)
3
Hola mundo
# esto es un comentario
implement Hi;
include "sys.m"; sys:Sys;
include "draw.m";
Hi: module {
init:
};
fn(nil: ref Draw->Context, argv: list of string);
init(nil: ref Draw->Context, argv: list of string)
{
sys = load Sys Sys->PATH;
sys->print("Hola mundo\n");
}
c
2003
GSyC
Lenguaje programación limbo
Introducción (cont.)
4
Compilación y ejecución
limbo -g holamundo.b
./holamundo.dis
ejecutables en dis, interpretados
máquina virtual DIS
/dis/
c
2003
GSyC
Lenguaje programación limbo
Introducción (cont.)
5
Módulos como tipos
cabeceras .m
implementación .b
implementaciones como valores de variable
carga dinámica de módulos
no hay enlazado estático
import
función init
c
2003
GSyC
Lenguaje programación limbo
Tipos de datos
6
Tipos de datos
declaración :
inicialización, asignación =
declaración implı́cita :=
básicos: int, byte, big, real, string
compuestos: lists, array, tuplas, adt
tipos valor: se pasan como parámetros en funciones
tipos referencia
conversión entre tipos
c
2003
GSyC
Lenguaje programación limbo
Tipos de datos (cont.)
7
Tipos enteros: int, byte, big
int, [−231 , 231 − 1], i := 341421432;
byte, [0, 255]
big, [−263 , 263 − 1]
se inicializan a cero solo si son globales, locales indefinido
los tipos no son miscibles
para pasar de un tipo entero a otro se necesita una conversión
b : byte; b = (byte) 7;
i : int; i = (i << 3) + 345;
c
2003
GSyC
Lenguaje programación limbo
Tipos de datos (cont.)
8
Tipo real
64 bits, notación flotante IEEE
r: real; r=3.141592;
r = real 4;
c
2003
GSyC
Lenguaje programación limbo
Tipos de datos (cont.)
9
Tipo string
secuencias de caracteres Unicode
codificación UTF-8 de Unicode
’K’ no es lo mismo que “K”
cada carácter es un entero
s: string; s=”telefono”;
s[3] = ’E’;
c := s[2];
operador len
num := len s;
s = ’F’; (??)
c
2003
GSyC
Lenguaje programación limbo
Tipos de datos (cont.)
10
se pueden incrementar uno a uno
de int a string
a: string; a = (string) 234;
de string a int
i: int; i = (int) “456 67”;
se concatenan con el operador +
nombre := “Juan”
saludo:= “hola”+” ”+nombre;
c
2003
GSyC
Lenguaje programación limbo
Tipos de datos (cont.)
11
Constantes
datos: con “/usr/jmplaza/texto”;
pi: con 3.14159265;
enumeraciones:
Lun, Mar, Mie, Jue, Vie, Sab, Dom: con iota;
doce, trece, catorce: con iota+12;
dos, cuatro, ocho, dieciseis: con 2<<iota;
c
2003
GSyC
Lenguaje programación limbo
Tipos de datos (cont.)
12
Tipos referencia
listas, arrays, tuplas...
antes de usarlos hay que ubicarles en un espacio de memoria
en Limbo no hay punteros, lo más parecido son las referencias
no hay aritmética de referencias
en Limbo sólo se puede pedir memoria, no liberarla. El recolector de
basura la libera automáticamente cuando deja de ser accesible
Si x e y son dos referencias, ¿que pasa al asignar x = y?
x = nil
nil es una referencia a cualquier cosa
también se usa para anunciar que no se usa cierto parámetro
a := funcion(“hola”,3,nil);
c
2003
GSyC
Lenguaje programación limbo
Tipos de datos (cont.)
13
Listas
lista de elementos del mismo tipo
menu : list of string;
menu := list of “sopa”,”coliflor”,”filete”;
es un tipo referencia
operador ::
operador hd
operador tl
operador len
menu = “pescado”::menu;
primero := hd menu;
submenu := tl menu;
num := len menu;
los operadores no son modifican elementos de la lista original
c
2003
GSyC
Lenguaje programación limbo
Tipos de datos (cont.)
14
Arrays
colecciones indexadas de elementos del mismo tipo
bonoloto : array of int;
bonoloto = array [6] of int;
bonoloto := array [6] of int;
indice de 0 a n-1
se les puede dar valor inicial
bonoloto := array [6] of {1,12,15,23,35,41};
z := array [20] of
{ 0 or 2 or 4 or 6 or 8 => 1;
1 or 3 or 5 or 7 or 9 => 0;
* => 2 };
puede haber arrays de arrays
c
2003
GSyC
Lenguaje programación limbo
Tipos de datos (cont.)
15
Rebanadas
subconjuntos de arrays y de strings
comienzan en un ı́ndice inicial y acaban uno antes del ı́ndice final
familia := array [] of “manuela”,”marta”,”pablo”,”luis”
chicos := familia[2:]; chicas := familia[0:2];
compuesto := chicas[0][:3]+chicas[1][3:5];
se pueden asignar cosas a una rebanada si no se especifica su final
a := array [10] of int; b:= array [20] of int;
b[15:]=a[5:]
c
2003
GSyC
Lenguaje programación limbo
Tipos de datos (cont.)
16
Conversión entre string y array of byte
de string a array of byte
pueden no tener la misma longitud, dependiendo de cuantos bytes se
necesite para representar los caracteres de Unicode
ingles := “ant”; inglesbytes := array of byte ingles;
castellano := “españa”; castellanobytes := array of byte castellano;
de array of byte a string
depende de si el flujo de bytes es una secuencia válida de Unicode
array of byte − > string − > array of byte, pueden no coincidir
c
2003
GSyC
Lenguaje programación limbo
Tipos de datos (cont.)
17
Tuplas
una colección sin nombre de elementos
a:= (“Juana”,”José”,34,9.2)
es un buen modo de pasar argumentos a funciones
recoger su retorno
(valor,ok):=funcion(34);
se puede usar a ambos lados de la asignación
int i; real r;
(nil,nil,i,r)=a;
c
2003
GSyC
Lenguaje programación limbo
Tipos de datos (cont.)
18
ADT
persona : adt
{ a~
no: int;
nombre: string;
}
paciente : persona;
colección de elementos heterogeneos con nombre, incluso funciones
es un tipo valor
acceso a los elementos por nombre, a:=paciente.nombre
se permite la asignación entre un ADT y una tupla homóloga
se adscriben a módulos, sus funciones deben definirse en él
c
2003
GSyC
Lenguaje programación limbo
Tipos de datos (cont.)
19
ref ADT
operador ref
admite también acceso con .
se hace una copia del ADT y se entrega una referencia a esa copia
funciones que admiten referencias pueden cambiar contenidos del
ADT
manolo: paciente; a, b, c : ref paciente
a= ref manolo;
manolo.nombre = “Manuel Garcı́a”;
manolo.año = 1970;
b=c= ref paciente(1923,”Jesús Molina”);
c
2003
GSyC
Lenguaje programación limbo
Tipos de datos (cont.)
20
autoreferencia self
persona : adt
{ a~
no: int;
nombre: string;
edad: fn(yomismo : self ref persona): int;
}
persona.edad(yomismo : self persona):int
{#comprueba fecha actual y le resta la de nacimiento
}
z: = manolo.edad();
ADT con especialidades, los campos dependen de la especialidad
similar a los registros variantes
c
2003
GSyC
Lenguaje programación limbo
Tipos de datos (cont.)
21
pick ADT
fichero : adt
{permisos: int;
due~
no: string;
pick
{regular => contenido : array of byte;
longitud : int;
directorio => hijos : ref fichero;
cuantos : int;
}}
ADT con especialidades, los campos dependen de la especialidad
f : fichero; tagof f;
g := fichero.regular(777,”jmplaza”,nil,0);
c
2003
GSyC
Lenguaje programación limbo
Tipos de datos (cont.)
22
Construcción pick del lenguaje
pick aux := variable
{ regular => print(‘‘%d bytes\n’’,aux.longitud);
directorio => print(‘‘dir con %d hijos\n’’, aux.cuantos);
}
para utilizarlos se utiliza la construcción pick del lenguaje
el flujo avanza por la rama con la especialidad acertada
c
2003
GSyC
Lenguaje programación limbo
Tipos de datos (cont.)
23
Definición de tipos nuevos
type
mientero: type int; a : mientero;
uchar: type byte; b : uchar;
c
2003
GSyC
Lenguaje programación limbo
Estructuras de control
24
Estructuras de control
Condicional if
if ( expresion ) sentencia;
if ( expresion ) sentencia1; else sentencia2;
la expresión es entera y evalúa a 0 o a distinto de 0
se pueden anidar condicionales, el else corresponde al último if
operadores lógicos
se pueden agrupar sentencias en un bloque con {}
c
2003
GSyC
Lenguaje programación limbo
Estructuras de control (cont.)
25
Construcción do while
do sentencia while ( expresion );
mientras la expresión evalúa a 0
siempre se ejecuta al menos una vez
se pueden anidar
c
2003
GSyC
Lenguaje programación limbo
Estructuras de control (cont.)
26
Construcción while
while ( expresion ) sentencia ;
mientras la expresión evalúa a 0
puede no ejecutarse nunca la sentencia
se pueden anidar
c
2003
GSyC
Lenguaje programación limbo
Estructuras de control (cont.)
27
Sentencia case
case expresion
{ expr1 => sentencia1;
expr2 to expr3 => sentencia2;
expr4 or expr5 => sentencia3;
* => sentencia4;
}
la expresión evalúa a un int o a un string
sólo ejecuta la rama que casa
si ninguna casa, entonces se evalúa la de *
las expresiones de las entradas no pueden solaparse
c
2003
GSyC
Lenguaje programación limbo
Estructuras de control (cont.)
28
Iteraciones con for
for (i=1; i<=10; i++)
{
print(‘‘i = %d\n’’,i);
}
for (expr1; expr2; expr3) sentencia;
expr1 para incializar
al final de cada iteración se comprueba expr2
si hay que dar otra iteración se evalúa expr3
c
2003
GSyC
Lenguaje programación limbo
Estructuras de control (cont.)
29
break, continue y return
n=0;
primero: do
{ segundo: do
{
if (n >= 5) break primero;
n++;
}while();
} while ();
return devuelve el flujo de control al llamante de una función
break saca el flujo de control fuera del while, do o case
continue salta la iteración actual de while, do, o for
pueden llevar etiqueta
c
2003
GSyC
Lenguaje programación limbo
Hebras de Limbo
30
Hebras de Limbo
flujos de ejecución concurrentes
no son los procesos del kernel
roundrobin
spawn función(1,3.24);
exit;
las hebras tienen estado
ready, broken, exiting, alt, send, receive, release
c
2003
GSyC
Lenguaje programación limbo
Hebras de Limbo (cont.)
31
Recursos de las hebras
sys− >pctl()
espacio de nombres
variables de entorno
tabla de descriptores abiertos
nuevo vacı́o | copia del padre | compartir con el padre
c
2003
GSyC
Lenguaje programación limbo
Hebras de Limbo (cont.)
32
hebra limbo 2
hebra limbo 1
hebra limbo 3
MAQUINA VIRTUAL
SO HUESPED, INFERNO NATIVO
proceso kernel A
proceso kernel B
hebra 1 puede ejecutarse en el proceso A o B en distintos instantes
el proceso A puede ejecutar la hebra 1 o 2 en distintos instantes
c
2003
GSyC
Lenguaje programación limbo
Canales
33
Canales
mecanismo de cita
el que quiere leer se bloquea hasta que alguien escribe
el que quiere escribir se bloquea hasta que alguien lee
útil para comunicar datos entre dos hebras
útil para sincronización
inchan := chan of int;
outchan := chan of string;
c =< − inchan;
outchan < −= “mesa”;
c
2003
GSyC
Lenguaje programación limbo
Canales (cont.)
34
sentencia alt
alt
{
a := <- chan1 => print(‘‘Esta preparado el 1\n’’);
b := <- chan2 => print(‘‘Esta preparado el 2\n’’);
chan3 <- 3 => print(‘‘Esta preparado el 3\n’’);
* => print(‘‘Ninguno está listo\n’’);
}
similar a case, pero con canales
el flujo prosigue por el envı́o o recepción que esté preparado
c
2003
GSyC
Lenguaje programación limbo
+ información
35
+ información
www.vitanuova.com/inferno/papers.html
Limbo Basics
A Descent into Limbo
Limbo programming
Inferno Programming with Limbo
c
2003
GSyC
Lenguaje programación limbo