Mensajes

Hola a todos, en estas vacaciones me he dedicado a escribir un intérprete para un lenguaje de programación, el cuál llamé "Yare".

Está escrito en C, con ayuda de lex y yacc.

El lenguaje que estoy haciendo aún es muy limitado, pero ya tiene algunas cosas algo "rescatables", como por ejemplo:

- Ciclos: for, while, do-while, unless.
- Condicional if y algunas expresiones se pueden procesar así:

Código (c) [Seleccionar] Expandir

expresion == expression && sentencia;

Un ejemplo:

Código (cpp) [Seleccionar] Expandir

1 == 1 && "Ok\n";
-Sentencia tipo "read(var)"
-Inicialización con valor aleatorio, ejemplo:

Código (cpp) [Seleccionar] Expandir

x = ?;

- Lo he hecho bastante "rico" en comentarios, es decir, se admiten comentarios de la forma

Código (cpp) [Seleccionar] Expandir

/* hjkhjkasd
asdasd
*/

Código (cpp) [Seleccionar] Expandir

rem Comentario de una sóla línea

Código (cpp) [Seleccionar] Expandir

# Comentario de una sóla línea

Código (cpp) [Seleccionar] Expandir

-- Comentario de una sóla línea

Código (cpp) [Seleccionar] Expandir

// Comentario de una sóla línea

Código (cpp) [Seleccionar] Expandir

:: Comentario de una sóla línea

- Caracteres especiales en la sentencia "puts(string)", los mismos que en C:
\n, \t, \s(este es de Perl), \b, \r, \f.
Añadí uno propio así:
\q el cuál inserta una doble comilla '"'.

- Además añadí unos caracteres de escape de nueva línea numéricos, es decir.

Código (cpp) [Seleccionar] Expandir

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
y así hasta el 9.

No hay tipos de datos por ahora, el tipo de dato que manejo es "double".

Hay 26 variables por default, las variables son de la "a" a la "z" y no es sensible a mayúsculas y minúsculas. Estas variables siempre están ahí disponibles.

-Se pueden definir variables propias de este modo:

Código (cpp) [Seleccionar] Expandir

:suma: = 2^3; ó así:

Código (cpp) [Seleccionar] Expandir

declare(:suma:, 2^3);

Código (cpp) [Seleccionar] Expandir

declare(:suma:);

Los identificadores pueden ser bastante flexibles, ejemplo:

Código (cpp) [Seleccionar] Expandir

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

Se pueden definir bloques de código:

Código (cpp) [Seleccionar] Expandir

{
  sentencias...
}

-Constantes numéricas:
número pi, número e, logaritmo en base 2 de el número e, y varias más, se pueden utilizar así:

Código (cpp) [Seleccionar] Expandir

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

-Operadores:
+, -, *, /, ^, %, <<, >>, |, &, &&, ||, ! y ~ para negación, XOR.

-Funciones matemáticas:

Código (cpp) [Seleccionar] Expandir

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.

-Operadores de posdecremento y posincremento, de esta manera:

Código (cpp) [Seleccionar] Expandir

a = 1;
a+@;
a-@;

ó incr(variable), decr(variable)

-Operador variable, lo que llamé operador variable no es más que un operador global que puede ser modificado, algo así:

Código (cpp) [Seleccionar] Expandir

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

Y que luego pueda ser usado de esta manera:

Código (cpp) [Seleccionar] Expandir

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

¿Para qué podría servir esto? no lo sé

-Inicialización por medio de smileys....  , algo así:

Código (cpp) [Seleccionar] Expandir

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

-Sentencia break para los ciclos, aún no hallo como implementar la sentencia continue.

-Ciclo foreach de esta manera:

Código (cpp) [Seleccionar] Expandir

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

-Sentencia system(CADENA).

-Asignaciones flexibles:

Código (cpp) [Seleccionar] Expandir

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;

Todas ellas son equivalentes.

-Sentencias tipo assembly:

Código (cpp) [Seleccionar] Expandir

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

-Sentencia "swap" para intercambiar valores:

Código (cpp) [Seleccionar] Expandir

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


-Sentencia exit:

Código (cpp) [Seleccionar] Expandir

exit(-1);

-Sentencia read(variable) para leer desde el teclado, ejemplo:

Código (cpp) [Seleccionar] Expandir

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

-Asignaciones abreviadas:

Código (cpp) [Seleccionar] Expandir

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


-Función par(expr) para saber si el número resultado de la expresión es par.

