Subversion Repositories SmartDukaan

#include "plugin.h"
#include "tokenizer.h"

#ifdef _WINDOWS
#include <windows.h>
BOOL APIENTRY DllMain( HANDLE hModule,
                       DWORD ul_reason_for_call,
                       LPVOID lpReserved )
{
    return TRUE;
}
#else
#include <errno.h>
#include <string.h>

extern int errno;
#endif

SendPluginEv SendPluginEvent;

string g_GetSysErrMsg( void )
{
    string strError = "Unknown";
    // Problem loading
#ifdef _WINDOWS
    int nErrorCode = GetLastError();
    LPTSTR s;
    if ( ::FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
    NULL, nErrorCode, 0, ( LPTSTR ) &s, 0, NULL ) )
    {
        strError = s;
    }
    else
    {
        char szBuf[ 20 ];
        _snprintf_s( szBuf, _countof(szBuf), 19, "%d", nErrorCode );
        strError = szBuf;
    }
#else
    char szError[80];
    if ( strerror_r( errno, szError, sizeof(szError)  ) )
    {
        strError = "no description found";
    }
    else
    {
        strError = szError;
    }
#endif
    return strError;
}

void g_sleep( unsigned int mseconds )
{
#ifdef _WINDOWS
    Sleep( mseconds );
#else
    usleep( mseconds * 1000 );
#endif
}

string& g_trim( string& str )
{
    // Whitespace characters
    char whspc[] = " \t\r\n\v\f";

    // Whack off first part
    size_t pos = str.find_first_not_of( whspc );

    if ( pos != string::npos )
        str.replace( 0, pos, "" );

    // Whack off trailing stuff
    pos = str.find_last_not_of( whspc );

    if ( pos != string::npos )
        str.replace( pos + 1, str.length() - pos, "" );

    return str;
}

void g_tokenize( const string& str, const string& delimiters, vector<string>& tokens )
{
    tokenize( str, tokens, delimiters );
}

char* SetEventFunc( SendPluginEv funcPtr )
{
    static char * szObjList = onGetObjList();
    SendPluginEvent = funcPtr;
    return szObjList;
}


const int nMAXSIZE = 512;
char* g_pszRetVal = NULL;

//-----------------------------------------------------------
// Map from an object Id to an object instance
//-----------------------------------------------------------
typedef std::map<string, JSExt*> StringToJExt_T;

//-----------------------------------------------------------
// Map from a browser context to an id mapping
//-----------------------------------------------------------
typedef std::map<void*, StringToJExt_T*> VoidToMap_T;

VoidToMap_T g_context2Map;

class GlobalSharedModule
{

public:
    GlobalSharedModule( void )
    {
        g_pszRetVal = new char[ nMAXSIZE ];
    }

    ~GlobalSharedModule()
    {
        delete [] g_pszRetVal;

        VoidToMap_T::iterator posMaps;

        for ( posMaps = g_context2Map.begin(); posMaps != g_context2Map.end(); ++posMaps )
        {
            StringToJExt_T& id2Obj = *posMaps->second;
            StringToJExt_T::iterator posMap;

            for ( posMap = id2Obj.begin(); posMap != id2Obj.end(); ++posMap )
            {
                JSExt* pJSExt = posMap->second;

                if ( pJSExt->CanDelete() )
                {
                    delete pJSExt;
                }
            }

            id2Obj.erase( id2Obj.begin(), id2Obj.end() );
        }

        g_context2Map.erase( g_context2Map.begin(), g_context2Map.end() );
    }
};

GlobalSharedModule g_sharedModule;

char* g_str2global( const string& strRetVal )
{
    int nLen = strRetVal.size();

    if ( nLen >= nMAXSIZE )
    {
        delete [] g_pszRetVal;
        g_pszRetVal = new char[ nLen + 1 ];
    }

    else
    {
        // To minimaize the number of memory reallocations, the assumption
        // is that in most times this will be the case
        delete [] g_pszRetVal;
        g_pszRetVal = new char[ nMAXSIZE ];
    }

    strcpy( g_pszRetVal, strRetVal.c_str() );
    return g_pszRetVal;
}

