Comunidad de diseño web y desarrollo en internet

Autómatas en Flash, reconocedor de sintaxis

Un autómata o reconocedor de lenguajes es una maquina cuya entrada pertenece a un alfabeto, y cuya salida es el conjunto de 2 valores que se pueden denotar como: “reconozco” o “no reconozco”.

Cuando la maquina produce el valor “reconozco”, significa que acepta la sentencia.

Y eso??

Pues bien, este concepto significa que si le damos una cadena cualquiera esta va a ser reconocida o no dependiendo de que se le haya especificado al autómata que reconozca en realidad que se quiere representar.

Por ejemplo si hacemos un reconocedor de variables, nosotros sabemos que una variable no debe comenzar por un numero y que algunos lenguajes admiten ciertos caracteres al inicio de estas como por underline ‘_’, o dólar ‘$’ (en el caso de php), o que pueden comenzar simplemente por caracteres; después de esta primer carácter lo siguiente puede ser un carácter o un numero, o combinación de estos con símbolos.

Ahora imaginemos que ya tenemos nuestro autómata que reconoce variables hecho y que introducimos las siguientes cadenas:

    Hola -> cadena reconocida como variable
    _num -> cadena reconocida como variable
    $cad -> cadena reconocida como variable
    1enun -> cadena NO reconocida como variable

Como se puede apreciar hemos validado las siguientes cadenas para el supuesto de que son variables

La forma de reconocer

Como se describió mas arriba lo que se ingresa (o entradas del autómata) son cadenas, pero el programa en una forma básica debe de ser capaz de destruir esta cadena en el sentido de que debe de separar carácter por carácter y evaluar cada una de estas si siguen una secuencia determinada para un tipo de realidad a representar. Por ejemplo:

    myCad -> m y C a d

En este caso la realidad a representar es el de una variable.

La lógica

Ya que nuestro intérprete no será implementado (en este caso) para que reconozca directamente cadenas ya definidas como en el caso del .fla “syntax highlight”, que examina directamente cadenas como: function, new, etc para darle un color; el nuestro reconocerá cada carácter (después de haber desmenuzado la cadena) por medio de su código ASCII de esa manera se determina si lo que se esta evaluando es una cadena, un digito o un símbolo en especial.

Comenzando con el código

Todos sabemos de alguna u otra manera el código ASCII, por ejemplo

Mayusculas

 

Minusculas

 

Numeros

 

Símbolos especiales

A = 65

 

a = 97

 

0 = 48

 

_ = 95

 

 

 

$ = 36

Z = 90

 

z = 122

 

9 = 57

 

 

Como ya se ha estado adelantando el código ASCII aquí representado es para nuestro autómata reconocedor de variables, ahora que tal implementarlo todo en funciones:

function isAlpha(cad:String):Boolean {
// comparacion, si el codigo ascii del caracter se encuentra
// entre 'a' (97) y 'z' (122); entre 'A' (65) y 'Z' (90).

if ((ord(cad)>=97 && ord(cad)<=122) || (ord(cad)>=65 && ord(cad)<=90)) {
return true;
} else {
return false;
}
}
Los comentarios dentro de la función hablan por si solos. El retornar true es si en el caso de que el código ASCII del carácter evaluado pertenece a la función, y el false lo contrario como indicador de error.

Algo muy similar se hará para las demás funciones.

Función para saber si el carácter a evaluar es un digito:

function isDigit(cad:String):Boolean {
// comparacion, si el codigo ascii del caracter se encuentra
// entre '0' (48) y '9' (57)

if (ord(cad)>=48 && ord(cad)<=57) {
return true;
} else {
return false;
}
}
Función para saber si el carácter a evaluar es un símbolo especial:
function isSimbol(cad:String):Boolean {
// comparacion, si el codigo ascii del caracter se encuentra
// entre '_' (95) y '$' (36)

if (ord(cad) == 95 || ord(cad) == 36) {
return true;
} else {
return false;
}
}
Y para hacer estas funciones reutilizables las meteremos en un archivo fAscii.as (versión 7) fAscii_f6.as (versión f6), ambos son lo mismo:
function isAlpha(cad:String):Boolean {
// comparacion, si el codigo ascii del caracter se encuentra
// entre 'a' (97) y 'z' (122); entre 'A' (65) y 'Z' (90).

if ((ord(cad)>=97 && ord(cad)<=122) || (ord(cad)>=65 && ord(cad)<=90)) {
return true;
} else {
return false;
}
} function isSimbol(cad:String):Boolean {
// comparacion, si el codigo ascii del caracter se encuentra
// entre '_' (95) y '$' (36)

if (ord(cad) == 95 || ord(cad) == 36) {
return true;
} else {
return false;
}
} function isSimbol(cad:String):Boolean {
// comparacion, si el codigo ascii del caracter se encuentra
// entre '_' (95) y '$' (36)

if (ord(cad) == 95 || ord(cad) == 36) {
return true;
} else {
return false;
}
}

El .fla

Ya tenemos las funciones que nos ayudaran a determinar por que camino vamos, ahora comencemos con el .fla.

Dentro de un documento de 225x80px (medidas que le di yo) creamos 2 capas, una con el nombre de “AS”, es la que tendrá el código para el autómata y quien llamara a fASCII_f6.as. Y otra capa para colocar una caja de introducción de texto y un botón cualquiera.

En la capa AS, colocaremos el siguiente código que nos ayudar a reconocer el autómata

#include "fAscii.as"
function automataVar(cad:String):Void {
var i, long, caso:Number;
// contador, longitud de cadena, case del switch
var error, stace:Boolean;
// error: variable que nos dira si se produjo un error en la comparcion de algun caracter
// stace: determina si se acepta o no la cadena (variable)

caso = 0;
error = false;
stace = false;
i = 0;
long = cad.length-1;
// longitud de la palabra, -1 nunca debe de faltar para restar la cadena bacia
while ((i<=long) && !error) {
stace = false;
switch (caso) {
case 0 :
if (isAlpha(cad.charAt(i)) || isSimbol(cad.charAt(i))) {
caso = 1;
stace = true;
} else {
error = true;
}
break;
case 1 :
if (isAlpha(cad.charAt(i)) || isSimbol(cad.charAt(i)) || isDigit(cad.charAt(i))) {
caso = 1;
stace = true;
} else {
error = true;
}
break;
}
i++;
}
if (stace) {
trace("variable correcta");
} else {
trace("No es una variable");
}
}
Luego a la caja de introducción de texto le ponemos como valor en el campo var: “texto”, (sin las comillas).
Y al botón el siguiente código:
on (release) {
automataVar(texto);
}

Ya esta listo nuestro autómata para poder ser usado, ahora falta que lo pruebes.

Más ejemplos

De esta manera se puede hacer autómatas para:

  • Reconocer un IP: 127.0.80.5
  • Fechas en formato: dd/mm/aa, d/m/a , dd/m/aaaa , d/mm/aaa , etc.
  • Un numero real: 1, 1.23, 897.456, 12E-2, -45.67E+2, etc.
  • Hora, etc

Salu2

¿Sabes SQL? ¿No-SQL? Aprende MySQL, PostgreSQL, MongoDB, Redis y más con el Curso Profesional de Bases de Datos que empieza el martes, en vivo.

Descargar Archivo

Publica tu comentario

El autor de este artículo ha cerrado los comentarios. Si tienes preguntas o comentarios, puedes hacerlos en el foro

Entra al foro y participa en la discusión

o puedes...

¿Estás registrado en Cristalab y quieres
publicar tu URL y avatar?

¿No estás registrado aún pero quieres hacerlo antes de publicar tu comentario?

Registrate