-Definición de procedimientos por el usuario, en la forma:

Código (cpp) [Seleccionar] Expandir

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


-Soporta recursión, obviamente no tan flexible, un ejemplo de cálculo del factorial con algoritmo recursivo:

Código (cpp) [Seleccionar] Expandir

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

.


Da por resultado 120.

La ejecución de algunos programas no es tan lenta, por ejemplo, calculemos el número pi en perl y luego calculemoslo en Yare.

Código (perl) [Seleccionar] Expandir

#!/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");


Código [Seleccionar] Expandir

3.14159165358978

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


Ahora en Yare:

Código (c) [Seleccionar] Expandir

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


Código [Seleccionar] Expandir

pi = 3.141592

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


Los tiempos de ejecución son muy similares. Obviamente no pretendo decir que la calidad de mi código es superior o si quiera igual que el de Perl, sería una estupidez, pero bueno... .
Estas son algunas cosas que he implementado en Yare, es muy muy limitado, pero bueno, quizás alguien quiera hacerlo crecer junto conmigo.

Lo primero en qué hay que pensar cuando se quiere hacer un lenguaje es "¿para qué va a servir?", "¿qué objetivo tiene?", yo no tengo objetivo, sólo aprender, ver cómo funcionan las cosas, y he aprendido muchisimo, no todo ha sido "miel sobre ojuelas", he batallado mucho con esto, han sido horas y horas de programar y a veces de dedicarle un día entero a algo y ver al final que las cosas no funcionan, y ni modo, a seguir adelante con otra cosa.

Por ahora estoy añadiendo soporte para arrays, pero les soy sincero, ya me aburrí de esto, porque son muchas horas dedicadas a esto y tengo otras cosas que hacer .


Entonces ahí está la petición, si alguien quiere unirse a desarrollar esto, yo encantado.

Saludos.

Pues la pila es totalmente nueva ..., esperemos y dure bastante.

Muchas gracias, entonces procederé a cargarla. Saludos

Hola a todos.

Recién compré una pila o bateria para mi laptop, según lo que me dijeron, duraba hasta 6 horas la pila, ayer que la usé por primera vez después del primer ciclo de carga (14 horas) me duró casi 4 horas. El manual dice para alcanzar su máximo rendimiento se deben realizar de 3 a 4 ciclos de carga/descarga siendo el de carga de 14 horas..... pero les soy honesto, me da miedo, jaja.

Qué piensan?, que por ser la primera carga/descarga sólo me duró 4 horas o que con más ciclos durará más según el manual? ....


PD: La probé sobre linux, no he visto el rendimiento sobre Windows.

Sí, al uso de && y || en batch y en algunos lenguajes script se le llama ejecución condicional, podrías buscar un post que escribí sobre ello.

Código (bash) [Seleccionar] Expandir

cd dir 2> nul && (
   echo Es dir.
) || (
   echo No es dir.
)

Otra sería usar el comando pushd y popd para regresarse luego que ingreses al directorio.

A ver si funciona esto...

Código (bash) [Seleccionar] Expandir

pushd dir 2> nul && (
    echo Es dir
    popd
) || (
   echo No es dir.
)

Lo mejor sería que usaras la librería gmp para esto, pero si es para un factorial, podrías checar el siguiente enlace:

http://mailman.linuxchix.org/pipermail/courses/2002-November/001043.html

No estoy en Windows, pero algo así debería funcionar, bueno, quizás :p

Código (bash) [Seleccionar] Expandir

cd dir && (
    echo Es dir
) || (
    echo No es un dir...
)

Saludos.

Perl.

Solo hay que definir las variables antes de definir la función:

Código (bash) [Seleccionar] Expandir

#!/usr/bin/env bash
edad=21

function algo() {
read -p "Edad: " edad
}

echo -e "Antes de llamar a función: ${edad}";
algo;
echo -e "Después de llamar a función: ${edad}";


[ -f "$in" ] && echo -e "Es un archivo regular."
[ -d "$in" ] && echo -e "Es un directorio."

Creo que con eso basta.

Tienes que pensar en "algo" en donde guardar otro "algo" y en cómo se va a "ordenar" o "estructurar", por ejemplo, una TAD llamada "bolsa" que contenga elementos de cualquier tipo, por ejemplo.

Solo debes imaginartelo.

Ahora, la tienes más fácil por que es en C++ y tienes sobrecarga de operadores que te permitirá definir de una manera característica las operaciones que se realizarán con esa nueva TAD.

Saludos.