Cosmos (sistema operativo)

La sintaxis de X# es sencilla pero más estricta en comparación con C.

X# solo admite comentarios de una sola línea al estilo C++, comenzando con - //.

X# permite la definición de constantes con nombre declaradas fuera de las funciones. Las constantes numéricas se definen de forma similar a C++ ; por ejemplo:

constante i = 0

. Para hacer referencia a ellos en otros lugares se requiere un #antes del nombre; por ejemplo: - "#i".

• Las constantes de cadena usan comillas simples ( ''). Para incluir una comilla simple en una constante de cadena, use una barra invertida (por ejemplo, 'I\'m so happy'). Las cadenas X# terminan en nulo .
• Las constantes hexadecimales se preceden con un signo de dólar ( $), seguido de la constante. ( $B8000).
• Las constantes decimales no llevan prefijo, pero no pueden empezar con 0.
• Las constantes binarias y octales aún no son compatibles.

Las etiquetas en X# funcionan de manera similar a las etiquetas en otros lenguajes ensamblador. gotoSe utiliza el mnemónico para saltar a una etiqueta en lugar del jumpmnemónico convencional jmp.

Etiqueta de código1 : ir a Etiqueta de código2 :

Los archivos de programa X# deben comenzar con una directiva de espacio de nombres. X# carece de una jerarquía de espacios de nombres, por lo que el espacio de nombres actual cambia con cada directiva hasta que finaliza el archivo. Las variables o constantes en diferentes espacios de nombres pueden tener el mismo nombre, ya que el espacio de nombres se antepone al nombre del miembro en la salida del ensamblado. Los espacios de nombres no pueden hacer referencia entre sí, excepto mediante operaciones de bajo nivel.

espacio de nombres FIRST // Todos los nombres de variables o constantes tendrán como prefijo FIRST y un guion bajo. Por lo tanto, el nombre completo real de la siguiente variable // es FIRST_aVar. var aVarespacio de nombres SEGUNDO // No hay problema en nombrar otra variable como aVar. Su nombre verdadero es SEGUNDO_aVar. var aVarespacio de nombres FIRST // Este código ahora vuelve al espacio de nombres FIRST hasta que finaliza el archivo.

Todo el código ejecutivo de X# debe ubicarse dentro de funciones definidas con la palabra clave 'function'. A diferencia de C, X# no admite la declaración formal de parámetros en el encabezado de las funciones, por lo que se omiten los paréntesis convencionales después del nombre de la función. Dado que los patrones fijos de línea se especifican en la sintaxis implementada en el analizador de código, la llave de apertura no puede colocarse en la siguiente línea, a diferencia de muchos otros lenguajes de estilo C.

