Documentación de JLeng & JCalc

Última versión actualizada de JLeng & JCalc:

Versión 0.0.0.9

Próxima versión:

Versión 0.0.0.10

Ejemplos de capturas:

Nota: La página del artículo de la Documentación de JLeng & JCalc está en construcción.

JLeng: Lenguaje de programación. Significado: Jorge Lenguaje (J de Jorge y Leng de Lenguaje).

JLang: Lenguaje de programación. Significado: Jorge Languaje (J de Jorge y Lang de Language). Es el nombre en idioma inglés de JLeng en idioma español.

JCalc:  Calculadora y motor de cálculo. Significado: Jorge Calculadora (J de Jorge y Calc de Calculadora).

JLeng & JCalc: Software 2 en 1.

JSintaxis: Sintaxis del lenguaje de programación JLeng (principalmente) (pero no únicamente) (sino también del) motor de cálculo JCalc. Significado: Jorge Sintaxis.

Subsistemas secundarios (Proyectos futuros/Visión a largo plazo):

JmotorGraph: Motor gráfico. Significado: Jorge motor graphics (Jorge motor gráfico).

JUnicode: Codificación de caracteres. Significado: Jorge Unicode.

JProcDocText: Procesador de texto. Significado: Jorge Procesador de Documentos & Texto.

JOS: Sistema Operativo construido con el lenguaje de programación JLeng. Significado: Jorge Operating System. Actualmente en modo teórico e hipotético.

JLengGraph: Es la capa o modo del lenguaje de programación Jleng sobre el procesador de texto JProcDocText con modo formato nativo en su sintaxis JSintaxisGraph. Significado: Jorge Lenguaje Graphics (Jorge Lenguaje Gráficos).

JSintaxisGraph: Es la sintaxis con formato para el lenguaje de programación JLeng en su modo o versión JLengGraph para el procesador de texto JProcDocText. Significado: Jorge Sintaxis Graphics (Jorge Sintaxis Gráficos).

JLeng (Jorge Lenguaje), no confundir con:

• J
• Java
• JavaScript
• Julia

JCalc (Jorge Calculadora), no confundir con:

•  jCalc.net
• JCalc (Java Calculator)

JLeng

JLeng es un lenguaje de programación creado (desde cero) y desarrollado por Jorge Chaves Román.

JLeng tiene como motor de cálculo a JCalc, por lo que tiene soporte nativo de precisión arbitraria (número con muchas cifras).

JLeng tiene características que no tiene otros lenguajes de programación:

• Sintaxis única: JSintaxis, no imita a ninguna otra sintaxis sino es creada desde cero, además con la intención de ser menos ambigua que otros lenguajes de programación
• Precisión arbitraria nativa (soporta número con muchas cifras)
• Soporta espacios en identificadores de nombres (comandos de instrucciones, nombres de variables, nombres de constantes, nombres de funciones, etc) 
• Soporta iguales nombres de identificadores para casos simultáneos y paralelos (tiene soporte para nombrar de igual manera una variable que una constante o una función entre otros) 
• Soporta palabras reservadas en nombres de identificadores sin causar problemas técnicos mediante técnicas avanzadas, ya que no existe palabras reservadas (0 palabras reservadas), siendo las palabras reservadas palabras reservadas y no reservadas, ya que usa técnicas avanzadas para ello
• Sistema de Secuencias de escape novedoso: Tiene dos delimitadores pares/parejas, uno para indicar el inicio y otro para indicar el final
• Nuevo sistema de Coma flotante para los números decimales que no está basado en el estándar IEEE 754 sino en uno nuevo creado desde cero
• Etc...

Los paradigmas del JLeng:

• Innovador
• Potente
• Precisión arbitraria
• Sin ambigüedad o por lo menos lo menos posible en ambigüedades, para una mayor interpretación
• Flexibilidad de opciones disponibles en la sintaxis (varias opciones en varios casos, en otros casos no, sino fijo)
• Funcional
• Secuencial
• Orientado a objetos
• TUI (Textual User Interface) Y GUI (Graphical User Interface)
• Multi-propósito
• General
• Etc

JLeng está escrito en C++ (ya que un lenguaje de programación puede crear y generar otro lenguaje de programación si tiene la capacidad suficiente para realizarlo).

C++:

C++ es el lenguaje de programación en el que está escrito el lenguaje JLeng, y a su vez el motor de cálculo JCalc.

Recuerde que son dos lenguajes con 2 sintaxis por separado, la JSintaxis no imita exactamente a la del C++ sino un subconjunto de particularidades solamente pero adaptadas a la sintaxis del JSintaxis por lo que son 2 sintaxis separadas entre sí (sin relación alguna entre ellas).

