home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d5xx / d573 / mtoollibrary.lha / MToolLibrary / German / Doc next >
Text File  |  1991-12-22  |  20KB  |  456 lines
  1.   MToolLibrary V 2.20
  2.   ===================
  3.  
  4.   © by Rüdiger Dreier 1988-91
  5.  
  6.   DER AUTOR ÜBERNIMMT KEINERLEI HAFTUNG FÜR SCHÄDEN, DIE AUS DER SACH- ODER
  7.   UNSACHGEMÄSSEN BENUTZUNG DES PROGRAMMS ENTSTEHEN !!
  8.   WEITERHIN WIRD KEINE HAFTUNG FÜR DIE FEHLERFREIHEIT DES PROGRAMMS
  9.   ÜBERNOMMEN !!
  10.   BENUTZUNG AUF EIGENE GEFAHR !
  11.  
  12.   Die mtool.library ist eine  Amiga-Shared-Library und kann genauso wie jede
  13.   andere Library  benutzt  werden. Um  diese  Library benutzen  zu  können,
  14.   müssen im  LIBS: Ordner  noch die  beiden folgenden  Libraries  vorhanden
  15.   sein:
  16.                         mathieeedoubbas.library
  17.                         mathieeedoubtrans.library
  18.  
  19.   Die mtool.library ist im LIBS: Ordner natürlich am Besten aufgehoben....
  20.  
  21.   DER NAME
  22.   ========
  23.  
  24.   Ursprünglich hieß diese Library mal "tool.library", aber dann entdeckte
  25.   ich, daß es eine weitere Library dieses Namens gibt. Also habe ich meine
  26.   Library in "mtool.library" umbenannt (das "m" steht für Mathe...). Ich
  27.   hoffe, daß keiner auf die Idee kommt/gekommen ist, seine/ihre Library
  28.   nun "mtool.library" zu nennen. Ältere Programme, die meine "tool.library"
  29.   benutzen müssen also leicht überarbeitet werden (ToolBase wurde in
  30.   "MToolBase" umbenannt).
  31.  
  32.  
  33.   FÜR PROGRAMMIERER
  34.   =================
  35.  
  36.   Die   Funktionen  der   Library   unterteilen   sich  in   die   Bereiche
  37.   Stringbearbeitung, Intuition/Graphikunterstützung und Mathematik. Jedes
  38.   Programm, daß die tool.library benutzen soll, muß tool.h einbinden.
  39.  
  40.   Öffnen der Library:
  41.                         struct MToolBase *MToolBase; /* Global */
  42.  
  43.                         MToolBase=(struct MToolBase *)OpenLibrary("mtool.library,0");
  44.  
  45.   Die Struktur  MToolBase enthält Zeiger auf  IntuitionBase, GfxBase und die
  46.   beiden MathIeee....Base's.  Ein Programm,  daß die  tool.library  öffnet,
  47.   braucht  daher diese vier  Libraries nicht mehr selbst  zu öffnen, sonder
  48.   kann direkt an sie gelangen über:
  49.                         IntuitionBase=MToolBase->IntuitionBase etc.
  50.   Das ist  vielleicht nicht ganz legitim, aber  diese vier Libraries werden
  51.   von  mtool.library  einmal  geöffnet  und  erst  wieder  geschloßen, wenn
  52.   mtool.library  aus dem Speicher entfernt wird.  Daher ist sichergestellt,
  53.   daß die  Libraries auch im Speicher  sind, sollange tool.library geöffnet
  54.   ist.
  55.  
  56.   Achtung : Auf Rechner mit FPU verhalten sich einige Funktionen nicht wie
  57.   gewohnt, wenn man die Libraries nicht explizit öffnet, besonders die
  58.   Funktion IEEEDPFix() fängt plötzlich an zu Runden....
  59.   Die beiden Mathe-Libraries sollten also besser von Hand geöffnet werden.
  60.  
  61.   STRINGBEARBEITUNG:
  62.   ==================
  63.  
  64.   VOID left (char *Ziel,char *Source,LONG Anzahl)(a0,a1,d0)
  65.   VOID right(char *Ziel,char *Source,LONG Anzahl)(a0,a1,d0)
  66.   VOID mid  (char *Ziel,char *Source,LONG Start,LONG Anzahl)(a0,a1,d0,d1)
  67.  
  68.   Diese 3 Funktionen  entsprechen den gleichnamigen Basic- Funktionen. Ziel
  69.   muß ein Zeiger auf einen  genügend großen String (Array of char...) sein,
  70.   da sonst  andere Daten  oder Programmteile  überschrieben werden  können.
  71.   Ziel muß  mind. Anzahl+1 Zeichen aufnehmen  können (Anzahl Zeichen werden
  72.   kopiert und  mit NULL abgeschloßen). ACHTUNG:  mid arbeitet (im Gegensatz
  73.   zu  Basic) nur in  einer Richtung, eine  Konstruktion wie mid(...)=string
  74.   ist natürlich nicht erlaubt.
  75.  
  76.  
  77.   VOID copy(LONG start,LONG anzahl,char *ziel,char *source)(d0,d1,d2,d3)
  78.  
  79.   Entspricht im wesentlichen der mid-Funktion, aus Kompatibilitäts- gründen
  80.   noch enthalten.
  81.  
  82.  
  83.   LONGcheck (LONG Zeichen1,LONG Zeichen2,LONG Start,LONG Ende,char *String)
  84.             (d0,d1,d2,d3,a0)
  85.   LONG checkback(LONG Zeichen1, LONG  Zeichen2, LONG Start, LONG Ende, char
  86.   *String)
  87.                 (d0,d1,d2,d3,a0)
  88.  
  89.   Diese beiden  Funktionen  suchen nach  dem  ersten (check)  bzw.  letzten
  90.   (checkback) Auftauchen eines der beiden Zeichen (1 und 2, müssen als LONG
  91.   übergeben werden) unter Beachtung von Klammerebenen (nur runde Klammern).
  92.   Beispiel: Es soll nach + und - in dem String
  93.         1+(2-3)
  94.         0123456 gesucht werden.  check würde eine 1 zurückliefern, checkback
  95.   ebenfalls, da  das Minuszeichen in der  Klammer eingeschlossen ist. Diese
  96.   beiden Funktionen werden intensiv von Init_Block benutzt.
  97.  
  98.  
  99.   LONG AnzahlKlammern(char *String)(a0)
  100.  
  101.   Diese  Funktion überprüft, ob  in einem String alle  Klammern (nur runde)
  102.   paarig sind.
  103.   Rückgabe:      0: paarig
  104.                         <0: zu viele )
  105.                         >0: zu viele (
  106.  
  107.  
  108.  
  109.   INTUITION/GRAFIKUNTERSTÜTZUNG
  110.   =============================
  111.  
  112.   LONG request(char *ja,char *nein,char *body)(d0,d1,d2)
  113.  
  114.   Diese Routine  eröffnet auf dem aktuellen  Screen einen AutoRequester und
  115.   zeigt in  diesem die übergebenen Texte an. *ja  und *nein werden als Text
  116.   in  den Gadgets (wo  sonst Retry  und Cancel steht)  angezeigt, *body als
  117.   Haupttext.  Dieser Haupttext  darf nicht länger  sein, als  in eine Zeile
  118.   paßt.  Rückgabe: 0 oder 1, je nachdem, was vom Benutzer angewählt wurde.
  119.  
  120.  
  121.   LONG NewRequest(struct Window *Window,ja,nein,body)(a0,d0,d1,d2)
  122.  
  123.   Diese  Funktion ist der vorigen  sehr ähnlich, nur daß  man hier noch das
  124.   Fenster angeben kann, auf  dem der Requester erscheinen soll. Die anderen
  125.   Parameter und die Rückgabewerte entsprechen denen von request.
  126.  
  127.   LONG EventAbfrage(struct Window *Window,struct info *msginfo)(a0,a1)
  128.  
  129.   Diese Funktion  füllt die Struktur msginfo (definiert  in Tool.h) mit den
  130.   Werten von Class, Code und IAddress (Class wird in msginfo NachrichtenArt
  131.   genannt, Code wird als code bezeichnet). Diese Funktion führt kein Wait()
  132.   aus.
  133.   Zusätzlich wird Class noch ausgegeben.
  134.  
  135.  
  136.   VOID Print(struct RastPort *RP,
  137.              char *text,
  138.              LONG col,
  139.              LONG xpos,
  140.              LONG ypos)(a1,a0,d0,d1,d2)
  141.  
  142.   Diese Funktion gibt den Text text auf dem RastPort RP in der Farbe col ab
  143.   der Position xpos/ypos aus. Ganz einfach.
  144.  
  145.  
  146.   VOID Center(struct Window *Window,
  147.               char *text,
  148.               LONG Farbe,
  149.               LONG yPos)(a1,a0,d0,d1)
  150.  
  151.   Wieder  eine sehr ähnliche  Funktion. Nur das diesmal  der Text zentriert
  152.   ausgegeben wird.  Dafür braucht die Funktion dann  aber auch einen Zeiger
  153.   auf das entsprechende Fenster (Aufpassen !).
  154.  
  155.  
  156.   VOID Box(struct RastPort *RP,
  157.            LONG x1,y1,x2,y2)(a1,d0,d1,d2,d3)
  158.  
  159.   Diese  Funktion (erraten)  zeichnet im angegebenen  RastPort ein Rechteck
  160.   mit die Ecken x1/y1 und x2/y2
  161.  
  162.  
  163.   VOID Gadget_On (struct Gadget *Gadget,struct Window *Window)(a0,a1)
  164.   VOID Gadget_Off(struct Gadget *Gadget,struct Window *Window)(a0,a1)
  165.  
  166.   Diese  beiden  Funktionen  ersetzen  die  Systemfunktionen  OnGadget  und
  167.   OffGadget.   Gadget_On  sorgt  dafür,  daß   das  Gadget  wieder  korrekt
  168.   gezeichnet wird  (OnGadget läßt meistens das  "Gitter" stehen, obwohl das
  169.   Gadget wieder anwählbar ist).
  170.  
  171.  
  172.   LONG GetPropPosH(struct Gadget *Gadget,LONG MaxPos)(a0,d0)
  173.   LONG GetPropPosV(struct Gadget *Gadget,LONG MaxPos)(a0,d0)
  174.  
  175.   Diese beiden Funktionen geben die aktuelle vertikale/horizontale Position
  176.   eines  PropGadgets zurück.  Die zurückgegebenen Werte  bewegen sich dabei
  177.   zwischen 0 und MaxPos.
  178.  
  179.  
  180.   VOID SetPropPosH(     struct Gadget *Gadget,
  181.                                 struct Window *Window,
  182.                         LONG MaxPos,
  183.                                 LONG Schrittweite,
  184.                                 LONG NewPos)(a0,a1,d0,d1,d2)
  185.   VOID SetPropPosV(     struct Gadget *Gadget,
  186.                                 struct Window *Window,
  187.                                 LONG MaxPos,
  188.                                 LONG Schrittweite,
  189.                                 LONG NewPos)(a0,a1,d0,d1,d2)
  190.  
  191.   Diese  beiden Funktionen setzten die  aktuelle Position eines PropGadgets
  192.   auf den  Wert NewPos, wobei MaxPos für 100%  steht. Schrittweite gibt an,
  193.   wie viele Positionen der Regler maximal haben soll, wenn neben ihn in das
  194.   Gadget  geklickt wird. Dazu  ein Beispiel. Man  will einen File-Requester
  195.   erstellen. Dabei ergibt sich die Situation, daß man 5 Zeilen gleichzeitig
  196.   darstellen kann,  es aber 15 Files gibt. Am  Anfang steht der Regler ganz
  197.   oben (GetPropPosV würde 0 zurückgeben). Steht der Regler ganz unten, dann
  198.   soll 10 zurückgegeben werden.  Damit gibt es 11 abfragbare Positionen und
  199.   dies ist auch der Wert für MaxPos. Klickt der Anwender aber in das Gadget
  200.   neben den  Regler,  dann  soll der  Regler  den  gesammten Bereich  in  3
  201.   Sprüngen  zurücklegen. Dafür setzt  man Schrittweite auf  3. Steht vorher
  202.   der Regler auf 0, dann steht er nach einem Klick auf 5 und danach auf 10.
  203.   HINWEIS: Bei  diesen Funktionen  wird mit  Ganzzahlen gerechnet,  und  da
  204.   kommt  es schon mal  vor, daß (bes.  wenn der Anwender  den Regler direkt
  205.   verschoben hat) ein Sprung etwas  weiter ist, als man ihn gerne hätte. Im
  206.   obigen  Beispiel passiert das  z.B., wenn  der Regler so  gerade noch auf
  207.   Position 9  steht (und noch nicht  auf 8) und wird  dann neben den Regler
  208.   geklickt,  dann wird als  nächster Wert  3 und nicht  4 angegeben. Dieser
  209.   Fehler muß  nicht immer  auftreten und  ist abhängig  von der  Größe  des
  210.   Gadgets und der Anzahl Positionen.
  211.  
  212.  
  213.   LONG PrepareTmpRas(struct RastPort *RP)(a1)
  214.   VOID ClearTmpRas  (struct RastPort *RP)(a1)
  215.  
  216.   Die  erste  Funktion  bereitet  einen  RastPort  auf  die  Benutzung  des
  217.   Flood-Befehls  vor (eine weitere  Bitmap für den  RastPort besorgen). Die
  218.   zweite  Funktion gibt den  Speicher dann wieder  frei. Wenn PrepareTmpRas
  219.   eine 0  zurückgibt, ist  entweder  die Bitmap  schon besorgt  oder  nicht
  220.   genügend Speicher vorhanden.
  221.  
  222.  
  223.   LONG PrepareArea(struct RastPort *RP,LONG MaxPoints)(a1,d0)
  224.   VOID ClearArea  (struct RastPort *RP)(a1)
  225.  
  226.   Diese beiden  Funktionen besorgen  die Vorbereitungen  für die  AreaMove/
  227.   Draw/  Ellipse Befehle. MaxPoints  gibt an, wie viele  Punkte maximal mit
  228.   AreaMove  bzw. Draw  angegeben  werden.  Die Funktionen  enthalten  einen
  229.   Aufruf von PrepareTmpRas bzw. ClearTmpRas. Ein zusätzlicher Aufruf dieser
  230.   Funktionen ist  nicht nötig.  Wurde erst  PrepareTmpRas aufgerufen,  dann
  231.   versagt PrepareArea. PrepareArea gibt  wieder 0 zurück, wenn etwas schief
  232.   gegangen ist.
  233.  
  234.   MENUUNTERSTÜTZUNG
  235.   =================
  236.  
  237.   Diese   Funktionssammlung  dient   dazu,  schnell   ein  Standartmenu  zu
  238.   erstellen,  ohne daß  Strukturen statisch definiert  werden müssen. Durch
  239.   einen  einzigen Befehl wird jeweils  ein Menu, ein Item  oder ein Subitem
  240.   angefügt.
  241.  
  242.   struct Menu *AddMenu(struct Menu *menu,
  243.                        char *Titel,
  244.                        unsigned short Flags);
  245.  
  246.   Diese Funktion  fügt ein Menu an. Beim ersten  Aufruf muß menu NULL sein.
  247.   Der Rückgabewert des ERSTEN  Aufrufs wird für alle weiteren Aufrufe (auch
  248.   der anderen Funktionen) als Argument verwendet.
  249.  
  250.   struct Item *AddItem(struct Menu *menu,
  251.                        char *Titel,
  252.                        unsigned short Flags,
  253.                        char HotKey);
  254.  
  255.   Diese Funktion fügt an das  zuletzt definierte Menu ein Item an. menu ist
  256.   der  Rückgabewert des ersten  Aufrufs von AddMenu. Titel  kann ein Zeiger
  257.   auf einen String sein, dann muß aber auch ITEMTEXT in Flags gesetzt sein.
  258.   Es wird dann aber nur Speicher für die IntuiText-Struktur reserviert, der
  259.   Speicher für den
  260.   String wird direkt benutzt. Eine Konstruktion wie :
  261.    char Text[50];
  262.    strcpy(Text,"Text 1");
  263.    AddItem(Menu,Text,Flags,Hotkey);
  264.    strcpy(Text,"Text 2");
  265.    AddItem(Menu,Text,Flags,Hotkey);
  266.   bringt darum nicht den gewünschten Erfolg. Dafür funktioniert:
  267.    char Text1[50],Text2[50];
  268.    AddItem(Menu,Text1,Flags,Hotkey); /*  Das  Item  wird aber  nicht  breit
  269.   genug */
  270.    AddItem(Menu,Text2,Flags,Hotkey);
  271.    strcpy(Text1,"Text 1");
  272.    strcpy(Test2,"Text 2");
  273.   Dann muß  aber  vorher  der String  in  der char-Deklaration  groß  genug
  274.   reserviert worden  sein, sonst gibt es dort  Probleme. Ist ITEMTEXT nicht
  275.   gesetzt, so wird  Titel  als Zeiger auf eine ImageStruktur interpretiert.
  276.   Titel darf kein Zeiger  auf eine IntuiText-Struktur sein (Menus verwenden
  277.   IntuiText). Diese Struktur wird, wenn benötigt, automatisch erstellt.
  278.   HotKey  ist die  Tastaturabkürzung für  das Item.  COMMSEQ muß zusätzlich
  279.   gesetzt sein.
  280.  
  281.   struct Item *AddSub(struct Menu *menu,
  282.                       char *Titel,
  283.                       unsigned short Flags,
  284.                       char HotKey);
  285.  
  286.   Wie bei  AddItem,  nur  wird an  das  letzte  Item ein  weiteres  SubItem
  287.   angehängt.
  288.  
  289.   Die Rückgabewerte dieser drei  Funktionen sind jeweils die Zeiger auf die
  290.   erstelle Menu-  bzw. Item-Struktur. Außer beim  ersten Aufruf von AddMenu
  291.   kann der Rückgabewert ignoriert  werden. Der Rückgabewert wird NULL, wenn
  292.   nicht mehr  genügend  Speicher vorhanden  ist. Trotzdem  sollten  weitere
  293.   Aufrufe von Add... Funktionen  nicht zum Absturz führen. Der Rückgabewert
  294.   ist  interessant,  wenn  man selbst  die  StandartMenus  noch  ein  wenig
  295.   manipulieren möchte  (z.B. eine andere Farbe  als die voreingestellte für
  296.   den  Text). Verändert man  dabei die Liste  im Speicher, so  muß man auch
  297.   dafür sorgen,  daß beim  Freigeben des  Speichers alles  freigegeben  und
  298.   nichts  doppelt freigegeben  wird. Einstellungen für  Farbe und Draw-Mode
  299.   werden von ersten Item des ersten Menus übernommen !
  300.  
  301.   VOID NewSetMenuStrip(struct Window *Window,struct Menu *menu);
  302.  
  303.   Diese Funktion ersetzt SetMenuStrip. Alle Items innerhalb eines Menus und
  304.   alle Subs innerhalb eines Items werden auf gleiche Breite gebracht (siehe
  305.   Beispiel). Außerdem wird natürlich SetMenuStrip aufgerufen.
  306.  
  307.   VOID ClearMenu(struct Menu *menu);
  308.  
  309.   Diese  Funktion gibt den  belegten Speicher wieder frei.  Vorher MUß noch
  310.   ClearMenuStrip aufgerufen werden.
  311.  
  312.   struct Menu *LastMenu(struct Menu *menu);
  313.   struct MenuItem *LastItem(struct Menu *menu);
  314.   struct MenuItem *LastSub(struct Menu *menu);
  315.  
  316.   Diese  drei  Funktionen  geben   jeweils  einen  Zeiger  auf  das  letzte
  317.   definierte Element zurück. Diese Funktionen werden intern benutzt.
  318.  
  319.   struct Menu *FreeMenu(struct Menu *menu);
  320.   struct MenuItem *FreeItem(struct MenuItem *item);
  321.  
  322.   Diese beiden Funktionen geben den Speicher für ein Item (incl. IntuiText,
  323.   falls  vorhanden)  bzw.  ein  Menu  wieder  frei.  Werden  von  ClearMenu
  324.   aufgerufen.
  325.  
  326.  
  327.   MATHEMATISCHE FUNKTIONEN
  328.   ========================
  329.  
  330.   VOID UmwFtoS(char *Ziel,DOUBLE *Zahl,LONG Nachkomma)(a0,a1,d0)
  331.  
  332.   Diese Funktion wandelt  eine doppeltgenaue Fließkommazahl in einen String
  333.   um. Die Anzahl der Nachkommastellen kann angegeben werden. Die Anzahl der
  334.   Vorkommastellen  bestimmt die  Funktion selbst.  Ist die  Zahl groß (oder
  335.   klein  bei negativen  Zahlen), dann  wird die  Zahl im wissenschaftlichen
  336.   Format ausgegeben.
  337.  
  338.  
  339.   VOID UmwStoF(DOUBLE *Ziel,char *Source)(a0,a1)
  340.  
  341.   Genau, die Umkehrfunktion. Sie wandelt einen String in eine doppeltgenaue
  342.   Fließkommazahl.
  343.  
  344.  
  345.   VOID Fak(DOUBLE *Ziel,LONG a)(a0,d0)
  346.   VOID NuK(DOUBLE *Ziel,LONG a,LONG b)(a0,d0,d1)
  347.  
  348.   Die erste Funktion ermittelt die Fakultät der Zahl a, die zweite Funktion
  349.   den Wert von "n über k". a und b sollten positive Zahlen sein.
  350.  
  351.  
  352.   APTR Init_Konst()()
  353.  
  354.   Diese  Funktion reserviert  einen Speicherbereich  für 26  Zahlen vom Typ
  355.   DOUBLE.
  356.  
  357.   LONG Set_Konst_P(APTR Zeiger,LONG Nummer,DOUBLE *Wert)(a0,d0,d1)
  358.  
  359.   Hier wird  die Zahl mit der Nummer  Nummer innerhalb des Speicherbereichs
  360.   auf den  Wert Wert  gesetzt.  Passierte ein  Fehler, dann  wird  NO_KONST
  361.   zurückgegeben, sonst 0.
  362.  
  363.  
  364.   VOID GetKonst_P(DOUBLE *Ziel,APTR Zeiger,LONG Nummer)(a0,a1,d1)
  365.  
  366.   Man will die Werte ja auch mal wieder auslesen können.....
  367.  
  368.  
  369.   VOID Free_Konst(APTR Zeiger)(a0)
  370.  
  371.   Und schließlich muß man den Speicher auch wieder freigeben können.
  372.  
  373.  
  374.   struct Block *Init_Mem(char *Zeiger)(a0)
  375.   LONG Init_Block(struct Block *Zeiger)(a0)
  376.   LONG PreCalc(struct Block *Zeiger,APTR Konstanten)(d0,d1)
  377.   LONG Calc_P(DOUBLE *Ziel,struct Block *Zeiger,DOUBLE *Wert)(a0,a1,a2)
  378.   VOID Free_Block(struct Block *Zeiger)(a0)
  379.  
  380.   Jetzt wirds  schwierig und interessant. Mit diesen  5 Funktionen kann man
  381.   recht  bequem und schnell  einen String auswerten und  bekommt dafür eine
  382.   Zahl  zurück. Der  String muß  eine korrekte  mathe. Funktion darstellen.
  383.   Erkannt   werden   die   4   Grundrechenarten   (+-*/),   Potenzen   (^),
  384.   Trigonometrische Funktionen ((a)sin,  (a)cos, (a)tan), log (Basis 10), ln
  385.   (Basis  e), abs  (Absolut),  sgn  (Vorzeichen), int  (Vorkomma)  und  sqr
  386.   (Wurzel).  Weiterhin ist vorbelegt  die Zeichenfolge pi  (3.141...) und e
  387.   (2.718...).  Eine  weitere  Sonderstellung  nimmt  x  ein.  Alle  anderen
  388.   Buchstaben (a-z) können als Konstanten benutzt werden. Zahlen in der Form
  389.   -1.2345  und -123e-4  werden  auch  erkannt (Alles  muß  kleingeschrieben
  390.   sein).
  391.  
  392.   Init_Mem() belegt den benötigten  Speicher im Rechner und gibt den Zeiger
  393.   darauf zurück.  Diesen Zeiger  braucht man  für alle  weiteren  Arbeiten.
  394.   Init_Block() "zerpflückt" die  Funktion. Zwischen Init_Mem und Init_Block
  395.   darf der Speicherbereich, in dem die Funktion steht, nicht angetastet und
  396.   auf  keinen Fall freigegeben  werden. Init_Mem merkt sich,  wo der String
  397.   steht und  Init_Block greift darauf zu.  Init_Block gibt einen Fehlerwert
  398.   zurück. Die  Bedeutung der einzelnen Bits ist  in Tool.h aufgeführt. Wird
  399.   NULL zurückgegeben, dann wurde  alles erkannt. Nach Init_Block() kann das
  400.   Programm mit dem Speicher für den String wieder machen, was es will......
  401.  
  402.   PreCalc() belegt  die in der Funktion gebrauchten  Konstanten (a-z ohne x
  403.   und e) mit Werten. Diese  holt sich die Funktion aus dem Speicherbereich,
  404.   den man  sich mit Init_Konst() anfordern kann.  Wird mit Set_Konst() eine
  405.   von der Funktion gebrauchte Konstante geändert, dann muß PreCalc() wieder
  406.   aufgerufen  werden. Außerdem  rechnet PreCalc schon  so weit,  wie zu dem
  407.   Zeitpunkt alles  bekannt ist.  Die  einzige Unbekannte  ist nur  noch  x.
  408.   Besteht die  Funktion nur  aus  Konstanten und  Zahlen, dann  steht  nach
  409.   PreCalc() in Zeiger->Wert bereits der Wert der Funktion.
  410.   HINWEIS: Die Routinen gehen an  die Funktion von hinten heran. Lautet die
  411.   Funktion z.B: x+1+2+3, dann wird das zerlegt in:
  412.         - Summe aus 3 und dem Bereich davor
  413.   Bereich davor in:
  414.         - Summe aus 2 und dem Bereich davor usw.
  415.  
  416.   Lautet die Funktion aber 1+2+3+x, dann wird die zerlegt in:
  417.         -  Summe aus x und  Bereich davor, und der  Bereich davor wird bereits
  418.   korrekt zu 6 bereichnet. Die  nächste Funktion braucht also nicht mehr so
  419.   viel zu rechnen, wenn man die Variable x immer möglichst weit nach hinten
  420.   schiebt.
  421.   PreCalc()  liefert wieder  einen  Fehlercode  zurück, z.B.  wenn  in  der
  422.   Funktion  die Wurzel  aus etwas negativen  (was dort  bereits als negativ
  423.   erkannt wird, x ist ja noch nicht bekannt) gezogen werden soll.
  424.  
  425.   Und jetzt die vorletzte und wichtigste Funktion:
  426.   Calc_P(). Sie benötigt zusätzlich  zu dem von Init_Mem gelieferten Zeiger
  427.   den Wert für  x und eine Variable, in der  sie das Ergebnis ablegen soll.
  428.   Calc_P() kann beliebig oft  mit unterschiedlichen Werten für x aufgerufen
  429.   werden. Geht  bei  der  Berechnung etwas  schief,  wird  in Ziel  eine  0
  430.   zurückgeliefert.  In Zeiger->Fehler steht, was  passiert ist, dieser Wert
  431.   wird auch zurückgegeben.
  432.  
  433.   FreeMem() schließlich gibt den benötigten Speicher wieder frei.
  434.  
  435.  
  436.   Wenn klar ist, daß von  einer Funktion nur ein Funktionswert zu bestimmen
  437.   ist,  dann ist der  Aufwand ein wenig groß.  Dafür gibt es  dann noch die
  438.   Funktion:
  439.  
  440.   VOID berechnen(DOUBLE *Ziel,char *string,
  441.                  DOUBLE *x,
  442.                  struct Konstanten *konstanten,
  443.                  LONG *fehler)(a0,d0,d1,d2,d3)
  444.   Hier wird  auf  einmal  alles nötige  übergeben.  Es  können aber  nur  4
  445.   Konstanten in  der  Struktur Konstanten  übergeben  werden. Es  kann  für
  446.   Konstanten auch  NULL angegeben  werden. In  Fehler werden  die  gleichen
  447.   Fehlercodes übergeben wie bei den Funktionen oben.
  448.  
  449.  
  450.   DIE HINWEISE IN TOOLLIBRARY.README BEACHTEN !!
  451.  
  452.  
  453.  
  454.  
  455.  
  456.