Visita la versión flash
Propuestas
Visita el perfil del autor
Hablan del blog

SOM30


"Cómo hacer un Sistema Operativo en 30 días"
6/07/2010 22:25

Estructuras básicas para el lenguaje de programación

Comunicaciones de Red
Hoy hemos llegando por fin a ese ansiado 20% del tiempo total de desarrollo del Sistema Operativo donde vamos a recapitular lo que tenemos para, por fin, definir nuestro lenguaje de ensamblador y comenzar a picar código de verdad.

Para esta labor, hay que recapitular lo que tenemos: el día 2 sacamos para qué Sistema Informático (arquitectura) íbamos a desarrollar el Sistema Operativo, el día 3 conocimos el juego de instrucciones que reconoce esa arquitectura, el día 4 fijamos el idioma de programación que marcará nuestros lenguajes de programación, y ayer día 5 supimos las estructuras nativas que nos ofrecerá el compilador. Hoy, por tanto, uniremos estos conceptos para formar en nuestro lenguaje de ensamblador.

El Sistema Informático seleccionado vimos que estaba enfocado a trabajar con memoria principalmente, frente a los habituales, que están orientados al cálculo. Esto da pie a que el lenguaje de ensamblador esté orientado igualmente a trabajar con memoria; además, para ahorrar grandes problemas de acercamiento a nuevos programadores, estará orientado a objetos. En líneas generales, podríamos decir que será un lenguaje de bajo nivel que tendrá las características de uno de alto nivel. Esto es una consecuencia directa de desarrollarlo con el idioma de programación que definíamos hace un par de días.

Para los que no estén acostumbrados a ver el tipo de sintaxis que usaré a la hora de definir métodos o recursos, voy a explicarla. Utilizo una sintaxis acorde con la que solicita el procedimiento #crea del que hablábamos ayer. En primer lugar, aparece la estructura en la que se va a crear, luego la estructura que devolverá, y después argumentos (#DEFINEDs y/o #OBJETCs en un vector #ARGUMENT), y por último, la función de ejecución (#FUNCTION) que dejaremos entre {...} para no complicarlo mucho. Los paréntesis del comienzo suelen omitirse, pero siendo la primera vez y puesto que no está sintácticamente mal, los incluiré.

Antes de nada, hay matizar que las estructuras son, de alguna manera, algo similar a las clases de los lenguajes de alto nivel... se definen como conjuntos de información, tanto en forma de datos (objetos) como en forma de métodos (funciones), que nos permitirán utilizar los recursos reales o virtuales que nos provee el Sistema. Recordar que las estructuras se crearán con el procedimiento #haz que incluye el compilador.

Como sabemos, inicialmente este Sistema Informático permite, a través de su juego de instrucciones, el acceso a tres recursos reales: registros, punteros y el Espacio de Direcciones. Es turno ahora de concretar las estructuras básicas que necesitamos, pero antes de acceder a estos tres recursos reales, necesitamos declarar dos estructuras de ámbito general:
  • BIT para acceder a recursos de 1 bit.
    • Este sin duda es el más importante, del que heredan casi todos los demás.
    • Implementa métodos funcionales, para realizar llamadas a funciones, utilizando el operador punto (".") como es lógico.
    • Tiene una función para escribir "(BIT #VOID) .pon(valor:BIT) {...}"
    • Tiene el método "(BIT #VOID) = valor:BIT {...}" que es un alias de la función anterior pero utilizando el operador igual ("=") como es habitual.
  • PAG para acceder a las páginas de los punteros de la MMU.
    • Tiene el método "(PAG BIT) [i:#UINT] {...}" para acceder a cada una de las ocho componentes de una página.
    • Tiene el método "(PAG #VOID) = valor:PAG {...}" para modificar el valor de una página.
Hay que recalcar que estas estructuras ya son propias del lenguaje de programación. Por ello, éstas no van antecedidas de la almohadilla ("#"), aunque seguirán estando en mayúsculas. Más adelante podremos definir clases, que tendrán sólo la primera letra mayúscula; mientras que las variables tendrán la primera letra siempre minúscula. También veremos más abajo que no hay restricciones a la hora de utilizar caracteres con tildes, etc.; salvo que se mantiene que estos nombres no puedan empezar por un número.

Dicho esto, y con esas dos estructuras básicas definidas, ya podemos declarar las estructuras para acceder a esos recursos que nos provee el Sistema Informático de los que hablaba antes. Declararemos estas tres estructuras:
  • REG para acceder a todos registros del núcleo del Sistema Informático.
    • Tiene el método "(REG BIT) [a:#STRING] {...}" para acceder a los diferentes registros, siendo a:STRING el identificador del registro en mayúscula.
    • Debido a que algunos son de lectura y otros de escritura, algunos BIT no variarán al intentar modificarlos.
  • WIT para acceder a todos los punteros de la MMU.
    • Tiene el método "(WIT PAG) [i:#UINT]{...}" para acceder a las diferentes páginas.
    • Tiene el método "(WIT PAG) [[i:#UINT]]{...}" para acceder directamente a las diferentes componentes absolutas.
    • Tiene el método "(WIT #VOID) ++ {...}" para incrementar el valor del puntero una dirección más arriba.
    • Tiene el método "(WIT #VOID) -- {...}" para decrementar el valor del puntero una dirección más arriba.
    • Tiene el método "(WIT WIT) + i:#UINT {...}" para incrementar el valor del puntero una dirección más arriba.
    • Tiene el método "(WIT WIT) - i:#UINT {...}" para decrementar el valor del puntero una dirección más arriba.
  • BUS para acceder al Espacio de Direcciones.
    • Tiene el método "(BUS REG) [i:#UINT]{...}" para acceder a los diferentes registros del Espacio de Direcciones o Bus de Direcciones.
