home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / amiga / programm / libs / lib_coll.lha / TOOLLIBR.ZOO / ToolLibrary / ToolLibrary.DOC < prev    next >
Text File  |  1990-11-02  |  19KB  |  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.