Milliseconds ReplSetConfig::getPriorityTakeoverDelay(int memberIdx) const {
    auto member = getMemberAt(memberIdx);
    int priorityRank = calculatePriorityRank(member.getPriority());
    return (priorityRank + 1) * getElectionTimeoutPeriod();
}
void IncludeOrderPPCallbacks::EndOfMainFile() {
  LookForMainModule = true;
  if (IncludeDirectives.empty())
    return;

  // TODO: find duplicated includes.

  // Form blocks of includes. We don't want to sort across blocks. This also
  // implicitly makes us never reorder over #defines or #if directives.
  // FIXME: We should be more careful about sorting below comments as we don't
  // know if the comment refers to the next include or the whole block that
  // follows.
  for (auto &Bucket : IncludeDirectives) {
    auto &FileDirectives = Bucket.second;
    std::vector<unsigned> Blocks(1, 0);
    for (unsigned I = 1, E = FileDirectives.size(); I != E; ++I)
      if (SM.getExpansionLineNumber(FileDirectives[I].Loc) !=
          SM.getExpansionLineNumber(FileDirectives[I - 1].Loc) + 1)
        Blocks.push_back(I);
    Blocks.push_back(FileDirectives.size()); // Sentinel value.

    // Get a vector of indices.
    std::vector<unsigned> IncludeIndices;
    for (unsigned I = 0, E = FileDirectives.size(); I != E; ++I)
      IncludeIndices.push_back(I);

    // Sort the includes. We first sort by priority, then lexicographically.
    for (unsigned BI = 0, BE = Blocks.size() - 1; BI != BE; ++BI)
      std::sort(IncludeIndices.begin() + Blocks[BI],
                IncludeIndices.begin() + Blocks[BI + 1],
                [&FileDirectives](unsigned LHSI, unsigned RHSI) {
                  IncludeDirective &LHS = FileDirectives[LHSI];
                  IncludeDirective &RHS = FileDirectives[RHSI];

                  int PriorityLHS =
                      getPriority(LHS.Filename, LHS.IsAngled, LHS.IsMainModule);
                  int PriorityRHS =
                      getPriority(RHS.Filename, RHS.IsAngled, RHS.IsMainModule);

                  return std::tie(PriorityLHS, LHS.Filename) <
                         std::tie(PriorityRHS, RHS.Filename);
                });

    // Emit a warning for each block and fixits for all changes within that
    // block.
    for (unsigned BI = 0, BE = Blocks.size() - 1; BI != BE; ++BI) {
      // Find the first include that's not in the right position.
      unsigned I, E;
      for (I = Blocks[BI], E = Blocks[BI + 1]; I != E; ++I)
        if (IncludeIndices[I] != I)
          break;

      if (I == E)
        continue;

      // Emit a warning.
      auto D = Check.diag(FileDirectives[I].Loc,
                          "#includes are not sorted properly");

      // Emit fix-its for all following includes in this block.
      for (; I != E; ++I) {
        if (IncludeIndices[I] == I)
          continue;
        const IncludeDirective &CopyFrom = FileDirectives[IncludeIndices[I]];

        SourceLocation FromLoc = CopyFrom.Range.getBegin();
        const char *FromData = SM.getCharacterData(FromLoc);
        unsigned FromLen = std::strcspn(FromData, "\n");

        StringRef FixedName(FromData, FromLen);

        SourceLocation ToLoc = FileDirectives[I].Range.getBegin();
        const char *ToData = SM.getCharacterData(ToLoc);
        unsigned ToLen = std::strcspn(ToData, "\n");
        auto ToRange =
            CharSourceRange::getCharRange(ToLoc, ToLoc.getLocWithOffset(ToLen));

        D << FixItHint::CreateReplacement(ToRange, FixedName);
      }
    }
  }

  IncludeDirectives.clear();
}
TVerdict CT_LbsHybridUEAssistedX3PAccurateGPS::doTestStepL()
	{
	// Generic test step used to test the LBS Client Notify position update API.
	INFO_PRINTF1(_L("CT_LbsHybridUEAssistedX3PAccurateGPS::doTestStepL()"));

	// Stop the test if the preamble failed
	TESTL(TestStepResult() == EPass);
	
	const TInt KTimeOut = 30*1000*1000;
	const TInt KAdviceSystemStatusTimeout = 40*1000*1000;
	const TInt KSmallTimeOut = 3*1000*1000; 
	
	// >> AdviceSystemStatus(0)
	TESTL(iProxy->WaitForResponse(KAdviceSystemStatusTimeout) == ENetMsgGetCurrentCapabilitiesResponse);
	CLbsNetworkProtocolBase::TLbsSystemStatus status;
	TInt cleanupCnt;
	cleanupCnt = iProxy->GetArgsLC(ENetMsgGetCurrentCapabilitiesResponse, &status);
	TESTL(status == CLbsNetworkProtocolBase::ESystemStatusNone);
	CleanupStack::PopAndDestroy(cleanupCnt);

//Initiate X3P start
	// TransmitPosition()
	_LIT(KThirdParty,"+4407463842101"); 
	const TInt KPriority= 6;
	TLbsTransmitPositionOptions options(TTimeIntervalMicroSeconds(50*1000*1000));
	TRequestStatus refPosStatus=KRequestPending;
	TRequestStatus transPosStatus=KRequestPending;
	TPositionInfo refPosInfo;
	TPositionInfo transPosInfo;
	iTransmitter.SetTransmitOptions(options);
	iTransmitter.TransmitPosition(KThirdParty, KPriority, refPosStatus, refPosInfo, transPosStatus, transPosInfo);
	
	// RequestTransmitLocation()
	TESTL(iProxy->WaitForResponse(KTimeOut) == ENetMsgRequestTransmitLocation);
	TBufC16<14> thirdParty(KThirdParty);
	TPtr16 ptr = thirdParty.Des(); 
	HBufC16* getThirdParty = NULL;
	TLbsNetSessionId* getSessionId = NULL;
	TInt getPriority(0);
	cleanupCnt = iProxy->GetArgsLC(ENetMsgRequestTransmitLocation, &getSessionId, &getThirdParty, &getPriority); 
	TESTL(ptr.Compare(*getThirdParty)==KErrNone);	
	TESTL(getPriority == KPriority);
	iSessionId = *getSessionId; //session ID is initialised by LBS
	CleanupStack::PopAndDestroy(cleanupCnt);

	// ProcessStatusUpdate()
	MLbsNetworkProtocolObserver::TLbsNetProtocolService service = MLbsNetworkProtocolObserver::EServiceTransmitThirdParty;		
	iProxy->CallL(ENetMsgProcessStatusUpdate, &service);
//End Initiate

//Reference Position Notification Start	
	// ProcessLocationUpdate()
	refPosInfo = ArgUtils::ReferencePositionInfo();
	iProxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, &refPosInfo);
