static void parse_method(fb_parser_t *P, fb_member_t *fld) { fb_token_t *t; if (!(t = match(P, LEX_TOK_ID, "method expected identifier"))) { goto fail; } fld->symbol.ident = t; if (!match(P, '(', "method expected '(' after identifier")) { goto fail; } parse_type(P, &fld->req_type); if (!match(P, ')', "method expected ')' after request type")) { goto fail; } if (!match(P, ':', "method expected ':' before mandatory response type")) { goto fail; } parse_type(P, &fld->type); if ((t = optional(P, '='))) { error_tok(P, t, "method does not accept an initializer"); goto fail; } fld->metadata = parse_metadata(P); advance(P, ';', "method must be terminated with ';'", 0); return; fail: recover2(P, ';', 1, '}', 0); }
void sessions_init(char *types) { char *comma; struct session *elt; bonus_time = 0; sessions_track_types = TYPE_NONE; while (NULL != (comma = strchr(types, ','))) { *comma = '\0'; sessions_track_types |= parse_type(types); types = comma + 1; } sessions_track_types |= parse_type(types); while (sessions_count) { elt = first_session; first_session = first_session->next; --sessions_count; dumper_close(elt->dumper); free(elt); } # ifdef HAVE_LIBOOH323C ooH323EpInitialize(OO_CALLMODE_AUDIOCALL, "/dev/null"); ooH323EpDisableAutoAnswer(); # endif track_sessions = 1; }
size_t smbresult_tocsv(smbresult data, char **buf, char *ace) { if(data.statuscode < 0) { return 0; } //parsehidden returns 0 or 1, so we need a quick if statement char hidden = ' '; if(parse_hidden(data.mode)) hidden = 'X'; //We need to parse the access entry, here are the variables we'll use to hold them char * principal = ""; unsigned int atype = 0; unsigned int aflags = 0; unsigned int amask = 0; //Parse the entry, if we can't then just quit because we got bad data. if(ace != NULL) { if(parse_acl(ace, &principal, &atype, &aflags, &amask) == 0) { return 0; } } //We need to determine the length of our new string size_t size = snprintf(NULL, 0, "\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%c\"", data.host, data.share, data.object, parse_type(data.type), principal, parse_accessmask(amask), hidden ); //Otherwise, just a simple sprintf to the buffer the user gave us. char *buffer = malloc(size+1); snprintf(buffer, size+1, "\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%c\"", data.host, data.share, data.object, parse_type(data.type), principal, parse_accessmask(amask), hidden ); *buf = strdup(buffer); free(buffer); return size+1; }
static void parse_types(const char *arg, uint16_t *mask) { const char *comma; while ((comma = strchr(arg, ',')) != NULL) { if (comma == arg || !parse_type(arg, comma-arg, mask)) xtables_error(PARAMETER_PROBLEM, "addrtype: bad type `%s'", arg); arg = comma + 1; } if (strlen(arg) == 0 || !parse_type(arg, strlen(arg), mask)) xtables_error(PARAMETER_PROBLEM, "addrtype: bad type \"%s\"", arg); }
/* returns the value as a ctype, pushes the user value onto the stack */ void check_ctype(lua_State* L, int idx, struct ctype* ct) { if (lua_isstring(L, idx)) { struct parser P; P.line = 1; P.prev = P.next = lua_tostring(L, idx); P.align_mask = DEFAULT_ALIGN_MASK; parse_type(L, &P, ct); parse_argument(L, &P, -1, ct, NULL, NULL); lua_remove(L, -2); /* remove the user value from parse_type */ } else if (lua_getmetatable(L, idx)) { if (!equals_upval(L, -1, &ctype_mt_key) && !equals_upval(L, -1, &cdata_mt_key)) { goto err; } lua_pop(L, 1); /* pop the metatable */ *ct = *(struct ctype*) lua_touserdata(L, idx); lua_getuservalue(L, idx); } else { goto err; } return; err: luaL_error(L, "expected cdata, ctype or string for arg #%d", idx); }
void handle_userdata_field(struct userdata *data) { trace(TRACE_USERDATA, "Adding a userdata field"); // find the field name char * field_name = next_token(); if (field_name == NULL) { error(ERROR_USERDATA, "Missing a field name for userdata %s", data->name); } struct userdata_field * field = data->fields; while (field != NULL && strcmp(field->name, field_name)) { field = field-> next; } if (field != NULL) { error(ERROR_USERDATA, "Field %s already exsists in userdata %s (declared on %d)", field_name, data->name, field->line); } trace(TRACE_USERDATA, "Adding field %s", field_name); field = (struct userdata_field *)allocate(sizeof(struct userdata_field)); field->next = data->fields; data->fields = field; field->line = state.line_num; string_copy(&(field->name), field_name); parse_type(&(field->type), TYPE_REQUIRED, RANGE_CHECK_NONE); field->access_flags = parse_access_flags(&(field->type)); }
static int parse_entries(const scconf_context * config, const scconf_block * block, scconf_entry * entry, int depth) { int r, i, idx; scconf_entry *e; scconf_block **blocks = NULL; if (config->debug) { fprintf(stderr, "parse_entries called, depth %d\n", depth); } for (idx = 0; entry[idx].name; idx++) { e = &entry[idx]; blocks = getblocks(config, block, e); if (!blocks) { if (!(e->flags & SCCONF_MANDATORY)) { if (config->debug) fprintf(stderr, "optional configuration entry '%s' not present\n", e->name); continue; } fprintf(stderr, "mandatory configuration entry '%s' not found\n", e->name); return 1; } for (i = 0; blocks[i]; i++) { r = parse_type(config, blocks[i], e, depth); if (r) { free(blocks); return r; } if (!(e->flags & SCCONF_ALL_BLOCKS)) break; } free(blocks); } return 0; }
int argdata_seq_iterate(const argdata_t *ad, argdata_seq_iterator_t *it_) { struct cloudabi_argdata_seq_iterator *it = (struct cloudabi_argdata_seq_iterator *)it_; switch (ad->type) { case AD_BUFFER: { const uint8_t *buf = ad->buffer; size_t len = ad->length; it->container = ad; it->error = parse_type(ADT_SEQ, &buf, &len); it->offset = buf - ad->buffer; break; } case AD_SEQ: it->container = ad; it->error = 0; it->offset = 0; break; default: it->error = EINVAL; break; } if (it->error != 0) { // If the iterator is invalid, fall back to using an empty buffer, // so that calls to argdata_seq_next() act as if iterating an empty // sequence. it->container = &argdata_null; it->offset = 0; } return it->error; }
static void parse_field(fb_parser_t *P, fb_member_t *fld) { fb_token_t *t; if (!(t = match(P, LEX_TOK_ID, "field expected identifier"))) { goto fail; } fld->symbol.ident = t; if (!match(P, ':', "field expected ':' before mandatory type")) { goto fail; } parse_type(P, &fld->type); if (optional(P, '=')) { /* * Because types can be named references, we do not check the * default assignment before the schema is fully parsed. * We allow the initializer to be a name in case it is an enum * name. */ parse_value(P, &fld->value, allow_id_value, "initializer must be of scalar type"); } fld->metadata = parse_metadata(P); advance(P, ';', "field must be terminated with ';'", 0); return; fail: recover2(P, ';', 1, '}', 0); }
static errr parse_specs(struct parser_hook *h, char *fmt) { char *name ; char *stype = NULL; int type; struct parser_spec *s; assert(h); assert(fmt); name = strtok(fmt, " "); if (!name) return -EINVAL; h->dir = string_make(name); h->fhead = NULL; h->ftail = NULL; while (name) { /* Lack of a type is legal; that means we're at the end of the line. */ stype = strtok(NULL, " "); if (!stype) break; /* Lack of a name, on the other hand... */ name = strtok(NULL, " "); if (!name) { clean_specs(h); return -EINVAL; } /* Grab a type, check to see if we have a mandatory type * following an optional type. */ type = parse_type(stype); if (type == PARSE_T_NONE) { clean_specs(h); return -EINVAL; } if (!(type & PARSE_T_OPT) && h->ftail && (h->ftail->type & PARSE_T_OPT)) { clean_specs(h); return -EINVAL; } if (h->ftail && ((h->ftail->type & ~PARSE_T_OPT) == PARSE_T_STR)) { clean_specs(h); return -EINVAL; } /* Save this spec. */ s = mem_alloc(sizeof *s); s->type = type; s->name = string_make(name); s->next = NULL; if (h->fhead) h->ftail->next = s; else h->fhead = s; h->ftail = s; } return 0; }
static xmms_magic_entry_t * parse_entry (const gchar *s) { xmms_magic_entry_t *entry; gchar *end = NULL; entry = g_new0 (xmms_magic_entry_t, 1); entry->endian = G_BYTE_ORDER; entry->oper = XMMS_MAGIC_ENTRY_OPERATOR_EQUAL; entry->offset = strtoul (s, &end, 0); end++; entry->type = parse_type (&end, &entry->endian); if (entry->type == XMMS_MAGIC_ENTRY_TYPE_UNKNOWN) { g_free (entry); return NULL; } if (!parse_pre_test_and_op (entry, &end)) { g_free (entry); return NULL; } /* @todo Implement string operators */ switch (entry->type) { case XMMS_MAGIC_ENTRY_TYPE_STRING: case XMMS_MAGIC_ENTRY_TYPE_STRINGC: break; default: entry->oper = parse_oper (&end); break; } switch (entry->type) { case XMMS_MAGIC_ENTRY_TYPE_BYTE: entry->value.i8 = strtoul (end, &end, 0); entry->len = 1; break; case XMMS_MAGIC_ENTRY_TYPE_INT16: entry->value.i16 = strtoul (end, &end, 0); entry->len = 2; break; case XMMS_MAGIC_ENTRY_TYPE_INT32: entry->value.i32 = strtoul (end, &end, 0); entry->len = 4; break; case XMMS_MAGIC_ENTRY_TYPE_STRING: case XMMS_MAGIC_ENTRY_TYPE_STRINGC: g_strlcpy (entry->value.s, end, sizeof (entry->value.s)); entry->len = strlen (entry->value.s); break; default: break; /* won't get here, handled above */ } return entry; }
/* `enum` must already be matched. */ static void parse_enum_decl(fb_parser_t *P, fb_compound_type_t *ct) { fb_token_t *t, *t0; fb_member_t *member; if (!(ct->symbol.ident = match(P, LEX_TOK_ID, "enum declaration expected identifier"))) { goto fail; } if (optional(P, ':')) { parse_type(P, &ct->type); if (ct->type.type != vt_scalar_type) { error_tok(P, ct->type.t, "integral type expected"); } else { switch (ct->type.t->id) { case tok_kw_float: case tok_kw_double: error_tok(P, ct->type.t, "integral type expected"); default: break; } } } ct->metadata = parse_metadata(P); if (!((t0 = match(P, '{', "enum declaration expected '{'")))) { goto fail; } for (;;) { if (!(t = match(P, LEX_TOK_ID, "member identifier expected"))) { goto fail; } if (P->failed >= FLATCC_MAX_ERRORS) { goto fail; } member = fb_add_member(P, &ct->members); member->symbol.ident = t; if (optional(P, '=')) { t = P->token; parse_value(P, &member->value, 0, "integral constant expected"); /* Leave detailed type (e.g. no floats) and range checking to a later stage. */ } /* * Trailing comma is optional in flatc but not in grammar, we * follow flatc. */ if (!optional(P, ',') || P->token->id == '}') { break; } P->doc = 0; } if (t0) { advance(P, '}', "enum missing closing '}' to match", t0); } revert_symbols(&ct->members); return; fail: recover(P, '}', 1); }
void parse_varDef() { expression_t expr; size_t addr; switch(next_token.type) { case TT_TYPE_DOUBLE: case TT_TYPE_INT: case TT_TYPE_STRING: var_init(); parse_type(); var_set_type(curr_token.type); match(TT_IDENTIFICATOR); var_set_name(curr_token.str); addr = generate_push(); var_set_addr(addr); symbol_t* var = var_finish(); var_table_add(var); parse_varDefFollow(var_table_find(var->name)); break; case TT_TYPE_AUTO: var_init(); match(TT_TYPE_AUTO); match(TT_IDENTIFICATOR); var_set_name(curr_token.str); match_deduction(TT_OP_ASSIGNMENT); var_set_initialized(); addr = generate_push(); var_set_addr(addr); expr = parse_expr(); switch (expr.type) { case DOUBLE_DT: case INT_DT: case STRING_DT: var_set_type(expr.type); generate_mov(addr, expr.addr); break; case DOUBLE_LIT_DT: var_set_type(DOUBLE_DT); generate_mov_double(addr, expr.double_val); break; case INT_LIT_DT: var_set_type(INT_DT); generate_mov_int(addr, expr.int_val); break; case STRING_LIT_DT: var_set_type(STRING_DT); generate_mov_string(addr, expr.str_val); break; default: ; } var_table_add(var_finish()); break; default: error("Syntactic error: Failed to parse the program", ERROR_SYN); } }
static struct arg_type_info * parse_lens(struct protolib *plib, struct locus *loc, char **str, struct param **extra_param, size_t param_num, int *ownp, int *forwardp) { int own_lens; struct lens *lens = name2lens(str, &own_lens); int has_args = 1; struct arg_type_info *info; if (lens != NULL) { eat_spaces(str); /* Octal lens gets special treatment, because of * backward compatibility. */ if (lens == &octal_lens && **str != '(') { has_args = 0; info = type_get_simple(ARGTYPE_INT); *ownp = 0; } else if (parse_char(loc, str, '(') < 0) { report_error(loc->filename, loc->line_no, "expected type argument after the lens"); return NULL; } } if (has_args) { eat_spaces(str); info = parse_type(plib, loc, str, extra_param, param_num, ownp, forwardp); if (info == NULL) { fail: if (own_lens && lens != NULL) lens_destroy(lens); return NULL; } } if (lens != NULL && has_args) { eat_spaces(str); parse_char(loc, str, ')'); } /* We can't modify shared types. Make a copy if we have a * lens. */ if (lens != NULL && unshare_type_info(loc, &info, ownp) < 0) goto fail; if (lens != NULL) { info->lens = lens; info->own_lens = own_lens; } return info; }
static int32_t snmp_import_top(struct snmp_toolinfo *snmptoolctx, enum tok *tok) { enum snmp_tc tc; struct enum_type *t; if (*tok == '(') return (snmp_import_tree(snmptoolctx, tok)); if (*tok == TOK_TYPEDEF) { if ((*tok = gettoken(snmptoolctx)) != TOK_STR) { warnx("type name expected after typedef - %s", input->fname); return (-1); } t = snmp_enumtc_init(nexttok); *tok = gettoken(snmptoolctx); t->is_enum = (*tok == TOK_ENUM); t->is_bits = (*tok == TOK_BITS); t->syntax = parse_type(snmptoolctx, tok, &tc, &(t->snmp_enum)); snmp_enumtc_insert(snmptoolctx, t); return (1); } if (*tok == TOK_INCLUDE) { int i; *tok = gettoken(snmptoolctx); if (*tok != TOK_FILENAME) { warnx("filename expected in include directive - %s", nexttok); return (-1); } if (( i = add_filename(snmptoolctx, nexttok, NULL, 1)) == 0) { *tok = gettoken(snmptoolctx); return (1); } if (i == -1) return (-1); input_fopen(nexttok); *tok = gettoken(snmptoolctx); return (1); } warnx("'(' or 'typedef' expected - %s", nexttok); return (-1); }
/* * Read everything after the syntax type that is certainly a leaf OID info. */ static int snmp_import_leaf(struct snmp_toolinfo *tool, enum tok *tok, struct snmp_oid2str *oid2str) { int32_t i, syntax; if ((syntax = parse_type(tool, tok, &(oid2str->tc), &(oid2str->snmp_enum))) < 0) return(-1); oid2str->syntax = syntax; /* * That is the name of the function, corresponding to the entry * It is used by bsnmpd, but is not interesting for us. */ if (*tok == TOK_STR) *tok = gettoken(tool); /* * Avoid looping forever here - * while (tok == TOK_ACCESS) */ for (i = 0; i < SNMP_ACCESS_GETSET && *tok == TOK_ACCESS; i++) { oid2str->access |= (u_int)val; *tok = gettoken(tool); } if (*tok != ')') { warnx("')' expected at end of line %d", input->lno); return (-1); } oid2str->table_idx = snmp_import_update_table(ENTRY_DATA, (struct snmp_index_entry *) NULL); if ((i = snmp_leaf_insert(tool, oid2str)) < 0) { warnx("Error adding leaf %s to list", oid2str->string); return (-1); } /* * Same entry is already present in the mapping lists and * the new one was not inserted. */ if (i == 0) { free(oid2str->string); free(oid2str); } (void) snmp_import_update_table(ENTRY_NONE, (struct snmp_index_entry *) NULL); return (1); }
void handle_method(enum trace_level traceType, char *parent_name, struct method **methods) { trace(traceType, "Adding a method"); // find the field name char * name = next_token(); if (name == NULL) { error(ERROR_USERDATA, "Missing method name for %s", parent_name); } struct method * method = *methods; while (method != NULL && strcmp(method->name, name)) { method = method-> next; } if (method != NULL) { error(ERROR_USERDATA, "Method %s already exsists for %s (declared on %d)", name, parent_name, method->line); } trace(traceType, "Adding method %s", name); method = allocate(sizeof(struct method)); method->next = *methods; *methods = method; string_copy(&(method->name), name); method->line = state.line_num; parse_type(&(method->return_type), TYPE_REQUIRED, RANGE_CHECK_NONE); // iterate the arguments struct type arg_type = {}; while (parse_type(&arg_type, TYPE_OPTIONAL, RANGE_CHECK_MANDATORY)) { if (arg_type.type == TYPE_NONE) { error(ERROR_USERDATA, "Can't pass an empty argument to a method"); } struct argument * arg = allocate(sizeof(struct argument)); memcpy(&(arg->type), &arg_type, sizeof(struct type)); arg->next = method->arguments; method->arguments = arg; } }
int main(void) { char input_buffer[MAX_STRING]; char type[MAX_SUBSTRING]; char declarator[MAX_SUBSTRING]; char identifier[MAX_SUBSTRING]; while (get_string(input_buffer)) { type[0] = identifier[0] = declarator[0] = '\0'; parse_type(type, input_buffer); parse_declarator(identifier, declarator, input_buffer); printf("Declare %s as %s %s\n", identifier, declarator, type); } return 0; }
void stuff_first(SCP_string &firstFont) { try { font_parse_setup("fonts.tbl"); FontType type; parse_type(type, firstFont); } catch (const parse::ParseException& e) { Error(LOCATION, "Failed to setup font parsing. This may be caused by an empty fonts.tbl file.\nError message: %s", e.what()); firstFont = ""; } }
int parse_desc_file(FILE* f, DESC* desc) { int c = 0; char* value; char line[256], buffer[256]; while (fgets(line, sizeof(line), f) != 0 && c < 4) { if (sscanf(line, "%s", buffer) != 1) return PARSE_ERROR; value = strchr(buffer, '='); if (!(value && strlen(value) > 1)) return PARSE_ERROR; value++; switch (c) { case 0: if (!parse_name(value, desc->name)) return PARSE_ERROR; break; case 1: if (!parse_type(value, &(desc->type))) return PARSE_ERROR; break; case 2: if (!parse_opcode(value, &(desc->opcode))) return PARSE_ERROR; break; case 3: if (desc->type == 'R') { if (!parse_function(value, &(desc->function))) return PARSE_ERROR; } else { desc->function = -1; } break; } c++; } return PARSE_SUCCESS; }
void parse_paramSpecFollow() { switch(next_token.type) { case TT_COMMA: match(TT_COMMA); var_init(); parse_type(); var_set_type(curr_token.type); match(TT_IDENTIFICATOR); var_set_name(curr_token.str); var_set_addr(++param_count); var_set_initialized(); func_add_param(var_finish()); parse_paramSpecFollow(); break; default: return; } }
/* parses a line of the file * tries to set the corresponding row in the matrix * returns false on error */ bool parse_row(char* s, int row, LinearProgram* lp) { assert(lp_is_valid(lp)); assert(row >= 0); assert(row < get_rows(lp)); char* end_ptr; int cols = get_cols(lp); int i; for (i = 0; i < cols; i++) { num_t num = parse_num(s, &end_ptr); if (!is_num_valid(num, s, end_ptr)) { return false; } set_coef(lp, row, i, num); s = end_ptr; } s = parse_type(s, row, lp); if (NULL == s) { return false; } num_t num = parse_num(s, &end_ptr); if (!is_num_valid(num, s, end_ptr)) { return false; } s = end_ptr; s = skip_spaces(s); if ('\0' != *s) { return false; } set_rhs(lp, row, num); assert(lp_is_valid(lp)); return true; }
/* parses a line of the file * tries to set the corresponding row in the matrix * returns false on error */ bool parse_row(char* s, int row, LinearProgram* lp) { assert(lp_is_valid(lp)); assert(row >= 0); assert(row < lp->rows); int i; char* end_ptr; for (i = 0; i < lp->cols; i++) { num_t num = parse_num(s, &end_ptr); if (!is_num_valid(num, s, end_ptr)) { return false; } lp->matrix[row][i] = num; s = end_ptr; } s = parse_type(s, row, lp); if (NULL == s) { return false; } num_t num = parse_num(s, &end_ptr); if (!is_num_valid(num, s, end_ptr)) { return false; } s = end_ptr; s = skip_spaces(s); if ('\0' != *s) { return false; } lp->vector[row] = num; assert(lp_is_valid(lp)); return true; }
t_map *parse_lemin() { t_map *map; char *buffer; int step; t_info info; init_map(&map); step = 0; info.command = 0; while ((buffer = get_next_line(0)) != NULL) { info.type = get_line_type(buffer); info.command = parse_type(info, buffer, &step, map); info.command = get_command(info.command, step, map); free(buffer); } is_valid_map(map); return (map); }
int argdata_get_binary(const argdata_t *ad, const void **value, size_t *valuelen) { switch (ad->type) { case AD_BUFFER: { const uint8_t *buf = ad->buffer; size_t len = ad->length; int error = parse_type(ADT_BINARY, &buf, &len); if (error != 0) return error; *value = buf; *valuelen = len; return 0; } case AD_BINARY: *value = ad->binary; *valuelen = ad->length - 1; return 0; default: return EINVAL; } }
int cloudabi_argdata_get_int_u(const argdata_t *ad, uintmax_t *value, uintmax_t max) { switch (ad->type) { case AD_BUFFER: { const uint8_t *buf = ad->buffer; size_t len = ad->length; int error = parse_type(ADT_INT, &buf, &len); if (error != 0) return error; // Parse unsigned number. uintmax_t res = 0; if (len > 0) { if ((buf[0] & 0x80) != 0) { // Number is negative. return ERANGE; } if (len > sizeof(res) && (len != sizeof(res) + 1 || buf[0] != 0)) { // Number is too large. return ERANGE; } // Add digits. do { res = res << 8 | *buf++; } while (--len > 0); if (res > max) return ERANGE; } *value = res; return 0; } default: return EINVAL; } }
inline bool parse_addr_type(char*& s, int& addr_t) { return parse_type(s,addr_t,addr_type_lookup,"address type"); }
inline bool parse_net_type(char*& s, int& network) { return parse_type(s,network,net_type_lookup,"net type"); }
inline bool parse_transport_prot(char*& s, int& tp) { return parse_type(s,tp,transport_prot_lookup,"transport protocol"); }
static int read_line(char *linebuf, DEFINITION_FILE_STATE state) { int retval = OK; switch (state) { case START: /* Non-whitespace line in START state */ printf("Can't parse line: %s\n"); retval = PARSE_ERROR; break; case NAME: if (lc_name) /* may be 2nd time through */ break; lc_name = (char *)malloc(strlen(linebuf) + 1); if (lc_name == NULL) { retval = SYSTEM_ERROR; break; } downcase_string_no_blanks(lc_name, linebuf); form_plural_name(lc_name); break; case TABLES: retval = parse_and_append_table(&tables, linebuf); break; case STATIC_TABLES: retval = parse_and_append_table(&static_tables, linebuf); break; case KEYS: if (tables) { if (fields == NULL) parse_table_files(tables, &fields); retval = mark_key(linebuf, fields, tables); } break; case CONDITIONAL_KEYS: if (tables) { if (fields == NULL) parse_table_files(tables, &fields); retval = mark_conditional_key(linebuf, fields, tables); } break; case KEY_STRINGS: retval = cache_key_string(linebuf); break; case IS_ACTIVE_STRINGS: retval = cache_is_active_string(linebuf); break; case CONDITIONAL_STRINGS: retval = cache_conditional_string(linebuf); break; case DISCONNECT_REASON_NAME: retval = cache_disconnect_reason_name(linebuf); break; case NEW_FIELDS: retval = cache_new_fields(linebuf); break; case IS_ACTIVE_FIELDS: if (tables) { if (fields == NULL) parse_table_files(tables, &fields); retval = add_is_active_field(linebuf); } break; case STATIC_KEYS: if (static_tables) { if (static_fields == NULL) parse_table_files(static_tables, &static_fields); retval = mark_key(linebuf, static_fields, static_tables); } else { printf("Sorry: current implementation requires that STATIC_TABLES appear ahead of STATIC_KEYS.\n"); retval = FORMAT_ERROR; } break; case JOINS: if (tables) { if (fields == NULL) parse_table_files(tables, &fields); retval = add_join(linebuf); } break; case CONDITIONAL_JOINS: if (tables) { if (fields == NULL) parse_table_files(tables, &fields); retval = add_conditional_join(linebuf); has_conditionals = TRUE; } break; case CONDITIONAL_TABLES: if (tables) { if (fields == NULL) parse_table_files(tables, &fields); retval = mark_table_as_conditional(linebuf); has_conditionals = TRUE; } break; case STATIC_JOINS: if (tables && (fields == NULL)) parse_table_files(tables, &fields); if (static_tables && (static_fields == NULL)) parse_table_files(static_tables, &static_fields); if (fields && static_fields) retval = add_static_join(linebuf); break; case NULL_KEY_VALUES: if (has_keys) retval = add_null_key_value(linebuf); else { /* Might get this on the second pass. */ fprintf(stderr, "WARNING: Null-key list seen with no keys parsed.\n"); retval = OK; } break; case EXCLUDES: if (has_includes) { printf("Cannot have both include and exclude fields.\n"); retval = FORMAT_ERROR; break; } if (tables) { if (fields == NULL) parse_table_files(tables, &fields); if (!has_excludes) { has_excludes = TRUE; mark_fields_include(fields); } retval = exclude_field(linebuf); } break; case INCLUDES: if (has_excludes) { printf("Cannot have both include and exclude fields.\n"); retval = FORMAT_ERROR; break; } if (tables) { if (fields == NULL) parse_table_files(tables, &fields); if (!has_includes) { has_includes = TRUE; mark_fields_exclude(fields); } retval = include_field(linebuf); } break; case READ_ONLIES: if (tables) { if (fields == NULL) parse_table_files(tables, &fields); retval = mark_read_only(linebuf); } break; case CHILDREN: retval = add_child(linebuf); break; case GRANDCHILDREN: retval = add_grandchild(linebuf); break; case ALIASES: retval = add_alias(linebuf); break; case TYPE: retval = parse_type(linebuf); break; case SORTING_FEATURES: retval = OK; has_sorting_features = TRUE; /* Add the line into the buffer */ { strcat(sorting_alias, linebuf); strcat(sorting_alias, "\n"); } break; case SPECIFY_EFFECTIVE_DATE: retval = OK; break; case NO_SELECT: retval = OK; break; case NO_LIST: retval = OK; break; case NO_NEW_DEL_UNSET: retval = OK; break; default: printf("Can't parse line: %s\n", linebuf); retval = PARSE_ERROR; break; } return retval; }