struct expression *parse() { init(); advanceToken(); struct expression *prop = parse_prop(); if (is_empty_expression(prop) || current_token == NULL || current_token->type != End) { return NULL; } return prop; }
static int setget_prop(int types, const char *object, const char *name, const char *value) { int ret; const struct prop_handler *prop = NULL; ret = parse_prop(name, prop_handlers, &prop); if (ret == -1) { fprintf(stderr, "ERROR: property is unknown\n"); ret = 40; goto out; } else if (ret) { fprintf(stderr, "ERROR: parse_prop reported unknown error\n"); ret = 42; goto out; } types &= prop->types; if (!types) { fprintf(stderr, "ERROR: object is not compatible with property\n"); ret = 47; goto out; } if (count_bits(types) > 1) { fprintf(stderr, "ERROR: type of object is ambiguous. Please specify a type by hand.\n"); ret = 48; goto out; } if (value && prop->read_only) { fprintf(stderr, "ERROR: %s is a read-only property.\n", prop->name); ret = 51; goto out; } ret = prop->handler(types, object, name, value); if (ret < 0) ret = 50; else ret = 0; out: return ret; }
static int setget_prop(int types, const char *object, const char *name, const char *value) { int ret; const struct prop_handler *prop = NULL; ret = parse_prop(name, prop_handlers, &prop); if (ret == -1) { error("unknown property: %s", name); ret = 40; goto out; } types &= prop->types; if (!types) { error("object is not compatible with property: %s", prop->name); ret = 47; goto out; } if (count_bits(types) > 1) { error("type of object is ambiguous, please use option -t"); ret = 48; goto out; } if (value && prop->read_only) { error("property is read-only property: %s", prop->name); ret = 51; goto out; } ret = prop->handler(types, object, name, value); if (ret < 0) ret = 50; else ret = 0; out: return ret; }
struct expression *parse_prop() { struct expression *exp = parse_exp(); if (is_empty_expression(exp) || current_token == NULL) return NULL; switch (current_token->type) { case OpOr: advanceToken(); struct expression *prop = new_op_expression(OrExp, exp, parse_prop()); if (is_right_child_empty(prop)) { destroy_expression(exp); return NULL; } return prop; default: return exp; } }
struct expression *parse_term() { struct expression *term; if (current_token == NULL) return NULL; switch (current_token->type) { case Var: term = new_var_expression(current_token->u.var_id); advanceToken(); return term; case LeftParen: advanceToken(); term = parse_prop(); if (is_empty_expression(term)) { return NULL; } switch (current_token->type) { case RightParen: advanceToken(); return term; default: return NULL; } case OpNot: advanceToken(); term = new_op_expression(NotExp, parse_term(), NULL); if (is_left_child_empty(term)) { destroy_expression(term); return NULL; } return term; default: return NULL; } }
prop_node::prop_node( const char* pn ) : accessed_flag( false ) { *this = parse_prop( pn ); }
/** Parse class, struct or interface member. * * @param parse Parser object. * @param outer_csi CSI containing this declaration. * @return New syntax tree node. In case of parse error, * @c NULL may (but need not) be returned. */ static stree_csimbr_t *parse_csimbr(parse_t *parse, stree_csi_t *outer_csi) { stree_csimbr_t *csimbr; stree_csi_t *csi; stree_ctor_t *ctor; stree_deleg_t *deleg; stree_enum_t *enum_d; stree_fun_t *fun; stree_var_t *var; stree_prop_t *prop; csimbr = NULL; switch (lcur_lc(parse)) { case lc_class: case lc_struct: case lc_interface: csi = parse_csi(parse, lcur_lc(parse), outer_csi); if (csi != NULL) { csimbr = stree_csimbr_new(csimbr_csi); csimbr->u.csi = csi; } break; case lc_new: ctor = parse_ctor(parse, outer_csi); if (ctor != NULL) { csimbr = stree_csimbr_new(csimbr_ctor); csimbr->u.ctor = ctor; } break; case lc_deleg: deleg = parse_deleg(parse, outer_csi); if (deleg != NULL) { csimbr = stree_csimbr_new(csimbr_deleg); csimbr->u.deleg = deleg; } break; case lc_enum: enum_d = parse_enum(parse, outer_csi); if (enum_d != NULL) { csimbr = stree_csimbr_new(csimbr_enum); csimbr->u.enum_d = enum_d; } break; case lc_fun: fun = parse_fun(parse, outer_csi); csimbr = stree_csimbr_new(csimbr_fun); csimbr->u.fun = fun; break; case lc_var: var = parse_var(parse, outer_csi); if (var != NULL) { csimbr = stree_csimbr_new(csimbr_var); csimbr->u.var = var; } break; case lc_prop: prop = parse_prop(parse, outer_csi); csimbr = stree_csimbr_new(csimbr_prop); csimbr->u.prop = prop; break; default: lunexpected_error(parse); lex_next(parse->lex); break; } return csimbr; }