/*
   Interface library-kernel
*/

#include "common.h"

#include "tsprintf.h"	/* TSPrintf and TSPrintfArgs */

#define KERNEL
#include "corefunc.h"
#undef 	KERNEL

#define __WIN _WIN && !defined(WIN32)

#if __WIN

#if DEB_MEM
Local(VoidPtr) hookMemNew(size_t size, CharPtr FileName, int Line) {
#else
#undef __MemNew
Local(VoidPtr) __MemNew(size_t size) {
#endif
  VoidPtr p;
  Prolog
#if DEB_MEM
  p=__MemNew(size,FileName,Line);
#define __MemNew hookMemNew
#else
  p=Nlm_MemNew(size);
#endif
  Epilog
  return p;
}

#if DEB_MEM
Local(VoidPtr) hookMemGet(size_t size, unsigned int flags, CharPtr FileName, int Line) {
#else
#undef __MemGet
Local(VoidPtr) __MemGet(size_t size, unsigned int flags) {
#endif
  VoidPtr p;
  Prolog
#if DEB_MEM
  p=__MemGet(size,flags,FileName,Line);
#define __MemGet hookMemGet
#else
  p=Nlm_MemGet(size,flags);
#endif
  Epilog
  return p;
}

#if DEB_MEM
Local(VoidPtr) hookMemMore(VoidPtr ptr, size_t size, CharPtr FileName, int Line) {
#else
#undef __MemMore
Local(VoidPtr) __MemMore(VoidPtr ptr, size_t size) {
#endif
  VoidPtr p;
  Prolog
#if DEB_MEM
  p=__MemMore(ptr,size,FileName,Line);
#define __MemMore hookMemMore
#else
  p=Nlm_MemMore(ptr,size);
#endif
  Epilog
  return p;
}

#if DEB_MEM
Local(VoidPtr) hookMemExtend(VoidPtr ptr, size_t size, size_t old, CharPtr FileName, int Line) {
#else
#undef __MemExtend
Local(VoidPtr) __MemExtend(VoidPtr ptr, size_t size, size_t old) {
#endif
  VoidPtr p;
  Prolog
#if DEB_MEM
  p=__MemExtend(ptr,size,old,FileName,Line);
#define __MemExtend hookMemExtend
#else
  p=Nlm_MemExtend(ptr,size,old);
#endif
  Epilog
  return p;
}

#if DEB_MEM
Local(VoidPtr) hookMemFree(VoidPtr ptr, CharPtr FileName, int Line) {
#else
#undef __MemFree
Local(VoidPtr) __MemFree(VoidPtr ptr) {
#endif
  VoidPtr p;
  Prolog
#if DEB_MEM
  p=__MemFree(ptr,FileName,Line);
#define __MemFree hookMemFree
#else
  p=Nlm_MemFree(ptr);
#endif
  Epilog
  return p;
}

#undef MemFill
Local(VoidPtr) MemFill(VoidPtr ptr, int value, size_t bytes) {
  VoidPtr p;
  Prolog
  p=Nlm_MemFill(ptr,value,bytes);
  Epilog
  return p;
}

#undef MemSet
Local(VoidPtr) MemSet(VoidPtr ptr, int value, size_t bytes) {
  VoidPtr p;
  Prolog
  p=Nlm_MemSet(ptr,value,bytes);
  Epilog
  return p;
}

#undef MemCopy
Local(VoidPtr) MemCopy(void *ptr, const void *src, size_t bytes) {
  VoidPtr p;
  Prolog
  p=Nlm_MemCopy(ptr,src,bytes);
  Epilog
  return p;
}

#undef MemMove
Local(VoidPtr) MemMove(void *ptr, const void *src, size_t bytes) {
  VoidPtr p;
  Prolog
  p=Nlm_MemMove(ptr,src,bytes);
  Epilog
  return p;
}

#undef StrLen
Local(size_t) StrLen(const char *str) {
  size_t l;
  Prolog
  l=Nlm_StrLen(str);
  Epilog
  return l;
}

#undef StrCmp
Local(int) StrCmp(const char *s1, const char *s2) {
  int r;
  Prolog
  r=Nlm_StrCmp(s1,s2);
  Epilog
  return r;
}

#undef StrICmp
Local(int) StrICmp(const char FAR *a, const char FAR *b) {
  int r;
  Prolog
  r=Nlm_StrICmp(a,b);
  Epilog
  return r;
}

#undef StrChr
Local(CharPtr) StrChr(const char *s, int c) {
  CharPtr p;
  Prolog
  p=Nlm_StrChr(s,c);
  Epilog
  return p;
}

#undef StringChr
Local(CharPtr) StringChr(const char FAR *str, int chr) {
  CharPtr p;
  Prolog
  p=Nlm_StringChr(str,chr);
  Epilog
  return p;
}

#undef StrStr
Local(CharPtr) StrStr(const char *s1, const char *s2) {
  CharPtr p;
  Prolog
  p=Nlm_StrStr(s1,s2);
  Epilog
  return p;
}

#undef StringStr
Local(CharPtr) StringStr(const char *s1, const char *s2) {
  CharPtr p;
  Prolog
  p=Nlm_StringStr(s1,s2);
  Epilog
  return p;
}

#undef StrCpy
Local(CharPtr) StrCpy(char *s1, const char *s2) {
  CharPtr p;
  Prolog
  p=Nlm_StrCpy(s1,s2);
  Epilog
  return p;
}

#undef StrNCpy
Local(CharPtr) StrNCpy(char *s1, const char *s2, size_t n) {
  CharPtr p;
  Prolog
  p=Nlm_StrNCpy(s1,s2,n);
  Epilog
  return p;
}

#undef StringNCpy
Local(CharPtr) StringNCpy(char *s1, const char *s2, size_t n) {
  CharPtr p;
  Prolog
  p=Nlm_StringNCpy(s1,s2,n);
  Epilog
  return p;
}

#undef StrPBrk
Local(CharPtr) StrPBrk(const char *s1, const char *s2) {
  CharPtr p;
  Prolog
  p=Nlm_StrPBrk(s1,s2);
  Epilog
  return p;
}

#undef StringCat
Local(CharPtr) StringCat(char *s1, const char *s2) {
  CharPtr p;
  Prolog
  p=Nlm_StringCat(s1,s2);
  Epilog
  return p;
}

#if DEB_MEM
Local(CharPtr) hookStringSave(const char FAR *from, CharPtr FileName, int Line) {
#else
#undef __StringSave
Local(CharPtr) __StringSave(const char FAR *from) {
#endif
  VoidPtr p;
  Prolog
#if DEB_MEM
  p=__StringSave(from,FileName,Line);
#define __StringSave hookStringSave
#else
  p=Nlm_StringSave(from);
#endif
  Epilog
  return p;
}

#undef StringTok
Local(CharPtr) StringTok(char FAR *str1, const char FAR *str2) {
  CharPtr p;
  Prolog
  p=Nlm_StringTok(str1,str2);
  Epilog
  return p;
}

#undef BSNew
Local(ByteStorePtr) BSNew(Int4 len) {
  ByteStorePtr bsp;
  Prolog
  bsp=Nlm_BSNew(len);
  Epilog
  return bsp;
}

#undef BSFree
Local(ByteStorePtr) BSFree(ByteStorePtr bsp) {
  Prolog
  bsp=Nlm_BSFree(bsp);
  Epilog
  return bsp;
}

#undef BSWrite
Local(Int4) BSWrite(ByteStorePtr bsp, VoidPtr ptr, Int4 len) {
  Int4 rlen;
  Prolog
  rlen=Nlm_BSWrite(bsp,ptr,len);
  Epilog
  return rlen;
}

#if DEB_MEM
Local(VoidPtr) hookBSMerge(ByteStorePtr ssp, VoidPtr dest, CharPtr FileName, int Line) {
#else
#undef __BSMerge
Local(VoidPtr) __BSMerge(ByteStorePtr ssp, VoidPtr dest) {
#endif
  VoidPtr vp;
  Prolog
#if DEB_MEM
  vp=__BSMerge(ssp,dest,FileName,Line);
#define __BSMerge hookBSMerge
#else
  vp=Nlm_BSMerge(ssp,dest);
#endif
  Epilog
  return vp;
}

#undef BSPutByte
Local(Int2) BSPutByte(ByteStorePtr bsp, Int2 value) {
  Int2 rlen;
  Prolog
  rlen=Nlm_BSPutByte(bsp,value);
  Epilog
  return rlen;
}

#undef BSRead
Local(Int4) BSRead(ByteStorePtr bsp, VoidPtr ptr, Int4 len) {
  Int4 l;
  Prolog
  l=Nlm_BSRead(bsp,ptr,len);
  Epilog
  return l;
}

#undef BSSeek
Local(Int2) BSSeek(ByteStorePtr bsp, Int4 offset, Int2 origin) {
  Int2 r;
  Prolog
  r=Nlm_BSSeek(bsp,offset,origin);
  Epilog
  return r;
}

#undef Message
Local(MsgAnswer) CDECL Message (Int2 sevkey, const CharPtr fmt, ...) {
  va_list args;
  MsgAnswer ans;
  Char buff[500];
  Prolog
  va_start(args,fmt);
  vsprintf(buff,fmt,args);
  va_end(args);
  ans=myMessage(sevkey,buff);
  Epilog
  return ans;
}

Local(FILE *) myfopen(const char *filename, const char *mode) {
  FILE *stream;
  Prolog
  stream=fopen(filename,mode);
  Epilog  
  return stream;
}
#define fopen myfopen

Local(int) myfclose(FILE *stream) {
  int r;
  Prolog
  r=fclose(stream);
  Epilog  
  return r;
}
#define fclose myfclose

Local(int) myfprintf(FILE *stream, const char *format, ...) {
  va_list valist;
  int n;
  Prolog
  va_start(valist,format);
  n=vfprintf(stream,format,valist);
  va_end(valist);
  Epilog
  return n;
}
#define fprintf myfprintf

Local(int) mysprintf(CharPtr buf, const char *format, ...) {
  va_list valist;
  int n;
  Prolog
  va_start(valist,format);
  n=vsprintf(buf,format,valist);
  va_end(valist);
  Epilog
  return n;
}
#define sprintf mysprintf

Local(int) myprintf(const char *format, ...) {
  va_list valist;
  int n;
  Prolog
  va_start(valist,format);
  n=vprintf(format,valist);
  va_end(valist);
  Epilog
  return n;
}
#define printf myprintf

#ifdef WIN32

Local(int) myfscanf(FILE *stream, const char *format, ...) {
  va_list valist;
  int n;
  Prolog
  va_start(valist,format);
  n=vfscanf(stream,format,valist);
  va_end(valist);
  Epilog
  return n;
}
#define fscanf myfscanf

Local(int) mysscanf(const char *buf, const char *format, ...) {
  va_list valist;
  int n;
  Prolog
  va_start(valist,format);
  n=vsscanf(buf,format,valist);
  va_end(valist);
  Epilog
  return n;
}
#define sscanf mysscanf

#endif	/* #ifdef WIN32 */

Local(int) myfseek(FILE *stream, long offset, int whence) {
  int n;
  Prolog
  n=fseek(stream,offset,whence);
  Epilog
  return n;
}
#define fseek myfseek

Local(void) myrewind(FILE *stream) {
  Prolog
  rewind(stream);
  Epilog
}
#define rewind myrewind


Local(size_t) myfread(void *ptr, size_t size, size_t n, FILE *stream) {
  size_t r;
  Prolog
  r=fread(ptr,size,n,stream);
  Epilog
  return r;
}
#define fread myfread

Local(int) myfputs(const char *s, FILE *stream) {
  int n;
  Prolog
  n=fputs(s,stream);
  Epilog
  return n;
}
#define fputs myfputs

Local(long) myftell(FILE *stream) {
  long l;
  Prolog
  l=ftell(stream);
  Epilog
  return l;
}
#define ftell myftell

Local(CharPtr) myfgets(char *s, int n, FILE *stream) {
  CharPtr p;
  Prolog
  p=fgets(s,n,stream);
  Epilog
  return p;
}
#define fgets myfgets

Local(int) myfgetc(FILE *stream) {
  int c;
  Prolog
  c=fgetc(stream);
  Epilog
  return c;
}
#define fgetc myfgetc


#ifdef WIN32
static int (_USERENTRY *savecompar)(const void*, const void*);
#else
EntryPtr(int,savecompar,(const void*, const void*));
#endif
Local(int) mycompar(const void *a, const void *b) {
  return savecompar(a,b);
}

#ifdef WIN32
Local(void) myqsort(VoidPtr base, size_t nmemb, size_t size, int (_USERENTRY *compar)(const void*, const void*)) {
#else
Local(void) myqsort(VoidPtr base, size_t nmemb, size_t size, EntryPtr(int,compar,(const void*, const void*))) {
#endif
  Prolog
  savecompar=compar;
  qsort(base,nmemb,size,mycompar);
  Epilog
}
#define __qsort myqsort

Local(void) __StrTrim(CharPtr source) {
  Prolog
  StrTrim(source);
  Epilog
}

Local(CharPtr) myGetParamString(CharPtr section, CharPtr key) {
  CharPtr p;
  Prolog
  p=GetParamString(section,key);
  Epilog
  return p;
}

Local(void) mySetParam(CharPtr Section, CharPtr Key, CharPtr Value) {
  Prolog
  SetParam(Section,Key,Value);
  Epilog
}

#else	/* #if __WIN */

#if DEB_MEM
  /* nothing */
#else	/* #if DEB_MEM */

#undef __MemNew
Local(VoidPtr) __MemNew(size_t size) {
  return Nlm_MemGet(size,MGET_CLEAR|MGET_ERRPOST);
}

#undef __MemGet
Local(VoidPtr) __MemGet(size_t size, unsigned int flags) {
  return Nlm_MemGet(size,flags);
}

#endif	/* #if DEB_MEM */

#define __qsort qsort

#define __StrTrim StrTrim

#endif	/* #if __WIN */


Global(CoreFunc) CoreFuncTable={
  __MemNew,
  __MemGet,
  __MemMore,
  __MemExtend,
  __MemFree,
  MemFill,
  MemSet,
  MemCopy,
  MemMove,
  StrLen,
  StringLen,
  StrCmp,
  StrICmp,
  StrChr,
  StringChr,
  StrStr,
  StringStr,
  StrCpy,
  StrNCpy,
  StringNCpy,
  StrPBrk,
  StrCat,
  StringCat,
  __StringSave,
  StringTok,
  BSNew,
  BSFree,
  BSWrite,
  BSPutByte,
  BSRead,
  BSSeek,
  BSTell,
  BSDelete,
  __BSMerge,
#if __WIN
  Message,
#else
  myMessage,
#endif
  MsgBeep,
  DayTimeStr,
  fopen,
  fclose,
  fprintf,
  sprintf,
  printf,
#if _WIN	/* NOT __WIN! */
#ifdef WIN32
  fscanf,
  sscanf,
#endif
#else
  fscanf,
  sscanf,
#endif	/* _WIN */
  fseek,
  rewind,
  fread,
  fputs,
  ftell,
  fgets,
  fgetc,
  TSPrintf,
  TSPrintfArgs,
  __qsort,
  atof,
  __StrTrim,
  StrSubstitute,
  StrInsert,
  /* parameters */
#if __WIN
  myGetParamString,
  mySetParam,
#else
  GetParamString,
  SetParam,
#endif
};