/*
        +==========================================================+
        |                                                          |
        |              ODBC extension for Win32 Perl               |
        |              -----------------------------               |
        |                                                          |
        |            by Dave Roth (rothd@infowire.com)             |
        |                                                          |
        |                  version v960522 (hack)                  |
        |                                                          |
        |    Copyright (c) 1996 Dave Roth. All rights reserved.    |
        |   This program is free software; you can redistribute    |
        | it and/or modify it under the same terms as Perl itself. |
        |                                                          |
        +==========================================================+
          based on original code by Dan DeMaggio (dmag@umich.edu)
   Use under GNU General Public License or Larry Wall's "Artistic License"
*/
#define WIN32_LEAN_AND_MEAN
#include <stdlib.h>
#include <math.h>
#include <windows.h>
#if defined(__cplusplus)
extern "C" {
#endif
#include <EXTERN.h>
#include "perl.h"
#include "XSub.h"
#include "patchlevel.h"
#if (PATCHLEVEL < 5) && !defined(PL_sv_undef)
# define PL_sv_undef sv_undef
#endif
#if defined(__cplusplus)
}
#endif
#include "cpipe.hpp"
#include "pipe.h"
char gszError[ERROR_TEXT_SIZE];
int     giError = 0;
/*----------------------- P E R L   F U N C T I O N S -------------------*/
// constant function for exporting NT definitions.
static long constant(char *name)
{
    errno = 0;
    switch (*name) {
            case 'A':
                        break;
        case 'B':
                        break;
        case 'C':
                        break;
        case 'D':
                        break;
        case 'E':
                        break;
            case 'F':
                        break;
            case 'G':
                        break;
            case 'H':
                        break;
            case 'I':
                        break;
            case 'J':
                        break;
            case 'K':
                        break;
            case 'L':
                        break;
            case 'M':
                        break;
            case 'N':
                        break;
            case 'O':
                        break;
            case 'P':
                        break;
            case 'Q':
                        break;
            case 'R':
                        break;
            case 'S':
                        break;
            case 'T':
                        break;
            case 'U':
                        break;
            case 'V':
                        break;
            case 'W':
                        break;
            case 'X':
                        break;
            case 'Y':
                        break;
            case 'Z':
                        break;
    }
    errno = EINVAL;
    return 0;
not_there:
    errno = ENOENT;
    return 0;
}
XS(XS_WIN32__Pipe_Constant)
{
        dXSARGS;
        if (items != 2)
        {
                croak("Usage: Win23::Pipe::Constant(name, arg)\n");
    }
        {
                STRLEN n_a;
                char* name = (char*)SvPV(ST(0),n_a);
                ST(0) = sv_newmortal();
                sv_setiv(ST(0), constant(name));
        }
        XSRETURN(1);
}
/*----------------------- M I S C   F U N C T I O N S -------------------*/
int     Error(int iErrorNum, char *szErrorText){
        strncpy((char *)gszError, szErrorText, ERROR_TEXT_SIZE);
        gszError[ERROR_TEXT_SIZE] = '\0';
        giError = iErrorNum;
        return giError;
}               
/*------------------- P E R L   O D B C   F U N C T I O N S ---------------*/
XS(XS_WIN32__Pipe_Create)
{
        dXSARGS;
         
        UCHAR   *szName = 0;
        DWORD   dWait = DEFAULT_WAIT_TIME;
        CPipe   *Pipe = 0;
        STRLEN  n_a;
        if(items != 2){
                CROAK("usage: Create(\"$Name\", $TimeToWait);\n");
        }
        szName = (UCHAR *)SvPV(ST(0), n_a);
        dWait = (DWORD)SvIV(ST(1));
        PUSHMARK(sp);
        if (strlen((const char *)szName) > 255){
                Error(ERROR_NAME_TOO_LONG);
        }else{
                Pipe = new CPipe((char *)szName, dWait);
        }
        if (Pipe){
                if (Pipe->iError){
                        giError = Pipe->iError;
                        strcpy(gszError, (const char *)Pipe->szError);
                        delete Pipe;
                        Pipe = 0;
                }
        }
        if (Pipe){ // everything is happy
                XPUSHs(sv_2mortal(newSViv((long)Pipe)));
        }else{
                XPUSHs(sv_2mortal(newSViv(0)));
        }
        PUTBACK;
} 
XS(XS_WIN32__Pipe_Close)
{
        dXSARGS;
        CPipe   *Pipe;
        if(items != 1){
                CROAK("usage: Close($PipeHandle);\n");
        }
        Pipe = (class CPipe *)SvIV(ST(0));
        PUSHMARK(sp);
         
        if (Pipe){
                delete Pipe;
        }
        XPUSHs(sv_2mortal(newSViv(0)));
        PUTBACK;
} 
XS(XS_WIN32__Pipe_Write)
{
        dXSARGS;
        CPipe   *Pipe = 0;
        void    *vpData = 0;
        int             iResult = 0;
        STRLEN  dDataLen;
        if(items != 2){
                CROAK("usage: Write($PipeHandle, $Data);\n");
        }
        Pipe = (class CPipe *)SvIV(ST(0));
        vpData = (void *)SvPV(ST(1), dDataLen);
        PUSHMARK(sp);
         
        if (Pipe){
                iResult = Pipe->Write((void *)vpData, (DWORD)dDataLen);
        }
        XPUSHs(sv_2mortal(newSViv(iResult)));
        PUTBACK;
} 
XS(XS_WIN32__Pipe_Read)
{
        dXSARGS;
        CPipe   *Pipe = 0;
        int             iFlag = 1;
        DWORD   dLen = 0;
        void    *vpData = 0;
        if(items != 1){
                CROAK("usage: Read($PipeHandle);\n");
        }
        Pipe = (class CPipe *)SvIV(ST(0));
        PUSHMARK(sp);
         
        if (Pipe){
                while(iFlag){
                        vpData = Pipe->Read(&dLen);
                        iFlag = 0;                              
                                //      If we have more data to read then for God's sake, do it!
                                //      I don't know if this will work ... it would return an
                                //      array. This may not be good. Hmmmm.
                        if(!vpData && GetLastError() == ERROR_MORE_DATA){
                                iFlag = 1;
                        }                               
                        if(dLen){
                                XPUSHs(sv_2mortal(newSVpv((char *)vpData, dLen)));
                        }else{
                                sv_setsv(ST(0), (SV*) &PL_sv_undef);
                        }
                }
        }
        PUTBACK;
} 
XS(XS_WIN32__Pipe_Connect)
{
        dXSARGS;
        CPipe   *Pipe;
        int             iResult = 0;
        if(items != 1){
                CROAK("usage: Connect($PipeHandle);\n");
        }
        Pipe = (class CPipe *)SvIV(ST(0));
        PUSHMARK(sp);
         
        if (Pipe){
                iResult = Pipe->Connect();
        }
        XPUSHs(sv_2mortal(newSViv((long)iResult)));
        PUTBACK;
} 
XS(XS_WIN32__Pipe_Disconnect)
{
        dXSARGS;
        CPipe   *Pipe;
        int             iResult = 0;
        int             iPurge = 0;
        if(items > 0 && items < 3){
                CROAK("usage: Disconnect($PipeHandle [, $iPurge]);\n");
        }
        Pipe = (class CPipe *)SvIV(ST(0));
        if (items == 2){
                iPurge = (int) SvIV(ST(1));
        }
        PUSHMARK(sp);
         
        if (Pipe){
                iResult = Pipe->Disconnect(iPurge);
        }
        XPUSHs(sv_2mortal(newSViv((long)iResult)));
        PUTBACK;
} 
XS(XS_WIN32__Pipe_ResizeBuffer)
{
        dXSARGS;
        CPipe   *Pipe = 0;
        DWORD   dResult = 0;
        DWORD   dSize;
         
        if(items != 2){
                CROAK("usage: ResizeBuffer($PipeHandle, $Size);\n");
        }
        Pipe = (class CPipe *)SvIV(ST(0));
        dSize = (DWORD)SvIV(ST(1));
        PUSHMARK(sp);
         
        if (Pipe){
                dResult = Pipe->ResizeBuffer(dSize);
        }
        XPUSHs(sv_2mortal(newSViv((long)dResult)));
        PUTBACK;
} 
XS(XS_WIN32__Pipe_BufferSize)
{
        dXSARGS;
        CPipe   *Pipe = 0;
        DWORD   dResult = 0;
         
        if(items != 1){
                CROAK("usage: BufferSize($PipeHandle);\n");
        }
        Pipe = (class CPipe *)SvIV(ST(0));
        PUSHMARK(sp);
         
        if (Pipe){
                dResult = Pipe->BufferSize();
        }
        XPUSHs(sv_2mortal(newSViv((long)dResult)));
        PUTBACK;
} 
XS(XS_WIN32__Pipe_Error)
{
        dXSARGS;
        CPipe   *Pipe = 0;
        int             iResult = 0;
        char    *szError = 0;
        int             iError = 0;
         
        if(items > 1){
                CROAK("usage: Error([$PipeHandle]);\n");
        }
        if (items == 1){
                Pipe = (class CPipe *)SvIV(ST(0));
        }
        PUSHMARK(sp);
         
        if (Pipe){
                iError = Pipe->iError;
                szError = (char *)Pipe->szError;
        }else{
                iError = giError;
                szError = gszError;
        }
        XPUSHs(sv_2mortal(newSViv((long)iError)));
        XPUSHs(sv_2mortal(newSVpv((char *)szError, strlen(szError))));
        PUTBACK;
} 
XS(XS_WIN32__Pipe_Info) 
{
        dXSARGS;
        if(items > 0){
                CROAK("usage: ($ExtName, $Version, $Date, $Author, $CompileDate, $Credits) = Info()\n");
        }
         
        PUSHMARK(sp);
         
        XPUSHs(sv_2mortal(newSVpv(VERNAME, strlen(VERNAME))));
        XPUSHs(sv_2mortal(newSVpv(VERSION, strlen(VERSION))));
        XPUSHs(sv_2mortal(newSVpv(VERDATE, strlen(VERDATE))));
        XPUSHs(sv_2mortal(newSVpv(VERAUTH, strlen(VERAUTH))));
        XPUSHs(sv_2mortal(newSVpv(__DATE__, strlen(__DATE__))));
        XPUSHs(sv_2mortal(newSVpv(__TIME__, strlen(__TIME__))));
        XPUSHs(sv_2mortal(newSVpv(VERCRED, strlen(VERCRED))));
        PUTBACK;
}
#if defined(__cplusplus)
extern "C"
#endif
XS(boot_Win32__Pipe)
{
        dXSARGS;
        char* file = __FILE__;
        int i;
        giError = 0;
        memset((void *)gszError, 0, ERROR_TEXT_SIZE);
        newXS("Win32::Pipe::constant",                          XS_WIN32__Pipe_Constant, file);
        newXS("Win32::Pipe::PipeCreate",                        XS_WIN32__Pipe_Create,  file);
        newXS("Win32::Pipe::PipeClose",                         XS_WIN32__Pipe_Close,  file);
        newXS("Win32::Pipe::PipeWrite",                         XS_WIN32__Pipe_Write,  file);
        newXS("Win32::Pipe::PipeRead",                          XS_WIN32__Pipe_Read,  file);
        newXS("Win32::Pipe::PipeConnect",                       XS_WIN32__Pipe_Connect,  file);
        newXS("Win32::Pipe::PipeDisconnect",            XS_WIN32__Pipe_Disconnect,  file);
        newXS("Win32::Pipe::PipeError",                         XS_WIN32__Pipe_Error,  file);
        newXS("Win32::Pipe::PipeResizeBuffer",          XS_WIN32__Pipe_ResizeBuffer,  file);
        newXS("Win32::Pipe::PipeBufferSize",            XS_WIN32__Pipe_BufferSize,  file);
        newXS("Win32::Pipe::Info",                                      XS_WIN32__Pipe_Info, file);
        XSRETURN_YES;
}