ecos: host/libcdl/expr.cxx comparison

comparison host/libcdl/expr.cxx @ 163:0d2b193a635f

Merge from eCos master repository on 2001-06-22-17:38:39-BST

author	jlarmour
date	Fri, 22 Jun 2001 18:18:44 +0000
parents	511f4dc167f6
children	74dbf4c3f2e1

comparison

equal deleted inserted replaced

-:2395031e7a66
+:0d2b193a635f
 property    = 0;
 toplevel    = 0;
 CYGDBG_MEMLEAK_DESTRUCTOR();
 CYG_REPORT_RETURN();
+}
+// Given a context and a reference inside an expression, obtain the node
+// being referenced - if it is loaded.
+CdlNode
+CdlEvalContext::resolve_reference(CdlExpression expr, int index)
+{
+CYG_REPORT_FUNCNAMETYPE("CdlEvalContext::resolve_reference", "result %");
+CYG_REPORT_FUNCARG2XV(expr, index);
+CYG_PRECONDITION_THISC();
+CYG_PRECONDITION_CLASSC(expr);
+CYG_PRECONDITIONC((0 <= index) && (index <= (int)expr->references.size()));
+// This expression may be happening in the context of a particular
+// property. If so then the destination may or may not be
+// resolved, which will have been handled when the containing package
+// was loaded. Alternatively this expression may be evaluated inside
+// some arbitrary Tcl code, in which case references remain unbound
+// and need to be resolved the hard way.
+CdlNode result = 0;
+if (0 != this->property) {
+// There is a property, use the bound/unbound reference.
+result = expr->references[index].get_destination();
+} else {
+// The destination name can be retrieved, but we still need some
+// way of resolving it.
+if (0 != this->toplevel) {
+std::string destination_name = expr->references[index].get_destination_name();
+result = this->toplevel->lookup(destination_name);
+}
+}
+CYG_REPORT_RETVAL(result);
+return result;
+}
+// Ditto, but also check that the result is a valuable.
+CdlValuable
+CdlEvalContext::resolve_valuable_reference(CdlExpression expr, int index)
+{
+CYG_REPORT_FUNCNAMETYPE("CdlEvalContext::resolve_reference", "result %");
+CYG_REPORT_FUNCARG2XV(expr, index);
+CdlValuable result  = 0;
+CdlNode     node = this->resolve_reference(expr, index);
+if (0 != node) {
+result = dynamic_cast<CdlValuable>(node);
+}
+CYG_REPORT_RETVAL(result);
+return result;
 }
 bool
 CdlEvalContext::check_this(cyg_assert_class_zeal zeal) const
 {
 T_And               = 27,   // &&
 T_Or                = 28,   // ||
 T_Colon             = 29,   // : (in a conditional)
 T_StringConcat      = 30,   // .
 T_Function          = 31,   // is_substr etc.
-T_Comma             = 32    // , (inside a function)
+T_Comma             = 32,   // , (inside a function)
+T_Implies           = 33,   // implies
+T_Xor               = 34,   // xor
+T_Eqv               = 35    // eqv
 };
 //}}}
 //{{{  Statics
 static unsigned int     token_start             = 0;
 static int              current_char            = EOF;
 static token            current_token           = T_Invalid;
 static std::string      current_string          = "";
 static std::string      current_reference       = "";
+static std::string      current_special         = "";
 static cdl_int          current_int             = 0;
 static double           current_double          = 0.0;
 static CdlValueFormat   current_format          = CdlValueFormat_Default;
 static int              current_function_id     = 0;
 }
 }
 CYG_REPORT_RETURN();
 return result;
+}
+// Export this functionality available to other modules, especially func.cxx and its
+// argument checking routines.
+std::string
+CdlParse::get_expression_error_location(void)
+{
+return get_error_location();
 }
 //}}}
 //{{{  Token translation
 case T_BitXor:            result = CdlExprOp_BitXor; break;
 case T_BitOr:             result = CdlExprOp_BitOr; break;
 case T_And:               result = CdlExprOp_And; break;
 case T_Or:                result = CdlExprOp_Or; break;
 case T_StringConcat:      result = CdlExprOp_StringConcat; break;
