ecos-v2_0-branch: host/libcdl/expr.cxx comparison

comparison host/libcdl/expr.cxx @ 115:6ed91473a1cd ecos-sw-2000-08-21

Merge from eCos master repository on 2000-08-21-22:40:54-BST

author	jlarmour
date	Fri, 25 Aug 2000 17:32:38 +0000
parents	6736c52df507
children	511f4dc167f6

comparison

equal deleted inserted replaced

-:5ad2b71d525e
+:6ed91473a1cd
 // The start of a string has been detected. Work out the entire string,
 // allowing for backslash escapes.
 static void
 process_string()
-throw(CdlParseException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAME("process_string");
 CYG_ASSERTC('"' == current_char);
 CYG_ASSERTC("" == current_string);
 // parsing a list expression then the following _5 will actually
 // be interpreted as a reference. To avoid this, here is a utility
 // which checks number completion and throws an exception if
 // necessary.
 static void check_number_termination()
-throw(CdlParseException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAME("check_number_termination");
 // End-of-data or any whitespace is ok.
 if ((EOF != current_char) && !isspace(current_char)) {
 CYG_REPORT_RETURN();
 }
 static void
 process_number()
-throw(CdlParseException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAME("process_number");
 std::string tmp      = "";
 bool        is_float = false;
 // Some care has to be taken with locale's, the C library may decide
 // that a character is a letter even though the same character is not
 // valid as far as the preprocessor is concerned.
 static void
 process_reference()
-throw(CdlParseException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAME("process_reference");
 do {
 current_reference += (char) current_char;
 // ----------------------------------------------------------------------------
 // Work out what the next token is. This includes the handling of
 // strings, integers, doubles, and references.
 static void
 next_token()
-throw(CdlParseException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAMETYPE("next_token", "token %d");
 // Make sure there is no dross left lying around from the previous call.
 current_token       = T_Invalid;
 //                      ( <expression> )
 //
 // There are separate functions for each of these terms.
 // A forward declaration, needed for bracketed subexpressions.
-static void parse_expression(CdlExpression) throw(CdlParseException, std::bad_alloc);
+static void parse_expression(CdlExpression);
 // A utility to add a reference to the current expression, returning
 // the index.
 static int
 push_reference(CdlExpression expr, const std::string& reference)
 return result;
 }
 static void
 parse_unary(CdlExpression expr)
-throw(CdlParseException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAME("parse_operand");
 CYG_REPORT_FUNCARG1XV(expr);
 CYG_PRECONDITION_CLASSC(expr);
 CYG_REPORT_RETURN();
 }
 static void
 parse_multiply(CdlExpression expr)
-throw(CdlParseException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAME("parse_multiply");
 parse_unary(expr);
 while ((T_Times == current_token) || (T_Divide == current_token) || (T_Remainder == current_token)) {
 CYG_REPORT_RETURN();
 }
 static void
 parse_add(CdlExpression expr)
-throw(CdlParseException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAME("parse_add");
 parse_multiply(expr);
 while ((T_Plus == current_token) || (T_Minus == current_token)) {
 CYG_REPORT_RETURN();
 }
 static void
 parse_shift(CdlExpression expr)
-throw(CdlParseException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAME("parse_shift");
 parse_add(expr);
 while ((T_LeftShift == current_token) || (T_RightShift == current_token)) {
 CYG_REPORT_RETURN();
 }
 static void
 parse_comparison(CdlExpression expr)
-throw(CdlParseException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAME("parse_comparison");
 parse_shift(expr);
 while ((T_LessThan == current_token)    || (T_LessEqual    == current_token) ||
 CYG_REPORT_RETURN();
 }
 static void
 parse_equals(CdlExpression expr)
-throw(CdlParseException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAME("parse_equals");
 parse_comparison(expr);
 while ((T_Equal == current_token) || (T_NotEqual == current_token)) {
 CYG_REPORT_RETURN();
 }
 static void
 parse_bitand(CdlExpression expr)
-throw(CdlParseException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAME("parse_bitand");
 parse_equals(expr);
 while (T_BitAnd == current_token) {
 CYG_REPORT_RETURN();
 }
 static void
 parse_bitxor(CdlExpression expr)
-throw(CdlParseException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAME("parse_bitxor");
 parse_bitand(expr);
 while (T_BitXor == current_token) {
 CYG_REPORT_RETURN();
 }
 static void
 parse_bitor(CdlExpression expr)
-throw(CdlParseException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAME("parse_bitor");
 parse_bitxor(expr);
 while (T_BitOr == current_token) {
 CYG_REPORT_RETURN();
 }
 static void
 parse_and(CdlExpression expr)
-throw(CdlParseException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAME("parse_and");
 parse_bitor(expr);
 while (T_And == current_token) {
 CYG_REPORT_RETURN();
 }
 static void
 parse_or(CdlExpression expr)
-throw(CdlParseException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAME("parse_or");
 parse_and(expr);
 while (T_Or == current_token) {
 CYG_REPORT_RETURN();
 }
 static void
 parse_conditional(CdlExpression expr)
-throw(CdlParseException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAME("parse_conditional");
 parse_or(expr);
 if (T_Questionmark == current_token) {
 CYG_REPORT_RETURN();
 }
 static void
 parse_expression(CdlExpression expr)
-throw(CdlParseException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAME("parse_expression");
 parse_conditional(expr);
 // ----------------------------------------------------------------------------
 // The entry point.
 void
 CdlExpressionBody::continue_parse(CdlExpression expr, std::string data, int& index, CdlExprOp& token, int& token_end)
-throw(CdlParseException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAME("CdlExpression::continue_parse");
 CYG_REPORT_FUNCARG1XV(expr);
 CYG_PRECONDITION_CLASSC(expr);
 CYG_PRECONDITIONC((CdlExprOp_Invalid == token) || (CdlExprOp_And == token));
 // to a simple tree, so evaluation involves some recursion and a big
 // switch statement.
 static void
 evaluate_subexpr(CdlEvalContext& context, CdlExpression expr, int subexpr_index, CdlSimpleValue& result)
-throw(CdlEvalException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAME("evaluate_subexpr");
 CYG_REPORT_FUNCARG2XV(expr, subexpr_index);
 CYG_ASSERTC((subexpr_index >= 0) && ((unsigned int)subexpr_index < expr->sub_expressions.size()));
 }
 // ----------------------------------------------------------------------------
 void
 CdlExpressionBody::eval_internal(CdlEvalContext& context, CdlSimpleValue& result)
-throw(CdlEvalException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAME("CdlExpression::eval_internal)");
 CYG_REPORT_FUNCARG3XV(this, &context, &result);
 CYG_INVARIANT_THISC(CdlExpressionBody);
 CYG_PRECONDITION_CLASSOC(context);
 //
 // continue_parse() is supposed to do all the hard work.
 CdlExpression
 CdlExpressionBody::parse(std::string data)
-throw(CdlParseException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAMETYPE("CdlExpression::parse", "result %p");
 CdlExpression       result  = 0;
 int                 index   = 0;
 return result;
 }
 CdlExpression
 CdlExpressionBody::parse(std::string data, int& index, CdlExprOp& next_token, int& token_end)
-throw(CdlParseException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAMETYPE("CdlExpression::parse", "result %d");
 CdlExpression result = new CdlExpressionBody;
 // eval_internal() member function does not, and is used for list
 // and goal expressions as well.
 void
 CdlExpressionBody::eval(CdlEvalContext& context, CdlSimpleValue& result)
-throw(CdlEvalException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAME("CdlExpression::eval");
 try {
 // Parsing a list expression involves repeated parsing of ordinary
 // expressions until an EOD token is reached.
 CdlListExpression
 CdlListExpressionBody::parse(std::string data)
-throw(CdlParseException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAMETYPE("CdlListExpression::parse", "result %p");
 // Allocate an expression object that can then be filled in.
 CdlListExpression result = new CdlListExpressionBody;
 // ----------------------------------------------------------------------------
 // Evaluation. The hard work is actually done in eval_internal()
 void
 CdlListExpressionBody::eval(CdlEvalContext& context, CdlListValue& result)
-throw(CdlEvalException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAME("CdlListExpression::eval");
 CYG_REPORT_FUNCARG3XV(this, &context, &result);
 CYG_PRECONDITION_THISC();
 CYG_PRECONDITION_CLASSOC(context);
 // vectors and adding the result to the appropriate vector in result.
 // Various error conditions are possible.
 void
 CdlListExpressionBody::eval_internal(CdlEvalContext& context, CdlListValue& result)
-throw(CdlEvalException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAME("CdlListExpression::eval_internal");
 CYG_REPORT_FUNCARG2XV(this, &context);
 result.table.clear();
 // ----------------------------------------------------------------------------
 bool
 CdlListExpressionBody::is_member(CdlEvalContext& context, CdlSimpleValue& val)
-throw(CdlEvalException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAMETYPE("CdlListExpression::is_member (value)", "result %d");
 CYG_REPORT_FUNCARG3XV(this, &context, &val);
 CYG_PRECONDITION_THISC();
 CYG_PRECONDITION_CLASSOC(context);
 return result;
 }
 bool
 CdlListExpressionBody::is_member(CdlEvalContext& context, std::string val)
-throw(CdlEvalException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAMETYPE("CdlListExpression::is_member (string)", "result %d");
 CYG_REPORT_FUNCARG2XV(this, &context);
 CYG_PRECONDITION_THISC();
 CYG_PRECONDITION_CLASSOC(context);
 return result;
 }
 bool
 CdlListExpressionBody::is_member(CdlEvalContext& context, cdl_int val)
-throw(CdlEvalException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAMETYPE("CdlListExpression::is_member (int)", "result %d");
 CYG_REPORT_FUNCARG3XV(this, &context, (int) val);
 CYG_PRECONDITION_THISC();
 CYG_PRECONDITION_CLASSOC(context);
 return result;
 }
 bool
 CdlListExpressionBody::is_member(CdlEvalContext& context, double val)
-throw(CdlEvalException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAMETYPE("CdlListExpression::is_member (double)", "result %d");
 CYG_REPORT_FUNCARG2XV(this, &context);
 CYG_PRECONDITION_THISC();
 CYG_PRECONDITION_CLASSOC(context);
 // easier) but it is almost as easy to derive a goal expression from
 // an ordinary one.
 CdlGoalExpression
 CdlGoalExpressionBody::parse(std::string data)
-throw(CdlParseException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAMETYPE("CdlGoalExpression::parse", "result %p");
 CdlGoalExpression result = new CdlGoalExpressionBody;
 }
 // ----------------------------------------------------------------------------
 void
 CdlGoalExpressionBody::eval(CdlEvalContext& context, bool& result)
-throw(CdlEvalException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAME("CdlGoalExpression::eval");
 CYG_REPORT_FUNCARG2XV(this, &context);
 CYG_PRECONDITION_THISC();
 CYG_PRECONDITION_CLASSOC(context);
 CYG_REPORT_RETURN();
 }
 bool
 CdlGoalExpressionBody::eval(CdlEvalContext& context)
-throw(CdlEvalException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAMETYPE("CdlGoalExpression::eval", "result %d");
 CYG_REPORT_FUNCARG2XV(this, &context);
 CYG_PRECONDITION_THISC();
 CYG_PRECONDITION_CLASSOC(context);
 // ----------------------------------------------------------------------------
 void
 CdlGoalExpressionBody::eval_internal(CdlEvalContext& context, bool& result)
-throw(CdlEvalException, std::bad_alloc)
 {
 CYG_REPORT_FUNCNAME("CdlGoalExpression::eval_internal");
 CYG_REPORT_FUNCARG2XV(this, &context);
 // The assertions are all done in the calling code

Mercurial > ecos-v2_0-branch

comparison host/libcdl/expr.cxx @ 115:6ed91473a1cd ecos-sw-2000-08-21