size_t
text_buffer_add_string (struct text_buffer *buf, const char *str, size_t len)
{
text_buffer_alloc (buf, len);
memcpy (buf->base + buf->off, str, len);
buf->off += len;
return len;
}
void debug_console_init(running_machine *machine)
{
/* allocate text buffers */
console_textbuf = text_buffer_alloc(CONSOLE_BUF_SIZE, CONSOLE_MAX_LINES);
if (!console_textbuf)
return;
errorlog_textbuf = text_buffer_alloc(ERRORLOG_BUF_SIZE, ERRORLOG_MAX_LINES);
if (!errorlog_textbuf)
return;
/* print the opening lines */
debug_console_printf("MAME new debugger version %s\n", build_version);
debug_console_printf("Currently targeting %s (%s)\n", Machine->gamedrv->name, Machine->gamedrv->description);
/* request callback upon exiting */
add_exit_callback(machine, debug_console_exit);
}
void debug_console_init(running_machine &machine)
{
/* allocate text buffers */
console_textbuf = text_buffer_alloc(CONSOLE_BUF_SIZE, CONSOLE_MAX_LINES);
if (!console_textbuf)
return;
errorlog_textbuf = text_buffer_alloc(ERRORLOG_BUF_SIZE, ERRORLOG_MAX_LINES);
if (!errorlog_textbuf)
return;
/* print the opening lines */
debug_console_printf(machine, "%s debugger version %s\n", emulator_info::get_appname(), build_version);
debug_console_printf(machine, "Currently targeting %s (%s)\n", machine.system().name, machine.system().description);
/* request callback upon exiting */
machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(debug_console_exit), &machine));
}
size_t
text_buffer_fill (struct text_buffer *buf, int c, size_t len)
{
char *p;
int i;
text_buffer_alloc (buf, len);
for (i = 0, p = buf->base + buf->off; i < len; i++)
*p++ = c;
buf->off += len;
return len;
}
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;
}