//Reference Position Notification End

	
//Assistance Data Notification Start
	// ProcessAssistanceData()
	TLbsAsistanceDataGroup dataRequestMask = EAssistanceDataReferenceTime;
	RLbsAssistanceDataBuilderSet assistanceData;
	ArgUtils::PopulateLC(assistanceData);
	TInt reason = KErrNone;
	iProxy->CallL(ENetMsgProcessAssistanceData, &dataRequestMask, &assistanceData, &reason);
	CleanupStack::PopAndDestroy(1); //assistanceData
// Assistance Data Notification End
	
// Network Location Request Start
	// ProcessLocationRequest()
	const TBool emergency(EFalse);
	TLbsNetPosRequestQuality quality = ArgUtils::QualityAlpha2(); 
	TLbsNetPosRequestMethod method   = ArgUtils::RequestHybridMethod();	
	iProxy->CallL(ENetMsgProcessLocationRequest, &iSessionId, &emergency, &service, &quality, &method);
// Network Location Request Stop

	//Start the timer
	TTime timerStart;
	timerStart.HomeTime();
	
	// RequestAssistanceData(0)
	TESTL(iProxy->WaitForResponse(KSmallTimeOut) == ENetMsgRequestAssistanceData); 
	TLbsAsistanceDataGroup dataGroup;
	cleanupCnt = iProxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataGroup);
	TESTL(dataGroup == EAssistanceDataNone);
	CleanupStack::PopAndDestroy(cleanupCnt);

	// now wait for either to complete - but we will expect only the asynchrous request
	// waiting for the REF position to complete with KErrNone
	User::WaitForRequest(refPosStatus, transPosStatus); 
	TESTL(refPosStatus==KErrNone);
	TESTL(transPosStatus.Int() == KRequestPending);
	
	//Find the time elapsed from timer
	TTimeIntervalMicroSeconds microseconds;
 	TTime timerStop;
 	timerStop.HomeTime();
 	microseconds = timerStop.MicroSecondsFrom(timerStart); 
	TInt64 timeElapsed = microseconds.Int64();
						
