Almetare  1.14
Alle meine Taschenrechner - Eine C++-Bibliothek zur Entwicklung von Taschenrechnern
 Alle Klassen Dateien Funktionen Variablen Typdefinitionen Aufzählungswerte Freundbeziehungen
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 
105  bool popNumDepOnLastSymBase();
106  virtual void handleEmptyNumStack(Number& a, SymOperator* soP, Number& b);
107 
108 public:
109  // Initialisierung:
110  ComputerBase();
111  virtual ~ComputerBase();
112  void createSymTabBase();
113  void showSymTab();
114  void initStacks();
115  void initMembers(bool clrMem = true);
116  void clearNum() { mNumStackList.back().clear(); }
117  // Zugriff:
118  Number getConstVal () const { return mConstVal ; }
119  Number getPrcWhole () const { return mPrcWhole ; }
120  Number getMemory () const { return mMemory ; }
121  int getBraLev () const { return mBraLev ; }
122  int getParam () const { return mParam ; }
123  SymOperator* getConstOpP () const { return mConstOpP ; }
124  SymOperator* getLastOpP () const { return mLastOpP ; }
125  SymOperator* getLastButOneOpP() const { return mLastButOneOpP; }
126  Symbol* getLastInP () const { return mLastInP ; }
127  Symbol* getLastButOneInP() const { return mLastButOneInP; }
128  Symbol* getSymP(const string& sym) { return mSymTab[sym]; }
129  void setDsplP (DisplayBase* dsplP) { mDsplP = dsplP; }
130  void setConstVal(const Number& val) { mConstVal = val; }
131  void setPrcWhole(const Number& val) { mPrcWhole = val; }
132  void setMemory (const Number& val) { mMemory = val; }
133  void setParam (const int val) { mParam = val; }
134  void setLastOpP (SymOperator* soP);
135  void setConstOpP(SymOperator* soP) { mConstOpP = soP; }
136  void setLastInPisNotToSet(bool is ) { mLastInPisNotToSet = is; }
137  void setLastInP (Symbol* sP );
138  // Stack-Manipulation:
139  void pushNewStacks();
140  void popStacks();
141  void pushNum(const Number& n) { mNumStackList.back().push(n); }
142  void pushSym(SymOperator* sP) { mSymStackList.back().push(sP ); }
143  Number getTopButOneNum() { return mNumStackList.back().getTopButOne(); }
144  void setTopButOneNum(const Number& n) { mNumStackList.back().setTopButOne(n); }
145  bool isNumEmpty() { return mNumStackList.back().empty(); }
146  bool isSymEmpty() { return mSymStackList.back().empty(); }
147  Number popNum() { return mNumStackList.back().pop (); }
148  Number topNum() { return mNumStackList.back().top (); }
149  SymOperator* popSym() { return mSymStackList.back().pop (); }
150  SymOperator* topSym() { return mSymStackList.back().top (); }
151  // Sonstiges:
152  void incBraLev() { ++mBraLev; }
153  void decBraLev() { --mBraLev; }
154  void printSymHelp();
155  string getAllSyms();
156  bool isSym(const string& sym);
157  Error compute();
158  Error swapNum();
159  string extractParam(string& in);
160  string makeCompBaseInfoStr();
161 
162  virtual bool preProcess (string& in) { in = in; return false; }
163  virtual void aftProcess (string& in) { in = in; }
164  virtual void aftProcess2(string& in) { in = in; }
165  virtual SymOperator* checkConstMode(SymOperator* opP);
166  virtual void handleDisplayAfterBra();
167  virtual void handlePercent();
168  virtual void popNumDepOnLastSym() { (void)popNumDepOnLastSymBase(); }
169  virtual bool map(string& sym) { sym = sym; return false; }
170  virtual string makeCompInfoStr() { return makeCompBaseInfoStr(); }
171 
172  friend ostream& operator<<(ostream& os, ComputerBase& c);
173 };
174 
175 //******************************************************************************
176 // Klasse DisplayBase:
177 //******************************************************************************
178 
186 
188 {
189 protected:
191  string mValue;
192  string mSeven;
193  string mSevenRaw;
194  string mMem;
195  string mK;
196  string mModes;
197  // Casio fx-3600P: "ON INV M K LRN Idx LR SD DEG RAD GRA"
198  // Casio fx-85v : " s m M K hyp SD LR DEG RAD GRA FIX SCI"
200 
201  void setModesBase();
202 public:
204  virtual ~DisplayBase() {}
205  // Zugriff:
206  string getValue () const { return mValue ; }
207  string getSeven () const { return mSeven ; }
208  string getSevenRaw() const { return mSevenRaw; }
209  string getModes () const { return mModes ; }
210  Number getVal () const { return mVal ; }
211  void setMem (bool isOn) { if (isOn) mMem = "M"; else mMem = "."; }
212  void setK (bool isOn) { if (isOn) mK = "K"; else mK = "." ; }
213  void setCompP(ComputerBase* cP) { mCompP = cP ; }
214  void setVal (const Number& val ) { mVal = val ; makeValue(); }
215  void setValue(const string& value) { mValue = value; }
216  void setSeven(const string& seven) { mSeven = seven; }
217  // Sonstiges:
218  void makeDisplay(const Number& val);
219  void makeDisplay();
220  bool isError();
221  void setError() { mValue = "nan"; }
222  virtual void setModes();
223  virtual void makeValue() { mValue = mVal.makeStr(0, 15); }
224  virtual void makeSeven(string displayStr = "");
225  virtual int getNumStrLen(string dsplStr) const { return dsplStr.size(); }
226  friend ostream& operator<<(ostream& os, const DisplayBase* dbP);
227 };
228 
229 //******************************************************************************
230 // Klasse CalculatorBase:
231 //******************************************************************************
232 
239 // fse, 06.10.01
240 // fse, 01.03.03: Konstruktor bekommt argv als Argument
241 
243 {
244 protected:
245  string mProgName;
246  string mProgPath;
247  string mProgVers;
248  string mHomeDir;
249  string mAccPath;
250  string mIniFileName;
254  bool mIsDlgApp;
255 public:
256  CalculatorBase(int argc, char** argv);
257  ~CalculatorBase();
258  // Zugriff:
259  ComputerBase* getComputerP() const { return mComputerP; }
260  DisplayBase * getDisplayP () const { return mDisplayP ; }
261  Cfgs* getCfgsP () const { return mCfgsP ; }
262  string getProgName () const { return mProgName ; }
263  string getProgVers () const { return mProgVers ; }
264  string getAccPath () const { return mAccPath ; }
265  bool getIsDlgApp () const { return mIsDlgApp ; }
266  // Sonstiges:
267  double calculate();
268  void process(string in);
269  string getTitle();
270  string getNextSym(string& expr) const;
271  bool isError() const { return mDisplayP->isError(); }
272  int getNumStrLen(string dsplStr) { return mDisplayP->getNumStrLen(dsplStr); }
273 };
274 
275 
276 //******************************************************************************
277 //************************************** ***************************************
278 //************************* ************************* **************************
279 
280 #endif // !CALCULATOR_H
281 
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:250
string mProgPath
Pfad, unter dem das Binary liegt.
Definition: calculator.h:246
Number mVal
numerischer Wert der Sieben-Segment-Anzeige
Definition: calculator.h:199
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
string mSeven
Sieben-Segment-Anzeige, formatiert wie Original.
Definition: calculator.h:192
SymOperator * mConstOpP
bei Konstantenrechnung: der Operator
Definition: calculator.h:100
Klasse zur Fehlerausgabe.
Definition: calculator.h:61
DisplayBase * mDisplayP
Zeiger auf die Anzeige.
Definition: calculator.h:252
Die Klasse Cfgs fasst alle Konfigurationsparameter zusammen.
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:251
Symbol * mLastButOneInP
das vorletzte eingegebene Symbol
Definition: calculator.h:94
string mMem
Memory-Anzeige.
Definition: calculator.h:194
string mModes
"INV MOD M K LRN ITG hyp SD LR DEG RAD GRA FIX SCI"
Definition: calculator.h:196
string mSevenRaw
dito, aber noch mit Spaces statt '#' und evtl. e+002
Definition: calculator.h:193
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:253
string mHomeDir
Home-Verzeichnis des Users (falls Linux)
Definition: calculator.h:248
Symbole, die alle Taschenrechner haben (Modul base)
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:242
Stack< Number > NumStack
Stack fuer Zahlen.
Definition: calculator.h:41
string mValue
Anzeige unformatiert.
Definition: calculator.h:191
Basisklasse aller Displays.
Definition: calculator.h:187
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:254
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:247
NumStackList mNumStackList
Zahlen-Stack-Liste zum Rechnen.
Definition: calculator.h:89
string mK
Konstante.
Definition: calculator.h:195
SymOperator * mLastButOneOpP
der vorletzte eingegebene Operator
Definition: calculator.h:96
string mProgName
z.B. "TI-30", "Casio fx-85v", ...
Definition: calculator.h:245
Symbol * mLastInP
das zuletzt eingegebene Symbol
Definition: calculator.h:93
ComputerBase * mCompP
Zeiger auf Computer mit den Modes.
Definition: calculator.h:190
Number mPrcWhole
bei Prozentrechnung: das "Ganze"
Definition: calculator.h:99
Basisklasse fuer saemtliche Symbole.
Definition: symbols.h:46
Template-Klasse fuer einen Stack mit Logging bei Stack-Operationen (Modul lib)
string mAccPath
Zubehoer-Ordner.
Definition: calculator.h:249
SymStack mSymStack
Default-Symbol-Stack: ist immer leer.
Definition: calculator.h:92
int mParam
bei manchen Operatoren uebergebener Parameter
Definition: calculator.h:102