Código
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdbool.h> struct String; struct Variable; struct VariableList; struct Function; struct Params; struct ParamsList; struct Instruction; struct InstructionList; const long INVALID_INDEX = -1; /* typedef struct Variable Variable ; typedef struct Function Function; typedef struct VariableList VariableList; */ struct String { char* text; size_t size; // Tamaño del bloque reservado (mas no el que se usa). }; struct Variable { // Define una varible. enum FORMAT_VARIABLE{ _NONE_ = 0x0, // Tipos... _CHAR_ = 0x1, _INT_ = 0x2, _FLOAT_ = 0x4, _DOUBLE_ = 0x8, _VOID_ = 0x10, // Modificadores... _UNSIGNED_ = 0x100, _LONG_ = 0x200, // Se permite usar 2 veces solo en INT y 1 vez en DOUBLE. _SHORT_ = 0x400, // Se permite usar 1 vez en INT. _CONST_ = 0x800, // Solo una vez en todos los tipos de variables. _PTR_ = 0x1000, // Indica que la variable es un puntero. _SHARED_ = 0x2000, // Se usa en combinacion de una variable tipo puntero (Se usa para que la memoria pedida no se autolibere al salir de la función). _STATIC_ = 0x3000 // Se usa para que una variable no pierda su valor al salir de una funcion. } a; struct String name; // Nombre de la variable. long flags; // Tipo de variable (Es una combinacion de las enumeraciones superiores). size_t size; // Tamaño en bytes de la variable. void* value; // Valor. }; struct VariableList { // Lista de variables. struct Function* parent; // Funcion padre donde estan alojadas las variables. unsigned long count; // Cantidad de variables. struct Variable** list; // Puntero a la lista de las funciones. }; struct Params { enum FORMAT_PARAM { _VARIABLE_ = 1, _FUNCTION_ = 2, //_VOID_ = 4 } a; void* value; // Apuntador al parametro (Segun flags debera de realizarse un cast adecuado). long flags; // Tipo de parametro: variable, funcion... }; struct ParamsList { struct Instruction* parent; // A que instruccion pertenece este parametro?. struct Params* list; // Lista d elos parametros. size_t count; // Cantidad de parametros. }; struct Instruction { enum { // Flags Predeterminados. //_NONE_, // No es ninguna instruccion. // Asignaciones. _ASIGN_, // Asignacion (A = B). _ASIGN_ADD_, // Asignacion con Sumatoria/Resta ( A += B, A >- B). _ASIGN_ROL_, // Asignacion con dezplazamientode de N bits a la izquierda ( A <<= B). _ASIGN_ROR_, // Asignacion con dezplazamientode de N bits a la derecha ( A >>= B). // Comparaciones. _EQUAL_, // Igual que (A == B). _GREATTHAT_, // Mayor que (A > B). _LESSTHAT_, // Menor que (A < B). _GREATTHAT_EQUAL_, // Mayor o igual que (A >= B). _LESSTHAT_EQUAL_, // Menor o igual que (A >= B). _AND_, // A y B (A && B). _OR_, // A o B (A || B). // Operaciones Basicas (base 10). _ADD_, // Resta/Suma (A+B). _ADD_PRE_, // Resta/Suma -/+ 1 (++A, --A). _ADD_POST_, // Resta/Suma -/+ 1 (A++, A--). _MULTIPLY_, // Multiplicacion (A * B). _MOD_, // Residuo de A entre B (A % B) (retorna un unsigned long long). _DIV_, // A entre B (A / B) (Retorna un long double). // Operaciones Binarias (base 2). _ROL_, // Rotacion de N bits a la izquierda (A << N). _ROR_, // Rotacion de N bits a la izquierda (A >> N). _AND_BIT_, // A y B (A & B). _OR_BIT_, // A o B (A | B). _XOR_, // A xor B (A ^ B). _NOT_ // complemento binario (not A). } a; struct Function* parent; // A que funcion pertenece la instruccion?. int opcode; // De que tipo es la instruccion?. struct ParamsList arg; // Lista de argumentos d ela funcion. }; struct InstructionList { struct Function* parent; // A que funcion pertenece la lista de instrucciones?. struct Instruction* list; // Lista de instruccion. size_t count; // Cantidad de instrucciones contenidas. }; struct Function { struct Function* stackCall; // Pila del proceso (Quien llamo al proceso). struct String name; // Nombre de la funcion. struct VariableList* vars; // Lista de variables. struct InstructionList code;// Codigo de la funcion Cada linea representa una instruccion. struct Variable ret; // Valor que retorno la funcion. }; bool stringInit(struct String* str); struct String* stringCreate(); char* stringRedim(struct String* str, size_t size); bool stringFinalize(struct String* str); bool stringFree(struct String* str); struct Variable* variableCreate(const char* name); bool variableFree(struct Variable* var); bool variableFreeList(struct Variable** varlist, size_t count); struct Variable** variableListFind(struct VariableList* varlist, const char* find); struct VariableList* variableListCreate(); struct VariableList variableListInit(); bool variableListFinalize(struct VariableList* varlist); bool variableListFree(struct VariableList* varlist); unsigned long variableListLink(struct VariableList* varlist, struct Variable* var); long variableListIndex(struct VariableList* varlist, struct Variable** ptr); unsigned long variableListUnLink(struct VariableList* varlist, struct Variable** ptr);
Dulces Lunas!¡.