elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Recopilación Tutoriales y Manuales Hacking, Seguridad, Privacidad, Hardware, etc


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación General
| | |-+  ¿Y si creamos un lenguaje de programación? [ACTUALIZADO]
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: 1 [2] Ir Abajo Respuesta Imprimir
Autor Tema: ¿Y si creamos un lenguaje de programación? [ACTUALIZADO]  (Leído 8,730 veces)
BlackZeroX
Wiki

Desconectado Desconectado

Mensajes: 3.158


I'Love...!¡.


Ver Perfil WWW
Re: ¿Y si creamos un lenguaje de programación?
« Respuesta #10 en: 18 Julio 2012, 10:20 am »

tal vez mis estructuras de mi CSxript que estoy haciendo te sirvan (por ahora me concentro en funciones y variables)...

Código
  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <stdbool.h>
  6.  
  7. struct String;
  8. struct Variable;
  9. struct VariableList;
  10. struct Function;
  11.  
  12. struct Params;
  13. struct ParamsList;
  14. struct Instruction;
  15. struct InstructionList;
  16.  
  17. const long INVALID_INDEX = -1;
  18.  
  19. /*
  20. typedef struct Variable Variable ;
  21. typedef struct Function Function;
  22. typedef struct VariableList VariableList;
  23. */
  24.  
  25. struct String {
  26.    char* text;
  27.    size_t size;          //  Tamaño del bloque reservado (mas no el que se usa).
  28. };
  29.  
  30. struct Variable {    //  Define una varible.
  31.    enum FORMAT_VARIABLE{
  32.        _NONE_      = 0x0,
  33.        //  Tipos...
  34.        _CHAR_      = 0x1,
  35.        _INT_       = 0x2,
  36.        _FLOAT_     = 0x4,
  37.        _DOUBLE_    = 0x8,
  38.        _VOID_      = 0x10,
  39.  
  40.        //  Modificadores...
  41.        _UNSIGNED_  = 0x100,
  42.        _LONG_      = 0x200,    //  Se permite usar 2 veces solo en INT y 1 vez en DOUBLE.
  43.        _SHORT_     = 0x400,    //  Se permite usar 1 vez en INT.
  44.        _CONST_     = 0x800,    //  Solo una vez en todos los tipos de variables.
  45.        _PTR_       = 0x1000,   //  Indica que la variable es un puntero.
  46.        _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).
  47.        _STATIC_    = 0x3000    //  Se usa para que una variable no pierda su valor al salir de una funcion.
  48.    } a;
  49.    struct String name;         //  Nombre de la variable.
  50.    long flags;                 //  Tipo de variable (Es una combinacion de las enumeraciones superiores).
  51.    size_t size;                //  Tamaño en bytes de la variable.
  52.    void* value;                //  Valor.
  53. };
  54.  
  55. struct VariableList {           //  Lista de variables.
  56.    struct Function* parent;    //  Funcion padre donde estan alojadas las variables.
  57.    unsigned long count;        //  Cantidad de variables.
  58.    struct Variable** list;     //  Puntero a la lista de las funciones.
  59. };
  60.  
  61. struct Params {
  62.    enum FORMAT_PARAM {
  63.        _VARIABLE_ = 1,
  64.        _FUNCTION_ = 2,
  65.        //_VOID_ = 4
  66.    } a;
  67.    void* value;                //  Apuntador al parametro (Segun flags debera de realizarse un cast adecuado).
  68.    long flags;                 //  Tipo de parametro: variable, funcion...
  69. };
  70.  
  71. struct ParamsList {
  72.    struct Instruction* parent; //  A que instruccion pertenece este parametro?.
  73.    struct Params* list;        //  Lista d elos parametros.
  74.    size_t count;               //  Cantidad de parametros.
  75. };
  76.  
  77. struct Instruction {
  78.    enum {
  79.        //  Flags Predeterminados.
  80.        //_NONE_,             //  No es ninguna instruccion.
  81.  
  82.        //  Asignaciones.
  83.        _ASIGN_,            //  Asignacion (A = B).
  84.        _ASIGN_ADD_,        //  Asignacion con Sumatoria/Resta ( A += B, A >- B).
  85.        _ASIGN_ROL_,        //  Asignacion con dezplazamientode de N bits a la izquierda ( A <<= B).
  86.        _ASIGN_ROR_,        //  Asignacion con dezplazamientode de N bits a la derecha ( A >>= B).
  87.  
  88.        //  Comparaciones.
  89.        _EQUAL_,            //  Igual que (A == B).
  90.        _GREATTHAT_,        //  Mayor que (A > B).
  91.        _LESSTHAT_,         //  Menor que (A < B).
  92.        _GREATTHAT_EQUAL_,  //  Mayor o igual que (A >= B).
  93.        _LESSTHAT_EQUAL_,   //  Menor o igual que (A >= B).
  94.        _AND_,              //  A y B (A && B).
  95.        _OR_,               //  A o B (A || B).
  96.  
  97.        //  Operaciones Basicas (base 10).
  98.        _ADD_,              //  Resta/Suma (A+B).
  99.        _ADD_PRE_,          //  Resta/Suma -/+ 1 (++A, --A).
  100.        _ADD_POST_,         //  Resta/Suma -/+ 1 (A++, A--).
  101.        _MULTIPLY_,         //  Multiplicacion (A * B).
  102.        _MOD_,              //  Residuo de A entre B (A % B) (retorna un unsigned long long).
  103.        _DIV_,              //  A entre B (A / B) (Retorna un long double).
  104.  
  105.        //  Operaciones Binarias (base 2).
  106.        _ROL_,              //  Rotacion de N bits a la izquierda (A << N).
  107.        _ROR_,              //  Rotacion de N bits a la izquierda (A >> N).
  108.        _AND_BIT_,          //  A y B (A & B).
  109.        _OR_BIT_,           //  A o B (A | B).
  110.        _XOR_,              //  A xor B (A ^ B).
  111.        _NOT_               //  complemento binario (not A).
  112.    } a;
  113.    struct Function* parent;    //  A que funcion pertenece la instruccion?.
  114.    int opcode;                 //  De que tipo es la instruccion?.
  115.    struct ParamsList arg;      //  Lista de argumentos d ela funcion.
  116. };
  117.  
  118. struct InstructionList {
  119.    struct Function* parent;    //  A que funcion pertenece la lista de instrucciones?.
  120.    struct Instruction* list;   //  Lista de instruccion.
  121.    size_t count;               //  Cantidad de instrucciones contenidas.
  122. };
  123.  
  124. struct Function {
  125.    struct Function* stackCall; //  Pila del proceso (Quien llamo al proceso).
  126.    struct String name;         //  Nombre de la funcion.
  127.    struct VariableList* vars;  //  Lista de variables.
  128.    struct InstructionList code;//  Codigo de la funcion Cada linea representa una instruccion.
  129.    struct Variable ret;        //  Valor que retorno la funcion.
  130. };
  131.  
  132.  
  133. bool            stringInit(struct String* str);
  134. struct String*  stringCreate();
  135. char*           stringRedim(struct String* str, size_t size);
  136. bool            stringFinalize(struct String* str);
  137. bool            stringFree(struct String* str);
  138. struct Variable*        variableCreate(const char* name);
  139. bool            variableFree(struct Variable* var);
  140. bool            variableFreeList(struct Variable** varlist, size_t count);
  141. struct Variable**       variableListFind(struct VariableList* varlist, const char* find);
  142. struct VariableList*    variableListCreate();
  143. struct VariableList     variableListInit();
  144. bool            variableListFinalize(struct VariableList* varlist);
  145. bool            variableListFree(struct VariableList* varlist);
  146. unsigned long   variableListLink(struct VariableList* varlist, struct Variable* var);
  147. long            variableListIndex(struct VariableList* varlist, struct Variable** ptr);
  148. unsigned long   variableListUnLink(struct VariableList* varlist, struct Variable** ptr);
  149.  
  150.  

