static enum parser_error parse_prefs_m(struct parser *p)
{
int a, msg_index;
const char *attr;
const char *type;
struct prefs_data *d = parser_priv(p);
assert(d != NULL);
if (d->bypass)
return PARSE_ERROR_NONE;
type = parser_getsym(p, "type");
attr = parser_getsym(p, "attr");
msg_index = message_lookup_by_name(type);
if (msg_index < 0)
return PARSE_ERROR_GENERIC;
if (strlen(attr) > 1)
a = color_text_to_attr(attr);
else
a = color_char_to_attr(attr[0]);
if (a < 0)
return PARSE_ERROR_INVALID_COLOR;
message_color_define(msg_index, (byte)a);
return PARSE_ERROR_NONE;
}
static enum parser_error parse_prefs_m(struct parser *p)
{
int a, type;
const char *attr;
struct prefs_data *d = parser_priv(p);
assert(d != NULL);
if (d->bypass)
return PARSE_ERROR_NONE;
type = parser_getint(p, "type");
attr = parser_getsym(p, "attr");
if (strlen(attr) > 1)
a = color_text_to_attr(attr);
else
a = color_char_to_attr(attr[0]);
if (a < 0)
return PARSE_ERROR_INVALID_COLOR;
message_color_define((u16b) type, (byte) a);
return PARSE_ERROR_NONE;
}
/*
* Output text to the screen or to a file depending on the
* selected hook. Takes strings with "embedded formatting",
* such that something within {red}{/} will be printed in red.
*
* Note that such formatting will be treated as a "breakpoint"
* for the printing, so if used within words may lead to part of the
* word being moved to the next line.
*/
void text_out_e(const char *fmt, ...)
{
char buf[1024];
char smallbuf[1024];
va_list vp;
const char *start, *next, *text, *tag;
size_t textlen, taglen = 0;
/* Begin the Varargs Stuff */
va_start(vp, fmt);
/* Do the va_arg fmt to the buffer */
(void)vstrnfmt(buf, sizeof(buf), fmt, vp);
/* End the Varargs Stuff */
va_end(vp);
start = buf;
while (next_section(start, 0, &text, &textlen, &tag, &taglen, &next))
{
int a = -1;
memcpy(smallbuf, text, textlen);
smallbuf[textlen] = 0;
if (tag)
{
char tagbuffer[11];
/* Colour names are less than 11 characters long. */
assert(taglen < 11);
memcpy(tagbuffer, tag, taglen);
tagbuffer[taglen] = '\0';
a = color_text_to_attr(tagbuffer);
}
if (a == -1)
a = TERM_WHITE;
/* Output now */
text_out_hook(a, smallbuf);
start = next;
}
}
static enum parser_error parse_r_c(struct parser *p) {
struct monster_race *r = parser_priv(p);
const char *color;
int attr;
if (!r)
return PARSE_ERROR_MISSING_RECORD_HEADER;
color = parser_getsym(p, "color");
if (strlen(color) > 1)
attr = color_text_to_attr(color);
else
attr = color_char_to_attr(color[0]);
if (attr < 0)
return PARSE_ERROR_INVALID_COLOR;
r->d_attr = attr;
return PARSE_ERROR_NONE;
}
/*
* Initialize the "f_info" array, by parsing an ascii "template" file
*/
errr parse_f_info(char *buf, header *head)
{
int i;
char *s;
/* Current entry */
static feature_type *f_ptr = NULL;
/* Process 'N' for "New/Number/Name" */
if (buf[0] == 'N')
{
/* Find the colon before the name */
s = strchr(buf+2, ':');
/* Verify that colon */
if (!s) return (PARSE_ERROR_GENERIC);
/* Nuke the colon, advance to the name */
*s++ = '\0';
/* Paranoia -- require a name */
if (!*s) return (PARSE_ERROR_GENERIC);
/* Get the index */
i = atoi(buf+2);
/* Verify information */
if (i <= error_idx) return (PARSE_ERROR_NON_SEQUENTIAL_RECORDS);
/* Verify information */
if (i >= head->info_num) return (PARSE_ERROR_TOO_MANY_ENTRIES);
/* Save the index */
error_idx = i;
/* Point at the "info" */
f_ptr = (feature_type*)head->info_ptr + i;
/* Store the name */
if (!(f_ptr->name = add_name(head, s)))
return (PARSE_ERROR_OUT_OF_MEMORY);
/* Default "mimic" */
f_ptr->mimic = i;
}
/* Process 'M' for "Mimic" (one line only) */
else if (buf[0] == 'M')
{
int mimic;
/* There better be a current f_ptr */
if (!f_ptr) return (PARSE_ERROR_MISSING_RECORD_HEADER);
/* Scan for the values */
if (1 != sscanf(buf+2, "%d",
&mimic)) return (PARSE_ERROR_GENERIC);
/* Save the values */
f_ptr->mimic = mimic;
}
/* Process 'G' for "Graphics" (one line only) */
else if (buf[0] == 'G')
{
char d_char;
int d_attr;
/* There better be a current f_ptr */
if (!f_ptr) return (PARSE_ERROR_MISSING_RECORD_HEADER);
/* Paranoia */
if (!buf[2]) return (PARSE_ERROR_GENERIC);
if (!buf[3]) return (PARSE_ERROR_GENERIC);
if (!buf[4]) return (PARSE_ERROR_GENERIC);
/* Extract d_char */
d_char = buf[2];
/* If we have a longer string than expected ... */
if (buf[5])
{
/* Advance "buf" on by 4 */
buf += 4;
/* Extract the colour */
d_attr = color_text_to_attr(buf);
}
else
{
/* Extract the attr */
d_attr = color_char_to_attr(buf[4]);
}
/* Paranoia */
if (d_attr < 0) return (PARSE_ERROR_GENERIC);
/* Save the values */
f_ptr->d_attr = d_attr;
f_ptr->d_char = d_char;
}
else
{
/* Oops */
return (PARSE_ERROR_UNDEFINED_DIRECTIVE);
}
/* Success */
return (0);
}