/*** NRH's Alpha2 timer expires. We enter Hybrid mode.***/
	//Test that we do not get response before alpha2 has expired
	TESTL(iProxy->WaitForResponse(KAlpha2Timeout-timeElapsed-KDelta) == ENetMsgTimeoutExpired); 
	TESTL(iProxy->WaitForResponse(2*KDelta) == ENetMsgRespondLocationRequest); 	
	getSessionId = NULL;
	TInt getReason = KErrNone;
	TPositionSatelliteInfo* getPositionInfo = NULL;
	cleanupCnt = iProxy->GetArgsLC(ENetMsgRespondLocationRequest, &getSessionId, &getReason, &getPositionInfo);
	TESTL(getSessionId->SessionNum() == iSessionId.SessionNum());
	TESTL(getReason==KErrNone);
	CleanupStack::PopAndDestroy(cleanupCnt);

	// no need for looping, we assume that the next update location from GPS will give accurate fix
	quality = ArgUtils::Quality(); 
	iProxy->CallL(ENetMsgProcessLocationRequest, &iSessionId, &emergency, &service, &quality, &method);

	// RequestAssistanceData(0)
	TESTL(iProxy->WaitForResponse(KSmallTimeOut) == ENetMsgRequestAssistanceData); 
	cleanupCnt = iProxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataGroup);
	TESTL(dataGroup == EAssistanceDataNone);		
	CleanupStack::PopAndDestroy(cleanupCnt);
	
	//	GPS positions meets required accuracy. This is sent immediately to protocol module
	// The ini file should contain accurate gps fix for this test case to work
	TESTL(iProxy->WaitForResponse(KTTimeout) == ENetMsgRespondLocationRequest);	
	getSessionId = NULL;
	getReason = KErrNone;
	getPositionInfo = NULL;
	cleanupCnt = iProxy->GetArgsLC(ENetMsgRespondLocationRequest, &getSessionId, &getReason, &getPositionInfo);
	TESTL(getSessionId->SessionNum() == iSessionId.SessionNum());
	TESTL(getReason == KErrNone);
	// Test position is the same as in the ini file data fed to the GPS module
	// $update,1,2,51.5015,-0.105,50,2,3*
	TPosition gpsPos;
	getPositionInfo->GetPosition(gpsPos);
	TESTL(gpsPos.Latitude()==51.5015 && gpsPos.Longitude()==-0.105 && gpsPos.Altitude()==50 && gpsPos.HorizontalAccuracy()==2 && gpsPos.VerticalAccuracy()==3); 
	CleanupStack::PopAndDestroy(cleanupCnt);
				
// Network Result Notification Start
	// ProcessLocationUpdate()
	//Final Network Position is the GPS position
	TPositionInfo gpsPosInfo;
	gpsPosInfo.SetPosition(gpsPos);
	gpsPosInfo.SetUpdateType(EPositionUpdateGeneral);
	gpsPosInfo.SetPositionMode(TPositionModuleInfo::ETechnologyNetwork | TPositionModuleInfo::ETechnologyAssisted);
	gpsPosInfo.SetPositionModeReason(EPositionModeReasonNone);
	iProxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, &gpsPosInfo);
// Network Result Notification Stop
	
// Session Complete Start
	reason = KErrNone;
	iProxy->CallL(ENetMsgProcessSessionComplete, &iSessionId, &reason);
	MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask activeServiceMask = MLbsNetworkProtocolObserver::EServiceNone;
	iProxy->CallL(ENetMsgProcessStatusUpdate, &activeServiceMask);
// Session Complete Stop

	// the REF position request has completed, so now, after injecting the FNP and Session Complete
	// we expect that the other request to complete with KErrNone
	User::WaitForRequest(transPosStatus);
 
	TESTL(transPosStatus==KErrNone);
	return TestStepResult();
	}
