Return to CalcEngine.C CVS log

Up to [NeXTSTEP 3.3 examples] / Examples / AppKit / CalculatorLab++

Annotation of Examples/AppKit/CalculatorLab++/CalcEngine.C, revision 1.1

1.1     ! root        1: //
        !             2: //     CalcEngine -- mem
        !             3: //     A general C++ class that directly supports a calculator interface
        !             4: //
        !             5: //     You may freely copy, distribute and reuse the code in this example.
        !             6: //     NeXT disclaims any warranty of any kind, expressed or implied, as to
        !             7: //     its fitness for any particular use.
        !             8: //
        !             9: //     Created 8-21-90
        !            10: //
        !            11: extern "Objective-C"
        !            12: {
        !            13: #import <objc/error.h>
        !            14: }
        !            15: 
        !            16: #import "CalcEngine.h"
        !            17: 
        !            18: // Create an instance of the class and initialize flags for start-up
        !            19: CalcEngine::CalcEngine()
        !            20: {      
        !            21:     //the buffer that holds the first number entered
        !            22:     accumulator = 0;
        !            23:        
        !            24:     //the current operator
        !            25:     op = 0;
        !            26: }
        !            27: 
        !            28: // Clear the state of the calculator engine.
        !            29: void CalcEngine::clear()
        !            30: {
        !            31:     setOperation(0);
        !            32:     accumulator = 0;
        !            33: }
        !            34: 
        !            35: // Set the current operation (+ - * / ),  0 is no operation.
        !            36: void CalcEngine::setOperation(int whichOp)
        !            37: {
        !            38:     op = whichOp;
        !            39: }
        !            40: 
        !            41: // Called when one of the operation keys is pressed.
        !            42: double CalcEngine::operationKeys(int whichOp, double firstNum)
        !            43: {
        !            44:     double result;
        !            45: 
        !            46:     switch(whichOp){
        !            47:        case DIVIDE:            // Indicates a series of numbers and
        !            48:        case MULTIPLY:          // operations.  For example: 1 + 2 + 3 + ...
        !            49:        case SUBTRACT:
        !            50:        case ADD:
        !            51:        {
        !            52:            if (op)
        !            53:                result = equalsKey(firstNum);
        !            54:            else
        !            55:                result = firstNum;
        !            56:            setOperation(whichOp);
        !            57:            accumulator = result;
        !            58:            break;
        !            59:        }
        !            60:        default:                // Indicates first number has just been
        !            61:        {                       // entered.
        !            62:            result = 0;
        !            63:            break;
        !            64:        }
        !            65:     }
        !            66:     return result;
        !            67: }
        !            68: 
        !            69: // Do the actual calculation.  This is called when the equals key is pressed or
        !            70: // when an operation key is pressed in a series of numbers.
        !            71: double CalcEngine::equalsKey(double secondNum)
        !            72: {
        !            73:     double result;
        !            74: 
        !            75:     switch(op){
        !            76:        case DIVIDE:
        !            77:        {
        !            78:            if(secondNum == 0) {
        !            79:                clear();
        !            80:                NX_RAISE(0, "divideByZero", 0);
        !            81:            }
        !            82:            result = accumulator / secondNum;
        !            83:            break;
        !            84:        }
        !            85:        case MULTIPLY:
        !            86:        {
        !            87:            result = accumulator * secondNum;
        !            88:            break;
        !            89:        }
        !            90:        case SUBTRACT:
        !            91:        {
        !            92:            result = accumulator - secondNum;
        !            93:            break;
        !            94:        }
        !            95:        case ADD:
        !            96:        {
        !            97:            result = accumulator + secondNum;
        !            98:            break;
        !            99:        }
        !           100:        default:{
        !           101:            result = secondNum;
        !           102:            break;
        !           103:        }
        !           104:     }
        !           105:     clear();
        !           106:     return result;
        !           107: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.