+case T_Implies:           result = CdlExprOp_Implies; break;
+case T_Xor:               result = CdlExprOp_Xor; break;
+case T_Eqv:               result = CdlExprOp_Eqv; break;
 default:                  result = CdlExprOp_Invalid; break;
 }
 CYG_REPORT_RETVAL(result);
 return result;
 case T_BitOr:             result = "bitwise or operator |"; break;
 case T_And:               result = "and operator &&"; break;
 case T_Or:                result = "or operator ||"; break;
 case T_Colon:             result = "colon"; break;
 case T_StringConcat:      result = "string concatenation operator ."; break;
+case T_Implies:           result = "implies operator"; break;
+case T_Xor:               result = "logical xor operator"; break;
+case T_Eqv:               result = "logical equivalence operator eqv"; break;
 case T_Function:          result = std::string("function call ") + CdlFunction::get_name(current_function_id); break;
 case T_Invalid:
 default:                  result = "<invalid token>"; break;
 }
 bool result = false;
 if ("to" == current_reference) {
 current_token  = T_Range;
 result = true;
+} else if ("implies" == current_reference) {
+current_token  = T_Implies;
+result = true;
+} else if ("xor" == current_reference) {
+current_token  = T_Xor;
+result = true;
+} else if ("eqv" == current_reference) {
+current_token  = T_Eqv;
+result = true;
 } else if (CdlFunction::is_function(current_reference.c_str(), current_function_id)) {
-current_token           = T_Function;
+current_token  = T_Function;
 result = true;
 }
 if (result) {
-current_reference = "";
+current_special     = current_reference;
+current_reference   = "";
 }
 CYG_REPORT_RETVAL(result);
 return result;
 }
 // Make sure there is no dross left lying around from the previous call.
 current_token       = T_Invalid;
 current_string      = "";
 current_reference   = "";
+current_special     = "";
 current_int         = 0;
 current_double      = 0.0;
 current_format      = CdlValueFormat_Default;
 current_function_id = 0;
 // Syntactic analysis.
 //
 // The BNF of CDL expressions is something like this:
 //
 //   <expression>   ::= <conditional>
-//   <conditional>  ::= <or> ? <conditional> : <conditional> | <or>
+//   <conditional>  ::= <implies> ? <conditional> : <conditional> | <implies>
-//   <or>           ::= <and>    [<or op>     <and>]           ||
+//   <implies>      ::= <eqv>    [<implies op>  <implies>]      implies
-//   <and>          ::= <bitor>  [<and op>    <bitor>]         ??
+//   <eqv>          ::= <or>     [<eqv op>      <eqv>]          xor, eqv
-//   <bitor>        ::= <bitxor> [<bitor op>  <bitxor>]        |
+//   <or>           ::= <and>    [<or op>       <or>]           ||
-//   <bitxor>       ::= <bitand> [<bitxor op> <bitand>]        ^
+//   <and>          ::= <bitor>  [<and op>      <and>]          &&
-//   <bitand>       ::= <eq>     [<bitand op> <eq>]            &
+//   <bitor>        ::= <bitxor> [<bitor op>    <bitor>]        |
-//   <eq>           ::= <comp>   [<eq op>     <comp>]          == !=
+//   <bitxor>       ::= <bitand> [<bitxor op>   <bitxor>]       ^
-//   <comp>         ::= <shift>  [<comp op>   <shift>]         < <= > >=
+//   <bitand>       ::= <eq>     [<bitand op>   <and>]          &
-//   <shift>        ::= <add>    [<shift op>  <add>]           << >>
+//   <eq>           ::= <comp>   [<eq op>       <eq>]           == !=
-//   <add>          ::= <mult>   [<add op>    <mult>]          + - .
+//   <comp>         ::= <shift>  [<comp op>     <comp>]         < <= > >=
-//   <mult>         ::= <unary>  [<mult op>   <unary>]         * / %
+//   <shift>        ::= <add>    [<shift op>    <shift>]        << >>
+//   <add>          ::= <mult>   [<add op>      <add>]          + - .
+//   <mult>         ::= <unary>  [<mult op>     <mult>]         * / %
 //   <unary>        ::= -<unary> | +<unary> | !<unary> | *<unary> | ?<unary> |
 //                      ~<unary> |
 //                      <string constant> | <integer constant> |
 //                      <double constant> | <reference> |
 //                      ( <expression> ) | <function>
 subexpr.op          = CdlExprOp_Function;
 subexpr.func        = current_function_id;
 int number_of_args  = CdlFunction::get_args_count(current_function_id);
 CYG_ASSERTC((0 < number_of_args) && (number_of_args <= CdlFunction_MaxArgs));
