/*
   The structure passed to the _ContInit function (if any)
   immediately after loading of any library.
   The structure is used by library's functions to access
   corelib and standard functions linked in the kernel.
*/

#define LIB_INIT_FUNC_NAME	_ContInit
#define LIB_INIT_FUNC_STR	"_ContInit"
#define LIB_INIT_FUNC_TYPE	_ContInit_

#if defined(WIN32)
#define myLIBCALL LIBCALL
#else
#define myLIBCALL
#endif

typedef struct {	/* Corelib */
  /* Mem... */
#if DEB_MEM
  VoidPtr	(* MemNew_)(size_t size, CharPtr FileName, int Line);
  VoidPtr	(* MemGet_)(size_t size, unsigned int flags, CharPtr FileName, int Line);
  VoidPtr 	myLIBCALL (* MemMore_)(VoidPtr ptr, size_t size, CharPtr FileName, int Line);
  VoidPtr 	myLIBCALL (* MemExtend_)(VoidPtr ptr, size_t size, size_t oldsize, CharPtr FileName, int Line);
  VoidPtr	myLIBCALL (* MemFree_)(VoidPtr ptr, CharPtr FileName, int Line);
#else
  VoidPtr	(* MemNew_)(size_t size);
  VoidPtr	(* MemGet_)(size_t size, unsigned int flags);
  VoidPtr	myLIBCALL (* MemMore_)(VoidPtr ptr, size_t size);
  VoidPtr	myLIBCALL (* MemExtend_)(VoidPtr ptr, size_t size, size_t oldsize);
  VoidPtr	myLIBCALL (* MemFree_)(VoidPtr ptr);
#endif
  VoidPtr	myLIBCALL (* MemFill_)(VoidPtr ptr, int value, size_t bytes);
  void *	(* MemSet_)(void *ptr, int value, size_t bytes);
  void *	myLIBCALL (* MemCopy_)(void *dst, const void *src, size_t bytes);
  void *	myLIBCALL (* MemMove_)(void *dst, const void *src, size_t bytes);
  /* Str... and String... */
  size_t	(* StrLen_)(const char *str);
  size_t	LIBCALL (* StringLen_)(const char *str);
  int		(* StrCmp_)(const char *s1, const char *s2);
  int		myLIBCALL (* StrICmp_)(const char FAR *a, const char FAR *b);
  CharPtr	(* StrChr_)(const char *s, int c);
  CharPtr	myLIBCALL (* StringChr_)(const char FAR *str, int chr);
  CharPtr	(* StrStr_)(const char *s1, const char *s2);
  CharPtr	myLIBCALL (* StringStr_)(const char *s1, const char *s2);
  CharPtr	(* StrCpy_)(char *s1, const char *s2);
  CharPtr	(* StrNCpy_)(char *s1, const char *s2, size_t n);
  CharPtr	myLIBCALL (* StringNCpy_)(char *s1, const char *s2, size_t n);
  CharPtr	(* StrPBrk_)(const char *s1, const char *s2);
  CharPtr	(* StrCat_)(char *s1, const char *s2);
  CharPtr	myLIBCALL (* StringCat_)(char *s1, const char *s2);
#if DEB_MEM
  CharPtr	myLIBCALL (* StringSave_)(const char FAR *from, CharPtr FileName, int Line);
#else
  CharPtr	myLIBCALL (* StringSave_)(const char FAR *from);
#endif
  CharPtr	myLIBCALL (* StringTok_)(char FAR *str1, const char FAR *str2);
  /* BS... */
  ByteStorePtr	myLIBCALL (* BSNew_)(Int4 len);
  ByteStorePtr	myLIBCALL (* BSFree_)(ByteStorePtr bsp);
  Int4		myLIBCALL (* BSWrite_)(ByteStorePtr bsp, VoidPtr ptr, Int4 len);
  Int2		myLIBCALL (* BSPutByte_)(ByteStorePtr bsp, Int2 value);
  Int4		myLIBCALL (* BSRead_)(ByteStorePtr bsp, VoidPtr ptr, Int4 len);
  Int2		myLIBCALL (* BSSeek_)(ByteStorePtr bsp, Int4 offset, Int2 origin);
  Int4		myLIBCALL (* BSTell_)(ByteStorePtr bsp);
  Int4		myLIBCALL (* BSDelete_)(ByteStorePtr bsp, Int4 len);
#if DEB_MEM
  VoidPtr	myLIBCALL (* BSMerge_)(ByteStorePtr ssp, VoidPtr dest, CharPtr FileName, int Line);
#else
  VoidPtr	myLIBCALL (* BSMerge_)(ByteStorePtr ssp, VoidPtr dest);
#endif
  /* Misc */
  MsgAnswer	CDECL (* Message_)(Int2 keysev, const CharPtr fmt,...);
  void		myLIBCALL (*Beep_)(void);
  Boolean	myLIBCALL (* DayTimeStr_)(CharPtr buf, Boolean date, Boolean time);
  /* I/O */
  FILE *	(* fopen_)(const char *filename, const char *mode);
  int		(* fclose_)(FILE *stream);
  int		CDECL (* fprintf_)(FILE *stream, const char *format, ...);
  int		CDECL (* sprintf_)(char *s, const char *format, ...);
  int		CDECL (* printf_)(const char *format, ...);
#if _WIN
#ifdef WIN32
  int		CDECL (* fscanf_)(FILE *stream, const char *format, ...);
  int		CDECL (* sscanf_)(const char *s, const char *format, ...);
#endif
#else
  int		(* fscanf_)(FILE *stream, const char *format, ...);
  int		(* sscanf_)(const char *s, const char *format, ...);
#endif	/* _WIN */
  int		(* fseek_)(FILE *stream, long offset, int whence);
  void		(* rewind_)(FILE *stream);
  size_t	(* fread_)(void *ptr, size_t size, size_t n, FILE *stream);
  int		(* fputs_)(const char *s, FILE *stream);
  long		(* ftell_)(FILE *stream);
  CharPtr	(* fgets_)(char *s, int n, FILE *stream);
  int		(* fgetc_)(FILE *stream);
  const Char PNTR CDECL (* TSPrintf_)(const Char PNTR fmt,  ...);
  const Char PNTR CDECL (* TSPrintfArgs_)(const Char PNTR fmt, va_list args);
  /* std */
#ifdef WIN32
  void		(* qsort_)(void *base, size_t nmemb, size_t size, int (_USERENTRY *compar)(const void *, const void *));
#else
  void		(* qsort_)(void *base, size_t nmemb, size_t size, EntryPtr(int,compar,(const void *, const void *)));
#endif
  double	(* atof_)(const char *s);
  /* private */
  void		(* StrTrim_)(CharPtr source);
  CharPtr	(*StrSubstitute_)(CharPtr source, CharPtr what, CharPtr with, Boolean wholeid, Int2Ptr num);
  CharPtr	(*StrInsert_)(CharPtr source, Int2 position, CharPtr what);
  CharPtr	(*GetParamString_)(CharPtr section, CharPtr key);
  void		(*SetParam_) (CharPtr Section, CharPtr Key, CharPtr Value);
} CoreFunc, PNTR CoreFuncPtr;

