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;
}
