engine.cpp

嵌入式Qt下的一个计算器源码

    }

    if (!dStack.isEmpty())
	dStack.top()->clear();
    state = sAppend;

    if (dStack.count() == 1 && !iStack.count())
	changeResetState(drNone);
    else
	changeResetState(drHard);
    emit(stackChanged());
}
void Engine::hardReset() {
    while (!dStack.isEmpty())
        delete dStack.pop();
    dStack.clear();
    while (!iStack.isEmpty())
        delete iStack.pop();
    iStack.clear();
    braceCount = 0;
    if (recoveredDStack) {
        delete recoveredDStack;
        recoveredDStack = 0;
    }
    softReset();
    changeResetState(drNone);
}

// Input and output
void Engine::pushInstruction(QString name) {
    if (!checkState())
	return;

    Instruction *i = resolve(name);
    previousInstructionsPrecedence = i->precedence;

    // Immediate instructions
    if (!i->precedence) {
	executeInstructionOnStack(i);
	emit(stackChanged());
	return;
    }

    // Overwrite last instruction
    if (!iStack.isEmpty()
	    && state == sStart
	    && i->precedence
	    && previousInstructionsPrecedence) {
	if ("Open brace impl" == *(iStack.top())) { // No tr
	    executeInstructionOnStack("Factory"); // No tr
	} else {
	    delete iStack.pop();
	}
    }

    // Evaluate previous high-precedence instructions
    if (!iStack.isEmpty()) {
	Instruction *top = resolve(*(iStack.top()));
	if (i->precedence <= top->precedence)
	    doEvalStack(top->precedence);
    }

    // Push instruction onto stack
    if (state != sError) {
	iStack.push(new QString(name));
	changeState(sStart);
    }
    emit(stackChanged());
}

void Engine::push(char c) {
    if (!checkState())
	return;
    if (state == sStart) {
	executeInstructionOnStack("Copy"); // No tr
	if (!checkState()) {
	    setError("Failed to copy some data"); // No tr
	    return;
	}
	dStack.top()->clear();
	if (!dStack.top()->push(c, false)) {
	    delete dStack.pop();
	    return;
	}
	dStack.top()->clear();
	changeState(sAppend);
    } else {
        
#ifdef QTOPIA_PHONE
	if (!Qtopia::mousePreferred() && !iStack.isEmpty() && *iStack.top() == "EvaluateLine") // No tr
	    hardReset();
	else
#endif
	changeResetState(drSoft);
	if (!dStack.top()->push(c, false)) {
            return;
        }
    }

    dStack.top()->push(c);
    emit(stackChanged());
}
void Engine::push(QString s) {
    if (state == sAppend && dStack.count() >= 1)
            dStack.top()->clear();
    for (int i=0;i < s.length();i++)
	push(s[(int)i].toLatin1());
}
void Engine::delChar() {
    if (!checkState())
	return;
    if (state == sStart) {
	if (iStack.isEmpty())
	    return;
	if (*iStack.top() != "Open brace impl") // No tr
	    changeState(sAppend);
	delete iStack.pop();
    } 
    else if (state == sAppend) {
	if(dStack.top()->del()) {
	    if (dStack.count() == 1) {
		hardReset();
	    } else if (dStack.count() > 1) {
		delete dStack.pop();
                if (iStack.count() >= 1) {
		    if (*iStack.top() == "EvaluateLine" || 
                            *iStack.top() != "Open brace impl") {
		        changeState(sAppend);
                    } else {
                        changeState(sStart);
                    }
		    delete iStack.pop();
		} else {
		    changeState(sStart);
		}
	    }
	}
    }
    emit(stackChanged());
}
bool Engine::checkState() {
    if (state == sError)
	return false;
    if (dStack.isEmpty())
	executeInstructionOnStack("Factory"); // No tr
    if (dStack.isEmpty()) {
	setError(eNoDataFactory);
	return false;
    }
    if (currentType == "NULL")
	return false;
    if (state == sError)
	return false;
    return true;
}
Data *Engine::getData() {
#ifdef QTOPIA_PHONE
    if (!Qtopia::mousePreferred()) {
        executeInstructionOnStack("Copy"); // No tr
        tmpDStack.push(dStack.pop());
    }
#endif
    return dStack.pop();
}
void Engine::putData(Data *d) {
    dStack.push(d);
}

// Memory
void Engine::memorySave() {
    if (!checkState())
	return;

    //save previous data on stack
    executeInstructionOnStack("Copy"); // No tr
    if (mem) {
	dStack.push(mem);
	executeInstructionOnStack("Add"); // No tr
    }
    if (state != sError)
	mem = dStack.pop();

    executeInstructionOnStack("Factory"); // No tr
    if (mem->getFormattedOutput() != dStack.top()->getFormattedOutput()) {
	memMark->show();
    } else {
	delete mem;
	mem = 0;
	memMark->hide();
    }
    delete dStack.pop();

    qApp->processEvents();
}
void Engine::memoryRecall() {
    if (!checkState())
	return;

    if (state == sAppend)
	delete dStack.pop();

    if ( mem ) {
        dStack.push(mem);
        //memory may have different data type
        if (currentType != mem->getType()) {
            wantedType = currentType;
            currentType = mem->getType();
            executeInstructionOnStack("Convert");
            currentType = wantedType;
        }

        executeInstructionOnStack("Copy"); // No tr
        if (!checkState())
	    return;
        mem = dStack.pop();
    }
    else 
        executeInstructionOnStack("Factory"); // No tr

    changeState(sAppend);
    emit(stackChanged());
}
void Engine::memoryReset() {
    if (mem) {
	delete mem;
	mem = 0;
    }
    memMark->hide();
}

