void debug_console_exit(running_machine *machine)
{
/* free allocated memory */
if (console_textbuf)
text_buffer_free(console_textbuf);
console_textbuf = NULL;
if (errorlog_textbuf)
text_buffer_free(errorlog_textbuf);
errorlog_textbuf = NULL;
/* free the command list */
commandlist = NULL;
}
static int
vtxt_disconnect (sqlite3_vtab * pVTab)
{
/* disconnects the virtual table */
VirtualTextPtr p_vt = (VirtualTextPtr) pVTab;
if (p_vt->buffer)
text_buffer_free (p_vt->buffer);
sqlite3_free (p_vt);
return SQLITE_OK;
}
static struct text_buffer *
text_parse (char *path, char *encoding, char first_line_titles,
char field_separator, char text_separator, char decimal_separator)
{
/* trying to open and parse the text file */
int c;
int fld;
int len;
int max_cell;
int is_string = 0;
char last = '\0';
char *fields[4096];
char buffer[35536];
char *p = buffer;
struct text_buffer *text;
int nrows;
int ncols;
int errs;
struct row_buffer *row;
void *toUtf8;
int encoding_errors;
int ir;
char title[64];
char *first_valid_row;
int i;
char *name;
for (fld = 0; fld < 4096; fld++)
{
/* preparing an empty row */
fields[fld] = NULL;
}
/* trying to open the text file */
FILE *in = fopen (path, "rb");
if (!in)
return NULL;
text = text_buffer_alloc ();
fld = 0;
while ((c = getc (in)) != EOF)
{
/* parsing the file, one char at each time */
if (c == '\r' && !is_string)
{
last = c;
continue;
}
if (c == field_separator && !is_string)
{
/* insering a field into the fields tmp array */
last = c;
*p = '\0';
len = strlen (buffer);
if (len)
{
fields[fld] = malloc (len + 1);
strcpy (fields[fld], buffer);
}
fld++;
p = buffer;
*p = '\0';
continue;
}
if (c == text_separator)
{
/* found a text separator */
if (is_string)
{
is_string = 0;
last = c;
}
else
{
if (last == text_separator)
*p++ = text_separator;
is_string = 1;
}
continue;
}
last = c;
if (c == '\n' && !is_string)
{
/* inserting the row into the text buffer */
*p = '\0';
len = strlen (buffer);
if (len)
{
fields[fld] = malloc (len + 1);
strcpy (fields[fld], buffer);
}
fld++;
p = buffer;
*p = '\0';
max_cell = -1;
for (fld = 0; fld < 4096; fld++)
{
if (fields[fld])
max_cell = fld;
}
text_insert_row (text, fields, max_cell);
for (fld = 0; fld < 4096; fld++)
{
/* resetting an empty row */
fields[fld] = NULL;
}
fld = 0;
continue;
}
*p++ = c;
}
fclose (in);
/* checking if the text file really seems to contain a table */
nrows = 0;
ncols = 0;
errs = 0;
row = text->first;
while (row)
{
if (first_line_titles && row == text->first)
{
/* skipping first line */
row = row->next;
continue;
}
nrows++;
if (row->n_cells > ncols)
ncols = row->n_cells;
row = row->next;
}
if (nrows == 0 && ncols == 0)
{
text_buffer_free (text);
return NULL;
}
text->n_rows = nrows;
/* going to check the column types */
text->max_n_cells = ncols;
text->types = malloc (sizeof (char) * text->max_n_cells);
first_valid_row = malloc (sizeof (char) * text->max_n_cells);
for (fld = 0; fld < text->max_n_cells; fld++)
{
/* initally assuming any cell contains TEXT */
*(text->types + fld) = VRTTXT_TEXT;
*(first_valid_row + fld) = 1;
}
row = text->first;
while (row)
{
if (first_line_titles && row == text->first)
{
/* skipping first line */
row = row->next;
continue;
}
for (fld = 0; fld < row->n_cells; fld++)
{
if (*(row->cells + fld))
{
if (text_is_integer (*(row->cells + fld)))
{
if (*(first_valid_row + fld))
{
*(text->types + fld) = VRTTXT_INTEGER;
*(first_valid_row + fld) = 0;
}
}
else if (text_is_double
(*(row->cells + fld), decimal_separator))
{
if (*(first_valid_row + fld))
{
*(text->types + fld) = VRTTXT_DOUBLE;
*(first_valid_row + fld) = 0;
}
else
{
/* promoting an INTEGER column to be of the DOUBLE type */
if (*(text->types + fld) == VRTTXT_INTEGER)
*(text->types + fld) = VRTTXT_DOUBLE;
}
}
else
{
/* this column is anyway of the TEXT type */
*(text->types + fld) = VRTTXT_TEXT;
if (*(first_valid_row + fld))
*(first_valid_row + fld) = 0;
}
}
}
row = row->next;
}
free (first_valid_row);
/* preparing the column names */
text->titles = malloc (sizeof (char *) * text->max_n_cells);
if (first_line_titles)
{
for (fld = 0; fld < text->max_n_cells; fld++)
{
if (fld >= text->first->n_cells)
{
/* this column name is NULL; setting a default name */
sprintf (title, "COL%03d", fld + 1);
len = strlen (title);
*(text->titles + fld) = malloc (len + 1);
strcpy (*(text->titles + fld), title);
}
else
{
if (*(text->first->cells + fld))
{
len = strlen (*(text->first->cells + fld));
*(text->titles + fld) = malloc (len + 1);
strcpy (*(text->titles + fld),
*(text->first->cells + fld));
name = *(text->titles + fld);
for (i = 0; i < len; i++)
{
/* masking any space in the column name */
if (*(name + i) == ' ')
*(name + i) = '_';
}
}
else
{
/* this column name is NULL; setting a default name */
sprintf (title, "COL%03d", fld + 1);
len = strlen (title);
*(text->titles + fld) = malloc (len + 1);
strcpy (*(text->titles + fld), title);
}
}
}
}
else
{
for (fld = 0; fld < text->max_n_cells; fld++)
{
sprintf (title, "COL%03d", fld + 1);
len = strlen (title);
*(text->titles + fld) = malloc (len + 1);
strcpy (*(text->titles + fld), title);
}
}
/* cleaning cell values when needed */
toUtf8 = iconvCreateUTF8Converter (encoding);
if (!toUtf8)
{
text_buffer_free (text);
return NULL;
}
encoding_errors = 0;
row = text->first;
while (row)
{
if (first_line_titles && row == text->first)
{
/* skipping first line */
row = row->next;
continue;
}
for (fld = 0; fld < row->n_cells; fld++)
{
if (*(row->cells + fld))
{
if (*(text->types + fld) == VRTTXT_INTEGER)
text_clean_integer (*(row->cells + fld));
else if (*(text->types + fld) == VRTTXT_DOUBLE)
text_clean_double (*(row->cells + fld));
else
encoding_errors +=
text_clean_text (row->cells + fld, toUtf8);
}
}
row = row->next;
}
iconvFreeUTF8Converter (toUtf8);
if (encoding_errors)
{
text_buffer_free (text);
return NULL;
}
/* ok, we can now go to prepare the rows array */
text->rows = malloc (sizeof (struct text_row *) * text->n_rows);
ir = 0;
row = text->first;
while (row)
{
if (first_line_titles && row == text->first)
{
/* skipping first line */
row = row->next;
continue;
}
*(text->rows + ir++) = row;
row = row->next;
}
return text;
}
static int
tag_image (char *text, struct text_buffer *outbuf)
{
mbi_iterator_t iter;
enum { state_kw, state_val, state_qstr, state_delim } state = state_kw;
struct text_buffer tmpbuf;
char *kw;
struct info_tag *tag_head = NULL, *tag;
int escaped = 0;
text_buffer_init (&tmpbuf);
for (mbi_init (iter, text, strlen (text)); mbi_avail (iter);
mbi_advance (iter))
{
const char *cur_ptr;
size_t cur_len;
if (mb_isspace (mbi_cur (iter)))
{
if (state == state_val)
{
struct info_tag *new_kw = tag_found_keyword (&tmpbuf, &kw);
new_kw->next = tag_head;
tag_head = new_kw;
state = state_delim;
continue;
}
if (state == state_delim)
continue;
}
cur_len = mb_len (mbi_cur (iter));
cur_ptr = mbi_cur_ptr (iter);
if (state == state_qstr && escaped)
{
escaped = 0;
}
else if (cur_len == 1)
{
switch (*cur_ptr)
{
case '=':
text_buffer_add_char (&tmpbuf, 0);
kw = tmpbuf.base;
if (!mbi_avail (iter))
break;
mbi_advance (iter);
state = state_val;
cur_len = mb_len (mbi_cur (iter));
cur_ptr = mbi_cur_ptr (iter);
if (!(cur_len == 1 && *cur_ptr == '"'))
break;
/* fall through */
case '"':
if (state == state_val)
{
state = state_qstr;
continue;
}
if (state == state_qstr)
{
struct info_tag *new_kw = tag_found_keyword (&tmpbuf, &kw);
new_kw->next = tag_head;
tag_head = new_kw;
state = state_delim;
continue;
}
break;
case '\\':
if (state == state_qstr)
{
escaped = 1;
continue;
}
}
}
text_buffer_add_string (&tmpbuf, cur_ptr, cur_len);
}
tag = info_tag_find (tag_head, "text");
if (!tag)
tag = info_tag_find (tag_head, "alt");
if (tag)
{
text_buffer_add_string (outbuf, tag->val, strlen (tag->val));
}
text_buffer_free (&tmpbuf);
info_tag_free (tag_head);
return 0;
}
