From f08f16c20d9a991f826f9f8062483dd0568cca5b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johnny=20Bergstr=C3=B6m?= Date: Tue, 11 Jan 2005 12:23:57 +0000 Subject: [PATCH] Adds cvars: cvar_t *csx_sqlstats_host; cvar_t *csx_sqlstats_username; cvar_t *csx_sqlstats_password; cvar_t *csx_sqlstats_db; cvar_t *csx_sqlstats_table; Exports players' statistics at map change to SQL db right after it saved those to the dat file. --- dlls/csx_sql/CMisc.cpp | 300 ++ dlls/csx_sql/CMisc.h | 116 + dlls/csx_sql/CRank.cpp | 306 ++ dlls/csx_sql/CRank.h | 123 + dlls/csx_sql/CRank_sql.cpp | 201 ++ dlls/csx_sql/CString.h | 404 +++ dlls/csx_sql/CVector.h | 444 +++ dlls/csx_sql/Makefile | 102 + dlls/csx_sql/Makefile.pl | 178 + dlls/csx_sql/amxxmodule.cpp | 3047 +++++++++++++++++ dlls/csx_sql/amxxmodule.h | 2197 ++++++++++++ dlls/csx_sql/compile.bat | 6 + .../extra/include/mysql/config-netware.h | 85 + dlls/csx_sql/extra/include/mysql/config-os2.h | 832 +++++ dlls/csx_sql/extra/include/mysql/config-win.h | 335 ++ dlls/csx_sql/extra/include/mysql/dbug.h | 93 + dlls/csx_sql/extra/include/mysql/errmsg.h | 66 + dlls/csx_sql/extra/include/mysql/ft_global.h | 67 + dlls/csx_sql/extra/include/mysql/hash.h | 66 + dlls/csx_sql/extra/include/mysql/heap.h | 185 + dlls/csx_sql/extra/include/mysql/m_ctype.h | 172 + dlls/csx_sql/extra/include/mysql/m_string.h | 254 ++ dlls/csx_sql/extra/include/mysql/md5.h | 93 + dlls/csx_sql/extra/include/mysql/merge.h | 93 + dlls/csx_sql/extra/include/mysql/my_aes.h | 66 + dlls/csx_sql/extra/include/mysql/my_alarm.h | 59 + dlls/csx_sql/extra/include/mysql/my_alloc.h | 52 + dlls/csx_sql/extra/include/mysql/my_base.h | 342 ++ dlls/csx_sql/extra/include/mysql/my_bitmap.h | 55 + dlls/csx_sql/extra/include/mysql/my_config.h | 882 +++++ dlls/csx_sql/extra/include/mysql/my_dbug.h | 93 + dlls/csx_sql/extra/include/mysql/my_dir.h | 106 + dlls/csx_sql/extra/include/mysql/my_getopt.h | 54 + dlls/csx_sql/extra/include/mysql/my_global.h | 1138 ++++++ dlls/csx_sql/extra/include/mysql/my_list.h | 46 + dlls/csx_sql/extra/include/mysql/my_net.h | 122 + .../extra/include/mysql/my_no_pthread.h | 31 + dlls/csx_sql/extra/include/mysql/my_nosys.h | 55 + dlls/csx_sql/extra/include/mysql/my_pthread.h | 693 ++++ .../extra/include/mysql/my_semaphore.h | 64 + dlls/csx_sql/extra/include/mysql/my_sys.h | 770 +++++ dlls/csx_sql/extra/include/mysql/my_tree.h | 84 + dlls/csx_sql/extra/include/mysql/myisam.h | 448 +++ dlls/csx_sql/extra/include/mysql/myisammrg.h | 112 + dlls/csx_sql/extra/include/mysql/myisampack.h | 229 ++ dlls/csx_sql/extra/include/mysql/mysql.h | 441 +++ dlls/csx_sql/extra/include/mysql/mysql_com.h | 256 ++ .../csx_sql/extra/include/mysql/mysql_embed.h | 34 + .../extra/include/mysql/mysql_version.h | 29 + .../extra/include/mysql/mysqld_error.h | 258 ++ dlls/csx_sql/extra/include/mysql/mysys_err.h | 77 + dlls/csx_sql/extra/include/mysql/nisam.h | 212 ++ dlls/csx_sql/extra/include/mysql/queues.h | 63 + dlls/csx_sql/extra/include/mysql/raid.h | 158 + dlls/csx_sql/extra/include/mysql/rijndael.h | 42 + dlls/csx_sql/extra/include/mysql/sha1.h | 67 + .../csx_sql/extra/include/mysql/sslopt-case.h | 29 + .../extra/include/mysql/sslopt-longopts.h | 41 + .../csx_sql/extra/include/mysql/sslopt-vars.h | 24 + dlls/csx_sql/extra/include/mysql/t_ctype.h | 255 ++ dlls/csx_sql/extra/include/mysql/thr_alarm.h | 120 + dlls/csx_sql/extra/include/mysql/thr_lock.h | 117 + dlls/csx_sql/extra/include/mysql/violite.h | 176 + dlls/csx_sql/extra/include/zlib.h | 893 +++++ dlls/csx_sql/extra/lib_win32/mysqlclient.lib | Bin 0 -> 541836 bytes dlls/csx_sql/extra/lib_win32/zlib.lib | Bin 0 -> 84034 bytes dlls/csx_sql/meta_api.cpp | 388 +++ dlls/csx_sql/moduleconfig.h | 462 +++ dlls/csx_sql/msvc/csx.sln | 21 + dlls/csx_sql/msvc/csx.suo | Bin 0 -> 13312 bytes dlls/csx_sql/msvc/csx.vcproj | 489 +++ dlls/csx_sql/rank.cpp | 397 +++ dlls/csx_sql/rank.h | 152 + dlls/csx_sql/usermsg.cpp | 217 ++ 74 files changed, 20684 insertions(+) create mode 100755 dlls/csx_sql/CMisc.cpp create mode 100755 dlls/csx_sql/CMisc.h create mode 100755 dlls/csx_sql/CRank.cpp create mode 100755 dlls/csx_sql/CRank.h create mode 100755 dlls/csx_sql/CRank_sql.cpp create mode 100755 dlls/csx_sql/CString.h create mode 100755 dlls/csx_sql/CVector.h create mode 100755 dlls/csx_sql/Makefile create mode 100755 dlls/csx_sql/Makefile.pl create mode 100755 dlls/csx_sql/amxxmodule.cpp create mode 100755 dlls/csx_sql/amxxmodule.h create mode 100755 dlls/csx_sql/compile.bat create mode 100755 dlls/csx_sql/extra/include/mysql/config-netware.h create mode 100755 dlls/csx_sql/extra/include/mysql/config-os2.h create mode 100755 dlls/csx_sql/extra/include/mysql/config-win.h create mode 100755 dlls/csx_sql/extra/include/mysql/dbug.h create mode 100755 dlls/csx_sql/extra/include/mysql/errmsg.h create mode 100755 dlls/csx_sql/extra/include/mysql/ft_global.h create mode 100755 dlls/csx_sql/extra/include/mysql/hash.h create mode 100755 dlls/csx_sql/extra/include/mysql/heap.h create mode 100755 dlls/csx_sql/extra/include/mysql/m_ctype.h create mode 100755 dlls/csx_sql/extra/include/mysql/m_string.h create mode 100755 dlls/csx_sql/extra/include/mysql/md5.h create mode 100755 dlls/csx_sql/extra/include/mysql/merge.h create mode 100755 dlls/csx_sql/extra/include/mysql/my_aes.h create mode 100755 dlls/csx_sql/extra/include/mysql/my_alarm.h create mode 100755 dlls/csx_sql/extra/include/mysql/my_alloc.h create mode 100755 dlls/csx_sql/extra/include/mysql/my_base.h create mode 100755 dlls/csx_sql/extra/include/mysql/my_bitmap.h create mode 100755 dlls/csx_sql/extra/include/mysql/my_config.h create mode 100755 dlls/csx_sql/extra/include/mysql/my_dbug.h create mode 100755 dlls/csx_sql/extra/include/mysql/my_dir.h create mode 100755 dlls/csx_sql/extra/include/mysql/my_getopt.h create mode 100755 dlls/csx_sql/extra/include/mysql/my_global.h create mode 100755 dlls/csx_sql/extra/include/mysql/my_list.h create mode 100755 dlls/csx_sql/extra/include/mysql/my_net.h create mode 100755 dlls/csx_sql/extra/include/mysql/my_no_pthread.h create mode 100755 dlls/csx_sql/extra/include/mysql/my_nosys.h create mode 100755 dlls/csx_sql/extra/include/mysql/my_pthread.h create mode 100755 dlls/csx_sql/extra/include/mysql/my_semaphore.h create mode 100755 dlls/csx_sql/extra/include/mysql/my_sys.h create mode 100755 dlls/csx_sql/extra/include/mysql/my_tree.h create mode 100755 dlls/csx_sql/extra/include/mysql/myisam.h create mode 100755 dlls/csx_sql/extra/include/mysql/myisammrg.h create mode 100755 dlls/csx_sql/extra/include/mysql/myisampack.h create mode 100755 dlls/csx_sql/extra/include/mysql/mysql.h create mode 100755 dlls/csx_sql/extra/include/mysql/mysql_com.h create mode 100755 dlls/csx_sql/extra/include/mysql/mysql_embed.h create mode 100755 dlls/csx_sql/extra/include/mysql/mysql_version.h create mode 100755 dlls/csx_sql/extra/include/mysql/mysqld_error.h create mode 100755 dlls/csx_sql/extra/include/mysql/mysys_err.h create mode 100755 dlls/csx_sql/extra/include/mysql/nisam.h create mode 100755 dlls/csx_sql/extra/include/mysql/queues.h create mode 100755 dlls/csx_sql/extra/include/mysql/raid.h create mode 100755 dlls/csx_sql/extra/include/mysql/rijndael.h create mode 100755 dlls/csx_sql/extra/include/mysql/sha1.h create mode 100755 dlls/csx_sql/extra/include/mysql/sslopt-case.h create mode 100755 dlls/csx_sql/extra/include/mysql/sslopt-longopts.h create mode 100755 dlls/csx_sql/extra/include/mysql/sslopt-vars.h create mode 100755 dlls/csx_sql/extra/include/mysql/t_ctype.h create mode 100755 dlls/csx_sql/extra/include/mysql/thr_alarm.h create mode 100755 dlls/csx_sql/extra/include/mysql/thr_lock.h create mode 100755 dlls/csx_sql/extra/include/mysql/violite.h create mode 100755 dlls/csx_sql/extra/include/zlib.h create mode 100755 dlls/csx_sql/extra/lib_win32/mysqlclient.lib create mode 100755 dlls/csx_sql/extra/lib_win32/zlib.lib create mode 100755 dlls/csx_sql/meta_api.cpp create mode 100755 dlls/csx_sql/moduleconfig.h create mode 100755 dlls/csx_sql/msvc/csx.sln create mode 100755 dlls/csx_sql/msvc/csx.suo create mode 100755 dlls/csx_sql/msvc/csx.vcproj create mode 100755 dlls/csx_sql/rank.cpp create mode 100755 dlls/csx_sql/rank.h create mode 100755 dlls/csx_sql/usermsg.cpp diff --git a/dlls/csx_sql/CMisc.cpp b/dlls/csx_sql/CMisc.cpp new file mode 100755 index 00000000..bc664d8a --- /dev/null +++ b/dlls/csx_sql/CMisc.cpp @@ -0,0 +1,300 @@ + + +#include "CMisc.h" +#include "rank.h" + +// ***************************************************** +// class Grenades +// ***************************************************** +void Grenades::put( edict_t* grenade, float time, int type, CPlayer* player ) +{ + Obj* a = new Obj; + if ( a == 0 ) return; + a->player = player; + a->grenade = grenade; + a->time = gpGlobals->time + time; + a->type = type; + a->prev = 0; + a->next = head; + if ( head ) head->prev = a; + head = a; +} + +bool Grenades::find( edict_t* enemy, CPlayer** p, int* type ) +{ + bool found = false; + Obj* a = head; + while ( a ){ + if ( a->time > gpGlobals->time && !found ) { + if ( a->grenade == enemy ) { + found = true; + *p = a->player; + *type = a->type; + } + } + else { + Obj* next = a->next; + if (a->prev) a->prev->next = next; + else head = next; + if (next) next->prev = a->prev; + delete a; + a = next; + continue; + } + a = a->next; + } + + return found; +} + + + +void Grenades::clear() +{ + while(head){ + Obj* a = head->next; + delete head; + head = a; + } +} + +// ***************************************************** +// class CPlayer +// ***************************************************** + +void CPlayer::Disconnect(){ + + if ( ignoreBots(pEdict) || !isModuleActive() ) // ignore if he is bot and bots rank is disabled or module is paused + return; + + rank->updatePosition( &life ); + rank = 0; +} + +void CPlayer::PutInServer(){ + + if ( ignoreBots(pEdict) ) + return; + + restartStats(); + const char* name = STRING(pEdict->v.netname); + const char* unique = name; + switch((int)csstats_rank->value) { + case 1: + if ( (unique = GETPLAYERAUTHID(pEdict)) == 0 ) + unique = name; // failed to get authid + break; + case 2: + unique = ip; + } + rank = g_rank.findEntryInRank( unique , name ); +} + +void CPlayer::Connect(const char* address ){ + bot = IsBot(); + strcpy(ip,address); + rank = 0; + clearStats = 0.0f; +} + +void CPlayer::restartStats(bool all) +{ + if ( all ) memset(weapons,0,sizeof(weapons)); + memset(weaponsRnd,0,sizeof(weaponsRnd)); //DEC-Weapon (Round) stats + memset(attackers,0,sizeof(attackers)); + memset(victims,0,sizeof(victims)); + memset(&life,0,sizeof(life)); +} + +void CPlayer::Init( int pi, edict_t* pe ) +{ + pEdict = pe; + index = pi; + current = 0; + clearStats = 0.0f; + rank = 0; +} + +void CPlayer::saveKill(CPlayer* pVictim, int wweapon, int hhs, int ttk){ + + if ( ignoreBots(pEdict,pVictim->pEdict) ) + return; + + if ( pVictim->index == index ){ // killed self + pVictim->weapons[0].deaths++; + pVictim->life.deaths++; + pVictim->weaponsRnd[0].deaths++; // DEC-Weapon (round) stats + return; + } + + pVictim->attackers[index].name = weaponData[wweapon].name; + pVictim->attackers[index].kills++; + pVictim->attackers[index].hs += hhs; + pVictim->attackers[index].tks += ttk; + pVictim->attackers[0].kills++; + pVictim->attackers[0].hs += hhs; + pVictim->attackers[0].tks += ttk; + pVictim->weapons[pVictim->current].deaths++; + pVictim->weapons[0].deaths++; + pVictim->life.deaths++; + + + pVictim->weaponsRnd[pVictim->current].deaths++; // DEC-Weapon (round) stats + pVictim->weaponsRnd[0].deaths++; // DEC-Weapon (round) stats + + int vi = pVictim->index; + victims[vi].name = weaponData[wweapon].name; + victims[vi].deaths++; + victims[vi].hs += hhs; + victims[vi].tks += ttk; + victims[0].deaths++; + victims[0].hs += hhs; + victims[0].tks += ttk; + + weaponsRnd[wweapon].kills++; // DEC-Weapon (round) stats + weaponsRnd[wweapon].hs += hhs; // DEC-Weapon (round) stats + weaponsRnd[wweapon].tks += ttk; // DEC-Weapon (round) stats + weaponsRnd[0].kills++; // DEC-Weapon (round) stats + weaponsRnd[0].hs += hhs; // DEC-Weapon (round) stats + weaponsRnd[0].tks += ttk; // DEC-Weapon (round) stats + + weapons[wweapon].kills++; + weapons[wweapon].hs += hhs; + weapons[wweapon].tks += ttk; + weapons[0].kills++; + weapons[0].hs += hhs; + weapons[0].tks += ttk; + life.kills++; + life.hs += hhs; + life.tks += ttk; +} + +void CPlayer::saveHit(CPlayer* pVictim, int wweapon, int ddamage, int bbody){ + + if ( ignoreBots(pEdict,pVictim->pEdict) ) + return; + + if ( index == pVictim->index ) return; + + pVictim->attackers[index].hits++; + pVictim->attackers[index].damage += ddamage; + pVictim->attackers[index].bodyHits[bbody]++; + pVictim->attackers[0].hits++; + pVictim->attackers[0].damage += ddamage; + pVictim->attackers[0].bodyHits[bbody]++; + + + int vi = pVictim->index; + victims[vi].hits++; + victims[vi].damage += ddamage; + victims[vi].bodyHits[bbody]++; + victims[0].hits++; + victims[0].damage += ddamage; + victims[0].bodyHits[bbody]++; + + weaponsRnd[wweapon].hits++; // DEC-Weapon (round) stats + weaponsRnd[wweapon].damage += ddamage; // DEC-Weapon (round) stats + weaponsRnd[wweapon].bodyHits[bbody]++; // DEC-Weapon (round) stats + weaponsRnd[0].hits++; // DEC-Weapon (round) stats + weaponsRnd[0].damage += ddamage; // DEC-Weapon (round) stats + weaponsRnd[0].bodyHits[bbody]++; // DEC-Weapon (round) stats + + weapons[wweapon].hits++; + weapons[wweapon].damage += ddamage; + weapons[wweapon].bodyHits[bbody]++; + weapons[0].hits++; + weapons[0].damage += ddamage; + weapons[0].bodyHits[bbody]++; + + life.hits++; + life.damage += ddamage; + life.bodyHits[bbody]++; +} + + +void CPlayer::saveShot(int weapon){ + + if ( ignoreBots(pEdict) ) + return; + + victims[0].shots++; + weapons[weapon].shots++; + weapons[0].shots++; + life.shots++; + weaponsRnd[weapon].shots++; // DEC-Weapon (round) stats + weaponsRnd[0].shots++; // DEC-Weapon (round) stats +} + + +void CPlayer::saveBPlant(){ + life.bPlants++; +} + +void CPlayer::saveBExplode(){ + life.bExplosions++; +} + +void CPlayer::saveBDefusing(){ + life.bDefusions++; +} + +void CPlayer::saveBDefused(){ + life.bDefused++; +} + + +// ***************************************************** +// class Forward +// ***************************************************** + +void Forward::put( AMX *a , int i ){ + head = new AmxCall( a, i , head ); +} + + +void Forward::clear(){ + while ( head ) { + AmxCall* a = head->next; + delete head; + head = a; + } +} + +void Forward::exec(int p1,int p2,int p3,int p4,int p5,int p6){ + AmxCall* a = head; + while ( a ){ + MF_AmxExec(a->amx, NULL, a->iFunctionIdx, 6,p1, p2, p3, p4, p5, p6); + a = a->next; + } +} + +void Forward::exec(int p1,int p2,int p3,int p4,int p5){ + AmxCall* a = head; + while ( a ){ + MF_AmxExec(a->amx, NULL, a->iFunctionIdx, 5,p1, p2, p3, p4, p5); + a = a->next; + } +} + +void Forward::exec(int p1,int p2){ + AmxCall* a = head; + while ( a ){ + MF_AmxExec(a->amx, NULL, a->iFunctionIdx, 2,p1, p2); + a = a->next; + } +} + +// ***************************************************** + +bool ignoreBots (edict_t *pEnt, edict_t *pOther){ + if ( !rankBots && ( pEnt->v.flags & FL_FAKECLIENT || ( pOther && pOther->v.flags & FL_FAKECLIENT ) ) ) + return true; + return false; +} + +bool isModuleActive(){ + if ( !(int)CVAR_GET_FLOAT("csstats_pause") ) + return true; + return false; +} + diff --git a/dlls/csx_sql/CMisc.h b/dlls/csx_sql/CMisc.h new file mode 100755 index 00000000..1996f334 --- /dev/null +++ b/dlls/csx_sql/CMisc.h @@ -0,0 +1,116 @@ + + +#ifndef CMISC_H +#define CMISC_H + +#include "amxxmodule.h" +#include "CRank.h" + +#define MAX_CWEAPONS 6 + +#define CSW_HEGRENADE 4 +#define CSW_C4 6 +#define CSW_SMOKEGRENADE 9 +#define CSW_FLASHBANG 25 + +// ***************************************************** +// class CPlayer +// ***************************************************** + +struct CPlayer { + edict_t* pEdict; + char ip[32]; + int index; + int aiming; + int current; + bool bot; + float clearStats; + RankSystem::RankStats* rank; + + struct PlayerWeapon : Stats { + const char* name; + int ammo; + int clip; + }; + + PlayerWeapon weapons[MAX_WEAPONS+MAX_CWEAPONS]; + PlayerWeapon attackers[33]; + PlayerWeapon victims[33]; + Stats weaponsRnd[MAX_WEAPONS+MAX_CWEAPONS]; // DEC-Weapon (Round) stats + Stats life; + + int teamId; + + void Init( int pi, edict_t* pe ); + void Connect(const char* ip ); + void PutInServer(); + void Disconnect(); + void saveKill(CPlayer* pVictim, int weapon, int hs, int tk); + void saveHit(CPlayer* pVictim, int weapon, int damage, int aiming); + void saveShot(int weapon); + + void saveBPlant(); + void saveBExplode(); + void saveBDefusing(); + void saveBDefused(); + + void restartStats(bool all = true); + inline bool IsBot(){ + const char* auth= (*g_engfuncs.pfnGetPlayerAuthId)(pEdict); + return ( auth && !strcmp( auth , "BOT" ) ); + } + inline bool IsAlive(){ + return ((pEdict->v.deadflag==DEAD_NO)&&(pEdict->v.health>0)); + } +}; + +// ***************************************************** +// class Grenades +// ***************************************************** + +class Grenades +{ + struct Obj + { + CPlayer* player; + edict_t* grenade; + float time; + int type; + Obj* next; + Obj* prev; + } *head; + +public: + Grenades() { head = 0; } + ~Grenades() { clear(); } + void put( edict_t* grenade, float time, int type, CPlayer* player ); + bool find( edict_t* enemy, CPlayer** p, int* type ); + void clear(); +}; + +// ***************************************************** +// class Forward +// ***************************************************** + +class Forward +{ + struct AmxCall { + AMX *amx; + int iFunctionIdx; + AmxCall* next; + AmxCall( AMX *a , int i, AmxCall* n ): amx(a), iFunctionIdx(i), next(n) {} + } *head; +public: + Forward() { head = 0; } + ~Forward() { clear(); } + void clear(); + void put( AMX *a , int i ); + void exec(int p1,int p2,int p3,int p4,int p5,int p6); + void exec(int p1,int p2,int p3,int p4,int p5); + void exec(int p1,int p2); +}; + +#endif // CMISC_H + + + diff --git a/dlls/csx_sql/CRank.cpp b/dlls/csx_sql/CRank.cpp new file mode 100755 index 00000000..92ce3c61 --- /dev/null +++ b/dlls/csx_sql/CRank.cpp @@ -0,0 +1,306 @@ +#include "amxxmodule.h" +#include "CRank.h" +#include "rank.h" + +// ***************************************************** +// class Stats +// ***************************************************** +Stats::Stats(){ + hits = shots = damage = hs = tks = kills = deaths = bDefusions = bDefused = bPlants = bExplosions = 0; + memset( bodyHits , 0 ,sizeof( bodyHits ) ); +} +void Stats::commit(Stats* a){ + hits += a->hits; + shots += a->shots; + damage += a->damage; + hs += a->hs; + tks += a->tks; + kills += a->kills; + deaths += a->deaths; + + bDefusions += a->bDefusions; + bDefused += a->bDefused; + bPlants += a->bPlants; + bExplosions += a->bExplosions; + + for(int i = 1; i < 8; ++i) + bodyHits[i] += a->bodyHits[i]; +} + + +// ***************************************************** +// class RankSystem +// ***************************************************** +RankSystem::RankStats::RankStats( const char* uu, const char* nn, RankSystem* pp ) { + name = 0; + namelen = 0; + unique = 0; + uniquelen = 0; + score = 0; + parent = pp; + id = ++parent->rankNum; + next = prev = 0; + setName( nn ); + setUnique( uu ); +} + +RankSystem::RankStats::~RankStats() { + delete[] name; + delete[] unique; + --parent->rankNum; +} + +void RankSystem::RankStats::setName( const char* nn ) { + delete[] name; + namelen = strlen(nn) + 1; + name = new char[namelen]; + if ( name ) + strcpy( name , nn ); + else + namelen = 0; +} + +void RankSystem::RankStats::setUnique( const char* nn ) { + delete[] unique; + uniquelen = strlen(nn) + 1; + unique = new char[uniquelen]; + if ( unique ) + strcpy( unique , nn ); + else + uniquelen = 0; +} + +RankSystem::RankSystem() { + head = 0; + tail = 0; + rankNum = 0; + calc.code = 0; +} + +RankSystem::~RankSystem() { + clear(); +} + +void RankSystem::put_before( RankStats* a, RankStats* ptr ){ + a->next = ptr; + if ( ptr ){ + a->prev = ptr->prev; + ptr->prev = a; + } + else{ + a->prev = head; + head = a; + } + if ( a->prev ) a->prev->next = a; + else tail = a; +} + +void RankSystem::put_after( RankStats* a, RankStats* ptr ) { + a->prev = ptr; + if ( ptr ){ + a->next = ptr->next; + ptr->next = a; + } + else{ + a->next = tail; + tail = a; + } + if ( a->next ) a->next->prev = a; + else head = a; +} + +void RankSystem::unlink( RankStats* ptr ){ + if (ptr->prev) ptr->prev->next = ptr->next; + else tail = ptr->next; + if (ptr->next) ptr->next->prev = ptr->prev; + else head = ptr->prev; +} + +void RankSystem::clear(){ + while( tail ){ + head = tail->next; + delete tail; + tail = head; + } +} + + + +bool RankSystem::loadCalc(const char* filename, char* error) +{ + if ((MF_LoadAmxScript(&calc.amx,&calc.code,filename,error,0)!=AMX_ERR_NONE)|| + (MF_AmxAllot(&calc.amx, 8 , &calc.amxAddr1, &calc.physAddr1)!=AMX_ERR_NONE)|| + (MF_AmxAllot(&calc.amx, 8 , &calc.amxAddr2, &calc.physAddr2)!=AMX_ERR_NONE)|| + (MF_AmxFindPublic(&calc.amx,"get_score",&calc.func)!=AMX_ERR_NONE)){ + LOG_CONSOLE( PLID, "Couldn't load plugin (file \"%s\")",filename); + MF_UnloadAmxScript(&calc.amx, &calc.code); + return false; + } + return true; +} + +void RankSystem::unloadCalc() +{ + MF_UnloadAmxScript(&calc.amx , &calc.code); +} + +RankSystem::RankStats* RankSystem::findEntryInRank(const char* unique, const char* name ) +{ + RankStats* a = head; + + while ( a ) + { + if ( strcmp( a->getUnique() ,unique ) == 0 ) + return a; + + a = a->prev; + } + a = new RankStats( unique ,name,this ); + if ( a == 0 ) return 0; + put_after( a , 0 ); + return a; +} + +void RankSystem::updatePos( RankStats* rr , Stats* s ) +{ + rr->addStats( s ); + if ( calc.code ) { + calc.physAddr1[0] = rr->kills; + calc.physAddr1[1] = rr->deaths; + calc.physAddr1[2] = rr->hs; + calc.physAddr1[3] = rr->tks; + calc.physAddr1[4] = rr->shots; + calc.physAddr1[5] = rr->hits; + calc.physAddr1[6] = rr->damage; + + calc.physAddr1[7] = rr->bDefusions; + calc.physAddr1[8] = rr->bDefused; + calc.physAddr1[9] = rr->bPlants; + calc.physAddr1[10] = rr->bExplosions; + + for(int i = 1; i < 8; ++i) + calc.physAddr2[i] = rr->bodyHits[i]; + cell result = 0; + int err; + if ((err = MF_AmxExec(&calc.amx,&result, calc.func ,2,calc.amxAddr1,calc.amxAddr2 )) != AMX_ERR_NONE) + LOG_CONSOLE( PLID, "Run time error %d on line %ld (plugin \"%s\")", err,calc.amx.curline,LOCALINFO("csstats_score")); + rr->score = result; + } + else rr->score = rr->kills - rr->deaths; + + + RankStats* aa = rr->next; + while ( aa && (aa->score <= rr->score) ) { // try to nominate + rr->goUp(); + aa->goDown(); + aa = aa->next; // go to next rank + } + if ( aa != rr->next ) + { + unlink( rr ); + put_before( rr, aa ); + } + else + { + aa = rr->prev; + while ( aa && (aa->score > rr->score) ) { // go down + rr->goDown(); + aa->goUp(); + aa = aa->prev; // go to prev rank + } + if ( aa != rr->prev ){ + unlink( rr ); + put_after( rr, aa ); + } + } + +} + +void RankSystem::loadRank( const char* filename ) +{ + FILE *bfp = fopen( filename , "rb" ); + + if ( !bfp ) return; + + short int i = 0; + fread(&i, 1 , sizeof(short int) , bfp); + + if (i == RANK_VERSION) + { + Stats d; + char unique[64], name[64]; + fread(&i , 1, sizeof(short int), bfp); + + while( i ) + { + fread(name , i,sizeof(char) , bfp); + fread(&i , 1, sizeof(short int), bfp); + fread(unique , i,sizeof(char) , bfp); + fread(&d.tks, 1,sizeof(int), bfp); + fread(&d.damage, 1,sizeof(int), bfp); + fread(&d.deaths, 1,sizeof(int), bfp); + fread(&d.kills, 1,sizeof(int), bfp); + fread(&d.shots, 1,sizeof(int), bfp); + fread(&d.hits, 1,sizeof(int), bfp); + fread(&d.hs, 1,sizeof(int), bfp); + + fread(&d.bDefusions, 1,sizeof(int), bfp); + fread(&d.bDefused, 1,sizeof(int), bfp); + fread(&d.bPlants, 1,sizeof(int), bfp); + fread(&d.bExplosions, 1,sizeof(int), bfp); + + fread(d.bodyHits, 1,sizeof(d.bodyHits), bfp); + fread(&i , 1, sizeof(short int), bfp); + + RankSystem::RankStats* a = findEntryInRank( unique , name ); + + if ( a ) a->updatePosition( &d ); + } + } + fclose(bfp); +} + +void RankSystem::saveRank( const char* filename ) +{ + FILE *bfp = fopen(filename, "wb"); + + if ( !bfp ) return; + + short int i = RANK_VERSION; + + fwrite(&i, 1, sizeof(short int) , bfp); + + RankSystem::iterator a = front(); + + while ( a ) + { + if ( (*a).score != (1<<31) ) // score must be different than mincell + { + fwrite( &(*a).namelen , 1, sizeof(short int), bfp); + fwrite( (*a).name , (*a).namelen , sizeof(char) , bfp); + fwrite( &(*a).uniquelen , 1, sizeof(short int), bfp); + fwrite( (*a).unique , (*a).uniquelen , sizeof(char) , bfp); + fwrite( &(*a).tks, 1, sizeof(int), bfp); + fwrite( &(*a).damage, 1, sizeof(int), bfp); + fwrite( &(*a).deaths, 1, sizeof(int), bfp); + fwrite( &(*a).kills, 1, sizeof(int), bfp); + fwrite( &(*a).shots, 1, sizeof(int), bfp); + fwrite( &(*a).hits, 1, sizeof(int), bfp); + fwrite( &(*a).hs, 1, sizeof(int), bfp); + + fwrite( &(*a).bDefusions, 1, sizeof(int), bfp); + fwrite( &(*a).bDefused, 1, sizeof(int), bfp); + fwrite( &(*a).bPlants, 1, sizeof(int), bfp); + fwrite( &(*a).bExplosions, 1, sizeof(int), bfp); + + fwrite( (*a).bodyHits, 1, sizeof((*a).bodyHits), bfp); + } + + --a; + } + + i = 0; + fwrite( &i , 1, sizeof(short int), bfp); // null terminator + + fclose(bfp); +} diff --git a/dlls/csx_sql/CRank.h b/dlls/csx_sql/CRank.h new file mode 100755 index 00000000..afbbfdfc --- /dev/null +++ b/dlls/csx_sql/CRank.h @@ -0,0 +1,123 @@ + + +#ifndef CRANK_H +#define CRANK_H + +#define RANK_VERSION 11 + +#include "amxxmodule.h" + +// ***************************************************** +// class Stats +// ***************************************************** + +struct Stats { + int hits; + int shots; + int damage; + int hs; + int tks; + int kills; + int deaths; + int bodyHits[9]; //////////////////// + + // SiDLuke start + int bPlants; + int bExplosions; + int bDefusions; + int bDefused; + // SiDLuke end :D + + Stats(); + void commit(Stats* a); +}; + +// ***************************************************** +// class RankSystem +// ***************************************************** + +class RankSystem +{ +public: + class RankStats; + friend class RankStats; + class iterator; + + class RankStats : public Stats { + friend class RankSystem; + friend class iterator; + RankSystem* parent; + RankStats* next; + RankStats* prev; + char* unique; + short int uniquelen; + char* name; + short int namelen; + int score; + int id; + RankStats( const char* uu, const char* nn, RankSystem* pp ); + ~RankStats(); + void setUnique( const char* nn ); + inline void goDown() {++id;} + inline void goUp() {--id;} + inline void addStats(Stats* a) { commit( a ); } + public: + void setName( const char* nn ); + inline const char* getName() const { return name ? name : ""; } + inline const char* getUnique() const { return unique ? unique : ""; } + inline int getPosition() const { return id; } + inline void updatePosition( Stats* points ) { + parent->updatePos( this , points ); + } + }; + +private: + RankStats* head; + RankStats* tail; + int rankNum; + + struct scoreCalc{ + AMX amx; + void* code; + int func; + cell amxAddr1; + cell amxAddr2; + cell *physAddr1; + cell *physAddr2; + } calc; + + void put_before( RankStats* a, RankStats* ptr ); + void put_after( RankStats* a, RankStats* ptr ); + void unlink( RankStats* ptr ); + void updatePos( RankStats* r , Stats* s ); + +public: + + RankSystem(); + ~RankSystem(); + + void saveRank( const char* filename ); + void saveRankSql(); + void loadRank( const char* filename ); + RankStats* findEntryInRank(const char* unique, const char* name ); + bool loadCalc(const char* filename, char* error); + inline int getRankNum( ) const { return rankNum; } + void clear(); + void unloadCalc(); + + class iterator { + RankStats* ptr; + public: + iterator(RankStats* a): ptr(a){} + inline iterator& operator--() { ptr = ptr->prev; return *this;} + inline iterator& operator++() { ptr = ptr->next; return *this; } + inline RankStats& operator*() { return *ptr;} + operator bool () { return (ptr != 0); } + }; + + inline iterator front() { return iterator(head); } + inline iterator begin() { return iterator(tail); } +}; + + +#endif \ No newline at end of file diff --git a/dlls/csx_sql/CRank_sql.cpp b/dlls/csx_sql/CRank_sql.cpp new file mode 100755 index 00000000..10b872f3 --- /dev/null +++ b/dlls/csx_sql/CRank_sql.cpp @@ -0,0 +1,201 @@ +// The good stuff: http://dev.mysql.com/doc/mysql/en/mysql_query.html + +#include "amxxmodule.h" +#include "CRank.h" +#include "rank.h" + +#ifndef __linux__ +#define WINDOWS_LEAN_AND_MEAN +#include +#endif +#include +#include + +#include +#define MYSQL_QUERY_IS_A_OKAY 0 + +cvar_t init_csx_sqlstats_host = {"csx_sqlstats_ip", "127.0.0.1", FCVAR_SPONLY | FCVAR_PROTECTED}; +cvar_t init_csx_sqlstats_username = {"csx_sqlstats_username", "", FCVAR_SPONLY | FCVAR_PROTECTED}; +cvar_t init_csx_sqlstats_password = {"csx_sqlstats_password", "", FCVAR_SPONLY | FCVAR_PROTECTED}; +cvar_t init_csx_sqlstats_db = {"csx_sqlstats_db", "amxmodx_stats_cs", FCVAR_SPONLY | FCVAR_PROTECTED}; +cvar_t init_csx_sqlstats_table = {"csx_sqlstats_table", "cs", FCVAR_SPONLY | FCVAR_PROTECTED}; +cvar_t *csx_sqlstats_host; +cvar_t *csx_sqlstats_username; +cvar_t *csx_sqlstats_password; +cvar_t *csx_sqlstats_db; +cvar_t *csx_sqlstats_table; + +void OnMetaAttach_sql() { + CVAR_REGISTER(&init_csx_sqlstats_host); + CVAR_REGISTER(&init_csx_sqlstats_username); + CVAR_REGISTER(&init_csx_sqlstats_password); + CVAR_REGISTER(&init_csx_sqlstats_db); + CVAR_REGISTER(&init_csx_sqlstats_table); + + csx_sqlstats_host = CVAR_GET_POINTER(init_csx_sqlstats_host.name); + csx_sqlstats_username = CVAR_GET_POINTER(init_csx_sqlstats_username.name); + csx_sqlstats_password = CVAR_GET_POINTER(init_csx_sqlstats_password.name); + csx_sqlstats_db = CVAR_GET_POINTER(init_csx_sqlstats_db.name); + csx_sqlstats_table = CVAR_GET_POINTER(init_csx_sqlstats_table.name); +} + +int Error(MYSQL *mysql) +{ + if (mysql == NULL) + return 0; + + return mysql_errno(mysql); +} + +void RankSystem::saveRankSql() +{ + MF_PrintSrvConsole("[CSX Sql] Exporting players' statistics to SQL db..."); + clock_t startTime = clock(); + time_t now = time(NULL); + + MYSQL *mysql = NULL; + + mysql = mysql_init(NULL); + int port = 0, error = 0; + if (!mysql_real_connect(mysql, csx_sqlstats_host->string, csx_sqlstats_username->string, csx_sqlstats_password->string, NULL, port, NULL, 0)) { + error = Error(mysql); + if (error) { + MF_Log("DB Connection failed (%d): %s", error, mysql_error(mysql)); + mysql_close(mysql); + return; + } + } + + if (mysql_select_db(mysql, csx_sqlstats_db->string) != 0) { + error = Error(mysql); + if (error) { + MF_Log("DB Select DB failed (%d): %s", error, mysql_error(mysql)); + mysql_close(mysql); + return; + } + } + + // Query + char query[1024]; + int exportedRecords = 0; + + RankSystem::iterator a = front(); + + char *authid, *name; + int tks, damage, deaths, kills, shots, hits, hs, defusions, defused, plants, explosions, *bodyHits; + + while ( a ) + { + if ( (*a).score != (1<<31) ) // score must be different than mincell + { + authid = (*a).unique; + if (strcmp(authid, "BOT") == 0 || strcmp(authid, "STEAM_ID_PENDING") == 0) { + --a; + continue; + } + exportedRecords++; + + name = (*a).name; + tks = (*a).tks; + damage = (*a).damage; + deaths = (*a).deaths; + kills = (*a).kills; + shots = (*a).shots; + hits = (*a).hits; + hs = (*a).hs; + defusions = (*a).bDefusions; + defused = (*a).bDefused; + plants = (*a).bPlants; + explosions = (*a).bExplosions; + bodyHits = ((*a).bodyHits); + + _snprintf(query, 1023, "UPDATE `%s` SET `timestamp` = %d, `stats_name` = \"%s\", `stats_tks` = \"%d\", `stats_damage` = \"%d\", `stats_deaths` = \"%d\", `stats_frags` = \"%d\", `stats_shots` = \"%d\", `stats_hits` = \"%d\", `stats_hs` = \"%d\", `stats_defusions` = \"%d\", `stats_defused` = \"%d\", `stats_plants` = \"%d\", `stats_explosions` = \"%d\", `stats_bodyhits0` = \"%d\", `stats_bodyhits1` = \"%d\", `stats_bodyhits2` = \"%d\", `stats_bodyhits3` = \"%d\", `stats_bodyhits4` = \"%d\", `stats_bodyhits5` = \"%d\", `stats_bodyhits6` = \"%d\", `stats_bodyhits7` = \"%d\", `stats_bodyhits8` = \"%d\" WHERE `stats_authid` = \"%s\" LIMIT 1", + csx_sqlstats_table->string, + now, + name, + tks, + damage, + deaths, + kills, + shots, + hits, + hs, + defusions, + defused, + plants, + explosions, + bodyHits[0], + bodyHits[1], + bodyHits[2], + bodyHits[3], + bodyHits[4], + bodyHits[5], + bodyHits[6], + bodyHits[7], + bodyHits[8], + authid); + // + + int queryResult = mysql_query(mysql, query); + if (queryResult != MYSQL_QUERY_IS_A_OKAY) + { + error = Error(mysql); + MF_Log("DB Query Update failed (%d): %s", error, mysql_error(mysql)); + mysql_close(mysql); + return; + } + + if (mysql_affected_rows(mysql) == 0) { + // New player, do insert + _snprintf(query, 1023, "INSERT INTO `%s` (`timestamp`, `stats_authid`, `stats_name`, `stats_tks`, `stats_damage`, `stats_deaths`, `stats_frags`, `stats_shots`, `stats_hits`, `stats_hs`, `stats_defusions`, `stats_defused`, `stats_plants`, `stats_explosions`, `stats_bodyhits0`, `stats_bodyhits1`, `stats_bodyhits2`, `stats_bodyhits3`, `stats_bodyhits4`, `stats_bodyhits5`, `stats_bodyhits6`, `stats_bodyhits7`, `stats_bodyhits8`) VALUES (\"%d\", \"%s\", \"%s\", \"%d\", \"%d\", \"%d\", \"%d\", \"%d\", \"%d\", \"%d\", \"%d\", \"%d\", \"%d\", \"%d\", \"%d\", \"%d\", \"%d\", \"%d\", \"%d\", \"%d\", \"%d\", \"%d\", \"%d\")", + csx_sqlstats_table->string, + now, + + authid, + name, + + tks, + damage, + deaths, + kills, + shots, + + hits, + hs, + defusions, + defused, + plants, + + explosions, + + bodyHits[0], + bodyHits[1], + bodyHits[2], + bodyHits[3], + bodyHits[4], + bodyHits[5], + bodyHits[6], + bodyHits[7], + bodyHits[8] + ); + + int queryResult = mysql_query(mysql, query); + if (queryResult != MYSQL_QUERY_IS_A_OKAY) + { + error = Error(mysql); + MF_Log("DB Query Insert failed (%d): %s", error, mysql_error(mysql)); + mysql_close(mysql); + return; + } + } + } + + --a; + } + + // Disconnect + mysql_close(mysql); + + clock_t stopTime = clock(); + MF_PrintSrvConsole("...done! (exported %d records in %.2f seconds)\n", exportedRecords, (double)(stopTime - startTime) / (double)CLOCKS_PER_SEC, stopTime, startTime); +} diff --git a/dlls/csx_sql/CString.h b/dlls/csx_sql/CString.h new file mode 100755 index 00000000..7288eded --- /dev/null +++ b/dlls/csx_sql/CString.h @@ -0,0 +1,404 @@ +/* AMX Mod X +* +* by the AMX Mod X Development Team +* originally developed by OLO +* +* +* This program is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License as published by the +* Free Software Foundation; either version 2 of the License, or (at +* your option) any later version. +* +* This program is distributed in the hope that it will be useful, but +* WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software Foundation, +* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +* +* In addition, as a special exception, the author gives permission to +* link the code of this program with the Half-Life Game Engine ("HL +* Engine") and Modified Game Libraries ("MODs") developed by Valve, +* L.L.C ("Valve"). You must obey the GNU General Public License in all +* respects for all of the code used other than the HL Engine and MODs +* from Valve. If you modify this file, you may extend this exception +* to your version of the file, but you are not obligated to do so. If +* you do not wish to do so, delete this exception statement from your +* version. +*/ + +#ifndef _INCLUDE_CSTRING_H +#define _INCLUDE_CSTRING_H + +//by David "BAILOPAN" Anderson +class String +{ +public: + String() + { + v = NULL; + mSize = 0; + cSize = 0; + Grow(2); + assign(""); + } + + ~String() + { + if (v) + delete [] v; + } + + String(const char *src) + { + v = NULL; + mSize = 0; + cSize = 0; assign(src); + } + + String(String &src) + { + v = NULL; + mSize = 0; + cSize = 0; + assign(src.c_str()); + } + + const char *c_str() { return v?v:""; } + const char *c_str() const { return v?v:""; } + + void append(const char *t) + { + Grow(cSize + strlen(t) + 1); + strcat(v, t); + cSize = strlen(v); + } + + void append(const char c) + { + Grow(cSize + 2); + v[cSize] = c; + v[++cSize] = 0; + } + + void append(String &d) + { + const char *t = d.c_str(); + Grow(cSize + strlen(t)); + strcat(v, t); + cSize = strlen(v); + } + + void assign(const String &src) + { + assign(src.c_str()); + } + + void assign(const char *d) + { + if (!d) + { + Grow(1); + cSize = 0; + strcpy(v, ""); + return; + } + Grow(strlen(d)); + if (v) + { + strcpy(v, d); + cSize = strlen(v); + } else { + cSize = 0; + } + } + + void clear() + { + if (v) + { + v[0] = 0; + cSize = 0; + } + } + + int compare (const char *d) + { + if (v) { + if (d) { + return strcmp(v, d); + } else { + return strlen(v); + } + } else { + if (d) { + return strlen(d); + } else { + return 0; + } + } + } + + //Added this for amxx inclusion + bool empty() + { + if (!v || !cSize) + return true; + + return false; + } + + int size() + { + if (!v) + return 0; + return cSize; + } + + const char * _fread(FILE *fp) + { + Grow(512); + char * ret = fgets(v, 511, fp); + cSize = strlen(v); + return ret; + } + + int find(const char c, int index = 0) + { + if (!v) + return npos; + if (index >= (int)cSize || index < 0) + return npos; + unsigned int i = 0; + for (i=index; i=0; i--) + { + if (!is_space(v[i]) + || (is_space(v[i]) && i==0)) + { + erase(i+1, j); + break; + } + j++; + } + } + + if (cSize == 1) + { + if (is_space(v[0])) + { + clear(); + return; + } + } + } + + String & erase(unsigned int start, int num = npos) + { + if (!v) + return (*this); + unsigned int i = 0; + //check for bounds + if (num == npos || start+num > cSize-num+1) + num = cSize - start; + //do the erasing + bool copyflag = false; + for (i=0; i=start && i= cSize || !v) + return ns; + + if (num == npos) + { + num = cSize - index; + } else if (index+num >= cSize) { + num = cSize - index; + } + + unsigned int i = 0, j=0; + char *s = new char[cSize+1]; + + for (i=index; i= 65 && v[i] <= 90) + v[i] |= 32; + } + } + + String & operator = (const String &src) + { + assign(src); + return *this; + } + + String & operator = (const char *src) + { + assign(src); + return *this; + + } + + char operator [] (unsigned int index) + { + if (index > cSize) + { + return -1; + } else { + return v[index]; + } + } + + int at(int a) + { + if (a < 0 || a >= (int)cSize) + return -1; + + return v[a]; + } + + bool at(int at, char c) + { + if (at < 0 || at >= (int)cSize) + return false; + + v[at] = c; + + return true; + } + +private: + void Grow(unsigned int d) + { + if (d<1) + return; + if (d > mSize) + { + mSize = d + 16; // allocate a buffer + char *t = new char[d+1]; + if (v) { + strcpy(t, v); + t[cSize] = 0; + delete [] v; + } + v = t; + mSize = d; + } + } + + char *v; + unsigned int mSize; + unsigned int cSize; +public: + static const int npos = -1; +}; + +#endif //_INCLUDE_CSTRING_H diff --git a/dlls/csx_sql/CVector.h b/dlls/csx_sql/CVector.h new file mode 100755 index 00000000..05538f53 --- /dev/null +++ b/dlls/csx_sql/CVector.h @@ -0,0 +1,444 @@ +/* AMX Mod X +* +* by the AMX Mod X Development Team +* originally developed by OLO +* +* +* This program is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License as published by the +* Free Software Foundation; either version 2 of the License, or (at +* your option) any later version. +* +* This program is distributed in the hope that it will be useful, but +* WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software Foundation, +* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +* +* In addition, as a special exception, the author gives permission to +* link the code of this program with the Half-Life Game Engine ("HL +* Engine") and Modified Game Libraries ("MODs") developed by Valve, +* L.L.C ("Valve"). You must obey the GNU General Public License in all +* respects for all of the code used other than the HL Engine and MODs +* from Valve. If you modify this file, you may extend this exception +* to your version of the file, but you are not obligated to do so. If +* you do not wish to do so, delete this exception statement from your +* version. +*/ + +#ifndef __CVECTOR_H__ +#define __CVECTOR_H__ + +#include + +// Vector +template class CVector +{ + bool Grow() + { + // automatic grow + size_t newSize = m_Size * 2; + if (newSize == 0) + newSize = 8; // a good init value + T *newData = new T[newSize]; + if (!newData) + return false; + if (m_Data) + { + memcpy(newData, m_Data, m_Size * sizeof(T)); + delete [] m_Data; + } + m_Data = newData; + m_Size = newSize; + return true; + } + + bool GrowIfNeeded() + { + if (m_CurrentUsedSize >= m_Size) + return Grow(); + else + return true; + } + + bool ChangeSize(size_t size) + { + // change size + if (size == m_Size) + return true; + T *newData = new T[size]; + if (!newData) + return false; + if (m_Data) + { + memcpy(newData, m_Data, (m_Size < size) ? (m_Size * sizeof(T)) : (size * sizeof(T))); + delete [] m_Data; + } + if (m_Size < size) + m_CurrentSize = size; + m_Data = newData; + m_Size = size; + return true; + } + + void FreeMemIfPossible() + { + + } +protected: + T *m_Data; + size_t m_Size; + size_t m_CurrentUsedSize; + size_t m_CurrentSize; +public: + class iterator + { + protected: + T *m_Ptr; + public: + // constructors / destructors + iterator() + { + m_Ptr = NULL; + } + + iterator(T * ptr) + { + m_Ptr = ptr; + } + + // member functions + T * base() + { + return m_Ptr; + } + + const T * base() const + { + return m_Ptr; + } + + // operators + T & operator*() + { + return *m_Ptr; + } + + T * operator->() + { + return m_Ptr; + } + + iterator & operator++() // preincrement + { + ++m_Ptr; + return (*this); + } + + iterator operator++(int) // postincrement + { + iterator tmp = *this; + ++m_Ptr; + return tmp; + } + + iterator & operator--() // predecrement + { + --m_Ptr; + return (*this); + } + + iterator operator--(int) // postdecrememnt + { + iterator tmp = *this; + --m_Ptr; + return tmp; + } + + bool operator==(T * right) const + { + return (m_Ptr == right); + } + + bool operator==(const iterator & right) const + { + return (m_Ptr == right.m_Ptr); + } + + bool operator!=(T * right) const + { + return (m_Ptr != right); + } + + bool operator!=(const iterator & right) const + { + return (m_Ptr != right.m_Ptr); + } + + iterator & operator+=(size_t offset) + { + m_Ptr += offset; + return (*this); + } + + iterator & operator-=(size_t offset) + { + m_Ptr += offset; + return (*this); + } + + iterator operator+(size_t offset) const + { + iterator tmp(*this); + tmp.m_Ptr += offset; + return tmp; + } + + iterator operator-(size_t offset) const + { + iterator tmp(*this); + tmp.m_Ptr += offset; + return tmp; + } + + T & operator[](size_t offset) + { + return (*(*this + offset)); + } + + const T & operator[](size_t offset) const + { + return (*(*this + offset)); + } + + bool operator<(const iterator & right) const + { + return m_Ptr < right.m_Ptr; + } + + bool operator>(const iterator & right) const + { + return m_Ptr > right.m_Ptr; + } + + bool operator<=(const iterator & right) const + { + return m_Ptr <= right.m_Ptr; + } + + bool operator>=(const iterator & right) const + { + return m_Ptr >= right.m_Ptr; + } + + size_t operator-(const iterator & right) const + { + return m_Ptr - right.m_Ptr; + } + }; + + // constructors / destructors + CVector() + { + m_Size = 0; + m_CurrentUsedSize = 0; + m_Data = NULL; + } + + CVector(const CVector & other) + { + // copy data + m_Data = new T [other.m_Size]; + m_Size = other.m_Size; + m_CurrentUsedSize = other.m_CurrentUsedSize; + memcpy(m_Data, other.m_Data, m_CurrentUsedSize * sizeof(T)); + } + + ~CVector() + { + clear(); + } + + // interface + size_t size() const + { + return m_CurrentUsedSize; + } + + size_t capacity() const + { + return m_Size; + } + + iterator begin() + { + return iterator(m_Data); + } + + iterator end() + { + return iterator(m_Data + m_CurrentUsedSize); + } + + iterator iterAt(size_t pos) + { + if (pos > m_CurrentUsedSize) + assert(0); + return iterator(m_Data + pos); + } + + bool reserve(size_t newSize) + { + return ChangeSize(newSize); + } + + bool push_back(const T & elem) + { + ++m_CurrentUsedSize; + if (!GrowIfNeeded()) + { + --m_CurrentUsedSize; + return false; + } + + m_Data[m_CurrentUsedSize - 1] = elem; + return true; + } + + void pop_back() + { + --m_CurrentUsedSize; + if (m_CurrentUsedSize < 0) + m_CurrentUsedSize = 0; + // :TODO: free memory sometimes + } + + bool resize(size_t newSize) + { + if (!ChangeSize(newSize)) + return false; + FreeMemIfPossible(); + return true; + } + + bool empty() const + { + return (m_CurrentUsedSize == 0); + } + + T & at(size_t pos) + { + if (pos > m_CurrentUsedSize) + { + assert(0); + } + return m_Data[pos]; + } + + const T & at(size_t pos) const + { + if (pos > m_CurrentUsedSize) + { + assert(0); + } + return m_Data[pos]; + } + + T & operator[](size_t pos) + { + return at(pos); + } + + const T & operator[](size_t pos) const + { + return at(pos); + } + + T & front() + { + if (m_CurrentUsedSize < 1) + { + assert(0); + } + return m_Data[0]; + } + + const T & front() const + { + if (m_CurrentUsedSize < 1) + { + assert(0); + } + return m_Data[0]; + } + + T & back() + { + if (m_CurrentUsedSize < 1) + { + assert(0); + } + return m_Data[m_CurrentUsedSize - 1]; + } + + const T & back() const + { + if (m_CurrentUsedSize < 1) + { + assert(0); + } + return m_Data[m_CurrentUsedSize - 1]; + } + + bool insert(iterator where, const T & value) + { + // we have to insert before + // if it is begin, don't decrement + if (where != m_Data) + --where; + // validate iter + if (where < m_Data || where >= (m_Data + m_CurrentUsedSize)) + return false; + + ++m_CurrentUsedSize; + if (!GrowIfNeeded()) + { + --m_CurrentUsedSize; + return false; + } + + memmove(where.base() + 1, where.base(), m_CurrentUsedSize - (where - m_Data)); + memcpy(where.base(), &value, sizeof(T)); + return true; + } + + void erase(iterator where) + { + // validate iter + if (where < m_Data || where >= (m_Data + m_CurrentUsedSize)) + return false; + + if (m_CurrentUsedSize > 1) + { + // move + memmove(where.base(), where.base() + 1, m_CurrentUsedSize - 1); + } + + --m_CurrentUsedSize; + // :TODO: free memory sometimes + } + + void clear() + { + m_Size = 0; + m_CurrentUsedSize = 0; + delete [] m_Data; + m_Data = NULL; + } +}; + +#endif // __CVECTOR_H__ + diff --git a/dlls/csx_sql/Makefile b/dlls/csx_sql/Makefile new file mode 100755 index 00000000..3c0c58c3 --- /dev/null +++ b/dlls/csx_sql/Makefile @@ -0,0 +1,102 @@ +MODNAME = csx_amxx +SRCFILES = amxxmodule.cpp CMisc.cpp CRank.cpp meta_api.cpp rank.cpp usermsg.cpp + +EXTRA_LIBS_LINUX = +EXTRA_LIBS_WIN32 = +EXTRA_LIBDIRS_LINUX = -Lextra/lib_linux +EXTRA_LIBDIRS_WIN32 = -Lextra/lib_win32 + +EXTRA_INCLUDEDIRS = -Iextra/include -I../amx + +EXTRA_FLAGS = -Dstrcmpi=strcasecmp + +AMXDIR=../amx +SDKSRC=../sdk +METADIR=../metamod + +OBJDIR_LINUX=obj.linux +OBJDIR_WIN32=obj.win32 +SRCDIR=. + +ifdef windir + OS=WIN32 +else + OS=LINUX +endif + +CC_LINUX=gcc +ifeq "$(OS)" "WIN32" + CC_WIN32=gcc + LD_WINDLL=dllwrap + DEFAULT=win32 + CLEAN=clean_win32 +else + CC_WIN32=/usr/local/cross-tools/i386-mingw32msvc/bin/gcc + LD_WINDLL=/usr/local/cross-tools/bin/i386-mingw32msvc-dllwrap + DEFAULT=linux win32 + CLEAN=clean_both +endif + + +LIBFILE_LINUX = $(MODNAME)_i386.so +LIBFILE_WIN32 = $(MODNAME).dll +TARGET_LINUX = $(OBJDIR_LINUX)/$(LIBFILE_LINUX) +TARGET_WIN32 = $(OBJDIR_WIN32)/$(LIBFILE_WIN32) + +FILES_ALL = *.cpp *.h [A-Z]* *.rc +ifeq "$(OS)" "LINUX" + ASRCFILES := $(shell ls -t $(SRCFILES)) +else + ASRCFILES := $(shell dir /b) +endif +OBJ_LINUX := $(SRCFILES:%.cpp=$(OBJDIR_LINUX)/%.o) +OBJ_WIN32 := $(SRCFILES:%.cpp=$(OBJDIR_WIN32)/%.o) + +CCOPT = -march=i586 -O6 -ffast-math -funroll-loops \ + -fomit-frame-pointer -fexpensive-optimizations -malign-loops=2 \ + -malign-jumps=2 -malign-functions=2 -s -DNDEBUG + +INCLUDEDIRS=-I../curl/include -I$(SRCDIR) -I$(AMXDIR) -I$(METADIR) -I$(SDKSRC)/engine -I$(SDKSRC)/common -I$(SDKSRC)/dlls -I$(SDKSRC) $(EXTRA_INCLUDEDIRS) +CFLAGS=-Wall -Wno-unknown-pragmas +ODEF = -DOPT_TYPE=\"optimized\" +CFLAGS:=$(CCOPT) $(CFLAGS) $(ODEF) $(EXTRA_FLAGS) + +DO_CC_LINUX=$(CC_LINUX) $(CFLAGS) -fPIC $(INCLUDEDIRS) -o $@ -c $< +DO_CC_WIN32=$(CC_WIN32) $(CFLAGS) $(INCLUDEDIRS) -o $@ -c $< +LINK_LINUX=$(CC_LINUX) $(CFLAGS) -shared -ldl -lm $(OBJ_LINUX) $(EXTRA_LIBDIRS_LINUX) $(EXTRA_LIBS_LINUX) -o $@ +LINK_WIN32=$(LD_WINDLL) -mwindows --add-stdcall-alias $(OBJ_WIN32) $(EXTRA_LIBDIRS_WIN32) $(EXTRA_LIBS_WIN32) -o $@ + +$(OBJDIR_LINUX)/%.o: $(SRCDIR)/%.cpp + $(DO_CC_LINUX) + +$(OBJDIR_WIN32)/%.o: $(SRCDIR)/%.cpp + $(DO_CC_WIN32) + +default: $(DEFAULT) + +$(TARGET_LINUX): $(OBJDIR_LINUX) $(OBJ_LINUX) + $(LINK_LINUX) + +$(TARGET_WIN32): $(OBJDIR_WIN32) $(OBJ_WIN32) + $(LINK_WIN32) + +$(OBJDIR_LINUX): + mkdir $@ + +$(OBJDIR_WIN32): + mkdir $@ + +win32: $(TARGET_WIN32) + +linux: $(TARGET_LINUX) + +clean: $(CLEAN) + +clean_both: + -rm -f $(OBJDIR_LINUX)/* + -rm -f $(OBJDIR_WIN32)/* + +clean_win32: + del /q $(OBJDIR_WIN32) + + diff --git a/dlls/csx_sql/Makefile.pl b/dlls/csx_sql/Makefile.pl new file mode 100755 index 00000000..c695d1b1 --- /dev/null +++ b/dlls/csx_sql/Makefile.pl @@ -0,0 +1,178 @@ +#!/usr/bin/perl +#(C)2004 AMX Mod X Development Team +# by David "BAILOPAN" Anderson + +# output will occur in bin.x.proc +# where x is debug or opt and proc is ix86 or amd64 +# You must use this script from the project src dir + +#options = +# debug - enable gdb debugging +# amd64 - compile for AMD64 +# proc=ix86 - assumed not amd64 +# clean - clean the specifications above + +$PROJECT = "csx_amxx"; +$sdk = "../../../hlsdk/SourceCode"; +$mm = "../../../metamod/metamod"; +$gccf = "gcc"; + +@CPP_SOURCE_FILES = ("amxxmodule.cpp", "CMisc.cpp", "usermsg.cpp", "meta_api.cpp", "rank.cpp", "CRank.cpp"); + +@C_SOURCE_FILES = (); +my %OPTIONS, %OPT; + +$OPT{"debug"} = "-g -ggdb"; +$OPT{"opt"} = "-O2 -ffast-math -funroll-loops -fomit-frame-pointer -s -DNDEBUG -Wall -Wno-unknown-pragmas -DOPT_TYPE=\"optimized\" -fno-exceptions -fno-rtti"; + +$OPTIONS{"include"} = "-I$sdk -I. -I$mm -I$sdk/engine -I$sdk/common -I$sdk/pm_shared -I$sdk/dlls"; + +while ($cmd = shift) +{ + if ($cmd =~ /amd64/) { + $OPTIONS{"amd64"} = 1; + } elsif ($cmd =~ /debug/) { + $OPTIONS{"debug"} = 1; + } elsif ($cmd =~ /proc=i(\d)86/) { + $proc = $1; + if ($OPTIONS{"amd64"}) + { + die "You cannot compile for i".$proc."86 and AMD64.\n"; + } else { + $OPTIONS{"proc"} = "i".$proc."86"; + } + } elsif ($cmd =~ /clean/) { + $OPTIONS{"clean"} = 1; + } +} + +$gcc = `$gccf --version`; +if ($gcc =~ /2\.9/) +{ + $OPT{"opt"} .= " -malign-loops=2 -malign-jumps=2 -malign-functions=2"; +} else { + $OPT{"opt"} .= " -falign-loops=2 -falign-jumps=2 -falign-functions=2"; +} + +if ($OPTIONS{"debug"}) +{ + $cflags = $OPT{"debug"}; +} else { + if (!$OPTIONS{"amd64"}) + { + $proc = $OPTIONS{"proc"}; + if (!$proc) + { + $proc = 3; + } + $cflags = "-march=i".$proc."86 ".$OPT{"opt"}; + } else { + $cflags = $OPT{"opt"}; + } +} + +if ($OPTIONS{"amd64"}) +{ + $cflags .= " -m64 -DHAVE_I64 -DSMALL_CELL_SIZE=64 $cflags"; +} + +if ($OPTIONS{"debug"}) +{ + $outdir = "bin.debug"; +} else { + $outdir = "bin.opt"; +} + +if ($OPTIONS{"amd64"}) +{ + $outdir .= ".amd64"; + $bin = $PROJECT."_amd64.so"; +} else { + $proc = $OPTIONS{"proc"}; + if ($proc) + { + $outdir .= ".i".$proc."86"; + $bin = $PROJECT."_i".$proc."86.so"; + } else { + $outdir .= ".i386"; + $bin = $PROJECT."_i386.so"; + } +} + +unlink("$outdir/$bin"); +if ($OPTIONS{"clean"}) +{ + `rm $outdir/*.o`; + die("Project cleaned.\n"); +} + +#create the dirs +#build link list +my @LINK; +for ($i=0; $i<=$#CPP_SOURCE_FILES; $i++) +{ + $file = $CPP_SOURCE_FILES[$i]; + $file =~ s/\.cpp/\.o/; + push(@LINK, $outdir."/".$file); +} +for ($i=0; $i<=$#C_SOURCE_FILES; $i++) +{ + $file = $C_SOURCE_FILES[$i]; + $file =~ s/\.c/\.o/; + push(@LINK, $outdir."/".$file); +} + +if (!(-d $outdir)) +{ + mkdir($outdir); +} + +$inc = $OPTIONS{"include"}; + +for ($i=0; $i<=$#CPP_SOURCE_FILES; $i++) +{ + $file = $CPP_SOURCE_FILES[$i]; + $ofile = $file; + $ofile =~ s/\.cpp/\.o/; + $ofile = "$outdir/$ofile"; + $gcc = "$gccf $cflags -Dstrcmpi=strcasecmp -fPIC $inc -c $file -o $ofile"; + if (-e $ofile) + { + $file_time = (stat($file))[9]; + $ofile_time = (stat($ofile))[9]; + if ($file_time > $ofile_time) + { + print "$gcc\n"; + `$gcc`; + } + } else { + print "$gcc\n"; + `$gcc`; + } +} + +for ($i=0; $i<=$#CPP_SOURCE_FILES; $i++) +{ + $file = $C_SOURCE_FILES[$i]; + $ofile = $file; + $ofile =~ s/\.c/\.o/; + $ofile = "$outdir/$ofile"; + $gcc = "cc $cflags -Dstrcmpi=strcasecmp -fPIC $inc -c $file -o $ofile"; + if (-e $ofile) + { + $file_time = (stat($file))[9]; + $ofile_time = (stat($ofile))[9]; + if ($file_time > $ofile_time) + { + print "$gcc\n"; + `$gcc`; + } + } else { + print "$gcc\n"; + `$gcc`; + } +} + +$gcc = "$gccf $cflags -shared -ldl -lm @LINK -o $outdir/$bin"; +print "$gcc\n"; +`$gcc`; diff --git a/dlls/csx_sql/amxxmodule.cpp b/dlls/csx_sql/amxxmodule.cpp new file mode 100755 index 00000000..5ade3d43 --- /dev/null +++ b/dlls/csx_sql/amxxmodule.cpp @@ -0,0 +1,3047 @@ +/* AMX Mod X +* +* by the AMX Mod X Development Team +* originally developed by OLO +* +* Parts Copyright (C) 2001-2003 Will Day +* +* This program is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License as published by the +* Free Software Foundation; either version 2 of the License, or (at +* your option) any later version. +* +* This program is distributed in the hope that it will be useful, but +* WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software Foundation, +* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +* +* In addition, as a special exception, the author gives permission to +* link the code of this program with the Half-Life Game Engine ("HL +* Engine") and Modified Game Libraries ("MODs") developed by Valve, +* L.L.C ("Valve"). You must obey the GNU General Public License in all +* respects for all of the code used other than the HL Engine and MODs +* from Valve. If you modify this file, you may extend this exception +* to your version of the file, but you are not obligated to do so. If +* you do not wish to do so, delete this exception statement from your +* version. +* +* Description: AMX Mod X Module Interface Functions +*/ + +#include +#include +#include +#include +#include +#include "amxxmodule.h" + +/************* METAMOD SUPPORT *************/ +#ifdef USE_METAMOD + +enginefuncs_t g_engfuncs; +globalvars_t *gpGlobals; + + + +DLL_FUNCTIONS *g_pFunctionTable; +DLL_FUNCTIONS *g_pFunctionTable_Post; +enginefuncs_t *g_pengfuncsTable; +enginefuncs_t *g_pengfuncsTable_Post; +NEW_DLL_FUNCTIONS *g_pNewFunctionsTable; +NEW_DLL_FUNCTIONS *g_pNewFunctionsTable_Post; + + +// GetEntityAPI2 functions +static DLL_FUNCTIONS g_EntityAPI_Table = +{ +#ifdef FN_GameDLLInit + FN_GameDLLInit, +#else + NULL, +#endif +#ifdef FN_DispatchSpawn + FN_DispatchSpawn, +#else + NULL, +#endif +#ifdef FN_DispatchThink + FN_DispatchThink, +#else + NULL, +#endif +#ifdef FN_DispatchUse + FN_DispatchUse, +#else + NULL, +#endif +#ifdef FN_DispatchTouch + FN_DispatchTouch, +#else + NULL, +#endif +#ifdef FN_DispatchBlocked + FN_DispatchBlocked, +#else + NULL, +#endif +#ifdef FN_DispatchKeyValue + FN_DispatchKeyValue, +#else + NULL, +#endif +#ifdef FN_DispatchSave + FN_DispatchSave, +#else + NULL, +#endif +#ifdef FN_DispatchRestore + FN_DispatchRestore, +#else + NULL, +#endif +#ifdef FN_DispatchObjectCollsionBox + FN_DispatchObjectCollsionBox, +#else + NULL, +#endif +#ifdef FN_SaveWriteFields + FN_SaveWriteFields, +#else + NULL, +#endif +#ifdef FN_SaveReadFields + FN_SaveReadFields, +#else + NULL, +#endif +#ifdef FN_SaveGlobalState + FN_SaveGlobalState, +#else + NULL, +#endif +#ifdef FN_RestoreGlobalState + FN_RestoreGlobalState, +#else + NULL, +#endif +#ifdef FN_ResetGlobalState + FN_ResetGlobalState, +#else + NULL, +#endif +#ifdef FN_ClientConnect + FN_ClientConnect, +#else + NULL, +#endif +#ifdef FN_ClientDisconnect + FN_ClientDisconnect, +#else + NULL, +#endif +#ifdef FN_ClientKill + FN_ClientKill, +#else + NULL, +#endif +#ifdef FN_ClientPutInServer + FN_ClientPutInServer, +#else + NULL, +#endif +#ifdef FN_ClientCommand + FN_ClientCommand, +#else + NULL, +#endif +#ifdef FN_ClientUserInfoChanged + FN_ClientUserInfoChanged, +#else + NULL, +#endif +#ifdef FN_ServerActivate + FN_ServerActivate, +#else + NULL, +#endif +#ifdef FN_ServerDeactivate + FN_ServerDeactivate, +#else + NULL, +#endif +#ifdef FN_PlayerPreThink + FN_PlayerPreThink, +#else + NULL, +#endif +#ifdef FN_PlayerPostThink + FN_PlayerPostThink, +#else + NULL, +#endif +#ifdef FN_StartFrame + FN_StartFrame, +#else + NULL, +#endif +#ifdef FN_ParmsNewLevel + FN_ParmsNewLevel, +#else + NULL, +#endif +#ifdef FN_ParmsChangeLevel + FN_ParmsChangeLevel, +#else + NULL, +#endif +#ifdef FN_GetGameDescription + FN_GetGameDescription, +#else + NULL, +#endif +#ifdef FN_PlayerCustomization + FN_PlayerCustomization, +#else + NULL, +#endif +#ifdef FN_SpectatorConnect + FN_SpectatorConnect, +#else + NULL, +#endif +#ifdef FN_SpectatorDisconnect + FN_SpectatorDisconnect, +#else + NULL, +#endif +#ifdef FN_SpectatorThink + FN_SpectatorThink, +#else + NULL, +#endif +#ifdef FN_Sys_Error + FN_Sys_Error, +#else + NULL, +#endif +#ifdef FN_PM_Move + FN_PM_Move, +#else + NULL, +#endif +#ifdef FN_PM_Init + FN_PM_Init, +#else + NULL, +#endif +#ifdef FN_PM_FindTextureType + FN_PM_FindTextureType, +#else + NULL, +#endif +#ifdef FN_SetupVisibility + FN_SetupVisibility, +#else + NULL, +#endif +#ifdef FN_UpdateClientData + FN_UpdateClientData, +#else + NULL, +#endif +#ifdef FN_AddToFullPack + FN_AddToFullPack, +#else + NULL, +#endif +#ifdef FN_CreateBaseline + FN_CreateBaseline, +#else + NULL, +#endif +#ifdef FN_RegisterEncoders + FN_RegisterEncoders, +#else + NULL, +#endif +#ifdef FN_GetWeaponData + FN_GetWeaponData, +#else + NULL, +#endif +#ifdef FN_CmdStart + FN_CmdStart, +#else + NULL, +#endif +#ifdef FN_CmdEnd + FN_CmdEnd, +#else + NULL, +#endif +#ifdef FN_ConnectionlessPacket + FN_ConnectionlessPacket, +#else + NULL, +#endif +#ifdef FN_GetHullBounds + FN_GetHullBounds, +#else + NULL, +#endif +#ifdef FN_CreateInstancedBaselines + FN_CreateInstancedBaselines, +#else + NULL, +#endif +#ifdef FN_InconsistentFile + FN_InconsistentFile, +#else + NULL, +#endif +#ifdef FN_AllowLagCompensation + FN_AllowLagCompensation +#else + NULL +#endif +}; // g_EntityAPI2_Table + +// GetEntityAPI2_Post functions +static DLL_FUNCTIONS g_EntityAPI_Post_Table = +{ +#ifdef FN_GameDLLInit_Post + FN_GameDLLInit_Post, +#else + NULL, +#endif +#ifdef FN_DispatchSpawn_Post + FN_DispatchSpawn_Post, +#else + NULL, +#endif +#ifdef FN_DispatchThink_Post + FN_DispatchThink_Post, +#else + NULL, +#endif +#ifdef FN_DispatchUse_Post + FN_DispatchUse_Post, +#else + NULL, +#endif +#ifdef FN_DispatchTouch_Post + FN_DispatchTouch_Post, +#else + NULL, +#endif +#ifdef FN_DispatchBlocked_Post + FN_DispatchBlocked_Post, +#else + NULL, +#endif +#ifdef FN_DispatchKeyValue_Post + FN_DispatchKeyValue_Post, +#else + NULL, +#endif +#ifdef FN_DispatchSave_Post + FN_DispatchSave_Post, +#else + NULL, +#endif +#ifdef FN_DispatchRestore_Post + FN_DispatchRestore_Post, +#else + NULL, +#endif +#ifdef FN_DispatchObjectCollsionBox_Post + FN_DispatchObjectCollsionBox_Post, +#else + NULL, +#endif +#ifdef FN_SaveWriteFields_Post + FN_SaveWriteFields_Post, +#else + NULL, +#endif +#ifdef FN_SaveReadFields_Post + FN_SaveReadFields_Post, +#else + NULL, +#endif +#ifdef FN_SaveGlobalState_Post + FN_SaveGlobalState_Post, +#else + NULL, +#endif +#ifdef FN_RestoreGlobalState_Post + FN_RestoreGlobalState_Post, +#else + NULL, +#endif +#ifdef FN_ResetGlobalState_Post + FN_ResetGlobalState_Post, +#else + NULL, +#endif +#ifdef FN_ClientConnect_Post + FN_ClientConnect_Post, +#else + NULL, +#endif +#ifdef FN_ClientDisconnect_Post + FN_ClientDisconnect_Post, +#else + NULL, +#endif +#ifdef FN_ClientKill_Post + FN_ClientKill_Post, +#else + NULL, +#endif +#ifdef FN_ClientPutInServer_Post + FN_ClientPutInServer_Post, +#else + NULL, +#endif +#ifdef FN_ClientCommand_Post + FN_ClientCommand_Post, +#else + NULL, +#endif +#ifdef FN_ClientUserInfoChanged_Post + FN_ClientUserInfoChanged_Post, +#else + NULL, +#endif +#ifdef FN_ServerActivate_Post + FN_ServerActivate_Post, +#else + NULL, +#endif +#ifdef FN_ServerDeactivate_Post + FN_ServerDeactivate_Post, +#else + NULL, +#endif +#ifdef FN_PlayerPreThink_Post + FN_PlayerPreThink_Post, +#else + NULL, +#endif +#ifdef FN_PlayerPostThink_Post + FN_PlayerPostThink_Post, +#else + NULL, +#endif +#ifdef FN_StartFrame_Post + FN_StartFrame_Post, +#else + NULL, +#endif +#ifdef FN_ParmsNewLevel_Post + FN_ParmsNewLevel_Post, +#else + NULL, +#endif +#ifdef FN_ParmsChangeLevel_Post + FN_ParmsChangeLevel_Post, +#else + NULL, +#endif +#ifdef FN_GetGameDescription_Post + FN_GetGameDescription_Post, +#else + NULL, +#endif +#ifdef FN_PlayerCustomization_Post + FN_PlayerCustomization_Post, +#else + NULL, +#endif +#ifdef FN_SpectatorConnect_Post + FN_SpectatorConnect_Post, +#else + NULL, +#endif +#ifdef FN_SpectatorDisconnect_Post + FN_SpectatorDisconnect_Post, +#else + NULL, +#endif +#ifdef FN_SpectatorThink_Post + FN_SpectatorThink_Post, +#else + NULL, +#endif +#ifdef FN_Sys_Error_Post + FN_Sys_Error_Post, +#else + NULL, +#endif +#ifdef FN_PM_Move_Post + FN_PM_Move_Post, +#else + NULL, +#endif +#ifdef FN_PM_Init_Post + FN_PM_Init_Post, +#else + NULL, +#endif +#ifdef FN_PM_FindTextureType_Post + FN_PM_FindTextureType_Post, +#else + NULL, +#endif +#ifdef FN_SetupVisibility_Post + FN_SetupVisibility_Post, +#else + NULL, +#endif +#ifdef FN_UpdateClientData_Post + FN_UpdateClientData_Post, +#else + NULL, +#endif +#ifdef FN_AddToFullPack_Post + FN_AddToFullPack_Post, +#else + NULL, +#endif +#ifdef FN_CreateBaseline_Post + FN_CreateBaseline_Post, +#else + NULL, +#endif +#ifdef FN_RegisterEncoders_Post + FN_RegisterEncoders_Post, +#else + NULL, +#endif +#ifdef FN_GetWeaponData_Post + FN_GetWeaponData_Post, +#else + NULL, +#endif +#ifdef FN_CmdStart_Post + FN_CmdStart_Post, +#else + NULL, +#endif +#ifdef FN_CmdEnd_Post + FN_CmdEnd_Post, +#else + NULL, +#endif +#ifdef FN_ConnectionlessPacket_Post + FN_ConnectionlessPacket_Post, +#else + NULL, +#endif +#ifdef FN_GetHullBounds_Post + FN_GetHullBounds_Post, +#else + NULL, +#endif +#ifdef FN_CreateInstancedBaselines_Post + FN_CreateInstancedBaselines_Post, +#else + NULL, +#endif +#ifdef FN_InconsistentFile_Post + FN_InconsistentFile_Post, +#else + NULL, +#endif +#ifdef FN_AllowLagCompensation + FN_AllowLagCompensation, +#else + NULL, +#endif +}; // g_EntityAPI2_Table + +static enginefuncs_t g_EngineFuncs_Table = +{ +#ifdef FN_PrecacheModel + FN_PrecacheModel, +#else + NULL, +#endif +#ifdef FN_PrecacheSound + FN_PrecacheSound, +#else + NULL, +#endif +#ifdef FN_SetModel + FN_SetModel, +#else + NULL, +#endif +#ifdef FN_ModelIndex + FN_ModelIndex, +#else + NULL, +#endif +#ifdef FN_ModelFrames + FN_ModelFrames, +#else + NULL, +#endif +#ifdef FN_SetSize + FN_SetSize, +#else + NULL, +#endif +#ifdef FN_ChangeLevel + FN_ChangeLevel, +#else + NULL, +#endif +#ifdef FN_GetSpawnParms + FN_GetSpawnParms, +#else + NULL, +#endif +#ifdef FN_SaveSpawnParms + FN_SaveSpawnParms, +#else + NULL, +#endif +#ifdef FN_VecToYaw + FN_VecToYaw, +#else + NULL, +#endif +#ifdef FN_VecToAngles + FN_VecToAngles, +#else + NULL, +#endif +#ifdef FN_MoveToOrigin + FN_MoveToOrigin, +#else + NULL, +#endif +#ifdef FN_ChangeYaw + FN_ChangeYaw, +#else + NULL, +#endif +#ifdef FN_ChangePitch + FN_ChangePitch, +#else + NULL, +#endif +#ifdef FN_FindEntityByString + FN_FindEntityByString, +#else + NULL, +#endif +#ifdef FN_GetEntityIllum + FN_GetEntityIllum, +#else + NULL, +#endif +#ifdef FN_FindEntityInSphere + FN_FindEntityInSphere, +#else + NULL, +#endif +#ifdef FN_FindClientInPVS + FN_FindClientInPVS, +#else + NULL, +#endif +#ifdef FN_EntitiesInPVS + FN_EntitiesInPVS, +#else + NULL, +#endif +#ifdef FN_MakeVectors + FN_MakeVectors, +#else + NULL, +#endif +#ifdef FN_AngleVectors + FN_AngleVectors, +#else + NULL, +#endif +#ifdef FN_CreateEntity + FN_CreateEntity, +#else + NULL, +#endif +#ifdef FN_RemoveEntity + FN_RemoveEntity, +#else + NULL, +#endif +#ifdef FN_CreateNamedEntity + FN_CreateNamedEntity, +#else + NULL, +#endif +#ifdef FN_MakeStatic + FN_MakeStatic, +#else + NULL, +#endif +#ifdef FN_EntIsOnFloor + FN_EntIsOnFloor, +#else + NULL, +#endif +#ifdef FN_DropToFloor + FN_DropToFloor, +#else + NULL, +#endif +#ifdef FN_WalkMove + FN_WalkMove, +#else + NULL, +#endif +#ifdef FN_SetOrigin + FN_SetOrigin, +#else + NULL, +#endif +#ifdef FN_EmitSound + FN_EmitSound, +#else + NULL, +#endif +#ifdef FN_EmitAmbientSound + FN_EmitAmbientSound, +#else + NULL, +#endif +#ifdef FN_TraceLine + FN_TraceLine, +#else + NULL, +#endif +#ifdef FN_TraceToss + FN_TraceToss, +#else + NULL, +#endif +#ifdef FN_TraceMonsterHull + FN_TraceMonsterHull, +#else + NULL, +#endif +#ifdef FN_TraceHull + FN_TraceHull, +#else + NULL, +#endif +#ifdef FN_TraceModel + FN_TraceModel, +#else + NULL, +#endif +#ifdef FN_TraceTexture + FN_TraceTexture, +#else + NULL, +#endif +#ifdef FN_TraceSphere + FN_TraceSphere, +#else + NULL, +#endif +#ifdef FN_GetAimVector + FN_GetAimVector, +#else + NULL, +#endif +#ifdef FN_ServerCommand + FN_ServerCommand, +#else + NULL, +#endif +#ifdef FN_ServerExecute + FN_ServerExecute, +#else + NULL, +#endif +#ifdef FN_engClientCommand + FN_engClientCommand, +#else + NULL, +#endif +#ifdef FN_ParticleEffect + FN_ParticleEffect, +#else + NULL, +#endif +#ifdef FN_LightStyle + FN_LightStyle, +#else + NULL, +#endif +#ifdef FN_DecalIndex + FN_DecalIndex, +#else + NULL, +#endif +#ifdef FN_PointContents + FN_PointContents, +#else + NULL, +#endif +#ifdef FN_MessageBegin + FN_MessageBegin, +#else + NULL, +#endif +#ifdef FN_MessageEnd + FN_MessageEnd, +#else + NULL, +#endif +#ifdef FN_WriteByte + FN_WriteByte, +#else + NULL, +#endif +#ifdef FN_WriteChar + FN_WriteChar, +#else + NULL, +#endif +#ifdef FN_WriteShort + FN_WriteShort, +#else + NULL, +#endif +#ifdef FN_WriteLong + FN_WriteLong, +#else + NULL, +#endif +#ifdef FN_WriteAngle + FN_WriteAngle, +#else + NULL, +#endif +#ifdef FN_WriteCoord + FN_WriteCoord, +#else + NULL, +#endif +#ifdef FN_WriteString + FN_WriteString, +#else + NULL, +#endif +#ifdef FN_WriteEntity + FN_WriteEntity, +#else + NULL, +#endif +#ifdef FN_CVarRegister + FN_CVarRegister, +#else + NULL, +#endif +#ifdef FN_CVarGetFloat + FN_CVarGetFloat, +#else + NULL, +#endif +#ifdef FN_CVarGetString + FN_CVarGetString, +#else + NULL, +#endif +#ifdef FN_CVarSetFloat + FN_CVarSetFloat, +#else + NULL, +#endif +#ifdef FN_CVarSetString + FN_CVarSetString, +#else + NULL, +#endif +#ifdef FN_AlertMessage + FN_AlertMessage, +#else + NULL, +#endif +#ifdef FN_EngineFprintf + FN_EngineFprintf, +#else + NULL, +#endif +#ifdef FN_PvAllocEntPrivateData + FN_PvAllocEntPrivateData, +#else + NULL, +#endif +#ifdef FN_PvEntPrivateData + FN_PvEntPrivateData, +#else + NULL, +#endif +#ifdef FN_FreeEntPrivateData + FN_FreeEntPrivateData, +#else + NULL, +#endif +#ifdef FN_SzFromIndex + FN_SzFromIndex, +#else + NULL, +#endif +#ifdef FN_AllocString + FN_AllocString, +#else + NULL, +#endif +#ifdef FN_GetVarsOfEnt + FN_GetVarsOfEnt, +#else + NULL, +#endif +#ifdef FN_PEntityOfEntOffset + FN_PEntityOfEntOffset, +#else + NULL, +#endif +#ifdef FN_EntOffsetOfPEntity + FN_EntOffsetOfPEntity, +#else + NULL, +#endif +#ifdef FN_IndexOfEdict + FN_IndexOfEdict, +#else + NULL, +#endif +#ifdef FN_PEntityOfEntIndex + FN_PEntityOfEntIndex, +#else + NULL, +#endif +#ifdef FN_FindEntityByVars + FN_FindEntityByVars, +#else + NULL, +#endif +#ifdef FN_GetModelPtr + FN_GetModelPtr, +#else + NULL, +#endif +#ifdef FN_RegUserMsg + FN_RegUserMsg, +#else + NULL, +#endif +#ifdef FN_AnimationAutomove + FN_AnimationAutomove, +#else + NULL, +#endif +#ifdef FN_GetBonePosition + FN_GetBonePosition, +#else + NULL, +#endif +#ifdef FN_FunctionFromName + FN_FunctionFromName, +#else + NULL, +#endif +#ifdef FN_NameForFunction + FN_NameForFunction, +#else + NULL, +#endif +#ifdef FN_ClientPrintf + FN_ClientPrintf, +#else + NULL, +#endif +#ifdef FN_ServerPrint + FN_ServerPrint, +#else + NULL, +#endif +#ifdef FN_Cmd_Args + FN_Cmd_Args, +#else + NULL, +#endif +#ifdef FN_Cmd_Argv + FN_Cmd_Argv, +#else + NULL, +#endif +#ifdef FN_Cmd_Argc + FN_Cmd_Argc, +#else + NULL, +#endif +#ifdef FN_GetAttachment + FN_GetAttachment, +#else + NULL, +#endif +#ifdef FN_CRC32_Init + FN_CRC32_Init, +#else + NULL, +#endif +#ifdef FN_CRC32_ProcessBuffer + FN_CRC32_ProcessBuffer, +#else + NULL, +#endif +#ifdef FN_CRC32_ProcessByte + FN_CRC32_ProcessByte, +#else + NULL, +#endif +#ifdef FN_CRC32_Final + FN_CRC32_Final, +#else + NULL, +#endif +#ifdef FN_RandomLong + FN_RandomLong, +#else + NULL, +#endif +#ifdef FN_RandomFloat + FN_RandomFloat, +#else + NULL, +#endif +#ifdef FN_SetView + FN_SetView, +#else + NULL, +#endif +#ifdef FN_Time + FN_Time, +#else + NULL, +#endif +#ifdef FN_CrosshairAngle + FN_CrosshairAngle, +#else + NULL, +#endif +#ifdef FN_LoadFileForMe + FN_LoadFileForMe, +#else + NULL, +#endif +#ifdef FN_FreeFile + FN_FreeFile, +#else + NULL, +#endif +#ifdef FN_EndSection + FN_EndSection, +#else + NULL, +#endif +#ifdef FN_CompareFileTime + FN_CompareFileTime, +#else + NULL, +#endif +#ifdef FN_GetGameDir + FN_GetGameDir, +#else + NULL, +#endif +#ifdef FN_Cvar_RegisterVariable + FN_Cvar_RegisterVariable, +#else + NULL, +#endif +#ifdef FN_FadeClientVolume + FN_FadeClientVolume, +#else + NULL, +#endif +#ifdef FN_SetClientMaxspeed + FN_SetClientMaxspeed, +#else + NULL, +#endif +#ifdef FN_CreateFakeClient + FN_CreateFakeClient, +#else + NULL, +#endif +#ifdef FN_RunPlayerMove + FN_RunPlayerMove, +#else + NULL, +#endif +#ifdef FN_NumberOfEntities + FN_NumberOfEntities, +#else + NULL, +#endif +#ifdef FN_GetInfoKeyBuffer + FN_GetInfoKeyBuffer, +#else + NULL, +#endif +#ifdef FN_InfoKeyValue + FN_InfoKeyValue, +#else + NULL, +#endif +#ifdef FN_SetKeyValue + FN_SetKeyValue, +#else + NULL, +#endif +#ifdef FN_SetClientKeyValue + FN_SetClientKeyValue, +#else + NULL, +#endif +#ifdef FN_IsMapValid + FN_IsMapValid, +#else + NULL, +#endif +#ifdef FN_StaticDecal + FN_StaticDecal, +#else + NULL, +#endif +#ifdef FN_PrecacheGeneric + FN_PrecacheGeneric, +#else + NULL, +#endif +#ifdef FN_GetPlayerUserId + FN_GetPlayerUserId, +#else + NULL, +#endif +#ifdef FN_BuildSoundMsg + FN_BuildSoundMsg, +#else + NULL, +#endif +#ifdef FN_IsDedicatedServer + FN_IsDedicatedServer, +#else + NULL, +#endif +#ifdef FN_CVarGetPointer + FN_CVarGetPointer, +#else + NULL, +#endif +#ifdef FN_GetPlayerWONId + FN_GetPlayerWONId, +#else + NULL, +#endif +#ifdef FN_Info_RemoveKey + FN_Info_RemoveKey, +#else + NULL, +#endif +#ifdef FN_GetPhysicsKeyValue + FN_GetPhysicsKeyValue, +#else + NULL, +#endif +#ifdef FN_SetPhysicsKeyValue + FN_SetPhysicsKeyValue, +#else + NULL, +#endif +#ifdef FN_GetPhysicsInfoString + FN_GetPhysicsInfoString, +#else + NULL, +#endif +#ifdef FN_PrecacheEvent + FN_PrecacheEvent, +#else + NULL, +#endif +#ifdef FN_PlaybackEvent + FN_PlaybackEvent, +#else + NULL, +#endif +#ifdef FN_SetFatPVS + FN_SetFatPVS, +#else + NULL, +#endif +#ifdef FN_SetFatPAS + FN_SetFatPAS, +#else + NULL, +#endif +#ifdef FN_CheckVisibility + FN_CheckVisibility, +#else + NULL, +#endif +#ifdef FN_DeltaSetField + FN_DeltaSetField, +#else + NULL, +#endif +#ifdef FN_DeltaUnsetField + FN_DeltaUnsetField, +#else + NULL, +#endif +#ifdef FN_DeltaAddEncoder + FN_DeltaAddEncoder, +#else + NULL, +#endif +#ifdef FN_GetCurrentPlayer + FN_GetCurrentPlayer, +#else + NULL, +#endif +#ifdef FN_CanSkipPlayer + FN_CanSkipPlayer, +#else + NULL, +#endif +#ifdef FN_DeltaFindField + FN_DeltaFindField, +#else + NULL, +#endif +#ifdef FN_DeltaSetFieldByIndex + FN_DeltaSetFieldByIndex, +#else + NULL, +#endif +#ifdef FN_DeltaUnsetFieldByIndex + FN_DeltaUnsetFieldByIndex, +#else + NULL, +#endif +#ifdef FN_SetGroupMask + FN_SetGroupMask, +#else + NULL, +#endif +#ifdef FN_engCreateInstancedBaseline + FN_engCreateInstancedBaseline, +#else + NULL, +#endif +#ifdef FN_Cvar_DirectSet + FN_Cvar_DirectSet, +#else + NULL, +#endif +#ifdef FN_ForceUnmodified + FN_ForceUnmodified, +#else + NULL, +#endif +#ifdef FN_GetPlayerStats + FN_GetPlayerStats, +#else + NULL, +#endif +#ifdef FN_AddServerCommand + FN_AddServerCommand, +#else + NULL, +#endif +#ifdef FN_Voice_GetClientListening + FN_Voice_GetClientListening, +#else + NULL, +#endif +#ifdef FN_Voice_SetClientListening + FN_Voice_SetClientListening, +#else + NULL, +#endif +#ifdef FN_GetPlayerAuthId + FN_GetPlayerAuthId +#else + NULL +#endif +}; // g_EngineFuncs_Table + + +static enginefuncs_t g_EngineFuncs_Post_Table = +{ +#ifdef FN_PrecacheModel_Post + FN_PrecacheModel_Post, +#else + NULL, +#endif +#ifdef FN_PrecacheSound_Post + FN_PrecacheSound_Post, +#else + NULL, +#endif +#ifdef FN_SetModel_Post + FN_SetModel_Post, +#else + NULL, +#endif +#ifdef FN_ModelIndex_Post + FN_ModelIndex_Post, +#else + NULL, +#endif +#ifdef FN_ModelFrames_Post + FN_ModelFrames_Post, +#else + NULL, +#endif +#ifdef FN_SetSize_Post + FN_SetSize_Post, +#else + NULL, +#endif +#ifdef FN_ChangeLevel_Post + FN_ChangeLevel_Post, +#else + NULL, +#endif +#ifdef FN_GetSpawnParms_Post + FN_GetSpawnParms_Post, +#else + NULL, +#endif +#ifdef FN_SaveSpawnParms_Post + FN_SaveSpawnParms_Post, +#else + NULL, +#endif +#ifdef FN_VecToYaw_Post + FN_VecToYaw_Post, +#else + NULL, +#endif +#ifdef FN_VecToAngles_Post + FN_VecToAngles_Post, +#else + NULL, +#endif +#ifdef FN_MoveToOrigin_Post + FN_MoveToOrigin_Post, +#else + NULL, +#endif +#ifdef FN_ChangeYaw_Post + FN_ChangeYaw_Post, +#else + NULL, +#endif +#ifdef FN_ChangePitch_Post + FN_ChangePitch_Post, +#else + NULL, +#endif +#ifdef FN_FindEntityByString_Post + FN_FindEntityByString_Post, +#else + NULL, +#endif +#ifdef FN_GetEntityIllum_Post + FN_GetEntityIllum_Post, +#else + NULL, +#endif +#ifdef FN_FindEntityInSphere_Post + FN_FindEntityInSphere_Post, +#else + NULL, +#endif +#ifdef FN_FindClientInPVS_Post + FN_FindClientInPVS_Post, +#else + NULL, +#endif +#ifdef FN_EntitiesInPVS_Post + FN_EntitiesInPVS_Post, +#else + NULL, +#endif +#ifdef FN_MakeVectors_Post + FN_MakeVectors_Post, +#else + NULL, +#endif +#ifdef FN_AngleVectors_Post + FN_AngleVectors_Post, +#else + NULL, +#endif +#ifdef FN_CreateEntity_Post + FN_CreateEntity_Post, +#else + NULL, +#endif +#ifdef FN_RemoveEntity_Post + FN_RemoveEntity_Post, +#else + NULL, +#endif +#ifdef FN_CreateNamedEntity_Post + FN_CreateNamedEntity_Post, +#else + NULL, +#endif +#ifdef FN_MakeStatic_Post + FN_MakeStatic_Post, +#else + NULL, +#endif +#ifdef FN_EntIsOnFloor_Post + FN_EntIsOnFloor_Post, +#else + NULL, +#endif +#ifdef FN_DropToFloor_Post + FN_DropToFloor_Post, +#else + NULL, +#endif +#ifdef FN_WalkMove_Post + FN_WalkMove_Post, +#else + NULL, +#endif +#ifdef FN_SetOrigin_Post + FN_SetOrigin_Post, +#else + NULL, +#endif +#ifdef FN_EmitSound_Post + FN_EmitSound_Post, +#else + NULL, +#endif +#ifdef FN_EmitAmbientSound_Post + FN_EmitAmbientSound_Post, +#else + NULL, +#endif +#ifdef FN_TraceLine_Post + FN_TraceLine_Post, +#else + NULL, +#endif +#ifdef FN_TraceToss_Post + FN_TraceToss_Post, +#else + NULL, +#endif +#ifdef FN_TraceMonsterHull_Post + FN_TraceMonsterHull_Post, +#else + NULL, +#endif +#ifdef FN_TraceHull_Post + FN_TraceHull_Post, +#else + NULL, +#endif +#ifdef FN_TraceModel_Post + FN_TraceModel_Post, +#else + NULL, +#endif +#ifdef FN_TraceTexture_Post + FN_TraceTexture_Post, +#else + NULL, +#endif +#ifdef FN_TraceSphere_Post + FN_TraceSphere_Post, +#else + NULL, +#endif +#ifdef FN_GetAimVector_Post + FN_GetAimVector_Post, +#else + NULL, +#endif +#ifdef FN_ServerCommand_Post + FN_ServerCommand_Post, +#else + NULL, +#endif +#ifdef FN_ServerExecute_Post + FN_ServerExecute_Post, +#else + NULL, +#endif +#ifdef FN_engClientCommand_Post + FN_engClientCommand_Post, +#else + NULL, +#endif +#ifdef FN_ParticleEffect_Post + FN_ParticleEffect_Post, +#else + NULL, +#endif +#ifdef FN_LightStyle_Post + FN_LightStyle_Post, +#else + NULL, +#endif +#ifdef FN_DecalIndex_Post + FN_DecalIndex_Post, +#else + NULL, +#endif +#ifdef FN_PointContents_Post + FN_PointContents_Post, +#else + NULL, +#endif +#ifdef FN_MessageBegin_Post + FN_MessageBegin_Post, +#else + NULL, +#endif +#ifdef FN_MessageEnd_Post + FN_MessageEnd_Post, +#else + NULL, +#endif +#ifdef FN_WriteByte_Post + FN_WriteByte_Post, +#else + NULL, +#endif +#ifdef FN_WriteChar_Post + FN_WriteChar_Post, +#else + NULL, +#endif +#ifdef FN_WriteShort_Post + FN_WriteShort_Post, +#else + NULL, +#endif +#ifdef FN_WriteLong_Post + FN_WriteLong_Post, +#else + NULL, +#endif +#ifdef FN_WriteAngle_Post + FN_WriteAngle_Post, +#else + NULL, +#endif +#ifdef FN_WriteCoord_Post + FN_WriteCoord_Post, +#else + NULL, +#endif +#ifdef FN_WriteString_Post + FN_WriteString_Post, +#else + NULL, +#endif +#ifdef FN_WriteEntity_Post + FN_WriteEntity_Post, +#else + NULL, +#endif +#ifdef FN_CVarRegister_Post + FN_CVarRegister_Post, +#else + NULL, +#endif +#ifdef FN_CVarGetFloat_Post + FN_CVarGetFloat_Post, +#else + NULL, +#endif +#ifdef FN_CVarGetString_Post + FN_CVarGetString_Post, +#else + NULL, +#endif +#ifdef FN_CVarSetFloat_Post + FN_CVarSetFloat_Post, +#else + NULL, +#endif +#ifdef FN_CVarSetString_Post + FN_CVarSetString_Post, +#else + NULL, +#endif +#ifdef FN_AlertMessage_Post + FN_AlertMessage_Post, +#else + NULL, +#endif +#ifdef FN_EngineFprintf_Post + FN_EngineFprintf_Post, +#else + NULL, +#endif +#ifdef FN_PvAllocEntPrivateData_Post + FN_PvAllocEntPrivateData_Post, +#else + NULL, +#endif +#ifdef FN_PvEntPrivateData_Post + FN_PvEntPrivateData_Post, +#else + NULL, +#endif +#ifdef FN_FreeEntPrivateData_Post + FN_FreeEntPrivateData_Post, +#else + NULL, +#endif +#ifdef FN_SzFromIndex_Post + FN_SzFromIndex_Post, +#else + NULL, +#endif +#ifdef FN_AllocString_Post + FN_AllocString_Post, +#else + NULL, +#endif +#ifdef FN_GetVarsOfEnt_Post + FN_GetVarsOfEnt_Post, +#else + NULL, +#endif +#ifdef FN_PEntityOfEntOffset_Post + FN_PEntityOfEntOffset_Post, +#else + NULL, +#endif +#ifdef FN_EntOffsetOfPEntity_Post + FN_EntOffsetOfPEntity_Post, +#else + NULL, +#endif +#ifdef FN_IndexOfEdict_Post + FN_IndexOfEdict_Post, +#else + NULL, +#endif +#ifdef FN_PEntityOfEntIndex_Post + FN_PEntityOfEntIndex_Post, +#else + NULL, +#endif +#ifdef FN_FindEntityByVars_Post + FN_FindEntityByVars_Post, +#else + NULL, +#endif +#ifdef FN_GetModelPtr_Post + FN_GetModelPtr_Post, +#else + NULL, +#endif +#ifdef FN_RegUserMsg_Post + FN_RegUserMsg_Post, +#else + NULL, +#endif +#ifdef FN_AnimationAutomove_Post + FN_AnimationAutomove_Post, +#else + NULL, +#endif +#ifdef FN_GetBonePosition_Post + FN_GetBonePosition_Post, +#else + NULL, +#endif +#ifdef FN_FunctionFromName_Post + FN_FunctionFromName_Post, +#else + NULL, +#endif +#ifdef FN_NameForFunction_Post + FN_NameForFunction_Post, +#else + NULL, +#endif +#ifdef FN_ClientPrintf_Post + FN_ClientPrintf_Post, +#else + NULL, +#endif +#ifdef FN_ServerPrint_Post + FN_ServerPrint_Post, +#else + NULL, +#endif +#ifdef FN_Cmd_Args_Post + FN_Cmd_Args_Post, +#else + NULL, +#endif +#ifdef FN_Cmd_Argv_Post + FN_Cmd_Argv_Post, +#else + NULL, +#endif +#ifdef FN_Cmd_Argc_Post + FN_Cmd_Argc_Post, +#else + NULL, +#endif +#ifdef FN_GetAttachment_Post + FN_GetAttachment_Post, +#else + NULL, +#endif +#ifdef FN_CRC32_Init_Post + FN_CRC32_Init_Post, +#else + NULL, +#endif +#ifdef FN_CRC32_ProcessBuffer_Post + FN_CRC32_ProcessBuffer_Post, +#else + NULL, +#endif +#ifdef FN_CRC32_ProcessByte_Post + FN_CRC32_ProcessByte_Post, +#else + NULL, +#endif +#ifdef FN_CRC32_Final_Post + FN_CRC32_Final_Post, +#else + NULL, +#endif +#ifdef FN_RandomLong_Post + FN_RandomLong_Post, +#else + NULL, +#endif +#ifdef FN_RandomFloat_Post + FN_RandomFloat_Post, +#else + NULL, +#endif +#ifdef FN_SetView_Post + FN_SetView_Post, +#else + NULL, +#endif +#ifdef FN_Time_Post + FN_Time_Post, +#else + NULL, +#endif +#ifdef FN_CrosshairAngle_Post + FN_CrosshairAngle_Post, +#else + NULL, +#endif +#ifdef FN_LoadFileForMe_Post + FN_LoadFileForMe_Post, +#else + NULL, +#endif +#ifdef FN_FreeFile_Post + FN_FreeFile_Post, +#else + NULL, +#endif +#ifdef FN_EndSection_Post + FN_EndSection_Post, +#else + NULL, +#endif +#ifdef FN_CompareFileTime_Post + FN_CompareFileTime_Post, +#else + NULL, +#endif +#ifdef FN_GetGameDir_Post + FN_GetGameDir_Post, +#else + NULL, +#endif +#ifdef FN_Cvar_RegisterVariable_Post + FN_Cvar_RegisterVariable_Post, +#else + NULL, +#endif +#ifdef FN_FadeClientVolume_Post + FN_FadeClientVolume_Post, +#else + NULL, +#endif +#ifdef FN_SetClientMaxspeed_Post + FN_SetClientMaxspeed_Post, +#else + NULL, +#endif +#ifdef FN_CreateFakeClient_Post + FN_CreateFakeClient_Post, +#else + NULL, +#endif +#ifdef FN_RunPlayerMove_Post + FN_RunPlayerMove_Post, +#else + NULL, +#endif +#ifdef FN_NumberOfEntities_Post + FN_NumberOfEntities_Post, +#else + NULL, +#endif +#ifdef FN_GetInfoKeyBuffer_Post + FN_GetInfoKeyBuffer_Post, +#else + NULL, +#endif +#ifdef FN_InfoKeyValue_Post + FN_InfoKeyValue_Post, +#else + NULL, +#endif +#ifdef FN_SetKeyValue_Post + FN_SetKeyValue_Post, +#else + NULL, +#endif +#ifdef FN_SetClientKeyValue_Post + FN_SetClientKeyValue_Post, +#else + NULL, +#endif +#ifdef FN_IsMapValid_Post + FN_IsMapValid_Post, +#else + NULL, +#endif +#ifdef FN_StaticDecal_Post + FN_StaticDecal_Post, +#else + NULL, +#endif +#ifdef FN_PrecacheGeneric_Post + FN_PrecacheGeneric_Post, +#else + NULL, +#endif +#ifdef FN_GetPlayerUserId_Post + FN_GetPlayerUserId_Post, +#else + NULL, +#endif +#ifdef FN_BuildSoundMsg_Post + FN_BuildSoundMsg_Post, +#else + NULL, +#endif +#ifdef FN_IsDedicatedServer_Post + FN_IsDedicatedServer_Post, +#else + NULL, +#endif +#ifdef FN_CVarGetPointer_Post + FN_CVarGetPointer_Post, +#else + NULL, +#endif +#ifdef FN_GetPlayerWONId_Post + FN_GetPlayerWONId_Post, +#else + NULL, +#endif +#ifdef FN_Info_RemoveKey_Post + FN_Info_RemoveKey_Post, +#else + NULL, +#endif +#ifdef FN_GetPhysicsKeyValue_Post + FN_GetPhysicsKeyValue_Post, +#else + NULL, +#endif +#ifdef FN_SetPhysicsKeyValue_Post + FN_SetPhysicsKeyValue_Post, +#else + NULL, +#endif +#ifdef FN_GetPhysicsInfoString_Post + FN_GetPhysicsInfoString_Post, +#else + NULL, +#endif +#ifdef FN_PrecacheEvent_Post + FN_PrecacheEvent_Post, +#else + NULL, +#endif +#ifdef FN_PlaybackEvent_Post + FN_PlaybackEvent_Post, +#else + NULL, +#endif +#ifdef FN_SetFatPVS_Post + FN_SetFatPVS_Post, +#else + NULL, +#endif +#ifdef FN_SetFatPAS_Post + FN_SetFatPAS_Post, +#else + NULL, +#endif +#ifdef FN_CheckVisibility_Post + FN_CheckVisibility_Post, +#else + NULL, +#endif +#ifdef FN_DeltaSetField_Post + FN_DeltaSetField_Post, +#else + NULL, +#endif +#ifdef FN_DeltaUnsetField_Post + FN_DeltaUnsetField_Post, +#else + NULL, +#endif +#ifdef FN_DeltaAddEncoder_Post + FN_DeltaAddEncoder_Post, +#else + NULL, +#endif +#ifdef FN_GetCurrentPlayer_Post + FN_GetCurrentPlayer_Post, +#else + NULL, +#endif +#ifdef FN_CanSkipPlayer_Post + FN_CanSkipPlayer_Post, +#else + NULL, +#endif +#ifdef FN_DeltaFindField_Post + FN_DeltaFindField_Post, +#else + NULL, +#endif +#ifdef FN_DeltaSetFieldByIndex_Post + FN_DeltaSetFieldByIndex_Post, +#else + NULL, +#endif +#ifdef FN_DeltaUnsetFieldByIndex_Post + FN_DeltaUnsetFieldByIndex_Post, +#else + NULL, +#endif +#ifdef FN_SetGroupMask_Post + FN_SetGroupMask_Post, +#else + NULL, +#endif +#ifdef FN_engCreateInstancedBaseline_Post + FN_engCreateInstancedBaseline_Post, +#else + NULL, +#endif +#ifdef FN_Cvar_DirectSet_Post + FN_Cvar_DirectSet_Post, +#else + NULL, +#endif +#ifdef FN_ForceUnmodified_Post + FN_ForceUnmodified_Post, +#else + NULL, +#endif +#ifdef FN_GetPlayerStats_Post + FN_GetPlayerStats_Post, +#else + NULL, +#endif +#ifdef FN_AddServerCommand_Post + FN_AddServerCommand_Post, +#else + NULL, +#endif +#ifdef FN_Voice_GetClientListening_Post + FN_Voice_GetClientListening_Post, +#else + NULL, +#endif +#ifdef FN_Voice_SetClientListening_Post + FN_Voice_SetClientListening_Post, +#else + NULL, +#endif +#ifdef FN_GetPlayerAuthId_Post + FN_GetPlayerAuthId_Post +#else + NULL +#endif +}; // g_EngineFuncs_Post_Table + + +static NEW_DLL_FUNCTIONS g_NewFuncs_Table = +{ +#ifdef FN_OnFreeEntPrivateData + FN_OnFreeEntPrivateData, +#else + NULL, +#endif +#ifdef FN_GameShutdown + FN_GameShutdown, +#else + NULL, +#endif +#ifdef FN_ShouldCollide + ShouldCollide, +#else + NULL, +#endif +}; + + +static NEW_DLL_FUNCTIONS g_NewFuncs_Post_Table = +{ +#ifdef FN_OnFreeEntPrivateData_Post + FN_OnFreeEntPrivateData_Post, +#else + NULL, +#endif +#ifdef FN_GameShutdown_Post + FN_GameShutdown_Post, +#else + NULL, +#endif +#ifdef FN_ShouldCollide_Post + ShouldCollide_Post, +#else + NULL, +#endif +}; + +// Global variables from metamod. These variable names are referenced by +// various macros. +meta_globals_t *gpMetaGlobals; // metamod globals +gamedll_funcs_t *gpGamedllFuncs; // gameDLL function tables +mutil_funcs_t *gpMetaUtilFuncs; // metamod utility functions + + +plugin_info_t Plugin_info = { + META_INTERFACE_VERSION, + MODULE_NAME, + MODULE_VERSION, + MODULE_DATE, + MODULE_AUTHOR, + MODULE_URL, + MODULE_LOGTAG, + PT_ANYTIME, + PT_ANYTIME +}; + +/* +C_DLLEXPORT int GetEntityAPI(DLL_FUNCTIONS *pFunctionTable, int interfaceVersion) +{ + LOG_DEVELOPER(PLID, "called: GetEntityAPI; version=%d", interfaceVersion); + if(!pFunctionTable) { + LOG_ERROR(PLID, "GetEntityAPI called with null pFunctionTable"); + return(FALSE); + } + else if(interfaceVersion != INTERFACE_VERSION) { + LOG_ERROR(PLID, "GetEntityAPI version mismatch; requested=%d ours=%d", interfaceVersion, INTERFACE_VERSION); + return(FALSE); + } + memcpy(pFunctionTable, &g_EntityAPI_Table, sizeof( DLL_FUNCTIONS ) ); + + return (TRUE); +} + +C_DLLEXPORT int GetEntityAPI_Post(DLL_FUNCTIONS *pFunctionTable, int interfaceVersion) +{ + LOG_DEVELOPER(PLID, "called: GetEntityAPI_Post; version=%d", interfaceVersion); + if(!pFunctionTable) { + LOG_ERROR(PLID, "GetEntityAPI_Post called with null pFunctionTable"); + return(FALSE); + } + else if(interfaceVersion != INTERFACE_VERSION) { + LOG_ERROR(PLID, "GetEntityAPI_Post version mismatch; requested=%d ours=%d", interfaceVersion, INTERFACE_VERSION); + return(FALSE); + } + memcpy(pFunctionTable, &g_EntityAPI_Post_Table, sizeof( DLL_FUNCTIONS ) ); + + return(TRUE); +} +*/ + +C_DLLEXPORT int GetEntityAPI2(DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion) +{ + LOG_DEVELOPER(PLID, "called: GetEntityAPI2; version=%d", *interfaceVersion); + if(!pFunctionTable) { + LOG_ERROR(PLID, "GetEntityAPI2 called with null pFunctionTable"); + return(FALSE); + } + else if(*interfaceVersion != INTERFACE_VERSION) { + LOG_ERROR(PLID, + "GetEntityAPI2 version mismatch; requested=%d ours=%d", + *interfaceVersion, INTERFACE_VERSION); + //! Tell engine what version we had, so it can figure out who is + //! out of date. + *interfaceVersion = INTERFACE_VERSION; + return(FALSE); + } + memcpy(pFunctionTable, &g_EntityAPI_Table, sizeof(DLL_FUNCTIONS)); + g_pFunctionTable=pFunctionTable; + return(TRUE); +} + +C_DLLEXPORT int GetEntityAPI2_Post(DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion) +{ + LOG_DEVELOPER(PLID, "called: GetEntityAPI2_Post; version=%d", *interfaceVersion); + if(!pFunctionTable) { + LOG_ERROR(PLID, "GetEntityAPI2_Post called with null pFunctionTable"); + return(FALSE); + } + else if(*interfaceVersion != INTERFACE_VERSION) { + LOG_ERROR(PLID, "GetEntityAPI2_Post version mismatch; requested=%d ours=%d", *interfaceVersion, INTERFACE_VERSION); + //! Tell engine what version we had, so it can figure out who is out of date. + *interfaceVersion = INTERFACE_VERSION; + return(FALSE); + } + memcpy( pFunctionTable, &g_EntityAPI_Post_Table, sizeof( DLL_FUNCTIONS ) ); + g_pFunctionTable_Post=pFunctionTable; + return(TRUE); +} + +C_DLLEXPORT int GetEngineFunctions(enginefuncs_t *pengfuncsFromEngine, int *interfaceVersion) +{ + LOG_DEVELOPER(PLID, "called: GetEngineFunctions; version=%d", + *interfaceVersion); + if(!pengfuncsFromEngine) { + LOG_ERROR(PLID, + "GetEngineFunctions called with null pengfuncsFromEngine"); + return(FALSE); + } + else if(*interfaceVersion != ENGINE_INTERFACE_VERSION) { + LOG_ERROR(PLID, + "GetEngineFunctions version mismatch; requested=%d ours=%d", + *interfaceVersion, ENGINE_INTERFACE_VERSION); + // Tell metamod what version we had, so it can figure out who is + // out of date. + *interfaceVersion = ENGINE_INTERFACE_VERSION; + return(FALSE); + } + memcpy(pengfuncsFromEngine, &g_EngineFuncs_Table, sizeof(enginefuncs_t)); + g_pengfuncsTable=pengfuncsFromEngine; + return TRUE; +} + +C_DLLEXPORT int GetEngineFunctions_Post(enginefuncs_t *pengfuncsFromEngine, int *interfaceVersion) +{ + LOG_DEVELOPER(PLID, "called: GetEngineFunctions_Post; version=%d", *interfaceVersion); + if(!pengfuncsFromEngine) { + LOG_ERROR(PLID, "GetEngineFunctions_Post called with null pengfuncsFromEngine"); + return(FALSE); + } + else if(*interfaceVersion != ENGINE_INTERFACE_VERSION) { + LOG_ERROR(PLID, "GetEngineFunctions_Post version mismatch; requested=%d ours=%d", *interfaceVersion, ENGINE_INTERFACE_VERSION); + // Tell metamod what version we had, so it can figure out who is out of date. + *interfaceVersion = ENGINE_INTERFACE_VERSION; + return(FALSE); + } + memcpy(pengfuncsFromEngine, &g_EngineFuncs_Post_Table, sizeof(enginefuncs_t)); + g_pengfuncsTable_Post=pengfuncsFromEngine; + return TRUE; + +} + +C_DLLEXPORT int GetNewDLLFunctions(NEW_DLL_FUNCTIONS *pNewFunctionTable, + int *interfaceVersion) +{ + LOG_DEVELOPER(PLID, "called: GetNewDLLFunctions; version=%d", + *interfaceVersion); + if(!pNewFunctionTable) { + LOG_ERROR(PLID, + "GetNewDLLFunctions called with null pNewFunctionTable"); + return(FALSE); + } + else if(*interfaceVersion != NEW_DLL_FUNCTIONS_VERSION) { + LOG_ERROR(PLID, + "GetNewDLLFunctions version mismatch; requested=%d ours=%d", + *interfaceVersion, NEW_DLL_FUNCTIONS_VERSION); + //! Tell engine what version we had, so it can figure out who is + //! out of date. + *interfaceVersion = NEW_DLL_FUNCTIONS_VERSION; + return(FALSE); + } + memcpy(pNewFunctionTable, &g_NewFuncs_Table, sizeof(NEW_DLL_FUNCTIONS)); + g_pNewFunctionsTable=pNewFunctionTable; + return TRUE; +} + +C_DLLEXPORT int GetNewDLLFunctions_Post( NEW_DLL_FUNCTIONS *pNewFunctionTable, int *interfaceVersion ) +{ + LOG_DEVELOPER(PLID, "called: GetNewDLLFunctions_Post; version=%d", *interfaceVersion); + if(!pNewFunctionTable) { + LOG_ERROR(PLID, "GetNewDLLFunctions_Post called with null pNewFunctionTable"); + return(FALSE); + } + else if(*interfaceVersion != NEW_DLL_FUNCTIONS_VERSION) { + LOG_ERROR(PLID, "GetNewDLLFunctions_Post version mismatch; requested=%d ours=%d", *interfaceVersion, NEW_DLL_FUNCTIONS_VERSION); + //! Tell engine what version we had, so it can figure out who is out of date. + *interfaceVersion = NEW_DLL_FUNCTIONS_VERSION; + return(FALSE); + } + memcpy(pNewFunctionTable, &g_NewFuncs_Post_Table, sizeof(NEW_DLL_FUNCTIONS)); + g_pNewFunctionsTable_Post=pNewFunctionTable; + return TRUE; +} + + +static META_FUNCTIONS g_MetaFunctions_Table = +{ + NULL, + NULL, + GetEntityAPI2, + GetEntityAPI2_Post, + GetNewDLLFunctions, + GetNewDLLFunctions_Post, + GetEngineFunctions, + GetEngineFunctions_Post +}; + +C_DLLEXPORT int Meta_Query(char *ifvers, plugin_info_t **pPlugInfo, mutil_funcs_t *pMetaUtilFuncs) +{ + if ((int) CVAR_GET_FLOAT("developer") != 0) + UTIL_LogPrintf("[%s] dev: called: Meta_Query; version=%s, ours=%s\n", + Plugin_info.logtag, ifvers, Plugin_info.ifvers); + + // Check for valid pMetaUtilFuncs before we continue. + if(!pMetaUtilFuncs) { + UTIL_LogPrintf("[%s] ERROR: Meta_Query called with null pMetaUtilFuncs\n", Plugin_info.logtag); + return(FALSE); + } + + gpMetaUtilFuncs = pMetaUtilFuncs; + + *pPlugInfo = &Plugin_info; + + // Check for interface version compatibility. + if(!FStrEq(ifvers, Plugin_info.ifvers)) { + int mmajor=0, mminor=0, pmajor=0, pminor=0; + LOG_MESSAGE(PLID, "WARNING: meta-interface version mismatch; requested=%s ours=%s", + Plugin_info.logtag, ifvers); + // If plugin has later interface version, it's incompatible (update + // metamod). + sscanf(ifvers, "%d:%d", &mmajor, &mminor); + sscanf(META_INTERFACE_VERSION, "%d:%d", &pmajor, &pminor); + if(pmajor > mmajor || (pmajor==mmajor && pminor > mminor)) { + LOG_ERROR(PLID, "metamod version is too old for this module; update metamod"); + return(FALSE); + } + // If plugin has older major interface version, it's incompatible + // (update plugin). + else if(pmajor < mmajor) { + LOG_ERROR(PLID, "metamod version is incompatible with this module; please find a newer version of this module"); + return(FALSE); + } + // Minor interface is older, but this is guaranteed to be backwards + // compatible, so we warn, but we still accept it. + else if(pmajor==mmajor && pminor < mminor) + LOG_MESSAGE(PLID, "WARNING: metamod version is newer than expected; consider finding a newer version of this module"); + else + LOG_ERROR(PLID, "unexpected version comparison; metavers=%s, mmajor=%d, mminor=%d; plugvers=%s, pmajor=%d, pminor=%d", ifvers, mmajor, mminor, META_INTERFACE_VERSION, pmajor, pminor); + } + +#ifdef FN_META_QUERY + return FN_META_QUERY(); +#endif // FN_META_QUERY + + return 1; +} + + +C_DLLEXPORT int Meta_Attach(PLUG_LOADTIME now, META_FUNCTIONS *pFunctionTable, meta_globals_t *pMGlobals, gamedll_funcs_t *pGamedllFuncs) +{ + if ( gpGamedllFuncs ){ + LOG_ERROR(PLID,"gpGamedllFuncs already set"); + return(FALSE); + } + + if(now > Plugin_info.loadable) { + LOG_ERROR(PLID, "Can't load module right now"); + return(FALSE); + } + if(!pMGlobals) { + LOG_ERROR(PLID, "Meta_Attach called with null pMGlobals"); + return(FALSE); + } + gpMetaGlobals=pMGlobals; + if(!pFunctionTable) { + LOG_ERROR(PLID, "Meta_Attach called with null pFunctionTable"); + return(FALSE); + } + + memcpy(pFunctionTable, &g_MetaFunctions_Table, sizeof(META_FUNCTIONS)); + gpGamedllFuncs=pGamedllFuncs; + + // Let's go. + +#ifdef FN_META_ATTACH + FN_META_ATTACH(); +#endif // FN_META_ATTACH + + return TRUE; +} + +C_DLLEXPORT int Meta_Detach(PLUG_LOADTIME now, PL_UNLOAD_REASON reason) +{ + if(now > Plugin_info.unloadable && reason != PNL_CMD_FORCED) { + LOG_ERROR(PLID, "Can't unload plugin right now"); + return(FALSE); + } + +#ifdef FN_META_DETACH + return FN_META_DETACH(); +#endif // FN_META_DETACH + return TRUE; +} + + + +#ifdef __linux__ +// linux prototype +C_DLLEXPORT void GiveFnptrsToDll( enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals ) { + +#else +#ifdef _MSC_VER +// MSVC: Simulate __stdcall calling convention +C_DLLEXPORT __declspec(naked) void GiveFnptrsToDll( enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals ) +{ + __asm // Prolog + { + // Save ebp + push ebp + // Set stack frame pointer + mov ebp, esp + // Allocate space for local variables + // The MSVC compiler gives us the needed size in __LOCAL_SIZE. + sub esp, __LOCAL_SIZE + // Push registers + push ebx + push esi + push edi + } +#else // _MSC_VER +#ifdef __GNUC__ +// GCC can also work with this +C_DLLEXPORT void __stdcall GiveFnptrsToDll( enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals ) +{ +#else // __GNUC__ +// compiler not known +#error There is no support (yet) for your compiler. Please use MSVC or GCC compilers or contact the AMX Mod X dev team. +#endif // __GNUC__ +#endif // _MSC_VER +#endif // __linux__ + + // ** Function core <-- + memcpy(&g_engfuncs, pengfuncsFromEngine, sizeof(enginefuncs_t)); + gpGlobals = pGlobals; + // NOTE! Have to call logging function _after_ copying into g_engfuncs, so + // that g_engfuncs.pfnAlertMessage() can be resolved properly, heh. :) + UTIL_LogPrintf("[%s] dev: called: GiveFnptrsToDll\n", Plugin_info.logtag); + // --> ** Function core + +#ifdef _MSC_VER + // Epilog + if (sizeof(int*) == 8) + { // 64 bit + __asm + { + // Pop registers + pop edi + pop esi + pop ebx + // Restore stack frame pointer + mov esp, ebp + // Restore ebp + pop ebp + // 2 * sizeof(int*) = 16 on 64 bit + ret 16 + } + } + else + { // 32 bit + __asm + { + // Pop registers + pop edi + pop esi + pop ebx + // Restore stack frame pointer + mov esp, ebp + // Restore ebp + pop ebp + // 2 * sizeof(int*) = 8 on 32 bit + ret 8 + } + } +#endif // #ifdef _MSC_VER +} + +#endif // #ifdef USE_METAMOD + +/************* AMXX Stuff *************/ + +// *** Types *** +typedef void* (*PFN_REQ_FNPTR)(const char * /*name*/); + +// *** Globals *** +// Module info +static amxx_module_info_s g_ModuleInfo = +{ + MODULE_NAME, + MODULE_AUTHOR, + MODULE_VERSION, +#ifdef MODULE_RELOAD_ON_MAPCHANGE + 1 +#else // MODULE_RELOAD_ON_MAPCHANGE + 0 +#endif // MODULE_RELOAD_ON_MAPCHANGE +}; + +// Storage for the requested functions +PFN_ADD_NATIVES g_fn_AddNatives; +PFN_BUILD_PATHNAME g_fn_BuildPathname; +PFN_GET_AMXADDR g_fn_GetAmxAddr; +PFN_PRINT_SRVCONSOLE g_fn_PrintSrvConsole; +PFN_GET_MODNAME g_fn_GetModname; +PFN_GET_AMXSCRIPTNAME g_fn_GetAmxScriptName; +PFN_GET_AMXSCRIPT g_fn_GetAmxScript; +PFN_FIND_AMXSCRIPT_BYAMX g_fn_FindAmxScriptByAmx; +PFN_FIND_AMXSCRIPT_BYNAME g_fn_FindAmxScriptByName; +PFN_SET_AMXSTRING g_fn_SetAmxString; +PFN_GET_AMXSTRING g_fn_GetAmxString; +PFN_GET_AMXSTRINGLEN g_fn_GetAmxStringLen; +PFN_FORMAT_AMXSTRING g_fn_FormatAmxString; +PFN_COPY_AMXMEMORY g_fn_CopyAmxMemory; +PFN_LOG g_fn_Log; +PFN_LOG_ERROR g_fn_LogErrorFunc; +PFN_RAISE_AMXERROR g_fn_RaiseAmxError; +PFN_REGISTER_FORWARD g_fn_RegisterForward; +PFN_EXECUTE_FORWARD g_fn_ExecuteForward; +PFN_PREPARE_CELLARRAY g_fn_PrepareCellArray; +PFN_PREPARE_CHARARRAY g_fn_PrepareCharArray; +PFN_PREPARE_CELLARRAY_A g_fn_PrepareCellArrayA; +PFN_PREPARE_CHARARRAY_A g_fn_PrepareCharArrayA; +PFN_IS_PLAYER_VALID g_fn_IsPlayerValid; +PFN_GET_PLAYER_NAME g_fn_GetPlayerName; +PFN_GET_PLAYER_IP g_fn_GetPlayerIP; +PFN_IS_PLAYER_INGAME g_fn_IsPlayerIngame; +PFN_IS_PLAYER_BOT g_fn_IsPlayerBot; +PFN_IS_PLAYER_AUTHORIZED g_fn_IsPlayerAuthorized; +PFN_GET_PLAYER_TIME g_fn_GetPlayerTime; +PFN_GET_PLAYER_PLAYTIME g_fn_GetPlayerPlayTime; +PFN_GET_PLAYER_CURWEAPON g_fn_GetPlayerCurweapon; +PFN_GET_PLAYER_TEAM g_fn_GetPlayerTeam; +PFN_GET_PLAYER_TEAMID g_fn_GetPlayerTeamID; +PFN_GET_PLAYER_DEATHS g_fn_GetPlayerDeaths; +PFN_GET_PLAYER_MENU g_fn_GetPlayerMenu; +PFN_GET_PLAYER_KEYS g_fn_GetPlayerKeys; +PFN_IS_PLAYER_ALIVE g_fn_IsPlayerAlive; +PFN_GET_PLAYER_FRAGS g_fn_GetPlayerFrags; +PFN_IS_PLAYER_CONNECTING g_fn_IsPlayerConnecting; +PFN_IS_PLAYER_HLTV g_fn_IsPlayerHLTV; +PFN_GET_PLAYER_ARMOR g_fn_GetPlayerArmor; +PFN_GET_PLAYER_HEALTH g_fn_GetPlayerHealth; +PFN_ALLOCATOR g_fn_Allocator; +PFN_REALLOCATOR g_fn_Reallocator; +PFN_DEALLOCATOR g_fn_Deallocator; +PFN_AMX_EXEC g_fn_AmxExec; +PFN_AMX_EXECV g_fn_AmxExecv; +PFN_AMX_ALLOT g_fn_AmxAllot; +PFN_AMX_FINDPUBLIC g_fn_AmxFindPublic; +PFN_LOAD_AMXSCRIPT g_fn_LoadAmxScript; +PFN_UNLOAD_AMXSCRIPT g_fn_UnloadAmxScript; +PFN_REAL_TO_CELL g_fn_RealToCell; +PFN_CELL_TO_REAL g_fn_CellToReal; +PFN_REGISTER_SPFORWARD g_fn_RegisterSPForward; +PFN_REGISTER_SPFORWARD_BYNAME g_fn_RegisterSPForwardByName; +PFN_UNREGISTER_SPFORWARD g_fn_UnregisterSPForward; +PFN_MERGEDEFINITION_FILE g_fn_MergeDefinition_File; +PFN_AMX_FINDNATIVE g_fn_AmxFindNative; +PFN_GETPLAYERFLAGS g_fn_GetPlayerFlags; +PFN_GET_PLAYER_EDICT g_fn_GetPlayerEdict; +PFN_FORMAT g_fn_Format; + +// *** Exports *** +C_DLLEXPORT int AMXX_Query(int *interfaceVersion, amxx_module_info_s *moduleInfo) +{ + // check parameters + if (!interfaceVersion || !moduleInfo) + return AMXX_PARAM; + + // check interface version + if (*interfaceVersion != AMXX_INTERFACE_VERSION) + { + // Tell amxx core our interface version + *interfaceVersion = AMXX_INTERFACE_VERSION; + return AMXX_IFVERS; + } + + // copy module info + memcpy(moduleInfo, &g_ModuleInfo, sizeof(amxx_module_info_s)); + +#ifdef FN_AMXX_QUERY + FN_AMXX_QUERY(); +#endif // FN_AMXX_QUERY + // Everything ok :) + return AMXX_OK; +} + +// request function +#define REQFUNC(name, fptr, type) if ((fptr = (type)reqFnptrFunc(name)) == 0) return AMXX_FUNC_NOT_PRESENT +// request optional function +#define REQFUNC_OPT(name, fptr, type) fptr = (type)reqFnptrFunc(name) + +C_DLLEXPORT int AMXX_Attach(PFN_REQ_FNPTR reqFnptrFunc) +{ + // Check pointer + if (!reqFnptrFunc) + return AMXX_PARAM; + + // Req all known functions + // Misc + REQFUNC("BuildPathname", g_fn_BuildPathname, PFN_BUILD_PATHNAME); + REQFUNC("PrintSrvConsole", g_fn_PrintSrvConsole, PFN_PRINT_SRVCONSOLE); + REQFUNC("GetModname", g_fn_GetModname, PFN_GET_MODNAME); + REQFUNC("Log", g_fn_Log, PFN_LOG); + REQFUNC("LogError", g_fn_LogErrorFunc, PFN_LOG_ERROR); + REQFUNC("MergeDefinitionFile", g_fn_MergeDefinition_File, PFN_MERGEDEFINITION_FILE); + REQFUNC("Format", g_fn_Format, PFN_FORMAT); + + // Amx scripts + REQFUNC("GetAmxScript", g_fn_GetAmxScript, PFN_GET_AMXSCRIPT); + REQFUNC("FindAmxScriptByAmx", g_fn_FindAmxScriptByAmx, PFN_FIND_AMXSCRIPT_BYAMX); + REQFUNC("FindAmxScriptByName", g_fn_FindAmxScriptByName, PFN_FIND_AMXSCRIPT_BYNAME); + REQFUNC("LoadAmxScript", g_fn_LoadAmxScript, PFN_LOAD_AMXSCRIPT); + REQFUNC("UnloadAmxScript", g_fn_UnloadAmxScript, PFN_UNLOAD_AMXSCRIPT); + REQFUNC("GetAmxScriptName", g_fn_GetAmxScriptName, PFN_GET_AMXSCRIPTNAME); + + // String / mem in amx scripts support + REQFUNC("SetAmxString", g_fn_SetAmxString, PFN_SET_AMXSTRING); + REQFUNC("GetAmxString", g_fn_GetAmxString, PFN_GET_AMXSTRING); + REQFUNC("GetAmxStringLen", g_fn_GetAmxStringLen, PFN_GET_AMXSTRINGLEN); + REQFUNC("FormatAmxString", g_fn_FormatAmxString, PFN_FORMAT_AMXSTRING); + REQFUNC("CopyAmxMemory", g_fn_CopyAmxMemory, PFN_COPY_AMXMEMORY); + REQFUNC("GetAmxAddr", g_fn_GetAmxAddr, PFN_GET_AMXADDR); + + REQFUNC("amx_Exec", g_fn_AmxExec, PFN_AMX_EXEC); + REQFUNC("amx_Execv", g_fn_AmxExecv, PFN_AMX_EXECV); + REQFUNC("amx_FindPublic", g_fn_AmxFindPublic, PFN_AMX_FINDPUBLIC); + REQFUNC("amx_Allot", g_fn_AmxAllot, PFN_AMX_ALLOT); + REQFUNC("amx_FindNative", g_fn_AmxFindNative, PFN_AMX_FINDNATIVE); + + // Natives / Forwards + REQFUNC("AddNatives", g_fn_AddNatives, PFN_ADD_NATIVES); + REQFUNC("RaiseAmxError", g_fn_RaiseAmxError, PFN_RAISE_AMXERROR); + REQFUNC("RegisterForward", g_fn_RegisterForward, PFN_REGISTER_FORWARD); + REQFUNC("RegisterSPForward", g_fn_RegisterSPForward, PFN_REGISTER_SPFORWARD); + REQFUNC("RegisterSPForwardByName", g_fn_RegisterSPForwardByName, PFN_REGISTER_SPFORWARD_BYNAME); + REQFUNC("UnregisterSPForward", g_fn_UnregisterSPForward, PFN_UNREGISTER_SPFORWARD); + REQFUNC("ExecuteForward", g_fn_ExecuteForward, PFN_EXECUTE_FORWARD); + REQFUNC("PrepareCellArray", g_fn_PrepareCellArray, PFN_PREPARE_CELLARRAY); + REQFUNC("PrepareCharArray", g_fn_PrepareCharArray, PFN_PREPARE_CHARARRAY); + REQFUNC("PrepareCellArrayA", g_fn_PrepareCellArrayA, PFN_PREPARE_CELLARRAY_A); + REQFUNC("PrepareCharArrayA", g_fn_PrepareCharArrayA, PFN_PREPARE_CHARARRAY_A); + // Player + REQFUNC("IsPlayerValid", g_fn_IsPlayerValid, PFN_IS_PLAYER_VALID); + REQFUNC("GetPlayerName", g_fn_GetPlayerName, PFN_GET_PLAYER_NAME); + REQFUNC("GetPlayerIP", g_fn_GetPlayerIP, PFN_GET_PLAYER_IP); + REQFUNC("IsPlayerInGame", g_fn_IsPlayerIngame, PFN_IS_PLAYER_INGAME); + REQFUNC("IsPlayerBot", g_fn_IsPlayerBot, PFN_IS_PLAYER_BOT); + REQFUNC("IsPlayerAuthorized", g_fn_IsPlayerAuthorized, PFN_IS_PLAYER_AUTHORIZED); + REQFUNC("GetPlayerTime", g_fn_GetPlayerTime, PFN_GET_PLAYER_TIME); + REQFUNC("GetPlayerPlayTime", g_fn_GetPlayerPlayTime, PFN_GET_PLAYER_PLAYTIME); + REQFUNC("GetPlayerCurweapon", g_fn_GetPlayerCurweapon, PFN_GET_PLAYER_CURWEAPON); + REQFUNC("GetPlayerTeamID", g_fn_GetPlayerTeamID, PFN_GET_PLAYER_TEAMID); + REQFUNC("GetPlayerTeam",g_fn_GetPlayerTeam, PFN_GET_PLAYER_TEAM); + REQFUNC("GetPlayerDeaths", g_fn_GetPlayerDeaths, PFN_GET_PLAYER_DEATHS); + REQFUNC("GetPlayerMenu", g_fn_GetPlayerMenu, PFN_GET_PLAYER_MENU); + REQFUNC("GetPlayerKeys", g_fn_GetPlayerKeys, PFN_GET_PLAYER_KEYS); + REQFUNC("IsPlayerAlive", g_fn_IsPlayerAlive, PFN_IS_PLAYER_ALIVE); + REQFUNC("GetPlayerFrags", g_fn_GetPlayerFrags, PFN_GET_PLAYER_FRAGS); + REQFUNC("IsPlayerConnecting", g_fn_IsPlayerConnecting, PFN_IS_PLAYER_CONNECTING); + REQFUNC("IsPlayerHLTV", g_fn_IsPlayerHLTV, PFN_IS_PLAYER_HLTV); + REQFUNC("GetPlayerArmor", g_fn_GetPlayerArmor, PFN_GET_PLAYER_ARMOR); + REQFUNC("GetPlayerHealth", g_fn_GetPlayerHealth, PFN_GET_PLAYER_HEALTH); + REQFUNC("GetPlayerFlags", g_fn_GetPlayerFlags, PFN_GETPLAYERFLAGS); + REQFUNC("GetPlayerEdict", g_fn_GetPlayerEdict, PFN_GET_PLAYER_EDICT); + + // Memory + REQFUNC_OPT("Allocator", g_fn_Allocator, PFN_ALLOCATOR); + REQFUNC_OPT("Reallocator", g_fn_Reallocator, PFN_REALLOCATOR); + REQFUNC_OPT("Deallocator", g_fn_Deallocator, PFN_DEALLOCATOR); + + REQFUNC("CellToReal", g_fn_CellToReal, PFN_CELL_TO_REAL); + REQFUNC("RealToCell", g_fn_RealToCell, PFN_REAL_TO_CELL); + +#ifdef FN_AMXX_ATTACH + FN_AMXX_ATTACH(); +#endif // FN_AMXX_ATACH + + return AMXX_OK; +} + +C_DLLEXPORT int AMXX_Detach() +{ +#ifdef FN_AMXX_DETACH + FN_AMXX_DETACH(); +#endif // FN_AMXX_DETACH + + return AMXX_OK; +} + +C_DLLEXPORT int AMXX_PluginsLoaded() +{ +#ifdef FN_AMXX_PLUGINSLOADED + FN_AMXX_PLUGINSLOADED(); +#endif // FN_AMXX_PLUGINSLOADED + return AMXX_OK; +} + +// Advanced MF functions +void MF_Log(const char *fmt, ...) +{ + // :TODO: Overflow possible here + char msg[3072]; + va_list arglst; + va_start(arglst, fmt); + vsprintf(msg, fmt, arglst); + va_end(arglst); + + g_fn_Log("[%s] %s", MODULE_NAME, msg); +} + +void MF_LogError(AMX *amx, int err, const char *fmt, ...) +{ + // :TODO: Overflow possible here + char msg[3072]; + va_list arglst; + va_start(arglst, fmt); + vsprintf(msg, fmt, arglst); + va_end(arglst); + + g_fn_LogErrorFunc(amx, err, "[%s] %s", MODULE_NAME, msg); +} + + +#ifdef _DEBUG +// validate macros +// Makes sure compiler reports errors when macros are invalid +void ValidateMacros_DontCallThis_Smiley() +{ + MF_BuildPathname("str", "str", 0); + MF_FormatAmxString(NULL, 0, 0, NULL); + MF_GetAmxAddr(NULL, 0); + MF_PrintSrvConsole("str", "str", 0); + MF_GetModname(); + MF_GetScriptName(0); + MF_GetScriptAmx(0); + MF_FindScriptByAmx(NULL); + MF_FindScriptByName("str"); + MF_SetAmxString(NULL, 0, "str", 0); + MF_GetAmxString(NULL, 0, 0, 0); + MF_GetAmxStringLen(NULL); + MF_CopyAmxMemory(NULL, NULL, 0); + MF_Log("str", "str", 0); + MF_LogError(NULL, 0, NULL); + MF_RaiseAmxError(NULL, 0); + MF_RegisterForward("str", (ForwardExecType)0, 0, 0, 0); + MF_ExecuteForward(0, 0, 0); + MF_PrepareCellArray(NULL, 0); + MF_PrepareCharArray(NULL, 0); + MF_PrepareCellArrayA(NULL, 0, true); + MF_PrepareCharArrayA(NULL, 0, true); + MF_IsPlayerValid(0); + MF_GetPlayerName(0); + MF_GetPlayerIP(0); + MF_IsPlayerIngame(0); + MF_IsPlayerBot(0); + MF_IsPlayerAuthorized(0); + MF_GetPlayerTime(0); + MF_GetPlayerPlayTime(0); + MF_GetPlayerCurweapon(0); + MF_GetPlayerTeamID(0); + MF_GetPlayerTeam(0); + MF_GetPlayerDeaths(0); + MF_GetPlayerMenu(0); + MF_GetPlayerKeys(0); + MF_IsPlayerAlive(0); + MF_GetPlayerFrags(0); + MF_IsPlayerConnecting(0); + MF_IsPlayerHLTV(0); + MF_GetPlayerArmor(0); + MF_GetPlayerHealth(0); + MF_AmxExec(0, 0, 0, 0); + MF_AmxExecv(0, 0, 0, 0, 0); + MF_AmxFindPublic(0, 0, 0); + MF_AmxAllot(0, 0, 0, 0); + MF_LoadAmxScript(0, 0, 0, 0, 0); + MF_UnloadAmxScript(0, 0); + MF_RegisterSPForward(0, 0, 0, 0, 0, 0); + MF_RegisterSPForwardByName(0, 0, 0, 0, 0, 0); + MF_UnregisterSPForward(0); + MF_GetPlayerFrags(0); + MF_GetPlayerEdict(0); + MF_Format("", 4, "str"); +} +#endif + +/************* MEMORY *************/ +// undef all defined macros +#undef new +#undef delete +#undef malloc +#undef calloc +#undef realloc +#undef free + +const unsigned int m_alloc_unknown = 0; +const unsigned int m_alloc_new = 1; +const unsigned int m_alloc_new_array = 2; +const unsigned int m_alloc_malloc = 3; +const unsigned int m_alloc_calloc = 4; +const unsigned int m_alloc_realloc = 5; +const unsigned int m_alloc_delete = 6; +const unsigned int m_alloc_delete_array = 7; +const unsigned int m_alloc_free = 8; + +const char *g_Mem_CurrentFilename = "??"; +int g_Mem_CurrentLine = 0; +const char *g_Mem_CurrentFunc = "??"; + +const char *Mem_MakeSourceFile(const char *sourceFile) +{ + static char buffer[512]; + static size_t pos = 0; + if (!pos) + { + // init + buffer[0] = '['; + strcpy(buffer + 1, MODULE_NAME); + pos = strlen(MODULE_NAME) + 1; + buffer[pos++] = ']'; + } + + // convert from absolute path to [modulename]filename + const char *ptr = strrchr(sourceFile, '\\'); + if (ptr) + ptr++; + else + { + ptr = strrchr(sourceFile, '/'); + if (ptr) + ptr++; + else + ptr = sourceFile; + } + strcpy(buffer + pos, ptr); + return buffer; +} + +void Mem_SetOwner(const char *filename, int line, const char *function) +{ + g_Mem_CurrentFilename = filename; + g_Mem_CurrentLine = line; + g_Mem_CurrentFunc = function; +} + +void Mem_ResetGlobals() +{ + Mem_SetOwner("??", 0, "??"); +} + +// raw (re/de)allocators +void * Mem_Allocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc, + const unsigned int allocationType, const size_t reportedSize) +{ + if (g_fn_Allocator) + return g_fn_Allocator(Mem_MakeSourceFile(sourceFile), sourceLine, sourceFunc, allocationType, reportedSize); + else + return malloc(reportedSize); +} + +void * Mem_Reallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc, + const unsigned int reallocationType, const size_t reportedSize, void *reportedAddress) +{ + if (g_fn_Reallocator) + return g_fn_Reallocator(Mem_MakeSourceFile(sourceFile), sourceLine, sourceFunc, reallocationType, reportedSize, reportedAddress); + else + return realloc(reportedAddress, reportedSize); +} + +void Mem_Deallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc, + const unsigned int deallocationType, void *reportedAddress) +{ + // If you you get user breakpoint here, something failed :) + // - invalid pointer + // - alloc type mismatch ( for example + // char *a = new char[5]; delete char; + // ) + // - The allocation unit is damaged (for example + // char *a = new char[5]; a[6] = 8; + // ) + // - break on dealloc flag set (somehow) + + if (g_fn_Deallocator) + g_fn_Deallocator(Mem_MakeSourceFile(sourceFile), sourceLine, sourceFunc, deallocationType, reportedAddress); + else + free(reportedAddress); +} + +// new and delete operators +void *operator new(size_t reportedSize) +{ + if (reportedSize == 0) + reportedSize = 1; + void *ptr = Mem_Allocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_new, reportedSize); + // :TODO: Handler support ? + if (ptr) + return ptr; + + // allocation failed + return NULL; +} + +void *operator new[](size_t reportedSize) +{ + if (reportedSize == 0) + reportedSize = 1; + void *ptr = Mem_Allocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_new_array, reportedSize); + // :TODO: Handler support ? + if (ptr) + return ptr; + + // allocation failed + return NULL; +} + +// Microsoft memory tracking operators +void *operator new(size_t reportedSize, const char *sourceFile, int sourceLine) +{ + if (reportedSize == 0) + reportedSize = 1; + void *ptr = Mem_Allocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_new, reportedSize); + // :TODO: Handler support ? + if (ptr) + return ptr; + + // allocation failed + return NULL; +} +void *operator new[](size_t reportedSize, const char *sourceFile, int sourceLine) +{ + if (reportedSize == 0) + reportedSize = 1; + void *ptr = Mem_Allocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_new_array, reportedSize); + // :TODO: Handler support ? + if (ptr) + return ptr; + + // allocation failed + return NULL; +} + +void operator delete(void *reportedAddress) +{ + if (!reportedAddress) + return; + + Mem_Deallocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_delete, reportedAddress); +} + +void operator delete[](void *reportedAddress) +{ + if (!reportedAddress) + return; + + Mem_Deallocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_delete_array, reportedAddress); +} + +/************* stuff from dlls/util.cpp *************/ +// must come here because cbase.h declares it's own operator new + +#ifdef USE_METAMOD + +// Selected portions of dlls/util.cpp from SDK 2.1. +// Functions copied from there as needed... +// And modified to avoid buffer overflows (argh). + +/*** +* +* Copyright (c) 1999, 2000 Valve LLC. All rights reserved. +* +* This product contains software technology licensed from Id +* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc. +* All Rights Reserved. +* +* Use, distribution, and modification of this source code and/or resulting +* object code is restricted to non-commercial enhancements to products from +* Valve LLC. All other use, distribution, or modification is prohibited +* without written permission from Valve LLC. +* +****/ +/* + +===== util.cpp ======================================================== + + Utility code. Really not optional after all. + +*/ + +#include +#include "sdk_util.h" +#include + +#include // for strncpy(), etc + +#include "osdep.h" // win32 vsnprintf, etc + +char* UTIL_VarArgs( char *format, ... ) +{ + va_list argptr; + static char string[1024]; + + va_start (argptr, format); + vsnprintf (string, sizeof(string), format, argptr); + va_end (argptr); + + return string; +} + + +//========================================================= +// UTIL_LogPrintf - Prints a logged message to console. +// Preceded by LOG: ( timestamp ) < message > +//========================================================= +void UTIL_LogPrintf( char *fmt, ... ) +{ + va_list argptr; + static char string[1024]; + + va_start ( argptr, fmt ); + vsnprintf ( string, sizeof(string), fmt, argptr ); + va_end ( argptr ); + + // Print to server console + ALERT( at_logged, "%s", string ); +} + + +void UTIL_HudMessage(CBaseEntity *pEntity, const hudtextparms_t &textparms, + const char *pMessage) +{ + if ( !pEntity ) + return; + + MESSAGE_BEGIN( MSG_ONE, SVC_TEMPENTITY, NULL, ENT(pEntity->pev) ); + WRITE_BYTE( TE_TEXTMESSAGE ); + WRITE_BYTE( textparms.channel & 0xFF ); + + WRITE_SHORT( FixedSigned16( textparms.x, 1<<13 ) ); + WRITE_SHORT( FixedSigned16( textparms.y, 1<<13 ) ); + WRITE_BYTE( textparms.effect ); + + WRITE_BYTE( textparms.r1 ); + WRITE_BYTE( textparms.g1 ); + WRITE_BYTE( textparms.b1 ); + WRITE_BYTE( textparms.a1 ); + + WRITE_BYTE( textparms.r2 ); + WRITE_BYTE( textparms.g2 ); + WRITE_BYTE( textparms.b2 ); + WRITE_BYTE( textparms.a2 ); + + WRITE_SHORT( FixedUnsigned16( textparms.fadeinTime, 1<<8 ) ); + WRITE_SHORT( FixedUnsigned16( textparms.fadeoutTime, 1<<8 ) ); + WRITE_SHORT( FixedUnsigned16( textparms.holdTime, 1<<8 ) ); + + if ( textparms.effect == 2 ) + WRITE_SHORT( FixedUnsigned16( textparms.fxTime, 1<<8 ) ); + + if ( strlen( pMessage ) < 512 ) + { + WRITE_STRING( pMessage ); + } + else + { + char tmp[512]; + strncpy( tmp, pMessage, 511 ); + tmp[511] = 0; + WRITE_STRING( tmp ); + } + MESSAGE_END(); +} + +short FixedSigned16( float value, float scale ) +{ + int output; + + output = (int) (value * scale); + + if ( output > 32767 ) + output = 32767; + + if ( output < -32768 ) + output = -32768; + + return (short)output; +} + +unsigned short FixedUnsigned16( float value, float scale ) +{ + int output; + + output = (int) (value * scale); + if ( output < 0 ) + output = 0; + if ( output > 0xFFFF ) + output = 0xFFFF; + + return (unsigned short)output; +} +#endif // USE_METAMOD diff --git a/dlls/csx_sql/amxxmodule.h b/dlls/csx_sql/amxxmodule.h new file mode 100755 index 00000000..e0b0e8fa --- /dev/null +++ b/dlls/csx_sql/amxxmodule.h @@ -0,0 +1,2197 @@ +/* + * AMX Mod X Module Interface Functions + * This file may be freely used +*/ + +// prevent double include +#ifndef __AMXXMODULE_H__ +#define __AMXXMODULE_H__ + +// config +#include "moduleconfig.h" + +// metamod include files +#ifdef USE_METAMOD +#include +#include +#include "osdep.h" +#endif // #ifdef USE_METAMOD + +// DLL Export +#undef DLLEXPORT +#ifndef __linux__ +#define DLLEXPORT __declspec(dllexport) +#else +#define DLLEXPORT +#define LINUX +#endif + +#undef C_DLLEXPORT +#define C_DLLEXPORT extern "C" DLLEXPORT + +// ***** AMXX stuff ***** + +// module interface version is 1 +#define AMXX_INTERFACE_VERSION 1 + +// amxx module info +struct amxx_module_info_s +{ + const char *name; + const char *author; + const char *version; + int reload; // reload on mapchange when nonzero +}; + + + +// return values from functions called by amxx +#define AMXX_OK 0 /* no error */ +#define AMXX_IFVERS 1 /* interface version */ +#define AMXX_PARAM 2 /* Invalid parameter */ +#define AMXX_FUNC_NOT_PRESENT 3 /* Function not present */ + +// *** Small stuff *** +// The next section is copied from the amx.h file +// Copyright (c) ITB CompuPhase, 1997-2004 + +#if defined __LCC__ || defined __DMC__ || defined __linux__ || defined __GNUC__ + #include +#elif !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L + /* The ISO C99 defines the int16_t and int_32t types. If the compiler got + * here, these types are probably undefined. + */ + #if defined __FreeBSD__ + #include + #else + typedef short int int16_t; + typedef unsigned short int uint16_t; + #if defined SN_TARGET_PS2 + typedef int int32_t; + typedef unsigned int uint32_t; + #else + typedef long int int32_t; + typedef unsigned long int uint32_t; + #endif + #if defined __WIN32__ || defined _WIN32 || defined WIN32 + typedef __int64 int64_t; + typedef unsigned __int64 uint64_t; + #define HAVE_I64 + #elif defined __GNUC__ + typedef long long int64_t; + typedef unsigned long long uint64_t; + #define HAVE_I64 + #endif + #endif +#endif + + +/* calling convention for native functions */ +#if !defined AMX_NATIVE_CALL + #define AMX_NATIVE_CALL +#endif +/* calling convention for all interface functions and callback functions */ +#if !defined AMXAPI + #if defined STDECL + #define AMXAPI __stdcall + #elif defined CDECL + #define AMXAPI __cdecl + #else + #define AMXAPI + #endif +#endif +#if !defined AMXEXPORT + #define AMXEXPORT +#endif + + + +#if !defined SMALL_CELL_SIZE + #define SMALL_CELL_SIZE 32 /* by default, use 32-bit cells */ +#endif +#if SMALL_CELL_SIZE==32 + typedef uint32_t ucell; + typedef int32_t cell; + typedef float REAL; +#elif SMALL_CELL_SIZE==64 + typedef uint64_t ucell; + typedef int64_t cell; + typedef double REAL; +#else + #error Unsupported cell size (SMALL_CELL_SIZE) +#endif + +#define UNPACKEDMAX ((1 << (sizeof(cell)-1)*8) - 1) + +struct tagAMX; +typedef cell (AMX_NATIVE_CALL *AMX_NATIVE)(struct tagAMX *amx, cell *params); +typedef int (AMXAPI *AMX_CALLBACK)(struct tagAMX *amx, cell index, + cell *result, cell *params); +typedef int (AMXAPI *AMX_DEBUG)(struct tagAMX *amx); +#if !defined _FAR + #define _FAR +#endif + +#if defined _MSC_VER + #pragma warning(disable:4103) /* disable warning message 4103 that complains + * about pragma pack in a header file */ + #pragma warning(disable:4100) /* "'%$S' : unreferenced formal parameter" */ +#endif + + +#if defined SN_TARGET_PS2 || defined __GNUC__ + #define AMX_NO_ALIGN +#endif + + +#if defined __GNUC__ + #define PACKED __attribute__((packed)) +#else + #define PACKED +#endif + + +#if !defined AMX_NO_ALIGN + #if defined __linux__ + #pragma pack(1) /* structures must be packed (byte-aligned) */ + #else + #pragma pack(push) + #pragma pack(1) /* structures must be packed (byte-aligned) */ + #if defined __TURBOC__ + #pragma option -a- /* "pack" pragma for older Borland compilers */ + #endif + #endif +#endif + +typedef struct { + const char _FAR *name PACKED; + AMX_NATIVE func PACKED; +} AMX_NATIVE_INFO; + +#define AMX_USERNUM 4 + +/* The AMX structure is the internal structure for many functions. Not all + * fields are valid at all times; many fields are cached in local variables. + */ +typedef struct tagAMX { + unsigned char _FAR *base PACKED; /* points to the AMX header ("amxhdr") plus the code, optionally also the data */ + unsigned char _FAR *data PACKED; /* points to separate data+stack+heap, may be NULL */ + AMX_CALLBACK callback PACKED; + AMX_DEBUG debug PACKED; /* debug callback */ + /* for external functions a few registers must be accessible from the outside */ + cell cip PACKED; /* instruction pointer: relative to base + amxhdr->cod */ + cell frm PACKED; /* stack frame base: relative to base + amxhdr->dat */ + cell hea PACKED; /* top of the heap: relative to base + amxhdr->dat */ + cell hlw PACKED; /* bottom of the heap: relative to base + amxhdr->dat */ + cell stk PACKED; /* stack pointer: relative to base + amxhdr->dat */ + cell stp PACKED; /* top of the stack: relative to base + amxhdr->dat */ + int flags PACKED; /* current status, see amx_Flags() */ + /* for assertions and debug hook */ + cell curline PACKED; + cell curfile PACKED; + int dbgcode PACKED; + cell dbgaddr PACKED; + cell dbgparam PACKED; + char _FAR *dbgname PACKED; + /* user data */ + long usertags[AMX_USERNUM] PACKED; + void _FAR *userdata[AMX_USERNUM] PACKED; + /* native functions can raise an error */ + int error PACKED; + /* the sleep opcode needs to store the full AMX status */ + cell pri PACKED; + cell alt PACKED; + cell reset_stk PACKED; + cell reset_hea PACKED; + cell sysreq_d PACKED; /* relocated address/value for the SYSREQ.D opcode */ + /* support variables for the JIT */ + int reloc_size PACKED; /* required temporary buffer for relocations */ + long code_size PACKED; /* estimated memory footprint of the native code */ +} AMX; + +enum { + AMX_ERR_NONE, + /* reserve the first 15 error codes for exit codes of the abstract machine */ + AMX_ERR_EXIT, /* forced exit */ + AMX_ERR_ASSERT, /* assertion failed */ + AMX_ERR_STACKERR, /* stack/heap collision */ + AMX_ERR_BOUNDS, /* index out of bounds */ + AMX_ERR_MEMACCESS, /* invalid memory access */ + AMX_ERR_INVINSTR, /* invalid instruction */ + AMX_ERR_STACKLOW, /* stack underflow */ + AMX_ERR_HEAPLOW, /* heap underflow */ + AMX_ERR_CALLBACK, /* no callback, or invalid callback */ + AMX_ERR_NATIVE, /* native function failed */ + AMX_ERR_DIVIDE, /* divide by zero */ + AMX_ERR_SLEEP, /* go into sleepmode - code can be restarted */ + + AMX_ERR_MEMORY = 16, /* out of memory */ + AMX_ERR_FORMAT, /* invalid file format */ + AMX_ERR_VERSION, /* file is for a newer version of the AMX */ + AMX_ERR_NOTFOUND, /* function not found */ + AMX_ERR_INDEX, /* invalid index parameter (bad entry point) */ + AMX_ERR_DEBUG, /* debugger cannot run */ + AMX_ERR_INIT, /* AMX not initialized (or doubly initialized) */ + AMX_ERR_USERDATA, /* unable to set user data field (table full) */ + AMX_ERR_INIT_JIT, /* cannot initialize the JIT */ + AMX_ERR_PARAMS, /* parameter error */ + AMX_ERR_DOMAIN, /* domain error, expression result does not fit in range */ +}; + +#if !defined AMX_NO_ALIGN + #if defined __linux__ + #pragma pack() /* reset default packing */ + #else + #pragma pack(pop) /* reset previous packing */ + #endif +#endif + + +// ***** declare functions ***** + +#ifdef USE_METAMOD +void UTIL_LogPrintf( char *fmt, ... ); +void UTIL_HudMessage(CBaseEntity *pEntity, const hudtextparms_t &textparms, const char *pMessage); +short FixedSigned16( float value, float scale ); +unsigned short FixedUnsigned16( float value, float scale ); + +#ifdef FN_META_QUERY +void FN_META_QUERY(void); +#endif // FN_META_QUERY + +#ifdef FN_META_ATTACH +void FN_META_ATTACH(void); +#endif // FN_META_ATTACH + +#ifdef FN_META_DETACH +void FN_META_DETACH(void); +#endif // FN_META_DETACH + + + + + +#ifdef FN_GameDLLInit +void FN_GameDLLInit(void); +#endif // FN_GameDLLInit + +#ifdef FN_DispatchSpawn +int FN_DispatchSpawn(edict_t *pent); +#endif // FN_DispatchSpawn + +#ifdef FN_DispatchThink +void FN_DispatchThink(edict_t *pent); +#endif // FN_DispatchThink + +#ifdef FN_DispatchUse +void FN_DispatchUse(edict_t *pentUser, edict_t *pentOther); +#endif // FN_DispatchUse + +#ifdef FN_DispatchTouch +void FN_DispatchTouch(edict_t *pentTouched, edict_t *pentOther); +#endif // FN_DispatchTouch + +#ifdef FN_DispatchBlocked +void FN_DispatchBlocked(edict_t *pentBlocked, edict_t *pentOther); +#endif // FN_DispatchBlocked + +#ifdef FN_DispatchKeyValue +void FN_DispatchKeyValue(edict_t *pentKeyvalue, KeyValueData *pkvd); +#endif // FN_DispatchKeyValue + +#ifdef FN_DispatchSave +void FN_DispatchSave(edict_t *pent, SAVERESTOREDATA *pSaveData); +#endif // FN_DispatchSave + +#ifdef FN_DispatchRestore +int FN_DispatchRestore(edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity); +#endif // FN_DispatchRestore + +#ifdef FN_DispatchObjectCollsionBox +void FN_DispatchObjectCollsionBox(edict_t *pent); +#endif // FN_DispatchObjectCollsionBox + +#ifdef FN_SaveWriteFields +void FN_SaveWriteFields(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount); +#endif // FN_SaveWriteFields + +#ifdef FN_SaveReadFields +void FN_SaveReadFields(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount); +#endif // FN_SaveReadFields + +#ifdef FN_SaveGlobalState +void FN_SaveGlobalState(SAVERESTOREDATA *pSaveData); +#endif // FN_SaveGlobalState + +#ifdef FN_RestoreGlobalState +void FN_RestoreGlobalState(SAVERESTOREDATA *pSaveData); +#endif // FN_RestoreGlobalState + +#ifdef FN_ResetGlobalState +void FN_ResetGlobalState(void); +#endif // FN_ResetGlobalState + +#ifdef FN_ClientConnect +BOOL FN_ClientConnect(edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ]); +#endif // FN_ClientConnect + +#ifdef FN_ClientDisconnect +void FN_ClientDisconnect(edict_t *pEntity); +#endif // FN_ClientDisconnect + +#ifdef FN_ClientKill +void FN_ClientKill(edict_t *pEntity); +#endif // FN_ClientKill + +#ifdef FN_ClientPutInServer +void FN_ClientPutInServer(edict_t *pEntity); +#endif // FN_ClientPutInServer + +#ifdef FN_ClientCommand +void FN_ClientCommand(edict_t *pEntity); +#endif // FN_ClientCommand + +#ifdef FN_ClientUserInfoChanged +void FN_ClientUserInfoChanged(edict_t *pEntity, char *infobuffer); +#endif // FN_ClientUserInfoChanged + +#ifdef FN_ServerActivate +void FN_ServerActivate(edict_t *pEdictList, int edictCount, int clientMax); +#endif // FN_ServerActivate + +#ifdef FN_ServerDeactivate +void FN_ServerDeactivate(void); +#endif // FN_ServerDeactivate + +#ifdef FN_PlayerPreThink +void FN_PlayerPreThink(edict_t *pEntity); +#endif // FN_PlayerPreThink + +#ifdef FN_PlayerPostThink +void FN_PlayerPostThink(edict_t *pEntity); +#endif // FN_PlayerPostThink + +#ifdef FN_StartFrame +void FN_StartFrame(void); +#endif // FN_StartFrame + +#ifdef FN_ParmsNewLevel +void FN_ParmsNewLevel(void); +#endif // FN_ParmsNewLevel + +#ifdef FN_ParmsChangeLevel +void FN_ParmsChangeLevel(void); +#endif // FN_ParmsChangeLevel + +#ifdef FN_GetGameDescription +const char *FN_GetGameDescription(void); +#endif // FN_GetGameDescription + +#ifdef FN_PlayerCustomization +void FN_PlayerCustomization(edict_t *pEntity, customization_t *pCust); +#endif // FN_PlayerCustomization + +#ifdef FN_SpectatorConnect +void FN_SpectatorConnect(edict_t *pEntity); +#endif // FN_SpectatorConnect + +#ifdef FN_SpectatorDisconnect +void FN_SpectatorDisconnect(edict_t *pEntity); +#endif // FN_SpectatorDisconnect + +#ifdef FN_SpectatorThink +void FN_SpectatorThink(edict_t *pEntity); +#endif // FN_SpectatorThink + +#ifdef FN_Sys_Error +void FN_Sys_Error(const char *error_string); +#endif // FN_Sys_Error + +#ifdef FN_PM_Move +void FN_PM_Move(struct playermove_s *ppmove, int server); +#endif // FN_PM_Move + +#ifdef FN_PM_Init +void FN_PM_Init(struct playermove_s *ppmove); +#endif // FN_PM_Init + +#ifdef FN_PM_FindTextureType +char FN_PM_FindTextureType(char *name); +#endif // FN_PM_FindTextureType + +#ifdef FN_SetupVisibility +void FN_SetupVisibility(edict_t *pViewEntity, edict_t *pClient, unsigned char **pvs, unsigned char **pas); +#endif // FN_SetupVisibility + +#ifdef FN_UpdateClientData +void FN_UpdateClientData(const struct edict_s *ent, int sendweapons, struct clientdata_s *cd); +#endif // FN_UpdateClientData + +#ifdef FN_AddToFullPack +int FN_AddToFullPack(struct entity_state_s *state, int e, edict_t *ent, edict_t *host, int hostflags, int player, unsigned char *pSet); +#endif // FN_AddToFullPack + +#ifdef FN_CreateBaseline +void FN_CreateBaseline(int player, int eindex, struct entity_state_s *baseline, struct edict_s *entity, int playermodelindex, vec3_t player_mins, vec3_t player_maxs); +#endif // FN_CreateBaseline + +#ifdef FN_RegisterEncoders +void FN_RegisterEncoders(void); +#endif // FN_RegisterEncoders + +#ifdef FN_GetWeaponData +int FN_GetWeaponData(struct edict_s *player, struct weapon_data_s *info); +#endif // FN_GetWeaponData + +#ifdef FN_CmdStart +void FN_CmdStart(const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed); +#endif // FN_CmdStart + +#ifdef FN_CmdEnd +void FN_CmdEnd(const edict_t *player); +#endif // FN_CmdEnd + +#ifdef FN_ConnectionlessPacket +int FN_ConnectionlessPacket(const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size); +#endif // FN_ConnectionlessPacket + +#ifdef FN_GetHullBounds +int FN_GetHullBounds(int hullnumber, float *mins, float *maxs); +#endif // FN_GetHullBounds + +#ifdef FN_CreateInstancedBaselines +void FN_CreateInstancedBaselines(void); +#endif // FN_CreateInstancedBaselines + +#ifdef FN_InconsistentFile +int FN_InconsistentFile(const edict_t *player, const char *filename, char *disconnect_message); +#endif // FN_InconsistentFile + +#ifdef FN_AllowLagCompensation +int FN_AllowLagCompensation(void); +#endif // FN_AllowLagCompensation + + + + +#ifdef FN_GameDLLInit_Post +void FN_GameDLLInit_Post(void); +#endif // FN_GameDLLInit_Post + +#ifdef FN_DispatchSpawn_Post +int FN_DispatchSpawn_Post(edict_t *pent); +#endif // FN_DispatchSpawn_Post + +#ifdef FN_DispatchThink_Post +void FN_DispatchThink_Post(edict_t *pent); +#endif // FN_DispatchThink_Post + +#ifdef FN_DispatchUse_Post +void FN_DispatchUse_Post(edict_t *pentUser, edict_t *pentOther); +#endif // FN_DispatchUse_Post + +#ifdef FN_DispatchTouch_Post +void FN_DispatchTouch_Post(edict_t *pentTouched, edict_t *pentOther); +#endif // FN_DispatchTouch_Post + +#ifdef FN_DispatchBlocked_Post +void FN_DispatchBlocked_Post(edict_t *pentBlocked, edict_t *pentOther); +#endif // FN_DispatchBlocked_Post + +#ifdef FN_DispatchKeyValue_Post +void FN_DispatchKeyValue_Post(edict_t *pentKeyvalue, KeyValueData *pkvd); +#endif // FN_DispatchKeyValue_Post + +#ifdef FN_DispatchSave_Post +void FN_DispatchSave_Post(edict_t *pent, SAVERESTOREDATA *pSaveData); +#endif // FN_DispatchSave_Post + +#ifdef FN_DispatchRestore_Post +int FN_DispatchRestore_Post(edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity); +#endif // FN_DispatchRestore_Post + +#ifdef FN_DispatchObjectCollsionBox_Post +void FN_DispatchObjectCollsionBox_Post(edict_t *pent); +#endif // FN_DispatchObjectCollsionBox_Post + +#ifdef FN_SaveWriteFields_Post +void FN_SaveWriteFields_Post(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount); +#endif // FN_SaveWriteFields_Post + +#ifdef FN_SaveReadFields_Post +void FN_SaveReadFields_Post(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount); +#endif // FN_SaveReadFields_Post + +#ifdef FN_SaveGlobalState_Post +void FN_SaveGlobalState_Post(SAVERESTOREDATA *pSaveData); +#endif // FN_SaveGlobalState_Post + +#ifdef FN_RestoreGlobalState_Post +void FN_RestoreGlobalState_Post(SAVERESTOREDATA *pSaveData); +#endif // FN_RestoreGlobalState_Post + +#ifdef FN_ResetGlobalState_Post +void FN_ResetGlobalState_Post(void); +#endif // FN_ResetGlobalState_Post + +#ifdef FN_ClientConnect_Post +BOOL FN_ClientConnect_Post(edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ]); +#endif // FN_ClientConnect_Post + +#ifdef FN_ClientDisconnect_Post +void FN_ClientDisconnect_Post(edict_t *pEntity); +#endif // FN_ClientDisconnect_Post + +#ifdef FN_ClientKill_Post +void FN_ClientKill_Post(edict_t *pEntity); +#endif // FN_ClientKill_Post + +#ifdef FN_ClientPutInServer_Post +void FN_ClientPutInServer_Post(edict_t *pEntity); +#endif // FN_ClientPutInServer_Post + +#ifdef FN_ClientCommand_Post +void FN_ClientCommand_Post(edict_t *pEntity); +#endif // FN_ClientCommand_Post + +#ifdef FN_ClientUserInfoChanged_Post +void FN_ClientUserInfoChanged_Post(edict_t *pEntity, char *infobuffer); +#endif // FN_ClientUserInfoChanged_Post + +#ifdef FN_ServerActivate_Post +void FN_ServerActivate_Post(edict_t *pEdictList, int edictCount, int clientMax); +#endif // FN_ServerActivate_Post + +#ifdef FN_ServerDeactivate_Post +void FN_ServerDeactivate_Post(void); +#endif // FN_ServerDeactivate_Post + +#ifdef FN_PlayerPreThink_Post +void FN_PlayerPreThink_Post(edict_t *pEntity); +#endif // FN_PlayerPreThink_Post + +#ifdef FN_PlayerPostThink_Post +void FN_PlayerPostThink_Post(edict_t *pEntity); +#endif // FN_PlayerPostThink_Post + +#ifdef FN_StartFrame_Post +void FN_StartFrame_Post(void); +#endif // FN_StartFrame_Post + +#ifdef FN_ParmsNewLevel_Post +void FN_ParmsNewLevel_Post(void); +#endif // FN_ParmsNewLevel_Post + +#ifdef FN_ParmsChangeLevel_Post +void FN_ParmsChangeLevel_Post(void); +#endif // FN_ParmsChangeLevel_Post + +#ifdef FN_GetGameDescription_Post +const char *FN_GetGameDescription_Post(void); +#endif // FN_GetGameDescription_Post + +#ifdef FN_PlayerCustomization_Post +void FN_PlayerCustomization_Post(edict_t *pEntity, customization_t *pCust); +#endif // FN_PlayerCustomization_Post + +#ifdef FN_SpectatorConnect_Post +void FN_SpectatorConnect_Post(edict_t *pEntity); +#endif // FN_SpectatorConnect_Post + +#ifdef FN_SpectatorDisconnect_Post +void FN_SpectatorDisconnect_Post(edict_t *pEntity); +#endif // FN_SpectatorDisconnect_Post + +#ifdef FN_SpectatorThink_Post +void FN_SpectatorThink_Post(edict_t *pEntity); +#endif // FN_SpectatorThink_Post + +#ifdef FN_Sys_Error_Post +void FN_Sys_Error_Post(const char *error_string); +#endif // FN_Sys_Error_Post + +#ifdef FN_PM_Move_Post +void FN_PM_Move_Post(struct playermove_s *ppmove, int server); +#endif // FN_PM_Move_Post + +#ifdef FN_PM_Init_Post +void FN_PM_Init_Post(struct playermove_s *ppmove); +#endif // FN_PM_Init_Post + +#ifdef FN_PM_FindTextureType_Post +char FN_PM_FindTextureType_Post(char *name); +#endif // FN_PM_FindTextureType_Post + +#ifdef FN_SetupVisibility_Post +void FN_SetupVisibility_Post(edict_t *pViewEntity, edict_t *pClient, unsigned char **pvs, unsigned char **pas); +#endif // FN_SetupVisibility_Post + +#ifdef FN_UpdateClientData_Post +void FN_UpdateClientData_Post(const struct edict_s *ent, int sendweapons, struct clientdata_s *cd); +#endif // FN_UpdateClientData_Post + +#ifdef FN_AddToFullPack_Post +int FN_AddToFullPack_Post(struct entity_state_s *state, int e, edict_t *ent, edict_t *host, int hostflags, int player, unsigned char *pSet); +#endif // FN_AddToFullPack_Post + +#ifdef FN_CreateBaseline_Post +void FN_CreateBaseline_Post(int player, int eindex, struct entity_state_s *baseline, struct edict_s *entity, int playermodelindex, vec3_t player_mins, vec3_t player_maxs); +#endif // FN_CreateBaseline_Post + +#ifdef FN_RegisterEncoders_Post +void FN_RegisterEncoders_Post(void); +#endif // FN_RegisterEncoders_Post + +#ifdef FN_GetWeaponData_Post +int FN_GetWeaponData_Post(struct edict_s *player, struct weapon_data_s *info); +#endif // FN_GetWeaponData_Post + +#ifdef FN_CmdStart_Post +void FN_CmdStart_Post(const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed); +#endif // FN_CmdStart_Post + +#ifdef FN_CmdEnd_Post +void FN_CmdEnd_Post(const edict_t *player); +#endif // FN_CmdEnd_Post + +#ifdef FN_ConnectionlessPacket_Post +int FN_ConnectionlessPacket_Post(const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size); +#endif // FN_ConnectionlessPacket_Post + +#ifdef FN_GetHullBounds_Post +int FN_GetHullBounds_Post(int hullnumber, float *mins, float *maxs); +#endif // FN_GetHullBounds_Post + +#ifdef FN_CreateInstancedBaselines_Post +void FN_CreateInstancedBaselines_Post(void); +#endif // FN_CreateInstancedBaselines_Post + +#ifdef FN_InconsistentFile_Post +int FN_InconsistentFile_Post(const edict_t *player, const char *filename, char *disconnect_message); +#endif // FN_InconsistentFile_Post + +#ifdef FN_AllowLagCompensation_Post +int FN_AllowLagCompensation_Post(void); +#endif // FN_AllowLagCompensation_Post + + + +#ifdef FN_PrecacheModel +int FN_PrecacheModel(char *s); +#endif // FN_PrecacheModel + +#ifdef FN_PrecacheSound +int FN_PrecacheSound(char *s); +#endif // FN_PrecacheSound + +#ifdef FN_SetModel +void FN_SetModel(edict_t *e, const char *m); +#endif // FN_SetModel + +#ifdef FN_ModelIndex +int FN_ModelIndex(const char *m); +#endif // FN_ModelIndex + +#ifdef FN_ModelFrames +int FN_ModelFrames(int modelIndex); +#endif // FN_ModelFrames + +#ifdef FN_SetSize +void FN_SetSize(edict_t *e, const float *rgflMin, const float *rgflMax); +#endif // FN_SetSize + +#ifdef FN_ChangeLevel +void FN_ChangeLevel(char *s1, char *s2); +#endif // FN_ChangeLevel + +#ifdef FN_GetSpawnParms +void FN_GetSpawnParms(edict_t *ent); +#endif // FN_GetSpawnParms + +#ifdef FN_SaveSpawnParms +void FN_SaveSpawnParms(edict_t *ent); +#endif // FN_SaveSpawnParms + +#ifdef FN_VecToYaw +float FN_VecToYaw(const float *rgflVector); +#endif // FN_VecToYaw + +#ifdef FN_VecToAngles +void FN_VecToAngles(const float *rgflVectorIn, float *rgflVectorOut); +#endif // FN_VecToAngles + +#ifdef FN_MoveToOrigin +void FN_MoveToOrigin(edict_t *ent, const float *pflGoal, float dist, int iMoveType); +#endif // FN_MoveToOrigin + +#ifdef FN_ChangeYaw +void FN_ChangeYaw(edict_t *ent); +#endif // FN_ChangeYaw + +#ifdef FN_ChangePitch +void FN_ChangePitch(edict_t *ent); +#endif // FN_ChangePitch + +#ifdef FN_FindEntityByString +edict_t *FN_FindEntityByString(edict_t *pEdictStartSearchAfter, const char *pszField, const char *pszValue); +#endif // FN_FindEntityByString + +#ifdef FN_GetEntityIllum +int FN_GetEntityIllum(edict_t *pEnt); +#endif // FN_GetEntityIllum + +#ifdef FN_FindEntityInSphere +edict_t *FN_FindEntityInSphere(edict_t *pEdictStartSearchAfter, const float *org, float rad); +#endif // FN_FindEntityInSphere + +#ifdef FN_FindClientInPVS +edict_t *FN_FindClientInPVS(edict_t *pEdict); +#endif // FN_FindClientInPVS + +#ifdef FN_EntitiesInPVS +edict_t *FN_EntitiesInPVS(edict_t *pplayer); +#endif // FN_EntitiesInPVS + +#ifdef FN_MakeVectors +void FN_MakeVectors(const float *rgflVector); +#endif // FN_MakeVectors + +#ifdef FN_AngleVectors +void FN_AngleVectors(const float *rgflVector, float *forward, float *right, float *up); +#endif // FN_AngleVectors + +#ifdef FN_CreateEntity +edict_t *FN_CreateEntity(void); +#endif // FN_CreateEntity + +#ifdef FN_RemoveEntity +void FN_RemoveEntity(edict_t *e); +#endif // FN_RemoveEntity + +#ifdef FN_CreateNamedEntity +edict_t *FN_CreateNamedEntity(int className); +#endif // FN_CreateNamedEntity + +#ifdef FN_MakeStatic +void FN_MakeStatic(edict_t *ent); +#endif // FN_MakeStatic + +#ifdef FN_EntIsOnFloor +int FN_EntIsOnFloor(edict_t *ent); +#endif // FN_EntIsOnFloor + +#ifdef FN_DropToFloor +int FN_DropToFloor(edict_t *ent); +#endif // FN_DropToFloor + +#ifdef FN_WalkMove +int FN_WalkMove(edict_t *ent, float yaw, float dist, int iMode); +#endif // FN_WalkMove + +#ifdef FN_SetOrigin +void FN_SetOrigin(edict_t *e, const float *rgflOrigin); +#endif // FN_SetOrigin + +#ifdef FN_EmitSound +void FN_EmitSound(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch); +#endif // FN_EmitSound + +#ifdef FN_EmitAmbientSound +void FN_EmitAmbientSound(edict_t *entity, float *pos, const char *samp, float vol, float attenuation, int fFlags, int pitch); +#endif // FN_EmitAmbientSound + +#ifdef FN_TraceLine +void FN_TraceLine(const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr); +#endif // FN_TraceLine + +#ifdef FN_TraceToss +void FN_TraceToss(edict_t *pent, edict_t *pentToIgnore, TraceResult *ptr); +#endif // FN_TraceToss + +#ifdef FN_TraceMonsterHull +int FN_TraceMonsterHull(edict_t *pEdict, const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr); +#endif // FN_TraceMonsterHull + +#ifdef FN_TraceHull +void FN_TraceHull(const float *v1, const float *v2, int fNoMonsters, int hullNumber, edict_t *pentToSkip, TraceResult *ptr); +#endif // FN_TraceHull + +#ifdef FN_TraceModel +void FN_TraceModel(const float *v1, const float *v2, int hullNumber, edict_t *pent, TraceResult *ptr); +#endif // FN_TraceModel + +#ifdef FN_TraceTexture +const char *FN_TraceTexture(edict_t *pTextureEntity, const float *v1, const float *v2 ); +#endif // FN_TraceTexture + +#ifdef FN_TraceSphere +void FN_TraceSphere(const float *v1, const float *v2, int fNoMonsters, float radius, edict_t *pentToSkip, TraceResult *ptr); +#endif // FN_TraceSphere + +#ifdef FN_GetAimVector +void FN_GetAimVector(edict_t *ent, float speed, float *rgflReturn); +#endif // FN_GetAimVector + +#ifdef FN_ServerCommand +void FN_ServerCommand(char *str); +#endif // FN_ServerCommand + +#ifdef FN_ServerExecute +void FN_ServerExecute(void); +#endif // FN_ServerExecute + +#ifdef FN_engClientCommand +void FN_engClientCommand(edict_t *pEdict, char *szFmt, ...); +#endif // FN_engClientCommand + +#ifdef FN_ParticleEffect +void FN_ParticleEffect(const float *org, const float *dir, float color, float count); +#endif // FN_ParticleEffect + +#ifdef FN_LightStyle +void FN_LightStyle(int style, char *val); +#endif // FN_LightStyle + +#ifdef FN_DecalIndex +int FN_DecalIndex(const char *name); +#endif // FN_DecalIndex + +#ifdef FN_PointContents +int FN_PointContents(const float *rgflVector); +#endif // FN_PointContents + +#ifdef FN_MessageBegin +void FN_MessageBegin(int msg_dest, int msg_type, const float *pOrigin, edict_t *ed); +#endif // FN_MessageBegin + +#ifdef FN_MessageEnd +void FN_MessageEnd(void); +#endif // FN_MessageEnd + +#ifdef FN_WriteByte +void FN_WriteByte(int iValue); +#endif // FN_WriteByte + +#ifdef FN_WriteChar +void FN_WriteChar(int iValue); +#endif // FN_WriteChar + +#ifdef FN_WriteShort +void FN_WriteShort(int iValue); +#endif // FN_WriteShort + +#ifdef FN_WriteLong +void FN_WriteLong(int iValue); +#endif // FN_WriteLong + +#ifdef FN_WriteAngle +void FN_WriteAngle(float flValue); +#endif // FN_WriteAngle + +#ifdef FN_WriteCoord +void FN_WriteCoord(float flValue); +#endif // FN_WriteCoord + +#ifdef FN_WriteString +void FN_WriteString(const char *sz); +#endif // FN_WriteString + +#ifdef FN_WriteEntity +void FN_WriteEntity(int iValue); +#endif // FN_WriteEntity + +#ifdef FN_CVarRegister +void FN_CVarRegister(cvar_t *pCvar); +#endif // FN_CVarRegister + +#ifdef FN_CVarGetFloat +float FN_CVarGetFloat(const char *szVarName); +#endif // FN_CVarGetFloat + +#ifdef FN_CVarGetString +const char *FN_CVarGetString(const char *szVarName); +#endif // FN_CVarGetString + +#ifdef FN_CVarSetFloat +void FN_CVarSetFloat(const char *szVarName, float flValue); +#endif // FN_CVarSetFloat + +#ifdef FN_CVarSetString +void FN_CVarSetString(const char *szVarName, const char *szValue); +#endif // FN_CVarSetString + +#ifdef FN_AlertMessage +void FN_AlertMessage(ALERT_TYPE atype, char *szFmt, ...); +#endif // FN_AlertMessage + +#ifdef FN_EngineFprintf +void FN_EngineFprintf(FILE *pfile, char *szFmt, ...); +#endif // FN_EngineFprintf + +#ifdef FN_PvAllocEntPrivateData +void *FN_PvAllocEntPrivateData(edict_t *pEdict, int32 cb); +#endif // FN_PvAllocEntPrivateData + +#ifdef FN_PvEntPrivateData +void *FN_PvEntPrivateData(edict_t *pEdict); +#endif // FN_PvEntPrivateData + +#ifdef FN_FreeEntPrivateData +void FN_FreeEntPrivateData(edict_t *pEdict); +#endif // FN_FreeEntPrivateData + +#ifdef FN_SzFromIndex +const char *FN_SzFromIndex(int iString); +#endif // FN_SzFromIndex + +#ifdef FN_AllocString +int FN_AllocString(const char *szValue); +#endif // FN_AllocString + +#ifdef FN_GetVarsOfEnt +struct entvars_s *FN_GetVarsOfEnt(edict_t *pEdict); +#endif // FN_GetVarsOfEnt + +#ifdef FN_PEntityOfEntOffset +edict_t *FN_PEntityOfEntOffset(int iEntOffset); +#endif // FN_PEntityOfEntOffset + +#ifdef FN_EntOffsetOfPEntity +int FN_EntOffsetOfPEntity(const edict_t *pEdict); +#endif // FN_EntOffsetOfPEntity + +#ifdef FN_IndexOfEdict +int FN_IndexOfEdict(const edict_t *pEdict); +#endif // FN_IndexOfEdict + +#ifdef FN_PEntityOfEntIndex +edict_t *FN_PEntityOfEntIndex(int iEntIndex); +#endif // FN_PEntityOfEntIndex + +#ifdef FN_FindEntityByVars +edict_t *FN_FindEntityByVars(struct entvars_s *pvars); +#endif // FN_FindEntityByVars + +#ifdef FN_GetModelPtr +void *FN_GetModelPtr(edict_t *pEdict); +#endif // FN_GetModelPtr + +#ifdef FN_RegUserMsg +int FN_RegUserMsg(const char *pszName, int iSize); +#endif // FN_RegUserMsg + +#ifdef FN_AnimationAutomove +void FN_AnimationAutomove(const edict_t *pEdict, float flTime); +#endif // FN_AnimationAutomove + +#ifdef FN_GetBonePosition +void FN_GetBonePosition(const edict_t *pEdict, int iBone, float *rgflOrigin, float *rgflAngles); +#endif // FN_GetBonePosition + +#ifdef FN_FunctionFromName +unsigned long FN_FunctionFromName(const char *pName); +#endif // FN_FunctionFromName + +#ifdef FN_NameForFunction +const char *FN_NameForFunction(unsigned long function); +#endif // FN_NameForFunction + +#ifdef FN_ClientPrintf +void FN_ClientPrintf(edict_t *pEdict, PRINT_TYPE ptype, const char *szMsg); +#endif // FN_ClientPrintf + +#ifdef FN_ServerPrint +void FN_ServerPrint(const char *szMsg); +#endif // FN_ServerPrint + +#ifdef FN_Cmd_Args +const char *FN_Cmd_Args(void); +#endif // FN_Cmd_Args + +#ifdef FN_Cmd_Argv +const char *FN_Cmd_Argv(int argc); +#endif // FN_Cmd_Argv + +#ifdef FN_Cmd_Argc +int FN_Cmd_Argc(void); +#endif // FN_Cmd_Argc + +#ifdef FN_GetAttachment +void FN_GetAttachment(const edict_t *pEdict, int iAttachment, float *rgflOrigin, float *rgflAngles ); +#endif // FN_GetAttachment + +#ifdef FN_CRC32_Init +void FN_CRC32_Init(CRC32_t *pulCRC); +#endif // FN_CRC32_Init + +#ifdef FN_CRC32_ProcessBuffer +void FN_CRC32_ProcessBuffer(CRC32_t *pulCRC, void *p, int len); +#endif // FN_CRC32_ProcessBuffer + +#ifdef FN_CRC32_ProcessByte +void FN_CRC32_ProcessByte(CRC32_t *pulCRC, unsigned char ch); +#endif // FN_CRC32_ProcessByte + +#ifdef FN_CRC32_Final +CRC32_t FN_CRC32_Final(CRC32_t pulCRC); +#endif // FN_CRC32_Final + +#ifdef FN_RandomLong +long FN_RandomLong(long lLow, long lHigh); +#endif // FN_RandomLong + +#ifdef FN_RandomFloat +float FN_RandomFloat(float flLow, float flHigh); +#endif // FN_RandomFloat + +#ifdef FN_SetView +void FN_SetView(const edict_t *pClient, const edict_t *pViewent); +#endif // FN_SetView + +#ifdef FN_Time +float FN_Time(void); +#endif // FN_Time + +#ifdef FN_CrosshairAngle +void FN_CrosshairAngle(const edict_t *pClient, float pitch, float yaw); +#endif // FN_CrosshairAngle + +#ifdef FN_LoadFileForMe +byte *FN_LoadFileForMe(char *filename, int *pLength); +#endif // FN_LoadFileForMe + +#ifdef FN_FreeFile +void FN_FreeFile(void *buffer); +#endif // FN_FreeFile + +#ifdef FN_EndSection +void FN_EndSection(const char *pszSectionName); +#endif // FN_EndSection + +#ifdef FN_CompareFileTime +int FN_CompareFileTime(char *filename1, char *filename2, int *iCompare); +#endif // FN_CompareFileTime + +#ifdef FN_GetGameDir +void FN_GetGameDir(char *szGetGameDir); +#endif // FN_GetGameDir + +#ifdef FN_Cvar_RegisterVariable +void FN_Cvar_RegisterVariable(cvar_t *variable); +#endif // FN_Cvar_RegisterVariable + +#ifdef FN_FadeClientVolume +void FN_FadeClientVolume(const edict_t *pEdict, int fadePercent, int fadeOutSeconds, int holdTime, int fadeInSeconds); +#endif // FN_FadeClientVolume + +#ifdef FN_SetClientMaxspeed +void FN_SetClientMaxspeed(const edict_t *pEdict, float fNewMaxspeed); +#endif // FN_SetClientMaxspeed + +#ifdef FN_CreateFakeClient +edict_t *FN_CreateFakeClient(const char *netname); +#endif // FN_CreateFakeClient + +#ifdef FN_RunPlayerMove +void FN_RunPlayerMove(edict_t *fakeclient, const float *viewangles, float forwardmove, float sidemove, float upmove, unsigned short buttons, byte impulse, byte msec); +#endif // FN_RunPlayerMove + +#ifdef FN_NumberOfEntities +int FN_NumberOfEntities(void); +#endif // FN_NumberOfEntities + +#ifdef FN_GetInfoKeyBuffer +char *FN_GetInfoKeyBuffer(edict_t *e); +#endif // FN_GetInfoKeyBuffer + +#ifdef FN_InfoKeyValue +char *FN_InfoKeyValue(char *infobuffer, char *key); +#endif // FN_InfoKeyValue + +#ifdef FN_SetKeyValue +void FN_SetKeyValue(char *infobuffer, char *key, char *value); +#endif // FN_SetKeyValue + +#ifdef FN_SetClientKeyValue +void FN_SetClientKeyValue(int clientIndex, char *infobuffer, char *key, char *value); +#endif // FN_SetClientKeyValue + +#ifdef FN_IsMapValid +int FN_IsMapValid(char *filename); +#endif // FN_IsMapValid + +#ifdef FN_StaticDecal +void FN_StaticDecal(const float *origin, int decalIndex, int entityIndex, int modelIndex); +#endif // FN_StaticDecal + +#ifdef FN_PrecacheGeneric +int FN_PrecacheGeneric(char *s); +#endif // FN_PrecacheGeneric + +#ifdef FN_GetPlayerUserId +int FN_GetPlayerUserId(edict_t *e ); +#endif // FN_GetPlayerUserId + +#ifdef FN_BuildSoundMsg +void FN_BuildSoundMsg(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch, int msg_dest, int msg_type, const float *pOrigin, edict_t *ed); +#endif // FN_BuildSoundMsg + +#ifdef FN_IsDedicatedServer +int FN_IsDedicatedServer(void); +#endif // FN_IsDedicatedServer + +#ifdef FN_CVarGetPointer +cvar_t *FN_CVarGetPointer(const char *szVarName); +#endif // FN_CVarGetPointer + +#ifdef FN_GetPlayerWONId +unsigned int FN_GetPlayerWONId(edict_t *e); +#endif // FN_GetPlayerWONId + +#ifdef FN_Info_RemoveKey +void FN_Info_RemoveKey( char *s, const char *key); +#endif // FN_Info_RemoveKey + +#ifdef FN_GetPhysicsKeyValue +const char *FN_GetPhysicsKeyValue(const edict_t *pClient, const char *key); +#endif // FN_GetPhysicsKeyValue + +#ifdef FN_SetPhysicsKeyValue +void FN_SetPhysicsKeyValue(const edict_t *pClient, const char *key, const char *value); +#endif // FN_SetPhysicsKeyValue + +#ifdef FN_GetPhysicsInfoString +const char *FN_GetPhysicsInfoString( const edict_t *pClient); +#endif // FN_GetPhysicsInfoString + +#ifdef FN_PrecacheEvent +unsigned short FN_PrecacheEvent(int type, const char *psz); +#endif // FN_PrecacheEvent + +#ifdef FN_PlaybackEvent +void FN_PlaybackEvent(int flags, const edict_t *pInvoker, unsigned short eventindex, float delay, float *origin, float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2); +#endif // FN_PlaybackEvent + +#ifdef FN_SetFatPVS +unsigned char *FN_SetFatPVS(float *org); +#endif // FN_SetFatPVS + +#ifdef FN_SetFatPAS +unsigned char *FN_SetFatPAS(float *org); +#endif // FN_SetFatPAS + +#ifdef FN_CheckVisibility +int FN_CheckVisibility(const edict_t *entity, unsigned char *pset); +#endif // FN_CheckVisibility + +#ifdef FN_DeltaSetField +void FN_DeltaSetField(struct delta_s *pFields, const char *fieldname); +#endif // FN_DeltaSetField + +#ifdef FN_DeltaUnsetField +void FN_DeltaUnsetField(struct delta_s *pFields, const char *fieldname); +#endif // FN_DeltaUnsetField + +#ifdef FN_DeltaAddEncoder +void FN_DeltaAddEncoder(char *name, void (*conditionalencode)( struct delta_s *pFields, const unsigned char *from, const unsigned char *to ) ); +#endif // FN_DeltaAddEncoder + +#ifdef FN_GetCurrentPlayer +int FN_GetCurrentPlayer(void); +#endif // FN_GetCurrentPlayer + +#ifdef FN_CanSkipPlayer +int FN_CanSkipPlayer(const edict_t *player); +#endif // FN_CanSkipPlayer + +#ifdef FN_DeltaFindField +int FN_DeltaFindField(struct delta_s *pFields, const char *fieldname); +#endif // FN_DeltaFindField + +#ifdef FN_DeltaSetFieldByIndex +void FN_DeltaSetFieldByIndex(struct delta_s *pFields, int fieldNumber); +#endif // FN_DeltaSetFieldByIndex + +#ifdef FN_DeltaUnsetFieldByIndex +void FN_DeltaUnsetFieldByIndex(struct delta_s *pFields, int fieldNumber); +#endif // FN_DeltaUnsetFieldByIndex + +#ifdef FN_SetGroupMask +void FN_SetGroupMask(int mask, int op); +#endif // FN_SetGroupMask + +#ifdef FN_engCreateInstancedBaseline +int FN_engCreateInstancedBaseline(int classname, struct entity_state_s *baseline); +#endif // FN_engCreateInstancedBaseline + +#ifdef FN_Cvar_DirectSet +void FN_Cvar_DirectSet(struct cvar_s *var, char *value); +#endif // FN_Cvar_DirectSet + +#ifdef FN_ForceUnmodified +void FN_ForceUnmodified(FORCE_TYPE type, float *mins, float *maxs, const char *filename); +#endif // FN_ForceUnmodified + +#ifdef FN_GetPlayerStats +void FN_GetPlayerStats(const edict_t *pClient, int *ping, int *packet_loss); +#endif // FN_GetPlayerStats + +#ifdef FN_AddServerCommand +void FN_AddServerCommand(char *cmd_name, void (*function) (void)); +#endif // FN_AddServerCommand + +#ifdef FN_Voice_GetClientListening +qboolean FN_Voice_GetClientListening(int iReceiver, int iSender); +#endif // FN_Voice_GetClientListening + +#ifdef FN_Voice_SetClientListening +qboolean FN_Voice_SetClientListening(int iReceiver, int iSender, qboolean bListen); +#endif // FN_Voice_SetClientListening + +#ifdef FN_GetPlayerAuthId +const char *FN_GetPlayerAuthId(edict_t *e); +#endif // FN_GetPlayerAuthId + + + + + + +#ifdef FN_PrecacheModel_Post +int FN_PrecacheModel_Post(char *s); +#endif // FN_PrecacheModel_Post + +#ifdef FN_PrecacheSound_Post +int FN_PrecacheSound_Post(char *s); +#endif // FN_PrecacheSound_Post + +#ifdef FN_SetModel_Post +void FN_SetModel_Post(edict_t *e, const char *m); +#endif // FN_SetModel_Post + +#ifdef FN_ModelIndex_Post +int FN_ModelIndex_Post(const char *m); +#endif // FN_ModelIndex_Post + +#ifdef FN_ModelFrames_Post +int FN_ModelFrames_Post(int modelIndex); +#endif // FN_ModelFrames_Post + +#ifdef FN_SetSize_Post +void FN_SetSize_Post(edict_t *e, const float *rgflMin, const float *rgflMax); +#endif // FN_SetSize_Post + +#ifdef FN_ChangeLevel_Post +void FN_ChangeLevel_Post(char *s1, char *s2); +#endif // FN_ChangeLevel_Post + +#ifdef FN_GetSpawnParms_Post +void FN_GetSpawnParms_Post(edict_t *ent); +#endif // FN_GetSpawnParms_Post + +#ifdef FN_SaveSpawnParms_Post +void FN_SaveSpawnParms_Post(edict_t *ent); +#endif // FN_SaveSpawnParms_Post + +#ifdef FN_VecToYaw_Post +float FN_VecToYaw_Post(const float *rgflVector); +#endif // FN_VecToYaw_Post + +#ifdef FN_VecToAngles_Post +void FN_VecToAngles_Post(const float *rgflVectorIn, float *rgflVectorOut); +#endif // FN_VecToAngles_Post + +#ifdef FN_MoveToOrigin_Post +void FN_MoveToOrigin_Post(edict_t *ent, const float *pflGoal, float dist, int iMoveType); +#endif // FN_MoveToOrigin_Post + +#ifdef FN_ChangeYaw_Post +void FN_ChangeYaw_Post(edict_t *ent); +#endif // FN_ChangeYaw_Post + +#ifdef FN_ChangePitch_Post +void FN_ChangePitch_Post(edict_t *ent); +#endif // FN_ChangePitch_Post + +#ifdef FN_FindEntityByString_Post +edict_t *FN_FindEntityByString_Post(edict_t *pEdictStartSearchAfter, const char *pszField, const char *pszValue); +#endif // FN_FindEntityByString_Post + +#ifdef FN_GetEntityIllum_Post +int FN_GetEntityIllum_Post(edict_t *pEnt); +#endif // FN_GetEntityIllum_Post + +#ifdef FN_FindEntityInSphere_Post +edict_t *FN_FindEntityInSphere_Post(edict_t *pEdictStartSearchAfter, const float *org, float rad); +#endif // FN_FindEntityInSphere_Post + +#ifdef FN_FindClientInPVS_Post +edict_t *FN_FindClientInPVS_Post(edict_t *pEdict); +#endif // FN_FindClientInPVS_Post + +#ifdef FN_EntitiesInPVS_Post +edict_t *FN_EntitiesInPVS_Post(edict_t *pplayer); +#endif // FN_EntitiesInPVS_Post + +#ifdef FN_MakeVectors_Post +void FN_MakeVectors_Post(const float *rgflVector); +#endif // FN_MakeVectors_Post + +#ifdef FN_AngleVectors_Post +void FN_AngleVectors_Post(const float *rgflVector, float *forward, float *right, float *up); +#endif // FN_AngleVectors_Post + +#ifdef FN_CreateEntity_Post +edict_t *FN_CreateEntity_Post(void); +#endif // FN_CreateEntity_Post + +#ifdef FN_RemoveEntity_Post +void FN_RemoveEntity_Post(edict_t *e); +#endif // FN_RemoveEntity_Post + +#ifdef FN_CreateNamedEntity_Post +edict_t *FN_CreateNamedEntity_Post(int className); +#endif // FN_CreateNamedEntity_Post + +#ifdef FN_MakeStatic_Post +void FN_MakeStatic_Post(edict_t *ent); +#endif // FN_MakeStatic_Post + +#ifdef FN_EntIsOnFloor_Post +int FN_EntIsOnFloor_Post(edict_t *ent); +#endif // FN_EntIsOnFloor_Post + +#ifdef FN_DropToFloor_Post +int FN_DropToFloor_Post(edict_t *ent); +#endif // FN_DropToFloor_Post + +#ifdef FN_WalkMove_Post +int FN_WalkMove_Post(edict_t *ent, float yaw, float dist, int iMode); +#endif // FN_WalkMove_Post + +#ifdef FN_SetOrigin_Post +void FN_SetOrigin_Post(edict_t *e, const float *rgflOrigin); +#endif // FN_SetOrigin_Post + +#ifdef FN_EmitSound_Post +void FN_EmitSound_Post(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch); +#endif // FN_EmitSound_Post + +#ifdef FN_EmitAmbientSound_Post +void FN_EmitAmbientSound_Post(edict_t *entity, float *pos, const char *samp, float vol, float attenuation, int fFlags, int pitch); +#endif // FN_EmitAmbientSound_Post + +#ifdef FN_TraceLine_Post +void FN_TraceLine_Post(const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr); +#endif // FN_TraceLine_Post + +#ifdef FN_TraceToss_Post +void FN_TraceToss_Post(edict_t *pent, edict_t *pentToIgnore, TraceResult *ptr); +#endif // FN_TraceToss_Post + +#ifdef FN_TraceMonsterHull_Post +int FN_TraceMonsterHull_Post(edict_t *pEdict, const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr); +#endif // FN_TraceMonsterHull_Post + +#ifdef FN_TraceHull_Post +void FN_TraceHull_Post(const float *v1, const float *v2, int fNoMonsters, int hullNumber, edict_t *pentToSkip, TraceResult *ptr); +#endif // FN_TraceHull_Post + +#ifdef FN_TraceModel_Post +void FN_TraceModel_Post(const float *v1, const float *v2, int hullNumber, edict_t *pent, TraceResult *ptr); +#endif // FN_TraceModel_Post + +#ifdef FN_TraceTexture_Post +const char *FN_TraceTexture_Post(edict_t *pTextureEntity, const float *v1, const float *v2 ); +#endif // FN_TraceTexture_Post + +#ifdef FN_TraceSphere_Post +void FN_TraceSphere_Post(const float *v1, const float *v2, int fNoMonsters, float radius, edict_t *pentToSkip, TraceResult *ptr); +#endif // FN_TraceSphere_Post + +#ifdef FN_GetAimVector_Post +void FN_GetAimVector_Post(edict_t *ent, float speed, float *rgflReturn); +#endif // FN_GetAimVector_Post + +#ifdef FN_ServerCommand_Post +void FN_ServerCommand_Post(char *str); +#endif // FN_ServerCommand_Post + +#ifdef FN_ServerExecute_Post +void FN_ServerExecute_Post(void); +#endif // FN_ServerExecute_Post + +#ifdef FN_engClientCommand_Post +void FN_engClientCommand_Post(edict_t *pEdict, char *szFmt, ...); +#endif // FN_engClientCommand_Post + +#ifdef FN_ParticleEffect_Post +void FN_ParticleEffect_Post(const float *org, const float *dir, float color, float count); +#endif // FN_ParticleEffect_Post + +#ifdef FN_LightStyle_Post +void FN_LightStyle_Post(int style, char *val); +#endif // FN_LightStyle_Post + +#ifdef FN_DecalIndex_Post +int FN_DecalIndex_Post(const char *name); +#endif // FN_DecalIndex_Post + +#ifdef FN_PointContents_Post +int FN_PointContents_Post(const float *rgflVector); +#endif // FN_PointContents_Post + +#ifdef FN_MessageBegin_Post +void FN_MessageBegin_Post(int msg_dest, int msg_type, const float *pOrigin, edict_t *ed); +#endif // FN_MessageBegin_Post + +#ifdef FN_MessageEnd_Post +void FN_MessageEnd_Post(void); +#endif // FN_MessageEnd_Post + +#ifdef FN_WriteByte_Post +void FN_WriteByte_Post(int iValue); +#endif // FN_WriteByte_Post + +#ifdef FN_WriteChar_Post +void FN_WriteChar_Post(int iValue); +#endif // FN_WriteChar_Post + +#ifdef FN_WriteShort_Post +void FN_WriteShort_Post(int iValue); +#endif // FN_WriteShort_Post + +#ifdef FN_WriteLong_Post +void FN_WriteLong_Post(int iValue); +#endif // FN_WriteLong_Post + +#ifdef FN_WriteAngle_Post +void FN_WriteAngle_Post(float flValue); +#endif // FN_WriteAngle_Post + +#ifdef FN_WriteCoord_Post +void FN_WriteCoord_Post(float flValue); +#endif // FN_WriteCoord_Post + +#ifdef FN_WriteString_Post +void FN_WriteString_Post(const char *sz); +#endif // FN_WriteString_Post + +#ifdef FN_WriteEntity_Post +void FN_WriteEntity_Post(int iValue); +#endif // FN_WriteEntity_Post + +#ifdef FN_CVarRegister_Post +void FN_CVarRegister_Post(cvar_t *pCvar); +#endif // FN_CVarRegister_Post + +#ifdef FN_CVarGetFloat_Post +float FN_CVarGetFloat_Post(const char *szVarName); +#endif // FN_CVarGetFloat_Post + +#ifdef FN_CVarGetString_Post +const char *FN_CVarGetString_Post(const char *szVarName); +#endif // FN_CVarGetString_Post + +#ifdef FN_CVarSetFloat_Post +void FN_CVarSetFloat_Post(const char *szVarName, float flValue); +#endif // FN_CVarSetFloat_Post + +#ifdef FN_CVarSetString_Post +void FN_CVarSetString_Post(const char *szVarName, const char *szValue); +#endif // FN_CVarSetString_Post + +#ifdef FN_AlertMessage_Post +void FN_AlertMessage_Post(ALERT_TYPE atype, char *szFmt, ...); +#endif // FN_AlertMessage_Post + +#ifdef FN_EngineFprintf_Post +void FN_EngineFprintf_Post(FILE *pfile, char *szFmt, ...); +#endif // FN_EngineFprintf_Post + +#ifdef FN_PvAllocEntPrivateData_Post +void *FN_PvAllocEntPrivateData_Post(edict_t *pEdict, long cb); +#endif // FN_PvAllocEntPrivateData_Post + +#ifdef FN_PvEntPrivateData_Post +void *FN_PvEntPrivateData_Post(edict_t *pEdict); +#endif // FN_PvEntPrivateData_Post + +#ifdef FN_FreeEntPrivateData_Post +void FN_FreeEntPrivateData_Post(edict_t *pEdict); +#endif // FN_FreeEntPrivateData_Post + +#ifdef FN_SzFromIndex_Post +const char *FN_SzFromIndex_Post(int iString); +#endif // FN_SzFromIndex_Post + +#ifdef FN_AllocString_Post +int FN_AllocString_Post(const char *szValue); +#endif // FN_AllocString_Post + +#ifdef FN_GetVarsOfEnt_Post +struct entvars_s *FN_GetVarsOfEnt_Post(edict_t *pEdict); +#endif // FN_GetVarsOfEnt_Post + +#ifdef FN_PEntityOfEntOffset_Post +edict_t *FN_PEntityOfEntOffset_Post(int iEntOffset); +#endif // FN_PEntityOfEntOffset_Post + +#ifdef FN_EntOffsetOfPEntity_Post +int FN_EntOffsetOfPEntity_Post(const edict_t *pEdict); +#endif // FN_EntOffsetOfPEntity_Post + +#ifdef FN_IndexOfEdict_Post +int FN_IndexOfEdict_Post(const edict_t *pEdict); +#endif // FN_IndexOfEdict_Post + +#ifdef FN_PEntityOfEntIndex_Post +edict_t *FN_PEntityOfEntIndex_Post(int iEntIndex); +#endif // FN_PEntityOfEntIndex_Post + +#ifdef FN_FindEntityByVars_Post +edict_t *FN_FindEntityByVars_Post(struct entvars_s *pvars); +#endif // FN_FindEntityByVars_Post + +#ifdef FN_GetModelPtr_Post +void *FN_GetModelPtr_Post(edict_t *pEdict); +#endif // FN_GetModelPtr_Post + +#ifdef FN_RegUserMsg_Post +int FN_RegUserMsg_Post(const char *pszName, int iSize); +#endif // FN_RegUserMsg_Post + +#ifdef FN_AnimationAutomove_Post +void FN_AnimationAutomove_Post(const edict_t *pEdict, float flTime); +#endif // FN_AnimationAutomove_Post + +#ifdef FN_GetBonePosition_Post +void FN_GetBonePosition_Post(const edict_t *pEdict, int iBone, float *rgflOrigin, float *rgflAngles); +#endif // FN_GetBonePosition_Post + +#ifdef FN_FunctionFromName_Post +unsigned long FN_FunctionFromName_Post(const char *pName); +#endif // FN_FunctionFromName_Post + +#ifdef FN_NameForFunction_Post +const char *FN_NameForFunction_Post(unsigned long function); +#endif // FN_NameForFunction_Post + +#ifdef FN_ClientPrintf_Post +void FN_ClientPrintf_Post(edict_t *pEdict, PRINT_TYPE ptype, const char *szMsg); +#endif // FN_ClientPrintf_Post + +#ifdef FN_ServerPrint_Post +void FN_ServerPrint_Post(const char *szMsg); +#endif // FN_ServerPrint_Post + +#ifdef FN_Cmd_Args_Post +const char *FN_Cmd_Args_Post(void); +#endif // FN_Cmd_Args_Post + +#ifdef FN_Cmd_Argv_Post +const char *FN_Cmd_Argv_Post(int argc); +#endif // FN_Cmd_Argv_Post + +#ifdef FN_Cmd_Argc_Post +int FN_Cmd_Argc_Post(void); +#endif // FN_Cmd_Argc_Post + +#ifdef FN_GetAttachment_Post +void FN_GetAttachment_Post(const edict_t *pEdict, int iAttachment, float *rgflOrigin, float *rgflAngles ); +#endif // FN_GetAttachment_Post + +#ifdef FN_CRC32_Init_Post +void FN_CRC32_Init_Post(CRC32_t *pulCRC); +#endif // FN_CRC32_Init_Post + +#ifdef FN_CRC32_ProcessBuffer_Post +void FN_CRC32_ProcessBuffer_Post(CRC32_t *pulCRC, void *p, int len); +#endif // FN_CRC32_ProcessBuffer_Post + +#ifdef FN_CRC32_ProcessByte_Post +void FN_CRC32_ProcessByte_Post(CRC32_t *pulCRC, unsigned char ch); +#endif // FN_CRC32_ProcessByte_Post + +#ifdef FN_CRC32_Final_Post +CRC32_t FN_CRC32_Final_Post(CRC32_t pulCRC); +#endif // FN_CRC32_Final_Post + +#ifdef FN_RandomLong_Post +long FN_RandomLong_Post(long lLow, long lHigh); +#endif // FN_RandomLong_Post + +#ifdef FN_RandomFloat_Post +float FN_RandomFloat_Post(float flLow, float flHigh); +#endif // FN_RandomFloat_Post + +#ifdef FN_SetView_Post +void FN_SetView_Post(const edict_t *pClient, const edict_t *pViewent); +#endif // FN_SetView_Post + +#ifdef FN_Time_Post +float FN_Time_Post(void); +#endif // FN_Time_Post + +#ifdef FN_CrosshairAngle_Post +void FN_CrosshairAngle_Post(const edict_t *pClient, float pitch, float yaw); +#endif // FN_CrosshairAngle_Post + +#ifdef FN_LoadFileForMe_Post +byte *FN_LoadFileForMe_Post(char *filename, int *pLength); +#endif // FN_LoadFileForMe_Post + +#ifdef FN_FreeFile_Post +void FN_FreeFile_Post(void *buffer); +#endif // FN_FreeFile_Post + +#ifdef FN_EndSection_Post +void FN_EndSection_Post(const char *pszSectionName); +#endif // FN_EndSection_Post + +#ifdef FN_CompareFileTime_Post +int FN_CompareFileTime_Post(char *filename1, char *filename2, int *iCompare); +#endif // FN_CompareFileTime_Post + +#ifdef FN_GetGameDir_Post +void FN_GetGameDir_Post(char *szGetGameDir); +#endif // FN_GetGameDir_Post + +#ifdef FN_Cvar_RegisterVariable_Post +void FN_Cvar_RegisterVariable_Post(cvar_t *variable); +#endif // FN_Cvar_RegisterVariable_Post + +#ifdef FN_FadeClientVolume_Post +void FN_FadeClientVolume_Post(const edict_t *pEdict, int fadePercent, int fadeOutSeconds, int holdTime, int fadeInSeconds); +#endif // FN_FadeClientVolume_Post + +#ifdef FN_SetClientMaxspeed_Post +void FN_SetClientMaxspeed_Post(const edict_t *pEdict, float fNewMaxspeed); +#endif // FN_SetClientMaxspeed_Post + +#ifdef FN_CreateFakeClient_Post +edict_t *FN_CreateFakeClient_Post(const char *netname); +#endif // FN_CreateFakeClient_Post + +#ifdef FN_RunPlayerMove_Post +void FN_RunPlayerMove_Post(edict_t *fakeclient, const float *viewangles, float forwardmove, float sidemove, float upmove, unsigned short buttons, byte impulse, byte msec); +#endif // FN_RunPlayerMove_Post + +#ifdef FN_NumberOfEntities_Post +int FN_NumberOfEntities_Post(void); +#endif // FN_NumberOfEntities_Post + +#ifdef FN_GetInfoKeyBuffer_Post +char *FN_GetInfoKeyBuffer_Post(edict_t *e); +#endif // FN_GetInfoKeyBuffer_Post + +#ifdef FN_InfoKeyValue_Post +char *FN_InfoKeyValue_Post(char *infobuffer, char *key); +#endif // FN_InfoKeyValue_Post + +#ifdef FN_SetKeyValue_Post +void FN_SetKeyValue_Post(char *infobuffer, char *key, char *value); +#endif // FN_SetKeyValue_Post + +#ifdef FN_SetClientKeyValue_Post +void FN_SetClientKeyValue_Post(int clientIndex, char *infobuffer, char *key, char *value); +#endif // FN_SetClientKeyValue_Post + +#ifdef FN_IsMapValid_Post +int FN_IsMapValid_Post(char *filename); +#endif // FN_IsMapValid_Post + +#ifdef FN_StaticDecal_Post +void FN_StaticDecal_Post(const float *origin, int decalIndex, int entityIndex, int modelIndex); +#endif // FN_StaticDecal_Post + +#ifdef FN_PrecacheGeneric_Post +int FN_PrecacheGeneric_Post(char *s); +#endif // FN_PrecacheGeneric_Post + +#ifdef FN_GetPlayerUserId_Post +int FN_GetPlayerUserId_Post(edict_t *e ); +#endif // FN_GetPlayerUserId_Post + +#ifdef FN_BuildSoundMsg_Post +void FN_BuildSoundMsg_Post(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch, int msg_dest, int msg_type, const float *pOrigin, edict_t *ed); +#endif // FN_BuildSoundMsg_Post + +#ifdef FN_IsDedicatedServer_Post +int FN_IsDedicatedServer_Post(void); +#endif // FN_IsDedicatedServer_Post + +#ifdef FN_CVarGetPointer_Post +cvar_t *FN_CVarGetPointer_Post(const char *szVarName); +#endif // FN_CVarGetPointer_Post + +#ifdef FN_GetPlayerWONId_Post +unsigned int FN_GetPlayerWONId_Post(edict_t *e); +#endif // FN_GetPlayerWONId_Post + +#ifdef FN_Info_RemoveKey_Post +void FN_Info_RemoveKey_Post( char *s, const char *key); +#endif // FN_Info_RemoveKey_Post + +#ifdef FN_GetPhysicsKeyValue_Post +const char *FN_GetPhysicsKeyValue_Post(const edict_t *pClient, const char *key); +#endif // FN_GetPhysicsKeyValue_Post + +#ifdef FN_SetPhysicsKeyValue_Post +void FN_SetPhysicsKeyValue_Post(const edict_t *pClient, const char *key, const char *value); +#endif // FN_SetPhysicsKeyValue_Post + +#ifdef FN_GetPhysicsInfoString_Post +const char *FN_GetPhysicsInfoString_Post( const edict_t *pClient); +#endif // FN_GetPhysicsInfoString_Post + +#ifdef FN_PrecacheEvent_Post +unsigned short FN_PrecacheEvent_Post(int type, const char *psz); +#endif // FN_PrecacheEvent_Post + +#ifdef FN_PlaybackEvent_Post +void FN_PlaybackEvent_Post(int flags, const edict_t *pInvoker, unsigned short eventindex, float delay, float *origin, float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2); +#endif // FN_PlaybackEvent_Post + +#ifdef FN_SetFatPVS_Post +unsigned char *FN_SetFatPVS_Post(float *org); +#endif // FN_SetFatPVS_Post + +#ifdef FN_SetFatPAS_Post +unsigned char *FN_SetFatPAS_Post(float *org); +#endif // FN_SetFatPAS_Post + +#ifdef FN_CheckVisibility_Post +int FN_CheckVisibility_Post(const edict_t *entity, unsigned char *pset); +#endif // FN_CheckVisibility_Post + +#ifdef FN_DeltaSetField_Post +void FN_DeltaSetField_Post(struct delta_s *pFields, const char *fieldname); +#endif // FN_DeltaSetField_Post + +#ifdef FN_DeltaUnsetField_Post +void FN_DeltaUnsetField_Post(struct delta_s *pFields, const char *fieldname); +#endif // FN_DeltaUnsetField_Post + +#ifdef FN_DeltaAddEncoder_Post +void FN_DeltaAddEncoder_Post(char *name, void (*conditionalencode)( struct delta_s *pFields, const unsigned char *from, const unsigned char *to ) ); +#endif // FN_DeltaAddEncoder_Post + +#ifdef FN_GetCurrentPlayer_Post +int FN_GetCurrentPlayer_Post(void); +#endif // FN_GetCurrentPlayer_Post + +#ifdef FN_CanSkipPlayer_Post +int FN_CanSkipPlayer_Post(const edict_t *player); +#endif // FN_CanSkipPlayer_Post + +#ifdef FN_DeltaFindField_Post +int FN_DeltaFindField_Post(struct delta_s *pFields, const char *fieldname); +#endif // FN_DeltaFindField_Post + +#ifdef FN_DeltaSetFieldByIndex_Post +void FN_DeltaSetFieldByIndex_Post(struct delta_s *pFields, int fieldNumber); +#endif // FN_DeltaSetFieldByIndex_Post + +#ifdef FN_DeltaUnsetFieldByIndex_Post +void FN_DeltaUnsetFieldByIndex_Post(struct delta_s *pFields, int fieldNumber); +#endif // FN_DeltaUnsetFieldByIndex_Post + +#ifdef FN_SetGroupMask_Post +void FN_SetGroupMask_Post(int mask, int op); +#endif // FN_SetGroupMask_Post + +#ifdef FN_engCreateInstancedBaseline_Post +int FN_engCreateInstancedBaseline_Post(int classname, struct entity_state_s *baseline); +#endif // FN_engCreateInstancedBaseline_Post + +#ifdef FN_Cvar_DirectSet_Post +void FN_Cvar_DirectSet_Post(struct cvar_s *var, char *value); +#endif // FN_Cvar_DirectSet_Post + +#ifdef FN_ForceUnmodified_Post +void FN_ForceUnmodified_Post(FORCE_TYPE type, float *mins, float *maxs, const char *filename); +#endif // FN_ForceUnmodified_Post + +#ifdef FN_GetPlayerStats_Post +void FN_GetPlayerStats_Post(const edict_t *pClient, int *ping, int *packet_loss); +#endif // FN_GetPlayerStats_Post + +#ifdef FN_AddServerCommand_Post +void FN_AddServerCommand_Post(char *cmd_name, void (*function)(void)); +#endif // FN_AddServerCommand_Post + +#ifdef FN_Voice_GetClientListening_Post +qboolean FN_Voice_GetClientListening_Post(int iReceiver, int iSender); +#endif // FN_Voice_GetClientListening_Post + +#ifdef FN_Voice_SetClientListening_Post +qboolean FN_Voice_SetClientListening_Post(int iReceiver, int iSender, qboolean bListen); +#endif // FN_Voice_SetClientListening_Post + +#ifdef FN_GetPlayerAuthId_Post +const char *FN_GetPlayerAuthId_Post(edict_t *e); +#endif // FN_GetPlayerAuthId + + + + +#ifdef FN_OnFreeEntPrivateData +void FN_OnFreeEntPrivateData(edict_t *pEnt); +#endif // FN_OnFreeEntPrivateData + +#ifdef FN_GameShutdown +void FN_GameShutdown(void); +#endif // FN_GameShutdown + +#ifdef FN_ShouldCollide +int FN_ShouldCollide(edict_t *pentTouched, edict_t *pentOther); +#endif // FN_ShouldCollide + + + + + +#ifdef FN_OnFreeEntPrivateData_Post +void FN_OnFreeEntPrivateData_Post(edict_t *pEnt); +#endif // FN_OnFreeEntPrivateData_Post + +#ifdef FN_GameShutdown_Post +void FN_GameShutdown_Post(void); +#endif // FN_GameShutdown_Post + +#ifdef FN_ShouldCollide_Post +int FN_ShouldCollide_Post(edict_t *pentTouched, edict_t *pentOther); +#endif // FN_ShouldCollide_Post + +#endif // USE_METAMOD + + +#ifdef FN_AMXX_QUERY +void FN_AMXX_QUERY(void); +#endif // FN_AMXX_QUERY + +#ifdef FN_AMXX_ATTACH +void FN_AMXX_ATTACH(void); +#endif // FN_AMXX_ATTACH + +#ifdef FN_AMXX_DETACH +void FN_AMXX_DETACH(void); +#endif // FN_AMXX_DETACH + +#ifdef FN_AMXX_PLUGINSLOADED +void FN_AMXX_PLUGINSLOADED(void); +#endif // FN_AMXX_PLUGINSLOADED + +// ***** Module funcs stuff ***** +enum ForwardExecType +{ + ET_IGNORE = 0, // Ignore return vaue + ET_STOP, // Stop on PLUGIN_HANDLED + ET_STOP2, // Stop on PLUGIN_HANDLED, continue on other values, return biggest return value + ET_CONTINUE, // Continue; return biggest return value +}; + +enum ForwardParam +{ + FP_DONE = -1, // specify this as the last argument + // only tells the function that there are no more arguments + FP_CELL, // normal cell + FP_FLOAT, // float; used as normal cell though + FP_STRING, // string + FP_STRINGEX, // string; will be updated to the last function's value + FP_ARRAY, // array; use the return value of prepareArray. +}; + + +typedef int (*PFN_ADD_NATIVES) (const AMX_NATIVE_INFO * /*list*/); +typedef char * (*PFN_BUILD_PATHNAME) (const char * /*format*/, ...); +typedef cell * (*PFN_GET_AMXADDR) (AMX * /*amx*/, cell /*offset*/); +typedef void (*PFN_PRINT_SRVCONSOLE) (char * /*format*/, ...); +typedef const char * (*PFN_GET_MODNAME) (void); +typedef const char * (*PFN_GET_AMXSCRIPTNAME) (int /*id*/); +typedef AMX * (*PFN_GET_AMXSCRIPT) (int /*id*/); +typedef int (*PFN_FIND_AMXSCRIPT_BYAMX) (const AMX * /*amx*/); +typedef int (*PFN_FIND_AMXSCRIPT_BYNAME) (const char * /*name*/); +typedef int (*PFN_SET_AMXSTRING) (AMX * /*amx*/, cell /*amx_addr*/, const char * /* source */, int /* max */); +typedef char * (*PFN_GET_AMXSTRING) (AMX * /*amx*/, cell /*amx_addr*/, int /*bufferId*/, int * /*pLen*/); +typedef int (*PFN_GET_AMXSTRINGLEN) (const cell *ptr); +typedef char * (*PFN_FORMAT_AMXSTRING) (AMX * /*amx*/, cell * /*params*/, int /*startParam*/, int * /*pLen*/); +typedef void (*PFN_COPY_AMXMEMORY) (cell * /*dest*/, const cell * /*src*/, int /*len*/); +typedef void (*PFN_LOG) (const char * /*fmt*/, ...); +typedef void (*PFN_LOG_ERROR) (AMX * /*amx*/, int /*err*/, const char * /*fmt*/, ...); +typedef int (*PFN_RAISE_AMXERROR) (AMX * /*amx*/, int /*error*/); +typedef int (*PFN_REGISTER_FORWARD) (const char * /*funcname*/, ForwardExecType /*exectype*/, ... /*paramtypes terminated by PF_DONE*/); +typedef int (*PFN_EXECUTE_FORWARD) (int /*id*/, ... /*params*/); +typedef cell (*PFN_PREPARE_CELLARRAY) (cell * /*ptr*/, unsigned int /*size*/); +typedef cell (*PFN_PREPARE_CHARARRAY) (char * /*ptr*/, unsigned int /*size*/); +typedef cell (*PFN_PREPARE_CELLARRAY_A) (cell * /*ptr*/, unsigned int /*size*/, bool /*copyBack*/); +typedef cell (*PFN_PREPARE_CHARARRAY_A) (char * /*ptr*/, unsigned int /*size*/, bool /*copyBack*/); +typedef int (*PFN_IS_PLAYER_VALID) (int /*id*/); +typedef const char * (*PFN_GET_PLAYER_NAME) (int /*id*/); +typedef const char * (*PFN_GET_PLAYER_IP) (int /*id*/); +typedef int (*PFN_IS_PLAYER_INGAME) (int /*id*/); +typedef int (*PFN_IS_PLAYER_BOT) (int /*id*/); +typedef int (*PFN_IS_PLAYER_AUTHORIZED) (int /*id*/); +typedef float (*PFN_GET_PLAYER_TIME) (int /*id*/); +typedef float (*PFN_GET_PLAYER_PLAYTIME) (int /*id*/); +typedef int (*PFN_GETPLAYERFLAGS) (int /* id*/); +typedef int (*PFN_GET_PLAYER_CURWEAPON) (int /*id*/); +typedef const char * (*PFN_GET_PLAYER_TEAM) (int /*id*/); +typedef int (*PFN_GET_PLAYER_TEAMID) (int /*id*/); +typedef int (*PFN_GET_PLAYER_DEATHS) (int /*id*/); +typedef int (*PFN_GET_PLAYER_MENU) (int /*id*/); +typedef int (*PFN_GET_PLAYER_KEYS) (int /*id*/); +typedef int (*PFN_IS_PLAYER_ALIVE) (int /*id*/); +typedef int (*PFN_GET_PLAYER_FRAGS) (int /*id*/); +typedef int (*PFN_IS_PLAYER_CONNECTING) (int /*id*/); +typedef int (*PFN_IS_PLAYER_HLTV) (int /*id*/); +typedef int (*PFN_GET_PLAYER_ARMOR) (int /*id*/); +typedef int (*PFN_GET_PLAYER_HEALTH) (int /*id*/); +#ifdef USE_METAMOD +typedef edict_t * (*PFN_GET_PLAYER_EDICT) (int /*id*/); +#else +typedef void * (*PFN_GET_PLAYER_EDICT) (int /*id*/); +#endif + +typedef void * (*PFN_ALLOCATOR) (const char* /*filename*/, const unsigned int /*line*/, const char* /*func*/, + const unsigned int /*type*/, const size_t /*size*/); +typedef void * (*PFN_REALLOCATOR) (const char* /*filename*/, const unsigned int /*line*/, const char* /*func*/, + const unsigned int /*type*/, const size_t /*size*/, void* /*addr*/ ); +typedef void (*PFN_DEALLOCATOR) (const char* /*filename*/, const unsigned int /*line*/, const char* /*func*/, + const unsigned int /*type*/, const void* /*addr*/ ); +typedef int (*PFN_AMX_EXEC) (AMX* /*amx*/, cell* /*return val*/, int /*index*/, int /*numparams*/, ... /*params*/); +typedef int (*PFN_AMX_EXECV) (AMX* /*amx*/, cell* /*return val*/, int /*index*/, int /*numparams*/, cell[] /*params*/); +typedef int (*PFN_AMX_ALLOT) (AMX* /*amx*/, int /*length*/, cell* /*amx_addr*/, cell** /*phys_addr*/); +typedef int (*PFN_AMX_FINDPUBLIC) (AMX* /*amx*/, char* /*func name*/, int* /*index*/); +typedef int (*PFN_AMX_FINDNATIVE) (AMX* /*amx*/, char* /*func name*/, int* /*index*/); +typedef int (*PFN_LOAD_AMXSCRIPT) (AMX* /*amx*/, void** /*code*/, const char* /*path*/, char[64] /*error info*/, int /* debug */); +typedef int (*PFN_UNLOAD_AMXSCRIPT) (AMX* /*amx*/,void** /*code*/); +typedef cell (*PFN_REAL_TO_CELL) (REAL /*x*/); +typedef REAL (*PFN_CELL_TO_REAL) (cell /*x*/); +typedef int (*PFN_REGISTER_SPFORWARD) (AMX * /*amx*/, int /*func*/, ... /*params*/); +typedef int (*PFN_REGISTER_SPFORWARD_BYNAME) (AMX * /*amx*/, const char * /*funcName*/, ... /*params*/); +typedef void (*PFN_UNREGISTER_SPFORWARD) (int /*id*/); +typedef void (*PFN_MERGEDEFINITION_FILE) (const char * /*filename*/); +typedef const char * (*PFN_FORMAT) (const char * /*fmt*/, ... /*params*/); + +extern PFN_ADD_NATIVES g_fn_AddNatives; +extern PFN_BUILD_PATHNAME g_fn_BuildPathname; +extern PFN_GET_AMXADDR g_fn_GetAmxAddr; +extern PFN_PRINT_SRVCONSOLE g_fn_PrintSrvConsole; +extern PFN_GET_MODNAME g_fn_GetModname; +extern PFN_GET_AMXSCRIPTNAME g_fn_GetAmxScriptName; +extern PFN_GET_AMXSCRIPT g_fn_GetAmxScript; +extern PFN_FIND_AMXSCRIPT_BYAMX g_fn_FindAmxScriptByAmx; +extern PFN_FIND_AMXSCRIPT_BYNAME g_fn_FindAmxScriptByName; +extern PFN_SET_AMXSTRING g_fn_SetAmxString; +extern PFN_GET_AMXSTRING g_fn_GetAmxString; +extern PFN_GET_AMXSTRINGLEN g_fn_GetAmxStringLen; +extern PFN_FORMAT_AMXSTRING g_fn_FormatAmxString; +extern PFN_COPY_AMXMEMORY g_fn_CopyAmxMemory; +extern PFN_LOG g_fn_Log; +extern PFN_LOG_ERROR g_fn_LogErrorFunc; +extern PFN_RAISE_AMXERROR g_fn_RaiseAmxError; +extern PFN_REGISTER_FORWARD g_fn_RegisterForward; +extern PFN_EXECUTE_FORWARD g_fn_ExecuteForward; +extern PFN_PREPARE_CELLARRAY g_fn_PrepareCellArray; +extern PFN_PREPARE_CHARARRAY g_fn_PrepareCharArray; +extern PFN_PREPARE_CELLARRAY_A g_fn_PrepareCellArrayA; +extern PFN_PREPARE_CHARARRAY_A g_fn_PrepareCharArrayA; +extern PFN_IS_PLAYER_VALID g_fn_IsPlayerValid; +extern PFN_GET_PLAYER_NAME g_fn_GetPlayerName; +extern PFN_GET_PLAYER_IP g_fn_GetPlayerIP; +extern PFN_IS_PLAYER_INGAME g_fn_IsPlayerIngame; +extern PFN_IS_PLAYER_BOT g_fn_IsPlayerBot; +extern PFN_IS_PLAYER_AUTHORIZED g_fn_IsPlayerAuthorized; +extern PFN_GET_PLAYER_TIME g_fn_GetPlayerTime; +extern PFN_GET_PLAYER_PLAYTIME g_fn_GetPlayerPlayTime; +extern PFN_GET_PLAYER_CURWEAPON g_fn_GetPlayerCurweapon; +extern PFN_GET_PLAYER_TEAMID g_fn_GetPlayerTeamID; +extern PFN_GET_PLAYER_DEATHS g_fn_GetPlayerDeaths; +extern PFN_GET_PLAYER_MENU g_fn_GetPlayerMenu; +extern PFN_GET_PLAYER_KEYS g_fn_GetPlayerKeys; +extern PFN_IS_PLAYER_ALIVE g_fn_IsPlayerAlive; +extern PFN_GET_PLAYER_FRAGS g_fn_GetPlayerFrags; +extern PFN_IS_PLAYER_CONNECTING g_fn_IsPlayerConnecting; +extern PFN_IS_PLAYER_HLTV g_fn_IsPlayerHLTV; +extern PFN_GET_PLAYER_ARMOR g_fn_GetPlayerArmor; +extern PFN_GET_PLAYER_HEALTH g_fn_GetPlayerHealth; +extern PFN_AMX_EXEC g_fn_AmxExec; +extern PFN_AMX_EXECV g_fn_AmxExecv; +extern PFN_AMX_ALLOT g_fn_AmxAllot; +extern PFN_AMX_FINDPUBLIC g_fn_AmxFindPublic; +extern PFN_LOAD_AMXSCRIPT g_fn_LoadAmxScript; +extern PFN_UNLOAD_AMXSCRIPT g_fn_UnloadAmxScript; +extern PFN_REAL_TO_CELL g_fn_RealToCell; +extern PFN_CELL_TO_REAL g_fn_CellToReal; +extern PFN_REGISTER_SPFORWARD g_fn_RegisterSPForward; +extern PFN_REGISTER_SPFORWARD_BYNAME g_fn_RegisterSPForwardByName; +extern PFN_UNREGISTER_SPFORWARD g_fn_UnregisterSPForward; +extern PFN_MERGEDEFINITION_FILE g_fn_MergeDefinition_File; +extern PFN_AMX_FINDNATIVE g_fn_AmxFindNative; +extern PFN_GETPLAYERFLAGS g_fn_GetPlayerFlags; +extern PFN_GET_PLAYER_EDICT g_fn_GetPlayerEdict; +extern PFN_FORMAT g_fn_Format; +extern PFN_GET_PLAYER_TEAM g_fn_GetPlayerTeam; + +#ifdef MAY_NEVER_BE_DEFINED +// Function prototypes for intellisense and similar systems +// They understand #if 0 so we use #ifdef MAY_NEVER_BE_DEFINED +int MF_AddNatives (const AMX_NATIVE_INFO *list) { } +char * MF_BuildPathname (const char * format, ...) { } +cell * MF_GetAmxAddr (AMX * amx, cell offset) { } +void MF_PrintSrvConsole (char * format, ...) { } +const char * MF_GetModname (void) { } +const char * MF_GetScriptName (int id) { } +AMX * MF_GetScriptAmx (int id) { } +int MF_FindScriptByAmx (const AMX * amx) { } +int MF_FindScriptByAmx (const char * name) { } +int MF_SetAmxString (AMX * amx, cell amx_addr, const char * source , int max ) { } +char * MF_GetAmxString (AMX * amx, cell amx_addr, int bufferId, int * pLen) { } +int MF_GetAmxStringLen (const cell *ptr) { } +char * MF_FormatAmxString (AMX * amx, cell * params, int startParam, int * pLen) { } +void MF_CopyAmxMemory (cell * dest, const cell * src, int len) { } +void MF_Log (const char * fmt, ...) { } +void MF_LogError (AMX * amx, int err, const char *fmt, ...) { } +int MF_RaiseAmxError (AMX * amx, int error) { } +int MF_RegisterForward (const char * funcname, ForwardExecType exectype, ...) { } +int MF_ExecuteForward (int id, ...) { } +cell MF_PrepareCellArray (cell * ptr, unsigned int size) { } +cell MF_PrepareCharArray (char * ptr, unsigned int size) { } +cell MF_PrepareCellArrayA (cell * ptr, unsigned int size, bool copyBack) { } +cell MF_PrepareCharArrayA (char * ptr, unsigned int size, bool copyBack) { } +int MF_IsPlayerValid (int id) { } +const char * MF_GetPlayerName (int id) { } +const char * MF_GetPlayerIP (int id) { } +int MF_IsPlayerIngame (int id) { } +int MF_IsPlayerBot (int id) { } +int MF_IsPlayerAuthorized (int id) { } +float MF_GetPlayerTime (int id) { } +float MF_GetPlayerPlayTime (int id) { } +int MF_GetPlayerCurweapon (int id) { } +const char * MF_GetPlayerTeam (int id) { } +int MF_GetPlayerTeamID (int id) { } +int MF_GetPlayerDeaths (int id) { } +int MF_GetPlayerMenu (int id) { } +int MF_GetPlayerKeys (int id) { } +int MF_IsPlayerAlive (int id) { } +int MF_GetPlayerFrags (int id) { } +int MF_IsPlayerConnecting (int id) { } +int MF_IsPlayerHLTV (int id) { } +int MF_GetPlayerArmor (int id) { } +int MF_GetPlayerHealth (int id) { } +REAL amx_ctof (cell x) { } +cell amx_ftoc (float x) { } +int MF_RegisterSPForwardByName (AMX * amx, const char *str, ...) { } +int MF_RegisterSPForward (AMX * amx, int func, ...) { } +void MF_UnregisterSPForward (int id) { } +int MF_GetPlayerFlags (int id) { } +edict_t* MF_GetPlayerEdict (int id) { } +const char * MF_Format (const char *fmt, ...) { } +#endif // MAY_NEVER_BE_DEFINED + +#define MF_AddNatives g_fn_AddNatives +#define MF_BuildPathname g_fn_BuildPathname +#define MF_FormatAmxString g_fn_FormatAmxString +#define MF_GetAmxAddr g_fn_GetAmxAddr +#define MF_PrintSrvConsole g_fn_PrintSrvConsole +#define MF_GetModname g_fn_GetModname +#define MF_GetScriptName g_fn_GetAmxScriptName +#define MF_GetScriptAmx g_fn_GetAmxScript +#define MF_FindScriptByAmx g_fn_FindAmxScriptByAmx +#define MF_FindScriptByName g_fn_FindAmxScriptByName +#define MF_SetAmxString g_fn_SetAmxString +#define MF_GetAmxString g_fn_GetAmxString +#define MF_GetAmxStringLen g_fn_GetAmxStringLen +#define MF_CopyAmxMemory g_fn_CopyAmxMemory +void MF_Log(const char *fmt, ...); +void MF_LogError(AMX *amx, int err, const char *fmt, ...); +#define MF_RaiseAmxError g_fn_RaiseAmxError +#define MF_RegisterForward g_fn_RegisterForward +#define MF_ExecuteForward g_fn_ExecuteForward +#define MF_PrepareCellArray g_fn_PrepareCellArray +#define MF_PrepareCharArray g_fn_PrepareCharArray +#define MF_PrepareCellArrayA g_fn_PrepareCellArrayA +#define MF_PrepareCharArrayA g_fn_PrepareCharArrayA +#define MF_IsPlayerValid g_fn_IsPlayerValid +#define MF_GetPlayerName g_fn_GetPlayerName +#define MF_GetPlayerIP g_fn_GetPlayerIP +#define MF_IsPlayerIngame g_fn_IsPlayerIngame +#define MF_IsPlayerBot g_fn_IsPlayerBot +#define MF_IsPlayerAuthorized g_fn_IsPlayerAuthorized +#define MF_GetPlayerTime g_fn_GetPlayerTime +#define MF_GetPlayerPlayTime g_fn_GetPlayerPlayTime +#define MF_GetPlayerCurweapon g_fn_GetPlayerCurweapon +#define MF_GetPlayerTeam g_fn_GetPlayerTeam +#define MF_GetPlayerTeamID g_fn_GetPlayerTeamID +#define MF_GetPlayerDeaths g_fn_GetPlayerDeaths +#define MF_GetPlayerMenu g_fn_GetPlayerMenu +#define MF_GetPlayerKeys g_fn_GetPlayerKeys +#define MF_IsPlayerAlive g_fn_IsPlayerAlive +#define MF_GetPlayerFrags g_fn_GetPlayerFrags +#define MF_IsPlayerConnecting g_fn_IsPlayerConnecting +#define MF_IsPlayerHLTV g_fn_IsPlayerHLTV +#define MF_GetPlayerArmor g_fn_GetPlayerArmor +#define MF_GetPlayerHealth g_fn_GetPlayerHealth +#define MF_AmxExec g_fn_AmxExec +#define MF_AmxExecv g_fn_AmxExecv +#define MF_AmxFindPublic g_fn_AmxFindPublic +#define MF_AmxAllot g_fn_AmxAllot +#define MF_AmxFindNative g_fn_AmxFindNative +#define MF_LoadAmxScript g_fn_LoadAmxScript +#define MF_UnloadAmxScript g_fn_UnloadAmxScript +#define MF_MergeDefinitionFile g_fn_MergeDefinition_File +#define amx_ctof g_fn_CellToReal +#define amx_ftoc g_fn_RealToCell +#define MF_RegisterSPForwardByName g_fn_RegisterSPForwardByName +#define MF_RegisterSPForward g_fn_RegisterSPForward +#define MF_UnregisterSPForward g_fn_UnregisterSPForward +#define MF_GetPlayerFlags g_fn_GetPlayerFlags +#define MF_GetPlayerEdict g_fn_GetPlayerEdict +#define MF_Format g_fn_Format + +/*** Memory ***/ +void *operator new(size_t reportedSize); +void *operator new[](size_t reportedSize); +void *operator new(size_t reportedSize, const char *sourceFile, int sourceLine); +void *operator new[](size_t reportedSize, const char *sourceFile, int sourceLine); +void operator delete(void *reportedAddress); +void operator delete[](void *reportedAddress); + +// Allocation types +extern const unsigned int m_alloc_unknown; +extern const unsigned int m_alloc_new; +extern const unsigned int m_alloc_new_array; +extern const unsigned int m_alloc_malloc; +extern const unsigned int m_alloc_calloc; +extern const unsigned int m_alloc_realloc; +extern const unsigned int m_alloc_delete; +extern const unsigned int m_alloc_delete_array; +extern const unsigned int m_alloc_free; + +// To be called before new / delete +void Mem_SetOwner(const char *filename, int line, const char *function); +// Actual allocator +void * Mem_Allocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc, + const unsigned int allocationType, const size_t reportedSize); +void * Mem_Reallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc, + const unsigned int reallocationType, const size_t reportedSize, void *reportedAddress); +void Mem_Deallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc, + const unsigned int deallocationType, void *reportedAddress); + +// memory macros +#ifndef __FUNCTION__ +#define __FUNCTION__ "??" +#endif + +// call Mem_SetOwner, followed by the actual new operator +#define new (Mem_SetOwner(__FILE__,__LINE__,__FUNCTION__),false) ? NULL : new +// call Mem_SetOwner, followed by the actual delete operator +#define delete (Mem_SetOwner(__FILE__,__LINE__,__FUNCTION__),false) ? Mem_SetOwner("",0,"") : delete +#define malloc(sz) Mem_Allocator (__FILE__,__LINE__,__FUNCTION__,m_alloc_malloc,sz) +#define calloc(sz) Mem_Allocator (__FILE__,__LINE__,__FUNCTION__,m_alloc_calloc,sz) +#define realloc(ptr,sz) Mem_Reallocator(__FILE__,__LINE__,__FUNCTION__,m_alloc_realloc,sz,ptr) +#define free(ptr) Mem_Deallocator(__FILE__,__LINE__,__FUNCTION__,m_alloc_free,ptr) + +#endif // #ifndef __AMXXMODULE_H__ diff --git a/dlls/csx_sql/compile.bat b/dlls/csx_sql/compile.bat new file mode 100755 index 00000000..60e889c2 --- /dev/null +++ b/dlls/csx_sql/compile.bat @@ -0,0 +1,6 @@ +@echo off +PATH=D:\gcc\bin;%PATH% + +make + +pause diff --git a/dlls/csx_sql/extra/include/mysql/config-netware.h b/dlls/csx_sql/extra/include/mysql/config-netware.h new file mode 100755 index 00000000..dab365a7 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/config-netware.h @@ -0,0 +1,85 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* Defines for netware compatible with MySQL */ + +/* required headers */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* required adjustments */ +#undef HAVE_READDIR_R +#undef HAVE_RWLOCK_INIT +#undef HAVE_SCHED_H +#undef HAVE_SYS_MMAN_H +#undef HAVE_SYNCH_H +#undef HAVE_CRYPT +#define HAVE_PTHREAD_ATTR_SETSTACKSIZE 1 +#define HAVE_PTHREAD_SIGMASK 1 +#define HAVE_PTHREAD_YIELD_ZERO_ARG 1 +#define HAVE_BROKEN_REALPATH 1 + +/* include the old function apis */ +#define USE_OLD_FUNCTIONS 1 + +/* no case sensitivity */ +#define FN_NO_CASE_SENCE 1 + +/* the thread alarm is not used */ +#define DONT_USE_THR_ALARM 1 + +/* signals do not interrupt sockets */ +#define SIGNALS_DONT_BREAK_READ 1 + +/* signal by closing the sockets */ +#define SIGNAL_WITH_VIO_CLOSE 1 + +/* default directory information */ +#define DEFAULT_MYSQL_HOME "sys:/mysql" +#define PACKAGE "mysql" +#define DEFAULT_BASEDIR "sys:/" +#define SHAREDIR "share/" +#define DEFAULT_CHARSET_HOME "sys:/mysql/" +#define DATADIR "data/" + +/* 64-bit file system calls */ +#define SIZEOF_OFF_T 8 +#define off_t off64_t +#define chsize chsize64 +#define ftruncate ftruncate64 +#define lseek lseek64 +#define pread pread64 +#define pwrite pwrite64 +#define tell tell64 + +/* do not use the extended time in LibC sys\stat.h */ +#define _POSIX_SOURCE + +/* Some macros for portability */ + +#define set_timespec(ABSTIME,SEC) { (ABSTIME).tv_sec=(SEC); (ABSTIME).tv_nsec=0; } diff --git a/dlls/csx_sql/extra/include/mysql/config-os2.h b/dlls/csx_sql/extra/include/mysql/config-os2.h new file mode 100755 index 00000000..7e9684ae --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/config-os2.h @@ -0,0 +1,832 @@ +/* Copyright (C) 2000 MySQL AB & Yuri Dario + All the above parties has a full, independent copyright to + the following code, including the right to use the code in + any manner without any demands from the other parties. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, + MA 02111-1307, USA */ + +/* Defines for OS2 to make it compatible for MySQL */ + +#ifndef __CONFIG_OS2_H__ +#define __CONFIG_OS2_H__ + +#include +#include +#include +#include + +/* Define to name of system eg solaris*/ +#define SYSTEM_TYPE "IBM OS/2 Warp" +/* Define to machine type name eg sun10 */ +#define MACHINE_TYPE "i686" +/* Name of package */ +#define PACKAGE "mysql" +/* Version number of package */ +#define VERSION MYSQL_SERVER_VERSION +/* Default socket */ +#define MYSQL_UNIX_ADDR "\\socket\\MySQL" + +#define FN_LIBCHAR '\\' +#define FN_ROOTDIR "\\" +#define MY_NFILE 1024 /* This is only used to save filenames */ + +#define HAVE_ACCESS + +#define DEFAULT_MYSQL_HOME "c:\\mysql" +#define DEFAULT_BASEDIR "C:\\" +#define SHAREDIR "share" +#define DEFAULT_CHARSET_HOME "C:/mysql/" +#define _POSIX_PATH_MAX 255 +#define DWORD ULONG + +#define O_SHARE 0x1000 /* Open file in sharing mode */ +#define FILE_BINARY O_BINARY /* my_fopen in binary mode */ +#define S_IROTH S_IREAD /* for my_lib */ + +#define CANT_DELETE_OPEN_FILES /* saves open files in a list, for delayed delete */ + +#define O_NONBLOCK 0x10 + +#define NO_OPEN_3 /* For my_create() */ +#define SIGQUIT SIGTERM /* No SIGQUIT */ +#define SIGALRM 14 /* Alarm */ + +#define NO_FCNTL_NONBLOCK + +#define EFBIG E2BIG +/*#define ENFILE EMFILE */ +/*#define ENAMETOOLONG (EOS2ERR+2) */ +/*#define ETIMEDOUT 145 */ +/*#define EPIPE 146 */ +#define EROFS 147 + +#define sleep(A) DosSleep((A)*1000) +#define closesocket(A) soclose(A) + +#define F_OK 0 +#define W_OK 2 + +#define bzero(x,y) memset((x),'\0',(y)) +#define bcopy(x,y,z) memcpy((y),(x),(z)) +#define bcmp(x,y,z) memcmp((y),(x),(z)) + +#define F_RDLCK 4 /* Read lock. */ +#define F_WRLCK 2 /* Write lock. */ +#define F_UNLCK 0 /* Remove lock. */ + +#define S_IFMT 0x17000 /* Mask for file type */ +#define F_TO_EOF 0L /* Param to lockf() to lock rest of file */ + +#define HUGE_PTR + +#ifdef __cplusplus +extern "C" +#endif +double _cdecl rint( double nr); + +DWORD TlsAlloc( void); +BOOL TlsFree( DWORD); +PVOID TlsGetValue( DWORD); +BOOL TlsSetValue( DWORD, PVOID); + +/* support for > 2GB file size */ +#define SIZEOF_OFF_T 8 +#define lseek(A,B,C) _lseek64( A, B, C) +#define tell(A) _lseek64( A, 0, SEEK_CUR) + +void* dlopen( char* path, int flag); +char* dlerror( void); +void* dlsym( void* hmod, char* fn); +void dlclose( void* hmod); + +/* Some typedefs */ +typedef unsigned long long os_off_t; + +/* config.h. Generated automatically by configure. */ +/* config.h.in. Generated automatically from configure.in by autoheader. */ + +/* Define if using alloca.c. */ +/* #undef C_ALLOCA */ + +/* Define to empty if the keyword does not work. */ +/* #undef const */ + +/* Define to one of _getb67, GETB67, getb67 for Cray-2 and Cray-YMP systems. + This function is required for alloca.c support on those systems. */ +/* #undef CRAY_STACKSEG_END */ + +/* Define if you have alloca, as a function or macro. */ +#define HAVE_ALLOCA 1 + +/* Define if you have and it should be used (not on Ultrix). */ +/* #define HAVE_ALLOCA_H 1 */ + +/* Define if you don't have vprintf but do have _doprnt. */ +/* #undef HAVE_DOPRNT */ + +/* Define if you have a working `mmap' system call. */ +/* #undef HAVE_MMAP */ + +/* Define if system calls automatically restart after interruption + by a signal. */ +/* #undef HAVE_RESTARTABLE_SYSCALLS */ + +/* Define if your struct stat has st_rdev. */ +#define HAVE_ST_RDEV 1 + +/* Define if you have that is POSIX.1 compatible. */ +/* #define HAVE_SYS_WAIT_H 1 */ + +/* Define if you don't have tm_zone but do have the external array + tzname. */ +#define HAVE_TZNAME 1 + +/* Define if utime(file, NULL) sets file's timestamp to the present. */ +#define HAVE_UTIME_NULL 1 + +/* Define if you have the vprintf function. */ +#define HAVE_VPRINTF 1 + +/* Define as __inline if that's what the C compiler calls it. */ +/* #undef inline */ + +/* Define to `long' if doesn't define. */ +/* #undef off_t */ + +/* Define as the return type of signal handlers (int or void). */ +#define RETSIGTYPE void + +/* Define to `unsigned' if doesn't define. */ +/* #undef size_t */ + +/* If using the C implementation of alloca, define if you know the + direction of stack growth for your system; otherwise it will be + automatically deduced at run-time. + STACK_DIRECTION > 0 => grows toward higher addresses + STACK_DIRECTION < 0 => grows toward lower addresses + STACK_DIRECTION = 0 => direction of growth unknown + */ +#define STACK_DIRECTION -1 + +/* Define if the `S_IS*' macros in do not work properly. */ +/* #undef STAT_MACROS_BROKEN */ + +/* Define if you have the ANSI C header files. */ +#define STDC_HEADERS 1 + +/* Define if you can safely include both and . */ +#define TIME_WITH_SYS_TIME 1 + +/* Define if your declares struct tm. */ +/* #undef TM_IN_SYS_TIME */ + +/* Define if your processor stores words with the most significant + byte first (like Motorola and SPARC, unlike Intel and VAX). */ +/* #undef WORDS_BIGENDIAN */ + +/* Version of .frm files */ +#define DOT_FRM_VERSION 6 + +/* READLINE: */ +#define FIONREAD_IN_SYS_IOCTL 1 + +/* READLINE: Define if your system defines TIOCGWINSZ in sys/ioctl.h. */ +/* #undef GWINSZ_IN_SYS_IOCTL */ + +/* Do we have FIONREAD */ +#define FIONREAD_IN_SYS_IOCTL 1 + +/* atomic_add() from (Linux only) */ +/* #undef HAVE_ATOMIC_ADD */ + +/* atomic_sub() from (Linux only) */ +/* #undef HAVE_ATOMIC_SUB */ + +/* bool is not defined by all C++ compilators */ +#define HAVE_BOOL 1 + +/* Have berkeley db installed */ +/* #define HAVE_BERKELEY_DB 1 */ + +/* DSB style signals ? */ +/* #undef HAVE_BSD_SIGNALS */ + +/* Can netinet be included */ +/* #undef HAVE_BROKEN_NETINET_INCLUDES */ + +/* READLINE: */ +/* #undef HAVE_BSD_SIGNALS */ + +/* ZLIB and compress: */ +#define HAVE_COMPRESS 1 + +/* Define if we are using OSF1 DEC threads */ +/* #undef HAVE_DEC_THREADS */ + +/* Define if we are using OSF1 DEC threads on 3.2 */ +/* #undef HAVE_DEC_3_2_THREADS */ + +/* fp_except from ieeefp.h */ +/* #undef HAVE_FP_EXCEPT */ + +/* READLINE: */ +/* #undef HAVE_GETPW_DECLS */ + +/* Solaris define gethostbyname_r with 5 arguments. glibc2 defines + this with 6 arguments */ +/* #undef HAVE_GETHOSTBYNAME_R_GLIBC2_STYLE */ + +/* In OSF 4.0f the 3'd argument to gethostname_r is hostent_data * */ +/* #undef HAVE_GETHOSTBYNAME_R_RETURN_INT */ + +/* Define if int8, int16 and int32 types exist */ +/* #undef HAVE_INT_8_16_32 */ + +/* Define if have -lwrap */ +/* #undef HAVE_LIBWRAP */ + +/* Define if we are using Xavier Leroy's LinuxThreads */ +/* #undef HAVE_LINUXTHREADS */ + +/* Do we use user level threads */ +/* #undef HAVE_mit_thread */ + +/* For some non posix threads */ +/* #undef HAVE_NONPOSIX_PTHREAD_GETSPECIFIC */ + +/* For some non posix threads */ +/* #undef HAVE_NONPOSIX_PTHREAD_MUTEX_INIT */ + +/* READLINE: */ +#define HAVE_POSIX_SIGNALS 0 + +/* sigwait with one argument */ +/* #undef HAVE_NONPOSIX_SIGWAIT */ + +/* pthread_attr_setscope */ +#define HAVE_PTHREAD_ATTR_SETSCOPE 1 + +/* POSIX readdir_r */ +/* #undef HAVE_READDIR_R */ + +/* POSIX sigwait */ +/* #undef HAVE_SIGWAIT */ + +/* crypt */ +#define HAVE_CRYPT 1 + +/* Solaris define gethostbyaddr_r with 7 arguments. glibc2 defines + this with 8 arguments */ +/* #undef HAVE_SOLARIS_STYLE_GETHOST */ + +/* Timespec has a ts_sec instead of tv_sev */ +#define HAVE_TIMESPEC_TS_SEC 1 + +/* Have the tzname variable */ +#define HAVE_TZNAME 1 + +/* Define if the system files define uchar */ +/* #undef HAVE_UCHAR */ + +/* Define if the system files define uint */ +/* #undef HAVE_UINT */ + +/* Define if the system files define ulong */ +/* #undef HAVE_ULONG */ + +/* UNIXWARE7 threads are not posix */ +/* #undef HAVE_UNIXWARE7_THREADS */ + +/* new UNIXWARE7 threads that are not yet posix */ +/* #undef HAVE_UNIXWARE7_POSIX */ + +/* READLINE: */ +/* #undef HAVE_USG_SIGHOLD */ + +/* Define if want -lwrap */ +/* #undef LIBWRAP */ + +/* mysql client protocoll version */ +#define PROTOCOL_VERSION 10 + +/* Define if qsort returns void */ +#define QSORT_TYPE_IS_VOID 1 + +/* Define as the return type of qsort (int or void). */ +#define RETQSORTTYPE void + +/* Define as the base type of the last arg to accept */ +#define SOCKET_SIZE_TYPE int + +/* Last argument to get/setsockopt */ +/* #undef SOCKOPT_OPTLEN_TYPE */ + +/* #undef SPEED_T_IN_SYS_TYPES */ +/* #undef SPRINTF_RETURNS_PTR */ +#define SPRINTF_RETURNS_INT 1 +/* #undef SPRINTF_RETURNS_GARBAGE */ + +/* #undef STRUCT_DIRENT_HAS_D_FILENO */ +#define STRUCT_DIRENT_HAS_D_INO 1 + +/* Define if you want to have threaded code. This may be undef on client code */ +#define THREAD 1 + +/* Should be client be thread safe */ +/* #undef THREAD_SAFE_CLIENT */ + +/* READLINE: */ +/* #undef TIOCSTAT_IN_SYS_IOCTL */ + +/* Use multi-byte character routines */ +/* #undef USE_MB */ +/* #undef USE_MB_IDENT */ + +/* Use MySQL RAID */ +/* #undef USE_RAID */ + +/* Use strcoll() functions when comparing and sorting. */ +/* #undef USE_STRCOLL */ + +/* READLINE: */ +#define VOID_SIGHANDLER 1 + +/* The number of bytes in a char. */ +#define SIZEOF_CHAR 1 + +/* The number of bytes in a int. */ +#define SIZEOF_INT 4 + +/* The number of bytes in a long. */ +#define SIZEOF_LONG 4 + +/* The number of bytes in a long long. */ +#define SIZEOF_LONG_LONG 8 + +/* Define if you have the alarm function. */ +#define HAVE_ALARM 1 + +/* Define if you have the atod function. */ +/* #undef HAVE_ATOD */ + +/* Define if you have the bcmp function. */ +#define HAVE_BCMP 1 + +/* Define if you have the bfill function. */ +/* #undef HAVE_BFILL */ + +/* Define if you have the bmove function. */ +/* #undef HAVE_BMOVE */ + +/* Define if you have the bzero function. */ +#define HAVE_BZERO 1 + +/* Define if you have the chsize function. */ +#define HAVE_CHSIZE 1 + +/* Define if you have the cuserid function. */ +/* #define HAVE_CUSERID 1 */ + +/* Define if you have the dlerror function. */ +#define HAVE_DLERROR 1 + +/* Define if you have the dlopen function. */ +#define HAVE_DLOPEN 1 + +/* Define if you have the fchmod function. */ +/* #undef HAVE_FCHMOD */ + +/* Define if you have the fcntl function. */ +/* #define HAVE_FCNTL 1 */ + +/* Define if you have the fconvert function. */ +/* #undef HAVE_FCONVERT */ + +/* Define if you have the finite function. */ +/* #undef HAVE_FINITE */ + +/* Define if you have the fpresetsticky function. */ +/* #undef HAVE_FPRESETSTICKY */ + +/* Define if you have the fpsetmask function. */ +/* #undef HAVE_FPSETMASK */ + +/* Define if you have the fseeko function. */ +/* #undef HAVE_FSEEKO */ + +/* Define if you have the ftruncate function. */ +/* #define HAVE_FTRUNCATE 1 */ + +/* Define if you have the getcwd function. */ +#define HAVE_GETCWD 1 + +/* Define if you have the gethostbyaddr_r function. */ +/* #undef HAVE_GETHOSTBYADDR_R */ + +/* Define if you have the gethostbyname_r function. */ +/* #undef HAVE_GETHOSTBYNAME_R */ + +/* Define if you have the getpagesize function. */ +#define HAVE_GETPAGESIZE 1 + +/* Define if you have the getpass function. */ +/*#define HAVE_GETPASS 1 */ + +/* Define if you have the getpassphrase function. */ +/* #undef HAVE_GETPASSPHRASE */ + +/* Define if you have the getpwnam function. */ +/* #define HAVE_GETPWNAM 1 */ + +/* Define if you have the getpwuid function. */ +/* #define HAVE_GETPWUID 1 */ + +/* Define if you have the getrlimit function. */ +/* #undef HAVE_GETRLIMIT */ + +/* Define if you have the getrusage function. */ +/* #undef HAVE_GETRUSAGE */ + +/* Define if you have the getwd function. */ +#define HAVE_GETWD 1 + +/* Define if you have the index function. */ +#define HAVE_INDEX 1 + +/* Define if you have the initgroups function. */ +/* #undef HAVE_INITGROUPS */ + +/* Define if you have the localtime_r function. */ +#define HAVE_LOCALTIME_R 1 + +/* Define if you have the locking function. */ +/* #undef HAVE_LOCKING */ + +/* Define if you have the longjmp function. */ +#define HAVE_LONGJMP 1 + +/* Define if you have the lrand48 function. */ +/* #undef HAVE_LRAND48 */ + +/* Define if you have the lstat function. */ +/* #undef HAVE_LSTAT */ + +/* Define if you have the madvise function. */ +/* #undef HAVE_MADVISE */ + +/* Define if you have the memcpy function. */ +#define HAVE_MEMCPY 1 + +/* Define if you have the memmove function. */ +#define HAVE_MEMMOVE 1 + +/* Define if you have the mkstemp function. */ +/* #define HAVE_MKSTEMP 1 */ + +/* Define if you have the mlockall function. */ +/* #undef HAVE_MLOCKALL */ + +/* Define if you have the perror function. */ +#define HAVE_PERROR 1 + +/* Define if you have the poll function. */ +/* #undef HAVE_POLL */ + +/* Define if you have the pread function. */ +/* #undef HAVE_PREAD */ + +/* Define if you have the pthread_attr_create function. */ +/* #undef HAVE_PTHREAD_ATTR_CREATE */ + +/* Define if you have the pthread_attr_setprio function. */ +#define HAVE_PTHREAD_ATTR_SETPRIO 1 + +/* Define if you have the pthread_attr_setschedparam function. */ +/* #undef HAVE_PTHREAD_ATTR_SETSCHEDPARAM */ + +/* Define if you have the pthread_attr_setstacksize function. */ +#define HAVE_PTHREAD_ATTR_SETSTACKSIZE 1 + +/* Define if you have the pthread_condattr_create function. */ +/* #undef HAVE_PTHREAD_CONDATTR_CREATE */ + +/* Define if you have the pthread_getsequence_np function. */ +/* #undef HAVE_PTHREAD_GETSEQUENCE_NP */ + +/* Define if you have the pthread_init function. */ +/* #undef HAVE_PTHREAD_INIT */ + +/* Define if you have the pthread_rwlock_rdlock function. */ +/* #undef HAVE_PTHREAD_RWLOCK_RDLOCK */ + +/* Define if you have the pthread_setprio function. */ +#define HAVE_PTHREAD_SETPRIO 1 + +/* Define if you have the pthread_setprio_np function. */ +/* #undef HAVE_PTHREAD_SETPRIO_NP */ + +/* Define if you have the pthread_setschedparam function. */ +/* #undef HAVE_PTHREAD_SETSCHEDPARAM */ + +/* Define if you have the pthread_sigmask function. */ +#define HAVE_PTHREAD_SIGMASK 1 + +/* Define if you have the putenv function. */ +#define HAVE_PUTENV 1 + +/* Define if you have the readlink function. */ +/* #undef HAVE_READLINK */ + +/* Define if you have the realpath function. */ +/* #undef HAVE_REALPATH */ + +/* Define if you have the rename function. */ +#define HAVE_RENAME 1 + +/* Define if you have the rint function. */ +#define HAVE_RINT 1 + +/* Define if you have the rwlock_init function. */ +/* #undef HAVE_RWLOCK_INIT */ + +/* Define if you have the select function. */ +#define HAVE_SELECT 1 + +/* Define if you have the setenv function. */ +/* #undef HAVE_SETENV */ + +/* Define if you have the setlocale function. */ +#define HAVE_SETLOCALE 1 + +/* Define if you have the setupterm function. */ +/* #undef HAVE_SETUPTERM */ + +/* Define if you have the sighold function. */ +/* #undef HAVE_SIGHOLD */ + +/* Define if you have the sigset function. */ +/* #undef HAVE_SIGSET */ + +/* Define if you have the sigthreadmask function. */ +/* #undef HAVE_SIGTHREADMASK */ + +/* Define if you have the snprintf function. */ +/* #define HAVE_SNPRINTF 1 */ + +/* Define if you have the socket function. */ +#define HAVE_SOCKET 1 + +/* Define if you have the stpcpy function. */ +/* #undef HAVE_STPCPY */ + +/* Define if you have the strcasecmp function. */ +/* #undef HAVE_STRCASECMP */ + +/* Define if you have the strcoll function. */ +#define HAVE_STRCOLL 1 + +/* Define if you have the strerror function. */ +#define HAVE_STRERROR 1 + +/* Define if you have the strnlen function. */ +/* #undef HAVE_STRNLEN */ + +/* Define if you have the strpbrk function. */ +#define HAVE_STRPBRK 1 + +/* Define if you have the strstr function. */ +#define HAVE_STRSTR 1 + +/* Define if you have the strtok_r function. */ +/* #undef HAVE_STRTOK_R */ + +/* Define if you have the strtol function. */ +#define HAVE_STRTOL 1 + +/* Define if you have the strtoul function. */ +#define HAVE_STRTOUL 1 + +/* Define if you have the strtoull function. */ +/* #undef HAVE_STRTOULL */ + +/* Define if you have the tcgetattr function. */ +#define HAVE_TCGETATTR 1 + +/* Define if you have the tell function. */ +#define HAVE_TELL 1 + +/* Define if you have the tempnam function. */ +#define HAVE_TEMPNAM 1 + +/* Define if you have the thr_setconcurrency function. */ +/* #undef HAVE_THR_SETCONCURRENCY */ + +/* Define if you have the vidattr function. */ +/* #undef HAVE_VIDATTR */ + +/* Define if you have the header file. */ +/* #define HAVE_ALLOCA_H 1 */ + +/* Define if you have the header file. */ +#define HAVE_ARPA_INET_H 1 + +/* Define if you have the header file. */ +/* #undef HAVE_ASM_TERMBITS_H */ + +/* Define if you have the header file. */ +#define HAVE_CRYPT_H 1 + +/* Define if you have the header file. */ +/* #define HAVE_CURSES_H 1 */ + +/* Define if you have the header file. */ +/* #define HAVE_DIRENT_H 1 */ + +/* Define if you have the header file. */ +#define HAVE_FCNTL_H 1 + +/* Define if you have the header file. */ +#define HAVE_FLOAT_H 1 + +/* Define if you have the header file. */ +/* #undef HAVE_FLOATINGPOINT_H */ + +/* Define if you have the header file. */ +/* #define HAVE_GRP_H 1 */ + +/* Define if you have the header file. */ +/* #undef HAVE_IEEEFP_H */ + +/* Define if you have the header file. */ +#define HAVE_LIMITS_H 1 + +/* Define if you have the header file. */ +#define HAVE_LOCALE_H 1 + +/* Define if you have the header file. */ +#define HAVE_MEMORY_H 1 + +/* Define if you have the header file. */ +/* #undef HAVE_NDIR_H */ + +/* Define if you have the header file. */ +#define HAVE_NETINET_IN_H 1 + +/* Define if you have the header file. */ +/* #undef HAVE_PATHS_H */ + +/* Define if you have the header file. */ +/* #define HAVE_PWD_H 1 */ + +/* Define if you have the header file. */ +/* #undef HAVE_SCHED_H */ + +/* Define if you have the header file. */ +/* #undef HAVE_SELECT_H */ + +/* Define if you have the header file. */ +#define HAVE_STDARG_H 1 + +/* Define if you have the header file. */ +#define HAVE_STDDEF_H 1 + +/* Define if you have the header file. */ +#define HAVE_STDLIB_H 1 + +/* Define if you have the header file. */ +#define HAVE_STRING_H 1 + +/* Define if you have the header file. */ +/* #define HAVE_STRINGS_H 1 */ + +/* Define if you have the header file. */ +/* #undef HAVE_SYNCH_H */ + +/* Define if you have the header file. */ +/* #define HAVE_SYS_DIR_H 1 */ + +/* Define if you have the header file. */ +/* #define HAVE_SYS_FILE_H 1 */ + +/* Define if you have the header file. */ +#define HAVE_SYS_IOCTL_H 1 + +/* Define if you have the header file. */ +/* #undef HAVE_SYS_MMAN_H */ + +/* Define if you have the header file. */ +/* #undef HAVE_SYS_NDIR_H */ + +/* Define if you have the header file. */ +/* #undef HAVE_SYS_PTE_H */ + +/* Define if you have the header file. */ +/* #undef HAVE_SYS_PTEM_H */ + +/* Define if you have the header file. */ +#define HAVE_SYS_SELECT_H 1 + +/* Define if you have the header file. */ +#define HAVE_SYS_SOCKET_H 1 + +/* Define if you have the header file. */ +/* #undef HAVE_SYS_STREAM_H */ + +/* Define if you have the header file. */ +#define HAVE_SYS_TIMEB_H 1 + +/* Define if you have the header file. */ +#define HAVE_SYS_TYPES_H 1 + +/* Define if you have the header file. */ +#define HAVE_SYS_UN_H 1 + +/* Define if you have the header file. */ +#define HAVE_SYS_UTIME_H 1 + +/* Define if you have the header file. */ +/* #undef HAVE_SYS_VADVISE_H */ + +/* Define if you have the header file. */ +/* #define HAVE_SYS_WAIT_H 1 */ + +/* Define if you have the header file. */ +/* #undef HAVE_TERM_H */ + +/* Define if you have the header file. */ +/* #undef HAVE_TERMBITS_H */ + +/* Define if you have the header file. */ +/* #define HAVE_TERMCAP_H 1 */ + +/* Define if you have the header file. */ +/* /#define HAVE_TERMIO_H 1 */ + +/* Define if you have the header file. */ +/* #define HAVE_TERMIOS_H 1 */ + +/* Define if you have the header file. */ +#define HAVE_UNISTD_H 1 + +/* Define if you have the header file. */ +#define HAVE_UTIME_H 1 + +/* Define if you have the header file. */ +#define HAVE_VARARGS_H 1 + +/* Define if you have the bind library (-lbind). */ +/* #undef HAVE_LIBBIND */ + +/* Define if you have the c_r library (-lc_r). */ +/* #undef HAVE_LIBC_R */ + +/* Define if you have the compat library (-lcompat). */ +/* #undef HAVE_LIBCOMPAT */ + +/* Define if you have the crypt library (-lcrypt). */ +#define HAVE_LIBCRYPT 1 + +/* Define if you have the dl library (-ldl). */ +#define HAVE_LIBDL 1 + +/* Define if you have the gen library (-lgen). */ +/* #undef HAVE_LIBGEN */ + +/* Define if you have the m library (-lm). */ +#define HAVE_LIBM 1 + +/* Define if you have the nsl library (-lnsl). */ +/* #undef HAVE_LIBNSL */ + +/* Define if you have the nsl_r library (-lnsl_r). */ +/* #undef HAVE_LIBNSL_R */ + +/* Define if you have the pthread library (-lpthread). */ +/* #undef HAVE_LIBPTHREAD */ + +/* Define if you have the socket library (-lsocket). */ +/* #undef HAVE_LIBSOCKET */ + +/* Number of bits in a file offset, on hosts where this is settable. */ +/* #undef _FILE_OFFSET_BITS */ + +/* Define to make fseeko etc. visible, on some hosts. */ +/* #undef _LARGEFILE_SOURCE */ + +/* Define for large files, on AIX-style hosts. */ +/* #undef _LARGE_FILES */ + +#endif /* __CONFIG_OS2_H__ */ diff --git a/dlls/csx_sql/extra/include/mysql/config-win.h b/dlls/csx_sql/extra/include/mysql/config-win.h new file mode 100755 index 00000000..e6f03a10 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/config-win.h @@ -0,0 +1,335 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* Defines for Win32 to make it compatible for MySQL */ + +#include +#include +#include /* Because of rint() */ +#include +#include +#include + +#if defined(__NT__) +#define SYSTEM_TYPE "NT" +#elif defined(__WIN2000__) +#define SYSTEM_TYPE "WIN2000" +#else +#define SYSTEM_TYPE "Win95/Win98" +#endif + +#if defined(_WIN64) || defined(WIN64) +#define MACHINE_TYPE "ia64" /* Define to machine type name */ +#else +#define MACHINE_TYPE "i32" /* Define to machine type name */ +#ifndef _WIN32 +#define _WIN32 /* Compatible with old source */ +#endif +#ifndef __WIN32__ +#define __WIN32__ +#endif +#endif /* _WIN64 */ +#ifndef __WIN__ +#define __WIN__ /* To make it easier in VC++ */ +#endif + +/* File and lock constants */ +#define O_SHARE 0x1000 /* Open file in sharing mode */ +#ifdef __BORLANDC__ +#define F_RDLCK LK_NBLCK /* read lock */ +#define F_WRLCK LK_NBRLCK /* write lock */ +#define F_UNLCK LK_UNLCK /* remove lock(s) */ +#else +#define F_RDLCK _LK_NBLCK /* read lock */ +#define F_WRLCK _LK_NBRLCK /* write lock */ +#define F_UNLCK _LK_UNLCK /* remove lock(s) */ +#endif + +#define F_EXCLUSIVE 1 /* We have only exclusive locking */ +#define F_TO_EOF (INT_MAX32/2) /* size for lock of all file */ +#define F_OK 0 /* parameter to access() */ + +#define S_IROTH S_IREAD /* for my_lib */ + +#ifdef __BORLANDC__ +#define FILE_BINARY O_BINARY /* my_fopen in binary mode */ +#define O_TEMPORARY 0 +#define O_SHORT_LIVED 0 +#define SH_DENYNO _SH_DENYNO +#else +#define O_BINARY _O_BINARY /* compability with MSDOS */ +#define FILE_BINARY _O_BINARY /* my_fopen in binary mode */ +#define O_TEMPORARY _O_TEMPORARY +#define O_SHORT_LIVED _O_SHORT_LIVED +#define SH_DENYNO _SH_DENYNO +#endif +#define NO_OPEN_3 /* For my_create() */ + +#define SIGQUIT SIGTERM /* No SIGQUIT */ + +#undef _REENTRANT /* Crashes something for win32 */ +#undef SAFE_MUTEX /* Can't be used on windows */ + +#define LONGLONG_MIN ((__int64) 0x8000000000000000) +#define LONGLONG_MAX ((__int64) 0x7FFFFFFFFFFFFFFF) +#define ULONGLONG_MAX ((unsigned __int64) 0xFFFFFFFFFFFFFFFF) +#define LL(A) ((__int64) A) + +/* Type information */ + +typedef unsigned short ushort; +typedef unsigned int uint; +typedef unsigned __int64 ulonglong; /* Microsofts 64 bit types */ +typedef __int64 longlong; +typedef int sigset_t; +#define longlong_defined +/* off_t should not be __int64 because of conflicts in header files; + Use my_off_t or os_off_t instead */ +typedef long off_t; +typedef __int64 os_off_t; +#ifdef _WIN64 +typedef UINT_PTR rf_SetTimer; +#else +typedef unsigned int size_t; +typedef uint rf_SetTimer; +#endif + +#define Socket_defined +#define my_socket SOCKET +#define bool BOOL +#define SIGPIPE SIGINT +#define RETQSORTTYPE void +#define QSORT_TYPE_IS_VOID +#define RETSIGTYPE void +#define SOCKET_SIZE_TYPE int +#define my_socket_defined +#define bool_defined +#define byte_defined +#define HUGE_PTR +#define STDCALL __stdcall /* Used by libmysql.dll */ +#define isnan(X) _isnan(X) +#define finite(X) _finite(X) + +#ifndef UNDEF_THREAD_HACK +#define THREAD +#endif +#define VOID_SIGHANDLER +#define SIZEOF_CHAR 1 +#define SIZEOF_LONG 4 +#define SIZEOF_LONG_LONG 8 +#define SIZEOF_OFF_T 8 +#ifdef _WIN64 +#define SIZEOF_CHARP 8 +#else +#define SIZEOF_CHARP 4 +#endif +#define HAVE_BROKEN_NETINET_INCLUDES +#ifdef __NT__ +#define HAVE_NAMED_PIPE /* We can only create pipes on NT */ +#endif + +/* We need to close files to break connections on shutdown */ +#ifndef SIGNAL_WITH_VIO_CLOSE +#define SIGNAL_WITH_VIO_CLOSE +#endif + +/* Use all character sets in MySQL */ +#define USE_MB 1 +#define USE_MB_IDENT 1 +#define USE_STRCOLL 1 + +/* All windows servers should support .sym files */ +#undef USE_SYMDIR +#define USE_SYMDIR + +/* If LOAD DATA LOCAL INFILE should be enabled by default */ +#define ENABLED_LOCAL_INFILE 1 + +/* Convert some simple functions to Posix */ + +#define sigset(A,B) signal((A),(B)) +#define finite(A) _finite(A) +#define sleep(A) Sleep((A)*1000) + +#ifndef __BORLANDC__ +#define access(A,B) _access(A,B) +#endif + +#if defined(__cplusplus) + +inline double rint(double nr) +{ + double f = floor(nr); + double c = ceil(nr); + return (((c-nr) >= (nr-f)) ? f :c); +} + +#ifdef _WIN64 +#define ulonglong2double(A) ((double) (ulonglong) (A)) +#define my_off_t2double(A) ((double) (my_off_t) (A)) + +#else +inline double ulonglong2double(ulonglong value) +{ + longlong nr=(longlong) value; + if (nr >= 0) + return (double) nr; + return (18446744073709551616.0 + (double) nr); +} +#define my_off_t2double(A) ulonglong2double(A) +#endif /* _WIN64 */ +#else +#define inline __inline +#endif /* __cplusplus */ + +#if SIZEOF_OFF_T > 4 +#define lseek(A,B,C) _lseeki64((A),(longlong) (B),(C)) +#define tell(A) _telli64(A) +#endif + +#define set_timespec(ABSTIME,SEC) { (ABSTIME).tv_sec=time((time_t*)0) + (time_t) (SEC); (ABSTIME).tv_nsec=0; } + +#define STACK_DIRECTION -1 + +/* Optimized store functions for Intel x86 */ + +#ifndef _WIN64 +#define sint2korr(A) (*((int16 *) (A))) +#define sint3korr(A) ((int32) ((((uchar) (A)[2]) & 128) ? \ + (((uint32) 255L << 24) | \ + (((uint32) (uchar) (A)[2]) << 16) |\ + (((uint32) (uchar) (A)[1]) << 8) | \ + ((uint32) (uchar) (A)[0])) : \ + (((uint32) (uchar) (A)[2]) << 16) |\ + (((uint32) (uchar) (A)[1]) << 8) | \ + ((uint32) (uchar) (A)[0]))) +#define sint4korr(A) (*((long *) (A))) +#define uint2korr(A) (*((uint16 *) (A))) +#define uint3korr(A) (long) (*((unsigned long *) (A)) & 0xFFFFFF) +#define uint4korr(A) (*((unsigned long *) (A))) +#define uint5korr(A) ((ulonglong)(((uint32) ((uchar) (A)[0])) +\ + (((uint32) ((uchar) (A)[1])) << 8) +\ + (((uint32) ((uchar) (A)[2])) << 16) +\ + (((uint32) ((uchar) (A)[3])) << 24)) +\ + (((ulonglong) ((uchar) (A)[4])) << 32)) +#define uint8korr(A) (*((ulonglong *) (A))) +#define sint8korr(A) (*((longlong *) (A))) +#define int2store(T,A) *((uint16*) (T))= (uint16) (A) +#define int3store(T,A) { *(T)= (uchar) ((A));\ + *(T+1)=(uchar) (((uint) (A) >> 8));\ + *(T+2)=(uchar) (((A) >> 16)); } +#define int4store(T,A) *((long *) (T))= (long) (A) +#define int5store(T,A) { *(T)= (uchar)((A));\ + *((T)+1)=(uchar) (((A) >> 8));\ + *((T)+2)=(uchar) (((A) >> 16));\ + *((T)+3)=(uchar) (((A) >> 24)); \ + *((T)+4)=(uchar) (((A) >> 32)); } +#define int8store(T,A) *((ulonglong *) (T))= (ulonglong) (A) + +#define doubleget(V,M) { *((long *) &V) = *((long*) M); \ + *(((long *) &V)+1) = *(((long*) M)+1); } +#define doublestore(T,V) { *((long *) T) = *((long*) &V); \ + *(((long *) T)+1) = *(((long*) &V)+1); } +#define float4get(V,M) { *((long *) &(V)) = *((long*) (M)); } +#define float8get(V,M) doubleget((V),(M)) +#define float4store(V,M) memcpy((byte*) V,(byte*) (&M),sizeof(float)) +#define float8store(V,M) doublestore((V),(M)) +#endif /* _WIN64 */ + +#define HAVE_PERROR +#define HAVE_VFPRINT +#define HAVE_RENAME /* Have rename() as function */ +#define HAVE_BINARY_STREAMS /* Have "b" flag in streams */ +#define HAVE_LONG_JMP /* Have long jump function */ +#define HAVE_LOCKING /* have locking() call */ +#define HAVE_ERRNO_AS_DEFINE /* errno is a define */ +#define HAVE_STDLIB /* everything is include in this file */ +#define HAVE_MEMCPY +#define HAVE_MEMMOVE +#define HAVE_GETCWD +#define HAVE_TELL +#define HAVE_TZNAME +#define HAVE_PUTENV +#define HAVE_SELECT +#define HAVE_SETLOCALE +#define HAVE_SOCKET /* Giangi */ +#define HAVE_FLOAT_H +#define HAVE_LIMITS_H +#define HAVE_STDDEF_H +#define HAVE_RINT /* defined in this file */ +#define NO_FCNTL_NONBLOCK /* No FCNTL */ +#define HAVE_ALLOCA +#define HAVE_STRPBRK +#define HAVE_STRSTR +#define HAVE_COMPRESS +#define HAVE_CREATESEMAPHORE +#define HAVE_ISNAN +#define HAVE_FINITE +#define HAVE_ISAM /* We want to have support for ISAM in 4.0 */ +#define HAVE_QUERY_CACHE +#define SPRINTF_RETURNS_INT +#define HAVE_SETFILEPOINTER + +#ifdef NOT_USED +#define HAVE_SNPRINTF /* Gave link error */ +#define _snprintf snprintf +#endif + +#ifdef _MSC_VER +#define HAVE_LDIV /* The optimizer breaks in zortech for ldiv */ +#define HAVE_ANSI_INCLUDE +#define HAVE_SYS_UTIME_H +#define HAVE_STRTOUL +#endif +#define my_reinterpret_cast(A) reinterpret_cast +#define my_const_cast(A) const_cast + + +/* MYSQL OPTIONS */ + +#ifdef _CUSTOMCONFIG_ +#include +#else +#define DEFAULT_MYSQL_HOME "c:\\mysql" +#define PACKAGE "mysql" +#define DEFAULT_BASEDIR "C:\\" +#define SHAREDIR "share" +#define DEFAULT_CHARSET_HOME "C:/mysql/" +#endif + +/* File name handling */ + +#define FN_LIBCHAR '\\' +#define FN_ROOTDIR "\\" +#define FN_NETWORK_DRIVES /* Uses \\ to indicate network drives */ +#define FN_NO_CASE_SENCE /* Files are not case-sensitive */ +#define MY_NFILE 1024 + +#define DO_NOT_REMOVE_THREAD_WRAPPERS +#define thread_safe_increment(V,L) InterlockedIncrement((long*) &(V)) +/* The following is only used for statistics, so it should be good enough */ +#ifdef __NT__ /* This should also work on Win98 but .. */ +#define thread_safe_add(V,C,L) InterlockedExchangeAdd((long*) &(V),(C)) +#define thread_safe_sub(V,C,L) InterlockedExchangeAdd((long*) &(V),-(long) (C)) +#define statistic_add(V,C,L) thread_safe_add((V),(C),(L)) +#else +#define thread_safe_add(V,C,L) \ + pthread_mutex_lock((L)); (V)+=(C); pthread_mutex_unlock((L)); +#define thread_safe_sub(V,C,L) \ + pthread_mutex_lock((L)); (V)-=(C); pthread_mutex_unlock((L)); +#define statistic_add(V,C,L) (V)+=(C) +#endif +#define statistic_increment(V,L) thread_safe_increment((V),(L)) diff --git a/dlls/csx_sql/extra/include/mysql/dbug.h b/dlls/csx_sql/extra/include/mysql/dbug.h new file mode 100755 index 00000000..5c88e2e4 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/dbug.h @@ -0,0 +1,93 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef _dbug_h +#define _dbug_h +#ifdef __cplusplus +extern "C" { +#endif +#if !defined(DBUG_OFF) && !defined(_lint) +extern int _db_on_,_no_db_; +extern FILE *_db_fp_; +extern char *_db_process_; +extern int _db_keyword_(const char *keyword); +extern void _db_setjmp_(void); +extern void _db_longjmp_(void); +extern void _db_push_(const char *control); +extern void _db_pop_(void); +extern void _db_enter_(const char *_func_,const char *_file_,uint _line_, + const char **_sfunc_,const char **_sfile_, + uint *_slevel_, char ***); +extern void _db_return_(uint _line_,const char **_sfunc_,const char **_sfile_, + uint *_slevel_); +extern void _db_pargs_(uint _line_,const char *keyword); +extern void _db_doprnt_ _VARARGS((const char *format,...)); +extern void _db_dump_(uint _line_,const char *keyword,const char *memory, + uint length); +extern void _db_lock_file(); +extern void _db_unlock_file(); + +#define DBUG_ENTER(a) const char *_db_func_, *_db_file_; uint _db_level_; \ + char **_db_framep_; \ + _db_enter_ (a,__FILE__,__LINE__,&_db_func_,&_db_file_,&_db_level_, \ + &_db_framep_) +#define DBUG_LEAVE \ + (_db_return_ (__LINE__, &_db_func_, &_db_file_, &_db_level_)) +#define DBUG_RETURN(a1) {DBUG_LEAVE; return(a1);} +#define DBUG_VOID_RETURN {DBUG_LEAVE; return;} +#define DBUG_EXECUTE(keyword,a1) \ + {if (_db_on_) {if (_db_keyword_ (keyword)) { a1 }}} +#define DBUG_PRINT(keyword,arglist) \ + {if (_db_on_) {_db_pargs_(__LINE__,keyword); _db_doprnt_ arglist;}} +#define DBUG_PUSH(a1) _db_push_ (a1) +#define DBUG_POP() _db_pop_ () +#define DBUG_PROCESS(a1) (_db_process_ = a1) +#define DBUG_FILE (_db_fp_) +#define DBUG_SETJMP(a1) (_db_setjmp_ (), setjmp (a1)) +#define DBUG_LONGJMP(a1,a2) (_db_longjmp_ (), longjmp (a1, a2)) +#define DBUG_DUMP(keyword,a1,a2)\ + {if (_db_on_) {_db_dump_(__LINE__,keyword,a1,a2);}} +#define DBUG_IN_USE (_db_fp_ && _db_fp_ != stderr) +#define DEBUGGER_OFF _no_db_=1;_db_on_=0; +#define DEBUGGER_ON _no_db_=0 +#define DBUG_LOCK_FILE { _db_lock_file(); } +#define DBUG_UNLOCK_FILE { _db_unlock_file(); } +#define DBUG_ASSERT(A) assert(A) +#else /* No debugger */ + +#define DBUG_ENTER(a1) +#define DBUG_RETURN(a1) return(a1) +#define DBUG_VOID_RETURN return +#define DBUG_EXECUTE(keyword,a1) {} +#define DBUG_PRINT(keyword,arglist) {} +#define DBUG_PUSH(a1) {} +#define DBUG_POP() {} +#define DBUG_PROCESS(a1) {} +#define DBUG_FILE (stderr) +#define DBUG_SETJMP setjmp +#define DBUG_LONGJMP longjmp +#define DBUG_DUMP(keyword,a1,a2) {} +#define DBUG_IN_USE 0 +#define DEBUGGER_OFF +#define DEBUGGER_ON +#define DBUG_LOCK_FILE +#define DBUG_UNLOCK_FILE +#define DBUG_ASSERT(A) {} +#endif +#ifdef __cplusplus +} +#endif +#endif diff --git a/dlls/csx_sql/extra/include/mysql/errmsg.h b/dlls/csx_sql/extra/include/mysql/errmsg.h new file mode 100755 index 00000000..5136af5b --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/errmsg.h @@ -0,0 +1,66 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* Error messages for mysql clients */ +/* error messages for the demon is in share/language/errmsg.sys */ + +#ifdef __cplusplus +extern "C" { +#endif +void init_client_errs(void); +extern const char *client_errors[]; /* Error messages */ +#ifdef __cplusplus +} +#endif + +#define CR_MIN_ERROR 2000 /* For easier client code */ +#define CR_MAX_ERROR 2999 +#if defined(OS2) && defined(MYSQL_SERVER) +#define CER(X) client_errors[(X)-CR_MIN_ERROR] +#else +#define ER(X) client_errors[(X)-CR_MIN_ERROR] +#endif +#define CLIENT_ERRMAP 2 /* Errormap used by my_error() */ + +#define CR_UNKNOWN_ERROR 2000 +#define CR_SOCKET_CREATE_ERROR 2001 +#define CR_CONNECTION_ERROR 2002 +#define CR_CONN_HOST_ERROR 2003 +#define CR_IPSOCK_ERROR 2004 +#define CR_UNKNOWN_HOST 2005 +#define CR_SERVER_GONE_ERROR 2006 +#define CR_VERSION_ERROR 2007 +#define CR_OUT_OF_MEMORY 2008 +#define CR_WRONG_HOST_INFO 2009 +#define CR_LOCALHOST_CONNECTION 2010 +#define CR_TCP_CONNECTION 2011 +#define CR_SERVER_HANDSHAKE_ERR 2012 +#define CR_SERVER_LOST 2013 +#define CR_COMMANDS_OUT_OF_SYNC 2014 +#define CR_NAMEDPIPE_CONNECTION 2015 +#define CR_NAMEDPIPEWAIT_ERROR 2016 +#define CR_NAMEDPIPEOPEN_ERROR 2017 +#define CR_NAMEDPIPESETSTATE_ERROR 2018 +#define CR_CANT_READ_CHARSET 2019 +#define CR_NET_PACKET_TOO_LARGE 2020 +#define CR_EMBEDDED_CONNECTION 2021 +#define CR_PROBE_SLAVE_STATUS 2022 +#define CR_PROBE_SLAVE_HOSTS 2023 +#define CR_PROBE_SLAVE_CONNECT 2024 +#define CR_PROBE_MASTER_CONNECT 2025 +#define CR_SSL_CONNECTION_ERROR 2026 +#define CR_MALFORMED_PACKET 2027 + diff --git a/dlls/csx_sql/extra/include/mysql/ft_global.h b/dlls/csx_sql/extra/include/mysql/ft_global.h new file mode 100755 index 00000000..9acdf6aa --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/ft_global.h @@ -0,0 +1,67 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* Written by Sergei A. Golubchik, who has a shared copyright to this code */ + +/* some definitions for full-text indices */ + +/* #include "myisam.h" */ + +#ifndef _ft_global_h +#define _ft_global_h +#ifdef __cplusplus +extern "C" { +#endif + +#define FT_QUERY_MAXLEN 1024 +#define HA_FT_MAXLEN 254 + +typedef struct st_ft_info FT_INFO; +struct _ft_vft +{ + int (*read_next)(FT_INFO *, char *); + float (*find_relevance)(FT_INFO *, byte *, uint); + void (*close_search)(FT_INFO *); + float (*get_relevance)(FT_INFO *); + void (*reinit_search)(FT_INFO *); +}; + +#ifndef FT_CORE +struct st_ft_info +{ + struct _ft_vft *please; /* INTERCAL style :-) */ +}; +#endif + +extern const char *ft_stopword_file; +extern const char *ft_precompiled_stopwords[]; + +extern ulong ft_min_word_len; +extern ulong ft_max_word_len; +extern ulong ft_max_word_len_for_sort; +extern const char *ft_boolean_syntax; + +int ft_init_stopwords(void); +void ft_free_stopwords(void); + +#define FT_NL 0 +#define FT_BOOL 1 +FT_INFO *ft_init_search(uint,void *, uint, byte *, uint, my_bool); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/dlls/csx_sql/extra/include/mysql/hash.h b/dlls/csx_sql/extra/include/mysql/hash.h new file mode 100755 index 00000000..e9c8c73c --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/hash.h @@ -0,0 +1,66 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* Dynamic hashing of record with different key-length */ + +#ifndef _hash_h +#define _hash_h +#ifdef __cplusplus +extern "C" { +#endif + +typedef byte *(*hash_get_key)(const byte *,uint*,my_bool); +typedef void (*hash_free_key)(void *); + + /* flags for hash_init */ +#define HASH_CASE_INSENSITIVE 1 + +typedef struct st_hash_info { + uint next; /* index to next key */ + byte *data; /* data for current entry */ +} HASH_LINK; + +typedef struct st_hash { + uint key_offset,key_length; /* Length of key if const length */ + uint records,blength,current_record; + uint flags; + DYNAMIC_ARRAY array; /* Place for hash_keys */ + hash_get_key get_key; + void (*free)(void *); + uint (*calc_hashnr)(const byte *key,uint length); +} HASH; + +#define hash_init(A,B,C,D,E,F,G) _hash_init(A,B,C,D,E,F,G CALLER_INFO) +my_bool _hash_init(HASH *hash,uint default_array_elements, uint key_offset, + uint key_length, hash_get_key get_key, + void (*free_element)(void*), uint flags CALLER_INFO_PROTO); +void hash_free(HASH *tree); +byte *hash_element(HASH *hash,uint idx); +gptr hash_search(HASH *info,const byte *key,uint length); +gptr hash_next(HASH *info,const byte *key,uint length); +my_bool hash_insert(HASH *info,const byte *data); +my_bool hash_delete(HASH *hash,byte *record); +my_bool hash_update(HASH *hash,byte *record,byte *old_key,uint old_key_length); +void hash_replace(HASH *hash, uint idx, byte *new_row); +my_bool hash_check(HASH *hash); /* Only in debug library */ + +#define hash_clear(H) bzero((char*) (H),sizeof(*(H))) +#define hash_inited(H) ((H)->array.buffer != 0) + +#ifdef __cplusplus +} +#endif +#endif diff --git a/dlls/csx_sql/extra/include/mysql/heap.h b/dlls/csx_sql/extra/include/mysql/heap.h new file mode 100755 index 00000000..ed023133 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/heap.h @@ -0,0 +1,185 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* This file should be included when using heap_database_funktions */ +/* Author: Michael Widenius */ + +#ifndef _heap_h +#define _heap_h +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef _my_base_h +#include +#endif +#ifdef THREAD +#include +#include +#endif + + /* defines used by heap-funktions */ + +#define HP_MAX_LEVELS 4 /* 128^5 records is enough */ +#define HP_PTRS_IN_NOD 128 + + /* struct used with heap_funktions */ + +typedef struct st_heapinfo /* Struct from heap_info */ +{ + ulong records; /* Records in database */ + ulong deleted; /* Deleted records in database */ + ulong max_records; + ulong data_length; + ulong index_length; + uint reclength; /* Length of one record */ + int errkey; + my_bool implicit_emptied; +} HEAPINFO; + + + /* Structs used by heap-database-handler */ + +typedef struct st_heap_ptrs +{ + byte *blocks[HP_PTRS_IN_NOD]; /* pointers to HP_PTRS or records */ +} HP_PTRS; + +struct st_level_info +{ + uint free_ptrs_in_block,records_under_level; + HP_PTRS *last_blocks; /* pointers to HP_PTRS or records */ +}; + +typedef struct st_heap_block /* The data is saved in blocks */ +{ + HP_PTRS *root; + struct st_level_info level_info[HP_MAX_LEVELS+1]; + uint levels; + uint records_in_block; /* Records in a heap-block */ + uint recbuffer; /* Length of one saved record */ + ulong last_allocated; /* Blocks allocated, used by keys */ +} HP_BLOCK; + +typedef struct st_hp_keyseg /* Key-portion */ +{ + uint start; /* Start of key in record (from 0) */ + uint length; /* Keylength */ + uint type; + uint null_bit; /* bit set in row+null_pos */ + uint null_pos; +} HP_KEYSEG; + +typedef struct st_hp_keydef /* Key definition with open */ +{ + uint flag; /* HA_NOSAME | HA_NULL_PART_KEY */ + uint keysegs; /* Number of key-segment */ + uint length; /* Length of key (automatic) */ + HP_KEYSEG *seg; + HP_BLOCK block; /* Where keys are saved */ +} HP_KEYDEF; + +typedef struct st_heap_share +{ + HP_BLOCK block; + HP_KEYDEF *keydef; + ulong min_records,max_records; /* Params to open */ + ulong data_length,index_length; + uint records; /* records */ + uint blength; + uint deleted; /* Deleted records in database */ + uint reclength; /* Length of one record */ + uint changed; + uint keys,max_key_length; + uint open_count; + byte *del_link; /* Link to next block with del. rec */ + my_string name; /* Name of "memory-file" */ +#ifdef THREAD + THR_LOCK lock; + pthread_mutex_t intern_lock; /* Locking for use with _locking */ +#endif + my_bool delete_on_close; + LIST open_list; +} HP_SHARE; + +struct st_hp_hash_info; + +typedef struct st_heap_info +{ + HP_SHARE *s; + byte *current_ptr; + struct st_hp_hash_info *current_hash_ptr; + ulong current_record,next_block; + int lastinx,errkey; + int mode; /* Mode of file (READONLY..) */ + uint opt_flag,update; + byte *lastkey; /* Last used key with rkey */ + my_bool implicit_emptied; +#ifdef THREAD + THR_LOCK_DATA lock; +#endif + LIST open_list; +} HP_INFO; + + /* Prototypes for heap-functions */ + +extern HP_INFO* heap_open(const char *name,int mode,uint keys, + HP_KEYDEF *keydef,uint reclength, + ulong max_records,ulong min_reloc); +extern int heap_close(HP_INFO *info); +extern int heap_write(HP_INFO *info,const byte *buff); +extern int heap_update(HP_INFO *info,const byte *old,const byte *newdata); +extern int heap_rrnd(HP_INFO *info,byte *buf,byte *pos); +extern int heap_scan_init(HP_INFO *info); +extern int heap_scan(register HP_INFO *info, byte *record); +extern int heap_delete(HP_INFO *info,const byte *buff); +extern int heap_info(HP_INFO *info,HEAPINFO *x,int flag); +extern int heap_create(const char *name); +extern int heap_delete_table(const char *name); +extern int heap_extra(HP_INFO *info,enum ha_extra_function function); +extern int heap_rename(const char *old_name,const char *new_name); +extern int heap_panic(enum ha_panic_function flag); +extern int heap_rsame(HP_INFO *info,byte *record,int inx); +extern int heap_rnext(HP_INFO *info,byte *record); +extern int heap_rprev(HP_INFO *info,byte *record); +extern int heap_rfirst(HP_INFO *info,byte *record); +extern int heap_rlast(HP_INFO *info,byte *record); +extern void heap_clear(HP_INFO *info); +extern int heap_rkey(HP_INFO *info,byte *record,int inx,const byte *key); +extern gptr heap_find(HP_INFO *info,int inx,const byte *key); +extern int heap_check_heap(HP_INFO *info, my_bool print_status); +extern byte *heap_position(HP_INFO *info); + +/* The following is for programs that uses the old HEAP interface where + pointer to rows where a long instead of a (byte*). +*/ + +#if defined(WANT_OLD_HEAP_VERSION) || defined(OLD_HEAP_VERSION) +extern int heap_rrnd_old(HP_INFO *info,byte *buf,ulong pos); +extern ulong heap_position_old(HP_INFO *info); +#endif +#ifdef OLD_HEAP_VERSION +typedef ulong HEAP_PTR; +#define heap_position(A) heap_position_old(A) +#define heap_rrnd(A,B,C) heap_rrnd_old(A,B,C) +#else +typedef byte *HEAP_PTR; +#endif + +#ifdef __cplusplus +} +#endif +#endif diff --git a/dlls/csx_sql/extra/include/mysql/m_ctype.h b/dlls/csx_sql/extra/include/mysql/m_ctype.h new file mode 100755 index 00000000..b3e50cec --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/m_ctype.h @@ -0,0 +1,172 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* + A better inplementation of the UNIX ctype(3) library. + Notes: my_global.h should be included before ctype.h +*/ + +#ifndef _m_ctype_h +#define _m_ctype_h + +#ifdef __cplusplus +extern "C" { +#endif + +#define CHARSET_DIR "charsets/" + +typedef struct charset_info_st +{ + uint number; + const char *name; + uchar *ctype; + uchar *to_lower; + uchar *to_upper; + uchar *sort_order; + + uint strxfrm_multiply; + int (*strcoll)(const uchar *, const uchar *); + int (*strxfrm)(uchar *, const uchar *, int); + int (*strnncoll)(const uchar *, int, const uchar *, int); + int (*strnxfrm)(uchar *, const uchar *, int, int); + my_bool (*like_range)(const char *, uint, pchar, uint, + char *, char *, uint *, uint *); + + uint mbmaxlen; + int (*ismbchar)(const char *, const char *); + my_bool (*ismbhead)(uint); + int (*mbcharlen)(uint); +} CHARSET_INFO; + +/* strings/ctype.c */ +extern CHARSET_INFO *default_charset_info; +extern CHARSET_INFO *find_compiled_charset(uint cs_number); +extern CHARSET_INFO *find_compiled_charset_by_name(const char *name); +extern CHARSET_INFO compiled_charsets[]; +extern uint compiled_charset_number(const char *name); +extern const char *compiled_charset_name(uint charset_number); + +#define MY_CHARSET_UNDEFINED 0 +#define MY_CHARSET_CURRENT (default_charset_info->number) + +/* Don't include std ctype.h when this is included */ +#define _CTYPE_H +#define _CTYPE_H_ +#define _CTYPE_INCLUDED +#define __CTYPE_INCLUDED +#define _CTYPE_USING /* Don't put names in global namespace. */ + +/* Fix things, if ctype.h would have been included before */ +#undef toupper +#undef _toupper +#undef _tolower +#undef toupper +#undef tolower +#undef isalpha +#undef isupper +#undef islower +#undef isdigit +#undef isxdigit +#undef isalnum +#undef isspace +#undef ispunct +#undef isprint +#undef isgraph +#undef iscntrl +#undef isascii +#undef toascii + +#define _U 01 /* Upper case */ +#define _L 02 /* Lower case */ +#define _NMR 04 /* Numeral (digit) */ +#define _SPC 010 /* Spacing character */ +#define _PNT 020 /* Punctuation */ +#define _CTR 040 /* Control character */ +#define _B 0100 /* Blank */ +#define _X 0200 /* heXadecimal digit */ + +#define my_ctype (default_charset_info->ctype) +#define my_to_upper (default_charset_info->to_upper) +#define my_to_lower (default_charset_info->to_lower) +#define my_sort_order (default_charset_info->sort_order) + +#define _toupper(c) (char) my_to_upper[(uchar) (c)] +#define _tolower(c) (char) my_to_lower[(uchar) (c)] +#define toupper(c) (char) my_to_upper[(uchar) (c)] +#define tolower(c) (char) my_to_lower[(uchar) (c)] + +#define isalpha(c) ((my_ctype+1)[(uchar) (c)] & (_U | _L)) +#define isupper(c) ((my_ctype+1)[(uchar) (c)] & _U) +#define islower(c) ((my_ctype+1)[(uchar) (c)] & _L) +#define isdigit(c) ((my_ctype+1)[(uchar) (c)] & _NMR) +#define isxdigit(c) ((my_ctype+1)[(uchar) (c)] & _X) +#define isalnum(c) ((my_ctype+1)[(uchar) (c)] & (_U | _L | _NMR)) +#define isspace(c) ((my_ctype+1)[(uchar) (c)] & _SPC) +#define ispunct(c) ((my_ctype+1)[(uchar) (c)] & _PNT) +#define isprint(c) ((my_ctype+1)[(uchar) (c)] & (_PNT | _U | _L | _NMR | _B)) +#define isgraph(c) ((my_ctype+1)[(uchar) (c)] & (_PNT | _U | _L | _NMR)) +#define iscntrl(c) ((my_ctype+1)[(uchar) (c)] & _CTR) +#define isascii(c) (!((c) & ~0177)) +#define toascii(c) ((c) & 0177) + +#ifdef ctype +#undef ctype +#endif /* ctype */ + +#define my_isalpha(s, c) (((s)->ctype+1)[(uchar) (c)] & (_U | _L)) +#define my_isupper(s, c) (((s)->ctype+1)[(uchar) (c)] & _U) +#define my_islower(s, c) (((s)->ctype+1)[(uchar) (c)] & _L) +#define my_isdigit(s, c) (((s)->ctype+1)[(uchar) (c)] & _NMR) +#define my_isxdigit(s, c) (((s)->ctype+1)[(uchar) (c)] & _X) +#define my_isalnum(s, c) (((s)->ctype+1)[(uchar) (c)] & (_U | _L | _NMR)) +#define my_isspace(s, c) (((s)->ctype+1)[(uchar) (c)] & _SPC) +#define my_ispunct(s, c) (((s)->ctype+1)[(uchar) (c)] & _PNT) +#define my_isprint(s, c) (((s)->ctype+1)[(uchar) (c)] & (_PNT | _U | _L | _NMR | _B)) +#define my_isgraph(s, c) (((s)->ctype+1)[(uchar) (c)] & (_PNT | _U | _L | _NMR)) +#define my_iscntrl(s, c) (((s)->ctype+1)[(uchar) (c)] & _CTR) + +#define use_strcoll(s) ((s)->strcoll != NULL) +#define MY_STRXFRM_MULTIPLY (default_charset_info->strxfrm_multiply) +#define my_strnxfrm(s, a, b, c, d) ((s)->strnxfrm((a), (b), (c), (d))) +#define my_strnncoll(s, a, b, c, d) ((s)->strnncoll((a), (b), (c), (d))) +#define my_strcoll(s, a, b) ((s)->strcoll((a), (b))) +#define my_like_range(s, a, b, c, d, e, f, g, h) \ + ((s)->like_range((a), (b), (c), (d), (e), (f), (g), (h))) + +#define use_mb(s) ((s)->ismbchar != NULL) +#define MBMAXLEN (default_charset_info->mbmaxlen) +#define my_ismbchar(s, a, b) ((s)->ismbchar((a), (b))) +#define my_ismbhead(s, a) ((s)->ismbhead((a))) +#define my_mbcharlen(s, a) ((s)->mbcharlen((a))) + +/* Some macros that should be cleaned up a little */ +#define isvar(c) (isalnum(c) || (c) == '_') +#define isvar_start(c) (isalpha(c) || (c) == '_') +#define tocntrl(c) ((c) & 31) +#define toprint(c) ((c) | 64) + +/* XXX: still need to take care of this one */ +#ifdef MY_CHARSET_TIS620 +#error The TIS620 charset is broken at the moment. Tell tim to fix it. +#define USE_TIS620 +#include "t_ctype.h" +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* _m_ctype_h */ diff --git a/dlls/csx_sql/extra/include/mysql/m_string.h b/dlls/csx_sql/extra/include/mysql/m_string.h new file mode 100755 index 00000000..eac1552f --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/m_string.h @@ -0,0 +1,254 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* There may be prolems include all of theese. Try to test in + configure with ones are needed? */ + +/* This is needed for the definitions of strchr... on solaris */ + +#ifndef _m_string_h +#define _m_string_h +#ifndef __USE_GNU +#define __USE_GNU /* We want to use stpcpy */ +#endif +#if defined(HAVE_STRINGS_H) +#include +#endif +#if defined(HAVE_STRING_H) +#include +#endif + +/* Correct some things for UNIXWARE7 */ +#ifdef HAVE_UNIXWARE7_THREADS +#undef HAVE_STRINGS_H +#undef HAVE_MEMORY_H +#define HAVE_MEMCPY +#ifndef HAVE_MEMMOVE +#define HAVE_MEMMOVE +#endif +#undef HAVE_BCMP +#undef bcopy +#undef bcmp +#undef bzero +#endif /* HAVE_UNIXWARE7_THREADS */ +#ifdef _AIX +#undef HAVE_BCMP +#endif + +/* This is needed for the definitions of bzero... on solaris */ +#if defined(HAVE_STRINGS_H) && !defined(HAVE_mit_thread) +#include +#endif + +/* This is needed for the definitions of memcpy... on solaris */ +#if defined(HAVE_MEMORY_H) && !defined(__cplusplus) +#include +#endif + +#if !defined(HAVE_MEMCPY) && !defined(HAVE_MEMMOVE) +# define memcpy(d, s, n) bcopy ((s), (d), (n)) +# define memset(A,C,B) bfill((A),(B),(C)) +# define memmove(d, s, n) bmove ((d), (s), (n)) +#elif defined(HAVE_MEMMOVE) +# define bmove(d, s, n) memmove((d), (s), (n)) +#else +# define memmove(d, s, n) bmove((d), (s), (n)) /* our bmove */ +#endif + +/* Unixware 7 */ +#if !defined(HAVE_BFILL) +# define bfill(A,B,C) memset((A),(C),(B)) +# define bmove_allign(A,B,C) memcpy((A),(B),(C)) +#endif + +#if !defined(HAVE_BCMP) +# define bcopy(s, d, n) memcpy((d), (s), (n)) +# define bcmp(A,B,C) memcmp((A),(B),(C)) +# define bzero(A,B) memset((A),0,(B)) +# define bmove_allign(A,B,C) memcpy((A),(B),(C)) +#endif + +#if defined(__cplusplus) && !defined(OS2) +extern "C" { +#endif + +#if defined(HAVE_STPCPY) && !defined(HAVE_mit_thread) +#define strmov(A,B) stpcpy((A),(B)) +#ifndef stpcpy +extern char *stpcpy(char *, const char *); /* For AIX with gcc 2.95.3 */ +#endif +#endif + +extern char NEAR _dig_vec[]; /* Declared in int2str() */ + +#ifdef BAD_STRING_COMPILER +#define strmov(A,B) (memccpy(A,B,0,INT_MAX)-1) +#else +#define strmov_overlapp(A,B) strmov(A,B) +#define strmake_overlapp(A,B,C) strmake(A,B,C) +#endif + +#ifdef BAD_MEMCPY /* Problem with gcc on Alpha */ +#define memcpy_fixed(A,B,C) bmove((A),(B),(C)) +#else +#define memcpy_fixed(A,B,C) memcpy((A),(B),(C)) +#endif + +#ifdef MSDOS +#undef bmove_allign +#define bmove512(A,B,C) bmove_allign(A,B,C) +#define my_itoa(A,B,C) itoa(A,B,C) +#define my_ltoa(A,B,C) ltoa(A,B,C) +extern void bmove_allign(gptr dst,const gptr src,uint len); +#endif + +#if (!defined(USE_BMOVE512) || defined(HAVE_purify)) && !defined(bmove512) +#define bmove512(A,B,C) memcpy(A,B,C) +#endif + +#ifdef HAVE_purify +#include +#define memcpy_overlap(A,B,C) \ +DBUG_ASSERT((A) == (B) || ((A)+(C)) <= (B) || ((B)+(C)) <= (A)); \ +bmove((byte*) key,(byte*) from,(size_t) length); +#else +#define memcpy_overlap(A,B,C) memcpy((A), (B), (C)) +#endif /* HAVE_purify */ + + + /* Prototypes for string functions */ + +#if !defined(bfill) && !defined(HAVE_BFILL) +extern void bfill(gptr dst,uint len,pchar fill); +#endif + +#if !defined(bzero) && !defined(HAVE_BZERO) +extern void bzero(gptr dst,uint len); +#endif + +#if !defined(bcmp) && !defined(HAVE_BCMP) +extern int bcmp(const char *s1,const char *s2,uint len); +#endif +#ifdef HAVE_purify +extern int my_bcmp(const char *s1,const char *s2,uint len); +#undef bcmp +#define bcmp(A,B,C) my_bcmp((A),(B),(C)) +#endif + +#ifndef bmove512 +extern void bmove512(gptr dst,const gptr src,uint len); +#endif + +#if !defined(HAVE_BMOVE) && !defined(bmove) +extern void bmove(char *dst, const char *src,uint len); +#endif + +extern void bmove_upp(char *dst,const char *src,uint len); +extern void bchange(char *dst,uint old_len,const char *src, + uint new_len,uint tot_len); +extern void strappend(char *s,uint len,pchar fill); +extern char *strend(const char *s); +extern char *strcend(const char *, pchar); +extern char *strfield(char *src,int fields,int chars,int blanks, + int tabch); +extern char *strfill(my_string s,uint len,pchar fill); +extern uint strinstr(const char *str,const char *search); +extern uint r_strinstr(reg1 my_string str,int from, reg4 my_string search); +extern char *strkey(char *dst,char *head,char *tail,char *flags); +extern char *strmake(char *dst,const char *src,uint length); +#ifndef strmake_overlapp +extern char *strmake_overlapp(char *dst,const char *src, uint length); +#endif + +#ifndef strmov +extern char *strmov(char *dst,const char *src); +#endif +extern char *strnmov(char *dst,const char *src,uint n); +extern char *strsuff(const char *src,const char *suffix); +extern char *strcont(const char *src,const char *set); +extern char *strxcat _VARARGS((char *dst,const char *src, ...)); +extern char *strxmov _VARARGS((char *dst,const char *src, ...)); +extern char *strxcpy _VARARGS((char *dst,const char *src, ...)); +extern char *strxncat _VARARGS((char *dst,uint len, const char *src, ...)); +extern char *strxnmov _VARARGS((char *dst,uint len, const char *src, ...)); +extern char *strxncpy _VARARGS((char *dst,uint len, const char *src, ...)); + +/* Prototypes of normal stringfunctions (with may ours) */ + +#ifdef WANT_STRING_PROTOTYPES +extern char *strcat(char *, const char *); +extern char *strchr(const char *, pchar); +extern char *strrchr(const char *, pchar); +extern char *strcpy(char *, const char *); +extern int strcmp(const char *, const char *); +#ifndef __GNUC__ +extern size_t strlen(const char *); +#endif +#endif +#ifndef HAVE_STRNLEN +extern uint strnlen(const char *s, uint n); +#endif + +#if !defined(__cplusplus) +#ifndef HAVE_STRPBRK +extern char *strpbrk(const char *, const char *); +#endif +#ifndef HAVE_STRSTR +extern char *strstr(const char *, const char *); +#endif +#endif +extern int is_prefix(const char *, const char *); + +/* Conversion rutins */ + +#ifdef USE_MY_ITOA +extern char *my_itoa(int val,char *dst,int radix); +extern char *my_ltoa(long val,char *dst,int radix); +#endif + +extern char *llstr(longlong value,char *buff); +#ifndef HAVE_STRTOUL +extern long strtol(const char *str, char **ptr, int base); +extern ulong strtoul(const char *str, char **ptr, int base); +#endif + +extern char *int2str(long val,char *dst,int radix); +extern char *int10_to_str(long val,char *dst,int radix); +extern char *str2int(const char *src,int radix,long lower,long upper, + long *val); +#if SIZEOF_LONG == SIZEOF_LONG_LONG +#define longlong2str(A,B,C) int2str((A),(B),(C)) +#define longlong10_to_str(A,B,C) int10_to_str((A),(B),(C)) +#define strtoll(A,B,C) strtol((A),(B),(C)) +#define strtoull(A,B,C) strtoul((A),(B),(C)) +#ifndef HAVE_STRTOULL +#define HAVE_STRTOULL +#endif +#else +#ifdef HAVE_LONG_LONG +extern char *longlong2str(longlong val,char *dst,int radix); +extern char *longlong10_to_str(longlong val,char *dst,int radix); +#if (!defined(HAVE_STRTOULL) || defined(HAVE_mit_thread)) || defined(NO_STRTOLL_PROTO) +extern longlong strtoll(const char *str, char **ptr, int base); +extern ulonglong strtoull(const char *str, char **ptr, int base); +#endif +#endif +#endif + +#if defined(__cplusplus) && !defined(OS2) +} +#endif +#endif diff --git a/dlls/csx_sql/extra/include/mysql/md5.h b/dlls/csx_sql/extra/include/mysql/md5.h new file mode 100755 index 00000000..aa4116ff --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/md5.h @@ -0,0 +1,93 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +/* MD5.H - header file for MD5C.C + */ + +/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All +rights reserved. + +License to copy and use this software is granted provided that it +is identified as the "RSA Data Security, Inc. MD5 Message-Digest +Algorithm" in all material mentioning or referencing this software +or this function. + +License is also granted to make and use derivative works provided +that such works are identified as "derived from the RSA Data +Security, Inc. MD5 Message-Digest Algorithm" in all material +mentioning or referencing the derived work. + +RSA Data Security, Inc. makes no representations concerning either +the merchantability of this software or the suitability of this +software for any particular purpose. It is provided "as is" +without express or implied warranty of any kind. + +These notices must be retained in any copies of any part of this +documentation and/or software. + */ + +/* GLOBAL.H - RSAREF types and constants + */ + +/* PROTOTYPES should be set to one if and only if the compiler supports + function argument prototyping. +The following makes PROTOTYPES default to 0 if it has not already + been defined with C compiler flags. + */ + +/* egcs 1.1.2 under linux didn't defined it.... :( */ + +#ifndef PROTOTYPES +#define PROTOTYPES 1 /* Assume prototypes */ +#endif + +/* POINTER defines a generic pointer type */ +typedef unsigned char *POINTER; + +/* UINT2 defines a two byte word */ +typedef uint16 UINT2; /* Fix for MySQL / Alpha */ + +/* UINT4 defines a four byte word */ +typedef uint32 UINT4; /* Fix for MySQL / Alpha */ + +/* PROTO_LIST is defined depending on how PROTOTYPES is defined above. +If using PROTOTYPES, then PROTO_LIST returns the list, otherwise it + returns an empty list. + */ +#if PROTOTYPES +#define PROTO_LIST(list) list +#else +#define PROTO_LIST(list) () +#endif +/* MD5 context. */ +typedef struct { + UINT4 state[4]; /* state (ABCD) */ + UINT4 count[2]; /* number of bits, modulo 2^64 (lsb first) */ + unsigned char buffer[64]; /* input buffer */ +} my_MD5_CTX; + +#ifdef __cplusplus +extern "C" { +#endif + void my_MD5Init PROTO_LIST ((my_MD5_CTX *)); + void my_MD5Update PROTO_LIST + ((my_MD5_CTX *, unsigned char *, unsigned int)); + void my_MD5Final PROTO_LIST ((unsigned char [16], my_MD5_CTX *)); + +#ifdef __cplusplus +} +#endif diff --git a/dlls/csx_sql/extra/include/mysql/merge.h b/dlls/csx_sql/extra/include/mysql/merge.h new file mode 100755 index 00000000..97cea5fa --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/merge.h @@ -0,0 +1,93 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* This file should be included when using merge_isam_funktions */ +/* Author: Michael Widenius */ + +#ifndef _merge_h +#define _merge_h +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef _my_base_h +#include +#endif +#ifndef _nisam_h +#include +#endif + +#define MRG_NAME_EXT ".MRG" + + /* Param to/from mrg_info */ + +typedef struct st_mrg_info /* Struct from h_info */ +{ + ulonglong records; /* Records in database */ + ulonglong deleted; /* Deleted records in database */ + ulonglong recpos; /* Pos for last used record */ + ulonglong data_file_length; + uint reclength; /* Recordlength */ + int errkey; /* With key was dupplicated on err */ + uint options; /* HA_OPTION_... used */ +} MERGE_INFO; + +typedef struct st_mrg_table_info +{ + N_INFO *table; + ulonglong file_offset; +} MRG_TABLE; + +typedef struct st_merge +{ + MRG_TABLE *open_tables,*current_table,*end_table,*last_used_table; + ulonglong records; /* records in tables */ + ulonglong del; /* Removed records */ + ulonglong data_file_length; + uint tables,options,reclength; + my_bool cache_in_use; + LIST open_list; +} MRG_INFO; + +typedef ulong mrg_off_t; + + /* Prototypes for merge-functions */ + +extern int mrg_close(MRG_INFO *file); +extern int mrg_delete(MRG_INFO *file,const byte *buff); +extern MRG_INFO *mrg_open(const char *name,int mode,int wait_if_locked); +extern int mrg_panic(enum ha_panic_function function); +extern int mrg_rfirst(MRG_INFO *file,byte *buf,int inx); +extern int mrg_rkey(MRG_INFO *file,byte *buf,int inx,const byte *key, + uint key_len, enum ha_rkey_function search_flag); +extern int mrg_rrnd(MRG_INFO *file,byte *buf, mrg_off_t pos); +extern int mrg_rsame(MRG_INFO *file,byte *record,int inx); +extern int mrg_update(MRG_INFO *file,const byte *old,const byte *new_rec); +extern int mrg_info(MRG_INFO *file,MERGE_INFO *x,int flag); +extern int mrg_lock_database(MRG_INFO *file,int lock_type); +extern int mrg_create(const char *name,const char **table_names); +extern int mrg_extra(MRG_INFO *file,enum ha_extra_function function); +extern ha_rows mrg_records_in_range(MRG_INFO *info,int inx, + const byte *start_key,uint start_key_len, + enum ha_rkey_function start_search_flag, + const byte *end_key,uint end_key_len, + enum ha_rkey_function end_search_flag); + +extern mrg_off_t mrg_position(MRG_INFO *info); +#ifdef __cplusplus +} +#endif +#endif diff --git a/dlls/csx_sql/extra/include/mysql/my_aes.h b/dlls/csx_sql/extra/include/mysql/my_aes.h new file mode 100755 index 00000000..5852baa5 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/my_aes.h @@ -0,0 +1,66 @@ +/* Copyright (C) 2002 MySQL AB & MySQL Finland AB & TCX DataKonsult AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +/* Header file for my_aes.c */ +/* Wrapper to give simple interface for MySQL to AES standard encryption */ + +#include "rijndael.h" + +C_MODE_START + +#define AES_KEY_LENGTH 128 /* Must be 128 192 or 256 */ + +/* + my_aes_encrypt - Crypt buffer with AES encryption algorithm. + source - Pointer to data for encryption + source_length - size of encryption data + dest - buffer to place encrypted data (must be large enough) + key - Key to be used for encryption + kel_length - Length of the key. Will handle keys of any length + + returns - size of encrypted data, or negative in case of error. +*/ + +int my_aes_encrypt(const char *source, int source_length, char *dest, + const char *key, int key_length); + +/* + my_aes_decrypt - DeCrypt buffer with AES encryption algorithm. + source - Pointer to data for decryption + source_length - size of encrypted data + dest - buffer to place decrypted data (must be large enough) + key - Key to be used for decryption + kel_length - Length of the key. Will handle keys of any length + + returns - size of original data, or negative in case of error. +*/ + + +int my_aes_decrypt(const char *source, int source_length, char *dest, + const char *key, int key_length); + +/* + my_aes_get_size - get size of buffer which will be large enough for encrypted + data + source_length - length of data to be encrypted + + returns - size of buffer required to store encrypted data +*/ + +int my_aes_get_size(int source_length); + +C_MODE_END diff --git a/dlls/csx_sql/extra/include/mysql/my_alarm.h b/dlls/csx_sql/extra/include/mysql/my_alarm.h new file mode 100755 index 00000000..fdfce9c6 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/my_alarm.h @@ -0,0 +1,59 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* + File to include when we want to use alarm or a loop_counter to display + some information when a program is running +*/ +#ifndef _my_alarm_h +#define _my_alarm_h +#ifdef __cplusplus +extern "C" { +#endif + +extern int volatile my_have_got_alarm; +extern ulong my_time_to_wait_for_lock; + +#if defined(HAVE_ALARM) && !defined(NO_ALARM_LOOP) +#include +#define ALARM_VARIABLES uint alarm_old=0; \ + sig_return alarm_signal=0 +#define ALARM_INIT my_have_got_alarm=0 ; \ + alarm_old=(uint) alarm(MY_HOW_OFTEN_TO_ALARM); \ + alarm_signal=signal(SIGALRM,my_set_alarm_variable); +#define ALARM_END VOID(signal(SIGALRM,alarm_signal)); \ + VOID(alarm(alarm_old)); +#define ALARM_TEST my_have_got_alarm +#ifdef DONT_REMEMBER_SIGNAL +#define ALARM_REINIT VOID(alarm(MY_HOW_OFTEN_TO_ALARM)); \ + VOID(signal(SIGALRM,my_set_alarm_variable));\ + my_have_got_alarm=0; +#else +#define ALARM_REINIT VOID(alarm((uint) MY_HOW_OFTEN_TO_ALARM)); \ + my_have_got_alarm=0; +#endif /* DONT_REMEMBER_SIGNAL */ +#else +#define ALARM_VARIABLES long alarm_pos=0,alarm_end_pos=MY_HOW_OFTEN_TO_WRITE-1 +#define ALARM_INIT +#define ALARM_END +#define ALARM_TEST (alarm_pos++ >= alarm_end_pos) +#define ALARM_REINIT alarm_end_pos+=MY_HOW_OFTEN_TO_WRITE +#endif /* HAVE_ALARM */ + +#ifdef __cplusplus +} +#endif +#endif diff --git a/dlls/csx_sql/extra/include/mysql/my_alloc.h b/dlls/csx_sql/extra/include/mysql/my_alloc.h new file mode 100755 index 00000000..a3dd35d7 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/my_alloc.h @@ -0,0 +1,52 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* + Data structures for mysys/my_alloc.c (root memory allocator) +*/ + +#ifndef _my_alloc_h +#define _my_alloc_h + +#define ALLOC_MAX_BLOCK_TO_DROP 4096 +#define ALLOC_MAX_BLOCK_USAGE_BEFORE_DROP 10 + +typedef struct st_used_mem +{ /* struct for once_alloc (block) */ + struct st_used_mem *next; /* Next block in use */ + unsigned int left; /* memory left in block */ + unsigned int size; /* size of block */ +} USED_MEM; + + +typedef struct st_mem_root +{ + USED_MEM *free; /* blocks with free memory in it */ + USED_MEM *used; /* blocks almost without free memory */ + USED_MEM *pre_alloc; /* preallocated block */ + /* if block have less memory it will be put in 'used' list */ + unsigned int min_malloc; + unsigned int block_size; /* initial block size */ + unsigned int block_num; /* allocated blocks counter */ + /* + first free block in queue test counter (if it exceed + MAX_BLOCK_USAGE_BEFORE_DROP block will be droped in 'used' list) + */ + unsigned int first_block_usage; + + void (*error_handler)(void); +} MEM_ROOT; +#endif diff --git a/dlls/csx_sql/extra/include/mysql/my_base.h b/dlls/csx_sql/extra/include/mysql/my_base.h new file mode 100755 index 00000000..5344d876 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/my_base.h @@ -0,0 +1,342 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* This file includes constants used with all databases */ +/* Author: Michael Widenius */ + +#ifndef _my_base_h +#define _my_base_h + +#ifndef stdin /* Included first in handler */ +#define USES_TYPES /* my_dir with sys/types is included */ +#define CHSIZE_USED +#include +#include /* This includes types */ +#include +#include +#include +#ifdef MSDOS +#include /* Neaded for sopen() */ +#endif +#if !defined(USE_MY_FUNC) && !defined(THREAD) +#include /* For faster code, after test */ +#endif /* USE_MY_FUNC */ +#endif /* stdin */ +#include + +/* The following is bits in the flag parameter to ha_open() */ + +#define HA_OPEN_ABORT_IF_LOCKED 0 /* default */ +#define HA_OPEN_WAIT_IF_LOCKED 1 +#define HA_OPEN_IGNORE_IF_LOCKED 2 +#define HA_OPEN_TMP_TABLE 4 /* Table is a temp table */ +#define HA_OPEN_DELAY_KEY_WRITE 8 /* Don't update index */ +#define HA_OPEN_ABORT_IF_CRASHED 16 +#define HA_OPEN_FOR_REPAIR 32 /* open even if crashed */ + + /* The following is parameter to ha_rkey() how to use key */ + +/* We define a complete-field prefix of a key value as a prefix where the +last included field in the prefix contains the full field, not just some bytes +from the start of the field. A partial-field prefix is allowed to +contain only a few first bytes from the last included field. + +Below HA_READ_KEY_EXACT, ..., HA_READ_BEFORE_KEY can take a +complete-field prefix of a key value as the search key. HA_READ_PREFIX +and HA_READ_PREFIX_LAST could also take a partial-field prefix, but +currently (4.0.10) they are only used with complete-field prefixes. MySQL uses +a padding trick to implement LIKE 'abc%' queries. + +NOTE that in InnoDB HA_READ_PREFIX_LAST will NOT work with a partial-field +prefix because InnoDB currently strips spaces from the end of varchar +fields! */ + +enum ha_rkey_function { + HA_READ_KEY_EXACT, /* Find first record else error */ + HA_READ_KEY_OR_NEXT, /* Record or next record */ + HA_READ_KEY_OR_PREV, /* Record or previous */ + HA_READ_AFTER_KEY, /* Find next rec. after key-record */ + HA_READ_BEFORE_KEY, /* Find next rec. before key-record */ + HA_READ_PREFIX, /* Key which as same prefix */ + HA_READ_PREFIX_LAST, /* Last key with the same prefix */ + HA_READ_MBR_CONTAIN, + HA_READ_MBR_INTERSECT, + HA_READ_MBR_WITHIN, + HA_READ_MBR_DISJOINT, + HA_READ_MBR_EQUAL +}; + + /* Key algorithm types */ + +enum ha_key_alg { + HA_KEY_ALG_UNDEF= 0, /* Not specified (old file) */ + HA_KEY_ALG_BTREE= 1, /* B-tree, default one */ + HA_KEY_ALG_RTREE= 2, /* R-tree, for spatial searches */ + HA_KEY_ALG_HASH= 3, /* HASH keys (HEAP tables) */ + HA_KEY_ALG_FULLTEXT= 4 /* FULLTEXT (MyISAM tables) */ +}; + + /* The following is parameter to ha_extra() */ + +enum ha_extra_function { + HA_EXTRA_NORMAL=0, /* Optimize for space (def) */ + HA_EXTRA_QUICK=1, /* Optimize for speed */ + HA_EXTRA_RESET=2, /* Reset database to after open */ + HA_EXTRA_CACHE=3, /* Cash record in HA_rrnd() */ + HA_EXTRA_NO_CACHE=4, /* End cacheing of records (def) */ + HA_EXTRA_NO_READCHECK=5, /* No readcheck on update */ + HA_EXTRA_READCHECK=6, /* Use readcheck (def) */ + HA_EXTRA_KEYREAD=7, /* Read only key to database */ + HA_EXTRA_NO_KEYREAD=8, /* Normal read of records (def) */ + HA_EXTRA_NO_USER_CHANGE=9, /* No user is allowed to write */ + HA_EXTRA_KEY_CACHE=10, + HA_EXTRA_NO_KEY_CACHE=11, + HA_EXTRA_WAIT_LOCK=12, /* Wait until file is avalably (def) */ + HA_EXTRA_NO_WAIT_LOCK=13, /* If file is locked, return quickly */ + HA_EXTRA_WRITE_CACHE=14, /* Use write cache in ha_write() */ + HA_EXTRA_FLUSH_CACHE=15, /* flush write_record_cache */ + HA_EXTRA_NO_KEYS=16, /* Remove all update of keys */ + HA_EXTRA_KEYREAD_CHANGE_POS=17, /* Keyread, but change pos */ + /* xxxxchk -r must be used */ + HA_EXTRA_REMEMBER_POS=18, /* Remember pos for next/prev */ + HA_EXTRA_RESTORE_POS=19, + HA_EXTRA_REINIT_CACHE=20, /* init cache from current record */ + HA_EXTRA_FORCE_REOPEN=21, /* Datafile have changed on disk */ + HA_EXTRA_FLUSH, /* Flush tables to disk */ + HA_EXTRA_NO_ROWS, /* Don't write rows */ + HA_EXTRA_RESET_STATE, /* Reset positions */ + HA_EXTRA_IGNORE_DUP_KEY, /* Dup keys don't rollback everything*/ + HA_EXTRA_NO_IGNORE_DUP_KEY, + HA_EXTRA_DONT_USE_CURSOR_TO_UPDATE, /* Cursor will not be used for update */ + HA_EXTRA_PREPARE_FOR_DELETE, + HA_EXTRA_PREPARE_FOR_UPDATE /* Remove read cache if problems */ +}; + + /* The following is parameter to ha_panic() */ + +enum ha_panic_function { + HA_PANIC_CLOSE, /* Close all databases */ + HA_PANIC_WRITE, /* Unlock and write status */ + HA_PANIC_READ /* Lock and read keyinfo */ +}; + + /* The following is parameter to ha_create(); keytypes */ + +enum ha_base_keytype { + HA_KEYTYPE_END=0, + HA_KEYTYPE_TEXT=1, /* Key is sorted as letters */ + HA_KEYTYPE_BINARY=2, /* Key is sorted as unsigned chars */ + HA_KEYTYPE_SHORT_INT=3, + HA_KEYTYPE_LONG_INT=4, + HA_KEYTYPE_FLOAT=5, + HA_KEYTYPE_DOUBLE=6, + HA_KEYTYPE_NUM=7, /* Not packed num with pre-space */ + HA_KEYTYPE_USHORT_INT=8, + HA_KEYTYPE_ULONG_INT=9, + HA_KEYTYPE_LONGLONG=10, + HA_KEYTYPE_ULONGLONG=11, + HA_KEYTYPE_INT24=12, + HA_KEYTYPE_UINT24=13, + HA_KEYTYPE_INT8=14, + HA_KEYTYPE_VARTEXT=15, /* Key is sorted as letters */ + HA_KEYTYPE_VARBINARY=16 /* Key is sorted as unsigned chars */ +}; + +#define HA_MAX_KEYTYPE 31 /* Must be log2-1 */ + + /* These flags kan be OR:ed to key-flag */ + +#define HA_NOSAME 1 /* Set if not dupplicated records */ +#define HA_PACK_KEY 2 /* Pack string key to previous key */ +#define HA_AUTO_KEY 16 +#define HA_BINARY_PACK_KEY 32 /* Packing of all keys to prev key */ +#define HA_FULLTEXT 128 /* SerG: for full-text search */ +#define HA_UNIQUE_CHECK 256 /* Check the key for uniqueness */ +#define HA_SPATIAL 1024 /* Alex Barkov: for spatial search */ +#define HA_NULL_ARE_EQUAL 2048 /* NULL in key are cmp as equal */ + + + /* Automatic bits in key-flag */ + +#define HA_SPACE_PACK_USED 4 /* Test for if SPACE_PACK used */ +#define HA_VAR_LENGTH_KEY 8 +#define HA_NULL_PART_KEY 64 +#ifndef ISAM_LIBRARY +#define HA_SORT_ALLOWS_SAME 512 /* Intern bit when sorting records */ +#else +/* poor old NISAM has 8-bit flags :-( */ +#define HA_SORT_ALLOWS_SAME 128 /* Intern bit when sorting records */ +#endif +/* + Key has a part that can have end space. If this is an unique key + we have to handle it differently from other unique keys as we can find + many matching rows for one key (becaue end space are not compared) +*/ +#define HA_END_SPACE_KEY 4096 + + /* These flags can be added to key-seg-flag */ + +#define HA_SPACE_PACK 1 /* Pack space in key-seg */ +#define HA_PART_KEY_SEG 4 /* Used by MySQL for part-key-cols */ +#define HA_VAR_LENGTH 8 +#define HA_NULL_PART 16 +#define HA_BLOB_PART 32 +#define HA_SWAP_KEY 64 +#define HA_REVERSE_SORT 128 /* Sort key in reverse order */ +#define HA_NO_SORT 256 /* do not bother sorting on this keyseg */ + + /* optionbits for database */ +#define HA_OPTION_PACK_RECORD 1 +#define HA_OPTION_PACK_KEYS 2 +#define HA_OPTION_COMPRESS_RECORD 4 +#define HA_OPTION_LONG_BLOB_PTR 8 /* new ISAM format */ +#define HA_OPTION_TMP_TABLE 16 +#define HA_OPTION_CHECKSUM 32 +#define HA_OPTION_DELAY_KEY_WRITE 64 +#define HA_OPTION_NO_PACK_KEYS 128 /* Reserved for MySQL */ +#define HA_OPTION_TEMP_COMPRESS_RECORD ((uint) 16384) /* set by isamchk */ +#define HA_OPTION_READ_ONLY_DATA ((uint) 32768) /* Set by isamchk */ + + /* Bits in flag to create() */ + +#define HA_DONT_TOUCH_DATA 1 /* Don't empty datafile (isamchk) */ +#define HA_PACK_RECORD 2 /* Request packed record format */ +#define HA_CREATE_TMP_TABLE 4 +#define HA_CREATE_CHECKSUM 8 +#define HA_CREATE_DELAY_KEY_WRITE 64 + + /* Bits in flag to _status */ + +#define HA_STATUS_POS 1 /* Return position */ +#define HA_STATUS_NO_LOCK 2 /* Don't use external lock */ +#define HA_STATUS_TIME 4 /* Return update time */ +#define HA_STATUS_CONST 8 /* Return constants values */ +#define HA_STATUS_VARIABLE 16 +#define HA_STATUS_ERRKEY 32 +#define HA_STATUS_AUTO 64 + + /* Errorcodes given by functions */ + +/* opt_sum_query() assumes these codes are > 1 */ +#define HA_ERR_KEY_NOT_FOUND 120 /* Didn't find key on read or update */ +#define HA_ERR_FOUND_DUPP_KEY 121 /* Dupplicate key on write */ +#define HA_ERR_RECORD_CHANGED 123 /* Uppdate with is recoverable */ +#define HA_ERR_WRONG_INDEX 124 /* Wrong index given to function */ +#define HA_ERR_CRASHED 126 /* Indexfile is crashed */ +#define HA_ERR_WRONG_IN_RECORD 127 /* Record-file is crashed */ +#define HA_ERR_OUT_OF_MEM 128 /* Record-file is crashed */ +#define HA_ERR_NOT_A_TABLE 130 /* not a MYI file - no signature */ +#define HA_ERR_WRONG_COMMAND 131 /* Command not supported */ +#define HA_ERR_OLD_FILE 132 /* old databasfile */ +#define HA_ERR_NO_ACTIVE_RECORD 133 /* No record read in update() */ +#define HA_ERR_RECORD_DELETED 134 /* Intern error-code */ +#define HA_ERR_RECORD_FILE_FULL 135 /* No more room in file */ +#define HA_ERR_INDEX_FILE_FULL 136 /* No more room in file */ +#define HA_ERR_END_OF_FILE 137 /* end in next/prev/first/last */ +#define HA_ERR_UNSUPPORTED 138 /* unsupported extension used */ +#define HA_ERR_TO_BIG_ROW 139 /* Too big row */ +#define HA_WRONG_CREATE_OPTION 140 /* Wrong create option */ +#define HA_ERR_FOUND_DUPP_UNIQUE 141 /* Dupplicate unique on write */ +#define HA_ERR_UNKNOWN_CHARSET 142 /* Can't open charset */ +#define HA_ERR_WRONG_MRG_TABLE_DEF 143 /* conflicting MyISAM tables in MERGE */ +#define HA_ERR_CRASHED_ON_REPAIR 144 /* Last (automatic?) repair failed */ +#define HA_ERR_CRASHED_ON_USAGE 145 /* Table must be repaired */ +#define HA_ERR_LOCK_WAIT_TIMEOUT 146 +#define HA_ERR_LOCK_TABLE_FULL 147 +#define HA_ERR_READ_ONLY_TRANSACTION 148 /* Updates not allowed */ +#define HA_ERR_LOCK_DEADLOCK 149 +#define HA_ERR_CANNOT_ADD_FOREIGN 150 /* Cannot add a foreign key constr. */ +#define HA_ERR_NO_REFERENCED_ROW 151 /* Cannot add a child row */ +#define HA_ERR_ROW_IS_REFERENCED 152 /* Cannot delete a parent row */ +#define HA_ERR_NO_SAVEPOINT 153 /* No savepoint with that name */ + + /* Other constants */ + +#define HA_NAMELEN 64 /* Max length of saved filename */ +#define NO_SUCH_KEY ((uint)~0) /* used as a key no. */ + + /* Intern constants in databases */ + + /* bits in _search */ +#define SEARCH_FIND 1 +#define SEARCH_NO_FIND 2 +#define SEARCH_SAME 4 +#define SEARCH_BIGGER 8 +#define SEARCH_SMALLER 16 +#define SEARCH_SAVE_BUFF 32 +#define SEARCH_UPDATE 64 +#define SEARCH_PREFIX 128 +#define SEARCH_LAST 256 +#define MBR_CONTAIN 512 +#define MBR_INTERSECT 1024 +#define MBR_WITHIN 2048 +#define MBR_DISJOINT 4096 +#define MBR_EQUAL 8192 +#define MBR_DATA 16384 +#define SEARCH_NULL_ARE_EQUAL 32768 /* NULL in keys are equal */ +#define SEARCH_NULL_ARE_NOT_EQUAL 65536 /* NULL in keys are not equal */ + + /* bits in opt_flag */ +#define QUICK_USED 1 +#define READ_CACHE_USED 2 +#define READ_CHECK_USED 4 +#define KEY_READ_USED 8 +#define WRITE_CACHE_USED 16 +#define OPT_NO_ROWS 32 + + /* bits in update */ +#define HA_STATE_CHANGED 1 /* Database has changed */ +#define HA_STATE_AKTIV 2 /* Has a current record */ +#define HA_STATE_WRITTEN 4 /* Record is written */ +#define HA_STATE_DELETED 8 +#define HA_STATE_NEXT_FOUND 16 /* Next found record (record before) */ +#define HA_STATE_PREV_FOUND 32 /* Prev found record (record after) */ +#define HA_STATE_NO_KEY 64 /* Last read didn't find record */ +#define HA_STATE_KEY_CHANGED 128 +#define HA_STATE_WRITE_AT_END 256 /* set in _ps_find_writepos */ +#define HA_STATE_BUFF_SAVED 512 /* If current keybuff is info->buff */ +#define HA_STATE_ROW_CHANGED 1024 /* To invalide ROW cache */ +#define HA_STATE_EXTEND_BLOCK 2048 + +enum en_fieldtype { + FIELD_LAST=-1,FIELD_NORMAL,FIELD_SKIP_ENDSPACE,FIELD_SKIP_PRESPACE, + FIELD_SKIP_ZERO,FIELD_BLOB,FIELD_CONSTANT,FIELD_INTERVALL,FIELD_ZERO, + FIELD_VARCHAR,FIELD_CHECK +}; + +enum data_file_type { + STATIC_RECORD,DYNAMIC_RECORD,COMPRESSED_RECORD +}; + +/* For number of records */ +#ifdef BIG_TABLES +#define rows2double(A) ulonglong2double(A) +typedef my_off_t ha_rows; +#else +#define rows2double(A) (double) (A) +typedef ulong ha_rows; +#endif + +#define HA_POS_ERROR (~ (ha_rows) 0) +#define HA_OFFSET_ERROR (~ (my_off_t) 0) + +#if SYSTEM_SIZEOF_OFF_T == 4 +#define MAX_FILE_SIZE INT_MAX32 +#else +#define MAX_FILE_SIZE LONGLONG_MAX +#endif + +#endif /* _my_base_h */ diff --git a/dlls/csx_sql/extra/include/mysql/my_bitmap.h b/dlls/csx_sql/extra/include/mysql/my_bitmap.h new file mode 100755 index 00000000..ca0037ad --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/my_bitmap.h @@ -0,0 +1,55 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef _my_bitmap_h_ +#define _my_bitmap_h_ + +#include + +#define MY_BIT_NONE (~(uint) 0) + +typedef struct st_bitmap +{ + uchar *bitmap; + uint bitmap_size; + my_bool thread_safe; /* set if several threads access the bitmap */ + /* + mutex will be acquired for the duration of each bitmap operation if + thread_safe flag is set. Otherwise, we optimize by not acquiring the + mutex + */ +#ifdef THREAD + pthread_mutex_t mutex; +#endif +} MY_BITMAP; + +#ifdef __cplusplus +extern "C" { +#endif + extern my_bool bitmap_init(MY_BITMAP *bitmap, uint bitmap_size, + my_bool thread_safe); + extern void bitmap_free(MY_BITMAP *bitmap); + extern void bitmap_set_bit(MY_BITMAP *bitmap, uint bitmap_bit); + extern uint bitmap_set_next(MY_BITMAP *bitmap); + extern void bitmap_set_all(MY_BITMAP* bitmap); + extern my_bool bitmap_is_set(MY_BITMAP* bitmap, uint bitmap_bit); + extern void bitmap_clear_all(MY_BITMAP* bitmap); + extern void bitmap_clear_bit(MY_BITMAP *bitmap, uint bitmap_bit); +#ifdef __cplusplus +} +#endif + +#endif /* _my_bitmap_h_ */ diff --git a/dlls/csx_sql/extra/include/mysql/my_config.h b/dlls/csx_sql/extra/include/mysql/my_config.h new file mode 100755 index 00000000..55e4b6c0 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/my_config.h @@ -0,0 +1,882 @@ +/* config.h. Generated by configure. */ +/* config.h.in. Generated from configure.in by autoheader. */ +/* acconfig.h + This file is in the public domain. + + Descriptive text for the C preprocessor macros that + the distributed Autoconf macros can define. + No software package will use all of them; autoheader copies the ones + your configure.in uses into your configuration header file templates. + + The entries are in sort -df order: alphabetical, case insensitive, + ignoring punctuation (such as underscores). Although this order + can split up related entries, it makes it easier to check whether + a given entry is in the file. + + Leave the following blank line there!! Autoheader needs it. */ + + +/* #undef C_ALLOCA */ + +/* #undef CRAY_STACKSEG_END */ + +/* Version of .frm files */ +#define DOT_FRM_VERSION 6 + +/* If LOAD DATA LOCAL INFILE should be enabled by default */ +#define ENABLED_LOCAL_INFILE 1 + +/* READLINE: */ +#define FIONREAD_IN_SYS_IOCTL 1 + +/* READLINE: Define if your system defines TIOCGWINSZ in sys/ioctl.h. */ +#define GWINSZ_IN_SYS_IOCTL 1 + +/* Handing of large files on Solaris 2.6 */ +#define _FILE_OFFSET_BITS 64 + +/* Do we have FIONREAD */ +#define FIONREAD_IN_SYS_IOCTL 1 + +/* Do we need to define _GNU_SOURCE */ +/* #undef _GNU_SOURCE */ + +/* atomic_add() from (Linux only) */ +#define HAVE_ATOMIC_ADD 1 + +/* atomic_sub() from (Linux only) */ +#define HAVE_ATOMIC_SUB 1 + +/* If we have a working alloca() implementation */ +#define HAVE_ALLOCA 1 + +/* bool is not defined by all C++ compilators */ +#define HAVE_BOOL 1 + +/* Have berkeley db installed */ +#define HAVE_BERKELEY_DB 1 + +/* DSB style signals ? */ +/* #undef HAVE_BSD_SIGNALS */ + +/* Can netinet be included */ +/* #undef HAVE_BROKEN_NETINET_INCLUDES */ + +/* READLINE: */ +/* #undef HAVE_BSD_SIGNALS */ + +/* ZLIB and compress: */ +#define HAVE_COMPRESS 1 + +/* Define if we are using OSF1 DEC threads */ +/* #undef HAVE_DEC_THREADS */ + +/* Define if we are using OSF1 DEC threads on 3.2 */ +/* #undef HAVE_DEC_3_2_THREADS */ + +/* fp_except from ieeefp.h */ +/* #undef HAVE_FP_EXCEPT */ + +/* READLINE: */ +/* #undef HAVE_GETPW_DECLS */ + +/* Solaris define gethostbyname_r with 5 arguments. glibc2 defines + this with 6 arguments */ +#define HAVE_GETHOSTBYNAME_R_GLIBC2_STYLE 1 + +/* In OSF 4.0f the 3'd argument to gethostname_r is hostent_data * */ +/* #undef HAVE_GETHOSTBYNAME_R_RETURN_INT */ + +/* Define if int8, int16 and int32 types exist */ +/* #undef HAVE_INT_8_16_32 */ + +/* Using Innobase DB */ +#define HAVE_INNOBASE_DB 1 + +/* Using old ISAM tables */ +#define HAVE_ISAM 1 + +/* Define if we have GNU readline */ +/* #undef HAVE_LIBREADLINE */ + +/* Define if have -lwrap */ +/* #undef HAVE_LIBWRAP */ + +/* Define if we are using Xavier Leroy's LinuxThreads */ +#define HAVE_LINUXTHREADS 1 + +/* Do we have lstat */ +#define HAVE_LSTAT 1 + +/* Do we use user level threads */ +/* #undef HAVE_mit_thread */ + +/* For some non posix threads */ +/* #undef HAVE_NONPOSIX_PTHREAD_GETSPECIFIC */ + +/* For some non posix threads */ +/* #undef HAVE_NONPOSIX_PTHREAD_MUTEX_INIT */ + +/* READLINE: */ +#define HAVE_POSIX_SIGNALS 1 + +/* Well.. */ +/* #undef HAVE_POSIX_SIGSETJMP */ + +/* sigwait with one argument */ +/* #undef HAVE_NONPOSIX_SIGWAIT */ + +/* ORBIT */ +/* #undef HAVE_ORBIT */ + +/* pthread_attr_setscope */ +#define HAVE_PTHREAD_ATTR_SETSCOPE 1 + +/* pthread_yield that doesn't take any arguments */ +#define HAVE_PTHREAD_YIELD_ZERO_ARG 1 + +/* pthread_yield function with one argument */ +/* #undef HAVE_PTHREAD_YIELD_ONE_ARG */ + +/* POSIX readdir_r */ +#define HAVE_READDIR_R 1 + +/* Have Gemini db installed */ +/* #undef HAVE_GEMINI_DB */ + +/* POSIX sigwait */ +#define HAVE_SIGWAIT 1 + +/* crypt */ +#define HAVE_CRYPT 1 + +/* If we want to have query cache */ +#define HAVE_QUERY_CACHE 1 + +/* Solaris define gethostbyaddr_r with 7 arguments. glibc2 defines + this with 8 arguments */ +/* #undef HAVE_SOLARIS_STYLE_GETHOST */ + +/* MIT pthreads does not support connecting with unix sockets */ +/* #undef HAVE_THREADS_WITHOUT_SOCKETS */ + +/* Timespec has a ts_sec instead of tv_sev */ +/* #undef HAVE_TIMESPEC_TS_SEC */ + +/* Have the tzname variable */ +#define HAVE_TZNAME 1 + +/* Define if the system files define uchar */ +/* #undef HAVE_UCHAR */ + +/* Define if the system files define uint */ +#define HAVE_UINT 1 + +/* Define if the system files define ulong */ +#define HAVE_ULONG 1 + +/* Define if the system files define in_addr_t */ +#define HAVE_IN_ADDR_T 1 + +/* UNIXWARE7 threads are not posix */ +/* #undef HAVE_UNIXWARE7_THREADS */ + +/* new UNIXWARE7 threads that are not yet posix */ +/* #undef HAVE_UNIXWARE7_POSIX */ + +/* OpenSSL */ +#define HAVE_OPENSSL 1 + +/* READLINE: */ +/* #undef HAVE_USG_SIGHOLD */ + +/* Virtual IO */ +#define HAVE_VIO 1 + +/* Handling of large files on Solaris 2.6 */ +/* #undef _LARGEFILE_SOURCE */ + +/* Handling of large files on Solaris 2.6 */ +/* #undef _LARGEFILE64_SOURCE */ + +/* Define if want -lwrap */ +/* #undef LIBWRAP */ + +/* Define to machine type name eg sun10 */ +#define MACHINE_TYPE "i686" + +/* #undef MUST_REINSTALL_SIGHANDLERS */ + +/* Defined to used character set */ +/* #undef MY_CHARSET_CURRENT */ + +/* READLINE: no sys file*/ +/* #undef NO_SYS_FILE */ + +/* Program name */ +#define PACKAGE "mysql" + +/* mysql client protocoll version */ +#define PROTOCOL_VERSION 10 + +/* Define if qsort returns void */ +#define QSORT_TYPE_IS_VOID 1 + +/* Define as the return type of qsort (int or void). */ +#define RETQSORTTYPE void + +/* Size of off_t */ +#define SIZEOF_OFF_T 8 + +/* Define as the base type of the last arg to accept */ +#define SOCKET_SIZE_TYPE socklen_t + +/* Last argument to get/setsockopt */ +/* #undef SOCKOPT_OPTLEN_TYPE */ + +/* #undef SPEED_T_IN_SYS_TYPES */ +/* #undef SPRINTF_RETURNS_PTR */ +#define SPRINTF_RETURNS_INT 1 +/* #undef SPRINTF_RETURNS_GARBAGE */ + +/* Needed to get large file support on HPUX 10.20 */ +/* #undef __STDC_EXT__ */ + +#define STACK_DIRECTION -1 + +/* #undef STRCOLL_BROKEN */ + +/* #undef STRUCT_DIRENT_HAS_D_FILENO */ +#define STRUCT_DIRENT_HAS_D_INO 1 + +/* #undef STRUCT_WINSIZE_IN_SYS_IOCTL */ +/* #undef STRUCT_WINSIZE_IN_TERMIOS */ + +/* Define to name of system eg solaris*/ +#define SYSTEM_TYPE "pc-linux" + +/* Define if you want to have threaded code. This may be undef on client code */ +#define THREAD 1 + +/* Should be client be thread safe */ +#define THREAD_SAFE_CLIENT 1 + +/* READLINE: */ +/* #undef TIOCSTAT_IN_SYS_IOCTL */ + +/* Use multi-byte character routines */ +#define USE_MB 1 +#define USE_MB_IDENT 1 + +/* the pstack backtrace library */ +/* #undef USE_PSTACK */ + +/* Use MySQL RAID */ +#define USE_RAID 1 + +/* Use strcoll() functions when comparing and sorting. */ +#define USE_STRCOLL 1 + +/* Program version */ +#define VERSION "4.0.18" + +/* READLINE: */ +#define VOID_SIGHANDLER 1 + + +/* Leave that blank line there!! Autoheader needs it. + If you're adding to this file, keep in mind: + The entries are in sort -df order: alphabetical, case insensitive, + ignoring punctuation (such as underscores). */ + +/* Define to 1 if you have the `alarm' function. */ +#define HAVE_ALARM 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_ALLOCA_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_ARPA_INET_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_ASM_TERMBITS_H 1 + +/* Define to 1 if you have the `atod' function. */ +/* #undef HAVE_ATOD */ + +/* Define to 1 if you have the `bcmp' function. */ +#define HAVE_BCMP 1 + +/* Define to 1 if you have the `bfill' function. */ +/* #undef HAVE_BFILL */ + +/* Define to 1 if you have the `bmove' function. */ +/* #undef HAVE_BMOVE */ + +/* Define to 1 if you have the `bzero' function. */ +#define HAVE_BZERO 1 + +/* Define to 1 if you have the `chsize' function. */ +/* #undef HAVE_CHSIZE */ + +/* Define to 1 if you have the header file. */ +#define HAVE_CRYPT_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_CURSES_H 1 + +/* Define to 1 if you have the `cuserid' function. */ +#define HAVE_CUSERID 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_DIRENT_H 1 + +/* Define to 1 if you have the `dlerror' function. */ +#define HAVE_DLERROR 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_DLFCN_H 1 + +/* Define to 1 if you have the `dlopen' function. */ +#define HAVE_DLOPEN 1 + +/* Define to 1 if you don't have `vprintf' but do have `_doprnt.' */ +/* #undef HAVE_DOPRNT */ + +/* Define to 1 if you have the `fchmod' function. */ +#define HAVE_FCHMOD 1 + +/* Define to 1 if you have the `fcntl' function. */ +#define HAVE_FCNTL 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_FCNTL_H 1 + +/* Define to 1 if you have the `fconvert' function. */ +/* #undef HAVE_FCONVERT */ + +/* Define to 1 if you have the `fdatasync' function. */ +#define HAVE_FDATASYNC 1 + +/* Define to 1 if you have the `finite' function. */ +#define HAVE_FINITE 1 + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_FLOATINGPOINT_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_FLOAT_H 1 + +/* Define to 1 if you have the `fpresetsticky' function. */ +/* #undef HAVE_FPRESETSTICKY */ + +/* Define to 1 if you have the `fpsetmask' function. */ +/* #undef HAVE_FPSETMASK */ + +/* Define to 1 if you have the `fseeko' function. */ +#define HAVE_FSEEKO 1 + +/* Define to 1 if you have the `fsync' function. */ +#define HAVE_FSYNC 1 + +/* Define to 1 if you have the `ftruncate' function. */ +#define HAVE_FTRUNCATE 1 + +/* Define to 1 if you have the `getcwd' function. */ +#define HAVE_GETCWD 1 + +/* Define to 1 if you have the `gethostbyaddr_r' function. */ +#define HAVE_GETHOSTBYADDR_R 1 + +/* Define to 1 if you have the `gethostbyname_r' function. */ +#define HAVE_GETHOSTBYNAME_R 1 + +/* Define to 1 if you have the `getpagesize' function. */ +#define HAVE_GETPAGESIZE 1 + +/* Define to 1 if you have the `getpass' function. */ +#define HAVE_GETPASS 1 + +/* Define to 1 if you have the `getpassphrase' function. */ +/* #undef HAVE_GETPASSPHRASE */ + +/* Define to 1 if you have the `getpwnam' function. */ +#define HAVE_GETPWNAM 1 + +/* Define to 1 if you have the `getpwuid' function. */ +#define HAVE_GETPWUID 1 + +/* Define to 1 if you have the `getrlimit' function. */ +#define HAVE_GETRLIMIT 1 + +/* Define to 1 if you have the `getrusage' function. */ +#define HAVE_GETRUSAGE 1 + +/* Define to 1 if you have the `getwd' function. */ +#define HAVE_GETWD 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_GRP_H 1 + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_IEEEFP_H */ + +/* Define to 1 if you have the `index' function. */ +#define HAVE_INDEX 1 + +/* Define to 1 if you have the `initgroups' function. */ +#define HAVE_INITGROUPS 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_INTTYPES_H 1 + +/* Define to 1 if you have the `isnan' function. */ +#define HAVE_ISNAN 1 + +/* Define to 1 if you have the `bind' library (-lbind). */ +/* #undef HAVE_LIBBIND */ + +/* Define to 1 if you have the `compat' library (-lcompat). */ +/* #undef HAVE_LIBCOMPAT */ + +/* Define to 1 if you have the `crypt' library (-lcrypt). */ +#define HAVE_LIBCRYPT 1 + +/* Define to 1 if you have the `c_r' library (-lc_r). */ +/* #undef HAVE_LIBC_R */ + +/* Define to 1 if you have the `dl' library (-ldl). */ +#define HAVE_LIBDL 1 + +/* Define to 1 if you have the `gen' library (-lgen). */ +/* #undef HAVE_LIBGEN */ + +/* Define to 1 if you have the `m' library (-lm). */ +#define HAVE_LIBM 1 + +/* Define to 1 if you have the `nsl' library (-lnsl). */ +#define HAVE_LIBNSL 1 + +/* Define to 1 if you have the `nsl_r' library (-lnsl_r). */ +/* #undef HAVE_LIBNSL_R */ + +/* Define to 1 if you have the `posix4' library (-lposix4). */ +/* #undef HAVE_LIBPOSIX4 */ + +/* Define to 1 if you have the `pthread' library (-lpthread). */ +#define HAVE_LIBPTHREAD 1 + +/* Define to 1 if you have the `socket' library (-lsocket). */ +/* #undef HAVE_LIBSOCKET */ + +/* Define to 1 if you have the header file. */ +#define HAVE_LIMITS_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_LINUX_CONFIG_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_LOCALE_H 1 + +/* Define to 1 if you have the `localtime_r' function. */ +#define HAVE_LOCALTIME_R 1 + +/* Define to 1 if you have the `locking' function. */ +/* #undef HAVE_LOCKING */ + +/* Define to 1 if you have the `longjmp' function. */ +#define HAVE_LONGJMP 1 + +/* Define to 1 if you have the `lrand48' function. */ +#define HAVE_LRAND48 1 + +/* Define to 1 if you have the `lstat' function. */ +#define HAVE_LSTAT 1 + +/* Define to 1 if you have the `madvise' function. */ +#define HAVE_MADVISE 1 + +/* Define to 1 if you have the `mallinfo' function. */ +#define HAVE_MALLINFO 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_MALLOC_H 1 + +/* Define to 1 if you have the `memcpy' function. */ +#define HAVE_MEMCPY 1 + +/* Define to 1 if you have the `memmove' function. */ +#define HAVE_MEMMOVE 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_MEMORY_H 1 + +/* Define to 1 if you have the `mkstemp' function. */ +#define HAVE_MKSTEMP 1 + +/* Define to 1 if you have the `mlockall' function. */ +#define HAVE_MLOCKALL 1 + +/* Define to 1 if you have a working `mmap' system call. */ +#define HAVE_MMAP 1 + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_NDIR_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_NETINET_IN_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_PATHS_H 1 + +/* Define to 1 if you have the `perror' function. */ +#define HAVE_PERROR 1 + +/* Define to 1 if you have the `poll' function. */ +#define HAVE_POLL 1 + +/* Define to 1 if you have the `pread' function. */ +#define HAVE_PREAD 1 + +/* Define to 1 if you have the `pthread_attr_create' function. */ +/* #undef HAVE_PTHREAD_ATTR_CREATE */ + +/* Define to 1 if you have the `pthread_attr_getstacksize' function. */ +#define HAVE_PTHREAD_ATTR_GETSTACKSIZE 1 + +/* Define to 1 if you have the `pthread_attr_setprio' function. */ +/* #undef HAVE_PTHREAD_ATTR_SETPRIO */ + +/* Define to 1 if you have the `pthread_attr_setschedparam' function. */ +#define HAVE_PTHREAD_ATTR_SETSCHEDPARAM 1 + +/* Define to 1 if you have the `pthread_attr_setstacksize' function. */ +#define HAVE_PTHREAD_ATTR_SETSTACKSIZE 1 + +/* Define to 1 if you have the `pthread_condattr_create' function. */ +/* #undef HAVE_PTHREAD_CONDATTR_CREATE */ + +/* Define to 1 if you have the `pthread_getsequence_np' function. */ +/* #undef HAVE_PTHREAD_GETSEQUENCE_NP */ + +/* Define to 1 if you have the `pthread_init' function. */ +/* #undef HAVE_PTHREAD_INIT */ + +/* Define to 1 if you have the `pthread_key_delete' function. */ +#define HAVE_PTHREAD_KEY_DELETE 1 + +/* Define to 1 if you have the `pthread_rwlock_rdlock' function. */ +#define HAVE_PTHREAD_RWLOCK_RDLOCK 1 + +/* Define to 1 if you have the `pthread_setprio' function. */ +/* #undef HAVE_PTHREAD_SETPRIO */ + +/* Define to 1 if you have the `pthread_setprio_np' function. */ +/* #undef HAVE_PTHREAD_SETPRIO_NP */ + +/* Define to 1 if you have the `pthread_setschedparam' function. */ +#define HAVE_PTHREAD_SETSCHEDPARAM 1 + +/* Define to 1 if you have the `pthread_sigmask' function. */ +#define HAVE_PTHREAD_SIGMASK 1 + +/* Define to 1 if you have the `putenv' function. */ +#define HAVE_PUTENV 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_PWD_H 1 + +/* Define to 1 if you have the `readlink' function. */ +#define HAVE_READLINK 1 + +/* Define to 1 if you have the `realpath' function. */ +#define HAVE_REALPATH 1 + +/* Define to 1 if you have the `rename' function. */ +#define HAVE_RENAME 1 + +/* Define to 1 if system calls automatically restart after interruption by a + signal. */ +#define HAVE_RESTARTABLE_SYSCALLS 1 + +/* Define to 1 if you have the `rint' function. */ +#define HAVE_RINT 1 + +/* Define to 1 if you have the `rwlock_init' function. */ +/* #undef HAVE_RWLOCK_INIT */ + +/* Define to 1 if you have the header file. */ +#define HAVE_SCHED_H 1 + +/* Define to 1 if you have the `select' function. */ +#define HAVE_SELECT 1 + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_SELECT_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_SEMAPHORE_H 1 + +/* Define to 1 if you have the `setenv' function. */ +#define HAVE_SETENV 1 + +/* Define to 1 if you have the `setlocale' function. */ +#define HAVE_SETLOCALE 1 + +/* Define to 1 if you have the `setupterm' function. */ +/* #undef HAVE_SETUPTERM */ + +/* Define to 1 if you have the `sighold' function. */ +#define HAVE_SIGHOLD 1 + +/* Define to 1 if you have the `sigset' function. */ +#define HAVE_SIGSET 1 + +/* Define to 1 if you have the `sigthreadmask' function. */ +/* #undef HAVE_SIGTHREADMASK */ + +/* Define to 1 if you have the `snprintf' function. */ +#define HAVE_SNPRINTF 1 + +/* Define to 1 if you have the `socket' function. */ +#define HAVE_SOCKET 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_STDARG_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_STDDEF_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_STDINT_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_STDLIB_H 1 + +/* Define to 1 if you have the `stpcpy' function. */ +#define HAVE_STPCPY 1 + +/* Define to 1 if you have the `strcasecmp' function. */ +#define HAVE_STRCASECMP 1 + +/* Define to 1 if you have the `strcoll' function. */ +#define HAVE_STRCOLL 1 + +/* Define to 1 if you have the `strerror' function. */ +#define HAVE_STRERROR 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_STRINGS_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_STRING_H 1 + +/* Define to 1 if you have the `strnlen' function. */ +#define HAVE_STRNLEN 1 + +/* Define to 1 if you have the `strpbrk' function. */ +#define HAVE_STRPBRK 1 + +/* Define to 1 if you have the `strstr' function. */ +#define HAVE_STRSTR 1 + +/* Define to 1 if you have the `strtok_r' function. */ +#define HAVE_STRTOK_R 1 + +/* Define to 1 if you have the `strtol' function. */ +#define HAVE_STRTOL 1 + +/* Define to 1 if you have the `strtoll' function. */ +#define HAVE_STRTOLL 1 + +/* Define to 1 if you have the `strtoul' function. */ +#define HAVE_STRTOUL 1 + +/* Define to 1 if you have the `strtoull' function. */ +#define HAVE_STRTOULL 1 + +/* Define to 1 if `st_rdev' is member of `struct stat'. */ +#define HAVE_STRUCT_STAT_ST_RDEV 1 + +/* Define to 1 if your `struct stat' has `st_rdev'. Deprecated, use + `HAVE_STRUCT_STAT_ST_RDEV' instead. */ +#define HAVE_ST_RDEV 1 + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_SYNCH_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_DIR_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_FILE_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_IOCTL_H 1 + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_SYS_MALLOC_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_MMAN_H 1 + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_SYS_NDIR_H */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_SYS_PTEM_H */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_SYS_PTE_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_SELECT_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_SOCKET_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_STAT_H 1 + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_SYS_STREAM_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_TIMEB_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_TYPES_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_UN_H 1 + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_SYS_UTIME_H */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_SYS_VADVISE_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_WAIT_H 1 + +/* Define to 1 if you have the `tcgetattr' function. */ +#define HAVE_TCGETATTR 1 + +/* Define to 1 if you have the `tell' function. */ +/* #undef HAVE_TELL */ + +/* Define to 1 if you have the `tempnam' function. */ +#define HAVE_TEMPNAM 1 + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_TERMBITS_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_TERMCAP_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_TERMIOS_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_TERMIO_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_TERM_H 1 + +/* Define to 1 if you have the `thr_setconcurrency' function. */ +/* #undef HAVE_THR_SETCONCURRENCY */ + +/* Define to 1 if you have the header file. */ +#define HAVE_UNISTD_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_UTIME_H 1 + +/* Define to 1 if `utime(file, NULL)' sets file's timestamp to the present. */ +#define HAVE_UTIME_NULL 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_VARARGS_H 1 + +/* Define to 1 if you have the `vidattr' function. */ +/* #undef HAVE_VIDATTR */ + +/* Define to 1 if you have the `vprintf' function. */ +#define HAVE_VPRINTF 1 + +/* Name of package */ +#define PACKAGE "mysql" + +/* Define to the address where bug reports for this package should be sent. */ +#define PACKAGE_BUGREPORT "" + +/* Define to the full name of this package. */ +#define PACKAGE_NAME "" + +/* Define to the full name and version of this package. */ +#define PACKAGE_STRING "" + +/* Define to the one symbol short name of this package. */ +#define PACKAGE_TARNAME "" + +/* Define to the version of this package. */ +#define PACKAGE_VERSION "" + +/* Define as the return type of signal handlers (`int' or `void'). */ +#define RETSIGTYPE void + +/* The size of a `char', as computed by sizeof. */ +#define SIZEOF_CHAR 1 + +/* The size of a `char*', as computed by sizeof. */ +#define SIZEOF_CHARP 4 + +/* The size of a `int', as computed by sizeof. */ +#define SIZEOF_INT 4 + +/* The size of a `long', as computed by sizeof. */ +#define SIZEOF_LONG 4 + +/* The size of a `long long', as computed by sizeof. */ +#define SIZEOF_LONG_LONG 8 + +/* Define to 1 if the `S_IS*' macros in do not work properly. */ +/* #undef STAT_MACROS_BROKEN */ + +/* Define to 1 if you have the ANSI C header files. */ +#define STDC_HEADERS 1 + +/* Define to 1 if you can safely include both and . */ +#define TIME_WITH_SYS_TIME 1 + +/* Define to 1 if your declares `struct tm'. */ +/* #undef TM_IN_SYS_TIME */ + +/* Version number of package */ +#define VERSION "4.0.18" + +/* Define to 1 if your processor stores words with the most significant byte + first (like Motorola and SPARC, unlike Intel and VAX). */ +/* #undef WORDS_BIGENDIAN */ + +/* Number of bits in a file offset, on hosts where this is settable. */ +#define _FILE_OFFSET_BITS 64 + +/* Define to make fseeko etc. visible, on some hosts. */ +/* #undef _LARGEFILE_SOURCE */ + +/* Define for large files, on AIX-style hosts. */ +/* #undef _LARGE_FILES */ + +/* Define to empty if `const' does not conform to ANSI C. */ +/* #undef const */ + +/* Define as `__inline' if that's what the C compiler calls it, or to nothing + if it is not supported. */ +/* #undef inline */ + +/* Define to `long' if does not define. */ +/* #undef off_t */ + +/* Define to `unsigned' if does not define. */ +/* #undef size_t */ diff --git a/dlls/csx_sql/extra/include/mysql/my_dbug.h b/dlls/csx_sql/extra/include/mysql/my_dbug.h new file mode 100755 index 00000000..5c88e2e4 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/my_dbug.h @@ -0,0 +1,93 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef _dbug_h +#define _dbug_h +#ifdef __cplusplus +extern "C" { +#endif +#if !defined(DBUG_OFF) && !defined(_lint) +extern int _db_on_,_no_db_; +extern FILE *_db_fp_; +extern char *_db_process_; +extern int _db_keyword_(const char *keyword); +extern void _db_setjmp_(void); +extern void _db_longjmp_(void); +extern void _db_push_(const char *control); +extern void _db_pop_(void); +extern void _db_enter_(const char *_func_,const char *_file_,uint _line_, + const char **_sfunc_,const char **_sfile_, + uint *_slevel_, char ***); +extern void _db_return_(uint _line_,const char **_sfunc_,const char **_sfile_, + uint *_slevel_); +extern void _db_pargs_(uint _line_,const char *keyword); +extern void _db_doprnt_ _VARARGS((const char *format,...)); +extern void _db_dump_(uint _line_,const char *keyword,const char *memory, + uint length); +extern void _db_lock_file(); +extern void _db_unlock_file(); + +#define DBUG_ENTER(a) const char *_db_func_, *_db_file_; uint _db_level_; \ + char **_db_framep_; \ + _db_enter_ (a,__FILE__,__LINE__,&_db_func_,&_db_file_,&_db_level_, \ + &_db_framep_) +#define DBUG_LEAVE \ + (_db_return_ (__LINE__, &_db_func_, &_db_file_, &_db_level_)) +#define DBUG_RETURN(a1) {DBUG_LEAVE; return(a1);} +#define DBUG_VOID_RETURN {DBUG_LEAVE; return;} +#define DBUG_EXECUTE(keyword,a1) \ + {if (_db_on_) {if (_db_keyword_ (keyword)) { a1 }}} +#define DBUG_PRINT(keyword,arglist) \ + {if (_db_on_) {_db_pargs_(__LINE__,keyword); _db_doprnt_ arglist;}} +#define DBUG_PUSH(a1) _db_push_ (a1) +#define DBUG_POP() _db_pop_ () +#define DBUG_PROCESS(a1) (_db_process_ = a1) +#define DBUG_FILE (_db_fp_) +#define DBUG_SETJMP(a1) (_db_setjmp_ (), setjmp (a1)) +#define DBUG_LONGJMP(a1,a2) (_db_longjmp_ (), longjmp (a1, a2)) +#define DBUG_DUMP(keyword,a1,a2)\ + {if (_db_on_) {_db_dump_(__LINE__,keyword,a1,a2);}} +#define DBUG_IN_USE (_db_fp_ && _db_fp_ != stderr) +#define DEBUGGER_OFF _no_db_=1;_db_on_=0; +#define DEBUGGER_ON _no_db_=0 +#define DBUG_LOCK_FILE { _db_lock_file(); } +#define DBUG_UNLOCK_FILE { _db_unlock_file(); } +#define DBUG_ASSERT(A) assert(A) +#else /* No debugger */ + +#define DBUG_ENTER(a1) +#define DBUG_RETURN(a1) return(a1) +#define DBUG_VOID_RETURN return +#define DBUG_EXECUTE(keyword,a1) {} +#define DBUG_PRINT(keyword,arglist) {} +#define DBUG_PUSH(a1) {} +#define DBUG_POP() {} +#define DBUG_PROCESS(a1) {} +#define DBUG_FILE (stderr) +#define DBUG_SETJMP setjmp +#define DBUG_LONGJMP longjmp +#define DBUG_DUMP(keyword,a1,a2) {} +#define DBUG_IN_USE 0 +#define DEBUGGER_OFF +#define DEBUGGER_ON +#define DBUG_LOCK_FILE +#define DBUG_UNLOCK_FILE +#define DBUG_ASSERT(A) {} +#endif +#ifdef __cplusplus +} +#endif +#endif diff --git a/dlls/csx_sql/extra/include/mysql/my_dir.h b/dlls/csx_sql/extra/include/mysql/my_dir.h new file mode 100755 index 00000000..851b6d8d --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/my_dir.h @@ -0,0 +1,106 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef _my_dir_h +#define _my_dir_h +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef MY_DIR_H +#define MY_DIR_H + +#include + + /* Defines for my_dir and my_stat */ + +#define MY_S_IFMT S_IFMT /* type of file */ +#define MY_S_IFDIR S_IFDIR /* directory */ +#define MY_S_IFCHR S_IFCHR /* character special */ +#define MY_S_IFBLK S_IFBLK /* block special */ +#define MY_S_IFREG S_IFREG /* regular */ +#define MY_S_IFIFO S_IFIFO /* fifo */ +#define MY_S_ISUID S_ISUID /* set user id on execution */ +#define MY_S_ISGID S_ISGID /* set group id on execution */ +#define MY_S_ISVTX S_ISVTX /* save swapped text even after use */ +#define MY_S_IREAD S_IREAD /* read permission, owner */ +#define MY_S_IWRITE S_IWRITE /* write permission, owner */ +#define MY_S_IEXEC S_IEXEC /* execute/search permission, owner */ + +#define MY_S_ISDIR(m) (((m) & MY_S_IFMT) == MY_S_IFDIR) +#define MY_S_ISCHR(m) (((m) & MY_S_IFMT) == MY_S_IFCHR) +#define MY_S_ISBLK(m) (((m) & MY_S_IFMT) == MY_S_IFBLK) +#define MY_S_ISREG(m) (((m) & MY_S_IFMT) == MY_S_IFREG) +#define MY_S_ISFIFO(m) (((m) & MY_S_IFMT) == MY_S_IFIFO) + +#define MY_DONT_SORT 512 /* my_lib; Don't sort files */ +#define MY_WANT_STAT 1024 /* my_lib; stat files */ + + /* typedefs for my_dir & my_stat */ + +#ifdef USE_MY_STAT_STRUCT + +typedef struct my_stat +{ + dev_t st_dev; /* major & minor device numbers */ + ino_t st_ino; /* inode number */ + ushort st_mode; /* file permissons (& suid sgid .. bits) */ + short st_nlink; /* number of links to file */ + ushort st_uid; /* user id */ + ushort st_gid; /* group id */ + dev_t st_rdev; /* more major & minor device numbers (???) */ + off_t st_size; /* size of file */ + time_t st_atime; /* time for last read */ + time_t st_mtime; /* time for last contens modify */ + time_t st_ctime; /* time for last inode or contents modify */ +} MY_STAT; + +#else + +#define MY_STAT struct stat /* Orginal struct have what we need */ + +#endif /* USE_MY_STAT_STRUCT */ + +/* Struct describing one file returned from my_dir */ +typedef struct fileinfo +{ + char *name; + MY_STAT *mystat; +} FILEINFO; + +typedef struct st_my_dir /* Struct returned from my_dir */ +{ + /* + These members are just copies of parts of DYNAMIC_ARRAY structure, + which is allocated right after the end of MY_DIR structure (MEM_ROOT + for storing names is also resides there). We've left them here because + we don't want to change code that uses my_dir. + */ + struct fileinfo *dir_entry; + uint number_off_files; +} MY_DIR; + +extern MY_DIR *my_dir(const char *path,myf MyFlags); +extern void my_dirend(MY_DIR *buffer); +extern MY_STAT *my_stat(const char *path, MY_STAT *stat_area, myf my_flags); +extern int my_fstat(int filenr, MY_STAT *stat_area, myf MyFlags); + +#endif /* MY_DIR_H */ + +#ifdef __cplusplus +} +#endif +#endif diff --git a/dlls/csx_sql/extra/include/mysql/my_getopt.h b/dlls/csx_sql/extra/include/mysql/my_getopt.h new file mode 100755 index 00000000..3b4551b4 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/my_getopt.h @@ -0,0 +1,54 @@ +/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +C_MODE_START + +enum get_opt_var_type { GET_NO_ARG, GET_BOOL, GET_INT, GET_UINT, GET_LONG, + GET_ULONG, GET_LL, GET_ULL, GET_STR, GET_STR_ALLOC }; +enum get_opt_arg_type { NO_ARG, OPT_ARG, REQUIRED_ARG }; + +struct my_option +{ + const char *name; /* Name of the option */ + int id; /* unique id or short option */ + const char *comment; /* option comment, for autom. --help */ + gptr *value; /* The variable value */ + gptr *u_max_value; /* The user def. max variable value */ + const char **str_values; /* Pointer to possible values */ + enum get_opt_var_type var_type; + enum get_opt_arg_type arg_type; + longlong def_value; /* Default value */ + longlong min_value; /* Min allowed value */ + longlong max_value; /* Max allowed value */ + longlong sub_size; /* Subtract this from given value */ + long block_size; /* Value should be a mult. of this */ + int app_type; /* To be used by an application */ +}; + +extern char *disabled_my_option; +extern my_bool my_getopt_print_errors; + +extern int handle_options (int *argc, char ***argv, + const struct my_option *longopts, + my_bool (*get_one_option)(int, + const struct my_option *, + char *)); +extern void my_print_help(const struct my_option *options); +extern void my_print_variables(const struct my_option *options); + +ulonglong getopt_ull_limit_value(ulonglong num, const struct my_option *optp); +my_bool getopt_compare_strings(const char *s, const char *t, uint length); +C_MODE_END diff --git a/dlls/csx_sql/extra/include/mysql/my_global.h b/dlls/csx_sql/extra/include/mysql/my_global.h new file mode 100755 index 00000000..e4c0fb44 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/my_global.h @@ -0,0 +1,1138 @@ +/* Copyright (C) 2000-2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* This is the include file that should be included 'first' in every C file. */ + +#ifndef _global_h +#define _global_h + +#ifndef EMBEDDED_LIBRARY +#define HAVE_REPLICATION +#define HAVE_EXTERNAL_CLIENT +#endif + +#if defined( __EMX__) && !defined( MYSQL_SERVER) +/* moved here to use below VOID macro redefinition */ +#define INCL_BASE +#define INCL_NOPMAPI +#include +#endif /* __EMX__ */ + +#ifdef __CYGWIN__ +/* We use a Unix API, so pretend it's not Windows */ +#undef WIN +#undef WIN32 +#undef _WIN +#undef _WIN32 +#undef _WIN64 +#undef __WIN__ +#undef __WIN32__ +#define HAVE_ERRNO_AS_DEFINE +#endif /* __CYGWIN__ */ + +#if defined(i386) && !defined(__i386__) +#define __i386__ +#endif + +/* Macros to make switching between C and C++ mode easier */ +#ifdef __cplusplus +#define C_MODE_START extern "C" { +#define C_MODE_END } +#else +#define C_MODE_START +#define C_MODE_END +#endif + +#if defined(_WIN32) || defined(_WIN64) || defined(__WIN32__) || defined(WIN32) +#include +#elif defined(OS2) +#include +#elif defined(__NETWARE__) +#include +#include +#if defined(__cplusplus) && defined(inline) +#undef inline /* fix configure problem */ +#endif +#else +#include +#if defined(__cplusplus) && defined(inline) +#undef inline /* fix configure problem */ +#endif +#endif /* _WIN32... */ + +/* + The macros below are borrowed from include/linux/compiler.h in the + Linux kernel. Use them to indicate the likelyhood of the truthfulness + of a condition. This serves two purposes - newer versions of gcc will be + able to optimize for branch predication, which could yield siginficant + performance gains in frequently executed sections of the code, and the + other reason to use them is for documentation +*/ + +#if !defined(__GNUC__) || (__GNUC__ == 2 && __GNUC_MINOR__ < 96) +#define __builtin_expect(x, expected_value) (x) +#endif + +#define likely(x) __builtin_expect((x),1) +#define unlikely(x) __builtin_expect((x),0) + + +/* Fix problem with S_ISLNK() on Linux */ +#if defined(HAVE_LINUXTHREADS) +#undef _GNU_SOURCE +#define _GNU_SOURCE 1 +#endif + +/* The client defines this to avoid all thread code */ +#if defined(UNDEF_THREADS_HACK) +#undef THREAD +#undef HAVE_mit_thread +#undef HAVE_LINUXTHREADS +#undef HAVE_UNIXWARE7_THREADS +#endif + +#ifdef HAVE_THREADS_WITHOUT_SOCKETS +/* MIT pthreads does not work with unix sockets */ +#undef HAVE_SYS_UN_H +#endif + +#define __EXTENSIONS__ 1 /* We want some extension */ +#ifndef __STDC_EXT__ +#define __STDC_EXT__ 1 /* To get large file support on hpux */ +#endif + +#if defined(THREAD) && !defined(__WIN__) && !defined(OS2) +#ifndef _POSIX_PTHREAD_SEMANTICS +#define _POSIX_PTHREAD_SEMANTICS /* We want posix threads */ +#endif + +#if !defined(SCO) +#define _REENTRANT 1 /* Some thread libraries require this */ +#endif +#if !defined(_THREAD_SAFE) && !defined(_AIX) +#define _THREAD_SAFE /* Required for OSF1 */ +#endif +#ifndef HAVE_mit_thread +#ifdef HAVE_UNIXWARE7_THREADS +#include +#else +#include /* AIX must have this included first */ +#endif /* HAVE_UNIXWARE7_THREADS */ +#endif /* HAVE_mit_thread */ +#if !defined(SCO) && !defined(_REENTRANT) +#define _REENTRANT 1 /* Threads requires reentrant code */ +#endif +#endif /* THREAD */ + +/* Go around some bugs in different OS and compilers */ +#ifdef _AIX /* By soren@t.dk */ +#define _H_STRINGS +#define _SYS_STREAM_H +/* #define _AIX32_CURSES */ /* XXX: this breaks AIX 4.3.3 (others?). */ +#define ulonglong2double(A) my_ulonglong2double(A) +#define my_off_t2double(A) my_ulonglong2double(A) +C_MODE_START +double my_ulonglong2double(unsigned long long A); +C_MODE_END +#endif /* _AIX */ + +#ifdef HAVE_BROKEN_SNPRINTF /* HPUX 10.20 don't have this defined */ +#undef HAVE_SNPRINTF +#endif +#ifdef HAVE_BROKEN_PREAD /* These doesn't work on HPUX 11.x */ +#undef HAVE_PREAD +#undef HAVE_PWRITE +#endif +#if defined(HAVE_BROKEN_INLINE) && !defined(__cplusplus) +#undef inline +#define inline +#endif + +#ifdef UNDEF_HAVE_GETHOSTBYNAME_R /* For OSF4.x */ +#undef HAVE_GETHOSTBYNAME_R +#endif +#ifdef UNDEF_HAVE_INITGROUPS /* For AIX 4.3 */ +#undef HAVE_INITGROUPS +#endif + +/* gcc/egcs issues */ + +#if defined(__GNUC) && defined(__EXCEPTIONS) +#error "Please add -fno-exceptions to CXXFLAGS and reconfigure/recompile" +#endif + + +/* Fix a bug in gcc 2.8.0 on IRIX 6.2 */ +#if SIZEOF_LONG == 4 && defined(__LONG_MAX__) +#undef __LONG_MAX__ /* Is a longlong value in gcc 2.8.0 ??? */ +#define __LONG_MAX__ 2147483647 +#endif + +/* Fix problem when linking c++ programs with gcc 3.x */ +#ifdef DEFINE_CXA_PURE_VIRTUAL +#define FIX_GCC_LINKING_PROBLEM extern "C" { int __cxa_pure_virtual() {return 0;} } +#else +#define FIX_GCC_LINKING_PROBLEM +#endif + +/* egcs 1.1.2 has a problem with memcpy on Alpha */ +#if defined(__GNUC__) && defined(__alpha__) && ! (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)) +#define BAD_MEMCPY +#endif + +/* In Linux-alpha we have atomic.h if we are using gcc */ +#if defined(HAVE_LINUXTHREADS) && defined(__GNUC__) && defined(__alpha__) && (__GNUC__ > 2 || ( __GNUC__ == 2 && __GNUC_MINOR__ >= 95)) && !defined(HAVE_ATOMIC_ADD) +#define HAVE_ATOMIC_ADD +#define HAVE_ATOMIC_SUB +#endif + +/* In Linux-ia64 including atomic.h will give us an error */ +#if (defined(HAVE_LINUXTHREADS) && defined(__GNUC__) && (defined(__ia64__)||defined(__powerpc64__))) || !defined(THREAD) +#undef HAVE_ATOMIC_ADD +#undef HAVE_ATOMIC_SUB +#endif + +#if defined(_lint) && !defined(lint) +#define lint +#endif +#if SIZEOF_LONG_LONG > 4 && !defined(_LONG_LONG) +#define _LONG_LONG 1 /* For AIX string library */ +#endif + +#ifndef stdin +#include +#endif +#ifdef HAVE_STDLIB_H +#include +#endif +#ifdef HAVE_STDDEF_H +#include +#endif + +#include +#ifdef HAVE_LIMITS_H +#include +#endif +#ifdef HAVE_FLOAT_H +#include +#endif + +#ifdef HAVE_SYS_TYPES_H +#include +#endif +#ifdef HAVE_FCNTL_H +#include +#endif +#ifdef HAVE_SYS_TIMEB_H +#include /* Avoid warnings on SCO */ +#endif +#if TIME_WITH_SYS_TIME +# include +# include +#else +# if HAVE_SYS_TIME_H +# include +# else +# include +# endif +#endif /* TIME_WITH_SYS_TIME */ +#ifdef HAVE_UNISTD_H +#if defined(HAVE_OPENSSL) && !defined(__FreeBSD__) && !defined(NeXT) && !defined(__OpenBSD__) +#define crypt unistd_crypt +#endif +#include +#ifdef HAVE_OPENSSL +#undef crypt +#endif +#endif +#if defined(__cplusplus) && defined(NO_CPLUSPLUS_ALLOCA) +#undef HAVE_ALLOCA +#undef HAVE_ALLOCA_H +#endif +#ifdef HAVE_ALLOCA_H +#include +#endif +#ifdef HAVE_ATOMIC_ADD +#define __SMP__ +#ifdef HAVE_LINUX_CONFIG_H +#include /* May define CONFIG_SMP */ +#endif +#ifndef CONFIG_SMP +#define CONFIG_SMP +#endif +C_MODE_START +#include +C_MODE_END +#endif +#include /* Recommended by debian */ +/* We need the following to go around a problem with openssl on solaris */ +#if defined(HAVE_CRYPT_H) +#include +#endif + +/* Go around some bugs in different OS and compilers */ +#if defined(_HPUX_SOURCE) && defined(HAVE_SYS_STREAM_H) +#include /* HPUX 10.20 defines ulong here. UGLY !!! */ +#define HAVE_ULONG +#endif +#ifdef DONT_USE_FINITE /* HPUX 11.x has is_finite() */ +#undef HAVE_FINITE +#endif +#if defined(HPUX10) && defined(_LARGEFILE64_SOURCE) && defined(THREAD) +/* Fix bug in setrlimit */ +#undef setrlimit +#define setrlimit cma_setrlimit64 +#endif + +#ifdef __QNXNTO__ +/* This has to be after include limits.h */ +#define HAVE_ERRNO_AS_DEFINE +#define HAVE_FCNTL_LOCK +#undef HAVE_FINITE +#undef LONGLONG_MIN /* These get wrongly defined in QNX 6.2 */ +#undef LONGLONG_MAX /* standard system library 'limits.h' */ +#endif + +/* We can not live without the following defines */ + +#define USE_MYFUNC 1 /* Must use syscall indirection */ +#define MASTER 1 /* Compile without unireg */ +#define ENGLISH 1 /* Messages in English */ +#define POSIX_MISTAKE 1 /* regexp: Fix stupid spec error */ +#define USE_REGEX 1 /* We want the use the regex library */ +/* Do not define for ultra sparcs */ +#ifndef OS2 +#define USE_BMOVE512 1 /* Use this unless system bmove is faster */ +#endif + +/* Paranoid settings. Define I_AM_PARANOID if you are paranoid */ +#ifdef I_AM_PARANOID +#define DONT_ALLOW_USER_CHANGE 1 +#define DONT_USE_MYSQL_PWD 1 +#endif + +/* Does the system remember a signal handler after a signal ? */ +#ifndef HAVE_BSD_SIGNALS +#define DONT_REMEMBER_SIGNAL +#endif + +/* Define void to stop lint from generating "null effekt" comments */ +#ifndef DONT_DEFINE_VOID +#ifdef _lint +int __void__; +#define VOID(X) (__void__ = (int) (X)) +#else +#undef VOID +#define VOID(X) (X) +#endif +#endif /* DONT_DEFINE_VOID */ + +#if defined(_lint) || defined(FORCE_INIT_OF_VARS) +#define LINT_INIT(var) var=0 /* No uninitialize-warning */ +#else +#define LINT_INIT(var) +#endif + +/* Define some useful general macros */ +#if defined(__cplusplus) && defined(__GNUC__) +#define max(a, b) ((a) >? (b)) +#define min(a, b) ((a) (b) ? (a) : (b)) +#define min(a, b) ((a) < (b) ? (a) : (b)) +#endif + +#if defined(__EMX__) || !defined(HAVE_UINT) +typedef unsigned int uint; +typedef unsigned short ushort; +#endif + +#define CMP_NUM(a,b) (((a) < (b)) ? -1 : ((a) == (b)) ? 0 : 1) +#define sgn(a) (((a) < 0) ? -1 : ((a) > 0) ? 1 : 0) +#define swap(t,a,b) { register t dummy; dummy = a; a = b; b = dummy; } +#define test(a) ((a) ? 1 : 0) +#define set_if_bigger(a,b) { if ((a) < (b)) (a)=(b); } +#define set_if_smaller(a,b) { if ((a) > (b)) (a)=(b); } +#define test_all_bits(a,b) (((a) & (b)) == (b)) +#define set_bits(type, bit_count) (sizeof(type)*8 <= (bit_count) ? ~(type) 0 : ((((type) 1) << (bit_count)) - (type) 1)) +#define array_elements(A) ((uint) (sizeof(A)/sizeof(A[0]))) +#ifndef HAVE_RINT +#define rint(A) floor((A)+(((A) < 0)? -0.5 : 0.5)) +#endif + +/* Define some general constants */ +#ifndef TRUE +#define TRUE (1) /* Logical true */ +#define FALSE (0) /* Logical false */ +#endif + +#if defined(__GNUC__) +#define function_volatile volatile +#define my_reinterpret_cast(A) reinterpret_cast +#define my_const_cast(A) const_cast +#elif !defined(my_reinterpret_cast) +#define my_reinterpret_cast(A) (A) +#define my_const_cast(A) (A) +#endif +#if !defined(__attribute__) && (defined(__cplusplus) || !defined(__GNUC__) || __GNUC__ == 2 && __GNUC_MINOR__ < 8) +#define __attribute__(A) +#endif + +/* From old s-system.h */ + +/* + Support macros for non ansi & other old compilers. Since such + things are no longer supported we do nothing. We keep then since + some of our code may still be needed to upgrade old customers. +*/ +#define _VARARGS(X) X +#define _STATIC_VARARGS(X) X +#define _PC(X) X + +#if defined(DBUG_ON) && defined(DBUG_OFF) +#undef DBUG_OFF +#endif + +#if defined(_lint) && !defined(DBUG_OFF) +#define DBUG_OFF +#endif + +#include + +#define MIN_ARRAY_SIZE 0 /* Zero or One. Gcc allows zero*/ +#define ASCII_BITS_USED 8 /* Bit char used */ +#define NEAR_F /* No near function handling */ + +/* Some types that is different between systems */ + +typedef int File; /* File descriptor */ +#ifndef Socket_defined +typedef int my_socket; /* File descriptor for sockets */ +#define INVALID_SOCKET -1 +#endif +/* Type for fuctions that handles signals */ +#define sig_handler RETSIGTYPE +C_MODE_START +typedef void (*sig_return)();/* Returns type from signal */ +C_MODE_END +#if defined(__GNUC__) && !defined(_lint) +typedef char pchar; /* Mixed prototypes can take char */ +typedef char puchar; /* Mixed prototypes can take char */ +typedef char pbool; /* Mixed prototypes can take char */ +typedef short pshort; /* Mixed prototypes can take short int */ +typedef float pfloat; /* Mixed prototypes can take float */ +#else +typedef int pchar; /* Mixed prototypes can't take char */ +typedef uint puchar; /* Mixed prototypes can't take char */ +typedef int pbool; /* Mixed prototypes can't take char */ +typedef int pshort; /* Mixed prototypes can't take short int */ +typedef double pfloat; /* Mixed prototypes can't take float */ +#endif +C_MODE_START +typedef int (*qsort_cmp)(const void *,const void *); +typedef int (*qsort_cmp2)(void*, const void *,const void *); +C_MODE_END +#ifdef HAVE_mit_thread +#define qsort_t void +#undef QSORT_TYPE_IS_VOID +#define QSORT_TYPE_IS_VOID +#else +#define qsort_t RETQSORTTYPE /* Broken GCC cant handle typedef !!!! */ +#endif +#ifdef HAVE_mit_thread +#define size_socket socklen_t /* Type of last arg to accept */ +#else +#ifdef HAVE_SYS_SOCKET_H +#include +#endif +typedef SOCKET_SIZE_TYPE size_socket; +#endif + +#ifndef SOCKOPT_OPTLEN_TYPE +#define SOCKOPT_OPTLEN_TYPE size_socket +#endif + +/* file create flags */ + +#ifndef O_SHARE /* Probably not windows */ +#define O_SHARE 0 /* Flag to my_open for shared files */ +#ifndef O_BINARY +#define O_BINARY 0 /* Flag to my_open for binary files */ +#endif +#ifndef FILE_BINARY +#define FILE_BINARY O_BINARY /* Flag to my_fopen for binary streams */ +#endif +#ifdef HAVE_FCNTL +#define HAVE_FCNTL_LOCK +#define F_TO_EOF 0L /* Param to lockf() to lock rest of file */ +#endif +#endif /* O_SHARE */ + +#ifndef O_TEMPORARY +#define O_TEMPORARY 0 +#endif +#ifndef O_SHORT_LIVED +#define O_SHORT_LIVED 0 +#endif + +/* #define USE_RECORD_LOCK */ + + /* Unsigned types supported by the compiler */ +#define UNSINT8 /* unsigned int8 (char) */ +#define UNSINT16 /* unsigned int16 */ +#define UNSINT32 /* unsigned int32 */ + + /* General constants */ +#define SC_MAXWIDTH 256 /* Max width of screen (for error messages) */ +#define FN_LEN 256 /* Max file name len */ +#define FN_HEADLEN 253 /* Max length of filepart of file name */ +#define FN_EXTLEN 20 /* Max length of extension (part of FN_LEN) */ +#define FN_REFLEN 512 /* Max length of full path-name */ +#define FN_EXTCHAR '.' +#define FN_HOMELIB '~' /* ~/ is used as abbrev for home dir */ +#define FN_CURLIB '.' /* ./ is used as abbrev for current dir */ +#define FN_PARENTDIR ".." /* Parentdirectory; Must be a string */ +#define FN_DEVCHAR ':' + +#ifndef FN_LIBCHAR +#ifdef __EMX__ +#define FN_LIBCHAR '\\' +#define FN_ROOTDIR "\\" +#else +#define FN_LIBCHAR '/' +#define FN_ROOTDIR "/" +#endif +#define MY_NFILE 1024 /* This is only used to save filenames */ +#endif + +/* #define EXT_IN_LIBNAME */ +/* #define FN_NO_CASE_SENCE */ +/* #define FN_UPPER_CASE TRUE */ + +/* + Io buffer size; Must be a power of 2 and a multiple of 512. May be + smaller what the disk page size. This influences the speed of the + isam btree library. eg to big to slow. +*/ +#define IO_SIZE 4096 +/* + How much overhead does malloc have. The code often allocates + something like 1024-MALLOC_OVERHEAD bytes +*/ +#ifdef SAFEMALLOC +#define MALLOC_OVERHEAD (8+24+4) +#else +#define MALLOC_OVERHEAD 8 +#endif + /* get memory in huncs */ +#define ONCE_ALLOC_INIT (uint) (4096-MALLOC_OVERHEAD) + /* Typical record cash */ +#define RECORD_CACHE_SIZE (uint) (64*1024-MALLOC_OVERHEAD) + /* Typical key cash */ +#define KEY_CACHE_SIZE (uint) (8*1024*1024-MALLOC_OVERHEAD) + + /* Some things that this system doesn't have */ + +#define NO_HASH /* Not needed anymore */ +#ifdef __WIN__ +#define NO_DIR_LIBRARY /* Not standar dir-library */ +#define USE_MY_STAT_STRUCT /* For my_lib */ +#endif + +/* Some things that this system does have */ + +#ifndef HAVE_ITOA +#define USE_MY_ITOA /* There is no itoa */ +#endif + +/* Some defines of functions for portability */ + +#ifndef HAVE_ATOD +#define atod atof +#endif +#ifdef USE_MY_ATOF +#define atof my_atof +extern void init_my_atof(void); +extern double my_atof(const char*); +#endif +#undef remove /* Crashes MySQL on SCO 5.0.0 */ +#ifndef __WIN__ +#ifdef OS2 +#define closesocket(A) soclose(A) +#else +#define closesocket(A) close(A) +#endif +#ifndef ulonglong2double +#define ulonglong2double(A) ((double) (ulonglong) (A)) +#define my_off_t2double(A) ((double) (my_off_t) (A)) +#endif +#endif + +#ifndef offsetof +#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER) +#endif +#define ulong_to_double(X) ((double) (ulong) (X)) +#define SET_STACK_SIZE(X) /* Not needed on real machines */ + +#if !defined(HAVE_mit_thread) && !defined(HAVE_STRTOK_R) +#define strtok_r(A,B,C) strtok((A),(B)) +#endif + +/* Remove some things that mit_thread break or doesn't support */ +#if defined(HAVE_mit_thread) && defined(THREAD) +#undef HAVE_PREAD +#undef HAVE_REALPATH +#undef HAVE_MLOCK +#undef HAVE_TEMPNAM /* Use ours */ +#undef HAVE_PTHREAD_SETPRIO +#undef HAVE_FTRUNCATE +#undef HAVE_READLINK +#endif + +/* This is from the old m-machine.h file */ + +#if SIZEOF_LONG_LONG > 4 +#define HAVE_LONG_LONG 1 +#endif + +/* + Some pre-ANSI-C99 systems like AIX 5.1 and Linux/GCC 2.95 define + ULONGLONG_MAX, LONGLONG_MIN, LONGLONG_MAX; we use them if they're defined. + Also on Windows we define these constants by hand in config-win.h. +*/ + +#if defined(HAVE_LONG_LONG) && !defined(LONGLONG_MIN) +#define LONGLONG_MIN ((long long) 0x8000000000000000LL) +#define LONGLONG_MAX ((long long) 0x7FFFFFFFFFFFFFFFLL) +#endif + +#if defined(HAVE_LONG_LONG) && !defined(ULONGLONG_MAX) +/* First check for ANSI C99 definition: */ +#ifdef ULLONG_MAX +#define ULONGLONG_MAX ULLONG_MAX +#else +#define ULONGLONG_MAX ((unsigned long long)(~0ULL)) +#endif +#endif /* defined (HAVE_LONG_LONG) && !defined(ULONGLONG_MAX)*/ + +#if SIZEOF_LONG == 4 +#define INT_MIN32 (long) 0x80000000L +#define INT_MAX32 (long) 0x7FFFFFFFL +#define INT_MIN24 ((long) 0xff800000L) +#define INT_MAX24 0x007fffffL +#define INT_MIN16 ((short int) 0x8000) +#define INT_MAX16 0x7FFF +#define INT_MIN8 ((char) 0x80) +#define INT_MAX8 ((char) 0x7F) +#else /* Probably Alpha */ +#define INT_MIN32 ((long) (int) 0x80000000) +#define INT_MAX32 ((long) (int) 0x7FFFFFFF) +#define INT_MIN24 ((long) (int) 0xff800000) +#define INT_MAX24 ((long) (int) 0x007fffff) +#define INT_MIN16 ((short int) 0xffff8000) +#define INT_MAX16 ((short int) 0x00007FFF) +#endif + +/* From limits.h instead */ +#ifndef DBL_MIN +#define DBL_MIN 4.94065645841246544e-324 +#define FLT_MIN ((float)1.40129846432481707e-45) +#endif +#ifndef DBL_MAX +#define DBL_MAX 1.79769313486231470e+308 +#define FLT_MAX ((float)3.40282346638528860e+38) +#endif + +/* + Max size that must be added to a so that we know Size to make + adressable obj. +*/ +#if SIZEOF_CHARP == 4 +typedef long my_ptrdiff_t; +#else +typedef long long my_ptrdiff_t; +#endif + +#define MY_ALIGN(A,L) (((A) + (L) - 1) & ~((L) - 1)) +#define ALIGN_SIZE(A) MY_ALIGN((A),sizeof(double)) +/* Size to make adressable obj. */ +#define ALIGN_PTR(A, t) ((t*) MY_ALIGN((A),sizeof(t))) + /* Offset of filed f in structure t */ +#define OFFSET(t, f) ((size_t)(char *)&((t *)0)->f) +#define ADD_TO_PTR(ptr,size,type) (type) ((byte*) (ptr)+size) +#define PTR_BYTE_DIFF(A,B) (my_ptrdiff_t) ((byte*) (A) - (byte*) (B)) + +#define NullS (char *) 0 +/* Nowdays we do not support MessyDos */ +#ifndef NEAR +#define NEAR /* Who needs segments ? */ +#define FAR /* On a good machine */ +#ifndef HUGE_PTR +#define HUGE_PTR +#endif +#endif +#if defined(__IBMC__) || defined(__IBMCPP__) +#define STDCALL _System _Export +#elif !defined( STDCALL) +#define STDCALL +#endif + +/* Typdefs for easyier portability */ + +#if defined(VOIDTYPE) +typedef void *gptr; /* Generic pointer */ +#else +typedef char *gptr; /* Generic pointer */ +#endif +#ifndef HAVE_INT_8_16_32 +typedef char int8; /* Signed integer >= 8 bits */ +typedef short int16; /* Signed integer >= 16 bits */ +#endif +#ifndef HAVE_UCHAR +typedef unsigned char uchar; /* Short for unsigned char */ +#endif +typedef unsigned char uint8; /* Short for unsigned integer >= 8 bits */ +typedef unsigned short uint16; /* Short for unsigned integer >= 16 bits */ + +#if SIZEOF_INT == 4 +#ifndef HAVE_INT_8_16_32 +typedef int int32; +#endif +typedef unsigned int uint32; /* Short for unsigned integer >= 32 bits */ +#elif SIZEOF_LONG == 4 +#ifndef HAVE_INT_8_16_32 +typedef long int32; +#endif +typedef unsigned long uint32; /* Short for unsigned integer >= 32 bits */ +#else +error "Neither int or long is of 4 bytes width" +#endif + +#if !defined(HAVE_ULONG) && !defined(HAVE_LINUXTHREADS) && !defined(__USE_MISC) +typedef unsigned long ulong; /* Short for unsigned long */ +#endif +#ifndef longlong_defined +#if defined(HAVE_LONG_LONG) && SIZEOF_LONG != 8 +typedef unsigned long long int ulonglong; /* ulong or unsigned long long */ +typedef long long int longlong; +#else +typedef unsigned long ulonglong; /* ulong or unsigned long long */ +typedef long longlong; +#endif +#endif + +/* typedef used for length of string; Should be unsigned! */ +typedef ulong size_str; + +#ifdef USE_RAID +/* + The following is done with a if to not get problems with pre-processors + with late define evaluation +*/ +#if SIZEOF_OFF_T == 4 +#define SYSTEM_SIZEOF_OFF_T 4 +#else +#define SYSTEM_SIZEOF_OFF_T 8 +#endif +#undef SIZEOF_OFF_T +#define SIZEOF_OFF_T 8 +#else +#define SYSTEM_SIZEOF_OFF_T SIZEOF_OFF_T +#endif /* USE_RAID */ + +#if SIZEOF_OFF_T > 4 +typedef ulonglong my_off_t; +#else +typedef unsigned long my_off_t; +#endif +#define MY_FILEPOS_ERROR (~(my_off_t) 0) +#if !defined(__WIN__) && !defined(OS2) +typedef off_t os_off_t; +#endif + +#if defined(__WIN__) +#define socket_errno WSAGetLastError() +#define SOCKET_EINTR WSAEINTR +#define SOCKET_EAGAIN WSAEINPROGRESS +#define SOCKET_EWOULDBLOCK WSAEINPROGRESS +#define SOCKET_ENFILE ENFILE +#define SOCKET_EMFILE EMFILE +#elif defined(OS2) +#define socket_errno sock_errno() +#define SOCKET_EINTR SOCEINTR +#define SOCKET_EAGAIN SOCEINPROGRESS +#define SOCKET_EWOULDBLOCK SOCEWOULDBLOCK +#define SOCKET_ENFILE SOCENFILE +#define SOCKET_EMFILE SOCEMFILE +#define closesocket(A) soclose(A) +#else /* Unix */ +#define socket_errno errno +#define closesocket(A) close(A) +#define SOCKET_EINTR EINTR +#define SOCKET_EAGAIN EAGAIN +#define SOCKET_EWOULDBLOCK EWOULDBLOCK +#define SOCKET_ENFILE ENFILE +#define SOCKET_EMFILE EMFILE +#endif + +typedef uint8 int7; /* Most effective integer 0 <= x <= 127 */ +typedef short int15; /* Most effective integer 0 <= x <= 32767 */ +typedef char *my_string; /* String of characters */ +typedef unsigned long size_s; /* Size of strings (In string-funcs) */ +typedef int myf; /* Type of MyFlags in my_funcs */ +#ifndef byte_defined +typedef char byte; /* Smallest addressable unit */ +#endif +typedef char my_bool; /* Small bool */ +#if !defined(bool) && !defined(bool_defined) && (!defined(HAVE_BOOL) || !defined(__cplusplus)) +typedef char bool; /* Ordinary boolean values 0 1 */ +#endif + /* Macros for converting *constants* to the right type */ +#define INT8(v) (int8) (v) +#define INT16(v) (int16) (v) +#define INT32(v) (int32) (v) +#define MYF(v) (myf) (v) + +#ifndef LL +#ifdef HAVE_LONG_LONG +#define LL(A) A ## LL +#else +#define LL(A) A ## L +#endif +#endif + +/* + Defines to make it possible to prioritize register assignments. No + longer that important with modern compilers. +*/ +#ifndef USING_X +#define reg1 register +#define reg2 register +#define reg3 register +#define reg4 register +#define reg5 register +#define reg6 register +#define reg7 register +#define reg8 register +#define reg9 register +#define reg10 register +#define reg11 register +#define reg12 register +#define reg13 register +#define reg14 register +#define reg15 register +#define reg16 register +#endif + +/* + Sometimes we want to make sure that the variable is not put into + a register in debugging mode so we can see its value in the core +*/ + +#ifndef DBUG_OFF +#define dbug_volatile volatile +#else +#define dbug_volatile +#endif + +/* Defines for time function */ +#define SCALE_SEC 100 +#define SCALE_USEC 10000 +#define MY_HOW_OFTEN_TO_ALARM 2 /* How often we want info on screen */ +#define MY_HOW_OFTEN_TO_WRITE 1000 /* How often we want info on screen */ + +#ifndef set_timespec +#ifdef HAVE_TIMESPEC_TS_SEC +#define set_timespec(ABSTIME,SEC) { (ABSTIME).ts_sec=time(0) + (time_t) (SEC); (ABSTIME).ts_nsec=0; } +#else +#define set_timespec(ABSTIME,SEC) \ +{\ + struct timeval tv;\ + gettimeofday(&tv,0);\ + (ABSTIME).tv_sec=tv.tv_sec+(time_t) (SEC);\ + (ABSTIME).tv_nsec=tv.tv_usec*1000;\ +} +#endif /* HAVE_TIMESPEC_TS_SEC */ +#endif /* set_timespec */ + +/* + Define-funktions for reading and storing in machine independent format + (low byte first) +*/ + +/* Optimized store functions for Intel x86 */ +#if defined(__i386__) && !defined(_WIN64) +#define sint2korr(A) (*((int16 *) (A))) +#define sint3korr(A) ((int32) ((((uchar) (A)[2]) & 128) ? \ + (((uint32) 255L << 24) | \ + (((uint32) (uchar) (A)[2]) << 16) |\ + (((uint32) (uchar) (A)[1]) << 8) | \ + ((uint32) (uchar) (A)[0])) : \ + (((uint32) (uchar) (A)[2]) << 16) |\ + (((uint32) (uchar) (A)[1]) << 8) | \ + ((uint32) (uchar) (A)[0]))) +#define sint4korr(A) (*((long *) (A))) +#define uint2korr(A) (*((uint16 *) (A))) +#ifdef HAVE_purify +#define uint3korr(A) (uint32) (((uint32) ((uchar) (A)[0])) +\ + (((uint32) ((uchar) (A)[1])) << 8) +\ + (((uint32) ((uchar) (A)[2])) << 16)) +#else +#define uint3korr(A) (long) (*((unsigned long *) (A)) & 0xFFFFFF) +#endif +#define uint4korr(A) (*((unsigned long *) (A))) +#define uint5korr(A) ((ulonglong)(((uint32) ((uchar) (A)[0])) +\ + (((uint32) ((uchar) (A)[1])) << 8) +\ + (((uint32) ((uchar) (A)[2])) << 16) +\ + (((uint32) ((uchar) (A)[3])) << 24)) +\ + (((ulonglong) ((uchar) (A)[4])) << 32)) +#define uint8korr(A) (*((ulonglong *) (A))) +#define sint8korr(A) (*((longlong *) (A))) +#define int2store(T,A) *((uint16*) (T))= (uint16) (A) +#define int3store(T,A) { *(T)= (uchar) ((A));\ + *(T+1)=(uchar) (((uint) (A) >> 8));\ + *(T+2)=(uchar) (((A) >> 16)); } +#define int4store(T,A) *((long *) (T))= (long) (A) +#define int5store(T,A) { *(T)= (uchar)((A));\ + *((T)+1)=(uchar) (((A) >> 8));\ + *((T)+2)=(uchar) (((A) >> 16));\ + *((T)+3)=(uchar) (((A) >> 24)); \ + *((T)+4)=(uchar) (((A) >> 32)); } +#define int8store(T,A) *((ulonglong *) (T))= (ulonglong) (A) + +typedef union { + double v; + long m[2]; +} doubleget_union; +#define doubleget(V,M) \ +{ doubleget_union _tmp; \ + _tmp.m[0] = *((long*)(M)); \ + _tmp.m[1] = *(((long*) (M))+1); \ + (V) = _tmp.v; } +#define doublestore(T,V) { *((long *) T) = ((doubleget_union *)&V)->m[0]; \ + *(((long *) T)+1) = ((doubleget_union *)&V)->m[1]; } +#define float4get(V,M) { *((long *) &(V)) = *((long*) (M)); } +#define float8get(V,M) doubleget((V),(M)) +#define float4store(V,M) memcpy((byte*) V,(byte*) (&M),sizeof(float)) +#define float8store(V,M) doublestore((V),(M)) +#endif /* __i386__ */ + +#ifndef sint2korr +#define sint2korr(A) (int16) (((int16) ((uchar) (A)[0])) +\ + ((int16) ((int16) (A)[1]) << 8)) +#define sint3korr(A) ((int32) ((((uchar) (A)[2]) & 128) ? \ + (((uint32) 255L << 24) | \ + (((uint32) (uchar) (A)[2]) << 16) |\ + (((uint32) (uchar) (A)[1]) << 8) | \ + ((uint32) (uchar) (A)[0])) : \ + (((uint32) (uchar) (A)[2]) << 16) |\ + (((uint32) (uchar) (A)[1]) << 8) | \ + ((uint32) (uchar) (A)[0]))) +#define sint4korr(A) (int32) (((int32) ((uchar) (A)[0])) +\ + (((int32) ((uchar) (A)[1]) << 8)) +\ + (((int32) ((uchar) (A)[2]) << 16)) +\ + (((int32) ((int16) (A)[3]) << 24))) +#define sint8korr(A) (longlong) uint8korr(A) +#define uint2korr(A) (uint16) (((uint16) ((uchar) (A)[0])) +\ + ((uint16) ((uchar) (A)[1]) << 8)) +#define uint3korr(A) (uint32) (((uint32) ((uchar) (A)[0])) +\ + (((uint32) ((uchar) (A)[1])) << 8) +\ + (((uint32) ((uchar) (A)[2])) << 16)) +#define uint4korr(A) (uint32) (((uint32) ((uchar) (A)[0])) +\ + (((uint32) ((uchar) (A)[1])) << 8) +\ + (((uint32) ((uchar) (A)[2])) << 16) +\ + (((uint32) ((uchar) (A)[3])) << 24)) +#define uint5korr(A) ((ulonglong)(((uint32) ((uchar) (A)[0])) +\ + (((uint32) ((uchar) (A)[1])) << 8) +\ + (((uint32) ((uchar) (A)[2])) << 16) +\ + (((uint32) ((uchar) (A)[3])) << 24)) +\ + (((ulonglong) ((uchar) (A)[4])) << 32)) +#define uint8korr(A) ((ulonglong)(((uint32) ((uchar) (A)[0])) +\ + (((uint32) ((uchar) (A)[1])) << 8) +\ + (((uint32) ((uchar) (A)[2])) << 16) +\ + (((uint32) ((uchar) (A)[3])) << 24)) +\ + (((ulonglong) (((uint32) ((uchar) (A)[4])) +\ + (((uint32) ((uchar) (A)[5])) << 8) +\ + (((uint32) ((uchar) (A)[6])) << 16) +\ + (((uint32) ((uchar) (A)[7])) << 24))) <<\ + 32)) +#define int2store(T,A) { uint def_temp= (uint) (A) ;\ + *((uchar*) (T))= (uchar)(def_temp); \ + *((uchar*) (T+1))=(uchar)((def_temp >> 8)); } +#define int3store(T,A) { /*lint -save -e734 */\ + *((uchar*)(T))=(uchar) ((A));\ + *((uchar*) (T)+1)=(uchar) (((A) >> 8));\ + *((uchar*)(T)+2)=(uchar) (((A) >> 16)); \ + /*lint -restore */} +#define int4store(T,A) { *(T)=(char) ((A));\ + *((T)+1)=(char) (((A) >> 8));\ + *((T)+2)=(char) (((A) >> 16));\ + *((T)+3)=(char) (((A) >> 24)); } +#define int5store(T,A) { *(T)=((A));\ + *((T)+1)=(((A) >> 8));\ + *((T)+2)=(((A) >> 16));\ + *((T)+3)=(((A) >> 24)); \ + *((T)+4)=(((A) >> 32)); } +#define int8store(T,A) { uint def_temp= (uint) (A), def_temp2= (uint) ((A) >> 32); \ + int4store((T),def_temp); \ + int4store((T+4),def_temp2); \ + } +#ifdef WORDS_BIGENDIAN +#define float4store(T,A) { *(T)= ((byte *) &A)[3];\ + *((T)+1)=(char) ((byte *) &A)[2];\ + *((T)+2)=(char) ((byte *) &A)[1];\ + *((T)+3)=(char) ((byte *) &A)[0]; } + +#define float4get(V,M) { float def_temp;\ + ((byte*) &def_temp)[0]=(M)[3];\ + ((byte*) &def_temp)[1]=(M)[2];\ + ((byte*) &def_temp)[2]=(M)[1];\ + ((byte*) &def_temp)[3]=(M)[0];\ + (V)=def_temp; } +#define float8store(T,V) { *(T)= ((byte *) &V)[7];\ + *((T)+1)=(char) ((byte *) &V)[6];\ + *((T)+2)=(char) ((byte *) &V)[5];\ + *((T)+3)=(char) ((byte *) &V)[4];\ + *((T)+4)=(char) ((byte *) &V)[3];\ + *((T)+5)=(char) ((byte *) &V)[2];\ + *((T)+6)=(char) ((byte *) &V)[1];\ + *((T)+7)=(char) ((byte *) &V)[0]; } + +#define float8get(V,M) { double def_temp;\ + ((byte*) &def_temp)[0]=(M)[7];\ + ((byte*) &def_temp)[1]=(M)[6];\ + ((byte*) &def_temp)[2]=(M)[5];\ + ((byte*) &def_temp)[3]=(M)[4];\ + ((byte*) &def_temp)[4]=(M)[3];\ + ((byte*) &def_temp)[5]=(M)[2];\ + ((byte*) &def_temp)[6]=(M)[1];\ + ((byte*) &def_temp)[7]=(M)[0];\ + (V) = def_temp; } +#else +#define float4get(V,M) memcpy_fixed((byte*) &V,(byte*) (M),sizeof(float)) +#define float4store(V,M) memcpy_fixed((byte*) V,(byte*) (&M),sizeof(float)) + +#if defined(__FLOAT_WORD_ORDER) && (__FLOAT_WORD_ORDER == __BIG_ENDIAN) +#define doublestore(T,V) { *(T)= ((byte *) &V)[4];\ + *((T)+1)=(char) ((byte *) &V)[5];\ + *((T)+2)=(char) ((byte *) &V)[6];\ + *((T)+3)=(char) ((byte *) &V)[7];\ + *((T)+4)=(char) ((byte *) &V)[0];\ + *((T)+5)=(char) ((byte *) &V)[1];\ + *((T)+6)=(char) ((byte *) &V)[2];\ + *((T)+7)=(char) ((byte *) &V)[3]; } +#define doubleget(V,M) { double def_temp;\ + ((byte*) &def_temp)[0]=(M)[4];\ + ((byte*) &def_temp)[1]=(M)[5];\ + ((byte*) &def_temp)[2]=(M)[6];\ + ((byte*) &def_temp)[3]=(M)[7];\ + ((byte*) &def_temp)[4]=(M)[0];\ + ((byte*) &def_temp)[5]=(M)[1];\ + ((byte*) &def_temp)[6]=(M)[2];\ + ((byte*) &def_temp)[7]=(M)[3];\ + (V) = def_temp; } +#endif /* __FLOAT_WORD_ORDER */ + +#define float8get(V,M) doubleget((V),(M)) +#define float8store(V,M) doublestore((V),(M)) +#endif /* WORDS_BIGENDIAN */ + +#endif /* sint2korr */ + +/* + Define-funktions for reading and storing in machine format from/to + short/long to/from some place in memory V should be a (not + register) variable, M is a pointer to byte +*/ + +#ifdef WORDS_BIGENDIAN + +#define ushortget(V,M) { V = (uint16) (((uint16) ((uchar) (M)[1]))+\ + ((uint16) ((uint16) (M)[0]) << 8)); } +#define shortget(V,M) { V = (short) (((short) ((uchar) (M)[1]))+\ + ((short) ((short) (M)[0]) << 8)); } +#define longget(V,M) { int32 def_temp;\ + ((byte*) &def_temp)[0]=(M)[0];\ + ((byte*) &def_temp)[1]=(M)[1];\ + ((byte*) &def_temp)[2]=(M)[2];\ + ((byte*) &def_temp)[3]=(M)[3];\ + (V)=def_temp; } +#define ulongget(V,M) { uint32 def_temp;\ + ((byte*) &def_temp)[0]=(M)[0];\ + ((byte*) &def_temp)[1]=(M)[1];\ + ((byte*) &def_temp)[2]=(M)[2];\ + ((byte*) &def_temp)[3]=(M)[3];\ + (V)=def_temp; } +#define shortstore(T,A) { uint def_temp=(uint) (A) ;\ + *(T+1)=(char)(def_temp); \ + *(T+0)=(char)(def_temp >> 8); } +#define longstore(T,A) { *((T)+3)=((A));\ + *((T)+2)=(((A) >> 8));\ + *((T)+1)=(((A) >> 16));\ + *((T)+0)=(((A) >> 24)); } + +#define doubleget(V,M) memcpy((byte*) &V,(byte*) (M),sizeof(double)) +#define doublestore(T,V) memcpy((byte*) (T),(byte*) &V,sizeof(double)) +#define longlongget(V,M) memcpy((byte*) &V,(byte*) (M),sizeof(ulonglong)) +#define longlongstore(T,V) memcpy((byte*) (T),(byte*) &V,sizeof(ulonglong)) + +#else + +#define ushortget(V,M) { V = uint2korr(M); } +#define shortget(V,M) { V = sint2korr(M); } +#define longget(V,M) { V = sint4korr(M); } +#define ulongget(V,M) { V = uint4korr(M); } +#define shortstore(T,V) int2store(T,V) +#define longstore(T,V) int4store(T,V) +#ifndef doubleget +#define doubleget(V,M) memcpy_fixed((byte*) &V,(byte*) (M),sizeof(double)) +#define doublestore(T,V) memcpy_fixed((byte*) (T),(byte*) &V,sizeof(double)) +#endif /* doubleget */ +#define longlongget(V,M) memcpy_fixed((byte*) &V,(byte*) (M),sizeof(ulonglong)) +#define longlongstore(T,V) memcpy_fixed((byte*) (T),(byte*) &V,sizeof(ulonglong)) + +#endif /* WORDS_BIGENDIAN */ + +/* sprintf does not always return the number of bytes :- */ +#ifdef SPRINTF_RETURNS_INT +#define my_sprintf(buff,args) sprintf args +#else +#ifdef SPRINTF_RETURNS_PTR +#define my_sprintf(buff,args) ((int)(sprintf args - buff)) +#else +#define my_sprintf(buff,args) ((ulong) sprintf args, (ulong) strlen(buff)) +#endif +#endif + +#ifndef THREAD +#define thread_safe_increment(V,L) (V)++ +#define thread_safe_add(V,C,L) (V)+=(C) +#define thread_safe_sub(V,C,L) (V)-=(C) +#define statistic_increment(V,L) (V)++ +#define statistic_add(V,C,L) (V)+=(C) +#endif + +#ifdef HAVE_OPENSSL +#include +#if OPENSSL_VERSION_NUMBER < 0x0090700f +#define DES_cblock des_cblock +#define DES_key_schedule des_key_schedule +#define DES_set_key_unchecked(k,ks) des_set_key_unchecked((k),*(ks)) +#define DES_ede3_cbc_encrypt(i,o,l,k1,k2,k3,iv,e) des_ede3_cbc_encrypt((i),(o),(l),*(k1),*(k2),*(k3),(iv),(e)) +#endif +#endif + +#endif /* my_global_h */ diff --git a/dlls/csx_sql/extra/include/mysql/my_list.h b/dlls/csx_sql/extra/include/mysql/my_list.h new file mode 100755 index 00000000..0f56d4c5 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/my_list.h @@ -0,0 +1,46 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef _list_h_ +#define _list_h_ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct st_list { + struct st_list *prev,*next; + void *data; +} LIST; + +typedef int (*list_walk_action)(void *,void *); + +extern LIST *list_add(LIST *root,LIST *element); +extern LIST *list_delete(LIST *root,LIST *element); +extern LIST *list_cons(void *data,LIST *root); +extern LIST *list_reverse(LIST *root); +extern void list_free(LIST *root,pbool free_data); +extern uint list_length(LIST *list); +extern int list_walk(LIST *list,list_walk_action action,gptr argument); + +#define rest(a) ((a)->next) +#define list_push(a,b) (a)=list_cons((b),(a)) +#define list_pop(A) {LIST *old=(A); (A)=list_delete(old,old) ; my_free((gptr) old,MYF(MY_FAE)); } + +#ifdef __cplusplus +} +#endif +#endif diff --git a/dlls/csx_sql/extra/include/mysql/my_net.h b/dlls/csx_sql/extra/include/mysql/my_net.h new file mode 100755 index 00000000..7b42afa1 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/my_net.h @@ -0,0 +1,122 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* + thread safe version of some common functions: + my_inet_ntoa + + This file is also used to make handling of sockets and ioctl() + portable accross systems. + +*/ + +#ifndef _my_net_h +#define _my_net_h +C_MODE_START + +#include +#ifdef HAVE_SYS_SOCKET_H +#include +#endif +#ifdef HAVE_NETINET_IN_H +#include +#endif +#ifdef HAVE_ARPA_INET_H +#include +#endif +#ifdef HAVE_POLL +#include +#endif +#ifdef HAVE_SYS_IOCTL_H +#include +#endif + +#if !defined(MSDOS) && !defined(__WIN__) && !defined(HAVE_BROKEN_NETINET_INCLUDES) && !defined(__BEOS__) && !defined(__NETWARE__) +#include +#include +#include +#if !defined(alpha_linux_port) +#include +#endif +#endif + +#if defined(__EMX__) +#include +#define ioctlsocket(A,B,C) ioctl((A),(B),(void *)(C),sizeof(*(C))) +#undef HAVE_FCNTL +#endif /* defined(__EMX__) */ + +#if defined(MSDOS) || defined(__WIN__) +#define O_NONBLOCK 1 /* For emulation of fcntl() */ +#endif + +/* + On OSes which don't have the in_addr_t, we guess that using uint32 is the best + possible choice. We guess this from the fact that on HP-UX64bit & FreeBSD64bit + & Solaris64bit, in_addr_t is equivalent to uint32. And on Linux32bit too. +*/ +#ifndef HAVE_IN_ADDR_T +#define in_addr_t uint32 +#endif + +/* Thread safe or portable version of some functions */ + +void my_inet_ntoa(struct in_addr in, char *buf); + +/* + Handling of gethostbyname_r() +*/ + +#if !defined(HPUX10) +struct hostent; +#endif /* HPUX */ +#if !defined(HAVE_GETHOSTBYNAME_R) +struct hostent *my_gethostbyname_r(const char *name, + struct hostent *result, char *buffer, + int buflen, int *h_errnop); +void my_gethostbyname_r_free(); +#elif defined(HAVE_PTHREAD_ATTR_CREATE) || defined(_AIX) || defined(HAVE_GETHOSTBYNAME_R_GLIBC2_STYLE) +struct hostent *my_gethostbyname_r(const char *name, + struct hostent *result, char *buffer, + int buflen, int *h_errnop); +#define my_gethostbyname_r_free() +#if !defined(HAVE_GETHOSTBYNAME_R_GLIBC2_STYLE) && !defined(HPUX10) +#define GETHOSTBYNAME_BUFF_SIZE sizeof(struct hostent_data) +#endif /* !defined(HAVE_GETHOSTBYNAME_R_GLIBC2_STYLE) */ + +#elif defined(HAVE_GETHOSTBYNAME_R_RETURN_INT) +#define GETHOSTBYNAME_BUFF_SIZE sizeof(struct hostent_data) +struct hostent *my_gethostbyname_r(const char *name, + struct hostent *result, char *buffer, + int buflen, int *h_errnop); +#define my_gethostbyname_r_free() +#else +#define my_gethostbyname_r(A,B,C,D,E) gethostbyname_r((A),(B),(C),(D),(E)) +#define my_gethostbyname_r_free() +#endif /* !defined(HAVE_GETHOSTBYNAME_R) */ + +#ifndef GETHOSTBYNAME_BUFF_SIZE +#define GETHOSTBYNAME_BUFF_SIZE 2048 +#endif + +/* On SCO you get a link error when refering to h_errno */ +#ifdef SCO +#undef h_errno +#define h_errno errno +#endif + +C_MODE_END +#endif diff --git a/dlls/csx_sql/extra/include/mysql/my_no_pthread.h b/dlls/csx_sql/extra/include/mysql/my_no_pthread.h new file mode 100755 index 00000000..0a034f78 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/my_no_pthread.h @@ -0,0 +1,31 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* + This undefs some pthread mutex locks when one isn't using threads + to make thread safe code, that should also work in single thread + environment, easier to use. +*/ + +#if !defined(_my_no_pthread_h) && !defined(THREAD) +#define _my_no_pthread_h + +#define pthread_mutex_init(A,B) +#define pthread_mutex_lock(A) +#define pthread_mutex_unlock(A) +#define pthread_mutex_destroy(A) + +#endif diff --git a/dlls/csx_sql/extra/include/mysql/my_nosys.h b/dlls/csx_sql/extra/include/mysql/my_nosys.h new file mode 100755 index 00000000..605906f0 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/my_nosys.h @@ -0,0 +1,55 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* + Header to remove use of my_functions in functions where we need speed and + where calls to posix functions should work +*/ +#ifndef _my_nosys_h +#define _my_nosys_h +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef __MY_NOSYS__ +#define __MY_NOSYS__ + +#ifdef MSDOS +#include /* Get prototypes for read()... */ +#endif +#ifndef HAVE_STDLIB_H +#include +#endif + +#undef my_read /* Can be predefined in raid.h */ +#undef my_write +#undef my_seek +#define my_read(a,b,c,d) my_quick_read(a,b,c,d) +#define my_write(a,b,c,d) my_quick_write(a,b,c) +extern uint my_quick_read(File Filedes,byte *Buffer,uint Count,myf myFlags); +extern uint my_quick_write(File Filedes,const byte *Buffer,uint Count); + +#if !defined(SAFEMALLOC) && defined(USE_HALLOC) +#define my_malloc(a,b) halloc(a,1) +#define my_no_flags_free(a) hfree(a) +#endif + +#endif /* __MY_NOSYS__ */ + +#ifdef __cplusplus +} +#endif +#endif diff --git a/dlls/csx_sql/extra/include/mysql/my_pthread.h b/dlls/csx_sql/extra/include/mysql/my_pthread.h new file mode 100755 index 00000000..40302f48 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/my_pthread.h @@ -0,0 +1,693 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* Defines to make different thread packages compatible */ + +#ifndef _my_pthread_h +#define _my_pthread_h + +#include +#ifndef ETIME +#define ETIME ETIMEDOUT /* For FreeBSD */ +#endif + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +#if defined(__WIN__) || defined(OS2) + +#ifdef OS2 +typedef ULONG HANDLE; +typedef ULONG DWORD; +typedef int sigset_t; +#endif + +#ifdef OS2 +typedef HMTX pthread_mutex_t; +#else +typedef CRITICAL_SECTION pthread_mutex_t; +#endif +typedef HANDLE pthread_t; +typedef struct thread_attr { + DWORD dwStackSize ; + DWORD dwCreatingFlag ; + int priority ; +} pthread_attr_t ; + +typedef struct { int dummy; } pthread_condattr_t; + +/* Implementation of posix conditions */ + +typedef struct st_pthread_link { + DWORD thread_id; + struct st_pthread_link *next; +} pthread_link; + +typedef struct { + uint32 waiting; +#ifdef OS2 + HEV semaphore; +#else + HANDLE semaphore; +#endif +} pthread_cond_t; + + +#ifndef OS2 +struct timespec { /* For pthread_cond_timedwait() */ + time_t tv_sec; + long tv_nsec; +}; +#endif + +typedef int pthread_mutexattr_t; +#define win_pthread_self my_thread_var->pthread_self +#ifdef OS2 +#define pthread_handler_decl(A,B) void * _Optlink A(void *B) +typedef void * (_Optlink *pthread_handler)(void *); +#else +#define pthread_handler_decl(A,B) void * __cdecl A(void *B) +typedef void * (__cdecl *pthread_handler)(void *); +#endif + +void win_pthread_init(void); +int win_pthread_setspecific(void *A,void *B,uint length); +int pthread_create(pthread_t *,pthread_attr_t *,pthread_handler,void *); +int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr); +int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); +int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, + struct timespec *abstime); +int pthread_cond_signal(pthread_cond_t *cond); +int pthread_cond_broadcast(pthread_cond_t *cond); +int pthread_cond_destroy(pthread_cond_t *cond); +int pthread_attr_init(pthread_attr_t *connect_att); +int pthread_attr_setstacksize(pthread_attr_t *connect_att,DWORD stack); +int pthread_attr_setprio(pthread_attr_t *connect_att,int priority); +int pthread_attr_destroy(pthread_attr_t *connect_att); +struct tm *localtime_r(const time_t *timep,struct tm *tmp); + +void pthread_exit(void *a); /* was #define pthread_exit(A) ExitThread(A)*/ + +#ifndef OS2 +#define ETIMEDOUT 145 /* Win32 doesn't have this */ +#define getpid() GetCurrentThreadId() +#endif +#define pthread_self() win_pthread_self +#define HAVE_LOCALTIME_R 1 +#define _REENTRANT 1 +#define HAVE_PTHREAD_ATTR_SETSTACKSIZE 1 + +#ifdef USE_TLS /* For LIBMYSQL.DLL */ +#undef SAFE_MUTEX /* This will cause conflicts */ +#define pthread_key(T,V) DWORD V +#define pthread_key_create(A,B) ((*A=TlsAlloc())==0xFFFFFFFF) +#define pthread_key_delete(A) TlsFree(A) +#define pthread_getspecific(A) (TlsGetValue(A)) +#define my_pthread_getspecific(T,A) ((T) TlsGetValue(A)) +#define my_pthread_getspecific_ptr(T,V) ((T) TlsGetValue(V)) +#define my_pthread_setspecific_ptr(T,V) (!TlsSetValue((T),(V))) +#define pthread_setspecific(A,B) (!TlsSetValue((A),(B))) +#else +#define pthread_key(T,V) __declspec(thread) T V +#define pthread_key_create(A,B) pthread_dummy(0) +#define pthread_key_delete(A) pthread_dummy(0) +#define pthread_getspecific(A) (&(A)) +#define my_pthread_getspecific(T,A) (&(A)) +#define my_pthread_getspecific_ptr(T,V) (V) +#define my_pthread_setspecific_ptr(T,V) ((T)=(V),0) +#define pthread_setspecific(A,B) win_pthread_setspecific(&(A),(B),sizeof(A)) +#endif /* USE_TLS */ + +#define pthread_equal(A,B) ((A) == (B)) +#ifdef OS2 +extern int pthread_mutex_init (pthread_mutex_t *, const pthread_mutexattr_t *); +extern int pthread_mutex_lock (pthread_mutex_t *); +extern int pthread_mutex_unlock (pthread_mutex_t *); +extern int pthread_mutex_destroy (pthread_mutex_t *); +#define my_pthread_setprio(A,B) DosSetPriority(PRTYS_THREAD,PRTYC_NOCHANGE, B, A) +#define pthread_kill(A,B) raise(B) +#define pthread_exit(A) pthread_dummy() +#else +#define pthread_mutex_init(A,B) InitializeCriticalSection(A) +#define pthread_mutex_lock(A) (EnterCriticalSection(A),0) +#define pthread_mutex_trylock(A) (WaitForSingleObject((A), 0) == WAIT_TIMEOUT) +#define pthread_mutex_unlock(A) LeaveCriticalSection(A) +#define pthread_mutex_destroy(A) DeleteCriticalSection(A) +#define my_pthread_setprio(A,B) SetThreadPriority(GetCurrentThread(), (B)) +#define pthread_kill(A,B) pthread_dummy(0) +#endif /* OS2 */ + +/* Dummy defines for easier code */ +#define pthread_attr_setdetachstate(A,B) pthread_dummy(0) +#define my_pthread_attr_setprio(A,B) pthread_attr_setprio(A,B) +#define pthread_attr_setscope(A,B) +#define pthread_detach_this_thread() +#define pthread_condattr_init(A) +#define pthread_condattr_destroy(A) + +/*Irena: compiler does not like this: */ +/*#define my_pthread_getprio(pthread_t thread_id) pthread_dummy(0) */ +#define my_pthread_getprio(thread_id) pthread_dummy(0) + +#elif defined(HAVE_UNIXWARE7_THREADS) + +#include +#include + +#ifndef _REENTRANT +#define _REENTRANT +#endif + +#define HAVE_NONPOSIX_SIGWAIT +#define pthread_t thread_t +#define pthread_cond_t cond_t +#define pthread_mutex_t mutex_t +#define pthread_key_t thread_key_t +typedef int pthread_attr_t; /* Needed by Unixware 7.0.0 */ + +#define pthread_key_create(A,B) thr_keycreate((A),(B)) +#define pthread_key_delete(A) thr_keydelete(A) + +#define pthread_handler_decl(A,B) void *A(void *B) +#define pthread_key(T,V) pthread_key_t V + +void * my_pthread_getspecific_imp(pthread_key_t key); +#define my_pthread_getspecific(A,B) ((A) my_pthread_getspecific_imp(B)) +#define my_pthread_getspecific_ptr(T,V) my_pthread_getspecific(T,V) + +#define pthread_setspecific(A,B) thr_setspecific(A,B) +#define my_pthread_setspecific_ptr(T,V) pthread_setspecific(T,V) + +#define pthread_create(A,B,C,D) thr_create(NULL,65536L,(C),(D),THR_DETACHED,(A)) +#define pthread_cond_init(a,b) cond_init((a),USYNC_THREAD,NULL) +#define pthread_cond_destroy(a) cond_destroy(a) +#define pthread_cond_signal(a) cond_signal(a) +#define pthread_cond_wait(a,b) cond_wait((a),(b)) +#define pthread_cond_timedwait(a,b,c) cond_timedwait((a),(b),(c)) +#define pthread_cond_broadcast(a) cond_broadcast(a) + +#define pthread_mutex_init(a,b) mutex_init((a),USYNC_THREAD,NULL) +#define pthread_mutex_lock(a) mutex_lock(a) +#define pthread_mutex_unlock(a) mutex_unlock(a) +#define pthread_mutex_destroy(a) mutex_destroy(a) + +#define pthread_self() thr_self() +#define pthread_exit(A) thr_exit(A) +#define pthread_equal(A,B) (((A) == (B)) ? 1 : 0) +#define pthread_kill(A,B) thr_kill((A),(B)) +#define HAVE_PTHREAD_KILL + +#define pthread_sigmask(A,B,C) thr_sigsetmask((A),(B),(C)) + +extern int my_sigwait(const sigset_t *set,int *sig); + +#define pthread_detach_this_thread() pthread_dummy(0) + +#define pthread_attr_init(A) pthread_dummy(0) +#define pthread_attr_destroy(A) pthread_dummy(0) +#define pthread_attr_setscope(A,B) pthread_dummy(0) +#define pthread_attr_setdetachstate(A,B) pthread_dummy(0) +#define my_pthread_setprio(A,B) pthread_dummy (0) +#define my_pthread_getprio(A) pthread_dummy (0) +#define my_pthread_attr_setprio(A,B) pthread_dummy(0) + +#else /* Normal threads */ + +#ifdef HAVE_rts_threads +#define sigwait org_sigwait +#include +#undef sigwait +#endif +#undef _REENTRANT /* Fix if _REENTRANT is in pthread.h */ +#include +#ifndef _REENTRANT +#define _REENTRANT +#endif +#ifdef HAVE_THR_SETCONCURRENCY +#include /* Probably solaris */ +#endif +#ifdef HAVE_SCHED_H +#include +#endif +#ifdef HAVE_SYNCH_H +#include +#endif +#if defined(__EMX__) && (!defined(EMX_PTHREAD_REV) || (EMX_PTHREAD_REV < 2)) +#error Requires at least rev 2 of EMX pthreads library. +#endif + +#ifdef __NETWARE__ +void my_pthread_exit(void *status); +#define pthread_exit(A) my_pthread_exit(A) +#endif + +extern int my_pthread_getprio(pthread_t thread_id); + +#define pthread_key(T,V) pthread_key_t V +#define my_pthread_getspecific_ptr(T,V) my_pthread_getspecific(T,(V)) +#define my_pthread_setspecific_ptr(T,V) pthread_setspecific(T,(void*) (V)) +#define pthread_detach_this_thread() +#define pthread_handler_decl(A,B) void *A(void *B) +typedef void *(* pthread_handler)(void *); + +/* Test first for RTS or FSU threads */ + +#if defined(PTHREAD_SCOPE_GLOBAL) && !defined(PTHREAD_SCOPE_SYSTEM) +#define HAVE_rts_threads +extern int my_pthread_create_detached; +#define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C)) +#define PTHREAD_CREATE_DETACHED &my_pthread_create_detached +#define PTHREAD_SCOPE_SYSTEM PTHREAD_SCOPE_GLOBAL +#define PTHREAD_SCOPE_PROCESS PTHREAD_SCOPE_LOCAL +#define USE_ALARM_THREAD +#elif defined(HAVE_mit_thread) +#define USE_ALARM_THREAD +#undef HAVE_LOCALTIME_R +#define HAVE_LOCALTIME_R +#undef HAVE_PTHREAD_ATTR_SETSCOPE +#define HAVE_PTHREAD_ATTR_SETSCOPE +#undef HAVE_GETHOSTBYNAME_R_GLIBC2_STYLE /* If we are running linux */ +#undef HAVE_RWLOCK_T +#undef HAVE_RWLOCK_INIT +#undef HAVE_PTHREAD_RWLOCK_RDLOCK +#undef HAVE_SNPRINTF + +#define sigset(A,B) pthread_signal((A),(void (*)(int)) (B)) +#define signal(A,B) pthread_signal((A),(void (*)(int)) (B)) +#define my_pthread_attr_setprio(A,B) +#endif /* defined(PTHREAD_SCOPE_GLOBAL) && !defined(PTHREAD_SCOPE_SYSTEM) */ + +#if defined(_BSDI_VERSION) && _BSDI_VERSION < 199910 +int sigwait(sigset_t *set, int *sig); +#endif + +#if defined(HAVE_UNIXWARE7_POSIX) +#undef HAVE_NONPOSIX_SIGWAIT +#define HAVE_NONPOSIX_SIGWAIT /* sigwait takes only 1 argument */ +#endif + +#ifndef HAVE_NONPOSIX_SIGWAIT +#define my_sigwait(A,B) sigwait((A),(B)) +#else +int my_sigwait(const sigset_t *set,int *sig); +#endif + +#ifdef HAVE_NONPOSIX_PTHREAD_MUTEX_INIT +#ifndef SAFE_MUTEX +#define pthread_mutex_init(a,b) my_pthread_mutex_init((a),(b)) +extern int my_pthread_mutex_init(pthread_mutex_t *mp, + const pthread_mutexattr_t *attr); +#endif /* SAFE_MUTEX */ +#define pthread_cond_init(a,b) my_pthread_cond_init((a),(b)) +extern int my_pthread_cond_init(pthread_cond_t *mp, + const pthread_condattr_t *attr); +#endif /* HAVE_NONPOSIX_PTHREAD_MUTEX_INIT */ + +#if defined(HAVE_SIGTHREADMASK) && !defined(HAVE_PTHREAD_SIGMASK) +#define pthread_sigmask(A,B,C) sigthreadmask((A),(B),(C)) +#endif + +#if !defined(HAVE_SIGWAIT) && !defined(HAVE_mit_thread) && !defined(HAVE_rts_threads) && !defined(sigwait) && !defined(alpha_linux_port) && !defined(HAVE_NONPOSIX_SIGWAIT) && !defined(HAVE_DEC_3_2_THREADS) && !defined(_AIX) +int sigwait(sigset_t *setp, int *sigp); /* Use our implemention */ +#endif +#if !defined(HAVE_SIGSET) && !defined(HAVE_mit_thread) && !defined(sigset) +#define sigset(A,B) do { struct sigaction s; sigset_t set; \ + sigemptyset(&set); \ + s.sa_handler = (B); \ + s.sa_mask = set; \ + s.sa_flags = 0; \ + sigaction((A), &s, (struct sigaction *) NULL); \ + } while (0) +#endif + +#ifndef my_pthread_setprio +#if defined(HAVE_PTHREAD_SETPRIO_NP) /* FSU threads */ +#define my_pthread_setprio(A,B) pthread_setprio_np((A),(B)) +#elif defined(HAVE_PTHREAD_SETPRIO) +#define my_pthread_setprio(A,B) pthread_setprio((A),(B)) +#else +extern void my_pthread_setprio(pthread_t thread_id,int prior); +#endif +#endif + +#ifndef my_pthread_attr_setprio +#ifdef HAVE_PTHREAD_ATTR_SETPRIO +#define my_pthread_attr_setprio(A,B) pthread_attr_setprio((A),(B)) +#else +extern void my_pthread_attr_setprio(pthread_attr_t *attr, int priority); +#endif +#endif + +#if !defined(HAVE_PTHREAD_ATTR_SETSCOPE) || defined(HAVE_DEC_3_2_THREADS) +#define pthread_attr_setscope(A,B) +#undef HAVE_GETHOSTBYADDR_R /* No definition */ +#endif + +#if defined(HAVE_BROKEN_PTHREAD_COND_TIMEDWAIT) && !defined(SAFE_MUTEX) +extern int my_pthread_cond_timedwait(pthread_cond_t *cond, + pthread_mutex_t *mutex, + struct timespec *abstime); +#define pthread_cond_timedwait(A,B,C) my_pthread_cond_timedwait((A),(B),(C)) +#endif + +#if defined(OS2) +#define my_pthread_getspecific(T,A) ((T) &(A)) +#define pthread_setspecific(A,B) win_pthread_setspecific(&(A),(B),sizeof(A)) +#elif !defined( HAVE_NONPOSIX_PTHREAD_GETSPECIFIC) +#define my_pthread_getspecific(A,B) ((A) pthread_getspecific(B)) +#else +#define my_pthread_getspecific(A,B) ((A) my_pthread_getspecific_imp(B)) +void *my_pthread_getspecific_imp(pthread_key_t key); +#endif /* OS2 */ + +#ifndef HAVE_LOCALTIME_R +struct tm *localtime_r(const time_t *clock, struct tm *res); +#endif + +#ifdef HAVE_PTHREAD_CONDATTR_CREATE +/* DCE threads on HPUX 10.20 */ +#define pthread_condattr_init pthread_condattr_create +#define pthread_condattr_destroy pthread_condattr_delete +#endif + +/* FSU THREADS */ +#if !defined(HAVE_PTHREAD_KEY_DELETE) && !defined(pthread_key_delete) +#define pthread_key_delete(A) pthread_dummy(0) +#endif + +#ifdef HAVE_CTHREADS_WRAPPER /* For MacOSX */ +#define pthread_cond_destroy(A) pthread_dummy(0) +#define pthread_mutex_destroy(A) pthread_dummy(0) +#define pthread_attr_delete(A) pthread_dummy(0) +#define pthread_condattr_delete(A) pthread_dummy(0) +#define pthread_attr_setstacksize(A,B) pthread_dummy(0) +#define pthread_equal(A,B) ((A) == (B)) +#define pthread_cond_timedwait(a,b,c) pthread_cond_wait((a),(b)) +#define pthread_attr_init(A) pthread_attr_create(A) +#define pthread_attr_destroy(A) pthread_attr_delete(A) +#define pthread_attr_setdetachstate(A,B) pthread_dummy(0) +#define pthread_create(A,B,C,D) pthread_create((A),*(B),(C),(D)) +#define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C)) +#define pthread_kill(A,B) pthread_dummy(0) +#undef pthread_detach_this_thread +#define pthread_detach_this_thread() { pthread_t tmp=pthread_self() ; pthread_detach(&tmp); } +#endif + +#ifdef HAVE_DARWIN_THREADS +#define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C)) +#define pthread_kill(A,B) pthread_dummy(0) +#define pthread_condattr_init(A) pthread_dummy(0) +#define pthread_condattr_destroy(A) pthread_dummy(0) +#define pthread_signal(A,B) pthread_dummy(0) +#undef pthread_detach_this_thread +#define pthread_detach_this_thread() { pthread_t tmp=pthread_self() ; pthread_detach(tmp); } +#undef sigset +#define sigset(A,B) pthread_signal((A),(void (*)(int)) (B)) +#endif + +#if ((defined(HAVE_PTHREAD_ATTR_CREATE) && !defined(HAVE_SIGWAIT)) || defined(HAVE_DEC_3_2_THREADS)) && !defined(HAVE_CTHREADS_WRAPPER) +/* This is set on AIX_3_2 and Siemens unix (and DEC OSF/1 3.2 too) */ +#define pthread_key_create(A,B) \ + pthread_keycreate(A,(B) ?\ + (pthread_destructor_t) (B) :\ + (pthread_destructor_t) pthread_dummy) +#define pthread_attr_init(A) pthread_attr_create(A) +#define pthread_attr_destroy(A) pthread_attr_delete(A) +#define pthread_attr_setdetachstate(A,B) pthread_dummy(0) +#define pthread_create(A,B,C,D) pthread_create((A),*(B),(C),(D)) +#ifndef pthread_sigmask +#define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C)) +#endif +#define pthread_kill(A,B) pthread_dummy(0) +#undef pthread_detach_this_thread +#define pthread_detach_this_thread() { pthread_t tmp=pthread_self() ; pthread_detach(&tmp); } +#elif !defined(__NETWARE__) /* HAVE_PTHREAD_ATTR_CREATE && !HAVE_SIGWAIT */ +#define HAVE_PTHREAD_KILL +#endif + +#endif /* defined(__WIN__) */ + +#if defined(HPUX10) && !defined(DONT_REMAP_PTHREAD_FUNCTIONS) +#undef pthread_cond_timedwait +#define pthread_cond_timedwait(a,b,c) my_pthread_cond_timedwait((a),(b),(c)) +int my_pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, + struct timespec *abstime); +#endif + +#if defined(HPUX10) +#define pthread_attr_getstacksize(A,B) my_pthread_attr_getstacksize(A,B) +void my_pthread_attr_getstacksize(pthread_attr_t *attrib, size_t *size); +#endif + +#if defined(HAVE_POSIX1003_4a_MUTEX) && !defined(DONT_REMAP_PTHREAD_FUNCTIONS) +#undef pthread_mutex_trylock +#define pthread_mutex_trylock(a) my_pthread_mutex_trylock((a)) +int my_pthread_mutex_trylock(pthread_mutex_t *mutex); +#endif + + /* safe_mutex adds checking to mutex for easier debugging */ + +#if defined(__NETWARE__) && !defined(SAFE_MUTEX_DETECT_DESTROY) +#define SAFE_MUTEX_DETECT_DESTROY +#endif + +typedef struct st_safe_mutex_t +{ + pthread_mutex_t global,mutex; + char *file; + uint line,count; + pthread_t thread; +#ifdef SAFE_MUTEX_DETECT_DESTROY + struct st_safe_mutex_info_t *info; /* to track destroying of mutexes */ +#endif +} safe_mutex_t; + +#ifdef SAFE_MUTEX_DETECT_DESTROY +/* + Used to track the destroying of mutexes. This needs to be a seperate + structure because the safe_mutex_t structure could be freed before + the mutexes are destroyed. +*/ + +typedef struct st_safe_mutex_info_t +{ + struct st_safe_mutex_info_t *next; + struct st_safe_mutex_info_t *prev; + char *init_file; + uint32 init_line; +} safe_mutex_info_t; +#endif /* SAFE_MUTEX_DETECT_DESTROY */ + +int safe_mutex_init(safe_mutex_t *mp, const pthread_mutexattr_t *attr, + const char *file, uint line); +int safe_mutex_lock(safe_mutex_t *mp,const char *file, uint line); +int safe_mutex_unlock(safe_mutex_t *mp,const char *file, uint line); +int safe_mutex_destroy(safe_mutex_t *mp,const char *file, uint line); +int safe_cond_wait(pthread_cond_t *cond, safe_mutex_t *mp,const char *file, + uint line); +int safe_cond_timedwait(pthread_cond_t *cond, safe_mutex_t *mp, + struct timespec *abstime, const char *file, uint line); +void safe_mutex_global_init(void); +void safe_mutex_end(FILE *file); + + /* Wrappers if safe mutex is actually used */ +#ifdef SAFE_MUTEX +#undef pthread_mutex_init +#undef pthread_mutex_lock +#undef pthread_mutex_unlock +#undef pthread_mutex_destroy +#undef pthread_mutex_wait +#undef pthread_mutex_timedwait +#undef pthread_mutex_t +#undef pthread_cond_wait +#undef pthread_cond_timedwait +#undef pthread_mutex_trylock +#define pthread_mutex_init(A,B) safe_mutex_init((A),(B),__FILE__,__LINE__) +#define pthread_mutex_lock(A) safe_mutex_lock((A),__FILE__,__LINE__) +#define pthread_mutex_unlock(A) safe_mutex_unlock((A),__FILE__,__LINE__) +#define pthread_mutex_destroy(A) safe_mutex_destroy((A),__FILE__,__LINE__) +#define pthread_cond_wait(A,B) safe_cond_wait((A),(B),__FILE__,__LINE__) +#define pthread_cond_timedwait(A,B,C) safe_cond_timedwait((A),(B),(C),__FILE__,__LINE__) +#define pthread_mutex_trylock(A) pthread_mutex_lock(A) +#define pthread_mutex_t safe_mutex_t +#define safe_mutex_assert_owner(mp) DBUG_ASSERT((mp)->count > 0 && pthread_equal(pthread_self(),(mp)->thread)) +#else +#define safe_mutex_assert_owner(mp) +#endif /* SAFE_MUTEX */ + + /* READ-WRITE thread locking */ + +#ifdef HAVE_BROKEN_RWLOCK /* For OpenUnix */ +#undef HAVE_PTHREAD_RWLOCK_RDLOCK +#undef HAVE_RWLOCK_INIT +#undef HAVE_RWLOCK_T +#endif + +#if defined(USE_MUTEX_INSTEAD_OF_RW_LOCKS) +/* use these defs for simple mutex locking */ +#define rw_lock_t pthread_mutex_t +#define my_rwlock_init(A,B) pthread_mutex_init((A),(B)) +#define rw_rdlock(A) pthread_mutex_lock((A)) +#define rw_wrlock(A) pthread_mutex_lock((A)) +#define rw_tryrdlock(A) pthread_mutex_trylock((A)) +#define rw_trywrlock(A) pthread_mutex_trylock((A)) +#define rw_unlock(A) pthread_mutex_unlock((A)) +#define rwlock_destroy(A) pthread_mutex_destroy((A)) +#elif defined(HAVE_PTHREAD_RWLOCK_RDLOCK) +#define rw_lock_t pthread_rwlock_t +#define my_rwlock_init(A,B) pthread_rwlock_init((A),(B)) +#define rw_rdlock(A) pthread_rwlock_rdlock(A) +#define rw_wrlock(A) pthread_rwlock_wrlock(A) +#define rw_tryrdlock(A) pthread_rwlock_tryrdlock((A)) +#define rw_trywrlock(A) pthread_rwlock_trywrlock((A)) +#define rw_unlock(A) pthread_rwlock_unlock(A) +#define rwlock_destroy(A) pthread_rwlock_destroy(A) +#elif defined(HAVE_RWLOCK_INIT) +#ifdef HAVE_RWLOCK_T /* For example Solaris 2.6-> */ +#define rw_lock_t rwlock_t +#endif +#define my_rwlock_init(A,B) rwlock_init((A),USYNC_THREAD,0) +#else +/* Use our own version of read/write locks */ +typedef struct _my_rw_lock_t { + pthread_mutex_t lock; /* lock for structure */ + pthread_cond_t readers; /* waiting readers */ + pthread_cond_t writers; /* waiting writers */ + int state; /* -1:writer,0:free,>0:readers */ + int waiters; /* number of waiting writers */ +} my_rw_lock_t; + +#define rw_lock_t my_rw_lock_t +#define rw_rdlock(A) my_rw_rdlock((A)) +#define rw_wrlock(A) my_rw_wrlock((A)) +#define rw_tryrdlock(A) my_rw_tryrdlock((A)) +#define rw_trywrlock(A) my_rw_trywrlock((A)) +#define rw_unlock(A) my_rw_unlock((A)) +#define rwlock_destroy(A) my_rwlock_destroy((A)) + +extern int my_rwlock_init(my_rw_lock_t *, void *); +extern int my_rwlock_destroy(my_rw_lock_t *); +extern int my_rw_rdlock(my_rw_lock_t *); +extern int my_rw_wrlock(my_rw_lock_t *); +extern int my_rw_unlock(my_rw_lock_t *); +extern int my_rw_tryrdlock(my_rw_lock_t *); +extern int my_rw_trywrlock(my_rw_lock_t *); +#endif /* USE_MUTEX_INSTEAD_OF_RW_LOCKS */ + +#define GETHOSTBYADDR_BUFF_SIZE 2048 + +#ifndef HAVE_THR_SETCONCURRENCY +#define thr_setconcurrency(A) pthread_dummy(0) +#endif +#if !defined(HAVE_PTHREAD_ATTR_SETSTACKSIZE) && ! defined(pthread_attr_setstacksize) +#define pthread_attr_setstacksize(A,B) pthread_dummy(0) +#endif + +/* Define mutex types */ +#define MY_MUTEX_INIT_SLOW NULL +#define MY_MUTEX_INIT_FAST NULL +#define MY_MUTEX_INIT_ERRCHK NULL +#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP +extern pthread_mutexattr_t my_fast_mutexattr; +#undef MY_MUTEX_INIT_FAST +#define MY_MUTEX_INIT_FAST &my_fast_mutexattr +#endif +#ifdef PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP +extern pthread_mutexattr_t my_errchk_mutexattr; +#undef MY_INIT_MUTEX_ERRCHK +#define MY_INIT_MUTEX_ERRCHK &my_errchk_mutexattr +#endif + +extern my_bool my_thread_global_init(void); +extern void my_thread_global_end(void); +extern my_bool my_thread_init(void); +extern void my_thread_end(void); +extern const char *my_thread_name(void); +extern long my_thread_id(void); +extern int pthread_no_free(void *); +extern int pthread_dummy(int); + +/* All thread specific variables are in the following struct */ + +#define THREAD_NAME_SIZE 10 +#if defined(__ia64__) +/* + MySQL can survive with 32K, but some glibc libraries require > 128K stack + To resolve hostnames +*/ +#define DEFAULT_THREAD_STACK (192*1024L) +#else +#define DEFAULT_THREAD_STACK (192*1024L) +#endif + +struct st_my_thread_var +{ + int thr_errno; + pthread_cond_t suspend; + pthread_mutex_t mutex; + pthread_mutex_t * volatile current_mutex; + pthread_cond_t * volatile current_cond; + pthread_t pthread_self; + long id; + int cmp_length; + int volatile abort; + my_bool init; +#ifndef DBUG_OFF + gptr dbug; + char name[THREAD_NAME_SIZE+1]; +#endif +}; + +extern struct st_my_thread_var *_my_thread_var(void) __attribute__ ((const)); +#define my_thread_var (_my_thread_var()) +#define my_errno my_thread_var->thr_errno +/* + Keep track of shutdown,signal, and main threads so that my_end() will not + report errors with them +*/ +extern pthread_t shutdown_th, main_th, signal_th; + + /* statistics_xxx functions are for not essential statistic */ + +#ifndef thread_safe_increment +#ifdef HAVE_ATOMIC_ADD +#define thread_safe_increment(V,L) atomic_add(1,(atomic_t*) &V); +#define thread_safe_add(V,C,L) atomic_add((C),(atomic_t*) &V); +#define thread_safe_sub(V,C,L) atomic_sub((C),(atomic_t*) &V); +#define statistic_increment(V,L) thread_safe_increment((V),(L)) +#define statistic_add(V,C,L) thread_safe_add((V),(C),(L)) +#else +#define thread_safe_increment(V,L) \ + pthread_mutex_lock((L)); (V)++; pthread_mutex_unlock((L)); +#define thread_safe_add(V,C,L) \ + pthread_mutex_lock((L)); (V)+=(C); pthread_mutex_unlock((L)); +#define thread_safe_sub(V,C,L) \ + pthread_mutex_lock((L)); (V)-=(C); pthread_mutex_unlock((L)); +#ifdef SAFE_STATISTICS +#define statistic_increment(V,L) thread_safe_increment((V),(L)) +#define statistic_add(V,C,L) thread_safe_add((V),(C),(L)) +#else +#define statistic_increment(V,L) (V)++ +#define statistic_add(V,C,L) (V)+=(C) +#endif /* SAFE_STATISTICS */ +#endif /* HAVE_ATOMIC_ADD */ +#endif /* thread_safe_increment */ + +#ifdef __cplusplus +} +#endif +#endif /* _my_ptread_h */ diff --git a/dlls/csx_sql/extra/include/mysql/my_semaphore.h b/dlls/csx_sql/extra/include/mysql/my_semaphore.h new file mode 100755 index 00000000..7f182bea --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/my_semaphore.h @@ -0,0 +1,64 @@ +/* + * Module: semaphore.h + * + * Purpose: + * Semaphores aren't actually part of the PThreads standard. + * They are defined by the POSIX Standard: + * + * POSIX 1003.1b-1993 (POSIX.1b) + * + * Pthreads-win32 - POSIX Threads Library for Win32 + * Copyright (C) 1998 + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, + * MA 02111-1307, USA + */ + +/* This is hacked by Monty to be included in mysys library */ + +#ifndef _my_semaphore_h_ +#define _my_semaphore_h_ + +#ifdef THREAD + +C_MODE_START +#ifdef HAVE_SEMAPHORE_H +#include +#elif !defined(__bsdi__) +#ifdef __WIN__ +typedef HANDLE sem_t; +#else +typedef struct { + pthread_mutex_t mutex; + pthread_cond_t cond; + uint count; +} sem_t; +#endif /* __WIN__ */ + +int sem_init(sem_t * sem, int pshared, unsigned int value); +int sem_destroy(sem_t * sem); +int sem_trywait(sem_t * sem); +int sem_wait(sem_t * sem); +int sem_post(sem_t * sem); +int sem_post_multiple(sem_t * sem, unsigned int count); +int sem_getvalue(sem_t * sem, unsigned int * sval); + +#endif /* !__bsdi__ */ + +C_MODE_END + +#endif /* THREAD */ + +#endif /* !_my_semaphore_h_ */ diff --git a/dlls/csx_sql/extra/include/mysql/my_sys.h b/dlls/csx_sql/extra/include/mysql/my_sys.h new file mode 100755 index 00000000..75e22629 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/my_sys.h @@ -0,0 +1,770 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef _my_sys_h +#define _my_sys_h +C_MODE_START + +#ifdef HAVE_AIOWAIT +#include /* Used by record-cache */ +typedef struct my_aio_result { + aio_result_t result; + int pending; +} my_aio_result; +#endif + +#ifndef THREAD +extern int NEAR my_errno; /* Last error in mysys */ +#else +#include +#endif + +#ifndef _m_ctype_h +#include /* for CHARSET_INFO */ +#endif + +#include + +#define MYSYS_PROGRAM_USES_CURSES() { error_handler_hook = my_message_curses; mysys_uses_curses=1; } +#define MYSYS_PROGRAM_DONT_USE_CURSES() { error_handler_hook = my_message_no_curses; mysys_uses_curses=0;} +#define MY_INIT(name); { my_progname= name; my_init(); } + +#define MAXMAPS (4) /* Number of error message maps */ +#define ERRMOD (1000) /* Max number of errors in a map */ +#define ERRMSGSIZE (SC_MAXWIDTH) /* Max length of a error message */ +#define NRERRBUFFS (2) /* Buffers for parameters */ +#define MY_FILE_ERROR ((uint) ~0) + + /* General bitmaps for my_func's */ +#define MY_FFNF 1 /* Fatal if file not found */ +#define MY_FNABP 2 /* Fatal if not all bytes read/writen */ +#define MY_NABP 4 /* Error if not all bytes read/writen */ +#define MY_FAE 8 /* Fatal if any error */ +#define MY_WME 16 /* Write message on error */ +#define MY_WAIT_IF_FULL 32 /* Wait and try again if disk full error */ +#define MY_RAID 64 /* Support for RAID (not the "Johnson&Johnson"-s one ;) */ +#define MY_FULL_IO 512 /* For my_read - loop intil I/O + is complete + */ +#define MY_DONT_CHECK_FILESIZE 128 /* Option to init_io_cache() */ +#define MY_LINK_WARNING 32 /* my_redel() gives warning if links */ +#define MY_COPYTIME 64 /* my_redel() copys time */ +#define MY_DELETE_OLD 256 /* my_create_with_symlink() */ +#define MY_RESOLVE_LINK 128 /* my_realpath(); Only resolve links */ +#define MY_HOLD_ORIGINAL_MODES 128 /* my_copy() holds to file modes */ +#define MY_REDEL_MAKE_BACKUP 256 +#define MY_SEEK_NOT_DONE 32 /* my_lock may have to do a seek */ +#define MY_DONT_WAIT 64 /* my_lock() don't wait if can't lock */ +#define MY_ZEROFILL 32 /* my_malloc(), fill array with zero */ +#define MY_ALLOW_ZERO_PTR 64 /* my_realloc() ; zero ptr -> malloc */ +#define MY_FREE_ON_ERROR 128 /* my_realloc() ; Free old ptr on error */ +#define MY_HOLD_ON_ERROR 256 /* my_realloc() ; Return old ptr on error */ +#define MY_THREADSAFE 128 /* pread/pwrite: Don't allow interrupts */ +#define MY_DONT_OVERWRITE_FILE 1024 /* my_copy; Don't overwrite file */ + +#define MY_CHECK_ERROR 1 /* Params to my_end; Check open-close */ +#define MY_GIVE_INFO 2 /* Give time info about process*/ + +#define ME_HIGHBYTE 8 /* Shift for colours */ +#define ME_NOCUR 1 /* Don't use curses message */ +#define ME_OLDWIN 2 /* Use old window */ +#define ME_BELL 4 /* Ring bell then printing message */ +#define ME_HOLDTANG 8 /* Don't delete last keys */ +#define ME_WAITTOT 16 /* Wait for errtime secs of for a action */ +#define ME_WAITTANG 32 /* Wait for a user action */ +#define ME_NOREFRESH 64 /* Dont refresh screen */ +#define ME_NOINPUT 128 /* Dont use the input libary */ +#define ME_COLOUR1 ((1 << ME_HIGHBYTE)) /* Possibly error-colours */ +#define ME_COLOUR2 ((2 << ME_HIGHBYTE)) +#define ME_COLOUR3 ((3 << ME_HIGHBYTE)) + + /* Bits in last argument to fn_format */ +#define MY_REPLACE_DIR 1 /* replace dir in name with 'dir' */ +#define MY_REPLACE_EXT 2 /* replace extension with 'ext' */ +#define MY_UNPACK_FILENAME 4 /* Unpack name (~ -> home) */ +#define MY_PACK_FILENAME 8 /* Pack name (home -> ~) */ +#define MY_RESOLVE_SYMLINKS 16 /* Resolve all symbolic links */ +#define MY_RETURN_REAL_PATH 32 /* return full path for file */ +#define MY_SAFE_PATH 64 /* Return NULL if too long path */ +#define MY_RELATIVE_PATH 128 /* name is relative to 'dir' */ + + /* My seek flags */ +#define MY_SEEK_SET 0 +#define MY_SEEK_CUR 1 +#define MY_SEEK_END 2 + + /* My charsets_list flags */ +#define MY_NO_SETS 0 +#define MY_COMPILED_SETS 1 /* show compiled-in sets */ +#define MY_CONFIG_SETS 2 /* sets that have a *.conf file */ +#define MY_INDEX_SETS 4 /* all sets listed in the Index file */ +#define MY_LOADED_SETS 8 /* the sets that are currently loaded */ + + /* Some constants */ +#define MY_WAIT_FOR_USER_TO_FIX_PANIC 60 /* in seconds */ +#define MY_WAIT_GIVE_USER_A_MESSAGE 10 /* Every 10 times of prev */ +#define MIN_COMPRESS_LENGTH 50 /* Don't compress small bl. */ +#define DEFAULT_KEYCACHE_BLOCK_SIZE 1024 +#define MAX_KEYCACHE_BLOCK_SIZE 16384 + + /* root_alloc flags */ +#define MY_KEEP_PREALLOC 1 +#define MY_MARK_BLOCKS_FREE 2 /* move used to free list and reuse them */ + + /* defines when allocating data */ + +#ifdef SAFEMALLOC +#define my_malloc(SZ,FLAG) _mymalloc((SZ), __FILE__, __LINE__, FLAG ) +#define my_malloc_ci(SZ,FLAG) _mymalloc((SZ), sFile, uLine, FLAG ) +#define my_realloc(PTR,SZ,FLAG) _myrealloc((PTR), (SZ), __FILE__, __LINE__, FLAG ) +#define my_checkmalloc() _sanity( __FILE__, __LINE__ ) +#define my_free(PTR,FLAG) _myfree((PTR), __FILE__, __LINE__,FLAG) +#define my_memdup(A,B,C) _my_memdup((A),(B), __FILE__,__LINE__,C) +#define my_strdup(A,C) _my_strdup((A), __FILE__,__LINE__,C) +#define my_strdup_with_length(A,B,C) _my_strdup_with_length((A),(B),__FILE__,__LINE__,C) +#define QUICK_SAFEMALLOC sf_malloc_quick=1 +#define NORMAL_SAFEMALLOC sf_malloc_quick=0 +extern uint sf_malloc_prehunc,sf_malloc_endhunc,sf_malloc_quick; +extern ulonglong sf_malloc_mem_limit; + +#define CALLER_INFO_PROTO , const char *sFile, uint uLine +#define CALLER_INFO , __FILE__, __LINE__ +#define ORIG_CALLER_INFO , sFile, uLine +#else +#define my_checkmalloc() +#undef TERMINATE +#define TERMINATE(A) {} +#define QUICK_SAFEMALLOC +#define NORMAL_SAFEMALLOC +extern gptr my_malloc(uint Size,myf MyFlags); +#define my_malloc_ci(SZ,FLAG) my_malloc( SZ, FLAG ) +extern gptr my_realloc(gptr oldpoint,uint Size,myf MyFlags); +extern void my_no_flags_free(gptr ptr); +extern gptr my_memdup(const byte *from,uint length,myf MyFlags); +extern char *my_strdup(const char *from,myf MyFlags); +extern char *my_strdup_with_length(const byte *from, uint length, + myf MyFlags); +#define my_free(PTR,FG) my_no_flags_free(PTR) +#define CALLER_INFO_PROTO /* nothing */ +#define CALLER_INFO /* nothing */ +#define ORIG_CALLER_INFO /* nothing */ +#endif + +#ifdef HAVE_ALLOCA +#if defined(_AIX) && !defined(__GNUC__) +#pragma alloca +#endif /* _AIX */ +#if defined(__GNUC__) && !defined(HAVE_ALLOCA_H) && ! defined(alloca) +#define alloca __builtin_alloca +#endif /* GNUC */ +#define my_alloca(SZ) alloca((size_t) (SZ)) +#define my_afree(PTR) {} +#else +#define my_alloca(SZ) my_malloc(SZ,MYF(0)) +#define my_afree(PTR) my_free(PTR,MYF(MY_WME)) +#endif /* HAVE_ALLOCA */ + +#ifdef MSDOS +#ifdef __ZTC__ +void * __CDECL halloc(long count,size_t length); +void __CDECL hfree(void *ptr); +#endif +#if defined(USE_HALLOC) +#if defined(_VCM_) || defined(M_IC80386) +#undef USE_HALLOC +#endif +#endif +#ifdef USE_HALLOC +#define malloc(a) halloc((long) (a),1) +#define free(a) hfree(a) +#endif +#endif /* MSDOS */ + +#ifdef HAVE_ERRNO_AS_DEFINE +#include /* errno is a define */ +#else +extern int errno; /* declare errno */ +#endif +extern const char ** NEAR my_errmsg[]; +extern char NEAR errbuff[NRERRBUFFS][ERRMSGSIZE]; +extern char *home_dir; /* Home directory for user */ +extern char *my_progname; /* program-name (printed in errors) */ +extern char NEAR curr_dir[]; /* Current directory for user */ +extern int (*error_handler_hook)(uint my_err, const char *str,myf MyFlags); +extern int (*fatal_error_handler_hook)(uint my_err, const char *str, + myf MyFlags); + +/* charsets */ +extern uint get_charset_number(const char *cs_name); +extern const char *get_charset_name(uint cs_number); +extern CHARSET_INFO *get_charset(uint cs_number, myf flags); +extern my_bool set_default_charset(uint cs, myf flags); +extern CHARSET_INFO *get_charset_by_name(const char *cs_name, myf flags); +extern my_bool set_default_charset_by_name(const char *cs_name, myf flags); +extern void free_charsets(void); +extern char *list_charsets(myf want_flags); /* my_free() this string... */ +extern char *get_charsets_dir(char *buf); + + +/* statistics */ +extern ulong _my_cache_w_requests,_my_cache_write,_my_cache_r_requests, + _my_cache_read; +extern ulong _my_blocks_used,_my_blocks_changed; +extern uint key_cache_block_size; +extern ulong my_file_opened,my_stream_opened, my_tmp_file_created; +extern my_bool key_cache_inited, my_init_done; + + /* Point to current my_message() */ +extern void (*my_sigtstp_cleanup)(void), + /* Executed before jump to shell */ + (*my_sigtstp_restart)(void), + (*my_abort_hook)(int); + /* Executed when comming from shell */ +extern int NEAR my_umask, /* Default creation mask */ + NEAR my_umask_dir, + NEAR my_recived_signals, /* Signals we have got */ + NEAR my_safe_to_handle_signal, /* Set when allowed to SIGTSTP */ + NEAR my_dont_interrupt; /* call remember_intr when set */ +extern my_bool NEAR mysys_uses_curses, my_use_symdir; +extern ulong sf_malloc_cur_memory, sf_malloc_max_memory; + +extern ulong my_default_record_cache_size; +extern my_bool NEAR my_disable_locking,NEAR my_disable_async_io, + NEAR my_disable_flush_key_blocks, NEAR my_disable_symlinks; +extern char wild_many,wild_one,wild_prefix; +extern const char *charsets_dir; +extern char *defaults_extra_file; + +typedef struct wild_file_pack /* Struct to hold info when selecting files */ +{ + uint wilds; /* How many wildcards */ + uint not_pos; /* Start of not-theese-files */ + my_string *wild; /* Pointer to wildcards */ +} WF_PACK; + +typedef struct st_typelib { /* Different types saved here */ + uint count; /* How many types */ + const char *name; /* Name of typelib */ + const char **type_names; +} TYPELIB; + +enum cache_type +{ + READ_CACHE,WRITE_CACHE, + SEQ_READ_APPEND /* sequential read or append */, + READ_FIFO, READ_NET,WRITE_NET}; + +enum flush_type +{ + FLUSH_KEEP, FLUSH_RELEASE, FLUSH_IGNORE_CHANGED, FLUSH_FORCE_WRITE +}; + +typedef struct st_record_cache /* Used when cacheing records */ +{ + File file; + int rc_seek,error,inited; + uint rc_length,read_length,reclength; + my_off_t rc_record_pos,end_of_file; + byte *rc_buff,*rc_buff2,*rc_pos,*rc_end,*rc_request_pos; +#ifdef HAVE_AIOWAIT + int use_async_io; + my_aio_result aio_result; +#endif + enum cache_type type; +} RECORD_CACHE; + +enum file_type +{ + UNOPEN = 0, FILE_BY_OPEN, FILE_BY_CREATE, STREAM_BY_FOPEN, STREAM_BY_FDOPEN, + FILE_BY_MKSTEMP, FILE_BY_DUP +}; + +extern struct my_file_info +{ + my_string name; + enum file_type type; +#if defined(THREAD) && !defined(HAVE_PREAD) + pthread_mutex_t mutex; +#endif +} my_file_info[MY_NFILE]; + + +typedef struct st_dynamic_array +{ + char *buffer; + uint elements,max_element; + uint alloc_increment; + uint size_of_element; +} DYNAMIC_ARRAY; + +typedef struct st_dynamic_string +{ + char *str; + uint length,max_length,alloc_increment; +} DYNAMIC_STRING; + +struct st_io_cache; +typedef int (*IO_CACHE_CALLBACK)(struct st_io_cache*); + +#ifdef THREAD +typedef struct st_io_cache_share +{ + /* to sync on reads into buffer */ + pthread_mutex_t mutex; + pthread_cond_t cond; + int count, total; + /* actual IO_CACHE that filled the buffer */ + struct st_io_cache *active; +#ifdef NOT_YET_IMPLEMENTED + /* whether the structure should be free'd */ + my_bool alloced; +#endif +} IO_CACHE_SHARE; +#endif + +typedef struct st_io_cache /* Used when cacheing files */ +{ + /* Offset in file corresponding to the first byte of byte* buffer. */ + my_off_t pos_in_file; + /* + The offset of end of file for READ_CACHE and WRITE_CACHE. + For SEQ_READ_APPEND it the maximum of the actual end of file and + the position represented by read_end. + */ + my_off_t end_of_file; + /* Points to current read position in the buffer */ + byte *read_pos; + /* the non-inclusive boundary in the buffer for the currently valid read */ + byte *read_end; + byte *buffer; /* The read buffer */ + /* Used in ASYNC_IO */ + byte *request_pos; + + /* Only used in WRITE caches and in SEQ_READ_APPEND to buffer writes */ + byte *write_buffer; + /* + Only used in SEQ_READ_APPEND, and points to the current read position + in the write buffer. Note that reads in SEQ_READ_APPEND caches can + happen from both read buffer (byte* buffer) and write buffer + (byte* write_buffer). + */ + byte *append_read_pos; + /* Points to current write position in the write buffer */ + byte *write_pos; + /* The non-inclusive boundary of the valid write area */ + byte *write_end; + + /* + Current_pos and current_end are convenience variables used by + my_b_tell() and other routines that need to know the current offset + current_pos points to &write_pos, and current_end to &write_end in a + WRITE_CACHE, and &read_pos and &read_end respectively otherwise + */ + byte **current_pos, **current_end; +#ifdef THREAD + /* + The lock is for append buffer used in SEQ_READ_APPEND cache + need mutex copying from append buffer to read buffer. + */ + pthread_mutex_t append_buffer_lock; + /* + The following is used when several threads are reading the + same file in parallel. They are synchronized on disk + accesses reading the cached part of the file asynchronously. + It should be set to NULL to disable the feature. Only + READ_CACHE mode is supported. + */ + IO_CACHE_SHARE *share; +#endif + /* + A caller will use my_b_read() macro to read from the cache + if the data is already in cache, it will be simply copied with + memcpy() and internal variables will be accordinging updated with + no functions invoked. However, if the data is not fully in the cache, + my_b_read() will call read_function to fetch the data. read_function + must never be invoked directly. + */ + int (*read_function)(struct st_io_cache *,byte *,uint); + /* + Same idea as in the case of read_function, except my_b_write() needs to + be replaced with my_b_append() for a SEQ_READ_APPEND cache + */ + int (*write_function)(struct st_io_cache *,const byte *,uint); + /* + Specifies the type of the cache. Depending on the type of the cache + certain operations might not be available and yield unpredicatable + results. Details to be documented later + */ + enum cache_type type; + /* + Callbacks when the actual read I/O happens. These were added and + are currently used for binary logging of LOAD DATA INFILE - when a + block is read from the file, we create a block create/append event, and + when IO_CACHE is closed, we create an end event. These functions could, + of course be used for other things + */ + IO_CACHE_CALLBACK pre_read; + IO_CACHE_CALLBACK post_read; + IO_CACHE_CALLBACK pre_close; + void* arg; /* for use by pre/post_read */ + char *file_name; /* if used with 'open_cached_file' */ + char *dir,*prefix; + File file; /* file descriptor */ + /* + seek_not_done is set by my_b_seek() to inform the upcoming read/write + operation that a seek needs to be preformed prior to the actual I/O + error is 0 if the cache operation was successful, -1 if there was a + "hard" error, and the actual number of I/O-ed bytes if the read/write was + partial. + */ + int seek_not_done,error; + /* buffer_length is memory size allocated for buffer or write_buffer */ + uint buffer_length; + /* read_length is the same as buffer_length except when we use async io */ + uint read_length; + myf myflags; /* Flags used to my_read/my_write */ + /* + alloced_buffer is 1 if the buffer was allocated by init_io_cache() and + 0 if it was supplied by the user. + Currently READ_NET is the only one that will use a buffer allocated + somewhere else + */ + my_bool alloced_buffer; +#ifdef HAVE_AIOWAIT + /* + As inidicated by ifdef, this is for async I/O, which is not currently + used (because it's not reliable on all systems) + */ + uint inited; + my_off_t aio_read_pos; + my_aio_result aio_result; +#endif +} IO_CACHE; + +typedef int (*qsort2_cmp)(const void *, const void *, const void *); + + /* defines for mf_iocache */ + + /* Test if buffer is inited */ +#define my_b_clear(info) (info)->buffer=0 +#define my_b_inited(info) (info)->buffer +#define my_b_EOF INT_MIN + +#define my_b_read(info,Buffer,Count) \ + ((info)->read_pos + (Count) <= (info)->read_end ?\ + (memcpy(Buffer,(info)->read_pos,(size_t) (Count)), \ + ((info)->read_pos+=(Count)),0) :\ + (*(info)->read_function)((info),Buffer,Count)) + +#define my_b_write(info,Buffer,Count) \ + ((info)->write_pos + (Count) <=(info)->write_end ?\ + (memcpy((info)->write_pos, (Buffer), (size_t)(Count)),\ + ((info)->write_pos+=(Count)),0) : \ + (*(info)->write_function)((info),(Buffer),(Count))) + +#define my_b_get(info) \ + ((info)->read_pos != (info)->read_end ?\ + ((info)->read_pos++, (int) (uchar) (info)->read_pos[-1]) :\ + _my_b_get(info)) + + /* my_b_write_byte dosn't have any err-check */ +#define my_b_write_byte(info,chr) \ + (((info)->write_pos < (info)->write_end) ?\ + ((*(info)->write_pos++)=(chr)) :\ + (_my_b_write(info,0,0) , ((*(info)->write_pos++)=(chr)))) + +#define my_b_fill_cache(info) \ + (((info)->read_end=(info)->read_pos),(*(info)->read_function)(info,0,0)) + +#define my_b_tell(info) ((info)->pos_in_file + \ + (uint) (*(info)->current_pos - (info)->request_pos)) + +/* tell write offset in the SEQ_APPEND cache */ +my_off_t my_b_append_tell(IO_CACHE* info); + +#define my_b_bytes_in_cache(info) (uint) (*(info)->current_end - \ + *(info)->current_pos) + +#include + + /* Prototypes for mysys and my_func functions */ + +extern int my_copy(const char *from,const char *to,myf MyFlags); +extern int my_append(const char *from,const char *to,myf MyFlags); +extern int my_delete(const char *name,myf MyFlags); +extern int my_getwd(my_string buf,uint size,myf MyFlags); +extern int my_setwd(const char *dir,myf MyFlags); +extern int my_lock(File fd,int op,my_off_t start, my_off_t length,myf MyFlags); +extern gptr my_once_alloc(uint Size,myf MyFlags); +extern void my_once_free(void); +extern my_string my_tempnam(const char *dir,const char *pfx,myf MyFlags); +extern File my_open(const char *FileName,int Flags,myf MyFlags); +extern File my_register_filename(File fd, const char *FileName, + enum file_type type_of_file, + uint error_message_number, myf MyFlags); +extern File my_create(const char *FileName,int CreateFlags, + int AccsesFlags, myf MyFlags); +extern int my_close(File Filedes,myf MyFlags); +extern File my_dup(File file, myf MyFlags); +extern int my_mkdir(const char *dir, int Flags, myf MyFlags); +extern int my_readlink(char *to, const char *filename, myf MyFlags); +extern int my_realpath(char *to, const char *filename, myf MyFlags); +extern File my_create_with_symlink(const char *linkname, const char *filename, + int createflags, int access_flags, + myf MyFlags); +extern int my_delete_with_symlink(const char *name, myf MyFlags); +extern int my_rename_with_symlink(const char *from,const char *to,myf MyFlags); +extern int my_symlink(const char *content, const char *linkname, myf MyFlags); +extern uint my_read(File Filedes,byte *Buffer,uint Count,myf MyFlags); +extern uint my_pread(File Filedes,byte *Buffer,uint Count,my_off_t offset, + myf MyFlags); +extern int my_rename(const char *from,const char *to,myf MyFlags); +extern my_off_t my_seek(File fd,my_off_t pos,int whence,myf MyFlags); +extern my_off_t my_tell(File fd,myf MyFlags); +extern uint my_write(File Filedes,const byte *Buffer,uint Count, + myf MyFlags); +extern uint my_pwrite(File Filedes,const byte *Buffer,uint Count, + my_off_t offset,myf MyFlags); +extern uint my_fread(FILE *stream,byte *Buffer,uint Count,myf MyFlags); +extern uint my_fwrite(FILE *stream,const byte *Buffer,uint Count, + myf MyFlags); +extern my_off_t my_fseek(FILE *stream,my_off_t pos,int whence,myf MyFlags); +extern my_off_t my_ftell(FILE *stream,myf MyFlags); +extern gptr _mymalloc(uint uSize,const char *sFile, + uint uLine, myf MyFlag); +extern gptr _myrealloc(gptr pPtr,uint uSize,const char *sFile, + uint uLine, myf MyFlag); +extern gptr my_multi_malloc _VARARGS((myf MyFlags, ...)); +extern void _myfree(gptr pPtr,const char *sFile,uint uLine, myf MyFlag); +extern int _sanity(const char *sFile,unsigned int uLine); +extern gptr _my_memdup(const byte *from,uint length, + const char *sFile, uint uLine,myf MyFlag); +extern my_string _my_strdup(const char *from, const char *sFile, uint uLine, + myf MyFlag); +extern char *_my_strdup_with_length(const byte *from, uint length, + const char *sFile, uint uLine, + myf MyFlag); + +#ifndef TERMINATE +extern void TERMINATE(FILE *file); +#endif +extern void init_glob_errs(void); +extern FILE *my_fopen(const char *FileName,int Flags,myf MyFlags); +extern FILE *my_fdopen(File Filedes,const char *name, int Flags,myf MyFlags); +extern int my_fclose(FILE *fd,myf MyFlags); +extern int my_chsize(File fd,my_off_t newlength, int filler, myf MyFlags); +extern int my_sync(File fd, myf my_flags); +extern int my_error _VARARGS((int nr,myf MyFlags, ...)); +extern int my_printf_error _VARARGS((uint my_err, const char *format, + myf MyFlags, ...) + __attribute__ ((format (printf, 2, 4)))); +extern int my_vsnprintf( char *str, size_t n, + const char *format, va_list ap ); +extern int my_snprintf(char* to, size_t n, const char* fmt, ...); +extern int my_message(uint my_err, const char *str,myf MyFlags); +extern int my_message_no_curses(uint my_err, const char *str,myf MyFlags); +extern int my_message_curses(uint my_err, const char *str,myf MyFlags); +extern my_bool my_init(void); +extern void my_end(int infoflag); +extern int my_redel(const char *from, const char *to, int MyFlags); +extern int my_copystat(const char *from, const char *to, int MyFlags); +extern my_string my_filename(File fd); + +#ifndef THREAD +extern void dont_break(void); +extern void allow_break(void); +#else +#define dont_break() +#define allow_break() +#endif + +extern void my_remember_signal(int signal_number,sig_handler (*func)(int)); +extern void caseup(my_string str,uint length); +extern void casedn(my_string str,uint length); +extern void caseup_str(my_string str); +extern void casedn_str(my_string str); +extern void case_sort(my_string str,uint length); +extern uint dirname_part(my_string to,const char *name); +extern uint dirname_length(const char *name); +#define base_name(A) (A+dirname_length(A)) +extern int test_if_hard_path(const char *dir_name); +extern char *convert_dirname(char *to, const char *from, const char *from_end); +extern void to_unix_path(my_string name); +extern my_string fn_ext(const char *name); +extern my_string fn_same(my_string toname,const char *name,int flag); +extern my_string fn_format(my_string to,const char *name,const char *dir, + const char *form, uint flag); +extern size_s strlength(const char *str); +extern void pack_dirname(my_string to,const char *from); +extern uint unpack_dirname(my_string to,const char *from); +extern uint cleanup_dirname(my_string to,const char *from); +extern uint system_filename(my_string to,const char *from); +extern my_string unpack_filename(my_string to,const char *from); +extern my_string intern_filename(my_string to,const char *from); +extern my_string directory_file_name(my_string dst, const char *src); +extern int pack_filename(my_string to, const char *name, size_s max_length); +extern my_string my_path(my_string to,const char *progname, + const char *own_pathname_part); +extern my_string my_load_path(my_string to, const char *path, + const char *own_path_prefix); +extern int wild_compare(const char *str,const char *wildstr); +extern my_string my_strcasestr(const char *src,const char *suffix); +extern int my_strcasecmp(const char *s,const char *t); +extern int my_strsortcmp(const char *s,const char *t); +extern int my_casecmp(const char *s,const char *t,uint length); +extern int my_sortcmp(const char *s,const char *t,uint length); +extern int my_sortncmp(const char *s,uint s_len, const char *t,uint t_len); +extern WF_PACK *wf_comp(my_string str); +extern int wf_test(struct wild_file_pack *wf_pack,const char *name); +extern void wf_end(struct wild_file_pack *buffer); +extern size_s strip_sp(my_string str); +extern void get_date(my_string to,int timeflag,time_t use_time); +extern void soundex(my_string out_pntr, my_string in_pntr,pbool remove_garbage); +extern int init_record_cache(RECORD_CACHE *info,uint cachesize,File file, + uint reclength,enum cache_type type, + pbool use_async_io); +extern int read_cache_record(RECORD_CACHE *info,byte *to); +extern int end_record_cache(RECORD_CACHE *info); +extern int write_cache_record(RECORD_CACHE *info,my_off_t filepos, + const byte *record,uint length); +extern int flush_write_cache(RECORD_CACHE *info); +extern long my_clock(void); +extern sig_handler sigtstp_handler(int signal_number); +extern void handle_recived_signals(void); +extern int init_key_cache(ulong use_mem); +extern int resize_key_cache(ulong use_mem); +extern byte *key_cache_read(File file,my_off_t filepos,byte* buff,uint length, + uint block_length,int return_buffer); +extern int key_cache_write(File file,my_off_t filepos,byte* buff,uint length, + uint block_length,int force_write); +extern int flush_key_blocks(int file, enum flush_type type); +extern void end_key_cache(void); +extern sig_handler my_set_alarm_variable(int signo); +extern void my_string_ptr_sort(void *base,uint items,size_s size); +extern void radixsort_for_str_ptr(uchar* base[], uint number_of_elements, + size_s size_of_element,uchar *buffer[]); +extern qsort_t qsort2(void *base_ptr, size_t total_elems, size_t size, + qsort2_cmp cmp, void *cmp_argument); +extern qsort2_cmp get_ptr_compare(uint); +extern int init_io_cache(IO_CACHE *info,File file,uint cachesize, + enum cache_type type,my_off_t seek_offset, + pbool use_async_io, myf cache_myflags); +extern my_bool reinit_io_cache(IO_CACHE *info,enum cache_type type, + my_off_t seek_offset,pbool use_async_io, + pbool clear_cache); +extern int _my_b_read(IO_CACHE *info,byte *Buffer,uint Count); +#ifdef THREAD +extern int _my_b_read_r(IO_CACHE *info,byte *Buffer,uint Count); +extern void init_io_cache_share(IO_CACHE *info, + IO_CACHE_SHARE *s, uint num_threads); +extern void remove_io_thread(IO_CACHE *info); +#endif +extern int _my_b_seq_read(IO_CACHE *info,byte *Buffer,uint Count); +extern int _my_b_net_read(IO_CACHE *info,byte *Buffer,uint Count); +extern int _my_b_get(IO_CACHE *info); +extern int _my_b_async_read(IO_CACHE *info,byte *Buffer,uint Count); +extern int _my_b_write(IO_CACHE *info,const byte *Buffer,uint Count); +extern int my_b_append(IO_CACHE *info,const byte *Buffer,uint Count); +extern int my_b_safe_write(IO_CACHE *info,const byte *Buffer,uint Count); + +extern int my_block_write(IO_CACHE *info, const byte *Buffer, + uint Count, my_off_t pos); +extern int _flush_io_cache(IO_CACHE *info, int need_append_buffer_lock); + +#define flush_io_cache(info) _flush_io_cache((info),1) + +extern int end_io_cache(IO_CACHE *info); +extern uint my_b_fill(IO_CACHE *info); +extern void my_b_seek(IO_CACHE *info,my_off_t pos); +extern uint my_b_gets(IO_CACHE *info, char *to, uint max_length); +extern my_off_t my_b_filelength(IO_CACHE *info); +extern uint my_b_printf(IO_CACHE *info, const char* fmt, ...); +extern uint my_b_vprintf(IO_CACHE *info, const char* fmt, va_list ap); +extern my_bool open_cached_file(IO_CACHE *cache,const char *dir, + const char *prefix, uint cache_size, + myf cache_myflags); +extern my_bool real_open_cached_file(IO_CACHE *cache); +extern void close_cached_file(IO_CACHE *cache); +File create_temp_file(char *to, const char *dir, const char *pfx, + int mode, myf MyFlags); +#define my_init_dynamic_array(A,B,C,D) init_dynamic_array(A,B,C,D CALLER_INFO) +#define my_init_dynamic_array_ci(A,B,C,D) init_dynamic_array(A,B,C,D ORIG_CALLER_INFO) +extern my_bool init_dynamic_array(DYNAMIC_ARRAY *array,uint element_size, + uint init_alloc,uint alloc_increment CALLER_INFO_PROTO); +extern my_bool insert_dynamic(DYNAMIC_ARRAY *array,gptr element); +extern byte *alloc_dynamic(DYNAMIC_ARRAY *array); +extern byte *pop_dynamic(DYNAMIC_ARRAY*); +extern my_bool set_dynamic(DYNAMIC_ARRAY *array,gptr element,uint array_index); +extern void get_dynamic(DYNAMIC_ARRAY *array,gptr element,uint array_index); +extern void delete_dynamic(DYNAMIC_ARRAY *array); +extern void delete_dynamic_element(DYNAMIC_ARRAY *array, uint array_index); +extern void freeze_size(DYNAMIC_ARRAY *array); +#define dynamic_array_ptr(array,array_index) ((array)->buffer+(array_index)*(array)->size_of_element) +#define dynamic_element(array,array_index,type) ((type)((array)->buffer) +(array_index)) +#define push_dynamic(A,B) insert_dynamic(A,B) + +extern int find_type(my_string x,TYPELIB *typelib,uint full_name); +extern void make_type(my_string to,uint nr,TYPELIB *typelib); +extern const char *get_type(TYPELIB *typelib,uint nr); +extern my_bool init_dynamic_string(DYNAMIC_STRING *str, const char *init_str, + uint init_alloc,uint alloc_increment); +extern my_bool dynstr_append(DYNAMIC_STRING *str, const char *append); +my_bool dynstr_append_mem(DYNAMIC_STRING *str, const char *append, + uint length); +extern my_bool dynstr_set(DYNAMIC_STRING *str, const char *init_str); +extern my_bool dynstr_realloc(DYNAMIC_STRING *str, ulong additional_size); +extern void dynstr_free(DYNAMIC_STRING *str); +#ifdef HAVE_MLOCK +extern byte *my_malloc_lock(uint length,myf flags); +extern void my_free_lock(byte *ptr,myf flags); +#else +#define my_malloc_lock(A,B) my_malloc((A),(B)) +#define my_free_lock(A,B) my_free((A),(B)) +#endif +#define alloc_root_inited(A) ((A)->min_malloc != 0) +extern void init_alloc_root(MEM_ROOT *mem_root, uint block_size, + uint pre_alloc_size); +extern gptr alloc_root(MEM_ROOT *mem_root,unsigned int Size); +extern void free_root(MEM_ROOT *root, myf MyFLAGS); +extern void set_prealloc_root(MEM_ROOT *root, char *ptr); +extern void reset_root_defaults(MEM_ROOT *mem_root, uint block_size, + uint prealloc_size); +extern char *strdup_root(MEM_ROOT *root,const char *str); +extern char *strmake_root(MEM_ROOT *root,const char *str,uint len); +extern char *memdup_root(MEM_ROOT *root,const char *str,uint len); +extern int load_defaults(const char *conf_file, const char **groups, + int *argc, char ***argv); +extern void free_defaults(char **argv); +extern void print_defaults(const char *conf_file, const char **groups); +extern my_bool my_compress(byte *, ulong *, ulong *); +extern my_bool my_uncompress(byte *, ulong *, ulong *); +extern byte *my_compress_alloc(const byte *packet, ulong *len, ulong *complen); +extern ulong checksum(const byte *mem, uint count); +extern uint my_bit_log2(ulong value); +uint my_count_bits(ulonglong v); +extern void my_sleep(ulong m_seconds); + +#ifdef __WIN__ +extern my_bool have_tcpip; /* Is set if tcpip is used */ +#endif +#ifdef __NETWARE__ +void netware_reg_user(const char *ip, const char *user, + const char *application); +#endif + +C_MODE_END +#include "raid.h" +#endif /* _my_sys_h */ diff --git a/dlls/csx_sql/extra/include/mysql/my_tree.h b/dlls/csx_sql/extra/include/mysql/my_tree.h new file mode 100755 index 00000000..7cc7c615 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/my_tree.h @@ -0,0 +1,84 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef _tree_h +#define _tree_h +#ifdef __cplusplus +extern "C" { +#endif + +#define MAX_TREE_HIGHT 40 /* = max 1048576 leafs in tree */ +#define ELEMENT_KEY(tree,element)\ +(tree->offset_to_key ? (void*)((byte*) element+tree->offset_to_key) :\ + *((void**) (element+1))) + +#define tree_set_pointer(element,ptr) *((byte **) (element+1))=((byte*) (ptr)) + +typedef enum { left_root_right, right_root_left } TREE_WALK; +typedef uint32 element_count; +typedef int (*tree_walk_action)(void *,element_count,void *); + +typedef enum { free_init, free_free, free_end } TREE_FREE; +typedef void (*tree_element_free)(void*, TREE_FREE, void *); + +#ifdef MSDOS +typedef struct st_tree_element { + struct st_tree_element *left,*right; + unsigned long count; + uchar colour; /* black is marked as 1 */ +} TREE_ELEMENT; +#else +typedef struct st_tree_element { + struct st_tree_element *left,*right; + uint32 count:31, + colour:1; /* black is marked as 1 */ +} TREE_ELEMENT; +#endif /* MSDOS */ + +typedef struct st_tree { + TREE_ELEMENT *root,null_element; + TREE_ELEMENT **parents[MAX_TREE_HIGHT]; + uint offset_to_key,elements_in_tree,size_of_element,memory_limit,allocated; + qsort_cmp2 compare; + void* custom_arg; + MEM_ROOT mem_root; + my_bool with_delete; + tree_element_free free; +} TREE; + + /* Functions on whole tree */ +void init_tree(TREE *tree, uint default_alloc_size, uint memory_limit, + int size, qsort_cmp2 compare, my_bool with_delete, + tree_element_free free_element, void *custom_arg); +void delete_tree(TREE*); +void reset_tree(TREE*); + /* similar to delete tree, except we do not my_free() blocks in mem_root + */ +#define is_tree_inited(tree) ((tree)->root != 0) + + /* Functions on leafs */ +TREE_ELEMENT *tree_insert(TREE *tree,void *key,uint key_size); +void *tree_search(TREE *tree,void *key); +int tree_walk(TREE *tree,tree_walk_action action, + void *argument, TREE_WALK visit); +int tree_delete(TREE *tree,void *key); + +#define TREE_ELEMENT_EXTRA_SIZE (sizeof(TREE_ELEMENT) + sizeof(void*)) + +#ifdef __cplusplus +} +#endif +#endif diff --git a/dlls/csx_sql/extra/include/mysql/myisam.h b/dlls/csx_sql/extra/include/mysql/myisam.h new file mode 100755 index 00000000..87a40b50 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/myisam.h @@ -0,0 +1,448 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* This file should be included when using myisam_funktions */ + +#ifndef _myisam_h +#define _myisam_h +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef _my_base_h +#include +#endif +#ifndef _m_ctype_h +#include +#endif + + /* defines used by myisam-funktions */ + +/* The following defines can be increased if necessary */ +#define MI_MAX_KEY 32 /* Max allowed keys */ +#define MI_MAX_KEY_SEG 16 /* Max segments for key */ +#define MI_MAX_KEY_LENGTH 500 + +#define MI_MAX_KEY_BUFF (MI_MAX_KEY_LENGTH+MI_MAX_KEY_SEG*6+8+8) +#define MI_MAX_POSSIBLE_KEY_BUFF (1024+6+6) /* For myisam_chk */ +#define MI_MAX_POSSIBLE_KEY 64 /* For myisam_chk */ +#define MI_MAX_MSG_BUF 1024 /* used in CHECK TABLE, REPAIR TABLE */ +#define MI_NAME_IEXT ".MYI" +#define MI_NAME_DEXT ".MYD" +/* Max extra space to use when sorting keys */ +#define MI_MAX_TEMP_LENGTH 256*1024L*1024L + +/* Possible values for myisam_block_size (must be power of 2) */ +#define MI_KEY_BLOCK_LENGTH 1024 /* default key block length */ +#define MI_MIN_KEY_BLOCK_LENGTH 1024 /* Min key block length */ +#define MI_MAX_KEY_BLOCK_LENGTH 16384 + +#define mi_portable_sizeof_char_ptr 8 + +typedef uint32 ha_checksum; + + /* Param to/from mi_info */ + +typedef struct st_mi_isaminfo /* Struct from h_info */ +{ + ha_rows records; /* Records in database */ + ha_rows deleted; /* Deleted records in database */ + my_off_t recpos; /* Pos for last used record */ + my_off_t newrecpos; /* Pos if we write new record */ + my_off_t dupp_key_pos; /* Position to record with dupp key */ + my_off_t data_file_length, /* Length of data file */ + max_data_file_length, + index_file_length, + max_index_file_length, + delete_length; + ulong reclength; /* Recordlength */ + ulong mean_reclength; /* Mean recordlength (if packed) */ + ulonglong auto_increment; + ulonglong key_map; /* Which keys are used */ + char *data_file_name, *index_file_name; + uint keys; /* Number of keys in use */ + uint options; /* HA_OPTION_... used */ + int errkey, /* With key was dupplicated on err */ + sortkey; /* clustered by this key */ + File filenr; /* (uniq) filenr for datafile */ + time_t create_time; /* When table was created */ + time_t check_time; + time_t update_time; + uint reflength; + ulong record_offset; + ulong *rec_per_key; /* for sql optimizing */ + uint raid_type,raid_chunks; + ulong raid_chunksize; +} MI_ISAMINFO; + + +typedef struct st_mi_create_info +{ + const char *index_file_name, *data_file_name; /* If using symlinks */ + ha_rows max_rows; + ha_rows reloc_rows; + ulonglong auto_increment; + ulonglong data_file_length; + uint raid_type,raid_chunks; + ulong raid_chunksize; + uint old_options; + uint8 language; + my_bool with_auto_increment; +} MI_CREATE_INFO; + +struct st_myisam_info; /* For referense */ +typedef struct st_myisam_info MI_INFO; + +typedef struct st_mi_keyseg /* Key-portion */ +{ + uint8 type; /* Type of key (for sort) */ + uint8 language; + uint8 null_bit; /* bitmask to test for NULL */ + uint8 bit_start,bit_end; /* if bit field */ + uint16 flag; + uint16 length; /* Keylength */ + uint32 start; /* Start of key in record */ + uint32 null_pos; /* position to NULL indicator */ + CHARSET_INFO *charset; +} MI_KEYSEG; + + +struct st_mi_s_param; + +typedef struct st_mi_keydef /* Key definition with open & info */ +{ + uint16 keysegs; /* Number of key-segment */ + uint16 flag; /* NOSAME, PACK_USED */ + + uint8 key_alg; /* BTREE, RTREE */ + uint16 block_length; /* Length of keyblock (auto) */ + uint16 underflow_block_length; /* When to execute underflow */ + uint16 keylength; /* Tot length of keyparts (auto) */ + uint16 minlength; /* min length of (packed) key (auto) */ + uint16 maxlength; /* max length of (packed) key (auto) */ + uint16 block_size; /* block_size (auto) */ + uint32 version; /* For concurrent read/write */ + + MI_KEYSEG *seg,*end; + int (*bin_search)(struct st_myisam_info *info,struct st_mi_keydef *keyinfo, + uchar *page,uchar *key, + uint key_len,uint comp_flag,uchar * *ret_pos, + uchar *buff, my_bool *was_last_key); + uint (*get_key)(struct st_mi_keydef *keyinfo,uint nod_flag,uchar * *page, + uchar *key); + int (*pack_key)(struct st_mi_keydef *keyinfo,uint nod_flag,uchar *next_key, + uchar *org_key, uchar *prev_key, uchar *key, + struct st_mi_s_param *s_temp); + void (*store_key)(struct st_mi_keydef *keyinfo, uchar *key_pos, + struct st_mi_s_param *s_temp); +} MI_KEYDEF; + + +#define MI_UNIQUE_HASH_LENGTH 4 + +typedef struct st_unique_def /* Segment definition of unique */ +{ + uint16 keysegs; /* Number of key-segment */ + uchar key; /* Mapped to which key */ + uint8 null_are_equal; + MI_KEYSEG *seg,*end; +} MI_UNIQUEDEF; + +typedef struct st_mi_decode_tree /* Decode huff-table */ +{ + uint16 *table; + uint quick_table_bits; + byte *intervalls; +} MI_DECODE_TREE; + + +struct st_mi_bit_buff; + +/* + Note that null markers should always be first in a row ! + When creating a column, one should only specify: + type, length, null_bit and null_pos +*/ + +typedef struct st_columndef /* column information */ +{ + int16 type; /* en_fieldtype */ + uint16 length; /* length of field */ + uint32 offset; /* Offset to position in row */ + uint8 null_bit; /* If column may be 0 */ + uint16 null_pos; /* position for null marker */ + +#ifndef NOT_PACKED_DATABASES + void (*unpack)(struct st_columndef *rec,struct st_mi_bit_buff *buff, + uchar *start,uchar *end); + enum en_fieldtype base_type; + uint space_length_bits,pack_type; + MI_DECODE_TREE *huff_tree; +#endif +} MI_COLUMNDEF; + +/* invalidator function reference for Query Cache */ +typedef void (* invalidator_by_filename)(const char * filename); + +extern my_string myisam_log_filename; /* Name of logfile */ +extern uint myisam_block_size; +extern my_bool myisam_flush,myisam_delay_key_write,myisam_single_user; +extern my_bool myisam_concurrent_insert; +extern my_off_t myisam_max_temp_length,myisam_max_extra_temp_length; +extern ulong myisam_bulk_insert_tree_size; + + /* Prototypes for myisam-functions */ + +extern int mi_close(struct st_myisam_info *file); +extern int mi_delete(struct st_myisam_info *file,const byte *buff); +extern struct st_myisam_info *mi_open(const char *name,int mode, + uint wait_if_locked); +extern int mi_panic(enum ha_panic_function function); +extern int mi_rfirst(struct st_myisam_info *file,byte *buf,int inx); +extern int mi_rkey(struct st_myisam_info *file,byte *buf,int inx, + const byte *key, + uint key_len, enum ha_rkey_function search_flag); +extern int mi_rlast(struct st_myisam_info *file,byte *buf,int inx); +extern int mi_rnext(struct st_myisam_info *file,byte *buf,int inx); +extern int mi_rnext_same(struct st_myisam_info *info, byte *buf); +extern int mi_rprev(struct st_myisam_info *file,byte *buf,int inx); +extern int mi_rrnd(struct st_myisam_info *file,byte *buf, my_off_t pos); +extern int mi_scan_init(struct st_myisam_info *file); +extern int mi_scan(struct st_myisam_info *file,byte *buf); +extern int mi_rsame(struct st_myisam_info *file,byte *record,int inx); +extern int mi_rsame_with_pos(struct st_myisam_info *file,byte *record, + int inx, my_off_t pos); +extern int mi_update(struct st_myisam_info *file,const byte *old, + byte *new_record); +extern int mi_write(struct st_myisam_info *file,byte *buff); +extern my_off_t mi_position(struct st_myisam_info *file); +extern int mi_status(struct st_myisam_info *info, MI_ISAMINFO *x, uint flag); +extern int mi_lock_database(struct st_myisam_info *file,int lock_type); +extern int mi_create(const char *name,uint keys,MI_KEYDEF *keydef, + uint columns, MI_COLUMNDEF *columndef, + uint uniques, MI_UNIQUEDEF *uniquedef, + MI_CREATE_INFO *create_info, uint flags); +extern int mi_delete_table(const char *name); +extern int mi_rename(const char *from, const char *to); +extern int mi_extra(struct st_myisam_info *file, + enum ha_extra_function function, + void *extra_arg); +extern ha_rows mi_records_in_range(struct st_myisam_info *info,int inx, + const byte *start_key,uint start_key_len, + enum ha_rkey_function start_search_flag, + const byte *end_key,uint end_key_len, + enum ha_rkey_function end_search_flag); +extern int mi_log(int activate_log); +extern int mi_is_changed(struct st_myisam_info *info); +extern int mi_delete_all_rows(struct st_myisam_info *info); +extern ulong _mi_calc_blob_length(uint length , const byte *pos); +extern uint mi_get_pointer_length(ulonglong file_length, uint def); + +/* this is used to pass to mysql_myisamchk_table -- by Sasha Pachev */ + +#define MYISAMCHK_REPAIR 1 /* equivalent to myisamchk -r */ +#define MYISAMCHK_VERIFY 2 /* Verify, run repair if failure */ + +/* + Definitions needed for myisamchk.c + + Entries marked as "QQ to be removed" are NOT used to + pass check/repair options to mi_check.c. They are used + internally by myisamchk.c or/and ha_myisam.cc and should NOT + be stored together with other flags. They should be removed + from the following list to make addition of new flags possible. +*/ + +#define T_AUTO_INC 1 +#define T_AUTO_REPAIR 2 /* QQ to be removed */ +#define T_BACKUP_DATA 4 +#define T_CALC_CHECKSUM 8 +#define T_CHECK 16 /* QQ to be removed */ +#define T_CHECK_ONLY_CHANGED 32 /* QQ to be removed */ +#define T_CREATE_MISSING_KEYS 64 +#define T_DESCRIPT 128 +#define T_DONT_CHECK_CHECKSUM 256 +#define T_EXTEND 512 +#define T_FAST (1L << 10) /* QQ to be removed */ +#define T_FORCE_CREATE (1L << 11) /* QQ to be removed */ +#define T_FORCE_UNIQUENESS (1L << 12) +#define T_INFO (1L << 13) +#define T_MEDIUM (1L << 14) +#define T_QUICK (1L << 15) /* QQ to be removed */ +#define T_READONLY (1L << 16) /* QQ to be removed */ +#define T_REP (1L << 17) +#define T_REP_BY_SORT (1L << 18) /* QQ to be removed */ +#define T_REP_PARALLEL (1L << 19) /* QQ to be removed */ +#define T_RETRY_WITHOUT_QUICK (1L << 20) +#define T_SAFE_REPAIR (1L << 21) +#define T_SILENT (1L << 22) +#define T_SORT_INDEX (1L << 23) /* QQ to be removed */ +#define T_SORT_RECORDS (1L << 24) /* QQ to be removed */ +#define T_STATISTICS (1L << 25) +#define T_UNPACK (1L << 26) +#define T_UPDATE_STATE (1L << 27) +#define T_VERBOSE (1L << 28) +#define T_VERY_SILENT (1L << 29) +#define T_WAIT_FOREVER (1L << 30) +#define T_WRITE_LOOP ((ulong) 1L << 31) + +#define T_REP_ANY (T_REP | T_REP_BY_SORT | T_REP_PARALLEL) + +/* + Flags used by myisamchk.c or/and ha_myisam.cc that are NOT passed + to mi_check.c follows: +*/ + +#define TT_USEFRM 1 + +#define O_NEW_INDEX 1 /* Bits set in out_flag */ +#define O_NEW_DATA 2 +#define O_DATA_LOST 4 + +/* these struct is used by my_check to tell it what to do */ + +typedef struct st_sort_key_blocks /* Used when sorting */ +{ + uchar *buff,*end_pos; + uchar lastkey[MI_MAX_POSSIBLE_KEY_BUFF]; + uint last_length; + int inited; +} SORT_KEY_BLOCKS; + +typedef struct st_mi_check_param +{ + ulonglong auto_increment_value; + ulonglong max_data_file_length; + ulonglong keys_in_use; + my_off_t search_after_block; + my_off_t new_file_pos,key_file_blocks; + my_off_t keydata,totaldata,key_blocks,start_check_pos; + ha_rows total_records,total_deleted; + ha_checksum record_checksum,glob_crc; + ulong use_buffers,read_buffer_length,write_buffer_length, + sort_buffer_length,sort_key_blocks; + uint out_flag,warning_printed,error_printed,verbose; + uint opt_sort_key,total_files,max_level; + uint testflag; + uint8 language; + my_bool using_global_keycache, opt_lock_memory, opt_follow_links; + my_bool retry_repair, force_sort, calc_checksum; + char temp_filename[FN_REFLEN],*isam_file_name,*tmpdir; + int tmpfile_createflag; + myf myf_rw; + IO_CACHE read_cache; + ulonglong unique_count[MI_MAX_KEY_SEG+1]; + ha_checksum key_crc[MI_MAX_POSSIBLE_KEY]; + ulong rec_per_key_part[MI_MAX_KEY_SEG*MI_MAX_POSSIBLE_KEY]; + void *thd; + char *db_name,*table_name; + char *op_name; +} MI_CHECK; + + +typedef struct st_sort_info +{ + my_off_t filelength,dupp,buff_length; + ha_rows max_records; + uint current_key, total_keys; + myf myf_rw; + enum data_file_type new_data_file_type; + MI_INFO *info; + MI_CHECK *param; + char *buff; + SORT_KEY_BLOCKS *key_block,*key_block_end; + /* sync things*/ + uint got_error, threads_running; +#ifdef THREAD + pthread_mutex_t mutex; + pthread_cond_t cond; +#endif +} SORT_INFO; + + +typedef struct st_mi_sort_param +{ +#ifdef THREAD + pthread_t thr; +#endif + IO_CACHE read_cache, tempfile, tempfile_for_exceptions; + DYNAMIC_ARRAY buffpek; + ulonglong unique[MI_MAX_KEY_SEG+1]; + my_off_t pos,max_pos,filepos,start_recpos; + uint key, key_length,real_key_length,sortbuff_size; + uint maxbuffers, keys, find_length, sort_keys_length; + my_bool fix_datafile, master; + MI_KEYDEF *keyinfo; + SORT_INFO *sort_info; + uchar **sort_keys; + byte *rec_buff; + void *wordlist, *wordptr; + char *record; + char *tmpdir; + int (*key_cmp)(struct st_mi_sort_param *, const void *, const void *); + int (*key_read)(struct st_mi_sort_param *,void *); + int (*key_write)(struct st_mi_sort_param *, const void *); + void (*lock_in_memory)(MI_CHECK *); +} MI_SORT_PARAM; + + +/* functions in mi_check */ +void myisamchk_init(MI_CHECK *param); +int chk_status(MI_CHECK *param, MI_INFO *info); +int chk_del(MI_CHECK *param, register MI_INFO *info, uint test_flag); +int chk_size(MI_CHECK *param, MI_INFO *info); +int chk_key(MI_CHECK *param, MI_INFO *info); +int chk_data_link(MI_CHECK *param, MI_INFO *info,int extend); +int mi_repair(MI_CHECK *param, register MI_INFO *info, + my_string name, int rep_quick); +int mi_sort_index(MI_CHECK *param, register MI_INFO *info, my_string name); +int mi_repair_by_sort(MI_CHECK *param, register MI_INFO *info, + const char * name, int rep_quick); +int mi_repair_parallel(MI_CHECK *param, register MI_INFO *info, + const char * name, int rep_quick); +int change_to_newfile(const char * filename, const char * old_ext, + const char * new_ext, uint raid_chunks, + myf myflags); +int lock_file(MI_CHECK *param, File file, my_off_t start, int lock_type, + const char *filetype, const char *filename); +void lock_memory(MI_CHECK *param); +int flush_blocks(MI_CHECK *param, File file); +void update_auto_increment_key(MI_CHECK *param, MI_INFO *info, + my_bool repair); +int update_state_info(MI_CHECK *param, MI_INFO *info,uint update); +void update_key_parts(MI_KEYDEF *keyinfo, ulong *rec_per_key_part, + ulonglong *unique, ulonglong records); +int filecopy(MI_CHECK *param, File to,File from,my_off_t start, + my_off_t length, const char *type); +int movepoint(MI_INFO *info,byte *record,my_off_t oldpos, + my_off_t newpos, uint prot_key); +int sort_write_record(MI_SORT_PARAM *sort_param); +int write_data_suffix(SORT_INFO *sort_info, my_bool fix_datafile); +int _create_index_by_sort(MI_SORT_PARAM *info,my_bool no_messages, ulong); +int test_if_almost_full(MI_INFO *info); +int recreate_table(MI_CHECK *param, MI_INFO **org_info, char *filename); +void mi_disable_non_unique_index(MI_INFO *info, ha_rows rows); +my_bool mi_test_if_sort_rep(MI_INFO *info, ha_rows rows, ulonglong key_map, + my_bool force); + +int mi_init_bulk_insert(MI_INFO *info, ulong cache_size, ha_rows rows); +void mi_flush_bulk_insert(MI_INFO *info, uint inx); +void mi_end_bulk_insert(MI_INFO *info); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/dlls/csx_sql/extra/include/mysql/myisammrg.h b/dlls/csx_sql/extra/include/mysql/myisammrg.h new file mode 100755 index 00000000..ea882450 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/myisammrg.h @@ -0,0 +1,112 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* This file should be included when using merge_isam_funktions */ + +#ifndef _myisammrg_h +#define _myisammrg_h +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef _my_base_h +#include +#endif +#ifndef _myisam_h +#include +#endif + +#include + +#define MYRG_NAME_EXT ".MRG" + +/* In which table to INSERT rows */ +#define MERGE_INSERT_DISABLED 0 +#define MERGE_INSERT_TO_FIRST 1 +#define MERGE_INSERT_TO_LAST 2 + +extern TYPELIB merge_insert_method; + + /* Param to/from myrg_info */ + +typedef struct st_mymerge_info /* Struct from h_info */ +{ + ulonglong records; /* Records in database */ + ulonglong deleted; /* Deleted records in database */ + ulonglong recpos; /* Pos for last used record */ + ulonglong data_file_length; + uint reclength; /* Recordlength */ + int errkey; /* With key was dupplicated on err */ + uint options; /* HA_OPTION_... used */ + ulong *rec_per_key; /* for sql optimizing */ +} MYMERGE_INFO; + +typedef struct st_myrg_table_info +{ + struct st_myisam_info *table; + ulonglong file_offset; +} MYRG_TABLE; + +typedef struct st_myrg_info +{ + MYRG_TABLE *open_tables,*current_table,*end_table,*last_used_table; + ulonglong records; /* records in tables */ + ulonglong del; /* Removed records */ + ulonglong data_file_length; + ulong cache_size; + uint merge_insert_method; + uint tables,options,reclength,keys; + my_bool cache_in_use; + LIST open_list; + QUEUE by_key; + ulong *rec_per_key_part; /* for sql optimizing */ +} MYRG_INFO; + + + /* Prototypes for merge-functions */ + +extern int myrg_close(MYRG_INFO *file); +extern int myrg_delete(MYRG_INFO *file,const byte *buff); +extern MYRG_INFO *myrg_open(const char *name,int mode,int wait_if_locked); +extern int myrg_panic(enum ha_panic_function function); +extern int myrg_rfirst(MYRG_INFO *file,byte *buf,int inx); +extern int myrg_rlast(MYRG_INFO *file,byte *buf,int inx); +extern int myrg_rnext(MYRG_INFO *file,byte *buf,int inx); +extern int myrg_rprev(MYRG_INFO *file,byte *buf,int inx); +extern int myrg_rkey(MYRG_INFO *file,byte *buf,int inx,const byte *key, + uint key_len, enum ha_rkey_function search_flag); +extern int myrg_rrnd(MYRG_INFO *file,byte *buf,ulonglong pos); +extern int myrg_rsame(MYRG_INFO *file,byte *record,int inx); +extern int myrg_update(MYRG_INFO *file,const byte *old,byte *new_rec); +extern int myrg_write(MYRG_INFO *info,byte *rec); +extern int myrg_status(MYRG_INFO *file,MYMERGE_INFO *x,int flag); +extern int myrg_lock_database(MYRG_INFO *file,int lock_type); +extern int myrg_create(const char *name, const char **table_names, + uint insert_method, my_bool fix_names); +extern int myrg_extra(MYRG_INFO *file,enum ha_extra_function function, + void *extra_arg); +extern void myrg_extrafunc(MYRG_INFO *info,invalidator_by_filename inv); +extern ha_rows myrg_records_in_range(MYRG_INFO *info,int inx, + const byte *start_key,uint start_key_len, + enum ha_rkey_function start_search_flag, + const byte *end_key,uint end_key_len, + enum ha_rkey_function end_search_flag); + +extern ulonglong myrg_position(MYRG_INFO *info); +#ifdef __cplusplus +} +#endif +#endif diff --git a/dlls/csx_sql/extra/include/mysql/myisampack.h b/dlls/csx_sql/extra/include/mysql/myisampack.h new file mode 100755 index 00000000..6004177c --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/myisampack.h @@ -0,0 +1,229 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* + Storing of values in high byte first order. + + integer keys and file pointers are stored with high byte first to get + better compression +*/ + +#define mi_sint2korr(A) (int16) (((int16) ((uchar) (A)[1])) +\ + ((int16) ((int16) (A)[0]) << 8)) +#define mi_sint3korr(A) ((int32) ((((uchar) (A)[0]) & 128) ? \ + (((uint32) 255L << 24) | \ + (((uint32) (uchar) (A)[0]) << 16) |\ + (((uint32) (uchar) (A)[1]) << 8) | \ + ((uint32) (uchar) (A)[2])) : \ + (((uint32) (uchar) (A)[0]) << 16) |\ + (((uint32) (uchar) (A)[1]) << 8) | \ + ((uint32) (uchar) (A)[2]))) +#define mi_sint4korr(A) (int32) (((int32) ((uchar) (A)[3])) +\ + (((int32) ((uchar) (A)[2]) << 8)) +\ + (((int32) ((uchar) (A)[1]) << 16)) +\ + (((int32) ((int16) (A)[0]) << 24))) +#define mi_sint8korr(A) (longlong) mi_uint8korr(A) +#define mi_uint2korr(A) (uint16) (((uint16) ((uchar) (A)[1])) +\ + ((uint16) ((uchar) (A)[0]) << 8)) +#define mi_uint3korr(A) (uint32) (((uint32) ((uchar) (A)[2])) +\ + (((uint32) ((uchar) (A)[1])) << 8) +\ + (((uint32) ((uchar) (A)[0])) << 16)) +#define mi_uint4korr(A) (uint32) (((uint32) ((uchar) (A)[3])) +\ + (((uint32) ((uchar) (A)[2])) << 8) +\ + (((uint32) ((uchar) (A)[1])) << 16) +\ + (((uint32) ((uchar) (A)[0])) << 24)) +#define mi_uint5korr(A) ((ulonglong)(((uint32) ((uchar) (A)[4])) +\ + (((uint32) ((uchar) (A)[3])) << 8) +\ + (((uint32) ((uchar) (A)[2])) << 16) +\ + (((uint32) ((uchar) (A)[1])) << 24)) +\ + (((ulonglong) ((uchar) (A)[0])) << 32)) +#define mi_uint6korr(A) ((ulonglong)(((uint32) ((uchar) (A)[5])) +\ + (((uint32) ((uchar) (A)[4])) << 8) +\ + (((uint32) ((uchar) (A)[3])) << 16) +\ + (((uint32) ((uchar) (A)[2])) << 24)) +\ + (((ulonglong) (((uint32) ((uchar) (A)[1])) +\ + (((uint32) ((uchar) (A)[0]) << 8)))) <<\ + 32)) +#define mi_uint7korr(A) ((ulonglong)(((uint32) ((uchar) (A)[6])) +\ + (((uint32) ((uchar) (A)[5])) << 8) +\ + (((uint32) ((uchar) (A)[4])) << 16) +\ + (((uint32) ((uchar) (A)[3])) << 24)) +\ + (((ulonglong) (((uint32) ((uchar) (A)[2])) +\ + (((uint32) ((uchar) (A)[1])) << 8) +\ + (((uint32) ((uchar) (A)[0])) << 16))) <<\ + 32)) +#define mi_uint8korr(A) ((ulonglong)(((uint32) ((uchar) (A)[7])) +\ + (((uint32) ((uchar) (A)[6])) << 8) +\ + (((uint32) ((uchar) (A)[5])) << 16) +\ + (((uint32) ((uchar) (A)[4])) << 24)) +\ + (((ulonglong) (((uint32) ((uchar) (A)[3])) +\ + (((uint32) ((uchar) (A)[2])) << 8) +\ + (((uint32) ((uchar) (A)[1])) << 16) +\ + (((uint32) ((uchar) (A)[0])) << 24))) <<\ + 32)) + +#define mi_int2store(T,A) { uint def_temp= (uint) (A) ;\ + *((uchar*) ((T)+1))= (uchar)(def_temp); \ + *((uchar*) ((T)+0))= (uchar)(def_temp >> 8); } +#define mi_int3store(T,A) { /*lint -save -e734 */\ + ulong def_temp= (ulong) (A);\ + *(((T)+2))=(char) (def_temp);\ + *((T)+1)= (char) (def_temp >> 8);\ + *((T)+0)= (char) (def_temp >> 16);\ + /*lint -restore */} +#define mi_int4store(T,A) { ulong def_temp= (ulong) (A);\ + *((T)+3)=(char) (def_temp);\ + *((T)+2)=(char) (def_temp >> 8);\ + *((T)+1)=(char) (def_temp >> 16);\ + *((T)+0)=(char) (def_temp >> 24); } +#define mi_int5store(T,A) { ulong def_temp= (ulong) (A),\ + def_temp2= (ulong) ((A) >> 32);\ + *((T)+4)=(char) (def_temp);\ + *((T)+3)=(char) (def_temp >> 8);\ + *((T)+2)=(char) (def_temp >> 16);\ + *((T)+1)=(char) (def_temp >> 24);\ + *((T)+0)=(char) (def_temp2); } +#define mi_int6store(T,A) { ulong def_temp= (ulong) (A),\ + def_temp2= (ulong) ((A) >> 32);\ + *((T)+5)=(char) (def_temp);\ + *((T)+4)=(char) (def_temp >> 8);\ + *((T)+3)=(char) (def_temp >> 16);\ + *((T)+2)=(char) (def_temp >> 24);\ + *((T)+1)=(char) (def_temp2);\ + *((T)+0)=(char) (def_temp2 >> 8); } +#define mi_int7store(T,A) { ulong def_temp= (ulong) (A),\ + def_temp2= (ulong) ((A) >> 32);\ + *((T)+6)=(char) (def_temp);\ + *((T)+5)=(char) (def_temp >> 8);\ + *((T)+4)=(char) (def_temp >> 16);\ + *((T)+3)=(char) (def_temp >> 24);\ + *((T)+2)=(char) (def_temp2);\ + *((T)+1)=(char) (def_temp2 >> 8);\ + *((T)+0)=(char) (def_temp2 >> 16); } +#define mi_int8store(T,A) { ulong def_temp3= (ulong) (A), \ + def_temp4= (ulong) ((A) >> 32); \ + mi_int4store((T),def_temp4); \ + mi_int4store((T+4),def_temp3); \ + } + +#ifdef WORDS_BIGENDIAN + +#define mi_float4store(T,A) { *(T)= ((byte *) &A)[0];\ + *((T)+1)=(char) ((byte *) &A)[1];\ + *((T)+2)=(char) ((byte *) &A)[2];\ + *((T)+3)=(char) ((byte *) &A)[3]; } + +#define mi_float4get(V,M) { float def_temp;\ + ((byte*) &def_temp)[0]=(M)[0];\ + ((byte*) &def_temp)[1]=(M)[1];\ + ((byte*) &def_temp)[2]=(M)[2];\ + ((byte*) &def_temp)[3]=(M)[3];\ + (V)=def_temp; } + +#define mi_float8store(T,V) { *(T)= ((byte *) &V)[0];\ + *((T)+1)=(char) ((byte *) &V)[1];\ + *((T)+2)=(char) ((byte *) &V)[2];\ + *((T)+3)=(char) ((byte *) &V)[3];\ + *((T)+4)=(char) ((byte *) &V)[4];\ + *((T)+5)=(char) ((byte *) &V)[5];\ + *((T)+6)=(char) ((byte *) &V)[6];\ + *((T)+7)=(char) ((byte *) &V)[7]; } + +#define mi_float8get(V,M) { double def_temp;\ + ((byte*) &def_temp)[0]=(M)[0];\ + ((byte*) &def_temp)[1]=(M)[1];\ + ((byte*) &def_temp)[2]=(M)[2];\ + ((byte*) &def_temp)[3]=(M)[3];\ + ((byte*) &def_temp)[4]=(M)[4];\ + ((byte*) &def_temp)[5]=(M)[5];\ + ((byte*) &def_temp)[6]=(M)[6];\ + ((byte*) &def_temp)[7]=(M)[7]; \ + (V)=def_temp; } +#else + +#define mi_float4store(T,A) { *(T)= ((byte *) &A)[3];\ + *((T)+1)=(char) ((byte *) &A)[2];\ + *((T)+2)=(char) ((byte *) &A)[1];\ + *((T)+3)=(char) ((byte *) &A)[0]; } + +#define mi_float4get(V,M) { float def_temp;\ + ((byte*) &def_temp)[0]=(M)[3];\ + ((byte*) &def_temp)[1]=(M)[2];\ + ((byte*) &def_temp)[2]=(M)[1];\ + ((byte*) &def_temp)[3]=(M)[0];\ + (V)=def_temp; } + +#if defined(__FLOAT_WORD_ORDER) && (__FLOAT_WORD_ORDER == __BIG_ENDIAN) +#define mi_float8store(T,V) { *(T)= ((byte *) &V)[3];\ + *((T)+1)=(char) ((byte *) &V)[2];\ + *((T)+2)=(char) ((byte *) &V)[1];\ + *((T)+3)=(char) ((byte *) &V)[0];\ + *((T)+4)=(char) ((byte *) &V)[7];\ + *((T)+5)=(char) ((byte *) &V)[6];\ + *((T)+6)=(char) ((byte *) &V)[5];\ + *((T)+7)=(char) ((byte *) &V)[4];} + +#define mi_float8get(V,M) { double def_temp;\ + ((byte*) &def_temp)[0]=(M)[3];\ + ((byte*) &def_temp)[1]=(M)[2];\ + ((byte*) &def_temp)[2]=(M)[1];\ + ((byte*) &def_temp)[3]=(M)[0];\ + ((byte*) &def_temp)[4]=(M)[7];\ + ((byte*) &def_temp)[5]=(M)[6];\ + ((byte*) &def_temp)[6]=(M)[5];\ + ((byte*) &def_temp)[7]=(M)[4];\ + (V)=def_temp; } + +#else +#define mi_float8store(T,V) { *(T)= ((byte *) &V)[7];\ + *((T)+1)=(char) ((byte *) &V)[6];\ + *((T)+2)=(char) ((byte *) &V)[5];\ + *((T)+3)=(char) ((byte *) &V)[4];\ + *((T)+4)=(char) ((byte *) &V)[3];\ + *((T)+5)=(char) ((byte *) &V)[2];\ + *((T)+6)=(char) ((byte *) &V)[1];\ + *((T)+7)=(char) ((byte *) &V)[0];} + +#define mi_float8get(V,M) { double def_temp;\ + ((byte*) &def_temp)[0]=(M)[7];\ + ((byte*) &def_temp)[1]=(M)[6];\ + ((byte*) &def_temp)[2]=(M)[5];\ + ((byte*) &def_temp)[3]=(M)[4];\ + ((byte*) &def_temp)[4]=(M)[3];\ + ((byte*) &def_temp)[5]=(M)[2];\ + ((byte*) &def_temp)[6]=(M)[1];\ + ((byte*) &def_temp)[7]=(M)[0];\ + (V)=def_temp; } +#endif /* __FLOAT_WORD_ORDER */ +#endif /* WORDS_BIGENDIAN */ + +/* Fix to avoid warnings when sizeof(ha_rows) == sizeof(long) */ + +#ifdef BIG_TABLES +#define mi_rowstore(T,A) mi_int8store(T,A) +#define mi_rowkorr(T) mi_uint8korr(T) +#else +#define mi_rowstore(T,A) { mi_int4store(T,0); mi_int4store(((T)+4),A); } +#define mi_rowkorr(T) mi_uint4korr((T)+4) +#endif + +#if SIZEOF_OFF_T > 4 +#define mi_sizestore(T,A) mi_int8store(T,A) +#define mi_sizekorr(T) mi_uint8korr(T) +#else +#define mi_sizestore(T,A) { if ((A) == HA_OFFSET_ERROR) bfill((char*) (T),8,255); else { mi_int4store((T),0); mi_int4store(((T)+4),A); }} +#define mi_sizekorr(T) mi_uint4korr((T)+4) +#endif diff --git a/dlls/csx_sql/extra/include/mysql/mysql.h b/dlls/csx_sql/extra/include/mysql/mysql.h new file mode 100755 index 00000000..3ffc014c --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/mysql.h @@ -0,0 +1,441 @@ +/* Copyright (C) 2000-2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef _mysql_h +#define _mysql_h + +#ifdef __CYGWIN__ /* CYGWIN implements a UNIX API */ +#undef WIN +#undef _WIN +#undef _WIN32 +#undef _WIN64 +#undef __WIN__ +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef _global_h /* If not standard header */ +#include +#ifdef __LCC__ +#include /* For windows */ +#endif +typedef char my_bool; +#if (defined(_WIN32) || defined(_WIN64)) && !defined(__WIN__) +#define __WIN__ +#endif +#if !defined(__WIN__) +#define STDCALL +#else +#define STDCALL __stdcall +#endif +typedef char * gptr; + +#ifndef my_socket_defined +#ifdef __WIN__ +#define my_socket SOCKET +#else +typedef int my_socket; +#endif /* __WIN__ */ +#endif /* my_socket_defined */ +#endif /* _global_h */ + +#include "mysql_com.h" +#include "mysql_version.h" + +extern unsigned int mysql_port; +extern char *mysql_unix_port; + +#define CLIENT_NET_READ_TIMEOUT 365*24*3600 /* Timeout on read */ +#define CLIENT_NET_WRITE_TIMEOUT 365*24*3600 /* Timeout on write */ + +#ifdef __NETWARE__ +#pragma pack(push, 8) /* 8 byte alignment */ +#endif + +#define IS_PRI_KEY(n) ((n) & PRI_KEY_FLAG) +#define IS_NOT_NULL(n) ((n) & NOT_NULL_FLAG) +#define IS_BLOB(n) ((n) & BLOB_FLAG) +#define IS_NUM(t) ((t) <= FIELD_TYPE_INT24 || (t) == FIELD_TYPE_YEAR) +#define IS_NUM_FIELD(f) ((f)->flags & NUM_FLAG) +#define INTERNAL_NUM_FIELD(f) (((f)->type <= FIELD_TYPE_INT24 && ((f)->type != FIELD_TYPE_TIMESTAMP || (f)->length == 14 || (f)->length == 8)) || (f)->type == FIELD_TYPE_YEAR) + +typedef struct st_mysql_field { + char *name; /* Name of column */ + char *table; /* Table of column if column was a field */ + char *org_table; /* Org table name if table was an alias */ + char *db; /* Database for table */ + char *def; /* Default value (set by mysql_list_fields) */ + unsigned long length; /* Width of column */ + unsigned long max_length; /* Max width of selected set */ + unsigned int flags; /* Div flags */ + unsigned int decimals; /* Number of decimals in field */ + enum enum_field_types type; /* Type of field. Se mysql_com.h for types */ +} MYSQL_FIELD; + +typedef char **MYSQL_ROW; /* return data as array of strings */ +typedef unsigned int MYSQL_FIELD_OFFSET; /* offset to current field */ + +#if defined(NO_CLIENT_LONG_LONG) +typedef unsigned long my_ulonglong; +#elif defined (__WIN__) +typedef unsigned __int64 my_ulonglong; +#else +typedef unsigned long long my_ulonglong; +#endif + +#define MYSQL_COUNT_ERROR (~(my_ulonglong) 0) + +typedef struct st_mysql_rows { + struct st_mysql_rows *next; /* list of rows */ + MYSQL_ROW data; +} MYSQL_ROWS; + +typedef MYSQL_ROWS *MYSQL_ROW_OFFSET; /* offset to current row */ + +#include "my_alloc.h" + +typedef struct st_mysql_data { + my_ulonglong rows; + unsigned int fields; + MYSQL_ROWS *data; + MEM_ROOT alloc; +} MYSQL_DATA; + +struct st_mysql_options { + unsigned int connect_timeout,client_flag; + unsigned int port; + char *host,*init_command,*user,*password,*unix_socket,*db; + char *my_cnf_file,*my_cnf_group, *charset_dir, *charset_name; + char *ssl_key; /* PEM key file */ + char *ssl_cert; /* PEM cert file */ + char *ssl_ca; /* PEM CA file */ + char *ssl_capath; /* PEM directory of CA-s? */ + char *ssl_cipher; /* cipher to use */ + unsigned long max_allowed_packet; + my_bool use_ssl; /* if to use SSL or not */ + my_bool compress,named_pipe; + /* + On connect, find out the replication role of the server, and + establish connections to all the peers + */ + my_bool rpl_probe; + /* + Each call to mysql_real_query() will parse it to tell if it is a read + or a write, and direct it to the slave or the master + */ + my_bool rpl_parse; + /* + If set, never read from a master,only from slave, when doing + a read that is replication-aware + */ + my_bool no_master_reads; +}; + +enum mysql_option { MYSQL_OPT_CONNECT_TIMEOUT, MYSQL_OPT_COMPRESS, + MYSQL_OPT_NAMED_PIPE, MYSQL_INIT_COMMAND, + MYSQL_READ_DEFAULT_FILE, MYSQL_READ_DEFAULT_GROUP, + MYSQL_SET_CHARSET_DIR, MYSQL_SET_CHARSET_NAME, + MYSQL_OPT_LOCAL_INFILE}; + +enum mysql_status { MYSQL_STATUS_READY,MYSQL_STATUS_GET_RESULT, + MYSQL_STATUS_USE_RESULT}; + +/* + There are three types of queries - the ones that have to go to + the master, the ones that go to a slave, and the adminstrative + type which must happen on the pivot connectioin +*/ +enum mysql_rpl_type { MYSQL_RPL_MASTER, MYSQL_RPL_SLAVE, + MYSQL_RPL_ADMIN }; + + +typedef struct st_mysql { + NET net; /* Communication parameters */ + gptr connector_fd; /* ConnectorFd for SSL */ + char *host,*user,*passwd,*unix_socket,*server_version,*host_info, + *info,*db; + struct charset_info_st *charset; + MYSQL_FIELD *fields; + MEM_ROOT field_alloc; + my_ulonglong affected_rows; + my_ulonglong insert_id; /* id if insert on table with NEXTNR */ + my_ulonglong extra_info; /* Used by mysqlshow */ + unsigned long thread_id; /* Id for connection in server */ + unsigned long packet_length; + unsigned int port,client_flag,server_capabilities; + unsigned int protocol_version; + unsigned int field_count; + unsigned int server_status; + unsigned int server_language; + struct st_mysql_options options; + enum mysql_status status; + my_bool free_me; /* If free in mysql_close */ + my_bool reconnect; /* set to 1 if automatic reconnect */ + char scramble_buff[9]; + + /* + Set if this is the original connection, not a master or a slave we have + added though mysql_rpl_probe() or mysql_set_master()/ mysql_add_slave() + */ + my_bool rpl_pivot; + /* + Pointers to the master, and the next slave connections, points to + itself if lone connection. + */ + struct st_mysql* master, *next_slave; + + struct st_mysql* last_used_slave; /* needed for round-robin slave pick */ + /* needed for send/read/store/use result to work correctly with replication */ + struct st_mysql* last_used_con; +} MYSQL; + + +typedef struct st_mysql_res { + my_ulonglong row_count; + MYSQL_FIELD *fields; + MYSQL_DATA *data; + MYSQL_ROWS *data_cursor; + unsigned long *lengths; /* column lengths of current row */ + MYSQL *handle; /* for unbuffered reads */ + MEM_ROOT field_alloc; + unsigned int field_count, current_field; + MYSQL_ROW row; /* If unbuffered read */ + MYSQL_ROW current_row; /* buffer to current row */ + my_bool eof; /* Used by mysql_fetch_row */ +} MYSQL_RES; + +#define MAX_MYSQL_MANAGER_ERR 256 +#define MAX_MYSQL_MANAGER_MSG 256 + +#define MANAGER_OK 200 +#define MANAGER_INFO 250 +#define MANAGER_ACCESS 401 +#define MANAGER_CLIENT_ERR 450 +#define MANAGER_INTERNAL_ERR 500 + + + +typedef struct st_mysql_manager +{ + NET net; + char *host,*user,*passwd; + unsigned int port; + my_bool free_me; + my_bool eof; + int cmd_status; + int last_errno; + char* net_buf,*net_buf_pos,*net_data_end; + int net_buf_size; + char last_error[MAX_MYSQL_MANAGER_ERR]; +} MYSQL_MANAGER; + +/* + Set up and bring down the server; to ensure that applications will + work when linked against either the standard client library or the + embedded server library, these functions should be called. +*/ +int STDCALL mysql_server_init(int argc, char **argv, char **groups); +void STDCALL mysql_server_end(void); + +/* + Set up and bring down a thread; these function should be called + for each thread in an application which opens at least one MySQL + connection. All uses of the connection(s) should be between these + function calls. +*/ +my_bool STDCALL mysql_thread_init(void); +void STDCALL mysql_thread_end(void); + +/* + Functions to get information from the MYSQL and MYSQL_RES structures + Should definitely be used if one uses shared libraries. +*/ + +my_ulonglong STDCALL mysql_num_rows(MYSQL_RES *res); +unsigned int STDCALL mysql_num_fields(MYSQL_RES *res); +my_bool STDCALL mysql_eof(MYSQL_RES *res); +MYSQL_FIELD *STDCALL mysql_fetch_field_direct(MYSQL_RES *res, + unsigned int fieldnr); +MYSQL_FIELD * STDCALL mysql_fetch_fields(MYSQL_RES *res); +MYSQL_ROW_OFFSET STDCALL mysql_row_tell(MYSQL_RES *res); +MYSQL_FIELD_OFFSET STDCALL mysql_field_tell(MYSQL_RES *res); + +unsigned int STDCALL mysql_field_count(MYSQL *mysql); +my_ulonglong STDCALL mysql_affected_rows(MYSQL *mysql); +my_ulonglong STDCALL mysql_insert_id(MYSQL *mysql); +unsigned int STDCALL mysql_errno(MYSQL *mysql); +const char * STDCALL mysql_error(MYSQL *mysql); +const char * STDCALL mysql_info(MYSQL *mysql); +unsigned long STDCALL mysql_thread_id(MYSQL *mysql); +const char * STDCALL mysql_character_set_name(MYSQL *mysql); + +MYSQL * STDCALL mysql_init(MYSQL *mysql); +int STDCALL mysql_ssl_set(MYSQL *mysql, const char *key, + const char *cert, const char *ca, + const char *capath, const char *cipher); +my_bool STDCALL mysql_change_user(MYSQL *mysql, const char *user, + const char *passwd, const char *db); +MYSQL * STDCALL mysql_real_connect(MYSQL *mysql, const char *host, + const char *user, + const char *passwd, + const char *db, + unsigned int port, + const char *unix_socket, + unsigned int clientflag); +void STDCALL mysql_close(MYSQL *sock); +int STDCALL mysql_select_db(MYSQL *mysql, const char *db); +int STDCALL mysql_query(MYSQL *mysql, const char *q); +int STDCALL mysql_send_query(MYSQL *mysql, const char *q, + unsigned long length); +int STDCALL mysql_read_query_result(MYSQL *mysql); +int STDCALL mysql_real_query(MYSQL *mysql, const char *q, + unsigned long length); +/* perform query on master */ +int STDCALL mysql_master_query(MYSQL *mysql, const char *q, + unsigned long length); +int STDCALL mysql_master_send_query(MYSQL *mysql, const char *q, + unsigned long length); +/* perform query on slave */ +int STDCALL mysql_slave_query(MYSQL *mysql, const char *q, + unsigned long length); +int STDCALL mysql_slave_send_query(MYSQL *mysql, const char *q, + unsigned long length); + +/* + enable/disable parsing of all queries to decide if they go on master or + slave +*/ +void STDCALL mysql_enable_rpl_parse(MYSQL* mysql); +void STDCALL mysql_disable_rpl_parse(MYSQL* mysql); +/* get the value of the parse flag */ +int STDCALL mysql_rpl_parse_enabled(MYSQL* mysql); + +/* enable/disable reads from master */ +void STDCALL mysql_enable_reads_from_master(MYSQL* mysql); +void STDCALL mysql_disable_reads_from_master(MYSQL* mysql); +/* get the value of the master read flag */ +int STDCALL mysql_reads_from_master_enabled(MYSQL* mysql); + +enum mysql_rpl_type STDCALL mysql_rpl_query_type(const char* q, int len); + +/* discover the master and its slaves */ +int STDCALL mysql_rpl_probe(MYSQL* mysql); + +/* set the master, close/free the old one, if it is not a pivot */ +int STDCALL mysql_set_master(MYSQL* mysql, const char* host, + unsigned int port, + const char* user, + const char* passwd); +int STDCALL mysql_add_slave(MYSQL* mysql, const char* host, + unsigned int port, + const char* user, + const char* passwd); + +int STDCALL mysql_shutdown(MYSQL *mysql); +int STDCALL mysql_dump_debug_info(MYSQL *mysql); +int STDCALL mysql_refresh(MYSQL *mysql, + unsigned int refresh_options); +int STDCALL mysql_kill(MYSQL *mysql,unsigned long pid); +int STDCALL mysql_ping(MYSQL *mysql); +const char * STDCALL mysql_stat(MYSQL *mysql); +const char * STDCALL mysql_get_server_info(MYSQL *mysql); +const char * STDCALL mysql_get_client_info(void); +unsigned long STDCALL mysql_get_client_version(void); +const char * STDCALL mysql_get_host_info(MYSQL *mysql); +unsigned int STDCALL mysql_get_proto_info(MYSQL *mysql); +MYSQL_RES * STDCALL mysql_list_dbs(MYSQL *mysql,const char *wild); +MYSQL_RES * STDCALL mysql_list_tables(MYSQL *mysql,const char *wild); +MYSQL_RES * STDCALL mysql_list_fields(MYSQL *mysql, const char *table, + const char *wild); +MYSQL_RES * STDCALL mysql_list_processes(MYSQL *mysql); +MYSQL_RES * STDCALL mysql_store_result(MYSQL *mysql); +MYSQL_RES * STDCALL mysql_use_result(MYSQL *mysql); +int STDCALL mysql_options(MYSQL *mysql,enum mysql_option option, + const char *arg); +void STDCALL mysql_free_result(MYSQL_RES *result); +void STDCALL mysql_data_seek(MYSQL_RES *result, + my_ulonglong offset); +MYSQL_ROW_OFFSET STDCALL mysql_row_seek(MYSQL_RES *result, + MYSQL_ROW_OFFSET offset); +MYSQL_FIELD_OFFSET STDCALL mysql_field_seek(MYSQL_RES *result, + MYSQL_FIELD_OFFSET offset); +MYSQL_ROW STDCALL mysql_fetch_row(MYSQL_RES *result); +unsigned long * STDCALL mysql_fetch_lengths(MYSQL_RES *result); +MYSQL_FIELD * STDCALL mysql_fetch_field(MYSQL_RES *result); +unsigned long STDCALL mysql_escape_string(char *to,const char *from, + unsigned long from_length); +unsigned long STDCALL mysql_real_escape_string(MYSQL *mysql, + char *to,const char *from, + unsigned long length); +void STDCALL mysql_debug(const char *debug); +char * STDCALL mysql_odbc_escape_string(MYSQL *mysql, + char *to, + unsigned long to_length, + const char *from, + unsigned long from_length, + void *param, + char * + (*extend_buffer) + (void *, char *to, + unsigned long *length)); +void STDCALL myodbc_remove_escape(MYSQL *mysql,char *name); +unsigned int STDCALL mysql_thread_safe(void); +MYSQL_MANAGER* STDCALL mysql_manager_init(MYSQL_MANAGER* con); +MYSQL_MANAGER* STDCALL mysql_manager_connect(MYSQL_MANAGER* con, + const char* host, + const char* user, + const char* passwd, + unsigned int port); +void STDCALL mysql_manager_close(MYSQL_MANAGER* con); +int STDCALL mysql_manager_command(MYSQL_MANAGER* con, + const char* cmd, int cmd_len); +int STDCALL mysql_manager_fetch_line(MYSQL_MANAGER* con, + char* res_buf, + int res_buf_size); +#define mysql_reload(mysql) mysql_refresh((mysql),REFRESH_GRANT) + +#ifdef USE_OLD_FUNCTIONS +MYSQL * STDCALL mysql_connect(MYSQL *mysql, const char *host, + const char *user, const char *passwd); +int STDCALL mysql_create_db(MYSQL *mysql, const char *DB); +int STDCALL mysql_drop_db(MYSQL *mysql, const char *DB); +#define mysql_reload(mysql) mysql_refresh((mysql),REFRESH_GRANT) +#endif +#define HAVE_MYSQL_REAL_CONNECT + +/* + The following functions are mainly exported because of mysqlbinlog; + They are not for general usage +*/ + +int simple_command(MYSQL *mysql,enum enum_server_command command, + const char *arg, unsigned long length, my_bool skipp_check); +unsigned long net_safe_read(MYSQL* mysql); +int mysql_once_init(void); + +extern my_bool server_inited; + +#ifdef __NETWARE__ +#pragma pack(pop) /* restore alignment */ +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* _mysql_h */ diff --git a/dlls/csx_sql/extra/include/mysql/mysql_com.h b/dlls/csx_sql/extra/include/mysql/mysql_com.h new file mode 100755 index 00000000..e183a0ed --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/mysql_com.h @@ -0,0 +1,256 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* +** Common definition between mysql server & client +*/ + +#ifndef _mysql_com_h +#define _mysql_com_h + +#define NAME_LEN 64 /* Field/table name length */ +#define HOSTNAME_LENGTH 60 +#define USERNAME_LENGTH 16 +#define SERVER_VERSION_LENGTH 60 + +#define LOCAL_HOST "localhost" +#define LOCAL_HOST_NAMEDPIPE "." + +#if defined(__WIN__) && !defined( _CUSTOMCONFIG_) +#define MYSQL_NAMEDPIPE "MySQL" +#define MYSQL_SERVICENAME "MySQL" +#endif /* __WIN__ */ + +enum enum_server_command { + COM_SLEEP, COM_QUIT, COM_INIT_DB, COM_QUERY, COM_FIELD_LIST, + COM_CREATE_DB, COM_DROP_DB, COM_REFRESH, COM_SHUTDOWN, COM_STATISTICS, + COM_PROCESS_INFO, COM_CONNECT, COM_PROCESS_KILL, COM_DEBUG, COM_PING, + COM_TIME, COM_DELAYED_INSERT, COM_CHANGE_USER, COM_BINLOG_DUMP, + COM_TABLE_DUMP, COM_CONNECT_OUT, COM_REGISTER_SLAVE, + COM_END /* Must be last! */ +}; + +#define NOT_NULL_FLAG 1 /* Field can't be NULL */ +#define PRI_KEY_FLAG 2 /* Field is part of a primary key */ +#define UNIQUE_KEY_FLAG 4 /* Field is part of a unique key */ +#define MULTIPLE_KEY_FLAG 8 /* Field is part of a key */ +#define BLOB_FLAG 16 /* Field is a blob */ +#define UNSIGNED_FLAG 32 /* Field is unsigned */ +#define ZEROFILL_FLAG 64 /* Field is zerofill */ +#define BINARY_FLAG 128 +/* The following are only sent to new clients */ +#define ENUM_FLAG 256 /* field is an enum */ +#define AUTO_INCREMENT_FLAG 512 /* field is a autoincrement field */ +#define TIMESTAMP_FLAG 1024 /* Field is a timestamp */ +#define SET_FLAG 2048 /* field is a set */ +#define NUM_FLAG 32768 /* Field is num (for clients) */ +#define PART_KEY_FLAG 16384 /* Intern; Part of some key */ +#define GROUP_FLAG 32768 /* Intern: Group field */ +#define UNIQUE_FLAG 65536 /* Intern: Used by sql_yacc */ + +#define REFRESH_GRANT 1 /* Refresh grant tables */ +#define REFRESH_LOG 2 /* Start on new log file */ +#define REFRESH_TABLES 4 /* close all tables */ +#define REFRESH_HOSTS 8 /* Flush host cache */ +#define REFRESH_STATUS 16 /* Flush status variables */ +#define REFRESH_THREADS 32 /* Flush thread cache */ +#define REFRESH_SLAVE 64 /* Reset master info and restart slave + thread */ +#define REFRESH_MASTER 128 /* Remove all bin logs in the index + and truncate the index */ + +/* The following can't be set with mysql_refresh() */ +#define REFRESH_READ_LOCK 16384 /* Lock tables for read */ +#define REFRESH_FAST 32768 /* Intern flag */ + +/* RESET (remove all queries) from query cache */ +#define REFRESH_QUERY_CACHE 65536 +#define REFRESH_QUERY_CACHE_FREE 0x20000L /* pack query cache */ +#define REFRESH_DES_KEY_FILE 0x40000L +#define REFRESH_USER_RESOURCES 0x80000L + +#define CLIENT_LONG_PASSWORD 1 /* new more secure passwords */ +#define CLIENT_FOUND_ROWS 2 /* Found instead of affected rows */ +#define CLIENT_LONG_FLAG 4 /* Get all column flags */ +#define CLIENT_CONNECT_WITH_DB 8 /* One can specify db on connect */ +#define CLIENT_NO_SCHEMA 16 /* Don't allow database.table.column */ +#define CLIENT_COMPRESS 32 /* Can use compression protocol */ +#define CLIENT_ODBC 64 /* Odbc client */ +#define CLIENT_LOCAL_FILES 128 /* Can use LOAD DATA LOCAL */ +#define CLIENT_IGNORE_SPACE 256 /* Ignore spaces before '(' */ +#define CLIENT_INTERACTIVE 1024 /* This is an interactive client */ +#define CLIENT_SSL 2048 /* Switch to SSL after handshake */ +#define CLIENT_IGNORE_SIGPIPE 4096 /* IGNORE sigpipes */ +#define CLIENT_TRANSACTIONS 8192 /* Client knows about transactions */ + +#define SERVER_STATUS_IN_TRANS 1 /* Transaction has started */ +#define SERVER_STATUS_AUTOCOMMIT 2 /* Server in auto_commit mode */ + +#define MYSQL_ERRMSG_SIZE 200 +#define NET_READ_TIMEOUT 30 /* Timeout on read */ +#define NET_WRITE_TIMEOUT 60 /* Timeout on write */ +#define NET_WAIT_TIMEOUT 8*60*60 /* Wait for new query */ + +struct st_vio; /* Only C */ +typedef struct st_vio Vio; + +#define MAX_CHAR_WIDTH 255 /* Max length for a CHAR colum */ +#define MAX_BLOB_WIDTH 8192 /* Default width for blob */ + +typedef struct st_net { + Vio* vio; + unsigned char *buff,*buff_end,*write_pos,*read_pos; + my_socket fd; /* For Perl DBI/dbd */ + unsigned long max_packet,max_packet_size; + unsigned int last_errno,pkt_nr,compress_pkt_nr; + unsigned int write_timeout, read_timeout, retry_count; + int fcntl; + char last_error[MYSQL_ERRMSG_SIZE]; + unsigned char error; + my_bool return_errno,compress; + /* + The following variable is set if we are doing several queries in one + command ( as in LOAD TABLE ... FROM MASTER ), + and do not want to confuse the client with OK at the wrong time + */ + unsigned long remain_in_buf,length, buf_length, where_b; + unsigned int *return_status; + unsigned char reading_or_writing; + char save_char; + my_bool no_send_ok; + gptr query_cache_query; +} NET; + +#define packet_error (~(unsigned long) 0) + +enum enum_field_types { FIELD_TYPE_DECIMAL, FIELD_TYPE_TINY, + FIELD_TYPE_SHORT, FIELD_TYPE_LONG, + FIELD_TYPE_FLOAT, FIELD_TYPE_DOUBLE, + FIELD_TYPE_NULL, FIELD_TYPE_TIMESTAMP, + FIELD_TYPE_LONGLONG,FIELD_TYPE_INT24, + FIELD_TYPE_DATE, FIELD_TYPE_TIME, + FIELD_TYPE_DATETIME, FIELD_TYPE_YEAR, + FIELD_TYPE_NEWDATE, + FIELD_TYPE_ENUM=247, + FIELD_TYPE_SET=248, + FIELD_TYPE_TINY_BLOB=249, + FIELD_TYPE_MEDIUM_BLOB=250, + FIELD_TYPE_LONG_BLOB=251, + FIELD_TYPE_BLOB=252, + FIELD_TYPE_VAR_STRING=253, + FIELD_TYPE_STRING=254, + FIELD_TYPE_GEOMETRY=255 +}; + +#define FIELD_TYPE_CHAR FIELD_TYPE_TINY /* For compability */ +#define FIELD_TYPE_INTERVAL FIELD_TYPE_ENUM /* For compability */ + +#define net_new_transaction(net) ((net)->pkt_nr=0) + +#ifdef __cplusplus +extern "C" { +#endif + +int my_net_init(NET *net, Vio* vio); +void my_net_local_init(NET *net); +void net_end(NET *net); +void net_clear(NET *net); +int net_flush(NET *net); +int my_net_write(NET *net,const char *packet,unsigned long len); +int net_write_command(NET *net,unsigned char command,const char *packet, + unsigned long len); +int net_real_write(NET *net,const char *packet,unsigned long len); +unsigned long my_net_read(NET *net); + +/* The following function is not meant for normal usage */ +struct sockaddr; +int my_connect(my_socket s, const struct sockaddr *name, unsigned int namelen, + unsigned int timeout); + +struct rand_struct { + unsigned long seed1,seed2,max_value; + double max_value_dbl; +}; + +#ifdef __cplusplus +} +#endif + + /* The following is for user defined functions */ + +enum Item_result {STRING_RESULT,REAL_RESULT,INT_RESULT}; + +typedef struct st_udf_args +{ + unsigned int arg_count; /* Number of arguments */ + enum Item_result *arg_type; /* Pointer to item_results */ + char **args; /* Pointer to argument */ + unsigned long *lengths; /* Length of string arguments */ + char *maybe_null; /* Set to 1 for all maybe_null args */ +} UDF_ARGS; + + /* This holds information about the result */ + +typedef struct st_udf_init +{ + my_bool maybe_null; /* 1 if function can return NULL */ + unsigned int decimals; /* for real functions */ + unsigned long max_length; /* For string functions */ + char *ptr; /* free pointer for function data */ + my_bool const_item; /* 0 if result is independent of arguments */ +} UDF_INIT; + + /* Constants when using compression */ +#define NET_HEADER_SIZE 4 /* standard header size */ +#define COMP_HEADER_SIZE 3 /* compression header extra size */ + + /* Prototypes to password functions */ + +#ifdef __cplusplus +extern "C" { +#endif + +extern unsigned long max_allowed_packet; +extern unsigned long net_buffer_length; + +void randominit(struct rand_struct *,unsigned long seed1, + unsigned long seed2); +double my_rnd(struct rand_struct *); +void make_scrambled_password(char *to,const char *password); +void get_salt_from_password(unsigned long *res,const char *password); +void make_password_from_salt(char *to, unsigned long *hash_res); +char *scramble(char *to,const char *message,const char *password, + my_bool old_ver); +my_bool check_scramble(const char *, const char *message, + unsigned long *salt,my_bool old_ver); +char *get_tty_password(char *opt_message); +void hash_password(unsigned long *result, const char *password); + +/* Some other useful functions */ + +my_bool my_init(void); +int load_defaults(const char *conf_file, const char **groups, + int *argc, char ***argv); +my_bool my_thread_init(void); +void my_thread_end(void); + +#ifdef __cplusplus +} +#endif + +#define NULL_LENGTH ((unsigned long) ~0) /* For net_store_length */ + +#endif diff --git a/dlls/csx_sql/extra/include/mysql/mysql_embed.h b/dlls/csx_sql/extra/include/mysql/mysql_embed.h new file mode 100755 index 00000000..bc75c3fb --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/mysql_embed.h @@ -0,0 +1,34 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* Defines that are unique to the embedded version of MySQL */ + +#ifdef EMBEDDED_LIBRARY + +/* Things we don't need in the embedded version of MySQL */ + +#undef HAVE_PSTACK /* No stacktrace */ +#undef HAVE_DLOPEN /* No udf functions */ +#undef HAVE_OPENSSL +#undef HAVE_VIO +#undef HAVE_ISAM + +#define DONT_USE_RAID + +#undef MYSQL_SERVER_SUFFIX +#define MYSQL_SERVER_SUFFIX "-embedded" + +#endif /* EMBEDDED_LIBRARY */ diff --git a/dlls/csx_sql/extra/include/mysql/mysql_version.h b/dlls/csx_sql/extra/include/mysql/mysql_version.h new file mode 100755 index 00000000..35faa702 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/mysql_version.h @@ -0,0 +1,29 @@ +/* Copyright Abandoned 1996, 1999, 2001 MySQL AB + This file is public domain and comes with NO WARRANTY of any kind */ + +/* Version numbers for protocol & mysqld */ + +#ifndef _mysql_version_h +#define _mysql_version_h +#ifdef _CUSTOMCONFIG_ +#include +#else +#define PROTOCOL_VERSION 10 +#define MYSQL_SERVER_VERSION "4.0.18" +#define MYSQL_BASE_VERSION "mysqld-4.0" +#ifndef MYSQL_SERVER_SUFFIX +#define MYSQL_SERVER_SUFFIX "" +#endif +#define FRM_VER 6 +#define MYSQL_VERSION_ID 40018 +#define MYSQL_PORT 3306 +#define MYSQL_UNIX_ADDR "/tmp/mysql.sock" +#define MYSQL_CONFIG_NAME "my" +#define MYSQL_COMPILATION_COMMENT "Source distribution" + +/* mysqld compile time options */ +#ifndef MYSQL_CHARSET +#define MYSQL_CHARSET "latin1" +#endif /* MYSQL_CHARSET */ +#endif /* _CUSTOMCONFIG_ */ +#endif /* _mysql_version_h */ diff --git a/dlls/csx_sql/extra/include/mysql/mysqld_error.h b/dlls/csx_sql/extra/include/mysql/mysqld_error.h new file mode 100755 index 00000000..acc9b596 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/mysqld_error.h @@ -0,0 +1,258 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* Definefile for error messagenumbers */ + +#define ER_HASHCHK 1000 +#define ER_NISAMCHK 1001 +#define ER_NO 1002 +#define ER_YES 1003 +#define ER_CANT_CREATE_FILE 1004 +#define ER_CANT_CREATE_TABLE 1005 +#define ER_CANT_CREATE_DB 1006 +#define ER_DB_CREATE_EXISTS 1007 +#define ER_DB_DROP_EXISTS 1008 +#define ER_DB_DROP_DELETE 1009 +#define ER_DB_DROP_RMDIR 1010 +#define ER_CANT_DELETE_FILE 1011 +#define ER_CANT_FIND_SYSTEM_REC 1012 +#define ER_CANT_GET_STAT 1013 +#define ER_CANT_GET_WD 1014 +#define ER_CANT_LOCK 1015 +#define ER_CANT_OPEN_FILE 1016 +#define ER_FILE_NOT_FOUND 1017 +#define ER_CANT_READ_DIR 1018 +#define ER_CANT_SET_WD 1019 +#define ER_CHECKREAD 1020 +#define ER_DISK_FULL 1021 +#define ER_DUP_KEY 1022 +#define ER_ERROR_ON_CLOSE 1023 +#define ER_ERROR_ON_READ 1024 +#define ER_ERROR_ON_RENAME 1025 +#define ER_ERROR_ON_WRITE 1026 +#define ER_FILE_USED 1027 +#define ER_FILSORT_ABORT 1028 +#define ER_FORM_NOT_FOUND 1029 +#define ER_GET_ERRNO 1030 +#define ER_ILLEGAL_HA 1031 +#define ER_KEY_NOT_FOUND 1032 +#define ER_NOT_FORM_FILE 1033 +#define ER_NOT_KEYFILE 1034 +#define ER_OLD_KEYFILE 1035 +#define ER_OPEN_AS_READONLY 1036 +#define ER_OUTOFMEMORY 1037 +#define ER_OUT_OF_SORTMEMORY 1038 +#define ER_UNEXPECTED_EOF 1039 +#define ER_CON_COUNT_ERROR 1040 +#define ER_OUT_OF_RESOURCES 1041 +#define ER_BAD_HOST_ERROR 1042 +#define ER_HANDSHAKE_ERROR 1043 +#define ER_DBACCESS_DENIED_ERROR 1044 +#define ER_ACCESS_DENIED_ERROR 1045 +#define ER_NO_DB_ERROR 1046 +#define ER_UNKNOWN_COM_ERROR 1047 +#define ER_BAD_NULL_ERROR 1048 +#define ER_BAD_DB_ERROR 1049 +#define ER_TABLE_EXISTS_ERROR 1050 +#define ER_BAD_TABLE_ERROR 1051 +#define ER_NON_UNIQ_ERROR 1052 +#define ER_SERVER_SHUTDOWN 1053 +#define ER_BAD_FIELD_ERROR 1054 +#define ER_WRONG_FIELD_WITH_GROUP 1055 +#define ER_WRONG_GROUP_FIELD 1056 +#define ER_WRONG_SUM_SELECT 1057 +#define ER_WRONG_VALUE_COUNT 1058 +#define ER_TOO_LONG_IDENT 1059 +#define ER_DUP_FIELDNAME 1060 +#define ER_DUP_KEYNAME 1061 +#define ER_DUP_ENTRY 1062 +#define ER_WRONG_FIELD_SPEC 1063 +#define ER_PARSE_ERROR 1064 +#define ER_EMPTY_QUERY 1065 +#define ER_NONUNIQ_TABLE 1066 +#define ER_INVALID_DEFAULT 1067 +#define ER_MULTIPLE_PRI_KEY 1068 +#define ER_TOO_MANY_KEYS 1069 +#define ER_TOO_MANY_KEY_PARTS 1070 +#define ER_TOO_LONG_KEY 1071 +#define ER_KEY_COLUMN_DOES_NOT_EXITS 1072 +#define ER_BLOB_USED_AS_KEY 1073 +#define ER_TOO_BIG_FIELDLENGTH 1074 +#define ER_WRONG_AUTO_KEY 1075 +#define ER_READY 1076 +#define ER_NORMAL_SHUTDOWN 1077 +#define ER_GOT_SIGNAL 1078 +#define ER_SHUTDOWN_COMPLETE 1079 +#define ER_FORCING_CLOSE 1080 +#define ER_IPSOCK_ERROR 1081 +#define ER_NO_SUCH_INDEX 1082 +#define ER_WRONG_FIELD_TERMINATORS 1083 +#define ER_BLOBS_AND_NO_TERMINATED 1084 +#define ER_TEXTFILE_NOT_READABLE 1085 +#define ER_FILE_EXISTS_ERROR 1086 +#define ER_LOAD_INFO 1087 +#define ER_ALTER_INFO 1088 +#define ER_WRONG_SUB_KEY 1089 +#define ER_CANT_REMOVE_ALL_FIELDS 1090 +#define ER_CANT_DROP_FIELD_OR_KEY 1091 +#define ER_INSERT_INFO 1092 +#define ER_INSERT_TABLE_USED 1093 +#define ER_NO_SUCH_THREAD 1094 +#define ER_KILL_DENIED_ERROR 1095 +#define ER_NO_TABLES_USED 1096 +#define ER_TOO_BIG_SET 1097 +#define ER_NO_UNIQUE_LOGFILE 1098 +#define ER_TABLE_NOT_LOCKED_FOR_WRITE 1099 +#define ER_TABLE_NOT_LOCKED 1100 +#define ER_BLOB_CANT_HAVE_DEFAULT 1101 +#define ER_WRONG_DB_NAME 1102 +#define ER_WRONG_TABLE_NAME 1103 +#define ER_TOO_BIG_SELECT 1104 +#define ER_UNKNOWN_ERROR 1105 +#define ER_UNKNOWN_PROCEDURE 1106 +#define ER_WRONG_PARAMCOUNT_TO_PROCEDURE 1107 +#define ER_WRONG_PARAMETERS_TO_PROCEDURE 1108 +#define ER_UNKNOWN_TABLE 1109 +#define ER_FIELD_SPECIFIED_TWICE 1110 +#define ER_INVALID_GROUP_FUNC_USE 1111 +#define ER_UNSUPPORTED_EXTENSION 1112 +#define ER_TABLE_MUST_HAVE_COLUMNS 1113 +#define ER_RECORD_FILE_FULL 1114 +#define ER_UNKNOWN_CHARACTER_SET 1115 +#define ER_TOO_MANY_TABLES 1116 +#define ER_TOO_MANY_FIELDS 1117 +#define ER_TOO_BIG_ROWSIZE 1118 +#define ER_STACK_OVERRUN 1119 +#define ER_WRONG_OUTER_JOIN 1120 +#define ER_NULL_COLUMN_IN_INDEX 1121 +#define ER_CANT_FIND_UDF 1122 +#define ER_CANT_INITIALIZE_UDF 1123 +#define ER_UDF_NO_PATHS 1124 +#define ER_UDF_EXISTS 1125 +#define ER_CANT_OPEN_LIBRARY 1126 +#define ER_CANT_FIND_DL_ENTRY 1127 +#define ER_FUNCTION_NOT_DEFINED 1128 +#define ER_HOST_IS_BLOCKED 1129 +#define ER_HOST_NOT_PRIVILEGED 1130 +#define ER_PASSWORD_ANONYMOUS_USER 1131 +#define ER_PASSWORD_NOT_ALLOWED 1132 +#define ER_PASSWORD_NO_MATCH 1133 +#define ER_UPDATE_INFO 1134 +#define ER_CANT_CREATE_THREAD 1135 +#define ER_WRONG_VALUE_COUNT_ON_ROW 1136 +#define ER_CANT_REOPEN_TABLE 1137 +#define ER_INVALID_USE_OF_NULL 1138 +#define ER_REGEXP_ERROR 1139 +#define ER_MIX_OF_GROUP_FUNC_AND_FIELDS 1140 +#define ER_NONEXISTING_GRANT 1141 +#define ER_TABLEACCESS_DENIED_ERROR 1142 +#define ER_COLUMNACCESS_DENIED_ERROR 1143 +#define ER_ILLEGAL_GRANT_FOR_TABLE 1144 +#define ER_GRANT_WRONG_HOST_OR_USER 1145 +#define ER_NO_SUCH_TABLE 1146 +#define ER_NONEXISTING_TABLE_GRANT 1147 +#define ER_NOT_ALLOWED_COMMAND 1148 +#define ER_SYNTAX_ERROR 1149 +#define ER_DELAYED_CANT_CHANGE_LOCK 1150 +#define ER_TOO_MANY_DELAYED_THREADS 1151 +#define ER_ABORTING_CONNECTION 1152 +#define ER_NET_PACKET_TOO_LARGE 1153 +#define ER_NET_READ_ERROR_FROM_PIPE 1154 +#define ER_NET_FCNTL_ERROR 1155 +#define ER_NET_PACKETS_OUT_OF_ORDER 1156 +#define ER_NET_UNCOMPRESS_ERROR 1157 +#define ER_NET_READ_ERROR 1158 +#define ER_NET_READ_INTERRUPTED 1159 +#define ER_NET_ERROR_ON_WRITE 1160 +#define ER_NET_WRITE_INTERRUPTED 1161 +#define ER_TOO_LONG_STRING 1162 +#define ER_TABLE_CANT_HANDLE_BLOB 1163 +#define ER_TABLE_CANT_HANDLE_AUTO_INCREMENT 1164 +#define ER_DELAYED_INSERT_TABLE_LOCKED 1165 +#define ER_WRONG_COLUMN_NAME 1166 +#define ER_WRONG_KEY_COLUMN 1167 +#define ER_WRONG_MRG_TABLE 1168 +#define ER_DUP_UNIQUE 1169 +#define ER_BLOB_KEY_WITHOUT_LENGTH 1170 +#define ER_PRIMARY_CANT_HAVE_NULL 1171 +#define ER_TOO_MANY_ROWS 1172 +#define ER_REQUIRES_PRIMARY_KEY 1173 +#define ER_NO_RAID_COMPILED 1174 +#define ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE 1175 +#define ER_KEY_DOES_NOT_EXITS 1176 +#define ER_CHECK_NO_SUCH_TABLE 1177 +#define ER_CHECK_NOT_IMPLEMENTED 1178 +#define ER_CANT_DO_THIS_DURING_AN_TRANSACTION 1179 +#define ER_ERROR_DURING_COMMIT 1180 +#define ER_ERROR_DURING_ROLLBACK 1181 +#define ER_ERROR_DURING_FLUSH_LOGS 1182 +#define ER_ERROR_DURING_CHECKPOINT 1183 +#define ER_NEW_ABORTING_CONNECTION 1184 +#define ER_DUMP_NOT_IMPLEMENTED 1185 +#define ER_FLUSH_MASTER_BINLOG_CLOSED 1186 +#define ER_INDEX_REBUILD 1187 +#define ER_MASTER 1188 +#define ER_MASTER_NET_READ 1189 +#define ER_MASTER_NET_WRITE 1190 +#define ER_FT_MATCHING_KEY_NOT_FOUND 1191 +#define ER_LOCK_OR_ACTIVE_TRANSACTION 1192 +#define ER_UNKNOWN_SYSTEM_VARIABLE 1193 +#define ER_CRASHED_ON_USAGE 1194 +#define ER_CRASHED_ON_REPAIR 1195 +#define ER_WARNING_NOT_COMPLETE_ROLLBACK 1196 +#define ER_TRANS_CACHE_FULL 1197 +#define ER_SLAVE_MUST_STOP 1198 +#define ER_SLAVE_NOT_RUNNING 1199 +#define ER_BAD_SLAVE 1200 +#define ER_MASTER_INFO 1201 +#define ER_SLAVE_THREAD 1202 +#define ER_TOO_MANY_USER_CONNECTIONS 1203 +#define ER_SET_CONSTANTS_ONLY 1204 +#define ER_LOCK_WAIT_TIMEOUT 1205 +#define ER_LOCK_TABLE_FULL 1206 +#define ER_READ_ONLY_TRANSACTION 1207 +#define ER_DROP_DB_WITH_READ_LOCK 1208 +#define ER_CREATE_DB_WITH_READ_LOCK 1209 +#define ER_WRONG_ARGUMENTS 1210 +#define ER_NO_PERMISSION_TO_CREATE_USER 1211 +#define ER_UNION_TABLES_IN_DIFFERENT_DIR 1212 +#define ER_LOCK_DEADLOCK 1213 +#define ER_TABLE_CANT_HANDLE_FULLTEXT 1214 +#define ER_CANNOT_ADD_FOREIGN 1215 +#define ER_NO_REFERENCED_ROW 1216 +#define ER_ROW_IS_REFERENCED 1217 +#define ER_CONNECT_TO_MASTER 1218 +#define ER_QUERY_ON_MASTER 1219 +#define ER_ERROR_WHEN_EXECUTING_COMMAND 1220 +#define ER_WRONG_USAGE 1221 +#define ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT 1222 +#define ER_CANT_UPDATE_WITH_READLOCK 1223 +#define ER_MIXING_NOT_ALLOWED 1224 +#define ER_DUP_ARGUMENT 1225 +#define ER_USER_LIMIT_REACHED 1226 +#define ER_SPECIFIC_ACCESS_DENIED_ERROR 1227 +#define ER_LOCAL_VARIABLE 1228 +#define ER_GLOBAL_VARIABLE 1229 +#define ER_NO_DEFAULT 1230 +#define ER_WRONG_VALUE_FOR_VAR 1231 +#define ER_WRONG_TYPE_FOR_VAR 1232 +#define ER_VAR_CANT_BE_READ 1233 +#define ER_CANT_USE_OPTION_HERE 1234 +#define ER_NOT_SUPPORTED_YET 1235 +#define ER_MASTER_FATAL_ERROR_READING_BINLOG 1236 +#define ER_SLAVE_IGNORED_TABLE 1237 /* only the slave SQL thread can be sent this */ +#define ER_INCORRECT_GLOBAL_LOCAL_VAR 1238 +#define ER_ERROR_MESSAGES 239 diff --git a/dlls/csx_sql/extra/include/mysql/mysys_err.h b/dlls/csx_sql/extra/include/mysql/mysys_err.h new file mode 100755 index 00000000..0ee89e91 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/mysys_err.h @@ -0,0 +1,77 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef _mysys_err_h +#define _mysys_err_h +#ifdef __cplusplus +extern "C" { +#endif + +#define GLOB 0 /* Error maps */ +#define GLOBERRS 28 /* Max number of error messages in map's */ +#define EE(X) globerrs[ X ] /* Defines to add error to right map */ + +extern const char * NEAR globerrs[]; /* my_error_messages is here */ + +/* Error message numbers in global map */ +#define EE_FILENOTFOUND 0 +#define EE_CANTCREATEFILE 1 +#define EE_READ 2 +#define EE_WRITE 3 +#define EE_BADCLOSE 4 +#define EE_OUTOFMEMORY 5 +#define EE_DELETE 6 +#define EE_LINK 7 +#define EE_EOFERR 9 +#define EE_CANTLOCK 10 +#define EE_CANTUNLOCK 11 +#define EE_DIR 12 +#define EE_STAT 13 +#define EE_CANT_CHSIZE 14 +#define EE_CANT_OPEN_STREAM 15 +#define EE_GETWD 16 +#define EE_SETWD 17 +#define EE_LINK_WARNING 18 +#define EE_OPEN_WARNING 19 +#define EE_DISK_FULL 20 +#define EE_CANT_MKDIR 21 +#define EE_UNKNOWN_CHARSET 22 +#define EE_OUT_OF_FILERESOURCES 23 +#define EE_CANT_READLINK 24 +#define EE_CANT_SYMLINK 25 +#define EE_REALPATH 26 +#define EE_SYNC 27 + + /* exit codes for all MySQL programs */ + +#define EXIT_UNSPECIFIED_ERROR 1 +#define EXIT_UNKNOWN_OPTION 2 +#define EXIT_AMBIGUOUS_OPTION 3 +#define EXIT_NO_ARGUMENT_ALLOWED 4 +#define EXIT_ARGUMENT_REQUIRED 5 +#define EXIT_VAR_PREFIX_NOT_UNIQUE 6 +#define EXIT_UNKNOWN_VARIABLE 7 +#define EXIT_OUT_OF_MEMORY 8 +#define EXIT_UNKNOWN_SUFFIX 9 +#define EXIT_NO_PTR_TO_VARIABLE 10 +#define EXIT_CANNOT_CONNECT_TO_SERVICE 11 + + +#ifdef __cplusplus +} +#endif +#endif + diff --git a/dlls/csx_sql/extra/include/mysql/nisam.h b/dlls/csx_sql/extra/include/mysql/nisam.h new file mode 100755 index 00000000..e8f29991 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/nisam.h @@ -0,0 +1,212 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* This file should be included when using nisam_funktions */ +/* Author: Michael Widenius */ + +#ifndef _nisam_h +#define _nisam_h +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef _my_base_h +#include +#endif + /* defines used by nisam-funktions */ + +#define N_MAXKEY 16 /* Max allowed keys */ +#define N_MAXKEY_SEG 16 /* Max segments for key */ +#define N_MAX_KEY_LENGTH 256 /* May be increased up to 500 */ +#define N_MAX_KEY_BUFF (N_MAX_KEY_LENGTH+N_MAXKEY_SEG+sizeof(double)-1) +#define N_MAX_POSSIBLE_KEY_BUFF 500+9 + +#define N_NAME_IEXT ".ISM" +#define N_NAME_DEXT ".ISD" +#define NI_POS_ERROR (~ (ulong) 0) + + + /* Param to/from nisam_info */ + +typedef struct st_n_isaminfo /* Struct from h_info */ +{ + ulong records; /* Records in database */ + ulong deleted; /* Deleted records in database */ + ulong recpos; /* Pos for last used record */ + ulong newrecpos; /* Pos if we write new record */ + ulong dupp_key_pos; /* Position to record with dupp key */ + ulong data_file_length, /* Length of data file */ + max_data_file_length, + index_file_length, + max_index_file_length, + delete_length; + uint reclength; /* Recordlength */ + uint mean_reclength; /* Mean recordlength (if packed) */ + uint keys; /* How many keys used */ + uint options; /* HA_OPTION_... used */ + int errkey, /* With key was dupplicated on err */ + sortkey; /* clustered by this key */ + File filenr; /* (uniq) filenr for datafile */ + time_t create_time; /* When table was created */ + time_t isamchk_time; + time_t update_time; + ulong *rec_per_key; /* for sql optimizing */ +} N_ISAMINFO; + + + /* Info saved on file for each info-part */ + +#ifdef __WATCOMC__ +#pragma pack(2) +#define uint uint16 /* Same format as in MSDOS */ +#endif + +#ifdef __ZTC__ +#pragma ZTC align 2 +#define uint uint16 /* Same format as in MSDOS */ +#endif + +typedef struct st_n_save_keyseg /* Key-portion */ +{ + uint8 type; /* Typ av nyckel (f|r sort) */ + uint8 flag; /* HA_DIFF_LENGTH */ + uint16 start; /* Start of key in record */ + uint16 length; /* Keylength */ +} N_SAVE_KEYSEG; + +typedef struct st_n_save_keydef /* Key definition with create & info */ +{ + uint8 flag; /* NOSAME, PACK_USED */ + uint8 keysegs; /* Number of key-segment */ + uint16 block_length; /* Length of keyblock (auto) */ + uint16 keylength; /* Tot length of keyparts (auto) */ + uint16 minlength; /* min length of (packed) key (auto) */ + uint16 maxlength; /* max length of (packed) key (auto) */ +} N_SAVE_KEYDEF; + +typedef struct st_n_save_recinfo /* Info of record */ +{ + int16 type; /* en_fieldtype */ + uint16 length; /* length of field */ +} N_SAVE_RECINFO; + + +#ifdef __ZTC__ +#pragma ZTC align +#undef uint +#endif + +#ifdef __WATCOMC__ +#pragma pack() +#undef uint +#endif + + +struct st_isam_info; /* For referense */ + +#ifndef ISAM_LIBRARY +typedef struct st_isam_info N_INFO; +#endif + +typedef struct st_n_keyseg /* Key-portion */ +{ + N_SAVE_KEYSEG base; +} N_KEYSEG; + + +typedef struct st_n_keydef /* Key definition with open & info */ +{ + N_SAVE_KEYDEF base; + N_KEYSEG seg[N_MAXKEY_SEG+1]; + int (*bin_search)(struct st_isam_info *info,struct st_n_keydef *keyinfo, + uchar *page,uchar *key, + uint key_len,uint comp_flag,uchar * *ret_pos, + uchar *buff); + uint (*get_key)(struct st_n_keydef *keyinfo,uint nod_flag,uchar * *page, + uchar *key); +} N_KEYDEF; + + +typedef struct st_decode_tree /* Decode huff-table */ +{ + uint16 *table; + uint quick_table_bits; + byte *intervalls; +} DECODE_TREE; + + +struct st_bit_buff; + +typedef struct st_n_recinfo /* Info of record */ +{ + N_SAVE_RECINFO base; +#ifndef NOT_PACKED_DATABASES + void (*unpack)(struct st_n_recinfo *rec,struct st_bit_buff *buff, + uchar *start,uchar *end); + enum en_fieldtype base_type; + uint space_length_bits,pack_type; + DECODE_TREE *huff_tree; +#endif +} N_RECINFO; + + +extern my_string nisam_log_filename; /* Name of logfile */ +extern uint nisam_block_size; +extern my_bool nisam_flush; + + /* Prototypes for nisam-functions */ + +extern int nisam_close(struct st_isam_info *file); +extern int nisam_delete(struct st_isam_info *file,const byte *buff); +extern struct st_isam_info *nisam_open(const char *name,int mode, + uint wait_if_locked); +extern int nisam_panic(enum ha_panic_function function); +extern int nisam_rfirst(struct st_isam_info *file,byte *buf,int inx); +extern int nisam_rkey(struct st_isam_info *file,byte *buf,int inx, + const byte *key, + uint key_len, enum ha_rkey_function search_flag); +extern int nisam_rlast(struct st_isam_info *file,byte *buf,int inx); +extern int nisam_rnext(struct st_isam_info *file,byte *buf,int inx); +extern int nisam_rprev(struct st_isam_info *file,byte *buf,int inx); +extern int nisam_rrnd(struct st_isam_info *file,byte *buf,ulong pos); +extern int nisam_rsame(struct st_isam_info *file,byte *record,int inx); +extern int nisam_rsame_with_pos(struct st_isam_info *file,byte *record, + int inx,ulong pos); +extern int nisam_update(struct st_isam_info *file,const byte *old, + const byte *new_record); +extern int nisam_write(struct st_isam_info *file,const byte *buff); +extern int nisam_info(struct st_isam_info *file,N_ISAMINFO *x,int flag); +extern ulong nisam_position(struct st_isam_info *info); +extern int nisam_lock_database(struct st_isam_info *file,int lock_type); +extern int nisam_create(const char *name,uint keys,N_KEYDEF *keyinfo, + N_RECINFO *recinfo,ulong records, + ulong reloc,uint flags,uint options, + ulong data_file_length); +extern int nisam_extra(struct st_isam_info *file, + enum ha_extra_function function); +extern ulong nisam_records_in_range(struct st_isam_info *info,int inx, + const byte *start_key,uint start_key_len, + enum ha_rkey_function start_search_flag, + const byte *end_key,uint end_key_len, + enum ha_rkey_function end_search_flag); +extern int nisam_log(int activate_log); +extern int nisam_is_changed(struct st_isam_info *info); +extern uint _calc_blob_length(uint length , const byte *pos); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/dlls/csx_sql/extra/include/mysql/queues.h b/dlls/csx_sql/extra/include/mysql/queues.h new file mode 100755 index 00000000..ac15b097 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/queues.h @@ -0,0 +1,63 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* + Code for generell handling of priority Queues. + Implemention of queues from "Algoritms in C" by Robert Sedgewick. + Copyright Monty Program KB. + By monty. +*/ + +#ifndef _queues_h +#define _queues_h +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct st_queue { + byte **root; + void *first_cmp_arg; + uint elements; + uint max_elements; + uint offset_to_key; /* compare is done on element+offset */ + int max_at_top; /* Set if queue_top gives max */ + int (*compare)(void *, byte *,byte *); +} QUEUE; + +#define queue_top(queue) ((queue)->root[1]) +#define queue_element(queue,index) ((queue)->root[index+1]) +#define queue_end(queue) ((queue)->root[(queue)->elements]) +#define queue_replaced(queue) _downheap(queue,1) +typedef int (*queue_compare)(void *,byte *, byte *); + +int init_queue(QUEUE *queue,uint max_elements,uint offset_to_key, + pbool max_at_top, queue_compare compare, + void *first_cmp_arg); +int reinit_queue(QUEUE *queue,uint max_elements,uint offset_to_key, + pbool max_at_top, queue_compare compare, + void *first_cmp_arg); +int resize_queue(QUEUE *queue, uint max_elements); +void delete_queue(QUEUE *queue); +void queue_insert(QUEUE *queue,byte *element); +byte *queue_remove(QUEUE *queue,uint idx); +void _downheap(QUEUE *queue,uint idx); +void queue_fix(QUEUE *queue); +#define is_queue_inited(queue) ((queue)->root != 0) + +#ifdef __cplusplus +} +#endif +#endif diff --git a/dlls/csx_sql/extra/include/mysql/raid.h b/dlls/csx_sql/extra/include/mysql/raid.h new file mode 100755 index 00000000..b5a5e665 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/raid.h @@ -0,0 +1,158 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* Parser needs these defines always, even if USE_RAID is not defined */ +#define RAID_TYPE_0 1 /* Striping */ +#define RAID_TYPE_x 2 /* Some new modes */ +#define RAID_TYPE_y 3 + +#define RAID_DEFAULT_CHUNKS 4 +#define RAID_DEFAULT_CHUNKSIZE 256*1024 /* 256kB */ + +C_MODE_START +#define my_raid_type(raid_type) raid_type_string[(int)(raid_type)] +extern const char *raid_type_string[]; +C_MODE_END + +#ifdef DONT_USE_RAID +#undef USE_RAID +#endif +#if defined(USE_RAID) + +#ifdef __GNUC__ +#pragma interface /* gcc class implementation */ +#endif +#include "my_dir.h" + +/* Trap all occurences of my_...() in source and use our wrapper around this function */ + +#ifdef MAP_TO_USE_RAID +#define my_read(A,B,C,D) my_raid_read(A,B,C,D) +#define my_write(A,B,C,D) my_raid_write(A,B,C,D) +#define my_pwrite(A,B,C,D,E) my_raid_pwrite(A,B,C,D,E) +#define my_pread(A,B,C,D,E) my_raid_pread(A,B,C,D,E) +#define my_chsize(A,B,C,D) my_raid_chsize(A,B,C,D) +#define my_close(A,B) my_raid_close(A,B) +#define my_tell(A,B) my_raid_tell(A,B) +#define my_seek(A,B,C,D) my_raid_seek(A,B,C,D) +#define my_lock(A,B,C,D,E) my_raid_lock(A,B,C,D,E) +#define my_fstat(A,B,C) my_raid_fstat(A,B,C) +#endif /* MAP_TO_USE_RAID */ + +#ifdef __cplusplus +extern "C" { +#endif + + void init_raid(void); + void end_raid(void); + + bool is_raid(File fd); + File my_raid_create(const char *FileName, int CreateFlags, int access_flags, + uint raid_type, uint raid_chunks, ulong raid_chunksize, + myf MyFlags); + File my_raid_open(const char *FileName, int Flags, + uint raid_type, uint raid_chunks, ulong raid_chunksize, + myf MyFlags); + int my_raid_rename(const char *from, const char *to, uint raid_chunks, + myf MyFlags); + int my_raid_delete(const char *from, uint raid_chunks, myf MyFlags); + int my_raid_redel(const char *old_name, const char *new_name, + uint raid_chunks, myf MyFlags); + + my_off_t my_raid_seek(File fd, my_off_t pos, int whence, myf MyFlags); + my_off_t my_raid_tell(File fd, myf MyFlags); + + uint my_raid_write(File,const byte *Buffer, uint Count, myf MyFlags); + uint my_raid_read(File Filedes, byte *Buffer, uint Count, myf MyFlags); + + uint my_raid_pread(File Filedes, byte *Buffer, uint Count, my_off_t offset, + myf MyFlags); + uint my_raid_pwrite(int Filedes, const byte *Buffer, uint Count, + my_off_t offset, myf MyFlags); + + int my_raid_lock(File,int locktype, my_off_t start, my_off_t length, + myf MyFlags); + int my_raid_chsize(File fd, my_off_t newlength, int filler, myf MyFlags); + int my_raid_close(File, myf MyFlags); + int my_raid_fstat(int Filedes, struct stat *buf, myf MyFlags); + +#ifdef __cplusplus +} + +class RaidName { + public: + RaidName(const char *FileName); + ~RaidName(); + bool IsRaid(); + int Rename(const char * from, const char * to, myf MyFlags); + private: + uint _raid_type; /* RAID_TYPE_0 or RAID_TYPE_1 or RAID_TYPE_5 */ + uint _raid_chunks; /* 1..n */ + ulong _raid_chunksize; /* 1..n in bytes */ +}; + +class RaidFd { + public: + RaidFd(uint raid_type, uint raid_chunks , ulong raid_chunksize); + ~RaidFd(); + File Create(const char *FileName, int CreateFlags, int access_flags, + myf MyFlags); + File Open(const char *FileName, int Flags, myf MyFlags); + my_off_t Seek(my_off_t pos,int whence,myf MyFlags); + my_off_t Tell(myf MyFlags); + int Write(const byte *Buffer, uint Count, myf MyFlags); + int Read(const byte *Buffer, uint Count, myf MyFlags); + int Lock(int locktype, my_off_t start, my_off_t length, myf MyFlags); + int Chsize(File fd, my_off_t newlength, int filler, myf MyFlags); + int Fstat(int fd, MY_STAT *stat_area, myf MyFlags ); + int Close(myf MyFlags); + static bool IsRaid(File fd); + static DYNAMIC_ARRAY _raid_map; /* Map of RaidFD* */ + private: + + uint _raid_type; /* RAID_TYPE_0 or RAID_TYPE_1 or RAID_TYPE_5 */ + uint _raid_chunks; /* 1..n */ + ulong _raid_chunksize; /* 1..n in bytes */ + + ulong _total_block; /* We are operating with block no x (can be 0..many). */ + uint _this_block; /* can be 0.._raid_chunks */ + uint _remaining_bytes; /* Maximum bytes that can be written in this block */ + + my_off_t _position; + my_off_t _size; /* Cached file size for faster seek(SEEK_END) */ + File _fd; + File *_fd_vector; /* Array of File */ + off_t *_seek_vector; /* Array of cached seek positions */ + + inline void Calculate() + { + DBUG_ENTER("RaidFd::_Calculate"); + DBUG_PRINT("info",("_position: %lu _raid_chunksize: %d, _size: %lu", + (ulong) _position, _raid_chunksize, (ulong) _size)); + + _total_block = (ulong) (_position / _raid_chunksize); + _this_block = _total_block % _raid_chunks; /* can be 0.._raid_chunks */ + _remaining_bytes = (uint) (_raid_chunksize - + (_position - _total_block * _raid_chunksize)); + DBUG_PRINT("info", + ("_total_block: %d this_block: %d _remaining_bytes:%d", + _total_block, _this_block, _remaining_bytes)); + DBUG_VOID_RETURN; + } +}; + +#endif /* __cplusplus */ +#endif /* USE_RAID */ diff --git a/dlls/csx_sql/extra/include/mysql/rijndael.h b/dlls/csx_sql/extra/include/mysql/rijndael.h new file mode 100755 index 00000000..e286c89c --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/rijndael.h @@ -0,0 +1,42 @@ +/* Copyright (C) 2002 MySQL AB & MySQL Finland AB & TCX DataKonsult AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +/* + rijndael-alg-fst.h + + @version 3.0 (December 2000) + Optimised ANSI C code for the Rijndael cipher (now AES) + @author Vincent Rijmen + @author Antoon Bosselaers + @author Paulo Barreto + + This code is hereby placed in the public domain. + Modified by Peter Zaitsev to fit MySQL coding style. + */ + +#define AES_MAXKC (256/32) +#define AES_MAXKB (256/8) +#define AES_MAXNR 14 + +int rijndaelKeySetupEnc(uint32 rk[/*4*(Nr + 1)*/], const uint8 cipherKey[], + int keyBits); +int rijndaelKeySetupDec(uint32 rk[/*4*(Nr + 1)*/], const uint8 cipherKey[], + int keyBits); +void rijndaelEncrypt(const uint32 rk[/*4*(Nr + 1)*/], int Nr, + const uint8 pt[16], uint8 ct[16]); +void rijndaelDecrypt(const uint32 rk[/*4*(Nr + 1)*/], int Nr, + const uint8 ct[16], uint8 pt[16]); diff --git a/dlls/csx_sql/extra/include/mysql/sha1.h b/dlls/csx_sql/extra/include/mysql/sha1.h new file mode 100755 index 00000000..1c345469 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/sha1.h @@ -0,0 +1,67 @@ +/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* + This is the header file for code which implements the Secure + Hashing Algorithm 1 as defined in FIPS PUB 180-1 published + April 17, 1995. + + Many of the variable names in this code, especially the + single character names, were used because those were the names + used in the publication. + + Please read the file sha1.c for more information. + + Modified 2002 by Peter Zaitsev to better follow MySQL standards +*/ + + +enum sha_result_codes +{ + SHA_SUCCESS = 0, + SHA_NULL, /* Null pointer parameter */ + SHA_INPUT_TOO_LONG, /* input data too long */ + SHA_STATE_ERROR /* called Input after Result */ +}; + +#define SHA1_HASH_SIZE 20 /* Hash size in bytes */ + +/* + This structure will hold context information for the SHA-1 + hashing operation +*/ + +typedef struct SHA1_CONTEXT +{ + ulonglong Length; /* Message length in bits */ + uint32 Intermediate_Hash[SHA1_HASH_SIZE/4]; /* Message Digest */ + int Computed; /* Is the digest computed? */ + int Corrupted; /* Is the message digest corrupted? */ + int16 Message_Block_Index; /* Index into message block array */ + uint8 Message_Block[64]; /* 512-bit message blocks */ +} SHA1_CONTEXT; + +/* + Function Prototypes +*/ + +C_MODE_START + +int sha1_reset( SHA1_CONTEXT* ); +int sha1_input( SHA1_CONTEXT*, const uint8 *, unsigned int ); +int sha1_result( SHA1_CONTEXT* , uint8 Message_Digest[SHA1_HASH_SIZE] ); + +C_MODE_END diff --git a/dlls/csx_sql/extra/include/mysql/sslopt-case.h b/dlls/csx_sql/extra/include/mysql/sslopt-case.h new file mode 100755 index 00000000..ea23c31a --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/sslopt-case.h @@ -0,0 +1,29 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifdef HAVE_OPENSSL + case OPT_SSL_KEY: + case OPT_SSL_CERT: + case OPT_SSL_CA: + case OPT_SSL_CAPATH: + case OPT_SSL_CIPHER: + /* + Enable use of SSL if we are using any ssl option + One can disable SSL later by using --skip-ssl or --ssl=0 + */ + opt_use_ssl= 1; + break; +#endif diff --git a/dlls/csx_sql/extra/include/mysql/sslopt-longopts.h b/dlls/csx_sql/extra/include/mysql/sslopt-longopts.h new file mode 100755 index 00000000..397d8baa --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/sslopt-longopts.h @@ -0,0 +1,41 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifdef HAVE_OPENSSL + + {"ssl", OPT_SSL_SSL, + "Enable SSL for connection (automatically enabled with other flags). Disable with --skip-ssl", + (gptr*) &opt_use_ssl, (gptr*) &opt_use_ssl, 0, GET_BOOL, NO_ARG, 0, 0, 0, + 0, 0, 0}, + {"ssl-key", OPT_SSL_KEY, "X509 key in PEM format (implies --ssl)", + (gptr*) &opt_ssl_key, (gptr*) &opt_ssl_key, 0, GET_STR, REQUIRED_ARG, + 0, 0, 0, 0, 0, 0}, + {"ssl-cert", OPT_SSL_CERT, "X509 cert in PEM format (implies --ssl)", + (gptr*) &opt_ssl_cert, (gptr*) &opt_ssl_cert, 0, GET_STR, REQUIRED_ARG, + 0, 0, 0, 0, 0, 0}, + {"ssl-ca", OPT_SSL_CA, + "CA file in PEM format (check OpenSSL docs, implies --ssl)", + (gptr*) &opt_ssl_ca, (gptr*) &opt_ssl_ca, 0, GET_STR, REQUIRED_ARG, + 0, 0, 0, 0, 0, 0}, + {"ssl-capath", OPT_SSL_CAPATH, + "CA directory (check OpenSSL docs, implies --ssl)", + (gptr*) &opt_ssl_capath, (gptr*) &opt_ssl_capath, 0, GET_STR, REQUIRED_ARG, + 0, 0, 0, 0, 0, 0}, + {"ssl-cipher", OPT_SSL_CIPHER, "SSL cipher to use (implies --ssl)", + (gptr*) &opt_ssl_cipher, (gptr*) &opt_ssl_cipher, 0, GET_STR, REQUIRED_ARG, + 0, 0, 0, 0, 0, 0}, + +#endif /* HAVE_OPENSSL */ diff --git a/dlls/csx_sql/extra/include/mysql/sslopt-vars.h b/dlls/csx_sql/extra/include/mysql/sslopt-vars.h new file mode 100755 index 00000000..164cf541 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/sslopt-vars.h @@ -0,0 +1,24 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifdef HAVE_OPENSSL +static my_bool opt_use_ssl = 0; +static char *opt_ssl_key = 0; +static char *opt_ssl_cert = 0; +static char *opt_ssl_ca = 0; +static char *opt_ssl_capath = 0; +static char *opt_ssl_cipher = 0; +#endif diff --git a/dlls/csx_sql/extra/include/mysql/t_ctype.h b/dlls/csx_sql/extra/include/mysql/t_ctype.h new file mode 100755 index 00000000..3e190977 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/t_ctype.h @@ -0,0 +1,255 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* + Copyright (C) 1998, 1999 by Pruet Boonma, all rights reserved. + Copyright (C) 1998 by Theppitak Karoonboonyanan, all rights reserved. + Permission to use, copy, modify, distribute and sell this software + and its documentation for any purpose is hereby granted without fee, + provided that the above copyright notice appear in all copies. + Smaphan Raruenrom and Pruet Boonma makes no representations about + the suitability of this software for any purpose. It is provided + "as is" without express or implied warranty. +*/ + +/* LC_COLLATE category + Level information */ + +#ifndef _t_ctype_h +#define _t_ctype_h + +#define TOT_LEVELS 5 +#define LAST_LEVEL 4 /* TOT_LEVELS - 1 */ + +#define IGNORE 0 + + +/* level 1 symbols & order */ +enum l1_symbols { + L1_08 = TOT_LEVELS, + L1_18, + L1_28, + L1_38, + L1_48, + L1_58, + L1_68, + L1_78, + L1_88, + L1_98, + L1_A8, + L1_B8, + L1_C8, + L1_D8, + L1_E8, + L1_F8, + L1_G8, + L1_H8, + L1_I8, + L1_J8, + L1_K8, + L1_L8, + L1_M8, + L1_N8, + L1_O8, + L1_P8, + L1_Q8, + L1_R8, + L1_S8, + L1_T8, + L1_U8, + L1_V8, + L1_W8, + L1_X8, + L1_Y8, + L1_Z8, + L1_KO_KAI, + L1_KHO_KHAI, + L1_KHO_KHUAT, + L1_KHO_KHWAI, + L1_KHO_KHON, + L1_KHO_RAKHANG, + L1_NGO_NGU, + L1_CHO_CHAN, + L1_CHO_CHING, + L1_CHO_CHANG, + L1_SO_SO, + L1_CHO_CHOE, + L1_YO_YING, + L1_DO_CHADA, + L1_TO_PATAK, + L1_THO_THAN, + L1_THO_NANGMONTHO, + L1_THO_PHUTHAO, + L1_NO_NEN, + L1_DO_DEK, + L1_TO_TAO, + L1_THO_THUNG, + L1_THO_THAHAN, + L1_THO_THONG, + L1_NO_NU, + L1_BO_BAIMAI, + L1_PO_PLA, + L1_PHO_PHUNG, + L1_FO_FA, + L1_PHO_PHAN, + L1_FO_FAN, + L1_PHO_SAMPHAO, + L1_MO_MA, + L1_YO_YAK, + L1_RO_RUA, + L1_RU, + L1_LO_LING, + L1_LU, + L1_WO_WAEN, + L1_SO_SALA, + L1_SO_RUSI, + L1_SO_SUA, + L1_HO_HIP, + L1_LO_CHULA, + L1_O_ANG, + L1_HO_NOKHUK, + L1_NKHIT, + L1_SARA_A, + L1_MAI_HAN_AKAT, + L1_SARA_AA, + L1_SARA_AM, + L1_SARA_I, + L1_SARA_II, + L1_SARA_UE, + L1_SARA_UEE, + L1_SARA_U, + L1_SARA_UU, + L1_SARA_E, + L1_SARA_AE, + L1_SARA_O, + L1_SARA_AI_MAIMUAN, + L1_SARA_AI_MAIMALAI +}; + +/* level 2 symbols & order */ +enum l2_symbols { + L2_BLANK = TOT_LEVELS, + L2_THAII, + L2_YAMAK, + L2_PINTHU, + L2_GARAN, + L2_TYKHU, + L2_TONE1, + L2_TONE2, + L2_TONE3, + L2_TONE4 +}; + +/* level 3 symbols & order */ +enum l3_symbols { + L3_BLANK = TOT_LEVELS, + L3_SPACE, + L3_NB_SACE, + L3_LOW_LINE, + L3_HYPHEN, + L3_COMMA, + L3_SEMICOLON, + L3_COLON, + L3_EXCLAMATION, + L3_QUESTION, + L3_SOLIDUS, + L3_FULL_STOP, + L3_PAIYAN_NOI, + L3_MAI_YAMOK, + L3_GRAVE, + L3_CIRCUMFLEX, + L3_TILDE, + L3_APOSTROPHE, + L3_QUOTATION, + L3_L_PARANTHESIS, + L3_L_BRACKET, + L3_L_BRACE, + L3_R_BRACE, + L3_R_BRACKET, + L3_R_PARENTHESIS, + L3_AT, + L3_BAHT, + L3_DOLLAR, + L3_FONGMAN, + L3_ANGKHANKHU, + L3_KHOMUT, + L3_ASTERISK, + L3_BK_SOLIDUS, + L3_AMPERSAND, + L3_NUMBER, + L3_PERCENT, + L3_PLUS, + L3_LESS_THAN, + L3_EQUAL, + L3_GREATER_THAN, + L3_V_LINE +}; + +/* level 4 symbols & order */ +enum l4_symbols { + L4_BLANK = TOT_LEVELS, + L4_MIN, + L4_CAP, + L4_EXT +}; + +enum level_symbols { + L_UPRUPR = TOT_LEVELS, + L_UPPER, + L_MIDDLE, + L_LOWER +}; + +#define _is(c) (t_ctype[(c)][LAST_LEVEL]) +#define _level 8 +#define _consnt 16 +#define _ldvowel 32 +#define _fllwvowel 64 +#define _uprvowel 128 +#define _lwrvowel 256 +#define _tone 512 +#define _diacrt1 1024 +#define _diacrt2 2048 +#define _combine 4096 +#define _stone 8192 +#define _tdig 16384 +#define _rearvowel (_fllwvowel | _uprvowel | _lwrvowel) +#define _diacrt (_diacrt1 | _diacrt2) +#define levelof(c) ( _is(c) & _level ) +#define isthai(c) ( (c) >= 128 ) +#define istalpha(c) ( _is(c) & (_consnt|_ldvowel|_rearvowel|\ + _tone|_diacrt1|_diacrt2) ) +#define isconsnt(c) ( _is(c) & _consnt ) +#define isldvowel(c) ( _is(c) & _ldvowel ) +#define isfllwvowel(c) ( _is(c) & _fllwvowel ) +#define ismidvowel(c) ( _is(c) & (_ldvowel|_fllwvowel) ) +#define isuprvowel(c) ( _is(c) & _uprvowel ) +#define islwrvowel(c) ( _is(c) & _lwrvowel ) +#define isuprlwrvowel(c) ( _is(c) & (_lwrvowel | _uprvowel)) +#define isrearvowel(c) ( _is(c) & _rearvowel ) +#define isvowel(c) ( _is(c) & (_ldvowel|_rearvowel) ) +#define istone(c) ( _is(c) & _tone ) +#define isunldable(c) ( _is(c) & (_rearvowel|_tone|_diacrt1|_diacrt2) ) +#define iscombinable(c) ( _is(c) & _combine ) +#define istdigit(c) ( _is(c) & _tdig ) +#define isstone(c) ( _is(c) & _stone ) +#define isdiacrt1(c) ( _is(c) & _diacrt1) +#define isdiacrt2(c) ( _is(c) & _diacrt2) +#define isdiacrt(c) ( _is(c) & _diacrt) + +/* Function prototype called by sql/field.cc */ +void ThNormalize(uchar* ptr, uint field_length, const uchar* from, uint length); + +#endif diff --git a/dlls/csx_sql/extra/include/mysql/thr_alarm.h b/dlls/csx_sql/extra/include/mysql/thr_alarm.h new file mode 100755 index 00000000..0dbb700b --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/thr_alarm.h @@ -0,0 +1,120 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* Prototypes when using thr_alarm library functions */ + +#ifndef _thr_alarm_h +#define _thr_alarm_h +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef USE_ALARM_THREAD +#define USE_ONE_SIGNAL_HAND /* One must call process_alarm */ +#endif +#ifdef HAVE_LINUXTHREADS +#define THR_CLIENT_ALARM SIGALRM +#else +#define THR_CLIENT_ALARM SIGUSR1 +#endif +#ifdef HAVE_rts_threads +#undef USE_ONE_SIGNAL_HAND +#define USE_ALARM_THREAD +#define THR_SERVER_ALARM SIGUSR1 +#else +#define THR_SERVER_ALARM SIGALRM +#endif + +typedef struct st_alarm_info +{ + ulong next_alarm_time; + uint active_alarms; + uint max_used_alarms; +} ALARM_INFO; + +void thr_alarm_info(ALARM_INFO *info); + +#if defined(DONT_USE_THR_ALARM) || !defined(THREAD) + +#define USE_ALARM_THREAD +#undef USE_ONE_SIGNAL_HAND + +typedef my_bool thr_alarm_t; +typedef my_bool ALARM; + +#define thr_alarm_init(A) (*(A))=0 +#define thr_alarm_in_use(A) (*(A) != 0) +#define thr_end_alarm(A) +#define thr_alarm(A,B,C) ((*(A)=1)-1) +/* The following should maybe be (*(A)) */ +#define thr_got_alarm(A) 0 +#define init_thr_alarm(A) +#define thr_alarm_kill(A) +#define resize_thr_alarm(N) +#define end_thr_alarm() + +#else +#if defined(__WIN__) +typedef struct st_thr_alarm_entry +{ + rf_SetTimer crono; +} thr_alarm_entry; + +#elif defined(__EMX__) || defined(OS2) + +typedef struct st_thr_alarm_entry +{ + uint crono; + uint event; +} thr_alarm_entry; + +#else /* System with posix threads */ + +typedef int thr_alarm_entry; + +#define thr_got_alarm(thr_alarm) (**(thr_alarm)) + +#endif /* __WIN__ */ + +typedef thr_alarm_entry* thr_alarm_t; + +typedef struct st_alarm { + ulong expire_time; + thr_alarm_entry alarmed; /* set when alarm is due */ + pthread_t thread; + my_bool malloced; +} ALARM; + +#define thr_alarm_init(A) (*(A))=0 +#define thr_alarm_in_use(A) (*(A)!= 0) +void init_thr_alarm(uint max_alarm); +void resize_thr_alarm(uint max_alarms); +my_bool thr_alarm(thr_alarm_t *alarmed, uint sec, ALARM *buff); +void thr_alarm_kill(pthread_t thread_id); +void thr_end_alarm(thr_alarm_t *alarmed); +void end_thr_alarm(my_bool free_structures); +sig_handler process_alarm(int); +#ifndef thr_got_alarm +bool thr_got_alarm(thr_alarm_t *alrm); +#endif + + +#endif /* DONT_USE_THR_ALARM */ + +#ifdef __cplusplus +} +#endif /* __cplusplus */ +#endif /* _thr_alarm_h */ diff --git a/dlls/csx_sql/extra/include/mysql/thr_lock.h b/dlls/csx_sql/extra/include/mysql/thr_lock.h new file mode 100755 index 00000000..f1bda0ce --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/thr_lock.h @@ -0,0 +1,117 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* For use with thr_lock:s */ + +#ifndef _thr_lock_h +#define _thr_lock_h +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + +struct st_thr_lock; +extern ulong locks_immediate,locks_waited ; + +enum thr_lock_type { TL_IGNORE=-1, + TL_UNLOCK, /* UNLOCK ANY LOCK */ + TL_READ, /* Read lock */ + TL_READ_WITH_SHARED_LOCKS, + /* High prior. than TL_WRITE. Allow concurrent insert */ + TL_READ_HIGH_PRIORITY, + /* READ, Don't allow concurrent insert */ + TL_READ_NO_INSERT, + /* + Write lock, but allow other threads to read / write. + Used by BDB tables in MySQL to mark that someone is + reading/writing to the table. + */ + TL_WRITE_ALLOW_WRITE, + /* + Write lock, but allow other threads to read. + Used by ALTER TABLE in MySQL to allow readers + to use the table until ALTER TABLE is finished. + */ + TL_WRITE_ALLOW_READ, + /* + WRITE lock used by concurrent insert. Will allow + READ, if one could use concurrent insert on table. + */ + TL_WRITE_CONCURRENT_INSERT, + /* Write used by INSERT DELAYED. Allows READ locks */ + TL_WRITE_DELAYED, + /* WRITE lock that has lower priority than TL_READ */ + TL_WRITE_LOW_PRIORITY, + /* Normal WRITE lock */ + TL_WRITE, + /* Abort new lock request with an error */ + TL_WRITE_ONLY}; + +extern ulong max_write_lock_count; +extern my_bool thr_lock_inited; +extern enum thr_lock_type thr_upgraded_concurrent_insert_lock; + +typedef struct st_thr_lock_data { + pthread_t thread; + struct st_thr_lock_data *next,**prev; + struct st_thr_lock *lock; + pthread_cond_t *cond; + enum thr_lock_type type; + ulong thread_id; + void *status_param; /* Param to status functions */ +} THR_LOCK_DATA; + +struct st_lock_list { + THR_LOCK_DATA *data,**last; +}; + +typedef struct st_thr_lock { + LIST list; + pthread_mutex_t mutex; + struct st_lock_list read_wait; + struct st_lock_list read; + struct st_lock_list write_wait; + struct st_lock_list write; +/* write_lock_count is incremented for write locks and reset on read locks */ + ulong write_lock_count; + uint read_no_write_count; + void (*get_status)(void*); /* When one gets a lock */ + void (*copy_status)(void*,void*); + void (*update_status)(void*); /* Before release of write */ + my_bool (*check_status)(void *); +} THR_LOCK; + + +my_bool init_thr_lock(void); /* Must be called once/thread */ +void thr_lock_init(THR_LOCK *lock); +void thr_lock_delete(THR_LOCK *lock); +void thr_lock_data_init(THR_LOCK *lock,THR_LOCK_DATA *data, + void *status_param); +int thr_lock(THR_LOCK_DATA *data,enum thr_lock_type lock_type); +void thr_unlock(THR_LOCK_DATA *data); +int thr_multi_lock(THR_LOCK_DATA **data,uint count); +void thr_multi_unlock(THR_LOCK_DATA **data,uint count); +void thr_abort_locks(THR_LOCK *lock); +void thr_abort_locks_for_thread(THR_LOCK *lock, pthread_t thread); +void thr_print_locks(void); /* For debugging */ +my_bool thr_upgrade_write_delay_lock(THR_LOCK_DATA *data); +my_bool thr_reschedule_write_lock(THR_LOCK_DATA *data); +#ifdef __cplusplus +} +#endif +#endif /* _thr_lock_h */ diff --git a/dlls/csx_sql/extra/include/mysql/violite.h b/dlls/csx_sql/extra/include/mysql/violite.h new file mode 100755 index 00000000..18f862d4 --- /dev/null +++ b/dlls/csx_sql/extra/include/mysql/violite.h @@ -0,0 +1,176 @@ +/* Copyright (C) 2000 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* + * Vio Lite. + * Purpose: include file for Vio that will work with C and C++ + */ + +#ifndef vio_violite_h_ +#define vio_violite_h_ + +#include "my_net.h" /* needed because of struct in_addr */ + + +/* Simple vio interface in C; The functions are implemented in violite.c */ + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +enum enum_vio_type { VIO_CLOSED, VIO_TYPE_TCPIP, VIO_TYPE_SOCKET, + VIO_TYPE_NAMEDPIPE, VIO_TYPE_SSL}; + +#ifndef __WIN__ +#define HANDLE void * +#endif + +Vio* vio_new(my_socket sd, enum enum_vio_type type, my_bool localhost); +#ifdef __WIN__ +Vio* vio_new_win32pipe(HANDLE hPipe); +#endif +void vio_delete(Vio* vio); +int vio_close(Vio* vio); + +#ifdef EMBEDDED_LIBRARY +void vio_reset(Vio *vio); +#else +void vio_reset(Vio* vio, enum enum_vio_type type, + my_socket sd, HANDLE hPipe, my_bool localhost); +#endif + +int vio_read(Vio *vio, gptr buf, int size); +int vio_write(Vio *vio, const gptr buf, int size); +int vio_blocking(Vio *vio, my_bool onoff, my_bool *old_mode); +my_bool vio_is_blocking(Vio *vio); +/* setsockopt TCP_NODELAY at IPPROTO_TCP level, when possible */ +int vio_fastsend(Vio *vio); +/* setsockopt SO_KEEPALIVE at SOL_SOCKET level, when possible */ +int vio_keepalive(Vio *vio, my_bool onoff); +/* Whenever we should retry the last read/write operation. */ +my_bool vio_should_retry(Vio *vio); +/* Short text description of the socket for those, who are curious.. */ +const char* vio_description(Vio *vio); +/* Return the type of the connection */ +enum enum_vio_type vio_type(Vio* vio); +/* Return last error number */ +int vio_errno(Vio*vio); +/* Get socket number */ +my_socket vio_fd(Vio*vio); +/* Remote peer's address and name in text form */ +my_bool vio_peer_addr(Vio* vio, char *buf, uint16 *port); +/* Remotes in_addr */ +void vio_in_addr(Vio *vio, struct in_addr *in); +my_bool vio_poll_read(Vio *vio,uint timeout); +void vio_timeout(Vio *vio,uint timeout); + +#ifdef HAVE_OPENSSL +#define HEADER_DES_LOCL_H dummy_something +#include +#include + +struct st_VioSSLAcceptorFd +{ + SSL_CTX *ssl_context; + SSL_METHOD *ssl_method; + struct st_VioSSLAcceptorFd *session_id_context; +}; + +/* One copy for client */ +struct st_VioSSLConnectorFd +{ + SSL_CTX *ssl_context; + /* function pointers which are only once for SSL client */ + SSL_METHOD *ssl_method; +}; + +int sslaccept(struct st_VioSSLAcceptorFd*, Vio *, long timeout); +int sslconnect(struct st_VioSSLConnectorFd*, Vio *, long timeout); + +struct st_VioSSLConnectorFd +*new_VioSSLConnectorFd(const char *key_file, const char *cert_file, + const char *ca_file, const char *ca_path, + const char *cipher); +struct st_VioSSLAcceptorFd +*new_VioSSLAcceptorFd(const char *key_file, const char *cert_file, + const char *ca_file,const char *ca_path, + const char *cipher); +Vio *new_VioSSL(struct st_VioSSLAcceptorFd *fd, Vio *sd, int state); +#endif + +#ifdef __cplusplus +} +#endif + +#if defined(HAVE_VIO) && !defined(DONT_MAP_VIO) +#define vio_delete(vio) (vio)->viodelete(vio) +#define vio_errno(vio) (vio)->vioerrno(vio) +#define vio_read(vio, buf, size) (vio)->read(vio,buf,size) +#define vio_write(vio, buf, size) (vio)->write(vio, buf, size) +#define vio_blocking(vio, set_blocking_mode, old_mode)\ + (vio)->vioblocking(vio, set_blocking_mode, old_mode) +#define vio_is_blocking(vio) (vio)->is_blocking(vio) +#define vio_fastsend(vio) (vio)->fastsend(vio) +#define vio_keepalive(vio, set_keep_alive) (vio)->viokeepalive(vio, set_keep_alive) +#define vio_should_retry(vio) (vio)->should_retry(vio) +#define vio_close(vio) ((vio)->vioclose)(vio) +#define vio_peer_addr(vio, buf, prt) (vio)->peer_addr(vio, buf, prt) +#define vio_in_addr(vio, in) (vio)->in_addr(vio, in) +#define vio_timeout(vio, seconds) (vio)->timeout(vio, seconds) +#endif /* defined(HAVE_VIO) && !defined(DONT_MAP_VIO) */ + +/* This enumerator is used in parser - should be always visible */ +enum SSL_type +{ + SSL_TYPE_NOT_SPECIFIED= -1, + SSL_TYPE_NONE, + SSL_TYPE_ANY, + SSL_TYPE_X509, + SSL_TYPE_SPECIFIED +}; + +#ifndef EMBEDDED_LIBRARY +/* This structure is for every connection on both sides */ +struct st_vio +{ + my_socket sd; /* my_socket - real or imaginary */ + HANDLE hPipe; + my_bool localhost; /* Are we from localhost? */ + int fcntl_mode; /* Buffered fcntl(sd,F_GETFL) */ + struct sockaddr_in local; /* Local internet address */ + struct sockaddr_in remote; /* Remote internet address */ + enum enum_vio_type type; /* Type of connection */ + char desc[30]; /* String description */ +#ifdef HAVE_VIO + /* function pointers. They are similar for socket/SSL/whatever */ + void (*viodelete)(Vio*); + int (*vioerrno)(Vio*); + int (*read)(Vio*, gptr, int); + int (*write)(Vio*, gptr, int); + int (*vioblocking)(Vio*, my_bool, my_bool *); + my_bool (*is_blocking)(Vio*); + int (*viokeepalive)(Vio*, my_bool); + int (*fastsend)(Vio*); + my_bool (*peer_addr)(Vio*, char *, uint16*); + void (*in_addr)(Vio*, struct in_addr*); + my_bool (*should_retry)(Vio*); + int (*vioclose)(Vio*); + void (*timeout)(Vio*, unsigned int timeout); + void *ssl_arg; +#endif /* HAVE_VIO */ +}; +#endif /* EMBEDDED_LIBRARY */ +#endif /* vio_violite_h_ */ diff --git a/dlls/csx_sql/extra/include/zlib.h b/dlls/csx_sql/extra/include/zlib.h new file mode 100755 index 00000000..52cb529f --- /dev/null +++ b/dlls/csx_sql/extra/include/zlib.h @@ -0,0 +1,893 @@ +/* zlib.h -- interface of the 'zlib' general purpose compression library + version 1.1.4, March 11th, 2002 + + Copyright (C) 1995-2002 Jean-loup Gailly and Mark Adler + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Jean-loup Gailly Mark Adler + jloup@gzip.org madler@alumni.caltech.edu + + + The data format used by the zlib library is described by RFCs (Request for + Comments) 1950 to 1952 in the files ftp://ds.internic.net/rfc/rfc1950.txt + (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format). +*/ + +#ifndef _ZLIB_H +#define _ZLIB_H + +#include "zconf.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define ZLIB_VERSION "1.1.4" + +/* + The 'zlib' compression library provides in-memory compression and + decompression functions, including integrity checks of the uncompressed + data. This version of the library supports only one compression method + (deflation) but other algorithms will be added later and will have the same + stream interface. + + Compression can be done in a single step if the buffers are large + enough (for example if an input file is mmap'ed), or can be done by + repeated calls of the compression function. In the latter case, the + application must provide more input and/or consume the output + (providing more output space) before each call. + + The library also supports reading and writing files in gzip (.gz) format + with an interface similar to that of stdio. + + The library does not install any signal handler. The decoder checks + the consistency of the compressed data, so the library should never + crash even in case of corrupted input. +*/ + +typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); +typedef void (*free_func) OF((voidpf opaque, voidpf address)); + +struct internal_state; + +typedef struct z_stream_s { + Bytef *next_in; /* next input byte */ + uInt avail_in; /* number of bytes available at next_in */ + uLong total_in; /* total nb of input bytes read so far */ + + Bytef *next_out; /* next output byte should be put there */ + uInt avail_out; /* remaining free space at next_out */ + uLong total_out; /* total nb of bytes output so far */ + + char *msg; /* last error message, NULL if no error */ + struct internal_state FAR *state; /* not visible by applications */ + + alloc_func zalloc; /* used to allocate the internal state */ + free_func zfree; /* used to free the internal state */ + voidpf opaque; /* private data object passed to zalloc and zfree */ + + int data_type; /* best guess about the data type: ascii or binary */ + uLong adler; /* adler32 value of the uncompressed data */ + uLong reserved; /* reserved for future use */ +} z_stream; + +typedef z_stream FAR *z_streamp; + +/* + The application must update next_in and avail_in when avail_in has + dropped to zero. It must update next_out and avail_out when avail_out + has dropped to zero. The application must initialize zalloc, zfree and + opaque before calling the init function. All other fields are set by the + compression library and must not be updated by the application. + + The opaque value provided by the application will be passed as the first + parameter for calls of zalloc and zfree. This can be useful for custom + memory management. The compression library attaches no meaning to the + opaque value. + + zalloc must return Z_NULL if there is not enough memory for the object. + If zlib is used in a multi-threaded application, zalloc and zfree must be + thread safe. + + On 16-bit systems, the functions zalloc and zfree must be able to allocate + exactly 65536 bytes, but will not be required to allocate more than this + if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, + pointers returned by zalloc for objects of exactly 65536 bytes *must* + have their offset normalized to zero. The default allocation function + provided by this library ensures this (see zutil.c). To reduce memory + requirements and avoid any allocation of 64K objects, at the expense of + compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h). + + The fields total_in and total_out can be used for statistics or + progress reports. After compression, total_in holds the total size of + the uncompressed data and may be saved for use in the decompressor + (particularly if the decompressor wants to decompress everything in + a single step). +*/ + + /* constants */ + +#define Z_NO_FLUSH 0 +#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */ +#define Z_SYNC_FLUSH 2 +#define Z_FULL_FLUSH 3 +#define Z_FINISH 4 +/* Allowed flush values; see deflate() below for details */ + +#define Z_OK 0 +#define Z_STREAM_END 1 +#define Z_NEED_DICT 2 +#define Z_ERRNO (-1) +#define Z_STREAM_ERROR (-2) +#define Z_DATA_ERROR (-3) +#define Z_MEM_ERROR (-4) +#define Z_BUF_ERROR (-5) +#define Z_VERSION_ERROR (-6) +/* Return codes for the compression/decompression functions. Negative + * values are errors, positive values are used for special but normal events. + */ + +#define Z_NO_COMPRESSION 0 +#define Z_BEST_SPEED 1 +#define Z_BEST_COMPRESSION 9 +#define Z_DEFAULT_COMPRESSION (-1) +/* compression levels */ + +#define Z_FILTERED 1 +#define Z_HUFFMAN_ONLY 2 +#define Z_DEFAULT_STRATEGY 0 +/* compression strategy; see deflateInit2() below for details */ + +#define Z_BINARY 0 +#define Z_ASCII 1 +#define Z_UNKNOWN 2 +/* Possible values of the data_type field */ + +#define Z_DEFLATED 8 +/* The deflate compression method (the only one supported in this version) */ + +#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ + +#define zlib_version zlibVersion() +/* for compatibility with versions < 1.0.2 */ + + /* basic functions */ + +ZEXTERN const char * ZEXPORT zlibVersion OF((void)); +/* The application can compare zlibVersion and ZLIB_VERSION for consistency. + If the first character differs, the library code actually used is + not compatible with the zlib.h header file used by the application. + This check is automatically made by deflateInit and inflateInit. + */ + +/* +ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); + + Initializes the internal stream state for compression. The fields + zalloc, zfree and opaque must be initialized before by the caller. + If zalloc and zfree are set to Z_NULL, deflateInit updates them to + use default allocation functions. + + The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: + 1 gives best speed, 9 gives best compression, 0 gives no compression at + all (the input data is simply copied a block at a time). + Z_DEFAULT_COMPRESSION requests a default compromise between speed and + compression (currently equivalent to level 6). + + deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_STREAM_ERROR if level is not a valid compression level, + Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible + with the version assumed by the caller (ZLIB_VERSION). + msg is set to null if there is no error message. deflateInit does not + perform any compression: this will be done by deflate(). +*/ + + +ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); +/* + deflate compresses as much data as possible, and stops when the input + buffer becomes empty or the output buffer becomes full. It may introduce some + output latency (reading input without producing any output) except when + forced to flush. + + The detailed semantics are as follows. deflate performs one or both of the + following actions: + + - Compress more input starting at next_in and update next_in and avail_in + accordingly. If not all input can be processed (because there is not + enough room in the output buffer), next_in and avail_in are updated and + processing will resume at this point for the next call of deflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. This action is forced if the parameter flush is non zero. + Forcing flush frequently degrades the compression ratio, so this parameter + should be set only when necessary (in interactive applications). + Some output may be provided even if flush is not set. + + Before the call of deflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming + more output, and updating avail_in or avail_out accordingly; avail_out + should never be zero before the call. The application can consume the + compressed output when it wants, for example when the output buffer is full + (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK + and with zero avail_out, it must be called again after making room in the + output buffer because there might be more output pending. + + If the parameter flush is set to Z_SYNC_FLUSH, all pending output is + flushed to the output buffer and the output is aligned on a byte boundary, so + that the decompressor can get all input data available so far. (In particular + avail_in is zero after the call if enough output space has been provided + before the call.) Flushing may degrade compression for some compression + algorithms and so it should be used only when necessary. + + If flush is set to Z_FULL_FLUSH, all output is flushed as with + Z_SYNC_FLUSH, and the compression state is reset so that decompression can + restart from this point if previous compressed data has been damaged or if + random access is desired. Using Z_FULL_FLUSH too often can seriously degrade + the compression. + + If deflate returns with avail_out == 0, this function must be called again + with the same value of the flush parameter and more output space (updated + avail_out), until the flush is complete (deflate returns with non-zero + avail_out). + + If the parameter flush is set to Z_FINISH, pending input is processed, + pending output is flushed and deflate returns with Z_STREAM_END if there + was enough output space; if deflate returns with Z_OK, this function must be + called again with Z_FINISH and more output space (updated avail_out) but no + more input data, until it returns with Z_STREAM_END or an error. After + deflate has returned Z_STREAM_END, the only possible operations on the + stream are deflateReset or deflateEnd. + + Z_FINISH can be used immediately after deflateInit if all the compression + is to be done in a single step. In this case, avail_out must be at least + 0.1% larger than avail_in plus 12 bytes. If deflate does not return + Z_STREAM_END, then it must be called again as described above. + + deflate() sets strm->adler to the adler32 checksum of all input read + so far (that is, total_in bytes). + + deflate() may update data_type if it can make a good guess about + the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered + binary. This field is only for information purposes and does not affect + the compression algorithm in any manner. + + deflate() returns Z_OK if some progress has been made (more input + processed or more output produced), Z_STREAM_END if all input has been + consumed and all output has been produced (only when flush is set to + Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example + if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible + (for example avail_in or avail_out was zero). +*/ + + +ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); +/* + All dynamically allocated data structures for this stream are freed. + This function discards any unprocessed input and does not flush any + pending output. + + deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the + stream state was inconsistent, Z_DATA_ERROR if the stream was freed + prematurely (some input or output was discarded). In the error case, + msg may be set but then points to a static string (which must not be + deallocated). +*/ + + +/* +ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); + + Initializes the internal stream state for decompression. The fields + next_in, avail_in, zalloc, zfree and opaque must be initialized before by + the caller. If next_in is not Z_NULL and avail_in is large enough (the exact + value depends on the compression method), inflateInit determines the + compression method from the zlib header and allocates all data structures + accordingly; otherwise the allocation will be deferred to the first call of + inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to + use default allocation functions. + + inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_VERSION_ERROR if the zlib library version is incompatible with the + version assumed by the caller. msg is set to null if there is no error + message. inflateInit does not perform any decompression apart from reading + the zlib header if present: this will be done by inflate(). (So next_in and + avail_in may be modified, but next_out and avail_out are unchanged.) +*/ + + +ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); +/* + inflate decompresses as much data as possible, and stops when the input + buffer becomes empty or the output buffer becomes full. It may some + introduce some output latency (reading input without producing any output) + except when forced to flush. + + The detailed semantics are as follows. inflate performs one or both of the + following actions: + + - Decompress more input starting at next_in and update next_in and avail_in + accordingly. If not all input can be processed (because there is not + enough room in the output buffer), next_in is updated and processing + will resume at this point for the next call of inflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. inflate() provides as much output as possible, until there + is no more input data or no more space in the output buffer (see below + about the flush parameter). + + Before the call of inflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming + more output, and updating the next_* and avail_* values accordingly. + The application can consume the uncompressed output when it wants, for + example when the output buffer is full (avail_out == 0), or after each + call of inflate(). If inflate returns Z_OK and with zero avail_out, it + must be called again after making room in the output buffer because there + might be more output pending. + + If the parameter flush is set to Z_SYNC_FLUSH, inflate flushes as much + output as possible to the output buffer. The flushing behavior of inflate is + not specified for values of the flush parameter other than Z_SYNC_FLUSH + and Z_FINISH, but the current implementation actually flushes as much output + as possible anyway. + + inflate() should normally be called until it returns Z_STREAM_END or an + error. However if all decompression is to be performed in a single step + (a single call of inflate), the parameter flush should be set to + Z_FINISH. In this case all pending input is processed and all pending + output is flushed; avail_out must be large enough to hold all the + uncompressed data. (The size of the uncompressed data may have been saved + by the compressor for this purpose.) The next operation on this stream must + be inflateEnd to deallocate the decompression state. The use of Z_FINISH + is never required, but can be used to inform inflate that a faster routine + may be used for the single inflate() call. + + If a preset dictionary is needed at this point (see inflateSetDictionary + below), inflate sets strm-adler to the adler32 checksum of the + dictionary chosen by the compressor and returns Z_NEED_DICT; otherwise + it sets strm->adler to the adler32 checksum of all output produced + so far (that is, total_out bytes) and returns Z_OK, Z_STREAM_END or + an error code as described below. At the end of the stream, inflate() + checks that its computed adler32 checksum is equal to that saved by the + compressor and returns Z_STREAM_END only if the checksum is correct. + + inflate() returns Z_OK if some progress has been made (more input processed + or more output produced), Z_STREAM_END if the end of the compressed data has + been reached and all uncompressed output has been produced, Z_NEED_DICT if a + preset dictionary is needed at this point, Z_DATA_ERROR if the input data was + corrupted (input stream not conforming to the zlib format or incorrect + adler32 checksum), Z_STREAM_ERROR if the stream structure was inconsistent + (for example if next_in or next_out was NULL), Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if no progress is possible or if there was not + enough room in the output buffer when Z_FINISH is used. In the Z_DATA_ERROR + case, the application may then call inflateSync to look for a good + compression block. +*/ + + +ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); +/* + All dynamically allocated data structures for this stream are freed. + This function discards any unprocessed input and does not flush any + pending output. + + inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state + was inconsistent. In the error case, msg may be set but then points to a + static string (which must not be deallocated). +*/ + + /* Advanced functions */ + +/* + The following functions are needed only in some special applications. +*/ + +/* +ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, + int level, + int method, + int windowBits, + int memLevel, + int strategy)); + + This is another version of deflateInit with more compression options. The + fields next_in, zalloc, zfree and opaque must be initialized before by + the caller. + + The method parameter is the compression method. It must be Z_DEFLATED in + this version of the library. + + The windowBits parameter is the base two logarithm of the window size + (the size of the history buffer). It should be in the range 8..15 for this + version of the library. Larger values of this parameter result in better + compression at the expense of memory usage. The default value is 15 if + deflateInit is used instead. + + The memLevel parameter specifies how much memory should be allocated + for the internal compression state. memLevel=1 uses minimum memory but + is slow and reduces compression ratio; memLevel=9 uses maximum memory + for optimal speed. The default value is 8. See zconf.h for total memory + usage as a function of windowBits and memLevel. + + The strategy parameter is used to tune the compression algorithm. Use the + value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a + filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman encoding only (no + string match). Filtered data consists mostly of small values with a + somewhat random distribution. In this case, the compression algorithm is + tuned to compress them better. The effect of Z_FILTERED is to force more + Huffman coding and less string matching; it is somewhat intermediate + between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy parameter only affects + the compression ratio but not the correctness of the compressed output even + if it is not set appropriately. + + deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid + method). msg is set to null if there is no error message. deflateInit2 does + not perform any compression: this will be done by deflate(). +*/ + +ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dictLength)); +/* + Initializes the compression dictionary from the given byte sequence + without producing any compressed output. This function must be called + immediately after deflateInit, deflateInit2 or deflateReset, before any + call of deflate. The compressor and decompressor must use exactly the same + dictionary (see inflateSetDictionary). + + The dictionary should consist of strings (byte sequences) that are likely + to be encountered later in the data to be compressed, with the most commonly + used strings preferably put towards the end of the dictionary. Using a + dictionary is most useful when the data to be compressed is short and can be + predicted with good accuracy; the data can then be compressed better than + with the default empty dictionary. + + Depending on the size of the compression data structures selected by + deflateInit or deflateInit2, a part of the dictionary may in effect be + discarded, for example if the dictionary is larger than the window size in + deflate or deflate2. Thus the strings most likely to be useful should be + put at the end of the dictionary, not at the front. + + Upon return of this function, strm->adler is set to the Adler32 value + of the dictionary; the decompressor may later use this value to determine + which dictionary has been used by the compressor. (The Adler32 value + applies to the whole dictionary even if only a subset of the dictionary is + actually used by the compressor.) + + deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a + parameter is invalid (such as NULL dictionary) or the stream state is + inconsistent (for example if deflate has already been called for this stream + or if the compression method is bsort). deflateSetDictionary does not + perform any compression: this will be done by deflate(). +*/ + +ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, + z_streamp source)); +/* + Sets the destination stream as a complete copy of the source stream. + + This function can be useful when several compression strategies will be + tried, for example when there are several ways of pre-processing the input + data with a filter. The streams that will be discarded should then be freed + by calling deflateEnd. Note that deflateCopy duplicates the internal + compression state which can be quite large, so this strategy is slow and + can consume lots of memory. + + deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_STREAM_ERROR if the source stream state was inconsistent + (such as zalloc being NULL). msg is left unchanged in both source and + destination. +*/ + +ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); +/* + This function is equivalent to deflateEnd followed by deflateInit, + but does not free and reallocate all the internal compression state. + The stream will keep the same compression level and any other attributes + that may have been set by deflateInit2. + + deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being NULL). +*/ + +ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, + int level, + int strategy)); +/* + Dynamically update the compression level and compression strategy. The + interpretation of level and strategy is as in deflateInit2. This can be + used to switch between compression and straight copy of the input data, or + to switch to a different kind of input data requiring a different + strategy. If the compression level is changed, the input available so far + is compressed with the old level (and may be flushed); the new level will + take effect only at the next call of deflate(). + + Before the call of deflateParams, the stream state must be set as for + a call of deflate(), since the currently available input may have to + be compressed and flushed. In particular, strm->avail_out must be non-zero. + + deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source + stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR + if strm->avail_out was zero. +*/ + +/* +ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, + int windowBits)); + + This is another version of inflateInit with an extra parameter. The + fields next_in, avail_in, zalloc, zfree and opaque must be initialized + before by the caller. + + The windowBits parameter is the base two logarithm of the maximum window + size (the size of the history buffer). It should be in the range 8..15 for + this version of the library. The default value is 15 if inflateInit is used + instead. If a compressed stream with a larger window size is given as + input, inflate() will return with the error code Z_DATA_ERROR instead of + trying to allocate a larger window. + + inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative + memLevel). msg is set to null if there is no error message. inflateInit2 + does not perform any decompression apart from reading the zlib header if + present: this will be done by inflate(). (So next_in and avail_in may be + modified, but next_out and avail_out are unchanged.) +*/ + +ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dictLength)); +/* + Initializes the decompression dictionary from the given uncompressed byte + sequence. This function must be called immediately after a call of inflate + if this call returned Z_NEED_DICT. The dictionary chosen by the compressor + can be determined from the Adler32 value returned by this call of + inflate. The compressor and decompressor must use exactly the same + dictionary (see deflateSetDictionary). + + inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a + parameter is invalid (such as NULL dictionary) or the stream state is + inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the + expected one (incorrect Adler32 value). inflateSetDictionary does not + perform any decompression: this will be done by subsequent calls of + inflate(). +*/ + +ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); +/* + Skips invalid compressed data until a full flush point (see above the + description of deflate with Z_FULL_FLUSH) can be found, or until all + available input is skipped. No output is provided. + + inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR + if no more input was provided, Z_DATA_ERROR if no flush point has been found, + or Z_STREAM_ERROR if the stream structure was inconsistent. In the success + case, the application may save the current current value of total_in which + indicates where valid compressed data was found. In the error case, the + application may repeatedly call inflateSync, providing more input each time, + until success or end of the input data. +*/ + +ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); +/* + This function is equivalent to inflateEnd followed by inflateInit, + but does not free and reallocate all the internal decompression state. + The stream will keep attributes that may have been set by inflateInit2. + + inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being NULL). +*/ + + + /* utility functions */ + +/* + The following utility functions are implemented on top of the + basic stream-oriented functions. To simplify the interface, some + default options are assumed (compression level and memory usage, + standard memory allocation functions). The source code of these + utility functions can easily be modified if you need special options. +*/ + +ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen)); +/* + Compresses the source buffer into the destination buffer. sourceLen is + the byte length of the source buffer. Upon entry, destLen is the total + size of the destination buffer, which must be at least 0.1% larger than + sourceLen plus 12 bytes. Upon exit, destLen is the actual size of the + compressed buffer. + This function can be used to compress a whole file at once if the + input file is mmap'ed. + compress returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if there was not enough room in the output + buffer. +*/ + +ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen, + int level)); +/* + Compresses the source buffer into the destination buffer. The level + parameter has the same meaning as in deflateInit. sourceLen is the byte + length of the source buffer. Upon entry, destLen is the total size of the + destination buffer, which must be at least 0.1% larger than sourceLen plus + 12 bytes. Upon exit, destLen is the actual size of the compressed buffer. + + compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_BUF_ERROR if there was not enough room in the output buffer, + Z_STREAM_ERROR if the level parameter is invalid. +*/ + +ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen)); +/* + Decompresses the source buffer into the destination buffer. sourceLen is + the byte length of the source buffer. Upon entry, destLen is the total + size of the destination buffer, which must be large enough to hold the + entire uncompressed data. (The size of the uncompressed data must have + been saved previously by the compressor and transmitted to the decompressor + by some mechanism outside the scope of this compression library.) + Upon exit, destLen is the actual size of the compressed buffer. + This function can be used to decompress a whole file at once if the + input file is mmap'ed. + + uncompress returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if there was not enough room in the output + buffer, or Z_DATA_ERROR if the input data was corrupted. +*/ + + +typedef voidp gzFile; + +ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); +/* + Opens a gzip (.gz) file for reading or writing. The mode parameter + is as in fopen ("rb" or "wb") but can also include a compression level + ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for + Huffman only compression as in "wb1h". (See the description + of deflateInit2 for more information about the strategy parameter.) + + gzopen can be used to read a file which is not in gzip format; in this + case gzread will directly read from the file without decompression. + + gzopen returns NULL if the file could not be opened or if there was + insufficient memory to allocate the (de)compression state; errno + can be checked to distinguish the two cases (if errno is zero, the + zlib error is Z_MEM_ERROR). */ + +ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); +/* + gzdopen() associates a gzFile with the file descriptor fd. File + descriptors are obtained from calls like open, dup, creat, pipe or + fileno (in the file has been previously opened with fopen). + The mode parameter is as in gzopen. + The next call of gzclose on the returned gzFile will also close the + file descriptor fd, just like fclose(fdopen(fd), mode) closes the file + descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode). + gzdopen returns NULL if there was insufficient memory to allocate + the (de)compression state. +*/ + +ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); +/* + Dynamically update the compression level or strategy. See the description + of deflateInit2 for the meaning of these parameters. + gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not + opened for writing. +*/ + +ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); +/* + Reads the given number of uncompressed bytes from the compressed file. + If the input file was not in gzip format, gzread copies the given number + of bytes into the buffer. + gzread returns the number of uncompressed bytes actually read (0 for + end of file, -1 for error). */ + +ZEXTERN int ZEXPORT gzwrite OF((gzFile file, + const voidp buf, unsigned len)); +/* + Writes the given number of uncompressed bytes into the compressed file. + gzwrite returns the number of uncompressed bytes actually written + (0 in case of error). +*/ + +ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...)); +/* + Converts, formats, and writes the args to the compressed file under + control of the format string, as in fprintf. gzprintf returns the number of + uncompressed bytes actually written (0 in case of error). +*/ + +ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); +/* + Writes the given null-terminated string to the compressed file, excluding + the terminating null character. + gzputs returns the number of characters written, or -1 in case of error. +*/ + +ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); +/* + Reads bytes from the compressed file until len-1 characters are read, or + a newline character is read and transferred to buf, or an end-of-file + condition is encountered. The string is then terminated with a null + character. + gzgets returns buf, or Z_NULL in case of error. +*/ + +ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); +/* + Writes c, converted to an unsigned char, into the compressed file. + gzputc returns the value that was written, or -1 in case of error. +*/ + +ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); +/* + Reads one byte from the compressed file. gzgetc returns this byte + or -1 in case of end of file or error. +*/ + +ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); +/* + Flushes all pending output into the compressed file. The parameter + flush is as in the deflate() function. The return value is the zlib + error number (see function gzerror below). gzflush returns Z_OK if + the flush parameter is Z_FINISH and all output could be flushed. + gzflush should be called only when strictly necessary because it can + degrade compression. +*/ + +ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, + z_off_t offset, int whence)); +/* + Sets the starting position for the next gzread or gzwrite on the + given compressed file. The offset represents a number of bytes in the + uncompressed data stream. The whence parameter is defined as in lseek(2); + the value SEEK_END is not supported. + If the file is opened for reading, this function is emulated but can be + extremely slow. If the file is opened for writing, only forward seeks are + supported; gzseek then compresses a sequence of zeroes up to the new + starting position. + + gzseek returns the resulting offset location as measured in bytes from + the beginning of the uncompressed stream, or -1 in case of error, in + particular if the file is opened for writing and the new starting position + would be before the current position. +*/ + +ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); +/* + Rewinds the given file. This function is supported only for reading. + + gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) +*/ + +ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); +/* + Returns the starting position for the next gzread or gzwrite on the + given compressed file. This position represents a number of bytes in the + uncompressed data stream. + + gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) +*/ + +ZEXTERN int ZEXPORT gzeof OF((gzFile file)); +/* + Returns 1 when EOF has previously been detected reading the given + input stream, otherwise zero. +*/ + +ZEXTERN int ZEXPORT gzclose OF((gzFile file)); +/* + Flushes all pending output if necessary, closes the compressed file + and deallocates all the (de)compression state. The return value is the zlib + error number (see function gzerror below). +*/ + +ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); +/* + Returns the error message for the last error which occurred on the + given compressed file. errnum is set to zlib error number. If an + error occurred in the file system and not in the compression library, + errnum is set to Z_ERRNO and the application may consult errno + to get the exact error code. +*/ + + /* checksum functions */ + +/* + These functions are not related to compression but are exported + anyway because they might be useful in applications using the + compression library. +*/ + +ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); + +/* + Update a running Adler-32 checksum with the bytes buf[0..len-1] and + return the updated checksum. If buf is NULL, this function returns + the required initial value for the checksum. + An Adler-32 checksum is almost as reliable as a CRC32 but can be computed + much faster. Usage example: + + uLong adler = adler32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + adler = adler32(adler, buffer, length); + } + if (adler != original_adler) error(); +*/ + +ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); +/* + Update a running crc with the bytes buf[0..len-1] and return the updated + crc. If buf is NULL, this function returns the required initial value + for the crc. Pre- and post-conditioning (one's complement) is performed + within this function so it shouldn't be done by the application. + Usage example: + + uLong crc = crc32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + crc = crc32(crc, buffer, length); + } + if (crc != original_crc) error(); +*/ + + + /* various hacks, don't look :) */ + +/* deflateInit and inflateInit are macros to allow checking the zlib version + * and the compiler's view of z_stream: + */ +ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, + int windowBits, int memLevel, + int strategy, const char *version, + int stream_size)); +ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, + const char *version, int stream_size)); +#define deflateInit(strm, level) \ + deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream)) +#define inflateInit(strm) \ + inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream)) +#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ + deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ + (strategy), ZLIB_VERSION, sizeof(z_stream)) +#define inflateInit2(strm, windowBits) \ + inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) + + +#if !defined(_Z_UTIL_H) && !defined(NO_DUMMY_DECL) + struct internal_state {int dummy;}; /* hack for buggy compilers */ +#endif + +ZEXTERN const char * ZEXPORT zError OF((int err)); +ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp z)); +ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void)); + +#ifdef __cplusplus +} +#endif + +#endif /* _ZLIB_H */ diff --git a/dlls/csx_sql/extra/lib_win32/mysqlclient.lib b/dlls/csx_sql/extra/lib_win32/mysqlclient.lib new file mode 100755 index 0000000000000000000000000000000000000000..1ff9ce0f0cb13158f75d0e39ab3a42def71f164a GIT binary patch literal 541836 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≪-_r#4O-#L z9DM|>VE~8}QZ*Au(9?b=^fc(aJ_EKa<3*@yGoh=!h@*hsd%Sl)Jst zr~K^--58{q5+tZi5>IORmjR+A3~CGTq-+g}3yUa;gW6U+DanJ{?<`1-f!~5hGk$K3 z73=sfZ?lSgA!DQatdu}D%5-P%$e1~)RIm|#{9W%KQ-a!~K69GRWiY!C=_t$xP6jf} zoQ6ds2aa8ZU<^*`)8{2wD3h`i!GS8u$E1_$vInYsa)B@vH>x${u9_H2bqc9I!>JP( zIIjjtJ5F6lJg7BmB@;@{7l`5nwvj^8=0Pc%pt6!l(*6wXC(SuXTCPR2yG)X{34MsH{i zM%MVzInirISQt2uE4-u8dlop`k3la2db@!$hOGmR@jCIZ2so2$c$wyILioNMI7@7J zPV`m*r`d*=iC!5p*an=PRD$8i#!Nja`S7vAAs(GmPkID+BdEB;nS4IJb4JH+o%ynr z3+FFfx_I2Dn>Ui%;c)25iV4+nNw%>rY?K!m6~4mmhm7AFHD2S8`@`x{zf+;OL2Rz^ z8}rOw|&QDNspr90OI8a<_lnufanT(8#^@CX=_mT~t6 z#Aa+es}HFv+-{VIU_o(j*DH#8&ot`tjPl?>0=QT3x=y_=sMiHxBh0VY&(&)@-Rqk{ zh?Rt)%0S01LH5IS76d?}eVEQXGmcp{PrVB;+LLfViy-CMTAR~{1(Kj{&=FutTK4T*_8sqhrzlc1(G%Zh-@sE^D*nE#gqyqQ#}#R%aR8jG2LCzN_@bCV$(=4JVaPZvJp+G{5x4 z#(x*?iw14@v0bQ_+-9lILq*mtF80QymDcSAr8dd43>x7*@t3lISn(>Ws#o7kVR2+k5 zjWKz}_8@r$Kv?AX7uAb3%)H7DC(ob)dZ-{qtithGq^RSO=b}MbBO1y-xrq9cqxyn5TF zxTbKsDGlbvZ3V{FMMh^~mwOlP6AvVVxuq|!IT1$y@rX;y0_mDo&^t0xQ{7j64GiJb zy1#{tHJ2jduK<|x7!!d*d)nLF8Sdkm(z~zCjhlGBh&kJ-#ww3dUBrF+JNhuUIJKmM ziZxgMV$H3w*?ou?^&nYEUvBBn)s2ywo>LIRq(%PL=Ml%Gm^{2_((+hN^R2E$m?*i` z6^q?S%55`TAUlOb4Xyd`BAS-XOM5D1^F!^-CvD7I7H&Z@-1`v?a#XsL)8A|IVV@0V z$a@d-#~GNs9)lU3R)BAl(_N5MBjxtu4S~LC1$`)u-dh@6Vhm#ODt5c@pO4a+ic<$B zEn?XiLt;Z34uE1&q&K%=C=ygOOHC(2L@|k1g~u0eM%jpR$w#>`nJ=#yf+QC7T!UMM zn4Y3YDw;f5uKt9V({@M-Co1Awi+Fq%uW2XP{veWn0e(4JDY!ZwP*A%MP>Jw+!h-%} zg|b~?Wf-cLux)96Q9W5tkEdnX>irgq=<)d998{DcKDN8LPu!4HO&D)VafBq{V1Vu< z@stngLynp*-9p5#(=9|&(YNcV)PdZt4m?S1#A|Qgk&1m5eCXu1U_x{G5RU1wTkF_I zr^j`)1AZ9S{D1xyMT$Zfu2KD!2mEBVuBNUZ?;ra>i?GunK+TAUvCllE4x?5x_S;nK zpY{+S();tNPhghQq)gp`?$aCs6vFqUH^WtljGB}mf)CxNIs^!;U=8?^cesu66M`iNaof{Rta4)#%6Coi}_4uS_YW2yfuzy%_I@6f> zX%@NNWf(J4{~93`ZwoWym>C88L*V@z^@on6oyKTqVysl6##OAvnZ{`I;D0f29#MFd zVNUe60q50Y&|8Iw{tTR%>`LHR51r^O1WuE}b4p(X1a1S)uf*IoTEkK3^#bQ3h37~Q z-)CcxQ_X=6+|lSY0Vl5ToamK-MiMx`8U(#w;CyrpdLiUD8v~!S*g)ZqRvuRaXRg9? zN?$u@To0Us3h!w7JrRSWvp7J4bD|eQ*m=O2sql_kzQAcZ2E7iJFK{mApbU;C1*iHF z2hP0;&nbOn`2G=v15h|8dVd7o+sC4ZhzThB*f?*0M1Ja&xzhVeE&P(Ogseu9Pym!O#x1o4KI^Ch=9Oc;C!FME4ZW8mluJvN8vf8 z?@3eSli>+|1$6NAj9J6ijA1UTPUcqYB$Yb#nP=6f}5&S$>= zQfbSd&QuhCi=)$gj;=Yx3}eh7PRz~2fXc^Jpcqr+b7&vZ%h#54=qJG_@gZKr{zp1W zKh!Jc@I=^}MS9IVy=JLivwXt?_n`=IqOQKaSpX3%XS^7YR{9~#ALdy{u;1`zfbj?a zIQs3DziA;&YuUzU>CR|&{BTz6CanIN(AshHG9)ZCt08Na8YjVyQu-Sv3&Ymnn!LuG zQVfT1odZTv9LO45#46O^7~2c43Ktn$Mt8Ps?!zj?_%03U-qjd{G3D^;5gd0Gt_>Hp zbTbf96qM}d_`2myTsYqsKkNaO3I5g=q&j{$JGwSGt?%G2#2Sjf`LE>K^ZL#_RQgF% zmhlNvYIMikNzbJvJ4!$C-@o~a_#1&?FREcD@`$C^<$19X!dkIKNyL=&-2PDfFK+ji z&4+NZD!3c!{a$=+xFAa}55=2mDTp6tMvx9B#jBkyJlI3SJcBcI5wi#PYxHDA$MI2WOphdXJjZWh z+2T+9Lzg~%c6Zq|!f$kPdOJ_oyK~B0c3IzF&y=x>bBN#YUD2R0UB&O@YGK zY9SQD(X*Km>~H8%hZ(!Kpe+}`v&i@rrf&@9Qhv&*arui?0LNOI|{Q?uqqv z!#eahzgEY_iO-SE`a0xmKmaoeQRwa}{I$w-*!@oYb;z!)T2u4pcn!LsoU*QL%yC>pZ*rR_9d-Sidb{y}7$&ocz{UDP}Y;Z>Uq@!-K<%(@FX76P1$rJ!8!DTQycJg-4h^#y%wa&jL8yj~s# z#{%8u1;D37)mKF<*+mHj5mwAU^0;j;ASp$;l)mTx|9e?1O|IcjVTdh zdVz5dTe=M6Yh_Tc3L0evxF28`4#G7=dyl`=SK6&td7?SSt--=u^AdevmfjRdNv3tz zv!z3E+k#sPy3sU3Xf70oXjBw|?>#R3qG0okK;bU;A@_dw_QY;VPp~iqGkLx~Bj8Uo z!N{B{mI19DB?WD%8cP zJ-FFm6>gMLI!<{ARmN{rgzHhS>(qgo$W$IWgy8gQV?~&XRXO^zs2_|geSOWzjXAv2 zpvj-CFb~o~OYGeP^ZjT6w8fdpq@)^YF{js_^_GenE`|mue|@ zWFics+GUFiD&7Vb+5rwF1EwRd1%`C4B{;4Jvv13{Nsx41uMWiVXZpURPn>p!eS6rYKPp ztCu6~vK8G4NXmsSKxg0=)GARz5^4k_+roTE2MOJ7K|t1?#~aNuxUf#NHtO|OYnuld zkWom$2rLg>)riOV12!e!U;$O4nT?rV|;AnPU z!`Ofqqsm9+(^G4dmUOsZ8r6k4{K7Tar8B&%!=gfUi%E3>)=Rh!gYLOfX5zlQTMLXS zqM{deD< zvUdc|8R$gOlU50JHZ>`2S7oKfM)^5oZG5{2=LuTP0R+%Dr=?l;%I+iXU$ZU`Lk9=# zkRPMSvAN||Dsh(nhWcIa-UjWfK+Ns4XD9&UX5kkUQ<9YeYQgh*0d?RhYs23GMT8$7 zV#6T+y0xGv<(Yt0Syb0Rp4C#I<*AA(*$N(_#^x1vm+teg-w1r0NHm#C1h7}Da_{fY z+!N6(f{}jh-sJNvQvp~T-{Gk=K56*}HH_LCQ^De8ji;m$NaNuQp=STfebD_9nK;9% zPw}xbAV#t=je}JM?pGsvRe_ZfE|O4PEG(z06_KNogNp#kc5*Ku$-!@0e(zWi0F7fV zI=41VaJ3e&>~Z5a&&i4n0Z%;?aTLrx^ua~7#?6?wKe_bRYt97gFa+Ca{7$A;E{=uX za-Dl;y*|AFq672NsI{~#dHUvElhO*Hk!g%cL@5rpViYhn(%L9S<2)z|&CF+1c?>uE zw@~RnscDB&>mlysV7Jj*y5AqCSVs*Ep<{T-{p(TNu*>osEH4_iCaeY{9JyABs*M#D z*18N_3d+-)6iz9mSPHA~hz$>AIUL1@d<4{h0-6sv5^{ID55`~B5Ri{9DBg^8KwN2P z4+y0Aol?Y6Hr8L2j+)^q?O8J&$vW6{Sz(EB1l4j2RM0KP4V2RP?oX5euxn}1(9i`! zN84OFrGVqM)o!#TY_uOei!scyE3IC1fdO_@s6=96fINW8iEnz{QM`GEI zWI0U58&jXHcU&H2ZpmeWED?tQTB41Ev-RV4JDM+ z*s12?Fb@twAFjV3x+|_eyRH*w7z|C8Pf)GPSXWTEF63|JG7#7TgRLDfP}F&1bL4_6 zuz!kCA>>z;+N)_Tvf_vWRvJ*NnJ`PW5EhkM2!$KP);A*`bhy;D+#}oD2wb!!Z50?N zC4J|a77OFk-k^;x`Ac^uUp%p3Z`{v_)h48~eXyyEC zZehL=@c+V+7TbQw&uU4_H<*nyXJ1r8v59+tlpgfXqJuPquJaL+ndY7(@C}6sKh`^MFb0$yd#IDV4%{_|S3LOZt{H+8xp< zJ1uhIv@`P(>AvHN6lK;9I=RTjo@Ot6(6;Vn zadEYBdRzlH4AS}{@3mrF!#^4ZB?(y)j@Au2xuk{AV|)n5^0LR}gKv6VPB&eZ5fi_s z{(AfRR9sKPhfXeXAw-?rbh5Vm)qF*HNgq>-U_g3$M!+XMJx=#yg+PjRWA4T;HK)>Z zvSNa{G$ysHg7Ph$veW%o?Zm`y>99XvkfMB+qRjiT7>d~f<)gtTJr~rn(&LghX4%^y zTb0`t!jn9?dfAU}NyT-!qCCoq>l(+n*!8BzHA;+b>~V3<+U@ECpz zIz`z~lur?q5v)C^d}LYB=j&-cIH|d@afR8w`{$H%Kj}F=Wk7m3i-0~6R4HX1zhlqG zsr39v#Wh;%PZ=}M{V0zfK$$bnZr40KN#@*_3a6(ii`f|Xer^Ee)8Lz)=FbhFjQLC8 zaEhKac5JT~ogU+$+ogch1!el|HG_nYT}p%ynjY8b1L8VE;5-T%tYfb(G(Jql)vG9< zAt)nQR(b*S=hztdrpI;0fVj>SIBchs0FNH|@Ap%2oy_J0ccvBBS;|MVd@dT`bG7Be zq}lTx2Cek;oGH??9A9Ab>N0GcwN|E?=Za&&+x+Fr{$Hl0Z;<@9`>o79xQ&Y!uEc4F zVu4$I6TVcWm*8e_E}Fyow#LQ%BNGeUL^qP2j`}9-=mmvU(WMNajh$B#)wY}-YO zWth1X&uO7v8i}T5*RPmwt?iq(0%tO2TH9wOs~(H!aP9dGHU_29TQi?Yimf;r&Voj4 zc3U{V35aq*U(@27WY?+Q#inK%v<3?ek!{4UAcBeqtLGyzB4u)!qIzkXzhtqA%}|k) z6rEKmaNsgT@OHU4P(T)&JZ=)Zp~-BkMu2F)+YZxMun1>eHm<})JhJ9Y#p1`4Ek)oH@EKX5Rb=>r0=Y0;+FE8nm-(^~jR0h1M>@RH2 zX?0U8@a|K%Ob6*5-_Pu zeKF>0dpKMSZw$oT`!Rs7JJ9KhUE8|nmgUx{9g{5e;>aBARLHAL-WTSD1#&oSw1$iD zF=jgvRv-s)Kqv%4;jUT9yTYt7m2!F@zBSx?vT(u#62Rgmc6S#{*9xx;l zh7=v>^uU|uHxaez-Egj%HX1)acc3#XHeC8}gm_n4>7%}YKl z&S-@3adtR=mbsD1EAy-lHA3{0MD)SlsVXT4I?JM58U-U>%T|^Ut?DYZNan?Th`TZS zS^iN8uwCzRpfeObE&gU;^PBFfS~E(Y93?Ai2RZ}MGm@<$ZEAi7=S1Emu7IgDKMAIN zB27e8ZKxCl#aUHUp@Q1Acv5i-Y8*OK&6DOM=|_{Q^!o`Qs*XW%q?lZ~@jBiqCxYT6 zv5edih>$dS4xJUb_*aGN3-R}8&%~Ozp_H#1mqWA@Gdau#e9_o5fJH-8w42HGaOCc{uQdQvF%KK_m}Hn&x} zuw5+_J=nTC_6MF8Wo(vbMv*cNFLdVQKnU>hG%hHau#j;|_gNVizHSn<{@Mo{R5fui zGWf{Se9QP8#_M3HaHzh*rHl(K4e6)|(y?AiN1uVGEY;sQ;Jh1KufiDmp93Z7%H!-v znK+Vi`Z?YVo5+W7W_n;BP|ozBDOx%!g#%6_T56(b=2y3-`PfxVc0%bY=0JmpG;NeA z8sFH|c5RBQy7J8taoH(T6;G!uPhz?c{ycwN))Ao$QB_>NY{d=ci@f1RZI!T2$2O05 zvCf`JKNSY5=IX_b(bUm20}mZA!_-0D(0|m1jq}c*Sp1*d@jCJRfwvD*=P=DxnRJ|| z6{oB}4myr`s*j16NyjNe;8UpB`&H#;y?4?zMj&0MscJ~{|I@mLIJW-N>Kbh9HN4r3 z#|NV4_L^%0_PYfzq}N2&{j%EzMG<9sBJ9Qrc3Irk_$qpMet4l+mco zC?vZyk+PM1S5+QyQg+eYmENq;md8zy0}$~%)_CRo@fWJb%w1AmFR-#FEa5UL3UU?MLtUj%$wJE(X=jd^%wxj`G9-*XF1IGR2)N?`xax zGIo{W0_7l%1CM4mA3iUZW$c14{9?XHJ?zAhSU zo8HG<`*3AsG?y1p!8?^crU0fw;oMq4RAQ#_c&e*rQ7=^Sq9KUOzn3kVeP*%N*GB_xqE_S8rXBWGUvsz3v+~r?<0?Rv0%44J_O0R#KSqszELpiHe z0)I=OoBL_g&++T8=|SROknz+$yC?dB^NWiwyb!jj@fYw(M~R=OU5~qJ?*TiesKnZf znqDmESCmv!D2@{UT(jI1VkU{-jIfu1SIIJg<0noM^%mgh3Xe?9B%zz(e=l%Gv9#ch zMz0h&GZdZ^Jxcs);A|TNy|;n$$sp+EVmPpdLjt&?rSEIN`5%Snls;DC=YZ2=!*k-_ zd%$tCuE9Ccn};y&alg@q=R|J}aPG9>Wh#&Tpmz^&S}48Yj+Wo=0OvV{=ajw<(C7qC zT%9F#Gd|1kQUlyiELK z`aS{9jhrEdJ6ihI0Ow8{9_jsG)i^NMuz2B$)t^q|c#Iq~rjJkTsHu%!flk{8>mh83 zIMt>tht|Zy?jx`m&5{SOW0`v8co;EZqV!-J!btz7lN5nKTW~0jKx)23i@gH<0g8pM z&4mw7QTGMR3ivm5w0Qy>T+$X5`-jvrSXk6pa>QBw61vRtV-G9+0BE=I0q4><5|dg< zu3Rzj8RWostQ`10`y5D}$t;7K#18VUHhMA3AvtLT*3->QUZHNG0qRZ_psnNs zE-Ov9`qU}*9V^8sjn62>oU?{risP%mnA5-*PYrl#V@}YD%BJ_yAegFopC=38Q0>S( zjeHa9$FL;<3X^2LNAw((*+XRW_A z!B;Gex0*56FS8-{xZf%LpsBVxRgF#sAKFfC8!`Rz@-Oa;O~YX0-;!MKSpN&TvT{ZG zDzQ1xgA=#T@^3obj17%>L|eZ5@^WU*SNcKYckqFke7TFD)3`D~#ZS_ zNO7zOZ**De*ry`E;1~xpnlV{%EP6A!g=&$XEXo0ct|7m`Bva0voZ`?_!6ET^Mh=C^ zAw?Y=I!SRTD>e)q`ku-M{+J9>i?~Jg*>*K#>L~ETn2b+P#;4_|Ia$%a*Vm!qqz?JB zb6_&^A#;0`1H< zT$@l_n^;`3w9MKor(XC>l^N5rfDbra^dXdFuF$ijcz$9BlXNPYYaWJ?!Afjl!P@1@ zzDPK}l^1MuvUn1G(XcU{_x%J>cma+h{hLmOKy1q&HuEx6N^fjvqL0FkiSchL@AGe( zg`Yj4spJVLB@>ypoA`ipYr{nvDIL@KhQ-!m3-NV*^TSxf&BS6IxA941mhquT-W5z9 z7wLnU=}8;Oq!FJN5%ChD3@H>fKb>!^+jJgPmSupC=P1`yFW3i5_rE#HZAO$-T%SI3 zA(nRwp{soG2jvn%{h#-rgYQmKh{%} zuP0eJuBS|=Osh*epPg1uHUpEC@7?>r11ZX@;Y0UnR!^E~e&Ow=%Tko@kc2T!-apN> z#HFWMuAcld{8dXh$_ZuyW6=tU!FE&Mw30XGVx zf$%lRze`2uB$u5!jmU2TPK&}L=}aT&dGI%Y)2r|(TAk?i0msi40p~<7fUr{(jzGl2 ziQX50H}M$sBKUp^aPC!j{NqILc?7h%jqjn@Vze&C zDEZNm#!EQZ$6CAO?ajhSA45&OJPJHqND7SC<9`XLJ^vW!6C?hTrB*c%`OCCx8ko zPEcEhr<^EV2Z$Q3ygWiec-8LZ11>vl%G7r81`PxTQd<#i2rRwqE7(0DS7ANRDzT5B z#&Ppu2hM_8%WL<%k(!b{%G+DlmVRHEr73;^pE12btqf02_(@AR4A@#Te&z%&hh(|h zxQ^5;1xdgYdW&>yV05Hm?dRoQuZwX4_gb)aE%#xm1bGsDYlqpcOf<@)YIAzU%@~?t zBO;E2?jbqFTP`megP*)$?hFBq$5Zlengsz67y9up=7>b1LV%C2R*7Tb?Q_qc+1$xv z%to5CYfa?5+w~}()cGcS`6HVKqNIgQt7Iul#~zKYK)&K>`dpOeW7mjCFTK}u(mdw@ zlk{soy76GDKfMe-bW-yqgcUT(_3vQ^uZyy6(M_-4T$qXrY!HsRX!;H%FZ|PU;kb_o zn9Q^1MD3Ln^_J*m>xruR@L1GAv~txOlnW5_G9EEQ03EHQAX~ zLobAXbTJNvy>XQ|oRta+>Z-XAo%gZTN2ydS#l8=Y!(U!9z>#}l~9uL&jCokg}@KZbMVbS4V_Nc7ZQcw61AogxK zTCW8G(DG4}M&hqWodH1O9PBvQMNWG#_?zgcrujB<8w^jk=Ls&J0CUbYUDLF&(-ar6 z4;(&%J0sy=Jgpv2+~P6Ukv~OHmWC?cBz?^8dXieSsws%NiXvSi7@p3NU( z-~8r%r@MExZTa!g1HI>LhYh){g_$8^bHJikuLEPIY17D=55SpeeIg~~h;%9aiDN#= zmmgaYNxg=jkF|4q-mcEgBcVq zbV}CPdVP-FO~+oj{{mlo|HQA;dq<}}elIccd+_nZ1F6{mbL$e9`(l$)O1NMv&Z1@4 z*RNi@5YYVC^5u(`txjR2jt56ClzD}lLoYO8oa%(cdIyi_g}8E*6^1TTFZ8qwN%dedwT@l@ASjVr1cd8kJcZ%b82tT1MfwJOMYh3`bh89LDI_x!%tL9 zccNDYdZz=YUg0rIPU)kz96ts;i>DJUS-HGE1NCHA7M< zXT3QMzo2$Hp3FP-N_o;N|C)JGD>A?Z@Fc%RY5PeqX1kG<=rGRL$LX%vzl_cHq^EHO zO^2;VI}<$Vf#uc72oG*RIOd0)X6QdKK;co$cSi!-*(uZZr(a&*S z8B7g=m$i|;-@x{XEDteOdlCm?y(Jx-dX^<~F3G^5;}pCa3-~zb&NtqI`={qDXEk0Z z;!8a~tB#W$M7kT;aZ-5DWj)$xZCs2U zfV^K`yqSx~#mk!c%Wu$zLX*4jqW{2tcR@+z8hbJ_-MXCF=Na8;H?nECn8cmgsVz^8z>#$$_On+AIN*ICdPToqJPLCso zYX^bH>bZOncpO2l83Z1M^@c&Hez zc1UNz$0I78w4KdB?f`V{I(4e@7_V+u^v1;2t20m8=3HIyV`*w zR6qW;yJoGp!``JajP2;#p!ckz$u7-lq_YJ$yKQ)xMxJH({tv*(r%ndPd^you0GvjJ z$9OZ*WBS$t=Pnzb6TJt3^Mno0iQZGd>9FBB(c1}}-`nt<==~Kq@7wU4=p6yh2&KC^ zCwlwXowdOySN@znG2u(?cfjpg~dLEup# z3l9R1s@K^W@dlphQw+Q^h3mw>4$!+2I77z)fIC|KivVYy!gHcG4*?Cp*;yj#jldtl zzkcnF-}iS;XA{+ohYZAz&M98j`&9}@AmZUv51N73ehhjn{{I5bPKC$vcA~crIERiw zFM{v0EIh`Z4GQK<|4B2cU3H<@+<>{c;fWUK=F6zXR{UAn4hS zb2)1I0+L54%SXT) zc8SDtigz!9PXx{f3Xl4)6JMrXirvHb(K*p;Mp!*?{;cqhCJ){Nj=KyWz&X*|g|Oje zn)XNh=<@K(#25AhznV;pl*^=-u)Y0e5O`dy@a7=!81K7-z@r)NP)59g_4#Aq`7Xl; za4!5Z>1)i#NeYK}bWY`VHt;Sy2EAqsRLX$UF+X>J`UPLnCPVMNd zYcSh~ADt7u00J%r&dh5i-f;YJqW3az-cWc>^jHkNz$yKbq?f7(1NnC?aF!`NCwi+8 z&;*<}uaoqGM@iq4bHG3R=$z;kBWxRRKCt0A<+l$w{<(sjBfVV+J_R^E3Xko|iQecs z%+TUT=afG3?*iZ?6kZnIo#;ITobL>R-j9Lfu4k+=UMG6Pfx~kOO}tEUd=&ye51g+m zyp$XoSiZji&P&Ij_Y@fMJK*T^WxOdpVjw-&0<09mkM3yv8?A68rZfL;0N$;~pf?Xh z5`(1oH{gA640^>#cpq@iTO?C=wE8k1I5#Ogr~J;#LLPv#XNjce#~-Kiz3F=F*TIj@ zi5}aB0i5R*9>_b=dkHvyJ_fzLh^PlRJC-q4x$Mm;eQz{q+Q0Fmb4(usJ_1hRa*3CV zKTh;+0#1vJuXYs<)WVO> ziCzR@Hz^!}h=)`9HUsbFW6%rX`#poC_Yv@h-6UgmN+0Q+sBk2vbNVg--n3)TW71{< z=NAeuRsYiUCO`20t#HhEo%9l|5%zEV=$!JwcuxgRo5D-A^YnPBKW|hxq(|oz?-Rh= zq;QWGZwGLSnL~V1vu|2JSTdO z;`@(*^KeYkJDOeZx4_w_@SNy{K;~WGoUmHbBc4_icEY@*4oXBMJwga8C3_+>FIe_|ZA#m-Gr0jzGl2 ziQWX@O&PZ`~m2-3`2rgP`~A zLDG8`c-xObFN93)9wfbYftR&ba^-0J^C_HT@h=~EMT4Ms;UMXi1FvQf^yUqc-YVcV zAA=tG*EUFc-v!=J2SIP^AnE-Tc<&E_-jPAlJMA{CQ^Jq#XyrRW;Ydv9_AwoJ*9?N* zf# z{$o0DuCd`|>W|70(E{Lny_vDv=Z^-aFQ)}Ia{TC=()TC=Lcr;`L*mgM?UcT79K6Pl z&XFF%E>SoF5f3MNe*)e+{pcOv75vBP{EOww7GMqZP0K&s9$GCV7*^I?@`j5)lYRf& ze@ELQq*_QzOO99{Pg_ckn1Wg$pnN>*1r)+_j)1~=(x#gu)~(kFs0hz00kJtm1T-Gc zs|7Rx&npEq3D3&~REFnN0r5FmK-2NOL_k;JSt=mX;`ce)Y&KIF#Vh77SiX2H?+j@gyQFdDjbm@b9c>D8*~0lGI(Aj#$_0zHMa!B5F0NLazkKYn z6-$;aU#z9QU>)&_#S5cjqswkwyfPNmmaPD#`MCFP^nzTifNE+AuF2MOm z+R~M{Z;nSDjKvA$H_l(NNQ*TgZ)W;dEnBr%TQ$F_X$|h|(|AaE0V|G?II4ELUY7^L=G;4q6$bq(xGuKM`N{LFGA13Q-&4;lA!>sjVr)r!Zi-ybG2s) zn!7&`ErS-~mqUN`6rgxe@y!)CIay3l-?Sh^@_{{|-8JJS^EY=QB=a}SiP(JZK^0mC>ML?C2S8aSD@itB*%xQ+U5X&*f z5*-(jpYRI;#(U4P2P)b9-V?Fx=jqd+RkNXLRpN;QaEg}lT&GA^Yq*3_iPAGJCQ5v3 zK5t(qC=LN~^U2RTaDQ2GrM#Ei*dIUA=TH0r-hHoM{15zzEmYT{E!({hl;zcE5*eF* z)*w{VSHKBDa|54{0Xao_7kO(K?iFZvhH#G%udM2(w z$Ms^&c;|rcDndpu$Q=9xf<3$XIdjdNrrHjnF^KsF{BpEHJf9E{3+o#Knuh12 z0^+p$BLZUA@?ZD`MbSMZ{8-B#6wpuc{HlOhbPovVJv{HnFQ}b{<|F+I0ZG4F%Wt9O zcNd`h#J67sbgzJZWZ}JF;mw(&&7okLqn#_Is}N#9*WLwA7JeQrPc)&gz)x*@i(jHe zSD4kn6F<}!oriif$EXN2PejeT6PWQs?$u-c&){OS_`a<8=B$gm;i=bzaOE7Kh`nHa zs6}<1sBpV-)t%G!YUUN8GB(u3l8%-STTm+g`#VrKrpNc@X8#eN>E(Y_m8Q~6m?WEC zSnWPU{sa7iS_Pip7ZA%s@|4}=_ko&?Neh{cX? zBM0}_$6vw)_U6rj*bRsyBF>n&QOklZA3|>b#N1B6S82IbSJ5ZSC!sk8yTHlqeKmSr zNZ(k7!qC^R63-}}QZ6hHhd{ctHtt5 zE$c$$Wb90czaSFyS0u<79sw043bF4Fv7?z^*C{_XNqCW!zcDK8>`RL(J(}nk;E?ib z%xWI9Dvu!pVI@2|+pY?SOFD4L$b%+vPswgnDgXUj>h<-k#)$q(V~Y~Yl)=xzGpMoe zk>&D5K(bs|e(Z088Wovm@XHZx?rGu2@|0if03^ToJs?@mdjUzxJjF+TF&dEkVhkYp z#l?VF)}m2pU&0$*wl-9F{1|Yqw#8%bz0!{xQy*w7F7vpt95f%lJVy+L*)6)pejHcZ zFNfo+t@s7SeRrJ#8iOZuBvV8wL}%7Z=FW^~{Z)t^ag9u_j{w58nxYb+I3P>!rq@y} zgyL7ezHadWsdcY^6rpr7A*TR(5x<~NKX(cU59^puGj^uS+A8aBHSlVb^Ki8*~u%=vbVh|woo-j|1^YmJ zM6xEoL0ut=%o*iV;W@;L$f{{|s-R8>6&W|y8v6cjs}zE0h85c)IPA0{kWui5+F$zfY>R5CMT>*%#M5d-15S?4g5~aBp z@c+NO{u5swE3bbuse6nKyk!*!Dn-4<4}$=EbBw3>SAU8D`cupd8F7XKBT{Uq`UF1s z6dz0uq!_>bOYML#2Kghj7040(spm+QJ0}?iGlh*E~^+o)b~mYQ?ugnT!>i z4bKC#Gvo(2^1Jgoq@_mR#A>e!4hXTVl0E4tOaG1@%p`%nOP(6vFCX%Ht^iV=BW{!2 z4Jasv*t}dmC;mhg(r`W0kvb^Dq-`H9wYO7_N}XyfAlY+HwESjT5CAa- zq!A-a3y2gmccM;vYm}fq# z5*&SMRx7HV@L(dWU1ALoG^s9y!n?uCX6SP+ZpzA;ex4U7Z)*VXx1)vk1vFzFdrFCB|c$B0V|67$#fCHSm+IV;LY>G91;&cG3w*mJxeLSw{P++$3~Qu zb~XMB*~Wo)TfCZ4i~C%5;9884@y%b09}cdW>EEP-zSb8`@{fO0nX4^7P_m=>qow}) zH&cPWBK}5}u^Hc{h21B@CW`=IJx-d^V`a(Fo&t1^fSv}#0cMU+r@tT|cnKwif3wsz*98d4 zm9+&mDZ7NCoyL^JZgiZ*OG8#w+J$xiPdCE5?(o3d)jPcQxeXwNQ;$D<@5%a>wx>X= z86Mqtd=C%{O8*L5vHlfNJ-@;px$6!;zcsd`iC&;9Gudf?E>vG*+ZW#G;6W7a0z8$$ zthK|Rprm?~{$1I8y1ve*sQI`MB}Wv1G@U)h07#drr3A#ITYU0QpZWlqKe=Sb5@Who zYN92(ml(TrmViVTRF!UOsiEIsut_^)BTIkV7uf=_q(deKX?tI$O*J-V?MD2h0WX4A zY0H*=ry^vD2&HhIiO?X1`Z&N)KqY{di_l4UUM;?z4CqP$U2cU&09`J=mmUii_(jzG9mRX~eFG%^)NF{zrQqmWs0wguuNIp&9 zyTmI#35rkPpV%(3rAJpHo9(hY@i=?|X|V~Ve~JwgQNmVG*lQU-8A#)2^yIe0hd@T? z@JHbXz@IoD9)@69QbrX?-X*eDIZO47TLT>bEw#QaQ|z+aS49*Zh~iA>JxpKXfWMW4 zs9!Li=UB8%fj_YYQ1`SD?MIJ|2OLRWJ;@yVdV8*hw<@js!g(MwOP{8J1>~_Yob5%N zV?Na!nFft%5EA~@w-7k|G#Xb!mQ3bv;~(|K&PMF7fD^(iVoWn_vz5te^;ORqNCdx=vkzcW zNe66K`S`&!<-?!68p2DUNkEbdLbMs?z%$r;Gjz*P-7{ej?k-`)g;#&hfJWx)lNrxcp z<9&Vp)?D}*({PQHH-31io@8-H$21HDvDZZ=@#|fo}8iW29YO?hEzYP!n zGv#hwv`^#bf51BiPUDTlZwYl6pF=9NsO)HrB!e3Qk~4Z@I^Iy%bb-@5+enZaI=o9F zs5u2o`Qb|TWPZI~LqaPvMd{#*poER00Q5`9j1 z{D#@#3DJ|$??q2&2t|-H%XH}L9S$)v(Ujeu_|G2(%^~=l<>9|?3qxl`WE-+<&>q#u z$cR2;fAoBrRByDPp{%xCN}q;6t+8L#te~El3bK%->^SMr0LB--TZ5!bup~aL4gSOr z5omS+9(p`#_n>*Z^&R+-5xHFnPM5lj#QXSz5^?L(@{w}Jfj7S*Od`~QjKt3*+PQ6y zu+NQD%f45N1Y+H9MJ3C0gTQM`e1z|yJPwuVLStJg?mWXlp32RZkk!u&XFp??Y~J3f zXpg@|dweW}AbS(^_I|;rR&B3)8UjUkl@Zm~_J{`ww%CG%^IayqzHWmE41q-rOiCj|7mh4&^PN%`M^ZW2^H5L>GRza2hAsp|D@TsD%!2+4kmSa90JR9poCcM=`aPhz!ta2EM@>nl;A}v1 zMCe6;t`pF7K(Z8W2gI5j)V>KwT3db$h{Nch_8g#Hq7+^NG+f~Q3y|d1VL&p?Lx-4t zK|s=P44|#z+Y7AFORdlfKwCs;9iU$c%CQwUtXR2bg?82=HBO7vPStL_1z0$P4p=`$ zn!MU*Ds;kXl-qyQtcFz$fd~v;KC`d#rL231M!OS_9Q-p|{t19ugB#>9apP1}^Z|100GSN!_Prtf14fMGem{)&hv757Q-`?Bz>UAAHo z77Nu^%+_W~b5t?HltaFybjsD@Z{@)n6|P2S;-kLo6$%M@81F1tREnr9q3f1Y#$$BQa%;JE`RHEM1fata;Zm+PcEcSG#svNo-o#*I0bLb zH@g7QveIy|oxE(hqd9$kvA7J=WZwo_65FTCHSP`MX$0Y7s7{D}ezJDo` zVfM$q>G4CS`tSS!65AI}FeHHv@N0OL=1{%d+jBSG=&R$eQIjt<74*J>d>q4w^86l( zu&(l}T|I31L}u;BRG>^(8ggDwnLw^^^<1QoY3)++<@B7cJZXhDDuOblX%vDzoabOH z2k_UZ31mo8pojCv#Mw=pa#b_a==gdzDV!e=ry`Ugu22vApm>ERt4AkNO;Lu(ih5TW z<;5BDTHIUPQUN<4wCW0I^(UD;gW?ez(z3*JJMR7H9S@Xd(C#gSj{wGWmCtnb=697> zYP~0Ql}B8?P=lgAvq+{xl{Th%;@gD&vg?z+zIs|q%`)|1@z2)0PNNSr|JR(Q5CCB7 zej25hqfH0&LqI`|%zH{e-?X6TEa)Xb!|}_}Ud8i&1YQpy*2^62AfVC0FMy}iC-MME zS<6{}=|@AC^kbhSzqs8Br3{jx-?03iwEVg)zn3gO&df^6?^%8{d#V%wlJve{`JHe1 zT?I&{pv{851Be=TP@_5d`+#z^p8=xHAxG-~#PsB7TLFDnK-&R*M?k*>^lbs{0`x5b zy#nY70sR)xHwE+uK#vP(FQA76^jAR4bB?yp@_WmI_FK^V7IX;E*Tokf1A0tA8nlf^ z1w<`Jro{`0!XiiW0oo`a&KW%-pdg@!1(XNqzXg;JNTw+7XYmg6!-wMiy(f)(IoN44C~J-Qc)+uad#B=0#E4Ug*>G3* zOa>Y4c&RjuB8gEz3|I+p-=B;KEqgdxW05{1gdSpgZ$n$0x^&eB3{vs8OT5XxKp5GR zn65HDdheU)G<=oPvSHdcxJ;^EkFP=$dYr0j-8ib?YyG z`0LVGq;gq~oJK}Z=$&{En@221*ZFtiJydA;#=jHq$y0CqYqXFVrCXwTyk*|lZ#2vI z*!%k3gz7qVoqweo!I-Y&0}h@@gG@1N20euNmr-(cr@7qf;V`3xflaREWba%piwMR5 z1{rs=a+bvp5Aol(Ir#vMIF(guw2uMw1iV9z^4_6XHbs?IsYa!8bz|XXT3JG~8b+Gd zFkBQK^<#oaFrMk!63~qGtSBnpyIGN>m^L0@-7@9FBY{FpdfZ8#hlm~?(=!`WrSdBukFTN}jF<)Q*w1o1kPuQo)PgqG)pYTn# zO@SKCMo{l?;}@)^&`(F&E??Ex)3d%y)Gv(}D?tZVebD)UWEM*|_ z)Y?ZQ23hVG0Ad`nWH>udhuGnVLz6}9ED4YgfV@vG`GZd?4iQ7lT!a=xH^auHZxBz> z#IX2S+*TDKN5jj?;qbCi{!r(bidSH&m ziyCzm=V=n%piK^|GORHUNhDD7fttVdBt(djUSb6PN?HNZ3R<){@$fVi04cSgY6UCR zdhG|OR|!OY{muM-{eyTS`U6`-`U7hLLmZ+W`Jc(s*FVl6kjX+UOp*J=(#`%jkm!yZpsQH`*w5J+ zAU34F4$7b)@czwjvj)T;!U zb+EnNk1%PT`aB>huO|T75A2{;4QLoB1hu&qUaJ-QRX`sIJQ~a-^u85(E<&W=R6x8x zIVcRVoMV>ljDr|Dmo{9~AP&5gR_SUBG=KO}(-6#~=_CD{w9Z&=neGBFI-5WII5spH zal`wWG8bMyiH*SJIQmGV%ykwxqje@DL&Tf1MKOje`G8XqirlI7M&7oOjA>}H(xqck z(DhJfY{+Dt%j`>bi^zs0E8PfrW-@{pn?H$biUP)D8QVjh$;u(()u_x)S-%8>8KX37 zrD7&WM9jWw+?(l3dYWrC?{%vw1#A>T12_QdQ84DNo7)L-9~alC9Uh{ebo&YM!@02&jPm#6hekw)#t(ThX>@paEVrfN zW33sZD9kBCB%MN9WvGtUR0(pWm+$Y*?JnPsTwo{DA^tHgjdvBW0iTN`!v2+i9mT6< z&Jc_A6h}t^o$@azObZ_gh$90DaU>(5&mrVByvh2-ew_|7Rd}%G39}x>Y6$BGrRXHr zJ=~$yT8K*8P~1>#Nf1aQeQh`tI}-!0)D%kkc#9JxG`wJVaCu;<7BV#`h>x=5Odq6G z_vQIsB!fo6?p!9Q`*L=RnvP{{7zIrUG*37JOJV@x;fTxMT83mAxyDLQyu%fLRnu2` z8obGsfoeThrV9elo7m%Ty_R^GO-yyB^To!UZWJj-kt`rN*kJa$%R;><2xItigjMzyn!^y>7H^hj8ZwLCI57m| zS@8~Qv4<~(osy^R?Zbg4C2AOuT>Ex0AUUqS9FQE9EdsO?zo14vRo3n|EQsGp8T@NN zk{;{0tld83O48#5t@NXfL_!m-&?$gqY#^-7#+$UV3={2vGFi$ZaMas>8$&Kc;J{4` zavKBt`k*!jG%2%HYhx5}<~9aux*Vx{@fUlru!t+6hzrTbs#bz1(R?eFVDHwHU- z5QW+&i*g?;_uE+HQf_Z>sXdO+A&{=Q*y0FkoyJ{aNMF_9S<0xzgUe?M)CilFpkh;# zjc*O1z9Y55HL{afx9^c#M6KoP#GGq>1~noUN$k1pG9(CDG!w*J z<5~+7>{mQ6shcJAi=&^`ePTlag9T zmGPi3Ma8cI3U1ks<%)&O9xeX7P}rhppu^#IL}NIWu}XW7qcDwosn8`o_eX%xP#o!w z^GiBe%BmrekPu(PLkP-5C|Mopns${-uMQe%q8{the6fJFOu$S)K(E$} zGLJsZW9-z8Rs6Ktqu)!-+L-1ureo3!t5xnLwOYN}oBVMEQ1Z5X&UDfQD`L~9O@e7h zpH`+%o30CX)Zy-MyE)-JU`vkE$|K8T0U%lHZni?nX&L%mKvLiQDWFt&aAZU0(t@Hq zxXfLZN44>7Q6LFfAgS{Bxmh05(#m7oB$FLplO6Y`mxn9`*;mK1MUIj)BKnM=VIs2A z#{8*3q|`%yJvA0EEx8_(Zjwo=snutAlRpt0yw&2MphWgfDbsJr)2B?=t0vXyA`jgO zCLI5@xpGg9)nYU8^BUkuezsW9J%CcY`v>0WTw0Fc9k~VGVP&~-Wm)N!lNz(dQu7+4 z(VO(>larn<{mL?PH=h+ZDV)g%9C9Vf;|xJbZY;ut9Sn4xu~`%9u8Nf#mg&8|_MdbtPN3H1?r`E+51GAi=A%2A&mV(#_2JaY_I5x_Rw zp?ckP(*rk*LeCAD-&u(iz*$Hk)j^S2(TZi7<)*l^MVjMpajOEg6>DdcP>_Z~PGX>o zGVSEP$$;2~eT2i`xx$mf$mLMEpzXT1L$roU_6SuB3eM^|P=E@|J3p<_B{d|aeFeIw z{(sbc34B!5+5R0SP69>}H7Y9A0fL|`hAixw$sQmZy9yFQGLVFj#AF7m})mrVM#<~}Aga7lq=iF`XMAPrH-|zQ7FemRl=Xu|= zpYxvOp3Bu)D3RzM(6=AYA!gE3b9QaY>#g{i;eUi;dy~8OCgB9Gzu!-NE?7F}t=OMB z?%uxGSKGVfXIManyQr-xTwodveTYXK)N#Ot4i$${#&9dKc4{_j5wg-w*bl4L`Dak7 z{eduemoy(lF*)-UXK`i<_C(lG@PKwQ2r3Mzjf5)Y1GQ0gHPpo5kB%M6QIcL= z!DKBJ>r-3yPzFL)+KBzEV_^Q_N@f{C4#=yqs?;aKtpaWt2DM#vyk#*c^)gXsW80>n zc`-{ToUy2iUkJZp#*qjVm+weY*q(62?_ww%ZyteCU*3hg4Hlu6s>G-?^o>MvaN;2+ zhVtsn?D}A3A}k zoD4`hcuxxQA5BudDS`t(hV3~(O*MxX3V{R`R9XqIo zKT~@^1=%Yj9inQ)X7qN>jma@X0HFFRKUm&7^s(|#OolC0Gf|GQb ztFlXOCOl+LSj8E%PrhYf{ zv_?gS)DoRx)<&CD65K>0r7m}IK$qxG!V8e4SVS_SqcPF@6G!snSai=Ydjv3kZX?pT@lP;G+1njr`BkcBv&J)-{ujTLx~1auh8Xv&6SLkaIs3 z+3P^w_^HUN1bIJ$aV*s`#OvS_Fmk76P0h}#qd%V9<{HJjU!DZPC^gfp9aDmAo}{;m)3?9&dYg#BCCwoC``p?^5B8)ck9_?DZ0 z4Bt!9&DkQhY@=HjqNLp-P(rTz72Ndl1FN_--$?DfoL&y-RZrqs?`uOhYPNPZ0Hv1$ zdim3M)_pfrQ}fjn^y0nZ<$zxI44{KVfL;#hRe#3wAQ7OKg6d@{cj+X4GSwCSrQ-B` zDdnp`sfo=Epwy=01D4ybEw{f}Zd|oixHLpV@tzDyxy`oRN-ek5pm^>Jm;ZsfQ>aEz z-xaC_)Ez>#gSuTPPMdEN>OxSr3Ux84TZHNY^&O!Q6*)u8zkY)Qq+#3)AB^QxaedeY z(CwT)skC4OhQD_!B>Li5Xs*>C5HW%ljEVfIh3pGed@Aw*6PY40ScnN=*Y>1cu3l3q z%xW@aE3XfkoQO@zr-rfHflU8YTQg(dF{nbKZCikhxe^|&^SICM1 zWybf$0}kZ2Pes0EBcXRAZ3V24G_n?nzi<@uZ$aMAM@Mf=ulTePCTQeFVKnPAXP&$^MWvy6UEV@qIIDJvRQ$caz zQpMtIP&8(&51Z+;?K!_GD7uIlK z;CcF#g)zyyMdoH$I*yb%Iy25$Y?)lDpi#Mux2#0wLdeOG^8>L3xq6j?n=3v0wogt@ z`x>;SIiEloPfy#r1-!At(5psc^KR7A<%bvNc5^u@lG>NHZDeU#dG!72f%E#3(;j-H z`-7F6D%0+xzKbD^YM;>`SXtU1$Qqcbh}MBK711$pnj%&Xd_fTt1~L>ecHl@woHsCR zTcEUT&L`0==sMD|4t#E6&|b*`I2XP2)>W9%j<~>(>uS{Ck9c_>cYskk{Ps z=3z&5ed`HA?SR|yLhS){oKTN|;)&OQ@mo;oLOluUXrZ14b&OEYfZ{=kfWd_lz9*#W z7tb-{KT1z6O0ryaUyeC%>?_iS=I5$~rVLJugWFdIK0@hcT17c(&L?SG8Id{fc4Wh6 zqHGq#9-H*UmYq;d`I0K`i#d$9^|;rGSy7;Jv$~DoZmIh_luEVXx*;!e+S$Wwr6k>{2)mNJLU|Yo0dL`X3LcGy;YE#3K zaajh=K%mc^+R%afi8qFcV8;4=Jc{NvQ{@if%*Ax&h~f9$;s)SpDi^Y}E0P7wwXjdc zZ{!WtLHyB%J@PjE1mohOkKdP~ao;+2GCCB7Mstk%BmKE@n+zAuh`n--psUZ+Pwts< z;|^O6m*HrL8RiO|J&)gaBt2m!p3#gvGecji9Hn=1b75WyF6z-V%O7l7U~}~-N7T*u zu$V@_&(won|4#emHW%lbG{m^W8V(n~&&-LutJYs;bFu%VA;!%`O~~&%j-D_V-G4>5 z&E?lEi5NE*^TF>kHJ-u`I~`@gLrgTpxVflV`+cTPbJ;gfc-0Q8T5}QO=3*#*wJr^6 z--AF@>n~U0n-$zY?=J16Xj-04UX4*V~$l7&jMdh2O{0r+IbLbB#7vx(<{WHy6v-?_)XAT(tNb`)#f>G#4>$ zF4lIt?M&Ex=qJcc%-rA#6%8?NF4iT#PmR>*p`SlxlFh|+ z2O47BTr4R&U9a82nDTS%3AP zY_8vFE@IqVY>#$W9UXT;r8Hyso+gNKbDbnyY^^jObl?0vo9jq+PB6r{xu~t$VZC?v z74OSN|chvp*2&BgxSPS>*JdmKGmOmh*VB;5)ZX()8!2(NGu$O`VoJ zP9)cE*jyXNo&L(ihm{FuJBGxJ^Mp0tg=tQ@FKCCw_v2~Cds1;4T-}n#dn8YAVSe$C z=e}!8-mWE25XlVVR_(&PcjwqdmmFdzc)~i}g>i@V6D|34E3E!O!#cwyhhd%W2@BmH z(jJ8E!>_64o^RXf`n{Gs$qMVQgN8L3-0nP_pic4*0dj~#9u~q;U*9;eiex)9lRUVg!$EDA5Q6*^Whf^Wb?_;~8x$@U{ zqTQ?b;XZiHMU1;|;ck@OBTWmQQ*LwpKywk}=E@Q-Q~KoL$xvI&r+&>vjGJqka8WO! z*^+y~H8$6Cnu{2B&CG_2y9B3rN-#$-J7BXdU-ikk%j^<-UrWxBvZ(EhbZltb2oy~a zVTnuK`mpUnDqs%9f^qgOx$t$zC&v??Ji)B?LGuFj^RssU%#P2oT5_I9hPN@!9hRfV zo-T4A#$n8Sp02rwQEsJfIgb8t1~Be8=Xv6cj#XnA*dzPj#$axSyiiM?DRFk@#w?4= z#Lo0co-G)uGoUW{@bA~#l2>cVvmx1U)V78rc2~>Np=lX3U31{;PS~fW-o`dpSakV@%f*>?&U@UU&-H}PRXxA&X4n*y)3Et5JM`PNd!z zREsu@qJ@v3nVRT7Xvu|;>~6V5!sV1)=#gA3nANZu=T+Z34hotn`CnRcu}5-=a5*Ix zdnA_%CUKmHvzve^^++y*t2>`dJ(AHy0@DtgaW4Bs{RBJCr)tUN9?A1OlFL1k=UW&M z#?)&9PuY@ZYsvFHk}*k(i}QSsCBBGwZ;=xgJ7P74W-7o`-S5i z8pvZ>a)X5BTydpJXs^jUe(A`&nNDS1&|JhYK6c$$D_rRsw=!6Rc42ZI&|Jho^IR8> zgj+XiWH3$+Iu3-MrhONcEX=g!oHSfH69YM|k+#Op5EWAx%AuL7G0Mdm!$$bp>Dv19 zbMLSvS86U|-05OF^ZVG=X^Q8(yT#@TYc66`=wH+>Ds;}E`FT8HwPLv4!lCJzPwnj#Ocrdm)d??^Ir`Od zEx8l5m*cYCYq4qCYm7IPd>dVqSrg9DT*SCj5p{8mxccjVw7J?e7cuTsu*Y+^?oLlC zSk!99!93c2&cowWnroZnK0UbM{y9jlP48l6igOG&jj_JD&TGW-i$b0)c8Iv zFUPnR37{M`zE8``Hh5yu=`zi@B+ezvxX|sAJIm;ZbD3#0#ku4f+|_VM&do8-igTG} zWV&5)X32~D4z8RT247xrx?~$KAlVL=>{-Sy;#{U1*TuQy$la+`TJstYcsF)Uith6GD182?(9|-f?yvJAq0q%q2!p z+PmG8Tnblr8@$9Lxl1ssVbjc;^^+%T$rH8YE|26bz`7-Oc_d$^Fo^R}phiCV?Iv6D zTrK%BNOtE&w@3129?4q;Q$riSybI@#wk0pplDB#!_jn|4^+>*4FztwQ2B@QMP5+H8 zIjkjL?vZ?jNAl$!$=d|O9vi}qrP~)wuq8*dV>QU&}*5nsI(bOTHG8-6i-nVBK-P)+6~k z!K{W&bMLx^pV*Q=)RM3BNd7voZpqhqBx7;~4CmCWbuF7l?zAPRvBAS!FOo@}qFoHQ zs9toE%f+exd;@rQ=+}Efzd;{!!gs3qShsc=gE7JS`tzR@H3Cc(T2Vd$=m=kA+xvMqVJmVA@M8Qw;VD}Ok* z;%C+AW9Q*U7luCFmJ8!wTO01^Xr*pX!9EaM-0G2hyI@$#G+&?bR*j9`r6u3)k$eZR?l|A>k^CLOTn(F{_YC|R!@C)eKWfR} z@ksuzNAh<(lJ6AETd>))Z4ADI>4+)$H7)s0NOt!U-}6Ym({ll=3v$ZSU55z zAJme+?}_sdfOY4__dSw-C>Ug}m?>{PTWm{C8>w7>=#hLEJlv9h=#l&*!332E0;Yxu`^WfdX(HWDUCZ@TFamVN9aB;`yXP)@nFPOynbElSkzbAhl z5H3BK8Ff#Ndf$%EgPMyNcYJ=~iO>C>`212ZEFv!3ESXt^4haupp4XCpspDg7-M@mr zJEgz$NPbW-H^UC#7aBSDd|UFnTJnP)$qxxvI&3o*4|*g&ESR9i%>K#w@7m}ibtQV( zBYB5#IVC^rk-SqdSz7Y5{Wra4Oa6kEywf9jmq+qWkL2Ah$-lYct(CUqsao=GkK{cb z$-6z0e=V3GY#)B7=3Rn`6e*gyTJoYTEc^e(U9YTk=vZd9O$E zBf{m(=e-`u`ven&&6s}t^VR4q%sAI;$@@H#e93Kudnq zBl))$ml=ykJ(3@@FqFJJI%TUZxlc=e%p>`6i_4V!m`Cyx7KV~9zcf0O;+`Y~3Tw&n>@BMKM zaGq6r+QQKP`n~H0?3BKtB|q&+>F+HrGo?>^B>zD$R|Aj%s;}f5%WTObSY=@TAdXOf%-jVX}-#ZkL>y zaw^v5nvQ*|)kqCp+}h3`=_2Q-&D{8dCpQ>xg#lqqzJCM;PZK>_=f*RV8%}){lf5{} z&v+z1Yhft)nOl+$+LEVg$1(QD$U8p7h*(3RRi_66R z*(3P{!31H`-1Yw7kUb{4T1$SxBl$1Dy7T!3kK`9E3<%?f?$MaonUdFQ$uD{&|JC9$ zu`hZgzhq%3`SQXrDxQhnq9woNk^Hj7Wny3QNdB9Jq2$N+T!02+qOZ}C|K^eWcZ>v9-2`$h2%Bc^+jY0ulE14Z|HC8spTN5F`5zw1uLvdxo960GV;s7~ue9V>Jd$4p z)-CxJk7Nw+jyPvLe49g;_??#gnnyCatvJcAc_c&8)EE%PLp!d+KyBvTKeXi6J(B-r zahcfHJ(AzBFqHhjOZ?)BiT<~i{Dw#Jn--UeeZwR9Eek`*1?lHB+LDuwrW}SORgGp zy3CYsz&TxJ7~O6;dDD%H;#~5K3*uaIuA`X*naF*c2Ofw#gbICG(>T;O@%_;+NA(ze#?DXYYF3#NW5#!Qi40)T!sWA={ z%*_k~=9!Eq(Qqk@=4qW9!+gvQr)2Jmxg`%1$*+S0i-VD-w$|Fn=62lll%HQ)6spad zQCVJ598x}=`I!X;A)~e-ytXdd647`IT38$^Dk+&C+E904{;ax|mbOjdhWuIWb@l7R z5yh!xR)pp)C@v3mcDCfts&8s<40pJ^3kyRPMJ1)7j&M5w?R6cU;rv+_M8h4M-LUzg z;sx^yLg7|kO_e{3OQfCov(|RBZOEUsp{_F$FSaPOpsKJ;#5UE}F{zN=(Y7Y+7F!ys zE-I=FH8gc9xh-w=b%;k(D_=NuL90UZE2?Tjg98c+Agcy%kG8hrZPEN$k){pdwx~NZ z3QIyoRr5!X54;%_yxX(p>AqafMbC zswk`|L?J|?9mxN+ZP8X#k`8=D&m}&uw4%HQNnI0N=W?G}Q-mTnZ+~-nZgDYkAleyMU1n656<3B56+~`H<-D3udsDl+ zHq5N5DW4Z=uj}mG)Yjn+VrF4cQL(&4+!5|{Cv^IP;+h4a&NfdY$(>hSvLMvnX67wc z?>jGO!67RYcxzotE!suh1{^Qz=tRTqSZ5xa%4Xb1Jn>v~z;aZ&n<-|5(yP%=g z>UIiojDbR}iLPB6?x<}Ex2}sca@&9bM_ZdNtYvge2PdsQz@<)rX*}|CBZM&DL({TN zChdxS^-z}ShC_0W)Y$HkMv1OS5OA%-#bnk_mOvB3oqOhqZhMAFNL=b67+KSb3~Z=n zL1MS0X+wK$ZBa{GXSf_Sq$P~gcG_`qI8sGq4S>pTaRlrk96PAh3CC7T8w)~7Szgy< za}{tf>5^QS{9B}ptmZa2qqrq4lZov8!WnhW>-}$C=2Ch!Wgz|G;_*tce%A-~lz9DD58p188yhiQXj&QiPt)-z>I(S3s zi&V<`+K#q1R5k%9QdLCd5bneXM8S-5TkYDGx^Z3x}14$w;3ytjIVAG%y#O7wo`4Wa(mE%;5{$(MGtz z*oKm3`&E%swB(&DSW9vthA`Axm*n#5#Y;@VD#sWnDG*Ub*nUingX0;-I@FT2ZD#38 z|DYvzZ+VqH6{>zo@i2BuR3K%Bd(REDuHM+jVX-0gjGD zs;z1VsxMcW0&NKmC=$w+q_T>jbX%-$EeBmJo9^0{Xs7hq@+3n5T5>(c3e+!YE$Ckw zqU}O%KpSd8*{NJ(IqD4Vtc9Xrrej7?L1l4Bf9F@n*?~1-*_9D9rT#02vrDdy%5C?N#$N`hi=4P5B3d+VO>K*2OGii#RX;YJ*SMK(u#SUw7soG zG6`K7AJ>P&?R70suO#Ud#f(>eIC)x&i$ijxH#KS-+4xaFP3>mlW|f!gvd8C*U8R{_ zRED;)L902^b=FduP|4L*A$NXBRZ)l^D0cDYmR6Qmhxo~2mvcp^y0WAqWPe@Q<(oYZ ztus^|*JRMrtyZG7b=?!{wu5T57N0AYCS}yNwApw|fuBCFqH;k<4QVP!-GSn+6Q#nM zO>3>_0-}ppy(|j0bzNA}E<>ZPw&>^UBee}{*o>7^JqKC4A5&c~d^_9gHnr+PF`3Pt zC6sNc3#b6K(#1I35_ZY#{d7M9wM!2d(ngxX7;sGWCf=pCrNw}@Lxl)A1|(9b+Ke8N zq`7EX!l3qQCQcfqJ(@_wIB}?rv{~aH>bB&8RK(6!{Wfv!x)yZ99aJOMw$`p~>)23- z+Nm=l($>K-+DwIVMK$xdtqn)&8&$mRELM()CY>b8P!f@XO{RPWP&vZW+&Wn5*@$&` zy<=nqmvXYoQ!**et);1xh2ClRhBcw`(t^SeZ*R`eGZlEP3)j}Q<6KGunqW(V+2UqY zR~1x-^7D9sa(-U^Ojm^z@#;!qJA}$md3i~J4ncW(nN*27(j%fU4XlS|9(JU?voRXM z$Guza+~^2H_2_K0EAslLmKOV|Aqovr^c~dUwQV+EC$vTTslBOno&CgqRO`fUCVH@2 zjFUxYL>86F3%8VT1fFGOwP}MszA-0uo-G?|bsx`WS zRmPD;bkX@~Rhe+xT03=)%E$o)9f6%)4nK!T)~-kx*=h+?wJVWZJ?4&%jIG0@1+(FX zxJWj&B7c#MPTh(JqwEkwjj}j&EnA!#%v<2{ZRmCW@pXH z3fg8`*37&a)3Rse=Gbnere$SKpFTYpoS8LCd#oN&f%k*feeb@|hge7Aswj=~E-XHu zho7u{@xe6MYSimci%q9nL5wt)th8guNH27*a?zP9t3Qsz1=DL*JJ+>{V|-o&?k$bw zpHO;w;hDuHr3FhXmQ>6uoIN%gZEBc`tG>nthvE#DqRJ(4*y@U6bWJ6T#|F8QyhhH4 z;55$v^7=8=5Lb3!ysYaCuf$sr?dWitE}Yu7rg^4uY&sV5u#U--F1L-Py=2^&%BK2` zw$8S-k>JEdrw6OCdbgqJBGji~5w0u4nA0H_^QH9RuC-;6V{xZj%GG_x7nII^GI|u< zqVL?#ELyc2x8a)CX5txlbtp5;7%n+^6dsd}&;7nNRrfm`DaDGsGN0FdYph{zX(&jZqoDJ6;*1+h%>XNP0MvOsLyI;(`L<@ zrr>O4M@lQ>S>SOxCW%_vZ>4-RfPWISvYX+28Y`;9NGo%^8$_@1`1N~mSv#CLM%)hk zc!%o`n0+w(Ggxcf2hTrg9HYwC7%%T?xWBA1AjJ$OuM?Tyt&3(bdF(BCFV2Gw++gzd z0`o@)E>Zj_kGIbp%?&9ShC7(NlYyD!!2S1opVhkeIrnq!eOe>gXrKSPz9(y1c1~{I z^cgc}6%-bs4=yX8H-AAzWmPpkcfWWEKAL#Wx#t<(uNU*S$t67pmVaq-_n|+hU5V2T zM)#pZX>Dh;?N|$^o(4Rb|?EOEz{{rrsJ!jyU?n9ZEZs>8rucbV&z3ec)6t|~%H$SPszt-iHB-+5n4l*EHX54qlFtF>a z-9X4^1L*EI)Wv2Trqt&$5a}eOzh?)&C4)qq^Q93z`^;qC|JZMT``h>by7M)E->!Q{ z92hv`k*=LtJ^LAVJ8{2>OuT>H+O=!ne{JW7!(zL3zH+MnNe8?N_>r;SM4!Wzr*Y}Q zcX-?hVNAE;r((*>XVt}WDyH2BN8pChG8bPD3`(y|0J2#!_u?jhjVIo+EOXP>}kIP7Bg0Qa=U zGU@;Qu{f;9;#HsTSS(Y1y{q`Y8<5d!W4x*9*|7{mW0L+zli7l2Rz$|!LaF#%L)v{+hx?ZJd|fZ4bbT0% z4zB`l(ww)W{}kT-fC`yx%_-&=$Wk#9*Ej|p8GcwjzJOoAI05!a_+=PlV4o<|Y}ljl z3m7=9t$jIFJx<)BusLD{W0pkJK%J4)bOQHsEx0@`Jw7>h-G2Y5W{mVHkTT#OsO9o$YyMwt1|~&4$@22=JMaP!ui-c zp01Yt^k&4g(&BPBW)>~btAPo3*EBe%u&}g-+q?6y2us_!2VGbgnqRh{C?pj>KhKOu zevV)ZLNWqQcMf)+H3CkbF>8hzE;#~@krA*570S%#L?hr_7QWLY7y-Wx|Lfv#iDtp= zz~!NU?_eRraCi?HAm9#}IJm z0(Yke=S}Y!z**O8gQiIozYyFfQ44dJP`X#%Y4Bg~!Fe?ZP8Ys11RV4EheN=f4&3jC zfSU~5$3wtP1a2ZVN{305FXQ1~Gelf;2)H2R-7o~)DZu?=2)Nn6J(CFMxT_Qps}~|| znyv(z-&A-WL!H@S66Fi)L1+lLAaHAkfMY(J_rQP@Gg!Dk7=k>;@2Mf+nBMn?fEx?k zcn**bBk^-g;ONC3zYMtL8p|7MiXYPzx!)A_&CagqN2 zb5n;91EQ3y5{mul3ZYmk=Lp3DT`Cl{%tb;`8?6?K!%T%xLD=(z%7k4i6g!zBp(eu) z36%vK>(vN17dD%3z?cbphEQ{1(>);QX+jmlW;G2M<*+9S#V{#7VAQ~7;|Ul`V6&PA zB<80IwGuYt7%*1DrarAcW<)hEAcOO3eURJV!3pC#Cj=vH zL7ZAzADmdy(NW*l5S|?z-*CEthqjJjTWgS;Up#_3@pL{32a)h3Oi5Hn_aJyfOH=E5 z1!`}@w43`Lb&)~1xaS?*Sl1E_2eGm4=5_>89gPIr)*>FAZBbnQ(;3{<7;X*n&IC%g z)8USPk+~lj#D1WPKvQS1wJj2?3*w|4cVZfX)~2C=aC$1JF`ez<`X+30!l5-7Y1BEz zu-qwD`=@Oko9!gpSy;?mg}}AZmX;t7{V=}Fz^OqVMwHky-S{pJcK%roJVh78iHrL1 z)TvXA@ePu?&LAU(2dw>u>o#;!WJ?(POU!~1#`3xjX2fh2gGOX2pe%+?Gpcd~1ZCX8 zAgltkX%F1dn z?i4s$3J+6Ru}hrU7FwOPw9syuy3TLFCNWE)DjaS=T^t_`uGt(3cRE_999bDehziQA zc!M<*h5D>SI@|e~a)3?h>mXTDYPqw)sl0S2aIdBItMvj7rD5r#0Wn&7CX5?AAK%FHA|GpVvg4lO4BlPDK6iQWsIMM|T@@;!BKs`br_SeN@hA_FwadBAcs9Im#-kn~UY*_i+kCbL~IpLkvreM)qm& zml!t}XIXw9CrC6kKPhjvxgJxF)&$#LI7oqy9oB}YAAi{9O3`y}V%%YIX5ja6@uk+MjGK%4wcmFJSzsP|{eoZGTo-9BV%%KRD%C4-sEq#JIV*?Be%P)1fJN z?!_%OSCEw*h8Q>3F>tZ>Un=@`>V}$gXSW}%|)%y?+e1F z`C{Skpwj8&7|&`hV%%I@o%H)S$)oA})~k2hTwlj4);luhCq@xWl53>-SA180KXEh%;@j+cXz3ZZ2w=cJ009Ti<`i z=K8zlBF4>il5hoK)4bh$6%=GMhU3^3!4Tu-Vr{p}Yx1L~K4Ei(H5V~%F7};v3}4>% zZh_5pyXGRs&BfJen=5qe(+}8Of7M*XxVc!qb{_7yzYEbZ({&0vLKtG)T&Kdt?;A@` zm`8g8A)9N3<{}1Mj>%^bE^5J%A-uKhhB@}6|67_XXasfmcWDF)=JebQAgG8R>Y3QO>sA%_0^nUVZFP8;&`s79!hpGBpeH~^X#X~W4;Xu4coESgu+ z5i(af@wQoYIZjNAf{~wx7yI&{WyoBDNc`q2R~{qP!juSGMsZoFte|4P6$drZU|eLT z;fjcwaM;0Dg-R-G@E)IzJ~f>DJeh7F6>S|}Ar>n_ttu<54nYe;4A(N=dhU^*$H@mA z)$D`WVR4nt50w-Z7lf>t2SUIbfO1M!C$Fh9KMxvFeqLRE9w#9dFWwBAUp%kEimaJV zYkuJp6Q4^sUt3XFRTkoeBR`LUaLR$WsyT;~H#a{|<{oy)V4GipGrjVPfD|wIq0xg& zIq7MK63mH5exAi$SP?3oH?KUTCn2)NY?me`BbF4Ik+{~WQ9r7RDv@8hfYe-pl?i3T zTIH=5n6p?x7tIfq7vMcelO0nCq*zU0M2O5_Bz)A$j(VH1GE`VrQf)D^EKyW4xkAqI zP1QU#rP0hb=e*GT%Bp!5rx{~TZ&XFmtwS0DCet=&DROzf9i~K<6CTBuFs0%A92b9S zf!z*NWtN;`{rqfxyiBtI)x^v!HA`akmDX&=w*g^FqWQK6nx|`9p*mDnhKgc};6&;_ z5`cGk3JZ&>LiS86KMzwa$dK1fb<0u{5i8-=TWn^hR2?cVE5hamRdr;ZbSj*7c``Dt z23Zn|%0fka+0`LIO~pJCbTi{b+2%$bmP3TqHK-|?swrxkrZO;^pC@xQPd*lvhAJuw z<~hTcN!+Ie@2m-U;dox96@9CTd-~;su`dgi%&RUo!&Z5{&MHN_trWu zW}@?)gPrA=K7B@>y^}RocCs#n#=V|nB}}57tOl(DCggrjn_VF);?UcE!a-97{y z!+m%NI8Gv-8v>3~k%1xLrUQ2Z=Y$TEC|?TUZ+@f0geEEvs_$POg1obV+cyLpRrh4h zJ{=}e{FshYhJc#_oc%osB{Y#dD&$*+Adgd~Zw>)Rc|RHgj^+Ev5O7qH6Yh*TP9Feb zKu~>OKJYZCDd-;EsWcxKV~xcon;@pHSH7UFQ zkXt7qxUs1&XtNr4TZ@;{bOzhh_9It6<^+T1wnc;Wl0zL)?hLX%DJ1q5HyIU3rB%u( zHYD6xgMtlFzFHWRSCMtOV}ntZlI){(Hu9Ue&N$&(gEQyVKr${oVkSyNc^v{a4&`>3 z)Tp_8=5-tGIM?7)Zk*N-oa(+b<^Nk+(9gA zX$rSSTy9#j72D3>I__K6ZK~UBENxwn^tbBNYJug9?gX8f3Bie;4P%uyoe-D5YCoR* zLzX6%XX7z1t!r`TI^O?mi>_-l!$~XwlOfbwN5-o7xD%!t^Ir24j)uK?)hHbd)p{<) zEA>8Zz&6&w=fALdWt}orvm)pIRfwxhQ=1x=jLR|(AI2i0Ylg#7+V49Lw%a)03FV0I z_kG(9z>|0LDgsx|XWS-9KXSF)y%b6xzi)~5FSxkkEh3a*$4x_wn~ReyzmM}Cnm4@Aeq1sB1=3@c9)#JIVr8u)#jkT%38)Oin3!*ygJEjLj>v{rzcw5A-}UhF{WLgKb`!VO3A)`LWIQL(N6C z%pF7Ko?Q=TY(3*0o9lVaMU0z^s;b{d6_94s`+F*FF2C+>h;egKJ@otLkOk(2^3x#L zOxGOEMU0z^DY9GTpKe>!ZF9A2E@IqVZ2R^m>VeV`2-XbC++HKb&Ba#i_XT0oT+mYI z;CexaMU0z^J+A$}bm5^B(Jaic#^@C(V%%JuC;EMbuxXO+Tzrqsb&lpD#?8e%w>LI- zJ$utfHrG{}ix@XoP`FqdY1Y-h3BhIzAJ<$#_<+kX`y2xod&{f8d^fsG-SCZrnrn;^ z)RIQ10T(4M$` z(Gv#ePDmjxzN{$Hs?vGbUbENW zT|D|$vN)!KP*vf)f{-~i;pP}8Rj&BshR^bn(#jC#D^~X9sTm7WjVTMaI?PFnwYFT0 z?Yd&e=7>FaK^~iv7jrWXds-G_32uKXt9I;gatlf3FKRJfrUQrwFO@{5TYT8bsHrTm zw-(h7QXCqaNKk*xb!?j#+lu82>}?cITet;+&5T3>EWSeQmQ|{oyz*z|=W^DC-OMIz zBs$rgl>ymOQH)Cp&6y0+WbS9mR&Hi7>R^5zW;Dnq*@LqJ!!AwDyo&M=r!($)%BrXC zYBS3(&*CavfQ#g+7nt>;iMwj5jAcJfrZ%qPE-VgJm7~pI-M=(0QJ5LzPn%cchT}50 z%5vOQYEFf822f{5P%;~GGZf(Rq4N15nIY-&$m1Nzjj9P%RiiX@vdjjLnUf>O^fr$x ze=9=eh2@1Ib3%nSsb^HU3F`aV74;!6$ zJ--n9W-`UH^4|=Bvn;j?I~T3cim)-fps*%>%O=mvT{F{U>z@4HZ9i;imo6xC>`bdp zOLanVslZi5=H@?|R%wO3->ADH#U(Q|D;cOF78my17nGFQ4a?jHca`v`M79v6xB#~y z$7hwJcU8Mds*n@yCuL{p4IFvPMqQrs+!Xh6vS+OB`b(S95kqkX38 zDJWf^ayj8!TUb3EZQfB@Y4p9+*5%qF{pj$!%Nq zp;@}~m}``k#$giW3$^rnIZ1MuMD>sT$^IeWSf8IB0p8^Wz&|D}6-^qah&?}id9zuM?wTg9tAv(GfPyk3I>TfB5x&W`0Zy~UZM z@#A#?#f=8sYj8!)sp_@;*bg)LrSe#b5xX(-Vo=?CQo9chOS|$i$ch~qyCCUd5XJ-S zE^_w2`<>{9?MXeEc&NcG0L2Smp(n28>DiIC^+d`!GB$jBO|W-FENVP}XJgLW8#8dd zO)MvtdsT0w?_;Faf)B z4j?iY*Ts&F6(%(jZ(fIh5F^JSw1r8{XQ@jEVs9ZHr2|u9{#d!fI${?&MMN~8W$}k@ zqqx1u7S^cP*33pmKRst(&;H(u%+c@&5`cWmjHF*3t4ZqKkyOyLKl*R_#wv~G;6hw^ zkky=IUU`tdbw^syaS+yXAd-Wu9$h05UM4m&tA_ZwCVEuQ4v5Z3yYgiO^6LGtV!z64 zKopk0!eDWa0}_~Ki&@@m4E#b04{i-Lhh+g1Qb#Wo`O6`@Wf8n;ST1wTlp~b1o-L4f z3x)RVc!+-@m9fLIK-WwoG7?;)7byWX1IKGnWSs3>(`-;EWX`N{2)#HfR+`k^k2pqu zhFdEp$CeuYC$}ekEm6flGUrB5lt3Co2wtZzrP(JGY70s%1yV+#)>J@NBy-~Si;~{G z<8;)?oSiQY^S{-b)BPo5Sgilz(_-zqK5|sZ*@60aEUIpKFQ9%D5bE`@zFt3yM`D$; zJ$3uXxD;vo#g`?;cJ6$27^3{{9kEBc|LTADc7Xg0?&8e3dz1Pg&OqHH8^Vhkt}2P- zPgJSzE6zLtWwUh$GV$2hFjd5o4n*T26h0fnoc>ErM%B!?M`f+)&FVSlt&9KO$gso_ zlA0BTa5GTx&1!%3ctA?<%aF~`Vo(9233h?F{T_A*zku-^Y>sRh#+$I`3gtsIuwVq= zWKhcYWKhaC6O`H(Ede!Ca2r773Gd~gR4;O+MST-gjrjfwRIX5ufuhC~FkS-1u|HtE z4(d#ye5l8Y<7iME=mW+mi<$yT@lFS&;!Ws2f2| z6yNWFnjqAlL7gVPOE8R&6SpQ%W5ul%6i2%ZV;d;0X$6e!mfN>LrHk9GpiUMX*DICe z@tr{fzfEn?mIm(qhJ$Ou^6pz*2d*?#8^nA$a4qh%Zo^I0>w!KU5Z`L_`gfV4` z+#x*0y6U+UV|9z#59Vuyrn`E74%}0Nm`bk0rQpH3HTa}MxM74b6>AyB)cV%7hKYt) zlbjO1Fw#*sg@^9Waypw1t!)+*3Bv&^BbE5V1uP~j1fui-gh`>N9@o$KYIVEd9kMkhUM(X;1mL0d3+)s{@-l*fXn`A z-CL0cbhTME=%6O*%g*{nV)*L%;F4%kzcDowyE3yF?1=kPv)fM}V4s({)a-^+nv)tC z53wK!(ke1@&9r7TgV}{xk~x#T>|9e`h9Wrjr1l)Z&3D1Ht-O74+4d_lbMd$FFm@SC zaj6_7cfs}E6m=y}+I?4MX5krK-e_FU!%KEbxBd=NMsNR>ctnm$yKlL#uVR?5Z0n=Z zcl(m(j!WCR3LJCiq-|wO!I-nPiq9*e=aw~}zZ_Y4lImCWpuC>qMb%EbujX)UUdq;$ zBYcq~@o=b|Wc1(t0Bp@HXGZyJ%+ZHY{Wi+x)whw?==6?ZK#VHrV@dxB?h4#|*7DdZ zQo=eHBEw>Dm_aT*94kPO!+eorw||ovopxX4A*Qo(>+hoP_8f?whp<^ECcU|Rseh4~ ztr*>@u&7{`E|=1={B)LID|G|KmATL?%?u8~-$Be?oy{t8UzJa1Df4le5$kzF5*jU3VS!G!3Mv&#=h1EuA3Mn#h}^iSHm zy?A1hHBws1I0n%{LUWN&RKHPnIvL@ABU>==jhghPPN`X6Qglj}WCl^a`i-+fbKbc( zC9;aKSQ)L}e$nAM??=kh9;)({cJF+l`-4TB^3v|>WiB7i+|ED!#)yG4`iB~&`+o#?Hs52(k>wqI-4U^9bR zEqX$q96sD^s60e1Gxaq#^xYW8MzaY`RBFjUT8tV7TFgW>R5~?)bR;_H>R8V2e&jHQ zK#>HcaY!Zw#z*TvHN%9#?_f&;eMBJHzA6zERxFGT{4&rJU@Jx_W^ubv-+Jd;XZO?%^M{pm4S}wjvCSh4csB}=L3w0c*iGs@n zr8wq-S|Pq6Q0EC%4C-8=%0ZnkR0XKjLe+p;CDam7D}_1-RIN}eK`j(YRt9GWOXYQM zb-lWb>pU}qOM~mf^6K|GoF8fDn2mMJwN2{M0UTe#oB0vGYA;tNj4-q;bsk5tV5pYe z2%K9PoEyh&s4XBq7$gw0ZTR7~G#Oy26sa+~FJ*D|{_N+r?u!&(jjo9O(b(vStF&4GhbEuCLq|+PW{gYsGG~_7&>r zimLVuc_}RzpD2*3ekEf{$*Ci5Lj6@{DhSp2_hG`cb${B|c1jl=ds{kI#~>0pwlN4v zrc27JKf#ll#w^K9U8JTlJqI}dG0Y3^mZQ5!cWBnP(6f6_x;cFbtHDL4FwsEIzR3L8 z&Ssg9rmLQ_uOc(UsRuNx;a#G*T=l7(;YiF>&!!}H?-^}PYi<#=BnLx-Ky4T3F;r(` z0U2Z?ljNpa!88YjB^Hn;-G9qeNfHo!))oS>wX3%5VWvs}a7J?#ei@>qvi}Z@ua3H zigyg$lJQ$JQP;ZJc7U=DeoKWHU47i}Y92ftTmmN$x zl_XKxbgZ7CLeS~uhkKjz;GVcIeC#T%l4gZaQ3rud?)%jV??p~yrh*7Q-(?+ zgRo~oDim~hcD(WNy>JIt@6j2f@VfAKn2~~3U>FzU_g^>_r>=C+8SOk1hgtOJbSmy< zM&D(;r{YrKFUfS_lJpZsLijp&Yv?oB3*DTs(GcT4V{rsr{616a!Mh94weY0(hl z4l4i`n~NCRgfvNv`(%bX6~~>OiST>iqKmFj>$7Aq2a#md9r@zx^elWDixW?B1&mt9 zU5r@4rew!Td>7BMcA=|V4hIEWPWQ`K zo@UEgp}B}rIo4^(32K*amy0u9TtfEySRyp99lz!dQ;K1HU2_rRj!zm~?9+9X@4bsG zFl)k3G#4?*RlK-c-`D|~Ca6(=8#F!~n(XtVFMinEV@rNha}lFLJIM@GBs@PbIqXf*0lVk6890QCx=VV4XSz4-dr|nq5WWgq8>zChr)NXO-Y01Y* z4B>4w4H_0TN_SYtdcrzRFgwtdOat||KjWix5-J{yh?aaD!ji8g7olild23|#6YStCT0WQ6A(ieXU!Z1SHI6> zSo!6LQJu|$qID)_ZjWr(56 zg_e`ab-tSm-yvMz8R7gBh8X9*AV)uU?LE#@druO~YS=VB-(POBYcE%VX-<;b>y%7Y z(k=NUk7O=f`hBZ?j29;E1Ct!19%}*3XdP#JPxcFN#o1zT(cE;?#rGLHzi?@i<|2mq zjG?h!V6ar$Z8@jF%|7$m`{ElbY&pNta)@!)1S7#(L<-Eh{!F(Ri7HqG5@fBA|n=PWIU7|LnI0BVk(L5YvuLyiT; zT{@$sbRv*peO=MKD5EKCo#V_hKY(jqnp}=6GKz2@Z<;z@W%711?2bBoG>zZlO!y7P zoT3t3`@jQIIHu(~oQ0!+6;=2Ur}mSr0$v}1?}g`avp~)haxEWsQ{a6v9vDTq{K{@^ z1HVk#RBxV`Dl7~wsKf^?aS#q4K*vl3-vw7XxBecVPDU}lB3@lk6O!Eo^WZ2>wc*YS z6RxhWz>b1-uqwB@x}p#tAI4&YPQ3aka#=W{KWJGjUxLGJbNn>24l1{*qPzrL*ncpy ztO=jF-VnAv)5ygQGaiBN zD24pY;wl}W{p}_#7ui%(UV@vlUCeP@j*mfVw(3w}0g?iy);33|a-L5e33KqM&l{Uj zL-pk6kk!|YJMkH1e9BS#sXC*Bz}*<771iY-b=WK?KTj5waE4Ikf~x%G1SZ#&tdc3N z!nsZ)%Hq<86=gCeWvUmDaPqhnl?RuJuhrkF)F07{t4G;I3-IB3rc`I4;{&5+w0SC) zpUIQ=#Y7~Juu41RyNvwAC04p{Iv0hjN}OM)R3EIv7a{q^8#cML7H(#S)$j_7t3&0L zC1@1WF~Q{FR=quD<^>uNCg^M+IP}8=Oj7q4D+om+ zslU%WA2?%1j{1NY&j&7+`zGF=j0FxKIyIO?_f4cy(RP{y_f32Y{%hlKA%3MV?wnrG zDM!x1aiaYoBA_k1(fjdA|8ipEO zqVq}|SI(h&>o9|zM>`L=W{s8jB{+{(133|3_Glc_l_*@!YG2nFGw4L;pNM-WA7*g(Y*W-xhA!mkyWv#CnMFdm80%W``` zV~C@X^v2Z}h7)hPZ^_mIX25SB`> zH=q4bPmiUF3Nu(bYT)q&U^Y-qg&{mqxYQB9NQKj31`GEazerO#o(w#tkN~9sC8r+@o<^?HNoSUjaLs>MP7(^4K0u24<4ReOmnTfvNrsd8;As zTwos1IJT?7;x_=yM?;WzL=Zw8W-xi-Aa+aeqZur{SHthpAa=pW5M{_J*I@FRfZ42Z zgUMSB8Qs9VtZ{aK>aC|ojzwPMM>Ckb5d6ji6V|w4cpfZ%n}O-oxWVLQf&Us{b~|u` z$$Jc#=N-62?e{In`zJ7e90vl1%}L3#=VEl{xbS8sDcdCKuej>@?;+qQ@8cohC~w$! zJ4{l8wcp{uov5*c<=+nQj|1jqjT@}LIs>>LoCeEb5~X(-{C__L9H*>*Oo;Q=t7n0G zO=Aa3$7;xX511trK)`U#Gf}y*JNvE15Jxju{=Ev^2O2wAxU7HviP$2;kA~?=6fRY! zg&IQ~&0yiy0@tRopBCNOu*eDpIHwy*}w;lYGfcd7z z9f4;RuD9GC1Lpb9kQW61KY>YR1%qL@gULG@m@y7qqV}5({z)1`c{GE`n*-c}&ycqR z{7Zp3ZW1Not}y%(Qv}Y~l0$5=z6G=;w4R6tzg) zS_FCK8SUtZy=+TH2tORBO6r<9B|3r!HgKdP3LEFPHG-(c`s8EmnOFEIR`cw|IF&X^ zXniIxZR`7}V9V1U3Ut3xP}+SkC+&(S;E;A-7r72+_VCXwv{c}%jom53y3U@g4%C%8 zkIdoZLhqI!D*CH2;M7sZy@e^{76zVJG8x{A1=J}BeHKDys>^x{QY3ab6!9we@`a6S zqb8e7b{NiOJZSOiIC$Mc`LUGleMztKIGujnvX3q2Ra)Amdtb_{Zv$#QroZ}<^D*@5 z@65+7DV*;11xn{mj!xGpJlI!y2m#M6h@{M|izMaj7&t<1agU|xV}0gXmeg0bLykUM zqEnMHa50h+-Q-P1CXz8wYsD!zun=XNjyDxl_VvzB9Vigr?i3$I5kUKw8g{hYlaEU91_BR;}1Q)MIr>+Mp&a&6hSTjmDpb zZ_cKr1?0iBlGD;s(uSv{jiAGk$*E~arH$m_A|C{Dq7#taOGR<#Zo0Tlfz7@yV9bJj zCw>`52=-Q?N?^|sY9Z`@3AGV+9)1DiOR#f=x(qf)*nqJOHh0tl#_WdLOaDo3a*L1hVbHK?gVT?>kXMZmZo)OewI>VKS2H-j20)a{^76^fx7 z2HygpK{ojLmlMcj99+veEbSon7EX=l#!5qYdF9OJ$;$0XH2Itz4;%?-?8A3|pnJ2u zg{c%!+q*0j+qG(UY;UdoA?+jJQHWoLd~S(#Cqq(D04gA#c{*FDeA!IMUmI<$$FpIS zi%pBAqiQu`7h_GvdG@rex8iT?@`>=oVcV_O;)z9L#LClqj}oFLqgT4e*yZel@tV+Z z)wd!EvCG+A#yPR;iE|q5aVkwW53AwmT#^g!?E3qB@V#@GIYu!)k|oS&Rd1NvilV}- zS~*LWOJ@Ni1e?jpFcw?XT8r9jQ9YoZ!Y{-4nnm3NDkyHZ!&YJ33re+e5XOVF#Q0G7 zxDOYx(T*<Wq9<5d*c<)R{tuy;k)l<@5ieH9kqpE-8^oYG`Kw9Mzq1ZRFTr%VU?w5sP zZ@{&ofWf?GuNpAua~FOY#`Un7-x-p7suaJA=NkM1f~gc==Km)`{Svl{%h}^QN8ka= zb7Hdy)Eglcc(#gT@v^j@-@`$bgQ={r0Xz)XoAL7&$1QX{V016XOIxEO7bVEys-!t- zkzj0Dia^znxk#NQHBZ&256m<(nB_Eyr8$&R>E4rJ@x_u+<{9O^rAe`)Q7=aIE=!4} z^j4)xVtPl_VxU#WY4x!8KP|4gNUy5si$JO3ItP?0u63Ze>Kc&Kr`C0 zw5)bf$&#gus)G28nLIA5o>y$TZK$j7XydVG_JTYP85}#lbF8W)|AbhYBx5)`5joPG ztZD^HXC(4D2_=-$TORDK$+U8n&0E!X@|erO=+(r8VWUq~RSVsH+SZ@LC03egb(HK{ z*$*jYE;ch!RSK#aquOWRFm`;tNE%KEhb%Dzqhg5~Fb*FhFjf1Um5)_Lxyl=sTA@?{ zENUJh@ipsMrm9Ph#?RELG#>}*8~A0&0bx}rY~!ke%m$?@ND(Mi-19)GinJ1xD)?ql zs^Hr}wc!^qs8gwezs&O8X8B%a`LcgdyzGlx@XIj1Z@ICXT`z9;!&cR22PhR&)*L+G z+H0{nP^*&(j8L-C{rc*qx>#Q6`B!gCW=h)DNhoi$`F2zHM#D|pdORIVJe_QDW{d7y zkD`1vVzJ*dm85tJ2nDw|wlecVzNyv)=4FfdVr{Syq@j4FU*Q`rlg<8Q zbk5KX%BscTs02y z-T#0q^V*23Awj7V-Frq=M!ykj$xK&~(G_Q@_Do&1qW1jmJ*&;O5`Y|4Z8!v|YLf>_ zRTlcF%2EPKRh9*yRApHON>vsXu`2KmP^z+A2uf9!Ye8LvU%|uiuX8BO5PVNx5<`UuI0wp!BjP5 z<*Sr$>EW%7mJ5TyLViYXw%qVJ0%75HV_?~#U}lrS=Lmkum}ldqsMNkd&U1M8_w1$1 zx9*6&5lNjpIdW8ADPG#!5q*!dwxs@mQQEBLwo79Nr9^sblX{c;_^JSS{u1r4J%3ef zw_|)z1I1K?@+^KCG99{8C|FW9{OdD@No+W5C#&Ican5tIcSqHj(|?43B*4bW=qXgt zqk7Lt={+a4_neI0>!}&`UQf-h_j)Rhz1LGQ+#5=I1gv{Q=^^}4EduSMcN-N@_K@;= z2(m;g6>L+z_+^Mfmj)^z3b3kS{m~@jVZ=s!fd+1w!78;$KLhc$w%Wt2Z^2 zx+E2tUaF=hgX+VN^;s?J3ZX5=N$VDUDa&#W9N6iLlwt5l!3_a(YLYIUgI6D8S2GW+ zw*~QbUL^At@~dRWzQPRA4N>0gkcod3FP@ufKVzfPG6B@J_+`ih=6FzQ;;MX0Eng5a zr17uMU>#OtG2Z0C$kwwDZ^bT;l%O$>!n>~@#L{B_?mMyXce784j^4UIlF@gr4-cz+ z(UILd@$&jGyxH?&&c1;oPTtr3r^9&jB{gsY5; zd3%b=+p8p3&EArke#FDf275NeCsmW!0$Fnc^349qsoJu3sr+SMrE>p#i)sR;%3-7B z2EvHZf~P=~I>u5C{Mr{eN$Q!(NvCc^o#{Bj4h#!LPKX6Q6%mY_q(n+74k9KA zmwuF{I&}dzFx?CU#qy#nB8(jm=c)6vt*zisK4U z9Ah(#?XVTcHJ~_&3y5Z*IBvzW;<(4cQGr%*c@UJs^;@{7E!?x9evDthcoDY3jn8eE zjTeZfa6i?b$({)Oy*_TpLBd6wOkFy?7A^Dx)z3 zODd~8D#~($5(ark0b&K^8q=A7Di4{@zr`;@ma8U$Qp-cimovQS;#L4#mB~C%%9qOe zqvBf+`w^j7#=pidL-Z_F11`ZcXWIdz8@7_S4V23N?Vwn10`hg%ouD#|uftZj8$s<5 zx9`GM;rgYL3O1-#x zRtRKd;aNfcnQslG0ly46IQ2ZJfJFIaapOD6 z_*AvN*B?%@T*|*b;|K}(S~fnSC!0RLSm)*;Cjer`f8G~uGbns9v`Kdxb}7TIG6m|&PP#CS<27G`_) zM^ed;1Vdyp+`PXc3=mMjiDvMNJcJCau(9`FIz#-K^WT;)iAlxuh;2&|tZrq*>Y(AkS z_NEM+>Ktlu?FVbMYjGM)77od=@`=a>=fbF^>8nNP1`hW(>6)drh6r6x{|g@ znr5_VlMa@QvWFnEWhi^o0s<;1;y{Lgi=hZk_C^^pR0I_f1P6+s4B>aqz1c}W^7;Dl z{~dqN>y?{x-}gM{o@d#uT?~)w8 zVM)0ez-@;gpXiy8*fKcBPegnQzCFoG2j8Ce;76zQh9iaY9&vQ%AXX*h)9IPpD1_A- z5-21HH9K2YM6R}7BP-2)Mw~M3D9Y}Z2-X{<4Pn5M6(1_XCzd4gt;-?w5*bdY-KR~% z%N{*3EPr?hHT+Wy=6-M%gAfpC_81I~C59UGB}ACLIMvi8Kr`vbjiS!y8HrV9^p$QLlKCgn1Yiz zJ&_{H1s|kdD%U5h$x*wSdPIsg6Kqf@hl1W-lGQD;fUog`vu7WxAbBn z3=UV7z}-FbB7_KqRw2D3ExhZ_i|0wuF$LQ*6dSHkgPfsSwxw)#hr&J>63URddV)B| zg9H%IiGjp(=oK%PU%c>bMGe{xN90a?eFk3P&Q!Pn2vVq@W_)XSPihPG(~NaDHRvcD zF=bCKX4Shj{{RS57@^sJvbkq!U}*Q#J!s%+nKR}vz>&~G-hoVwXs7XT1yaLffmNB<{kGizqms+0W#O%h;4w4D>v_V$Gy^VFLKJW zXH1E@)ioWSncpAkDKb{z$#;Z88SmN;??4SQz!6D1=`*c6)Cfl?l<_Vb0zkZD;Xj!g z+sf1+2^>+))U5+Ax?_QZJ&>X)5+BW2lX`28_Di2wLI%qQ#%Jb<^<{3&Z#gu_5}N%d zmO=o^PKS&$cih99u?6HVEni7UI2#SU6u86il(E(Y^~Tc$NfgFS@rX`Qej$jqX_BN`goz;~fhT zAl|Vcr2 z7(74@Qz`Wh&53@RrGA>p4Ng35PIAehnvY|R_uQI$I5Z~_n&C2Km;*uHJAIM?@s353 zUo4<<0hwNK42Iv%dCRAg_i8c>Z-jjW`vVC5RNwST0n}Tw%ujPFA=3+vNW4v}dpI;( zhFM{K9s*7E)0_slx8_to&FO^9LO9}EDy;7`Xv7BrhqTC%8tI_fJ2f)ks<-BJKh2qh zOfNX%Td((9vXd^G`{5Kyq)b1XvjFwhoav`In~>4M5e>YUzY|_)PMcqF*qrUBIfn?v zgQHV6+fQ>YA(Q8jd6J`nh@x~;L-QyDt_J~>>!%szy=~6*(<~=suE7!Of_wbW;Wg&8 zW1YihxkIzNMp6)=oNx2duiu53I)o{k9Sq7~?zlrKiBQ;1L%Oi^+AepfqmEE0;~gp= z5O>RA*X-rc`E%auM+bv4-l0@PDCfOSTCk%mnJ1`KT(JqVgCom-Ju6%ywk9R2<5m;nbf^M zbXS~dxWoaY4A%UarcUYC9rw~e`gpfR zONmhU)<8-bQhMBN;WkGol)>~Nr)U#`j&ydv3*c4llgk=E3nB6#Lp)Q!(JbqsigH@` ztK(kfeimwpP}sIaYI$x66mVx65)}}jTKIv5j}Y_Sfk%=6;+cjzz`V<0xu1o4LIy3w za=(fby54PJ5>|FVdcs2J6RG6Tv%`7?LqX5ZZ@DDTC$|D*s6kRVB1zXDGr41t?a+)e z-ZmQm@wQp-XLBVXGXjqIZW^2xGr(>0V29>PN2%jl=M(oZv(2zQsjF$jK~Q^u=q z&Ep)JO@wAFz3vr@d{f>Gp}k{a^1GMCB?AoQ(~s88bl+>5<6aiOSX8+}p@m2mKh4#E zl64EVTwBgP*2%4To zT9*uJyRq-)!=%kkhWz(ugjI~ z``xK=&|$M3G<(}zM}+dU+3u&go{*8?5q?Kr*S+i3{Ha58y`Sa=B9y1*dP4IR2vH7e z25DhslXBd?Y;a#JWX;2eXtl-KVhXvwML*bGige$M0DqE$Lr)Ij(t#BZ`}Q9_y2-hG zN50)qY0{#v&9RC^qq)AxYOAOQ{}0SsA;ZAS#T7tqs)7X{oNG?>9p0}$*Z@1~Iu)ua zDq*b@SlPo)uGIm%G`TL>t8j4@xB>$O9k;_pDPY@PSnQ!`Oz%-nyPeiT%c=h;*RAu- zwN^bUu#rnV6gYJZeq=;bQzgn)jDqc~VPD{e{=`T`ZNBr~u0>*q7>(-R+%gIh$FZVE zzQL@Ar8JTaHC~FH>wQ#e^;LFq_p;Hr&zoalWVy;?WF)L70Xw@904&~t&a)A)0wts~ z!S@?JV$`r^I2q$yEzWsov)xn!cgAHaK(jMK5WHUtL<&O>9@sRdzkBr5lvaPY@=n#kE1W zf7%jp8`6LLSXlKDY&C)#k7%Gn7r;IWR>U3WOkkC@Qb+D-mye5jc(345P;0YcwpJM7 z8?xV3Rh1q#3dF0b06`5E_FCd%d2yjfSdUVL%h*twFk@`6^obGI{&A#zMYYy!sc^0x z0#=cmZYbY-7GpfIclmKUi=Xrms}XT*j--Sk=O%LgsJ9$8wK5+-4)rM>KrRI23LiiY z-$}X$kVE?_A5hNv0CL#rYj^-TjBnQmkVE@=29opmWC0??oSyz5_mo2xn=0+izg-71 z+Z=L1AQxy}@(93pfs7L0-a!9Kp9y3-JLLYAzTO~n>;d#$1eqIuqAw3@x(_nB@N6Jq z(Qa>^bB#lW5QIZ}^PFuU*W{3O#^dju_uJDk@3-?`{LV=34%vMatkVWHT=%}s<45%W zi@SHZs;o35*O`kk^So(>iyZh=f`S4NDKL$o4gm`& zwgkj;UU1$wr~{P-yDczTA#6@4H;fk^5y_7dM90Jm6d(Pa}wt4dxJic(z;wPSbYRS^4pIP?o^5>p^;l&j%tz5Nw z&C6@ot$*d!*Is{P!^TaU-+XJ!+grE2^X_}^fAHa#UwwVyn~UFGy8PXhtKa|d<4@Oq z{^k0wH*TK({nqU}cmKF|zMbp8Ij-M_@05Qn{yKeyq0(qFTdJz9uq&*+uD+oW1`~Jb z`Vbla_OJg(;=g^z&Rx6r?A^Ejz`;X@k9_p;(PPI?d~)*C=`){x_W9W_&Yf@P`frZw z|Lfzg1M1$bdqpLX1;_wxRGY2G=`$TWcI?{q-1&B{|K_-UpXq!K9`GOQO;7SYcV24` zcXqLza=zzI+|lQBp1S^h^+vj`JQ(A9Km4@y?~reJbQ=dEUpt*LzTxrXO(61>bISPY z4Rv1d`S+D`UiQ@+;k@AU|DfrQ?#h3Me442LPSAE`IbiG*xJswsrY$oFjt|^)f{Oue z8o|W_H3wmeh6x^0&9KqqXEMp0-A8=y`ZV+%S1UD2o{9r<- zi~w#l!QmRPqX-UL*&_*V3UDI`ZU%6}2@aiC!w7C6a6<_0N#MX&1p3gCHJIR*1BVWC zI%O4b0|{;|aNs8d>{a0U6Wj*i`Vrilz+tPNPB{!*AA&myTob{40$fjmI|Ez~f;$Ub zcY?bMTsMNl4!}bMM+2@a!Eu1=LU26bIuaZoxJH7D0S+BPbV@vM=uo0lG{DsnoEA7c z!5M(F5u6n`be7R6cHq#}N2fFbhmJwW1>n%JNT+lM4&9KjKnZXrf*S-Jx}m6@RI|bvKBb}^Z~g59DXRFQ#JsHpH*P$DscE&266#7CBYp94%@YK$|u0(65JW! zatQ7$aM=X+4RBcmcNw@$g8Lr041&7`9QfWr%dfzt5!_wiQV9-VVm2o1#0s2@z&OAq z6C4k?M1tc3Cn2~P;II~gd;?BIaLK^oX9YSX4LGdh=#(tr;s`DeI3dC10~bqhR^YHM zg}ekVir^Z7!%sqxm%w374S5M1);X{y18~?Fhcy|1gQh-kGk}9m32^&?;}TrU!-Gdt zng@?AP~=fYBR>@UiNoZu$SY-FpCRy5DCG)D|CYW@Lq<{hKH9(UAWEOX162+&#|)d9 z2eyJT%9sco$g4gGGnUNS>Dyr(?ATv?hPHM9G4jSN7l%PH0g-~pKgw+Qch4e+7SD%x zVT=XlQ1RPrw6+_>Zal3)t)kYWFh5QN^QZ)^x}escLBzRxCe>NbnN;CzChhcn+L_zO zzDsUsMy&P#v#Q8px5UUt(mJeoNe=Iel?74|g^ejrnFqgituwi-ZJ&PTK8%?SU>$>)^Yw39x5(4FZD_9}V|F(4+H~6KJ1_x$ zA#!Y2n~vs)Jf=JuV{EjL92Vwh;72DOWAYJ!Q&%o60se2;$_0FE;Ex*Z=!ju$>!SbE zxKDKGc$24#h6I9&oAZ75?;3N_m>O6&i5_!xIY4t)pV}X{sNA~DndOyXfg+jrcLqZu+^J~O89-Q{< z@aEU_x%uD$jM3My<~n!fgfV>LOkOIwK2qt;ZV6}p=p&f4)EG^ghCneUbqAg zNzQmp@XAB|qej7vdQ&%wK9y z2$3o7vh;3SSP!;N_x7_E6}EOCf#{QD3l?w8!kN(2g1MyoggQI4R>!O-Gw;y zX#9{GKcuG@;%PI!;oZ+^<-2XSoqAz02}dZDA#I-N(&MynsULz(bCR4g+gylK4>rr4 zL~8!R5Bbpx@w6Gso7?8^j|-rpbfz;l-;q#;#G0t9O0)Ko8j*9QY)IGuDCVVJ2dkhn%()1 z9Vhpw6ivoCu!qbWXyZFVp^Wzk4}qUOe8Qe75W=|`2JB?yxy1&~PJ&O&uyqCrkA?wQ zeUKm8e^?XI`cK_BH7}Y+(N;M~@FbkV9*G*th|s9`VJ7^@V*re82#5 zUQ!-rJMZ8!+yfv@cLJpGjx&e(1x6bT5+N~X1Y8M7^i$ml=sqP9kUaH{t_yQT)(at{ z>Io4M^#q7$l7L4fNx&6F*C`o6@|27o!8`M&vRZG}BI1miSKhdL;9l9|50hs5;e_pe zC=me<)FT!is4FVo7#SZAjEs~UaKx+_c45)FP-pC18HXMPcfPsKh-@RyymQS7xiZZY zAS3UA5YhHHCn8LodqkBucSX{9Mn;b~BO`{aBT7oMxvEwRK!Df~z7fv|xdBIN?9cxK4mWbdKyI(D!BJiYJ83_T4l4L}Mh7Vhit@=X z@Hje%MT`#m7+&HMc)=qD8XYtth`i=H1{fW*5-y(dkqb0B2%SXk&NZn~i=%^lMx!i* zOH&;ULFawj8;ueU_9r@;E@(oa(I|Oi^Wx5FWPvy~#BQFrtE`Y!0kkZHTj|$)Uh;<3! zYZ9CjA6@a^`Bsbp-cM5~p=m6gh}tefUyI{Jd4SLx_S6o`^slIGJIIezs1ZLNBRMtW zht$9O8x&dX_a*KNuUKrQJ;m4M3Rr?X_Ef0-5^`In0Vc z?bhvpv*7tYfX_J4ztR^BLo1?icm+^<`m}IO3^Gj)IZUGV>>CX-)Bi+Y9)zC{GVgoH zwWn_%$ei|&3lv|}_Z7%^?sC|kKF?ha+l%i}(5He2&Xd~H7c7DFgCA0R`WC`9u>|(^ zh943ZiT3mzk-%O48PYRdCFls0Lc^Mk&qXL-_MXx4%<7PKg2LCeKB8IJjd3GuN>Ooi=nN) z7=D-a#qjH-FNS&Oi{V#8Uko6EPzMs)=Onxrk|&lyLS9&A04ys2hWAJE)aQ5$5*Vhh z(>|2JALfHEhF=?fG5osdi(!w&7sGFbz8JQbeK9PHz8F3Oz8IEIUkrz7`eHbU(-(u* zkspSwAYVBw@4gtOn=giMcVA2r080#jNdsU>0Wf^deD5I(fZ_A)E0-Do!@9v&4j_Us z9g#fC3*HOK6LYj2y)a^ErjHyxcSxRLv5X)g=2`ymSw_sW{5dht^5?`n%byeTEPqbS zv-~+R&+_NQJjH{%?FwKxW%S$#1d1082 zNS<<-r%0X{iTs28lP+XQ_@7WVoHpP;wwIjG5&mO+gYSD^4Bz*@7{2d)F??2hv77){ zZU8JV045KBDFR^V+w#3{egI4r00YO7U)aI`SWy71H~>}>08q-*#ls80kHZ2 zSVI7;F#y&v0M;o01`t8m?m)t4wF~?_%Q&WSS08K^oIm7)pmL9c5CHQ` zdyJO}eon&nA`(MF{1M}bo%YbNkpqPNFDDj^6&(=v(|j?nzMezQtFPz4y!x0>fpzxO z1w5Sw2Ovxz=RKSl;@ECOa$ctc@04R`$^Ne|hO)jGriCwtw)tY%|MkT%O?)v-6JHF| z#23Rf@x=fl2-}}XXs?s7{fXp>k;uP?-FF6Z{1f_IF8}|bi$eI={I{L{^X32l^r8^| zjbHw|_vqHMsq$YgiqZ8iFADNkM}FWoWYfR5cf>tyx_7pdJIBEGdd)BfU_@Qp@AY#h zBsX8ir*Ezyc>;Ccd^2oI%bR}7K7VL3XA;}F!waqLGHB}8_Ho;>9p80mnBP4&sO^vI ztJ@C32lMNzK=;tSv@{BcjA+|Wh_u~tUG2D+MkP0Xaczy&cD-#6xw}s5gUnmK3G-HO zPCs{lz9E^XzTB;u<=mN+)&x5#!q%jA=cL+&*oMJ=1-VBZ$zi(`{T+N_pGovU@QK}v zN$w1sV{e-D=wMPHN272F01pgG9c-!yk>tZ>cAa5Y#e2A$ou%zNVl!FZ=HJ5>JPBg0 z+$p!Fj2f!k-nwJHX3CCB9olB2cV{iHnL1_H?`tK^GT7KtdA#-LeE#B_w5RYIuQ_}U z9a4>Fo>LnH8Nf4MRZssAUz4l}iuuMMM}Dp-@!IG%sJMK`?XiYKrh~| zbq-vn%;BOYqj~0b)D-sk(EIoA ztMGkBp?nCxAmYa%QUz0v7-7M~WZ|i=b)M9r?Hb-5_SEHcvXi?AcHT=XbZ!8}BlZC# z(ygg&2f4u=YQc9PnO9_Pz$r0#AOC3-P6zzQcPHEp_H1_SCU~3BQ&$fV>TPqL6XkgN zZe9}>2W;e^v4p|IbbL60Q3b&m5n{5vuTHcd^0f|kpS0II_m?EKk<+5lD}~mOI#W>* z5Y?d*`=dmvFwrow$nfTKFoPv?t&mJVgXZMUkUKH+<2y7P=1&TmZ=tAnHJ7vs!alg7 z9-18A5~`k%%x`A2b_z0@u0~9`-PFR|OM$&a?q6k1xh-o}&k3J{yT$XhI-^PbOUq73 z{+PC-nWxmdfXkaJfMeENK{ID>kYq1KqSdK)wfqW&KmmhqoT8)%D9Hm(GFO3ea05?K z$0Ts#4`a9+4?s*xA`x|L@R6wpapOR&Xq|8e^%(W-F&)}&D{s!cKc;WP!dBj#@USgB zDDG|XL~*~lkKSAXTN_7*ZL!}+m`}ocgIcm?93Pj~+6AAF6JA&5HYUfk&}JMTA2KJl zm8YFk7o;;9bz1drqh9Rhvp*%KKUsPWE)M$>BnAwzpa}lM(@n*H?0Ns~<9QsPbFuXg zLl6E#<9SvS+B^>d#`DBDt`Cej?3To;gb5WRCIInx5%nb#Do8hyhB8nox)Jm}V6i8W zrsgJMKnj8+;y=RY8eGHL!%5T@gv@xB*1cE~fGvHwDjcf#1@%~)=A-)jmWNFfj}?~zp4!|~P}LiDmcHDiy*t$F)2 zYL;8`6Q~x5MBbV?ewwk5MD9C-I@t3qP)(!tNNdPHSP#P2W_%NQYi@65;X;&z zAD908({9c0IW#}`%)$c@!gGw4W5$?!&VmO(j?;1i&nPbiyIW5Bp!s^4l2P<#{ zSnoctHmui-6{idtkeI9C4H5G>JfHv*?HUKw4j%=Jun&H;KP4BY?>Gi@5naMR8~>HB zRC%mw8cB@*Du(hvQ~;1Dp2H6@RnZCIoFb3s1O*uXwGu82z?|`*faAZQeqv!A^l!K zld)z1!m6yj_`VA=ha7V4#WxSap9Gm;tVMuOu04HWAS3pW3zUAnAbdK=%yr0N_1B)h z=RoGQKhcNwy$v##JmlKb_cO=@VZ8>_UVQNa8)Vp6w*mbt`@|rV>yUHm`+LWe{jKvz zaPsG098LD$?M?byW`{heQnJ7h$A7#@|9F%B$`Z5fdyD=@EV24$-Zbp#wFYUXj-qK^ z7{kQ_W~g}RB|~D}3-d;>H;*CEM}dSe5_WIe35m-8MM%^{^j~S%=Wl51p3ET}JTaZ; zYlQ04^RwuqJGI?c-xzK0Tz?s4VSjKYESi?qk@TODXF_njNR2^Hp|khqjA5438V^qq=J20;buc6u zL%bJ~)2kx~9%2Y(9Q`hke-6)1GI~7t)P3sT!J)%PH^uy{@X^EPHw9hAQpH!F9Nov^ z2qVf%E2AYT?1TMkD|mS_K@DI1>F6X=UFQmq0>*A-%%SV&=I}d4js!zY=`c+ zQ**5Y{VOx1oSL5%NSC@b_i$)_@EKB`z6fmpQ-fZFBX)UiEqZ*XTk|7;ApIx29D)5O zf5pqu3oPpZzo)LL>~5QhS{~59;^n~35$2n>XU18AAKc5~na&ZQj~aw((PqoCZ=t9; z%f_34AU*i{N&7+C(|(*E(EeM|n? zx8wo#ZTYhy8tq*FKecbkZk_MGC9rP`>|1iyv2RI$>%_h#aJ}pQ_I+z`Ul!Q8#b@6Z z8xjAGUC%YNbDfAkT*pzh|LdvJF9sw6#|FIgFRsJD7VKNQ`qez_SI2`3W$&vP_WsCM5FKs_X3VIBD@JSh%pDpiNJmX^EDWM{`~xK z^+#=&M`tWl?;9-(+Y;Wo7=zA%s5n?HM2`U%sdIQRwBw^ur<;0a?&+~>VLFJBcH{%+ z_K)Dmb0iui47=>aRuBI*50HC=R5mICa(aNo!29ZibbbJzix5Hv_PHdJI=#!q{CHv{ z4RyczdfR0fPlLV~7)=A4G&EPhP#W+u!N8j4BKKGtw)#%{BWXGkBWWNoF_PvwF_I<^ zM$(*A?{SWzX*)V5to5P$Gd^!&R;f>dhh*%}kYO?Eoz3B-&%`;#W~b*E8$J%l@f~A> z;TF0E+PLMtd@K-Y$^|?CF)1=4X)tI1c7KYyLDv@=_y3_0D$bHmM29%|`%|#9f|O4A z1t$$Si14Qbli%^l9uI#1$JJ@DUqd2TcD#Kq*ueK*mBxSww71=%x&VSiBA&fpyeBni z100e2Ba|KM?)?r11nIB%T%YL~RJ@ zU-7v(HG6v*UU%61S9~tl96Dme(;j!H#%>4t;69fxAOx=C*k`!nk=`R5tejvy*4J?r zZ@(ocapxIyN_eh1NnoTa!Xu#9I1YcDa3c7@g!jP@4It~`b#RM==b`Z5@jR#$1*&4g zQ-Lc^MiHKe5&OwqkuYTgc^t8 zgZ3e{r*FpTkAyLJau-N>*DQVX8^mXD7Nm%#@PB!yEU9I5PNNqYRHKpo+~@>tpj^baFm*Koss(D&k1$J~qLFp5~0nEMJ} zRlN{i%z9W6qI=#vI^q~(TX_gqT0bgxu=NaA$D5@)Y`J9^88?CYgXmJBO0mm$*Fd$2DyHWw&0c2MU)feaJijjZRPHg$w2~JszuCFb-=^QHAH^7vKP5QT zevVykK4)7R{EPnS{BuQnXj%@lP2Untp6e<;vVzc@%%3Sf}nMIuqWv&eYhL{(8y15zlGDbSHU6*7Bld ziA~%>rX={5`DE;?<_or6AsMD{>j#zHZSS&YMGg->Shpf`Zrp2@b%s}rix@Y;*vx0_ z*0RLl^|gaVh1%~*KCcT^uhV~0!zh@W)3bJA!pG?|x#Ki1L=O{P&^=!GisA>!8Adq! zV1X>Sqv1sLSaWyHGitNBYxsBcy7(7sXGU#e98O+ceXe$7)>XFkjhhNP zvL6-KNB?d+pj4QKao;wirlkar&-+58PuY+bo?%sVsA$sksh$>QYk0CSRr#WLf7!2% zGWoD%21_aEEx#W+hiTUq$59!N3bpJ*rGrCnCk&2QRFNwAfyYjjGqyxgD;8HoX3;Gn z;>Y7H%0&^+)z78AQ!vxgnAkgK0kf=XO6YniD(q%SpJ&qJIqf~*y$&wf6!`c`qAI04XIyQa=p4W`nqx{YnSYS~O15Q; zC|esfNPJZ}K1{%WuBt!v1=*(zW!CbBew-d9LwRg*XljUlSJ;H`iQ!kp9oRSQ%@OZs z&8TaM7$4D+cq8&)-t$sP^g5N99TB%uv6Lf-s|X!kendi*-Htevzk}N$D?2s0em1?M zsFSE`;cLvJ{BG>uq*Hm?@P|a-vTMb&!{()PY$Izna6+ZsncdkNIl(f1#75=}c@MUx zF_(XU_7Ly5a${I-!j-rb(-mP~-s-YE-N#WYit-aqamFO}WaqHAGS`%COykQA<_;_D zD%}&+DYlR8;|6-lM9B-OPYHrVO9a-0nuLcn{P@lZT@u*!&obX{?387Yovmk>eiSLB z0}V6lPFU8~chBmZ{Hmm|s-_y()i-S)@eiFIQ@_6o#;=P)u_(yrPsMDOY z;*hA0*&m7RmgNaM65og!nLjDKoALra=0>GB~F?Y zcZ&D3Zg)Y7wxeAYea~3Jebknh+lAUi`J?gGy1Wc-DXr*>(nF0=5gg|8H809$anFgq zrcM)_HoYNZvVKb1ARBC2W7=2q8~p3hCbDPs0itUSYh-c!M#E8WlRY`0J=# z+U$aa;x`+{#a}9!95-A$u^^RmI7*dY7!t}Wi8+#)mT|9A+PIAKwfR`iN5UM-_K*$A z=S8C#%Xzk#a^0n@7UQh2=VBh_>l1%VdxAeN<8!%QClDpo7KMy2I#G5=yPvnQXr-hr z_ap7==?$tfuC#bw{qfSV`tz3G<*((XH*T%`((-G?5zgU!QS|jPntU#u5=l3I5dFL0 zLrz0^Ove_+cD1#iAxKX=Vz>GJQO{#Vqo(1yb&qMw2w0*()H^2NM5v}q}JLas%O+7nl$>B zWk7u2GFip!@(wa%zK-=vZIEeB*m=2>`=)YcMpRUAsa`rDrDt+_VP)fO?cpk_A|d>a z;yr4p?G81 zx$>UXCvv&LzwmF?{vu2$ooMb5b3{QaTvI(IW|HC4^dcrb+FD>P&yOq3&DXu5_`P94 za+mVO@f+0F*jo#(^KWJyQ0xr8NWCjN(m2CDHmgpPB$^PiH(_pKFU^R;LDa5>^fbO< zXUt>5eS(uYw2CO(4d$15mqU-GpO4uPIaqVaytyD*^pK$}_N(;ns^Q5!45e|3q*%k8 z=-1LSltOl*W@zY1$+g$n<-+H99|^c+!^%Du7*(IBjtYKI9~bPd+AB63-ls?79)bf#%>+1=6v`O|4HNWT~VY|U2W zC^j@a8Jeg#ukT#=Yj%&UUh#A5rWj9JRw>mH`O+(8y(69uwutMvBJr8HxDc^8Dz`;5 zCcjtRiKv_Ed19@3N5t~9xcsuH9!3Q%FZF)?_{dE$uho4)y~8o*Uda49?shaUeLK4} zWO3C?Fu;k%%YMn{CFr-V^Lz?A`PXe}sbu9S9e2rh#IM4cd z>^a^z^RKi$>}46jEPgpdzB;0F{U*`JqJo$L{#f>Ni67=2Ox9H%kNqQTa5>XBOTQ%U zWoh5)Ppii#MyRhBjn2HHJ;$0@rcfE`UzWX+yN&i~Esr;%bhu7jH`92@K8+e2)ywok z;&Sa)!$+z21&zr!nXl#!3VxLJZrZH0-8q{SYcs}Wtt|^LDNXA{k752)C$X}43wK@7 zV%}3cm4?b)n`Mo-6kDL#$LU~^Hq<7B(Jm`^$}DM3ReatS?&O5;%o>JT6PG+qGBS2m zXtU~F#R6ki@<4qn^^);GXy<|`@rmT`rTx=}nJP5BwWDIA(_+#l6&#WUrM}2qVjOMy zAi174qI`eBkcM2#rF443u!dtXgOX0hd{sFt>9Jx%hLSg_xWY0n>iL8f5l`8Q=w<3k zl{|Gbr)%XAgEjk#{%}p7j843x%J*_iQNfBk8L63bSlPC(qPp_m(1d6vm?i~t<0@-Q z<0UjkIEULQ_Z7)7!&0u!{95eb#5p!oFkRRoVmJ3=V?!{L_MP_kyccz$v?mg%DMNU% zwNEB=EFKbZQ}|nOR=Sy$6PBykC0>%#nR!jWI(&OvO^ht`Xhf6vy5O`{R{urLkm#Cv zS?#`v-&sc`JsP%|E@ypVD2*5sv8w!Xn3DEZL%N-s{ZUP)vc!t7EK7Mkvz7--i=O6f zkKR^UAO5@jo6M(Z$08J|NsWC}Jqj7-8|haX8YJ(iMubg?+aCE#zVQhzpf zUgj!ld^O9c6Mb3Eu1n01EZtzpEH6tLn=wGuSYpW=qcxRlIHzKUi@u;eQ(0TqAb7rU zl6ig2H>#R~CsVg)FmgN4Hl$}HEm0n`zfz+YT~?)JB~|m)m$SEMRJoeuuGuGOC3*Q( zxivY)sEks}=EU{YZ)bNFd?ivh2yFc5Mad0zVQgG%2(3@STj{g&hDVLjWh!&ZPuaF* zmQ<)Krew`Yxh8ukwwvJB(B`_el{!m(Y_MLLG*@-jG?RHCVQ0pc@ZsUCirT7}m@LuO z@GixJ)!!*{Qeuri8?I.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≧)GyEaQ1n-)>R6R1_c)qW+uC;L2ScL`I> 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 literal 0 HcmV?d00001 diff --git a/dlls/csx_sql/extra/lib_win32/zlib.lib b/dlls/csx_sql/extra/lib_win32/zlib.lib new file mode 100755 index 0000000000000000000000000000000000000000..c39ef6d59d4debf60aade8eb1b79bdc616b2003d GIT binary patch literal 84034 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 literal 0 HcmV?d00001 diff --git a/dlls/csx_sql/meta_api.cpp b/dlls/csx_sql/meta_api.cpp new file mode 100755 index 00000000..20b74c1a --- /dev/null +++ b/dlls/csx_sql/meta_api.cpp @@ -0,0 +1,388 @@ +#include "amxxmodule.h" +#include "rank.h" + +funEventCall modMsgsEnd[MAX_REG_MSGS]; +funEventCall modMsgs[MAX_REG_MSGS]; + +void (*function)(void*); +void (*endfunction)(void*); + +CPlayer players[33]; + +CPlayer* mPlayer; + +int mPlayerIndex; +int mState; + +RankSystem g_rank; + +Grenades g_grenades; + +int iFGrenade; +int iFDeath; +int iFDamage; + +int iFBPlanted; +int iFBDefused; +int iFBPlanting; +int iFBDefusing; +int iFBExplode; + +int g_bombAnnounce; +int g_Planter; +int g_Defuser; + +bool rankBots; + +int gmsgCurWeapon; +int gmsgDeathMsg; +int gmsgDamage; +int gmsgDamageEnd; +int gmsgWeaponList; +int gmsgResetHUD; +int gmsgAmmoX; +int gmsgScoreInfo; +int gmsgAmmoPickup; + +int gmsgSendAudio; +int gmsgTextMsg; +int gmsgBarTime; + +int g_CurrentMsg; + +cvar_t init_csstats_maxsize ={"csstats_maxsize","3500", 0 , 3500.0 }; +cvar_t init_csstats_reset ={"csstats_reset","0"}; +cvar_t init_csstats_rank ={"csstats_rank","0"}; +cvar_t *csstats_maxsize; +cvar_t *csstats_reset; +cvar_t *csstats_rank; + +cvar_t* csstats_rankbots; +cvar_t* csstats_pause; +cvar_t init_csstats_rankbots ={"csstats_rankbots","1"}; +cvar_t init_csstats_pause = {"csstats_pause","0"}; + +struct sUserMsg { + const char* name; + int* id; + funEventCall func; + bool endmsg; +} g_user_msg[] = { + { "CurWeapon" , &gmsgCurWeapon , Client_CurWeapon, false }, + { "Damage" , &gmsgDamage,Client_Damage, false }, + { "Damage" , &gmsgDamageEnd, Client_Damage_End, true }, + { "WeaponList" , &gmsgWeaponList, Client_WeaponList, false }, + { "ResetHUD" , &gmsgResetHUD,Client_ResetHUD, true }, + { "AmmoX" , &gmsgAmmoX, Client_AmmoX , false }, + { "ScoreInfo" , &gmsgScoreInfo, Client_ScoreInfo, false }, + { "AmmoPickup" , &gmsgAmmoPickup, Client_AmmoPickup , false }, + + { "SendAudio" , &gmsgSendAudio , Client_SendAudio , false }, + { "TextMsg" , &gmsgTextMsg , Client_TextMsg , false }, + { "BarTime" , &gmsgBarTime , Client_BarTime , false }, + + { 0 , 0,0,false } +}; + +int RegUserMsg_Post(const char *pszName, int iSize) +{ + for (int i = 0; g_user_msg[ i ].name; ++i ) + { + if ( !*g_user_msg[i].id && strcmp( g_user_msg[ i ].name , pszName ) == 0 ) + { + int id = META_RESULT_ORIG_RET( int ); + + *g_user_msg[ i ].id = id; + + if ( g_user_msg[ i ].endmsg ) + modMsgsEnd[ id ] = g_user_msg[ i ].func; + else + modMsgs[ id ] = g_user_msg[ i ].func; + //break; + } + } + RETURN_META_VALUE(MRES_IGNORED, 0); +} + +const char* get_localinfo( const char* name , const char* def = 0 ) +{ + const char* b = LOCALINFO( (char*)name ); + if (((b==0)||(*b==0)) && def ) + SET_LOCALINFO((char*)name,(char*)(b = def) ); + return b; +} + +void ClientKill(edict_t *pEntity){ + CPlayer *pPlayer = GET_PLAYER_POINTER(pEntity); + if ( !pPlayer->IsAlive()) + RETURN_META(MRES_IGNORED); + + MF_ExecuteForward( iFDamage,pPlayer->index , pPlayer->index , 0, 0, 0, 0 ); + pPlayer->saveKill(pPlayer,0,0,0); + MF_ExecuteForward( iFDeath,pPlayer->index, pPlayer->index, 0, 0, 0 ); + + RETURN_META(MRES_IGNORED); +} + +void ServerActivate_Post( edict_t *pEdictList, int edictCount, int clientMax ){ + + rankBots = (int)csstats_rankbots->value ? true:false; + + for( int i = 1; i <= gpGlobals->maxClients; ++i) + GET_PLAYER_POINTER_I(i)->Init( i , pEdictList + i ); + RETURN_META(MRES_IGNORED); +} + +void PlayerPreThink_Post( edict_t *pEntity ) { + if ( !isModuleActive() ) + return; + + CPlayer *pPlayer = GET_PLAYER_POINTER(pEntity); + if (pPlayer->clearStats && pPlayer->clearStats < gpGlobals->time ){ + + if ( !ignoreBots(pEntity) ){ + pPlayer->clearStats = 0.0f; + if (pPlayer->rank) + pPlayer->rank->updatePosition( &pPlayer->life ); + pPlayer->restartStats(false); + } + } + RETURN_META(MRES_IGNORED); +} + +void ServerDeactivate() { + int i; + for( i = 1;i<=gpGlobals->maxClients; ++i){ + CPlayer *pPlayer = GET_PLAYER_POINTER_I(i); + if (pPlayer->rank) pPlayer->Disconnect(); + } + if ( (g_rank.getRankNum() >= (int)csstats_maxsize->value) || ((int)csstats_reset->value == 1 ) ) { + CVAR_SET_FLOAT("csstats_reset",0.0); + g_rank.clear(); // clear before save to file + } + g_rank.saveRank( MF_BuildPathname("%s",get_localinfo("csstats")) ); + g_rank.saveRankSql(); + + + // clear custom weapons info + for ( i=MAX_WEAPONS;iConnect(pszAddress); + RETURN_META_VALUE(MRES_IGNORED, TRUE); +} + +void ClientDisconnect( edict_t *pEntity ) { + CPlayer *pPlayer = GET_PLAYER_POINTER(pEntity); + if (pPlayer->rank) pPlayer->Disconnect(); + RETURN_META(MRES_IGNORED); +} + +void ClientPutInServer_Post( edict_t *pEntity ) { + GET_PLAYER_POINTER(pEntity)->PutInServer(); + RETURN_META(MRES_IGNORED); +} + +void ClientUserInfoChanged_Post( edict_t *pEntity, char *infobuffer ) { + CPlayer *pPlayer = GET_PLAYER_POINTER(pEntity); + const char* name = INFOKEY_VALUE(infobuffer,"name"); + const char* oldname = STRING(pEntity->v.netname); + + if ( pPlayer->rank ){ + if ( strcmp(oldname,name) != 0 ) { + if ((int)csstats_rank->value == 0) + pPlayer->rank = g_rank.findEntryInRank( name, name ); + else + pPlayer->rank->setName( name ); + } + } + else if ( pPlayer->IsBot() ) { + pPlayer->Connect( "127.0.0.1" ); + pPlayer->PutInServer(); + } + RETURN_META(MRES_IGNORED); +} + +void MessageBegin_Post(int msg_dest, int msg_type, const float *pOrigin, edict_t *ed) { + if (ed){ + mPlayerIndex = ENTINDEX(ed); + mPlayer = GET_PLAYER_POINTER_I(mPlayerIndex); + } else { + mPlayerIndex = 0; + mPlayer = 0; + } + mState = 0; + g_CurrentMsg = msg_type; + if ( g_CurrentMsg < 0 || g_CurrentMsg >= MAX_REG_MSGS ) + g_CurrentMsg = 0; + function=modMsgs[g_CurrentMsg]; + endfunction=modMsgsEnd[g_CurrentMsg]; + RETURN_META(MRES_IGNORED); +} + +void MessageEnd_Post(void) { + if (endfunction) (*endfunction)(NULL); + RETURN_META(MRES_IGNORED); +} + +void WriteByte_Post(int iValue) { + if (function) (*function)((void *)&iValue); + RETURN_META(MRES_IGNORED); +} + +void WriteChar_Post(int iValue) { + if (function) (*function)((void *)&iValue); + RETURN_META(MRES_IGNORED); +} + +void WriteShort_Post(int iValue) { + if (function) (*function)((void *)&iValue); + RETURN_META(MRES_IGNORED); +} + +void WriteLong_Post(int iValue) { + if (function) (*function)((void *)&iValue); + RETURN_META(MRES_IGNORED); +} + +void WriteAngle_Post(float flValue) { + if (function) (*function)((void *)&flValue); + RETURN_META(MRES_IGNORED); +} + +void WriteCoord_Post(float flValue) { + if (function) (*function)((void *)&flValue); + RETURN_META(MRES_IGNORED); +} + +void WriteString_Post(const char *sz) { + if (function) (*function)((void *)sz); + RETURN_META(MRES_IGNORED); +} + +void WriteEntity_Post(int iValue) { + if (function) (*function)((void *)&iValue); + RETURN_META(MRES_IGNORED); +} + +void StartFrame_Post(){ + if (g_bombAnnounce){ + switch (g_bombAnnounce){ + case BOMB_PLANTING: + MF_ExecuteForward( iFBPlanting,g_Planter ); + break; + case BOMB_PLANTED: + MF_ExecuteForward( iFBPlanted,g_Planter ); + break; + case BOMB_EXPLODE: + MF_ExecuteForward( iFBExplode,g_Planter,g_Defuser ); + break; + case BOMB_DEFUSING: + MF_ExecuteForward( iFBDefusing,g_Defuser ); + break; + case BOMB_DEFUSED: + MF_ExecuteForward( iFBDefused,g_Defuser ); + break; + } + g_bombAnnounce = 0; + } + RETURN_META(MRES_IGNORED); +} + +void SetModel_Post(edict_t *e, const char *m){ + + if ( !isModuleActive() ) + return; + + if ( e->v.owner && m[7]=='w' && m[8]=='_' ){ + int w_id = 0; + CPlayer *pPlayer = GET_PLAYER_POINTER(e->v.owner); + switch(m[9]){ + case 'h': + w_id = CSW_HEGRENADE; + g_grenades.put(e, 2.0, 4, pPlayer); + pPlayer->saveShot(CSW_HEGRENADE); + break; + case 'f': + if (m[10]=='l') w_id = CSW_FLASHBANG; + break; + case 's': + if (m[10]=='m') w_id = CSW_SMOKEGRENADE; + break; + } + if ( w_id ) + MF_ExecuteForward( iFGrenade, pPlayer->index, ENTINDEX(e) ,w_id ); + } + + RETURN_META(MRES_IGNORED); +} + +void EmitSound_Post(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch) { + if (sample[0]=='w'&&sample[1]=='e'&&sample[8]=='k'&&sample[9]=='n'&&sample[14]!='d'){ + CPlayer*pPlayer = GET_PLAYER_POINTER(entity); + pPlayer->saveShot(pPlayer->current); + } + RETURN_META(MRES_IGNORED); +} + +void TraceLine_Post(const float *v1, const float *v2, int fNoMonsters, edict_t *e, TraceResult *ptr) { + if (ptr->pHit&&(ptr->pHit->v.flags& (FL_CLIENT | FL_FAKECLIENT) )&& + e&&(e->v.flags& (FL_CLIENT | FL_FAKECLIENT) )&&ptr->iHitgroup) + GET_PLAYER_POINTER(e)->aiming = ptr->iHitgroup; + RETURN_META(MRES_IGNORED); +} + +extern void OnMetaAttach_sql(); + +void OnMetaAttach() { + CVAR_REGISTER (&init_csstats_maxsize); + CVAR_REGISTER (&init_csstats_reset); + CVAR_REGISTER (&init_csstats_rank); + csstats_maxsize=CVAR_GET_POINTER(init_csstats_maxsize.name); + csstats_reset=CVAR_GET_POINTER(init_csstats_reset.name); + csstats_rank=CVAR_GET_POINTER(init_csstats_rank.name); + + CVAR_REGISTER (&init_csstats_rankbots); + CVAR_REGISTER (&init_csstats_pause); + csstats_rankbots = CVAR_GET_POINTER(init_csstats_rankbots.name); + csstats_pause = CVAR_GET_POINTER(init_csstats_pause.name); + + OnMetaAttach_sql(); +} + +void OnAmxxAttach(){ + MF_AddNatives(stats_Natives); + const char* path = get_localinfo("csstats_score"); + if ( path && *path ) + { + char error[128]; + g_rank.loadCalc( MF_BuildPathname("%s",path) , error ); + } + + if ( !g_rank.begin() ) + { + g_rank.loadRank( MF_BuildPathname("%s", + get_localinfo("csstats") ) ); + } +} + +void OnAmxxDetach() { + g_grenades.clear(); + g_rank.clear(); + g_rank.unloadCalc(); +} + +void OnPluginsLoaded(){ + iFDeath = MF_RegisterForward("client_death",ET_IGNORE,FP_CELL,FP_CELL,FP_CELL,FP_CELL,FP_CELL,FP_DONE); + iFDamage = MF_RegisterForward("client_damage",ET_IGNORE,FP_CELL,FP_CELL,FP_CELL,FP_CELL,FP_CELL,FP_CELL,FP_DONE); + iFBPlanted = MF_RegisterForward("bomb_planted",ET_IGNORE,FP_CELL,FP_DONE); + iFBDefused = MF_RegisterForward("bomb_defused",ET_IGNORE,FP_CELL,FP_DONE); + iFBPlanting = MF_RegisterForward("bomb_planting",ET_IGNORE,FP_CELL,FP_DONE); + iFBDefusing = MF_RegisterForward("bomb_defusing",ET_IGNORE,FP_CELL,FP_DONE); + iFBExplode = MF_RegisterForward("bomb_explode",ET_IGNORE,FP_CELL,FP_CELL,FP_DONE); + iFGrenade = MF_RegisterForward("grenade_throw",ET_IGNORE,FP_CELL,FP_CELL,FP_CELL,FP_DONE); +} diff --git a/dlls/csx_sql/moduleconfig.h b/dlls/csx_sql/moduleconfig.h new file mode 100755 index 00000000..873662d0 --- /dev/null +++ b/dlls/csx_sql/moduleconfig.h @@ -0,0 +1,462 @@ +// Configuration + +#ifndef __MODULECONFIG_H__ +#define __MODULECONFIG_H__ + +// Module info +#define MODULE_NAME "CSX" +#define MODULE_VERSION "1.00" +#define MODULE_AUTHOR "AMX Mod X Dev Team" +#define MODULE_URL "http://www.amxmodx.org/" +#define MODULE_LOGTAG "CSX" +// If you want the module not to be reloaded on mapchange, remove / comment out the next line +#define MODULE_RELOAD_ON_MAPCHANGE + +#ifdef __DATE__ +#define MODULE_DATE __DATE__ +#else // __DATE__ +#define MODULE_DATE "Unknown" +#endif // __DATE__ + +// metamod plugin? +#define USE_METAMOD + +// - AMXX Init functions +// Also consider using FN_META_* +// AMXX query +//#define FN_AMXX_QUERY OnAmxxQuery +// AMXX attach +// Do native functions init here (MF_AddNatives) +#define FN_AMXX_ATTACH OnAmxxAttach +// AMXX detach +#define FN_AMXX_DETACH OnAmxxDetach +// All plugins loaded +// Do forward functions init here (MF_RegisterForward) +#define FN_AMXX_PLUGINSLOADED OnPluginsLoaded + +/**** METAMOD ****/ +// If your module doesn't use metamod, you may close the file now :) +#ifdef USE_METAMOD +// ---- +// Hook Functions +// Uncomment these to be called +// You can also change the function name + +// - Metamod init functions +// Also consider using FN_AMXX_* +// Meta query +//#define FN_META_QUERY OnMetaQuery +// Meta attach +#define FN_META_ATTACH OnMetaAttach +// Meta detach +//#define FN_META_DETACH OnMetaDetach + +// (wd) are Will Day's notes +// - GetEntityAPI2 functions +// #define FN_GameDLLInit GameDLLInit /* pfnGameInit() */ +// #define FN_DispatchSpawn DispatchSpawn /* pfnSpawn() */ +// #define FN_DispatchThink DispatchThink /* pfnThink() */ +// #define FN_DispatchUse DispatchUse /* pfnUse() */ +// #define FN_DispatchTouch DispatchTouch /* pfnTouch() */ +// #define FN_DispatchBlocked DispatchBlocked /* pfnBlocked() */ +// #define FN_DispatchKeyValue DispatchKeyValue /* pfnKeyValue() */ +// #define FN_DispatchSave DispatchSave /* pfnSave() */ +// #define FN_DispatchRestore DispatchRestore /* pfnRestore() */ +// #define FN_DispatchObjectCollsionBox DispatchObjectCollsionBox /* pfnSetAbsBox() */ +// #define FN_SaveWriteFields SaveWriteFields /* pfnSaveWriteFields() */ +// #define FN_SaveReadFields SaveReadFields /* pfnSaveReadFields() */ +// #define FN_SaveGlobalState SaveGlobalState /* pfnSaveGlobalState() */ +// #define FN_RestoreGlobalState RestoreGlobalState /* pfnRestoreGlobalState() */ +// #define FN_ResetGlobalState ResetGlobalState /* pfnResetGlobalState() */ +// #define FN_ClientConnect ClientConnect /* pfnClientConnect() (wd) Client has connected */ +#define FN_ClientDisconnect ClientDisconnect /* pfnClientDisconnect() (wd) Player has left the game */ +#define FN_ClientKill ClientKill /* pfnClientKill() (wd) Player has typed "kill" */ +// #define FN_ClientPutInServer ClientPutInServer /* pfnClientPutInServer() (wd) Client is entering the game */ +// #define FN_ClientCommand ClientCommand /* pfnClientCommand() (wd) Player has sent a command (typed or from a bind) */ +// #define FN_ClientUserInfoChanged ClientUserInfoChanged /* pfnClientUserInfoChanged() (wd) Client has updated their setinfo structure */ +// #define FN_ServerActivate ServerActivate /* pfnServerActivate() (wd) Server is starting a new map */ +#define FN_ServerDeactivate ServerDeactivate /* pfnServerDeactivate() (wd) Server is leaving the map (shutdown or changelevel); SDK2 */ +// #define FN_PlayerPreThink PlayerPreThink /* pfnPlayerPreThink() */ +// #define FN_PlayerPostThink PlayerPostThink /* pfnPlayerPostThink() */ +// #define FN_StartFrame StartFrame /* pfnStartFrame() */ +// #define FN_ParmsNewLevel ParmsNewLevel /* pfnParmsNewLevel() */ +// #define FN_ParmsChangeLevel ParmsChangeLevel /* pfnParmsChangeLevel() */ +// #define FN_GetGameDescription GetGameDescription /* pfnGetGameDescription() Returns string describing current .dll. E.g. "TeamFotrress 2" "Half-Life" */ +// #define FN_PlayerCustomization PlayerCustomization /* pfnPlayerCustomization() Notifies .dll of new customization for player. */ +// #define FN_SpectatorConnect SpectatorConnect /* pfnSpectatorConnect() Called when spectator joins server */ +// #define FN_SpectatorDisconnect SpectatorDisconnect /* pfnSpectatorDisconnect() Called when spectator leaves the server */ +// #define FN_SpectatorThink SpectatorThink /* pfnSpectatorThink() Called when spectator sends a command packet (usercmd_t) */ +// #define FN_Sys_Error Sys_Error /* pfnSys_Error() Notify game .dll that engine is going to shut down. Allows mod authors to set a breakpoint. SDK2 */ +// #define FN_PM_Move PM_Move /* pfnPM_Move() (wd) SDK2 */ +// #define FN_PM_Init PM_Init /* pfnPM_Init() Server version of player movement initialization; (wd) SDK2 */ +// #define FN_PM_FindTextureType PM_FindTextureType /* pfnPM_FindTextureType() (wd) SDK2 */ +// #define FN_SetupVisibility SetupVisibility /* pfnSetupVisibility() Set up PVS and PAS for networking for this client; (wd) SDK2 */ +// #define FN_UpdateClientData UpdateClientData /* pfnUpdateClientData() Set up data sent only to specific client; (wd) SDK2 */ +// #define FN_AddToFullPack AddToFullPack /* pfnAddToFullPack() (wd) SDK2 */ +// #define FN_CreateBaseline CreateBaseline /* pfnCreateBaseline() Tweak entity baseline for network encoding allows setup of player baselines too.; (wd) SDK2 */ +// #define FN_RegisterEncoders RegisterEncoders /* pfnRegisterEncoders() Callbacks for network encoding; (wd) SDK2 */ +// #define FN_GetWeaponData GetWeaponData /* pfnGetWeaponData() (wd) SDK2 */ +// #define FN_CmdStart CmdStart /* pfnCmdStart() (wd) SDK2 */ +// #define FN_CmdEnd CmdEnd /* pfnCmdEnd() (wd) SDK2 */ +// #define FN_ConnectionlessPacket ConnectionlessPacket /* pfnConnectionlessPacket() (wd) SDK2 */ +// #define FN_GetHullBounds GetHullBounds /* pfnGetHullBounds() (wd) SDK2 */ +// #define FN_CreateInstancedBaselines CreateInstancedBaselines /* pfnCreateInstancedBaselines() (wd) SDK2 */ +// #define FN_InconsistentFile InconsistentFile /* pfnInconsistentFile() (wd) SDK2 */ +// #define FN_AllowLagCompensation AllowLagCompensation /* pfnAllowLagCompensation() (wd) SDK2 */ + +// - GetEntityAPI2_Post functions +// #define FN_GameDLLInit_Post GameDLLInit_Post +// #define FN_DispatchSpawn_Post DispatchSpawn_Post +// #define FN_DispatchThink_Post DispatchThink_Post +// #define FN_DispatchUse_Post DispatchUse_Post +// #define FN_DispatchTouch_Post DispatchTouch_Post +// #define FN_DispatchBlocked_Post DispatchBlocked_Post +// #define FN_DispatchKeyValue_Post DispatchKeyValue_Post +// #define FN_DispatchSave_Post DispatchSave_Post +// #define FN_DispatchRestore_Post DispatchRestore_Post +// #define FN_DispatchObjectCollsionBox_Post DispatchObjectCollsionBox_Post +// #define FN_SaveWriteFields_Post SaveWriteFields_Post +// #define FN_SaveReadFields_Post SaveReadFields_Post +// #define FN_SaveGlobalState_Post SaveGlobalState_Post +// #define FN_RestoreGlobalState_Post RestoreGlobalState_Post +// #define FN_ResetGlobalState_Post ResetGlobalState_Post +#define FN_ClientConnect_Post ClientConnect_Post +// #define FN_ClientDisconnect_Post ClientDisconnect_Post +// #define FN_ClientKill_Post ClientKill_Post +#define FN_ClientPutInServer_Post ClientPutInServer_Post +// #define FN_ClientCommand_Post ClientCommand_Post +#define FN_ClientUserInfoChanged_Post ClientUserInfoChanged_Post +#define FN_ServerActivate_Post ServerActivate_Post +// #define FN_ServerDeactivate_Post ServerDeactivate_Post +#define FN_PlayerPreThink_Post PlayerPreThink_Post +// #define FN_PlayerPostThink_Post PlayerPostThink_Post +#define FN_StartFrame_Post StartFrame_Post +// #define FN_ParmsNewLevel_Post ParmsNewLevel_Post +// #define FN_ParmsChangeLevel_Post ParmsChangeLevel_Post +// #define FN_GetGameDescription_Post GetGameDescription_Post +// #define FN_PlayerCustomization_Post PlayerCustomization_Post +// #define FN_SpectatorConnect_Post SpectatorConnect_Post +// #define FN_SpectatorDisconnect_Post SpectatorDisconnect_Post +// #define FN_SpectatorThink_Post SpectatorThink_Post +// #define FN_Sys_Error_Post Sys_Error_Post +// #define FN_PM_Move_Post PM_Move_Post +// #define FN_PM_Init_Post PM_Init_Post +// #define FN_PM_FindTextureType_Post PM_FindTextureType_Post +// #define FN_SetupVisibility_Post SetupVisibility_Post +// #define FN_UpdateClientData_Post UpdateClientData_Post +// #define FN_AddToFullPack_Post AddToFullPack_Post +// #define FN_CreateBaseline_Post CreateBaseline_Post +// #define FN_RegisterEncoders_Post RegisterEncoders_Post +// #define FN_GetWeaponData_Post GetWeaponData_Post +// #define FN_CmdStart_Post CmdStart_Post +// #define FN_CmdEnd_Post CmdEnd_Post +// #define FN_ConnectionlessPacket_Post ConnectionlessPacket_Post +// #define FN_GetHullBounds_Post GetHullBounds_Post +// #define FN_CreateInstancedBaselines_Post CreateInstancedBaselines_Post +// #define FN_InconsistentFile_Post InconsistentFile_Post +// #define FN_AllowLagCompensation_Post AllowLagCompensation_Post + +// - GetEngineAPI functions +// #define FN_PrecacheModel PrecacheModel +// #define FN_PrecacheSound PrecacheSound +// #define FN_SetModel SetModel +// #define FN_ModelIndex ModelIndex +// #define FN_ModelFrames ModelFrames +// #define FN_SetSize SetSize +// #define FN_ChangeLevel ChangeLevel +// #define FN_GetSpawnParms GetSpawnParms +// #define FN_SaveSpawnParms SaveSpawnParms +// #define FN_VecToYaw VecToYaw +// #define FN_VecToAngles VecToAngles +// #define FN_MoveToOrigin MoveToOrigin +// #define FN_ChangeYaw ChangeYaw +// #define FN_ChangePitch ChangePitch +// #define FN_FindEntityByString FindEntityByString +// #define FN_GetEntityIllum GetEntityIllum +// #define FN_FindEntityInSphere FindEntityInSphere +// #define FN_FindClientInPVS FindClientInPVS +// #define FN_EntitiesInPVS EntitiesInPVS +// #define FN_MakeVectors MakeVectors +// #define FN_AngleVectors AngleVectors +// #define FN_CreateEntity CreateEntity +// #define FN_RemoveEntity RemoveEntity +// #define FN_CreateNamedEntity CreateNamedEntity +// #define FN_MakeStatic MakeStatic +// #define FN_EntIsOnFloor EntIsOnFloor +// #define FN_DropToFloor DropToFloor +// #define FN_WalkMove WalkMove +// #define FN_SetOrigin SetOrigin +// #define FN_EmitSound EmitSound +// #define FN_EmitAmbientSound EmitAmbientSound +// #define FN_TraceLine TraceLine +// #define FN_TraceToss TraceToss +// #define FN_TraceMonsterHull TraceMonsterHull +// #define FN_TraceHull TraceHull +// #define FN_TraceModel TraceModel +// #define FN_TraceTexture TraceTexture +// #define FN_TraceSphere TraceSphere +// #define FN_GetAimVector GetAimVector +// #define FN_ServerCommand ServerCommand +// #define FN_ServerExecute ServerExecute +// #define FN_engClientCommand engClientCommand +// #define FN_ParticleEffect ParticleEffect +// #define FN_LightStyle LightStyle +// #define FN_DecalIndex DecalIndex +// #define FN_PointContents PointContents +// #define FN_MessageBegin MessageBegin +// #define FN_MessageEnd MessageEnd +// #define FN_WriteByte WriteByte +// #define FN_WriteChar WriteChar +// #define FN_WriteShort WriteShort +// #define FN_WriteLong WriteLong +// #define FN_WriteAngle WriteAngle +// #define FN_WriteCoord WriteCoord +// #define FN_WriteString WriteString +// #define FN_WriteEntity WriteEntity +// #define FN_CVarRegister CVarRegister +// #define FN_CVarGetFloat CVarGetFloat +// #define FN_CVarGetString CVarGetString +// #define FN_CVarSetFloat CVarSetFloat +// #define FN_CVarSetString CVarSetString +// #define FN_AlertMessage AlertMessage +// #define FN_EngineFprintf EngineFprintf +// #define FN_PvAllocEntPrivateData PvAllocEntPrivateData +// #define FN_PvEntPrivateData PvEntPrivateData +// #define FN_FreeEntPrivateData FreeEntPrivateData +// #define FN_SzFromIndex SzFromIndex +// #define FN_AllocString AllocString +// #define FN_GetVarsOfEnt GetVarsOfEnt +// #define FN_PEntityOfEntOffset PEntityOfEntOffset +// #define FN_EntOffsetOfPEntity EntOffsetOfPEntity +// #define FN_IndexOfEdict IndexOfEdict +// #define FN_PEntityOfEntIndex PEntityOfEntIndex +// #define FN_FindEntityByVars FindEntityByVars +// #define FN_GetModelPtr GetModelPtr +// #define FN_RegUserMsg RegUserMsg +// #define FN_AnimationAutomove AnimationAutomove +// #define FN_GetBonePosition GetBonePosition +// #define FN_FunctionFromName FunctionFromName +// #define FN_NameForFunction NameForFunction +// #define FN_ClientPrintf ClientPrintf +// #define FN_ServerPrint ServerPrint +// #define FN_Cmd_Args Cmd_Args +// #define FN_Cmd_Argv Cmd_Argv +// #define FN_Cmd_Argc Cmd_Argc +// #define FN_GetAttachment GetAttachment +// #define FN_CRC32_Init CRC32_Init +// #define FN_CRC32_ProcessBuffer CRC32_ProcessBuffer +// #define FN_CRC32_ProcessByte CRC32_ProcessByte +// #define FN_CRC32_Final CRC32_Final +// #define FN_RandomLong RandomLong +// #define FN_RandomFloat RandomFloat +// #define FN_SetView SetView +// #define FN_Time Time +// #define FN_CrosshairAngle CrosshairAngle +// #define FN_LoadFileForMe LoadFileForMe +// #define FN_FreeFile FreeFile +// #define FN_EndSection EndSection +// #define FN_CompareFileTime CompareFileTime +// #define FN_GetGameDir GetGameDir +// #define FN_Cvar_RegisterVariable Cvar_RegisterVariable +// #define FN_FadeClientVolume FadeClientVolume +// #define FN_SetClientMaxspeed SetClientMaxspeed +// #define FN_CreateFakeClient CreateFakeClient +// #define FN_RunPlayerMove RunPlayerMove +// #define FN_NumberOfEntities NumberOfEntities +// #define FN_GetInfoKeyBuffer GetInfoKeyBuffer +// #define FN_InfoKeyValue InfoKeyValue +// #define FN_SetKeyValue SetKeyValue +// #define FN_SetClientKeyValue SetClientKeyValue +// #define FN_IsMapValid IsMapValid +// #define FN_StaticDecal StaticDecal +// #define FN_PrecacheGeneric PrecacheGeneric +// #define FN_GetPlayerUserId GetPlayerUserId +// #define FN_BuildSoundMsg BuildSoundMsg +// #define FN_IsDedicatedServer IsDedicatedServer +// #define FN_CVarGetPointer CVarGetPointer +// #define FN_GetPlayerWONId GetPlayerWONId +// #define FN_Info_RemoveKey Info_RemoveKey +// #define FN_GetPhysicsKeyValue GetPhysicsKeyValue +// #define FN_SetPhysicsKeyValue SetPhysicsKeyValue +// #define FN_GetPhysicsInfoString GetPhysicsInfoString +// #define FN_PrecacheEvent PrecacheEvent +// #define FN_PlaybackEvent PlaybackEvent +// #define FN_SetFatPVS SetFatPVS +// #define FN_SetFatPAS SetFatPAS +// #define FN_CheckVisibility CheckVisibility +// #define FN_DeltaSetField DeltaSetField +// #define FN_DeltaUnsetField DeltaUnsetField +// #define FN_DeltaAddEncoder DeltaAddEncoder +// #define FN_GetCurrentPlayer GetCurrentPlayer +// #define FN_CanSkipPlayer CanSkipPlayer +// #define FN_DeltaFindField DeltaFindField +// #define FN_DeltaSetFieldByIndex DeltaSetFieldByIndex +// #define FN_DeltaUnsetFieldByIndex DeltaUnsetFieldByIndex +// #define FN_SetGroupMask SetGroupMask +// #define FN_engCreateInstancedBaseline engCreateInstancedBaseline +// #define FN_Cvar_DirectSet Cvar_DirectSet +// #define FN_ForceUnmodified ForceUnmodified +// #define FN_GetPlayerStats GetPlayerStats +// #define FN_AddServerCommand AddServerCommand +// #define FN_Voice_GetClientListening Voice_GetClientListening +// #define FN_Voice_SetClientListening Voice_SetClientListening +// #define FN_GetPlayerAuthId GetPlayerAuthId + +// - GetEngineAPI_Post functions +// #define FN_PrecacheModel_Post PrecacheModel_Post +// #define FN_PrecacheSound_Post PrecacheSound_Post +#define FN_SetModel_Post SetModel_Post +// #define FN_ModelIndex_Post ModelIndex_Post +// #define FN_ModelFrames_Post ModelFrames_Post +// #define FN_SetSize_Post SetSize_Post +// #define FN_ChangeLevel_Post ChangeLevel_Post +// #define FN_GetSpawnParms_Post GetSpawnParms_Post +// #define FN_SaveSpawnParms_Post SaveSpawnParms_Post +// #define FN_VecToYaw_Post VecToYaw_Post +// #define FN_VecToAngles_Post VecToAngles_Post +// #define FN_MoveToOrigin_Post MoveToOrigin_Post +// #define FN_ChangeYaw_Post ChangeYaw_Post +// #define FN_ChangePitch_Post ChangePitch_Post +// #define FN_FindEntityByString_Post FindEntityByString_Post +// #define FN_GetEntityIllum_Post GetEntityIllum_Post +// #define FN_FindEntityInSphere_Post FindEntityInSphere_Post +// #define FN_FindClientInPVS_Post FindClientInPVS_Post +// #define FN_EntitiesInPVS_Post EntitiesInPVS_Post +// #define FN_MakeVectors_Post MakeVectors_Post +// #define FN_AngleVectors_Post AngleVectors_Post +// #define FN_CreateEntity_Post CreateEntity_Post +// #define FN_RemoveEntity_Post RemoveEntity_Post +// #define FN_CreateNamedEntity_Post CreateNamedEntity_Post +// #define FN_MakeStatic_Post MakeStatic_Post +// #define FN_EntIsOnFloor_Post EntIsOnFloor_Post +// #define FN_DropToFloor_Post DropToFloor_Post +// #define FN_WalkMove_Post WalkMove_Post +// #define FN_SetOrigin_Post SetOrigin_Post +#define FN_EmitSound_Post EmitSound_Post +// #define FN_EmitAmbientSound_Post EmitAmbientSound_Post +#define FN_TraceLine_Post TraceLine_Post +// #define FN_TraceToss_Post TraceToss_Post +// #define FN_TraceMonsterHull_Post TraceMonsterHull_Post +// #define FN_TraceHull_Post TraceHull_Post +// #define FN_TraceModel_Post TraceModel_Post +// #define FN_TraceTexture_Post TraceTexture_Post +// #define FN_TraceSphere_Post TraceSphere_Post +// #define FN_GetAimVector_Post GetAimVector_Post +// #define FN_ServerCommand_Post ServerCommand_Post +// #define FN_ServerExecute_Post ServerExecute_Post +// #define FN_engClientCommand_Post engClientCommand_Post +// #define FN_ParticleEffect_Post ParticleEffect_Post +// #define FN_LightStyle_Post LightStyle_Post +// #define FN_DecalIndex_Post DecalIndex_Post +// #define FN_PointContents_Post PointContents_Post +#define FN_MessageBegin_Post MessageBegin_Post +#define FN_MessageEnd_Post MessageEnd_Post +#define FN_WriteByte_Post WriteByte_Post +#define FN_WriteChar_Post WriteChar_Post +#define FN_WriteShort_Post WriteShort_Post +#define FN_WriteLong_Post WriteLong_Post +#define FN_WriteAngle_Post WriteAngle_Post +#define FN_WriteCoord_Post WriteCoord_Post +#define FN_WriteString_Post WriteString_Post +#define FN_WriteEntity_Post WriteEntity_Post +// #define FN_CVarRegister_Post CVarRegister_Post +// #define FN_CVarGetFloat_Post CVarGetFloat_Post +// #define FN_CVarGetString_Post CVarGetString_Post +// #define FN_CVarSetFloat_Post CVarSetFloat_Post +// #define FN_CVarSetString_Post CVarSetString_Post +// #define FN_AlertMessage_Post AlertMessage_Post +// #define FN_EngineFprintf_Post EngineFprintf_Post +// #define FN_PvAllocEntPrivateData_Post PvAllocEntPrivateData_Post +// #define FN_PvEntPrivateData_Post PvEntPrivateData_Post +// #define FN_FreeEntPrivateData_Post FreeEntPrivateData_Post +// #define FN_SzFromIndex_Post SzFromIndex_Post +// #define FN_AllocString_Post AllocString_Post +// #define FN_GetVarsOfEnt_Post GetVarsOfEnt_Post +// #define FN_PEntityOfEntOffset_Post PEntityOfEntOffset_Post +// #define FN_EntOffsetOfPEntity_Post EntOffsetOfPEntity_Post +// #define FN_IndexOfEdict_Post IndexOfEdict_Post +// #define FN_PEntityOfEntIndex_Post PEntityOfEntIndex_Post +// #define FN_FindEntityByVars_Post FindEntityByVars_Post +// #define FN_GetModelPtr_Post GetModelPtr_Post +#define FN_RegUserMsg_Post RegUserMsg_Post +// #define FN_AnimationAutomove_Post AnimationAutomove_Post +// #define FN_GetBonePosition_Post GetBonePosition_Post +// #define FN_FunctionFromName_Post FunctionFromName_Post +// #define FN_NameForFunction_Post NameForFunction_Post +// #define FN_ClientPrintf_Post ClientPrintf_Post +// #define FN_ServerPrint_Post ServerPrint_Post +// #define FN_Cmd_Args_Post Cmd_Args_Post +// #define FN_Cmd_Argv_Post Cmd_Argv_Post +// #define FN_Cmd_Argc_Post Cmd_Argc_Post +// #define FN_GetAttachment_Post GetAttachment_Post +// #define FN_CRC32_Init_Post CRC32_Init_Post +// #define FN_CRC32_ProcessBuffer_Post CRC32_ProcessBuffer_Post +// #define FN_CRC32_ProcessByte_Post CRC32_ProcessByte_Post +// #define FN_CRC32_Final_Post CRC32_Final_Post +// #define FN_RandomLong_Post RandomLong_Post +// #define FN_RandomFloat_Post RandomFloat_Post +// #define FN_SetView_Post SetView_Post +// #define FN_Time_Post Time_Post +// #define FN_CrosshairAngle_Post CrosshairAngle_Post +// #define FN_LoadFileForMe_Post LoadFileForMe_Post +// #define FN_FreeFile_Post FreeFile_Post +// #define FN_EndSection_Post EndSection_Post +// #define FN_CompareFileTime_Post CompareFileTime_Post +// #define FN_GetGameDir_Post GetGameDir_Post +// #define FN_Cvar_RegisterVariable_Post Cvar_RegisterVariable_Post +// #define FN_FadeClientVolume_Post FadeClientVolume_Post +// #define FN_SetClientMaxspeed_Post SetClientMaxspeed_Post +// #define FN_CreateFakeClient_Post CreateFakeClient_Post +// #define FN_RunPlayerMove_Post RunPlayerMove_Post +// #define FN_NumberOfEntities_Post NumberOfEntities_Post +// #define FN_GetInfoKeyBuffer_Post GetInfoKeyBuffer_Post +// #define FN_InfoKeyValue_Post InfoKeyValue_Post +// #define FN_SetKeyValue_Post SetKeyValue_Post +// #define FN_SetClientKeyValue_Post SetClientKeyValue_Post +// #define FN_IsMapValid_Post IsMapValid_Post +// #define FN_StaticDecal_Post StaticDecal_Post +// #define FN_PrecacheGeneric_Post PrecacheGeneric_Post +// #define FN_GetPlayerUserId_Post GetPlayerUserId_Post +// #define FN_BuildSoundMsg_Post BuildSoundMsg_Post +// #define FN_IsDedicatedServer_Post IsDedicatedServer_Post +// #define FN_CVarGetPointer_Post CVarGetPointer_Post +// #define FN_GetPlayerWONId_Post GetPlayerWONId_Post +// #define FN_Info_RemoveKey_Post Info_RemoveKey_Post +// #define FN_GetPhysicsKeyValue_Post GetPhysicsKeyValue_Post +// #define FN_SetPhysicsKeyValue_Post SetPhysicsKeyValue_Post +// #define FN_GetPhysicsInfoString_Post GetPhysicsInfoString_Post +// #define FN_PrecacheEvent_Post PrecacheEvent_Post +// #define FN_PlaybackEvent_Post PlaybackEvent_Post +// #define FN_SetFatPVS_Post SetFatPVS_Post +// #define FN_SetFatPAS_Post SetFatPAS_Post +// #define FN_CheckVisibility_Post CheckVisibility_Post +// #define FN_DeltaSetField_Post DeltaSetField_Post +// #define FN_DeltaUnsetField_Post DeltaUnsetField_Post +// #define FN_DeltaAddEncoder_Post DeltaAddEncoder_Post +// #define FN_GetCurrentPlayer_Post GetCurrentPlayer_Post +// #define FN_CanSkipPlayer_Post CanSkipPlayer_Post +// #define FN_DeltaFindField_Post DeltaFindField_Post +// #define FN_DeltaSetFieldByIndex_Post DeltaSetFieldByIndex_Post +// #define FN_DeltaUnsetFieldByIndex_Post DeltaUnsetFieldByIndex_Post +// #define FN_SetGroupMask_Post SetGroupMask_Post +// #define FN_engCreateInstancedBaseline_Post engCreateInstancedBaseline_Post +// #define FN_Cvar_DirectSet_Post Cvar_DirectSet_Post +// #define FN_ForceUnmodified_Post ForceUnmodified_Post +// #define FN_GetPlayerStats_Post GetPlayerStats_Post +// #define FN_AddServerCommand_Post AddServerCommand_Post +// #define FN_Voice_GetClientListening_Post Voice_GetClientListening_Post +// #define FN_Voice_SetClientListening_Post Voice_SetClientListening_Post +// #define FN_GetPlayerAuthId_Post GetPlayerAuthId_Post + +// #define FN_OnFreeEntPrivateData OnFreeEntPrivateData +// #define FN_GameShutdown GameShutdown +// #define FN_ShouldCollide ShouldCollide + +// #define FN_OnFreeEntPrivateData_Post OnFreeEntPrivateData_Post +// #define FN_GameShutdown_Post GameShutdown_Post +// #define FN_ShouldCollide_Post ShouldCollide_Post + + +#endif // USE_METAMOD + +#endif // __MODULECONFIG_H__ \ No newline at end of file diff --git a/dlls/csx_sql/msvc/csx.sln b/dlls/csx_sql/msvc/csx.sln new file mode 100755 index 00000000..433753c0 --- /dev/null +++ b/dlls/csx_sql/msvc/csx.sln @@ -0,0 +1,21 @@ +Microsoft Visual Studio Solution File, Format Version 8.00 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "csx", "csx.vcproj", "{1DC4A99A-F23F-4AAE-881C-79D157C91155}" + ProjectSection(ProjectDependencies) = postProject + EndProjectSection +EndProject +Global + GlobalSection(SolutionConfiguration) = preSolution + Debug = Debug + Release = Release + EndGlobalSection + GlobalSection(ProjectConfiguration) = postSolution + {1DC4A99A-F23F-4AAE-881C-79D157C91155}.Debug.ActiveCfg = Debug|Win32 + {1DC4A99A-F23F-4AAE-881C-79D157C91155}.Debug.Build.0 = Debug|Win32 + {1DC4A99A-F23F-4AAE-881C-79D157C91155}.Release.ActiveCfg = Release|Win32 + {1DC4A99A-F23F-4AAE-881C-79D157C91155}.Release.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + EndGlobalSection + GlobalSection(ExtensibilityAddIns) = postSolution + EndGlobalSection +EndGlobal diff --git a/dlls/csx_sql/msvc/csx.suo b/dlls/csx_sql/msvc/csx.suo new file mode 100755 index 0000000000000000000000000000000000000000..a394b92a24b266b54c9694ed160bccf9785e3957 GIT binary patch literal 13312 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 literal 0 HcmV?d00001 diff --git a/dlls/csx_sql/msvc/csx.vcproj b/dlls/csx_sql/msvc/csx.vcproj new file mode 100755 index 00000000..9f4f1463 --- /dev/null +++ b/dlls/csx_sql/msvc/csx.vcproj @@ -0,0 +1,489 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/dlls/csx_sql/rank.cpp b/dlls/csx_sql/rank.cpp new file mode 100755 index 00000000..61d6e735 --- /dev/null +++ b/dlls/csx_sql/rank.cpp @@ -0,0 +1,397 @@ + + +#include "amxxmodule.h" +#include "rank.h" + + +static cell AMX_NATIVE_CALL get_user_astats(AMX *amx, cell *params) /* 6 param */ +{ + int index = params[1]; + CHECK_PLAYERRANGE(index); + int attacker = params[2]; + CHECK_PLAYERRANGE(attacker); + CPlayer* pPlayer = GET_PLAYER_POINTER_I(index); + if (pPlayer->attackers[attacker].hits){ + cell *cpStats = MF_GetAmxAddr(amx,params[3]); + cell *cpBodyHits = MF_GetAmxAddr(amx,params[4]); + CPlayer::PlayerWeapon* stats = &pPlayer->attackers[attacker]; + cpStats[0] = stats->kills; + cpStats[1] = stats->deaths; + cpStats[2] = stats->hs; + cpStats[3] = stats->tks; + cpStats[4] = stats->shots; + cpStats[5] = stats->hits; + cpStats[6] = stats->damage; + for(int i = 1; i < 8; ++i) + cpBodyHits[i] = stats->bodyHits[i]; + if (params[6] && attacker && stats->name ) + MF_SetAmxString(amx,params[5],stats->name,params[6]); + return 1; + } + return 0; +} + +static cell AMX_NATIVE_CALL get_user_vstats(AMX *amx, cell *params) /* 6 param */ +{ + int index = params[1]; + CHECK_PLAYERRANGE(index); + int victim = params[2]; + CHECK_PLAYERRANGE(victim); + CPlayer* pPlayer = GET_PLAYER_POINTER_I(index); + if (pPlayer->victims[victim].hits){ + cell *cpStats = MF_GetAmxAddr(amx,params[3]); + cell *cpBodyHits = MF_GetAmxAddr(amx,params[4]); + CPlayer::PlayerWeapon* stats = &pPlayer->victims[victim]; + cpStats[0] = stats->kills; + cpStats[1] = stats->deaths; + cpStats[2] = stats->hs; + cpStats[3] = stats->tks; + cpStats[4] = stats->shots; + cpStats[5] = stats->hits; + cpStats[6] = stats->damage; + for(int i = 1; i < 8; ++i) + cpBodyHits[i] = stats->bodyHits[i]; + if (params[6] && victim && stats->name) + MF_SetAmxString(amx,params[5],stats->name,params[6]); + return 1; + } + return 0; +} + +static cell AMX_NATIVE_CALL get_user_wrstats(AMX *amx, cell *params) /* 4 param */ // DEC-Weapon (round) stats (end) +{ + int index = params[1]; + CHECK_PLAYERRANGE(index); + int weapon = params[2]; + if (weapon<0||weapon>=MAX_WEAPONS+MAX_CWEAPONS){ + MF_LogError(amx, AMX_ERR_NATIVE, "Invalid weapon id %d", weapon); + return 0; + } + CPlayer* pPlayer = GET_PLAYER_POINTER_I(index); + if (pPlayer->weaponsRnd[weapon].shots){ + cell *cpStats = MF_GetAmxAddr(amx,params[3]); + cell *cpBodyHits = MF_GetAmxAddr(amx,params[4]); + Stats* stats = &pPlayer->weaponsRnd[weapon]; + cpStats[0] = stats->kills; + cpStats[1] = stats->deaths; + cpStats[2] = stats->hs; + cpStats[3] = stats->tks; + cpStats[4] = stats->shots; + cpStats[5] = stats->hits; + cpStats[6] = stats->damage; + for(int i = 1; i < 8; ++i) + cpBodyHits[i] = stats->bodyHits[i]; + return 1; + } + return 0; +} + +static cell AMX_NATIVE_CALL get_user_wstats(AMX *amx, cell *params) /* 4 param */ +{ + int index = params[1]; + CHECK_PLAYERRANGE(index); + int weapon = params[2]; + if (weapon<0||weapon>=MAX_WEAPONS+MAX_CWEAPONS){ + MF_LogError(amx, AMX_ERR_NATIVE, "Invalid weapon id %d", weapon); + return 0; + } + CPlayer* pPlayer = GET_PLAYER_POINTER_I(index); + if (pPlayer->weapons[weapon].shots){ + cell *cpStats = MF_GetAmxAddr(amx,params[3]); + cell *cpBodyHits = MF_GetAmxAddr(amx,params[4]); + CPlayer::PlayerWeapon* stats = &pPlayer->weapons[weapon]; + cpStats[0] = stats->kills; + cpStats[1] = stats->deaths; + cpStats[2] = stats->hs; + cpStats[3] = stats->tks; + cpStats[4] = stats->shots; + cpStats[5] = stats->hits; + cpStats[6] = stats->damage; + for(int i = 1; i < 8; ++i) + cpBodyHits[i] = stats->bodyHits[i]; + return 1; + } + return 0; +} + +static cell AMX_NATIVE_CALL reset_user_wstats(AMX *amx, cell *params) /* 6 param */ +{ + int index = params[1]; + CHECK_PLAYER(index); + GET_PLAYER_POINTER_I(index)->restartStats(); + return 1; +} + +static cell AMX_NATIVE_CALL get_user_rstats(AMX *amx, cell *params) /* 3 param */ +{ + int index = params[1]; + CHECK_PLAYERRANGE(index); + CPlayer* pPlayer = GET_PLAYER_POINTER_I(index); + if (pPlayer->rank){ + cell *cpStats = MF_GetAmxAddr(amx,params[2]); + cell *cpBodyHits = MF_GetAmxAddr(amx,params[3]); + cpStats[0] = pPlayer->life.kills; + cpStats[1] = pPlayer->life.deaths; + cpStats[2] = pPlayer->life.hs; + cpStats[3] = pPlayer->life.tks; + cpStats[4] = pPlayer->life.shots; + cpStats[5] = pPlayer->life.hits; + cpStats[6] = pPlayer->life.damage; + for(int i = 1; i < 8; ++i) + cpBodyHits[i] = pPlayer->life.bodyHits[i]; + return 1; + } + return 0; +} + +static cell AMX_NATIVE_CALL get_user_stats(AMX *amx, cell *params) /* 3 param */ +{ + int index = params[1]; + CHECK_PLAYERRANGE(index); + CPlayer* pPlayer = GET_PLAYER_POINTER_I(index); + if ( pPlayer->rank ){ + cell *cpStats = MF_GetAmxAddr(amx,params[2]); + cell *cpBodyHits = MF_GetAmxAddr(amx,params[3]); + cpStats[0] = pPlayer->rank->kills; + cpStats[1] = pPlayer->rank->deaths; + cpStats[2] = pPlayer->rank->hs; + cpStats[3] = pPlayer->rank->tks; + cpStats[4] = pPlayer->rank->shots; + cpStats[5] = pPlayer->rank->hits; + cpStats[6] = pPlayer->rank->damage; + + cpStats[7] = pPlayer->rank->getPosition(); + + for(int i = 1; i < 8; ++i) + cpBodyHits[i] = pPlayer->rank->bodyHits[i]; + return pPlayer->rank->getPosition(); + } + return 0; + +} + +static cell AMX_NATIVE_CALL get_user_stats2(AMX *amx, cell *params) /* 3 param */ +{ + int index = params[1]; + CHECK_PLAYERRANGE(index); + CPlayer* pPlayer = GET_PLAYER_POINTER_I(index); + if ( pPlayer->rank ){ + cell *cpStats = MF_GetAmxAddr(amx,params[2]); + + cpStats[0] = pPlayer->rank->bDefusions; + cpStats[1] = pPlayer->rank->bDefused; + cpStats[2] = pPlayer->rank->bPlants; + cpStats[3] = pPlayer->rank->bExplosions; + + return pPlayer->rank->getPosition(); + } + return 0; +} + +static cell AMX_NATIVE_CALL get_stats(AMX *amx, cell *params) /* 3 param */ +{ + + int index = params[1] + 1; + + for(RankSystem::iterator a = g_rank.front(); a ;--a){ + if ((*a).getPosition() == index) { + cell *cpStats = MF_GetAmxAddr(amx,params[2]); + cell *cpBodyHits = MF_GetAmxAddr(amx,params[3]); + cpStats[0] = (*a).kills; + cpStats[1] = (*a).deaths; + cpStats[2] = (*a).hs; + cpStats[3] = (*a).tks; + cpStats[4] = (*a).shots; + cpStats[5] = (*a).hits; + cpStats[6] = (*a).damage; + + cpStats[7] = (*a).getPosition(); + + MF_SetAmxString(amx,params[4],(*a).getName(),params[5]); + for(int i = 1; i < 8; ++i) + cpBodyHits[i] = (*a).bodyHits[i]; + return --a ? index : 0; + } + } + + return 0; +} + +static cell AMX_NATIVE_CALL get_stats2(AMX *amx, cell *params) /* 3 param */ +{ + + int index = params[1] + 1; + + for(RankSystem::iterator a = g_rank.front(); a ;--a){ + if ((*a).getPosition() == index) { + cell *cpStats = MF_GetAmxAddr(amx,params[2]); + + cpStats[0] = (*a).bDefusions; + cpStats[1] = (*a).bDefused; + cpStats[2] = (*a).bPlants; + cpStats[3] = (*a).bExplosions; + + return --a ? index : 0; + } + } + + return 0; +} + +static cell AMX_NATIVE_CALL get_statsnum(AMX *amx, cell *params) +{ + return g_rank.getRankNum(); +} + +static cell AMX_NATIVE_CALL register_cwpn(AMX *amx, cell *params){ // name,melee=0,logname + int i,iLen; + for ( i=MAX_WEAPONS;i= MAX_WEAPONS+MAX_CWEAPONS || !weaponData[weapon].used ){ // only for custom weapons + MF_LogError(amx, AMX_ERR_NATIVE, "Invalid weapon id %d", weapon); + return 0; + } + + int att = params[2]; + CHECK_PLAYERRANGE(att); + + int vic = params[3]; + CHECK_PLAYERRANGE(vic); + + int dmg = params[4]; + if ( dmg<1 ){ + MF_LogError(amx, AMX_ERR_NATIVE, "Invalid damage %d", dmg); + return 0; + } + + int aim = params[5]; + if ( aim < 0 || aim > 7 ){ + MF_LogError(amx, AMX_ERR_NATIVE, "Invalid aim %d", aim); + return 0; + } + + CPlayer* pAtt = GET_PLAYER_POINTER_I(att); + CPlayer* pVic = GET_PLAYER_POINTER_I(vic); + + pVic->pEdict->v.dmg_inflictor = NULL; + pAtt->saveHit( pVic , weapon , dmg, aim ); + + if ( !pAtt ) pAtt = pVic; + int TA = 0; + if ( (pVic->teamId == pAtt->teamId) && ( pVic != pAtt) ) + TA = 1; + MF_ExecuteForward( iFDamage,pAtt->index, pVic->index, dmg, weapon, aim, TA ); + + if ( pVic->IsAlive() ) + return 1; + + pAtt->saveKill(pVic,weapon,( aim == 1 ) ? 1:0 ,TA); + MF_ExecuteForward( iFDeath,pAtt->index, pVic->index, weapon, aim, TA ); + + return 1; +} + +static cell AMX_NATIVE_CALL custom_wpn_shot(AMX *amx, cell *params){ // player,wid + int index = params[2]; + CHECK_PLAYERRANGE(index); + + int weapon = params[1]; + if ( weapon < MAX_WEAPONS || weapon >= MAX_WEAPONS+MAX_CWEAPONS || !weaponData[weapon].used ){ + MF_LogError(amx, AMX_ERR_NATIVE, "Invalid weapon id %d", weapon); + return 0; + } + + CPlayer* pPlayer = GET_PLAYER_POINTER_I(index); + pPlayer->saveShot(weapon); + + return 1; +} + +static cell AMX_NATIVE_CALL get_wpnname(AMX *amx, cell *params){ + int id = params[1]; + if (id<1 || id>=MAX_WEAPONS+MAX_CWEAPONS ){ + MF_LogError(amx, AMX_ERR_NATIVE, "Invalid weapon id %d", id); + return 0; + } + return MF_SetAmxString(amx,params[2],weaponData[id].name,params[3]); +} + +static cell AMX_NATIVE_CALL get_wpnlogname(AMX *amx, cell *params){ + int id = params[1]; + if (id<1 || id>=MAX_WEAPONS+MAX_CWEAPONS ){ + MF_LogError(amx, AMX_ERR_NATIVE, "Invalid weapon id %d", id); + return 0; + } + return MF_SetAmxString(amx,params[2],weaponData[id].logname,params[3]); +} + +static cell AMX_NATIVE_CALL is_melee(AMX *amx, cell *params){ + int id = params[1]; + if (id<1 || id>=MAX_WEAPONS+MAX_CWEAPONS ){ + MF_LogError(amx, AMX_ERR_NATIVE, "Invalid weapon id %d", id); + return 0; + } + if ( id == 29 ) + return 1; + return weaponData[id].melee ? 1:0; +} + +static cell AMX_NATIVE_CALL get_maxweapons(AMX *amx, cell *params){ + return MAX_WEAPONS+MAX_CWEAPONS; +} + +static cell AMX_NATIVE_CALL get_stats_size(AMX *amx, cell *params){ + return 8; +} + +AMX_NATIVE_INFO stats_Natives[] = { + { "get_stats", get_stats}, + { "get_stats2", get_stats2}, + { "get_statsnum", get_statsnum}, + { "get_user_astats", get_user_astats }, + { "get_user_rstats", get_user_rstats }, + { "get_user_lstats", get_user_rstats }, // for backward compatibility + { "get_user_stats", get_user_stats }, + { "get_user_stats2", get_user_stats2 }, + { "get_user_vstats", get_user_vstats }, + { "get_user_wrstats", get_user_wrstats}, // DEC-Weapon(Round) Stats + { "get_user_wstats", get_user_wstats}, + { "reset_user_wstats", reset_user_wstats }, + + // Custom Weapon Support + { "custom_weapon_add", register_cwpn }, + { "custom_weapon_dmg", custom_wpn_dmg }, + { "custom_weapon_shot", custom_wpn_shot }, + + { "xmod_get_wpnname", get_wpnname }, + { "xmod_get_wpnlogname", get_wpnlogname }, + { "xmod_is_melee_wpn", is_melee }, + { "xmod_get_maxweapons", get_maxweapons }, + { "xmod_get_stats_size", get_stats_size }, + + //*************************************** + //{ "get_weaponname", get_wpnname }, + + ///******************* + { NULL, NULL } +}; + diff --git a/dlls/csx_sql/rank.h b/dlls/csx_sql/rank.h new file mode 100755 index 00000000..62db6cf5 --- /dev/null +++ b/dlls/csx_sql/rank.h @@ -0,0 +1,152 @@ +#ifndef RANK_H +#define RANK_H + +#include "amxxmodule.h" +#include "CMisc.h" +#include "CRank.h" + +#define GET_PLAYER_POINTER(e) (&players[ENTINDEX(e)]) +#define GET_PLAYER_POINTER_I(i) (&players[i]) + +extern AMX_NATIVE_INFO stats_Natives[]; + +struct weaponsVault { + char name[32]; + char logname[16]; + short int ammoSlot; + bool used; + bool melee; +}; + +extern bool rankBots; +extern cvar_t* csstats_rankbots; +extern cvar_t* csstats_pause; + +extern int iFGrenade; +extern int iFDeath; +extern int iFDamage; + +extern int iFBPlanted; +extern int iFBDefused; +extern int iFBPlanting; +extern int iFBDefusing; +extern int iFBExplode; + +extern int g_bombAnnounce; +extern int g_Planter; +extern int g_Defuser; + +#define BOMB_PLANTING 1 +#define BOMB_PLANTED 2 +#define BOMB_EXPLODE 3 +#define BOMB_DEFUSING 4 +#define BOMB_DEFUSED 5 + +extern weaponsVault weaponData[MAX_WEAPONS+MAX_CWEAPONS]; + +typedef void (*funEventCall)(void*); +extern funEventCall modMsgsEnd[MAX_REG_MSGS]; +extern funEventCall modMsgs[MAX_REG_MSGS]; + +extern void (*function)(void*); +extern void (*endfunction)(void*); + +extern cvar_t *csstats_maxsize; +extern cvar_t* csstats_rank; +extern cvar_t* csstats_reset; + +extern Grenades g_grenades; + +extern RankSystem g_rank; + +extern CPlayer players[33]; + +extern CPlayer* mPlayer; + +extern int mPlayerIndex; + +extern int mState; + +extern int gmsgCurWeapon; +extern int gmsgDamageEnd; +extern int gmsgDamage; +extern int gmsgWeaponList; +extern int gmsgResetHUD; +extern int gmsgAmmoX; +extern int gmsgScoreInfo; +extern int gmsgAmmoPickup; + +extern int gmsgSendAudio; +extern int gmsgTextMsg; +extern int gmsgBarTime; + +void Client_AmmoX(void*); +void Client_CurWeapon(void*); +void Client_Damage(void*); +void Client_WeaponList(void*); +void Client_AmmoPickup(void*); +void Client_Damage_End(void*); +void Client_ScoreInfo(void*); +void Client_ResetHUD(void*); + +void Client_SendAudio(void*); +void Client_TextMsg(void*); +void Client_BarTime(void*); + +bool ignoreBots (edict_t *pEnt, edict_t *pOther = NULL ); +bool isModuleActive(); + +#define CHECK_ENTITY(x) \ + if (x < 0 || x > gpGlobals->maxEntities) { \ + MF_LogError(amx, AMX_ERR_NATIVE, "Entity out of range (%d)", x); \ + return 0; \ + } else { \ + if (x <= gpGlobals->maxClients) { \ + if (!MF_IsPlayerIngame(x)) { \ + MF_LogError(amx, AMX_ERR_NATIVE, "Invalid player %d (not in-game)", x); \ + return 0; \ + } \ + } else { \ + if (x != 0 && FNullEnt(INDEXENT(x))) { \ + MF_LogError(amx, AMX_ERR_NATIVE, "Invalid entity %d", x); \ + return 0; \ + } \ + } \ + } + +#define CHECK_PLAYER(x) \ + if (x < 1 || x > gpGlobals->maxClients) { \ + MF_LogError(amx, AMX_ERR_NATIVE, "Player out of range (%d)", x); \ + return 0; \ + } else { \ + if (!MF_IsPlayerIngame(x) || FNullEnt(MF_GetPlayerEdict(x))) { \ + MF_LogError(amx, AMX_ERR_NATIVE, "Invalid player %d", x); \ + return 0; \ + } \ + } + +#define CHECK_PLAYERRANGE(x) \ + if (x > gpGlobals->maxClients || x < 0) \ + { \ + MF_LogError(amx, AMX_ERR_NATIVE, "Player out of range (%d)", x); \ + return 0; \ + } + +#define CHECK_NONPLAYER(x) \ + if (x < 1 || x <= gpGlobals->maxClients || x > gpGlobals->maxEntities) { \ + MF_LogError(amx, AMX_ERR_NATIVE, "Non-player entity %d out of range", x); \ + return 0; \ + } else { \ + if (FNullEnt(INDEXENT(x))) { \ + MF_LogError(amx, AMX_ERR_NATIVE, "Invalid non-player entity %d", x); \ + return 0; \ + } \ + } + +#define GETEDICT(n) \ + ((n >= 1 && n <= gpGlobals->maxClients) ? MF_GetPlayerEdict(n) : INDEXENT(n)) + +#endif // RANK_H + + + diff --git a/dlls/csx_sql/usermsg.cpp b/dlls/csx_sql/usermsg.cpp new file mode 100755 index 00000000..a8103ffb --- /dev/null +++ b/dlls/csx_sql/usermsg.cpp @@ -0,0 +1,217 @@ +#include "amxxmodule.h" +#include "rank.h" + +weaponsVault weaponData[MAX_WEAPONS+MAX_CWEAPONS]; + +int damage; +int TA; +int weapon; +int aim; +bool ignore; +CPlayer *pAttacker; + + +void Client_ResetHUD(void* mValue){ + if ( mPlayer ){ + mPlayer->clearStats = gpGlobals->time + 0.25f; + } +} + +void Client_WeaponList(void* mValue){ + static int wpnList; + static int iSlot; + static const char* wpnName; + + switch (mState++) { + case 0: + wpnName = (const char*)mValue; + break; + case 1: + iSlot = *(int*)mValue; + break; + case 7: + int iId = *(int*)mValue; + if ( (iId < 0 || iId >= MAX_WEAPONS ) || ( wpnList & (1<pEdict->v.dmg_inflictor; + + if ( FNullEnt( enemy ) ){ + ignore = true; + break; + } + + aim = 0; + weapon = 0; + pAttacker = NULL; + + if (enemy->v.flags & (FL_CLIENT | FL_FAKECLIENT) ) { + pAttacker = GET_PLAYER_POINTER(enemy); + aim = pAttacker->aiming; + weapon = pAttacker->current; + pAttacker->saveHit( mPlayer , weapon , damage, aim); + break; + } + if( g_grenades.find(enemy , &pAttacker , &weapon ) ) + pAttacker->saveHit( mPlayer , weapon , damage, aim ); + else if ( strcmp("grenade",STRING(enemy->v.classname))==0 ) // ? more checks ? + weapon = CSW_C4; + } +} + +void Client_Damage_End(void* mValue){ + if ( ignore ) + return; + + if ( !pAttacker ) pAttacker = mPlayer; + TA = 0; + if ( (mPlayer->teamId == pAttacker->teamId) && (mPlayer != pAttacker) ) + TA = 1; + + MF_ExecuteForward( iFDamage,pAttacker->index , mPlayer->index , damage, weapon, aim, TA ); + + if ( !mPlayer->IsAlive() ){ + if ( weapon != CSW_C4 ) + pAttacker->saveKill(mPlayer,weapon,( aim == 1 ) ? 1:0 ,TA); + MF_ExecuteForward( iFDeath,pAttacker->index, mPlayer->index, weapon, aim, TA ); + } +} + +void Client_CurWeapon(void* mValue){ + static int iState; + static int iId; + switch (mState++){ + case 0: + iState = *(int*)mValue; + break; + case 1: + if (!iState) break; + iId = *(int*)mValue; + break; + case 2: + if (!mPlayer || !iState ) break; + int iClip = *(int*)mValue; + if ((iClip > -1) && (iClip < mPlayer->weapons[iId].clip)) + mPlayer->saveShot(iId); + mPlayer->weapons[iId].clip = iClip; + mPlayer->current = iId; + } +} + +void Client_AmmoX(void* mValue){ + static int iAmmo; + switch (mState++){ + case 0: + iAmmo = *(int*)mValue; + break; + case 1: + if (!mPlayer ) break; + for(int i = 1; i < MAX_WEAPONS ; ++i) + if (iAmmo == weaponData[i].ammoSlot) + mPlayer->weapons[i].ammo = *(int*)mValue; + } +} + +void Client_AmmoPickup(void* mValue){ + static int iSlot; + switch (mState++){ + case 0: + iSlot = *(int*)mValue; + break; + case 1: + if (!mPlayer ) break; + for(int i = 1; i < MAX_WEAPONS ; ++i) + if (weaponData[i].ammoSlot == iSlot) + mPlayer->weapons[i].ammo += *(int*)mValue; + } +} + +void Client_ScoreInfo(void* mValue){ + static int index; + switch (mState++){ + case 0: + index = *(int*)mValue; + break; + case 4: + if ( index > 0 && index <= gpGlobals->maxClients ) + GET_PLAYER_POINTER_I( index )->teamId = *(int*)mValue; + } +} + +void Client_SendAudio(void* mValue){ + static const char* szText; + if ( mState == 1 ){ + szText = (const char*)mValue; + if ( !mPlayer && szText[7]=='B' ) { + if ( szText[11]=='P' && g_Planter ){ + GET_PLAYER_POINTER_I(g_Planter)->saveBPlant(); + g_bombAnnounce = BOMB_PLANTED; + } + else if ( szText[11]=='D' && g_Defuser ){ + GET_PLAYER_POINTER_I(g_Defuser)->saveBDefused(); + g_bombAnnounce = BOMB_DEFUSED; + } + + } + } + mState++; +} + +void Client_TextMsg(void* mValue){ + static const char* szText; + if ( !mPlayer && mState==1 ){ + szText = (const char*)mValue; + if ( szText[1]=='T' && szText[8]=='B' && g_Planter ){ + GET_PLAYER_POINTER_I(g_Planter)->saveBExplode(); + g_bombAnnounce = BOMB_EXPLODE; + } + } + mState++; +} + +void Client_BarTime(void* mValue){ + int iTime = *(int*)mValue; + if ( !iTime || !mPlayer->IsAlive() ) return; + if ( iTime == 3 ){ + g_Planter = mPlayerIndex; + g_bombAnnounce = BOMB_PLANTING; + g_Defuser = 0; + } + else { + mPlayer->saveBDefusing(); + g_Defuser = mPlayerIndex; + g_bombAnnounce = BOMB_DEFUSING; + } +} +