Nota informativa: La JSintaxis (de JLeng) es una mejor sintaxis que la de la sintaxis de C++, ya que la JSintaxis genera menos ambigüedad que la del C++, aunque al principio puede generar un pelín de dificultad por ser novedosa en su estilo, aunque la curva de aprendizaje cueste un poco al principio pero baja según se va evolucionando sobre la asimilación de la misma, además puede ser un poco confusa al principio por ser más flexible que otras sintaxis en ciertos casos y ciertas tareas o características. Pero en fin no da falta de sabor la experiencia que se experimenta al usarla sobre otras sintaxis menos experimentadas sobre las características de las mismas para una mayor construcción de las gramáticas con su mayor eficiencia de ser menos ambiguas, solamente hay que experimentar y dejarse llevar por la experiencia sin negarse a crear etiquetas negativas por una crítica precipitada, por lo menos da que alguna que otra oportunidad para ver como evoluciona y como se adapta según el tiempo, aparte de ver como asimilas los conceptos como experimental y experiencia.

JCalc

JCalc es un motor de cálculo que soporta nativamente la precisión arbitraria (número con muchas cifras).

La Precisión arbitraria:

La Precisión arbitraria soporta números naturales, números enteros, fracciones, decimales (decimales puros, decimales periódicos y decimales mixtos), complejos, entre otros tipos (números racionales, etc).

Nota: En algunas versiones alfas no soporta todos los tipos sino un subconjunto hasta que se implemente correctamente todos los tipos según la evolución de las versiones/ediciones/actualizaciones del módulo de cálculo según el tiempo para implementar correctamente cada una.

JCalc no soporta solamente la precisión arbitraria sino también otros tipos de datos para ciertos tipos de cálculos (como por ejemplo el tipo booleano (boolean o bool)).

La Precisión arbitraria:

La Precisión arbitraria es un motor de cálculo o módulo creado desde cero. Por lo que la Precisión arbitraria no contiene ninguna librería externa (ya que es creada desde cero), y además está adaptada a la sintaxis JSintaxis del JLeng.

JSintaxis (Sintaxis del JLeng)

Un "Hola mundo" en Jleng:

cout\,/Hola mundo\;/

Otra forma de un "Hola mundo" en JLeng:

"Hola mundo"\;/

 

Cómo funciona la JSintaxis en JLeng

Secuencia de escapes:

\.../

\.../ (... para indicar el contenido de secuencia de escape).

Los delimitadores pares para la secuencia de escapes: \ (para iniciar la secuencia de escapes) y / (para finalizar la secuencia de escapes).

Secuencia de escape para finalizar una instrucción en JLeng:

 \;/

 \;/ es para finalizar la/una instrucción.

Secuencia de escape para separar los argumentos o parámetros de una instrucción en una instrucción en JLeng:

\,/

\,/ es para separar argumentos dentro de una instrucción.

2 Ejemplos de una instrucción simple:

Un "Hola mundo" en Jleng:

cout\,/Hola mundo\;/

Otra forma de un "Hola mundo" en JLeng:

"Hola mundo"\;/

La instrucción "cout" (significa "console out" o "console output") imprime por pantalla en modo consola (en este caso un "Hola mundo"):

cout\,/Hola mundo\;/

El "Hola mundo" está separado del "cout" por una secuencia de escapes:

\,/

La instrucción "cout\,/Hola mundo" está finalizada por una secuencia de escapes:

\;/

2 instrucciones consecutivos:

cout\,/Hola mundo\;/cout\,/Adios mundo\;/

La instrucción (2 instrucciones consecutivos) "cout\,/Hola mundo\;/cout\,/Adios mundo\;/" se puede transformar en, ya que el intro (está disponible para nueva línea):

cout\,/Hola mundo\;/

cout\,/Adios mundo\;/

La instrucción (2 instrucciones consecutivos) "cout\,/Hola mundo\;/cout\,/Adios mundo\;/" se puede transformar en:

cout\,/Hola mundo\,/Adios mundo\;/

La instrucción siguiente es válida:

cout\,/Hola mundo\,/Adios mundo\;/

La instrucción siguiente es válida:

cout\,/Hola mundo\,/Adios mundo\,/...\;/

Nota: Se recomienda que el texto o contenido del comando o instrucción después de separador en formato \,/ sea para la forma inglesa, ya que para la forma española sea "cout lang\,/esp".

 

 

2 Ejemplos de una instrucción simple (en forma española):

Un "Hola mundo" en Jleng:

cout lang\,/esp\,/Hola mundo\;/

Otra forma de un "Hola mundo" en JLeng:

