Almetare 1.20
Alle meine Taschenrechner - Eine C++-Bibliothek zur Entwicklung von Taschenrechnern
calculator.h
gehe zur Dokumentation dieser Datei
1//******************************************************************************
2// Copyright (c) 2002-2004 by Friedemann Seebass, Germany.
3// Dieses Programm ist freie Software. Siehe GNU GPL Notiz in Datei main.cpp.
4// This program is free software. See the GNU GPL notice in file main.cpp.
5// Projekt: Almetare - Alle meine Taschenrechner
6//******************************************************************************
9//******************************************************************************
10// Wann Wer Was
11// ---------- -------- ---------------------------------------------------------
12// 31.03.2003 fse neue Funktion getAllSyms()
13// 25.03.2003 fse neue virtuelle Funktion Computer::aftProcess2()
14// 16.03.2003 fse Konstruktor Calculator mit Argument argc
15// 01.03.2003 fse Bugfix in CalculatorBase
16// 01.09.2001 fse erzeugt
17//******************************************************************************
18
19#ifndef CALCULATOR_H
20#define CALCULATOR_H
21
22#ifndef __cplusplus
23#error calculator.h is only for C++!
24#endif
25
26//******************************************************************************
27
28#include <string>
29#include <map>
30#include "stack.h"
31#include "symbols.h"
32#include "cfgs.h"
33
34using namespace std;
35
36//******************************************************************************
37
38class Symbol;
39class Calculator;
40class SymOperator;
41class Number;
42
45typedef list<NumStack> NumStackList;
46typedef list<SymStack> SymStackList;
47typedef map<string, Symbol*> SymTabT;
48typedef SymTabT::iterator SymTabIT;
49
50//******************************************************************************
51// Klasse Error:
52//******************************************************************************
53
54enum ErrId { OK, SYM_EXP, OP_EXP, TWO_OPS_EXP };
55enum { NO_PARAM = 9999 };
56
60
61class Error
62{
63 ErrId mErrId;
64public:
65 Error(ErrId id = OK) : mErrId(id) {}
66 void set(ErrId id) { mErrId = id; }
67 friend ostream& operator<<(ostream& os, const Error& e);
68};
69
70//******************************************************************************
71// Klasse Computer:
72//******************************************************************************
73
83
85{
86protected:
98 int mBraLev;
102 int mParam;
105
107 virtual void handleEmptyNumStack(Number& a, SymOperator* soP, Number& b);
108
109public:
110 // Initialisierung:
111 ComputerBase();
112 virtual ~ComputerBase();
113 void createSymTabBase();
114 void showSymTab();
115 void initStacks();
116 void initMembers(bool clrMem = true);
117 void clearNum() { mNumStackList.back().clear(); }
118 // Zugriff:
119 Number getConstVal () const { return mConstVal ; }
120 Number getPrcWhole () const { return mPrcWhole ; }
121 Number getMemory () const { return mMemory ; }
122 int getBraLev () const { return mBraLev ; }
123 int getParam () const { return mParam ; }
124 SymOperator* getConstOpP () const { return mConstOpP ; }
125 SymOperator* getLastOpP () const { return mLastOpP ; }
126 SymOperator* getLastButOneOpP() const { return mLastButOneOpP; }
127 Symbol* getLastInP () const { return mLastInP ; }
128 Symbol* getLastButOneInP() const { return mLastButOneInP; }
129 Symbol* getSymP(const string& sym) { return mSymTab[sym]; }
130 void setDsplP (DisplayBase* dsplP) { mDsplP = dsplP; }
131 void setConstVal(const Number& val) { mConstVal = val; }
132 void setPrcWhole(const Number& val) { mPrcWhole = val; }
133 void setMemory (const Number& val) { mMemory = val; }
134 void setParam (const int val) { mParam = val; }
135 void setLastOpP (SymOperator* soP);
136 void setConstOpP(SymOperator* soP) { mConstOpP = soP; }
137 void setLastInPisNotToSet(bool is ) { mLastInPisNotToSet = is; }
138 void setLastInP (Symbol* sP );
139 void setIsToInit(bool in ) { mIsToInit = in; }
140 // Stack-Manipulation:
141 void pushNewStacks();
142 void popStacks();
143 void pushNum(const Number& n) { mNumStackList.back().push(n); }
144 void pushSym(SymOperator* sP) { mSymStackList.back().push(sP ); }
145 Number getTopButOneNum() { return mNumStackList.back().getTopButOne(); }
146 void setTopButOneNum(const Number& n) { mNumStackList.back().setTopButOne(n); }
147 bool isNumEmpty() { return mNumStackList.back().empty(); }
148 bool isSymEmpty() { return mSymStackList.back().empty(); }
149 Number popNum() { return mNumStackList.back().pop (); }
150 Number topNum() { return mNumStackList.back().top (); }
151 SymOperator* popSym() { return mSymStackList.back().pop (); }
152 SymOperator* topSym() { return mSymStackList.back().top (); }
153 // Sonstiges:
154 void incBraLev() { ++mBraLev; }
155 void decBraLev() { --mBraLev; }
156 void printSymHelp();
157 string getAllSyms();
158 bool isSym(const string& sym);
159 Error compute();
160 Error swapNum();
161 string extractParam(string& in);
162 string makeCompBaseInfoStr();
163
164 virtual bool preProcess (string& in) { in = in; return false; }
165 virtual void aftProcess (string& in) { in = in; }
166 virtual void aftProcess2(string& in) { in = in; }
168 virtual void handleDisplayAfterBra();
169 virtual void handlePercent();
170 virtual void popNumDepOnLastSym() { (void)popNumDepOnLastSymBase(); }
171 virtual bool map(string& sym) { sym = sym; return false; }
172 virtual string makeCompInfoStr() { return makeCompBaseInfoStr(); }
173
174 friend ostream& operator<<(ostream& os, ComputerBase& c);
175};
176
177//******************************************************************************
178// Klasse DisplayBase:
179//******************************************************************************
180
188
190{
191protected:
193 string mValue;
194 string mSeven;
195 string mSevenRaw;
196 string mMem;
197 string mK;
198 string mModes;
199 // Casio fx-3600P: "ON INV M K LRN Idx LR SD DEG RAD GRA"
200 // Casio fx-85v : " s m M K hyp SD LR DEG RAD GRA FIX SCI"
202
203 void setModesBase();
204public:
206 virtual ~DisplayBase() {}
207 // Zugriff:
208 string getValue () const { return mValue ; }
209 string getSeven () const { return mSeven ; }
210 string getSevenRaw() const { return mSevenRaw; }
211 string getModes () const { return mModes ; }
212 Number getVal () const { return mVal ; }
213 void setMem (bool isOn) { if (isOn) mMem = "M"; else mMem = "."; }
214 void setK (bool isOn) { if (isOn) mK = "K"; else mK = "." ; }
215 void setCompP(ComputerBase* cP) { mCompP = cP ; }
216 void setVal (const Number& val ) { mVal = val ; makeValue(); }
217 void setValue(const string& value) { mValue = value; }
218 void setSeven(const string& seven) { mSeven = seven; }
219 // Sonstiges:
220 void makeDisplay(const Number& val);
221 void makeDisplay();
222 bool isError();
223 void setError() { mValue = "nan"; }
224 virtual void setModes();
225 virtual void makeValue() { mValue = mVal.makeStr(0, 15); }
226 virtual void makeSeven(string displayStr = "");
227 virtual int getNumStrLen(string dsplStr) const { return dsplStr.size(); }
228 friend ostream& operator<<(ostream& os, const DisplayBase* dbP);
229};
230
231//******************************************************************************
232// Klasse CalculatorBase:
233//******************************************************************************
234
241// fse, 06.10.01
242// fse, 01.03.03: Konstruktor bekommt argv als Argument
243
245{
246protected:
247 string mProgName;
248 string mProgPath;
249 string mProgVers;
250 string mHomeDir;
251 string mAccPath;
257public:
258 CalculatorBase(int argc, char** argv);
260 // Zugriff:
261 ComputerBase* getComputerP() const { return mComputerP; }
262 DisplayBase * getDisplayP () const { return mDisplayP ; }
263 Cfgs* getCfgsP () const { return mCfgsP ; }
264 string getProgName () const { return mProgName ; }
265 string getProgVers () const { return mProgVers ; }
266 string getAccPath () const { return mAccPath ; }
267 bool getIsDlgApp () const { return mIsDlgApp ; }
268 // Sonstiges:
269 double calculate();
270 void process(string in);
271 string getTitle();
272 string getNextSym(string& expr) const;
273 bool isError() const { return mDisplayP->isError(); }
274 int getNumStrLen(string dsplStr) { return mDisplayP->getNumStrLen(dsplStr); }
275};
276
277
278//******************************************************************************
279//************************************** ***************************************
280//************************* ************************* **************************
281
282#endif // !CALCULATOR_H
283
Stack< Number > NumStack
Stack fuer Zahlen.
Definition: calculator.h:43
list< SymStack > SymStackList
Liste von Symbol-Stacks.
Definition: calculator.h:46
map< string, Symbol * > SymTabT
Symboltabelle.
Definition: calculator.h:47
SymTabT::iterator SymTabIT
Iterator fuer die Symboltabelle.
Definition: calculator.h:48
Stack< SymOperator * > SymStack
Stack fuer Symbole.
Definition: calculator.h:44
list< NumStack > NumStackList
Liste von Zahlen-Stacks.
Definition: calculator.h:45
Klasse mit allen Parametern, die in der Konfigurationsdatei stehen (Modul base)
Basisklasse aller Taschenrechner.
Definition: calculator.h:245
string mHomeDir
Home-Verzeichnis des Users (falls Linux)
Definition: calculator.h:250
ComputerBase * mComputerP
Zeiger auf den Computer.
Definition: calculator.h:253
string mProgName
z.B. "TI-30", "Casio fx-85v", ...
Definition: calculator.h:247
string mProgPath
Pfad, unter dem das Binary liegt.
Definition: calculator.h:248
string mAccPath
Zubehoer-Ordner.
Definition: calculator.h:251
double calculate()
Uebernimmt bei der Konsolenversion die Steuerung der Eingabe und Berechnung und Ausgabe der Werte.
Definition: calculator.cpp:789
string mProgVers
Programmversion zwecks Vrgl. in Ini-Datei.
Definition: calculator.h:249
DisplayBase * mDisplayP
Zeiger auf die Anzeige.
Definition: calculator.h:254
void process(string in)
Verarbeitet ein einzelnes Symbol.
Definition: calculator.cpp:857
CalculatorBase(int argc, char **argv)
Konstruktor tut eigentlich nichts, da die Konstruktion von den abgeleiteten Klassen uebernommen wird.
Definition: calculator.cpp:693
bool mIsDlgApp
als Konsolen- oder Dialogapplik. gestartet?
Definition: calculator.h:256
Cfgs * mCfgsP
Zeiger auf die Konfigurationsdaten.
Definition: calculator.h:255
string getTitle()
Erzeugt fuer die Konsolenversion einen String mit einem Titelbild.
Definition: calculator.cpp:756
~CalculatorBase()
Destruktor raeumt die Objekte auf, die von den abgeleiteten Calculatoren angelegt wurden,...
Definition: calculator.cpp:741
string getNextSym(string &expr) const
Holt aus dem String expr das erste Symbol.
Definition: calculator.cpp:829
string mIniFileName
Name der Initialisierungsdatei (ohne Pfad)
Definition: calculator.h:252
Anzeigeart des Rechners.
Definition: cfgs.h:48
Basisklasse aller Computer.
Definition: calculator.h:85
Error compute()
Berechnet den letzten Operator auf dem Symbol-Stack.
Definition: calculator.cpp:502
ComputerBase()
Konstruktor erzeugt Symboltabelle, initialisiert Symbol- und Nummern-Stack.
Definition: calculator.cpp:223
void pushNewStacks()
Wirft neue Stacks auf die Stack-Listen.
Definition: calculator.cpp:443
Symbol * mLastButOneInP
das vorletzte eingegebene Symbol
Definition: calculator.h:94
Number mConstVal
bei Konstantenrechnung: der konstante Wert
Definition: calculator.h:101
SymStackList mSymStackList
Symbol-Stack-Liste zum Rechnen.
Definition: calculator.h:90
SymOperator * mLastButOneOpP
der vorletzte eingegebene Operator
Definition: calculator.h:96
friend ostream & operator<<(ostream &os, ComputerBase &c)
Ausgabeoperator gibt wichtige Member-Variablen aus.
Definition: calculator.cpp:671
virtual void handleDisplayAfterBra()
Erzeugt passende Anzeige nach Eingabe von "(".
Definition: calculator.cpp:587
SymTabT mSymTab
Symboltabelle.
Definition: calculator.h:88
virtual ~ComputerBase()
Die mit new angelegten Symbole muessen wieder geloescht werden.
Definition: calculator.cpp:396
Symbol * mLastInP
das zuletzt eingegebene Symbol
Definition: calculator.h:93
virtual void handlePercent()
Prozentrechnung des Solar-Rechners:
Definition: calculator.cpp:610
void initStacks()
Initialisiert die beiden Stack-Listen.
Definition: calculator.cpp:356
void setLastOpP(SymOperator *soP)
Speichert die Zeiger auf die beiden zuletzt eingegebene Operator-Symbole.
Definition: calculator.cpp:431
bool mLastInPisNotToSet
damit kann Setzen von mLastInP verhindert werden
Definition: calculator.h:103
bool isSym(const string &sym)
Prueft, ob Symbol sym in der Symboltabelle ist, und gibt true oder false zurueck.
Definition: calculator.cpp:904
bool popNumDepOnLastSymBase()
Holt die vorherige Eingabe vom Zahlenstack, wenn es kein Operator war.
Definition: calculator.cpp:474
void createSymTabBase()
Erzeugt Symboltabelle mit allen Symbolen des "minimalen" Taschenrechners.
Definition: calculator.cpp:239
int mParam
bei manchen Operatoren uebergebener Parameter
Definition: calculator.h:102
void initMembers(bool clrMem=true)
Initialisiert die Members von ComputerBase.
Definition: calculator.cpp:377
virtual SymOperator * checkConstMode(SymOperator *opP)
Untersucht, ob in den Konstanten-Modus gewechselt werden oder dieser abgeschaltet werden muss.
Definition: calculator.cpp:567
NumStackList mNumStackList
Zahlen-Stack-Liste zum Rechnen.
Definition: calculator.h:89
string makeCompBaseInfoStr()
Erzeugt fuers Debugging String mit den wichtigen Member-Variablen.
Definition: calculator.cpp:651
int mBraLev
Klammerebene.
Definition: calculator.h:98
SymOperator * mLastOpP
der zuletzt eingegebene Operator
Definition: calculator.h:95
NumStack mNumStack
Default-Zahlen-Stack: ist immer leer.
Definition: calculator.h:91
virtual void handleEmptyNumStack(Number &a, SymOperator *soP, Number &b)
Erfindet einen zweiten Operanden, falls ein Operator mit nur einem berechnet werden soll.
Definition: calculator.cpp:547
void popStacks()
Holt die letzten Stacks von den Stack-Listen.
Definition: calculator.cpp:455
string getAllSyms()
Gibt saemtliche Symbole und Infos im String zurueck.
Definition: calculator.cpp:303
SymOperator * mConstOpP
bei Konstantenrechnung: der Operator
Definition: calculator.h:100
Number mPrcWhole
bei Prozentrechnung: das "Ganze"
Definition: calculator.h:99
void setLastInP(Symbol *sP)
Speichert den Zeiger auf das zuletzt eingegebene Symbol.
Definition: calculator.cpp:414
bool mIsToInit
wird von AcAc::process() auf true gesetzt und nur vom fx-3600P ausgewertet
Definition: calculator.h:104
DisplayBase * mDsplP
Zeiger auf zugehoeriges Display.
Definition: calculator.h:87
Number mMemory
Speicherregister.
Definition: calculator.h:97
string extractParam(string &in)
Extrahiert einen moeglicherweise vorhandenen Parameter des Symbols.
Definition: calculator.cpp:927
SymStack mSymStack
Default-Symbol-Stack: ist immer leer.
Definition: calculator.h:92
void showSymTab()
Schreibt alle Symbole in die Log-Datei.
Definition: calculator.cpp:326
void printSymHelp()
Gibt alle Symbole der Symboltabelle auf die Konsole aus.
Definition: calculator.cpp:272
Basisklasse aller Displays.
Definition: calculator.h:190
string mModes
"INV MOD M K LRN ITG hyp SD LR DEG RAD GRA FIX SCI"
Definition: calculator.h:198
void makeDisplay()
Wie makeDisplay(const Number& val), aber der Wert wird nicht neu gesetzt.
Definition: calculator.cpp:118
ComputerBase * mCompP
Zeiger auf Computer mit den Modes.
Definition: calculator.h:192
string mSevenRaw
dito, aber noch mit Spaces statt '#' und evtl. e+002
Definition: calculator.h:195
virtual void makeSeven(string displayStr="")
Erzeugt einen String des Wertes, wie ihn der Taschenrechner darstellen wuerde.
Definition: calculator.cpp:135
string mSeven
Sieben-Segment-Anzeige, formatiert wie Original.
Definition: calculator.h:194
void setModesBase()
Setzt den String fuer die Rechner-Modi (DEG, SCI etc) zusammen.
Definition: calculator.cpp:157
string mValue
Anzeige unformatiert.
Definition: calculator.h:193
string mK
Konstante.
Definition: calculator.h:197
virtual void setModes()
Setzt den String fuer die Rechner-Modi (DEG, SCI etc) zusammen.
Definition: calculator.cpp:145
bool isError()
Prueft, ob bei einer Berechnung ein Fehler aufgetreten ist.
Definition: calculator.cpp:176
friend ostream & operator<<(ostream &os, const DisplayBase *dbP)
Ausgabeoperator fuer Klasse DisplayBase.
Definition: calculator.cpp:206
string mMem
Memory-Anzeige.
Definition: calculator.h:196
DisplayBase(ComputerBase *cbP)
Konstruktor. Setzt den Zeiger auf den Computer und die anderen Members.
Definition: calculator.cpp:87
Number mVal
numerischer Wert der Sieben-Segment-Anzeige
Definition: calculator.h:201
hat Symbol Parameter?
Definition: calculator.h:62
ErrId mErrId
Art des Fehlers.
Definition: calculator.h:63
friend ostream & operator<<(ostream &os, const Error &e)
Ausgabeoperator, wandelt enum ErrId in Strings.
Definition: calculator.cpp:68
Die Klasse Number repraesentiert Zahlen.
Definition: number.h:49
string makeStr(int format=3, int digits=-1, int shiftNum=0, double forceSci=-1.0) const
Wandelt Number in String um.
Definition: number.cpp:157
Basisklasse fuer die Operatoren.
Definition: symbols.h:104
Basisklasse fuer saemtliche Symbole.
Definition: symbols.h:47
Template-Klasse fuer einen Stack mit Logging bei Stack-Operationen (Modul lib)
Symbole, die alle Taschenrechner haben (Modul base)