#ifdef KERNEL

typedef EntryPtr(void,LIB_INIT_FUNC_TYPE,(CoreFuncPtr cfp));

extern Global(CoreFunc) CoreFuncTable;

#else /* #ifdef KERNEL */

Local(CoreFuncPtr) coreFuncPtr=NULL;

Entry(void) LIB_INIT_FUNC_NAME(CoreFuncPtr cfp) {
  if (coreFuncPtr==NULL) coreFuncPtr=cfp;
}

#undef MemNew
#if DEB_MEM
#define MemNew(size) coreFuncPtr->MemNew_(size,__FILE__,(int)__LINE__)
#else
#define MemNew	coreFuncPtr->MemNew_
#endif
#define MemNewDeb coreFuncPtr->MemNew_

#undef MemGet
#if DEB_MEM
#define MemGet(size,clear) coreFuncPtr->MemGet_(size,clear,__FILE__,(int)__LINE__)
#else
#define MemGet	coreFuncPtr->MemGet_
#endif

#undef MemMore
#if DEB_MEM
#define MemMore(ptr,size) coreFuncPtr->MemMore_(ptr,size,__FILE__,(int)__LINE__)
#else
#define MemMore	coreFuncPtr->MemMore_
#endif

#undef MemExtend
#if DEB_MEM
#define MemExtend(ptr,size,old) coreFuncPtr->MemExtend_(ptr,size,old,__FILE__,(int)__LINE__)
#else
#define MemExtend	coreFuncPtr->MemExtend_
#endif