void Engine::setError(Error e, bool resetStack){
    QString s;
    switch (e) {
	case eNotANumber:
	    s = qApp->translate("Engine",
		    "Not a number");
	    break;
	case eNegInf:
	    s = qApp->translate("Engine",
		    "Negative infinity");
	    break;
	case eInf:
	    s = qApp->translate("Engine",
		    "Infinity");
	    break;
	case eNonPositive:
	    s = qApp->translate("Engine",
		    "Input is not a positive number");
	    break;
	case eNonInteger:
	    s = qApp->translate("Engine",
		    "Not an integer");
	    break;
	case eOutOfRange:
	    s = qApp->translate("Engine",
		    "Out of range");
	    break;
	case eDivZero:
	    s = qApp->translate("Engine",
		    "Divide by zero error");
	    break;
	case eNotSolvable:
	    s = qApp->translate("Engine",
		    "Not solvable");
	    break;
	case eNoDataFactory:
	    s = qApp->translate("Engine",
		    "No data factory found");
	case eSurpassLimits:
	    s = qApp->translate("Engine",
		    "Calc surpasses limit");
	case eError:
	default:
	    // let setError(QString) pick it up
	    break;
    }
    setError(s, resetStack);
}
void Engine::setError(QString s, bool resetStack) {
    if (s.isEmpty())
	s = qApp->translate("Engine","Error");
    if (!resetStack) {
        recoveredDStack = getData();
        putData(recoveredDStack);
    }
    
    changeState(sError);
    errorString = s;
    emit(stackChanged());
}
void Engine::setDisplay(MyLcdDisplay *l) {
    lcd = l;

    memMark = new QLabel( "m", lcd );
    memMark->setBackgroundRole( QPalette::Base );
    memMark->setFont( QFont( "helvetica", 12, QFont::Bold, true ) );
    memMark->resize( 12, 12 );
    memMark->move( 4, 2 );
    memMark->hide();

    kMark = new QLabel( "k", lcd );
    kMark->setBackgroundRole( QPalette::Base );
    kMark->setFont( QFont( "helvetica", 12, QFont::Bold, true ) );
    kMark->resize( 12, 12 );
    kMark->move( 4, 14 );
    kMark->hide();
}

void Engine::executeInstructionOnStack(QString name) {
    executeInstructionOnStack(resolve(name));
}
void Engine::executeInstructionOnStack(Instruction *i) {
    if (i->name == "Factory") { // No tr
	i->eval();
	return;
    }

    while (dStack.count() < i->argCount)
	executeInstructionOnStack("Factory"); // No tr

    if (state != sError)
	i->eval();
}
void Engine::setAccType(QString type) {
    if (currentType != type || recoveredDStack) {
	if (dStack.isEmpty()) {
	    currentType = type;
	    executeInstructionOnStack("Factory"); // No tr
	    state = sAppend;
	} else {
            if (recoveredDStack) {
                //don't call dualReset() or recoveredDStack will be deleted
                dStack.clear();
                iStack.clear();
                braceCount = 0;
                softReset();
                changeResetState(drNone);
                putData(recoveredDStack);
            }
	    wantedType = type;

            if (currentType == "NONE") // workaround for bug #3356
                currentType = dStack.top()->getType();
           
            if (currentType != wantedType) {
                if (!recoveredDStack) 
                    executeInstructionOnStack("Convert"); // No tr
                else  // don't convert recoveredStack
                    recoveredDStack = 0;
            }
	}
	// Doublecheck the type in case a factory or convert doesnt go as planned.
	currentType = dStack.top()->getType();
	emit(stackChanged());
    }
    changeResetState(drs);
}
QString Engine::getDisplay() {
    return dStack.top()->getFormattedOutput();
}

void Engine::changeState(State s) {
    switch (s) {
	case sStart:
	case sAppend:
	    changeResetState(drSoft);
	    break;
	case sError:
	    changeResetState(drHard);
	    break;
    }
    state = s;
}
void Engine::changeResetState(ResetState s) {
    emit(dualResetStateChanged(s));
    drs = s;
}
void Engine::incBraceCount() {
    if (systemEngine->state == sAppend)
        systemEngine->iStack.push(new QString("Multiply")); // No tr
    systemEngine->iStack.push(new QString("Open brace impl")); // No tr
    braceCount++;
}

#ifdef QTOPIA_PHONE
bool Engine::error(){
    if ( state == sError )
        return true;
    return false;
}

int Engine::numOps(){
    return dStack.count();
}

#endif