Lenguaje programación limbo

Transcripción

1 José María Cañas Plaza Octubre 2003

2 Índice 1 Índice Introducción Tipos de datos Estructuras de control Hebras Canales

3 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

4 Introducción (cont.) 3 Hola mundo # esto es un comentario implement Hi; include "sys.m"; include "draw.m"; sys:sys; 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"); }

5 Introducción (cont.) 4 Compilación y ejecución limbo -g holamundo.b./holamundo.dis ejecutables en dis, interpretados máquina virtual DIS /dis/

6 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

7 Tipos de datos 6 Tipos de datos declaración : inicialización, asignación = declaración impĺı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

8 Tipos de datos (cont.) 7 Tipos enteros: int, byte, big int, [ 2 31, ], i := ; byte, [0, 255] big, [ 2 63, ] 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;

9 Tipos de datos (cont.) 8 Tipo real 64 bits, notación flotante IEEE r: real; r= ; r = real 4;

10 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 ; (??)

11 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) ; se concatenan con el operador + nombre := Juan saludo:= hola + +nombre;

12 Tipos de datos (cont.) 11 Constantes datos: con /usr/jmplaza/texto ; pi: con ; enumeraciones: Lun, Mar, Mie, Jue, Vie, Sab, Dom: con iota; doce, trece, catorce: con iota+12; dos, cuatro, ocho, dieciseis: con 2<<iota;

13 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);

14 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

15 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

16 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:]

17 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

18 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;

19 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

20 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 );

21 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

22 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);

23 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

24 Tipos de datos (cont.) 23 Definición de tipos nuevos type mientero: type int; a : mientero; uchar: type byte; b : uchar;

25 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 {}

26 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

27 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

28 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

29 Estructuras de control (cont.) 28 for (i=1; i<=10; i++) { print( i = %d\n,i); } Iteraciones con for 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

30 Estructuras de control (cont.) 29 n=0; primero: do { segundo: do { if (n >= 5) break primero; n++; }while(); } while (); break, continue y return 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

31 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

32 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

33 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

34 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 ;

35 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

36 + información 35 + información Limbo Basics A Descent into Limbo Limbo programming Inferno Programming with Limbo