Foro de elhacker.net

expresion == expression && sentencia;

1 == 1 && "Ok\n";

x = ?;

/* hjkhjkasd
asdasd
*/

rem Comentario de una sóla línea

# Comentario de una sóla línea

-- Comentario de una sóla línea

// Comentario de una sóla línea

:: Comentario de una sóla línea

puts("Hola\1mundo") <- Haría que se insertara un \n
puts("Hola\2mundo") <- Haría que se insertara dos \n
puts("Hola\3mundo") <- Haría que se insertara tres \n
 

:suma: = 2^3;

declare(:suma:, 2^3);

declare(:suma:);

: _Hola mundo # 123342432 : = 123;
printn(: _Hola mundo # 123342432 :);

{
   sentencias...
}

printn(cos(const.pi^2));

factorial(expr), abs(expr), ln(expr), cos(expr), sin(expr), tan(expr), atan(expr), asin(expr), acos(expr), floor(expr), sinh(expr), sumatoria(expr, expr), etc.

a = 1;
a+@;
a-@;
 
ó incr(variable), decr(variable)

_@_= *;
_@_ = /;
_@_ = -;
etc...

_@_ = *;
printn(1 + 2 _@_ 3);
 

x = :);   # Lo inicializa a 1
x = :|;  # Lo inicializa a 0
x = :(;  # Lo inicializa a -1.

foreach(1 ... factorial(5), k) {
	printn(k);
}

let x to 1+2;
set x to 1+2;
move 1+2 to x;
x = 1+2;
mov x, 1+2;
x <- 1+2;
let x = 1+2;
set x = 1+2;
x := 1+2;
 

mov x, factorial(6);
sub x, -123;
add x, 1+2;

x = 1;
y = 2;
x <-> y;
 

exit(-1);

read(x);
for i = 0, i < x, +1 {
	printn(i);
}

x += 1;
x -= 1;
x *= 1;
x ^= 3;
x /= 2;
x <<= 1;
x >>= 1;
x |= 1;
x &= 1;
x %= 2;
 

proc $suma$ {
	a += b;
	# Demás sentencias ...
}
 
a = 1;
b = 2;
 
# Imprime 3
# El valor retornado por el procedimiento o función es
# el resultado de la última sentencia o expresión.
printn(call $suma$);
 

# Intento de recursion
proc $factorial$ {
	if(a != 1) {
		r *= a;
		a-@;
		call $factorial$;
	}
}
 
# Calculando el factorial de 5:
a = 5;
r = 1;
 
call $factorial$;
printn(r);
 
.
 

#!/usr/bin/env perl
my $suma = 0.0;
my $i = 0.0;
for($i = 1; $i <= 1000000; $i++) {
	$suma += (-1)**($i + 1)/(2 * $i - 1);
}
$suma *= 4.0;
print($suma . "\n");
 

3.14159165358978

real	0m0.646s
user	0m0.572s
sys	0m0.004s

:suma: = 0;
for i = 1, i <= 1000000, +1 {
	:suma: += (-1)^(i + 1)/(2 * i - 1);
}
:suma: *= 4.0;
puts("pi = ");
printn(:suma:);
.
 

pi = 3.141592

real	0m0.641s
user	0m0.564s
sys	0m0.000s

:var1: = 'hola ';
:var2: = 'mundo!';
printn(:var1: + :var2:);
printn(:var1: . :var2:);
printn(:var1::var2:);
var2 = 'Esto es una variable?';

print("hola! ", : variable :, " bye", "ok\n\4", 1 + 2.34545, -5, "etc....");

print_expression_list:
    print_expression_list ',' expression
    | {;} /* por si se escribe print() */

expression:
    constante_numerica
    | cadena
    | variable
    | ID

[$].+[$]				{
						strcpy(yylval.nameFunction, yytext);
						yylval.nameFunction[strlen(yylval.nameFunction)] = '\0';
						return FUNCNAME;
					}

 
#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);