Muy buenas recomendaciones, sin los bucles aumenta considerablemente el rendimiento, y ya que está es una función “base” o “hoja”, es una de esas que se ejecutan gran número de veces. Ya que me da las palabras, para luego hacer las comparaciones en el lenguaje.
Es interesante tener un limitante para evitar bucles infinitos, o casi (es lectura de un archivo).
La función __isLetter y __follow son para la parte:
Cuando entra el programa, el interprete esta en el estado 0, hay entra __isLetter, si es, sigue hasta juntar una palabra, hay __follow, si da negativo, es otro carácter, y hará lo que tenga que hacer, si no es ningún carácter especificado, da error y cierra el interprete.
Con lo qué, parte en estado 0, si es letra, pasa a estado 1 para juntar una palabra, y pasar a estado 2 para ver qué palabra, sino a estado de error. Si no es una letra, pasa a estado 3, revisa si es un carácter existente, sino, a estado de error.
Esa sería la lógica del interprete.
Cuando arme algo decente, lo subo a github, y ahí acepto colaboradores con derecho a editar el código (si se gana mi confianza para el proyecto, con colaboraciones como esta, gracias), si esta alguien interesado.
Por el momento, una prueba del funcionamiento del interprete, aún no tengo claro, bien, que sintaxis darle…
marco@marco:/d/Escritorio/Git/hispa$ cat hola.txt
print ("HolaMundo")
print ("QueTal")
print ("Probando")
print ("HolaMundoProbando1234567890")
marco@marco:/d/Escritorio/Git/hispa$ ./g hola.txt
HolaMundo
QueTal
Probando
HolaMundoProbando1234567890
Por último, está función es la que permite convertir un archivo de texto a una cadena:
char* __read(const char *file)
{
FILE *f = fopen(file,"rb");
fseek(f,0,SEEK_END);
long s = ftell(f);
fseek(f,0,SEEK_SET);
char *buffer = (char*)malloc((int)s);
fread(buffer,(int)s,1,f);
fclose(f);
return buffer;
}
Junto con el código fuente del pre prototipo:
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
char* __read(const char *file)
{
FILE *f = fopen(file,"rb");
fseek(f,0,SEEK_END);
long s = ftell(f);
fseek(f,0,SEEK_SET);
char *buffer = (char*)malloc((int)s);
fread(buffer,(int)s,1,f);
fclose(f);
return buffer;
}
bool __isLetter(char l) {
return (l >= '0' && l <='9') || (l >= 'A' && l <='Z') || (l >= 'a' && l <='z');
}
char* __follow(const char *const buffer,int *n)
{
int i=0;
while(__isLetter(buffer[i])) i++;
char *follow = (char*)malloc(i);
i=0;
while(__isLetter(buffer[i])){
follow[i] = buffer[i];
follow[i+1] = 0x00;
i++;
}
*n=i;
return follow;
}
bool __print(const char*const _string,int *n)
{
int i=0;
char const* string = _string;
if(*string=='('){
string++;
if(*string==0x22){
string++;
i=0;
puts(__follow(string,&i));
string+=i;
if(*string==0x22) { *n=i; return true; }
else return false;
}
}else if(*string==' '){
string++;
__print(string,n);
}else return false;
return true;
}
bool ___interpeter(const char*const buffer)
{
int i=0;
const char* copy = buffer;
// read first char on file
if(!__isLetter(copy[0])){
// Token reserved for system
if(copy[0]=='#'){
}else if(copy[0]=='/'){
}else{
puts("Character unknow!");
return false;
}
}
// read first follow on file
char *follow = __follow(copy,&i);
copy+=i;
// API std-hispa
int n=0;
if(!strcmp(follow,"print")){
__print(copy,&n);
copy+=n+5;
}else if(!strcmp(follow,"")){
}else if(!strcmp(follow,"")){
}else{
puts("Token unknow!");
return false;
}
if(copy[0]==0x0A) {
if(copy[1]=='\0') return true;
___interpeter(copy+1);
}
return true;
}
bool __interpeter(const char*const buffer)
{
int i=0;
const char * copy = buffer;
char *follow = __follow(copy,&i);
copy+=i;
if(!strcmp(follow,"print")){
if(copy[0]==' '||copy[0]=='('){
if(copy[1]==0x22){
free(follow);
copy+=2;
follow = __follow(copy,&i);
puts(follow);
free(follow);
copy+=i;
if(copy[0]==0x22){
if(copy[1]==0x0A)
copy+=2;
__interpeter(copy);
}
}
}else return false;
}else return false;
return true;
}
int main(int argc,char**argv)
{
char *buffer = __read(argv[1]);
___interpeter(buffer);
free(buffer);
return 0;
}
, es mejor que el mio, bueno, ojalá resiva muchos likes no como el mio