diff options
Diffstat (limited to 'qlparser/qtunaryinduce.cc')
| -rw-r--r-- | qlparser/qtunaryinduce.cc | 1013 |
1 files changed, 1013 insertions, 0 deletions
diff --git a/qlparser/qtunaryinduce.cc b/qlparser/qtunaryinduce.cc new file mode 100644 index 0000000..60322d1 --- /dev/null +++ b/qlparser/qtunaryinduce.cc @@ -0,0 +1,1013 @@ +/* +* This file is part of rasdaman community. +* +* Rasdaman community is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* Rasdaman community is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with rasdaman community. If not, see <http://www.gnu.org/licenses/>. +* +* Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009 Peter Baumann / +rasdaman GmbH. +* +* For more information please see <http://www.rasdaman.org> +* or contact Peter Baumann via <baumann@rasdaman.com>. +*/ +/************************************************************* + * + * + * PURPOSE: + * + * + * COMMENTS: + * + ************************************************************/ + +static const char rcsid[] = "@(#)qlparser, QtUnaryInduce: $Id: qtunaryinduce.cc,v 1.47 2002/08/19 11:13:27 coman Exp $"; + +#include "raslib/rmdebug.hh" + +#include "qlparser/qtunaryinduce.hh" +#include "qlparser/qtmdd.hh" +#include "qlparser/qtatomicdata.hh" +#include "qlparser/qtcomplexdata.hh" +#include "qlparser/qtnode.hh" + +#include "mddmgr/mddobj.hh" +#include "tilemgr/tile.hh" + +#include "catalogmgr/typefactory.hh" +#include "relcatalogif/structtype.hh" + +#include <sstream> +#ifndef CPPSTDLIB +#include <ospace/string.h> // STL<ToolKit> +#else +#include <string> +using namespace std; +#endif + +const QtNode::QtNodeType QtUnaryInduce::nodeType = QtNode::QT_UNARY_INDUCE; + +QtUnaryInduce::QtUnaryInduce( QtOperation* initInput ) + : QtUnaryOperation( initInput ) +{ +} + + + +bool +QtUnaryInduce::getOperand( QtDataList* inputList, QtData* &operand ) +{ + bool success = false; + + // get the operands + operand = input->evaluate( inputList ); + + // Test, if the operands are valid. + if( operand ) + success = true; + else + { + RMDBGMIDDLE( 1, RMDebug::module_qlparser, "QtUnaryInduce", "Information: QtUnaryInduce::getOperand() - operand is not provided." ) + } + + return success; +} + + + +QtData* +QtUnaryInduce::computeOp( QtData* operand, Ops::OpType operation ) +{ + QtData* returnValue = NULL; + + if( operand->getDataType() == QT_MDD ) + { + QtMDD* mdd = (QtMDD*) operand; + + const BaseType* resultCellType = (BaseType*)(Ops::getResultType( operation, mdd->getCellType() )); + + returnValue = computeUnaryMDDOp( mdd, resultCellType, operation); + } + else if( operand->isScalarData() ) + { + QtScalarData* scalar = (QtScalarData*) operand; + + const BaseType* resultCellType = (BaseType*)(Ops::getResultType( operation, scalar->getValueType() )); + + returnValue = computeUnaryOp( scalar, resultCellType, operation ); + } + + return returnValue; +} + + + +QtData* +QtUnaryInduce::computeUnaryMDDOp( QtMDD* operand, const BaseType* resultBaseType, + Ops::OpType operation, unsigned int operandOffset ) +{ + RMDBCLASS( "QtUnaryInduce", "computeUnaryMDDOp( QtMDD*, BaseType*, Ops::OpType, unsigned int ) ", "qlparser", __FILE__, __LINE__ ) + + QtData* returnValue = NULL; + + // get the MDD object + MDDObj* op = ((QtMDD*)operand)->getMDDObject(); + + // get the area, where the operation has to be applied + const r_Minterval &areaOp = ((QtMDD*)operand)->getLoadDomain(); + + // contains all tiles of the operand + vector<Tile*>* allTiles=NULL; + + // iterator for tiles + + // create MDDObj for result + MDDBaseType* mddBaseType = new MDDBaseType( "tmp", resultBaseType ); + TypeFactory::addTempType( mddBaseType ); + + MDDObj* mddres = new MDDObj( mddBaseType, areaOp ); + + // get all tiles in relevant area + allTiles = op->intersect(areaOp); + std::vector<Tile*>::iterator tileIt = allTiles->begin(); + if (tileIt != allTiles->end()) + { + Tile* resTile = NULL; + UnaryOp* myOp = NULL; + if (operation == Ops::OP_IDENTITY) + { + myOp = Ops::getUnaryOp(operation, resultBaseType, resultBaseType, 0, operandOffset); + } + else { + myOp = Ops::getUnaryOp(operation, resultBaseType, (*tileIt)->getType(), 0, 0); + } + if (myOp == NULL) + { + RMInit::logOut << "QtUnaryInduce::computeUnaryMDDOp(...) could not get operation for result type " << resultBaseType->getName() << " argument type " << (*tileIt)->getType() << " operation " << operation << endl; + delete myOp; + myOp = NULL; + delete allTiles; + allTiles = NULL; + //contents of allTiles are deleted when index is deleted + delete mddres; + mddres = NULL; + delete resTile; + resTile = NULL; + delete mddres; + mddres = NULL; + // i am not sure about that error number... + parseInfo.setErrorNo(366); + throw parseInfo; + } + // and iterate over them + try { + for( ; tileIt != allTiles->end(); tileIt++ ) + { + // domain of the actual tile + const r_Minterval &tileDom = (*tileIt)->getDomain(); + + // domain of the relevant area of the actual tile + r_Minterval intersectDom( tileDom.create_intersection( areaOp ) ); + + // create tile for result + resTile = new Tile( intersectDom, resultBaseType ); + + // carry out operation on the relevant area of the tiles + resTile->execUnaryOp(myOp, intersectDom, (*tileIt), intersectDom); + // insert Tile in result mdd + mddres->insertTile( resTile ); + } + } + catch(r_Error& err) + { + RMInit::logOut << "QtUnaryInduce::computeUnaryMDDOp caught " << err.get_errorno() << " " << err.what() << endl; + delete myOp; + myOp = NULL; + delete allTiles; + allTiles = NULL; + //contents of allTiles are deleted when index is deleted + delete mddres; + mddres = NULL; + delete resTile; + resTile = NULL; + delete mddres; + mddres = NULL; + parseInfo.setErrorNo(err.get_errorno()); + throw parseInfo; + } + catch (int err) + { + RMInit::logOut << "QtUnaryInduce::computeUnaryMDDOp caught errno error (" << err << ") in unaryinduce" << endl; + delete myOp; + myOp = NULL; + delete allTiles; + allTiles = NULL; + //contents of allTiles are deleted when index is deleted + delete mddres; + mddres = NULL; + delete resTile; + resTile = NULL; + delete mddres; + mddres = NULL; + parseInfo.setErrorNo(err); + throw parseInfo; + } + + delete myOp; + myOp = NULL; + } + // delete tile vector + delete allTiles; + allTiles = NULL; + + // create a new QtMDD object as carrier object for the transient MDD object + returnValue = new QtMDD( (MDDObj*)mddres ); + + // The following is now done when deleting the last reference to the operand + // delete the obsolete MDD object + // delete op; + + return returnValue; +} + + +QtData* +QtUnaryInduce::computeUnaryOp( QtScalarData* operand, const BaseType* resultBaseType, + Ops::OpType operation, unsigned int operandOffset ) +{ + RMDBCLASS( "QtUnaryInduce", "computeUnaryOp( QtScalarData*, BaseType*, Ops::OpType, unsigned int ) ", "qlparser", __FILE__, __LINE__ ) + + QtScalarData* scalarDataObj = NULL; + + // allocate memory for the result + char* resultBuffer = new char[ resultBaseType->getSize() ]; + + RMDBGIF( 4, RMDebug::module_qlparser, "QtUnaryInduce", \ + RMInit::dbgOut << "Operand value "; \ + operand->getValueType()->printCell( RMInit::dbgOut, operand->getValueBuffer() ); \ + RMInit::dbgOut << endl; \ + ) + + if(( operation == Ops::OP_IDENTITY )) // || ( operation == Ops::OP_SQRT )) + // operand type is the same as result type + Ops::execUnaryConstOp( operation, resultBaseType, + resultBaseType, + resultBuffer, + operand->getValueBuffer(), + 0, operandOffset ); + else + try + { + Ops::execUnaryConstOp( operation, resultBaseType, + operand->getValueType(), + resultBuffer, + operand->getValueBuffer(), + 0, operandOffset ); + } + catch(int err) + { + delete[] resultBuffer; + resultBuffer = NULL; + parseInfo.setErrorNo(err); + throw parseInfo; + } + + RMDBGIF( 4, RMDebug::module_qlparser, "QtUnaryInduce", \ + RMInit::dbgOut << "Result value "; \ + resultBaseType->printCell( RMInit::dbgOut, resultBuffer ); \ + RMInit::dbgOut << endl; \ + ) + + if( resultBaseType->getType() == STRUCT ) + scalarDataObj = new QtComplexData(); + else + scalarDataObj = new QtAtomicData(); + + scalarDataObj->setValueType ( resultBaseType ); + scalarDataObj->setValueBuffer( resultBuffer ); + + return scalarDataObj; +} + + +const QtNode::QtNodeType QtNot::nodeType = QtNode::QT_NOT; + +QtNot::QtNot( QtOperation* initInput ) + : QtUnaryInduce( initInput ) +{ +} + + +QtData* +QtNot::evaluate( QtDataList* inputList ) +{ + QtData* returnValue = NULL; + QtData* operand = NULL; + + if( getOperand( inputList, operand ) ) + { + returnValue = computeOp( operand, Ops::OP_NOT ); + + // delete old operand + if( operand ) operand->deleteRef(); + } + return returnValue; +} + + + +void +QtNot::printTree( int tab, ostream& s, QtChildType mode ) +{ + s << SPACE_STR(tab).c_str() << "QtNot Object" << endl; + + QtUnaryInduce::printTree( tab+2, s, mode ); +} + + + +void +QtNot::printAlgebraicExpression( ostream& s ) +{ + s << "not("; + + if( input ) + input->printAlgebraicExpression( s ); + else + s << "<nn>"; + + s << ")"; +} + + + +const QtTypeElement& +QtNot::checkType( QtTypeTuple* typeTuple ) +{ + RMDBCLASS( "QtNot", "checkType( QtTypeTuple* )", "qlparser", __FILE__, __LINE__ ) + + dataStreamType.setDataType( QT_TYPE_UNKNOWN ); + + // check operand branches + if( input ) + { + + // get input types + const QtTypeElement& inputType = input->checkType( typeTuple ); + + RMDBGIF( 4, RMDebug::module_qlparser, "QtNot", \ + RMInit::dbgOut << "Operand: " << flush; \ + inputType.printStatus( RMInit::dbgOut ); \ + RMInit::dbgOut << endl; \ + ) + + if( inputType.getDataType() == QT_MDD ) + { + const BaseType* baseType = ((const MDDBaseType*)(inputType.getType()))->getBaseType(); + + const BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_NOT, baseType )); + + if( !resultBaseType ) + { + RMInit::logOut << "Error: QtNot::checkType() - induce operand type is not supported." << endl; + parseInfo.setErrorNo(366); + throw parseInfo; + } + + MDDBaseType* resultMDDType = new MDDBaseType( "tmp", resultBaseType ); + TypeFactory::addTempType( resultMDDType ); + + dataStreamType.setType( resultMDDType ); + } + else if( inputType.isBaseType() ) + { + BaseType* baseType = (BaseType*)(inputType.getType()); + + const BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_NOT, baseType )); + + if( !resultBaseType ) + { + RMInit::logOut << "Error: QtNot::checkType() - operand type is not supported." << endl; + parseInfo.setErrorNo(367); + throw parseInfo; + } + + // MDDBaseType* resultMDDType = new MDDBaseType( "tmp", resultBaseType ); + // TypeFactory::addTempType( resultMDDType ); + + // dataStreamType.setType( resultMDDType ); + dataStreamType.setType( resultBaseType ); + } + else + { + RMInit::logOut << "Error: QtNot::checkType() - operation is not supported for strings." << endl; + parseInfo.setErrorNo(385); + throw parseInfo; + } + } + else + RMInit::logOut << "Error: QtNot::checkType() - operand branch invalid." << endl; + + return dataStreamType; +} + + + + +const QtNode::QtNodeType QtDot::nodeType = QtNode::QT_DOT; + + + +QtDot::QtDot( const string& initElementName ) + : QtUnaryInduce( NULL ), + elementName( initElementName ), + elementNo(-1) +{ +} + + + +QtDot::QtDot( unsigned initElementNo ) + : QtUnaryInduce( NULL ), + elementNo( initElementNo ) +{ +} + + + +bool +QtDot::equalMeaning( QtNode* node ) +{ + bool result = false; + + if( nodeType == node->getNodeType() ) + { + QtDot* dotNode = (QtDot* ) node; // by force + + // In future, elementName have to be converted to elementNo + // and then just the numbers are compared. + if( (elementNo != -1 && elementNo == dotNode->elementNo) || + (elementNo == -1 && elementName == dotNode->elementName) ) + result = input->equalMeaning( dotNode->getInput() ); + }; + + return result; +} + + +string +QtDot::getSpelling() +{ + char tempStr[20]; + sprintf(tempStr, "%ud", (unsigned long)getNodeType()); + string result = string(tempStr); + + if( elementNo == -1 ) + result.append( elementName ); + else + { + std::ostringstream bufferStream; + bufferStream << elementNo << ends; + + result.append( bufferStream.str() ); + } + + result.append( "(" ); + result.append( input->getSpelling() ); + result.append( ")" ); + + return result; +} + + +QtData* +QtDot::evaluate( QtDataList* inputList ) +{ + RMDBCLASS( "QtDot", "evaluate( QtDataList* )", "qlparser", __FILE__, __LINE__ ) + + QtData* returnValue = NULL; + QtData* operand = NULL; + + if( getOperand( inputList, operand ) ) + { + if( operand->getDataType() == QT_MDD ) + { + QtMDD* mdd = (QtMDD*) operand; + +#ifdef QT_RUNTIME_TYPE_CHECK + // test, if operand has complex base type + if( mdd->getCellType()->getType() != STRUCT ) + { + RMInit::logOut << "Internal error in QtDot::evaluate() - " + << "runtime type checking failed." << endl; + + // delete old operand + if( operand ) operand->deleteRef(); + + return 0; + } +#endif + + StructType* operandType = (StructType*)mdd->getCellType(); + unsigned int operandOffset; + const BaseType* resultCellType = NULL; + + if( elementNo == -1 ) + resultCellType = operandType->getElemType( (char*)(elementName.c_str()) ); + else + resultCellType = operandType->getElemType( (unsigned int)elementNo ); + + if( !resultCellType ) + { + RMInit::logOut << "Error: QtDot::evaluate() - struct selector is not valid." << endl; + parseInfo.setErrorNo(370); + throw parseInfo; + } + + if( elementNo == -1 ) + operandOffset = operandType->getOffset( (char*)(elementName.c_str()) ); + else + operandOffset = operandType->getOffset( (unsigned int)elementNo ); + + RMDBGIF( 1, RMDebug::module_qlparser, "QtUnaryInduce", \ + char* typeStructure = operandType->getTypeStructure(); \ + RMDBGMIDDLE( 4, RMDebug::module_qlparser, "QtUnaryInduce", "Operand base type " << operandType->getTypeName() << ", structure " << typeStructure ) \ + free( typeStructure ); typeStructure=NULL; \ + RMDBGMIDDLE( 4, RMDebug::module_qlparser, "QtUnaryInduce", "Operand base offset " << operandOffset ) \ + typeStructure = resultCellType->getTypeStructure(); \ + RMDBGMIDDLE( 4, RMDebug::module_qlparser, "QtUnaryInduce", "Result base type " << resultCellType->getTypeName() << ", structure " << typeStructure ) \ + free( typeStructure ); typeStructure=NULL; \ + ) + + returnValue = computeUnaryMDDOp( mdd, resultCellType, Ops::OP_IDENTITY, operandOffset ); + } + else if( operand->isScalarData() ) + { + QtScalarData* scalar = (QtScalarData*) operand; + +#ifdef QT_RUNTIME_TYPE_CHECK + // test, if operand has complex base type + if( scalar->getValueType()->getType() != STRUCT ) + { + RMInit::logOut << "Internal error in QtDot::evaluate() - " + << "runtime type checking failed." << endl; + + // delete old operand + if( operand ) operand->deleteRef(); + + return 0; + } +#endif + + StructType* operandType = (StructType*)scalar->getValueType(); + unsigned int operandOffset; + const BaseType* resultCellType=NULL; + + if( elementNo == -1 ) + resultCellType = operandType->getElemType( (char*)(elementName.c_str()) ); + else + resultCellType = operandType->getElemType( (unsigned int)elementNo ); + + if( !resultCellType ) + { + RMInit::logOut << "Error: QtDot::evaluate() - struct selector is not valid." << endl; + parseInfo.setErrorNo(370); + throw parseInfo; + } + + if( elementNo == -1 ) + operandOffset = operandType->getOffset( (char*)(elementName.c_str()) ); + else + operandOffset = operandType->getOffset( (unsigned int)elementNo ); + + RMDBGIF( 1, RMDebug::module_qlparser, "QtUnaryInduce", \ + char* typeStructure = operandType->getTypeStructure(); \ + RMDBGMIDDLE( 4, RMDebug::module_qlparser, "QtUnaryInduce", "Operand scalar type " << operandType->getTypeName() << ", structure " << typeStructure ) \ + free( typeStructure ); typeStructure=NULL; \ + RMDBGMIDDLE( 4, RMDebug::module_qlparser, "QtUnaryInduce", "Operand scalar offset " << operandOffset ) \ + typeStructure = resultCellType->getTypeStructure(); \ + RMDBGMIDDLE( 4, RMDebug::module_qlparser, "QtUnaryInduce", "Result scalar type " << resultCellType->getTypeName() << ", structure " << typeStructure ) \ + free( typeStructure ); typeStructure=NULL; \ + ) + + returnValue = computeUnaryOp( scalar, resultCellType, Ops::OP_IDENTITY, operandOffset ); + } + else + { + RMInit::logOut << "Error: QtDot::evaluate() - operation is not supported for strings." << endl; + parseInfo.setErrorNo(385); + throw parseInfo; + } + + // delete old operand + if( operand ) operand->deleteRef(); + } + + return returnValue; +} + + + +void +QtDot::printTree( int tab, ostream& s, QtChildType mode ) +{ + if( elementNo == -1 ) + s << SPACE_STR(tab).c_str() << "QtDot Object: access " << elementName.c_str() << endl; + else + s << SPACE_STR(tab).c_str() << "QtDot Object: access no " << elementNo << endl; + + QtUnaryInduce::printTree( tab+2, s, mode ); +} + +void +QtDot::printAlgebraicExpression( ostream& s ) +{ + s << "("; + + if( input ) + input->printAlgebraicExpression( s ); + else + s << "<nn>"; + + s << ")."; + + if( elementNo == -1 ) + s << elementName.c_str(); + else + s << elementNo; + + s << " "; +} + +const QtTypeElement& +QtDot::checkType( QtTypeTuple* typeTuple ) +{ + RMDBCLASS( "QtDot", "checkType( QtTypeTuple* )", "qlparser", __FILE__, __LINE__ ) + + dataStreamType.setDataType( QT_TYPE_UNKNOWN ); + + // check operand branches + if( input ) + { + + // get input types + const QtTypeElement& inputType = input->checkType( typeTuple ); + + RMDBGIF( 4, RMDebug::module_qlparser, "QtDot", \ + RMInit::dbgOut << "Operand: " << flush; \ + inputType.printStatus( RMInit::dbgOut ); \ + RMInit::dbgOut << endl; \ + ) + + if( inputType.getDataType() == QT_MDD ) + { + const BaseType* baseType = ((MDDBaseType*)(inputType.getType()))->getBaseType(); + + // test, if operand has complex base type + if( baseType->getType() != STRUCT ) + { + RMInit::logOut << "Error: QtDot::evaluate() - operand of induce dot operation must be complex." << endl; + parseInfo.setErrorNo(368); + throw parseInfo; + } + + StructType* structType = (StructType*)baseType; + const BaseType* resultBaseType = NULL; + + if( elementNo == -1 ) + resultBaseType = structType->getElemType( (char*)(elementName.c_str()) ); + else + resultBaseType = structType->getElemType( (unsigned int)elementNo ); + + if( !resultBaseType ) + { + RMInit::logOut << "Error: QtDot::evaluate() - struct selector is not valid." << endl; + parseInfo.setErrorNo(370); + throw parseInfo; + } + + MDDBaseType* resultMDDType = new MDDBaseType( "tmp", resultBaseType ); + TypeFactory::addTempType( resultMDDType ); + + dataStreamType.setType( resultMDDType ); + } + else if( inputType.isBaseType() ) + { + BaseType* baseType = (BaseType*)(inputType.getType()); + + // test, if operand has complex base type + if( baseType->getType() != STRUCT ) + { + RMInit::logOut << "Error: QtDot::evaluate() - operand of dot operation must be complex." << endl; + parseInfo.setErrorNo(369); + throw parseInfo; + } + + StructType* structType = (StructType*)baseType; + const BaseType* resultBaseType = NULL; + + if( elementNo == -1 ) + resultBaseType = structType->getElemType( (char*)(elementName.c_str()) ); + else + resultBaseType = structType->getElemType( (unsigned int)elementNo ); + + if( !resultBaseType ) + { + RMInit::logOut << "Error: QtDot::evaluate() - struct selector is not valid." << endl; + parseInfo.setErrorNo(370); + throw parseInfo; + } + + dataStreamType.setType( resultBaseType ); + } + else + { + RMInit::logOut << "Error: QtDot::checkType() - operation is not supported for strings." << endl; + parseInfo.setErrorNo(385); + throw parseInfo; + } + } else + RMInit::logOut << "Error: QtDot::checkType() - operand branch invalid." << endl; + return dataStreamType; +} + +//-------------------------------------------- +// QtCast +//-------------------------------------------- + +const QtNode::QtNodeType QtCast::nodeType = QtNode::QT_CAST; + +QtCast::QtCast(QtOperation* initInput, cast_types t): + QtUnaryInduce(initInput), castType(t) {} + +QtData* QtCast::evaluate(QtDataList* inputList) { + QtData* returnValue = NULL; + QtData* operand = NULL; + + if(getOperand(inputList, operand)) + returnValue = computeOp( operand, getOp(castType)); + + // delete old operand + if(operand) operand->deleteRef(); + return returnValue; +} + +void QtCast::printTree(int tab, ostream& s, QtChildType mode) { + const char *type_name[] = { + "bool", "octet", "char", "short", "ushort", + "long", "ulong", "float", "double" + }; + s << SPACE_STR(tab).c_str() << "QtCastObject " + << getNodeType() + << "<" << type_name[castType] << ">" + << endl; + QtUnaryInduce::printTree( tab + 2, s, mode ); +} + +void QtCast::printAlgebraicExpression(ostream& s) { + const char *type_name[] = { + "bool", "octet", "char", "short", "ushort", + "long", "ulong", "float", "double" + }; + s << "cast<" << type_name[castType] << ">("; + if(input) + input->printAlgebraicExpression(s); + else + s << "<nn>"; + s << ")"; +} + +const QtTypeElement& QtCast::checkType(QtTypeTuple* typeTuple) { + + RMDBCLASS( "QtCast", "checkType( QtTypeTuple* )", "qlparser", __FILE__, __LINE__ ) + + dataStreamType.setDataType( QT_TYPE_UNKNOWN ); + + // check operand branches + if(input) { + + // get input types + const QtTypeElement& inputType = input->checkType( typeTuple ); + RMDBGIF( 4, RMDebug::module_qlparser, "QtCast", \ + RMInit::dbgOut << "Operand: " << flush; \ + inputType.printStatus( RMInit::dbgOut ); \ + RMInit::dbgOut << endl; \ + ) + + if(inputType.getDataType() == QT_MDD) { + const BaseType* baseType = ((MDDBaseType*)(inputType.getType()))->getBaseType(); + BaseType* resultBaseType = (BaseType*)(Ops::getResultType( getOp(castType), baseType )); + + + if(!resultBaseType) { + RMInit::logOut << "Error: QtCast::checkType() - induce operand type is not support" << endl; + parseInfo.setErrorNo(366); + throw parseInfo; + } + + MDDBaseType* resultMDDType = new MDDBaseType( "tmp", resultBaseType ); + TypeFactory::addTempType( resultMDDType ); + dataStreamType.setType( resultMDDType ); + } + + else if(inputType.isBaseType()) { + BaseType* baseType = (BaseType*)(inputType.getType()); + BaseType* resultBaseType = (BaseType*)(Ops::getResultType( getOp(castType), baseType )); + + if(!resultBaseType) { + RMInit::logOut << "Error: QtCast::checkType() - operand type is not supported." << endl; + parseInfo.setErrorNo(367); + throw parseInfo; + } + + dataStreamType.setType( resultBaseType ); + } + else { + RMInit::logOut << "Error: QtCast::checkType() - operation is not supported for strings." << endl; + parseInfo.setErrorNo(385); + throw parseInfo; + } + } + else + RMInit::logOut << "Error: QtCast::checkType() - operand branch invalid." << endl; + + return dataStreamType; +} + + +//-------------------------------------------- +// QtRealPartOp +//-------------------------------------------- + +const QtNode::QtNodeType QtRealPartOp::nodeType = QtNode::QT_REALPART; + +QtRealPartOp::QtRealPartOp(QtOperation* initInput): QtUnaryInduce(initInput) {} + +QtData* QtRealPartOp::evaluate(QtDataList* inputList) { + QtData* returnValue = NULL; + QtData* operand = NULL; + + if(getOperand(inputList, operand)) + returnValue = computeOp( operand, Ops::OP_REALPART ); + // delete old operand + if(operand) operand->deleteRef(); + return returnValue; +} + +void QtRealPartOp::printTree(int tab, ostream& s, QtChildType mode) { + s << SPACE_STR(tab).c_str() << "QtRealPartOpObject " << getNodeType() << endl; + QtUnaryInduce::printTree( tab + 2, s, mode ); +} + +void QtRealPartOp::printAlgebraicExpression(ostream& s) { + s << "Re("; + if(input) + input->printAlgebraicExpression(s); + else + s << "<nn>"; + s << ")"; +} + +const QtTypeElement& QtRealPartOp::checkType(QtTypeTuple* typeTuple) { + RMDBCLASS( "QtRealPartOp", "checkType( QtTypeTuple* )", "qlparser", __FILE__, __LINE__ ) + + dataStreamType.setDataType( QT_TYPE_UNKNOWN ); + + // check operand branches + if(input) { + + // get input types + const QtTypeElement& inputType = input->checkType( typeTuple ); + RMDBGIF( 1, RMDebug::module_qlparser, "QtRealPartOp", \ + RMInit::dbgOut << "Operand: " << flush; \ + inputType.printStatus( RMInit::dbgOut ); \ + RMInit::dbgOut << endl; + ) + + if(inputType.getDataType() == QT_MDD) { + const BaseType* baseType = ((MDDBaseType*)(inputType.getType()))->getBaseType(); + BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_REALPART, baseType )); + if(!resultBaseType) { + RMInit::logOut << "Error: QtRealPartOp::checkType() - induce operand type is not support" << endl; + parseInfo.setErrorNo(366); + throw parseInfo; + } + MDDBaseType* resultMDDType = new MDDBaseType( "tmp", resultBaseType ); + TypeFactory::addTempType( resultMDDType ); + dataStreamType.setType( resultMDDType ); + } + else if(inputType.isBaseType()) { + BaseType* baseType = (BaseType*)(inputType.getType()); + BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_REALPART, baseType )); + if(!resultBaseType) { + RMInit::logOut << "Error: QtRealPartOp::checkType() - operand type is not supported." << endl; + parseInfo.setErrorNo(367); + throw parseInfo; + } + dataStreamType.setType( resultBaseType ); + } + else { + RMInit::logOut << "Error: QtRealPartOp::checkType() - operation is not supported for strings." << endl; + parseInfo.setErrorNo(385); + throw parseInfo; + } + } else + RMInit::logOut << "Error: QtRealPartOp::checkType() - operand branch invalid." << endl; + + return dataStreamType; +} + +//-------------------------------------------- +// QtImaginarPartOp +//-------------------------------------------- + +const QtNode::QtNodeType QtImaginarPartOp::nodeType = QtNode::QT_IMAGINARPART; + +QtImaginarPartOp::QtImaginarPartOp(QtOperation* initInput): QtUnaryInduce(initInput) {} + +QtData* QtImaginarPartOp::evaluate(QtDataList* inputList) { + QtData* returnValue = NULL; + QtData* operand = NULL; + + if(getOperand(inputList, operand)) + returnValue = computeOp( operand, Ops::OP_IMAGINARPART ); + // delete old operand + if(operand) operand->deleteRef(); + return returnValue; +} + +void QtImaginarPartOp::printTree(int tab, ostream& s, QtChildType mode) { + s << SPACE_STR(tab).c_str() << "QtImaginarPartObject " << getNodeType() << endl; + QtUnaryInduce::printTree( tab + 2, s, mode ); +} + +void QtImaginarPartOp::printAlgebraicExpression(ostream& s) { + s << "Im("; + if(input) + input->printAlgebraicExpression(s); + else + s << "<nn>"; + s << ")"; +} + +const QtTypeElement& QtImaginarPartOp::checkType(QtTypeTuple* typeTuple) { + RMDBCLASS( "QtImaginarPart", "checkType( QtTypeTuple* )", "qlparser", __FILE__, __LINE__ ) + + dataStreamType.setDataType( QT_TYPE_UNKNOWN ); + + // check operand branches + if(input) + { + + // get input types + const QtTypeElement& inputType = input->checkType( typeTuple ); + + RMDBGIF( 4, RMDebug::module_qlparser, "QtImaginarPartOp", \ + RMInit::dbgOut << "Operand: " << flush; \ + inputType.printStatus( RMInit::dbgOut ); \ + RMInit::dbgOut << endl; \ + ) + + if(inputType.getDataType() == QT_MDD) { + const BaseType* baseType = ((MDDBaseType*)(inputType.getType()))->getBaseType(); + BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_IMAGINARPART, baseType )); + if(!resultBaseType) { + RMInit::logOut << "Error: QtImaginarPart::checkType() - induce operand type is not support" << endl; + parseInfo.setErrorNo(366); + throw parseInfo; + } + MDDBaseType* resultMDDType = new MDDBaseType( "tmp", resultBaseType ); + TypeFactory::addTempType( resultMDDType ); + dataStreamType.setType( resultMDDType ); + } + else if(inputType.isBaseType()) { + BaseType* baseType = (BaseType*)(inputType.getType()); + BaseType* resultBaseType = (BaseType*)(Ops::getResultType(Ops::OP_IMAGINARPART, baseType)); + if(!resultBaseType) { + RMInit::logOut << "Error: QtImaginarPart::checkType() - operand type is not supported." << endl; + parseInfo.setErrorNo(367); + throw parseInfo; + } + dataStreamType.setType( resultBaseType ); + } + else { + RMInit::logOut << "Error: QtImaginarPart::checkType() - operation is not supported for strings." << endl; + parseInfo.setErrorNo(385); + throw parseInfo; + } + } + else + RMInit::logOut << "Error: QtImaginarPart::checkType() - operand branch invalid." << endl; + return dataStreamType; +} + +#include "autogen_qtui.cc" |