Almetare 1.20
Alle meine Taschenrechner - Eine C++-Bibliothek zur Entwicklung von Taschenrechnern
symbols.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// 23.03.2002 fse erzeugt
13//******************************************************************************
14
15#ifndef SYMBOLS_H
16#define SYMBOLS_H
17
18#ifndef __cplusplus
19#error symbols.h is only for C++!
20#endif
21
22//******************************************************************************
23
24#include <string>
25
26#include <math.h>
27#include "number.h"
28
29using namespace std;
30
31//******************************************************************************
32
33class ComputerBase; // Forward-Deklaration
34class DisplayBase; // Forward-Deklaration
35
36//******************************************************************************
37// Klasse Symbol und Ableitungen:
38//******************************************************************************
39
44// fse, 06.10.01
45
46class Symbol
47{
48protected:
49 string mSym;
50 string mHlp;
53 static Symbol* getLastInP();
54 static Symbol* getLastOpP();
55 static Symbol* getLastButOneOpP();
56public:
57 explicit Symbol(string sym = "", string hlp = "no help available") : mSym(sym), mHlp(hlp) {}
58 string getSym() const { return mSym; }
59 string getHlp() const { return mHlp; }
60 virtual ~Symbol() {}
61 virtual void process() = 0;
62 static void setCompP(ComputerBase* cP) { mCompP = cP; }
63 static void setDsplP(DisplayBase* cP) { mDsplP = cP; }
64 friend ostream& operator<<(ostream& os, const Symbol& s);
65 friend ostream& operator<<(ostream& os, const Symbol* s);
66};
67
68//************************************** ***************************************
69
72
73class SymNumber : public Symbol
74{
75protected:
76 explicit SymNumber(string sym = "", string hlp = "any number")
77 : Symbol(sym, hlp) {}
78public:
79 void processCommon() const;
80};
81
82//************************* ************************* **************************
83
88
89class NumDmy : public SymNumber
90{
91public:
92 explicit NumDmy(string num = "0", string hlp = "any number") : SymNumber(num) { hlp = hlp; }
93 void setSym(const string& num) { mSym = num; }
94 void process();
95 static bool isFraction(const string& sym, double& val, long& numr, long& dnom);
96};
97
98//************************************** ***************************************
99
101// fse, 06.10.01
102
103class SymOperator : public Symbol
104{
105protected:
106 int mPrio;
107public:
108 explicit SymOperator(string op = "", int prio = 2, string hlp = "no help available")
109 : Symbol(op, hlp), mPrio(prio) {}
110 int getPrio() const { return mPrio; }
111 void processCommon();
112 void processAddSub();
114 SymOperator* checkConstMode(const SymOperator* lastSymP) const;
115 virtual Number calcVal(const Number& a, const Number& b) = 0;
116};
117
118//************************* ************************* **************************
119
121
122class OpAdd : public SymOperator
123{
124public:
125 OpAdd() : SymOperator("+", 2, "adding operator") {};
126 Number calcVal(const Number& a, const Number& b) { return a + b; }
127 void process() { processAddSub(); }
128};
129
130//****************** ******************* ******************* *******************
131
133
134class OpAddCasioSci : public OpAdd
135{
136public:
137 OpAddCasioSci() : OpAdd() {};
138 void process() { processAddSubCasioSci(); }
139};
140
141//************************* ************************* **************************
142
144
145class OpSub : public SymOperator
146{
147public:
148 OpSub() : SymOperator("-", 2, "subtracting operator") {}
149 Number calcVal(const Number& a, const Number& b) { return a - b; }
150 void process() { processAddSub(); }
151};
152
153//****************** ******************* ******************* *******************
154
156
157class OpSubCasioSci : public OpSub
158{
159public:
160 OpSubCasioSci() : OpSub() {};
161 void process() { processAddSubCasioSci(); }
162};
163
164//************************* ************************* **************************
165
167
168class OpMul : public SymOperator
169{
170public:
171 OpMul() : SymOperator("*", 4, "multiplying operator") {}
172
173 Number calcVal(const Number& a, const Number& b) { return a * b; }
174 void process() { processCommon(); }
175};
176
177//************************* ************************* **************************
178
180
181class OpDiv : public SymOperator
182{
183public:
184 OpDiv() : SymOperator("/", 4, "dividing operator") {}
185 Number calcVal(const Number& a, const Number& b) { return a / b; }
186 void process() { processCommon(); }
187};
188
189//************************************** ***************************************
190
192// fse, 06.10.01
193
194class SymOther : public Symbol
195{
196protected:
197 static int mBraLev;
198public:
199 explicit SymOther(string sym = "", string hlp = "no help available")
200 : Symbol(sym, hlp) {}
201 static int getBraLev() { return mBraLev; }
202};
203
204//************************* ************************* **************************
205
207
208class OthBra : public SymOther
209{
210public:
211 OthBra() : SymOther("(", "parentheses open") {}
212 void process();
213};
214
215//************************* ************************* **************************
216
218
219class OthKet : public SymOther
220{
221public:
222 OthKet() : SymOther(")", "parentheses close") {}
223 void process();
224};
225
226//************************* ************************* **************************
227
229
230class OthEqu : public SymOther
231{
232public:
233 OthEqu() : SymOther("#") {}
234 void process();
235};
236
237//************************************** ***************************************
238
240
241class SymFunction : public Symbol
242{
243public:
244 explicit SymFunction(string sym = "", string hlp = "no help available")
245 : Symbol(sym, hlp) {}
246};
247
248//************************* ************************* **************************
249
251
253{
254public:
255 explicit SymOtherFunction(string sym = "", string hlp = "no help available")
256 : SymFunction(sym, hlp) {}
257 void process();
258 virtual Number calcVal(const Number& a) = 0;
259};
260
261//****************** ******************* ******************* *******************
262
264
266{
267public:
268 FnSqrt() : SymOtherFunction("sqrt", "square root") {}
269 Number calcVal(const Number& a) { return sqrt(a.getVal()); }
270};
271
272//************************************** ***************************************
273
275// fse, 06.10.01
276
277class SymAction : public Symbol
278{
279public:
280 explicit SymAction(string sym = "", string hlp = "no help available")
281 : Symbol(sym, hlp) {}
282};
283
284//************************* ************************* **************************
285
287
288class AcHelp : public SymAction
289{
290public:
291 AcHelp() : SymAction("help", "print this help page") {}
292 void process();
293};
294
295//************************* ************************* **************************
296
298// fse, 30.06.02
299
300class AcC : public SymAction
301{
302public:
303 AcC() : SymAction("c", "clear") {}
304 void process();
305};
306
307//************************* ************************* **************************
308
310// fse, 30.06.02
311
312class AcAc : public SymAction
313{
314public:
315 AcAc() : SymAction("ac", "clear all") {}
316 void process();
317};
318
319//************************* ************************* **************************
320
322
323class AcEqu : public SymAction
324{
325public:
326 AcEqu() : SymAction("=", "execute calculation") {}
327 void process();
328};
329
330//************************* ************************* **************************
331
333
334class AcPrc : public SymAction
335{
336public:
337 AcPrc() : SymAction("%", "percent calculation") {}
338 void process();
339};
340
341//************************* ************************* **************************
342
344
345class AcSto : public SymAction
346{
347public:
348 AcSto() : SymAction("sto", "store display in memory") {}
349 void process();
350};
351
352//************************* ************************* **************************
353
355
356class AcRcl : public SymAction
357{
358public:
359 AcRcl() : SymAction("rcl", "recall memory to display") {}
360 void process();
361};
362
363//************************* ************************* **************************
364
366
367class AcSum : public SymAction
368{
369public:
370 AcSum() : SymAction("sum", "sum display to memory") {}
371 void process();
372};
373
374//************************* ************************* **************************
375
377
378class AcSub : public SymAction
379{
380public:
381 AcSub() : SymAction("sub", "subtract display from memory") {}
382 void process();
383};
384
385//************************* ************************* **************************
386
388
389class AcExc : public SymAction
390{
391public:
392 AcExc() : SymAction("exc", "exchange memory and display") {}
393 void process();
394};
395
396//************************* ************************* **************************
397
399
400class AcInit : public SymAction
401{
402public:
403 AcInit() : SymAction("init", "initialize calculator") {}
404 void process();
405};
406
407//************************* ************************* **************************
408
410
411class AcInitWoMem : public SymAction
412{
413public:
414 AcInitWoMem() : SymAction("initwomem", "initialize without clearing memory") {}
415 void process();
416};
417
418//************************* ************************* **************************
419
421
422class AcSign : public SymAction
423{
424public:
425 AcSign() : SymAction("sign", "change sign of display") {}
426 void process();
427};
428
429//******************************************************************************
430//************************************** ***************************************
431//************************* ************************* **************************
432
433#endif // !SYMBOLS_H
434
Gesamtloeschung.
Definition: symbols.h:313
void process()
Initialisiert den Rechner, ohne die Speicher zu loeschen (Taste "AC" - all clear).
Definition: symbols.cpp:500
Loeschen der letzten Eingabe.
Definition: symbols.h:301
void process()
Ersetzt die letzte Eingabe durch 0 (Taste "C" - clear).
Definition: symbols.cpp:487
Berechnung durchfuehren.
Definition: symbols.h:324
void process()
Prozessiert das Gleichheitszeichen.
Definition: symbols.cpp:515
Anzeige und Speicher austauschen (exchange).
Definition: symbols.h:390
void process()
Austausch von Memory-Register und oberstem Wert im Zahlen-Stack.
Definition: symbols.cpp:632
Symbol fuer Ausgabe der Hilfe.
Definition: symbols.h:289
void process()
Zeigt alle Symbole auf der Konsole.
Definition: symbols.cpp:477
Rechner initialisieren.
Definition: symbols.h:401
void process()
Initialisiert die Stacks und Members des Computers.
Definition: symbols.cpp:553
Rechner initialisieren, ohne Speicher zu loeschen (init without memory).
Definition: symbols.h:412
void process()
Initialisiert die Stacks und Members des Computers, loescht aber nicht den Memory-Speicher.
Definition: symbols.cpp:565
Prozent.
Definition: symbols.h:335
void process()
Prozessiert das Prozentzeichen.
Definition: symbols.cpp:543
Speicher wieder in die Anzeige holen (recall).
Definition: symbols.h:357
void process()
Ersetzen von oberstem Wert im Zahlen-Stack durch Memory-Register, falls zuletzt Zahl eingegeben; sons...
Definition: symbols.cpp:601
Vorzeichenwechsel.
Definition: symbols.h:423
void process()
Vorzeichenwechsel.
Definition: symbols.cpp:580
Anzeige speichern (store).
Definition: symbols.h:346
void process()
Speichern im Memory-Register.
Definition: symbols.cpp:590
Im Speicher subtrahieren.
Definition: symbols.h:379
void process()
Subtrahieren von aktueller Zahl vom Memory-Register.
Definition: symbols.cpp:622
Im Speicher addieren.
Definition: symbols.h:368
void process()
Addieren von aktueller Zahl zum Memory-Register.
Definition: symbols.cpp:612
Basisklasse aller Computer.
Definition: calculator.h:85
Basisklasse aller Displays.
Definition: calculator.h:190
Wurzelfunktion.
Definition: symbols.h:266
Klasse der "normalen" Zahlen.
Definition: symbols.h:90
void process()
Eine eingegebene Zahl wird prozessiert, indem sie einfach auf den Stack gelegt wird.
Definition: symbols.cpp:130
static bool isFraction(const string &sym, double &val, long &numr, long &dnom)
Untersucht, ob der eingegebene String als Bruch interpretiert werden kann.
Definition: symbols.cpp:168
Die Klasse Number repraesentiert Zahlen.
Definition: number.h:49
Operator fuer Addition.
Definition: symbols.h:135
Operator fuer Addition.
Definition: symbols.h:123
Operator fuer Division.
Definition: symbols.h:182
Operator fuer Multiplikation.
Definition: symbols.h:169
Operator fuer Subtraktion.
Definition: symbols.h:158
Operator fuer Subtraktion.
Definition: symbols.h:146
Symbol "(" ("Bra" von Bracket).
Definition: symbols.h:209
void process()
Prozessiert Symbol "(".
Definition: symbols.cpp:400
Symbol "=".
Definition: symbols.h:231
void process()
Berechnet die letzte Operation auf dem Stack.
Definition: symbols.cpp:382
Symbol ")" ("ket" von Bracket).
Definition: symbols.h:220
void process()
Prozessiert Symbol ")".
Definition: symbols.cpp:418
Basisklasse fuer alle Aktionen ("=", "%", ...).
Definition: symbols.h:278
Basisklasse aller Funktionen.
Definition: symbols.h:242
Basisklasse fuer Zahlen.
Definition: symbols.h:74
void processCommon() const
Holt die vorherige Eingabe wieder vom Zahlenstack, wenn es kein Operator war.
Definition: symbols.cpp:112
Basisklasse fuer die Operatoren.
Definition: symbols.h:104
void processCommon()
Prozessiert einen eingegebenen Operator.
Definition: symbols.cpp:255
void processAddSub()
Prozessiert "+" und "-".
Definition: symbols.cpp:309
void processAddSubCasioSci()
Prozessiert "+" und "-".
Definition: symbols.cpp:348
Basisklasse der Nicht-Winkelfunktionen.
Definition: symbols.h:253
void process()
Prozessiert alle Nicht-Winkelfunktionen.
Definition: symbols.cpp:451
Basisklasse fuer weitere Symbole ("(", etc.)
Definition: symbols.h:195
Basisklasse fuer saemtliche Symbole.
Definition: symbols.h:47
string mSym
das Symbol als String ("+", "sto", ...)
Definition: symbols.h:49
static DisplayBase * mDsplP
Zeiger auf Display (f. wissenschftl. Rechner)
Definition: symbols.h:52
static Symbol * getLastButOneOpP()
Liefert das vorletzte eingegebene Operator-Symbol zurueck.
Definition: symbols.cpp:100
static ComputerBase * mCompP
Zeiger auf Computer mit der Symboltabelle.
Definition: symbols.h:51
static Symbol * getLastInP()
Liefert das letzte eingegebene Symbol zurueck.
Definition: symbols.cpp:68
static Symbol * getLastOpP()
Liefert das letzte eingegebene Operator-Symbol zurueck.
Definition: symbols.cpp:83
friend ostream & operator<<(ostream &os, const Symbol &s)
Ausgabeoperator fuer ein Symbol.
Definition: symbols.cpp:36
string mHlp
kurzer Hilfetext
Definition: symbols.h:50
Klasse der Zahlen (Kombination aus double und Bruechen) (Modul base)