-std::string name    = current_reference;
+std::string name    = current_special;
 // check for the opening bracket: xyzzy(arg1, arg2)
 next_token();
 if (T_OpenBracket != current_token) {
 throw CdlParseException(std::string("Expected opening bracket after function ") + name + "\n" + get_error_location());
 throw CdlParseException(std::string("Expected comma between arguments in function ") +
 name + "\n" + get_error_location());
 }
 next_token();
 }
+}
+if (T_Comma == current_token) {
+throw CdlParseException(std::string("Too many arguments passed to function ") + name + "\n" + get_error_location());
 }
 if (T_CloseBracket != current_token) {
 throw CdlParseException(std::string("Expected closing bracket after function ") + name + "\n" + get_error_location());
 }
 next_token();
 CYG_REPORT_RETURN();
 }
 static void
+parse_eqv(CdlExpression expr)
+{
+CYG_REPORT_FUNCNAME("parse_eqv");
+parse_or(expr);
+while ((T_Xor == current_token) || (T_Eqv == current_token)) {
+CdlSubexpression subexpr;
+subexpr.op = (T_Xor == current_token) ? CdlExprOp_Xor : CdlExprOp_Eqv;
+subexpr.lhs_index = expr->first_subexpression;
+next_token();
+parse_or(expr);
+subexpr.rhs_index = expr->first_subexpression;
+push_subexpression(expr, subexpr);
+}
+CYG_REPORT_RETURN();
+}
+static void
+parse_implies(CdlExpression expr)
+{
+CYG_REPORT_FUNCNAME("parse_implies");
+parse_eqv(expr);
+while (T_Implies == current_token) {
+CdlSubexpression subexpr;
+subexpr.op = CdlExprOp_Implies;
+subexpr.lhs_index = expr->first_subexpression;
+next_token();
+parse_eqv(expr);
+subexpr.rhs_index = expr->first_subexpression;
+push_subexpression(expr, subexpr);
+}
+CYG_REPORT_RETURN();
+}
+static void
 parse_conditional(CdlExpression expr)
 {
 CYG_REPORT_FUNCNAME("parse_conditional");
-parse_or(expr);
+parse_implies(expr);
 if (T_Questionmark == current_token) {
 CdlSubexpression subexpr;
 subexpr.op = CdlExprOp_Cond;
 subexpr.lhs_index = expr->first_subexpression;
 result = true;
 } else {
 result = false;
 }
 }
+break;
+}
+case CdlExprOp_Xor :
+{
+// x xor y. Both sides should be interpreted as boolean values.
+CdlSimpleValue lhs;
+CdlSimpleValue rhs;
+evaluate_subexpr(context, expr, subexpr.lhs_index, lhs);
+evaluate_subexpr(context, expr, subexpr.rhs_index, rhs);
+bool lhs_bool = lhs.get_bool_value();
+bool rhs_bool = rhs.get_bool_value();
+if ((lhs_bool && !rhs_bool) || (!lhs_bool && rhs_bool)) {
+result = true;
+} else {
+result = false;
+}
+break;
+}
+case CdlExprOp_Eqv :
+{
+// x eqv y. Both sides should be interpreted as boolean values.
+CdlSimpleValue lhs;
+CdlSimpleValue rhs;
+evaluate_subexpr(context, expr, subexpr.lhs_index, lhs);
+evaluate_subexpr(context, expr, subexpr.rhs_index, rhs);
+bool lhs_bool = lhs.get_bool_value();
+bool rhs_bool = rhs.get_bool_value();
+if ((!lhs_bool && !rhs_bool) || (lhs_bool && rhs_bool)) {
+result = true;
+} else {
+result = false;
+}
+break;
+}
+case CdlExprOp_Implies :
+{
+// x implies y. Both sides should be interpreted as boolean values.
+CdlSimpleValue lhs;
+CdlSimpleValue rhs;
+evaluate_subexpr(context, expr, subexpr.lhs_index, lhs);
+evaluate_subexpr(context, expr, subexpr.rhs_index, rhs);
+bool lhs_bool = lhs.get_bool_value();
+bool rhs_bool = rhs.get_bool_value();
+if (!lhs_bool || rhs_bool) {
+result = true;
+} else {
+result = false;
+}
 break;
 }
 case CdlExprOp_Cond :
 {
 // x ? a : b.

Mercurial > ecos

comparison host/libcdl/expr.cxx @ 163:0d2b193a635f