Dulces Lunas!¡.


« Última modificación: 20 Julio 2012, 20:46 pm por BlackZeroX (Astaroth) » En línea

The Dark Shadow is my passion.
gonzalo57

Desconectado Desconectado

Mensajes: 74



Ver Perfil
Re: ¿Y si creamos un lenguaje de programación?
« Respuesta #11 en: 25 Julio 2012, 12:37 pm »

Ojala lo termines pronto y pongas cursillos y etc..

te esta quedando  PERFECTO!  :D :D


En línea

@echo off
title Gonzalo57
color 5a
echo Estoy aprendiendo Batch :3
echo.
pause
cls
echo un saludo elhacker.net :)
pause > nul
leogtz
. . .. ... ..... ........ ............. .....................
Colaborador
***
Desconectado Desconectado

Mensajes: 3.069


/^$/


Ver Perfil WWW
Re: ¿Y si creamos un lenguaje de programación?
« Respuesta #12 en: 21 Marzo 2013, 08:11 am »

Terminé por así decirlo la versión 1.0 hace unos meses, les dejo las características que tiene incorporadas el lenguaje:

https://dl.dropbox.com/u/58795303/yare_doc.docx

Cualquier retroalimentación es bienvenida :)

El que desee el código fuente por favor me lo pida por mensaje privado.

Saludos!
En línea

Código
  1. (( 1 / 0 )) &> /dev/null || {
  2. echo -e "stderrrrrrrrrrrrrrrrrrr";
  3. }
  4.  
http://leonardogtzr.wordpress.com/
leogutierrezramirez@gmail.com
Páginas: 1 [2] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Lenguaje de programacion
Scripting
Geormarsch 4 4,416 Último mensaje 26 Octubre 2011, 01:08 am
por Geormarsch
lenguaje de programacion
Programación General
kakashi20 1 2,941 Último mensaje 2 Enero 2013, 05:06 am
por nelson dias
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines