/*Decide si el siguiente caracter leido pertenece a 'Ch'.
* consume el caracter leido
*Deja el resultado accesible en 'result'*/
static bool is_the_next_char (Lexer *input, const char *ch){
bool result = false;
bstring taken = NULL;
/*Pre:*/
assert (input != NULL);
/*Leo el siguiente caracter para ver si pertenece a 'ch'*/
if (!lexer_is_off (input)){
lexer_next_char (input, ch);
/*si (leyo algo) ´o´ (no EOF y no leyo nada)*/
if (!lexer_is_off (input)){
taken = lexer_item (input);
/*Decide si leyo el caracter perteneciente a 'ch'*/
if ((blength (taken) > 0)){
result = true;
}
/*libero el puntero despues de usarlo*/
bdestroy (taken);
}
}
return result;
}
/* Lee todo un edge de `input' hasta llegar a un fin de línea o de archivo*/
edge *parse_edge(Lexer *input){
edge *result = NULL;
u32 x = 0; /*nodo x*/
u32 y = 0; /*nodo y*/
u32 cap = 0; /*capacidad de xy*/
/*Pre:*/
assert(input != NULL);
assert(!lexer_is_off(input));
/*No se debe encontrar al comienzo ningun caracter distinto a 'DIGIT'*/
if (!is_the_next_char(input, ALPHA BLANK)){
/*asigno el 1er argumento parseado a 'x'*/
its_ok = parse_argument(input, x);
if (its_ok && is_the_next_char(input, WHITE_SPACE)){
/*asigno el 2do argumento parseado a 'y'*/
its_ok = parse_argument(input, y);
if (its_ok && is_the_next_char(input, WHITE_SPACE)){
/*asigno el 3er argumento parseado a 'cap'*/
its_ok = parse_argument(input, cap);
}
}
/* Si se parseo todo bien, creo el nuevo edge con los valores*/
if (it_ok){
result = edge_new(x, y, cap);
}
}
return result;
}
/* Consume el fin de línea.
* Indica si encontro basura antes del fin de línea*/
int parse_next_line (Lexer *input){
bool result = PARSER_OK; /*si es EOF (o el sig char es '\n'), sera true*/
bstring taken = NULL; /*caracteres leidos*/
/*Pre:*/
assert(input != NULL);
/*consumo toda la basura anterior al primer '\n' (o EOF)*/
taken = next_bstring (input, END_LINE);
/*si leyo algo, entonces taken no es nulo*/
if (taken != NULL){
result = PARSER_ERR;
bdestroy (taken);
return result;
}
/*INTERNAS*/
/*Parsea un argumento de los ingresados.
* Si no hubo error, asigna el argumento parseado en 'arg' y retorna PARSER_OK
* Si hubo error, no asigna nada a 'arg' y retorna PARSER_ERR
* El llamador se encarga de liberarlo.
*/
static int parse_argument (Lexer *input, u32 arg){
int result = PARSER_ERR; /*retorno (error al menos que todo salga bien)*/
bstring barg = NULL; /*argumento leido en tipo bstring*/
char * sarg = NULL; /*argumento leido convertido a string*/
assert(input != NULL);
if (!lexer_is_off (input)){
/*leo hasta el siguiente caracter distinto de 'DIGIT'*/
barg = next_bstring (input, ALPHA BLANK);
if (barg != NULL){
/* lo convierto a string*/
sarg = bstr2cstr (barg, '\0');
if (sarg != NULL){
/* lo convierto a u32*/
arg = (u32) atoi(sarg);
result = PARSER_OK;
/*destruyo sarg*/
bcstrfree (sarg);
}
/*destruyo barg*/
bdestroy (barg);
}
}
return result,
}
/*lee el siguiente item.
* Consume todo caracter hasta encontrar alguno perteneciente a 'str'.
*Deja el resultado accesible en 'result'. El llamador se encarga de liberarlo*/
static bstring next_bstring (Lexer *input, const char *str){
bstring result=NULL;
/*Pre:*/
assert (input != NULL);
/*Leo todos los caracteres anteriores y no pertenecientes a 'str'*/
if (!lexer_is_off (input)){
lexer_next_to (input, str);
/*si (leyo algo) ´o´ (no EOF y no leyo nada)*/
if (!lexer_is_off (input)){
result = lexer_item(input);
/*Si no leyo ningun caracter, destruyo el puntero.
* Esto pasa cuando el caracter inmediato a leer pertenece a str
* y el item es vacio*/
if (blength (result) == 0){
bdestroy (result);
result=NULL;
}
}
}
return result;
}
int parse_string (const string_t client_string, list_s lista) {
string_t almost_done = NULL;
string_t done = NULL;
FILE * strf = NULL;
int result = CODE_OK;
assert (client_string != NULL && lista != NULL);
strf = fmemopen (client_string, strlen(client_string) + 1, "r");
if (strf != NULL) {
Lexer * l = lexer_new (strf);
lexer_next_to (l, "\n");
almost_done = lexer_item (l);
if (strncmp (client_string, almost_done, strlen (client_string) - 2) != 0)
return BAD_EOL;
lexer_destroy (l);
fclose (strf);
if (strlen (almost_done) > 1 && almost_done != NULL) {
strf = fmemopen (almost_done, strlen(almost_done), "r");
if (strf != NULL) {
Lexer * j = lexer_new (strf);
lexer_next_to (j, "\r");
done = lexer_item (j);
lexer_destroy (j);
fclose (strf);
if (strlen (done) > 1 && done != NULL) {
strf = fmemopen (done, strlen(done), "r");
if (strf){
string_t valid_elem = NULL;
Lexer * p = lexer_new (strf);
while (!lexer_is_off (p)) {
lexer_next (p, SUPERALPHANUMERIC);
valid_elem = lexer_item (p);
list_adjoin_back (lista, valid_elem);
lexer_skip (p, BLANK);
}
lexer_destroy (p); p = NULL;
fclose (strf);
}
else {
fprintf (stderr, "fmemopen");
result = INTERNAL_ERROR;
}
}
else {
if (done != NULL)
result = STRING_VOID;
else
result = INTERNAL_ERROR;
}
}
else {
fprintf (stderr, "fmemopen");
result = INTERNAL_ERROR;
}
}
else {
if (almost_done != NULL)
result = STRING_VOID;
else
result = INTERNAL_ERROR;
}
if(almost_done != NULL) {
free (almost_done); almost_done = NULL;
}
if(done != NULL) {
free (done); done = NULL;
}
}
else {
fprintf (stderr, "fmemopen");
result = INTERNAL_ERROR;
}
return result;
}
