¿Y si creamos un lenguaje de programación? [ACTUALIZADO] página 2

tal vez mis estructuras de mi CSxript que estoy haciendo te sirvan (por ahora me concentro en funciones y variables)...
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!¡.