#undef MemFree
#if DEB_MEM
#define MemFree(ptr) coreFuncPtr->MemFree_(ptr,__FILE__,(int)__LINE__)
#else
#define MemFree coreFuncPtr->MemFree_
#endif

#undef MemFill
#define MemFill coreFuncPtr->MemFill_

#undef MemSet
#define MemSet coreFuncPtr->MemSet_

#undef MemCopy
#define MemCopy coreFuncPtr->MemCopy_

#undef MemMove
#define MemMove coreFuncPtr->MemMove_

#undef StrLen
#define StrLen coreFuncPtr->StrLen_

#undef StringLen
#define StringLen coreFuncPtr->StringLen_

#undef StrCmp
#define StrCmp coreFuncPtr->StrCmp_

#undef StrICmp
#define StrICmp coreFuncPtr->StrICmp_

#undef StrChr
#define StrChr coreFuncPtr->StrChr_

#undef StringChr
#define StringChr coreFuncPtr->StringChr_

#undef StrStr
#define StrStr coreFuncPtr->StrStr_

#undef StringStr
#define StringStr coreFuncPtr->StringStr_

#undef StrCpy
#define StrCpy coreFuncPtr->StrCpy_

#undef StrNCpy
#define StrNCpy coreFuncPtr->StrNCpy_

#undef StringNCpy
#define StringNCpy coreFuncPtr->StringNCpy_

#undef StrPBrk
#define StrPBrk coreFuncPtr->StrPBrk_

#undef StrCat
#define StrCat coreFuncPtr->StrCat_

#undef StringCat
#define StringCat coreFuncPtr->StringCat_

#undef StringSave
#if DEB_MEM
#define StringSave(ptr) coreFuncPtr->StringSave_(ptr,__FILE__,(int)__LINE__)
#else
#define StringSave coreFuncPtr->StringSave_
#endif

#undef StringTok
#define StringTok coreFuncPtr->StringTok_

#undef BSNew
#define BSNew coreFuncPtr->BSNew_

#undef BSFree
#define BSFree coreFuncPtr->BSFree_

#undef BSWrite
#define BSWrite coreFuncPtr->BSWrite_

#undef BSPutByte
#define BSPutByte coreFuncPtr->BSPutByte_

#undef BSRead
#define BSRead coreFuncPtr->BSRead_

#undef BSSeek
#define BSSeek coreFuncPtr->BSSeek_

#undef BSTell
#define BSTell coreFuncPtr->BSTell_

#undef BSDelete
#define BSDelete coreFuncPtr->BSDelete_

#undef BSMerge
#if DEB_MEM
#define BSMerge(bsp,buffer) coreFuncPtr->BSMerge_(bsp,buffer,__FILE__,(int)__LINE__)
#else
#define BSMerge coreFuncPtr->BSMerge_
#endif

#undef Message
#define Message coreFuncPtr->Message_

#undef Beep
#define Beep coreFuncPtr->Beep_

#undef DayTimeStr
#define DayTimeStr coreFuncPtr->DayTimeStr_

#define fopen coreFuncPtr->fopen_

#define fclose coreFuncPtr->fclose_

#define fprintf coreFuncPtr->fprintf_

#define sprintf coreFuncPtr->sprintf_

#define printf coreFuncPtr->printf_

#if _WIN
#ifdef WIN32
#define fscanf coreFuncPtr->fscanf_
#define sscanf coreFuncPtr->sscanf_
#endif
#else
#define fscanf coreFuncPtr->fscanf_
#define sscanf coreFuncPtr->sscanf_
#endif	/* _WIN */

#define fseek coreFuncPtr->fseek_

#define rewind coreFuncPtr->rewind_

#define fread coreFuncPtr->fread_

#define fputs coreFuncPtr->fputs_

#define ftell coreFuncPtr->ftell_

#define fgets coreFuncPtr->fgets_

#define fgetc coreFuncPtr->fgetc_

#undef TSPrintf
#define TSPrintf coreFuncPtr->TSPrintf_

#undef TSPrintfArgs
#define TSPrintfArgs coreFuncPtr->TSPrintfArgs_

#define qsort coreFuncPtr->qsort_

#define atof coreFuncPtr->atof_

#define StrTrim coreFuncPtr->StrTrim_
#define StrSubstitute coreFuncPtr->StrSubstitute_
#define StrInsert coreFuncPtr->StrInsert_
#define GetParamString coreFuncPtr->GetParamString_
#define SetParam coreFuncPtr->SetParam_

#endif /* #ifdef KERNEL */