/* Called when one of the stub PM's receives a message from the NG
 *
 * @param aPmId The ID of the PM that received this message
 * @param aMessageType The ID of the message type received from the PM
 */
void CT_LbsHybridMultipleTest::OnHandleNGMessage(TUint aPmId, TInt aMessageType)
{
    //Get the correct proxy
    CLbsTestNgMessageHandler* proxy = LookupProtocolModuleProxy(aPmId);
    if (!proxy)
    {
        INFO_PRINTF2(_L("ERROR: No NG proxy setup for PM%d"), aPmId);
        User::Leave(KErrNotFound);
    }

    TInt cleanupCnt;
    TInt sequenceId = KErrNotFound;

    //For each of the different message types, find out whether the message type was expected by the
    // sequence (if a session Id is sent with the message) or by any sequence (if the session Id is not
    // present).  Then confirm the message parameters are expected and then move the correct sequence
    // onto the next message.
    switch(aMessageType)
    {
    // >> AdviceSystemStatus() [2009]
    case ENetMsgGetCurrentCapabilitiesResponse:
    {
        sequenceId = WasMessageExpectedPmId(aPmId, ENetMsgGetCurrentCapabilitiesResponse);
        INFO_PRINTF2(_L("-> AdviceSystemStatus() [2009] Sq: %d"), sequenceId);

        if(sequenceId != KErrNotFound)
        {
            CLbsNetworkProtocolBase::TLbsSystemStatus status;
            cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgGetCurrentCapabilitiesResponse, &status);
            TESTL(status == CLbsNetworkProtocolBase::ESystemStatusNone);
            CleanupStack::PopAndDestroy(cleanupCnt);
        }

        break;
    }

    // >> RespondPrivacyRequest() [2000]
    case ENetMsgRespondPrivacyRequest:
    {
        TLbsNetSessionId* getSessionId = NULL;
        CLbsNetworkProtocolBase::TLbsPrivacyResponse getPrivacy;
        cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgRespondPrivacyRequest, &getSessionId, &getPrivacy);

        sequenceId = WasMessageExpectedSessionId(getSessionId->SessionNum(), ENetMsgRespondPrivacyRequest);
        INFO_PRINTF3(_L("-> RespondPrivacyRequest(%d) [2000] Sq: %d"), getPrivacy, sequenceId);

        if(sequenceId != KErrNotFound)
        {
            iSequences[sequenceId]->CheckRespondPrivacyRequest(getPrivacy);
        }
        CleanupStack::PopAndDestroy(cleanupCnt);//getSessionId

        break;
    }

    // >> RequestAssistanceData() [2004]
    case ENetMsgRequestAssistanceData:
    {
        sequenceId = WasMessageExpectedPmId(aPmId, ENetMsgRequestAssistanceData);

        //Request Assistance Data is a special case.  Depending upon the timing of when the messages
        // will be sent/received, it is not possible to predict in advance whether this message will
        // always arrive in some of the later sequences.  As such, a RequestAssistanceData message can
        // arrive and even if it is not expected by any of the sequences, it will not fail the test.

        if(sequenceId != KErrNotFound)
        {
            INFO_PRINTF2(_L("-> RequestAssistanceData() [2004] Sq: %d"), sequenceId);
            TLbsAsistanceDataGroup dataGroup;
            cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgRequestAssistanceData, &dataGroup);
            CleanupStack::PopAndDestroy(cleanupCnt);
        }
        else
        {
            //Message was not expected by any sequence.  Manually set the Net Proxy off listening
            // again, so the sequence can receive the message it expected.
            INFO_PRINTF2(_L("-> RequestAssistanceData() [2004] Sq: unknown, PM: %d"), aPmId);
            proxy->WaitForResponseL(80 * 1000 * 1000);

            //Break out of the function now
            return;
        }

        break;
    }

    // >> ResponsdLocationRequest() [2001]
    case ENetMsgRespondLocationRequest:
    {
        TLbsNetSessionId* getSessionId = NULL;
        getSessionId = NULL;
        TInt getReason = KErrNone;
        TPositionSatelliteInfo* getPositionInfo = NULL;
        cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgRespondLocationRequest, &getSessionId, &getReason, &getPositionInfo);
        sequenceId = WasMessageExpectedSessionId(getSessionId->SessionNum(), ENetMsgRespondLocationRequest);
        INFO_PRINTF3(_L("-> RespondLocationRequest(%d) [2001] Sq: %d"), getReason, sequenceId);
        CleanupStack::PopAndDestroy(cleanupCnt);
        break;
    }

    // >> RequestSelfLocation() [2005]
    case ENetMsgRequestSelfLocation:
    {
        TLbsNetSessionId* sessionId = NULL;
        TLbsNetPosRequestOptionsAssistance*	opts = NULL;
        cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgRequestSelfLocation, &sessionId, &opts);

        sequenceId = WasMessageExpectedPmId(aPmId, ENetMsgRequestSelfLocation);
        INFO_PRINTF2(_L("-> RequestSelfLocation() [2005] Sq: %d"), sequenceId);

        if(sequenceId != KErrNotFound)
        {
            iSequences[sequenceId]->CheckSelfLocationRequest(sessionId);
        }

        CleanupStack::PopAndDestroy(cleanupCnt);
        break;
    }

    // >> CancelSelfLocation() [2006]
    case ENetMsgCancelSelfLocation:
    {
        TLbsNetSessionId* sessionId = NULL;
        TInt reason = 0;
        cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgCancelSelfLocation, &sessionId, &reason);

        sequenceId = WasMessageExpectedSessionId(sessionId->SessionNum(), ENetMsgRequestSelfLocation);
        INFO_PRINTF2(_L("-> CancelSelfLocation() [2006] Sq: %d"), sequenceId);

        CleanupStack::PopAndDestroy(cleanupCnt);

        break;
    }

    // >> RequestTransmitLocation() [2002]
    case ENetMsgRequestTransmitLocation:
    {
        HBufC16* getThirdParty = NULL;
        TLbsNetSessionId* getSessionId = NULL;
        TInt getPriority(0);
        TInt cleanupCnt;
        cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgRequestTransmitLocation, &getSessionId, &getThirdParty, &getPriority);

        sequenceId = WasMessageExpectedPmId(aPmId, ENetMsgRequestTransmitLocation);
        INFO_PRINTF2(_L("-> RequestTransmitLocation() [2002] Sq: %d"), sequenceId);

        if(sequenceId != KErrNotFound)
        {
            iSequences[sequenceId]->CheckRequestTransmitLocation(getSessionId, getPriority, *getThirdParty);
        }

        CleanupStack::PopAndDestroy(cleanupCnt);
        break;
    }

    // >> CancelTransmitLocation() [2003]
    case ENetMsgCancelTransmitLocation:
    {
        TLbsNetSessionId* sessionId = NULL;
        TInt reason = 0;

        cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgCancelTransmitLocation, &sessionId, &reason);

        sequenceId = WasMessageExpectedSessionId(sessionId->SessionNum(), ENetMsgCancelTransmitLocation);
        INFO_PRINTF2(_L("-> CancelTransmitLocation() [2003] Sq: %d"), sequenceId);

        CleanupStack::PopAndDestroy(cleanupCnt);

        break;
    }

    // >> RequestNetworkLocation() [2007]
    case ENetMsgRequestNetworkLocation:
    {
        TLbsNetSessionId* sessionId = NULL;
        TLbsNetPosRequestOptionsAssistance* opts = NULL;
        cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgRequestNetworkLocation, &sessionId, &opts);

        sequenceId = WasMessageExpectedPmId(aPmId, ENetMsgRequestNetworkLocation);

        INFO_PRINTF2(_L("-> RequestNetworkLocation() [2007] Sq: %d"), sequenceId);

        if(sequenceId != KErrNotFound)
        {
            iSequences[sequenceId]->CheckNetworkLocationRequest(sessionId);
        }

        break;
    }

    // >> CancelNetworkLocation [2008]
    case ENetMsgCancelNetworkLocation:
    {
        sequenceId = WasMessageExpectedPmId(aPmId, ENetMsgCancelNetworkLocation);

        INFO_PRINTF2(_L("-> CancelNetworkLocation() [2008] Sq: %d"), sequenceId);

        //NOTE: Currently no handling implemented for this message type

        break;
    }

    // Timeout occurred waiting for a NG Message
    case -1000:
    {
        INFO_PRINTF2(_L("Error - Timeout occurred waiting for NG message on PM: %d"), aPmId);
        break;
    }

    //Error occurred, not a recognised message.  Fail the test.
    default:
    {
        INFO_PRINTF3(_L("Error - Received invalid NG message: %d on PM: %d"), aMessageType, aPmId);
        return StopTest(KErrArgument);
    }
    }

    //If the message was expected, continue the test
    if(sequenceId != KErrNotFound)
    {
        iSequences[sequenceId]->SignalCallbackIdleStart();
    }
    else
    {
        // when an unexpected message arrives merley ignore and wait for next one!
        proxy->WaitForResponseL(80 * 1000 * 1000);
    }
}
示例#5
0
void CTR::execRP_RSCT()
{
	BUS::glbl_READ_BUS = 034 + getPriority();
}
示例#6
0
void CTR::execWP_WPCTR()
{
	register_PSEQ.write(getSubseq());
	register_PCELL.write(getPriority());
}
Token exprEvaluate(vector<Token> tokens) {
    vector<Token> round1;
    /* round 1: check which tokens are unary add or unary sub */
    for(int i = 0; i < tokens.size(); ++i) {
        if(tokens[i].getIndex() == sub) {
            if(round1.size() == 0 || (round1.back().getIndex() != num && round1.back().getIndex() != bracket_r)) {
                round1.push_back(Token(unary_sub, "-"));
            }
            else {
                round1.push_back(tokens[i]);
            }
        }
        else if(tokens[i].getIndex() == add) {
            if(round1.size() == 0 || (round1.back().getIndex() != num && round1.back().getIndex() != bracket_r)) {
                round1.push_back(Token(unary_add, "+"));
            }
            else {
                round1.push_back(tokens[i]);
            }
        }
        else {
            round1.push_back(tokens[i]);
        }
    }
    vector<Token> postfixExpr;
    stack<Token> temp;
    /* transform the expression to postfix form */
    for(int i = 0; i < round1.size(); ++i) {
        if(round1[i].getIndex() == num) {
            postfixExpr.push_back(round1[i]);
        }
        else if(round1[i].getIndex() == bracket_l || temp.empty()) {
            temp.push(round1[i]);
        }
        else if(round1[i].getIndex() == bracket_r) {
            while(!temp.empty()) {
                if(temp.top().getIndex() == bracket_l) {
                    temp.pop();
                    break;
                }
                postfixExpr.push_back(temp.top());
                temp.pop();
            }
        }
        else {
            bool flag = false;
            while(!temp.empty()) {
                if(temp.top().getIndex() == bracket_l || getPriority(round1[i].getIndex()) > getPriority(temp.top().getIndex())) {
                    temp.push(round1[i]);
                    flag = true;
                    break;
                }
                else {
                    postfixExpr.push_back(temp.top());
                    temp.pop();
                }
            }
            if(!flag) {
                temp.push(round1[i]);
            }
        }
    }
    while(!temp.empty()) {
        postfixExpr.push_back(temp.top());
        temp.pop();
    }
    Token num1, num2, result;
    /* evaluate the postfix expression using a stack */
    for(int i = 0; i < postfixExpr.size(); ++i) {
        if(postfixExpr[i].getIndex() == num || postfixExpr[i].getIndex() == _bool) {
            temp.push(postfixExpr[i]);
        }
        else if(isLogicToken(postfixExpr[i].getIndex())) {
            num1 = temp.top();
            temp.pop();
            if(postfixExpr[i].getIndex() == _not) {
                result = evaluate(Token(dollar, ""), num1, _not);
            }
            else {
                num2 = temp.top();
                temp.pop();
                result = evaluate(num1, num2, postfixExpr[i].getIndex());
            }
            temp.push(result);
        }
        else if(postfixExpr[i].getIndex() == unary_add || postfixExpr[i].getIndex() == unary_sub) {
            num1 = temp.top();
            temp.pop();
            result = evaluate(Token(dollar, ""), num1, postfixExpr[i].getIndex());
            temp.push(result);
        }
        else {
            num1 = temp.top();
            temp.pop();
            num2 = temp.top();
            temp.pop();
            result = evaluate(num1, num2, postfixExpr[i].getIndex());
            if(result.getIndex() == dollar) {
                return result;
            }
            temp.push(result);
        }
    }
    return temp.top();
}