🚀 go-pugleaf

Thanks Remy, I'll try to give this a go later.

And yes, I want the DLL to be accessible from BCB or VC++.  I achieved this 
with the AidAim CryptoPress component this month.

Paul

"Remy Lebeau (TeamB)" <no.spam@no.spam.com> wrote in message 
news:44285b69$1@newsgroups.borland.com...
>
> "Paul" <plmacca@clara.co.uk> wrote in message
> news:4428309f@newsgroups.borland.com...
>
> I suggest you get rid of that and use the WINAPI macro instead.  Tha is 
> how
> DllEntryPoint() and DllMain() arte meant to be used, ie:
>
>    BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fwdreason, LPVOID
> lpvReserved)
>
> Now, with that said, BCB DLLs use DllEntryPoint() by default, not 
> DllMain().
> Are you trying to create a VC++ style DLL?
>
>> #ifdef CTS_BCB_DLL_STDCALL
>> unsigned long   __stdcall
>> #else
>> unsigned long   __cdecl
>> #endif
>> CtsSysLogCreate ( const char *        In_ServerAddress,
>>                   const unsigned long In_ServerPort,
>>                   void**              Out_ClientHandle )
>
> I strongly suggest that you __stdcall for all of your functions
> unconditionally.  The only time you should ever use __cdecl is when you 
> need
> to use variable-length parameter lists via the '...' keyword, which you 
> are
> not using.  Besides, not all environments support __cdecl anyway, so if 
> you
> want your DLL to be portable then you should always use __stdcall.
>
> I suggest that you use this code instead (untested):
>
>    TThreadList *SysLogs = NULL;
>
>    BOOL WINAPI DllEntryPoint(HINSTANCE hinstDLL, DWORD fwdreason, LPVOID
> lpvReserved)
>    {
>        switch( fwdreason )
>        {
>            case DLL_PROCESS_ATTACH:
>            {
>                SysLogs = NULL;
>                try
>                {
>                    SysLogs = new TThreadList;
>                }
>                catch (const Exception &) {}
>                catch (...) {}
>
>                if( !SysLogs )
>                    return FALSE;
>
>                break;
>            }
>
>            case DLL_PROCESS_DETACH:
>            {
>                if( SysLogs != NULL )
>                {
>                    TList *Logs = SysLogs->LockList();
>                    try
>                    {
>                        for(int i = 0; i < Logs->Count; ++i)
>                            delete static_cast<TIdSysLog*>(Logs->Items[i]);
>                        Logs->Clear();
>                    }
>                    __finally
>                    {
>                        SysLogs->UnlockList();
>                    }
>
>                    delete SysLogs;
>                    SysLogs = NULL;
>                }
>
>                break;
>            }
>        }
>
>        return TRUE;
>    }
>
>    ULONG __stdcall CtsSysLogCreate(const char* In_ServerAddress, const
> USHORT In_ServerPort, void** Out_ClientHandle)
>    {
>        if( (!strlen(In_ServerAddress)) || (!In_ServerPort) ||
> (!Out_ClientHandle) || IsBadWritePtr(*Out_ClientHandle, sizeof(void*) )
>            return CTSSYSLOG_RESULT_PARAMETER_INVALID;
>
>        try
>        {
>            *Out_ClientHandle = NULL;
>
>            TIdSysLog* IdSysLog = new TIdSysLog(NULL);
>            try
>            {
>                IdSysLog->Host = In_ServerAddress;
>                IdSysLog->Port = In_ServerPort;
>                SysLogs->Add(IdSysLog);
>
>                // no need to set the Active property here.  All that does
> is
>                // ensures that the TIdSysLog's Binding property has a 
> valid
>                // TIdSocketHandle available.  When TIdSysLog::SendMsg()
>                // is called later, it does the same thing anyway, so it is
> redundant
>                // to activate the TIdSysLog at this time...
>
>                *Out_ClientHandle = IdSysLog;
>            }
>            catch(const Exception &)
>            {
>                delete IdSysLog;
>                IdSysLog = NULL;
>                throw;
>            }
>
>            return CTSSYSLOG_RESULT_OK;
>        }
>        catch (const Exception &) {}
>        catch (...) {}
>
>        return CTSSYSLOG_RESULT_UNKNOWN_EXCEPTION;
>    }
>
>    ULONG __stdcall CtsSysLogDestroy(void* In_ClientHandle)
>    {
>        try
>        {
>            TIdSysLog *IdSysLog = static_cast<TIdSysLog*>(In_ClientHandle);
>            bool Found = false;
>
>            TList *Logs = SysLogs->LockList();
>            try
>            {
>                if( List->Remove(IdSysLog) > -1 )
>                {
>                    Found = true;
>                    delete IdSysLog;
>                }
>            }
>            __finally
>            {
>                SysLogs->UnlockList();
>            }
>
>            return Found ? CTSSYSLOG_RESULT_OK :
> CTSSYSLOG_RESULT_INVALID_PARAM;
>        }
>        catch (const Exception &) {}
>        catch (...) {}
>
>        return CTSSYSLOG_RESULT_UNKNOWN_EXCEPTION;
>    }
>
>    TIdSyslogSeverity GetSeverity(const ULONG In_Severity)
>    {
>        switch( In_Severity )
>        {
>            case CTS_SYSLOG_slEmergency:
>                return slEmergency;
>
>            case CTS_SYSLOG_slAlert:
>                return slAlert;
>
>            case CTS_SYSLOG_slCritical:
>                return slCritical;
>
>            case CTS_SYSLOG_slError:
>                return slError;
>
>            case CTS_SYSLOG_slWarning:
>                return slWarning;
>
>            case CTS_SYSLOG_slNotice:
>                return slNotice;
>
>            case CTS_SYSLOG_slInformational:
>                return slInformational;
>
>            case CTS_SYSLOG_slDebug:
>            default:
>                return slDebug;
>        }
>    }
>
>    TIdSyslogFacility  GetFacility(const ULONG In_Facility)
>    {
>        switch( In_Facility )
>        {
>            case CTS_SYSLOG_sfKernel:
>                return sfKernel;
>
>            case CTS_SYSLOG_sfMailSystem:
>                return sfMailSystem;
>
>            case CTS_SYSLOG_sfSystemDaemon:
>                return sfSystemDaemon;
>
>            case CTS_SYSLOG_sfClockDaemonOne:
>                return sfClockDaemonOne;
>
>            case CTS_SYSLOG_sfClockDaemonTwo:
>                return sfClockDaemonTwo;
>
>            case CTS_SYSLOG_sfFTPDaemon:
>                return sfFTPDaemon;
>
>            case CTS_SYSLOG_sfSecurityOne:
>                return sfSecurityOne;
>
>            case CTS_SYSLOG_sfSecurityTwo:
>                return sfSecurityTwo;
>
>            case CTS_SYSLOG_sfSysLogInternal:
>                return sfSysLogInternal;
>
>            case CTS_SYSLOG_sfLogAlert:
>                return sfLogAlert;
>
>            case CTS_SYSLOG_sfLPR:
>                return sfLPR;
>
>            case CTS_SYSLOG_sfNNTP:
>                return sfNNTP;
>
>            case CTS_SYSLOG_sfUUCP:
>                return sfUUCP;
>
>            case CTS_SYSLOG_sfNTP:
>                return sfNTP;
>
>            case CTS_SYSLOG_sfLocalUseZero:
>                return sfLocalUseZero;
>
>            case CTS_SYSLOG_sfLocalUseOne:
>                return sfLocalUseOne;
>
>            case CTS_SYSLOG_sfLocalUseTwo:
>                return sfLocalUseTwo;
>
>            case CTS_SYSLOG_sfLocalUseThree:
>                return sfLocalUseThree;
>
>            case CTS_SYSLOG_sfLocalUseFour:
>                return sfLocalUseFour;
>
>            case CTS_SYSLOG_sfLocalUseFive:
>                return sfLocalUseFive;
>
>            case CTS_SYSLOG_sfLocalUseSix:
>                return sfLocalUseSix;
>
>            case CTS_SYSLOG_sfLocalUseSeven:
>                return sfLocalUseSeven;
>
>            case CTS_SYSLOG_sfUserLevel:
>            default:
>                return sfUserLevel;
>        }
>    }
>
>    ULONG __stdcall CtsSysLogSend(void* In_ClientHandle, const ULONG
> In_Severity, const ULONG In_Facility, const char* In_Message)
>    {
>        try
>        {
>            TIdSysLog* IdSysLog = static_cast<TIdSysLog*>(In_ClientHandle);
>            bool Found = false;
>
>            TList *Logs = SysLogs->LockList();
>            try
>            {
>                if( List->IndexOf(IdSysLog) > -1 )
>                {
>                    Found = true;
>                    IdSysLog->SendMsg("TestApp", In_Message,
> GetFacility(In_Facility), GetSeverity(In_Severity), true; 1234);
>                }
>            }
>            __finally
>            {
>                SysLogs->UnlockList();
>            }
>
>            return Found ? CTSSYSLOG_RESULT_OK :
> CTSSYSLOG_RESULT_INVALID_PARAM;
>        }
>        catch (const Exception &) {}
>        catch (...) {}
>
>        return CTSSYSLOG_RESULT_UNKNOWN_EXCEPTION;
>    }
>
>
> Gambit
>
>