"lang=esp":"Hola mundo"\;/

El símbolo ":" (sin comillas) sirve para poder implementar metadatos o características a los textos y a las variables.

Otra forma de un "Hola mundo" en JLeng:

"lang=esp":"¡Hola mundo!"\;/

Otra forma de un "Hola mundo" en JLeng:

"lang=esp":"¿Hola mundo?"\;/

El formato sirve para indicar el idioma para una tarea o característica en concreto.

El formato soporta nativamente 2 idiomas (el inglés y el español (con la letra "ñ"/"Ñ")), aunque puede o podría soportar más en un futuro (como por ejemplo el francés con la letra "ç"/"Ç").

Nota sobre el alfabeto o los alfabetos o la codificación de caracteres básicos: Soporta como mínimo como base la codificación de caracteres 8 bits, ya que se está preparando para ello, aunque por encima soporte otras codificaciones (como por ejemplo JUnicode). Por lo que soporta la letra "ñ"/"Ñ" y la letra "ç"/"Ç" nativamente. Soporta 8 bits como base (mínimo), y soportará en un futuro a JUnicode con técnicas avanzadas.

Nota de bilingüismo: Está pensado la base de bilingüismo en lugar del monolingüismo anglicentrismo, digamos más flexibilidad lingüística para una mayor comunidad de desarrolladores de software internacionalización, aunque la traducción del mismo se deja fuera aparte.

Nota del interprete: El interprete soporta nativamente el bilingüismo aparte de soportar los 8 bits de los mapas de caracteres como base.

*Nota: A partir de aquí hay que actualizar la documentación para una nueva versión en concreto la del software en versión 0.0.0.8. Por lo que la información a partir de aquí está obsoleta en parte, en concreto la referente al idioma con el formato lang.

Ejemplo de comparación:

cout lang\,/ing\,/Hola mundo\;/

cout lang\,/esp\,/Hello world\;/

cout lang\,/fra\,/...\;/

Otra forma de un "Hola mundo" en JLeng (en futuras versiones):

"lang=esp":"context=pregunta":"format=negrita":"Hola mundo"\;/

A continuación, en algunas versiones está parcialmente implementadas, se recomienda en versiones futuras:

Variables:

Crear una variable genérica de tipo de Datos Abstracto Genérico con posibilidad de precisión arbitraria:

var asig\,/variable\,/valor de la variable\;/

 

var asig lang\,/ing\,/variable\,/valor de la variable\;/

var asig lang\,/esp\,/variable\,/valor de la variable\;/

 

var asig lang=i\,/variable\,/valor de la variable\;/

var asig lang=ñ\,/variable\,/valor de la variable\;/

Ejemplo de variable:

var asig\,/variable\,/Hola mundo\;/

 

Para mostrar la variable genérica:

cout var\,/variable\;/

cout var lang\,/ing\,/variable\;/

cout var lang\,/esp\,/variable\;/

 

cout var lang\,/i\,/variable\;/

cout var lang\,/ñ\,/variable\;/

Crear una variable de tipo de Datos para casos específicos con inicialización automática por defecto:

make var\,/tipo de Datos\,/variable\;/

make var lang\,/esp\,/tipo de Datos\,/variable\;/

Nota: "tipo de Datos" pueden ser de tipo:

• gen
• uchar
• linea_texto
• texto
• numero_nat
• numero_ent 
• ...

Nota: "tipo de Datos" pueden ser de tipo:

• gen (genérico)
• uchar (unsigned char) (8 bits)
• linea_texto
• texto
• numero_nat (naturales con precisión arbitraria)
• numero_ent (enteros con precisión arbitraria)
• ...

Nota: "linea_texto" estará en futuras versiones, en "linea_texto" no soportará el intro (nueva línea).

Nota: Actualmente está en desarrollo la implementación total de todos los caracteres de 8 bits, ya que se ha preferido un subconjunto temporal de caracteres de 8 bits, hasta completarse todos los caracteres de 8 bits. De momento la letra "ñ"/"Ñ" y la letra "ç"/"Ç" están implementadas, pero no las letras con diacríticos, entre otros caracteres o símbolos, cada versión se implementara algún que otro carácter hasta implementar a todos los caracteres, solo un poco de paciencia.

Para mostrar una variable de tipo de Datos específico:

cout var maked\,/tipo de Datos\,/variable\;/

 

cout var maked lang\,/esp\,/tipo de Datos\,/variable\;/

Para asignar una operación de cálculo en una variable:

asig oper var maked\,/tipo de Datos\,/variable\,/operación de cálculo\,/operando 1\,/operando 2\;/

