enlightenment/efl
enlightenment
/
efl
8
7
Fork 14
Code Issues 13 Pull Requests 1 Projects Releases Wiki Activity

Fork'n'bitch is now operational. 

TODO -
* Actually make the limits mean something.
* Clean up all that allocing and copying.  I'm sure I could make that better.


SVN revision: 19915
This commit is contained in:
David Walter Seikel 2006-01-20 04:42:35 +00:00
parent 836e5963c5
commit 96b9fe94e5
1 changed files with 122 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

245
legacy/ecore/src/lib/ecore/ecore_exe.c
View File

@ -552,19 +552,136 @@ ecore_exe_auto_limits_set(Ecore_Exe *exe, int start_bytes, int end_bytes, int st
*/
}
/**
* Gets the auto pipe data for the given process handle
*
* @param exe The given process handle.
* @param flags The flag parameters for how to deal with inter-process I/O
* @ingroup Ecore_Exe_Basic_Group
*/
EAPI Ecore_Exe_Event_Data *
ecore_exe_event_data_get(Ecore_Exe *exe, Ecore_Exe_Flags flags)
{
Ecore_Exe_Event_Data *e = NULL;
int is_buffered = 0;
unsigned char *inbuf;
int inbuf_num;
if (!ECORE_MAGIC_CHECK(exe, ECORE_MAGIC_EXE))
{
ECORE_MAGIC_FAIL(exe, ECORE_MAGIC_EXE,
"ecore_exe_event_data_get");
return NULL;
}
/* FIXME: sanitize the input. */
/* FIXME: insert code here. */
return NULL;
/* Sort out what sort of event we are. */
if (flags & ECORE_FD_READ)
{
flags = ECORE_FD_READ;
if (exe->flags & ECORE_EXE_PIPE_READ_LINE_BUFFERED)
is_buffered = 1;
}
else
{
flags = ECORE_FD_ERROR;
if (exe->flags & ECORE_EXE_PIPE_ERROR_LINE_BUFFERED)
is_buffered = 1;
}
/* Get the data. */
if (flags & ECORE_FD_READ)
{
inbuf = exe->read_data_buf;
inbuf_num = exe->read_data_size;
exe->read_data_buf = NULL;
exe->read_data_size = 0;
}
else
{
inbuf = exe->error_data_buf;
inbuf_num = exe->error_data_size;
exe->error_data_buf = NULL;
exe->error_data_size = 0;
}
e = calloc(1, sizeof(Ecore_Exe_Event_Data));
if (e)
{
e->exe = exe;
e->data = inbuf;
e->size = inbuf_num;
if (is_buffered)
{ /* Deal with line buffering. */
int max = 0;
int count = 0;
int i;
int last = 0;
char *c;
c = (char *)inbuf;
for (i = 0; i < inbuf_num; i++) /* Find the lines. */
{
if (inbuf[i] == '\n')
{
if (count >= max)
{
/* In testing, the lines seem to arrive in batches of 500 to 1000 lines at most, roughly speaking. */
max += 10; /* FIXME: Maybe keep track of the largest number of lines ever sent, and add half that many instead of 10. */
e->lines = realloc(e->lines, sizeof(Ecore_Exe_Event_Data_Line) * (max + 1)); /* Allow room for the NULL termination. */
}
/* raster said to leave the line endings as line endings, however -
* This is line buffered mode, we are not dealing with binary here, but lines.
* If we are not dealing with binary, we must be dealing with ASCII, unicode, or some other text format.
* Thus the user is most likely gonna deal with this text as strings.
* Thus the user is most likely gonna pass this data to str functions.
* rasters way - the endings are always gonna be '\n'; onefangs way - they will always be '\0'
* We are handing them the string length as a convenience.
* Thus if they really want it in raw format, they can e->lines[i].line[e->lines[i].size - 1] = '\n'; easily enough.
* In the default case, we can do this conversion quicker than the user can, as we already have the index and pointer.
* Let's make it easy on them to use these as standard C strings.
*
* onefang is proud to announce that he has just set a new personal record for the
* most over documentation of a simple assignment statement. B-)
*/
inbuf[i] = '\0';
e->lines[count].line = c;
e->lines[count].size = i - last;
last = i + 1;
c = (char *)&inbuf[last];
count++;
}
}
if (count == 0) /* No lines to send, cancel the event. */
{
_ecore_exe_event_exe_data_free(NULL, e);
e = NULL;
}
else /* NULL terminate the array, so that people know where the end is. */
{
e->lines[count].line = NULL;
e->lines[count].size = 0;
}
if (i > last) /* Partial line left over, save it for next time. */
{
e->size = last;
if (flags & ECORE_FD_READ)
{
exe->read_data_size = i - last;
exe->read_data_buf = malloc(exe->read_data_size);
memcpy(exe->read_data_buf, c, exe->read_data_size);
}
else
{
exe->error_data_size = i - last;
exe->error_data_buf = malloc(exe->error_data_size);
memcpy(exe->error_data_buf, c, exe->error_data_size);
}
}
}
}
return e;
}
@ -1059,124 +1176,6 @@ _ecore_exe_exec_it(const char *exe_cmd)
return;
}
static Ecore_Exe_Event_Data *
_ecore_exe_create_event_data(Ecore_Exe *exe, Ecore_Fd_Handler_Flags flags)
{
Ecore_Exe_Event_Data *e = NULL;
int is_buffered = 0;
unsigned char *inbuf;
int inbuf_num;
/* Sort out what sort of event we are. */
if (flags & ECORE_FD_READ)
{
flags = ECORE_FD_READ;
if (exe->flags & ECORE_EXE_PIPE_READ_LINE_BUFFERED)
is_buffered = 1;
}
else
{
flags = ECORE_FD_ERROR;
if (exe->flags & ECORE_EXE_PIPE_ERROR_LINE_BUFFERED)
is_buffered = 1;
}
/* Get the data. */
if (flags & ECORE_FD_READ)
{
inbuf = exe->read_data_buf;
inbuf_num = exe->read_data_size;
exe->read_data_buf = NULL;
exe->read_data_size = 0;
}
else
{
inbuf = exe->error_data_buf;
inbuf_num = exe->error_data_size;
exe->error_data_buf = NULL;
exe->error_data_size = 0;
}
e = calloc(1, sizeof(Ecore_Exe_Event_Data));
if (e)
{
e->exe = exe;
e->data = inbuf;
e->size = inbuf_num;
if (is_buffered)
{ /* Deal with line buffering. */
int max = 0;
int count = 0;
int i;
int last = 0;
char *c;
c = (char *)inbuf;
for (i = 0; i < inbuf_num; i++) /* Find the lines. */
{
if (inbuf[i] == '\n')
{
if (count >= max)
{
/* In testing, the lines seem to arrive in batches of 500 to 1000 lines at most, roughly speaking. */
max += 10; /* FIXME: Maybe keep track of the largest number of lines ever sent, and add half that many instead of 10. */
e->lines = realloc(e->lines, sizeof(Ecore_Exe_Event_Data_Line) * (max + 1)); /* Allow room for the NULL termination. */
}
/* raster said to leave the line endings as line endings, however -
* This is line buffered mode, we are not dealing with binary here, but lines.
* If we are not dealing with binary, we must be dealing with ASCII, unicode, or some other text format.
* Thus the user is most likely gonna deal with this text as strings.
* Thus the user is most likely gonna pass this data to str functions.
* rasters way - the endings are always gonna be '\n'; onefangs way - they will always be '\0'
* We are handing them the string length as a convenience.
* Thus if they really want it in raw format, they can e->lines[i].line[e->lines[i].size - 1] = '\n'; easily enough.
* In the default case, we can do this conversion quicker than the user can, as we already have the index and pointer.
* Let's make it easy on them to use these as standard C strings.
*
* onefang is proud to announce that he has just set a new personal record for the
* most over documentation of a simple assignment statement. B-)
*/
inbuf[i] = '\0';
e->lines[count].line = c;
e->lines[count].size = i - last;
last = i + 1;
c = (char *)&inbuf[last];
count++;
}
}
if (count == 0) /* No lines to send, cancel the event. */
{
_ecore_exe_event_exe_data_free(NULL, e);
e = NULL;
}
else /* NULL terminate the array, so that people know where the end is. */
{
e->lines[count].line = NULL;
e->lines[count].size = 0;
}
if (i > last) /* Partial line left over, save it for next time. */
{
e->size = last;
if (flags & ECORE_FD_READ)
{
exe->read_data_size = i - last;
exe->read_data_buf = malloc(exe->read_data_size);
memcpy(exe->read_data_buf, c, exe->read_data_size);
}
else
{
exe->error_data_size = i - last;
exe->error_data_buf = malloc(exe->error_data_size);
memcpy(exe->error_data_buf, c, exe->error_data_size);
}
}
}
}
return e;
}
static int
_ecore_exe_data_generic_handler(void *data, Ecore_Fd_Handler *fd_handler, Ecore_Fd_Handler_Flags flags)
{
@ -1269,7 +1268,7 @@ _ecore_exe_data_generic_handler(void *data, Ecore_Fd_Handler *fd_handler, Ecore_
if (! (exe->flags & ECORE_EXE_PIPE_AUTO))
{
e = _ecore_exe_create_event_data(exe, flags);
e = ecore_exe_event_data_get(exe, flags);
if (e) /* Send the event. */
ecore_event_add(event_type, e,
_ecore_exe_event_exe_data_free, NULL);