Prototipo de máquina virtual simple para idiomas de estilo lisp -- amp codereview Relacionados El problema

Simple virtual machine prototype for Lisp-style languages


4
vote

problema

Español

Encontré un post que hice aquí hace un año ( máquina virtual-virtual" para un dialecto LISP mínimo para ejecutarse en la máquina virtual Java ) y se ha interesado nuevamente en este tema. Esta vez, decidí implementar el nivel de instrucción, en lugar de confiar en la máquina virtual de Java como la última vez. Un obstáculo es que, dado que estoy implementando el nivel de instrucción, si decido portear una variante LISP a esta VM, también debería manejar la compilación de las construcciones de alto nivel LISP a las instrucciones de bajo nivel. Como esta es una tarea bastante complicada, aún no se ha hecho.

Las funciones que terminan con x1 corresponden a las instrucciones que debe manejar el VM. La función x2 está ahí para mostrar cómo se recopilaría una cierta construcción LISP a una secuencia de instrucciones.

El colector de basura es un colector de copia simple. Hay dos montones, y cuando el montón actual en uso está lleno, los objetos referenciados se copian al otro montón, y así sucesivamente.

y parece que el colector de basura original se rompió. Editado con el parche de trabajo esperanzado.

  x3  
Original en ingles

I found a post I made here an year ago (Compiler for a minimal LISP dialect to run on the Java Virtual Machine) and got interested on this subject again. This time I decided to implement the instruction level myself instead of relying on the Java virtual machine like last time. An obstacle is that since I'm implementing the instruction level, if I decide to port a Lisp variant to this VM, I should also handle the compilation from the high level Lisp constructs to the low level instructions. As this is a fairly complicated task, it is not yet done.

The functions ending with _ correspond to the instructions that the VM should handle. The main function is there to show how a certain Lisp construct would be compiled down to a sequence of instructions.

The garbage collector is a simple copying collector. There are two heaps, and when the current heap in use is full, the referenced objects are copied to the other heap, and so on.

And it seems the original garbage collector was broken. I edited with the hopefully working patch.

#include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include <inttypes.h>  #define WORD uint32_t #define WORD_FORMAT PRIu32 #define STACK_SIZE 0x100000 #define HEAP_SIZE 0x1000000 #define NIL ((WORD)0) #define LIN ((WORD)-1)  enum {INTEGER_TYPE, BOOLEAN_TYPE, CHARACTER_TYPE, LIST_TYPE};  static WORD stack[STACK_SIZE]; static WORD *stackPointer = stack; static WORD heap[2][HEAP_SIZE]; static int heapIndex; static WORD *heapPointer = *heap + 1;  static void check(bool isOK, const char *message) {     if (!isOK) {         fprintf(stderr, "error: %s\n", message);         exit(EXIT_FAILURE);     } }  static void push_(WORD type, WORD value) {     check(stackPointer <= stack + STACK_SIZE - 2, "stack overflow");     *stackPointer++ = type;     *stackPointer++ = value; }  static void pop_(void) {     stackPointer -= 2; }  static void nil_(void) {     push_(LIST_TYPE, NIL); }  static WORD allocate(WORD type, WORD head, WORD tail) {     if (heapPointer > heap[heapIndex] + HEAP_SIZE - 3) {         heapPointer = heap[!heapIndex] + 1;         for (WORD *p = stack; p < stackPointer; p += 2) {             if (*p == LIST_TYPE) {                 WORD *p2 = p + 1;                 while (*p2) {                     if (heap[heapIndex][*p2 + 2] == LIN) {                         break;                     }                     check(heapPointer <= heap[!heapIndex] + HEAP_SIZE - 3, "heap overflow");                     *heapPointer++ = heap[heapIndex][*p2];                     *heapPointer++ = heap[heapIndex][*p2 + 1];                     *heapPointer++ = heap[heapIndex][*p2 + 2];                     heap[heapIndex][*p2 + 2] = LIN;                     *p2 = heapPointer - heap[!heapIndex] - 3;                     p2 = heapPointer - 1;                 }             }         }         heapIndex = !heapIndex;     }     *heapPointer++ = type;     *heapPointer++ = head;     *heapPointer++ = tail;     return heapPointer - heap[heapIndex] - 3; }  /* This one is broken. static WORD allocate(WORD type, WORD head, WORD tail) {     if (heapPointer > heap[heapIndex] + HEAP_SIZE - 3) {         heapPointer = heap[!heapIndex] + 1;         for (WORD *p = stack; p < stackPointer; p += 2) {             if (*p == LIST_TYPE) {                 WORD list = p[1];                 while (list) {                     if (heap[heapIndex][list + 2] == LIN) {                         break;                     }                     check(heapPointer <= heap[!heapIndex] + HEAP_SIZE - 3, "heap overflow");                     *heapPointer++ = heap[heapIndex][list];                     *heapPointer++ = heap[heapIndex][list + 1];                     list = *heapPointer++ = heap[heapIndex][list + 2];                     heap[heapIndex][list + 2] = LIN;                 }             }         }         heapIndex = !heapIndex;     }     *heapPointer++ = type;     *heapPointer++ = head;     *heapPointer++ = tail;     return heapPointer - heap[heapIndex] - 3; } */  static void link_(void) {     WORD list = allocate(stackPointer[-2], stackPointer[-1], stackPointer[-3]);     pop_();     pop_();     push_(LIST_TYPE, list); }  static void print(WORD type, WORD value) {     switch (type) {     case INTEGER_TYPE:         printf("%" WORD_FORMAT, value);         break;     case BOOLEAN_TYPE:         if (!value) {             fputs("false", stdout);         } else {             fputs("true", stdout);         }         break;     case CHARACTER_TYPE:         putchar(value);         break;     default:         putchar('(');         while (value) {             print(heap[heapIndex][value], heap[heapIndex][value + 1]);             if (value = heap[heapIndex][value + 2]) {                 putchar(' ');             }         }         putchar(')');     } }  static void print_(void) {     print(stackPointer[-2], stackPointer[-1]);     pop_(); }  int main(void) {     // print (1 (1 (2)) ((true) false))     nil_();     nil_();     push_(BOOLEAN_TYPE, false);     link_();     nil_();     push_(BOOLEAN_TYPE, true);     link_();     link_();     link_();     nil_();     nil_();     push_(INTEGER_TYPE, 2);     link_();     link_();     push_(INTEGER_TYPE, 1);     link_();     link_();     push_(INTEGER_TYPE, 1);     link_();     print_();     push_(CHARACTER_TYPE, '\n');     print_(); } 
  

Lista de respuestas


Relacionados problema

2  Mejora de la función que compara dos cadenas  ( Improving function that compares two strings ) 
Estoy aprendiendo C y he hecho esta función muy simple para comparar dos cuerdas. Me gustaría saber cómo se puede mejorar: int match(char* string1, char* s...

4  Juego de Runas: Versión 3  ( Game of runes version 3 ) 
He escrito una versión muy revisada y desarrollada de la juego de runas . Los cambios principales se enumeran: Convertir runas para usar maldiciones. ag...

2  Función para borrar un carácter en una cadena  ( Function to erase a character in a string ) 
void chrrem (char arr[], size_t len, size_t pos) { memmove(arr + pos, arr + (pos + 1), (len - pos) + 1); } Se supone que es simplemente rápido. Borra...

1  Imprima todos los tamaños posibles de subsecuencias de cadena en C  ( Print out all possible sizes of subsequences of string in c ) 
Por ejemplo, dada una cadena "abcdefghijk", quiero que mi función se imprima: a, b, c, d, e, f, g, h, i, j, k. ab, bc, cd, de, ef, fg, gh, hi, ij, jk ab...

5  Cola de bloqueo con la exactitud de la lista doblemente vinculada  ( Lock free queue with doubly linked list correctness ) 
Necesito una cola de bloqueo que se implementa mediante la lista doblemente vinculada. es mi código correcto? ¿Hay algún error? ¿Hay alguna mejoras a realiz...

14  Representación de OpenGL ACTUPTAR  ( Opengl instanced rendering ) 
Tengo una configuración de representación muy básica de OpenGL ANDRANCT, que está compilando y funcionando, sin embargo, es super lento, y aunque pasé días de...

6  Palindrome más largo en una matriz  ( Longest palindrome in an array ) 
Soy nuevo en la programación, y creo que este código podría mejorarse. ¿Alguna sugerencia? 'done'0 ...

38  Sundoku Solver en C  ( Sudoku solver in c ) 
Tuve este código que miente, así que pensé que sometería esto como mi primer intento de una Fin de semana: desafío . Preferiría si las revisiones contenían s...

12  Codificación de árbol binario  ( Binary tree encoding ) 
Implementé una solución a este desafío de codificación en el código de golf. Tengo experiencia decente con C / C ++, pero ha sido un tiempo desde que los us...

4  C Socket Parte-1  ( C socket part 1 ) 
En mis intentos en curso de convertirse en un mejor escritor de blog, tengo algunos códigos más que necesitan revisar. Fuente completa: https://github.com/...




© 2022 respuesta.top Reservados todos los derechos. Centro de preguntas y respuestas reservados todos los derechos