asig oper var maked lang\,/esp\,/tipo de Datos\,/variable\,/operación de cálculo\,/operando 1\,/operando 2\;/

"operación de cálculo" puede ser los siguientes (entre otras, aún no documentadas totalmente) (nota: todavía no está implementada los diacríticos, por lo que no se pueden usar de momento tildes en las vocales, eso se espera para versiones futuras):

• suma
• resta
• multiplicacion
• cociente
• resto division
• division
• potencia
• raiz
• logaritmo
• mcd
• mcm

Funciones:

Ejemplo de llamada a una función.

call function\,/nombre de la función\,/argumento de la función\,/...\;/

Otra forma de llamada de función:

f\,/nombre de la función\,/argumento de la función\,/...\;/

Otra forma de llamada de función:

f()\,/nombre de la función\,/argumento de la función\,/...\;/

Nota: Puede haber uno o más de un argumento según el tipo de función. 

Ejemplos de funciones:

f\,/suma 1\,/5\;/

Da como resultado:

6

Ejemplos de funciones:

f\,/resta 1\,/5\;/

Da como resultado:

4

Ejemplos de funciones:

f\,/suma\,/5\,/2\;/

Da como resultado:

7

Ejemplos de funciones:

f\,/resta\,/5\,/2\;/

Da como resultado:

3

Ejemplos de funciones:

f\,/suma\,/5\,/2\,/1\,/...\;/

f\,/resta\,/5\,/2\,/1\,/...\;/

Ejemplos de funciones:

f\,/suma tipo\,/tipo de conjunto o tipo de Datos\,/5\,/2\;/

Ejemplo:

f\,/suma tipo\,/nat\,/5\,/2\;/

f\,/suma tipo\,/ent\,/5\,/-2\;/

"nombre de la función" puede ser:

• suma 1
• resta 1
• suma
• resta
• multiplicacion
• cociente
• resto division
• division
• potencia
• raiz
• logaritmo
• mcd
• mcm
• absoluto
• opuesto
• if_cifra
• if_cifra_nat
• if_cifra_par
• if_cifra_impar
• if_nat
• if_ent
• if_fracc
• if_dec

[...] Continuará...

Sentencias de control:

Sentencias de control:

• if
• if tipo
• if else
• if else tipo

Lo siguiente es un borrador:

Ejemplos de Sentencias de control:

if var\,/condición de la var (variable) sea verdadera\,/«bloque de instrucciones»\;/

Ejemplo:

if var\,/variable\,/«bloque de instrucciones»\;/

Ejemplos de Sentencias de control:

if tipo var\,/if_nat\,/condición de la var (variable) sea verdadera\,/«bloque de instrucciones»\;/

Ejemplo:

if tipo var\,/if_nat\,/variable\,/«bloque de instrucciones»\;/

[...] Continuará...

Bucles:

En versiones futuras soportará las siguientes características:

Tipos de bucles:

• while
• repeat
• for

Lo siguiente es un borrador:

El bucle while:

while var\,/condición de la var (variable) sea verdadera\,/«bloque de instrucciones»\;/

El bucle repeat:

repeat var\,/condición de la var (variable) sea verdadera\,/«bloque de instrucciones»\;/

El bucle for:

for var\,/«bloque de instrucciones de asig var»\,/«bloque de instrucciones de condiciones»\,/«bloque de instrucciones de actualizaciones de asig var»\,/«bloque de instrucciones»\;/

[...] Continuará...

Teclado:

La tecla mayúscula derecha se ha modificado su comportamiento para admitir nuevas características al software JLeng & JCalc: Permite nuevos caracteres al JLeng en concreto la parte de los 8 bits (la zona 8 bits para poder acceder/se de forma cómodo y nativamente).

Así que la tecla mayúscula derecha y la tecla mayúscula izquierda no comporta el mismo mecanismo de letras mayúsculas/minúsculas, por lo menos hasta encontrase una mejor manera de hacerse posible acceder de forma cómoda a la zona 8 bits de forma nativa.

Lo siguiente está en desarrollo:

Ejemplo para teclados que no incluyan la letra "ñ"/"Ñ" (como posibilidad temporal al menos):

Tecla mayúscula derecha + Tecla N.

Tecla mayúscula derecha + Tecla N = ñ.

Tecla mayúscula izquierda + Tecla mayúscula derecha + Tecla N = Ñ.

Ejemplo para teclados que no incluyan la letra "ç"/"Ç" (como posibilidad temporal al menos):

Tecla mayúscula derecha + Tecla C.

Tecla mayúscula derecha + Tecla C = ç.

Tecla mayúscula izquierda + Tecla mayúscula derecha + Tecla C = Ç.

[...] Continuará...