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