static void test_string_substring_with_equal_large() {
char* original_word = "hola";
char* substring = string_substring(original_word, 0, 4);
CU_ASSERT_STRING_EQUAL(substring, original_word);
CU_ASSERT_PTR_NOT_EQUAL(substring, original_word);
free(substring);
}
static void test_string_substring_extract_internal_text() {
char* original_word = "hola mundo";
char* substring = string_substring(original_word, 2, 5);
CU_ASSERT_STRING_EQUAL(substring, "la mu");
CU_ASSERT_PTR_NOT_EQUAL(substring, original_word);
free(substring);
}
static void test_string_substring_from_other_start() {
char* original_word = "hola mundo!";
char* substring = string_substring(original_word, 5, strlen(original_word) - 5);
CU_ASSERT_STRING_EQUAL(substring, "mundo!");
CU_ASSERT_PTR_NOT_EQUAL(substring, original_word);
free(substring);
}
static void test_string_substring_empty() {
char* original_word = "";
char* substring = string_substring(original_word, 0, 3);
CU_ASSERT_STRING_EQUAL(substring, original_word);
CU_ASSERT_PTR_NOT_EQUAL(substring, original_word);
free(substring);
}
void mathg_math_cog_bsp (mathgMathCog *self) {
gchar* s = NULL;
mathgElmnt* _tmp0_ = NULL;
gint _tmp0__length1 = 0;
gint _tmp1_ = 0;
mathgElmnt _tmp2_ = {0};
const gchar* _tmp3_ = NULL;
gchar* _tmp4_ = NULL;
mathgElmnt* _tmp5_ = NULL;
gint _tmp5__length1 = 0;
gint _tmp6_ = 0;
gint _tmp7_ = 0;
gint _tmp8_ = 0;
gchar* _tmp9_ = NULL;
_tmp0_ = (*self).stra;
_tmp0__length1 = (*self).stra_length1;
_tmp1_ = (*self).straind;
_tmp2_ = _tmp0_[_tmp1_];
_tmp3_ = _tmp2_.guess;
_tmp4_ = g_strdup (_tmp3_);
s = _tmp4_;
_tmp5_ = (*self).stra;
_tmp5__length1 = (*self).stra_length1;
_tmp6_ = (*self).straind;
_tmp7_ = strlen (s);
_tmp8_ = _tmp7_;
_tmp9_ = string_substring (s, (glong) 0, (glong) (_tmp8_ - 1));
_g_free0 (_tmp5_[_tmp6_].guess);
_tmp5_[_tmp6_].guess = _tmp9_;
_g_free0 (s);
}
result test_string_substring_StringWithSubstring() {
int passed = 0;
char* description = "string_substring(char*, char*) : StringWithSubstring CASE";
passed = is_true(string_substring("abc", "ab"));
return (result){passed, description};
}
result test_string_substring_NULL() {
int passed = 0;
char* description = "string_substring(char*, char*) : NULL CASE";
passed = is_false(string_substring(0, 0));
return (result){passed, description};
}
result test_string_substring_EmptyStrings() {
int passed = 0;
char* description = "string_substring(char*, char*) : 2EmptyString CASE";
passed = is_true(string_substring("", ""));
return (result){passed, description};
}
result test_string_substring_StringWithBiggerSuperstring() {
int passed = 0;
char* description = "string_substring(char*, char*) : StringWithBiggerSuperstring CASE";
passed = is_false(string_substring("abc", "abcdefg"));
return (result){passed, description};
}
char* header(int numero){ //Recibe numero de bytes, y lo devuelve en 4 bytes (Ej. recibe "2" y devuelve "0002")
char* asd=string_new();
char* num_char = string_itoa(numero);
num_char = string_reverse(num_char);
string_append(&asd,num_char);
free(num_char);
string_append(&asd,"0000");
char* longitud=string_substring(asd,0,4);
free(asd);
char* longitudPosta=string_reverse(longitud);
free(longitud);
return longitudPosta;
}
gchar* system_text_regular_expressions_capture_GetLeftSubString (SystemTextRegularExpressionsCapture* self) {
gchar* result = NULL;
const gchar* _tmp0_ = NULL;
gint _tmp1_ = 0;
gchar* _tmp2_ = NULL;
#line 73 "/home/developer/projects/Backup/LibDotNet/src/System/Text/RegularExpressions/RegexCapture.vala"
g_return_val_if_fail (self != NULL, NULL);
#line 75 "/home/developer/projects/Backup/LibDotNet/src/System/Text/RegularExpressions/RegexCapture.vala"
_tmp0_ = self->_text;
#line 75 "/home/developer/projects/Backup/LibDotNet/src/System/Text/RegularExpressions/RegexCapture.vala"
_tmp1_ = self->_index;
#line 75 "/home/developer/projects/Backup/LibDotNet/src/System/Text/RegularExpressions/RegexCapture.vala"
_tmp2_ = string_substring (_tmp0_, (glong) 0, (glong) _tmp1_);
#line 75 "/home/developer/projects/Backup/LibDotNet/src/System/Text/RegularExpressions/RegexCapture.vala"
result = _tmp2_;
#line 75 "/home/developer/projects/Backup/LibDotNet/src/System/Text/RegularExpressions/RegexCapture.vala"
return result;
#line 335 "RegexCapture.c"
}
static void plank_services_logger_print_log (PlankServicesLoggerLogMessage* log) {
PlankServicesLoggerLogMessage* _tmp0_ = NULL;
PlankServicesLogLevel _tmp1_ = 0;
PlankServicesLogLevel _tmp2_ = 0;
FILE* _tmp3_ = NULL;
PlankServicesLoggerLogMessage* _tmp4_ = NULL;
PlankServicesLogLevel _tmp5_ = 0;
PlankServicesLogLevel _tmp6_ = 0;
GEnumValue* _tmp7_;
gchar* _tmp8_ = NULL;
gchar* _tmp9_ = NULL;
gchar* _tmp10_ = NULL;
gchar* _tmp11_ = NULL;
FILE* _tmp12_ = NULL;
PlankServicesLoggerLogMessage* _tmp13_ = NULL;
const gchar* _tmp14_ = NULL;
const gchar* _tmp15_ = NULL;
g_return_if_fail (log != NULL);
_tmp0_ = log;
_tmp1_ = plank_services_logger_log_message_get_Level (_tmp0_);
_tmp2_ = _tmp1_;
plank_services_logger_set_color_for_level (_tmp2_);
_tmp3_ = stdout;
_tmp4_ = log;
_tmp5_ = plank_services_logger_log_message_get_Level (_tmp4_);
_tmp6_ = _tmp5_;
_tmp7_ = g_enum_get_value (g_type_class_ref (PLANK_SERVICES_TYPE_LOG_LEVEL), _tmp6_);
_tmp8_ = string_substring ((_tmp7_ != NULL) ? _tmp7_->value_name : NULL, (glong) 25, (glong) (-1));
_tmp9_ = _tmp8_;
_tmp10_ = plank_services_logger_get_time ();
_tmp11_ = _tmp10_;
fprintf (_tmp3_, "[%s %s]", _tmp9_, _tmp11_);
_g_free0 (_tmp11_);
_g_free0 (_tmp9_);
plank_services_logger_reset_color ();
_tmp12_ = stdout;
_tmp13_ = log;
_tmp14_ = plank_services_logger_log_message_get_Message (_tmp13_);
_tmp15_ = _tmp14_;
fprintf (_tmp12_, " %s\n", _tmp15_);
}
int main()
{
string *s = string_init();
string *o;
string *subs;
string *q = string_init_cstring("quit");
string_read_line(s);
while(string_cmp(s, q))
{
string_print(s);
string_reset(s);
string_read_line(s);
}
string_append(s, q);
o = string_cat(s, q);
string_print(s);
string_print(o);
string_append_cstring(o, "hello");
string_append_char(o, 'J');
string_print(o);
subs = string_substring(o, 5, 6);
printf("--\n");
printf("%c\n", string_get(s, 5));
printf("%d\n", string_index(o, 'o'));
string_print(subs);
printf("--\n");
o = string_free(o);
s = string_free(s);
q = string_free(q);
subs = string_free(subs);
return 0;
}
gchar* system_text_regular_expressions_capture_get_Value (SystemTextRegularExpressionsCapture* self) {
gchar* result;
const gchar* _tmp0_ = NULL;
gint _tmp1_ = 0;
gint _tmp2_ = 0;
gchar* _tmp3_ = NULL;
#line 54 "/home/developer/projects/Backup/LibDotNet/src/System/Text/RegularExpressions/RegexCapture.vala"
g_return_val_if_fail (self != NULL, NULL);
#line 56 "/home/developer/projects/Backup/LibDotNet/src/System/Text/RegularExpressions/RegexCapture.vala"
_tmp0_ = self->_text;
#line 56 "/home/developer/projects/Backup/LibDotNet/src/System/Text/RegularExpressions/RegexCapture.vala"
_tmp1_ = self->_index;
#line 56 "/home/developer/projects/Backup/LibDotNet/src/System/Text/RegularExpressions/RegexCapture.vala"
_tmp2_ = self->_length;
#line 56 "/home/developer/projects/Backup/LibDotNet/src/System/Text/RegularExpressions/RegexCapture.vala"
_tmp3_ = string_substring (_tmp0_, (glong) _tmp1_, (glong) _tmp2_);
#line 56 "/home/developer/projects/Backup/LibDotNet/src/System/Text/RegularExpressions/RegexCapture.vala"
result = _tmp3_;
#line 56 "/home/developer/projects/Backup/LibDotNet/src/System/Text/RegularExpressions/RegexCapture.vala"
return result;
#line 428 "RegexCapture.c"
}
gchar* system_text_regular_expressions_capture_GetRightSubString (SystemTextRegularExpressionsCapture* self) {
gchar* result = NULL;
const gchar* _tmp0_ = NULL;
gint _tmp1_ = 0;
gint _tmp2_ = 0;
const gchar* _tmp3_ = NULL;
gint _tmp4_ = 0;
gint _tmp5_ = 0;
gint _tmp6_ = 0;
gint _tmp7_ = 0;
gchar* _tmp8_ = NULL;
#line 78 "/home/developer/projects/Backup/LibDotNet/src/System/Text/RegularExpressions/RegexCapture.vala"
g_return_val_if_fail (self != NULL, NULL);
#line 80 "/home/developer/projects/Backup/LibDotNet/src/System/Text/RegularExpressions/RegexCapture.vala"
_tmp0_ = self->_text;
#line 80 "/home/developer/projects/Backup/LibDotNet/src/System/Text/RegularExpressions/RegexCapture.vala"
_tmp1_ = self->_index;
#line 80 "/home/developer/projects/Backup/LibDotNet/src/System/Text/RegularExpressions/RegexCapture.vala"
_tmp2_ = self->_length;
#line 80 "/home/developer/projects/Backup/LibDotNet/src/System/Text/RegularExpressions/RegexCapture.vala"
_tmp3_ = self->_text;
#line 80 "/home/developer/projects/Backup/LibDotNet/src/System/Text/RegularExpressions/RegexCapture.vala"
_tmp4_ = strlen (_tmp3_);
#line 80 "/home/developer/projects/Backup/LibDotNet/src/System/Text/RegularExpressions/RegexCapture.vala"
_tmp5_ = _tmp4_;
#line 80 "/home/developer/projects/Backup/LibDotNet/src/System/Text/RegularExpressions/RegexCapture.vala"
_tmp6_ = self->_index;
#line 80 "/home/developer/projects/Backup/LibDotNet/src/System/Text/RegularExpressions/RegexCapture.vala"
_tmp7_ = self->_length;
#line 80 "/home/developer/projects/Backup/LibDotNet/src/System/Text/RegularExpressions/RegexCapture.vala"
_tmp8_ = string_substring (_tmp0_, (glong) (_tmp1_ + _tmp2_), (glong) ((_tmp5_ - _tmp6_) - _tmp7_));
#line 80 "/home/developer/projects/Backup/LibDotNet/src/System/Text/RegularExpressions/RegexCapture.vala"
result = _tmp8_;
#line 80 "/home/developer/projects/Backup/LibDotNet/src/System/Text/RegularExpressions/RegexCapture.vala"
return result;
#line 374 "RegexCapture.c"
}
//Recibe y procesa un mensaje recibido
void receiptMessage(void * arguments)
{
args_receiptMessage * args = arguments;
int numbytes; /* bytes recibidos por cada lectura (0 = desconexion del cliente) */
char buffer[MAXDATASIZE]; /* buffer de lectura */
bool bufferUsed; /* determina si se analizo por lo menos una vez un nuevo set de datos */
unsigned int n = -1; /* cantidad de argumentos del packete que recibo */
int i = 0; /* ayuda a saber la ultima posicion de lectura en el buffer (tambien se usa como i en otros casos) */
int j = 0; /* j de for */
int seps = 0; /* cantidad de separadores ,(coma) contados en el encabezado del paquete */
char * packet_head; /* encabezado del paquete */
char * packet_body; /* cuerpo del paquete */
char * exceeded; /* datos excedidos del final del paquete */
char * str_tmp; /* temporar para operaciones de string */
bool isExceeded = false; /* determina si hay datos excedidos cargados en el buffer */
bool fullHead = false; /* determina si ya fue recibido el encabezado del paquete */
int bytesBody = 0; /* determina los bytes que contendrá el cuerpo del paquete */
char ** head = NULL; /* encabezado divido por n, name y bytes de los args */
char * b; /* utilizado para extraer bytes del buffer */
void (*fn)(); /* utilizado para guardar la funcion que hay que ejecutar del cliente */
char ** packet_args; /* Argumentos que se envian por la funcion */
//loopeo
while(1)
{
//si en la ultima lectura dejo informacion excedida la guardo
if(isExceeded)
exceeded = string_duplicate(buffer);
//Pongo en blanco el buffer
buffer[0] = '\0';
//Espero a recibir un mensaje del job, si se produce un error lo informo error y finalizo hilo
if ((numbytes=recv(args->connection->socket, buffer, MAXDATASIZE-1, 0)) == -1)
{
//perror("recv");
break;
}
//si en la ultima lectura dejo informacion excedida la agrego al inicio del buffer
if(isExceeded)
{
exceeded = string_new();
string_append(&exceeded, buffer);
buffer[sizeof(exceeded)] = '\0'; //mejor que memset?
strcpy(buffer, exceeded);
free(exceeded);
}
//finalizo el hilo
if(numbytes == 0)
break;
else
{
//Corta el bufer hasta donde recibe informacion
buffer[numbytes] = '\0';
//analizo el buffer si es la primera vez que lo voy a analizar o si queda informacion excedida para seguir analizando
//(Analizar significa, buscar paquetes completos y ejecutarlos)
bufferUsed = false;
while(!bufferUsed || isExceeded)
{
bufferUsed = true;
isExceeded = false;
i = 0;
//si comienzo a leer un nuevo paquete inicializo el head y el body
if(n == -1)
{
packet_head = string_new();
packet_body = string_new();
}
//recorro buffer hasta armar cabezal si no esta armado
if(!fullHead)
{
for(i = 0; i < strlen(buffer); i++)
{
b = buffer[i];
//primer caracter es [n] (cantidad de args)
if(n == -1)
n = atoi(&b);
//cuento comas
else if(b == ',')
seps++;
//voy completando cabezal
string_append(&packet_head, &b);
//fianlizo cuando llego al ultimo separador
if(n+2 == seps)
{
fullHead = true;
i++; //dejo posicion en el primer byte del cuerpo del paquete
break;
}
}
}
//cabezal completo
if(fullHead)
{
//si el cabezal no fue explodiado, le doy explode y calculo los bytes del cabezal
if(head == NULL)
{
//hago explode
head = string_n_split(packet_head, n+2, ",");
for(j = 2; j < n+2; j++)
bytesBody += atoi(head[j]);
}
//Agrego al cuerpo del packete todos los datos
str_tmp = string_substring_from(buffer, i);
string_append(&packet_body, str_tmp);
free(str_tmp);
//paquete completo
if(bytesBody <= strlen(packet_body))
{
//si el paquete esta excedido, corto el paquete en la posicion correspondiente y guardo el excedente sobre el buffer
if(bytesBody < strlen(packet_body))
{
isExceeded = true;
exceeded = string_substring_from(packet_body, bytesBody);
str_tmp = string_substring_until(packet_body, bytesBody);
free(packet_body);
packet_body = str_tmp;
buffer[0] = '\0';
strcpy(buffer, exceeded);
free(exceeded);
}
//llamo a la funcion que maneja los mensajes recibidos
if(args->fns_receipts != NULL)
{
i = 0;
//armo argumentos en array
packet_args = malloc(sizeof(char*)*n);
for(j = 2; j < n+2; j++)
{
char * part = string_substring(packet_body, i, atoi(head[j]));
packet_args[j-2] = part;
i += atoi(head[j]);
}
//Si n=0 el split no toma el vacio despues de la coma final.. quito ultima coma
if(n==0)
head[1][strlen(head[1])-1] = '\0';
//Ejecuto la función solicitada, si no existe la función muestro error
fn = dictionary_get(args->fns_receipts, head[1]);
if(fn != NULL)
fn(args->connection, packet_args);
else
printf("Cliente SOCK%d(%s:%d) intento ejecutar la función inexistente '%s'.\n", args->connection->socket, args->connection->ip, args->connection->port, head[1]);
//libero argumentos
for(i = 0; i < n; i++)
free(packet_args[i]);
free(packet_args);
}
free(packet_head);
free(packet_body);
for(i = 0; i < n+3; i++)
free(head[i]);
free(head);
n = -1;
seps = 0;
fullHead = false;
bytesBody = 0;
head = NULL;
}
}
}
}
}
//cierro socket
close(args->connection->socket);
//Informo a la funcion que maneja los cierres (si existe y la estructura de conexion lo permite)
if(args->connection->run_fn_connectionClosed && args->fn_connectionClosed != NULL)
args->fn_connectionClosed(args->connection);
//libero memoria
if(isExceeded)
free(exceeded);
if(n != -1)
{
free(packet_head);
free(packet_body);
}
free(args);
}
static void fix_server_read_logon(int socket)
{
unsigned long msg_start_idx, msg_end_idx;
String *buffer, *fix_msg;
FixSession *session;
char buf[BUFSZ];
ssize_t n;
int done;
session = NULL;
done = 0;
buffer = string_create();
fix_msg = NULL;
while(!done) {
DBG("Server waiting for data from client\n");
/* Read data onto the end of buffer */
if((n = recv(socket, buf, BUFSZ, 0)) > 0) {
string_append_buf(buffer, buf, n);
/* Find BeginString tag and CheckSum tag */
if((string_find(buffer, "8=", &msg_start_idx) == 0) &&
(string_find(buffer, "\00110=", &msg_end_idx) == 0)) {
/* Length of "<SOH>10=xxx<SOH>" is 8 characters */
if((string_length(buffer) - msg_end_idx) >= 8) {
/* Extract FIX message. Index of final SOH is
* msg_end_idx + 7.
*/
fix_msg = string_substring(buffer, msg_start_idx,
(msg_end_idx + 7));
DBG("New msg: '%s'\n", string_get_chars(fix_msg));
/* Pass message to session object */
if(NULL == session) {
if(fix_session_manager_lookup_session(fix_msg,
&session) < 0) {
done = 1;
} else {
if(NULL == session) {
done = 1;
} else {
if(!fix_session_is_active(session)) {
fix_session_set_socket(session, socket);
fix_session_activate(session);
fix_session_receive_message(session, fix_msg);
}
done = 1;
}
}
}
}
}
} else {
/* Assume client disconnected.
*
* TODO Check more thoroughly the reason for
* recv failure
*/
done = 1;
}
}
/* Free the buffer string since there should
* be no other valid data in it. When a client
* connects, the only thing they should send
* us is a logon message.
*/
string_free(buffer);
DBG("Server is done waiting for data from client\n");
}
void gtk_mate_pattern_replace_repository_includes (GeeArrayList* patlist, GtkMateGrammar* g) {
GeeArrayList* include_patterns;
GeeArrayList* patterns_to_include;
gboolean any_included;
g_return_if_fail (patlist != NULL);
g_return_if_fail (g != NULL);
include_patterns = gee_array_list_new (GTK_MATE_TYPE_PATTERN, (GBoxedCopyFunc) g_object_ref, g_object_unref, g_direct_equal);
patterns_to_include = gee_array_list_new (GTK_MATE_TYPE_PATTERN, (GBoxedCopyFunc) g_object_ref, g_object_unref, g_direct_equal);
any_included = TRUE;
while (any_included) {
/* stdout.printf("repo replacement pass\n");*/
any_included = FALSE;
{
GeeIterator* _p_it;
_p_it = gee_iterable_iterator ((GeeIterable*) patlist);
while (gee_iterator_next (_p_it)) {
GtkMatePattern* p;
gboolean _tmp0;
p = (GtkMatePattern*) gee_iterator_get (_p_it);
_tmp0 = FALSE;
if (GTK_MATE_IS_INCLUDE_PATTERN (p)) {
_tmp0 = g_str_has_prefix (p->name, "#");
} else {
_tmp0 = FALSE;
}
if (_tmp0) {
char* reponame;
GeeArrayList* ps;
gee_collection_add ((GeeCollection*) include_patterns, p);
reponame = string_substring (p->name, (glong) 1, (glong) (((gint) strlen (p->name)) - 1));
ps = (GeeArrayList*) gee_map_get ((GeeMap*) g->repository, reponame);
/* stdout.printf("(%s) getting reponame: %s (%d)\n", this.name, reponame, ps.size);*/
if (ps != NULL) {
{
GeeIterator* _p1_it;
_p1_it = gee_iterable_iterator ((GeeIterable*) ps);
while (gee_iterator_next (_p1_it)) {
GtkMatePattern* p1;
p1 = (GtkMatePattern*) gee_iterator_get (_p1_it);
any_included = TRUE;
gee_collection_add ((GeeCollection*) patterns_to_include, p1);
(p1 == NULL) ? NULL : (p1 = (g_object_unref (p1), NULL));
}
(_p1_it == NULL) ? NULL : (_p1_it = (g_object_unref (_p1_it), NULL));
}
} else {
fprintf (stdout, "warning: couldn't find repository key '%s' in grammar '%s'\n", reponame, gtk_mate_grammar_get_name (g));
}
reponame = (g_free (reponame), NULL);
(ps == NULL) ? NULL : (ps = (g_object_unref (ps), NULL));
}
(p == NULL) ? NULL : (p = (g_object_unref (p), NULL));
}
(_p_it == NULL) ? NULL : (_p_it = (g_object_unref (_p_it), NULL));
}
gtk_mate_pattern_remove_patterns (patlist, include_patterns);
gtk_mate_pattern_add_patterns (patlist, patterns_to_include);
gee_collection_clear ((GeeCollection*) include_patterns);
gee_collection_clear ((GeeCollection*) patterns_to_include);
}
(include_patterns == NULL) ? NULL : (include_patterns = (g_object_unref (include_patterns), NULL));
(patterns_to_include == NULL) ? NULL : (patterns_to_include = (g_object_unref (patterns_to_include), NULL));
}
void mathg_math_cog_put (mathgMathCog *self) {
gchar* s = NULL;
mathgElmnt* _tmp0_ = NULL;
gint _tmp0__length1 = 0;
gint _tmp1_ = 0;
mathgElmnt _tmp2_ = {0};
const gchar* _tmp3_ = NULL;
gchar* _tmp4_ = NULL;
const gchar* _tmp5_ = NULL;
gdouble d = 0.0;
const gchar* _tmp25_ = NULL;
gdouble _tmp26_ = 0.0;
mathgElmnt* _tmp27_ = NULL;
gint _tmp27__length1 = 0;
gint _tmp28_ = 0;
const gchar* _tmp29_ = NULL;
gchar* _tmp30_ = NULL;
gdouble ans = 0.0;
mathgElmnt* _tmp31_ = NULL;
gint _tmp31__length1 = 0;
gint _tmp32_ = 0;
mathgElmnt _tmp33_ = {0};
gdouble _tmp34_ = 0.0;
gboolean _tmp35_ = FALSE;
gdouble _tmp36_ = 0.0;
gdouble _tmp37_ = 0.0;
gdouble _tmp38_ = 0.0;
gdouble _tmp39_ = 0.0;
_tmp0_ = (*self).stra;
_tmp0__length1 = (*self).stra_length1;
_tmp1_ = (*self).straind;
_tmp2_ = _tmp0_[_tmp1_];
_tmp3_ = _tmp2_.guess;
_tmp4_ = g_strdup (_tmp3_);
s = _tmp4_;
_tmp5_ = (*self).ch;
if (g_strcmp0 (_tmp5_, "-") == 0) {
gchar* _tmp6_ = NULL;
const gchar* _tmp7_ = NULL;
gboolean _tmp8_ = FALSE;
gchar* _tmp14_ = NULL;
_tmp7_ = s;
_tmp8_ = string_contains (_tmp7_, "-");
if (_tmp8_) {
const gchar* _tmp9_ = NULL;
gchar* _tmp10_ = NULL;
_tmp9_ = s;
_tmp10_ = string_substring (_tmp9_, (glong) 1, (glong) -1);
_g_free0 (_tmp6_);
_tmp6_ = _tmp10_;
} else {
const gchar* _tmp11_ = NULL;
const gchar* _tmp12_ = NULL;
gchar* _tmp13_ = NULL;
_tmp11_ = (*self).ch;
_tmp12_ = s;
_tmp13_ = g_strconcat (_tmp11_, _tmp12_, NULL);
_g_free0 (_tmp6_);
_tmp6_ = _tmp13_;
}
_tmp14_ = g_strdup (_tmp6_);
_g_free0 (s);
s = _tmp14_;
_g_free0 (_tmp6_);
} else {
mathgNumberUtils _tmp15_ = {0};
gint _tmp16_ = 0;
gchar* _tmp17_ = NULL;
gchar* _tmp18_ = NULL;
const gchar* _tmp19_ = NULL;
gboolean _tmp20_ = FALSE;
gboolean _tmp21_ = FALSE;
_tmp15_ = (*self).nu;
_tmp16_ = _tmp15_.bas;
_tmp17_ = string_substring (MATHG_digits, (glong) 0, (glong) _tmp16_);
_tmp18_ = _tmp17_;
_tmp19_ = (*self).ch;
_tmp20_ = string_contains (_tmp18_, _tmp19_);
_tmp21_ = _tmp20_;
_g_free0 (_tmp18_);
if (_tmp21_) {
const gchar* _tmp22_ = NULL;
const gchar* _tmp23_ = NULL;
gchar* _tmp24_ = NULL;
_tmp22_ = s;
_tmp23_ = (*self).ch;
_tmp24_ = g_strconcat (_tmp22_, _tmp23_, NULL);
_g_free0 (s);
s = _tmp24_;
}
}
_tmp25_ = s;
_tmp26_ = mathg_number_utils_td (&(*self).nu, _tmp25_);
d = _tmp26_;
_tmp27_ = (*self).stra;
_tmp27__length1 = (*self).stra_length1;
_tmp28_ = (*self).straind;
_tmp29_ = s;
_tmp30_ = g_strdup (_tmp29_);
_g_free0 (_tmp27_[_tmp28_].guess);
_tmp27_[_tmp28_].guess = _tmp30_;
_tmp31_ = (*self).stra;
_tmp31__length1 = (*self).stra_length1;
_tmp32_ = (*self).straind;
_tmp33_ = _tmp31_[_tmp32_];
_tmp34_ = _tmp33_.answer;
ans = _tmp34_;
_tmp36_ = d;
_tmp37_ = ans;
_tmp38_ = fabs ((_tmp36_ / _tmp37_) - 1);
_tmp39_ = (*self).deviation;
if (_tmp38_ <= _tmp39_) {
_tmp35_ = TRUE;
} else {
gboolean _tmp40_ = FALSE;
_tmp40_ = (*self).isenter;
_tmp35_ = _tmp40_;
}
if (_tmp35_) {
gdouble _tmp41_ = 0.0;
_tmp41_ = ans;
mathg_math_cog_close (&(*self), _tmp41_);
}
(*self).isenter = FALSE;
_g_free0 (s);
}
/**
* @NAME: string_substring_from
* @DESC: Retorna el substring de text desde el caracter start hasta
* el ultimo
*/
char *string_substring_from(char *text, int start) {
return string_substring(text, start, strlen(text) - start);
}
static gchar* vala_markup_reader_text (ValaMarkupReader* self, gchar end_char, gboolean rm_trailing_whitespace) {
gchar* result = NULL;
GString* _tmp0_;
GString* content;
gchar* _tmp1_;
gchar* text_begin;
gchar* _tmp2_;
gchar* last_linebreak;
gchar* _tmp84_;
gchar* _tmp85_;
gint _tmp92_;
gchar* _tmp93_;
gchar* _tmp94_;
gboolean _tmp95_;
GString* _tmp116_;
const gchar* _tmp117_;
gchar* _tmp118_;
g_return_val_if_fail (self != NULL, NULL);
_tmp0_ = g_string_new ("");
content = _tmp0_;
_tmp1_ = self->priv->current;
text_begin = _tmp1_;
_tmp2_ = self->priv->current;
last_linebreak = _tmp2_;
while (TRUE) {
gboolean _tmp3_ = FALSE;
gchar* _tmp4_;
gchar* _tmp5_;
gboolean _tmp9_;
gchar* _tmp10_;
gchar* _tmp11_;
gchar* _tmp12_;
gunichar _tmp13_ = 0U;
gunichar u;
gunichar _tmp14_;
_tmp4_ = self->priv->current;
_tmp5_ = self->priv->end;
if (_tmp4_ < _tmp5_) {
gchar* _tmp6_;
gchar _tmp7_;
gchar _tmp8_;
_tmp6_ = self->priv->current;
_tmp7_ = _tmp6_[0];
_tmp8_ = end_char;
_tmp3_ = _tmp7_ != _tmp8_;
} else {
_tmp3_ = FALSE;
}
_tmp9_ = _tmp3_;
if (!_tmp9_) {
break;
}
_tmp10_ = self->priv->current;
_tmp11_ = self->priv->end;
_tmp12_ = self->priv->current;
_tmp13_ = g_utf8_get_char_validated ((const gchar*) _tmp10_, (gssize) ((glong) (_tmp11_ - _tmp12_)));
u = _tmp13_;
_tmp14_ = u;
if (_tmp14_ == ((gunichar) (-1))) {
vala_report_error (NULL, "invalid UTF-8 character");
} else {
gunichar _tmp15_;
_tmp15_ = u;
if (_tmp15_ == ((gunichar) '&')) {
gchar* _tmp16_;
gunichar _tmp17_;
gint _tmp18_ = 0;
gchar* next_pos;
gchar* _tmp19_;
gboolean _tmp20_ = FALSE;
_tmp16_ = self->priv->current;
_tmp17_ = u;
_tmp18_ = g_unichar_to_utf8 (_tmp17_, NULL);
next_pos = _tmp16_ + _tmp18_;
_tmp19_ = next_pos;
_tmp20_ = g_str_has_prefix ((const gchar*) _tmp19_, "amp;");
if (_tmp20_) {
GString* _tmp21_;
gchar* _tmp22_;
gchar* _tmp23_;
gchar* _tmp24_;
gchar* _tmp25_ = NULL;
gchar* _tmp26_;
GString* _tmp27_;
gchar* _tmp28_;
gchar* _tmp29_;
_tmp21_ = content;
_tmp22_ = text_begin;
_tmp23_ = self->priv->current;
_tmp24_ = text_begin;
_tmp25_ = string_substring ((const gchar*) _tmp22_, (glong) 0, (glong) ((gint) (_tmp23_ - _tmp24_)));
_tmp26_ = _tmp25_;
g_string_append (_tmp21_, _tmp26_);
_g_free0 (_tmp26_);
_tmp27_ = content;
g_string_append_c (_tmp27_, '&');
_tmp28_ = self->priv->current;
self->priv->current = _tmp28_ + 5;
_tmp29_ = self->priv->current;
text_begin = _tmp29_;
} else {
gchar* _tmp30_;
gboolean _tmp31_ = FALSE;
_tmp30_ = next_pos;
_tmp31_ = g_str_has_prefix ((const gchar*) _tmp30_, "quot;");
if (_tmp31_) {
GString* _tmp32_;
gchar* _tmp33_;
gchar* _tmp34_;
gchar* _tmp35_;
gchar* _tmp36_ = NULL;
gchar* _tmp37_;
GString* _tmp38_;
gchar* _tmp39_;
gchar* _tmp40_;
_tmp32_ = content;
_tmp33_ = text_begin;
_tmp34_ = self->priv->current;
_tmp35_ = text_begin;
_tmp36_ = string_substring ((const gchar*) _tmp33_, (glong) 0, (glong) ((gint) (_tmp34_ - _tmp35_)));
_tmp37_ = _tmp36_;
g_string_append (_tmp32_, _tmp37_);
_g_free0 (_tmp37_);
_tmp38_ = content;
g_string_append_c (_tmp38_, '"');
_tmp39_ = self->priv->current;
self->priv->current = _tmp39_ + 6;
_tmp40_ = self->priv->current;
text_begin = _tmp40_;
} else {
gchar* _tmp41_;
gboolean _tmp42_ = FALSE;
_tmp41_ = next_pos;
_tmp42_ = g_str_has_prefix ((const gchar*) _tmp41_, "apos;");
if (_tmp42_) {
GString* _tmp43_;
gchar* _tmp44_;
gchar* _tmp45_;
gchar* _tmp46_;
gchar* _tmp47_ = NULL;
gchar* _tmp48_;
GString* _tmp49_;
gchar* _tmp50_;
gchar* _tmp51_;
_tmp43_ = content;
_tmp44_ = text_begin;
_tmp45_ = self->priv->current;
_tmp46_ = text_begin;
_tmp47_ = string_substring ((const gchar*) _tmp44_, (glong) 0, (glong) ((gint) (_tmp45_ - _tmp46_)));
_tmp48_ = _tmp47_;
g_string_append (_tmp43_, _tmp48_);
_g_free0 (_tmp48_);
_tmp49_ = content;
g_string_append_c (_tmp49_, '\'');
_tmp50_ = self->priv->current;
self->priv->current = _tmp50_ + 6;
_tmp51_ = self->priv->current;
text_begin = _tmp51_;
} else {
gchar* _tmp52_;
gboolean _tmp53_ = FALSE;
_tmp52_ = next_pos;
_tmp53_ = g_str_has_prefix ((const gchar*) _tmp52_, "lt;");
if (_tmp53_) {
GString* _tmp54_;
gchar* _tmp55_;
gchar* _tmp56_;
gchar* _tmp57_;
gchar* _tmp58_ = NULL;
gchar* _tmp59_;
GString* _tmp60_;
gchar* _tmp61_;
gchar* _tmp62_;
_tmp54_ = content;
_tmp55_ = text_begin;
_tmp56_ = self->priv->current;
_tmp57_ = text_begin;
_tmp58_ = string_substring ((const gchar*) _tmp55_, (glong) 0, (glong) ((gint) (_tmp56_ - _tmp57_)));
_tmp59_ = _tmp58_;
g_string_append (_tmp54_, _tmp59_);
_g_free0 (_tmp59_);
_tmp60_ = content;
g_string_append_c (_tmp60_, '<');
_tmp61_ = self->priv->current;
self->priv->current = _tmp61_ + 4;
_tmp62_ = self->priv->current;
text_begin = _tmp62_;
} else {
gchar* _tmp63_;
gboolean _tmp64_ = FALSE;
_tmp63_ = next_pos;
_tmp64_ = g_str_has_prefix ((const gchar*) _tmp63_, "gt;");
if (_tmp64_) {
GString* _tmp65_;
gchar* _tmp66_;
gchar* _tmp67_;
gchar* _tmp68_;
gchar* _tmp69_ = NULL;
gchar* _tmp70_;
GString* _tmp71_;
gchar* _tmp72_;
gchar* _tmp73_;
_tmp65_ = content;
_tmp66_ = text_begin;
_tmp67_ = self->priv->current;
_tmp68_ = text_begin;
_tmp69_ = string_substring ((const gchar*) _tmp66_, (glong) 0, (glong) ((gint) (_tmp67_ - _tmp68_)));
_tmp70_ = _tmp69_;
g_string_append (_tmp65_, _tmp70_);
_g_free0 (_tmp70_);
_tmp71_ = content;
g_string_append_c (_tmp71_, '>');
_tmp72_ = self->priv->current;
self->priv->current = _tmp72_ + 4;
_tmp73_ = self->priv->current;
text_begin = _tmp73_;
} else {
gchar* _tmp74_;
gunichar _tmp75_;
gint _tmp76_ = 0;
_tmp74_ = self->priv->current;
_tmp75_ = u;
_tmp76_ = g_unichar_to_utf8 (_tmp75_, NULL);
self->priv->current = _tmp74_ + _tmp76_;
}
}
}
}
}
} else {
gunichar _tmp77_;
gchar* _tmp80_;
gunichar _tmp81_;
gint _tmp82_ = 0;
gint _tmp83_;
_tmp77_ = u;
if (_tmp77_ == ((gunichar) '\n')) {
gint _tmp78_;
gchar* _tmp79_;
_tmp78_ = self->priv->line;
self->priv->line = _tmp78_ + 1;
self->priv->column = 0;
_tmp79_ = self->priv->current;
last_linebreak = _tmp79_;
}
_tmp80_ = self->priv->current;
_tmp81_ = u;
_tmp82_ = g_unichar_to_utf8 (_tmp81_, NULL);
self->priv->current = _tmp80_ + _tmp82_;
_tmp83_ = self->priv->column;
self->priv->column = _tmp83_ + 1;
}
}
}
_tmp84_ = text_begin;
_tmp85_ = self->priv->current;
if (_tmp84_ != _tmp85_) {
GString* _tmp86_;
gchar* _tmp87_;
gchar* _tmp88_;
gchar* _tmp89_;
gchar* _tmp90_ = NULL;
gchar* _tmp91_;
_tmp86_ = content;
_tmp87_ = text_begin;
_tmp88_ = self->priv->current;
_tmp89_ = text_begin;
_tmp90_ = string_substring ((const gchar*) _tmp87_, (glong) 0, (glong) ((gint) (_tmp88_ - _tmp89_)));
_tmp91_ = _tmp90_;
g_string_append (_tmp86_, _tmp91_);
_g_free0 (_tmp91_);
}
_tmp92_ = self->priv->column;
_tmp93_ = self->priv->current;
_tmp94_ = last_linebreak;
self->priv->column = _tmp92_ + ((gint) (_tmp93_ - _tmp94_));
_tmp95_ = rm_trailing_whitespace;
if (_tmp95_) {
GString* _tmp96_;
const gchar* _tmp97_;
GString* _tmp98_;
gssize _tmp99_;
gchar* str_pos;
GString* _tmp112_;
gchar* _tmp113_;
GString* _tmp114_;
const gchar* _tmp115_;
_tmp96_ = content;
_tmp97_ = _tmp96_->str;
_tmp98_ = content;
_tmp99_ = _tmp98_->len;
str_pos = ((gchar*) _tmp97_) + _tmp99_;
{
gchar* _tmp100_;
gboolean _tmp101_;
_tmp100_ = str_pos;
str_pos = _tmp100_ - 1;
_tmp101_ = TRUE;
while (TRUE) {
gboolean _tmp102_;
gboolean _tmp104_ = FALSE;
gchar* _tmp105_;
GString* _tmp106_;
const gchar* _tmp107_;
gboolean _tmp111_;
_tmp102_ = _tmp101_;
if (!_tmp102_) {
gchar* _tmp103_;
_tmp103_ = str_pos;
str_pos = _tmp103_ - 1;
}
_tmp101_ = FALSE;
_tmp105_ = str_pos;
_tmp106_ = content;
_tmp107_ = _tmp106_->str;
if (_tmp105_ > ((gchar*) _tmp107_)) {
gchar* _tmp108_;
gchar _tmp109_;
gboolean _tmp110_ = FALSE;
_tmp108_ = str_pos;
_tmp109_ = _tmp108_[0];
_tmp110_ = g_ascii_isspace (_tmp109_);
_tmp104_ = _tmp110_;
} else {
_tmp104_ = FALSE;
}
_tmp111_ = _tmp104_;
if (!_tmp111_) {
break;
}
}
}
_tmp112_ = content;
_tmp113_ = str_pos;
_tmp114_ = content;
_tmp115_ = _tmp114_->str;
g_string_erase (_tmp112_, (gssize) ((_tmp113_ - ((gchar*) _tmp115_)) + 1), (gssize) (-1));
}
_tmp116_ = content;
_tmp117_ = _tmp116_->str;
_tmp118_ = g_strdup (_tmp117_);
result = _tmp118_;
_g_string_free0 (content);
return result;
}
static gchar* vala_markup_reader_read_name (ValaMarkupReader* self) {
gchar* result = NULL;
gchar* _tmp0_;
gchar* begin;
gchar* _tmp33_;
gchar* _tmp34_;
gchar* _tmp35_;
gchar* _tmp36_;
gchar* _tmp37_;
gchar* _tmp38_ = NULL;
g_return_val_if_fail (self != NULL, NULL);
_tmp0_ = self->priv->current;
begin = _tmp0_;
while (TRUE) {
gchar* _tmp1_;
gchar* _tmp2_;
gboolean _tmp3_ = FALSE;
gboolean _tmp4_ = FALSE;
gboolean _tmp5_ = FALSE;
gboolean _tmp6_ = FALSE;
gboolean _tmp7_ = FALSE;
gchar* _tmp8_;
gchar _tmp9_;
gboolean _tmp12_;
gboolean _tmp15_;
gboolean _tmp18_;
gboolean _tmp21_;
gboolean _tmp24_;
gchar* _tmp25_;
gchar* _tmp26_;
gchar* _tmp27_;
gunichar _tmp28_ = 0U;
gunichar u;
gunichar _tmp29_;
_tmp1_ = self->priv->current;
_tmp2_ = self->priv->end;
if (!(_tmp1_ < _tmp2_)) {
break;
}
_tmp8_ = self->priv->current;
_tmp9_ = _tmp8_[0];
if (_tmp9_ == ' ') {
_tmp7_ = TRUE;
} else {
gchar* _tmp10_;
gchar _tmp11_;
_tmp10_ = self->priv->current;
_tmp11_ = _tmp10_[0];
_tmp7_ = _tmp11_ == '\t';
}
_tmp12_ = _tmp7_;
if (_tmp12_) {
_tmp6_ = TRUE;
} else {
gchar* _tmp13_;
gchar _tmp14_;
_tmp13_ = self->priv->current;
_tmp14_ = _tmp13_[0];
_tmp6_ = _tmp14_ == '>';
}
_tmp15_ = _tmp6_;
if (_tmp15_) {
_tmp5_ = TRUE;
} else {
gchar* _tmp16_;
gchar _tmp17_;
_tmp16_ = self->priv->current;
_tmp17_ = _tmp16_[0];
_tmp5_ = _tmp17_ == '/';
}
_tmp18_ = _tmp5_;
if (_tmp18_) {
_tmp4_ = TRUE;
} else {
gchar* _tmp19_;
gchar _tmp20_;
_tmp19_ = self->priv->current;
_tmp20_ = _tmp19_[0];
_tmp4_ = _tmp20_ == '=';
}
_tmp21_ = _tmp4_;
if (_tmp21_) {
_tmp3_ = TRUE;
} else {
gchar* _tmp22_;
gchar _tmp23_;
_tmp22_ = self->priv->current;
_tmp23_ = _tmp22_[0];
_tmp3_ = _tmp23_ == '\n';
}
_tmp24_ = _tmp3_;
if (_tmp24_) {
break;
}
_tmp25_ = self->priv->current;
_tmp26_ = self->priv->end;
_tmp27_ = self->priv->current;
_tmp28_ = g_utf8_get_char_validated ((const gchar*) _tmp25_, (gssize) ((glong) (_tmp26_ - _tmp27_)));
u = _tmp28_;
_tmp29_ = u;
if (_tmp29_ != ((gunichar) (-1))) {
gchar* _tmp30_;
gunichar _tmp31_;
gint _tmp32_ = 0;
_tmp30_ = self->priv->current;
_tmp31_ = u;
_tmp32_ = g_unichar_to_utf8 (_tmp31_, NULL);
self->priv->current = _tmp30_ + _tmp32_;
} else {
vala_report_error (NULL, "invalid UTF-8 character");
}
}
_tmp33_ = self->priv->current;
_tmp34_ = begin;
if (_tmp33_ == _tmp34_) {
}
_tmp35_ = begin;
_tmp36_ = self->priv->current;
_tmp37_ = begin;
_tmp38_ = string_substring ((const gchar*) _tmp35_, (glong) 0, (glong) ((gint) (_tmp36_ - _tmp37_)));
result = _tmp38_;
return result;
}
static RestProxyCall* ease_flickr_service_real_create_call (EasePluginImportService* base, RestProxy* proxy, const char* search) {
#line 184 "ease-import-flickr-service.c"
EaseFlickrService * self;
RestProxyCall* result = NULL;
char* licenses;
RestProxyCall* call;
char* _tmp4_;
self = (EaseFlickrService*) base;
#line 40 "ease-import-flickr-service.vala"
g_return_val_if_fail (proxy != NULL, NULL);
#line 40 "ease-import-flickr-service.vala"
g_return_val_if_fail (search != NULL, NULL);
#line 195 "ease-import-flickr-service.c"
licenses = NULL;
#line 44 "ease-import-flickr-service.vala"
if (gtk_toggle_button_get_active ((GtkToggleButton*) self->priv->share_alike)) {
#line 199 "ease-import-flickr-service.c"
char* _tmp0_;
#line 46 "ease-import-flickr-service.vala"
licenses = (_tmp0_ = g_strdup (EASE_FLICKR_SERVICE_CC_BY_SA), _g_free0 (licenses), _tmp0_);
#line 47 "ease-import-flickr-service.vala"
if (!gtk_toggle_button_get_active ((GtkToggleButton*) self->priv->for_commercial)) {
#line 205 "ease-import-flickr-service.c"
char* _tmp1_;
#line 47 "ease-import-flickr-service.vala"
licenses = (_tmp1_ = g_strconcat (licenses, EASE_FLICKR_SERVICE_CC_BY_NC_SA, NULL), _g_free0 (licenses), _tmp1_);
#line 209 "ease-import-flickr-service.c"
}
} else {
char* _tmp2_;
#line 51 "ease-import-flickr-service.vala"
licenses = (_tmp2_ = g_strdup (EASE_FLICKR_SERVICE_CC_BY), _g_free0 (licenses), _tmp2_);
#line 52 "ease-import-flickr-service.vala"
if (!gtk_toggle_button_get_active ((GtkToggleButton*) self->priv->for_commercial)) {
#line 217 "ease-import-flickr-service.c"
char* _tmp3_;
#line 52 "ease-import-flickr-service.vala"
licenses = (_tmp3_ = g_strconcat (licenses, EASE_FLICKR_SERVICE_CC_BY_NC, NULL), _g_free0 (licenses), _tmp3_);
#line 221 "ease-import-flickr-service.c"
}
}
#line 55 "ease-import-flickr-service.vala"
call = rest_proxy_new_call (proxy);
#line 56 "ease-import-flickr-service.vala"
rest_proxy_call_set_function (call, "flickr.photos.search");
#line 57 "ease-import-flickr-service.vala"
rest_proxy_call_add_params (call, "tags", search, "tag_mode", "all", "per_page", "10", "format", "json", "sort", "relevance", "nojsoncallback", "1", "license", _tmp4_ = string_substring (licenses, (glong) 0, string_get_length (licenses) - 1), "extras", "description,license", NULL, NULL);
#line 230 "ease-import-flickr-service.c"
_g_free0 (_tmp4_);
result = call;
_g_free0 (licenses);
#line 71 "ease-import-flickr-service.vala"
return result;
#line 236 "ease-import-flickr-service.c"
}
/**
* @NAME: string_substring_until
* @DESC: Retorna los primeros length caracteres de text como un nuevo
* string
*/
char *string_substring_until(char *text, int length) {
return string_substring(text, 0, length);
}
void consola() {
//char eleccion[30];
char* eleccion;
char* comando;
char* parametro;
char c = 0;
int longComando = 0;
int posInicioParametro = 0;
int consola = 1;
while (consola) {
posInicioParametro = 0;
eleccion = string_new();
comando = string_new();
puts(
"____________________________________________________________________\n\n"
"Comandos disponibles: \n"
"- 1) correr PATH \n"
"- 2) finalizar PID \n"
"- 3) ps \n"
"- 4) cpu \n"
"Ingrese un comando: ");
scanf("%c", &c);
//printf("Escanee %c\n",c);
longComando++;
eleccion = (char*) malloc( sizeof(char) * longComando );
string_append(&eleccion, string_repeat(c,1));
while(c != '\n'){
scanf("%c", &c);
//printf("Escanee %c\n",c);
longComando++;
eleccion = (char*) realloc(eleccion, sizeof(char) * longComando );
string_append(&eleccion, string_repeat(c,1));
}
eleccion = (char*) realloc(eleccion, sizeof(char) * (longComando+1) );
eleccion[longComando] = '\0';
int i = 0;
while(eleccion[i] != '\0'){
if(eleccion[i] == ' ') posInicioParametro = i+1;
i++;
}
//printf("El parametro empieza en la posicion %d\n", posInicioParametro);
if(posInicioParametro != 0){
parametro = string_new();
comando = (char*) malloc( sizeof(char) * strlen(string_substring(eleccion, 0, posInicioParametro-1)));
comando = string_substring(eleccion, 0, posInicioParametro-1);
parametro = (char*) malloc( sizeof(char) * strlen(string_substring_from(eleccion, posInicioParametro)));
parametro = string_substring_from(eleccion, posInicioParametro);
}
else{
//printf("strlen %d \n", strlen(eleccion));
eleccion[strlen(eleccion)-1] = '\0';
//printf("strlen %d \n", strlen(eleccion));
comando = (char*) malloc( sizeof(char) * strlen(eleccion) );
comando = string_duplicate(eleccion);
}
if(posInicioParametro == 0){
if(strcmp(eleccion, "ps") == 0){
printf("3Comando a ejecutar: %s\n", comando);
}
else{
if(strcmp(eleccion, "cpu") == 0){
printf("4Comando a ejecutar: %s\n", comando);
}
else{
printf("El comando (%s) ingresado no es valido \n", comando);
eleccion[0] = '\0';
comando[0] = '\0';
}
}
}
if(posInicioParametro != 0){
if(strcmp(comando, "correr") == 0){
printf("1Comando a ejecutar: %s %s\n", comando, parametro);
Enviar(socketCPU, comando);
Enviar(socketCPU, parametro);
}
else{
if(strcmp(comando, "finalizar") == 0){
printf("2Comando a ejecutar: %s %s\n", comando, parametro);
}
else{
printf("El comando (%s %s) ingresado no es valido \n", comando, parametro);
eleccion[0] = '\0';
comando[0] = '\0';
parametro[0] = '\0';
}
}
}
free(eleccion);
free(comando);
if(posInicioParametro != 0){
free(parametro);
}
}
}
