static bool field_endmsg(void *closure, const void *hd, upb_status *status) {
UPB_UNUSED(hd);
upb_descreader *r = closure;
upb_fielddef *f = r->f;
// TODO: verify that all required fields were present.
assert(upb_fielddef_number(f) != 0);
assert(upb_fielddef_name(f) != NULL);
assert((upb_fielddef_subdefname(f) != NULL) == upb_fielddef_hassubdef(f));
if (r->default_string) {
if (upb_fielddef_issubmsg(f)) {
upb_status_seterrmsg(status, "Submessages cannot have defaults.");
return false;
}
if (upb_fielddef_isstring(f) || upb_fielddef_type(f) == UPB_TYPE_ENUM) {
upb_fielddef_setdefaultcstr(f, r->default_string, NULL);
} else {
if (r->default_string && !parse_default(r->default_string, f)) {
// We don't worry too much about giving a great error message since the
// compiler should have ensured this was correct.
upb_status_seterrmsg(status, "Error converting default value.");
return false;
}
}
}
return true;
}
static void field_endmsg(void *_r, upb_status *status) {
upb_descreader *r = _r;
upb_fielddef *f = r->f;
// TODO: verify that all required fields were present.
assert(upb_fielddef_number(f) != 0 && upb_fielddef_name(f) != NULL);
assert((upb_fielddef_subdefname(f) != NULL) == upb_fielddef_hassubdef(f));
if (r->default_string) {
if (upb_fielddef_issubmsg(f)) {
upb_status_seterrliteral(status, "Submessages cannot have defaults.");
return;
}
if (upb_fielddef_isstring(f) || upb_fielddef_type(f) == UPB_TYPE(ENUM)) {
upb_fielddef_setdefaultcstr(f, r->default_string);
} else {
upb_value val;
upb_value_setptr(&val, NULL); // Silence inaccurate compiler warnings.
if (!parse_default(r->default_string, &val, upb_fielddef_type(f))) {
// We don't worry too much about giving a great error message since the
// compiler should have ensured this was correct.
upb_status_seterrliteral(status, "Error converting default value.");
return;
}
upb_fielddef_setdefault(f, val);
}
}
}
dns_result ReadName(unsigned char *reader, size_t data_len, unsigned short type, unsigned char *dns,
char *output_buf, size_t output_buf_size)
{
if (type < 1 || type > 256)
{
return DNS_RESULT_ERR;
}
switch (type)
{
case T_A:
return parse_ip(reader, output_buf, output_buf_size);
break;
case T_NS:
// printf("datalen: %d", data_len);
parse_ns(reader, (unsigned short)data_len, dns, output_buf, output_buf_size);
break;
case T_CNAME:
parse_cname(reader, dns, output_buf, output_buf_size, data_len);
break;
case T_SOA:
parse_soa(reader, (unsigned short)data_len, dns, output_buf, output_buf_size);
break;
case T_PTR:
parse_ptr(reader, (unsigned short)data_len, dns, output_buf, output_buf_size);
break;
case T_HINFO:
parse_hinfo(reader, (unsigned short)data_len, output_buf, output_buf_size);
break;
case T_MX:
parse_mx(reader, (unsigned short)data_len, dns, output_buf, output_buf_size);
break;
case T_TXT:
return parse_txt(reader, data_len, output_buf, output_buf_size);
break;
case T_RP:
parse_rp(reader, dns, output_buf, output_buf_size, data_len);
break;
case T_AFSDB:
parse_afsdb(reader, dns, output_buf, output_buf_size, data_len);
break;
case T_AAAA:
parse_aaaa(reader, output_buf, output_buf_size);
break;
case T_LOC:
parse_loc(reader, output_buf, output_buf_size);
break;
case T_SRV:
parse_srv(reader, dns, output_buf, output_buf_size, data_len);
break;
case T_NAPTR:
return parse_naptr(reader, (unsigned short)data_len, output_buf, output_buf_size);
break;
case T_RRSIG:
parse_rrsig(reader, dns, (unsigned short)data_len, output_buf, output_buf_size);
break;
case T_NSEC:
parse_nsec(reader, dns, output_buf, output_buf_size, data_len);
break;
case T_DNSKEY:
parse_dnskey(reader, (unsigned short)data_len, output_buf, output_buf_size);
break;
default:
parse_default(reader, (unsigned short)data_len, output_buf, output_buf_size);
break;
}
return DNS_RESULT_OK;
}
int
parse_config(char *config_file, boolean_t file_required)
{
FILE *fp;
char line[MAXLINELEN];
char pline[MAXLINELEN];
int argcount;
char *argvec[MAXARGSPERLINE];
int defaultdone = 0; /* Set when first non-default command found */
if (debug & D_CONFIG)
logmsg(LOG_DEBUG, "parse_config()\n");
set_protocol_defaults();
if (debug & D_DEFAULTS)
print_defaults();
fp = open_conffile(config_file);
if (fp == NULL) {
if (errno == ENOENT && !file_required)
return (0);
logperror(config_file);
return (-1);
}
while (readline(fp, line, sizeof (line)) != 0) {
(void) strncpy(pline, line, sizeof (pline));
pline[sizeof (pline) - 1] = '\0'; /* NULL terminate */
argcount = parse_line(pline, argvec,
sizeof (argvec) / sizeof (argvec[0]));
if (debug & D_PARSE) {
int i;
logmsg(LOG_DEBUG, "scanned %d args\n", argcount);
for (i = 0; i < argcount; i++)
logmsg(LOG_DEBUG, "arg[%d]: %s\n",
i, argvec[i]);
}
if (argcount == 0) {
/* Empty line - or comment only line */
continue;
}
if (strcmp(argvec[0], "ifdefault") == 0) {
char save[sizeof (ifdefaults)];
if (defaultdone) {
conferr("ifdefault after non-default "
"command\n");
continue;
}
/*
* Save existing values in case what we read is
* invalid and we need to restore previous settings.
*/
(void) memcpy(save, ifdefaults, sizeof (ifdefaults));
parse_default(CONFIG_IF, iflist, argvec+1, argcount-1,
ifdefaults);
check_if_var_consistency(ifdefaults, save,
sizeof (save));
} else if (strcmp(argvec[0], "prefixdefault") == 0) {
char save[sizeof (prefixdefaults)];
if (defaultdone) {
conferr("prefixdefault after non-default "
"command\n");
continue;
}
/*
* Save existing values in case what we read is
* invalid and we need to restore previous settings.
*/
(void) memcpy(save, prefixdefaults,
sizeof (prefixdefaults));
parse_default(CONFIG_PREFIX, prefixlist, argvec+1,
argcount-1, prefixdefaults);
check_var_consistency(prefixdefaults, save,
sizeof (save));
} else if (strcmp(argvec[0], "if") == 0) {
defaultdone = 1;
parse_if(iflist, argvec+1, argcount-1);
} else if (strcmp(argvec[0], "prefix") == 0) {
defaultdone = 1;
parse_prefix(prefixlist, argvec+1, argcount-1);
} else {
conferr("Unknown command: %s\n", argvec[0]);
}
}
(void) fclose(fp);
if (debug & D_DEFAULTS)
print_defaults();
return (0);
}
std::list<SDL::StateDescriptor> SDL::Parser::parse()
{
std::list<StateDescriptor> descriptors;
StateDescriptor descBuffer;
VarDescriptor varBuffer;
int state = e_State_File;
for ( ;; ) {
SDL::Token tok = next();
if (tok.m_type == e_TokError)
break;
if (tok.m_type == e_TokEof) {
if (state != e_State_File)
fprintf(stderr, "[SDL] Unexpected EOF in %s\n", m_filename.c_str());
break;
}
switch (tok.m_type) {
case '(':
if (state == e_State_Default) {
push(tok);
state = parse_default(&varBuffer, this);
} else {
BAD_TOK(tok.m_type, this);
}
break;
case ')':
BAD_TOK(tok.m_type, this);
break;
case ';':
// Dunno what this is doing here... >_>
break;
case '=':
if (state == e_State_Default_EQ) {
state = e_State_Default;
} else if (state == e_State_DefaultOption_EQ) {
state = e_State_DefaultOption;
} else if (state == e_State_DisplayOption_EQ) {
state = e_State_DisplayOption;
} else {
BAD_TOK(tok.m_type, this);
}
break;
case '[':
if (state == e_State_Var_SZ) {
state = e_State_SZ_N;
} else {
BAD_TOK(tok.m_type, this);
}
break;
case ']':
if (state == e_State_SZ_N) {
varBuffer.m_size = -1;
state = e_State_Var;
} else if (state == e_State_SZ_X) {
state = e_State_Var;
} else {
BAD_TOK(tok.m_type, this);
}
break;
case '{':
if (state == e_State_Statedesc_BR) {
state = e_State_Statedesc;
} else {
BAD_TOK(tok.m_type, this);
}
break;
case '}':
if (state == e_State_Var /*|| state == e_State_Var_SZ*/) {
descBuffer.m_vars.push_back(varBuffer);
descriptors.push_back(descBuffer);
state = e_State_File;
} else if (state == e_State_Statedesc) {
descriptors.push_back(descBuffer);
state = e_State_File;
} else {
BAD_TOK(tok.m_type, this);
}
break;
case e_TokStatedesc:
if (state == e_State_File) {
state = e_State_Statedesc_ID;
} else {
BAD_TOK(tok.m_type, this);
}
descBuffer.m_name = DS::String();
descBuffer.m_vars.clear();
descBuffer.m_version = -1;
break;
case e_TokVersion:
if (state == e_State_Var /*|| state == e_State_Var_SZ*/) {
descBuffer.m_vars.push_back(varBuffer);
state = e_State_Version_N;
} else if (state == e_State_Statedesc) {
state = e_State_Version_N;
} else {
BAD_TOK(tok.m_type, this);
}
break;
case e_TokVar:
if (state == e_State_Var /*|| state == e_State_Var_SZ*/) {
descBuffer.m_vars.push_back(varBuffer);
state = e_State_Var_TP;
} else if (state == e_State_Statedesc) {
state = e_State_Var_TP;
} else {
BAD_TOK(tok.m_type, this);
}
varBuffer.m_type = static_cast<SDL::VarType>(-1);
varBuffer.m_typeName = DS::String();
varBuffer.m_name = DS::String();
varBuffer.m_size = 0;
varBuffer.m_default.m_valid = false;
varBuffer.m_defaultOption = DS::String();
break;
case e_TokInt:
TYPE_TOK(e_VarInt);
break;
case e_TokFloat:
TYPE_TOK(e_VarFloat);
break;
case e_TokBool:
TYPE_TOK(e_VarBool);
break;
case e_TokString:
TYPE_TOK(e_VarString);
break;
case e_TokPlKey:
TYPE_TOK(e_VarKey);
break;
case e_TokCreatable:
TYPE_TOK(e_VarCreatable);
break;
case e_TokDouble:
TYPE_TOK(e_VarDouble);
break;
case e_TokTime:
TYPE_TOK(e_VarTime);
break;
case e_TokByte:
TYPE_TOK(e_VarByte);
break;
case e_TokShort:
TYPE_TOK(e_VarShort);
break;
case e_TokAgeTimeOfDay:
TYPE_TOK(e_VarAgeTimeOfDay);
break;
case e_TokVector3:
TYPE_TOK(e_VarVector3);
break;
case e_TokPoint3:
TYPE_TOK(e_VarPoint3);
break;
case e_TokQuat:
TYPE_TOK(e_VarQuaternion);
break;
case e_TokRgb:
TYPE_TOK(e_VarRgb);
break;
case e_TokRgb8:
TYPE_TOK(e_VarRgb8);
break;
case e_TokRgba:
TYPE_TOK(e_VarRgba);
break;
case e_TokRgba8:
TYPE_TOK(e_VarRgba8);
break;
case e_TokDefault:
if (/*state == e_State_Var_SZ ||*/ state == e_State_Var) {
state = e_State_Default_EQ;
} else {
BAD_TOK(tok.m_type, this);
}
break;
case e_TokDefaultOption:
if (/*state == e_State_Var_SZ ||*/ state == e_State_Var) {
state = e_State_DefaultOption_EQ;
} else {
BAD_TOK(tok.m_type, this);
}
break;
case e_TokDisplayOption:
if (/*state == e_State_Var_SZ ||*/ state == e_State_Var) {
state = e_State_DisplayOption_EQ;
} else {
BAD_TOK(tok.m_type, this);
}
break;
case e_TokIdent:
if (state == e_State_Statedesc_ID) {
descBuffer.m_name = tok.m_value;
state = e_State_Statedesc_BR;
} else if (state == e_State_Var_ID) {
varBuffer.m_name = tok.m_value;
state = e_State_Var_SZ;
} else if (state == e_State_Default) {
push(tok);
state = parse_default(&varBuffer, this);
} else if (state == e_State_DefaultOption) {
varBuffer.m_defaultOption = tok.m_value;
state = e_State_Var;
} else if (state == e_State_DisplayOption) {
varBuffer.m_displayOption = tok.m_value;
state = e_State_Var;
} else {
BAD_TOK(tok.m_type, this);
}
break;
case e_TokNumeric:
if (state == e_State_Version_N) {
descBuffer.m_version = strtol(tok.m_value.c_str(), 0, 0);
state = e_State_Statedesc;
} else if (state == e_State_SZ_N) {
varBuffer.m_size = strtol(tok.m_value.c_str(), 0, 0);
state = e_State_SZ_X;
} else if (state == e_State_Default) {
push(tok);
state = parse_default(&varBuffer, this);
} else {
BAD_TOK(tok.m_type, this);
}
break;
case e_TokQuoted:
if (state == e_State_Default) {
push(tok);
state = parse_default(&varBuffer, this);
} else {
BAD_TOK(tok.m_type, this);
}
break;
case e_TokTypename:
if (state == e_State_Var_TP) {
varBuffer.m_type = e_VarStateDesc;
varBuffer.m_typeName = tok.m_value;
state = e_State_Var_ID;
} else {
BAD_TOK(tok.m_type, this);
}
break;
default:
BAD_TOK(tok.m_type, this);
break;
}
}
return descriptors;
}
