@database stormamiga_lib.guide @author "Matthias Henze" @$VER: stormamiga_lib.guide 3.0 (15.08.98) @SMARTWRAP @index guideIndex /// Inhalt @node Main Inhalt @{jcenter} @{b}@{fg shine}stormamiga.lib Version 44.01 ( 15.08.1998 )@{par} Kopierrecht © 1996/98 bei CyberdyneSystems@{par} geschrieben von Matthias Henze@{fg text}@{ub}@{par} @{b}@{FG fill}S H A R E W A R E@{FG text}@{ub} @{code}@{jleft} @{" Einleitung " link Einleitung} Informationen über die stormamiga.lib. @{" Besonderheiten " link Besonderheiten} Was ist an der stormamiga.lib so besonders? @{" Systemanforderungen " link Systemanforderungen} Was braucht man für die stormamiga.lib? @{" Installation " link Installation} Wie installiere ich die stormamiga.lib? @{" Funktionen " link Funktionen} Beschreibung der einzelnen Funktionen. @{" Anwendungshinweise " link Anwendungshinweise} Tips und Tricks zur Anwendung. @{" Beispiele " link Beispiele} Beschreibung der Beispielprogramme. @{" Bekannte Fehler " link "Bekannte Fehler"} Wo gibt es Probleme? @{" Updates " link Updates} Wo gibt es neue Versionen? @{" Einschränkungen " link Einschränkungen} Was funktioniert in der Demo-Version nicht? @{" Registrierung " link Registrierung} Wie kann ich mich registrieren? @{" Kopierrecht " link Kopierrecht} Das Rechtliche. @{" Geschichte " link Geschichte} Was hat sich bisher getan? @{" In Zukunft " link Zukunft} Was wird sich noch ändern? @{" Danksagungen " link Danksagungen} Danksagungen an ... . @{" Autor " link Autor} Wie erreicht man den Autor? @{" Index " link guideIndex} Das Stichwortverzeichnis. @endnode /// /// Einleitung @node Einleitung @{b}@{fg shine}Einleitung:@{par} ~~~~~~~~~~~@{fg text}@{ub}@{par} Die "stormamiga.lib" ist eine Linkerbibliothek für StormC. Sie ist ein Ersatz für die Linkerbibliotheken "amiga.lib", "storm020.lib", "math020.lib", "math881.lib", "math040.lib", "math060.lib" und den Startupcode "startup.o". Bei StormC Version 3.x werden noch die Linkerbibliotheken "stormclibstartup020.lib", "stormcstartup020.lib" und "stormcsupport020.lib" ersetzt.@{par} Die "stormamiga.lib" ist komplett in Assembler geschrieben. Dadurch werden die damit gelinkten Programme auch sehr klein und schnell.@{par} Mein Ziel ist es, alle Funktionen der "amiga.lib", die nicht in den Pragmadateien enthalten sind, und alle Funktionen der "storm.lib", außer Funktionen im kleinen Datenmodell a6, durch kurze und schnelle Assemblerroutinen zu ersetzen. Außerdem will ich einige Spezialbefehle von anderen Compilern (GNU C, SAS C, DICE, Maxon C++) und einige Routinen, die das Programmieren erleichtern, in die "stormamiga.lib" integrieren.@{par} @{b}Entstehungsgeschichte:@{ub}@{par} Da die Funktionen der "storm.lib" in C geschrieben sind, werden die damit gelinkten Programme sehr groß und langsam. Die Funktionen der "amiga.lib" sind auch nicht gerade klein und schnell.@{par} Aus diesem Grund habe ich mich am 18.03.1996 entschlossen die "stormamiga.lib" zu schreiben.@{par} @endnode /// /// Besonderheiten @node Besonderheiten @{b}@{fg shine}Ein paar Besonderheiten der "stormamiga.lib":@{par} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@{fg text}@{ub}@{par} @{b}1.)@{ub}@{par} komplett in Assembler geschrieben; dadurch werden die mit der "stormamiga.lib" gelinkten Programme sehr klein und schnell@{par} @{b}2.)@{ub}@{par} spezielle Versionen des @{" Startupcodes " link Startupcode} für das große und kleine Codemodell in "ANSI C" und "C++"; dadurch werden die Programme noch etwas kürzer@{par} @{b}3.)@{ub}@{par} spezielle Versionen der "stormamiga.lib" für MC68EC020+, MC68881+, MC68040+ und MC68060; die "stormamiga_040.lib" ist bis zu 22 mal so schnell wie die "math040.lib" und natürlich auch wesentlich kleiner@{par} @{b}4.)@{ub}@{par} Unterstützung des kleinen Codemodelles; damit können Sie auch das letzte Byte aus Ihrem Programm herausholen@{par} @{b}5.)@{ub}@{par} die "stormamiga.lib" enthält viele @{" Funktionen " link Funktionen} (z.B.: "access", "chdir", "sleep", "strdup", "isnan" usw.) von Unix und Posix, einige Spezialfunktionen (z.B.: "strbpl", "strins" usw.) der Compiler GNU C, SAS C, DICE und Maxon C++ und unterstützt Pfadangaben im Unix-Format; dadurch wird der Umstieg von anderen Compilern wesentlich erleichtert@{par} @{b}6.)@{ub}@{par} durch Definition von @{" STORMAMIGA_INLINE " link Inlinefunktionen} können für viele Funktionen (z.B.: "putc", "GetAPen" usw.) sehr kurze und schnelle Inlinefunktionen verwendet werden@{par} @{b}7.)@{ub}@{par} durch Definition von @{" STORMAMIGA_STACK " link STORMAMIGA_STACK} xxxx (xxxx steht für die Stackgröße) kann die Stackgröße, mit der ein Programm arbeiten soll, definiert werden@{par} @{b}8.)@{ub}@{par} die mit der "stormamiga.lib" gelinkten Programme sind, wenn @{" STORMAMIGA_NOWB " link STORMAMIGA_NOWB} nicht definiert ist, automatich von der Workbench startbar@{par} @{b}9.)@{ub}@{par} die "stormamiga.lib" enthält einige funktionsreduzierte (ohne mathematische Unterstützung) @{" Funktionen " link Funktionen} (z.B.: "printf_", "scanf_" usw.); dadurch werden die Programme wesentlich kürzer und etwas schneller@{par} @{b}10.)@{ub}@{par} durch Definition von @{" STORMAMIGA_OS3 " link "OS3 Funktionen"} können für viele Funktionen (z.B.: "malloc", "free" usw.) speziel für AmigaOS 3.x optimierte Versionen verwendet werden@{par} @{b}11.)@{ub}@{par} Unterstützung von Umlauten (z.B.: "islower_d", "toupper_d" usw.) und Ausgabe von deutschen Texten (z.B.: "strftime_d", "asctime_d" usw.); siehe @{" Deutsche Funktionen " link "Deutsche Funktionen"}@{par} @{b}12.)@{ub}@{par} die "stormamiga.lib" enthält einige Spezialfunktionen (z.B.: "button", "max_Width" usw.); dadurch wird z.B. die Verwendung einer Mausabfrage, oder das Ermitteln der sichtbaren Fensterbreite auch für Anfänger, extrem einfach; siehe @{" Funktionen " link Funktionen}@{par} @{b}13.)@{ub}@{par} die "stormamiga.lib" ist sehr preiswert@{par} @endnode /// /// Systemanforderungen @node Systemanforderungen @{code}@{b}@{fg shine}Systemanforderungen: ~~~~~~~~~~~~~~~~~~~~@{fg text}@{ub} - Ein Amiga - AmigaOS 2.0 (V37) oder höher - MC68EC020 oder höher - StormC V.2.0 oder höher @endnode /// /// Installation @node Installation @{b}@{fg shine}Installation:@{par} ~~~~~~~~~~~~~@{fg text}@{ub}@{par} Obwohl es von der "stormamiga.lib" mehrere Versionen, mit unterschiedlichen Namen ("stormamiga.lib", "stormamiga_nc.lib" usw.) gibt, verwende ich meistens den allgemeinen Namen "stormamiga.lib". Für die Startupcodes "stormamiga_startups.o", "stormamiga_nc_startups.o" usw. verwende ich meistens den allgemeinen Namen "stormamiga_startups.o".@{par} Die Installation der "stormamiga.lib" wird mit dem Installer durchgeführt und ist sehr einfach. Die einzige Bedingung ist, daß StormC bereits erfolgreich installiert wurde.@{par} Starten Sie das Installationsprogramm "HD-Install_xxx" (xxx steht für Ihre bevorzugte Sprache) und führen Sie die Installation nach Ihren Wünschen und Anforderungen durch.@{par} Wurde die Installation erfolgreich durchgeführt, dann muß StormC gestartet und einige Änderungen an der Konfiguration vorgenommmen werden. Öffnen Sie ein vorhandenes Projekt oder erstellen Sie ein neues Projekt und fügen Sie die "stormamiga.lib" an erster Stelle in dieses Projekt ein. Bei Shared Libraries muß die "stormamiga_library.lib" noch vor der "stormamiga.lib" in das Projekt eingefügt werden. Wenn Sie das kleine Codemodell nutzen wollen, dann sollten Sie die nc-Versionen der "stormamiga.lib" (z.B.: "stormamiga_nc.lib"), die speziell für das kleine Codemodell optimiert sind, verwenden.@{par} Als nächstes müssen Sie noch einen Startupcode auswählen. Dazu müssen Sie den Menüpunkt "Linkeroptionen" des Menüs "Einstellungen", auswählen, die Option "Eigener Startup-Code" einschalten und den gewünschten Startupcode (z.B.: "stormamiga_startups+.o" für C oder "stormamiga_C++_startups+.o" für C++) auswählen.@{par} Wenn Sie die Spezialfunktionen der "stormamiga.lib" nutzen wollen, müssen Sie noch die Inkluddatei "stormamiga.h", mit "#include ", in Ihren Quelltext einbinden. Als letztes müssen Sie noch @{" STORMAMIGA " link STORMAMIGA} definieren.@{par} @endnode /// /// Funktionsübersicht @node Funktionsübersicht @{b}@{fg shine}Auflistung aller vorhandenen Funktionen:@{par} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@{fg text}@{ub}@{par} @{fg shine}Funktionen der "stormamiga.lib", "stormamiga_nc.lib", "stormamiga_881.lib", "stormamiga_nc_881.lib", "stormamiga_040.lib", "stormamiga_nc_040.lib", "stormamiga_060.lib" und "stormamiga_nc_060.lib"@{fg text}@{par} @{" amiga.lib Funktionen " link "amiga.lib Funktionen"}@{" assert Funktionen " link "assert Funktionen"}@{" ctype Funktionen " link "ctype Funktionen"} @{" dirent Funktionen " link "dirent Funktionen"}@{" fcntl Funktionen " link "fcntl Funktionen"}@{" interne Funktionen " link "interne Funktionen"} @{" Klasse filebuf " link "Klasse filebuf"}@{" Klasse fstream " link "Klasse fstream"}@{" Klasse ifstream " link "Klasse ifstream"} @{" Klasse ios " link "Klasse ios"}@{" Klasse istream " link "Klasse istream"}@{" Klasse ofstream " link "Klasse ofstream"} @{" Klasse ostream " link "Klasse ostream"}@{" Klasse streambuf " link "Klasse streambuf"}@{" math Funktionen " link "math Funktionen"} @{" new Funktionen " link "new Funktionen"}@{" resource Funktionen " link "resource Funktionen"}@{" setjmp Funktionen " link "setjmp Funktionen"} @{" signal Funktionen " link "signal Funktionen"}@{" sonstige Funktionen " link "sonstige Funktionen"}@{" spezial Funktionen " link "spezial Funktionen"} @{" stat Funktionen " link "stat Funktionen"}@{" stdio Funktionen " link "stdio Funktionen"}@{" stdlib Funktionen " link "stdlib Funktionen"} @{" string Funktionen " link "string Funktionen"}@{" time Funktionen " link "time Funktionen"}@{" unistd Funktionen " link "unistd Funktionen"}@{par} @{fg shine}Funktionen der "stormamiga-library.lib" und "stormamiga-library_nc.lib"@{fg text}@{par} @{" interne Funktionen " link interne-lib-Funktionen}@{" new Funktionen " link new-lib-Funktionen}@{" sonstige Funktionen " link sonstige-lib-Funktionen} @{" stdlib Funktionen " link stdlib-lib-Funktionen}@{" time Funktionen " link time-lib-Funktionen}@{" unistd Funktionen " link unistd-lib-Funktionen}@{par} @endnode @node "amiga.lib Funktionen" @{code}@{fg shine}amiga.lib Funktionen@{fg text} AddTOF() ArgArrayDone() ArgArrayInit() ArgInt() ArgString() BeginIO() CallHook() CallHookA() CoerceMethod() CoerceMethodA() CreatePort() CreateTask() CreateExtIO() CreateStdIO() DeleteExtIO() DeletePort() DeleteStdIO() DeleteTask() DoMethod() DoMethodA() DoSuperMethod() DoSuperMethodA() FastRand() FreeIEvents() HookEntry() HotKey() InvertString() LibAllocPooled() LibCreatePool() LibDeletePool() LibFreePooled() NewList() RangeRand() RemTOF() SetSuperAttrs() SPRINTF() TimeDelay() VSPRINTF() waitbeam() @endnode @node "assert Funktionen" @{code}@{fg shine}assert Funktionen@{fg text} assert() assert_() do_assert() do_assert_() @endnode @node "ctype Funktionen" @{code}@{fg shine}ctype Funktionen@{fg text} isalnum() isalnum_d() isalpha() isalpha_d() iscntrl() isdigit() isgraph() islower() islower_d() isprint() isprint_d() ispunct() ispunct_d() isspace() isupper() isupper_d() isxdigit() tolower() tolower_d() toupper() toupper_d() which_xdigit() @endnode @node "dirent Funktionen" @{code}@{fg shine}dirent Funktionen@{fg text} closedir() opendir() readdir() rewinddir() @endnode @node "interne Funktionen" @{code}@{fg shine}interne Funktionen@{fg text} Add64() blocksize_a2_d2() Cmp64() dotimer() exitNearData() EXIT_0_Main() EXIT_4_free() EXIT_4_free_3() EXIT_9_AtExitFunktionenCaller EXIT_9_Stack() geta4() GetBaseReg() initNearData() INIT_0_InitExceptionHandling INIT_5_clock() INIT_5_timer INIT_9_Stack() lib_64bit_shl() lib_64bit_shr() lib_catch() lib_catchclass() lib_destruct() lib_destruct_a0() lib_rethrow() lib_throw() main() (Ansi C) main() (C++) main__() Neg64() SDiv64() SDivMod64() set_terminate() set_unexpected() SMod64() SMult64() Sub64() terminate() UDiv64() UDivMod64() UMod64() UMult64() unexpected() wbmain() (Ansi C) wbmain() (C++) wbmain_() (Ansi C) wbmain_() (C++) @{b}Autolib Funktionen@{ub} EXIT_3_AmigaGuideBase() EXIT_2_AslBase() EXIT_3_BulletBase() EXIT_3_ColorWheelBase() EXIT_2_CxBase() EXIT_3_DataTypesBase() EXIT_2_DiskfontBase() EXIT_1_DOSBase() EXIT_2_ExpansionBase() EXIT_2_GadToolsBase() EXIT_3_GradientSliderBase() EXIT_2_GfxBase() EXIT_2_IconBase() EXIT_2_IFFParseBase() EXIT_2_IntuitionBase() EXIT_2_KeymapBase() EXIT_2_LayersBase() EXIT_3_LocaleBase() EXIT_3_LowLevelBase() EXIT_2_MathBase() EXIT_2_MathIeeeDoubBasBase() EXIT_2_MathIeeeDoubTransBase() EXIT_2_MathIeeeSingBasBase() EXIT_2_MathIeeeSingTransBase() EXIT_2_MathTransBase() EXIT_2_MUIMasterBase() EXIT_3_NVBase() EXIT_3_RealTimeBase() EXIT_2_ReqToolsBase() EXIT_2_RexxSysBase() EXIT_3_TranslatorBase() EXIT_1_UtilityBase() EXIT_2_VersionBase() EXIT_2_WizardBase() EXIT_2_WorkbenchBase() INIT_3_AmigaGuideBase() INIT_2_AslBase() INIT_3_BulletBase() INIT_3_ColorWheelBase() INIT_2_CxBase() INIT_3_DataTypesBase() INIT_2_DiskfontBase() INIT_1_DOSBase() INIT_2_ExpansionBase() INIT_2_GadToolsBase() INIT_3_GradientSliderBase() INIT_2_GfxBase() INIT_2_IconBase() INIT_2_IFFParseBase() INIT_2_IntuitionBase() INIT_2_KeymapBase() INIT_2_LayersBase() INIT_3_LocaleBase() INIT_3_LowLevelBase() INIT_2_MathBase() INIT_2_MathIeeeDoubBasBase() INIT_2_MathIeeeDoubTransBase() INIT_2_MathIeeeSingBasBase() INIT_2_MathIeeeSingTransBase() INIT_2_MathTransBase() INIT_2_MUIMasterBase() INIT_3_NVBase() INIT_3_RealTimeBase() INIT_2_ReqToolsBase() INIT_2_RexxSysBase() INIT_3_TranslatorBase() INIT_1_UtilityBase() INIT_2_VersionBase() INIT_2_WizardBase() INIT_2_WorkbenchBase() @{b}IO Funktionen@{ub} amigaclose() amigaeof() amigaflush() amigagetc() amigagetcunget() amigaopen() amigaputc() amigaread() amigareadunget() amigaseek() amigaungetc() amigawrite() double_in() double_out() EXIT_5_fstream() EXIT_5_InitFiles() EXIT_5_InitStdIOFiles() EXIT_6_InitPOSIXIOFiles() EXIT_9_chdir() form_in() form_in64() form_in_() form_in64_() form_out() form_out64() form_out_() form_out64_() getch() INIT_0_InitFiles() INIT_0_NEAR_CODE_StdioFiles() INIT_5_fstream() INIT_5_InitStdIOFiles() INIT_6_InitPOSIXIOFiles() INIT_9_chdir() putch() udiv_64() ungetch() UnixToAmigaPath() un_signed_out() @{b}math Funktionen@{ub} (nur in den Versionen für MC68EC020+) lib_double2float() lib_double2int() lib_float2double() lib_float2int() lib_float_add() lib_float_cmp() lib_float_div() lib_float_mult() lib_float_neg() lib_float_sub() lib_float_tst() lib_int2double() lib_int2float() @{b}interne Daten@{ub} AmigaGuideBase AslBase BulletBase ColorWheelBase CxBase DataTypesBase DiskfontBase DOSBase errno ExpansionBase fileList GadToolsBase GradientSliderBase GfxBase IconBase IFFParseBase IntuitionBase KeymapBase LayersBase LocaleBase LowLevelBase MathBase MathIeeeDoubBasBase MathIeeeDoubTransBase MathIeeeSingBasBase MathIeeeSingTransBase MathTransBase MUIMasterBase NVBase RealTimeBase ReqToolsBase RexxSysBase SaveSP signal_dat std__err std__in std__out tmpnamList tmpnamNext TranslatorBase UtilityBase VersionBase WBMsg WizardBase WorkbenchBase __ctypetable @endnode @node "Klasse filebuf" @{code}@{FG shine}Klasse filebuf@{FG text} @{b}Konstruktoren@{ub} filebuf::filebuf() @{b}Destruktoren@{ub} filebuf::~filebuf() @{b}Methoden@{ub} filebuf *open(const char *, int) filebuf *filebuf::close() filebuf::seekoff(long, enum seek_dir__ios, int) filebuf::seekpos(streampos, int) filebuf::setbuf(char *, uint) filebuf::sync() filebuf::doallocate() filebuf::overflow(int) filebuf::underflow() filebuf::xsputn(cchar *, int) filebuf::xsgetn(char *, int) filebuf::pbackfail(int) @endnode @node "Klasse fstream" @{code}@{FG shine}Klasse fstream@{FG text} @{b}Konstruktoren@{ub} fstream::fstream() fstream::fstream(cchar *, int) @{b}Methoden@{ub} fstream::open(const char *, int) fstream::close() fstream::setbuf(char *, uint) @endnode @node "Klasse ifstream" @{code}@{FG shine}Klasse ifstream@{FG text} @{b}Konstruktoren@{ub} ifstream::ifstream() ifstream::ifstream(cchar *, int) @{b}Methoden@{ub} ifstream::open(const char *, int) ifstream::close() ifstream::setbuf(char *, uint) @endnode @node "Klasse ifstream" @{code}@{FG shine}Klasse ifstream@{FG text} @{b}Konstruktoren@{ub} ifstream::ifstream() ifstream::ifstream(cchar *, int) @{b}Methoden@{ub} ifstream::open(const char *, int) ifstream::close() ifstream::setbuf(char *, uint) @endnode @node "Klasse ios" @{code}@{FG shine}Klasse ios@{FG text} @{b}Methoden@{ub} ios::bitalloc() ios::init(streambuf *) ios::xalloc() @{b}Flags@{ub} dec(ios &) hex(ios &) oct(ios &) @endnode @node "Klasse istream" @{code}@{FG shine}Klasse istream@{FG text} @{b}Konstruktoren@{ub} istream::istream(streambuf *b) @{b}Methoden@{ub} istream::ipfx(int) istream::get() istream::peek() istream::operator >>(char &) istream::operator >>(uchar &) istream::operator >>(schar &) istream::operator >>(uchar *) istream::operator >>(schar *) istream::operator >>(char *) istream::operator >>(short &) istream::operator >>(ushort &) istream::operator >>(int &) istream::operator >>(uint &) istream::operator >>(long &) istream::operator >>(ulong &) istream::operator >>(float &) istream::operator >>(double &) istream::operator >>(long double &) istream::operator >>(istream &(*f)(istream &)) istream::operator >>(ios &(*f)(ios &)) istream::get(char *, int, char) istream::get(uchar *, int, char) istream::get(schar *, int, char) istream::get(schar &) istream::get(uchar &) istream::get(char &) istream::getline(char *, int, char) istream::getline(uchar *, int, char) istream::getline(schar *, int, char) istream::ignore(int, int) istream::read(uchar *, int) istream::read(schar *, int) istream::read(char *, int) istream::seekg(streampos) istream::seekg(streamoff, enum seek_dir__ios) isteam &ws(istream &) @endnode @node "Klasse ofstream" @{code}@{FG shine}Klasse ofstream@{FG text} @{b}Konstruktoren@{ub} ofstream::ofstream() ofstream::ofstream(const char *, int) @{b}Methoden@{ub} ofstream::open(const char *, int) ofstream::close() ofstream::setbuf(char *, uint) @endnode @node "Klasse ostream" @{code}@{FG shine}Klasse ostream@{FG text} @{b}Konstruktoren@{ub} ostream::ostream(streambuf *) @{b}Methoden@{ub} ostream::opfx() ostream::osfx() ostream::operator <<(schar) ostream::operator <<(uchar) ostream::operator <<(char) ostream::operator <<(cuchar *) ostream::operator <<(cschar *) ostream::operator <<(cchar *) ostream::operator <<(short) ostream::operator <<(ushort) ostream::operator <<(int) ostream::operator <<(uint) ostream::operator <<(long) ostream::operator <<(ulong) ostream::operator <<(float) ostream::operator <<(double) ostream::operator <<(void *) ostream::flush(); ostream::seekp(streampos, enum seek_dir__ios) ostream::seekp(streamoff, enum seek_dir__ios) ends(ostream &) endl(ostream &) @endnode @node "Klasse streambuf" @{code}@{FG shine}Klasse streambuf@{FG text} @{b}Konstruktoren@{ub} streambuf::streambuf() streambuf::streambuf(char *, int) @{b}Destruktoren@{ub} streambuf::~streambuf() @{b}Methoden@{ub} streambuf *streambuf::setbuf(char *, ulong) streambuf::setbuffer(char *, ulong, int) streambuf::doallocate() streambuf::sgetn(char *, int) streambuf::sputn(cchar *, int) streambuf::overflow(int) streambuf::underflow() streambuf::xsgetn(char *, int) streambuf::xsputn(cchar *, int) @endnode @node "math Funktionen" @{code}@{fg shine}math Funktionen@{fg text} acos() asin() atan() atan2() ceil() cos() cosh() exp() fabs() floor() fmod() frexp() isinf() isnan() ldexp() log() log10() modf() pow() sin() sinh() sqrt() tan() tanh() @endnode @node "new Funktionen" @{code}@{fg shine}new Funktionen@{fg text} set_new_handler() @endnode @node "resource Funktionen" @{code}@{fg shine}resource Funktionen@{fg text} getrusage() @endnode @node "setjmp Funktionen" @{code}@{fg shine}setjmp Funktionen@{fg text} longjmp() setjmp() @endnode @node "signal Funktionen" @{code}@{fg shine}signal Funktionen@{fg text} raise() signal() @endnode @node "sonstige Funktionen" @{code}@{FG shine}sonstige Funktionen@{FG text} cinfilebuf::cinfilebuf() cinfilebuf::~cinfilebuf() coutfilebuf::coutfilebuf() coutfilebuf::~coutfilebuf() operator new(size_t) operator delete(void, size_t) @endnode @node "spezial Funktionen" @{code}@{fg shine}spezial Funktionen@{fg text} button() button_al() button_ar() button_bl() button_br() divs64() divsl() divu64() divul() max_Height() max_Width() muls() muls64() mulu() mulu64() waitbutton() waitbutton_al() waitbutton_ar() waitbutton_bl() waitbutton_br() @endnode @node "stat Funktionen" @{code}@{fg shine}stat Funktionen@{fg text} chmod() fstat() lstat() mkdir() stat() @endnode @node "stdio Funktionen" @{code}@{fg shine}stdio Funktionen@{fg text} clearerr() fclose() feof() ferror() fflush() fgetc() fgetpos() fgets() fopen() fprintf() fprintf64() fprintf_() fprintf64_() fputc() fputs() fputstr() fread() freopen() fscanf() fscanf64() fscanf_() fscanf64_() fseek() fsetpos() ftell() fwrite() getc() getchar() gets() getw() perror() printf() printf64() printf_() printf64_() putc() putchar() puts() putw() remove() rename() rewind() scanf() scanf64() scanf_() scanf64_() setbuf() setbuffer() setlinebuf() setvbuf() snprintf() snprintf64() snprintf_() snprintf64_() sprintf() sprintf64() sprintf_() sprintf64_() sscanf() sscanf64() sscanf_() sscanf64_() tmpfile() tmpnam() ungetc() vfprintf() vfprintf64() vfprintf_() vfprintf64_() vfscanf() vfscanf64() vfscanf_() vfscanf64_() vprintf() vprintf64() vprintf_() vprintf64_() vscanf() vscanf64() vscanf_() vscanf64_() vsnprintf() vsnprintf64() vsnprintf_() vsnprintf64_() vsprintf() vsprintf64() vsprintf_() vsprintf64_() vsscanf() vsscanf64() vsscanf_() vsscanf64_() @endnode @node "stdlib Funktionen" @{code}@{fg shine}stdlib Funktionen@{fg text} abort() abort__STANDARD() abs() atexit() atof() atoi() atol() atoll() bsearch() calloc() div() exit() free() free_3() getenv() inttostr() labs() ldiv() llabs() llongtostr() malloc() malloc_3() qsort() rand() realloc() srand() strtod() strtol() strtoll() strtoul() strtoull() system() uinttostr() ullongtostr() @endnode @node "string Funktionen" @{code}@{fg shine}string Funktionen@{fg text} bcmp() bcopy() bzero() ffs() index() memccpy() memchr() memcmp() memcpy() memmove() memset() rindex() stpchr() stpcpy() strbpl() strcasecmp() strcasecmp_d() strcat() strchr() strcmp() strcpy() strcspn() strdup() strerror() stricmp() stricmp_d() strins() strlen() strlower() strlower_d() strlwr() strlwr_d() strncasecmp() strncasecmp_d() strncat() strncmp() strncpy() strncpyn() strnicmp() strnicmp_d() strpbrk() strrchr() strsep() strspn() strstr() strtok() strupper() strupper_d() strupr() strupr_d() strxfrm() swab() @endnode @node "time Funktionen" @{code}@{fg shine}time Funktionen@{fg text} asctime() asctime_d() clock() ctime() ctime_d() difftime() gmtime() mktime() strftime() strftime_d() time() times() utime() utimes() @endnode @node "unistd Funktionen" @{code}@{fg shine}unistd Funktionen@{fg text} access() chdir() close() getcwd() getwd() lseek() mktemp() read() rmdir() sleep() unlink() usleep() write() @endnode @node "fcntl Funktionen" @{code}@{fg shine}fcntl Funktionen@{fg text} creat() open() @endnode @node interne-lib-Funktionen "interne Funktionen" @{code}@{fg shine}interne Funktionen@{fg text} EXIT_4_free() EXIT_4_free_3() EXIT_9_Stack() INIT_5_clock() INIT_9_Stack() @{b}shared-Librarie Funktionen@{ub} abortLibInit() LibClose() LibExpunge() LibInit() LibInitError() LibNull() LibOpen() __LibClose() __LibOpen() @{b}Autolib Funktionen@{ub} EXIT_3_AmigaGuideBase() EXIT_2_AslBase() EXIT_3_BulletBase() EXIT_3_ColorWheelBase() EXIT_2_CxBase() EXIT_3_DataTypesBase() EXIT_2_DiskfontBase() EXIT_1_DOSBase() EXIT_2_ExpansionBase() EXIT_2_GadToolsBase() EXIT_3_GradientSliderBase() EXIT_2_GfxBase() EXIT_2_IconBase() EXIT_2_IFFParseBase() EXIT_2_IntuitionBase() EXIT_2_KeymapBase() EXIT_2_LayersBase() EXIT_3_LocaleBase() EXIT_3_LowLevelBase() EXIT_2_MathBase() EXIT_2_MathIeeeDoubBasBase() EXIT_2_MathIeeeDoubTransBase() EXIT_2_MathIeeeSingBasBase() EXIT_2_MathIeeeSingTransBase() EXIT_2_MathTransBase() EXIT_2_MUIMasterBase() EXIT_3_NVBase() EXIT_3_RealTimeBase() EXIT_2_ReqToolsBase() EXIT_2_RexxSysBase() EXIT_3_TranslatorBase() EXIT_1_UtilityBase() EXIT_2_VersionBase() EXIT_2_WizardBase() EXIT_2_WorkbenchBase() INIT_3_AmigaGuideBase() INIT_2_AslBase() INIT_3_BulletBase() INIT_3_ColorWheelBase() INIT_2_CxBase() INIT_3_DataTypesBase() INIT_2_DiskfontBase() INIT_1_DOSBase() INIT_2_ExpansionBase() INIT_2_GadToolsBase() INIT_3_GradientSliderBase() INIT_2_GfxBase() INIT_2_IconBase() INIT_2_IFFParseBase() INIT_2_IntuitionBase() INIT_2_KeymapBase() INIT_2_LayersBase() INIT_3_LocaleBase() INIT_3_LowLevelBase() INIT_2_MathBase() INIT_2_MathIeeeDoubBasBase() INIT_2_MathIeeeDoubTransBase() INIT_2_MathIeeeSingBasBase() INIT_2_MathIeeeSingTransBase() INIT_2_MathTransBase() INIT_2_MUIMasterBase() INIT_3_NVBase() INIT_3_RealTimeBase() INIT_2_ReqToolsBase() INIT_2_RexxSysBase() INIT_3_TranslatorBase() INIT_1_UtilityBase() INIT_2_VersionBase() INIT_2_WizardBase() INIT_2_WorkbenchBase() @{b}IO Funktionen@{ub} EXIT_5_fstream() EXIT_5_InitFiles() EXIT_5_InitStdIOFiles() EXIT_6_InitPOSIXIOFiles() EXIT_9_chdir() INIT_0_InitFiles() INIT_0_NEAR_CODE_StdioFiles() INIT_5_fstream() INIT_5_InitStdIOFiles() INIT_6_InitPOSIXIOFiles() INIT_9_chdir() @{b}interne Daten@{ub} AmigaGuideBase AslBase BulletBase ColorWheelBase CxBase DataTypesBase DiskfontBase DOSBase ExpansionBase fileList GadToolsBase GradientSliderBase GfxBase IconBase IFFParseBase IntuitionBase KeymapBase LayersBase LocaleBase LowLevelBase MathBase MathIeeeDoubBasBase MathIeeeDoubTransBase MathIeeeSingBasBase MathIeeeSingTransBase MathTransBase MUIMasterBase NVBase RealTimeBase ReqToolsBase RexxSysBase std__err std__in std__out tmpnamList tmpnamNext TranslatorBase UtilityBase VersionBase WizardBase WorkbenchBase @endnode @node new-lib-Funktionen "new Funktionen" @{code}@{fg shine}new Funktionen@{fg text} set_new_handler() @endnode @node sonstige-lib-Funktionen "sonstige Funktionen" @{code}@{FG shine}sonstige Funktionen@{FG text} operator new(size_t) operator delete(void, size_t) @endnode @node stdlib-lib-Funktionen "stdlib Funktionen" @{code}@{fg shine}stdlib Funktionen@{fg text} free() free_3() malloc() malloc_3() @endnode @node time-lib-Funktionen "time Funktionen" @{code}@{fg shine}time Funktionen@{fg text} clock() @endnode @node unistd-lib-Funktionen "unistd Funktionen" @{code}@{fg shine}unistd Funktionen@{fg text} chdir() @endnode /// /// Funktionen @node Funktionen @{b}@{fg shine}Die Funktionen der "stormamiga.lib":@{par} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@{fg text}@{ub}@{par} @{" Funktionsübersicht " link Funktionsübersicht}@{par} Da die normalen Ansi-C und C++ Funktionen bereits bei StormC beschrieben werden, erkläre ich nur die Spezialfunktionen.@{par} @{" main__() " link main__()}@{" Startupcode " link Startupcode}@{" wbmain() " link wbmain()}@{par} @{fg shine}AmigaDOS stdio Funktionen@{par} @{" SPRINTF " link SPRINTF}@{" VSPRINTF " link VSPRINTF}@{par} stdio Funktionen@{par} @{" fprintf64 " link fprintf64}@{" fprintf_ " link fprintf_}@{" fprintf64_ " link fprintf64_}@{" fscanf64 " link fscanf64} @{" fscanf_ " link fscanf_}@{" fscanf64_ " link fscanf64_}@{" getw " link getw}@{" printf64 " link printf64} @{" printf_ " link printf_}@{" printf64_ " link printf64_}@{" putw " link putw}@{" scanf64 " link scanf64} @{" scanf_ " link scanf_}@{" scanf64_ " link scanf64_}@{" setbuffer " link setbuffer}@{" setlinebuf " link setlinebuf} @{" snprintf " link snprintf}@{" snprintf64 " link snprintf64}@{" snprintf_ " link snprintf_}@{" snprintf64_ " link snprintf64_} @{" sprintf64 " link sprintf64}@{" sprintf_ " link sprintf_}@{" sprintf64_ " link sprintf64_}@{" sscanf64 " link sscanf64} @{" sscanf_ " link sscanf_}@{" sscanf64_ " link sscanf64_}@{" vfprintf64 " link vfprintf64}@{" vfprintf_ " link vfprintf_} @{" vfprintf64_ " link vfprintf64_}@{" vfscanf " link vfscanf}@{" vfscanf64 " link vfscanf64}@{" vfscanf_ " link vfscanf_} @{" vfscanf64_ " link vfscanf64_}@{" vprintf64 " link vprintf64}@{" vprintf_ " link vprintf_}@{" vprintf64_ " link vprintf64_} @{" vscanf " link vscanf}@{" vscanf64 " link vscanf64}@{" vscanf_ " link vscanf_}@{" vscanf64_ " link vscanf64_} @{" vsnprintf " link vsnprintf}@{" vsnprintf64 " link vsnprintf64}@{" vsnprintf_ " link vsnprintf_}@{" vsnprintf64_ " link vsnprintf64_} @{" vsprintf64 " link vsprintf64}@{" vsprintf_ " link vsprintf_}@{" vsprintf64_ " link vsprintf64_}@{" vsscanf " link vsscanf} @{" vsscanf64 " link vsscanf64}@{" vsscanf_ " link vsscanf_}@{" vsscanf64_ " link vsscanf64_}@{par} unistd Funktionen@{par} @{" access " link access}@{" chdir " link chdir}@{" close " link close}@{" getcwd " link getcwd} @{" getwd " link getwd}@{" lseek " link lseek}@{" mktemp " link mktemp}@{" read " link read} @{" rmdir " link rmdir}@{" sleep " link sleep}@{" unlink " link unlink}@{" usleep " link usleep} @{" write " link write}@{par} fcntl Funktionen@{par} @{" creat " link creat}@{" open " link open}@{par} dirent Funktionen@{par} @{" closedir " link closedir}@{" opendir " link opendir}@{" readdir " link readdir}@{" rewinddir " link rewinddir}@{par} stat Funktionen@{par} @{" chmod " link chmod}@{" fstat " link fstat}@{" lstat " link lstat}@{" mkdir " link mkdir} @{" stat " link stat}@{par} string Funktionen@{par} @{" bcmp " link bcmp}@{" bcopy " link bcopy}@{" bzero " link bzero}@{" ffs " link ffs} @{" index " link index}@{" memccpy " link memccpy}@{" rindex " link rindex}@{" stpchr " link stpchr} @{" stpcpy " link stpcpy}@{" strbpl " link strbpl}@{" strcasecmp " link strcasecmp}@{" strcasecmp_d " link strcasecmp_d} @{" strcoll " link strcoll}@{" strdup " link strdup}@{" stricmp_d " link stricmp_d}@{" strins " link strins} @{" strlower " link strlower}@{" strlower_d " link strlower_d}@{" strlwr_d " link strlwr_d}@{" strncasecmp " link strncasecmp} @{" strncasecmp_d " link strncasecmp_d}@{" strncpyn " link strncpyn}@{" strnicmp " link strnicmp}@{" strnicmp_d " link strnicmp_d} @{" strsep " link strsep}@{" strupper " link strupper}@{" strupper_d " link strupper_d}@{" strupr_d " link strupr_d} @{" strxfrm " link strxfrm}@{" swab " link swab}@{par} ctype Funktionen@{par} @{" isalnum_d " link isalnum_d}@{" isalpha_d " link isalpha_d}@{" islower_d " link islower_d}@{" isprint_d " link isprint_d} @{" ispunct_d " link ispunct_d}@{" isupper_d " link isupper_d}@{" tolower_d " link tolower_d}@{" toupper_d " link toupper_d}@{par} assert Funktionen@{par} @{" assert_ " link assert_}@{par} time Funktionen@{par} @{" asctime_d " link asctime_d}@{" ctime_d " link ctime_d}@{" strftime " link strftime}@{" strftime_d " link strftime_d} @{" times " link times}@{" utime " link utime}@{" utimes " link utimes}@{par} resource Funktionen@{par} @{" getrusage " link getrusage}@{par} math Funktionen@{par} @{" isinf " link isinf}@{" isnan " link isnan}@{par} Spezial Funktionen@{par} @{" button " link button}@{" button_al " link button_al}@{" button_ar " link button_ar}@{" button_bl " link button_bl} @{" button_br " link button_br}@{" divsl " link divsl}@{" divul " link divul}@{" divs64 " link divs64} @{" divu64 " link divu64}@{" max_Height " link max_Height}@{" max_Width " link max_Width}@{" muls " link muls} @{" mulu " link mulu}@{" muls64 " link muls64}@{" mulu64 " link mulu64}@{" waitbutton " link "waitbutton"} @{" waitbutton_al " link waitbutton_al}@{" waitbutton_ar " link waitbutton_ar}@{" waitbutton_bl " link waitbutton_bl}@{" waitbutton_br " link waitbutton_br}@{par} @endnode /// /// Startupcode @node Startupcode @{b}@{fg shine}Die Startupcodes@{par} ~~~~~~~~~~~~~~~~@{fg text}@{ub}@{par} Die Startupcodes der "stormamiga.lib" bieten mehr Funktionen, sind flexibler und kleiner als der Startupcode "startup.o" von StormC.@{par} @{b}Die Startupcodes für Ansi-C@{ub}@{par} Bei den Startupcodes "stormamiga_startups.o", "stormamiga_nc_startups.o", "stormamiga_startups+.o" und "stormamiga_nc_startups+.o" wird, bei einem Start aus dem CLI, die Funktion "_main__", das entspricht der Funktion @{" main__() " link main__()} in Ansi-C, aufgerufen. Wenn es diese Funktion in Ihrem Programm nicht gibt, dann wird sie aus der "stormamiga.lib" dazugelinkt. Die Funktion "_main__" ruft die Funktion "_main", das entspricht der Funktion "main()" in Ansi-C, auf. Wenn es diese Funktion nicht gibt, meldet der Linker einen Fehler.@{par} Bei einem Start von der Workbench wird die Funktion @{" _wbmain_ " link _wbmain_} aufgerufen. Wenn "STORMAMIGA_NOWB" definiert wurde, wird eine leere Funktion eingebunden. Ansonsten wird sie aus der "stormamiga.lib" dazugelinkt. Die Funktion "_wbmain_" ruft die Funktion "_wbmain", das entspricht der Funktion @{" wbmain() " link wbmain()} in Ansi-C, auf. Wenn es diese Funktion nicht gibt, wird sie aus der "stormamiga.lib" dazugelinkt.@{par} @{b}Die Startupcodes für C++@{ub}@{par} Bei den Startupcodes "stormamiga_C++_startups.o", "stormamiga_nc_C++_startups.o", "stormamiga_C++_startups+.o" und "stormamiga_nc_C++_startups+.o" wird, bei einem Start aus dem CLI, die Funktion "main_", das entspricht der parameterlosen Funktion main() in C++, aufgerufen. Wenn es diese Funktion in Ihrem Programm nicht gibt, dann wird sie aus der "stormamiga.lib" dazugelinkt. Die Funktion "main_" ruft die Funktion "main__iPPc", das entspricht der Funktion "main(int, char **)" in C++, auf. Wenn es diese Funktion nicht gibt, meldet der Linker einen Fehler.@{par} Bei einem Start von der Workbench wird die Funktion @{" wbmain__ " link _wbmain_} aufgerufen. Wenn "STORMAMIGA_NOWB" definiert wurde, wird eine leere Funktion eingebunden. Ansonsten wird sie aus der "stormamiga.lib" dazugelinkt. Die Funktion "wbmain__" ruft die Funktion "wbmain__P09WBStartup", das entspricht der Funktion @{" wbmain(struct WBStartup *) " link wbmain()} in C++, auf. Wenn es diese Funktion nicht gibt, wird sie aus der "stormamiga.lib" dazugelinkt.@{par} @{code} @{b}Funktionsübersicht der Startupcodes@{ub} _________________________________________________________________________________________ | Startupcode | Ansi C | C++ | Codemodell | Datenmodell | | | | | FAR | NEAR | FAR | NEAR A4 | NEAR A6 | |¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯|¯¯¯¯¯¯¯¯|¯¯¯¯¯¯|¯¯¯¯¯¯|¯¯¯¯¯¯|¯¯¯¯¯|¯¯¯¯¯¯¯¯¯|¯¯¯¯¯¯¯¯¯| | stormamiga_startups.o | ja | nein | ja | (ja) | ja | (ja)¹ | nein | |-------------------------------|--------|------|------|------|-----|---------|---------| | stormamiga_startups+.o | ja | nein | ja | (ja) | ja | ja | nein | |-------------------------------|--------|------|------|------|-----|---------|---------| | stormamiga_nc_startups.o | ja | nein | (ja) | ja | ja | (ja)¹ | nein | |-------------------------------|--------|------|------|------|-----|---------|---------| | stormamiga_nc_startups+.o | ja | nein | (ja) | ja | ja | ja | nein | |-------------------------------|--------|------|------|------|-----|---------|---------| | stormamiga_C++_startups.o | nein | ja | ja | (ja) | ja | (ja)¹ | nein | |-------------------------------|--------|------|------|------|-----|---------|---------| | stormamiga_C++_startups+.o | nein | ja | ja | (ja) | ja | ja | nein | |-------------------------------|--------|------|------|------|-----|---------|---------| | stormamiga_nc_C++_startups.o | nein | ja | (ja) | ja | ja | (ja)¹ | nein | |-------------------------------|--------|------|------|------|-----|---------|---------| | stormamiga_nc_C++_startups+.o | nein | ja | (ja) | ja | ja | ja | nein | ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ (ja) = Wenn die so gekennzeichneten Startupcodes in dem entsprechenden Codemodell verwendet werden, dann funktionieren diese Programme zwar, werden dadurch aber größer. (ja)¹ = Die so gekennzeichneten Startupcodes bieten die Möglichkeit residenfähige Programme zu erzeugen. Bei Programmen die nicht residentfähig sein müssen bringen diese Startupcodes keine Vorteile. Sie vergrößern die Programme nur. @endnode /// /// wb-main @node main__() @{b}@{FG shine}Die Funktion "main__()".@{par} ~~~~~~~~~~~~~~~~~~~~~~~~@{FG text}@{ub}@{par} Wenn Sie für Ihr Programm keine Auswertung von Argumenten benötigen oder diese Routine selber schreiben, können Sie die Funktion "main()" in "main__()" umbenennen. Dadurch wird Ihr Programm etwas kleiner.@{par} @{b}@{FG fill}Wichtig@{FG text}@{ub}@{par} Da der Compiler die Funktion "main__()" nicht als "normale" main-Funktion erkennt, setzt er auch nicht den Returncode auf 0. Deshalb müssen Sie den Returncode, mit "return 0", selber auf 0 setzen.@{par} Die Funktion "main__()" wird nur in den Startupcodes "stormamiga_startups.o", "stormamiga_nc_startups.o", "stormamiga_startups+.o" und "stormamiga_nc_startups+.o" unterstützt und funktioniert nur in Ansi C.@{par} @endnode @node _wbmain_ @{b}@{FG shine}Die Funktionen "_wbmain_" und "wbmain__".@{par} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@{FG text}@{ub}@{par} Die Funktionen "_wbmain_" und "wbmain__" sind notwendig, um die Quelltexte der verschiedenen Compiler (GNU C, SAS C, DICE, Maxon C++, StormC) mit den Startupcodes und der "stormamiga.lib" nutzen zu können. Außerdem enthalten sie alle Funktionen, um ein von der Workbench gestartetes Programm, korrekt zu beenden.@{par} In den Funktionen "_wbmain_" und "wbmain__" wird die Workbenchmessage in die globale Variable "WBMsg" kopiert.@{par} Sehen Sie sich bitte auch die @{" Workbenchbeispiele " link Workbenchbeispiele} an.@{par} @endnode @node wbmain() @{b}@{FG shine}Die Funktion "wbmain()".@{par} ~~~~~~~~~~~~~~~~~~~~~~~~@{FG text}@{ub}@{par} Die Funktion "wbmain()" ist bereits in der "stormamiga.lib" enhalten. Es wird in das aktuelle Verzeichnis gewechselt und, wenn @{" STORMAMIGA_NO_IO_WB " link STORMAMIGA_NO_IO_WB} nicht definiert wurde, die Standardausgabe "stdout" und die Standardeingabe "stdin" in ein CLI Fenster umgeleitet. Die Eigenschaften dieses Fensters können Sie mit der Variable "__stdiowin" festlegen. Die Standarteinstellung ist "char __stdiowin[] = \"CON://///AUTO/CLOSE\"".@{par} Wenn Sie die Funktion "wbmain()" selber schreiben, dann wird Ihre Funktion und nicht die der "stormamiga.lib" verwendet.@{par} Sehen Sie sich bitte auch die @{" Workbenchbeispiele " link Workbenchbeispiele} an.@{par} @endnode @node Workbenchbeispiele @{b}@{FG shine}Einige Beispiele für den Start von der Workbench.@{par} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@{FG text}@{ub}@{par} Bei der "stormamiga.lib" gibt es viele Möglichkeiten, einen Start von der Workbench auszuwerten. Diese Beispiele sollen dazu dienen einige dieser Möglichkeiten etwas zu verdeutlichen.@{par} @{code} @{b}Beispiel 1@{ub} void main (int argc, char **argv) { if (argc == 0) { // Hier würden alle Funktionen, die bei einem Start von // der Workbench notwendig sind, stehen. } else { // Hier würden alle Funktionen, die bei einem Start vom // CLI notwendig sind, stehen. } @{b}Beispiel 2@{ub} void main__ (void) { extern struct WBStartup *WBMsg; if (WBMsg != 0) { // Hier würden alle Funktionen, die bei einem Start von // der Workbench notwendig sind, stehen. } else { // Hier würden alle Funktionen, die bei einem Start vom // CLI notwendig sind, stehen. } @{b}Beispiel 3@{ub} void main (int argc, char **argv) { // Hier würden alle Funktionen, die bei einem Start vom // CLI notwendig sind, stehen. } void wbmain (struct WBStartup *wbs) { // Hier würden alle Funktionen, die bei einem Start von // der Workbench notwendig sind, stehen. } @endnode /// /// stdio-Funktionen @node SPRINTF @{fg shine}SPRINTF@{fg text}@{par} Formatierte Ausgabe in den Stringpuffer "s".@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = SPRINTF (s, format, ...);@{par} int r;@{par} char *s;@{par} const char *format;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe in den @{" Stringpuffer " link Stringpuffer} "s". Der Formatstring "format" beschreibt das Ausgabeformat. Danach folgen zusätzlich angegebene Parameter.@{par} "SPRINTF" verwendet den Befehl @{" RawDoFmt " link "StormC:StormSYS/Help/exec/RawDoFmt()"} der "exec.library" und ist dadurch auch sehr klein.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen.@{par} @endnode @node VSPRINTF @{fg shine}VSPRINTF@{fg text}@{par} Formatierte Ausgabe in den Stringpuffer "s".@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = VSPRINTF (s, format, vl);@{par} int r;@{par} char *s;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe in den @{" Stringpuffer " link Stringpuffer} "s". Der Formatstring "format" beschreibt das Ausgabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} "VSPRINTF" verwendet den Befehl @{" RawDoFmt " link "StormC:StormSYS/Help/exec/RawDoFmt()"} der "exec.library" und ist dadurch auch sehr klein.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen.@{par} @endnode @node printf64 @{fg shine}printf64@{fg text}@{par} Formatierte Ausgabe in die Standardausgabe "stdout".@{par} @{i}Erweiterte Version von "printf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = printf64 (format, ...);@{par} int r;@{par} const char *format;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe in die Standardausgabe "stdout". Der @{" Ausgabeformatstring " link Ausgabeformatstring} "format" beschreibt das Ausgabeformat. Danach folgen zusätzlich angegebene Parameter.@{par} Die Funktion "printf64" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall eine negative Zahl.@{par} @endnode @node printf_ @{fg shine}printf_@{fg text}@{par} Formatierte Ausgabe in die Standardausgabe "stdout".@{par} @{i}Funktionsreduzierte Version von "printf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = printf_ (format, ...);@{par} int r;@{par} const char *format;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe in die Standardausgabe "stdout". Der @{" Ausgabeformatstring_ " link Ausgabeformatstring_} "format" beschreibt das Ausgabeformat. Danach folgen zusätzlich angegebene Parameter.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall eine negative Zahl.@{par} @endnode @node printf64_ @{fg shine}printf64_@{fg text}@{par} Formatierte Ausgabe in die Standardausgabe "stdout".@{par} @{i}Erweiterte Version von "printf_".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = printf64_ (format, ...);@{par} int r;@{par} const char *format;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe in die Standardausgabe "stdout". Der @{" Ausgabeformatstring_ " link Ausgabeformatstring_} "format" beschreibt das Ausgabeformat. Danach folgen zusätzlich angegebene Parameter.@{par} Die Funktion "printf64_" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall eine negative Zahl.@{par} @endnode @node fprintf64 @{fg shine}fprintf64@{fg text}@{par} Formatierte Ausgabe in die Datei "f".@{par} @{i}Erweiterte Version von "fprintf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = fprintf64 (f, format, ...);@{par} int r;@{par} FILE *f;@{par} const char *format;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe in die Datei "f". Der @{" Ausgabeformatstring " link Ausgabeformatstring} "format" beschreibt das Ausgabeformat. Danach folgen zusätzlich angegebene Parameter.@{par} Die Funktion "fprintf64" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall eine negative Zahl.@{par} @endnode @node fprintf_ @{fg shine}fprintf_@{fg text}@{par} Formatierte Ausgabe in die Datei "f".@{par} @{i}Funktionsreduzierte Version von "fprintf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = fprintf_ (f, format, ...);@{par} int r;@{par} FILE *f;@{par} const char *format;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe in die Datei "f". Der @{" Ausgabeformatstring_ " link Ausgabeformatstring_} "format" beschreibt das Ausgabeformat. Danach folgen zusätzlich angegebene Parameter.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall eine negative Zahl.@{par} @endnode @node fprintf64_ @{fg shine}fprintf64_@{fg text}@{par} Formatierte Ausgabe in die Datei "f".@{par} @{i}Erweiterte Version von "fprintf_".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = fprintf64_ (f, format, ...);@{par} int r;@{par} FILE *f;@{par} const char *format;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe in die Datei "f". Der @{" Ausgabeformatstring_ " link Ausgabeformatstring_} "format" beschreibt das Ausgabeformat. Danach folgen zusätzlich angegebene Parameter.@{par} Die Funktion "fprintf64_" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall eine negative Zahl.@{par} @endnode @node sprintf64 @{fg shine}sprintf64@{fg text}@{par} Formatierte Ausgabe in den Stringpuffer "s".@{par} @{i}Erweiterte Version von "sprintf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = sprintf64 (s, format, ...);@{par} int r;@{par} char *s;@{par} const char *format;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe in den @{" Stringpuffer " link Stringpuffer} "s". Der @{" Ausgabeformatstring " link Ausgabeformatstring} "format" beschreibt das Ausgabeformat. Danach folgen zusätzlich angegebene Parameter.@{par} Die Funktion "sprintf64" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall eine negative Zahl.@{par} @endnode @node sprintf_ @{fg shine}sprintf_@{fg text}@{par} Formatierte Ausgabe in den Stringpuffer "s".@{par} @{i}Funktionsreduzierte Version von "sprintf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = sprintf_ (s, format, ...);@{par} int r;@{par} char *s;@{par} const char *format;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe in den @{" Stringpuffer " link Stringpuffer} "s". Der @{" Ausgabeformatstring_ " link Ausgabeformatstring_} "format" beschreibt das Ausgabeformat. Danach folgen zusätzlich angegebene Parameter.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall eine negative Zahl.@{par} @endnode @node sprintf64_ @{fg shine}sprintf64_@{fg text}@{par} Formatierte Ausgabe in den Stringpuffer "s".@{par} @{i}Erweiterte Version von "sprintf_".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = sprintf64_ (s, format, ...);@{par} int r;@{par} char *s;@{par} const char *format;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe in den @{" Stringpuffer " link Stringpuffer} "s". Der @{" Ausgabeformatstring_ " link Ausgabeformatstring_} "format" beschreibt das Ausgabeformat. Danach folgen zusätzlich angegebene Parameter.@{par} Die Funktion "sprintf64_" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall eine negative Zahl.@{par} @endnode @node snprintf @{fg shine}snprintf@{fg text}@{par} Formatierte Ausgabe von "n" Zeichen in den Stringpuffer "s".@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = snprintf (s, n, format, ...);@{par} int r;@{par} char *s;@{par} size_t n;@{par} const char *format;@{par} @{b}Standard@{ub}@{par} (noch) keiner (BSD)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe von "n" Zeichen in den @{" Stringpuffer " link Stringpuffer} "s", wobei immer ein Nullzeichen angehängt wird. Deshalb werden bei Strings, die länger als "n" sind, nur n-1 Zeichen ausgegeben. Der @{" Ausgabeformatstring " link Ausgabeformatstring} "format" beschreibt das Ausgabeformat. Danach folgen zusätzlich angegebene Parameter.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder, wenn "n" kleiner als "format" ist, -1.@{par} @{code} @{b}Beispiel@{ub} #define STORMAMIGA #define STORMAMIGA_NOWB #include #include int main__(void) { cchar *format = "This is a test."; char s[8]; int r; size_t n = sizeof s; r = snprintf(s, n, format); printf("%s\\n", s); /* "This is" */ printf("%d\\n", r); /* "-1" */ return NULL; } @endnode @node snprintf64 @{fg shine}snprintf64@{fg text}@{par} Formatierte Ausgabe von "n" Zeichen in den Stringpuffer "s".@{par} @{i}Erweiterte Version von "snprintf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = snprintf64 (s, n, format, ...);@{par} int r;@{par} char *s;@{par} size_t n;@{par} const char *format;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe von "n" Zeichen in den @{" Stringpuffer " link Stringpuffer} "s", wobei immer ein Nullzeichen angehängt wird. Deshalb werden bei Strings, die länger als "n" sind, nur n-1 Zeichen ausgegeben. Der @{" Ausgabeformatstring " link Ausgabeformatstring} "format" beschreibt das Ausgabeformat. Danach folgen zusätzlich angegebene Parameter.@{par} Die Funktion "snprintf64" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder, wenn "n" kleiner als "format" ist, -1.@{par} @{code} @{b}Beispiel@{ub} #define STORMAMIGA #define STORMAMIGA_NOWB #include #include int main__(void) { cchar *format = "This is a test."; char s[8]; int r; size_t n = sizeof s; r = snprintf64(s, n, format); printf64("%s\\n", s); /* "This is" */ printf64("%d\\n", r); /* "-1" */ return NULL; } @endnode @node snprintf_ @{fg shine}snprintf_@{fg text}@{par} Formatierte Ausgabe von "n" Zeichen in den Stringpuffer "s".@{par} @{i}Funktionsreduzierte Version von "snprintf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = snprintf_ (s, n, format, ...);@{par} int r;@{par} char *s;@{par} size_t n;@{par} const char *format;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe von "n" Zeichen in den @{" Stringpuffer " link Stringpuffer} "s", wobei immer ein Nullzeichen angehängt wird. Deshalb werden bei Strings, die länger als "n" sind, nur n-1 Zeichen ausgegeben. Der @{" Ausgabeformatstring_ " link Ausgabeformatstring_} "format" beschreibt das Ausgabeformat. Danach folgen zusätzlich angegebene Parameter.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder, wenn "n" kleiner als "format" ist, -1.@{par} @{code} @{b}Beispiel@{ub} #define STORMAMIGA #define STORMAMIGA_NOWB #include #include int main__(void) { cchar *format = "This is a test."; char s[8]; int r; size_t n = sizeof s; r = snprintf_(s, n, format); printf_("%s\\n", s); /* "This is" */ printf_("%d\\n", r); /* "-1" */ return NULL; } @endnode @node snprintf64_ @{fg shine}snprintf64_@{fg text}@{par} Formatierte Ausgabe von "n" Zeichen in den Stringpuffer "s".@{par} @{i}Erweiterte Version von "snprintf_".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = snprintf64_ (s, n, format, ...);@{par} int r;@{par} char *s;@{par} size_t n;@{par} const char *format;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe von "n" Zeichen in den @{" Stringpuffer " link Stringpuffer} "s", wobei immer ein Nullzeichen angehängt wird. Deshalb werden bei Strings, die länger als "n" sind, nur n-1 Zeichen ausgegeben. Der @{" Ausgabeformatstring_ " link Ausgabeformatstring_} "format" beschreibt das Ausgabeformat. Danach folgen zusätzlich angegebene Parameter.@{par} Die Funktion "snprintf64_" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder, wenn "n" kleiner als "format" ist, -1.@{par} @{code} @{b}Beispiel@{ub} #define STORMAMIGA #define STORMAMIGA_NOWB #include #include int main__(void) { cchar *format = "This is a test."; char s[8]; int r; size_t n = sizeof s; r = snprintf64_(s, n, format); printf64_("%s\\n", s); /* "This is" */ printf64_("%d\\n", r); /* "-1" */ return NULL; } @endnode @node vprintf64 @{fg shine}vprintf64@{fg text}@{par} Formatierte Ausgabe in die Standardausgabe "stdout".@{par} @{i}Erweiterte Version von "vprintf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = vprintf64 (format, vl);@{par} int r;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe in die Standardausgabe "stdout". Der @{" Ausgabeformatstring " link Ausgabeformatstring} "format" beschreibt das Ausgabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} Die Funktion "vprintf64" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall eine negative Zahl.@{par} @endnode @node vprintf_ @{fg shine}vprintf_@{fg text}@{par} Formatierte Ausgabe in die Standardausgabe "stdout".@{par} @{i}Funktionsreduzierte Version von "vprintf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = vprintf_ (format, vl);@{par} int r;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe in die Standardausgabe "stdout". Der @{" Ausgabeformatstring_ " link Ausgabeformatstring_} "format" beschreibt das Ausgabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall eine negative Zahl.@{par} @endnode @node vprintf64_ @{fg shine}vprintf64_@{fg text}@{par} Formatierte Ausgabe in die Standardausgabe "stdout".@{par} @{i}Erweiterte Version von "vprintf_".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = vprintf64_ (format, vl);@{par} int r;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe in die Standardausgabe "stdout". Der @{" Ausgabeformatstring_ " link Ausgabeformatstring_} "format" beschreibt das Ausgabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} Die Funktion "vprintf64_" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall eine negative Zahl.@{par} @endnode @node vfprintf64 @{fg shine}vfprintf64@{fg text}@{par} Formatierte Ausgabe in die Datei "f".@{par} @{i}Erweiterte Version von "vfprintf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = vfprintf64 (f, format, vl);@{par} int r;@{par} FILE *f;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe in die Datei "f". Der @{" Ausgabeformatstring " link Ausgabeformatstring} "format" beschreibt das Ausgabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} Die Funktion "vfprintf64" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall eine negative Zahl.@{par} @endnode @node vfprintf_ @{fg shine}vfprintf_@{fg text}@{par} Formatierte Ausgabe in die Datei "f".@{par} @{i}Funktionsreduzierte Version von "vfprintf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = vfprintf_ (f, format, vl);@{par} int r;@{par} FILE *f;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe in die Datei "f". Der @{" Ausgabeformatstring_ " link Ausgabeformatstring_} "format" beschreibt das Ausgabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall eine negative Zahl.@{par} @endnode @node vfprintf64_ @{fg shine}vfprintf64_@{fg text}@{par} Formatierte Ausgabe in die Datei "f".@{par} @{i}Erweiterte Version von "vfprintf_".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = vfprintf64_ (f, format, vl);@{par} int r;@{par} FILE *f;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe in die Datei "f". Der @{" Ausgabeformatstring_ " link Ausgabeformatstring_} "format" beschreibt das Ausgabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} Die Funktion "vfprintf64_" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall eine negative Zahl.@{par} @endnode @node vsprintf64 @{fg shine}vsprintf64@{fg text}@{par} Formatierte Ausgabe in den Stringpuffer "s".@{par} @{i}Erweiterte Version von "vsprintf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = vsprintf64 (s, format, vl);@{par} int r;@{par} char *s;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe in den @{" Stringpuffer " link Stringpuffer} "s". Der @{" Ausgabeformatstring " link Ausgabeformatstring} "format" beschreibt das Ausgabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} Die Funktion "vsprintf64" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall eine negative Zahl.@{par} @endnode @node vsprintf_ @{fg shine}vsprintf_@{fg text}@{par} Formatierte Ausgabe in den Stringpuffer "s".@{par} @{i}Funktionsreduzierte Version von "vsprintf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = vsprintf_ (s, format, vl);@{par} int r;@{par} char *s;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe in den @{" Stringpuffer " link Stringpuffer} "s". Der @{" Ausgabeformatstring_ " link Ausgabeformatstring_} "format" beschreibt das Ausgabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall eine negative Zahl.@{par} @endnode @node vsprintf64_ @{fg shine}vsprintf64_@{fg text}@{par} Formatierte Ausgabe in den Stringpuffer "s".@{par} @{i}Erweiterte Version von "vsprintf_".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = vsprintf64_ (s, format, vl);@{par} int r;@{par} char *s;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe in den @{" Stringpuffer " link Stringpuffer} "s". Der @{" Ausgabeformatstring_ " link Ausgabeformatstring_} "format" beschreibt das Ausgabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} Die Funktion "vsprintf64_" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall eine negative Zahl.@{par} @endnode @node vsnprintf @{fg shine}vsnprintf@{fg text}@{par} Formatierte Ausgabe von "n" Zeichen in den Stringpuffer "s".@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = vsnprintf (s, n, format, vl);@{par} int r;@{par} char *s;@{par} size_t n;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (BSD)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe von "n" Zeichen in den @{" Stringpuffer " link Stringpuffer} "s", wobei immer ein Nullzeichen angehängt wird. Deshalb werden bei Strings, die länger als "n" sind, nur n-1 Zeichen ausgegeben. Der @{" Ausgabeformatstring " link Ausgabeformatstring} "format" beschreibt das Ausgabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder, wenn "n" kleiner als "format" ist, -1.@{par} @{code} @{b}Beispiel@{ub} #define STORMAMIGA #define STORMAMIGA_NOWB #include #include #include int main__(void) { cchar *format = "This is a test."; char s[8]; int r; size_t n = sizeof s; va_list vl; va_start (vl, format); r = vsnprintf(s, n, format, vl); va_end (vl); printf("%s\\n", s); /* "This is" */ printf("%d\\n", r); /* "-1" */ return NULL; } @endnode @node vsnprintf64 @{fg shine}vsnprintf64@{fg text}@{par} Formatierte Ausgabe von "n" Zeichen in den Stringpuffer "s".@{par} @{i}Erweiterte Version von "vsnprintf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = vsnprintf64 (s, n, format, vl);@{par} int r;@{par} char *s;@{par} size_t n;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe von "n" Zeichen in den @{" Stringpuffer " link Stringpuffer} "s", wobei immer ein Nullzeichen angehängt wird. Deshalb werden bei Strings, die länger als "n" sind, nur n-1 Zeichen ausgegeben. Der @{" Ausgabeformatstring " link Ausgabeformatstring} "format" beschreibt das Ausgabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} Die Funktion "vsnprintf64" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder, wenn "n" kleiner als "format" ist, -1.@{par} @{code} @{b}Beispiel@{ub} #define STORMAMIGA #define STORMAMIGA_NOWB #include #include #include int main__(void) { cchar *format = "This is a test."; char s[8]; int r; size_t n = sizeof s; va_list vl; va_start (vl, format); r = vsnprintf64(s, n, format, vl); va_end (vl); printf64("%s\\n", s); /* "This is" */ printf64("%d\\n", r); /* "-1" */ return NULL; } @endnode @node vsnprintf_ @{fg shine}vsnprintf_@{fg text}@{par} Formatierte Ausgabe von "n" Zeichen in den Stringpuffer "s".@{par} @{i}Funktionsreduzierte Version von "vsnprintf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = vsnprintf_ (s, n, format, vl);@{par} int r;@{par} char *s;@{par} size_t n;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe von "n" Zeichen in den @{" Stringpuffer " link Stringpuffer} "s", wobei immer ein Nullzeichen angehängt wird. Deshalb werden bei Strings, die länger als "n" sind, nur n-1 Zeichen ausgegeben. Der @{" Ausgabeformatstring_ " link Ausgabeformatstring_} "format" beschreibt das Ausgabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder, wenn "n" kleiner als "format" ist, -1.@{par} @{code} @{b}Beispiel@{ub} #define STORMAMIGA #define STORMAMIGA_NOWB #include #include #include int main__(void) { cchar *format = "This is a test."; char s[8]; int r; size_t n = sizeof s; va_list vl; va_start (vl, format); r = vsnprintf_(s, n, format, vl); va_end (vl); printf_("%s\\n", s); /* "This is" */ printf_("%d\\n", r); /* "-1" */ return NULL; } @endnode @node vsnprintf64_ @{fg shine}vsnprintf64_@{fg text}@{par} Formatierte Ausgabe von "n" Zeichen in den Stringpuffer "s".@{par} @{i}Erweiterte Version von "vsnprintf_".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = vsnprintf64_ (s, n, format, vl);@{par} int r;@{par} char *s;@{par} size_t n;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe von "n" Zeichen in den @{" Stringpuffer " link Stringpuffer} "s", wobei immer ein Nullzeichen angehängt wird. Deshalb werden bei Strings, die länger als "n" sind, nur n-1 Zeichen ausgegeben. Der @{" Ausgabeformatstring_ " link Ausgabeformatstring_} "format" beschreibt das Ausgabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} Die Funktion "vsnprintf64_" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen oder, wenn "n" kleiner als "format" ist, -1.@{par} @{code} @{b}Beispiel@{ub} #define STORMAMIGA #define STORMAMIGA_NOWB #include #include #include int main__(void) { cchar *format = "This is a test."; char s[8]; int r; size_t n = sizeof s; va_list vl; va_start (vl, format); r = vsnprintf64_(s, n, format, vl); va_end (vl); printf64_("%s\\n", s); /* "This is" */ printf64_("%d\\n", r); /* "-1" */ return NULL; } @endnode @node scanf64 @{fg shine}scanf64@{fg text}@{par} Einlesen einer formatierten Eingabe aus der Standardeingabe "stdin".@{par} @{i}Erweiterte Version von "scanf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = scanf64 (format, ...);@{par} int r;@{par} const char *format;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Einlesen einer formatierten Eingabe aus der Standardeingabe "stdin". Der @{" Eingabeformatstring " link "Eingabeformatstring"} "format" beschreibt das Eingabeformat. Danach folgen zusätzlich angegebene Parameter.@{par} Die Funktion "scanf64" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der akzeptierten Formatwerte oder im Fehlerfall einen Rückgabewert der kleiner als die Anzahl der Formatwerte ist.@{par} @endnode @node scanf_ @{fg shine}scanf_@{fg text}@{par} Einlesen einer formatierten Eingabe aus der Standardeingabe "stdin".@{par} @{i}Funktionsreduzierte Version von "scanf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = scanf_ (format, ...);@{par} int r;@{par} const char *format;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Einlesen einer formatierten Eingabe aus der Standardeingabe "stdin". Der @{" Eingabeformatstring_ " link Eingabeformatstring_} "format" beschreibt das Eingabeformat. Danach folgen zusätzlich angegebene Parameter.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der akzeptierten Formatwerte oder im Fehlerfall einen Rückgabewert der kleiner als die Anzahl der Formatwerte ist.@{par} @endnode @node scanf64_ @{fg shine}scanf64_@{fg text}@{par} Einlesen einer formatierten Eingabe aus der Standardeingabe "stdin".@{par} @{i}Erweiterte Version von "scanf_".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = scanf64_ (format, ...);@{par} int r;@{par} const char *format;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Einlesen einer formatierten Eingabe aus der Standardeingabe "stdin". Der @{" Eingabeformatstring_ " link Eingabeformatstring_} "format" beschreibt das Eingabeformat. Danach folgen zusätzlich angegebene Parameter.@{par} Die Funktion "scanf64_" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der akzeptierten Formatwerte oder im Fehlerfall einen Rückgabewert der kleiner als die Anzahl der Formatwerte ist.@{par} @endnode @node fscanf64 @{fg shine}fscanf64@{fg text}@{par} Einlesen einer formatierten Eingabe aus der Datei "f".@{par} @{i}Erweiterte Version von "fscanf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = fscanf64 (f, format, ...);@{par} int r;@{par} FILE *f;@{par} const char *format;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Einlesen einer formatierten Eingabe aus der Datei "f". Der @{" Eingabeformatstring " link Eingabeformatstring} "format" beschreibt das Eingabeformat. Danach folgen zusätzlich angegebene Parameter.@{par} Die Funktion "fscanf64" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der akzeptierten Formatwerte oder im Fehlerfall einen Rückgabewert der kleiner als die Anzahl der Formatwerte ist.@{par} @endnode @node fscanf_ @{fg shine}fscanf_@{fg text}@{par} Einlesen einer formatierten Eingabe aus der Datei "f".@{par} @{i}Funktionsreduzierte Version von "fscanf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = fscanf_ (f, format, ...);@{par} int r;@{par} FILE *f;@{par} const char *format;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Einlesen einer formatierten Eingabe aus der Datei "f". Der @{" Eingabeformatstring_ " link Eingabeformatstring_} "format" beschreibt das Eingabeformat. Danach folgen zusätzlich angegebene Parameter.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der akzeptierten Formatwerte oder im Fehlerfall einen Rückgabewert der kleiner als die Anzahl der Formatwerte ist.@{par} @endnode @node fscanf64_ @{fg shine}fscanf64_@{fg text}@{par} Einlesen einer formatierten Eingabe aus der Datei "f".@{par} @{i}Funktionsreduzierte Version von "fscanf_".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = fscanf64_ (f, format, ...);@{par} int r;@{par} FILE *f;@{par} const char *format;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Einlesen einer formatierten Eingabe aus der Datei "f". Der @{" Eingabeformatstring_ " link Eingabeformatstring_} "format" beschreibt das Eingabeformat. Danach folgen zusätzlich angegebene Parameter.@{par} Die Funktion "fscanf64_" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der akzeptierten Formatwerte. oder im Fehlerfall einen Rückgabewert der kleiner als die Anzahl der Formatwerte ist.@{par} @endnode @node sscanf64 @{fg shine}sscanf64@{fg text}@{par} Einlesen einer formatierten Eingabe aus dem Stringpuffer "s".@{par} @{i}Erweiterte Version von "sscanf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = sscanf64 (s, format, ...);@{par} int r;@{par} char *s;@{par} const char *format;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Einlesen einer formatierten Eingabe aus dem Stringpuffer "s". Der @{" Eingabeformatstring " link Eingabeformatstring} "format" beschreibt das Eingabeformat. Danach folgen zusätzlich angegebene Parameter.@{par} Die Funktion "sscanf64" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der akzeptierten Formatwerte oder im Fehlerfall einen Rückgabewert der kleiner als die Anzahl der Formatwerte ist.@{par} @endnode @node sscanf_ @{fg shine}sscanf_@{fg text}@{par} Einlesen einer formatierten Eingabe aus dem Stringpuffer "s".@{par} @{i}Funktionsreduzierte Version von "sscanf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = sscanf_ (s, format, ...);@{par} int r;@{par} char *s;@{par} const char *format;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Einlesen einer formatierten Eingabe aus dem Stringpuffer "s". Der @{" Eingabeformatstring_ " link Eingabeformatstring_} "format" beschreibt das Eingabeformat. Danach folgen zusätzlich angegebene Parameter.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der akzeptierten Formatwerte oder im Fehlerfall einen Rückgabewert der kleiner als die Anzahl der Formatwerte ist.@{par} @endnode @node sscanf64_ @{fg shine}sscanf64_@{fg text}@{par} Einlesen einer formatierten Eingabe aus dem Stringpuffer "s".@{par} @{i}Erweiterte Version von "sscanf_".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = sscanf64_ (s, format, ...);@{par} int r;@{par} char *s;@{par} const char *format;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Einlesen einer formatierten Eingabe aus dem Stringpuffer "s". Der @{" Eingabeformatstring_ " link Eingabeformatstring_} "format" beschreibt das Eingabeformat. Danach folgen zusätzlich angegebene Parameter.@{par} Die Funktion "sscanf64_" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der akzeptierten Formatwerte oder im Fehlerfall einen Rückgabewert der kleiner als die Anzahl der Formatwerte ist.@{par} @endnode @node vscanf @{fg shine}vscanf@{fg text}@{par} Einlesen einer formatierten Eingabe aus der Standardeingabe "stdin".@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = vscanf (format, vl);@{par} int r;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (BSD)@{par} @{b}Erklärung@{ub}@{par} Einlesen einer formatierten Eingabe aus der Standardeingabe "stdin". Der @{" Eingabeformatstring " link Eingabeformatstring} "format" beschreibt das Eingabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der akzeptierten Formatwerte oder im Fehlerfall einen Rückgabewert der kleiner als die Anzahl der Formatwerte ist.@{par} @endnode @node vscanf64 @{fg shine}vscanf64@{fg text}@{par} Einlesen einer formatierten Eingabe aus der Standardeingabe "stdin".@{par} @{i}Erweiterte Version von "scanf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = vscanf64 (format, vl);@{par} int r;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Einlesen einer formatierten Eingabe aus der Standardeingabe "stdin". Der @{" Eingabeformatstring " link Eingabeformatstring} "format" beschreibt das Eingabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} Die Funktion "vscanf64" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der akzeptierten Formatwerte oder im Fehlerfall einen Rückgabewert der kleiner als die Anzahl der Formatwerte ist.@{par} @endnode @node vscanf_ @{fg shine}vscanf_@{fg text}@{par} Einlesen einer formatierten Eingabe aus der Standardeingabe "stdin".@{par} @{i}Funktionsreduzierte Version von "scanf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = vscanf_ (format, vl);@{par} int r;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Einlesen einer formatierten Eingabe aus der Standardeingabe "stdin". Der @{" Eingabeformatstring_ " link Eingabeformatstring_} "format" beschreibt das Eingabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der akzeptierten Formatwerte oder im Fehlerfall einen Rückgabewert der kleiner als die Anzahl der Formatwerte ist.@{par} @endnode @node vscanf64_ @{fg shine}vscanf64_@{fg text}@{par} Einlesen einer formatierten Eingabe aus der Standardeingabe "stdin".@{par} @{i}Erweiterte Version von "scanf_".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = vscanf64_ (format, vl);@{par} int r;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Einlesen einer formatierten Eingabe aus der Standardeingabe "stdin". Der @{" Eingabeformatstring_ " link Eingabeformatstring_} "format" beschreibt das Eingabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} Die Funktion "vscanf64_" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der akzeptierten Formatwerte oder im Fehlerfall einen Rückgabewert der kleiner als die Anzahl der Formatwerte ist.@{par} @endnode @node vfscanf @{fg shine}vfscanf@{fg text}@{par} Einlesen einer formatierten Eingabe aus der Datei "f".@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = vfscanf (f, format, vl);@{par} int r;@{par} FILE *f;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (BSD)@{par} @{b}Erklärung@{ub}@{par} Einlesen einer formatierten Eingabe aus der Datei "f". Der @{" Eingabeformatstring " link Eingabeformatstring} "format" beschreibt das Eingabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der akzeptierten Formatwerte oder im Fehlerfall einen Rückgabewert der kleiner als die Anzahl der Formatwerte ist.@{par} @endnode @node vfscanf64 @{fg shine}vfscanf64@{fg text}@{par} Einlesen einer formatierten Eingabe aus der Datei "f".@{par} @{i}Erweiterte Version von "vfscanf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = vfscanf64 (f, format, vl);@{par} int r;@{par} FILE *f;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Einlesen einer formatierten Eingabe aus der Datei "f". Der @{" Eingabeformatstring " link Eingabeformatstring} "format" beschreibt das Eingabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} Die Funktion "vfcanf64" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der akzeptierten Formatwerte oder im Fehlerfall einen Rückgabewert der kleiner als die Anzahl der Formatwerte ist.@{par} @endnode @node vfscanf_ @{fg shine}vfscanf_@{fg text}@{par} Einlesen einer formatierten Eingabe aus der Datei "f".@{par} @{i}Funktionsreduzierte Version von "vfscanf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = vfscanf_ (f, format, vl);@{par} int r;@{par} FILE *f;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Einlesen einer formatierten Eingabe aus der Datei "f". Der @{" Eingabeformatstring_ " link Eingabeformatstring_} "format" beschreibt das Eingabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der akzeptierten Formatwerte oder im Fehlerfall einen Rückgabewert der kleiner als die Anzahl der Formatwerte ist.@{par} @endnode @node vfscanf64_ @{fg shine}vfscanf64_@{fg text}@{par} Einlesen einer formatierten Eingabe aus der Datei "f".@{par} @{i}Erweiterte Version von "vfscanf_".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = vfscanf64_ (f, format, vl);@{par} int r;@{par} FILE *f;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Einlesen einer formatierten Eingabe aus der Datei "f". Der @{" Eingabeformatstring_ " link Eingabeformatstring_} "format" beschreibt das Eingabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} Die Funktion "vfcanf64_" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der akzeptierten Formatwerte oder im Fehlerfall einen Rückgabewert der kleiner als die Anzahl der Formatwerte ist.@{par} @endnode @node vsscanf @{fg shine}vsscanf@{fg text}@{par} Einlesen einer formatierten Eingabe aus dem Stringpuffer "s".@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = vsscanf (s, format, vl);@{par} int r;@{par} char *s;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (BSD)@{par} @{b}Erklärung@{ub}@{par} Einlesen einer formatierten Eingabe aus dem Stringpuffer "s". Der @{" Eingabeformatstring " link Eingabeformatstring} "format" beschreibt das Eingabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der akzeptierten Formatwerte oder im Fehlerfall einen Rückgabewert der kleiner als die Anzahl der Formatwerte ist.@{par} @endnode @node vsscanf64 @{fg shine}vsscanf64@{fg text}@{par} Einlesen einer formatierten Eingabe aus dem Stringpuffer "s".@{par} @{i}Erweiterte Version von "vsscanf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = vsscanf64 (s, format, vl);@{par} int r;@{par} char *s;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Einlesen einer formatierten Eingabe aus dem Stringpuffer "s". Der @{" Eingabeformatstring " link Eingabeformatstring} "format" beschreibt das Eingabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} Die Funktion "vsscanf64" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der akzeptierten Formatwerte oder im Fehlerfall einen Rückgabewert der kleiner als die Anzahl der Formatwerte ist.@{par} @endnode @node vsscanf_ @{fg shine}vsscanf_@{fg text}@{par} Einlesen einer formatierten Eingabe aus dem Stringpuffer "s".@{par} @{i}Funktionsreduzierte Version von "vsscanf".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = vsscanf_ (s, format, vl);@{par} int r;@{par} char *s;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Einlesen einer formatierten Eingabe aus dem Stringpuffer "s". Der @{" Eingabeformatstring_ " link Eingabeformatstring_} "format" beschreibt das Eingabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der akzeptierten Formatwerte oder im Fehlerfall einen Rückgabewert der kleiner als die Anzahl der Formatwerte ist.@{par} @endnode @node vsscanf64_ @{fg shine}vsscanf64_@{fg text}@{par} Einlesen einer formatierten Eingabe aus dem Stringpuffer "s".@{par} @{i}Erweiterte Version von "vsscanf_".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = vsscanf64_ (s, format, vl);@{par} int r;@{par} char *s;@{par} const char *format;@{par} va_list vl;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Einlesen einer formatierten Eingabe aus dem Stringpuffer "s". Der @{" Eingabeformatstring_ " link Eingabeformatstring_} "format" beschreibt das Eingabeformat. Danach folgt eine @{" Parameterliste " link Parameterliste} "vl".@{par} Die Funktion "vsscanf64_" unterstützt zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der akzeptierten Formatwerte oder im Fehlerfall einen Rückgabewert der kleiner als die Anzahl der Formatwerte ist.@{par} @endnode @node setbuffer @{fg shine}setbuffer@{fg text}@{par} setzen eines Dateipuffers@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = setbuffer (f, buf, size);@{par} void r;@{par} FILE *f;@{par} char *buf;@{par} int size;@{par} @{b}Standard@{ub}@{par} (noch) keiner (4.3BSD)@{par} @{b}Erklärung@{ub}@{par} Setzt für die Datei "f" den Dateipuffer "buf" der Länge "size".@{par} Der Befehl "setbuffer" ist auch als @{" Inlinefunktion " link Inlinefunktionen} verfügbar.@{par} @{b}Rückgabe@{ub}@{par} keine@{par} @endnode @node setlinebuf @{fg shine}setlinebuf@{fg text}@{par} setzen eines Zeilenpuffers@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = setlinebuf (f);@{par} int r;@{par} FILE *f;@{par} @{b}Standard@{ub}@{par} (noch) keiner (4.3BSD)@{par} @{b}Erklärung@{ub}@{par} Setzt für die Datei "f" einen Zeilenpuffer.@{par} Der Befehl "setlinebuf" ist auch als @{" Inlinefunktion " link Inlinefunktionen} verfügbar.@{par} @{b}Rückgabe@{ub}@{par} Es wird immer 0 zurückgegeben.@{par} @endnode @node getw @{fg shine}getw@{fg text}@{par} Einlesen eines Wortes@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = getw(f);@{par} int r;@{par} FILE *f;@{par} @{b}Standard@{ub}@{par} (noch) keiner (BSD)@{par} @{b}Erklärung@{ub}@{par} Liest aus der Datei "f" das nächste Wort.@{par} @{b}Rückgabe@{ub}@{par} Das nächste Wort aus der Datei "f" oder "EOF" falls ein Fehler auftrat oder das Ende der Datei erreicht war.@{par} @endnode @node putw @{fg shine}putw@{fg text}@{par} Ausgabe eines Wortes@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = putw(w, f);@{par} int r;@{par} int w;@{par} FILE *f;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Version 6 AT&T UNIX)@{par} @{b}Erklärung@{ub}@{par} Das Wort "w" wird in die Datei "f" ausgegeben.@{par} @{b}Rückgabe@{ub}@{par} Das ausgegebene Wort oder im Fehlerfall "EOF".@{par} @endnode /// /// unistd-Funktionen @node access @{fg shine}access@{fg text}@{par} Überprüft den Zugriffsmodus von Dateien@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = access(file, mode);@{par} int r;@{par} const char *file;@{par} int mode;@{par} @{b}Standard@{ub}@{par} IEEE Std1003.1-1988 ("POSIX")@{par} @{b}Erklärung@{ub}@{par} Es wird überprüft ob der Zugriffsmodus "mode" bei der Datei "name" möglich ist oder nicht.@{par} Bei Definition von @{" STORMAMIGA_UNIXPATH " link STORMAMIGA_UNIXPATH} können für diese Funktionen auch Pfadangaben im Unix-Format verwendet werden.@{par} @{b}Rückgabe@{ub}@{par} Im Fehlerfall -1, sonst 0.@{par} @endnode @node chdir @{fg shine}chdir@{fg text}@{par} Verzeichnis wechseln@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = chdir(path);@{par} int r;@{par} const char *path;@{par} @{b}Standard@{ub}@{par} IEEE Std1003.1-1988 ("POSIX")@{par} @{b}Erklärung@{ub}@{par} Es wird vom aktuellen Arbeitsverzeichnis zum Verzeichnis "path" gewechselt.@{par} Beim Beenden des Programmes wird das Originalverzeichnis wieder hergestellt.@{par} Bei Definition von @{" STORMAMIGA_UNIXPATH " link STORMAMIGA_UNIXPATH} können für diese Funktionen auch Pfadangaben im Unix-Format verwendet werden.@{par} @{b}Rückgabe@{ub}@{par} Im Fehlerfall -1, sonst 0.@{par} @endnode @node rmdir @{fg shine}rmdir@{fg text}@{par} Verzeichnis löschen@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = rmdir(path);@{par} int r;@{par} char *path;@{par} @{b}Standard@{ub}@{par} (noch) keiner (4.3BSD)@{par} @{b}Erklärung@{ub}@{par} Das Verzeichnis "path" wird gelöscht.@{par} Bei Definition von @{" STORMAMIGA_UNIXPATH " link STORMAMIGA_UNIXPATH} können für diese Funktionen auch Pfadangaben im Unix-Format verwendet werden.@{par} @{b}Rückgabe@{ub}@{par} Im Fehlerfall -1, sonst 0.@{par} @endnode @node unlink @{fg shine}unlink@{fg text}@{par} Link löschen@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = unlink(name);@{par} int r;@{par} const char *name;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Version 6 AT&T UNIX)@{par} @{b}Erklärung@{ub}@{par} Es wird der Link "name" gelöscht.@{par} Bei Definition von @{" STORMAMIGA_UNIXPATH " link STORMAMIGA_UNIXPATH} können für diese Funktionen auch Pfadangaben im Unix-Format verwendet werden.@{par} @{b}Rückgabe@{ub}@{par} Im Fehlerfall -1, sonst 0.@{par} @endnode @node sleep @{fg shine}sleep@{fg text}@{par} stoppt den aktuellen Prozeß@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = sleep(n);@{par} void r;@{par} unsigned int n;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Version 7 AT&T UNIX)@{par} @{b}Erklärung@{ub}@{par} Der aktuelle Prozeß wird für "n" Sekunden gestoppt.@{par} @{b}Rückgabe@{ub}@{par} keine@{par} @endnode @node usleep @{fg shine}usleep@{fg text}@{par} stoppt den aktuellen Prozeß@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = usleep(n);@{par} void r;@{par} unsigned int n;@{par} @{b}Standard@{ub}@{par} (noch) keiner (4.3BSD)@{par} @{b}Erklärung@{ub}@{par} Der aktuelle Prozeß wird für "n" Mikrosekunden gestoppt.@{par} @{b}Rückgabe@{ub}@{par} keine@{par} @endnode @node getcwd @{fg shine}getcwd@{fg text}@{par} Verzeichnisname ermitteln@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = getcwd(buf, n);@{par} char *r;@{par} char *buf;@{par} size_t n;@{par} @{b}Standard@{ub}@{par} ANSI C3.159-1989 ("ANSI C")@{par} @{b}Erklärung@{ub}@{par} Es wird der Name des aktuellen Arbeitsverzeichnisses nach "buf" kopiert und ein Zeiger ("r") auf "buf" zurückgegeben. Die Größe von "buf" wird mit "n" angegeben.@{par} @{b}Rückgabe@{ub}@{par} Im Fehlerfall 0, sonst ein Zeiger auf "buf".@{par} @endnode @node getwd @{fg shine}getwd@{fg text}@{par} Verzeichnisname ermitteln@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = getwd(buf);@{par} char *r;@{par} char *buf;@{par} @{b}Standard@{ub}@{par} (noch) keiner (4.0BSD)@{par} @{b}Erklärung@{ub}@{par} Es wird der Name des aktuellen Arbeitsverzeichnisses nach "buf" kopiert und ein Zeiger ("r") auf "buf" zurückgegeben.@{par} @{b}Rückgabe@{ub}@{par} Im Fehlerfall 0, sonst ein Zeiger auf "buf".@{par} @endnode @node mktemp @{fg shine}mktemp@{fg text}@{par} erzeugt einen temporären Dateinamen@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = mktemp(template);@{par} char *r;@{par} char *template;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Version 7 AT&T UNIX)@{par} @{b}Erklärung@{ub}@{par} Es wird der temporäre Dateiname "template" erzeugt und ein Zeiger darauf zurückgegeben.@{par} @{b}Rückgabe@{ub}@{par} Im Fehlerfall 0, sonst ein Zeiger auf "template".@{par} @endnode @node close @{fg shine}close@{fg text}@{par} schließt einen File Descriptor@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = close(fd);@{par} int r;@{par} int fd;@{par} @{b}Standard@{ub}@{par} IEEE Std1003.1-1988 ("POSIX")@{par} @{b}Erklärung@{ub}@{par} Es wird der File Descriptor "fd" geschlossen.@{par} @{b}Rückgabe@{ub}@{par} Im Fehlerfall -1, sonst 0.@{par} @endnode @node lseek @{fg shine}lseek@{fg text}@{par} positioniert den Schreib- und Lesezeiger@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = lssek(fd, offset, whence);@{par} off_t r;@{par} int fd;@{par} off_t offset;@{par} int whence;@{par} @{b}Standard@{ub}@{par} IEEE Std1003.1-1988 ("POSIX")@{par} @{b}Erklärung@{ub}@{par} Der Schreib- und Lesezeiger von "fd" wird an eine neue Position gesetzt. Der Parameter "offset" gibt die Position relativ zur Startposition, die sich aus dem Modus "whence" ergibt, an.@{par} Als Moduswerte sind erlaubt:@{par} SEEK_CUR: Der Offset wird von der aktuellen Position gezählt und kann daher positiv oder negativ sein.@{par} SEEK_SET: Der Offset wird vom Anfang der Datei gezählt und sollte positiv sein.@{par} SEEK_END: Der Offset wird vom Ende der Datei gezählt und sollte negativ sein.@{par} @{b}Rückgabe@{ub}@{par} Im Fehlerfall -1, sonst die aktuelle Position.@{par} @endnode @node read @{fg shine}read@{fg text}@{par} Eingaben lesen@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = read(fd, buf, n);@{par} ssize_t r;@{par} int fd;@{par} void *buf;@{par} size_t n;@{par} @{b}Standard@{ub}@{par} IEEE Std1003.1-1988 ("POSIX")@{par} @{b}Erklärung@{ub}@{par} Es werden maximal "n" Zeichen aus "fd" in "buf" gelesen.@{par} @{b}Rückgabe@{ub}@{par} Im Fehlerfall -1, sonst die Anzahl der gelesenen Zeichen.@{par} @endnode @node write @{fg shine}write@{fg text}@{par} Ausgaben schreiben@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = write(fd, buf, n);@{par} ssize_t r;@{par} int fd;@{par} const void *buf;@{par} size_t n;@{par} @{b}Standard@{ub}@{par} IEEE Std1003.1-1988 ("POSIX")@{par} @{b}Erklärung@{ub}@{par} Es werden "n" Zeichen aus "buf" in "fd" geschrieben.@{par} @{b}Rückgabe@{ub}@{par} Im Fehlerfall -1, sonst die Anzahl der geschriebenen Zeichen.@{par} @endnode /// /// fcntl-Funktionen @node creat @{fg shine}creat@{fg text}@{par} erzeugt eine neue Datei@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = creat(path, mode);@{par} int r;@{par} const char *path;@{par} mode_t mode;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Version 6 AT&T UNIX)@{par} @{b}Erklärung@{ub}@{par} Es wird die Datei "path" in dem angegebenem Modus "mode" erzeugt.@{par} Bei Definition von @{" STORMAMIGA_UNIXPATH " link STORMAMIGA_UNIXPATH} können für diese Funktionen auch Pfadangaben im Unix-Format verwendet werden.@{par} @{b}Rückgabe@{ub}@{par} Im Fehlerfall -1, sonst den File Descriptor.@{par} @endnode @node open @{fg shine}open@{fg text}@{par} erzeugt oder öffnet eine Datei@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = open(path, flags, ...);@{par} int r;@{par} const char *path;@{par} int flags;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Version 6 AT&T UNIX)@{par} @{b}Erklärung@{ub}@{par} Es wird die Datei "path" in dem bei "flags" angegebenem Modus erzeugt oder geöffnet.@{par} Bei Definition von @{" STORMAMIGA_UNIXPATH " link STORMAMIGA_UNIXPATH} können für diese Funktionen auch Pfadangaben im Unix-Format verwendet werden.@{par} @{b}Rückgabe@{ub}@{par} Im Fehlerfall -1, sonst den File Descriptor.@{par} @endnode /// /// dirent-Funktionen @node closedir @{fg shine}closedir@{fg text}@{par} Verzeichnis schließen@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = closedir(dirp);@{par} int r;@{par} DIR *dirp;@{par} @{b}Standard@{ub}@{par} (noch) keiner (4.2BSD)@{par} @{b}Erklärung@{ub}@{par} Es wird das, in "dirp" benannte, Verzeichnis geschlossen und die zugehörige Struktur freigegeben.@{par} @{b}Rückgabe@{ub}@{par} Im Fehlerfall -1, sonst 0.@{par} @endnode @node opendir @{fg shine}opendir@{fg text}@{par} Verzeichnis öffnen@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = opendir(name);@{par} DIR *r;@{par} const char *name;@{par} @{b}Standard@{ub}@{par} (noch) keiner (4.2BSD)@{par} @{b}Erklärung@{ub}@{par} Es wird das Verzeichnis "name" geöffnet.@{par} Bei Definition von @{" STORMAMIGA_UNIXPATH " link STORMAMIGA_UNIXPATH} können für diese Funktionen auch Pfadangaben im Unix-Format verwendet werden.@{par} @{b}Rückgabe@{ub}@{par} Im Fehlerfall 0, sonst ein Zeiger auf den directory stream.@{par} @endnode @node readdir @{fg shine}readdir@{fg text}@{par} Verzeichnis lesen@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = readdir(dirp);@{par} struct dirent *r;@{par} DIR *dirp;@{par} @{b}Standard@{ub}@{par} (noch) keiner (4.2BSD)@{par} @{b}Erklärung@{ub}@{par} Es wird der nächste Verzeichniseintrag, des in "dirp" benannten Verzeichnisses, gelesen.@{par} @{b}Rückgabe@{ub}@{par} Im Fehlerfall oder am Ende des Verzeichnisses 0, sonst ein Zeiger auf den nächsten Verzeichniseintrag.@{par} @endnode @node rewinddir @{fg shine}rewinddir@{fg text}@{par} Verzeichnisposition zurücksetzen@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = rewinddir(dirp);@{par} void r;@{par} DIR *dirp;@{par} @{b}Standard@{ub}@{par} (noch) keiner (4.2BSD)@{par} @{b}Erklärung@{ub}@{par} Es wird die Position, des in "dirp" benannten Verzeichnisses, an den Anfang des Verzeichnisses zurückgesetzt.@{par} @{b}Rückgabe@{ub}@{par} keine@{par} @endnode /// /// resource-Funktionen @node getrusage @{fg shine}getrusage@{fg text}@{par} ermittelt Informationen zum aktuellen Prozess oder dessen Unterprozesse@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = getrusage(who, rusage);@{par} int r;@{par} int who;@{par} struct rusage *rusage;@{par} @{b}Standard@{ub}@{par} (noch) keiner (4.2BSD)@{par} @{b}Erklärung@{ub}@{par} Es werden Informationen zum aktuellen Prozess oder zu dessen Unterprozessen ermittelt und in "rusage" ausgegeben. Mit "who" wird angegeben ob Informationen zum aktuellen Prozess oder zu dessen Unterprozessen ermittelt werden sollen. Für den aktuellen Prezess wird für "who" "RUSAGE_SELF", für dessen Unterprozesse wird "RUSAGE_CHILDREN" angegeben.@{par} @{b}Rückgabe@{ub}@{par} Im Fehlerfall -1, sonst 0.@{par} @endnode /// /// stat-Funktionen @node chmod @{fg shine}chmod@{fg text}@{par} ändert den Zugriffsmodus von Dateien@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = chmod(path, mode);@{par} int r;@{par} const char *path;@{par} mode_t mode;@{par} @{b}Standard@{ub}@{par} IEEE Std1003.1-1988 ("POSIX")@{par} @{b}Erklärung@{ub}@{par} Der Zugriffsmodus von "path" wird in den Modus "mode" geändert.@{par} Bei Definition von @{" STORMAMIGA_UNIXPATH " link STORMAMIGA_UNIXPATH} können für diese Funktionen auch Pfadangaben im Unix-Format verwendet werden.@{par} @{b}Rückgabe@{ub}@{par} Im Fehlerfall -1, sonst 0.@{par} @endnode @node mkdir @{fg shine}mkdir@{fg text}@{par} Verzeichnis anlegen@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = mkdir(path, mode);@{par} int r;@{par} const char *path;@{par} mode_t mode;@{par} @{b}Standard@{ub}@{par} IEEE Std1003.1-1988 ("POSIX")@{par} @{b}Erklärung@{ub}@{par} Es wird das Verzeichnis "path" mit dem Zugriffsmodus "mode" angelegt.@{par} Bei Definition von @{" STORMAMIGA_UNIXPATH " link STORMAMIGA_UNIXPATH} können für diese Funktionen auch Pfadangaben im Unix-Format verwendet werden.@{par} @{b}Rückgabe@{ub}@{par} Im Fehlerfall -1, sonst 0.@{par} @endnode @node stat @{fg shine}stat@{fg text}@{par} Status von Dateien ermitteln@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = stat(path, sb);@{par} int r;@{par} const char *path;@{par} struct stat *sb;@{par} @{b}Standard@{ub}@{par} IEEE Std1003.1-1988 ("POSIX")@{par} @{b}Erklärung@{ub}@{par} Es werden Informationen der Datei "path" ermittelt. "sb" ist ein Zeiger auf die Struktur stat.@{par} Bei Definition von @{" STORMAMIGA_UNIXPATH " link STORMAMIGA_UNIXPATH} können für diese Funktionen auch Pfadangaben im Unix-Format verwendet werden.@{par} @{b}Rückgabe@{ub}@{par} Im Fehlerfall -1, sonst 0.@{par} @endnode @node lstat @{fg shine}lstat@{fg text}@{par} Status von Links ermitteln@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = lstat(path, sb);@{par} int r;@{par} const char *path;@{par} struct stat *sb;@{par} @{b}Standard@{ub}@{par} (noch) keiner (4.2BSD)@{par} @{b}Erklärung@{ub}@{par} Es werden Informationen des Links "path" ermittelt. "sb" ist ein Zeiger auf die Struktur stat.@{par} Bei Definition von @{" STORMAMIGA_UNIXPATH " link STORMAMIGA_UNIXPATH} können für diese Funktionen auch Pfadangaben im Unix-Format verwendet werden.@{par} @{b}Rückgabe@{ub}@{par} Im Fehlerfall -1, sonst 0.@{par} @endnode @node fstat @{fg shine}fstat@{fg text}@{par} Status von Dateien ermitteln@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = fstat(fd, sb);@{par} int r;@{par} int fd;@{par} struct stat *sb;@{par} @{b}Standard@{ub}@{par} IEEE Std1003.1-1988 ("POSIX")@{par} @{b}Erklärung@{ub}@{par} Es werden Informationen über "fd" ermittelt. "sb" ist ein Zeiger auf die Struktur stat.@{par} @{b}Rückgabe@{ub}@{par} Im Fehlerfall -1, sonst 0.@{par} @endnode /// /// string-Funktionen @node strcoll @{fg shine}strcoll@{fg text}@{par} vergleichen zweier Strings unter Beachtung der aktuellen Sprache@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = strcoll (s1, s2);@{par} int r;@{par} const char *s1;@{par} const char *s2;@{par} @{b}Standard@{ub}@{par} ANSI C3.159-1989 ("ANSI C")@{par} @{b}Erklärung@{ub}@{par} Vergleicht die Strings "s1" und "s2" Zeichen für Zeichen. Da die "stormamiga.lib" die ANSI-Lokalisierung nicht unterstützt, wird die aktuelle Sprache nicht berücksichtigt.@{par} Die Funktion "strcoll" ist nur aus Gründen der Kompatibilität zu anderen Compilern (z.B.: GCC) vorhanden.@{par} @{code} @{b}Rückgabe@{ub} < 0 wenn s1 < s2 = 0 wenn s1 = s2 > 0 wenn s1 > s2 @endnode @node strxfrm @{fg shine}strxfrm@{fg text}@{par} kopieren eines Strings unter Beachtung der aktuellen Sprache@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = strxfrm (dest, source, n);@{par} int r;@{par} char *dest;@{par} const char *source;@{par} size_t n;@{par} @{b}Standard@{ub}@{par} ANSI C3.159-1989 ("ANSI C")@{par} @{b}Erklärung@{ub}@{par} Kopiert maximal "n" Bytes vom String "source" nach "dest". Da die "stormamiga.lib" die ANSI-Lokalisierung nicht unterstützt, wird die aktuelle Sprache nicht berücksichtigt.@{par} Die Funktion "strxfrm" ist nur aus Gründen der Kompatibilität zu anderen Compilern (z.B.: GCC) vorhanden.@{par} @{b}Rückgabe@{ub}@{par} Die Länge des kopierten Strings "source" ohne Nullzeichen.@{par} @endnode @node bcmp @{fg shine}bcmp@{fg text}@{par} vergleichen zweier Speicherbereiche mit Beachtung einer Maximallänge@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = bcmp (b1, b2, n);@{par} int r;@{par} const void *b1;@{par} const void *b2;@{par} size_t n;@{par} @{b}Standard@{ub}@{par} (noch) keiner (4.2BSD)@{par} @{b}Erklärung@{ub}@{par} Vergleicht die Speicherbereiche "b1" und "b2" Byte für Byte auf maximal "n" Bytes Länge. Die Speicherbereiche dürfen sich überschneiden.@{par} @{code} @{b}Rückgabe@{ub} < 0 wenn b1 < b2 = 0 wenn b1 = b2 > 0 wenn b1 > b2 @endnode @node bcopy @{fg shine}bcopy@{fg text}@{par} Speicher kopieren@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = bcopy (source, dest, n);@{par} void r;@{par} const void *source;@{par} void *dest;@{par} size_t n;@{par} @{b}Standard@{ub}@{par} (noch) keiner (4.2BSD)@{par} @{b}Erklärung@{ub}@{par} Kopiert "n" Bytes vom Speicherbereich "source" nach "dest". Die Speicherbereiche dürfen sich überschneiden. Wenn "n" 0 ist, wird nichts kopiert.@{par} @{b}Rückgabe@{ub}@{par} keine@{par} @endnode @node bzero @{fg shine}bzero@{fg text}@{par} schreibt NULL-Bytes in einen Speicherbereich@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = bzero (b, n);@{par} void r;@{par} void *b;@{par} size_t n;@{par} @{b}Standard@{ub}@{par} (noch) keiner (4.3BSD)@{par} @{b}Erklärung@{ub}@{par} Schreibt "n" NULL-Bytes in den Speicherbereich "b".@{par} Der Befehl "bzero" ist auch als @{" Inlinefunktion " link Inlinefunktionen} verfügbar.@{par} @{b}Rückgabe@{ub}@{par} keine@{par} @endnode @node ffs @{fg shine}ffs@{fg text}@{par} findet das erste gesetzte Bit in einem Bit-String@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = ffs (value);@{par} int r;@{par} int value;@{par} @{b}Standard@{ub}@{par} (noch) keiner (4.3BSD)@{par} @{b}Erklärung@{ub}@{par} Findet das erste gesetzte Bit in dem Bit-String "value" und gibt den Index davon zurück.@{par} @{b}Rückgabe@{ub}@{par} Index des Bit-String "value"@{par} @endnode @node index @{fg shine}index@{fg text}@{par} sucht das erste Vorkommen eines Zeichens in einem String@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = index (s, c);@{par} char *r;@{par} const char *s;@{par} int c;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Version 6 AT&T UNIX)@{par} @{b}Erklärung@{ub}@{par} Sucht das erste Vorkommen des Zeichens "c" in dem String "s" und gibt einen Zeiger auf das erste gefundene Zeichen "c" zurück. Wenn das Zeichen "c" nicht gefunden wird, wird 0 zurückgegeben.@{par} @{b}Rückgabe@{ub}@{par} Ein Zeiger auf das erste gefundene Zeichen "c" oder 0.@{par} @endnode @node rindex @{fg shine}rindex@{fg text}@{par} sucht das letzte Vorkommen eines Zeichens in einem String@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = rindex (s, c);@{par} char *r;@{par} const char *s;@{par} int c;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Version 6 AT&T UNIX)@{par} @{b}Erklärung@{ub}@{par} Sucht das letzte Vorkommen des Zeichens "c" in dem String "s" und gibt einen Zeiger auf das letzte gefundene Zeichen "c" zurück. Wenn das Zeichen "c" nicht gefunden wird, wird 0 zurückgegeben.@{par} @{b}Rückgabe@{ub}@{par} Ein Zeiger auf das letzte gefundene Zeichen "c" oder 0.@{par} @endnode @node memccpy @{fg shine}memccpy@{fg text}@{par} Speicher kopieren@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = memccpy (dest, source, c, n);@{par} void *r;@{par} void *dest;@{par} const void *source;@{par} int c;@{par} size_t n;@{par} @{b}Standard@{ub}@{par} (noch) keiner (4.3BSD)@{par} @{b}Erklärung@{ub}@{par} Die Funktion kopiert den Speicherbereich "source" in den Speicherbereich "dest". Wenn das Zeichen "c" im Speicherbereich "source" vorkommt, wird der Kopiervorgang an dieser Stelle gestoppt und ein Zeiger auf das Byte hinter der Kopie des Zeichens "c" im Speicherbereich "dest" zurückgegeben. Ansonsten werden "n" Bytes kopiert und 0 zurückgegeben.@{par} @{b}Rückgabe@{ub}@{par} Ein Zeiger auf das Byte hinter der Kopie des Zeichens "c" im Speicherbereich "dest" oder 0.@{par} @{code} @{b}Beispiel@{ub} #define STORMAMIGA #define STORMAMIGA_NOWB #include #include #include int main__(void) { cvoid *source = "This is a test."; void *dest[50]; int c = 'e'; size_t n = sizeof dest; memccpy(dest, source, c, n); puts((char *)dest); /* "This is a te" */ return NULL; } @endnode @node strncpyn @{fg shine}strncpyn@{fg text}@{par} kopieren eines Strings mit Längenbegrenzung@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = strncpyn (dest, source, n);@{par} char *r;@{par} char *dest;@{par} const char *source;@{par} size_t n;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Die Funktion kopiert maximal "n" Zeichen aus dem String "source" in den String "dest", wobei immer ein Nullzeichen angehängt wird. Deshalb werden bei Strings, die länger als "n" sind, nur n-1 Zeichen kopiert. Bei Strings, die kürzer als "n" sind, wird der String "dest" mit zusätzlichen Nullzeichen auf exakt "n" Zeichen aufgefüllt. Es wird immer ein Zeiger auf den Zielstring "dest" zurückgegeben.@{par} @{code} @{b}Rückgabe@{ub} Ein Zeiger auf den Zielstring "dest". @{b}Beispiel@{ub} #define STORMAMIGA #define STORMAMIGA_NOWB #include #include int main__(void) { cchar *source = "This is a test."; char dest[10]; size_t n = 8; strncpyn(dest, source, n); puts(dest); /* "This is" */ return NULL; } @endnode @node strsep @{fg shine}strsep@{fg text}@{par} trennen eines Strings@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = strsep (s1, s2);@{par} char *r;@{par} char **s1;@{par} char *s2;@{par} @{b}Standard@{ub}@{par} (noch) keiner (BSD)@{par} @{b}Erklärung@{ub}@{par} Die Funktion sucht im String "*s1" (mit abschließendem Nullzeichen) das erste Vorkommen eines Zeichens aus dem String "s2". Wird ein Zeichen gefunden, so wird dieses durch ein Nullzeichen ersetzt und die Stelle des nächsten Zeichens im String "*s1" verzeichnet. Es wird der Originalwert des Strings "*s1" zurückgegeben. Wenn kein Zeichens aus dem String "s2" gefunden wird, wird 0 zurückgegeben.@{par} @{code} @{b}Rückgabe@{ub} Der Originalwert des Strings "*s1" oder 0. @{b}Beispiel@{ub} #define STORMAMIGA #define STORMAMIGA_NOWB #include #include #include int main__(void) { char *s1 = "This is a test."; char *s2 = " "; char *r; r = strsep(&s1, s2); puts(s1); /* "is a test." */ puts(r); /* "This" */ return NULL; } @endnode @node swab @{fg shine}swab@{fg text}@{par} vertauschen angrenzender Bytes@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = swab (source, dest, n);@{par} void r;@{par} const void *source;@{par} void *dest;@{par} size_t n;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Version 7 AT&T UNIX)@{par} @{b}Erklärung@{ub}@{par} Kopiert "n" Bytes von "source" nach "dest" und vertauscht die angrenzenden Bytes. "n" muß eine gerade Zahl sein.@{par} @{b}Rückgabe@{ub}@{par} keine@{par} @endnode @node strnicmp @{fg shine}strnicmp@{fg text}@{par} vergleichen zweier Strings mit Beachtung einer Maximallänge@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = strnicmp (s1, s2, n);@{par} int r;@{par} const char *s1;@{par} const char *s2;@{par} size_t n;@{par} @{b}Standard@{ub}@{par} (noch) keiner (BSD)@{par} @{b}Erklärung@{ub}@{par} Vergleicht die beiden Strings "s1" und "s2", bis maximal zum Zeichen mit Index "n", Zeichen für Zeichen, ohne die Groß- oder Kleinschreibung der Buchstaben zu beachten.@{par} Aus Portabilitätsgründen werden keine Umlaute unterstützt.@{par} @{code} @{b}Rückgabe@{ub} < 0 wenn s1 < s2 = 0 wenn s1 = s2 > 0 wenn s1 > s2 @endnode @node strcasecmp @{fg shine}strcasecmp@{fg text}@{par} vergleichen zweier Strings@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = strcasecmp (s1, s2);@{par} int r;@{par} const char *s1;@{par} const char *s2;@{par} @{b}Standard@{ub}@{par} (noch) keiner (BSD)@{par} @{b}Erklärung@{ub}@{par} Vergleicht die beiden Strings "s1" und "s2" Zeichen für Zeichen, ohne die Groß- oder Kleinschreibung der Buchstaben zu beachten.@{par} Aus Portabilitätsgründen werden keine Umlaute unterstützt.@{par} @{code} @{b}Rückgabe@{ub} < 0 wenn s1 < s2 = 0 wenn s1 = s2 > 0 wenn s1 > s2 @endnode @node strncasecmp @{fg shine}strncasecmp@{fg text}@{par} vergleichen zweier Strings mit Beachtung einer Maximallänge@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = strncasecmp (s1, s2, n);@{par} int r;@{par} const char *s1;@{par} const char *s2;@{par} size_t n;@{par} @{b}Standard@{ub}@{par} (noch) keiner (BSD)@{par} @{b}Erklärung@{ub}@{par} Vergleicht die beiden Strings "s1" und "s2", bis maximal zum Zeichen mit Index "n", Zeichen für Zeichen, ohne die Groß- oder Kleinschreibung der Buchstaben zu beachten.@{par} Aus Portabilitätsgründen werden keine Umlaute unterstützt.@{par} @{code} @{b}Rückgabe@{ub} < 0 wenn s1 < s2 = 0 wenn s1 = s2 > 0 wenn s1 > s2 @endnode @node strlower @{fg shine}strlower@{fg text}@{par} wandelt die Großbuchstaben eines Strings in Kleinbuchstaben um@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = strlower (s);@{par} char *r;@{par} char *s;@{par} @{b}Standard@{ub}@{par} (noch) keiner (BSD)@{par} @{b}Erklärung@{ub}@{par} Falls ein oder mehrere Zeichen des Strings "s" Großbuchstabe sind, werden sie in Kleinbuchstaben umgewandelt, ansonsten bleiben sie unverändert.@{par} Aus Portabilitätsgründen werden keine Umlaute unterstützt.@{par} @{b}Rückgabe@{ub}@{par} Der umgewandelte String "s".@{par} @endnode @node strupper @{fg shine}strupper@{fg text}@{par} wandelt die Kleinbuchstaben eines Strings in Großbuchstaben um@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = strupper (s);@{par} char *r;@{par} char *s;@{par} @{b}Standard@{ub}@{par} (noch) keiner (BSD)@{par} @{b}Erklärung@{ub}@{par} Falls ein oder mehrere Zeichen des Strings "s" Kleinbuchstaben sind, werden sie in Großbuchstaben umgewandelt, ansonsten bleiben sie unverändert.@{par} Aus Portabilitätsgründen werden keine Umlaute unterstützt.@{par} @{b}Rückgabe@{ub}@{par} Der umgewandelte String "s".@{par} @endnode @node stricmp_d @{fg shine}stricmp_d@{fg text}@{par} vergleichen zweier Strings@{par} @{i}deutsche Version von "stricmp"@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = stricmp_d (s1, s2);@{par} int r;@{par} const char *s1;@{par} const char *s2;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Vergleicht die beiden Strings "s1" und "s2" Zeichen für Zeichen, ohne die Groß- oder Kleinschreibung der Buchstaben zu beachten.@{par} Die Umlaute "ä", "ö", "ü", "Ä", "Ö" und "Ü" werden unterstützt. Da es "ß" nicht als Großbuchstabe gibt, muß dieser nicht extra unterstützt werden.@{par} Siehe auch bei @{" Deutsche Funktionen " link "Deutsche Funktionen"}.@{par} @{code} @{b}Rückgabe@{ub} < 0 wenn s1 < s2 = 0 wenn s1 = s2 > 0 wenn s1 > s2 @endnode @node strnicmp_d @{fg shine}strnicmp_d@{fg text}@{par} vergleichen zweier Strings mit Beachtung einer Maximallänge@{par} @{i}deutsche Version von "strnicmp"@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = strnicmp_d (s1, s2, n);@{par} int r;@{par} const char *s1;@{par} const char *s2;@{par} size_t n;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Vergleicht die beiden Strings "s1" und "s2", bis maximal zum Zeichen mit Index "n", Zeichen für Zeichen, ohne die Groß- oder Kleinschreibung der Buchstaben zu beachten.@{par} Die Umlaute "ä", "ö", "ü", "Ä", "Ö" und "Ü" werden unterstützt. Da es "ß" nicht als Großbuchstabe gibt, muß dieser nicht extra unterstützt werden.@{par} Siehe auch bei @{" Deutsche Funktionen " link "Deutsche Funktionen"}.@{par} @{code} @{b}Rückgabe@{ub} < 0 wenn s1 < s2 = 0 wenn s1 = s2 > 0 wenn s1 > s2 @endnode @node strcasecmp_d @{fg shine}strcasecmp_d@{fg text}@{par} vergleichen zweier Strings@{par} @{i}deutsche Version von "strcasecmp"@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = strcasecmp_d (s1, s2);@{par} int r;@{par} const char *s1;@{par} const char *s2;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Vergleicht die beiden Strings "s1" und "s2" Zeichen für Zeichen, ohne die Groß- oder Kleinschreibung der Buchstaben zu beachten.@{par} Die Umlaute "ä", "ö", "ü", "Ä", "Ö" und "Ü" werden unterstützt. Da es "ß" nicht als Großbuchstabe gibt, muß dieser nicht extra unterstützt werden.@{par} Siehe auch bei @{" Deutsche Funktionen " link "Deutsche Funktionen"}.@{par} @{code} @{b}Rückgabe@{ub} < 0 wenn s1 < s2 = 0 wenn s1 = s2 > 0 wenn s1 > s2 @endnode @node strncasecmp_d @{fg shine}strncasecmp_d@{fg text}@{par} vergleichen zweier Strings mit Beachtung einer Maximallänge@{par} @{i}deutsche Version von "strncasecmp"@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = strncasecmp_d (s1, s2, n);@{par} int r;@{par} const char *s1;@{par} const char *s2;@{par} size_t n;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Vergleicht die beiden Strings "s1" und "s2", bis maximal zum Zeichen mit Index "n", Zeichen für Zeichen, ohne die Groß- oder Kleinschreibung der Buchstaben zu beachten.@{par} Die Umlaute "ä", "ö", "ü", "Ä", "Ö" und "Ü" werden unterstützt. Da es "ß" nicht als Großbuchstabe gibt, muß dieser nicht extra unterstützt werden.@{par} Siehe auch bei @{" Deutsche Funktionen " link "Deutsche Funktionen"}.@{par} @{code} @{b}Rückgabe@{ub} < 0 wenn s1 < s2 = 0 wenn s1 = s2 > 0 wenn s1 > s2 @endnode @node strlower_d @{fg shine}strlower_d@{fg text}@{par} wandelt die Großbuchstaben eines Strings in Kleinbuchstaben um@{par} @{i}deutsche Version von "strlower"@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = strlower_d (s);@{par} char *r;@{par} char *s;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Falls ein oder mehrere Zeichen des Strings "s" Großbuchstabe sind, werden sie in Kleinbuchstaben umgewandelt, ansonsten bleiben sie unverändert.@{par} Die Umlaute "ä", "ö", "ü", "Ä", "Ö" und "Ü" werden unterstützt. Da es "ß" nicht als Großbuchstabe gibt, muß dieser nicht extra unterstützt werden.@{par} Siehe auch bei @{" Deutsche Funktionen " link "Deutsche Funktionen"}.@{par} @{b}Rückgabe@{ub}@{par} Der umgewandelte String "s".@{par} @endnode @node strupper_d @{fg shine}strupper_d@{fg text}@{par} wandelt die Kleinbuchstaben eines Strings in Großbuchstaben um@{par} @{i}deutsche Version von "strupper"@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = strupper_d (s);@{par} char *r;@{par} char *s;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Falls ein oder mehrere Zeichen des Strings "s" Kleinbuchstaben sind, werden sie in Großbuchstaben umgewandelt, ansonsten bleiben sie unverändert.@{par} Die Umlaute "ä", "ö", "ü", "Ä", "Ö" und "Ü" werden unterstützt. Da es "ß" nicht als Großbuchstabe gibt, muß dieser nicht extra unterstützt werden.@{par} Siehe auch bei @{" Deutsche Funktionen " link "Deutsche Funktionen"}.@{par} @{b}Rückgabe@{ub}@{par} Der umgewandelte String "s".@{par} @endnode @node strlwr_d @{fg shine}strlwr_d@{fg text}@{par} wandelt die Großbuchstaben eines Strings in Kleinbuchstaben um@{par} @{i}deutsche Version von "strlwr"@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = strlwr_d (s);@{par} char *r;@{par} char *s;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Falls ein oder mehrere Zeichen des Strings "s" Großbuchstabe sind, werden sie in Kleinbuchstaben umgewandelt, ansonsten bleiben sie unverändert.@{par} Die Umlaute "ä", "ö", "ü", "Ä", "Ö" und "Ü" werden unterstützt. Da es "ß" nicht als Großbuchstabe gibt, muß dieser nicht extra unterstützt werden.@{par} Siehe auch bei @{" Deutsche Funktionen " link "Deutsche Funktionen"}.@{par} @{b}Rückgabe@{ub}@{par} Der umgewandelte String "s".@{par} @endnode @node strupr_d @{fg shine}strupr_d@{fg text}@{par} wandelt die Kleinbuchstaben eines Strings in Großbuchstaben um@{par} @{i}deutsche Version von "strupr"@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = strupr_d (s);@{par} char *r;@{par} char *s;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Falls ein oder mehrere Zeichen des Strings "s" Kleinbuchstaben sind, werden sie in Großbuchstaben umgewandelt, ansonsten bleiben sie unverändert.@{par} Die Umlaute "ä", "ö", "ü", "Ä", "Ö" und "Ü" werden unterstützt. Da es "ß" nicht als Großbuchstabe gibt, muß dieser nicht extra unterstützt werden.@{par} Siehe auch bei @{" Deutsche Funktionen " link "Deutsche Funktionen"}.@{par} @{b}Rückgabe@{ub}@{par} Der umgewandelte String "s".@{par} @endnode @node strdup @{fg shine}strdup@{fg text}@{par} speichert die Kopie eines Strings@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = strdup (s);@{par} char *r;@{par} const char *s;@{par} @{b}Standard@{ub}@{par} (noch) keiner (BSD)@{par} @{b}Erklärung@{ub}@{par} "strdup" reserviert ausreichend Speicher für eine Kopie des Strings "s", kopiert diesen, und gibt einen Zeiger auf die Kopie zurück. Dieser Zeiger kann später als Argument für die Funktion @{" free " link "StormC:StormSYS/Help/StormReference.guide/free"} verwendet werden.@{par} @{b}Rückgabe@{ub}@{par} Einen Zeiger auf die Kopie des Strings "s".@{par} @endnode @node stpchr @{fg shine}stpchr@{fg text}@{par} sucht das erste Vorkommen eines Zeichens in einem String@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = stpchr (s, c);@{par} char *r;@{par} const char *s;@{par} int c;@{par} @{b}Standard@{ub}@{par} (noch) keiner (UNIX)@{par} @{b}Erklärung@{ub}@{par} Sucht das erste Vorkommen des Zeichens "c" in dem String "s" und gibt einen Zeiger auf das erste gefundene Zeichen "c" zurück. Das abschließende Nullzeichen des String "s" wird ignoriert. Wenn das Zeichen "c" nicht gefunden wird, wird 0 zurückgegeben.@{par} @{b}Rückgabe@{ub}@{par} Ein Zeiger auf das erste gefundene Zeichen "c" oder 0.@{par} @{code} @{b}Beispiel@{ub} #define STORMAMIGA #define STORMAMIGA_NOWB #include #include #include int main__(void) { char *s = "This is a test."; char *r; int c = ' '; r = stpchr(s, c); puts(r); /* " is a test" */ return NULL; } @endnode @node stpcpy @{fg shine}stpcpy@{fg text}@{par} kopieren eines Strings@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = stpcpy (dest, source);@{par} char *r;@{par} char *dest;@{par} const char *source;@{par} @{b}Standard@{ub}@{par} (noch) keiner (UNIX)@{par} @{b}Erklärung@{ub}@{par} Der String "source" wird in den String "dest" kopiert. Der String "dest" muß mindestens so groß wie der String "source" +1 (für das abschließende Nullzeichen) sein. Es wird immer ein Zeiger auf das Nullzeichen des Zielstring "dest" zurückgegeben@{par} @{b}Rückgabe@{ub}@{par} Ein Zeiger auf das Nullzeichen des Zielstrings "dest".@{par} @{code} @{b}Beispiel@{ub} #define STORMAMIGA #define STORMAMIGA_NOWB #include #include #include int main__(void) { cchar *source1 = "This is a "; cchar *source2 = "test."; char dest[50]; char *r; r = stpcpy(dest, source1); stpcpy(r, source2); puts(dest); /* "This is a test." */ return NULL; } @endnode @node strins @{fg shine}strins@{fg text}@{par} einfügen eines Strings in einen anderen String@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = strins (dest, source);@{par} void r;@{par} char *dest;@{par} const char *source;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Spezialfunktion von "DICE")@{par} @{b}Erklärung@{ub}@{par} Der String "source" wird in den String "dest" eingefügt. Dabei muß der String "dest" groß genug sein, um den String "source" aufzunehmen.@{par} @{b}Rückgabe@{ub}@{par} keine@{par} @{code} @{b}Beispiel@{ub} #define STORMAMIGA #define STORMAMIGA_NOWB #include #include #include int main__(void) { cchar *source1 = "This is a test."; cchar *source2 = "new "; char dest[50]; strcpy(dest, source1); strins(dest + 10, source2); puts(dest); /* "This is a new test." */ return NULL; } @endnode @node strbpl @{fg shine}strbpl@{fg text}@{par} Zerlegt eine Stringreihe in einzelne Strings@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = strbpl(av, n, sary);@{par} int r;@{par} char **av;@{par} int n;@{par} const char *sary;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Spezialfunktion von "DICE")@{par} @{b}Erklärung@{ub}@{par} Es wird die Stringreihe "sary" in einzelne Strings Zerlegt.@{par} Die Stringreihe "sary" besteht aus mehreren Strings mit abschließendem Nullzeichen. Mit "n" wird die maximale Anzahl von Einträgen in "av" angegeben.@{par} @{b}Rückgabe@{ub}@{par} Anzahl der Strings die in "av" geladen wurden. Das letzte Nullzeichen wird ignoriert.@{par} @{code} @{b}Beispiel@{ub} #define STORMAMIGA #define STORMAMIGA_NOWB #include #include #include int main__(void) { char *sary = "This\0is\0a\0test.\0\0"; char *av[17]; int n = sizeof av / sizeof av[0]; strbpl(av, n, sary); puts(av[0]); /* "This" */ puts(av[1]); /* "is" */ puts(av[2]); /* "a" */ puts(av[3]); /* "test." */ return NULL; } @endnode /// /// ctype-Funktionen @node isalnum_d @{fg shine}isalnum_d@{fg text}@{par} testet, ob es sich um ein Buchstabe oder eine Ziffer handelt@{par} @{i}deutsche Version von "isalnum"@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = isalnum_d (ch);@{par} int r;@{par} int ch;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Diese Funktion testet, ob das übergebene Zeichen ein Buchstabe oder eine Ziffer ist.@{par} Die Umlaute "ä", "ö", "ü", "ß", "Ä", "Ö" und "Ü" werden unterstützt.@{par} Siehe auch bei @{" Deutsche Funktionen " link "Deutsche Funktionen"}.@{par} @{b}Rückgabe@{ub}@{par} 0 wenn das Zeichen kein Buchstabe und keine Ziffer ist, sonst ein Wert ungleich 0@{par} @endnode @node isalpha_d @{fg shine}isalpha_d@{fg text}@{par} testet, ob es sich um ein Buchstabe handelt@{par} @{i}deutsche Version von "isalpha"@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = isalpha_d (ch);@{par} int r;@{par} int ch;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Diese Funktion testet, ob das übergebene Zeichen ein Buchstabe ist.@{par} Die Umlaute "ä", "ö", "ü", "ß", "Ä", "Ö" und "Ü" werden unterstützt.@{par} Siehe auch bei @{" Deutsche Funktionen " link "Deutsche Funktionen"}.@{par} @{b}Rückgabe@{ub}@{par} 0 wenn das Zeichen kein Buchstabe ist, sonst ein Wert ungleich 0@{par} @endnode @node islower_d @{fg shine}islower_d@{fg text}@{par} testet, ob es sich um ein Kleinbuchstabe handelt@{par} @{i}deutsche Version von "islower"@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = islower_d (ch);@{par} int r;@{par} int ch;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Diese Funktion testet, ob das übergebene Zeichen ein Kleinbuchstabe ist.@{par} Die Umlaute "ä", "ö", "ü", "ß", "Ä", "Ö" und "Ü" werden unterstützt.@{par} Siehe auch bei @{" Deutsche Funktionen " link "Deutsche Funktionen"}.@{par} @{b}Rückgabe@{ub}@{par} 0 wenn das Zeichen kein Kleinbuchstabe ist, sonst ein Wert ungleich 0@{par} @endnode @node isprint_d @{fg shine}isprint_d@{fg text}@{par} testet, ob es sich um ein druckbares Zeichen handelt@{par} @{i}deutsche Version von "isprint"@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = isprint_d (ch);@{par} int r;@{par} int ch;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Diese Funktion testet, ob das übergebene Zeichen ein druckbares Zeichen ist.@{par} Die Umlaute "ä", "ö", "ü", "ß", "Ä", "Ö" und "Ü" werden unterstützt.@{par} Siehe auch bei @{" Deutsche Funktionen " link "Deutsche Funktionen"}.@{par} @{b}Rückgabe@{ub}@{par} 0 wenn das Zeichen kein druckbares Zeichen ist, sonst ein Wert ungleich 0@{par} @endnode @node ispunct_d @{fg shine}ispunct_d@{fg text}@{par} testet, ob es sich um ein Sonderzeichen handelt@{par} @{i}deutsche Version von "ispunct"@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = ispunct_d (ch);@{par} int r;@{par} int ch;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Diese Funktion testet, ob das übergebene Zeichen ein Sonderzeichen ist.@{par} Die Umlaute "ä", "ö", "ü", "ß", "Ä", "Ö" und "Ü" werden nicht zu den Sonderzeichen gezählt.@{par} Siehe auch bei @{" Deutsche Funktionen " link "Deutsche Funktionen"}.@{par} @{b}Rückgabe@{ub}@{par} 0 wenn das Zeichen kein Sonderzeichen ist, sonst ein Wert ungleich 0@{par} @endnode @node isupper_d @{fg shine}isupper_d@{fg text}@{par} testet, ob es sich um ein Großbuchstabe handelt@{par} @{i}deutsche Version von "isupper"@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = isupper_d (ch);@{par} int r;@{par} int ch;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Diese Funktion testet, ob das übergebene Zeichen ein Großbuchstabe ist.@{par} Die Umlaute "ä", "ö", "ü", "Ä", "Ö" und "Ü" werden unterstützt. Da es "ß" nicht als Großbuchstabe gibt, muß dieser nicht extra unterstützt werden.@{par} Siehe auch bei @{" Deutsche Funktionen " link "Deutsche Funktionen"}.@{par} @{b}Rückgabe@{ub}@{par} 0 wenn das Zeichen kein Großbuchstabe ist, sonst ein Wert ungleich 0@{par} @endnode @node tolower_d @{fg shine}tolower_d@{fg text}@{par} wandelt Großbuchstaben in Kleinbuchstaben um@{par} @{i}deutsche Version von "tolower"@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = tolower_d (ch);@{par} int r;@{par} int ch;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Falls das Zeichen "ch" ein Großbuchstabe ist, wird es in einen Kleinbuchstaben umgewandelt, ansonsten bleibt es unverändert.@{par} Die Umlaute "ä", "ö", "ü", "Ä", "Ö" und "Ü" werden unterstützt. Da es "ß" nicht als Großbuchstabe gibt, muß dieser nicht extra unterstützt werden.@{par} Siehe auch bei @{" Deutsche Funktionen " link "Deutsche Funktionen"}.@{par} @{b}Rückgabe@{ub}@{par} das umgewandelte Zeichen@{par} @endnode @node toupper_d @{fg shine}toupper_d@{fg text}@{par} wandelt Kleinbuchstaben in Großbuchstaben um@{par} @{i}deutsche Version von "toupper"@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = toupper_d (ch);@{par} int r;@{par} int ch;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Falls das Zeichen "ch" ein Kleinbuchstabe ist, wird es in einen Großbuchstaben umgewandelt, ansonsten bleibt es unverändert.@{par} Die Umlaute "ä", "ö", "ü", "Ä", "Ö" und "Ü" werden unterstützt. Da es "ß" nicht als Großbuchstabe gibt, muß dieser nicht extra unterstützt werden.@{par} Siehe auch bei @{" Deutsche Funktionen " link "Deutsche Funktionen"}.@{par} @{b}Rückgabe@{ub}@{par} das umgewandelte Zeichen@{par} @endnode /// /// assert-Funktionen @node assert_ @{fg shine}assert@{fg text}@{par} testet eine Bedingung und unterbricht den Programmlauf@{par} @{b}Übersicht@{ub}@{par} #include @{par} assert_ (x);@{par} int x;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Siehe @{" assert " link "StormC:StormSYS/Help/StormReference.guide/assert"}.@{par} Der einzige Unterschied zu "assert" besteht darin, daß zur Ausgabe der Fehlermeldung "printf_" und nicht "printf" verwendet wird.@{par} @endnode /// /// time-Funktionen @node strftime @{fg shine}strftime@{fg text}@{par} Formatierte Ausgabe von Datum und Zeit in den Stringpuffer "s".@{par} @{i}Erweiterte Version von "strftime" der "storm.lib".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = strftime (s, size, format, tp);@{par} size_t r;@{par} char *s;@{par} size_t size;@{par} const char *format;@{par} const struct tm *tp;@{par} @{b}Standard@{ub}@{par} ANSI C3.159-1989 ("ANSI C")@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe von Datum und Zeit in den @{" Stringpuffer " link Stringpuffer} "s". Der @{" Zeitformatstring " link Zeitformatstring} "format" beschreibt das Ausgabeformat.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen.@{par} @endnode @node strftime_d @{fg shine}strftime_d@{fg text}@{par} Formatierte Ausgabe von Datum und Zeit in den Stringpuffer "s".@{par} @{i}Erweiterte deutsche Version von "strftime" der "storm.lib".@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = strftime_d (s, size, format, tp);@{par} size_t r;@{par} char *s;@{par} size_t size;@{par} const char *format;@{par} const struct tm *tp;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Formatierte Ausgabe von Datum und Zeit in den @{" Stringpuffer " link Stringpuffer} "s". Der @{" Zeitformatstring " link Zeitformatstring} "format" beschreibt das Ausgabeformat.@{par} Die Namen der Monate und Wochentage werden in deutsch ausgegeben.@{par} Siehe auch bei @{" Deutsche Funktionen " link "Deutsche Funktionen"}.@{par} @{b}Rückgabe@{ub}@{par} Die Anzahl der ausgegebenen Zeichen.@{par} @endnode @node asctime_d @{fg shine}asctime_d@{fg text}@{par} Erzeugt eine Zeichenkette aus Datum und Zeit@{par} @{i}deutsche Version von "asctime"@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} tp = asctime_d (t);@{par} char *tp;@{par} const struct tm *t;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} "asctime_d" wandelt die Zeit aus "*t" in eine Zeichenkette der Form "Mit Okt 07 01:03:42 1992" um. Diese Zeichenkette wird in einem internen Puffer abgelegt und ein Zeiger darauf zurückgegeben.@{par} Die Namen der Monate und Wochentage werden in deutsch ausgegeben.@{par} Siehe auch bei @{" Deutsche Funktionen " link "Deutsche Funktionen"}.@{par} @{b}Rückgabe@{ub}@{par} Die Funktion liefert einen ASCII-Text mit der exakten Länge von 26 Zeichen.@{par} Das Format des Textes ist:@{par} "DDD MMM dd hh:mm:ss YYYY"@{par} DDD ist der Wochentag, MMM ist der Monat, dd ist der Tag im Monat, hh:mm:ss sind Stunde:Minute:Sekunde und YYYY ist das Jahr.@{par} Zum Beispiel:@{par} "Mit Okt 25 12:05:43 1995"@{par} @endnode @node ctime_d @{fg shine}ctime_d@{fg text}@{par} Konvertiert einen Zeit-Wert in einen ASCII-Text@{par} @{i}deutsche Version von "ctime"@{ui}@{par} @{b}Übersicht@{ub}@{par} #include @{par} s = ctime_d (t);@{par} char *s;@{par} const time_t *t;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} "ctime_d" ist identisch mit "asctime_d (localtime (t))", wandelt also einen "time_t"-Wert in eine Stringdarstellung um.@{par} Die Namen der Monate und Wochentage werden in deutsch ausgegeben.@{par} Siehe auch bei @{" Deutsche Funktionen " link "Deutsche Funktionen"}.@{par} Der Befehl "ctime_d" ist auch als @{" Inlinefunktion " link Inlinefunktionen} verfügbar.@{par} @{b}Rückgabe@{ub}@{par} Die Funktion liefert einen ASCII-Text mit der exakten Länge von 26 Zeichen.@{par} Das Format des Textes ist:@{par} "DDD MMM dd hh:mm:ss YYYY"@{par} DDD ist der Wochentag, MMM ist der Monat, dd ist der Tag im Monat, hh:mm:ss sind Stunde:Minute:Sekunde und YYYY ist das Jahr.@{par} Zum Beispiel:@{par} "Mit Okt 25 12:05:43 1995"@{par} @endnode @node utime @{fg shine}utime@{fg text}@{par} setzen von Zugriffs- und Bearbeitungszeit@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = utime(file, timep);@{par} int r;@{par} const char *file;@{par} const struct utimebuf *timep;@{par} @{b}Standard@{ub}@{par} IEEE Std1003.1-1988 ("POSIX")@{par} @{b}Erklärung@{ub}@{par} Es wird die Zugriffs- und Bearbeitungszeit der Datei "file" gesetzt. Wenn "timep" null ist, dann wird die aktuelle Zeit als Zugriffs- und Bearbeitungszeit gesetzt.@{par} Bei Definition von @{" STORMAMIGA_UNIXPATH " link STORMAMIGA_UNIXPATH} können für diese Funktionen auch Pfadangaben im Unix-Format verwendet werden.@{par} @{b}Rückgabe@{ub}@{par} Im Fehlerfall -1, sonst 0.@{par} @endnode @node utimes @{fg shine}utimes@{fg text}@{par} setzen von Zugriffs- und Bearbeitungszeit@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = utimes(file, times);@{par} int r;@{par} const char *file;@{par} const struct timeval *times;@{par} @{b}Standard@{ub}@{par} (noch) keiner (4.2BSD)@{par} @{b}Erklärung@{ub}@{par} Es wird die Zugriffs- und Bearbeitungszeit der Datei "file" gesetzt. Wenn "times" null ist, dann wird die aktuelle Zeit als Zugriffs- und Bearbeitungszeit gesetzt.@{par} Bei Definition von @{" STORMAMIGA_UNIXPATH " link STORMAMIGA_UNIXPATH} können für diese Funktionen auch Pfadangaben im Unix-Format verwendet werden.@{par} @{b}Rückgabe@{ub}@{par} Im Fehlerfall -1, sonst 0.@{par} @endnode @node times @{fg shine}times@{fg text}@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = times(tp);@{par} clock_t r;@{par} struct tms *tp;@{par} @{b}Standard@{ub}@{par} IEEE Std1003.1-1988 ("POSIX")@{par} @{b}Erklärung@{ub}@{par} @{b}Rückgabe@{ub}@{par} @endnode /// /// math-Funktionen @node isinf @{fg shine}isinf@{fg text}@{par} testet, ob es sich um eine unendliche Zahl handelt@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = isinf (x);@{par} int r;@{par} double x;@{par} @{b}Standard@{ub}@{par} IEEE Standard for Binary Floating-Point Arithmetic, Std 754-1985, ANSI@{par} @{b}Erklärung@{ub}@{par} Die Funktion "isinf" (is infinite) testet, ob "x" eine unendliche Zahl ist.@{par} @{b}Rückgabe@{ub}@{par} 1 wenn "x" eine unendliche Zahl ist, sonst 0.@{par} @endnode @node isnan @{fg shine}isnan@{fg text}@{par} testet, ob es sich um eine ungültige Zahl handelt@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = isnan (x);@{par} int r;@{par} double x;@{par} @{b}Standard@{ub}@{par} IEEE Standard for Binary Floating-Point Arithmetic, Std 754-1985, ANSI@{par} @{b}Erklärung@{ub}@{par} Die Funktion "isnan" (is not a number) testet, ob "x" eine ungültige Zahl (Division durch 0, Wurzel einer negativen Zahl) ist.@{par} @{b}Rückgabe@{ub}@{par} 1 wenn "x" eine ungültige Zahl ist, sonst 0.@{par} @endnode /// /// Spezial-Funktionen @node muls @{fg shine}muls@{fg text}@{par} signed 32 Bit mal 32 Bit Multiplikation mit 32 Bit Ergebnis@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = muls (arg1, arg2);@{par} long r;@{par} long arg1;@{par} long arg2;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Der Befehl "muls" multipliziert "arg1" mit "arg2" und ermittelt das Ergebnis "r".@{par} Der Befehl "muls" ist ein sehr schneller und sehr kleiner Ersatz für den Befehl @{" SMult32 " link "StormC:StormSYS/Help/utility/SMult32()"} der "utility.library". Da die Funktion und der Aufruf beider Befehle identisch ist, kann "SMult32" einfach durch "muls" ersetzt werden.@{par} Der Befehl "muls" ist auch als @{" Inlinefunktion " link "Inlinefunktionen"} verfügbar.@{par} @{b}Rückgabe@{ub}@{par} signed 32 Bit Ergebnis "r"@{par} @endnode @node mulu @{fg shine}mulu@{fg text}@{par} unsigned 32 Bit mal 32 Bit Multiplikation mit 32 Bit Ergebnis@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = mulu (arg1, arg2);@{par} ulong r;@{par} ulong arg1;@{par} ulong arg2;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Der Befehl "mulu" multipliziert "arg1" mit "arg2" und ermittelt das Ergebnis "r".@{par} Der Befehl "mulu" ist ein sehr schneller und sehr kleiner Ersatz für den Befehl @{" UMult32 " link "StormC:StormSYS/Help/utility/UMult32()"} der "utility.library". Da die Funktion und der Aufruf beider Befehle identisch ist, kann "UMult32" einfach durch "mulu" ersetzt werden.@{par} Der Befehl "mulu" ist auch als @{" Inlinefunktion " link Inlinefunktionen} verfügbar.@{par} @{b}Rückgabe@{ub}@{par} unsigned 32 Bit Ergebnis "r"@{par} @endnode @node divsl @{fg shine}divsl@{fg text}@{par} signed 32 Bit durch 32 Bit Division mit 32 Bit Quotient und Rest@{par} @{b}Übersicht@{ub}@{par} #include @{par} quotient : remainder = divsl (dividend, divisor);@{par} long quotient;@{par} long remainder;@{par} long dividend;@{par} long divisor;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Der Befehl "divsl" teilt den Dividenden "dividend" durch den Divisor "divisor" und ermittelt den Quotient "quotient" und den Rest "remainder".@{par} Der Befehl "divsl" ist ein sehr schneller und sehr kleiner Ersatz für den Befehl @{" SDivMod32 " link "StormC:StormSYS/Help/utility/SDivMod32()"} der "utility.library". Da die Funktion und der Aufruf beider Befehle identisch ist, kann "SDivMod32" einfach durch "divsl" ersetzt werden.@{par} @{b}Rückgabe@{ub}@{par} signed 32 Bit Quotient "quotient"@{par} signed 32 Bit Rest "remainder"@{par} @endnode @node divul @{fg shine}divul@{fg text}@{par} unsigned 32 Bit durch 32 Bit Division mit 32 Bit Quotient und Rest@{par} @{b}Übersicht@{ub}@{par} #include @{par} quotient : remainder = divul (dividend, divisor);@{par} ulong quotient;@{par} ulong remainder;@{par} ulong dividend;@{par} ulong divisor;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Der Befehl "divul" teilt den Dividenden "dividend" durch den Divisor "divisor" und ermittelt den Quotient "quotient" und den Rest "remainder".@{par} Der Befehl "divul" ist ein sehr schneller und sehr kleiner Ersatz für den Befehl @{" UDivMod32 " link "StormC:StormSYS/Help/utility/UDivMod32()"} der "utility.library". Da die Funktion und der Aufruf beider Befehle identisch ist, kann "UDivMod32" einfach durch "divul" ersetzt werden.@{par} @{b}Rückgabe@{ub}@{par} unsigned 32 Bit Quotient "quotient"@{par} unsigned 32 Bit Rest "remainder"@{par} @endnode @node muls64 @{fg shine}muls64@{fg text}@{par} signed 32 Bit mal 32 Bit Multiplikation mit 64 Bit Ergebnis@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = muls64 (arg1, arg2);@{par} long r;@{par} long arg1;@{par} long arg2;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Der Befehl "muls64" multipliziert "arg1" mit "arg2" und ermittelt das Ergebnis "r".@{par} Der Befehl "muls64" ist ein sehr schneller und sehr kleiner Ersatz für den Befehl @{" SMult64 " link "StormC:StormSYS/Help/utility/SMult64()"} der "utility.library". Da die Funktion und der Aufruf beider Befehle identisch ist, kann "SMult64" einfach durch "muls64" ersetzt werden.@{par} Im Gegensatz zu "SMult64", benötigt "muls64" nicht AmigaOS 3.x, sondern ist bereits ab AmigaOS 2.x lauffähig.@{par} @{b}Rückgabe@{ub}@{par} signed 64 Bit Ergebnis "r"@{par} @endnode @node mulu64 @{fg shine}mulu64@{fg text}@{par} unsigned 32 Bit mal 32 Bit Multiplikation mit 64 Bit Ergebnis@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = mulu64 (arg1, arg2);@{par} ulong r;@{par} ulong arg1;@{par} ulong arg2;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Der Befehl "mulu64" multipliziert "arg1" mit "arg2" und ermittelt das Ergebnis "r".@{par} Der Befehl "mulu64" ist ein sehr schneller und sehr kleiner Ersatz für den Befehl @{" UMult64 " link "StormC:StormSYS/Help/utility/UMult64()"} der "utility.library". Da die Funktion und der Aufruf beider Befehle identisch ist, kann "UMult64" einfach durch "mulu64" ersetzt werden.@{par} Im Gegensatz zu "UMult64", benötigt "mulu64" nicht AmigaOS 3.x, sondern ist bereits ab AmigaOS 2.x lauffähig.@{par} @{b}Rückgabe@{ub}@{par} unsigned 64 Bit Ergebnis "r"@{par} @endnode @node divs64 @{fg shine}divs64@{fg text}@{par} signed 64 Bit durch 32 Bit Division mit 32 Bit Quotient und Rest@{par} @{b}Übersicht@{ub}@{par} #include @{par} quotient : remainder = divs64 (dividend, divisor);@{par} long quotient;@{par} long remainder;@{par} long dividend;@{par} long divisor;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Der Befehl "divs64" teilt den Dividenden "dividend" durch den Divisor "divisor" und ermittelt den Quotient "quotient" und den Rest "remainder".@{par} @{b}Rückgabe@{ub}@{par} signed 32 Bit Quotient "quotient"@{par} signed 32 Bit Rest "remainder"@{par} @endnode @node divu64 @{fg shine}divu64@{fg text}@{par} unsigned 64 Bit durch 32 Bit Division mit 32 Bit Quotient und Rest@{par} @{b}Übersicht@{ub}@{par} #include @{par} quotient : remainder = divu64 (dividend, divisor);@{par} ulong quotient;@{par} ulong remainder;@{par} ulong dividend;@{par} ulong divisor;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Der Befehl "divu64" teilt den Dividenden "dividend" durch den Divisor "divisor" und ermittelt den Quotient "quotient" und den Rest "remainder".@{par} @{b}Rückgabe@{ub}@{par} unsigned 32 Bit Quotient "quotient"@{par} unsigned 32 Bit Rest "remainder"@{par} @endnode @node button_al @{fg shine}button_al@{fg text}@{par} Abfrage der linken Maus- oder Joysticktaste an Port A@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = button_al ();@{par} int r;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Der Befehl "button_al" ist zur Abfrage der linken Maus- oder Joysticktaste an Port A. Wenn zum Zeitpunkt der Abfrage die entsprechende Taste betätigt ist, wird 1 zurückgegeben, sonst 0. @{b}Rückgabe@{ub}@{par} 1 wenn die entsprechende Taste betätigt ist, sonst 0@{par} @{code} @{b}Beispiel@{ub} #include int main__(void) { start: if (!button_al ()) goto start; printf_ ("Hello World!\\n"); return NULL; } @endnode @node button_ar @{fg shine}button_ar@{fg text}@{par} Abfrage der rechten Maustaste an Port A@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = button_ar ();@{par} int r;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Der Befehl "button_ar" ist zur Abfrage der rechten Maustaste an Port A. Wenn zum Zeitpunkt der Abfrage die entsprechende Taste betätigt ist, wird 1 zurückgegeben, sonst 0.@{par} @{b}Rückgabe@{ub}@{par} 1 wenn die entsprechende Taste betätigt ist, sonst 0@{par} @{code} @{b}Beispiel@{ub} #include int main__(void) { start: if (!button_ar ()) goto start; printf_ ("Hello World!\\n"); return NULL; } @endnode @node button_bl @{fg shine}button_bl@{fg text}@{par} Abfrage der linken Maus- oder Joysticktaste an Port B@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = button_bl ();@{par} int r;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Der Befehl "button_bl" ist zur Abfrage der linken Maus- oder Joysticktaste an Port B. Wenn zum Zeitpunkt der Abfrage die entsprechende Taste betätigt ist, wird 1 zurückgegeben, sonst 0.@{par} @{b}Rückgabe@{ub}@{par} 1 wenn die entsprechende Taste betätigt ist, sonst 0@{par} @{code} @{b}Beispiel@{ub} #include int main__(void) { start: if (!button_bl ()) goto start; printf_ ("Hello World!\\n"); return NULL; } @endnode @node button_br @{fg shine}button_br@{fg text}@{par} Abfrage der rechten Maustaste an Port B@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = button_br ();@{par} int r;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Der Befehl "button_br" ist zur Abfrage der rechten Maustaste an Port B. Wenn zum Zeitpunkt der Abfrage die entsprechende Taste betätigt ist, wird 1 zurückgegeben, sonst 0.@{par} @{b}Rückgabe@{ub}@{par} 1 wenn die entsprechende Taste betätigt ist, sonst 0@{par} @{code} @{b}Beispiel@{ub} #include int main__(void) { start: if (!button_br ()) goto start; printf_ ("Hello World!\\n"); return NULL; } @endnode @node button @{fg shine}button@{fg text}@{par} Abfrage der Maus- und Joysticktasten@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = button (port, button);@{par} int r;@{par} int port;@{par} int button;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Der Befehl "button" ist zur Abfrage der Maus- und Joysticktasten. Für "port" kann 0, für Port A, oder 1, für Port B, angegeben werden. Für "button" kann 0, für die linke Maustaste oder die Feuertaste am Joystick, oder 1, für die rechte Maustaste, angegeben werden. Wenn zum Zeitpunkt der Abfrage die entsprechende Taste betätigt ist, wird 1 zurückgegeben, sonst 0.@{par} @{b}Rückgabe@{ub}@{par} 1 wenn die entsprechende Taste betätigt ist, sonst 0@{par} @{code} @{b}Beispiel@{ub} #include int main__(void) { int p = 0; // Port A int b = 0; // linke Maustaste oder Feuertaste start: if (!button (p, b)) goto start; printf_ ("Hello World!\\n"); return NULL; } @endnode @node waitbutton_al @{fg shine}waitbutton_al@{fg text}@{par} Abfrage der linken Maus- oder Joysticktaste an Port A@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = waitbutton_al ();@{par} void r;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Der Befehl "waitbutton_al" ist zur Abfrage der linken Maus- oder Joysticktaste an Port A. Das Programm wartet solange, bis die richtige Taste betätigt wird.@{par} @{code} @{b}Rückgabe@{ub} keine @{b}Beispiel@{ub} #include int main__(void) { waitbutton_al (); printf_ ("Hello World!\\n"); return NULL; } @endnode @node waitbutton_ar @{fg shine}waitbutton_ar@{fg text}@{par} Abfrage der rechten Maustaste an Port A@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = waitbutton_ar ();@{par} void r;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Der Befehl "waitbutton_ar" ist zur Abfrage der rechten Maustaste an Port A. Das Programm wartet solange, bis die richtige Taste betätigt wird.@{par} @{code} @{b}Rückgabe@{ub} keine @{b}Beispiel@{ub} #include int main__(void) { waitbutton_ar (); printf_ ("Hello World!\\n"); return NULL; } @endnode @node waitbutton_bl @{fg shine}waitbutton_bl@{fg text}@{par} Abfrage der linken Maus- oder Joysticktaste an Port B@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = waitbutton_bl ();@{par} void r;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Der Befehl "waitbutton_bl" ist zur Abfrage der linken Maus- oder Joysticktaste an Port B. Das Programm wartet solange, bis die richtige Taste betätigt wird.@{par} @{code} @{b}Rückgabe@{ub} keine @{b}Beispiel@{ub} #include int main__(void) { waitbutton_bl (); printf_ ("Hello World!\\n"); return NULL; } @endnode @node waitbutton_br @{fg shine}waitbutton_br@{fg text}@{par} Abfrage der rechten Maustaste an Port B@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = waitbutton_br ();@{par} void r;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Der Befehl "waitbutton_br" ist zur Abfrage der rechten Maustaste an Port B. Das Programm wartet solange, bis die richtige Taste betätigt wird.@{par} @{code} @{b}Rückgabe@{ub} keine @{b}Beispiel@{ub} #include int main__(void) { waitbutton_br (); printf_ ("Hello World!\\n"); return NULL; } @endnode @node waitbutton @{fg shine}waitbutton@{fg text}@{par} Abfrage der Maus- und Joysticktasten@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = waitbutton (port, button);@{par} void r;@{par} int port;@{par} int button;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Der Befehl "waitbutton" ist zur Abfrage der Maus- und Joysticktasten. Für "port" kann 0, für Port A, oder 1, für Port B, angegeben werden. Für "button" kann 0, für die linke Maustaste oder die Feuertaste am Joystick, oder 1, für die rechte Maustaste, angegeben werden. Das Programm wartet solange, bis die richtige Taste betätigt wird.@{par} @{code} @{b}Rückgabe@{ub} keine @{b}Beispiel@{ub} #include int main__(void) { int p = 0; // Port A int b = 0; // linke Maustaste oder Feuertaste waitbutton (p, b); printf_ ("Hello World!\\n"); return NULL; } @endnode @node max_Height @{fg shine}max_Height@{fg text}@{par} Ermitteln der sichtbaren Fensterhöhe@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = max_Height (window);@{par} int r;@{par} struct Window *window;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Der Befehl "max_Height" ermittelt die sichtbare Höhe des Fensters "window".@{par} Der Befehl "max_Height" ist auch als @{" Inlinefunktion " link Inlinefunktionen} verfügbar.@{par} @{b}Rückgabe@{ub}@{par} Die sichtbare Höhe des Fensters "window".@{par} @endnode @node max_Width @{fg shine}max_Width@{fg text}@{par} Ermitteln der sichtbaren Fensterbreite@{par} @{b}Übersicht@{ub}@{par} #include @{par} r = max_Width (window);@{par} int r;@{par} struct Window *window;@{par} @{b}Standard@{ub}@{par} (noch) keiner (Eigenentwicklung)@{par} @{b}Erklärung@{ub}@{par} Der Befehl "max_Width" ermittelt die sichtbare Breite des Fensters "window".@{par} Der Befehl "max_Width" ist auch als @{" Inlinefunktion " link Inlinefunktionen} verfügbar.@{par} @{b}Rückgabe@{ub}@{par} Die sichtbare Breite des Fensters "window".@{par} @endnode /// /// Stringpuffer @node Stringpuffer @{b}@{fg shine}Der Stringpuffer "s".@{par} ~~~~~~~~~~~~~~~~~~~~~@{fg text}@{ub}@{par} Der Stringpuffer "s" muß mindestens so groß sein, daß die Ausgabe mit abschließenden Nullzeichen hineinpaßt.@{par} Die Funktion kann nicht feststellen ob der Stringpuffer groß genug ist.@{par} @endnode /// /// Parameterliste @node Parameterliste @{b}@{fg shine}Die Parameterliste "vl".@{par} ~~~~~~~~~~~~~~~~~~~~~~~~@{fg text}@{ub}@{par} Die Parameterliste "vl" muß vor dem Aufruf mit va_start initialisiert werden und nach dem Aufruf mit va_end abgeschlossen werden.@{par} @endnode /// /// Ausgabeformatstring @node Ausgabeformatstring @{b}@{fg shine}Der Ausgabeformatstring "format" zur formatierten Ausgabe.@{par} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@{fg text}@{ub}@{par} Der Formatstring "format" zur formatierten Ausgabe besteht aus Formatkommandos und Ausgabezeichen. Die Formatkommandos bestimmen den Typ der Parameter der Ausgabefunktion und die Art der Konvertierung und Ausgabe. Alle Zeichen, die kein Formatkommando sind, also nicht mit dem Zeichen "%" beginnen sind Ausgabezeichen und werden unverändert ausgegeben.@{par} Der Aufbau eines Formatkommandos:@{par} % [flags] [width [.limit] ] [size] type@{par} Die Angaben in den eckigen Klammern können optional angegeben werden.@{par} @{b}flags@{ub}@{par} @{b}"-"@{ub}@{par} zur Linksjustierung@{par} @{b}"+"@{ub}@{par} zur Ausgabe eines positiven Vorzeichens bei Zahlen@{par} @{b}"0"@{ub}@{par} zur Ausgabe führender Nullen bei Zahlen@{par} @{b}"#"@{ub}@{par} zur Ausgabe von "0x" bei hexadezimalen Zahlen und "0" bei oktalen Zahlen sowie abschließender Nullen, falls dies für type "g" oder "G" angegeben wird@{par} @{b}width@{ub}@{par} Feldbreite als dezimale Ziffernfolge oder "*", in diesem Fall wird die Feldbreite als nächstes Argument des Typs int übergeben. Die Feldbreite ist immer ein minimaler Wert, zu lange Ausgaben werden nicht beschnitten.@{par} @{b}limit@{ub}@{par} Die Genauigkeit als dezimale Ziffernfolge oder "*", in diesem Fall wird die Genauigkeit als nächstes Argument des Typs int übergeben. Der Wert beschreibt die maximale Anzahl von Zeichen bei Ausgabe einer Zeichenkette oder die minimale Anzahl von Ziffern einer ganzzahligen Ausgabe oder die Anzahl der Nachkommastellen einer Gleitkommaausgabe.@{par} @{b}size@{ub}@{par} Längenangabe des Arguments:@{par} @{b}"h"@{ub}@{par} für ein Argument des Typs short int oder unsigned short int oder float@{par} @{b}"l"@{ub}@{par} für ein Argument des Typs long int oder unsigned long int oder double@{par} @{b}"L"@{ub}@{par} für ein Argument des Typs long long int oder unsigned long long int (Nur in den speziellen 64-Bit Versionen verfügbar.)@{par} @{b}type@{ub}@{par} Typangabe des Arguments:@{par} @{b}"d", "i"@{ub}@{par} zur Ausgabe einer vorzeichenbehafteten Dezimalzahl, das zugehörige Argument ist vom Typ int@{par} @{b}"o"@{ub}@{par} zur Ausgabe einer vorzeichenlosen Oktalzahl, das zugehörige Argument ist vom Typ int oder unsigned int@{par} @{b}"x"@{ub}@{par} zur Ausgabe einer vorzeichenlosen Hexadezimalzahl mit Kleinbuchstaben, das zugehörige Argument ist vom Typ int oder unsigned int@{par} @{b}"X"@{ub}@{par} zur Ausgabe einer vorzeichenlosen Hexadezimalzahl mit Großbuchstaben, das zugehörige Argument ist vom Typ int oder unsigned int@{par} @{b}"u"@{ub}@{par} zur Ausgabe einer vorzeichenlosen Dezimalzahl, das zugehörige Argument ist vom Typ unsigned int@{par} @{b}"c"@{ub}@{par} zur Ausgabe eines Zeichens, das zugehörige Argument ist vom Typ int und wird in unsigned char konvertiert@{par} @{b}"s"@{ub}@{par} zur Ausgabe einer Zeichenkette, die mit einem Nullzeichen abgeschlossen ist, das zugehörige Argument ist vom Typ char *@{par} @{b}"f"@{ub}@{par} zur Ausgabe einer Fließkommazahl in nichtexponentieller Darstellung, das zugehörige Argument ist vom Typ double@{par} @{b}"e"@{ub}@{par} zur Ausgabe einer Fließkommazahl in exponentieller Darstellung mit kleinem "e" als Exponentzeichen, das zugehörige Argument ist vom Typ double@{par} @{b}"E"@{ub}@{par} zur Ausgabe einer Fließkommazahl in exponentieller Darstellung mit großem "E" als Exponentzeichen, das zugehörige Argument ist vom Typ double@{par} @{b}"g"@{ub}@{par} zur Ausgabe einer Fließkommazahl je nach Exponent in nichtexponentieller oder exponentieller Darstellung mit kleinem "e" als Exponentzeichen, das zugehörige Argument ist vom Typ double@{par} @{b}"G"@{ub}@{par} zur Ausgabe einer Fließkommazahl je nach Exponent in nichtexponentieller oder exponentieller Darstellung mit großem "E" als Exponentzeichen, das zugehörige Argument ist vom Typ double@{par} @{b}"p"@{ub}@{par} zur Ausgabe einer hexadezimalen Speicheradresse, das zugehörige Argument ist vom Typ void *@{par} @{b}"n"@{ub}@{par} zur Speicherung der Anzahl der bisher von diesem Funktionsaufruf ausgegebenen Zeichen in der Variablen, auf die das Argument vom Typ int * zeigt, es erfolgt keine Ausgabe@{par} @{b}"%"@{ub}@{par} zur Ausgabe eines Prozentzeichens@{par} Alle anderen Typangaben führen zu undefinierten Ausgaben.@{par} @endnode /// ///Ausgabeformatstring_ @node Ausgabeformatstring_ @{b}@{fg shine}Der Ausgabeformatstring_ "format" zur formatierten Ausgabe.@{par} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@{fg text}@{ub}@{par} Der Formatstring "format" zur formatierten Ausgabe besteht aus Formatkommandos und Ausgabezeichen. Die Formatkommandos bestimmen den Typ der Parameter der Ausgabefunktion und die Art der Konvertierung und Ausgabe. Alle Zeichen, die kein Formatkommando sind, also nicht mit dem Zeichen "%" beginnen sind Ausgabezeichen und werden unverändert ausgegeben.@{par} Der Aufbau eines Formatkommandos:@{par} % [flags] [width [.limit] ] [size] type@{par} Die Angaben in den eckigen Klammern können optional angegeben werden.@{par} @{b}flags@{ub}@{par} @{b}"-"@{ub}@{par} zur Linksjustierung@{par} @{b}"+"@{ub}@{par} zur Ausgabe eines positiven Vorzeichens bei Zahlen@{par} @{b}"0"@{ub}@{par} zur Ausgabe führender Nullen bei Zahlen@{par} @{b}"#"@{ub}@{par} zur Ausgabe von "0x" bei hexadezimalen Zahlen und "0" bei oktalen Zahlen@{par} @{b}width@{ub}@{par} Feldbreite als dezimale Ziffernfolge oder "*", in diesem Fall wird die Feldbreite als nächstes Argument des Typs int übergeben. Die Feldbreite ist immer ein minimaler Wert, zu lange Ausgaben werden nicht beschnitten.@{par} @{b}limit@{ub}@{par} Die Genauigkeit als dezimale Ziffernfolge oder "*", in diesem Fall wird die Genauigkeit als nächstes Argument des Typs int übergeben. Der Wert beschreibt die maximale Anzahl von Zeichen bei Ausgabe einer Zeichenkette oder die minimale Anzahl von Ziffern einer ganzzahligen Ausgabe.@{par} @{b}size@{ub}@{par} Längenangabe des Arguments:@{par} @{b}"h"@{ub}@{par} für ein Argument des Typs short int oder unsigned short int@{par} @{b}"l"@{ub}@{par} für ein Argument des Typs long int oder unsigned long int@{par} @{b}"L"@{ub}@{par} für ein Argument des Typs long long int oder unsigned long long int (Nur in den speziellen 64-Bit Versionen verfügbar.)@{par} @{b}type@{ub}@{par} Typangabe des Arguments:@{par} @{b}"d", "i"@{ub}@{par} zur Ausgabe einer vorzeichenbehafteten Dezimalzahl, das zugehörige Argument ist vom Typ int@{par} @{b}"o"@{ub}@{par} zur Ausgabe einer vorzeichenlosen Oktalzahl, das zugehörige Argument ist vom Typ int oder unsigned int@{par} @{b}"x"@{ub}@{par} zur Ausgabe einer vorzeichenlosen Hexadezimalzahl mit Kleinbuchstaben, das zugehörige Argument ist vom Typ int oder unsigned int@{par} @{b}"X"@{ub}@{par} zur Ausgabe einer vorzeichenlosen Hexadezimalzahl mit Großbuchstaben, das zugehörige Argument ist vom Typ int oder unsigned int@{par} @{b}"u"@{ub}@{par} zur Ausgabe einer vorzeichenlosen Dezimalzahl, das zugehörige Argument ist vom Typ unsigned int@{par} @{b}"c"@{ub}@{par} zur Ausgabe eines Zeichens, das zugehörige Argument ist vom Typ int und wird in unsigned char konvertiert@{par} @{b}"s"@{ub}@{par} zur Ausgabe einer Zeichenkette, die mit einem Nullzeichen abgeschlossen ist, das zugehörige Argument ist vom Typ char *@{par} @{b}"p"@{ub}@{par} zur Ausgabe einer hexadezimalen Speicheradresse, das zugehörige Argument ist vom Typ void *@{par} @{b}"n"@{ub}@{par} zur Speicherung der Anzahl der bisher von diesem Funktionsaufruf ausgegebenen Zeichen in der Variablen, auf die das Argument vom Typ int * zeigt, es erfolgt keine Ausgabe@{par} @{b}"%"@{ub}@{par} zur Ausgabe eines Prozentzeichens@{par} Alle anderen Typangaben führen zu undefinierten Ausgaben.@{par} @endnode /// /// Eingabeformatstring @node Eingabeformatstring @{b}@{fg shine}Der Eingabeformatstring "format" zur formatierten Eingabe.@{par} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@{fg text}@{ub}@{par} Der Formatstring "format" zur formatierten Eingabe besteht aus den Formatkommandos und Eingabezeichen. Die Formatkommandos bestimmen den Typ der Parameter der Eingabefunktion und die Art der Konvertierung und Eingabe. Alle Zeichen, die kein Formatkommando sind, also nicht mit dem Zeichen "%" beginnen und keine Trennzeichen (Leerzeichen, Tabulatoren und Zeilenvorschübe) sind, sind Eingabezeichen und werden unverändert in der Eingabe erwartet.@{par} Der Aufbau eines Formatkommandos:@{par} % [width] [size] type@{par} Die Angaben in den eckigen Klammern können optional angegeben werden.@{par} @{b}width@{ub}@{par} Die Anzahl der zu lesenden Zeichen als dezimale Ziffernfolge oder "*", in diesem Fall werden die Zeichen zwar gelesen, aber nicht in das nächste Argument übertragen.@{par} @{b}size@{ub}@{par} Längenangabe des Arguments:@{par} @{b}"h"@{ub}@{par} für ein Argument des Typs short int oder unsigned short int oder float@{par} @{b}"l"@{ub}@{par} für ein Argument des Typs long int oder unsigned long int oder double@{par} @{b}"L"@{ub}@{par} für ein Argument des Typs long long int oder unsigned long long int (Nur in den speziellen 64-Bit Versionen verfügbar.)@{par} @{b}type@{ub}@{par} Typangabe des Arguments:@{par} @{b}"d"@{ub}@{par} zur Eingabe einer vorzeichenbehafteten dezimalen Ganzzahl, das zugehörige Argument ist vom Typ int *@{par} @{b}"i"@{ub}@{par} zur Eingabe einer vorzeichenbehafteten Dezimalzahl, Oktalzahl (bei führender '0') oder Hexadezimalzahl (bei führendem '0x' oder '0X'), das zugehörige Argument ist vom Typ int *@{par} @{b}"o"@{ub}@{par} zur Eingabe einer Oktalzahl, das zugehörige Argument ist vom Typ int *@{par} @{b}"x"@{ub}@{par} zur Eingabe einer Hexadezimalzahl mit oder ohne '0x', das zugehörige Argument ist vom Typ int oder unsigned int@{par} @{b}"c"@{ub}@{par} zur Eingabe von "width" Zeichen, wobei Leerzeichen und Zeilentrenner nicht überlesen werden und kein Nullzeichen angehängt wird, das zugehörige Argument ist vom Typ char *@{par} @{b}"s"@{ub}@{par} zur Eingabe einer Zeichenkette, wobei führende Leerzeichen und Zeilentrenner überlesen werden und ein Nullzeichen angehängt wird, das zugehörigen Argument ist vom Typ char *@{par} @{b}"e", "f", "g"@{ub}@{par} zur Eingabe einer Fließkommazahl in beliebiger Darstellung, das zugehörige Argument ist vom Typ float *@{par} @{b}"p"@{ub}@{par} zur Eingabe einer hexadezimalen Speicheradresse, das zugehörige Argument ist vom Typ int *@{par} @{b}"n"@{ub}@{par} zur Speicherung der Anzahl der bisher von diesem Funktionsaufruf gelesenen Zeichen in der Variablen, auf die das Argument vom Typ int * zeigt, es wird kein Zeichen gelesen.@{par} @{b}"[...]"@{ub}@{par} zur Eingabe einer Zeichenkette, die nur aus den in den eckigen Klammern angegebenen Zeichen besteht, wobei ein Nullzeichen angehängt wird, das zugehörigen Argument ist vom Typ char *@{par} @{b}"[^...]"@{ub}@{par} zur Eingabe einer Zeichenkette, die nur aus Zeichen besteht, die nicht in den eckigen Klammern angegebenen sind, wobei ein Nullzeichen angehängt wird; das zugehörigen Argument ist vom Typ char *@{par} @{b}"%"@{ub}@{par} zur Eingabe eines Prozentzeichens@{par} Alle anderen Typangaben führen zu undefinierten Eingaben.@{par} @endnode /// /// Eingabeformatstring_ @node Eingabeformatstring_ @{b}@{fg shine}Der Eingabeformatstring_ "format" zur formatierten Eingabe.@{par} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@{fg text}@{ub}@{par} Der Formatstring "format" zur formatierten Eingabe besteht aus den Formatkommandos und Eingabezeichen. Die Formatkommandos bestimmen den Typ der Parameter der Eingabefunktion und die Art der Konvertierung und Eingabe. Alle Zeichen, die kein Formatkommando sind, also nicht mit dem Zeichen "%" beginnen und keine Trennzeichen (Leerzeichen, Tabulatoren und Zeilenvorschübe) sind, sind Eingabezeichen und werden unverändert in der Eingabe erwartet.@{par} Der Aufbau eines Formatkommandos:@{par} % [width] [size] type@{par} Die Angaben in den eckigen Klammern können optional angegeben werden.@{par} @{b}width@{ub}@{par} Die Anzahl der zu lesenden Zeichen als dezimale Ziffernfolge oder "*", in diesem Fall werden die Zeichen zwar gelesen, aber nicht in das nächste Argument übertragen.@{par} @{b}size@{ub}@{par} Längenangabe des Arguments:@{par} @{b}"h"@{ub}@{par} für ein Argument des Typs short int oder unsigned short int@{par} @{b}"l"@{ub}@{par} für ein Argument des Typs long int oder unsigned long int@{par} @{b}"L"@{ub}@{par} für ein Argument des Typs long long int oder unsigned long long int (Nur in den speziellen 64-Bit Versionen verfügbar.)@{par} @{b}type@{ub}@{par} Typangabe des Arguments:@{par} @{b}"d"@{ub}@{par} zur Eingabe einer vorzeichenbehafteten dezimalen Ganzzahl, das zugehörige Argument ist vom Typ int *@{par} @{b}"i"@{ub}@{par} zur Eingabe einer vorzeichenbehafteten Dezimalzahl, Oktalzahl (bei führender '0') oder Hexadezimalzahl (bei führendem '0x' oder '0X'), das zugehörige Argument ist vom Typ int *@{par} @{b}"o"@{ub}@{par} zur Eingabe einer Oktalzahl, das zugehörige Argument ist vom Typ int *@{par} @{b}"x"@{ub}@{par} zur Eingabe einer Hexadezimalzahl mit oder ohne '0x', das zugehörige Argument ist vom Typ int oder unsigned int@{par} @{b}"c"@{ub}@{par} zur Eingabe von "width" Zeichen, wobei Leerzeichen und Zeilentrenner nicht überlesen werden und kein Nullzeichen angehängt wird, das zugehörige Argument ist vom Typ char *@{par} @{b}"s"@{ub}@{par} zur Eingabe einer Zeichenkette, wobei führende Leerzeichen und Zeilentrenner überlesen werden und ein Nullzeichen angehängt wird, das zugehörigen Argument ist vom Typ char *@{par} @{b}"p"@{ub}@{par} zur Eingabe einer hexadezimalen Speicheradresse, das zugehörige Argument ist vom Typ int *@{par} @{b}"n"@{ub}@{par} zur Speicherung der Anzahl der bisher von diesem Funktionsaufruf gelesenen Zeichen in der Variablen, auf die das Argument vom Typ int * zeigt, es wird kein Zeichen gelesen.@{par} @{b}"[...]"@{ub}@{par} zur Eingabe einer Zeichenkette, die nur aus den in den eckigen Klammern angegebenen Zeichen besteht, wobei ein Nullzeichen angehängt wird, das zugehörigen Argument ist vom Typ char *@{par} @{b}"[^...]"@{ub}@{par} zur Eingabe einer Zeichenkette, die nur aus Zeichen besteht, die nicht in den eckigen Klammern angegebenen sind, wobei ein Nullzeichen angehängt wird; das zugehörigen Argument ist vom Typ char *@{par} @{b}"%"@{ub}@{par} zur Eingabe eines Prozentzeichens@{par} Alle anderen Typangaben führen zu undefinierten Eingaben.@{par} @endnode /// /// Zeitformatstring @node Zeitformatstring @{b}@{fg shine}Zeitformatstring zur Konvertierung einer Zeitangabe.@{par} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@{fg text}@{ub}@{par} Der Zeitformatstring "format" zur formatierten Ausgabe von Datum und Zeit besteht aus den Formatkommandos und Eingabezeichen. Die Formatkommandos bestimmen den Typ der Parameter der Ausgabefunktion und die Art der Konvertierung und Ausgabe. Alle Zeichen, die kein Formatkommando sind, also nicht mit dem Zeichen "%" beginnen sind Ausgabezeichen und werden unverändert ausgegeben.@{par} Der Aufbau eines Formatkommandos:@{par} % type@{par} @{b}type@{ub}@{par} Typangabe des Arguments:@{par} @{b}"a"@{ub}@{par} für den abgekürzten Namen des Wochentages (Mon, Tue, ...)@{par} @{b}"A"@{ub}@{par} für den vollständigen Namen des Wochentages@{par} @{b}"b", "h"@{ub}@{par} für den abgekürzten Namen des Monats (Jan, Feb, ...)@{par} @{b}"B"@{ub}@{par} für den vollständigen Namen des Monats@{par} @{b}"c"@{ub}@{par} für die Kurzdarstellung von Datum und Uhrzeit ("%m/%d/%y %I:%M:%S")@{par} @{b}"C"@{ub}@{par} für die Darstellung im Format "%a %b %e %I:%M:%S %Y"@{par} @{b}"d"@{ub}@{par} für die Nummer des Tages des Monats (01 bis 31)@{par} @{b}"e"@{ub}@{par} für die Nummer des Tages des Monats ( 1 bis 31)@{par} @{b}"H"@{ub}@{par} für die amerikanische Stundendarstellung (01 bis 12)@{par} @{b}"I"@{ub}@{par} für die europäische Stundendarstellung (00 bis 23)@{par} @{b}"j"@{ub}@{par} für die Nummer des Tages im Jahr (001 bis 366)@{par} @{b}"k"@{ub}@{par} für die europäische Stundendarstellung ( 0 bis 23)@{par} @{b}"l"@{ub}@{par} für die amerikanische Stundendarstellung ( 1 bis 12)@{par} @{b}"m"@{ub}@{par} für die Nummer des Monats (01 bis 12)@{par} @{b}"M"@{ub}@{par} für die Anzahl der Minuten (00 bis 59)@{par} @{b}"n"@{ub}@{par} für eine neue Zeile@{par} @{b}"p"@{ub}@{par} für die Tageshälfte ("AM" oder "PM")@{par} @{b}"r"@{ub}@{par} für die Darstellung im Format "%H:%M:%S %p"@{par} @{b}"R"@{ub}@{par} für die Darstellung im Format "%I:%M"@{par} @{b}"S"@{ub}@{par} für die Anzahl von Sekunden (00 bis 60)@{par} @{b}"t"@{ub}@{par} für einen Tabulator@{par} @{b}"u"@{ub}@{par} für die Nummer des Wochentages (1 bis 7); Montag ist erster Wochentag@{par} @{b}"U"@{ub}@{par} für die Nummer der Woche im Jahr (00 bis 53); Sonntag ist erster Wochentag@{par} @{b}"V"@{ub}@{par} für die Nummer der Woche im Jahr (01 bis 53); Montag ist erster Wochentag@{par} @{b}"w"@{ub}@{par} für die Nummer des Wochentages (0 bis 6); Sonntag ist erster Wochentag@{par} @{b}"W"@{ub}@{par} für die Nummer der Woche im Jahr (00 bis 53); Montag ist erster Wochentag@{par} @{b}"x", "D"@{ub}@{par} für die Kurzdarstellung des Datums ("%m/%d/%y")@{par} @{b}"X", "T"@{ub}@{par} für die Kurzdarstellung der Uhrzeit ("%I:%M:%S")@{par} @{b}"y"@{ub}@{par} für die Jahreszahl ohne Jahrhundert@{par} @{b}"Y"@{ub}@{par} für die vollständige Jahreszahl mit Jahrhundert@{par} @{b}"Z"@{ub}@{par} für den Namen der Zeitzone@{par} @{b}"%"@{ub}@{par} für ein Prozentzeichen@{par} Alle anderen Typangaben führen zu undefinierten Ausgaben.@{par} @endnode /// /// Anwendungshinweise @node Anwendungshinweise @{b}@{fg shine}Anwendungshinweise:@{par} ~~~~~~~~~~~~~~~~~~~@{fg text}@{ub}@{par} Obwohl die Anwendung der "stormamiga.lib" sehr einfach ist, möchte ich in diesem Abschnitt einige Hinweise geben.@{par} @{code} @{" Allgemeine Hinweise " link "Allgemeine Hinweise"} Nützliche Hinweise zur Anwendung. @{" Inlinefunktionen " link Inlinefunktionen} Beschreibung der Inlinefunktionen. @{" 64 Bit Funktionen " link "64 Bit Funktionen"} Beschreibung der 64 Bit Funktionen. @{" OS3 Funktionen " link "OS3 Funktionen"} Beschreibung der OS3 Funktionen. @{" Deutsche Funktionen " link "Deutsche Funktionen"} Beschreibung der deutschen Funktionen. @{" Amiga - Funktionen " link Amiga-Funktionen} Beschreibung der Amiga - Funktionen. @endnode /// /// Allgemeine Hinweise @node "Allgemeine Hinweise" @{b}@{fg shine}Allgemeine Hinweise:@{par} ~~~~~~~~~~~~~~~~~~~~@{fg text}@{ub}@{par} @{b}Funktionsübersicht der Bibliotheken@{ub}@{par} __________________________________________________________________________________@{par} | Bibliothek | benötigter | Codemodell | Datenmodell |@{par} | | Prozessor | FAR | NEAR | FAR | NEAR A4 | NEAR A6 |@{par} |¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯|¯¯¯¯¯¯¯¯¯¯¯¯|¯¯¯¯¯¯|¯¯¯¯¯¯|¯¯¯¯¯|¯¯¯¯¯¯¯¯¯|¯¯¯¯¯¯¯¯¯|@{par} | stormamiga.lib | MC68EC020+ | ja | (ja) | ja | ja | nein |@{par} |---------------------------|------------|------|------|-----|---------|---------|@{par} | stormamiga_nc.lib | MC68EC020+ | (ja) | ja | ja | ja | nein |@{par} |---------------------------|------------|------|------|-----|---------|---------|@{par} | stormamiga_881.lib | MC68881+ | ja | (ja) | ja | ja | nein |@{par} |---------------------------|------------|------|------|-----|---------|---------|@{par} | stormamiga_nc_881.lib | MC68881+ | (ja) | ja | ja | ja | nein |@{par} |---------------------------|------------|------|------|-----|---------|---------|@{par} | stormamiga_040.lib | MC68040+ | ja | (ja) | ja | ja | nein |@{par} |---------------------------|------------|------|------|-----|---------|---------|@{par} | stormamiga_nc_040.lib | MC68040+ | (ja) | ja | ja | ja | nein |@{par} |---------------------------|------------|------|------|-----|---------|---------|@{par} | stormamiga_060.lib | MC68060 | ja | (ja) | ja | ja | nein |@{par} |---------------------------|------------|------|------|-----|---------|---------|@{par} | stormamiga_nc_060.lib | MC68060 | (ja) | ja | ja | ja | nein |@{par} |---------------------------|------------|------|------|-----|---------|---------|@{par} | stormamiga-library.lib | MC68EC020+ | ja | (ja) | ja | nein | nein |@{par} |---------------------------|------------|------|------|-----|---------|---------|@{par} | stormamiga-library_nc.lib | MC68EC020+ | (ja) | ja | ja | nein | nein |@{par} ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯@{par} (ja) = Wenn die so gekennzeichneten Bibliotheken in dem entsprechenden Codemodell verwendet@{par} werden, dann funktionieren diese Programme zwar, werden dadurch aber größer.@{par} Die Includedatei "stormamiga.h" enthält die Deklaration für alle Spezialfunktionen.@{par} Um nicht ständig unendliche Verse wie "unsigned long long int" schreiben zu müssen, habe ich kurze Worte wie "ullint" definiert.@{par} @{b}definierte Abkürzungen@{ub}@{par} cvoid für const void@{par} cchar für const char@{par} cschar für const signed char@{par} cuchar für const unsigned char@{par} schar für signed char@{par} uchar für unsigned char@{par} ushort für unsigned short@{par} lint für long int@{par} llint für long long int@{par} uint für unsigned int@{par} ulint für unsigned long int@{par} ullint für unsigned long long int@{par} llong für long long@{par} ulong für unsigned long@{par} ullong für unsigned long long@{par} @{b}Definitionen der Includedatei "stormamiga.h"@{ub}@{par} @{" STORMAMIGA " link STORMAMIGA}@{" STORMAMIGA_DEUTSCH " link "Deutsche Funktionen"}@{" STORMAMIGA_INLINE " link Inlinefunktionen} @{" STORMAMIGA_NOWB " link STORMAMIGA_NOWB}@{" STORMAMIGA_NO_IO_WB " link STORMAMIGA_NO_IO_WB}@{" STORMAMIGA_OS3 " link "OS3 Funktionen"} @{" STORMAMIGA_STACK " link STORMAMIGA_STACK}@{" STORMAMIGA_UNIXPATH " link STORMAMIGA_UNIXPATH}@{" STORMAMIGA_64BIT " link "64 Bit Funktionen"}@{par} Die Includedatei "stormamigainline.h" enthält alle verfügbaren @{" Inlinefunktionen " link Inlinefunktionen}.@{par} Wenn Sie Fragen zum Startupcode haben, dann sehen Sie bitte bei @{" Startupcode " link Startupcode} nach.@{par} Alle Funktionen mit dem Namen "...64" (z.B.: "printf64") sind @{" 64 Bit Funktionen " link "64 Bit Funktionen"}.@{par} Alle Funktionen mit dem Namen "..._3" (z.B.: "malloc_3") sind @{" OS3 Funktionen " link "OS3 Funktionen"}.@{par} Alle Funktionen mit dem Namen "..._d" (z.B.: "ctime_d") sind @{" Deutsche Funktionen " link "Deutsche Funktionen"}.@{par} Wenn Ihre Quelltexte auch mit anderen Compilern problemlos funktionieren sollen, dann sollten Sie Ihre Quelltexte wie dieses Beispiel gestalten.@{par} @{code} @{b}Beispiel@{ub} #include #include #ifdef __STORM__ #define STORMAMIGA_INLINE #define STORMAMIGA_DEUTSCH #include #define printf printf_ #define main main__ #endif int main (void) { struct tm *tp; time_t t; time (&t); tp = localtime (&t); printf ("Die aktuelle Zeit ist %s", asctime (tp)); return NULL; } @endnode /// /// STORMAMIGA @node STORMAMIGA @{b}@{FG shine}Die Definition "STORMAMIGA":@{par} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~@{FG text}@{ub}@{par} Wenn Sie die Spezialfunktionen der "stormamiga.lib" nutzen wollen, müssen Sie die Zeile "#define STORMAMIGA", vor dem Aufruf der Includedateien in Ihr Programm einbinden, oder bei den Compileroptionen (Preprozessor) des Menüs Einstellungen eintragen.@{par} @endnode /// /// STORMAMIGA_UNIXPATH @node STORMAMIGA_UNIXPATH @{b}@{FG shine}Die Definition "STORMAMIGA_UNIXPATH":@{par} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@{FG text}@{ub}@{par} Durch Definition von "STORMAMIGA_UNIXPATH" wird es möglich Pfadangaben im Unix-Format zu verwenden. Um diese Defintion zu nutzen müssen Sie die Zeile "#define STORMAMIGA_UNIXPATH", vor dem Aufruf der Includedateien in Ihr Programm einbinden, oder bei den Compileroptionen (Preprozessor) des Menüs Einstellungen eintragen.@{par} @{code} @{u}@{b}Alle verfügbaren Funktionen:@{uu}@{ub} @{b}stdio Funktionen@{ub} remove() @{b}unistd Funktionen@{ub} access() chdir() rmdir() unlink() @{b}fcntl Funktionen@{ub} creat() open() @{b}stat Funktionen@{ub} chmod() lstat() mkdir() stat() @{b}dirent Funktionen@{ub} opendir() @{b}time Funktionen@{ub} utime() utimes() @endnode /// /// STORMAMIGA_STACK @node STORMAMIGA_STACK @{b}@{FG shine}Die Definition "STORMAMIGA_STACK":@{par} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@{FG text}@{ub}@{par} Mit der Definition "STORMAMIGA_STACK" kann die Stackgröße, mit der ein Programm arbeiten soll, definiert werden. Dazu müssen Sie die Zeile "#define STORMAMIGA_STACK xxxx" (xxxx steht für die Stackgröße), vor dem Aufruf der Includedateien, in Ihr Programm einbinden, oder bei den Compileroptionen (Preprozessor) des Menüs Einstellungen eintragen.@{par} @{b}@{FG fill}Wichtig@{FG text}@{ub}@{par} Wenn Sie diese Definition verwenden, dann müssen Sie unbedingt eine Stackgröße angeben, da es sonst zu Fehlern und Systemabstürzen kommen kann.@{par} @endnode /// /// STORMAMIGA_NOWB @node STORMAMIGA_NOWB @{b}@{FG shine}Die Definition "STORMAMIGA_NOWB":@{par} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@{FG text}@{ub}@{par} Durch Definition von "STORMAMIGA_NOWB" sind die mit der "stormamiga.lib" gelinkten Programme nich mehr von der Workbench startbar und werden etwas kleiner. Um diese Defintion zu nutzen müssen Sie die Zeile "#define STORMAMIGA_NOWB", vor dem Aufruf der Includedateien, in Ihr Programm einbinden, oder bei den Compileroptionen (Preprozessor) des Menüs Einstellungen eintragen.@{par} @{b}@{FG fill}Wichtig@{FG text}@{ub}@{par} Wenn Sie diese Definition verwenden, dann wird eine eventuel vorhandene wbmain-Funktion nicht beachtet. Wird ein Programm, daß mit dieser Definition kompiliert wurde, von der Workbench gestartet, dann kann es zum Systemabsturz kommen.@{par} Diese Definition ist nur für "reine" CLI-Programme gedacht.@{par} @endnode /// /// STORMAMIGA_NO_IO_WB @node STORMAMIGA_NO_IO_WB @{b}@{FG shine}Die Definition "STORMAMIGA_NO_IO_WB":@{par} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@{FG text}@{ub}@{par} Durch Definition von "STORMAMIGA_NO_IO_WB" wird verhindert, daß die Standardausgabe "stdout" und die Standardeingabe "stdin" in ein CLI Fenster umgeleitet werden. Um diese Defintion zu nutzen müssen Sie die Zeile "#define STORMAMIGA_NO_IO_WB", vor dem Aufruf der Includedateien; in Ihr Programm einbinden, oder bei den Compileroptionen (Preprozessor) des Menüs Einstellungen eintragen.@{par} @endnode /// /// OS3 Funktionen @node "OS3 Funktionen" @{b}@{FG shine}Die OS3 Funktionen":@{par} ~~~~~~~~~~~~~~~~~~~~@{FG text}@{ub}@{par} Die OS3 Funktionen sind speziell für AmigaOS 3.x optimierte Funktionen. Dadurch werden die neuen Funktionen von AmigaOS 3.x genutzt und die Programme werden etwas kleiner. Wenn Sie die OS3 Funktionen verwenden wollen, müssen Sie die Zeile "#define STORMAMIGA_OS3", vor dem Aufruf der Includedateien, in Ihr Programm einbinden, oder bei den Compileroptionen (Preprozessor) des Menüs Einstellungen eintragen.@{par} @{b}@{FG fill}Wichtig@{FG text}@{ub}@{par} Sie sollten die OS3 Funktionen nur durch die Definition "STORMAMIGA_OS3" aktivieren und @{b}niemals@{ub} einzeln verwenden.@{par} Bei Verwendung dieser Funktionen sind die so erzeugten Programme nich mehr unter AmigaOS 2.x verwendbar.@{par} @{code} @{u}@{b}Alle verfügbaren Funktionen:@{uu}@{ub} @{b}stdlib Funktionen@{ub} free_3() malloc_3() @{b}interne Funktionen@{ub} EXIT_4_free_3() @endnode /// /// 64BitFunktionen @node "64 Bit Funktionen" @{b}@{FG shine}Die 64 Bit Funktionen:@{par} ~~~~~~~~~~~~~~~~~~~~~~@{FG text}@{ub}@{par} Die 64 Bit Funktionen sind erweiterte Versionen der printf und scanf Funktionen. Sie unterstützen zusätzlich die Größe "L", die für long long int oder unsigned long long int steht.@{par} Wenn Sie alle 64 Bit Funktionen verwenden wollen, müssen Sie die Zeile "#define STORMAMIGA_64BIT", vor dem Aufruf der Includedateien, in Ihr Programm einbinden, oder bei den Compileroptionen (Preprozessor) des Menüs Einstellungen eintragen.@{par} Wenn Sie nur einige 64 Bit Funktionen verwenden wollen, müssen Sie an die Namen der entsprechenden Funktionen "64" anhängen (aus "printf" wird also "printf64").@{par} @{code} @{u}@{b}Alle verfügbaren Funktionen:@{uu}@{ub} @{b}stdio Funktionen@{ub} fprintf64() fprintf64_() fscanf64() fscanf64_() printf64() printf64_() scanf64() scanf64_() snprintf64() snprintf64_() sprintf64() sprintf64_() sscanf64() sscanf64_() vfprintf64() vfprintf64_() vfscanf64() vfscanf64_() vprintf64() vprintf64_() vscanf64() vscanf64_() vsnprintf64() vsnprintf64_() vsprintf64() vsprintf64_() vsscanf64() vsscanf64_() @endnode /// /// Inlinefunktionen @node Inlinefunktionen @{b}@{fg shine}Die Inlinefunktionen:@{par} ~~~~~~~~~~~~~~~~~~~~~@{fg text}@{ub}@{par} Die Inlinefunktionen werden, wie der Name schon sagt, an die Stelle (in die Zeile oder Linie) des Funktionsaufrufes eingefügt. Dadurch werden die Programme meistens etwas kürzer und schneller. Bei keiner oder geringer Optimierung kann es sein, daß die Programme wesentlich größer und langsamer werden.@{par} Wenn Sie die Inlinefunktionen nutzen wollen, müssen Sie die Zeile "#define STORMAMIGA_INLINE", vor dem Aufruf der Includedateien, in Ihr Programm einbinden, oder bei den Compileroptionen (Preprozessor) des Menüs Einstellungen eintragen.@{par} @{code} @{u}@{b}Alle verfügbaren Funktionen:@{uu}@{ub} @{b}stdio Funktionen@{ub} clearerr() feof() ferror() fgetc() fputc() getc() perror() putc() putchar() remove() rename() setbuf() setbuffer() setlinebuf() ungetc() @{b}string Funktionen@{ub} bzero() memchr() memcmp() memcpy() memmove() memset() @{b}stdlib Funktionen@{ub} abort() atof() atoi() atol() atoll() @{b}time Funktionen@{ub} ctime() ctime_d() difftime() localtime() @{b}Spezial Funktionen@{ub} max_Height() max_Width() muls() mulu() @{b}amiga.lib Funktionen@{ub} CreateExtIO() CreateStdIO() DeleteExtIO() DeleteStdIO() DeleteTask() NewList() RemTOF() waitbeam() @{b}Amiga Funktionen@{ub} GetAPen() GetBPen() Move() @endnode /// /// Deutsche Funktionen @node "Deutsche Funktionen" @{b}@{fg shine}Die deutschen Funktionen:@{par} ~~~~~~~~~~~~~~~~~~~~~~~~~@{fg text}@{ub}@{par} Da in "ANSI C" und "C++" keine Umlaute unterstützt werden und alle Texte auf englisch ausgegeben werden, habe ich einige deutsche Funktionen geschrieben, die alle Texte auf deutsch ausgeben und alle Umlaute unterstützen.@{par} Wenn Sie alle deutschen Funktionen verwenden wollen, müssen Sie die Zeile "#define STORMAMIGA_DEUTSCH", vor dem Aufruf der Includedateien, in Ihr Programm einbinden, oder bei den Compileroptionen (Preprozessor) des Menüs Einstellungen eintragen.@{par} Wenn Sie nur einige deutsche Funktionen verwenden wollen, müssen Sie an die Namen der entsprechenden Funktionen "_d" anhängen (aus "ctime" wird also "ctime_d").@{par} @{code} @{u}@{b}Alle verfügbaren Funktionen:@{uu}@{ub} @{b}string Funktionen@{ub} strcasecmp_d() strncasecmp_d() stricmp_d() strnicmp_d() strlower_d() strlwr_d() strupper_d() strupr_d() @{b}ctype Funktionen@{ub} isalnum_d() isalpha_d() islower_d() isprint_d() ispunct_d() isupper_d() tolower_d() toupper_d() @{b}time Funktionen@{ub} asctime_d() ctime_d() strftime_d() @endnode /// /// Amiga-Funktionen @node Amiga-Funktionen @{b}@{fg shine}Die Amiga - Funktionen:@{par} ~~~~~~~~~~~~~~~~~~~~~~~@{fg text}@{ub}@{par} Bei den Amiga - Funktionen handelt es sich um Funktionen, die bereits im AmigaOS enthalten sind. Da die AmigaOS - Funktionen aber oft sehr groß und langsam sind, habe ich mich entschlossen einige dieser Funktionen in die "stormamiga.lib" zu integrieren.@{par} Die Amiga - Funktionen sind nur als @{" Inlinefunktionen " link Inlinefunktionen} verfügbar.@{par} @endnode /// /// Beispiele @node Beispiele @{b}@{fg shine}Beispiele:@{par} ~~~~~~~~~~@{fg text}@{ub}@{par} Um in Ansi-C die Vorteile und Anwendungsmöglichkeiten der "stormamiga.lib" etwas zu verdeutlichen, habe ich die Programme "Hello_World", "Pi", "Dhrystone", "SpeedTest" und "TaskDemo" als Beispiele beigelegt.@{par} Die Beispiele mit dem Namen "...-storm" werden mit der "storm020.lib" und dem Startupcode "startup.o" gelinkt.@{par} Die Beispiele mit dem Namen "...-stormamiga" werden mit der "stormamiga_nc.lib" und dem Startupcode "stormamiga_nc_startups+.o" gelinkt.@{par} Die Beispiele mit dem Namen "...-stormamiga-2" werden mit der "stormamiga_nc.lib" und dem Startupcode "stormamiga_nc_startups+.o" gelinkt. Außerdem wurde der Quelltext für die "stormamiga.lib" optimiert.@{par} Um in C++ die Vorteile und Anwendungsmöglichkeiten der "stormamiga.lib" und der "C++.lib" etwas zu verdeutlichen, habe ich das Programm "Hello_World_C++" als Beispiel beigelegt.@{par} Die Beispiele mit dem Namen "...-storm" werden mit der "storm020.lib" und dem Startupcode "startup.o" gelinkt.@{par} Die Beispiele mit dem Namen "...-stormamiga" werden mit der "stormamiga_nc.lib", der "C++.lib" und dem Startupcode "stormamiga_nc_C++_startups+.o" gelinkt.@{par} Die Beispiele mit dem Namen "...-stormamiga-2" werden mit der "stormamiga_nc.lib", der "C++.lib" und dem Startupcode "stormamiga_nc_C++_startups+.o" gelinkt.Außerdem wurde der Quelltext für die "stormamiga.lib" optimiert.@{par} @{b}Hinweise zum Programm "SpeedTest":@{ub}@{par} Bei "SpeedTest" handelt es sich um ein einfaches Testprogramm, daß die Geschwindigkeit und Genauigkeit der mathematischen Funktionen und der Ausgaberoutinen testet.@{par} Die Anzahl der Testdurchläufe sollte für einen MC68060 etwa 1000000, für einen MC68040+ etwa 500000 bis 1000000, für einen MC68881+ etwa 100000 bis 500000 und ohne Koprozessor etwa 10000 bis 50000 betragen.@{par} Auf einem A1200 mit OS 3.0 gibt die Funktion "sqrt" der "mathieeedoubbas.library" merkwürdigerweise eine unendliche Zahl (inf) anstatt einer ungültigen Zahl (NaN) aus.@{par} @endnode /// /// Bekannte Fehler @node "Bekannte Fehler" @{b}@{fg shine}Bekannte Fehler:@{par} ~~~~~~~~~~~~~~~~@{fg text}@{ub}@{par} - @{b}K E I N E@{ub}@{par} @endnode /// /// Updates @node Updates @{b}@{fg shine}Updates:@{par} ~~~~~~~~@{fg text}@{ub}@{par} Sie können die neuste Version immer auf unserer Homepage "http://WWW.CyberdyneSystems.de/" finden.@{par} Sie können die neuste Version auch direkt von @{" mir " link Autor} bekommen. Wenn ich Ihnen die neuste Version per Post zuschicken soll, dann müssen Sie mir einen frankierten Briefumschlag und eine Diskette (HD oder DD) zuschicken.@{par} @endnode /// /// Einschränkungen @node Einschränkungen @{b}@{fg shine}Einschränkungen der Demo-Version:@{par} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@{fg text}@{ub}@{par} In der Demo-Version der "stormamiga.lib" fehlt die Unterstützung für das kleine Codemodell und die für den MC68881+, MC68040+ und MC68060 optimierten Versionen. Das Erstellen von Shared Librarys ist ebenfalls nicht möglich. Außerdem wird beim Start, eines mit der Demo-Version der "stormamiga.lib" gelinktem Programmes, ein Informationsrequester angezeigt. @{code} @{u}@{b}Alle verfügbaren Dateien der Demo-Version:@{uu}@{ub} @{b}Linkerbibliotheken@{ub} stormamiga.lib Diese Version der "stormamiga.lib" ist eine spezielle Demo-Version. @{b}Startupcodes@{ub} stormamiga_startups.o stormamiga_C++_startups.o Diese Startupcodes sind spezielle Demo-Versionen. @{b}Inkluddateien@{ub} sys/dir.h sys/dirent.h sys/resource.h sys/stat.h sys/time.h sys/times.h sys/types.h sys/unistd.h dirent.h limits.h limits_stormamiga.h math.h math_stormamiga.h stdio.h stdio_stormamiga.h stormamiga.h stormamigainline.h string.h string_stormamiga.h time.h time_stormamiga.h unistd.h UnixToAmigaPath.h utime.h @{b}Benutzerlexikon@{ub} User x.dic ("x" ist eine Zahl zwischen 1 und 3) @{b}Beispiele@{ub} Hello_World Hello_World_C++ Dhrystone TaskDemo drops SpeedTest Die Beispiele wurden an die Demo-Version angepaßt. @{u}@{b}Alle verfügbaren Dateien der Voll-Version:@{uu}@{ub} @{b}Linkerbibliotheken@{ub} stormamiga.lib stormamiga_nc.lib stormamiga_881.lib stormamiga_nc_881.lib stormamiga_040.lib stormamiga_nc_040.lib stormamiga_060.lib stormamiga_nc_060.lib stormamiga-library.lib stormamiga-library_nc.lib @{b}Startupcodes@{ub} stormamiga_startups.o stormamiga_startups+.o stormamiga_nc_startups.o stormamiga_nc_startups+.o stormamiga_C++_startups.o stormamiga_C++_startups+.o stormamiga_nc_C++_startups.o stormamiga_nc_C++_startups+.o @{b}Inkluddateien@{ub} sys/dir.h sys/dirent.h sys/resource.h sys/stat.h sys/time.h sys/times.h sys/types.h sys/unistd.h dirent.h limits.h limits_stormamiga.h math.h math_stormamiga.h stdio.h stdio_stormamiga.h stormamiga.h stormamigainline.h string.h string_stormamiga.h time.h time_stormamiga.h unistd.h UnixToAmigaPath.h utime.h @{b}Benutzerlexikon@{ub} User x.dic ("x" ist eine Zahl zwischen 1 und 3) @{b}Beispiele@{ub} Hello_World Hello_World_C++ Dhrystone TaskDemo drops SpeedTest @endnode /// /// Registrierung @node Registrierung @{b}@{fg shine}Registrierung:@{par} ~~~~~~~~~~~~~~@{fg text}@{ub}@{par} Die "stormamiga.lib" ist Shareware. Wenn Sie die uneingeschränkte Version nutzen möchten, müssen Sie sich bei mir registrieren und die angegebene Gebühr bezahlen. Meine Adresse finden Sie unter @{" Autor " link Autor}. Meine Bankverbindung können Sie von mir erfahren.@{par} Wenn sie sich registriert haben erhalten sie ihre Registriernummer zum Laden der "stormamiga.lib".@{par} @{b}Preise@{ub}@{par} Version für AmigaOS/68k: 10,- DM oder 7,- $ (US Dollar) oder 5,- £ (UK Pound)@{par} Version für p.OS/68k : 10,- DM oder 7,- $ (US Dollar) oder 5,- £ (UK Pound)@{par} Version für AmigaOS/PPC: 20,- DM oder 14,- $ (US Dollar) oder 10,- £ (UK Pound)@{par} Version für p.OS/PPC : 20,- DM oder 14,- $ (US Dollar) oder 10,- £ (UK Pound) (noch nicht verfügbar)@{par} @endnode /// /// Kopierrecht @node Kopierrecht @{b}@{fg shine}Kopierrecht:@{par} ~~~~~~~~~~~~@{fg text}@{ub}@{par} Die Demo-Version der "stormamiga.lib" darf frei kopiert werden, solange sie in KEINSTER Weise verändert wird und ALLE dazugehörigen Dateien UNVERÄNDERT mitkopiert werden.@{par} @{b}Die Voll-Version der "stormamiga.lib" ist NUR für registrierte Anwender. Die "stormamiga.lib", das Passwort und die Registriernummer dürfen NICHT weitergegeben oder verbreitet werden@{ub}.@{par} Eine Reassemblierung der "stormamiga.lib" ist selbstverständlich NICHT gestattet.@{par} @{b}@{i}@{u}AM WICHTIGSTEN:@{ub}@{ui}@{uu}@{par} Die Benutzung der "stormamiga.lib" erfolgt AUSSCHLIEßLICH auf eigenes Risiko.@{par} Der Autor kann auf KEINEN FALL für einen Schaden oder Datenverlust der direkt oder indirekt mit dem Gebrauch der "stormamiga.lib" entstehen sollte verantwortlich gemacht werden.@{par} Alle Rechte vorbehalten. Für Fehlermitteilungen oder Verbesserungsvorschläge bin ich jederzeit dankbar.@{par} @endnode /// /// Geschichte @node Geschichte @{b}@{fg shine}Geschichte:@{par} ~~~~~~~~~~~@{fg text}@{ub}@{par} @{" V.43.00 - V.43.05 " link V.43.00-V.43.05} 02.05.1997 - 13.03.1998@{par} @{b}stormamiga.lib V.44.01 (16.07.1998 - 15.08.1998):@{par} ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯@{ub}@{par} - die internen Funktionen "INIT_5_InitStdIOFiles" und "EXIT_5_InitStdIOFiles" optimiert; Diese Funktionen sind jetzt kürzer.@{par} - die Funktionen "ostream::operator <<(short)", "ostream::operator <<(ushort)", "ostream::operator <<(int)", "ostream::operator <<(uint)", "ostream::operator <<(long)", "ostream::operator <<(ulong)", "ostream::operator <<(cuchar *)", "ostream::operator <<(cschar *)" und "ostream::operator <<(cchar *)" optimiert; Diese Funktionen sind jetzt kürzer.@{par} - Fehlerkorrektur der internen Funktionen "INIT_5_InitStdIOFiles" und "EXIT_5_InitStdIOFiles" (nur bei Near Code und Near Data)@{par} - Fehlerkorrektur der Funktionen "ostream::operator <<(void *)"@{par} - das Installerskript überarbeitet und erweitert@{par} - die Anleitung überarbeitet und erweitert@{par} @{b}stormamiga-library.lib V.44.01 (16.07.1998 - 15.08.1998):@{par} ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯@{ub}@{par} - die internen Funktionen "INIT_5_InitStdIOFiles" und "EXIT_5_InitStdIOFiles" optimiert; Diese Funktionen sind jetzt kürzer.@{par} - die Funktionen "LibOpen" und "LibClose" überarbeitet und erweitert (nur die Versionen für StormC V2)@{par} @{b}stormamiga.lib V.44.00 (13.11.1997 - 15.07.1998):@{par} ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯@{ub}@{par} - die string-Funktionen "stpchr", "stpcpy", "strbpl" und "strins" geschrieben@{par} - die string-Funktion "strdup" optimiert; Diese Funktion ist jetzt kürzer und schneller.@{par} - die stdio-Funktionen "getw" und "putw" geschrieben@{par} - die stdio-Funktionen "fopen", "fclose", "freopen", "setvbuf" und "tmpnam" optimiert; Diese Funktionen sind jetzt kürzer und schneller.@{par} - die stdlib-Funktionen "calloc", "realloc", "atexit" und "getenv" optimiert; Diese Funktionen sind jetzt kürzer und schneller.@{par} - die dirent-Funktionen "opendir", "readdir", "rewinddir" und "closedir" geschrieben@{par} - die unistd-Funktionen "sleep", "usleep", "access", "chdir", "rmdir", "unlink", "getwd", "getcwd", "mktemp", "close", "lseek", "read" und "write" geschrieben@{par} - die fcntl-Funktionen "creat" und "open" geschrieben@{par} - die stat-Funktionen "stat", "lstat", "fstat", "chmod" und "mkdir" geschrieben@{par} - die time-Funktionen "times", "utime" und "utimes" geschrieben@{par} - die time-Funktionen "ctime" und "ctime_d" optimiert; Diese Funktionen sind jetzt kürzer und schneller.@{par} - die resource-Funktion "getrusage" geschrieben@{par} - die math-Funktionen "cosh", "sinh", "log10", "tanh", "log", "pow", "cos", "sin", "atan", "tan", "exp", "acos", "asin" (nur bei den Versionen für MC68EC020+, MC68040+ und MC68060), "fabs", "fmod", "modf", "sqrt", "atan2", "ceil" und "floor" optimiert (nur bei den Versionen für MC68EC020+)@{par} - die spezial-Funktionen "button" und "waitbutton" optimiert; Diese Funktionen sind jetzt kürzer.@{par} - die amiga.lib-Funktionen "LibAllocPooled" und "LibFreePooled" neu geschrieben@{par} - die internen Funktionen "dotimer", "INIT_9_chdir", "EXIT_9_chdir", "INIT_5_timer", "UnixToAmigaPath", "INIT_6_InitPOSIXIOFiles" und "EXIT_6_InitPOSIXIOFiles" geschrieben@{par} - die internen Funktionen "double_in", "double_out", "form_in", "form_in64", "form_out", "form_out64" (nur bei den Versionen für MC68EC020+), "INIT_9_Stack", "EXIT_9_Stack", "EXIT_5_InitFiles", "INIT_5_clock", "EXIT_4_free", "INIT_5_InitStdIOFiles", "INIT_5_fstream", "EXIT_0_Main", "amigaopen", "amigaclose", "amigaflush", "amigagetc", "amigagetcunget", "amigaputc", "amigaread", "amigareadunget", "amigaseek", "amigaungetc" und "amigawrite" optimiert; Diese Funktionen sind jetzt kürzer und schneller.@{par} - die Versionen für MC68060 optimiert (alle emulierten Instruktionen entfernt); dadurch werden viele Programme sehr schnell.@{par} - Fehlerkorrektur der stdlib-Funktionen "free" und "malloc_3"@{par} - Fehlerkorrektur der stdio-Funktion "fopen"@{par} - Fehlerkorrektur der string-Funktion "memset"@{par} - Fehlerkorrektur der internen Funktion "double_out" (nur im großen Datenmodell bei den Versionen für MC68EC020+), "double_in" (nur bei den Versionen für MC68881+, MC68040+ und MC68060), "form_in", "form_in_", "form_in64" "form_in64_", "form_out", "form_out_", "form_out64" und "form_out64_"@{par} - Fehlerkorrektur der Funktionen "istream::getline(char *, int, char)", "istream::get(char *, int, char)", "ostream::operator <<(const char *)" und "delete"@{par} - Fehlerkorrektur der Includedatei "stormamiga.h"@{par} - die internen Funktionen "LibInit", "LibOpen", "LibClose", "LibExpunge", "LibNull", "__LibOpen" und "__LibClose" entfernt; Diese Funktionen sind, in der aktuellen Version der "stormamiga.lib", nicht mehr notwendig.@{par} - die Includedateien "limits_stormamiga.h", "math_stormamiga.h", "stdio_stormamiga.h", "string_stormamiga.h", "time_stormamiga.h", "sys/time.h", "sys/times.h", "sys/resource.h", "utime.h", "unistd.h", "sys/dirent.h", "sys/dir.h", "dirent.h", "sys/stat.h", "sys/types.h", "sys/unistd.h" und "fcntl.h" geschrieben@{par} - die Includedateien "stormamiga.h" und "stormamigainline.h" überarbeitet und erweitert@{par} - alle Beispielprogramme an die aktuelle Version der "stormamiga.lib" angepaßt@{par} - die Definitionen "STORMAMIGA_UNIXPATH" und "STORMAMIGA" hinzugefügt@{par} - das Benutzer-Lexikon überarbeitet und erweitert@{par} - das Installerskript überarbeitet und erweitert@{par} - die Anleitung überarbeitet und erweitert; Beschreibung der neuen Funktionen hinzugefügt, einige Fehler beseitigt@{par} @{b}stormamiga-library.lib V.44.00 (10.03.1998 - 15.07.1998):@{par} ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯@{ub}@{par} - die internen Funktionen "EXIT_3_AmigaGuideBase", "EXIT_2_AslBase", "EXIT_3_BulletBase", "EXIT_3_ColorWheelBase", "EXIT_2_CxBase", "EXIT_3_DataTypesBase", "EXIT_2_DiskfontBase", "EXIT_1_DOSBase", "EXIT_2_ExpansionBase", "EXIT_2_GadToolsBase", "EXIT_3_GradientSliderBase", "EXIT_2_GfxBase", "EXIT_2_IconBase", "EXIT_2_IFFParseBase", "EXIT_2_IntuitionBase", "EXIT_2_KeymapBase", "EXIT_2_LayersBase", "EXIT_3_LocaleBase", "EXIT_3_LowLevelBase", "EXIT_2_MathBase", "EXIT_2_MathIeeeDoubBasBase", "EXIT_2_MathIeeeDoubTransBase", "EXIT_2_MathIeeeSingBasBase", "EXIT_2_MathIeeeSingTransBase", "EXIT_2_MathTransBase", "EXIT_2_MUIMasterBase", "EXIT_3_NVBase", "EXIT_3_RealTimeBase", "EXIT_2_ReqToolsBase", "EXIT_2_RexxSysBase", "EXIT_3_TranslatorBase", "EXIT_1_UtilityBase", "EXIT_2_VersionBase", "EXIT_2_WizardBase", "EXIT_2_WorkbenchBase", "INIT_3_AmigaGuideBase", "INIT_2_AslBase", "INIT_3_BulletBase", "INIT_3_ColorWheelBase", "INIT_2_CxBase", "INIT_3_DataTypesBase", "INIT_2_DiskfontBase", "INIT_1_DOSBase", "INIT_2_ExpansionBase", "INIT_2_GadToolsBase", "INIT_3_GradientSliderBase", "INIT_2_GfxBase", "INIT_2_IconBase", "INIT_2_IFFParseBase", "INIT_2_IntuitionBase", "INIT_2_KeymapBase", "INIT_2_LayersBase", "INIT_3_LocaleBase", "INIT_3_LowLevelBase", "INIT_2_MathBase", "INIT_2_MathIeeeDoubBasBase", "INIT_2_MathIeeeDoubTransBase", "INIT_2_MathIeeeSingBasBase", "INIT_2_MathIeeeSingTransBase", "INIT_2_MathTransBase", "INIT_2_MUIMasterBase", "INIT_3_NVBase", "INIT_3_RealTimeBase", "INIT_2_ReqToolsBase", "INIT_2_RexxSysBase", "INIT_3_TranslatorBase", "INIT_1_UtilityBase", "INIT_2_VersionBase", "INIT_2_WizardBase", "INIT_2_WorkbenchBase", "INIT_9_Stack", "EXIT_9_Stack", "INIT_0_NEAR_CODE_StdioFiles", "INIT_5_InitFiles", "EXIT_5_InitFiles", "INIT_5_clock", "EXIT_4_free", "EXIT_4_free_3", "INIT_5_InitStdIOFiles", "EXIT_5_InitStdIOFiles", "INIT_6_InitPOSIXIOFiles", "EXIT_6_InitPOSIXIOFiles", "INIT_5_fstream", "INIT_5_fstream", "INIT_9_chdir", "EXIT_9_chdir", "LibInit", "LibOpen", "LibClose", "LibExpunge", "LibNull", "abortLibInit", "LibInitError", "__LibOpen" und "__LibClose" geschrieben@{par} - die stdlib-Funktionen "malloc", "free", "malloc_3" und "free_3" geschrieben@{par} - die unistd-Funktion "chdir" geschrieben@{par} - die time-Funktion "clock" geschrieben@{par} - die new-Funktion "set_new_handler" geschrieben@{par} - die Funktionen "new" und "delete" geschrieben@{par} @endnode /// /// V.43.00-V.43.05 Geschichte @node V.43.00-V.43.05 Geschichte @{b}stormamiga.lib V.43.05 (Patch vom 13.03.1998):@{par} ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯@{ub}@{par} - die stdlib-Funktionen "malloc" und "free" neu geschrieben@{par} - die interne Funktion "EXIT_4_free" neu geschrieben@{par} - die Funktionen "new" und "delete" neu geschrieben@{par} @{b}stormamiga.lib V.43.04 (Patch vom 04.03.1998):@{par} ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯@{ub}@{par} - die amiga.lib-Funktionen "LibCreatePool" und "LibDeletePool" neu geschrieben@{par} - Fehlerkorrektur der internen Funktionen "INIT_5_clock", "EXIT_4_free", "INIT_5_InitStdIOFiles", "EXIT_5_InitFiles", "INIT_5_fstream" und "amigaputc"@{par} @{b}stormamiga.lib V.43.03 (Patch vom 30.01.1998):@{par} ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯@{ub}@{par} - Fehlerkorrektur der stdlib-Funktion "malloc"; Es traten einige Enforcer-Hits auf.@{par} @{b}stormamiga.lib V.43.02 (Patch vom 09.01.1998):@{par} ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯@{ub}@{par} - die stdlib-Funktionen "malloc" und "free" optimiert; Diese Funktionen sind jetzt kürzer und schneller.@{par} - Fehlerkorrektur der stdlib-Funktion "malloc"; Wenn das Programm Mungwall aktiv war, wurde der Speicher nicht oder nicht richtig angefordert.@{par} @{b}stormamiga.lib V.43.01 (11.11.1997 - 12.11.1997):@{par} ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯@{ub}@{par} - die internen Funktionen "LibInit" und "LibExpunge" an StormC V.3.x angepaßt; dadurch ist es möglich Shared Libraries mit StormC V.3.x zu schreiben.@{par} @{b}stormamiga.lib V.43.00 (02.05.1997 - 10.11.1997):@{par} ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯@{ub}@{par} - die amiga.lib-Funktion "InvertString" geschrieben@{par} - die amiga.lib-Funktionen "AddTOF", "CreatePort", "ArgArrayInit" und "HotKey" optimiert; Diese Funktionen sind jetzt kürzer und schneller.@{par} - die string-Funktion "strdup" optimiert; Diese Funktion ist jetzt kürzer und schneller.@{par} - die stdlib-Funktionen "malloc_3" und "free_3" geschrieben@{par} - die stdlib-Funktionen "exit" und "abort__STANDARD" neu geschrieben@{par} - die stdlib-Funktionen "div", "ldiv" und "uinttostr" optimiert; Diese Funktionen sind jetzt schneller.@{par} - die stdio-Funktionen "printf64", "printf64_", "vprintf64", "vprintf64_", "fprintf64", "fprintf64_", "vfprintf64", "vfprintf64_", "snprintf64", "snprintf64_", "sprintf64", "sprintf64_", "vsnprintf64", "vsnprintf64_", "vsprintf64", "vsprintf64_", "scanf64", "scanf64_", "vscanf64", "vscanf64_", "fscanf64", "fscanf64_", "vfscanf64", "vfscanf64_", "sscanf64", "sscanf64_", "vsscanf64" und "vsscanf64_" geschrieben@{par} - die stdio-Funktionen "sprintf", "sprintf_", "vsprintf", "vsprintf_", "snprintf", "snprintf_", "vsnprintf", "vsnprintf_", "freopen", "tmpnam", "fread", "fwrite", "tmpfile", "fopen" und "puts" optimiert; Diese Funktionen sind jetzt kürzer und schneller.@{par} - die time-Funktionen "gmtime", "mktime", "strftime" und "strftime_d" optimiert; Diese Funktionen sind jetzt kürzer und schneller.@{par} - die spezial-Funktionen "divsl" und "divul" optimiert; Diese Funktionen sind jetzt schneller.@{par} - die internen Funktionen "INIT_9_Stack", "EXIT_9_Stack", "wbmain_", "wbmain__", "un_signed_out", "INIT_5_fstream", "EXIT_5_fstream", "EXIT_4_free_3", "getch", "putch" und "ungetch" geschrieben@{par} - die internen Funktionen "form_in", "form_in_", "form_out", "form_out_", "wbmain" und "wbmain__P09WBStartup" neu geschrieben@{par} - die internen Funktionen "main_" und "main__" an die neuen Startupcodes angepaßt@{par} - die internen Funktionen "EXIT_3_AmigaGuideBase", "EXIT_2_AslBase", "EXIT_3_BulletBase", "EXIT_3_ColorWheelBase", "EXIT_2_CxBase", "EXIT_3_DataTypesBase", "EXIT_2_DiskfontBase", "EXIT_1_DOSBase", "EXIT_2_ExpansionBase", "EXIT_2_GadToolsBase", "EXIT_3_GradientSliderBase", "EXIT_2_GfxBase", "EXIT_2_IconBase", "EXIT_2_IFFParseBase", "EXIT_2_IntuitionBase", "EXIT_2_KeymapBase", "EXIT_2_LayersBase", "EXIT_3_LocaleBase", "EXIT_3_LowLevelBase", "EXIT_2_MathBase", "EXIT_2_MathIeeeDoubBasBase", "EXIT_2_MathIeeeDoubTransBase", "EXIT_2_MathIeeeSingBasBase", "EXIT_2_MathIeeeSingTransBase", "EXIT_2_MathTransBase", "EXIT_2_MUIMasterBase", "EXIT_3_NVBase", "EXIT_3_RealTimeBase", "EXIT_2_ReqToolsBase", "EXIT_2_RexxSysBase", "EXIT_3_TranslatorBase", "EXIT_1_UtilityBase", "EXIT_2_VersionBase", "EXIT_2_WizardBase", "EXIT_2_WorkbenchBase", "INIT_3_AmigaGuideBase", "INIT_2_AslBase", "INIT_3_BulletBase", "INIT_3_ColorWheelBase", "INIT_2_CxBase", "INIT_3_DataTypesBase", "INIT_2_DiskfontBase", "INIT_1_DOSBase", "INIT_2_ExpansionBase", "INIT_2_GadToolsBase", "INIT_3_GradientSliderBase", "INIT_2_GfxBase", "INIT_2_IconBase", "INIT_2_IFFParseBase", "INIT_2_IntuitionBase", "INIT_2_KeymapBase", "INIT_2_LayersBase", "INIT_3_LocaleBase", "INIT_3_LowLevelBase", "INIT_2_MathBase", "INIT_2_MathIeeeDoubBasBase", "INIT_2_MathIeeeDoubTransBase", "INIT_2_MathIeeeSingBasBase", "INIT_2_MathIeeeSingTransBase", "INIT_2_MathTransBase", "INIT_2_MUIMasterBase", "INIT_3_NVBase", "INIT_3_RealTimeBase", "INIT_2_ReqToolsBase", "INIT_2_RexxSysBase", "INIT_3_TranslatorBase", "INIT_1_UtilityBase", "INIT_2_VersionBase", "INIT_2_WizardBase", "INIT_2_WorkbenchBase", "INIT_5_clock", "INIT_0_NEAR_CODE_StdioFiles", "INIT_5_InitStdIOFiles", "EXIT_4_free", "EXIT_9_AtExitFunctionsCaller", "EXIT_5_InitFiles", "EXIT_0_Main", "LibInit", "LibClose", "LibExpunge", "amigareadunget", "amigaputc", "amigaopen", "form_in64", "form_in64_", "form_out64", "form_out64_", "double_in", "double_out", "main" und "main__" optimiert; Diese Funktionen sind jetzt kürzer und schneller.@{par} - die internen Funktionen "form_in", "form_in_", "form_out" und "form_out_" in "form_in64", "form_in64_", "form_out64" und "form_out64_" umbenannt@{par} - die Funktionen "cinfilebuf::cinfilebuf()", "cinfilebuf::~cinfilebuf()", "coutfilebuf::coutfilebuf()" und "coutfilebuf::~coutfilebuf()" geschrieben@{par} - alle Funktionen der Klassen "filebuf", "fstream", "ifstream", "ios", "istream", "ofstream", "ostream" und "streambuf" geschrieben@{par} - Fehlerkorrektur der amiga.lib-Funktion "TimeDelay"; Die Anwendung dieser Funktion hatte keinerlei Wirkung.@{par} - Fehlerkorrektur der stdio-Funktionen "freopen" und "tmpfile"; Die Anwendung dieser Funktionen führte auf einigen Systemen zum Systemabsturz.@{par} - Fehlerkorrektur der stdlib-Funktion "abort"@{par} - Fehlerkorrektur der math-Funktion "atan2"; Da die Register nicht korrekt restauriert wurden, führte die Anwendung dieser Funktionen zu Fehlern oder zum Systemabsturz.@{par} - Fehlerkorrektur der internen Funktionen "LibInit", "LibExpunge" (Register a6 wurde nicht gesichert), "form_out" (Bei den Typen "e", "E", "g" und "G" wurden maximal 2 Stellen des Exponenten angezeigt. Wenn der Exponent mehr als 2 Stellen hatte, dann wurden nur die letzten 2 Stellen angezeigt. Bei Type "p" wurde "0x" nicht ausgegeben.), "form_in" (Bei den Typen "e", "f" und "g" hatte die Angabe der Größe "h" keinerlei Wirkung.), "amigaread", "main__", "main_", "signal_dat" und "amigaputc"@{par} - die internen Funktionen "char_out", "string_out", "signed_out", "unsigned_out", "char_in", "string_in", "int_in", "Expo10", "expo10", "Pwr10", "pwr10", "fpwr10", "floattostr", "intmult", "uintmult", intdiv", "uintdiv", "li_div_int", "lib_div_uint", "SDivMod32", "UDivMod32", "INIT_0_InitUserbreak", "_userbreak", "main__iPc" und "main__iPPc" entfernt; Diese Funktionen sind, in der aktuellen Version der "stormamiga.lib", nicht mehr notwendig.@{par} - alle Register- und Alphafunktionen entfernt@{par} - die Startupcodes "stormamiga_startups+.o", "stormamiga_nc_startups+.o", "stormamiga_C++_startups+.o" und "stormamiga_nc_C++_startups+.o" geschrieben@{par} - die Startupcodes "stormamiga_startups.o", "stormamiga_nc_startups.o", "stormamiga_C++_startups.o" und "stormamiga_nc_C++_startups.o" neu geschrieben@{par} - spezielle Versionen der Startupcodes "stormamiga_startups.o", "stormamiga_nc_startups.o", "stormamiga_C++_startups.o", "stormamiga_nc_C++_startups.o", "stormamiga_startups+.o", "stormamiga_nc_startups+.o", "stormamiga_C++_startups+.o" und "stormamiga_nc_C++_startups+.o" für StormC V.3.x geschrieben@{par} - alle Beispielprogramme an die aktuelle Version der "stormamiga.lib" angepasst, das Beispielprogramm "SpeedTest" erweitert@{par} - die Includedateien "stormamiga.h" und "stormamigainline.h" überarbeitet und erweitert@{par} - das Benutzer-Lexikon überarbeitet und erweitert@{par} - das Installerskript überarbeitet und erweitert@{par} - die Anleitung überarbeitet und erweitert; Beschreibung der neuen Funktionen hinzugefügt, einige Fehler beseitigt@{par} @{b}stormamiga_881.lib V.43.00 (13.12.1996 - 10.11.1997):@{par} ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯@{ub}@{par} - die math-Funktionen "fmod" und "modf" neu geschrieben@{par} - die internen Funktionen "form_in", "form_in64", "form_out", "form_out64", "double_in" und "double_out" geschrieben@{par} - die Methoden "ostream &ostream::operator <<(float)" und "istream &istream::operator >>(float &)" geschrieben@{par} @{b}stormamiga_040.lib V.43.00 (13.12.1996 - 10.11.1997):@{par} ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯@{ub}@{par} - die math-Funktionen "acos", "asin", "atan", "cosh", "exp", "log", "log10", "pow", "sin", "sinh", "tan" und "tanh" geschrieben@{par} - die math-Funktionen "cos" (Diese Funktion ist jetzt schneller.), "floor", "ceil", "fmod" und "modf" neu geschrieben@{par} - die math-Funktion "atan2" optimiert; Diese Funktion ist jetzt kürzer und schneller.@{par} - die internen Funktionen "form_in", "form_in64", "form_out", "form_out64", "double_in" und "double_out" geschrieben@{par} - die Methoden "ostream &ostream::operator <<(float)" und "istream &istream::operator >>(float &)" geschrieben@{par} @{b}stormamiga_060.lib V.43.00 (13.12.1996 - 10.11.1997):@{par} ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯@{ub}@{par} - die math-Funktionen "acos", "asin", "atan", "cosh", "exp", "log", "log10", "pow", "sin", "sinh", "tan" und "tanh" geschrieben@{par} - die math-Funktionen "cos" (Diese Funktion ist jetzt schneller.), "fmod" und "modf" neu geschrieben@{par} - die math-Funktion "atan2" optimiert; Diese Funktion ist jetzt kürzer und schneller.@{par} - die stdlib-Funktionen "div", "ldiv" und "uinttostr" geschrieben@{par} - die time-Funktionen "gmtime", "mktime", "strftime" und "strftime_d" geschrieben@{par} - die spezial-Funktionen "divsl" und "divul" geschrieben@{par} - die internen Funktionen "form_in", "form_in64", "form_out", "form_out64", "form_out_", "form_out64_", "un_signed_out", "double_in" und "double_out" geschrieben@{par} - die Methoden "ostream &ostream::operator <<(float)" und "istream &istream::operator >>(float &)" geschrieben@{par} @endnode /// /// Zukunft @node Zukunft @{b}@{fg shine}In Zukunft:@{par} ~~~~~~~~~~~@{fg text}@{ub}@{par} Die folgenden Punkte habe ich mir für die nächsten Versionen der "stormamiga.lib" vorgenommen.@{par} - alle noch fehlenden Funktionen der "stormamiga.lib" für "p.OS" und "PowerPC" schreiben@{par} - viele Funktionen von "UNIX", "POSIX" und den Compilern "DICE" und "SAS C" schreiben@{par} - einige Amiga Funktionen und neue Funktionen schreiben@{par} - bessere Unterstützung von AmigaOS 3.x@{par} - Ihre Vorschläge@{par} @endnode /// /// Danksagungen @node Danksagungen @{b}@{fg shine}Danksagungen:@{par} ~~~~~~~~~~~~~@{fg text}@{ub}@{par} Bei folgenden Leuten und Firmen möchte ich mich bedanken:@{par} ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯@{par} - die @{b}Haage & Partner Computer GmbH@{ub}; für Ihre Unterstützung und die Quelltexte, die Sie mir kostenlos zur Verfügung gestellt haben, besonderen Dank an Jochen Becher und Jürgen Haage, die so manche Stunde für meine Probleme geopfert haben@{par} - @{b}Uwe Schienbein@{ub}; für Betatesting, Bugreports, neue Ideen, die Unterstützung bei der Entwicklung der Funktionen "cos" und "sin" für den MC68040+ und MC68060, für das Beispielprogramm "TaskDemo" und das Logo der "stormamiga.lib"@{par} - @{b}Thomas Blätte@{ub}; für die englische Übersetzung des Installerskripts, die Piktogramme für den Installer, Betatesting, Bugreports und neue Ideen@{par} - @{b}ALeX Kazik@{ub}; für Bugreports und neue Ideen@{par} - @{b}Kai Fleischer@{ub}; für die englische Übersetzung dieser Anleitung, Betatesting, Bugreports, neue Ideen und die moralische Unterstützung@{par} - @{b}Carsten Bornholz@{ub}; für Betatesting und Bugreports@{par} - @{b}Jens Schildknecht@{ub}; für Betatesting und Bugreports@{par} - @{b}Allan Odgaard@{ub}; für Bugreports@{par} - @{b}Andreas Mayer-Gürr@{ub}; für Bugreports und die moralische Unterstützung@{par} - @{b}Jens Rosenboom@{ub}; für Bugreports und die unzähligen Verbesserungsvorschläge@{par} - @{b}Joachim Schneider@{ub}; für Betatesting@{par} - @{b}Onur Pekdemir@{ub}; für seine Unterstützung bei der Veröffentlichung der "stormamiga.lib"@{par} - @{b}Dietmar Heidrich@{ub}; für seinen "OMA"@{par} - @{b}Frank Wille@{ub}; für seinen "PhxAss"@{par} @endnode /// /// Autor @node Autor @{b}@{fg shine}Autor:@{par} ~~~~~~@{fg text}@{ub}@{par} @{jcenter} Matthias Henze@{par} Gorkistraße 127@{par} 04347 Leipzig@{par} Deutschland@{par} Telefon: +49 (0) 341/2326414@{par} E-Mail: Matthias_Henze@CyberdyneSystems.de@{par} URL: http://WWW.CyberdyneSystems.de/@{par} @{jleft} Für Fehlerberichte und Verbesserungsvorschläge bin ich jederzeit dankbar.@{par} Es wäre auch sehr schön, wenn Sie mir Ihre Meinung zur "stormamiga.lib" mitteilen würden.@{par} @{b}@{u}An alle Anwender, die für ein "Dankeschön" arbeiten@{ub}@{uu}@{par} Ich suche dringend einige Anwender, die diese Anleitung und das Installerscript in andere Sprachen (Italienisch, Französisch und andere) übersetzen.@{par} Außerdem suche ich noch einige Tester.@{par} Wenn Sie Interesse haben, können Sie mir schreiben oder mich anrufen.@{par} Für Ihre Mühe danke ich im Voraus.@{par} @endnode /// /// Index @node guideIndex Index @{code}@{b}@{fg shine}Index: ~~~~~~@{fg text}@{ub} @{b} A@{ub} @{" access " link access} @{" Allgemeine Hinweise " link "Allgemeine Hinweise"} @{" Amiga - Funktionen " link Amiga-Funktionen} @{" Anwendungshinweise " link Anwendungshinweise} @{" asctime_d " link asctime_d} @{" assert_ " link assert_} @{" Ausgabeformatstring " link Ausgabeformatstring} @{" Ausgabeformatstring_ " link Ausgabeformatstring_} @{" Autor " link Autor} @{b} B@{ub} @{" Besonderheiten " link Besonderheiten} @{" bcmp " link bcmp} @{" bcopy " link bcopy} @{" Beispiele " link Beispiele} @{" Bekannte Fehler " link "Bekannte Fehler"} @{" button " link button} @{" button_al " link button_al} @{" button_ar " link button_ar} @{" button_bl " link button_bl} @{" button_br " link button_br} @{" bzero " link bzero} @{b} C@{ub} @{" chdir " link chdir} @{" chmod " link chmod} @{" close " link close} @{" closedir " link closedir} @{" creat " link creat} @{" ctime_d " link ctime_d} @{b} D@{ub} @{" Danksagungen " link Danksagungen} @{" Deutsche Funktionen " link "Deutsche Funktionen"} @{" divs64 " link divs64} @{" divsl " link divsl} @{" divu64 " link divu64} @{" divul " link divul} @{b} E@{ub} @{" Eingabeformatstring " link Eingabeformatstring} @{" Eingabeformatstring_ " link Eingabeformatstring_} @{" Einleitung " link Einleitung} @{" Einschränkungen " link Einschränkungen} @{b} F@{ub} @{" ffs " link ffs} @{" fprintf64 " link fprintf64} @{" fprintf_ " link fprintf_} @{" fprintf64_ " link fprintf64_} @{" fscanf64 " link fscanf64} @{" fscanf_ " link fscanf_} @{" fscanf64_ " link fscanf64_} @{" fstat " link fstat} @{" Funktionen " link Funktionen} @{" Funktionsübersicht " link Funktionsübersicht} @{b} G@{ub} @{" Geschichte " link Geschichte} @{" getcwd " link getcwd} @{" getrusage " link getrusage} @{" getw " link getw} @{" getwd " link getwd} @{b} I@{ub} @{" In Zukunft " link Zukunft} @{" index " link index} @{" Inlinefunktionen " link Inlinefunktionen} @{" Installation " link Installation} @{" isalnum_d " link isalnum_d} @{" isalpha_d " link isalpha_d} @{" isinf " link isinf} @{" islower_d " link islower_d} @{" isnan " link isnan} @{" isprint_d " link isprint_d} @{" ispunct_d " link ispunct_d} @{" isupper_d " link isupper_d} @{b} K@{ub} @{" Kopierrecht " link Kopierrecht} @{b} L@{ub} @{" lseek " link lseek} @{" lstat " link lstat} @{b} M@{ub} @{" main__() " link main__()} @{" max_Height " link max_Height} @{" max_Width " link max_Width} @{" memccpy " link memccpy} @{" mkdir " link mkdir} @{" mktemp " link mktemp} @{" muls " link muls} @{" muls64 " link muls64} @{" mulu " link mulu} @{" mulu64 " link mulu64} @{b} O@{ub} @{" open " link open} @{" opendir " link opendir} @{" OS3 Funktionen " link "OS3 Funktionen"} @{b} P@{ub} @{" Parameterliste " link Parameterliste} @{" printf64 " link printf64} @{" printf_ " link printf_} @{" printf64_ " link printf64_} @{" putw " link putw} @{b} R@{ub} @{" read " link read} @{" readdir " link readdir} @{" Registrierung " link Registrierung} @{" rewinddir " link rewinddir} @{" rindex " link rindex} @{" rmdir " link rmdir} @{b} S@{ub} @{" scanf64 " link scanf64} @{" scanf_ " link scanf_} @{" scanf64_ " link scanf64_} @{" setbuffer " link setbuffer} @{" setlinebuf " link setlinebuf} @{" sleep " link sleep} @{" snprintf " link snprintf} @{" snprintf64 " link snprintf64} @{" snprintf_ " link snprintf_} @{" snprintf64_ " link snprintf64_} @{" SPRINTF " link SPRINTF} @{" sprintf64 " link sprintf64} @{" sprintf_ " link sprintf_} @{" sprintf64_ " link sprintf64_} @{" sscanf64 " link sscanf64} @{" sscanf_ " link sscanf_} @{" sscanf64_ " link sscanf64_} @{" Startupcode " link Startupcode} @{" stat " link stat} @{" STORMAMIGA " link STORMAMIGA} @{" STORMAMIGA_DEUTSCH " link "Deutsche Funktionen"} @{" STORMAMIGA_INLINE " link Inlinefunktionen} @{" STORMAMIGA_NOWB " link STORMAMIGA_NOWB} @{" STORMAMIGA_NO_IO_WB " link STORMAMIGA_NO_IO_WB} @{" STORMAMIGA_OS3 " link "OS3 Funktionen"} @{" STORMAMIGA_STACK " link STORMAMIGA_STACK} @{" STORMAMIGA_UNIXPATH " link STORMAMIGA_UNIXPATH} @{" STORMAMIGA_64BIT " link "64 Bit Funktionen"} @{" stpchr " link stpchr} @{" stpcpy " link stpcpy} @{" strbpl " link strbpl} @{" strcasecmp " link strcasecmp} @{" strcasecmp_d " link strcasecmp_d} @{" strcoll " link strcoll} @{" strdup " link strdup} @{" strftime " link strftime} @{" strftime_d " link strftime_d} @{" stricmp_d " link stricmp_d} @{" Stringpuffer " link Stringpuffer} @{" strisns " link strins} @{" strlower " link strlower} @{" strlower_d " link strlower_d} @{" strlwr_d " link strlwr_d} @{" strncasecmp " link strncasecmp} @{" strncasecmp_d " link strncasecmp_d} @{" strncpyn " link strncpyn} @{" strnicmp " link strnicmp} @{" strnicmp_d " link strnicmp_d} @{" strsep " link strsep} @{" strupper " link strupper} @{" strupper_d " link strupper_d} @{" strupr_d " link strupr_d} @{" strxfrm " link strxfrm} @{" swab " link swab} @{" Systemanforderungen " link Systemanforderungen} @{b} T@{ub} @{" times " link times} @{" tolower_d " link tolower_d} @{" toupper_d " link toupper_d} @{b} U@{ub} @{" unlink " link unlink} @{" Updates " link Updates} @{" usleep " link usleep} @{" utime " link utime} @{" utimes " link utimes} @{b} V@{ub} @{" vfprintf64 " link vfprintf64} @{" vfprintf_ " link vfprintf_} @{" vfprintf64_ " link vfprintf64_} @{" vfscanf " link vfscanf} @{" vfscanf64 " link vfscanf64} @{" vfscanf_ " link vfscanf_} @{" vfscanf64_ " link vfscanf64_} @{" vprintf64 " link vprintf64} @{" vprintf_ " link vprintf_} @{" vprintf64_ " link vprintf64_} @{" vscanf " link vscanf} @{" vscanf64 " link vscanf64} @{" vscanf_ " link vscanf_} @{" vscanf64_ " link vscanf64_} @{" vsnprintf " link vsnprintf} @{" vsnprintf64 " link vsnprintf64} @{" vsnprintf_ " link vsnprintf_} @{" vsnprintf64_ " link vsnprintf64_} @{" VSPRINTF " link VSPRINTF} @{" vsprintf64 " link vsprintf64} @{" vsprintf_ " link vsprintf_} @{" vsprintf64_ " link vsprintf64_} @{" vsscanf " link vsscanf} @{" vsscanf64 " link vsscanf64} @{" vsscanf_ " link vsscanf_} @{" vsscanf64_ " link vsscanf64_} @{b} W@{ub} @{" waitbutton " link waitbutton} @{" waitbutton_al " link waitbutton_al} @{" waitbutton_ar " link waitbutton_ar} @{" waitbutton_bl " link waitbutton_bl} @{" waitbutton_br " link waitbutton_br} @{" wbmain() " link wbmain()} @{" _wbmain_ " link _wbmain_} @{" _wbmain__ " link _wbmain_} @{" Workbenchbeispiele " link Workbenchbeispiele} @{" write " link write} @{b} Z@{ub} @{" Zeitformatstring " link Zeitformatstring} @endnode ///