From 33613a85afc4b1481367fbe92a17ee59c240250b Mon Sep 17 00:00:00 2001 From: Sven Eisenhauer Date: Fri, 10 Nov 2023 15:11:48 +0100 Subject: add new repo --- .../ARM202U/SOURCE/WIN32/CLX/AIF.H | 52 +++ .../ARM202U/SOURCE/WIN32/CLX/ASDFMT.H | 473 +++++++++++++++++++++ .../ARM202U/SOURCE/WIN32/CLX/HOST.H | 279 ++++++++++++ .../ARM202U/SOURCE/WIN32/CLX/IEEEFLT.H | 75 ++++ .../ARM202U/SOURCE/WIN32/CLX/MSG.H | 104 +++++ .../ARM202U/SOURCE/WIN32/CLX/MSVC20/CLX.LIB | Bin 0 -> 143530 bytes 6 files changed, 983 insertions(+) create mode 100644 Bachelor/Mikroprozessorsysteme2/ARM202U/SOURCE/WIN32/CLX/AIF.H create mode 100644 Bachelor/Mikroprozessorsysteme2/ARM202U/SOURCE/WIN32/CLX/ASDFMT.H create mode 100644 Bachelor/Mikroprozessorsysteme2/ARM202U/SOURCE/WIN32/CLX/HOST.H create mode 100644 Bachelor/Mikroprozessorsysteme2/ARM202U/SOURCE/WIN32/CLX/IEEEFLT.H create mode 100644 Bachelor/Mikroprozessorsysteme2/ARM202U/SOURCE/WIN32/CLX/MSG.H create mode 100644 Bachelor/Mikroprozessorsysteme2/ARM202U/SOURCE/WIN32/CLX/MSVC20/CLX.LIB (limited to 'Bachelor/Mikroprozessorsysteme2/ARM202U/SOURCE/WIN32/CLX') diff --git a/Bachelor/Mikroprozessorsysteme2/ARM202U/SOURCE/WIN32/CLX/AIF.H b/Bachelor/Mikroprozessorsysteme2/ARM202U/SOURCE/WIN32/CLX/AIF.H new file mode 100644 index 0000000..71fbb5f --- /dev/null +++ b/Bachelor/Mikroprozessorsysteme2/ARM202U/SOURCE/WIN32/CLX/AIF.H @@ -0,0 +1,52 @@ +/* + Title: Acorn Image Format + Status: C Library Extension + Copyright: (C) 1991 Advanced RISC Machines Limited. All rights reserved. + $Revision: 1.5.2.1 $ 27-Apr-91 +*/ + + +#ifndef __aif_h +#define __aif_h + +#include "host.h" + +#define AIF_NOOP 0xe1a00000 /* MOV r0, r0 */ +#define AIF_BLAL 0xeb000000 +#define OS_EXIT 0xef000011 /* SWI OS_Exit */ +#define OS_GETENV 0xef000010 /* SWI OS_GetEnv */ +#define AIF_IMAGEBASE 0x00008000 /* Default load address = 32K */ +#define AIF_BLZINIT 0xeb00000C +#define DEBUG_TASK 0xef041d41 /* RISC OS SWI DDE_Debug */ +#define AIF_DBG_SRC 2 +#define AIF_DBG_LL 1 + +#define AIF_DATABASAT 0x100L /* if has a separate data base */ + +typedef struct aif_hdr { + unsigned32 compress_br; + unsigned32 reloc_br; + unsigned32 zinit_br; + unsigned32 entry_br; + unsigned32 exit_swi; + unsigned32 rosize, rwsize, dbgsize, zinitsize; + unsigned32 dbgtype; + unsigned32 imagebase; + unsigned32 workspace; + unsigned32 address_mode; /* and flags */ + unsigned32 data_base; + unsigned32 fragment_offset; + unsigned32 spare2; + unsigned32 debug_swi; + unsigned32 zinitcode[15]; +} aif_hdr; + +typedef struct { + unsigned32 next_fragment_offset; + unsigned32 load_address; + unsigned32 size; + char name[32]; +} fragment_header; + +#endif + \ No newline at end of file diff --git a/Bachelor/Mikroprozessorsysteme2/ARM202U/SOURCE/WIN32/CLX/ASDFMT.H b/Bachelor/Mikroprozessorsysteme2/ARM202U/SOURCE/WIN32/CLX/ASDFMT.H new file mode 100644 index 0000000..cbb0034 --- /dev/null +++ b/Bachelor/Mikroprozessorsysteme2/ARM202U/SOURCE/WIN32/CLX/ASDFMT.H @@ -0,0 +1,473 @@ +/* + Title: Acorn Object Format + Status: C Library Extension + Copyright: (C) 1991, 1994, Advanced RISC Machines Limited. All rights reserved. + + RCS $Revision: 1.15.2.1 $ + Checkin $Date: 1995/05/13 17:04:13 $ + Revising $Author: kwelton $ +*/ + +/* + * This header defines the essential structure of ASD debugging tables. + */ + +#ifndef __asd_h +#define __asd_h + +#include "host.h" + +#define ASD_FORMAT_VERSION 3 +/* decaof is already 4, stayed for armsd for the moment */ + +/* Most table items start with a word containing a type code and the length + in bytes of the item (most items end as defined here in an array of size 1, + which in actual tables is made as large as needed). + */ + +typedef unsigned32 CodeAndLen; + +#define asd_code_(x) ((x) & 0xffff) +#define asd_len_(x) ((x) >> 16) + +#define asd_codeword(c, l) ((c) | ((l) << 16)) + +/* the code field of a CodeAndLen may have the following values */ + +#define ITEMSECTION 1 +#define ITEMPROC 2 +#define ITEMENDPROC 3 +#define ITEMVAR 4 +#define ITEMTYPE 5 +#define ITEMSTRUCT 6 +#define ITEMARRAY 7 +#define ITEMSUBR 8 +#define ITEMSET 9 +#define ITEMFILEINFO 10 +#define ITEMENUMC 11 +#define ITEMENUMD 12 +#define ITEMFUNCTION 13 +#define ITEMSCOPEBEGIN 14 +#define ITEMSCOPEEND 15 +#define ITEMBITFIELD 16 +#define ITEMDEFINE 17 +#define ITEMUNDEF 18 +#define ITEMCLASS 19 +#define ITEMUNION 20 +#define ITEMFPMAPFRAG 32 + +/* Type descriptions are contained in items ... */ + +typedef int32 asd_Type; /* with the structure ... */ + +#define TYPE_PTRCOUNT(t) ((t) & 0xff) +#define TYPE_TYPECODE(t) ((t) >> 8) + +#define TYPE_TYPEWORD(t, p) (((t) << 8) | (p)) + +/* where TYPE_TYPECODE(type) is + negative, and its negated value is the offset in the debug data of an + item defining a type + or positive, and its value is one of those listed below + */ + +#define TYPEVOID 0 + +#define TYPESBYTE 10 +#define TYPESHALF 11 +#define TYPESWORD 12 + +#define TYPEUBYTE 20 +#define TYPEUHALF 21 +#define TYPEUWORD 22 + +#define TYPEFLOAT 30 +#define TYPEDOUBLE 31 +#define TYPELDOUBLE 32 + +#define TYPECOMPLEX 40 +#define TYPEDCOMPLEX 41 + +#define TYPESTRING 50 /* a primitive (char *) type (needed for Number) */ + +#define TYPEFUNCTION 100 + +#define type_integral(t) ((unsigned32)(t) < 30) +#define type_signed(t) ((unsigned32)(t) < 20) +#define type_fpoint(t) ((t) >= 30 && (t) < 40) +#define type_complex(t) ((t) >= 40 && (t) < 50) + +typedef unsigned32 asd_Address; +typedef unsigned32 asd_FileOffset; + +/* sourcepos items contain line number and character position fields */ + +#define FILE_LINE(f) ((f) & 0x3fffffL) +#define FILE_CHPOS(f) (((f) >> 22) & 0x3ff) + +#define FILE_POSWORD(f, ch) ((f) | ((ch) << 22)) + +typedef struct ItemFileInfo ItemFileInfo; +typedef struct ItemFileEntry ItemFileEntry; +typedef struct ItemEndProc ItemEndProc; + +/* Values for the lang field of an ItemSection */ + +#define LANG_NONE 0 +#define LANG_C 1 +#define LANG_PASCAL 2 +#define LANG_FORTRAN 3 +#define LANG_ASM 4 + +/* Bits set in the flags field of an ItemSection */ + +#define FLAG_LINES(f) ((f) & 1) +#define FLAG_VARS(f) ((f) & 2) +#define FLAG_FPMAP(f) ((f) & 4) + +typedef union asd_NameP +{ char name[1]; + char *namep; +} asd_Name; + +typedef struct ItemSection +{ CodeAndLen id; + unsigned char lang; + unsigned char flags; + unsigned char unused; + unsigned char asdversion; + asd_Address codestart; + asd_Address datastart; + int32 codesize; + int32 datasize; + union { + asd_FileOffset i; + ItemFileInfo *p; + } fileinfo; + unsigned32 debugsize; + union { + char name[1]; /* high level section */ + unsigned32 nsyms; /* low level section: nsyms ItemSymbols follow */ + char *namep; + } n; +} ItemSection; + +/* the sym field of an ItemSymbol consists of + * 24 (ls) bits of string table index + * 8 (ms) bits of flags. + */ + +#define STR_INDEX(s) ((s) & 0xffffffL) + +#define ASD_LOCSYM 0 +#define ASD_GLOBSYM 0x01000000L +#define ASD_SYMGLOBAL(s) ((s) & 0x1000000L) + +#define ASD_ABSSYM 0 +#define ASD_TEXTSYM 0x02000000L +#define ASD_DATASYM 0x04000000L +#define ASD_ZINITSYM 0x06000000L +#define ASD_SYMTYPE(s) ((s) & 0x6000000L) + +#define ASD_32BITSYM 0 +#define ASD_16BITSYM 0x10000000L +#define ASD_SYM16(s) ((s) & 0x10000000L) + + +typedef struct ItemSymbol +{ unsigned32 sym; + unsigned32 value; +} ItemSymbol; + +typedef union +{ asd_FileOffset i; + ItemFileEntry *p; +} asd_FileEntryP; + +typedef struct ItemProc +{ CodeAndLen id; + asd_Type type; /* of the return value */ + unsigned32 args; + unsigned32 sourcepos; + asd_Address startaddr; + asd_Address entry; + union { + asd_FileOffset i; + ItemEndProc *p; + } endproc; + asd_FileEntryP fileentry; + asd_Name n; +} ItemProc; + +struct ItemEndProc +{ CodeAndLen id; + unsigned32 sourcepos; + asd_Address endpoint; + asd_FileEntryP fileentry; + unsigned32 nreturns; + asd_Address retaddrs[1]; +}; + +/* Values for ItemVar storageclass field */ +typedef enum StgClass { + C_NONE, + C_EXTERN, + C_STATIC, + C_AUTO, + C_REG, + C_VAR, + C_FARG, + C_FCARG, + C_LOCAL, + C_FILTERED, + C_GLOBALREG +} StgClass; + +typedef struct ItemVar +{ CodeAndLen id; + asd_Type type; + unsigned32 sourcepos; + unsigned32 storageclass; /* StgClass really */ + union { + int32 offset; + asd_Address address; + } location; + asd_Name n; +} ItemVar; + +typedef struct ItemType +{ CodeAndLen id; + asd_Type type; + asd_Name n; +} ItemType; + +typedef struct StructField +{ unsigned32 offset; + asd_Type type; + asd_Name n; +} StructField; + +typedef struct SUC +{ CodeAndLen id; + unsigned32 fields; + unsigned32 size; + StructField fieldtable[1]; +} SUC; + +typedef SUC ItemStruct; +typedef SUC ItemClass; +typedef SUC ItemUnion; + +/* Meaning of the flags field in an ItemArray */ + +#define ARRAY_UNDEF_LBOUND(f) ((f) & 1) +#define ARRAY_CONST_LBOUND(f) ((f) & 2) +#define ARRAY_UNDEF_UBOUND(f) ((f) & 4) +#define ARRAY_CONST_UBOUND(f) ((f) & 8) +#define ARRAY_VAR_LBOUND(f) ((f) & 16) +#define ARRAY_VAR_UBOUND(f) ((f) & 32) + +typedef union asd_ArrayBound +{ int32 i; /* (undef), const */ + int32 o; /* no flag bit set: bound is a variable on the stack + * with this fp offset */ + asd_FileOffset v;/* var: file form */ + ItemVar *vp; /* var: in memory form */ +} asd_ArrayBound; + +typedef struct ItemArray +{ CodeAndLen id; + unsigned32 size; + unsigned32 flags; + asd_Type basetype; + asd_ArrayBound lowerbound, + upperbound; +} ItemArray; + +/* The sizeandtype field of an ItemSubRange */ + +#define SUBRANGE_SIZE(s) ((s) & 0xffff) +#define SUBRANGE_TYPECODE(s) ((s) >> 16) + +typedef struct ItemSubrange +{ CodeAndLen id; + int32 sizeandtype; + int32 lb, hb; +} ItemSubrange; + +typedef struct ItemSet +{ CodeAndLen id; + unsigned32 size; +} ItemSet; + +typedef struct ItemEnumC +{ CodeAndLen id; + asd_Type type; /* of the container */ + unsigned32 count; + int32 base; + union { + char nametable[1]; + char *nametablep[1]; + } nt; +} ItemEnumC; + +typedef struct asd_EnumMember +{ int32 val; + asd_Name n; +} asd_EnumMember; + +typedef struct ItemEnumD +{ CodeAndLen id; + asd_Type type; /* of the container */ + unsigned32 count; + asd_EnumMember nametable[1]; +} ItemEnumD; + +typedef struct asd_Arg +{ asd_Type type; + asd_Name n; +} asd_Arg; + +typedef struct ItemFunction +{ CodeAndLen id; + asd_Type type; /* of the returned value */ + unsigned32 argcount; + asd_Arg args[1]; +} ItemFunction; + +typedef struct ItemBitfield +{ CodeAndLen id; + asd_Type type; /* of the extracted value */ + asd_Type container; + unsigned char size, offset, + pad1, pad2; +} ItemBitfield; + +typedef struct ItemScope /* begin or end */ +{ CodeAndLen id; + asd_Address codeaddress; +} ItemScope; + +typedef struct ItemDefine +{ CodeAndLen id; + asd_FileEntryP fileentry; + unsigned32 sourcepos; + union { + asd_FileOffset i; + char *p; + } body; + int32 argcount; + union { + asd_FileOffset i; + asd_Name *p; + } argtable; + asd_Name n; +} ItemDefine; + +typedef struct ItemUndef +{ CodeAndLen id; + asd_FileEntryP fileentry; + unsigned32 sourcepos; + asd_Name n; +} ItemUndef; + +typedef struct Fragment +{ unsigned32 size; + unsigned32 firstline, lastline; + asd_Address codestart; + unsigned32 codesize; + unsigned char lineinfo[1]; +} Fragment; + +#define Asd_LineInfo_Short_MaxLine 63 + +/* short form lineinfo items have code and file position increments < 256. + * If the current file position is (line, col), a file position increment + * fpinc describes a new file position + * (line+fpinc, 1) if inc <= Asd_LineInfo_Short_MaxLine + * (line, col+fpinc-Asd_LineInfo_Short_MaxLine-1) otherwise + * + * fpinc = 0, codeinc = 0 indicates that the item is in long format 1: + * new file position is (line+lineinc, 1) + * + * fpinc = Asd_LineInfo_Short_MaxLine+1, codeinc = 0 indicates that the + * item is in long format 2. new file position is + * (line+lineinc, newcol) + */ + +typedef struct +{ unsigned char codeinc; + unsigned char lineinc; +} asd_LineInfo_Short; + +typedef struct +{ unsigned short marker; + unsigned short lineinc; /* (in target byte order) */ + unsigned short codeinc; /* (in target byte order) */ +} asd_LineInfo_Long_1; + +typedef struct +{ unsigned short marker; + unsigned short lineinc; /* (in target byte order) */ + unsigned short codeinc; /* (in target byte order) */ + unsigned short newcol; /* (in target byte order) */ +} asd_LineInfo_Long_2; + +struct ItemFileEntry +{ unsigned32 len; + unsigned32 date; + char filename[1]; +}; + +struct ItemFileInfo +{ CodeAndLen id; + ItemFileEntry entries[1]; +}; + +typedef struct ItemFPMapFragment { + unsigned32 marker; + int32 bytes; + asd_Address codestart; + asd_Address saveaddr; + unsigned32 codesize; + int32 initoffset; + char b[1]; +} ItemFPMapFragment; + +typedef struct { + unsigned char codeinc; + signed char offsetinc; +} asd_FPInfo_Short; + +typedef struct { + char marker[2]; + unsigned short codeinc; + signed short offsetinc; +} asd_FPInfo_Long; + +typedef union { + unsigned char b; + CodeAndLen c; + ItemSection sect; + ItemProc p; + ItemEndProc e; + ItemVar v; + ItemArray a; + ItemType t; + ItemStruct s; + ItemSubrange sr; + ItemSet set; + ItemFileInfo f; + ItemFileEntry fe; + ItemEnumC ec; + ItemEnumD ed; + ItemFunction fn; + ItemScope sc; + ItemBitfield bf; + ItemDefine def; + ItemUndef undef; + ItemFPMapFragment fp; +} Item; + +#endif + \ No newline at end of file diff --git a/Bachelor/Mikroprozessorsysteme2/ARM202U/SOURCE/WIN32/CLX/HOST.H b/Bachelor/Mikroprozessorsysteme2/ARM202U/SOURCE/WIN32/CLX/HOST.H new file mode 100644 index 0000000..1625b00 --- /dev/null +++ b/Bachelor/Mikroprozessorsysteme2/ARM202U/SOURCE/WIN32/CLX/HOST.H @@ -0,0 +1,279 @@ +/* + * C compiler file mip/host.h + * Copyright (C) Codemist Ltd., 1988 + * Copyright (C) Acorn Computers Ltd., 1988. + */ + +/* + * RCS $Revision: 1.15.2.7 $ Codemist 11 + * Checkin $Date: 1995/06/29 10:47:31 $ + * Revising $Author: kwelton $ + */ + +/* AM memo, July 1990: in principle there should be no tests of */ +/* COMPILING_ON_, but only COMPILING_ON_ or */ +/* COMPILING_ON_ (for special features). */ +/* Accordingly COMPILING_ON_ is deprecated. */ + +/* + * This file deals with peculiarities of the host system under which the + * compiler is compiled AND peculiarities of the host system under which + * the compiler will run (hence it might need further explication in the + * unlikely event that we wish to cross-compile the compiler (repeatedly + * as opposed to once-off bootstrap)). It is now loaded first and can + * therefore not depend on TARGET_xxx parameterisations, these are now + * done in target.h or, if systematic, in mip/defaults.h. + * The correct mechanism for host->target dependencies (e.g. if compiling + * on unix then make a unix compiler, else a homebrew object file version) + * is via the options.h file, along the lines of: + * #ifdef COMPILING_ON_UNIX + * # define TARGET_IS_UNIX + * #endif + * The intent is that most of the pecularities should be linked to + * COMPILING_ON_machine and/or COMPILING_ON_system. Further NO OTHER FILE + * should refer to magic names like 'unix', '__arm' etc., but go via + * the COMPILING_xxx flags defined here in terms of these. + * The aim is that this file should suffice for all host dependencies + * and thus all COMPILING_ON_xxx tests outwith are suspect. However, + * the #include file munger clearly needs to so depend. + */ + +#ifndef _host_LOADED +#define _host_LOADED 1 + +#include +#include /* for xsyn.c (and more?) and offsetof test below */ +#include /* for EXIT_FAILURE test below */ + +#ifndef SEEK_SET +# define SEEK_SET 0 +#endif +#ifndef SEEK_CUR +# define SEEK_CUR 1 +#endif +#ifndef SEEK_END +# define SEEK_END 2 +#endif + +#ifdef __STDC__ + +#define BELL '\a' +typedef void /* newline to fool the topcc tool */ + *VoidStar; +typedef const void + *ConstVoidStar; +#define safe_tolower(ch) tolower(ch) /* see comment below */ +#define safe_toupper(ch) toupper(ch) /* see comment below */ + +#else /* ! __STDC__ */ + +#define BELL '\007' +typedef char *VoidStar; +#define ConstVoidStar VoidStar +/* + * not all C libraries define tolower() and toupper() over all character + * values. BSD Unix, for example, defines tolower() only over UC chars. + */ +#define safe_tolower(ch) (isupper(ch) ? tolower(ch) : ch) +#define safe_toupper(ch) (islower(ch) ? toupper(ch) : ch) + +#endif /* ! __STDC__ */ + +/* The following for the benefit of compiling on SunOS */ +#ifndef offsetof +# define offsetof(T, member) ((char *)&(((T *)0)->member) - (char *)0) +#endif + +#ifdef unix /* A temporary sop to older compilers */ +# ifndef __unix /* (good for long-term portability?) */ +# define __unix 1 +# endif +#endif + +#ifdef __unix +/* Generic unix -- hopefully a split into other variants will not be */ +/* needed. However, beware the 'bsd' test above and safe_toupper etc. */ +/* which cope with backwards (pre-posix/X/open) unix compatility. */ +# define COMPILING_ON_UNIX 1 +#endif +#ifdef __helios +/* start improving parameterisation. Maybe we should also set */ +/* COMPILING_ON_UNIX and use HELIOS as a special subcase? */ +# define COMPILING_ON_HELIOS 1 +#endif +#ifdef __acorn +# define COMPILING_ON_ACORN_KIT 1 +#endif +#ifdef __riscos +# define COMPILING_ON_RISC_OS 1 +#endif +#ifdef __arm +# define COMPILING_ON_ARM 1 /* dying: unix/riscos/acorn suffice */ +#endif +#ifdef __ibm370 +# ifndef COMPILING_ON_UNIX +# define __mvs 1 /* a hack to be removed soon */ +# endif +#endif +#ifdef __mvs +# define COMPILING_ON_MVS 1 +#endif +#ifdef _MSDOS +# define COMPILING_ON_MSDOS 1 +#endif +#ifdef __ZTC__ +# define COMPILING_ON_MSDOS 1 +#endif +#ifdef __WATCOMC__ +# define COMPILING_ON_MSDOS 1 +#endif +#ifdef _MSC_VER +# define COMPILING_ON_MSDOS 1 +#endif +#ifdef macintosh +# define COMPILING_ON_MACINTOSH 1 /* for things that depend on how Macintosh handles filenames, etc. */ +# define COMPILING_ON_MPW 1 /* for things that depend on how MPW handles arguments, i/o, etc. */ +#endif + +/* + * The following typedefs may need alteration for obscure host machines. + */ +#ifdef __alpha +typedef int int32; +typedef unsigned int unsigned32; +#else +typedef long int int32; +typedef unsigned long int unsigned32; +#endif +typedef short int int16; +typedef unsigned short int unsigned16; +typedef signed char int8; +typedef unsigned char unsigned8; +typedef int bool; + +/* + * The following sets ArgvType for 64-bit pointers so that + * DEC Unix (OSF) cc can be used with the -xtaso_short compiler option + * to force pointers to be 32-bit. + */ +#if defined(__alpha) && defined(__osf__) +#pragma pointer_size (save) +#pragma pointer_size (long) +#endif +typedef char *ArgvType; +#if defined(__alpha) && defined(__osf__) +#pragma pointer_size (restore) +#endif + +#define YES 1 +#define TRUE 1 +#define NO 0 +#define FALSE 0 + +/* + * Rotate macros + */ +#define ROL_32(val, n) \ +((((unsigned32)(val) << (n)) | ((unsigned32)(val) >> (32-(n)))) & 0xFFFFFFFFL) +#define ROR_32(val, n) \ +((((unsigned32)(val) >> (n)) | ((unsigned32)(val) << (32-(n)))) & 0xFFFFFFFFL) + +/* The following two lines are a safety play against using ncc with a */ +/* vendor supplied library, many of which refuse to accept "wb". POSIX */ +/* and other unix standards require "wb" and "w" to have the same */ +/* effect and so the following is safe. */ +#ifdef COMPILING_ON_UNIX +# define FOPEN_WB "w" +# define FOPEN_RB "r" +# define FOPEN_RWB "r+" +# ifndef __STDC__ /* caveat RISCiX... */ +# define remove(file) unlink(file) /* a horrid hack, but probably best? */ +# endif +#else +# define FOPEN_WB "wb" +# define FOPEN_RB "rb" +# define FOPEN_RWB "rb+" +#endif + +/* (defined __sparc && defined P_tmpdir) is to detect gcc on SunOS */ +#if !defined __STDC__ || (defined __sparc && defined P_tmpdir) +/* Use bcopy rather than memmove, as memmove is not available. */ +# define memmove(d,s,l) bcopy(s,d,l) +/* BSD/SUN don't have strtoul(), but then strtol() doesn't barf on */ +/* overflow as required by ANSI... This bodge is horrid. */ +# define strtoul(s, ptr, base) strtol(s, ptr, base) +/* strtod is present in the C-library but is not in stdlib.h */ +extern double strtod(const char *str, char **ptr); +#endif + +#ifdef __CC_NORCROFT +# ifndef COMPILING_ON_UNIX /* suppress if maybe non-norcroft lib */ +# define LIBRARY_IS_NORCROFT 1 +# endif +# ifdef LIBRARY_IS_ALIEN /* unify with the 3 previous lines? */ +# undef LIBRARY_IS_NORCROFT +# endif +#endif + +#ifdef LIBRARY_IS_NORCROFT +/* + * Calls to all non-ansi functions are removable by macros here. + */ +#ifdef __cplusplus +extern "C" { +#endif +/* These routines have no floating point abilities. */ +extern int _vfprintf(FILE *stream, const char *format, __va_list arg); +extern int _vsprintf(char *s, const char *format, __va_list arg); +extern int _fprintf(FILE *stream, const char *format, ...); +extern int _sprintf(char *s, const char *format, ...); +#ifdef __cplusplus +} +#endif +#else /* LIBRARY_IS_NORCROFT */ +# define _vfprintf vfprintf +# define _vsprintf vsprintf +# define _fprintf fprintf +# define _sprintf sprintf +#endif /* LIBRARY_IS_NORCROFT */ + +#ifdef COMPILING_ON_MVS + +#define HOST_USES_CCOM_INTERFACE 1 +#define EXIT_warn 4 +#define EXIT_error 8 +#define EXIT_fatal 12 +#define EXIT_syserr 16 + +/* + * The following #included #define's ensure that external symbols are + * limited to 6 chars without gratuitous changes to every file. + */ +#include "sixchar.h" + +#else /* ! COMPILING_ON_MVS */ + +#define EXIT_warn 0 +#define EXIT_error 1 +#define EXIT_fatal 1 + +#ifdef COMPILING_ON_UNIX +# define EXIT_syserr 100 +#else +# define EXIT_syserr 1 +#endif + +#endif /* ! COMPILING_ON_MVS */ + +/* For systems that do not define EXIT_SUCCESS and EXIT_FAILURE */ +#ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +#endif +#ifndef EXIT_FAILURE +# define EXIT_FAILURE EXIT_error +#endif + +#endif + +/* end of host.h */ + \ No newline at end of file diff --git a/Bachelor/Mikroprozessorsysteme2/ARM202U/SOURCE/WIN32/CLX/IEEEFLT.H b/Bachelor/Mikroprozessorsysteme2/ARM202U/SOURCE/WIN32/CLX/IEEEFLT.H new file mode 100644 index 0000000..eb215c7 --- /dev/null +++ b/Bachelor/Mikroprozessorsysteme2/ARM202U/SOURCE/WIN32/CLX/IEEEFLT.H @@ -0,0 +1,75 @@ +/* + * ieeeflt.h: interface to host-arithmetic-independent IEEE fp package. + * Copyright (C) Codemist Ltd., 1994. + * Copyright (C) Advanced RISC Machines Limited, 1994. + */ + +/* + * RCS $Revision: 1.2.2.1 $ + * Checkin $Date: 1995/05/13 17:04:14 $ + * Revising $Author: kwelton $ + */ + +#ifndef _ieeeflt_LOADED +#define _ieeeflt_LOADED + +/* + * The following types describe the representation of floating-point + * values by the compiler in both binary and source-related forms. + * The order of fields in DbleBin in is exploited only in object-code + * formatters and assembly code generators. + */ + +#include "host.h" + +typedef struct DbleBin { +#ifdef TARGET_HAS_OTHER_IEEE_ORDER + int32 lsd,msd; /* e.g. clipper */ +#else + int32 msd,lsd; /* e.g. arm, 370 (not really ieee) */ +#endif +} DbleBin; + +typedef struct FloatBin { + int32 val; +} FloatBin; + +#define flt_ok 0 +#define flt_very_small 1 +#define flt_very_big 2 +#define flt_big_single 3 +#define flt_small_single 4 +#define flt_negative 5 +#define flt_divide_by_zero 6 +#define flt_invalidop 7 /* inf - int, inf / inf, anything involving NaNs */ +#define flt_bad 8 /* invalid string for stod */ + +extern int fltrep_stod(const char *s, DbleBin *p, char **endp); +extern int fltrep_narrow(DbleBin const *d, FloatBin *e); +extern int fltrep_narrow_round(DbleBin const *d, FloatBin *e); +extern void fltrep_widen(FloatBin const *e, DbleBin *d); + +extern int flt_add(DbleBin *a, DbleBin const *b, DbleBin const *c); +extern int flt_subtract(DbleBin *a, DbleBin const *b, DbleBin const *c); +extern int flt_multiply(DbleBin *a, DbleBin const *b, DbleBin const *c); +extern int flt_divide(DbleBin *a, DbleBin const *b, DbleBin const *c); +extern int flt_compare(DbleBin const *b, DbleBin const *c); +extern int flt_move(DbleBin *a, DbleBin const *b); +extern int flt_negate(DbleBin *a, DbleBin const *b); +extern int flt_abs(DbleBin *a, DbleBin const *b); + +extern int flt_dtoi(int32 *n, DbleBin const *a); +extern int flt_dtou(unsigned32 *u, DbleBin const *a); + +extern int flt_itod(DbleBin *a, int32 n); +extern int flt_utod(DbleBin *a, unsigned32 n); + +void flt_frexp(DbleBin *res, DbleBin const *dp, int *lvn); +void flt_ldexp(DbleBin *res, DbleBin const *dp, int n); + +int fltrep_dtos(char *p, int flags, int ch, int precision, int width, + char *prefix, DbleBin const *d); +extern void fltrep_sprintf(char *b, char const *fmt, DbleBin const *dp); + +#endif + \ No newline at end of file diff --git a/Bachelor/Mikroprozessorsysteme2/ARM202U/SOURCE/WIN32/CLX/MSG.H b/Bachelor/Mikroprozessorsysteme2/ARM202U/SOURCE/WIN32/CLX/MSG.H new file mode 100644 index 0000000..1722480 --- /dev/null +++ b/Bachelor/Mikroprozessorsysteme2/ARM202U/SOURCE/WIN32/CLX/MSG.H @@ -0,0 +1,104 @@ +/* msg.h -- interface to the message file and nls system. */ +/* Copyright (C) Advanced RISC Machines Limited, 1995. All rights reserved. */ + +/* + * RCS $Revision: 1.8 $ + * Checkin $Date: 1995/03/14 17:09:16 $ + * Revising $Author: mwilliam $ + */ + +#ifndef msg_h +#define msg_h + +#include + +#ifdef NLS +#include + +/* + * Initialise a tool. Passed in the name of the tool, and it attempts to + * locate the message file (in a host dependent way). Can be called + * multiple times for various components of a tool - e.g.: + * msg_init("armdbg",NULL); msg_init("armsd",NULL); msg_init("armul",NULL); + * + * toolname may be a full pathname to the tool - e.g. argv[0] under DOS, + * in which case that directory will be searched for the messagefile too. + */ +extern void msg_init(const char * /*toolname*/, + const char * /*default_name*/); + +/* Open and "closes" a message file. Once closed, all attempts to lookup a + * message will fail. close also frees any internally allocated store. + */ + +/* It is possible, at the moment, to call msg_open() multiple times, and the + * message files will be merged (new entries overwriting old). However any + * call to msg_close() will destroy the entire hash table, unfortunately. + */ +extern char *msg_open(const char * /*filename*/); /* Returns NULL on error */ +extern void msg_close(char * /*value_returned_by_msg_open*/); + +/* At the moment if you call msg_lookup(), or any function which in turn + * calls msg_lookup() will call msg_open("messages") if no msg_open call + * has yet been called. + */ + +typedef const unsigned char *msg_t; /* type of message tag */ + +/* printf variants */ +extern int msg_printf(msg_t /*tag*/, ...); +extern int msg_sprintf(char *, msg_t /*tag*/, ...); +extern int msg_fprintf(FILE *, msg_t /*tag*/, ...); +extern int msg_vsprintf(char *, msg_t /*tag*/, va_list); +extern int msg_vfprintf(FILE *, msg_t /*tag*/, va_list); + +/* Low-level find-a-message-from-a-tag routine */ +/* If the lookup fails, it tries the equivalent of returning the result + * from msg_sprintf("msg_lookup_failed",tag); + */ +extern char *msg_lookup(msg_t /*tag*/); + + +/* ==== nls printf functions (take format strings, not tags) ==== */ + +extern int nls_printf(const char * /*fmt*/, ...); +extern int nls_sprintf(char *,const char * /*fmt*/, ...); +extern int nls_fprintf(FILE *,const char * /*fmt*/, ...); +extern int nls_vfprintf(FILE *,const char * /*fmt*/, va_list); + +/* ==== Even lower-level things ==== */ +typedef union { + double floating; + long cardinal; + void *pointer; +} nls_type; + +/* These functions take a *format* string, not a tag. */ +extern nls_type *nls_va2type(const char * /*fmt*/, va_list); +extern int nls_tsprintf(char *,const char * /*fmt*/, nls_type *); +extern int nls_tfprintf(FILE *,const char * /*fmt*/, nls_type *); + +#else + +typedef char *msg_t; /* type of message tag */ + +# define msg_printf printf +# define msg_sprintf sprintf +# define msg_fprintf fprintf +# define msg_vsprintf vsprintf +# define msg_vfprintf vfprintf + +# define nls_printf printf +# define nls_sprintf sprintf +# define nls_fprintf fprintf +# define nls_vfprintf vfprintf + +# define msg_init(X,Y) /* null def'n */ +# define msg_open(X) +# define msg_close(X) + +# define msg_lookup(X) X +#endif + +#endif + \ No newline at end of file diff --git a/Bachelor/Mikroprozessorsysteme2/ARM202U/SOURCE/WIN32/CLX/MSVC20/CLX.LIB b/Bachelor/Mikroprozessorsysteme2/ARM202U/SOURCE/WIN32/CLX/MSVC20/CLX.LIB new file mode 100644 index 0000000..85ba5d7 Binary files /dev/null and b/Bachelor/Mikroprozessorsysteme2/ARM202U/SOURCE/WIN32/CLX/MSVC20/CLX.LIB differ -- cgit v1.2.3