Una vez tenemos las estructuras definidas, vamos a definir los tres recursos globales que nos abrirán la puerta a trabajar con el Sistema Informático. Los recursos son como las instancias de las clases, pero de las estructuras; dicho de otra forma, los recursos ofrecen la funcionalidad que implementa el tipo de estructura que son. Vamos a ver estos tres recursos globales necesitamos:
  • (# REG) reg. Será el recurso que contiene el conjunto de todos registros del núcleo.
  • (# WIT) wit. Será el recurso que contiene el conjunto de páginas de punteros de la MMU.
  • (# BUS) bus. Será el recurso que contiene el conjunto de bits del Espacio de Direcciones.
Por último, vamos a necesitar crear unos métodos globales:
  • (# #VOID) if condición:BIT acción:FUNCION {...}: Será el método que nos permitirá realizar acciones condicionadas.
  • (# #VOID) if condición:BIT acción1:FUNCION else acción2:FUNCION {...}: Será el método que nos permitirá realizar acciones condicionadas un poco más avanzadas.
  • (# #UINT) a:UINT mas b:UINT {...}: Será el método que nos permitirá trabajar con números enteros sin signo, para sumarlos.
    • Esta tiene un alias con el operador más ("+"), (# #UINT) a:UINT + b:UINT {...}, como es natural.
  • (# #UINT) a:UINT menos b:UINT {...}: Será el método que nos permitirá trabajar con números enteros sin signo, para restarlos.
    • Esta tiene un alias con el operador menos ("-"), (# #UINT) a:UINT - b:UINT {...}, como es natural.
    • También tener en cuenta que en caso que fuera a salir negativo, simplemente devolverá cero.
Llegados a este punto, tenemos listo las estructuras básicas de nuestro lenguaje de ensamblador. Quizás con el tiempo necesitemos implementar nuevos métodos a estos. Pero ahora nos vamos a centrar en definir nuevas estructuras (más métodos globales y otros recursos) a partir de éstas para poder trabajar más rápidamente.

Comentarios

17/09/2010 20:11
Con tan poco información, sólo puedo volverte a escribir lo mismo de la entrada. Lee las anteriores, ya que son necesarias para entender este concepto de las Estructuras Básicas del Lenguaje de Programación, sobre todo la entrada del día anterior.
Si eres programador de otros lenguajes orientados a objetos, intenta pensar que las estructuras 'son como' clases... si aun así no lo entiendes bien, plantea las dudas que te puedan surgir en este mismo tablón.

17/09/2010 16:10
no me he enterado

Deja tu comentario


Se enviará usando la Red Social @visitante
¿Quieres responder con otra cuenta de TuEntidad.es?
Usa MonoMola o LoTienes.

Búsqueda

Calendario

- Día 1
- Día 2
- Día 3
- Día 4
- Día 5
- Día 6
- Día 7
- Día 8
- Día 9
- Día 10
- Día 11
- Día 12
- Día 13
- Día 14
- Día 15
- Día 16
- Día 17
- Día 18
- Día 19
- Día 20
- Día 21
- Día 22
- Día 23
- Día 24
- Día 25
- Día 26
- Día 27
- Día 28
- Día 29

Código

- Sistemas Informáticos
- Compilador
- GAM
- GAE
- Kérnel
- LiSi
- ViSi
- SAM
Licencia LSW

Comentan

- Día 1 (16) 8/06 02:28
- Día 29 (19) 13/03 04:10
- Día 10 (18) 23/01 22:16
- Día 3 (9) 10/12 08:55
- Día 2 (19) 10/12 08:54
- Día 7 (4) 5/11 21:29
- Día 11 (44) 25/10 01:39
- Día 4 (3) 24/09 13:45
- Día 28 (2) 6/04 04:01
- Día 26 (1) 17/07 01:21
- Día 27 (4) 29/05 14:50
- Día 8 (9) 29/05 05:35
- Día 24 (2) 18/01 05:16
- Día 17 (5) 18/01 05:10
- Día 13 (7) 6/12 18:44
- Día 15 (1) 30/08 08:53
- Día 6 (2) 25/08 02:14
- Día 5 (4) 7/04 00:50
- Día 21 (6) 26/06 21:26
- Día 18 (2) 26/06 03:09
- Día 23 (2) 22/04 13:45
- Día 25 (1) 11/03 21:34
- Día 19 (3) 19/01 17:33
- Día 14 (2) 7/01 22:06

Valid HTML 4.01 Transitional