Almetare  1.15
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 
34 using namespace std;
35 
36 //******************************************************************************
37 
38 class Symbol;
39 class Calculator;
40 class SymOperator;
41 class Number;
42 
43 typedef Stack<Number> NumStack;
45 typedef list<NumStack> NumStackList;
46 typedef list<SymStack> SymStackList;
47 typedef map<string, Symbol*> SymTabT;
48 typedef SymTabT::iterator SymTabIT;
49 
50 //******************************************************************************
51 // Klasse Error:
52 //******************************************************************************
53 
54 enum ErrId { OK, SYM_EXP, OP_EXP, TWO_OPS_EXP };
55 enum { NO_PARAM = 9999 };
56 
60 
61 class Error
62 {
63  ErrId mErrId;
64 public:
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 {
86 protected:
98  int mBraLev;
102  int mParam;
104  bool mIsToInit;
105 
106  bool popNumDepOnLastSymBase();
107  virtual void handleEmptyNumStack(Number& a, SymOperator* soP, Number& b);
108 
109 public:
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; }
167  virtual SymOperator* checkConstMode(SymOperator* opP);
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 {
191 protected:
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();
204 public:
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 {
246 protected:
247  string mProgName;
248  string mProgPath;
249  string mProgVers;
250  string mHomeDir;
251  string mAccPath;
252  string mIniFileName;
256  bool mIsDlgApp;
257 public:
258  CalculatorBase(int argc, char** argv);
259  ~CalculatorBase();
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 
Number mMemory
Speicherregister.
Definition: calculator.h:97
int mBraLev
Klammerebene.
Definition: calculator.h:98
ErrId mErrId
Art des Fehlers.
Definition: calculator.h:63
string mIniFileName
Name der Initialisierungsdatei (ohne Pfad)
Definition: calculator.h:252
string mProgPath
Pfad, unter dem das Binary liegt.
Definition: calculator.h:248
Number mVal
numerischer Wert der Sieben-Segment-Anzeige
Definition: calculator.h:201
SymTabT::iterator SymTabIT
Iterator fuer die Symboltabelle.
Definition: calculator.h:48
ostream & operator<<(ostream &os, const Error &e)
Ausgabeoperator, wandelt enum ErrId in Strings.
Definition: calculator.cpp:68
NumStack mNumStack
Default-Zahlen-Stack: ist immer leer.
Definition: calculator.h:91
bool isError()
Prueft, ob bei einer Berechnung ein Fehler aufgetreten ist.
Definition: calculator.cpp:176
string mSeven
Sieben-Segment-Anzeige, formatiert wie Original.
Definition: calculator.h:194
SymOperator * mConstOpP
bei Konstantenrechnung: der Operator
Definition: calculator.h:100
hat Symbol Parameter?
Definition: calculator.h:61
DisplayBase * mDisplayP
Zeiger auf die Anzeige.
Definition: calculator.h:254
Anzeigeart des Rechners.
Definition: cfgs.h:47
SymTabT mSymTab
Symboltabelle.
Definition: calculator.h:88
Die Klasse Number repraesentiert Zahlen.
Definition: number.h:48
ComputerBase * mComputerP
Zeiger auf den Computer.
Definition: calculator.h:253
Symbol * mLastButOneInP
das vorletzte eingegebene Symbol
Definition: calculator.h:94
string mMem
Memory-Anzeige.
Definition: calculator.h:196
string mModes
"INV MOD M K LRN ITG hyp SD LR DEG RAD GRA FIX SCI"
Definition: calculator.h:198
string mSevenRaw
dito, aber noch mit Spaces statt '#' und evtl. e+002
Definition: calculator.h:195
map< string, Symbol * > SymTabT
Symboltabelle.
Definition: calculator.h:47
SymOperator * mLastOpP
der zuletzt eingegebene Operator
Definition: calculator.h:95
Basisklasse fuer die Operatoren.
Definition: symbols.h:103
Cfgs * mCfgsP
Zeiger auf die Konfigurationsdaten.
Definition: calculator.h:255
string mHomeDir
Home-Verzeichnis des Users (falls Linux)
Definition: calculator.h:250
Symbole, die alle Taschenrechner haben (Modul base)
bool mIsToInit
wird von AcAc::process() auf true gesetzt und nur vom fx-3600P ausgewertet
Definition: calculator.h:104
SymStackList mSymStackList
Symbol-Stack-Liste zum Rechnen.
Definition: calculator.h:90
bool mLastInPisNotToSet
damit kann Setzen von mLastInP verhindert werden
Definition: calculator.h:103
Basisklasse aller Taschenrechner.
Definition: calculator.h:244
Stack< Number > NumStack
Stack fuer Zahlen.
Definition: calculator.h:41
string mValue
Anzeige unformatiert.
Definition: calculator.h:193
Basisklasse aller Displays.
Definition: calculator.h:189
Number mConstVal
bei Konstantenrechnung: der konstante Wert
Definition: calculator.h:101
DisplayBase * mDsplP
Zeiger auf zugehoeriges Display.
Definition: calculator.h:87
bool mIsDlgApp
als Konsolen- oder Dialogapplik. gestartet?
Definition: calculator.h:256
list< NumStack > NumStackList
Liste von Zahlen-Stacks.
Definition: calculator.h:45
list< SymStack > SymStackList
Liste von Symbol-Stacks.
Definition: calculator.h:46
Klasse mit allen Parametern, die in der Konfigurationsdatei stehen (Modul base)
Basisklasse aller Computer.
Definition: calculator.h:84
Stack< SymOperator * > SymStack
Stack fuer Symbole.
Definition: calculator.h:44
string mProgVers
Programmversion zwecks Vrgl. in Ini-Datei.
Definition: calculator.h:249
NumStackList mNumStackList
Zahlen-Stack-Liste zum Rechnen.
Definition: calculator.h:89
string mK
Konstante.
Definition: calculator.h:197
SymOperator * mLastButOneOpP
der vorletzte eingegebene Operator
Definition: calculator.h:96
string mProgName
z.B. "TI-30", "Casio fx-85v", ...
Definition: calculator.h:247
Symbol * mLastInP
das zuletzt eingegebene Symbol
Definition: calculator.h:93
ComputerBase * mCompP
Zeiger auf Computer mit den Modes.
Definition: calculator.h:192
Number mPrcWhole
bei Prozentrechnung: das "Ganze"
Definition: calculator.h:99
Basisklasse fuer saemtliche Symbole.
Definition: symbols.h:46
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
Template-Klasse fuer einen Stack mit Logging bei Stack-Operationen (Modul lib)
string mAccPath
Zubehoer-Ordner.
Definition: calculator.h:251
SymStack mSymStack
Default-Symbol-Stack: ist immer leer.
Definition: calculator.h:92
int mParam
bei manchen Operatoren uebergebener Parameter
Definition: calculator.h:102