static list *
sequential_block (mvc *sql, sql_subtype *restype, list *restypelist, dlist *blk, char *opt_label, int is_func)
{
list *l=0;
dnode *n;
assert(!restype || !restypelist);
if (THRhighwater())
return sql_error(sql, 10, "SELECT: too many nested operators");
if (blk->h)
l = sa_list(sql->sa);
stack_push_frame(sql, opt_label);
for (n = blk->h; n; n = n->next ) {
sql_exp *res = NULL;
list *reslist = NULL;
symbol *s = n->data.sym;
switch (s->token) {
case SQL_SET:
res = psm_set_exp(sql, s->data.lval->h);
break;
case SQL_DECLARE:
reslist = rel_psm_declare(sql, s->data.lval->h);
break;
case SQL_CREATE_TABLE:
res = rel_psm_declare_table(sql, s->data.lval->h);
break;
case SQL_WHILE:
res = rel_psm_while_do(sql, restype, s->data.lval->h, is_func);
break;
case SQL_IF:
res = rel_psm_if_then_else(sql, restype, s->data.lval->h, is_func);
break;
case SQL_CASE:
reslist = rel_psm_case(sql, restype, s->data.lval->h, is_func);
break;
case SQL_CALL:
res = rel_psm_call(sql, s->data.sym);
break;
case SQL_RETURN:
/*If it is not a function it cannot have a return statement*/
if (!is_func)
res = sql_error(sql, 01,
"Return statement in the procedure body");
else {
/* should be last statement of a sequential_block */
if (n->next) {
res = sql_error(sql, 01,
"Statement after return");
} else {
reslist = rel_psm_return(sql, restype, restypelist, s->data.sym);
}
}
break;
case SQL_SELECT: { /* row selections (into variables) */
exp_kind ek = {type_value, card_row, TRUE};
reslist = rel_select_into(sql, s, ek);
} break;
case SQL_COPYFROM:
case SQL_BINCOPYFROM:
case SQL_INSERT:
case SQL_UPDATE:
case SQL_DELETE: {
sql_rel *r = rel_updates(sql, s);
if (!r)
return NULL;
res = exp_rel(sql, r);
} break;
default:
res = sql_error(sql, 01,
"Statement '%s' is not a valid flow control statement",
token2string(s->token));
}
if (!res && !reslist) {
l = NULL;
break;
}
if (res)
list_append(l, res);
else
list_merge(l, reslist, NULL);
}
stack_pop_frame(sql);
return l;
}
sql_rel *
rel_psm(mvc *sql, symbol *s)
{
sql_rel *ret = NULL;
switch (s->token) {
case SQL_CREATE_FUNC:
{
dlist *l = s->data.lval;
int type = l->h->next->next->next->next->next->data.i_val;
int lang = l->h->next->next->next->next->next->next->data.i_val;
ret = rel_create_func(sql, l->h->data.lval, l->h->next->data.lval, l->h->next->next->data.sym, l->h->next->next->next->data.lval, l->h->next->next->next->next->data.lval, type, lang);
sql->type = Q_SCHEMA;
} break;
case SQL_DROP_FUNC:
{
dlist *l = s->data.lval;
int type = l->h->next->next->next->next->data.i_val;
if (STORE_READONLY)
return sql_error(sql, 06, "schema statements cannot be executed on a readonly database.");
assert(l->h->next->type == type_int);
assert(l->h->next->next->next->type == type_int);
if (l->h->next->data.i_val) /*?l_val?*/
ret = rel_drop_all_func(sql, l->h->data.lval, l->h->next->next->next->data.i_val, type);
else
ret = rel_drop_func(sql, l->h->data.lval, l->h->next->next->data.lval, l->h->next->next->next->data.i_val, type);
sql->type = Q_SCHEMA;
} break;
case SQL_SET:
ret = rel_psm_stmt(sql->sa, psm_set_exp(sql, s->data.lval->h));
sql->type = Q_SCHEMA;
break;
case SQL_DECLARE:
ret = rel_psm_block(sql->sa, rel_psm_declare(sql, s->data.lval->h));
sql->type = Q_SCHEMA;
break;
case SQL_CALL:
ret = rel_psm_stmt(sql->sa, rel_psm_call(sql, s->data.sym));
sql->type = Q_UPDATE;
break;
case SQL_CREATE_TRIGGER:
{
dlist *l = s->data.lval;
assert(l->h->next->type == type_int);
ret = create_trigger(sql, l->h->data.lval, l->h->next->data.i_val, l->h->next->next->data.sym, l->h->next->next->next->data.sval, l->h->next->next->next->next->data.lval, l->h->next->next->next->next->next->data.lval);
sql->type = Q_SCHEMA;
}
break;
case SQL_DROP_TRIGGER:
{
dlist *l = s->data.lval;
ret = drop_trigger(sql, l);
sql->type = Q_SCHEMA;
}
break;
case SQL_ANALYZE: {
dlist *l = s->data.lval;
ret = psm_analyze(sql, l->h->data.lval /* qualified table name */, l->h->next->data.lval /* opt list of column */, l->h->next->next->data.sym /* opt_sample_size */);
sql->type = Q_UPDATE;
} break;
default:
return sql_error(sql, 01, "schema statement unknown symbol(" PTRFMT ")->token = %s", PTRFMTCAST s, token2string(s->token));
}
return ret;
}
sql_rel *
rel_psm(mvc *sql, symbol *s)
{
sql_rel *ret = NULL;
switch (s->token) {
case SQL_CREATE_FUNC:
{
dlist *l = s->data.lval;
int type = l->h->next->next->next->next->next->data.i_val;
int lang = l->h->next->next->next->next->next->next->data.i_val;
int repl = l->h->next->next->next->next->next->next->next->data.i_val;
ret = rel_create_func(sql, l->h->data.lval, l->h->next->data.lval, l->h->next->next->data.sym, l->h->next->next->next->data.lval, l->h->next->next->next->next->data.lval, type, lang, repl);
sql->type = Q_SCHEMA;
} break;
case SQL_DROP_FUNC:
{
dlist *l = s->data.lval;
dlist *qname = l->h->data.lval;
dlist *typelist = l->h->next->data.lval;
int type = l->h->next->next->data.i_val;
int if_exists = l->h->next->next->next->data.i_val;
int all = l->h->next->next->next->next->data.i_val;
int drop_action = l->h->next->next->next->next->next->data.i_val;
if (STORE_READONLY)
return sql_error(sql, 06, SQLSTATE(42000) "Schema statements cannot be executed on a readonly database.");
if (all)
ret = rel_drop_all_func(sql, qname, drop_action, type);
else {
ret = rel_drop_func(sql, qname, typelist, drop_action, type, if_exists);
}
sql->type = Q_SCHEMA;
} break;
case SQL_SET:
ret = rel_psm_stmt(sql->sa, psm_set_exp(sql, s->data.lval->h));
sql->type = Q_SCHEMA;
break;
case SQL_DECLARE:
ret = rel_psm_block(sql->sa, rel_psm_declare(sql, s->data.lval->h));
sql->type = Q_SCHEMA;
break;
case SQL_CALL:
ret = rel_psm_stmt(sql->sa, rel_psm_call(sql, s->data.sym));
sql->type = Q_UPDATE;
break;
case SQL_CREATE_TABLE_LOADER:
{
dlist *l = s->data.lval;
dlist *qname = l->h->data.lval;
symbol *sym = l->h->next->data.sym;
ret = create_table_from_loader(sql, qname, sym);
if (ret == NULL)
return NULL;
ret = rel_psm_stmt(sql->sa, exp_rel(sql, ret));
sql->type = Q_SCHEMA;
} break;
case SQL_CREATE_TRIGGER:
{
dlist *l = s->data.lval;
assert(l->h->next->type == type_int);
ret = create_trigger(sql, l->h->data.lval, l->h->next->data.i_val, l->h->next->next->data.sym, l->h->next->next->next->data.lval, l->h->next->next->next->next->data.lval, l->h->next->next->next->next->next->data.lval, l->h->next->next->next->next->next->next->data.i_val);
sql->type = Q_SCHEMA;
}
break;
case SQL_DROP_TRIGGER:
{
dlist *l = s->data.lval;
dlist *qname = l->h->data.lval;
int if_exists = l->h->next->data.i_val;
ret = drop_trigger(sql, qname, if_exists);
sql->type = Q_SCHEMA;
}
break;
case SQL_ANALYZE: {
dlist *l = s->data.lval;
ret = psm_analyze(sql, "analyze", l->h->data.lval /* qualified table name */, l->h->next->data.lval /* opt list of column */, l->h->next->next->data.sym /* opt_sample_size */, l->h->next->next->next->data.i_val);
sql->type = Q_UPDATE;
} break;
default:
return sql_error(sql, 01, SQLSTATE(42000) "Schema statement unknown symbol(%p)->token = %s", s, token2string(s->token));
}
return ret;
}
sql_rel *
rel_transactions(mvc *sql, symbol *s)
{
sql_rel *ret = NULL;
switch (s->token) {
case TR_RELEASE:
ret = rel_trans(sql, DDL_RELEASE, 0, s->data.sval);
break;
case TR_COMMIT:
assert(s->type == type_int);
ret = rel_trans(sql, DDL_COMMIT, s->data.i_val, NULL);
break;
case TR_SAVEPOINT:
ret = rel_trans(sql, DDL_COMMIT, 0, s->data.sval);
break;
case TR_ROLLBACK: {
dnode *n = s->data.lval->h;
assert(n->type == type_int);
ret= rel_trans(sql, DDL_ROLLBACK, n->data.i_val, n->next->data.sval);
} break;
case TR_START:
case TR_MODE:
assert(s->type == type_int);
ret = rel_trans(sql, DDL_TRANS, s->data.i_val, NULL);
break;
default:
return sql_error(sql, 01, "transaction unknown Symbol(" PTRFMT ")->token = %s", PTRFMTCAST s, token2string(s->token));
}
return ret;
}
int Material::MatReader(char *filename)
{
material *matpointer=NULL;
PFILE *p;
char cadena[256];
char cadena2[256];
char texname[256];
char *token;
char separadores [] = " \t";
int i,j;
int nmats=0; // Number of materials
int curmat=0; // Material currently being loaded
int ntextures;
p = pak_open(filename,"r");
if(!p) return -1;
while(pak_fgets(cadena,256,p))
{
if((cadena[0] == '\n') || (cadena[0] == '#')) continue; // Saltamos comentarios y líneas en blanco
token = strtok(cadena,separadores);
token2string(token,cadena2);
if(!strcmp(cadena2,"nmaterials")) // Leemos el número de materiales y seguimos
{
token = strtok(NULL,separadores);
token2string(token,cadena2);
nmats = atoi(cadena2);
matpointer = (material *) malloc(nmats * sizeof(material));
if(!matpointer) return -1;
continue;
}
else // En este caso hemos cogido el nombre de un material
{
if(!nmats)
{
sprintf (FANTASY_DEBUG_STRING, "Fallo al leer el fichero %s\n",filename);
Debug(DEBUG_LEVEL_ERROR);
return -1;
}
if(curmat >= nmats)
{
sprintf (FANTASY_DEBUG_STRING, "Error en el archivo %s. Tenemos más materiales de los definidos en nmats\n",filename);
Debug(DEBUG_LEVEL_ERROR);
return -1;
}
// Inicializamos algunos valores por defecto
matpointer[curmat].specular[0] = matpointer[curmat].specular[1] = matpointer[curmat].specular[2] = 0.0f;
matpointer[curmat].emission[0] = matpointer[curmat].emission[1] = matpointer[curmat].emission[2] = 0.0f;
matpointer[curmat].specular[3] = 1.0f;
matpointer[curmat].emission[3] = 1.0f;
matpointer[curmat].shininess = 0.0f;
// Empezamos con la juerga!
strcpy(matpointer[curmat].matname,cadena2);
token = strtok(NULL,separadores); // Ahora leemos si es estático o dinámico
token2string(token,cadena2);
if(!strcmp(cadena2,"static")) // Material estático
{
matpointer[curmat].shader_based = 0;
}
else if(!strcmp(cadena2,"shader")) // Shader based material
{
matpointer[curmat].shader_based = 1;
}
else
{
sprintf (FANTASY_DEBUG_STRING, "Material %s no valido. No es static ni shader\n",matpointer[curmat].matname);
Debug(DEBUG_LEVEL_ERROR);
return -1;
}
// En caso de ser un shader, lo siguiente son los ficheros de los shader
if(matpointer[curmat].shader_based == 1 )
{
token = strtok(NULL,separadores);
token2string(token,cadena2);
if(strcmp(cadena2,"standard")) // If shader_name == "standard", we are using the opengl pipeline
GLSL_LoadShader(&(matpointer[curmat].shader.vertexShader),cadena2, GLSL_VERTEX_SHADER);
else
matpointer[curmat].shader.vertexShader = 0;
token = strtok(NULL,separadores);
token2string(token,cadena2);
// There must always be a fragment shader
GLSL_LoadShader(&(matpointer[curmat].shader.fragmentShader),cadena2, GLSL_FRAGMENT_SHADER);
// CompileandLinkShader...
GLSL_CompileAndLinkShader(&(matpointer[curmat].shader.programObj),
matpointer[curmat].shader.vertexShader,
matpointer[curmat].shader.fragmentShader);
// GetBasicUniforms
GLSL_GetUniforms(&(matpointer[curmat]));
matpointer[curmat].shader.params.used=0; // no custom parameters to the shader
}
else // No shader, so let's fill the variables...
{
matpointer[curmat].shader.vertexShader = 0;
matpointer[curmat].shader.fragmentShader = 0;
matpointer[curmat].shader.programObj = 0;
}
token = strtok(NULL,separadores); // Ahora leemos si es opaco o transparente
token2string(token,cadena2);
if(!strcmp(cadena2,"opaque")) // Material opaco
{
matpointer[curmat].opaque = 1;
matpointer[curmat].blend_type=-1;
token = strtok(NULL,separadores); // Ahora leemos si es opaco o transparente
token2string(token,cadena2);
if(!strcmp(cadena2,"2sided")) // Material con 2 caras
{
matpointer[curmat].twosided = 1;
}
else if(!strcmp(cadena2,"1sided")) // Material con 2 caras
{
matpointer[curmat].twosided = 0;
}
else
{
sprintf (FANTASY_DEBUG_STRING, "Material %s no valido. No tiene 1 ni 2 caras\n",matpointer[curmat].matname);
Debug(DEBUG_LEVEL_ERROR);
return -1;
}
}
else if(!strcmp(cadena2,"transp")) // Material traslúcido
{
matpointer[curmat].opaque=0;
token = strtok(NULL,separadores); // Ahora leemos si es opaco o transparente
token2string(token,cadena2);
if(!strcmp(cadena2,"2sided")) // Material con 2 caras
{
matpointer[curmat].twosided = 1;
}
else if(!strcmp(cadena2,"1sided")) // Material con 2 caras
{
matpointer[curmat].twosided = 0;
}
else
{
sprintf (FANTASY_DEBUG_STRING, "Material %s no valido. No tiene 1 ni 2 caras\n",matpointer[curmat].matname);
Debug(DEBUG_LEVEL_ERROR);
return -1;
}
token = strtok(NULL,separadores); // Ahora leemos el tipo de blend
token2string(token,cadena2);
if(!strcmp(cadena2,"add")) // Blend aditivo
{
matpointer[curmat].blend_type=BLEND_ADD;
}
else if(!strcmp(cadena2,"blend")) // Blend normal
{
matpointer[curmat].blend_type=BLEND_BLEND;
}
else if(!strcmp(cadena2,"multiply")) // Blend multiplicativo
{
matpointer[curmat].blend_type=BLEND_MULTIPLY;
}
else if(!strcmp(cadena2,"sub")) // Blend sustractivo
{
matpointer[curmat].blend_type=BLEND_SUB;
}
else
{
sprintf (FANTASY_DEBUG_STRING, "Material %s no valido. El blend no es valido\n",matpointer[curmat].matname);
Debug(DEBUG_LEVEL_ERROR);
return -1;
}
}
else
{
sprintf (FANTASY_DEBUG_STRING, "Material %s no valido. No es opaque ni transp\n",matpointer[curmat].matname);
Debug(DEBUG_LEVEL_ERROR);
return -1;
}
// Hasta aquí tenemos el nombre del material, que es estático, su opacidad y el tipo de blend si aplica.
// Nos falta leer el número de texturas y las texturas
token = strtok(NULL,separadores);
token2string(token,cadena2);
ntextures= atoi(cadena2);
if(ntextures < 0)
{
sprintf (FANTASY_DEBUG_STRING, "Material %s no valido. No puede tener menos de 0 texturas\n",matpointer[curmat].matname);
Debug(DEBUG_LEVEL_ERROR);
return -1;
}
else if(ntextures == 0)
{
matpointer[curmat].textures=NULL;
matpointer[curmat].multitexblend=NULL;
matpointer[curmat].texcoordgen=NULL;
}
else if(ntextures == 1)
{
matpointer[curmat].textures = (int *) malloc (ntextures * sizeof(int));
matpointer[curmat].multitexblend = (int *) malloc ((ntextures) * sizeof(int));
matpointer[curmat].texcoordgen = (int *) malloc ((ntextures) * sizeof(int));;
matpointer[curmat].linearmultiplier = (float *)malloc((ntextures) * sizeof(float));
}
else
{
matpointer[curmat].textures = (int *) malloc (ntextures * sizeof(int));
matpointer[curmat].multitexblend = (int *) malloc ((ntextures) * sizeof(int));
matpointer[curmat].texcoordgen = (int *) malloc ((ntextures) * sizeof(int));
matpointer[curmat].linearmultiplier = (float *)malloc((ntextures) * sizeof(float));
}
matpointer[curmat].ntextures = ntextures;
// Cargamos las texturas
for(i=0;i<ntextures;i++)
{
token = strtok(NULL,separadores);
token2string(token,cadena2);
// La carga de la textura la haremos después de conocer si hay cubemap o no!
strcpy(texname,cadena2);
// Carga del tipo de coordenadas de textura
// En caso de usar shader, aunque se ignoren los tipos de coordenada, lo usamos
// para saber cuándo una textura es un cubemap...
token = strtok(NULL,separadores);
token2string(token,cadena2);
if((!strcmp(cadena2,"same")) || (!strcmp(cadena2,"uv")))
{
matpointer[curmat].texcoordgen[i]=TEXGEN_UV;
}
else if(!strcmp(cadena2,"eyelinear"))
{
matpointer[curmat].texcoordgen[i]=TEXGEN_EYE_LINEAR;
if(matpointer[curmat].shader_based == 1 )
{
sprintf (FANTASY_DEBUG_STRING, "Warning: el material %s está basado en shader, pero se ha seleccionado texgen tipo eyelinear. Pongo UV\n",matpointer[curmat].matname);
Debug(DEBUG_LEVEL_ERROR);
matpointer[curmat].texcoordgen[i]=TEXGEN_UV;
}
}
else if(!strcmp(cadena2,"objectlinear"))
{
matpointer[curmat].texcoordgen[i]=TEXGEN_OBJECT_LINEAR;
if(matpointer[curmat].shader_based == 1 )
{
sprintf (FANTASY_DEBUG_STRING, "Warning: el material %s está basado en shader, pero se ha seleccionado texgen tipo objectlinear. Pongo UV\n",matpointer[curmat].matname);
Debug(DEBUG_LEVEL_ERROR);
matpointer[curmat].texcoordgen[i]=TEXGEN_UV;
}
}
else if(!strcmp(cadena2,"spheremap"))
{
matpointer[curmat].texcoordgen[i]=TEXGEN_SPHERE_MAP;
if(matpointer[curmat].shader_based == 1 )
{
sprintf (FANTASY_DEBUG_STRING, "Warning: el material %s está basado en shader, pero se ha seleccionado texgen tipo spheremap. Pongo UV\n",matpointer[curmat].matname);
Debug(DEBUG_LEVEL_ERROR);
matpointer[curmat].texcoordgen[i]=TEXGEN_UV;
}
}
else if(!strcmp(cadena2,"cubemap"))
{
matpointer[curmat].texcoordgen[i]=TEXGEN_CUBE_MAP;
}
// Ahora podemos cargar la textura
if(matpointer[curmat].texcoordgen[i] != TEXGEN_CUBE_MAP)
{
matpointer[curmat].textures[i] = ConjuntoTexturas->CargaTextura(texname);
}
else
{
matpointer[curmat].textures[i] = ConjuntoTexturas->CargaCubeMap(texname);
}
// Si las coordenadas son eyelinear u objectlinear, cogemos el multiplicador
if((matpointer[curmat].texcoordgen[i]==TEXGEN_OBJECT_LINEAR) ||
(matpointer[curmat].texcoordgen[i]==TEXGEN_EYE_LINEAR))
{
token = strtok(NULL,separadores);
token2string(token,cadena2);
matpointer[curmat].linearmultiplier[i]=atof(cadena2);
}
// Finalmente, si no es la primera unidad de textura, vemos qué tipo de blend
// utiliza esta unidad de textura
if((i>0) && (matpointer[curmat].shader_based != 1)) // Para tipo shader no se carga
{
token = strtok(NULL,separadores);
token2string(token,cadena2);
if(!strcmp(cadena2,"add")) // Blend aditivo
{
matpointer[curmat].multitexblend[i]=BLEND_ADD;
}
else if(!strcmp(cadena2,"modulate")) // Modulate
{
matpointer[curmat].multitexblend[i]=BLEND_MODULATE;
}
else if(!strcmp(cadena2,"mask")) // Mask
{
matpointer[curmat].multitexblend[i]=BLEND_MASK;
}
else if(!strcmp(cadena2,"mask2")) // Mask
{
matpointer[curmat].multitexblend[i]=BLEND_MASK2;
}
else if(!strcmp(cadena2,"dot3")) // Dot3 bump mapping
{
matpointer[curmat].multitexblend[i]=BLEND_DOT3;
}
else // Por defecto dejamos replace, para darnos cuenta del error
{
sprintf (FANTASY_DEBUG_STRING, "Material %s no valido. Multitex blend no valido\n",matpointer[curmat].matname);
Debug(DEBUG_LEVEL_ERROR);
return -1;
}
}
else
matpointer[curmat].multitexblend[i]=BLEND_MODULATE;
} // Fin del bucle for
// Ahora vamos a cargar los parámetros relativos a la iluminación. Ojo, que son opcionales,
// y pueden ir en cualquier orden!!!
for(i=0;i<3;i++)
{
token = strtok(NULL,separadores);
if(token == NULL) break;
token2string(token,cadena2);
if(!strcmp(cadena2,"specular"))
{
for(j=0;j<3;j++) // Leemos las 4 componentes
{
token = strtok(NULL,separadores);
token2string(token,cadena2);
matpointer[curmat].specular[j]=2.0f*atof(cadena2);
}
matpointer[curmat].specular[3] = 1.0f;
}
else if(!strcmp(cadena2,"emission"))
{
for(j=0;j<3;j++) // Leemos las 4 componentes
{
token = strtok(NULL,separadores);
token2string(token,cadena2);
matpointer[curmat].emission[j]=atof(cadena2);
}
matpointer[curmat].emission[j] = 1.0f;
}
else if((!strcmp(cadena2,"shininess")) || (!strcmp(cadena2,"glossiness")))
{
token = strtok(NULL,separadores);
token2string(token,cadena2);
matpointer[curmat].shininess=atof(cadena2);
}
else
{
sprintf (FANTASY_DEBUG_STRING, "Material %s no valido. Parámetros de iluminación no válidos\n",matpointer[curmat].matname);
Debug(DEBUG_LEVEL_ERROR);
return -1;
}
}
}
curmat++;
}
materiales = matpointer;
numero_materiales = nmats;
pak_close(p);
if(curmat < nmats)
{
sprintf (FANTASY_DEBUG_STRING, "Fallo al leer el archivo de materiales %s. Hay menos materiales de los definidos en nmats\n",filename);
Debug(DEBUG_LEVEL_ERROR);
return -1;
}
return nmats;
}
/**
* The save an instance of TextToClassify structure in an XML file.
* The method use the class labels, and has_data lists in order to
* assign class labels {-1, 0, +1}
* */
bool Classifier::text2xml(TextToClassify* text, list<bool> hasdata,
list<pred> labels, string output_fpath) {
// Get the number of texts
TextToClassify* first_text = text;
unsigned int texts_count = 0;
bool texts_has_no_id = true;
while(text){
texts_has_no_id = texts_has_no_id && (text->iID == 0);
text = text->pNext;
texts_count++;
}
//printf("#hasdata=%d, #labels=%d, #texts=%d\n", hasdata.size(), labels.size(), texts_count);
// Data are consistent -> write output
if((hasdata.size() == texts_count) && (labels.size() == texts_count)){
// Open output file
FILE* output_file = fopen(output_fpath.c_str(), "w");
if (!output_file){
printf("Error: Cannot open the file '%s'.\n", output_fpath.c_str());
return false;
}
// Write each text as an XML element
const char* original_text;
string lemmas_text;
int label;
double confidence;
int text_num = 1;
text = first_text;
list<pred>::iterator labels_it = labels.begin();
list<bool>::iterator hasdata_it = hasdata.begin();
fprintf(output_file, "<%s>\n", ROOT_TAG);
while(text && labels_it != labels.end() && hasdata_it != hasdata.end()){
label = (*hasdata_it ? (*labels_it).category : NEGATIVE_CLASS_I);
confidence = (*hasdata_it ? (*labels_it).probability : 0);
fprintf(output_file, "<%s %s='%ld' %s='%s' %s='%0.4f'>\n",
TEXT_TAG, ID_ATT, (texts_has_no_id ? text_num : text->iID),
CLASS_ATT, get_label_name(label).c_str(),
CONFIDENCE_ATT, confidence);
original_text = (text->sText ? text->sText : "");
fprintf(output_file, "<%s>%s</%s>\n", ORIGINAL_TAG, original_text, ORIGINAL_TAG);
lemmas_text = (text->pToken ? token2string(text->pToken) : "");
fprintf(output_file, "<%s>%s</%s>\n", LEMMAS_TAG, lemmas_text.c_str(), LEMMAS_TAG);
fprintf(output_file, "</%s>\n", TEXT_TAG);
// Next text
text = text->pNext;
labels_it++;
hasdata_it++;
text_num++;
}
fprintf(output_file, "</%s>", ROOT_TAG);
// Close output file
fclose(output_file);
return true;
}
// Input data are not consistent
else{
printf("Error: Input data are not consistent. Output file was not written.\n");
return false;
}
}