función xSharpFunction { // código de la función }

Dado que X# es un lenguaje de bajo nivel, no se insertan marcos de pila , por lo que, por defecto, la dirección EIP de retorno se encuentra en la parte superior de la pila. Las llamadas a funciones de X# contienen argumentos entre paréntesis, a diferencia de los encabezados de función. Los argumentos que se pasan a las funciones pueden ser registros, direcciones o constantes. Estos argumentos se insertan en la pila en orden inverso. Cabe destacar que la pila en plataformas x86 no puede insertar ni extraer registros de un byte.

función xSharpFunction { EAX = $10 otraFunción ( EAX ); return }función otraFunción { //código de la función }

La returnpalabra clave devuelve la ejecución a la dirección EIP de retorno guardada en la pila.

X# puede trabajar con tres estructuras de datos de bajo nivel: los registros , la pila y la memoria , en diferentes puertos. Los registros son la base de todas las operaciones normales para X#. Un registro se puede copiar a otro escribiendo DST = SRCen lugar de movinstrucciones de carga/almacenamiento. Los registros se pueden incrementar o decrementar con la misma facilidad. Las operaciones aritméticas (suma, resta, multiplicación, división) se escriben como dest op srcdonde srces una constante, variable o registro, y destes tanto un operando como la ubicación donde se almacena el resultado.

A continuación se muestran ejemplos de operaciones de asignación y aritméticas.

ESI = 12345 // asigna 12345 a ESI EDX = #constantForEDX // asigna #ConstantForEDX a EDX EAX = EBX // mueve EBX a EAX => mov eax, ebx EAX -- // decrementa EAX => dec eax EAX ++ // incrementa EAX => inc eax EAX + 2 // suma 2 a eax => add eax, 2 EAX - $ 80 // resta 0x80 de eax => sub eax, 0x80 BX * CX // multiplica BX por CX => mul cx -- la división, la multiplicación y el módulo deben conservar los registros CX / BX // divide CX entre BX => div bx CX mod BX // resto de CX/BX a BX => div bx

El cambio y la rotación de registros son similares a los de C.

DX << 10 // desplazamiento a la izquierda 10 bits CX >> 8 // desplazamiento a la derecha 8 bits EAX <~ 6 // rotación a la izquierda 6 bits EAX ~> 4 // rotación a la derecha 4 bits

Otras operaciones bit a bit son similares a las operaciones aritméticas.

DL & $ 08 // Realiza una operación AND bit a bit en DL con 0x08 y almacena el resultado en DL. CX | 1 // Establece el bit menos significativo de CX a 1 (hazlo impar). EAX = ~ ECX // Realiza una operación NOT bit a bit en ECX y almacena el resultado en EAX. EAX ^ EAX // Borra EAX mediante una operación XOR consigo mismo.

La manipulación de la pila en X# se realiza mediante los prefijos +y -, donde +inserta un registro, un valor, una constante o todos los registros en la pila y -extrae un valor de algún registro. Todas las constantes se insertan en la pila como palabras dobles, a menos que se indique lo contrario (no se admite la inserción de bytes individuales).

+ ESI // insertar esi - EDI // insertar en edi + All // guardar todos los registros => pushad - All // cargar todos los registros => popad + $ 1 badboo2 // insertar 0x1badboo2 en la pila + $ cafe como palabra // \/ + $ babe como palabra // insertar 0xcafebabe + # VideoMemory // insertar el valor de la constante VideoMemory

Las variables se definen dentro de los espacios de nombres usando la varpalabra clave. Los arreglos se definen especificando el tipo y el tamaño. Las variables y los arreglos se inicializan a cero por defecto. Para hacer referencia al valor de una variable, use un punto ('.'), y para hacer referencia a su dirección, use @.

espacio de nombres XSharpVariables var zeroVar // a la variable se le asignará cero var myVar1 = $ f000beef // a la variable se le asignará 0xf000beef var someString = ' Hello XSharp ! ' // a la variable se le asignará 'Hello XSharp!\0', var buffer byte [ 1024 ] // a la variable de tamaño 1024 bytes se le asignarán 1024 bytes cero ... EAX = . myVar1 // mueve el valor de myVar1 (0xf000beef) a EAX ESI = @ . someString // mueve la dirección de someString a ESI CL = . someString // mueve el primer carácter de someString ('H') a CL . zeroVar = EAX // asigna zeroVar al valor de EAX

X# puede acceder a una dirección con un desplazamiento especificado usando corchetes:

var someString = ' Hola XSharp ! ' // la variable se asignará a 'Hello XSharp!\0' ... ESI = @ . someString // carga la dirección de someString en ESI CL = 'B' // establece CL en 'B' (reescribe 'H' al principio) CH = ESI [ 1 ] // mueve el segundo carácter ('E') de la cadena a CH ESI [ 4 ] = $ 00 // fin de la cadena // El valor de someString será 'Bell' (o 'Bell\0 XSharp!\0')

En X# existen dos formas de comparar valores: comparación pura y comparación condicional (if-comparing).

• La comparación pura deja el resultado en FLAGS, que se puede usar en el lenguaje ensamblador nativo o con la ifpalabra clave sin especificar miembros de comparación.
• Si la comparación compara directamente dos miembros después de una ifpalabra clave.

Aquí hay dos maneras de escribir una strlenfunción (lenta) para medir la longitud de una cadena X#:

// Método 1: usando la función de comparación pura strlen { ESI = ESP [ 4 ] // obtener puntero a la cadena pasada como primer argumento ECX ^ ECX // borrar ECX Loop : AL = ESI [ ECX ] // obtener el siguiente carácter AL ?= 0 // ¿es 0? guardar en FLAGS if = return // si ZF está activado, devolver ECX ++ // de lo contrario incrementar ECX goto Loop // bucle...// Método 2: usando la función if strlen { ESI = ESP [ 4 ] // obtener puntero a la cadena pasada como primer argumento ECX ^ ECX // borrar ECX Loop : AL = ESI [ ECX ] if AL = 0 return // ¿AL = 0? return ECX ++ goto Loop // bucle.... }

Hay seis operadores de comparación disponibles: . Estos operadores se pueden usar tanto en comparaciones como en bucles. Tenga en cuenta que también hay un operador AND bit a bit que prueba bits:< > = <= >= !=

AL ?& $ 80 // prueba AL MSB if = return // si ZF es 0, la instrucción de prueba resultó en 0 y MSB no está establecido.

Cosmos permite a los usuarios arrancar el sistema operativo en un entorno emulado mediante una máquina virtual . Esto permite a los desarrolladores probar el sistema en su propio ordenador sin necesidad de reiniciarlo, lo que ofrece la ventaja de no requerir hardware adicional ni salir de su entorno de desarrollo integrado (IDE). VMware es el método de virtualización principal, aunque también admite otros como QEMU e Hyper-V.

Esta opción graba el sistema operativo en un archivo de imagen de disco ( imagen ISO ), que se puede cargar en algunos emuladores (como Bochs , QEMU o, más comúnmente, VMware ) o grabar en una unidad flash USB e iniciar en hardware físico.

Esta opción permite que el sistema operativo arranque en hardware físico. Los datos se envían a través de una red de área local (LAN) a la máquina cliente . Esto requiere dos ordenadores: uno como máquina cliente (en el que se inicia el sistema operativo) y otro como servidor (normalmente la máquina de desarrollo). También requiere una red que conecte ambos ordenadores, una máquina cliente con tarjeta de red y un sistema básico de entrada/salida ( BIOS ) compatible con el arranque PXE. (Datos de 2022)La depuración a través de la red ya no es compatible.