bool g_unregisterObject( const string& strObjId, void* pContext )
{
    // Called by the plugin extension implementation
    // if the extension handles the deletion of its object

    StringToJExt_T * pID2Obj = NULL;

    VoidToMap_T::iterator iter = g_context2Map.find( pContext );

    if ( iter != g_context2Map.end() )
    {
        pID2Obj = iter->second;
    }
    else
    {
        return false;
    }

    StringToJExt_T& mapID2Obj = *pID2Obj;

    StringToJExt_T::iterator r = mapID2Obj.find( strObjId );

    if ( r == mapID2Obj.end() )
    {
        return false;
    }

    mapID2Obj.erase( strObjId );
    return true;
}

char* InvokeFunction( const char* szCommand, void* pContext )
{
    StringToJExt_T * pID2Obj = NULL;

    VoidToMap_T::iterator iter = g_context2Map.find( pContext );

    if ( iter != g_context2Map.end() )
    {
        pID2Obj = iter->second;
    }
    else
    {
        pID2Obj = new StringToJExt_T;
        g_context2Map[ pContext ] = pID2Obj;
    }

    StringToJExt_T& mapID2Obj = *pID2Obj;

    string strFullCommand = szCommand;
    vector<string> arParams;
    g_tokenize( strFullCommand, " ", arParams );
    string strCommand = arParams[ 0 ];
    string strRetVal = szERROR;

    if ( strCommand == szCREATE )
    {
        string strClassName = arParams[ 1 ];
        string strObjId = arParams[ 2 ];

        StringToJExt_T::iterator r = mapID2Obj.find( strObjId );

        if ( r != mapID2Obj.end() )
        {
            strRetVal += strObjId;
            strRetVal += " :Object already exists.";
            return g_str2global( strRetVal );
        }

        JSExt* pJSExt = onCreateObject( strClassName, strObjId );

        if ( pJSExt == NULL )
        {
            strRetVal += strObjId;
            strRetVal += " :Unknown object type ";
            strRetVal += strClassName;
            return g_str2global( strRetVal );
        }

        pJSExt->m_pContext = pContext;
        mapID2Obj[ strObjId ] = pJSExt;

        strRetVal = szOK;
        strRetVal += strObjId;
        return g_str2global( strRetVal );
    }
    else
    if ( strCommand == szINVOKE )
    {
        string strObjId = arParams[ 1 ];
        string strMethod = arParams[ 2 ];

        StringToJExt_T::iterator r = mapID2Obj.find( strObjId );

        if ( r == mapID2Obj.end() )
        {
            strRetVal += strObjId;
            strRetVal += " :No object found for id.";
            return g_str2global( strRetVal );
        }

        JSExt* pJSExt = r->second;

        size_t nLoc = strFullCommand.find( strObjId );

        if ( nLoc == string::npos )
        {
            strRetVal += strObjId;
            strRetVal += " :Internal InvokeMethod error.";
            return g_str2global( strRetVal );
        }

        if ( strMethod == szDISPOSE )
        {
            StringToJExt_T::iterator r = mapID2Obj.find( strObjId );

            if ( r == mapID2Obj.end() )
            {
                strRetVal = szERROR;
                strRetVal += strObjId;
                return g_str2global( strRetVal );
            }

            JSExt * pJSExt = mapID2Obj[ strObjId ];

            if ( pJSExt->CanDelete() )
            {
                delete pJSExt;
            }

            mapID2Obj.erase( strObjId );
            strRetVal = szOK;
            strRetVal += strObjId;
            return g_str2global( strRetVal );
        }

        size_t nSuffixLoc = nLoc + strObjId.size();
        string strInvoke = strFullCommand.substr( nSuffixLoc );
        strInvoke = g_trim( strInvoke );
        strRetVal = pJSExt->InvokeMethod( strInvoke );
        return g_str2global( strRetVal );
    }

    strRetVal += " :Unknown command ";
    strRetVal += strCommand;
    return g_str2global( strRetVal );
}

//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%