diff options
author | elliott_c <elliott_c@ae88bc3d-4319-0410-8dbf-d08b4c9d3795> | 2006-12-12 15:06:16 +0000 |
---|---|---|
committer | elliott_c <elliott_c@ae88bc3d-4319-0410-8dbf-d08b4c9d3795> | 2006-12-12 15:06:16 +0000 |
commit | c15e36dea4cbfea47e0fc599375e019858225127 (patch) | |
tree | 8ea10188819b6f76870ffb3e1943246aaf4218fb /TAO/orbsvcs | |
parent | 9fdb44b0ffd3e24e1413747723a8bb3ce0298e47 (diff) | |
download | ATCD-c15e36dea4cbfea47e0fc599375e019858225127.tar.gz |
ChangeLogTag: Tue Dec 12 15:05:04 UTC 2006 Chad Elliott <elliott_c@ociweb.com>
Diffstat (limited to 'TAO/orbsvcs')
17 files changed, 1549 insertions, 1155 deletions
diff --git a/TAO/orbsvcs/orbsvcs/CosTrading.mpc b/TAO/orbsvcs/orbsvcs/CosTrading.mpc index ba24c9a0354..78ce024dd5c 100644 --- a/TAO/orbsvcs/orbsvcs/CosTrading.mpc +++ b/TAO/orbsvcs/orbsvcs/CosTrading.mpc @@ -118,4 +118,55 @@ project(CosTrading_Serv) : orbsvcslib, core, trading_skel, dynamicany, svc_utils Pkgconfig_Files { TAO_CosTrading_Serv.pc.in } + + verbatim(gnuace, local) { + Trader/Constraint_l.cpp: Trader/constraint.l + " @echo 'INFORMATION: Potentially outdated $@'" + " @echo ' either touch(1) the file or explicitly'" + " @echo ' generate it using:'" + " @echo ' make -f GNUmakefile.CosTrading_Serv Constraint_l'" + + .PHONY: Constraint_l + Constraint_l: + " echo '#define YY_NO_UNPUT' > Trader/Constraint_l.cpp" + " $(LEX) -L -t Trader/constraint.l | \\" + " sed -e 's/ NULL/ 0/g' \\" + " -e 's/isatty/ACE_OS::isatty/g' \\" + " -e 's/YY_BREAK break;/YY_BREAK ACE_NOTREACHED (break;)/g' \\" + " -e 's/ECHO/TAO_TRADER_ECHO/' \\" + " -e 's/\\$$Hea''der.*\\$$/$$I''d$$/' \\" + " -e 's@#include <stdio\.h>@#include \"ace/os_include/os_stdio.h\"@' \\" + " -e 's@#include <unistd\.h>@#include \"ace/OS_NS_unistd.h\"@' \\" + " -e '/#include </d' \\" + " >> Trader/Constraint_l.cpp" + " (cd Trader; patch < Constraint_l.cpp.diff)" + + Trader/Constraint_y.cpp: Trader/constraint.y + " @echo 'INFORMATION: Potentially outdated $@'" + " @echo ' either touch(1) the file or explicitly'" + " @echo ' generate it using:'" + " @echo ' make -f GNUmakefile.CosTrading_Serv Constraint_y'" + + .PHONY: Constraint_y + Constraint_y: + " yacc -l -d Trader/constraint.y" + " sed -e 's/ / /g' \\" + " -e 's/ *$$\/\/g' \\" + " -e 's/\|\| defined(__GNUC__)/|| defined(__GNUC__) || defined (WIN32) || defined (__HP_aCC)/g' \\" + " -e 's/memcpy/ACE_OS::memcpy/g' \\" + " -e 's/getenv/ACE_OS::getenv/g' \\" + " -e 's/free/ACE_OS::free/g' \\" + " -e 's/malloc/ACE_OS::malloc/g' \\" + " -e 's/realloc/ACE_OS::realloc/g' < y.tab.c > Trader/Constraint_y.cpp" + " echo '\/\/ $$I''d$$' > Trader/Constraint_Tokens.h" + " echo '' >> Trader/Constraint_Tokens.h" + " echo '#ifndef CONSTRAINT_TOKEN_H' >> Trader/Constraint_Tokens.h" + " echo '#define CONSTRAINT_TOKEN_H' >> Trader/Constraint_Tokens.h" + " echo '#include /**/ \"ace/pre.h\"' >> Trader/Constraint_Tokens.h" + " echo '' >> Trader/Constraint_Tokens.h" + " cat y.tab.h >> Trader/Constraint_Tokens.h" + " echo '#include /**/ \"ace/post.h\"' >> Trader/Constraint_Tokens.h" + " echo '#endif /* CONSTRAINT_TOKEN_H */' >> Trader/Constraint_Tokens.h" + " $(RM) y.tab.h y.tab.c" + } } diff --git a/TAO/orbsvcs/orbsvcs/Trader/Constraint_Interpreter.cpp b/TAO/orbsvcs/orbsvcs/Trader/Constraint_Interpreter.cpp index d7e3826625e..90b01c53853 100644 --- a/TAO/orbsvcs/orbsvcs/Trader/Constraint_Interpreter.cpp +++ b/TAO/orbsvcs/orbsvcs/Trader/Constraint_Interpreter.cpp @@ -2,6 +2,7 @@ #include "orbsvcs/Trader/Constraint_Interpreter.h" #include "orbsvcs/Trader/Trader_Constraint_Visitors.h" +#include "orbsvcs/Trader/Constraint_Tokens.h" ACE_RCSID (Trader, Constraint_Interpreter, diff --git a/TAO/orbsvcs/orbsvcs/Trader/Constraint_Nodes.cpp b/TAO/orbsvcs/orbsvcs/Trader/Constraint_Nodes.cpp index dd5ddc1e92b..c75516aaa57 100644 --- a/TAO/orbsvcs/orbsvcs/Trader/Constraint_Nodes.cpp +++ b/TAO/orbsvcs/orbsvcs/Trader/Constraint_Nodes.cpp @@ -2,6 +2,7 @@ #include "orbsvcs/Trader/Constraint_Nodes.h" #include "orbsvcs/Trader/Constraint_Visitors.h" +#include "orbsvcs/Trader/Constraint_Tokens.h" #include "tao/AnyTypeCode/Any.h" #include "ace/OS_NS_string.h" @@ -277,12 +278,23 @@ TAO_Property_Constraint::accept (TAO_Constraint_Visitor* visitor) return visitor->visit_property (this); } +TAO_Expression_Type +TAO_Property_Constraint::expr_type (void) const +{ + return TAO_IDENT; +} + const char* TAO_Property_Constraint::name (void) const { return name_; } +TAO_Literal_Constraint::TAO_Literal_Constraint (void) + : type_ (TAO_UNKNOWN) +{ +} + TAO_Literal_Constraint:: TAO_Literal_Constraint (const TAO_Literal_Constraint& lit) : TAO_Constraint (lit) @@ -321,7 +333,7 @@ TAO_Literal_Constraint (CORBA::Any* any) { CORBA::Short sh; any_ref >>= sh; - this->op_.integer_ = (CORBA::Long) sh; + this->op_.integer_ = static_cast<CORBA::LongLong> (sh); } else any_ref >>= this->op_.integer_; @@ -332,7 +344,7 @@ TAO_Literal_Constraint (CORBA::Any* any) { CORBA::UShort sh; any_ref >>= sh; - this->op_.uinteger_ = (CORBA::ULong) sh; + this->op_.uinteger_ = static_cast<CORBA::ULongLong> (sh); } else any_ref >>= this->op_.uinteger_; @@ -365,13 +377,13 @@ TAO_Literal_Constraint (CORBA::Any* any) } } -TAO_Literal_Constraint::TAO_Literal_Constraint (CORBA::ULong uinteger) +TAO_Literal_Constraint::TAO_Literal_Constraint (CORBA::ULongLong uinteger) : type_ (TAO_UNSIGNED) { this->op_.uinteger_ = uinteger; } -TAO_Literal_Constraint::TAO_Literal_Constraint (CORBA::Long integer) +TAO_Literal_Constraint::TAO_Literal_Constraint (CORBA::LongLong integer) : type_ (TAO_SIGNED) { this->op_.integer_ = integer; @@ -418,52 +430,52 @@ TAO_Literal_Constraint::operator CORBA::Boolean (void) const return (this->type_ == TAO_BOOLEAN) ? this->op_.bool_ : 0; } -TAO_Literal_Constraint::operator CORBA::ULong (void) const +TAO_Literal_Constraint::operator CORBA::ULongLong (void) const { - CORBA::ULong return_value = (CORBA::ULong)0; + CORBA::ULongLong return_value = 0; if (this->type_ == TAO_UNSIGNED) return_value = this->op_.uinteger_; else if (this->type_ == TAO_SIGNED) return_value = - (this->op_.integer_ > 0) ? (CORBA::ULong) this->op_.integer_ : 0; + (this->op_.integer_ > 0) ? + static_cast<CORBA::ULongLong> (this->op_.integer_) : 0; else if (this->type_ == TAO_DOUBLE) return_value = (this->op_.double_ > 0) ? - ((this->op_.double_ > ACE_UINT32_MAX) ? - ACE_UINT32_MAX : - (CORBA::ULong) this->op_.double_) - : 0; + ((this->op_.double_ > ACE_UINT64_MAX) ? + ACE_UINT64_MAX : + static_cast<CORBA::ULongLong> (this->op_.double_)) : 0; return return_value; } -TAO_Literal_Constraint::operator CORBA::Long (void) const +TAO_Literal_Constraint::operator CORBA::LongLong (void) const { - CORBA::Long return_value = (CORBA::Long)0; + CORBA::LongLong return_value = 0; if (this->type_ == TAO_SIGNED) return_value = this->op_.integer_; else if (this->type_ == TAO_UNSIGNED) return_value = - (this->op_.uinteger_ > (CORBA::ULong) ACE_INT32_MAX) ? - ACE_INT32_MAX : (CORBA::Long) this->op_.uinteger_; + (this->op_.uinteger_ > static_cast<CORBA::ULongLong> (ACE_INT64_MAX)) ? + ACE_INT64_MAX : static_cast<CORBA::LongLong> (this->op_.uinteger_); else if (this->type_ == TAO_DOUBLE) return_value = (this->op_.double_ > 0) ? - ((this->op_.double_ > ACE_INT32_MAX) ? - ACE_INT32_MAX : - (CORBA::Long) this->op_.double_) : - ((this->op_.double_ < ACE_INT32_MIN) ? - ACE_INT32_MIN : - (CORBA::Long) this->op_.double_); + ((this->op_.double_ > ACE_INT64_MAX) ? + ACE_INT64_MAX : + static_cast<CORBA::LongLong> (this->op_.double_)) : + ((this->op_.double_ < ACE_INT64_MIN) ? + ACE_INT64_MIN : + static_cast<CORBA::LongLong> (this->op_.double_)); return return_value; } TAO_Literal_Constraint::operator CORBA::Double (void) const { - CORBA::Double return_value = (CORBA::Double)0.0; + CORBA::Double return_value = 0.0; if (this->type_ == TAO_DOUBLE) return_value = this->op_.double_; @@ -572,10 +584,12 @@ operator== (const TAO_Literal_Constraint& left, return_value = (CORBA::Double) left == (CORBA::Double) right; break; case TAO_SIGNED: - return_value = (CORBA::Long) left == (CORBA::Long) right; + return_value = static_cast<CORBA::LongLong> (left) == + static_cast<CORBA::LongLong> (right); break; case TAO_UNSIGNED: - return_value = (CORBA::ULong) left == (CORBA::ULong) right; + return_value = static_cast<CORBA::ULongLong> (left) == + static_cast<CORBA::ULongLong> (right); break; case TAO_BOOLEAN: return_value = (CORBA::Boolean) left == (CORBA::Boolean) right; @@ -603,10 +617,12 @@ operator!= (const TAO_Literal_Constraint& left, return_value = (CORBA::Double) left != (CORBA::Double) right; break; case TAO_SIGNED: - return_value = (CORBA::Long) left != (CORBA::Long) right; + return_value = static_cast<CORBA::LongLong> (left) != + static_cast<CORBA::LongLong> (right); break; case TAO_UNSIGNED: - return_value = (CORBA::ULong) left != (CORBA::ULong) right; + return_value = static_cast<CORBA::ULongLong> (left) != + static_cast<CORBA::ULongLong> (right); break; case TAO_BOOLEAN: return_value = (CORBA::Boolean) left != (CORBA::Boolean) right; @@ -633,10 +649,12 @@ operator< (const TAO_Literal_Constraint& left, return_value = (CORBA::Double) left < (CORBA::Double) right; break; case TAO_SIGNED: - return_value = (CORBA::Long) left < (CORBA::Long) right; + return_value = static_cast<CORBA::LongLong> (left) < + static_cast<CORBA::LongLong> (right); break; case TAO_UNSIGNED: - return_value = (CORBA::ULong) left < (CORBA::ULong) right; + return_value = static_cast<CORBA::ULongLong> (left) < + static_cast<CORBA::ULongLong> (right); break; case TAO_BOOLEAN: return_value = (CORBA::Boolean) left < (CORBA::Boolean) right; @@ -663,10 +681,12 @@ operator<= (const TAO_Literal_Constraint& left, return_value = (CORBA::Double) left <= (CORBA::Double) right; break; case TAO_SIGNED: - return_value = (CORBA::Long) left <= (CORBA::Long) right; + return_value = static_cast<CORBA::LongLong> (left) <= + static_cast<CORBA::LongLong> (right); break; case TAO_UNSIGNED: - return_value = (CORBA::ULong) left <= (CORBA::ULong) right; + return_value = static_cast<CORBA::ULongLong> (left) <= + static_cast<CORBA::ULongLong> (right); break; } @@ -690,10 +710,12 @@ operator> (const TAO_Literal_Constraint& left, return_value = (CORBA::Double) left > (CORBA::Double) right; break; case TAO_SIGNED: - return_value = (CORBA::Long) left > (CORBA::Long) right; + return_value = static_cast<CORBA::LongLong> (left) > + static_cast<CORBA::LongLong> (right); break; case TAO_UNSIGNED: - return_value = (CORBA::ULong) left > (CORBA::ULong) right; + return_value = static_cast<CORBA::ULongLong> (left) > + static_cast<CORBA::ULongLong> (right); break; } @@ -717,10 +739,12 @@ operator>= (const TAO_Literal_Constraint& left, return_value = (CORBA::Double) left >= (CORBA::Double) right; break; case TAO_SIGNED: - return_value = (CORBA::Long) left >= (CORBA::Long) right; + return_value = static_cast<CORBA::LongLong> (left) >= + static_cast<CORBA::LongLong> (right); break; case TAO_UNSIGNED: - return_value = (CORBA::ULong) left >= (CORBA::ULong) right; + return_value = static_cast<CORBA::ULongLong> (left) >= + static_cast<CORBA::ULongLong> (right); break; } @@ -759,20 +783,22 @@ operator+ (const TAO_Literal_Constraint& left, case TAO_DOUBLE: { CORBA::Double result = (CORBA::Double) left + (CORBA::Double) right; - return TAO_Literal_Constraint ((CORBA::Double) result); + return TAO_Literal_Constraint (result); } case TAO_SIGNED: { - CORBA::Long result = (CORBA::Long) left + (CORBA::Long) right; - return TAO_Literal_Constraint ((CORBA::Long) result); + CORBA::LongLong result = static_cast<CORBA::LongLong> (left) + + static_cast<CORBA::LongLong> (right); + return TAO_Literal_Constraint (result); } case TAO_UNSIGNED: { - CORBA::ULong result = (CORBA::ULong) left + (CORBA::ULong) right; - return TAO_Literal_Constraint ((CORBA::ULong) result); + CORBA::ULongLong result = static_cast<CORBA::ULongLong> (left) + + static_cast<CORBA::ULongLong> (right); + return TAO_Literal_Constraint (result); } default: - return TAO_Literal_Constraint ((CORBA::Long)0); + return TAO_Literal_Constraint (static_cast<CORBA::LongLong> (0)); } } @@ -788,20 +814,22 @@ operator- (const TAO_Literal_Constraint& left, case TAO_DOUBLE: { CORBA::Double result = (CORBA::Double) left - (CORBA::Double) right; - return TAO_Literal_Constraint ((CORBA::Double) result); + return TAO_Literal_Constraint (result); } case TAO_SIGNED: { - CORBA::Long result = (CORBA::Long) left - (CORBA::Long) right; - return TAO_Literal_Constraint ((CORBA::Long) result); + CORBA::LongLong result = static_cast<CORBA::LongLong> (left) - + static_cast<CORBA::LongLong> (right); + return TAO_Literal_Constraint (result); } case TAO_UNSIGNED: { - CORBA::ULong result = (CORBA::ULong) left - (CORBA::ULong) right; - return TAO_Literal_Constraint ((CORBA::ULong) result); + CORBA::ULongLong result = static_cast<CORBA::ULongLong> (left) - + static_cast<CORBA::ULongLong> (right); + return TAO_Literal_Constraint (result); } default: - return TAO_Literal_Constraint ((CORBA::Long)0); + return TAO_Literal_Constraint (static_cast<CORBA::LongLong> (0)); } } @@ -817,20 +845,22 @@ operator* (const TAO_Literal_Constraint& left, case TAO_DOUBLE: { CORBA::Double result = (CORBA::Double) left * (CORBA::Double) right; - return TAO_Literal_Constraint ((CORBA::Double) result); + return TAO_Literal_Constraint (result); } case TAO_SIGNED: { - CORBA::Long result = (CORBA::Long) left * (CORBA::Long) right; - return TAO_Literal_Constraint ((CORBA::Long) result); + CORBA::LongLong result = static_cast<CORBA::LongLong> (left) * + static_cast<CORBA::LongLong> (right); + return TAO_Literal_Constraint (result); } case TAO_UNSIGNED: { - CORBA::ULong result = (CORBA::ULong) left * (CORBA::ULong) right; - return TAO_Literal_Constraint ((CORBA::ULong) result); + CORBA::ULongLong result = static_cast<CORBA::ULongLong> (left) * + static_cast<CORBA::ULongLong> (right); + return TAO_Literal_Constraint (result); } default: - return TAO_Literal_Constraint ((CORBA::Long)0); + return TAO_Literal_Constraint (static_cast<CORBA::LongLong> (0)); } } @@ -846,20 +876,22 @@ operator/ (const TAO_Literal_Constraint& left, case TAO_DOUBLE: { CORBA::Double result = (CORBA::Double) left / (CORBA::Double) right; - return TAO_Literal_Constraint ((CORBA::Double) result); + return TAO_Literal_Constraint (result); } case TAO_SIGNED: { - CORBA::Long result = (CORBA::Long) left / (CORBA::Long) right; - return TAO_Literal_Constraint ((CORBA::Long) result); + CORBA::LongLong result = static_cast<CORBA::LongLong> (left) / + static_cast<CORBA::LongLong> (right); + return TAO_Literal_Constraint (result); } case TAO_UNSIGNED: { - CORBA::ULong result = (CORBA::ULong) left / (CORBA::ULong) right; - return TAO_Literal_Constraint ((CORBA::ULong) result); + CORBA::ULongLong result = static_cast<CORBA::ULongLong> (left) / + static_cast<CORBA::ULongLong> (right); + return TAO_Literal_Constraint (result); } default: - return TAO_Literal_Constraint ((CORBA::Long)0); + return TAO_Literal_Constraint (static_cast<CORBA::LongLong> (0)); } } @@ -871,20 +903,21 @@ operator- (const TAO_Literal_Constraint& operand) case TAO_DOUBLE: { CORBA::Double result = - (CORBA::Double) operand; - return TAO_Literal_Constraint ((CORBA::Double) result); + return TAO_Literal_Constraint (result); } case TAO_SIGNED: { - CORBA::Long result = - (CORBA::Long) operand; - return TAO_Literal_Constraint ((CORBA::Long) result); + CORBA::LongLong result = - static_cast<CORBA::LongLong> (operand); + return TAO_Literal_Constraint (result); } case TAO_UNSIGNED: { - CORBA::Long result = - (CORBA::Long) ((CORBA::ULong) operand); - return TAO_Literal_Constraint ((CORBA::ULong) result); + CORBA::LongLong result = - static_cast<CORBA::LongLong> ( + static_cast<CORBA::ULongLong> (operand)); + return TAO_Literal_Constraint (static_cast<CORBA::ULongLong> (result)); } default: - return TAO_Literal_Constraint ((CORBA::Long)0); + return TAO_Literal_Constraint (static_cast<CORBA::LongLong> (0)); } } diff --git a/TAO/orbsvcs/orbsvcs/Trader/Constraint_Nodes.h b/TAO/orbsvcs/orbsvcs/Trader/Constraint_Nodes.h index 6e9ccd203fd..5df82ffdd7e 100644 --- a/TAO/orbsvcs/orbsvcs/Trader/Constraint_Nodes.h +++ b/TAO/orbsvcs/orbsvcs/Trader/Constraint_Nodes.h @@ -15,8 +15,6 @@ #define TAO_CONSTRAINT_NODES_H #include /**/ "ace/pre.h" -#include "orbsvcs/Trader/Constraint_Tokens.h" - #include "tao/Basic_Types.h" #include "tao/String_Manager_T.h" @@ -201,8 +199,7 @@ public: virtual int accept (TAO_Constraint_Visitor* visitor); - virtual TAO_Expression_Type expr_type (void) const - { return TAO_IDENT; } + virtual TAO_Expression_Type expr_type (void) const; /// Returns the name of the property. const char* name (void) const; @@ -226,14 +223,13 @@ class TAO_Trading_Serv_Export TAO_Literal_Constraint : public TAO_Constraint { public: - TAO_Literal_Constraint (void) - : type_ (TAO_UNKNOWN) {} + TAO_Literal_Constraint (void); // = Constructors for each of the various types of literals. TAO_Literal_Constraint (CORBA::Any* any); - TAO_Literal_Constraint (CORBA::ULong uinteger); - TAO_Literal_Constraint (CORBA::Long integer); + TAO_Literal_Constraint (CORBA::ULongLong uinteger); + TAO_Literal_Constraint (CORBA::LongLong integer); TAO_Literal_Constraint (CORBA::Boolean boolean); TAO_Literal_Constraint (CORBA::Double doub); TAO_Literal_Constraint (const char* str); @@ -255,8 +251,8 @@ class TAO_Trading_Serv_Export TAO_Literal_Constraint : public TAO_Constraint // Conversion routines. operator CORBA::Boolean (void) const; - operator CORBA::ULong (void) const; - operator CORBA::Long (void) const; + operator CORBA::ULongLong (void) const; + operator CORBA::LongLong (void) const; operator CORBA::Double (void) const; operator const char* (void) const; operator const CORBA::Any* (void) const; @@ -265,57 +261,57 @@ class TAO_Trading_Serv_Export TAO_Literal_Constraint : public TAO_Constraint // = Comparison operators. - friend bool + friend TAO_Trading_Serv_Export bool operator< (const TAO_Literal_Constraint& left, const TAO_Literal_Constraint& right); - friend bool + friend TAO_Trading_Serv_Export bool operator<= (const TAO_Literal_Constraint& left, const TAO_Literal_Constraint& right); - friend bool + friend TAO_Trading_Serv_Export bool operator> (const TAO_Literal_Constraint& left, const TAO_Literal_Constraint& right); - friend bool + friend TAO_Trading_Serv_Export bool operator>= (const TAO_Literal_Constraint& left, const TAO_Literal_Constraint& right); - friend bool + friend TAO_Trading_Serv_Export bool operator== (const TAO_Literal_Constraint& left, const TAO_Literal_Constraint& right); - friend bool + friend TAO_Trading_Serv_Export bool operator!= (const TAO_Literal_Constraint& left, const TAO_Literal_Constraint& right); - friend bool + friend TAO_Trading_Serv_Export bool operator== (double left, const TAO_Literal_Constraint& right); - friend bool + friend TAO_Trading_Serv_Export bool operator== (const TAO::String_Manager& left, const TAO_Literal_Constraint& right); // = Arithmetic operators. - friend TAO_Literal_Constraint + friend TAO_Trading_Serv_Export TAO_Literal_Constraint operator+ (const TAO_Literal_Constraint& left, const TAO_Literal_Constraint& right); - friend TAO_Literal_Constraint + friend TAO_Trading_Serv_Export TAO_Literal_Constraint operator- (const TAO_Literal_Constraint& left, const TAO_Literal_Constraint& right); - friend TAO_Literal_Constraint + friend TAO_Trading_Serv_Export TAO_Literal_Constraint operator* (const TAO_Literal_Constraint& left, const TAO_Literal_Constraint& right); - friend TAO_Literal_Constraint + friend TAO_Trading_Serv_Export TAO_Literal_Constraint operator/ (const TAO_Literal_Constraint& left, const TAO_Literal_Constraint& right); - friend TAO_Literal_Constraint + friend TAO_Trading_Serv_Export TAO_Literal_Constraint operator- (const TAO_Literal_Constraint& operand); /// Ensure both operands are of the same simple numeric type. @@ -336,8 +332,8 @@ class TAO_Trading_Serv_Export TAO_Literal_Constraint : public TAO_Constraint { char* str_; CORBA::Any_ptr any_; - CORBA::ULong uinteger_; - CORBA::Long integer_; + CORBA::ULongLong uinteger_; + CORBA::LongLong integer_; CORBA::Boolean bool_; CORBA::Double double_; } op_; diff --git a/TAO/orbsvcs/orbsvcs/Trader/Constraint_Tokens.h b/TAO/orbsvcs/orbsvcs/Trader/Constraint_Tokens.h index 864f8a512be..a40ff4d15da 100644 --- a/TAO/orbsvcs/orbsvcs/Trader/Constraint_Tokens.h +++ b/TAO/orbsvcs/orbsvcs/Trader/Constraint_Tokens.h @@ -4,46 +4,43 @@ #define CONSTRAINT_TOKEN_H #include /**/ "ace/pre.h" -# define TAO_GT 257 -# define TAO_GE 258 -# define TAO_LT 259 -# define TAO_LE 260 -# define TAO_EQ 261 -# define TAO_NE 262 -# define TAO_EXIST 263 -# define TAO_AND 264 -# define TAO_OR 265 -# define TAO_NOT 266 -# define TAO_IN 267 -# define TAO_TWIDDLE 268 -# define TAO_BOOLEAN 269 -# define TAO_PLUS 270 -# define TAO_MINUS 271 -# define TAO_MULT 272 -# define TAO_DIV 273 -# define TAO_UMINUS 274 -# define TAO_NUMBER 275 -# define TAO_RPAREN 276 -# define TAO_LPAREN 277 -# define TAO_IDENT 278 -# define TAO_STRING 279 -# define TAO_UNKNOWN 280 -# define TAO_UNSIGNED 281 -# define TAO_SIGNED 282 -# define TAO_DOUBLE 283 -# define TAO_CONSTRAINT 284 -# define TAO_SEQUENCE 285 -# define TAO_WITH 286 -# define TAO_MAX 287 -# define TAO_MIN 288 -# define TAO_FIRST 289 -# define TAO_RANDOM 290 - - +#ifndef YYERRCODE +#define YYERRCODE 256 +#endif + +#define TAO_GT 257 +#define TAO_GE 258 +#define TAO_LT 259 +#define TAO_LE 260 +#define TAO_EQ 261 +#define TAO_NE 262 +#define TAO_EXIST 263 +#define TAO_AND 264 +#define TAO_OR 265 +#define TAO_NOT 266 +#define TAO_IN 267 +#define TAO_TWIDDLE 268 +#define TAO_BOOLEAN 269 +#define TAO_PLUS 270 +#define TAO_MINUS 271 +#define TAO_MULT 272 +#define TAO_DIV 273 +#define TAO_UMINUS 274 +#define TAO_NUMBER 275 +#define TAO_RPAREN 276 +#define TAO_LPAREN 277 +#define TAO_IDENT 278 +#define TAO_STRING 279 +#define TAO_UNKNOWN 280 +#define TAO_SIGNED 281 +#define TAO_UNSIGNED 282 +#define TAO_DOUBLE 283 +#define TAO_CONSTRAINT 284 +#define TAO_SEQUENCE 285 +#define TAO_WITH 286 +#define TAO_MAX 287 +#define TAO_MIN 288 +#define TAO_FIRST 289 +#define TAO_RANDOM 290 #include /**/ "ace/post.h" -#endif //CONSTRAINT_TOKEN_H - - - - - +#endif /* CONSTRAINT_TOKEN_H */ diff --git a/TAO/orbsvcs/orbsvcs/Trader/Constraint_Visitors.cpp b/TAO/orbsvcs/orbsvcs/Trader/Constraint_Visitors.cpp index 74b6cb25967..2d315aded9f 100644 --- a/TAO/orbsvcs/orbsvcs/Trader/Constraint_Visitors.cpp +++ b/TAO/orbsvcs/orbsvcs/Trader/Constraint_Visitors.cpp @@ -3,6 +3,7 @@ #include "orbsvcs/Trader/Constraint_Visitors.h" #include "orbsvcs/Trader/Constraint_Nodes.h" #include "orbsvcs/Trader/Interpreter_Utils_T.h" +#include "orbsvcs/Trader/Constraint_Tokens.h" #include "tao/DynamicAny/DynSequence_i.h" @@ -132,7 +133,7 @@ TAO_Constraint_Evaluator::visit_max (TAO_Unary_Constraint* unary_max) int TAO_Constraint_Evaluator::visit_random (TAO_Noop_Constraint *) { - TAO_Literal_Constraint random ((CORBA::Long) (ACE_OS::rand ())); + TAO_Literal_Constraint random (static_cast<CORBA::LongLong> (ACE_OS::rand ())); this->queue_.enqueue_head (random); return 0; } @@ -140,7 +141,7 @@ TAO_Constraint_Evaluator::visit_random (TAO_Noop_Constraint *) int TAO_Constraint_Evaluator::visit_first (TAO_Noop_Constraint *) { - TAO_Literal_Constraint first ((CORBA::Long) 0); + TAO_Literal_Constraint first (static_cast<CORBA::LongLong> (0)); this->queue_.enqueue_head (first); return 0; } @@ -540,25 +541,37 @@ sequence_does_contain (CORBA::Any* sequence, { case CORBA::tk_short: { - CORBA::Long value = element; + CORBA::LongLong value = element; return_value = ::TAO_find (*sequence, static_cast<CORBA::Short> (value)); } break; case CORBA::tk_ushort: { - CORBA::ULong value = element; + CORBA::ULongLong value = element; return_value = ::TAO_find (*sequence, static_cast<CORBA::UShort> (value)); } break; case CORBA::tk_long: { - CORBA::Long value = element; - return_value = ::TAO_find (*sequence, value); + CORBA::LongLong value = element; + return_value = ::TAO_find (*sequence, static_cast<CORBA::Long> (value)); } break; case CORBA::tk_ulong: { - CORBA::ULong value = element; + CORBA::ULongLong value = element; + return_value = ::TAO_find (*sequence, static_cast<CORBA::ULong> (value)); + } + break; + case CORBA::tk_longlong: + { + CORBA::LongLong value = element; + return_value = ::TAO_find (*sequence, value); + } + break; + case CORBA::tk_ulonglong: + { + CORBA::ULongLong value = element; return_value = ::TAO_find (*sequence, value); } break; @@ -672,6 +685,44 @@ operator () (TAO_DynSequence_i& dyn_any, } int +TAO_Element_Equal<CORBA::LongLong>:: +operator () (TAO_DynSequence_i& dyn_any, + CORBA::LongLong element) const +{ + int return_value = 0; + ACE_TRY_NEW_ENV + { + CORBA::LongLong value = dyn_any.get_longlong (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + return_value = (value == element); + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + return return_value; +} + +int +TAO_Element_Equal<CORBA::ULongLong>:: +operator () (TAO_DynSequence_i& dyn_any, + CORBA::ULongLong element) const +{ + int return_value = 0; + ACE_TRY_NEW_ENV + { + CORBA::ULongLong value = dyn_any.get_ulonglong (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + return_value = (value == element); + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + return return_value; +} + +int TAO_Element_Equal<CORBA::Float>:: operator () (TAO_DynSequence_i& dyn_any, CORBA::Float element) const @@ -944,15 +995,18 @@ visit_div (TAO_Binary_Constraint* boolean_div) { case TAO_UNSIGNED: right_isnt_zero = - ((CORBA::ULong) (*((TAO_Literal_Constraint*) right)) != 0); + (static_cast<CORBA::ULongLong> + (*dynamic_cast<TAO_Literal_Constraint*> (right)) != 0); break; case TAO_SIGNED: right_isnt_zero = - ((CORBA::Long) (*((TAO_Literal_Constraint*) right)) != 0); + (static_cast<CORBA::LongLong> + (*dynamic_cast<TAO_Literal_Constraint*> (right)) != 0); break; case TAO_DOUBLE: right_isnt_zero = - ((CORBA::Double) (*((TAO_Literal_Constraint*) right)) != 0.0); + (static_cast<CORBA::Double> + (*dynamic_cast<TAO_Literal_Constraint*> (right)) != 0.0); break; } @@ -1182,7 +1236,7 @@ TAO_Constraint_Validator::expr_returns_number (TAO_Expression_Type expr_type) int return_value = 0; if ((expr_type >= TAO_PLUS && expr_type <= TAO_NUMBER) || - (expr_type >= TAO_UNSIGNED && expr_type <= TAO_DOUBLE)) + (expr_type >= TAO_SIGNED && expr_type <= TAO_DOUBLE)) return_value = 1; return return_value; diff --git a/TAO/orbsvcs/orbsvcs/Trader/Constraint_Visitors.h b/TAO/orbsvcs/orbsvcs/Trader/Constraint_Visitors.h index 9bbba2e8755..a36eea5d980 100644 --- a/TAO/orbsvcs/orbsvcs/Trader/Constraint_Visitors.h +++ b/TAO/orbsvcs/orbsvcs/Trader/Constraint_Visitors.h @@ -404,6 +404,27 @@ public: }; template<> +class TAO_Element_Equal<CORBA::LongLong> +{ +public: + /// Calls the correct method on dyn_seq to extract the element type, + /// then uses the appropriate form of equals comparison. + int operator () (TAO_DynSequence_i& dyn_any, + CORBA::LongLong element) const; +}; + +template<> +class TAO_Element_Equal<CORBA::ULongLong> +{ +public: + /// Calls the correct method on dyn_seq to extract the element type, then + /// uses the appropriate form of equals comparison. + int operator () (TAO_DynSequence_i& dyn_any, + CORBA::ULongLong element) const; + +}; + +template<> class TAO_Element_Equal<CORBA::Float> { public: diff --git a/TAO/orbsvcs/orbsvcs/Trader/Constraint_l.cpp b/TAO/orbsvcs/orbsvcs/Trader/Constraint_l.cpp index a451f98e6a9..adb4f5b2ddc 100644 --- a/TAO/orbsvcs/orbsvcs/Trader/Constraint_l.cpp +++ b/TAO/orbsvcs/orbsvcs/Trader/Constraint_l.cpp @@ -1,15 +1,18 @@ +#define YY_NO_UNPUT /* A lexical scanner generated by flex */ /* Scanner skeleton version: - * $Header$ + * $Id$ */ #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 #define YY_FLEX_MINOR_VERSION 5 -#include "tao/orbconf.h" -#include "ace/OS.h" +#include "ace/os_include/os_stdio.h" +#include "ace/OS_NS_unistd.h" +#include /**/ "tao/Versioned_Namespace.h" + /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ #ifdef c_plusplus @@ -21,6 +24,7 @@ #ifdef __cplusplus + /* Use prototypes in function declarations. */ #define YY_USE_PROTOS @@ -37,6 +41,13 @@ #endif /* __STDC__ */ #endif /* ! __cplusplus */ +#ifdef __TURBOC__ + #pragma warn -rch + #pragma warn -use +#define YY_USE_CONST +#define YY_USE_PROTOS +#endif + #ifdef YY_USE_CONST #define yyconst const #else @@ -274,17 +285,16 @@ static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); #define YY_NUM_RULES 31 #define YY_END_OF_BUFFER 32 -static yyconst short int yy_accept[82] = +static yyconst short int yy_accept[81] = { 0, 0, 0, 32, 30, 31, 30, 30, 22, 23, 14, 12, 13, 30, 15, 26, 16, 30, 18, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, - 11, 21, 0, 28, 0, 26, 27, 0, 26, 17, - 20, 19, 29, 29, 29, 29, 29, 29, 10, 29, - 29, 29, 9, 29, 29, 0, 0, 29, 29, 8, - 29, 29, 2, 1, 7, 29, 29, 0, 27, 29, - 24, 29, 29, 29, 5, 25, 6, 3, 29, 4, - 0 + 11, 21, 0, 28, 0, 0, 26, 27, 17, 20, + 19, 29, 29, 29, 29, 29, 29, 10, 29, 29, + 29, 9, 29, 29, 0, 0, 29, 29, 8, 29, + 29, 2, 1, 7, 29, 29, 0, 27, 29, 24, + 29, 29, 29, 5, 25, 6, 3, 29, 4, 0 } ; static yyconst int yy_ec[256] = @@ -328,70 +338,70 @@ static yyconst int yy_meta[42] = 1 } ; -static yyconst short int yy_base[84] = +static yyconst short int yy_base[83] = { 0, - 0, 0, 107, 108, 108, 92, 38, 108, 108, 108, - 93, 92, 91, 108, 33, 88, 87, 86, 0, 83, - 77, 63, 56, 63, 60, 17, 58, 56, 64, 58, - 108, 108, 42, 108, 43, 77, 36, 76, 40, 108, - 108, 108, 0, 67, 62, 57, 52, 47, 0, 42, - 47, 42, 0, 45, 40, 47, 47, 55, 58, 0, - 38, 34, 0, 0, 0, 42, 38, 54, 52, 44, - 0, 23, 22, 23, 0, 0, 0, 0, 24, 0, - 108, 72, 51 + 0, 0, 108, 109, 109, 93, 38, 109, 109, 109, + 33, 34, 94, 109, 37, 91, 90, 89, 0, 86, + 80, 66, 59, 66, 63, 21, 61, 59, 67, 61, + 109, 109, 46, 109, 47, 80, 42, 44, 109, 109, + 109, 0, 71, 66, 61, 56, 51, 0, 46, 51, + 46, 0, 49, 44, 51, 49, 59, 62, 0, 42, + 38, 0, 0, 0, 46, 39, 57, 56, 49, 0, + 28, 27, 29, 0, 0, 0, 0, 27, 0, 109, + 76, 57 } ; -static yyconst short int yy_def[84] = +static yyconst short int yy_def[83] = { 0, - 81, 1, 81, 81, 81, 81, 82, 81, 81, 81, - 81, 81, 81, 81, 81, 81, 81, 81, 83, 83, - 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, - 81, 81, 82, 81, 81, 81, 81, 81, 81, 81, - 81, 81, 83, 83, 83, 83, 83, 83, 83, 83, - 83, 83, 83, 83, 83, 82, 81, 83, 83, 83, - 83, 83, 83, 83, 83, 83, 83, 81, 81, 83, - 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, - 0, 81, 81 + 80, 1, 80, 80, 80, 80, 81, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 82, 82, + 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, + 80, 80, 81, 80, 80, 80, 80, 80, 80, 80, + 80, 82, 82, 82, 82, 82, 82, 82, 82, 82, + 82, 82, 82, 82, 81, 80, 82, 82, 82, 82, + 82, 82, 82, 82, 82, 82, 80, 80, 82, 82, + 82, 82, 82, 82, 82, 82, 82, 82, 82, 0, + 80, 80 } ; -static yyconst short int yy_nxt[150] = +static yyconst short int yy_nxt[151] = { 0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 19, 19, 20, 19, 19, 19, 21, 19, 4, 4, 22, 19, 23, 24, 19, 25, 26, 27, 28, 29, 19, 19, 30, 19, - 31, 34, 38, 50, 39, 34, 56, 37, 51, 38, - 34, 39, 43, 57, 68, 68, 80, 79, 69, 78, - 77, 76, 35, 69, 57, 69, 35, 56, 75, 74, - 73, 35, 33, 33, 72, 71, 70, 67, 66, 65, - 64, 63, 62, 61, 60, 59, 58, 37, 36, 55, - 54, 53, 52, 49, 48, 47, 46, 45, 44, 42, - - 41, 40, 37, 36, 36, 32, 81, 3, 81, 81, - 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, - 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, - 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, - 81, 81, 81, 81, 81, 81, 81, 81, 81 + 31, 34, 36, 36, 37, 37, 36, 49, 37, 34, + 55, 36, 50, 37, 34, 38, 67, 67, 42, 79, + 68, 56, 35, 78, 77, 76, 75, 68, 68, 74, + 35, 55, 56, 73, 72, 35, 33, 33, 71, 70, + 69, 66, 65, 64, 63, 62, 61, 60, 59, 58, + 57, 38, 54, 53, 52, 51, 48, 47, 46, 45, + + 44, 43, 41, 40, 39, 38, 32, 80, 3, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80 } ; -static yyconst short int yy_chk[150] = +static yyconst short int yy_chk[151] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 7, 15, 26, 15, 33, 35, 37, 26, 39, - 56, 39, 83, 37, 57, 57, 79, 74, 57, 73, - 72, 70, 7, 69, 37, 68, 33, 35, 67, 66, - 62, 56, 82, 82, 61, 59, 58, 55, 54, 52, - 51, 50, 48, 47, 46, 45, 44, 38, 36, 30, - 29, 28, 27, 25, 24, 23, 22, 21, 20, 18, - - 17, 16, 13, 12, 11, 6, 3, 81, 81, 81, - 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, - 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, - 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, - 81, 81, 81, 81, 81, 81, 81, 81, 81 + 1, 7, 11, 12, 11, 12, 15, 26, 15, 33, + 35, 37, 26, 37, 55, 38, 56, 56, 82, 78, + 56, 38, 7, 73, 72, 71, 69, 68, 67, 66, + 33, 35, 38, 65, 61, 55, 81, 81, 60, 58, + 57, 54, 53, 51, 50, 49, 47, 46, 45, 44, + 43, 36, 30, 29, 28, 27, 25, 24, 23, 22, + + 21, 20, 18, 17, 16, 13, 6, 3, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80 } ; static yy_state_type yy_last_accepting_state; @@ -405,9 +415,7 @@ static char *yy_last_accepting_cpos; #define YY_MORE_ADJ 0 #define YY_RESTORE_YY_MORE_OFFSET char *yytext; - #define INITIAL 0 - TAO_END_VERSIONED_NAMESPACE_DECL // $Id$ @@ -415,7 +423,7 @@ TAO_END_VERSIONED_NAMESPACE_DECL // // = LIBRARY // orbsvcs -// +// // = FILENAME // constraint.l // @@ -431,6 +439,8 @@ TAO_END_VERSIONED_NAMESPACE_DECL TAO_BEGIN_VERSIONED_NAMESPACE_DECL static TAO_Literal_Constraint* extract_string(const char*); +static CORBA::LongLong trader_strtoll(const char* str, unsigned int base); +static CORBA::ULongLong trader_strtoull(const char* str, unsigned int base); #define TAO_YY_LEX_DEBUG @@ -440,7 +450,6 @@ static TAO_Literal_Constraint* extract_string(const char*); - /* Macros after this point can all be overridden by user definitions in * section 1. */ @@ -453,11 +462,9 @@ extern int yywrap YY_PROTO(( void )); #endif #endif -#if 0 #ifndef YY_NO_UNPUT static void yyunput YY_PROTO(( int c, char *buf_ptr )); #endif -#endif /* 0 */ #ifndef yytext_ptr static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); @@ -502,7 +509,6 @@ YY_MALLOC_DECL #else #if __STDC__ #ifndef __cplusplus -#include <stdlib.h> #endif #else /* Just try to get by without declaring the routines. This will fail @@ -582,7 +588,7 @@ YY_MALLOC_DECL /* Code executed at the end of each rule. */ #ifndef YY_BREAK -#define YY_BREAK break; +#define YY_BREAK ACE_NOTREACHED (break;) #endif #define YY_RULE_SETUP \ @@ -599,8 +605,6 @@ YY_DECL - - if ( yy_init ) { yy_init = 0; @@ -650,13 +654,13 @@ yy_match: while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 82 ) + if ( yy_current_state >= 81 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; ++yy_cp; } - while ( yy_base[yy_current_state] != 108 ); + while ( yy_base[yy_current_state] != 109 ); yy_find_action: yy_act = yy_accept[yy_current_state]; @@ -684,186 +688,163 @@ do_action: /* This label is used only to access EOF actions. */ case 1: YY_RULE_SETUP - { TAO_YY_LEX_DEBUG; return TAO_MIN; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 2: YY_RULE_SETUP - { TAO_YY_LEX_DEBUG; return TAO_MAX; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 3: YY_RULE_SETUP - { TAO_YY_LEX_DEBUG; return TAO_FIRST; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 4: YY_RULE_SETUP - { TAO_YY_LEX_DEBUG; return TAO_RANDOM; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 5: YY_RULE_SETUP - { TAO_YY_LEX_DEBUG; return TAO_WITH; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 6: YY_RULE_SETUP - { TAO_YY_LEX_DEBUG; return TAO_EXIST; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 7: YY_RULE_SETUP - { TAO_YY_LEX_DEBUG; return TAO_NOT; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 8: YY_RULE_SETUP - { TAO_YY_LEX_DEBUG; return TAO_AND; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 9: YY_RULE_SETUP - { TAO_YY_LEX_DEBUG; return TAO_OR; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 10: YY_RULE_SETUP - { TAO_YY_LEX_DEBUG; return TAO_IN; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 11: YY_RULE_SETUP - { TAO_YY_LEX_DEBUG; return TAO_TWIDDLE; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 12: YY_RULE_SETUP - { TAO_YY_LEX_DEBUG; return TAO_PLUS; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 13: YY_RULE_SETUP - { TAO_YY_LEX_DEBUG; return TAO_MINUS; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 14: YY_RULE_SETUP - { TAO_YY_LEX_DEBUG; return TAO_MULT; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 15: YY_RULE_SETUP - { TAO_YY_LEX_DEBUG; return TAO_DIV; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 16: YY_RULE_SETUP - { TAO_YY_LEX_DEBUG; return TAO_LT; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 17: YY_RULE_SETUP - { TAO_YY_LEX_DEBUG; return TAO_LE; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 18: YY_RULE_SETUP - { TAO_YY_LEX_DEBUG; return TAO_GT; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 19: YY_RULE_SETUP - { TAO_YY_LEX_DEBUG; return TAO_GE; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 20: YY_RULE_SETUP - { TAO_YY_LEX_DEBUG; return TAO_EQ; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 21: YY_RULE_SETUP - { TAO_YY_LEX_DEBUG; return TAO_NE; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 22: YY_RULE_SETUP - { TAO_YY_LEX_DEBUG; return TAO_LPAREN; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 23: YY_RULE_SETUP - { TAO_YY_LEX_DEBUG; return TAO_RPAREN; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 24: YY_RULE_SETUP - -{ - yylval.constraint_ = - new TAO_Literal_Constraint(true); +{ + yylval.constraint_ = + new TAO_Literal_Constraint(true); TAO_YY_LEX_DEBUG; return TAO_BOOLEAN; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 25: YY_RULE_SETUP - -{ - yylval.constraint_ = - new TAO_Literal_Constraint(false); +{ + yylval.constraint_ = + new TAO_Literal_Constraint(false); TAO_YY_LEX_DEBUG; return TAO_BOOLEAN; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 26: YY_RULE_SETUP - -{ - yylval.constraint_ = - new TAO_Literal_Constraint((yytext[0] == '-' ? - (CORBA::Long)atoi(yytext) : (CORBA::ULong)atoi(yytext))); - TAO_YY_LEX_DEBUG; return TAO_NUMBER; +{ + if (yytext[0] == '-') + { + yylval.constraint_ = + new TAO_Literal_Constraint( + trader_strtoll(yytext, 0)); + } + else + { + yylval.constraint_ = + new TAO_Literal_Constraint( + trader_strtoull(yytext, 0)); + } + TAO_YY_LEX_DEBUG; return TAO_NUMBER; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 27: YY_RULE_SETUP - -{ - yylval.constraint_ = - new TAO_Literal_Constraint((CORBA::Double)atof(yytext)); - TAO_YY_LEX_DEBUG; return TAO_NUMBER; +{ + yylval.constraint_ = + new TAO_Literal_Constraint(ACE_OS::strtod(yytext, 0)); + TAO_YY_LEX_DEBUG; return TAO_NUMBER; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 28: YY_RULE_SETUP - -{ +{ yylval.constraint_ = extract_string(yytext); - TAO_YY_LEX_DEBUG; return TAO_STRING; + TAO_YY_LEX_DEBUG; return TAO_STRING; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 29: YY_RULE_SETUP - -{ - yylval.constraint_ = +{ + yylval.constraint_ = new TAO_Property_Constraint(yytext); - TAO_YY_LEX_DEBUG; return TAO_IDENT; + TAO_YY_LEX_DEBUG; return TAO_IDENT; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 30: YY_RULE_SETUP - -{ +{ TAO_YY_LEX_DEBUG; return TAO_UNKNOWN; } - ACE_NOTREACHED (YY_BREAK) + YY_BREAK case 31: YY_RULE_SETUP - TAO_TRADER_ECHO; - YY_BREAK - + break; case YY_STATE_EOF(INITIAL): yyterminate(); @@ -1155,7 +1136,7 @@ static yy_state_type yy_get_previous_state() while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 82 ) + if ( yy_current_state >= 81 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; @@ -1190,16 +1171,16 @@ yy_state_type yy_current_state; while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 82 ) + if ( yy_current_state >= 81 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; - yy_is_jam = (yy_current_state == 81); + yy_is_jam = (yy_current_state == 80); return yy_is_jam ? 0 : yy_current_state; } -#if 0 + #ifndef YY_NO_UNPUT #ifdef YY_USE_PROTOS static void yyunput( int c, register char *yy_bp ) @@ -1243,8 +1224,9 @@ register char *yy_bp; yy_c_buf_p = yy_cp; } #endif /* ifndef YY_NO_UNPUT */ -#endif /* 0 */ + +#ifndef YY_NO_INPUT #ifdef __cplusplus static int yyinput() #else @@ -1316,7 +1298,7 @@ static int input() return c; } - +#endif /* YY_NO_INPUT */ #ifdef YY_USE_PROTOS void yyrestart( FILE *input_file ) @@ -1443,18 +1425,15 @@ FILE *file; b->yy_input_file = file; b->yy_fill_buffer = 1; -#if defined (ACE_HAS_WINCE) - // Mimic the behavior as WinCE does not have isatty(). - if ((file != 0) && (file == fileno(file))) { - b->yy_is_interactive = 1; - } - else { - b->yy_is_interactive = 0; - } +#if YY_ALWAYS_INTERACTIVE + b->yy_is_interactive = 1; #else - b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; -#endif // ACE_HAS_WINCE - +#if YY_NEVER_INTERACTIVE + b->yy_is_interactive = 0; +#else + b->yy_is_interactive = file ? (ACE_OS::isatty( fileno(file) ) > 0) : 0; +#endif +#endif } @@ -1749,11 +1728,10 @@ int main() #endif - TAO_Literal_Constraint* extract_string(const char* total) { - int prev_slash = 0, + int prev_slash = 0, ctr = 0; char str[BUFSIZ], *tmp = (char*) total + 1; @@ -1781,6 +1759,104 @@ extract_string(const char* total) return new TAO_Literal_Constraint(str); } +CORBA::ULongLong +trader_strtoull(const char* s, unsigned int base) +{ + CORBA::ULongLong result = 0; + CORBA::ULongLong previous = 0; + + // Check for a valid base + if (!(base == 0 || base == 8 || base == 10 || base == 16)) + { + errno = EINVAL; + return result; + } + + if (*s == '+') + { + s++; + } + + if ((base == 0 || base == 16) && + *s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X')) + { + s += 2; + base = 16; + } + else if ((base == 0 || base == 8) && *s == '0') + { + s++; + base = 8; + } + else + { + base = 10; + } + + for (; *s; ++s) + { + if (base == 8 && *s <= '7' && *s >= '0') + { + result = (result * base) + (*s - '0'); + } + else if (base > 8 && *s <= '9' && *s >= '0') + { + result = (result * base) + (*s - '0'); + } + else if (base > 10 && *s <= 'f' && *s >= 'a') + { + result = (result * base) + (*s - 'a' + 10); + } + else if (base > 10 && *s <= 'F' && *s >= 'A') + { + result = (result * base) + (*s - 'A' + 10); + } + else + { + break; + } + + // If the previous value is greater than result, then we have + // exceeded the size of a CORBA::ULongLong and the result + // will be ACE_UINT64_MAX. However, errno will be set to ERANGE + if (previous > result) + { + errno = ERANGE; + result = ACE_UINT64_MAX; + break; + } + previous = result; + } + + return result; +} + +CORBA::LongLong +trader_strtoll(const char* s, unsigned int base) +{ + // Check for the negative sign + bool negative = false; + if (*s == '-') + { + negative = true; + s++; + } + + // Convert the raw text into a CORBA::LongLong + CORBA::LongLong result = static_cast<CORBA::LongLong> ( + trader_strtoull(s, base)); + + // If the result that comes back is negative, then the value exceeded + // the maximum for CORBA::LongLong + if (result < 0) + { + errno = ERANGE; + return (negative ? ACE_INT64_MIN : ACE_INT64_MAX); + } + + return (negative ? -result : result); +} + int yywrap (void) { diff --git a/TAO/orbsvcs/orbsvcs/Trader/Constraint_l.cpp.diff b/TAO/orbsvcs/orbsvcs/Trader/Constraint_l.cpp.diff new file mode 100644 index 00000000000..d7ae0c457cd --- /dev/null +++ b/TAO/orbsvcs/orbsvcs/Trader/Constraint_l.cpp.diff @@ -0,0 +1,46 @@ +--- Constraint_l.cpp.orig 2006-12-11 08:23:38.000000000 -0600 ++++ Constraint_l.cpp 2006-12-11 08:23:19.000000000 -0600 +@@ -11,6 +11,7 @@ + + #include "ace/os_include/os_stdio.h" + #include "ace/OS_NS_unistd.h" ++#include /**/ "tao/Versioned_Namespace.h" + + + /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +@@ -94,6 +95,8 @@ + /* Size of default input buffer. */ + #define YY_BUF_SIZE 16384 + ++TAO_BEGIN_VERSIONED_NAMESPACE_DECL ++ + typedef struct yy_buffer_state *YY_BUFFER_STATE; + + extern int yyleng; +@@ -499,6 +502,8 @@ + #define YY_NO_TOP_STATE 1 + #endif + ++TAO_END_VERSIONED_NAMESPACE_DECL ++ + #ifdef YY_MALLOC_DECL + YY_MALLOC_DECL + #else +@@ -589,6 +594,8 @@ + #define YY_RULE_SETUP \ + YY_USER_ACTION + ++TAO_BEGIN_VERSIONED_NAMESPACE_DECL ++ + YY_DECL + { + register yy_state_type yy_current_state; +@@ -837,7 +844,7 @@ + case 31: + YY_RULE_SETUP + TAO_TRADER_ECHO; +- YY_BREAK ++ break; + case YY_STATE_EOF(INITIAL): + yyterminate(); + diff --git a/TAO/orbsvcs/orbsvcs/Trader/Constraint_y.cpp b/TAO/orbsvcs/orbsvcs/Trader/Constraint_y.cpp index 4376a5b05ba..9779557ec3e 100644 --- a/TAO/orbsvcs/orbsvcs/Trader/Constraint_y.cpp +++ b/TAO/orbsvcs/orbsvcs/Trader/Constraint_y.cpp @@ -1,900 +1,645 @@ - - // $Id$ -// ======================================================================== -// -// = LIBRARY -// orbsvcs -// -// = FILENAME -// constraint.y -// -// = AUTHOR -// Seth Widoff <sbw1@cs.wustl.edu> -// -// ======================================================================== +#ifndef lint +static char const +yyrcsid[] = "$FreeBSD: src/usr.bin/yacc/skeleton.c,v 1.28 2000/01/17 02:04:06 bde Exp $"; +#endif +#include <stdlib.h> +#define YYBYACC 1 +#define YYMAJOR 1 +#define YYMINOR 9 +#define YYLEX yylex() +#define YYEMPTY -1 +#define yyclearin (yychar=(YYEMPTY)) +#define yyerrok (yyerrflag=0) +#define YYRECOVERING() (yyerrflag!=0) +static int yygrowstack(); +#define YYPREFIX "yy" + /* $Id$*/ +/* ========================================================================*/ +/**/ +/* = LIBRARY*/ +/* orbsvcs*/ +/* */ +/* = FILENAME*/ +/* constraint.y*/ +/**/ +/* = AUTHOR*/ +/* Seth Widoff <sbw1@cs.wustl.edu>*/ +/**/ +/* ========================================================================*/ #include "ace/OS_NS_string.h" +#include "ace/OS_NS_stdlib.h" #include "orbsvcs/Trader/Constraint_Interpreter.h" #include "orbsvcs/Trader/Constraint_Nodes.h" TAO_BEGIN_VERSIONED_NAMESPACE_DECL -//#define YYDEBUG 1 -# define TAO_GT 257 -# define TAO_GE 258 -# define TAO_LT 259 -# define TAO_LE 260 -# define TAO_EQ 261 -# define TAO_NE 262 -# define TAO_EXIST 263 -# define TAO_AND 264 -# define TAO_OR 265 -# define TAO_NOT 266 -# define TAO_IN 267 -# define TAO_TWIDDLE 268 -# define TAO_BOOLEAN 269 -# define TAO_PLUS 270 -# define TAO_MINUS 271 -# define TAO_MULT 272 -# define TAO_DIV 273 -# define TAO_UMINUS 274 -# define TAO_NUMBER 275 -# define TAO_RPAREN 276 -# define TAO_LPAREN 277 -# define TAO_IDENT 278 -# define TAO_STRING 279 -# define TAO_UNKNOWN 280 -# define TAO_UNSIGNED 281 -# define TAO_SIGNED 282 -# define TAO_DOUBLE 283 -# define TAO_CONSTRAINT 284 -# define TAO_SEQUENCE 285 -# define TAO_WITH 286 -# define TAO_MAX 287 -# define TAO_MIN 288 -# define TAO_FIRST 289 -# define TAO_RANDOM 290 - -#ifdef __cplusplus - -#ifndef yyerror - void yyerror(const char *); -#endif - -#ifndef yylex -#ifdef __EXTERN_C__ - extern "C" { int yylex(void); } -#else - int yylex(void); -#endif -#endif - int yyparse(void); - -#endif -#define yyclearin yychar = -1 -#define yyerrok yyerrflag = 0 -extern int yychar; -extern int yyerrflag; -YYSTYPE yylval; -YYSTYPE yyval; -typedef int yytabelem; -#ifndef YYMAXDEPTH -#define YYMAXDEPTH 150 -#endif -#if YYMAXDEPTH > 0 -int yy_yys[YYMAXDEPTH], *yys = yy_yys; -YYSTYPE yy_yyv[YYMAXDEPTH], *yyv = yy_yyv; -#else /* user does initial allocation */ -int *yys; -YYSTYPE *yyv; -#endif -static int yymaxdepth = YYMAXDEPTH; -# define YYERRCODE 256 - - - - -//extern int yydebug = 1; -yytabelem yyexca[] ={ --1, 1, - 0, -1, - -2, 0, - }; -# define YYNPROD 38 -# define YYLAST 93 -yytabelem yyact[]={ - - 19, 54, 44, 16, 45, 19, 24, 37, 22, 38, - 39, 24, 21, 22, 18, 20, 23, 21, 25, 18, - 20, 23, 36, 7, 6, 5, 8, 9, 19, 60, - 26, 16, 40, 41, 24, 25, 22, 38, 39, 15, - 21, 11, 18, 20, 23, 32, 33, 34, 35, 30, - 31, 14, 10, 17, 13, 12, 4, 3, 1, 2, - 0, 0, 0, 0, 0, 27, 28, 29, 0, 0, - 42, 0, 48, 49, 50, 51, 52, 53, 43, 47, - 58, 59, 46, 0, 0, 0, 0, 0, 0, 0, - 56, 57, 55 }; -yytabelem yypact[]={ - - -263,-10000000, -230,-10000000, -234, -235, -235, -235,-10000000,-10000000, --10000000, -212, -245, -261, -240,-10000000, -258,-10000000, -235, -276, --10000000,-10000000, -271,-10000000,-10000000, -235, -235, -230, -230, -230, - -235, -235, -235, -235, -235, -235, -277, -235, -235, -235, - -235, -235,-10000000, -247,-10000000,-10000000, -234,-10000000,-10000000,-10000000, --10000000,-10000000,-10000000,-10000000,-10000000, -233, -240, -240,-10000000,-10000000, --10000000 }; -yytabelem yypgo[]={ - - 0, 58, 57, 59, 56, 52, 41, 55, 54, 51, - 39, 53 }; -yytabelem yyr1[]={ - - 0, 1, 1, 2, 2, 2, 2, 2, 3, 3, - 4, 4, 5, 5, 5, 5, 5, 5, 5, 6, - 6, 7, 7, 8, 8, 8, 9, 9, 9, 10, - 10, 11, 11, 11, 11, 11, 11, 11 }; -yytabelem yyr2[]={ - - 0, 3, 3, 5, 5, 5, 3, 3, 7, 3, - 7, 3, 7, 7, 7, 7, 7, 7, 3, 7, - 3, 7, 3, 7, 7, 3, 7, 7, 3, 5, - 3, 7, 5, 3, 3, 5, 3, 3 }; -yytabelem yychk[]={ - --10000000, -1, -3, -2, -4, 288, 287, 286, 289, 290, - -5, -6, -7, -8, -9, -10, 266, -11, 277, 263, - 278, 275, 271, 279, 269, 265, 264, -3, -3, -3, - 261, 262, 257, 258, 259, 260, 267, 268, 270, 271, - 272, 273, -11, -3, 278, 275, -4, -5, -6, -6, - -6, -6, -6, -6, 278, -8, -9, -9, -10, -10, - 276 }; -yytabelem yydef[]={ - - 0, -2, 1, 2, 9, 0, 0, 0, 6, 7, - 11, 18, 20, 22, 25, 28, 0, 30, 0, 0, - 33, 34, 0, 36, 37, 0, 0, 3, 4, 5, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 29, 0, 32, 35, 8, 10, 12, 13, - 14, 15, 16, 17, 19, 21, 23, 24, 26, 27, - 31 }; -typedef struct -#ifdef __cplusplus - yytoktype -#endif -{ char *t_name; int t_val; } yytoktype; +/*#define YYDEBUG 1*/ +#define YYERRCODE 256 +#define TAO_GT 257 +#define TAO_GE 258 +#define TAO_LT 259 +#define TAO_LE 260 +#define TAO_EQ 261 +#define TAO_NE 262 +#define TAO_EXIST 263 +#define TAO_AND 264 +#define TAO_OR 265 +#define TAO_NOT 266 +#define TAO_IN 267 +#define TAO_TWIDDLE 268 +#define TAO_BOOLEAN 269 +#define TAO_PLUS 270 +#define TAO_MINUS 271 +#define TAO_MULT 272 +#define TAO_DIV 273 +#define TAO_UMINUS 274 +#define TAO_NUMBER 275 +#define TAO_RPAREN 276 +#define TAO_LPAREN 277 +#define TAO_IDENT 278 +#define TAO_STRING 279 +#define TAO_UNKNOWN 280 +#define TAO_SIGNED 281 +#define TAO_UNSIGNED 282 +#define TAO_DOUBLE 283 +#define TAO_CONSTRAINT 284 +#define TAO_SEQUENCE 285 +#define TAO_WITH 286 +#define TAO_MAX 287 +#define TAO_MIN 288 +#define TAO_FIRST 289 +#define TAO_RANDOM 290 +const short yylhs[] = { -1, + 0, 0, 1, 1, 1, 1, 1, 2, 2, 3, + 3, 4, 4, 4, 4, 4, 4, 4, 5, 5, + 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, + 10, 10, 10, 10, 10, 10, 10, +}; +const short yylen[] = { 2, + 1, 1, 2, 2, 2, 1, 1, 3, 1, 3, + 1, 3, 3, 3, 3, 3, 3, 1, 3, 1, + 3, 1, 3, 3, 1, 3, 3, 1, 2, 1, + 3, 2, 1, 1, 2, 1, 1, +}; +const short yydefred[] = { 0, + 0, 0, 37, 0, 34, 0, 33, 36, 0, 0, + 0, 6, 7, 0, 2, 0, 0, 11, 0, 0, + 0, 0, 28, 30, 32, 29, 35, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 31, 0, 10, 14, 15, + 16, 17, 12, 13, 19, 0, 0, 0, 26, 27, +}; +const short yydgoto[] = { 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, +}; +const short yysindex[] = { -253, + -278, -219, 0, -271, 0, -224, 0, 0, -224, -224, + -224, 0, 0, 0, 0, -256, -252, 0, -195, -244, + -251, -243, 0, 0, 0, 0, 0, -262, -256, -256, + -256, -224, -224, -224, -224, -224, -224, -224, -224, -263, + -224, -224, -224, -224, -224, 0, -252, 0, 0, 0, + 0, 0, 0, 0, 0, -239, -243, -243, 0, 0, +}; +const short yyrindex[] = { 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 27, 8, 0, 11, 87, + 61, 1, 0, 0, 0, 0, 0, 0, 38, 40, + 43, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, + 0, 0, 0, 0, 0, 74, 21, 41, 0, 0, +}; +const short yygindex[] = { 0, + 0, -4, 14, 24, 34, 0, 36, 6, 31, 76, +}; +#define YYTABLESIZE 363 +const short yytable[] = { 25, + 25, 28, 32, 27, 29, 30, 31, 9, 32, 1, + 18, 33, 2, 46, 55, 3, 41, 4, 42, 43, + 23, 5, 40, 6, 7, 8, 1, 8, 44, 45, + 42, 43, 9, 10, 11, 12, 13, 5, 1, 4, + 24, 2, 3, 1, 3, 47, 4, 57, 58, 3, + 5, 4, 6, 7, 8, 5, 48, 6, 7, 8, + 22, 34, 35, 36, 37, 38, 39, 49, 50, 51, + 52, 53, 54, 21, 59, 60, 56, 26, 0, 0, + 0, 0, 0, 0, 0, 0, 20, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 25, 25, 25, + 25, 25, 25, 0, 25, 25, 0, 25, 25, 0, + 25, 25, 9, 0, 18, 18, 25, 23, 23, 23, + 23, 23, 23, 9, 23, 23, 18, 23, 23, 0, + 23, 23, 8, 0, 0, 0, 23, 24, 24, 24, + 24, 24, 24, 8, 24, 24, 0, 24, 24, 0, + 24, 24, 0, 0, 0, 0, 24, 22, 22, 22, + 22, 22, 22, 0, 22, 22, 0, 22, 0, 0, + 21, 21, 21, 21, 21, 21, 22, 21, 21, 0, + 21, 0, 0, 20, 20, 20, 20, 20, 20, 21, + 20, 20, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 20, +}; +const short yycheck[] = { 278, + 0, 6, 265, 275, 9, 10, 11, 0, 265, 263, + 0, 264, 266, 276, 278, 269, 268, 271, 270, 271, + 0, 275, 267, 277, 278, 279, 0, 0, 272, 273, + 270, 271, 286, 287, 288, 289, 290, 0, 263, 0, + 0, 266, 0, 263, 269, 32, 271, 42, 43, 269, + 275, 271, 277, 278, 279, 275, 33, 277, 278, 279, + 0, 257, 258, 259, 260, 261, 262, 34, 35, 36, + 37, 38, 39, 0, 44, 45, 41, 2, -1, -1, + -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 257, 258, 259, + 260, 261, 262, -1, 264, 265, -1, 267, 268, -1, + 270, 271, 265, -1, 264, 265, 276, 257, 258, 259, + 260, 261, 262, 276, 264, 265, 276, 267, 268, -1, + 270, 271, 265, -1, -1, -1, 276, 257, 258, 259, + 260, 261, 262, 276, 264, 265, -1, 267, 268, -1, + 270, 271, -1, -1, -1, -1, 276, 257, 258, 259, + 260, 261, 262, -1, 264, 265, -1, 267, -1, -1, + 257, 258, 259, 260, 261, 262, 276, 264, 265, -1, + 267, -1, -1, 257, 258, 259, 260, 261, 262, 276, + 264, 265, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 276, +}; +#define YYFINAL 14 #ifndef YYDEBUG -# define YYDEBUG 0 /* don't allow debugging */ +#define YYDEBUG 0 #endif - +#define YYMAXTOKEN 290 #if YYDEBUG - -yytoktype yytoks[] = -{ - "TAO_GT", 257, - "TAO_GE", 258, - "TAO_LT", 259, - "TAO_LE", 260, - "TAO_EQ", 261, - "TAO_NE", 262, - "TAO_EXIST", 263, - "TAO_AND", 264, - "TAO_OR", 265, - "TAO_NOT", 266, - "TAO_IN", 267, - "TAO_TWIDDLE", 268, - "TAO_BOOLEAN", 269, - "TAO_PLUS", 270, - "TAO_MINUS", 271, - "TAO_MULT", 272, - "TAO_DIV", 273, - "TAO_UMINUS", 274, - "TAO_NUMBER", 275, - "TAO_RPAREN", 276, - "TAO_LPAREN", 277, - "TAO_IDENT", 278, - "TAO_STRING", 279, - "TAO_UNKNOWN", 280, - "TAO_UNSIGNED", 281, - "TAO_SIGNED", 282, - "TAO_DOUBLE", 283, - "TAO_CONSTRAINT", 284, - "TAO_SEQUENCE", 285, - "TAO_WITH", 286, - "TAO_MAX", 287, - "TAO_MIN", 288, - "TAO_FIRST", 289, - "TAO_RANDOM", 290, - "-unknown-", -1 /* ends search */ +const char * const yyname[] = { +"end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"TAO_GT","TAO_GE","TAO_LT", +"TAO_LE","TAO_EQ","TAO_NE","TAO_EXIST","TAO_AND","TAO_OR","TAO_NOT","TAO_IN", +"TAO_TWIDDLE","TAO_BOOLEAN","TAO_PLUS","TAO_MINUS","TAO_MULT","TAO_DIV", +"TAO_UMINUS","TAO_NUMBER","TAO_RPAREN","TAO_LPAREN","TAO_IDENT","TAO_STRING", +"TAO_UNKNOWN","TAO_SIGNED","TAO_UNSIGNED","TAO_DOUBLE","TAO_CONSTRAINT", +"TAO_SEQUENCE","TAO_WITH","TAO_MAX","TAO_MIN","TAO_FIRST","TAO_RANDOM", }; - -char * yyreds[] = -{ - "-no such reduction-", - "constraint : bool_or", - "constraint : preference", - "preference : TAO_MIN bool_or", - "preference : TAO_MAX bool_or", - "preference : TAO_WITH bool_or", - "preference : TAO_FIRST", - "preference : TAO_RANDOM", - "bool_or : bool_or TAO_OR bool_and", - "bool_or : bool_and", - "bool_and : bool_and TAO_AND bool_compare", - "bool_and : bool_compare", - "bool_compare : expr_in TAO_EQ expr_in", - "bool_compare : expr_in TAO_NE expr_in", - "bool_compare : expr_in TAO_GT expr_in", - "bool_compare : expr_in TAO_GE expr_in", - "bool_compare : expr_in TAO_LT expr_in", - "bool_compare : expr_in TAO_LE expr_in", - "bool_compare : expr_in", - "expr_in : expr_twiddle TAO_IN TAO_IDENT", - "expr_in : expr_twiddle", - "expr_twiddle : expr TAO_TWIDDLE expr", - "expr_twiddle : expr", - "expr : expr TAO_PLUS term", - "expr : expr TAO_MINUS term", - "expr : term", - "term : term TAO_MULT factor_not", - "term : term TAO_DIV factor_not", - "term : factor_not", - "factor_not : TAO_NOT factor", - "factor_not : factor", - "factor : TAO_LPAREN bool_or TAO_RPAREN", - "factor : TAO_EXIST TAO_IDENT", - "factor : TAO_IDENT", - "factor : TAO_NUMBER", - "factor : TAO_MINUS TAO_NUMBER", - "factor : TAO_STRING", - "factor : TAO_BOOLEAN", +const char * const yyrule[] = { +"$accept : constraint", +"constraint : bool_or", +"constraint : preference", +"preference : TAO_MIN bool_or", +"preference : TAO_MAX bool_or", +"preference : TAO_WITH bool_or", +"preference : TAO_FIRST", +"preference : TAO_RANDOM", +"bool_or : bool_or TAO_OR bool_and", +"bool_or : bool_and", +"bool_and : bool_and TAO_AND bool_compare", +"bool_and : bool_compare", +"bool_compare : expr_in TAO_EQ expr_in", +"bool_compare : expr_in TAO_NE expr_in", +"bool_compare : expr_in TAO_GT expr_in", +"bool_compare : expr_in TAO_GE expr_in", +"bool_compare : expr_in TAO_LT expr_in", +"bool_compare : expr_in TAO_LE expr_in", +"bool_compare : expr_in", +"expr_in : expr_twiddle TAO_IN TAO_IDENT", +"expr_in : expr_twiddle", +"expr_twiddle : expr TAO_TWIDDLE expr", +"expr_twiddle : expr", +"expr : expr TAO_PLUS term", +"expr : expr TAO_MINUS term", +"expr : term", +"term : term TAO_MULT factor_not", +"term : term TAO_DIV factor_not", +"term : factor_not", +"factor_not : TAO_NOT factor", +"factor_not : factor", +"factor : TAO_LPAREN bool_or TAO_RPAREN", +"factor : TAO_EXIST TAO_IDENT", +"factor : TAO_IDENT", +"factor : TAO_NUMBER", +"factor : TAO_MINUS TAO_NUMBER", +"factor : TAO_STRING", +"factor : TAO_BOOLEAN", }; -#endif /* YYDEBUG */ - -/* - * Copyright (c) 1993 by Sun Microsystems, Inc. - */ - -//#pragma ident "@(#)yaccpar 6.12 93/06/07 SMI" - -/* -** Skeleton parser driver for yacc output -*/ - -/* -** yacc user known macros and defines -*/ -#define YYERROR goto yyerrlab -#define YYACCEPT return(0) -#define YYABORT return(1) -#define YYBACKUP( newtoken, newvalue )\ -{\ - if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\ - {\ - yyerror( "syntax error - cannot backup" );\ - goto yyerrlab;\ - }\ - yychar = newtoken;\ - yystate = *yyps;\ - yylval = newvalue;\ - goto yynewstate;\ -} -#define YYRECOVERING() (!!yyerrflag) -#define YYNEW(type) malloc(sizeof(type) * yynewmax) -#define YYCOPY(to, from, type) \ - (type *) ACE_OS::memcpy(to, (char *) from, yynewmax * sizeof(type)) -#define YYENLARGE( from, type) \ - (type *) realloc((char *) from, yynewmax * sizeof(type)) -#ifndef YYDEBUG -# define YYDEBUG 1 /* make debugging available */ #endif - -/* -** user known globals -*/ -int yydebug; /* set to 1 to get debugging */ - -/* -** driver internal defines -*/ -#define YYFLAG (-10000000) - -/* -** global variables used by the parser -*/ -YYSTYPE *yypv; /* top of value stack */ -int *yyps; /* top of state stack */ - -int yystate; /* current state */ -int yytmp; /* extra var (lasts between blocks) */ - -int yynerrs; /* number of errors */ -int yyerrflag; /* error recovery flag */ -int yychar; /* current input token number */ - - - -#ifdef YYNMBCHARS -#define YYLEX() yycvtok(yylex()) -/* -** yycvtok - return a token if i is a wchar_t value that exceeds 255. -** If i<255, i itself is the token. If i>255 but the neither -** of the 30th or 31st bit is on, i is already a token. -*/ -#if defined(__STDC__) || defined(__cplusplus) -int yycvtok(int i) +#if YYDEBUG +#include <stdio.h> +#endif +#ifdef YYSTACKSIZE +#undef YYMAXDEPTH +#define YYMAXDEPTH YYSTACKSIZE #else -int yycvtok(i) int i; +#ifdef YYMAXDEPTH +#define YYSTACKSIZE YYMAXDEPTH +#else +#define YYSTACKSIZE 10000 +#define YYMAXDEPTH 10000 #endif -{ - int first = 0; - int last = YYNMBCHARS - 1; - int mid; - wchar_t j; +#endif +#define YYINITSTACKSIZE 200 +int yydebug; +int yynerrs; +int yyerrflag; +int yychar; +short *yyssp; +YYSTYPE *yyvsp; +YYSTYPE yyval; +YYSTYPE yylval; +short *yyss; +short *yysslim; +YYSTYPE *yyvs; +int yystacksize; - if(i&0x60000000){/*Must convert to a token. */ - if( yymbchars[last].character < i ){ - return i;/*Giving up*/ - } - while ((last>=first)&&(first>=0)) {/*Binary search loop*/ - mid = (first+last)/2; - j = yymbchars[mid].character; - if( j==i ){/*Found*/ - return yymbchars[mid].tvalue; - }else if( j<i ){ - first = mid + 1; - }else{ - last = mid -1; - } - } - /*No entry in the table.*/ - return i;/* Giving up.*/ - }else{/* i is already a token. */ - return i; - } +TAO_END_VERSIONED_NAMESPACE_DECL +//extern int yydebug = 1; +/* allocate initial stack or double stack size, up to YYMAXDEPTH */ +static int yygrowstack() +{ + int newsize, i; + short *newss; + YYSTYPE *newvs; + + if ((newsize = yystacksize) == 0) + newsize = YYINITSTACKSIZE; + else if (newsize >= YYMAXDEPTH) + return -1; + else if ((newsize *= 2) > YYMAXDEPTH) + newsize = YYMAXDEPTH; + i = yyssp - yyss; + newss = yyss ? (short *)ACE_OS::realloc(yyss, newsize * sizeof *newss) : + (short *)ACE_OS::malloc(newsize * sizeof *newss); + if (newss == NULL) + return -1; + yyss = newss; + yyssp = newss + i; + newvs = yyvs ? (YYSTYPE *)ACE_OS::realloc(yyvs, newsize * sizeof *newvs) : + (YYSTYPE *)ACE_OS::malloc(newsize * sizeof *newvs); + if (newvs == NULL) + return -1; + yyvs = newvs; + yyvsp = newvs + i; + yystacksize = newsize; + yysslim = yyss + newsize - 1; + return 0; } -#else/*!YYNMBCHARS*/ -#define YYLEX() yylex() -#endif/*!YYNMBCHARS*/ -/* -** yyparse - return 0 if worked, 1 if syntax error not recovered from -*/ -#if defined(__STDC__) || defined(__cplusplus) -int yyparse(void) -#else -int yyparse() +#define YYABORT goto yyabort +#define YYREJECT goto yyabort +#define YYACCEPT goto yyaccept +#define YYERROR goto yyerrlab + +#ifndef YYPARSE_PARAM +#if defined(__cplusplus) || __STDC__ +#define YYPARSE_PARAM_ARG void +#define YYPARSE_PARAM_DECL +#else /* ! ANSI-C/C++ */ +#define YYPARSE_PARAM_ARG +#define YYPARSE_PARAM_DECL +#endif /* ANSI-C/C++ */ +#else /* YYPARSE_PARAM */ +#ifndef YYPARSE_PARAM_TYPE +#define YYPARSE_PARAM_TYPE void * #endif +#if defined(__cplusplus) || __STDC__ +#define YYPARSE_PARAM_ARG YYPARSE_PARAM_TYPE YYPARSE_PARAM +#define YYPARSE_PARAM_DECL +#else /* ! ANSI-C/C++ */ +#define YYPARSE_PARAM_ARG YYPARSE_PARAM +#define YYPARSE_PARAM_DECL YYPARSE_PARAM_TYPE YYPARSE_PARAM; +#endif /* ANSI-C/C++ */ +#endif /* ! YYPARSE_PARAM */ + +int +yyparse (YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL { - register YYSTYPE *yypvt = 0; /* top of value stack for $vars */ - -#if defined(__cplusplus) || defined(lint) -/* - hacks to please C++ and lint - goto's inside switch should never be - executed; yypvt is set to 0 to avoid "used before set" warning. -*/ - static int __yaccpar_lint_hack__ = 0; - switch (__yaccpar_lint_hack__) - { - case 1: goto yyerrlab; - case 2: goto yynewstate; - } - yypvt = 0; -#endif - - /* - ** Initialize externals - yyparse may be called more than once - */ - yypv = &yyv[-1]; - yyps = &yys[-1]; - yystate = 0; - yytmp = 0; - yynerrs = 0; - yyerrflag = 0; - yychar = -1; - -#if YYMAXDEPTH <= 0 - if (yymaxdepth <= 0) - { - if ((yymaxdepth = YYEXPAND(0)) <= 0) - { - yyerror("yacc initialization error"); - YYABORT; - } - } + register int yym, yyn, yystate; +#if YYDEBUG + register const char *yys; + + if ((yys = ACE_OS::getenv("YYDEBUG"))) + { + yyn = *yys; + if (yyn >= '0' && yyn <= '9') + yydebug = yyn - '0'; + } #endif - { - register YYSTYPE *yy_pv; /* top of value stack */ - register int *yy_ps; /* top of state stack */ - register int yy_state; /* current state */ - register int yy_n; /* internal state number info */ - goto yystack; /* moved from 6 lines above to here to please C++ */ - - /* - ** get globals into registers. - ** branch to here only if YYBACKUP was called. - */ - yynewstate: - yy_pv = yypv; - yy_ps = yyps; - yy_state = yystate; - goto yy_newstate; + yynerrs = 0; + yyerrflag = 0; + yychar = (-1); - /* - ** get globals into registers. - ** either we just started, or we just finished a reduction - */ - yystack: - yy_pv = yypv; - yy_ps = yyps; - yy_state = yystate; + if (yyss == NULL && yygrowstack()) goto yyoverflow; + yyssp = yyss; + yyvsp = yyvs; + *yyssp = yystate = 0; - /* - ** top of for (;;) loop while no reductions done - */ - yy_stack: - /* - ** put a state and value onto the stacks - */ +yyloop: + if ((yyn = yydefred[yystate])) goto yyreduce; + if (yychar < 0) + { + if ((yychar = yylex()) < 0) yychar = 0; #if YYDEBUG - /* - ** if debugging, look up token value in list of value vs. - ** name pairs. 0 and negative (-1) are special values. - ** Note: linear search is used since time is not a real - ** consideration while debugging. - */ - if ( yydebug ) - { - register int yy_i; - - printf( "State %d, token ", yy_state ); - if ( yychar == 0 ) - printf( "end-of-file\n" ); - else if ( yychar < 0 ) - printf( "-none-\n" ); - else - { - for ( yy_i = 0; yytoks[yy_i].t_val >= 0; - yy_i++ ) - { - if ( yytoks[yy_i].t_val == yychar ) - break; - } - printf( "%s\n", yytoks[yy_i].t_name ); - } - } -#endif /* YYDEBUG */ - if ( ++yy_ps >= &yys[ yymaxdepth ] ) /* room on stack? */ - { - /* - ** reallocate and recover. Note that pointers - ** have to be reset, or bad things will happen - */ - int yyps_index = (yy_ps - yys); - int yypv_index = (yy_pv - yyv); - int yypvt_index = (yypvt - yyv); - int yynewmax; -#ifdef YYEXPAND - yynewmax = YYEXPAND(yymaxdepth); -#else - yynewmax = 2 * yymaxdepth; /* double table size */ - if (yymaxdepth == YYMAXDEPTH) /* first time growth */ - { - char *newyys = (char *)YYNEW(int); - char *newyyv = (char *)YYNEW(YYSTYPE); - if (newyys != 0 && newyyv != 0) - { - yys = YYCOPY(newyys, yys, int); - yyv = YYCOPY(newyyv, yyv, YYSTYPE); - } - else - yynewmax = 0; /* failed */ - } - else /* not first time */ - { - yys = YYENLARGE(yys, int); - yyv = YYENLARGE(yyv, YYSTYPE); - if (yys == 0 || yyv == 0) - yynewmax = 0; /* failed */ - } + if (yydebug) + { + yys = 0; + if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; + if (!yys) yys = "illegal-symbol"; + printf("%sdebug: state %d, reading %d (%s)\n", + YYPREFIX, yystate, yychar, yys); + } #endif - if (yynewmax <= yymaxdepth) /* tables not expanded */ - { - yyerror( "yacc stack overflow" ); - YYABORT; - } - yymaxdepth = yynewmax; - - yy_ps = yys + yyps_index; - yy_pv = yyv + yypv_index; - yypvt = yyv + yypvt_index; - } - *yy_ps = yy_state; - *++yy_pv = yyval; - - /* - ** we have a new state - find out what to do - */ - yy_newstate: - if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG ) - goto yydefault; /* simple state */ + } + if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 && + yyn <= YYTABLESIZE && yycheck[yyn] == yychar) + { #if YYDEBUG - /* - ** if debugging, need to mark whether new token grabbed - */ - yytmp = yychar < 0; + if (yydebug) + printf("%sdebug: state %d, shifting to state %d\n", + YYPREFIX, yystate, yytable[yyn]); #endif - if ( ( yychar < 0 ) && ( ( yychar = YYLEX() ) < 0 ) ) - yychar = 0; /* reached EOF */ -#if YYDEBUG - if ( yydebug && yytmp ) - { - register int yy_i; - - printf( "Received token " ); - if ( yychar == 0 ) - printf( "end-of-file\n" ); - else if ( yychar < 0 ) - printf( "-none-\n" ); - else - { - for ( yy_i = 0; yytoks[yy_i].t_val >= 0; - yy_i++ ) - { - if ( yytoks[yy_i].t_val == yychar ) - break; - } - printf( "%s\n", yytoks[yy_i].t_name ); - } - } -#endif /* YYDEBUG */ - if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) ) - goto yydefault; - if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar ) /*valid shift*/ - { - yychar = -1; - yyval = yylval; - yy_state = yy_n; - if ( yyerrflag > 0 ) - yyerrflag--; - goto yy_stack; - } - - yydefault: - if ( ( yy_n = yydef[ yy_state ] ) == -2 ) - { -#if YYDEBUG - yytmp = yychar < 0; + if (yyssp >= yysslim && yygrowstack()) + { + goto yyoverflow; + } + *++yyssp = yystate = yytable[yyn]; + *++yyvsp = yylval; + yychar = (-1); + if (yyerrflag > 0) --yyerrflag; + goto yyloop; + } + if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 && + yyn <= YYTABLESIZE && yycheck[yyn] == yychar) + { + yyn = yytable[yyn]; + goto yyreduce; + } + if (yyerrflag) goto yyinrecovery; +#if defined(lint) || defined(__GNUC__) || defined (WIN32) || defined (__HP_aCC) + goto yynewerror; #endif - if ( ( yychar < 0 ) && ( ( yychar = YYLEX() ) < 0 ) ) - yychar = 0; /* reached EOF */ +yynewerror: + yyerror("syntax error"); +#if defined(lint) || defined(__GNUC__) || defined (WIN32) || defined (__HP_aCC) + goto yyerrlab; +#endif +yyerrlab: + ++yynerrs; +yyinrecovery: + if (yyerrflag < 3) + { + yyerrflag = 3; + for (;;) + { + if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 && + yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE) + { #if YYDEBUG - if ( yydebug && yytmp ) - { - register int yy_i; - - printf( "Received token " ); - if ( yychar == 0 ) - printf( "end-of-file\n" ); - else if ( yychar < 0 ) - printf( "-none-\n" ); - else - { - for ( yy_i = 0; - yytoks[yy_i].t_val >= 0; - yy_i++ ) - { - if ( yytoks[yy_i].t_val - == yychar ) - { - break; - } - } - printf( "%s\n", yytoks[yy_i].t_name ); - } - } -#endif /* YYDEBUG */ - /* - ** look through exception table - */ - { - register int *yyxi = yyexca; - - while ( ( *yyxi != -1 ) || - ( yyxi[1] != yy_state ) ) - { - yyxi += 2; - } - while ( ( *(yyxi += 2) >= 0 ) && - ( *yyxi != yychar ) ) - ; - if ( ( yy_n = yyxi[1] ) < 0 ) - YYACCEPT; - } - } - - /* - ** check for syntax error - */ - if ( yy_n == 0 ) /* have an error */ - { - /* no worry about speed here! */ - switch ( yyerrflag ) - { - case 0: /* new error */ - yyerror( "syntax error" ); - goto skip_init; - yyerrlab: - /* - ** get globals into registers. - ** we have a user generated syntax type error - */ - yy_pv = yypv; - yy_ps = yyps; - yy_state = yystate; - skip_init: - yynerrs++; - /* FALLTHRU */ - case 1: - case 2: /* incompletely recovered error */ - /* try again... */ - yyerrflag = 3; - /* - ** find state where "error" is a legal - ** shift action - */ - while ( yy_ps >= yys ) - { - yy_n = yypact[ *yy_ps ] + YYERRCODE; - if ( yy_n >= 0 && yy_n < YYLAST && - yychk[yyact[yy_n]] == YYERRCODE) { - /* - ** simulate shift of "error" - */ - yy_state = yyact[ yy_n ]; - goto yy_stack; - } - /* - ** current state has no shift on - ** "error", pop stack - */ + if (yydebug) + printf("%sdebug: state %d, error recovery shifting\ + to state %d\n", YYPREFIX, *yyssp, yytable[yyn]); +#endif + if (yyssp >= yysslim && yygrowstack()) + { + goto yyoverflow; + } + *++yyssp = yystate = yytable[yyn]; + *++yyvsp = yylval; + goto yyloop; + } + else + { #if YYDEBUG -# define _POP_ "Error recovery pops state %d, uncovers state %d\n" - if ( yydebug ) - printf( _POP_, *yy_ps, - yy_ps[-1] ); -# undef _POP_ + if (yydebug) + printf("%sdebug: error recovery discarding state %d\n", + YYPREFIX, *yyssp); #endif - yy_ps--; - yy_pv--; - } - /* - ** there is no state on stack with "error" as - ** a valid shift. give up. - */ - YYABORT; - case 3: /* no shift yet; eat a token */ + if (yyssp <= yyss) goto yyabort; + --yyssp; + --yyvsp; + } + } + } + else + { + if (yychar == 0) goto yyabort; #if YYDEBUG - /* - ** if debugging, look up token in list of - ** pairs. 0 and negative shouldn't occur, - ** but since timing doesn't matter when - ** debugging, it doesn't hurt to leave the - ** tests here. - */ - if ( yydebug ) - { - register int yy_i; - - printf( "Error recovery discards " ); - if ( yychar == 0 ) - printf( "token end-of-file\n" ); - else if ( yychar < 0 ) - printf( "token -none-\n" ); - else - { - for ( yy_i = 0; - yytoks[yy_i].t_val >= 0; - yy_i++ ) - { - if ( yytoks[yy_i].t_val - == yychar ) - { - break; - } - } - printf( "token %s\n", - yytoks[yy_i].t_name ); - } - } -#endif /* YYDEBUG */ - if ( yychar == 0 ) /* reached EOF. quit */ - YYABORT; - yychar = -1; - goto yy_newstate; - } - }/* end if ( yy_n == 0 ) */ - /* - ** reduction by production yy_n - ** put stack tops, etc. so things right after switch - */ + if (yydebug) + { + yys = 0; + if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; + if (!yys) yys = "illegal-symbol"; + printf("%sdebug: state %d, error recovery discards token %d (%s)\n", + YYPREFIX, yystate, yychar, yys); + } +#endif + yychar = (-1); + goto yyloop; + } +yyreduce: #if YYDEBUG - /* - ** if debugging, print the string that is the user's - ** specification of the reduction which is just about - ** to be done. - */ - if ( yydebug ) - printf( "Reduce by (%d) \"%s\"\n", - yy_n, yyreds[ yy_n ] ); + if (yydebug) + printf("%sdebug: state %d, reducing by rule %d (%s)\n", + YYPREFIX, yystate, yyn, yyrule[yyn]); #endif - yytmp = yy_n; /* value to switch over */ - yypvt = yy_pv; /* $vars top of value stack */ - /* - ** Look in goto table for next state - ** Sorry about using yy_state here as temporary - ** register variable, but why not, if it works... - ** If yyr2[ yy_n ] doesn't have the low order bit - ** set, then there is no action to be done for - ** this reduction. So, no saving & unsaving of - ** registers done. The only difference between the - ** code just after the if and the body of the if is - ** the goto yy_stack in the body. This way the test - ** can be made before the choice of what to do is needed. - */ - { - /* length of production doubled with extra bit */ - register int yy_len = yyr2[ yy_n ]; - - if ( !( yy_len & 01 ) ) - { - yy_len >>= 1; - yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */ - yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] + - *( yy_ps -= yy_len ) + 1; - if ( yy_state >= YYLAST || - yychk[ yy_state = - yyact[ yy_state ] ] != -yy_n ) - { - yy_state = yyact[ yypgo[ yy_n ] ]; - } - goto yy_stack; - } - yy_len >>= 1; - yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */ - yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] + - *( yy_ps -= yy_len ) + 1; - if ( yy_state >= YYLAST || - yychk[ yy_state = yyact[ yy_state ] ] != -yy_n ) - { - yy_state = yyact[ yypgo[ yy_n ] ]; - } - } - /* save until reenter driver code */ - yystate = yy_state; - yyps = yy_ps; - yypv = yy_pv; - } - /* - ** code supplied by user is placed in this switch - */ - switch( yytmp ) - { - + yym = yylen[yyn]; + yyval = yyvsp[1-yym]; + switch (yyn) + { case 1: - -{ yyval.constraint_ = new TAO_Unary_Constraint(TAO_CONSTRAINT, yypvt[-0].constraint_); } break; +{ yyval.constraint_ = new TAO_Unary_Constraint(TAO_CONSTRAINT, yyvsp[0].constraint_); } +break; case 2: - -{ yyval.constraint_ = yypvt[-0].constraint_; } break; +{ yyval.constraint_ = yyvsp[0].constraint_; } +break; case 3: - -{ yyval.constraint_ = new TAO_Unary_Constraint(TAO_MIN, yypvt[-0].constraint_); } break; +{ yyval.constraint_ = new TAO_Unary_Constraint(TAO_MIN, yyvsp[0].constraint_); } +break; case 4: - -{ yyval.constraint_ = new TAO_Unary_Constraint(TAO_MAX, yypvt[-0].constraint_); } break; +{ yyval.constraint_ = new TAO_Unary_Constraint(TAO_MAX, yyvsp[0].constraint_); } +break; case 5: - -{ yyval.constraint_ = new TAO_Unary_Constraint(TAO_WITH, yypvt[-0].constraint_); } break; +{ yyval.constraint_ = new TAO_Unary_Constraint(TAO_WITH, yyvsp[0].constraint_); } +break; case 6: - -{ yyval.constraint_ = new TAO_Noop_Constraint(TAO_FIRST); } break; +{ yyval.constraint_ = new TAO_Noop_Constraint(TAO_FIRST); } +break; case 7: - -{ yyval.constraint_ = new TAO_Noop_Constraint(TAO_RANDOM); } break; +{ yyval.constraint_ = new TAO_Noop_Constraint(TAO_RANDOM); } +break; case 8: - -{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_OR, yypvt[-2].constraint_, yypvt[-0].constraint_); } break; +{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_OR, yyvsp[-2].constraint_, yyvsp[0].constraint_); } +break; case 9: - -{ yyval.constraint_ = yypvt[-0].constraint_; } break; +{ yyval.constraint_ = yyvsp[0].constraint_; } +break; case 10: - -{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_AND, yypvt[-2].constraint_, yypvt[-0].constraint_); } break; +{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_AND, yyvsp[-2].constraint_, yyvsp[0].constraint_); } +break; case 11: - -{ yyval.constraint_ = yypvt[-0].constraint_; } break; +{ yyval.constraint_ = yyvsp[0].constraint_; } +break; case 12: - -{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_EQ, yypvt[-2].constraint_, yypvt[-0].constraint_); } break; +{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_EQ, yyvsp[-2].constraint_, yyvsp[0].constraint_); } +break; case 13: - -{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_NE, yypvt[-2].constraint_, yypvt[-0].constraint_); } break; +{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_NE, yyvsp[-2].constraint_, yyvsp[0].constraint_); } +break; case 14: - -{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_GT, yypvt[-2].constraint_, yypvt[-0].constraint_); } break; +{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_GT, yyvsp[-2].constraint_, yyvsp[0].constraint_); } +break; case 15: - -{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_GE, yypvt[-2].constraint_, yypvt[-0].constraint_); } break; +{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_GE, yyvsp[-2].constraint_, yyvsp[0].constraint_); } +break; case 16: - -{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_LT, yypvt[-2].constraint_, yypvt[-0].constraint_); } break; +{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_LT, yyvsp[-2].constraint_, yyvsp[0].constraint_); } +break; case 17: - -{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_LE, yypvt[-2].constraint_, yypvt[-0].constraint_); } break; +{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_LE, yyvsp[-2].constraint_, yyvsp[0].constraint_); } +break; case 18: - -{ yyval.constraint_ = yypvt[-0].constraint_; } break; +{ yyval.constraint_ = yyvsp[0].constraint_; } +break; case 19: - -{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_IN, yypvt[-2].constraint_, yypvt[-0].constraint_); } break; +{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_IN, yyvsp[-2].constraint_, yyvsp[0].constraint_); } +break; case 20: - -{ yyval.constraint_ = yypvt[-0].constraint_; } break; +{ yyval.constraint_ = yyvsp[0].constraint_; } +break; case 21: - -{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_TWIDDLE, yypvt[-2].constraint_, yypvt[-0].constraint_); } break; +{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_TWIDDLE, yyvsp[-2].constraint_, yyvsp[0].constraint_); } +break; case 22: - -{ yyval.constraint_ = yypvt[-0].constraint_; } break; +{ yyval.constraint_ = yyvsp[0].constraint_; } +break; case 23: - -{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_PLUS, yypvt[-2].constraint_, yypvt[-0].constraint_); } break; +{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_PLUS, yyvsp[-2].constraint_, yyvsp[0].constraint_); } +break; case 24: - -{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_MINUS, yypvt[-2].constraint_, yypvt[-0].constraint_); } break; +{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_MINUS, yyvsp[-2].constraint_, yyvsp[0].constraint_); } +break; case 25: - -{ yyval.constraint_ = yypvt[-0].constraint_; } break; +{ yyval.constraint_ = yyvsp[0].constraint_; } +break; case 26: - -{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_MULT, yypvt[-2].constraint_, yypvt[-0].constraint_); } break; +{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_MULT, yyvsp[-2].constraint_, yyvsp[0].constraint_); } +break; case 27: - -{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_DIV, yypvt[-2].constraint_, yypvt[-0].constraint_); } break; +{ yyval.constraint_ = new TAO_Binary_Constraint(TAO_DIV, yyvsp[-2].constraint_, yyvsp[0].constraint_); } +break; case 28: - -{ yyval.constraint_ = yypvt[-0].constraint_; } break; +{ yyval.constraint_ = yyvsp[0].constraint_; } +break; case 29: - -{ yyval.constraint_ = new TAO_Unary_Constraint(TAO_NOT, yypvt[-0].constraint_); } break; +{ yyval.constraint_ = new TAO_Unary_Constraint(TAO_NOT, yyvsp[0].constraint_); } +break; case 30: - -{ yyval.constraint_ = yypvt[-0].constraint_; } break; +{ yyval.constraint_ = yyvsp[0].constraint_; } +break; case 31: - -{ yyval.constraint_ = yypvt[-1].constraint_; } break; +{ yyval.constraint_ = yyvsp[-1].constraint_; } +break; case 32: - -{ yyval.constraint_ = new TAO_Unary_Constraint(TAO_EXIST, yypvt[-0].constraint_); } break; +{ yyval.constraint_ = new TAO_Unary_Constraint(TAO_EXIST, yyvsp[0].constraint_); } +break; case 33: - -{ yyval.constraint_ = yypvt[-0].constraint_; } break; +{ yyval.constraint_ = yyvsp[0].constraint_; } +break; case 34: - -{ yyval.constraint_ = yypvt[-0].constraint_; } break; +{ yyval.constraint_ = yyvsp[0].constraint_; } +break; case 35: - -{ yyval.constraint_ = new TAO_Unary_Constraint(TAO_UMINUS, yypvt[-0].constraint_); } break; +{ yyval.constraint_ = new TAO_Unary_Constraint(TAO_UMINUS, yyvsp[0].constraint_); } +break; case 36: - -{ yyval.constraint_ = yypvt[-0].constraint_; } break; +{ yyval.constraint_ = yyvsp[0].constraint_; } +break; case 37: - -{ yyval.constraint_ = yypvt[-0].constraint_; } break; - - } - goto yystack; /* reset registers in driver code */ +{ yyval.constraint_ = yyvsp[0].constraint_; } +break; + } + yyssp -= yym; + yystate = *yyssp; + yyvsp -= yym; + yym = yylhs[yyn]; + if (yystate == 0 && yym == 0) + { +#if YYDEBUG + if (yydebug) + printf("%sdebug: after reduction, shifting from state 0 to\ + state %d\n", YYPREFIX, YYFINAL); +#endif + yystate = YYFINAL; + *++yyssp = YYFINAL; + *++yyvsp = yyval; + if (yychar < 0) + { + if ((yychar = yylex()) < 0) yychar = 0; +#if YYDEBUG + if (yydebug) + { + yys = 0; + if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; + if (!yys) yys = "illegal-symbol"; + printf("%sdebug: state %d, reading %d (%s)\n", + YYPREFIX, YYFINAL, yychar, yys); + } +#endif + } + if (yychar == 0) goto yyaccept; + goto yyloop; + } + if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 && + yyn <= YYTABLESIZE && yycheck[yyn] == yystate) + yystate = yytable[yyn]; + else + yystate = yydgoto[yym]; +#if YYDEBUG + if (yydebug) + printf("%sdebug: after reduction, shifting from state %d \ +to state %d\n", YYPREFIX, *yyssp, yystate); +#endif + if (yyssp >= yysslim && yygrowstack()) + { + goto yyoverflow; + } + *++yyssp = yystate; + *++yyvsp = yyval; + goto yyloop; +yyoverflow: + yyerror("yacc stack overflow"); +yyabort: + return (1); +yyaccept: + return (0); } - -TAO_END_VERSIONED_NAMESPACE_DECL diff --git a/TAO/orbsvcs/orbsvcs/Trader/Interpreter.h b/TAO/orbsvcs/orbsvcs/Trader/Interpreter.h index 7971ed9e024..286f80456ea 100644 --- a/TAO/orbsvcs/orbsvcs/Trader/Interpreter.h +++ b/TAO/orbsvcs/orbsvcs/Trader/Interpreter.h @@ -93,6 +93,7 @@ private: }; // The union used by lex and yacc to build the Abstract Syntax Tree. +#define YYSTYPE_IS_DECLARED typedef union { TAO_Constraint* constraint_; diff --git a/TAO/orbsvcs/orbsvcs/Trader/constraint.l b/TAO/orbsvcs/orbsvcs/Trader/constraint.l index 9d1aef05376..e61d936732b 100644 --- a/TAO/orbsvcs/orbsvcs/Trader/constraint.l +++ b/TAO/orbsvcs/orbsvcs/Trader/constraint.l @@ -1,4 +1,6 @@ %{ +TAO_END_VERSIONED_NAMESPACE_DECL + // $Id$ // ======================================================================== // @@ -13,14 +15,15 @@ // // ======================================================================== -#include "ace/OS.h" -#include "Constraint_Interpreter.h" -#include "Constraint_Nodes.h" -#include "Constraint_Tokens.h" +#include "orbsvcs/Trader/Constraint_Interpreter.h" +#include "orbsvcs/Trader/Constraint_Nodes.h" +#include "orbsvcs/Trader/Constraint_Tokens.h" TAO_BEGIN_VERSIONED_NAMESPACE_DECL static TAO_Literal_Constraint* extract_string(const char*); +static CORBA::LongLong trader_strtoll(const char* str, unsigned int base); +static CORBA::ULongLong trader_strtoull(const char* str, unsigned int base); #define TAO_YY_LEX_DEBUG @@ -36,7 +39,7 @@ letter [a-zA-Z] digit [0-9] alpha_num ({letter}|{digit}) integer [-+]?{digit}+ -float ({digit}*\.{digit}+)([eE][-+]?{digit}+)? +float [-+]?({digit}*\.{digit}+)([eE][-+]?{digit}+)? string '(([^'\\]*)|([^'\\]*\\')|([^'\\]*\\\\))*' ident {letter}({alpha_num}|[_])* newline \n @@ -78,14 +81,23 @@ FALSE { TAO_YY_LEX_DEBUG; return TAO_BOOLEAN; } {integer} { - yylval.constraint_ = - new TAO_Literal_Constraint((yytext[0] == '-' ? - (CORBA::Long)atoi(yytext) : (CORBA::ULong)atoi(yytext))); + if (yytext[0] == '-') + { + yylval.constraint_ = + new TAO_Literal_Constraint( + trader_strtoll(yytext, 0)); + } + else + { + yylval.constraint_ = + new TAO_Literal_Constraint( + trader_strtoull(yytext, 0)); + } TAO_YY_LEX_DEBUG; return TAO_NUMBER; } {float} { yylval.constraint_ = - new TAO_Literal_Constraint((CORBA::Double)atof(yytext)); + new TAO_Literal_Constraint(ACE_OS::strtod(yytext, 0)); TAO_YY_LEX_DEBUG; return TAO_NUMBER; } {string} { @@ -133,4 +145,108 @@ extract_string(const char* total) return new TAO_Literal_Constraint(str); } +CORBA::ULongLong +trader_strtoull(const char* s, unsigned int base) +{ + CORBA::ULongLong result = 0; + CORBA::ULongLong previous = 0; + + // Check for a valid base + if (!(base == 0 || base == 8 || base == 10 || base == 16)) + { + errno = EINVAL; + return result; + } + + if (*s == '+') + { + s++; + } + + if ((base == 0 || base == 16) && + *s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X')) + { + s += 2; + base = 16; + } + else if ((base == 0 || base == 8) && *s == '0') + { + s++; + base = 8; + } + else + { + base = 10; + } + + for (; *s; ++s) + { + if (base == 8 && *s <= '7' && *s >= '0') + { + result = (result * base) + (*s - '0'); + } + else if (base > 8 && *s <= '9' && *s >= '0') + { + result = (result * base) + (*s - '0'); + } + else if (base > 10 && *s <= 'f' && *s >= 'a') + { + result = (result * base) + (*s - 'a' + 10); + } + else if (base > 10 && *s <= 'F' && *s >= 'A') + { + result = (result * base) + (*s - 'A' + 10); + } + else + { + break; + } + + // If the previous value is greater than result, then we have + // exceeded the size of a CORBA::ULongLong and the result + // will be ACE_UINT64_MAX. However, errno will be set to ERANGE + if (previous > result) + { + errno = ERANGE; + result = ACE_UINT64_MAX; + break; + } + previous = result; + } + + return result; +} + +CORBA::LongLong +trader_strtoll(const char* s, unsigned int base) +{ + // Check for the negative sign + bool negative = false; + if (*s == '-') + { + negative = true; + s++; + } + + // Convert the raw text into a CORBA::LongLong + CORBA::LongLong result = static_cast<CORBA::LongLong> ( + trader_strtoull(s, base)); + + // If the result that comes back is negative, then the value exceeded + // the maximum for CORBA::LongLong + if (result < 0) + { + errno = ERANGE; + return (negative ? ACE_INT64_MIN : ACE_INT64_MAX); + } + + return (negative ? -result : result); +} + +int +yywrap (void) +{ + return 1; +} + TAO_END_VERSIONED_NAMESPACE_DECL diff --git a/TAO/orbsvcs/orbsvcs/Trader/constraint.y b/TAO/orbsvcs/orbsvcs/Trader/constraint.y index 7d32796775a..d5bddc1d180 100644 --- a/TAO/orbsvcs/orbsvcs/Trader/constraint.y +++ b/TAO/orbsvcs/orbsvcs/Trader/constraint.y @@ -13,9 +13,10 @@ // // ======================================================================== -#include "ace/OS.h" -#include "Constraint_Interpreter.h" -#include "Constraint_Nodes.h" +#include "ace/OS_NS_string.h" +#include "ace/OS_NS_stdlib.h" +#include "orbsvcs/Trader/Constraint_Interpreter.h" +#include "orbsvcs/Trader/Constraint_Nodes.h" TAO_BEGIN_VERSIONED_NAMESPACE_DECL @@ -26,7 +27,7 @@ TAO_BEGIN_VERSIONED_NAMESPACE_DECL %token TAO_AND TAO_OR TAO_NOT TAO_IN TAO_TWIDDLE TAO_BOOLEAN %token TAO_PLUS TAO_MINUS TAO_MULT TAO_DIV TAO_UMINUS TAO_NUMBER %token TAO_RPAREN TAO_LPAREN TAO_IDENT TAO_STRING TAO_UNKNOWN -%token TAO_UNSIGNED TAO_SIGNED TAO_DOUBLE TAO_CONSTRAINT TAO_SEQUENCE +%token TAO_SIGNED TAO_UNSIGNED TAO_DOUBLE TAO_CONSTRAINT TAO_SEQUENCE %token TAO_WITH TAO_MAX TAO_MIN TAO_FIRST TAO_RANDOM %start constraint diff --git a/TAO/orbsvcs/tests/Trading/TT_Info.cpp b/TAO/orbsvcs/tests/Trading/TT_Info.cpp index e13b3b0766b..8c353be3664 100644 --- a/TAO/orbsvcs/tests/Trading/TT_Info.cpp +++ b/TAO/orbsvcs/tests/Trading/TT_Info.cpp @@ -127,14 +127,16 @@ const char* TT_Info::MODEL_NUMBERS[] = "9q834jidlj234ujof" }; -const int TT_Info::NUM_QUERIES = 7; +const int TT_Info::NUM_QUERIES = 9; const char* TT_Info::QUERIES[][3] = { {INTERFACE_NAMES[REMOTE_IO], "", ""}, {INTERFACE_NAMES[REMOTE_IO], "'Cupples' ~ Location", ""}, {INTERFACE_NAMES[PLOTTER], "'sbw1' in User_Queue", "min Cost_Per_Page"}, {INTERFACE_NAMES[PLOTTER], "Num_Colors > 1 and 'Cupples' ~ Location", "min Cost_Per_Page"}, - {INTERFACE_NAMES[PRINTER], "Pages_Per_Sec > 3 and Color == TRUE", "with 'sbw1' in User_Queue"}, + {INTERFACE_NAMES[PRINTER], "Pages_Per_Sec < -101215752192 and Color == TRUE", "with 'sbw1' in User_Queue"}, + {INTERFACE_NAMES[PRINTER], "Pages_Per_Sec > 3.0 and Color == TRUE", "with 'sbw1' in User_Queue"}, + {INTERFACE_NAMES[PRINTER], "Pages_Per_Sec > -3.0 and Color == TRUE", "with 'sbw1' in User_Queue"}, {INTERFACE_NAMES[PRINTER], "Color == TRUE or Double_Sided == TRUE", "random"}, {INTERFACE_NAMES[PRINTER], "(Color or Double_Sided) and 'sbw1' in User_Queue", "with 'Cupples' ~ Location"} }; diff --git a/TAO/orbsvcs/tests/unit/Trading/Interpreter/Interpreter.cpp b/TAO/orbsvcs/tests/unit/Trading/Interpreter/Interpreter.cpp new file mode 100644 index 00000000000..edc28721c2c --- /dev/null +++ b/TAO/orbsvcs/tests/unit/Trading/Interpreter/Interpreter.cpp @@ -0,0 +1,224 @@ +// $Id$ + +#include "orbsvcs/Trader/Interpreter.h" +#include "orbsvcs/Trader/Constraint_Visitors.h" +#include "ace/OS_NS_string.h" + +template<class T> class Literal_Interpreter; + +template<class T> +class Literal_Visitor: public TAO_Constraint_Visitor +{ +public: + Literal_Visitor (Literal_Interpreter<T>* interp); + virtual ~Literal_Visitor (void); + + virtual int visit_constraint (TAO_Unary_Constraint*); + + virtual int visit_with (TAO_Unary_Constraint*) { return 1; } + virtual int visit_min (TAO_Unary_Constraint*) { return 1; } + virtual int visit_max (TAO_Unary_Constraint*) { return 1; } + virtual int visit_first (TAO_Noop_Constraint*) { return 1; } + virtual int visit_random (TAO_Noop_Constraint*) { return 1; } + + virtual int visit_and (TAO_Binary_Constraint*) { return 1; } + virtual int visit_or (TAO_Binary_Constraint*) { return 1; } + virtual int visit_not (TAO_Unary_Constraint*) { return 1; } + + virtual int visit_exist (TAO_Unary_Constraint*) { return 1; } + virtual int visit_unary_minus (TAO_Unary_Constraint*) { return 1; } + + virtual int visit_add (TAO_Binary_Constraint*) { return 1; } + virtual int visit_sub (TAO_Binary_Constraint*) { return 1; } + virtual int visit_mult (TAO_Binary_Constraint*) { return 1; } + virtual int visit_div (TAO_Binary_Constraint*) { return 1; } + + virtual int visit_twiddle (TAO_Binary_Constraint*) { return 1; } + virtual int visit_in (TAO_Binary_Constraint*) { return 1; } + + virtual int visit_less_than (TAO_Binary_Constraint*) { return 1; } + virtual int visit_less_than_equal (TAO_Binary_Constraint*) { return 1; } + virtual int visit_greater_than (TAO_Binary_Constraint*) { return 1; } + virtual int visit_greater_than_equal (TAO_Binary_Constraint*) { return 1; } + virtual int visit_equal (TAO_Binary_Constraint*) { return 1; } + virtual int visit_not_equal (TAO_Binary_Constraint*) { return 1; } + + virtual int visit_literal (TAO_Literal_Constraint*); + virtual int visit_property (TAO_Property_Constraint*) { return 1; } + +private: + Literal_Interpreter<T>* interp_; +}; + +template<class T> +Literal_Visitor<T>::Literal_Visitor (Literal_Interpreter<T>* interp) + : interp_ (interp) +{ +} + +template<class T> +Literal_Visitor<T>::~Literal_Visitor (void) +{ +} + +template<class T> int +Literal_Visitor<T>::visit_constraint (TAO_Unary_Constraint* c) +{ + return c->operand ()->accept (this); +} + +template<class T> int +Literal_Visitor<T>::visit_literal (TAO_Literal_Constraint* literal) +{ + this->interp_->constraint(*literal); + return 1; +} + +template<class T> +class Literal_Interpreter: public TAO_Interpreter +{ +public: + Literal_Interpreter (void); + virtual ~Literal_Interpreter (void); + + bool test (const char* str, + T expected); + void constraint (TAO_Literal_Constraint& constraint); + const TAO_Literal_Constraint& constraint (void) const; + +private: + bool compare (T expected) const; + + TAO_Literal_Constraint constraint_; +}; + +template<class T> +Literal_Interpreter<T>::Literal_Interpreter (void) +{ +} + +template<class T> +Literal_Interpreter<T>::~Literal_Interpreter (void) +{ +} + +template<class T> bool +Literal_Interpreter<T>::test (const char* str, + T expected) +{ + this->build_tree (str); + if (this->root_ == 0) + { + ACE_ERROR ((LM_ERROR, "ERROR: Invalid interpreter string.\n")); + return false; + } + + Literal_Visitor<T> visitor (this); + this->root_->accept (&visitor); + + return this->compare(expected); +} + +template<> bool +Literal_Interpreter<const char*>::compare (const char* expected) const +{ + return (ACE_OS::strcmp(static_cast<const char*> (this->constraint_), + expected) == 0); +} + +template<class T> bool +Literal_Interpreter<T>::compare (T expected) const +{ + return (static_cast<T> (this->constraint_) == expected); +} + +template<class T> void +Literal_Interpreter<T>::constraint (TAO_Literal_Constraint& constraint) +{ + this->constraint_ = constraint; +} + +template<class T> const TAO_Literal_Constraint& +Literal_Interpreter<T>::constraint (void) const +{ + return this->constraint_; +} + +int +ACE_TMAIN (int, ACE_TCHAR **) +{ + int status = 0; + { + Literal_Interpreter<CORBA::ULongLong> u_interp; + if (!u_interp.test ("993834343433882", + ACE_UINT64_LITERAL (993834343433882))) + { + status++; + ACE_ERROR ((LM_ERROR, "ERROR: CORBA::ULongLong test failed.\n")); + } + + Literal_Interpreter<CORBA::LongLong> interp; + if (!interp.test ("-1879048193", -1879048193)) + { + status++; + ACE_ERROR ((LM_ERROR, "ERROR: CORBA::LongLong test failed.\n")); + } + + // Since we're comparing signed and unsigned, the signed should get + // promoted to unsigned. However, it gets logically promoted, not + // binarily. So, a negative value is converted into zero as an + // unsigned value. + if (interp.constraint () > u_interp.constraint ()) + { + status++; + ACE_ERROR ((LM_ERROR, "ERROR: Mixed greater than test 1 failed.\n")); + } + } + { + Literal_Interpreter<CORBA::Double> u_interp; + if (!u_interp.test ("993834343433882.88837719", 993834343433882.88837719)) + { + status++; + ACE_ERROR ((LM_ERROR, "ERROR: CORBA::Double test 1 failed.\n")); + } + + Literal_Interpreter<CORBA::Double> interp; + if (!interp.test ("-993834343433882.88837719", + -993834343433882.88837719)) + { + status++; + ACE_ERROR ((LM_ERROR, "ERROR: CORBA::Double test 2 failed.\n")); + } + + if (interp.constraint () > u_interp.constraint ()) + { + status++; + ACE_ERROR ((LM_ERROR, "ERROR: Mixed greater than test 2 failed.\n")); + } + } + { + Literal_Interpreter<CORBA::Boolean> interp; + if (!interp.test ("TRUE", true)) + { + status++; + ACE_ERROR ((LM_ERROR, "ERROR: CORBA::Boolean test 1 failed.\n")); + } + } + { + Literal_Interpreter<CORBA::Boolean> interp; + if (!interp.test ("FALSE", false)) + { + status++; + ACE_ERROR ((LM_ERROR, "ERROR: CORBA::Boolean test 2 failed.\n")); + } + } + { + Literal_Interpreter<const char*> interp; + if (!interp.test ("'This is a test'", "This is a test")) + { + status++; + ACE_ERROR ((LM_ERROR, "ERROR: const char* test failed.\n")); + } + } + return status; +} diff --git a/TAO/orbsvcs/tests/unit/Trading/Interpreter/Interpreter.mpc b/TAO/orbsvcs/tests/unit/Trading/Interpreter/Interpreter.mpc new file mode 100644 index 00000000000..b19d12a3bc1 --- /dev/null +++ b/TAO/orbsvcs/tests/unit/Trading/Interpreter/Interpreter.mpc @@ -0,0 +1,6 @@ +// -*- MPC -*- +// $Id$ + +project: trading_serv, portableserver { + exename = Interpreter +} diff --git a/TAO/orbsvcs/tests/unit/Trading/Interpreter/run_test.pl b/TAO/orbsvcs/tests/unit/Trading/Interpreter/run_test.pl new file mode 100755 index 00000000000..162b910b3fb --- /dev/null +++ b/TAO/orbsvcs/tests/unit/Trading/Interpreter/run_test.pl @@ -0,0 +1,24 @@ +eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' + & eval 'exec perl -S $0 $argv:q' + if 0; + +# $Id$ +# -*- perl -*- + +use lib "$ENV{ACE_ROOT}/bin"; +use PerlACE::Run_Test; +use File::Basename; + +my $status = 0; + +my $SV = new PerlACE::Process ("Interpreter"); + +my $server = $SV->SpawnWaitKill (10); + +if ($server != 0) { + print STDERR "ERROR: ", basename($SV->Executable()), + " returned $server \n"; + $status = 1; +} + +exit $status; |