src/common/longlong.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        wx/longlong.cpp
// Purpose:     implementation of wxLongLongNative
// Author:      Jeffrey C. Ollie <jeff@ollie.clive.ia.us>, Vadim Zeitlin
// Remarks:     this class is not public in wxWindows 2.0! It is intentionally
//              not documented and is for private use only.
// Modified by:
// Created:     10.02.99
// RCS-ID:      $Id$
// Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

// ============================================================================
// headers
// ============================================================================

#ifdef __GNUG__
    #pragma implementation "longlong.h"
#endif

#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#include "wx/longlong.h"

#include <memory.h>     // for memset()

// ============================================================================
// implementation
// ============================================================================

#if wxUSE_LONGLONG_NATIVE

// ----------------------------------------------------------------------------
// misc
// ----------------------------------------------------------------------------

void *wxLongLongNative::asArray(void) const
{
    static unsigned char temp[8];

    temp[0] = (m_ll >> 56) & 0xFF;
    temp[1] = (m_ll >> 48) & 0xFF;
    temp[2] = (m_ll >> 40) & 0xFF;
    temp[3] = (m_ll >> 32) & 0xFF;
    temp[4] = (m_ll >> 24) & 0xFF;
    temp[5] = (m_ll >> 16) & 0xFF;
    temp[6] = (m_ll >> 8)  & 0xFF;
    temp[7] = (m_ll >> 0)  & 0xFF;

    return temp;
}

// input/output
ostream& operator<< (ostream& o, const wxLongLongNative& ll)
{
    char result[65];

    memset(result, 'A', 64);

    result[64] = '\0';

    for (int i = 0; i < 64; i++)
    {
        result[63 - i] = '0' + (char) ((ll.m_ll >> i) & 1);
    }

    return o << result;
}

#endif // wxUSE_LONGLONG_NATIVE

#if wxUSE_LONGLONG_WX

wxLongLongWx wxLongLongWx::operator<<(int shift) const
{
    if (shift == 0)
        return *this;

    if (shift < 32)
        return wxLongLongWx((m_hi << shift) | (m_lo >> (32 - shift)),
                             m_lo << shift);
    else
        return wxLongLongWx(m_lo << (shift - 32),
                            0);
}

wxLongLongWx& wxLongLongWx::operator<<=(int shift)
{
    if (shift == 0)
        return *this;

    if (shift < 32)
    {
        m_hi <<= shift;
        m_hi |= m_lo >> (32 - shift);
        m_lo <<= shift;
    }
    else
    {
        m_hi = m_lo << (shift - 32);
        m_lo = 0;
    }

    return *this;
}

wxLongLongWx wxLongLongWx::operator>>(int shift) const
{
    if (shift == 0)
        return *this;

    if (shift < 32)
        return wxLongLongWx(m_hi >> shift,
                          (m_lo >> shift) | (m_hi << (32 - shift)));
    else
        return wxLongLongWx((m_hi < 0 ? -1l : 0),
                          m_hi >> (shift - 32));
}

wxLongLongWx& wxLongLongWx::operator>>=(int shift)
{
    if (shift == 0)
        return *this;

    if (shift < 32)
    {
        m_lo >>= shift;
        m_lo |= m_hi << (32 - shift);
        m_hi >>= shift;
    }
    else
    {
        m_lo = m_hi >> (shift - 32);
        m_hi = (m_hi < 0 ? -1L : 0);
    }

    return *this;
}

wxLongLongWx wxLongLongWx::operator+(const wxLongLongWx& ll) const
{
    wxLongLongWx temp;

    temp.m_lo = m_lo + ll.m_lo;
    temp.m_hi = m_hi + ll.m_hi;
    if ((temp.m_lo < m_lo) || (temp.m_lo < ll.m_lo))
        temp.m_hi++;

    return temp;
}

wxLongLongWx wxLongLongWx::operator+(long l) const
{
    wxLongLongWx temp;

    temp.m_lo = m_lo + l;

    if (l < 0)
        temp.m_hi += -1l;

    if ((temp.m_lo < m_lo) || (temp.m_lo < (unsigned long)l))
        temp.m_hi++;

    return temp;
}

wxLongLongWx& wxLongLongWx::operator+=(const wxLongLongWx& ll)
{
    unsigned long previous = m_lo;

    m_lo += ll.m_lo;
    m_hi += ll.m_hi;

    if ((m_lo < previous) || (m_lo < ll.m_lo))
        m_hi++;

    return *this;
}

wxLongLongWx& wxLongLongWx::operator+=(long l)
{
    unsigned long previous = m_lo;

    m_lo += l;
    if (l < 0)
        m_hi += -1l;

    if ((m_lo < previous) || (m_lo < (unsigned long)l))
        m_hi++;

    return *this;
}

// pre increment
wxLongLongWx& wxLongLongWx::operator++()
{
    m_lo++;
    if (m_lo == 0)
        m_hi++;

    return *this;
}

// post increment
wxLongLongWx& wxLongLongWx::operator++(int)
{
    m_lo++;
    if (m_lo == 0)
        m_hi++;

    return *this;
}

// negation
wxLongLongWx wxLongLongWx::operator-() const
{
    wxLongLongWx temp(~m_hi, ~m_lo);

    temp.m_lo++;
    if (temp.m_lo == 0)
        temp.m_hi++;

    return temp;
}

// subtraction

wxLongLongWx wxLongLongWx::operator-(const wxLongLongWx& ll) const
{
    wxLongLongWx temp;

    temp.m_lo = m_lo - ll.m_lo;
    temp.m_hi = m_hi - ll.m_hi;

    if (m_lo < ll.m_lo)
        temp.m_hi--;

    return temp;
}

wxLongLongWx& wxLongLongWx::operator-=(const wxLongLongWx& ll)
{
    unsigned long previous = m_lo;

    m_lo -= ll.m_lo;
    m_hi -= ll.m_hi;

    if (previous < ll.m_lo)
        m_hi--;

    return *this;;
}

// pre decrement
wxLongLongWx& wxLongLongWx::operator--()
{
    m_lo--;
    if (m_lo == 0xFFFFFFFF)
        m_hi--;

    return *this;
}

// post decrement
wxLongLongWx& wxLongLongWx::operator--(int)
{
    m_lo--;
    if (m_lo == 0xFFFFFFFF)
        m_hi--;

    return *this;
}

// comparison operators

bool wxLongLongWx::operator<(const wxLongLongWx& ll) const
{
    if (m_lo < ll.m_lo)
        return 1;
    if (m_lo > ll.m_lo)
        return 0;
    if (m_hi < ll.m_hi)
        return 1;
    if (m_hi > ll.m_hi)
        return 0;
    return 0;
}

bool wxLongLongWx::operator>(const wxLongLongWx& ll) const
{
    if (m_lo < ll.m_lo)
        return 0;
    if (m_lo > ll.m_lo)
        return 1;
    if (m_hi < ll.m_hi)
        return 0;
    if (m_hi > ll.m_hi)
        return 1;
    return 0;
}

bool wxLongLongWx::operator<=(const wxLongLongWx& ll) const
{
    if (m_lo < ll.m_lo)
        return 1;
    if (m_lo > ll.m_lo)
        return 0;
    if (m_hi < ll.m_hi)
        return 1;
    if (m_hi > ll.m_hi)
        return 0;
    return 1;
}

bool wxLongLongWx::operator>=(const wxLongLongWx& ll) const
{
    if (m_lo < ll.m_lo)
        return 0;
    if (m_lo > ll.m_lo)
        return 1;
    if (m_hi < ll.m_hi)
        return 0;
    if (m_hi > ll.m_hi)
        return 1;
    return 1;
}

// bitwise operators

wxLongLongWx wxLongLongWx::operator&(const wxLongLongWx& ll) const
{
    return wxLongLongWx(m_hi & ll.m_hi, m_lo & ll.m_lo);
}

wxLongLongWx wxLongLongWx::operator|(const wxLongLongWx& ll) const
{
    return wxLongLongWx(m_hi | ll.m_hi, m_lo | ll.m_lo);
}

wxLongLongWx wxLongLongWx::operator^(const wxLongLongWx& ll) const
{
    return wxLongLongWx(m_hi ^ ll.m_hi, m_lo ^ ll.m_lo);
}

wxLongLongWx& wxLongLongWx::operator&=(const wxLongLongWx& ll)
{
    m_lo &= ll.m_lo;
    m_hi &= ll.m_hi;

    return *this;
}

wxLongLongWx& wxLongLongWx::operator|=(const wxLongLongWx& ll)
{
    m_lo |= ll.m_lo;
    m_hi |= ll.m_hi;

    return *this;
}

wxLongLongWx& wxLongLongWx::operator^=(const wxLongLongWx& ll)
{
    m_lo ^= ll.m_lo;
    m_hi ^= ll.m_hi;

    return *this;
}

wxLongLongWx wxLongLongWx::operator~() const
{
    return wxLongLongWx(~m_hi, ~m_lo);
}

// multiplication

wxLongLongWx wxLongLongWx::operator*(const wxLongLongWx& ll) const
{
    wxLongLongWx t(m_hi, m_lo);
    wxLongLongWx q(ll.m_hi, ll.m_lo);
    wxLongLongWx p;
    int counter = 0;

    do
    {
        if ((q.m_lo & 1) != 0)
              p += t;
        q >>= 1;
        t <<= 1;
        counter++;
      }
      while ((counter < 64) && ((q.m_hi != 0) || (q.m_lo != 0)));
    return p;
}

wxLongLongWx& wxLongLongWx::operator*=(const wxLongLongWx& ll)
{
    wxLongLongWx t(m_hi, m_lo);
    wxLongLongWx q(ll.m_hi, ll.m_lo);
    int counter = 0;

    do
    {
        if ((q.m_lo & 1) != 0)
              *this += t;
        q >>= 1;
        t <<= 1;
        counter++;
      }
      while ((counter < 64) && ((q.m_hi != 0) || (q.m_lo != 0)));
    return *this;
}

// division

void wxLongLongWx::Divide(const wxLongLongWx& divisor, wxLongLongWx& quotient, wxLongLongWx& remainder) const
{
    if ((divisor.m_lo == 0) && (divisor.m_hi == 0))
    {
        // provoke division by zero error and silence the compilers warnings
        // about an expression without effect and unused variable
        long dummy = divisor.m_lo/divisor.m_hi;
        dummy += 0;
    }

    wxFAIL_MSG("not implemented");
}

// temporary - just for testing
void *wxLongLongWx::asArray(void) const
{
    static unsigned char temp[8];

    temp[0] = (m_hi >> 24) & 0xFF;
    temp[1] = (m_hi >> 16) & 0xFF;
    temp[2] = (m_hi >> 8)  & 0xFF;
    temp[3] = (m_hi >> 0)  & 0xFF;
    temp[4] = (m_lo >> 24) & 0xFF;
    temp[5] = (m_lo >> 16) & 0xFF;
    temp[6] = (m_lo >> 8)  & 0xFF;
    temp[7] = (m_lo >> 0)  & 0xFF;

    return temp;
}

// input/output

ostream& operator<< (ostream& o, const wxLongLongWx& ll)
{
    char result[65];

    memset(result, 'A', 64);

    result[64] = '\0';

    for (int i = 0; i < 32; i++)
    {
        result[31 - i] = (char) ('0' + (int) ((ll.m_hi >> i) & 1));
        result[63 - i] = (char) ('0' + (int) ((ll.m_lo >> i) & 1));
    }

    return o << result;
}
#endif wxUSE_LONGLONG_WX
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: wx/longlong.cpp
	3	// Purpose: implementation of wxLongLongNative
	4	// Author: Jeffrey C. Ollie <jeff@ollie.clive.ia.us>, Vadim Zeitlin
	5	// Remarks: this class is not public in wxWindows 2.0! It is intentionally
	6	// not documented and is for private use only.
	7	// Modified by:
	8	// Created: 10.02.99
	9	// RCS-ID: $Id$
	10	// Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
	11	// Licence: wxWindows license
	12	/////////////////////////////////////////////////////////////////////////////
	13
	14	// ============================================================================
	15	// headers
	16	// ============================================================================
	17
	18	#ifdef __GNUG__
	19	#pragma implementation "longlong.h"
	20	#endif
	21
	22	#include "wx/wxprec.h"
	23
	24	#ifdef __BORLANDC__
	25	#pragma hdrstop
	26	#endif
	27
	28	#include "wx/longlong.h"
	29
	30	#include <memory.h> // for memset()
	31
	32	// ============================================================================
	33	// implementation
	34	// ============================================================================
	35
	36	#if wxUSE_LONGLONG_NATIVE
	37
	38	// ----------------------------------------------------------------------------
	39	// misc
	40	// ----------------------------------------------------------------------------
	41
	42	void *wxLongLongNative::asArray(void) const
	43	{
	44	static unsigned char temp[8];
	45
	46	temp[0] = (m_ll >> 56) & 0xFF;
	47	temp[1] = (m_ll >> 48) & 0xFF;
	48	temp[2] = (m_ll >> 40) & 0xFF;
	49	temp[3] = (m_ll >> 32) & 0xFF;
	50	temp[4] = (m_ll >> 24) & 0xFF;
	51	temp[5] = (m_ll >> 16) & 0xFF;
	52	temp[6] = (m_ll >> 8) & 0xFF;
	53	temp[7] = (m_ll >> 0) & 0xFF;
	54
	55	return temp;
	56	}
	57
	58	// input/output
	59	ostream& operator<< (ostream& o, const wxLongLongNative& ll)
	60	{
	61	char result[65];
	62
	63	memset(result, 'A', 64);
	64
	65	result[64] = '\0';
	66
	67	for (int i = 0; i < 64; i++)
	68	{
	69	result[63 - i] = '0' + (char) ((ll.m_ll >> i) & 1);
	70	}
	71
	72	return o << result;
	73	}
	74
	75	#endif // wxUSE_LONGLONG_NATIVE
	76
	77	#if wxUSE_LONGLONG_WX
	78
	79	wxLongLongWx wxLongLongWx::operator<<(int shift) const
	80	{
	81	if (shift == 0)
	82	return *this;
	83
	84	if (shift < 32)
	85	return wxLongLongWx((m_hi << shift) \| (m_lo >> (32 - shift)),
	86	m_lo << shift);
	87	else
	88	return wxLongLongWx(m_lo << (shift - 32),
	89	0);
	90	}
	91
	92	wxLongLongWx& wxLongLongWx::operator<<=(int shift)
	93	{
	94	if (shift == 0)
	95	return *this;
	96
	97	if (shift < 32)
	98	{
	99	m_hi <<= shift;
	100	m_hi \|= m_lo >> (32 - shift);
	101	m_lo <<= shift;
	102	}
	103	else
	104	{
	105	m_hi = m_lo << (shift - 32);
	106	m_lo = 0;
	107	}
	108
	109	return *this;
	110	}
	111
	112	wxLongLongWx wxLongLongWx::operator>>(int shift) const
	113	{
	114	if (shift == 0)
	115	return *this;
	116
	117	if (shift < 32)
	118	return wxLongLongWx(m_hi >> shift,
	119	(m_lo >> shift) \| (m_hi << (32 - shift)));
	120	else
	121	return wxLongLongWx((m_hi < 0 ? -1l : 0),
	122	m_hi >> (shift - 32));
	123	}
	124
	125	wxLongLongWx& wxLongLongWx::operator>>=(int shift)
	126	{
	127	if (shift == 0)
	128	return *this;
	129
	130	if (shift < 32)
	131	{
	132	m_lo >>= shift;
	133	m_lo \|= m_hi << (32 - shift);
	134	m_hi >>= shift;
	135	}
	136	else
	137	{
	138	m_lo = m_hi >> (shift - 32);
	139	m_hi = (m_hi < 0 ? -1L : 0);
	140	}
	141
	142	return *this;
	143	}
	144
	145	wxLongLongWx wxLongLongWx::operator+(const wxLongLongWx& ll) const
	146	{
	147	wxLongLongWx temp;
	148
	149	temp.m_lo = m_lo + ll.m_lo;
	150	temp.m_hi = m_hi + ll.m_hi;
	151	if ((temp.m_lo < m_lo) \|\| (temp.m_lo < ll.m_lo))
	152	temp.m_hi++;
	153
	154	return temp;
	155	}
	156
	157	wxLongLongWx wxLongLongWx::operator+(long l) const
	158	{
	159	wxLongLongWx temp;
	160
	161	temp.m_lo = m_lo + l;
	162
	163	if (l < 0)
	164	temp.m_hi += -1l;
	165
	166	if ((temp.m_lo < m_lo) \|\| (temp.m_lo < (unsigned long)l))
	167	temp.m_hi++;
	168
	169	return temp;
	170	}
	171
	172	wxLongLongWx& wxLongLongWx::operator+=(const wxLongLongWx& ll)
	173	{
	174	unsigned long previous = m_lo;
	175
	176	m_lo += ll.m_lo;
	177	m_hi += ll.m_hi;
	178
	179	if ((m_lo < previous) \|\| (m_lo < ll.m_lo))
	180	m_hi++;
	181
	182	return *this;
	183	}
	184
	185	wxLongLongWx& wxLongLongWx::operator+=(long l)
	186	{
	187	unsigned long previous = m_lo;
	188
	189	m_lo += l;
	190	if (l < 0)
	191	m_hi += -1l;
	192
	193	if ((m_lo < previous) \|\| (m_lo < (unsigned long)l))
	194	m_hi++;
	195
	196	return *this;
	197	}
	198
	199	// pre increment
	200	wxLongLongWx& wxLongLongWx::operator++()
	201	{
	202	m_lo++;
	203	if (m_lo == 0)
	204	m_hi++;
	205
	206	return *this;
	207	}
	208
	209	// post increment
	210	wxLongLongWx& wxLongLongWx::operator++(int)
	211	{
	212	m_lo++;
	213	if (m_lo == 0)
	214	m_hi++;
	215
	216	return *this;
	217	}
	218
	219	// negation
	220	wxLongLongWx wxLongLongWx::operator-() const
	221	{
	222	wxLongLongWx temp(~m_hi, ~m_lo);
	223
	224	temp.m_lo++;
	225	if (temp.m_lo == 0)
	226	temp.m_hi++;
	227
	228	return temp;
	229	}
	230
	231	// subtraction
	232
	233	wxLongLongWx wxLongLongWx::operator-(const wxLongLongWx& ll) const
	234	{
	235	wxLongLongWx temp;
	236
	237	temp.m_lo = m_lo - ll.m_lo;
	238	temp.m_hi = m_hi - ll.m_hi;
	239
	240	if (m_lo < ll.m_lo)
	241	temp.m_hi--;
	242
	243	return temp;
	244	}
	245
	246	wxLongLongWx& wxLongLongWx::operator-=(const wxLongLongWx& ll)
	247	{
	248	unsigned long previous = m_lo;
	249
	250	m_lo -= ll.m_lo;
	251	m_hi -= ll.m_hi;
	252
	253	if (previous < ll.m_lo)
	254	m_hi--;
	255
	256	return *this;;
	257	}
	258
	259	// pre decrement
	260	wxLongLongWx& wxLongLongWx::operator--()
	261	{
	262	m_lo--;
	263	if (m_lo == 0xFFFFFFFF)
	264	m_hi--;
	265
	266	return *this;
	267	}
	268
	269	// post decrement
	270	wxLongLongWx& wxLongLongWx::operator--(int)
	271	{
	272	m_lo--;
	273	if (m_lo == 0xFFFFFFFF)
	274	m_hi--;
	275
	276	return *this;
	277	}
	278
	279	// comparison operators
	280
	281	bool wxLongLongWx::operator<(const wxLongLongWx& ll) const
	282	{
	283	if (m_lo < ll.m_lo)
	284	return 1;
	285	if (m_lo > ll.m_lo)
	286	return 0;
	287	if (m_hi < ll.m_hi)
	288	return 1;
	289	if (m_hi > ll.m_hi)
	290	return 0;
	291	return 0;
	292	}
	293
	294	bool wxLongLongWx::operator>(const wxLongLongWx& ll) const
	295	{
	296	if (m_lo < ll.m_lo)
	297	return 0;
	298	if (m_lo > ll.m_lo)
	299	return 1;
	300	if (m_hi < ll.m_hi)
	301	return 0;
	302	if (m_hi > ll.m_hi)
	303	return 1;
	304	return 0;
	305	}
	306
	307	bool wxLongLongWx::operator<=(const wxLongLongWx& ll) const
	308	{
	309	if (m_lo < ll.m_lo)
	310	return 1;
	311	if (m_lo > ll.m_lo)
	312	return 0;
	313	if (m_hi < ll.m_hi)
	314	return 1;
	315	if (m_hi > ll.m_hi)
	316	return 0;
	317	return 1;
	318	}
	319
	320	bool wxLongLongWx::operator>=(const wxLongLongWx& ll) const
	321	{
	322	if (m_lo < ll.m_lo)
	323	return 0;
	324	if (m_lo > ll.m_lo)
	325	return 1;
	326	if (m_hi < ll.m_hi)
	327	return 0;
	328	if (m_hi > ll.m_hi)
	329	return 1;
	330	return 1;
	331	}
	332
	333	// bitwise operators
	334
	335	wxLongLongWx wxLongLongWx::operator&(const wxLongLongWx& ll) const
	336	{
	337	return wxLongLongWx(m_hi & ll.m_hi, m_lo & ll.m_lo);
	338	}
	339
	340	wxLongLongWx wxLongLongWx::operator\|(const wxLongLongWx& ll) const
	341	{
	342	return wxLongLongWx(m_hi \| ll.m_hi, m_lo \| ll.m_lo);
	343	}
	344
	345	wxLongLongWx wxLongLongWx::operator^(const wxLongLongWx& ll) const
	346	{
	347	return wxLongLongWx(m_hi ^ ll.m_hi, m_lo ^ ll.m_lo);
	348	}
	349
	350	wxLongLongWx& wxLongLongWx::operator&=(const wxLongLongWx& ll)
	351	{
	352	m_lo &= ll.m_lo;
	353	m_hi &= ll.m_hi;
	354
	355	return *this;
	356	}
	357
	358	wxLongLongWx& wxLongLongWx::operator\|=(const wxLongLongWx& ll)
	359	{
	360	m_lo \|= ll.m_lo;
	361	m_hi \|= ll.m_hi;
	362
	363	return *this;
	364	}
	365
	366	wxLongLongWx& wxLongLongWx::operator^=(const wxLongLongWx& ll)
	367	{
	368	m_lo ^= ll.m_lo;
	369	m_hi ^= ll.m_hi;
	370
	371	return *this;
	372	}
	373
	374	wxLongLongWx wxLongLongWx::operator~() const
	375	{
	376	return wxLongLongWx(~m_hi, ~m_lo);
	377	}
	378
	379	// multiplication
	380
	381	wxLongLongWx wxLongLongWx::operator*(const wxLongLongWx& ll) const
	382	{
	383	wxLongLongWx t(m_hi, m_lo);
	384	wxLongLongWx q(ll.m_hi, ll.m_lo);
	385	wxLongLongWx p;
	386	int counter = 0;
	387
	388	do
	389	{
	390	if ((q.m_lo & 1) != 0)
	391	p += t;
	392	q >>= 1;
	393	t <<= 1;
	394	counter++;
	395	}
	396	while ((counter < 64) && ((q.m_hi != 0) \|\| (q.m_lo != 0)));
	397	return p;
	398	}
	399
	400	wxLongLongWx& wxLongLongWx::operator*=(const wxLongLongWx& ll)
	401	{
	402	wxLongLongWx t(m_hi, m_lo);
	403	wxLongLongWx q(ll.m_hi, ll.m_lo);
	404	int counter = 0;
	405
	406	do
	407	{
	408	if ((q.m_lo & 1) != 0)
	409	*this += t;
	410	q >>= 1;
	411	t <<= 1;
	412	counter++;
	413	}
	414	while ((counter < 64) && ((q.m_hi != 0) \|\| (q.m_lo != 0)));
	415	return *this;
	416	}
	417
	418	// division
	419
	420	void wxLongLongWx::Divide(const wxLongLongWx& divisor, wxLongLongWx& quotient, wxLongLongWx& remainder) const
	421	{
	422	if ((divisor.m_lo == 0) && (divisor.m_hi == 0))
	423	{
	424	// provoke division by zero error and silence the compilers warnings
	425	// about an expression without effect and unused variable
	426	long dummy = divisor.m_lo/divisor.m_hi;
	427	dummy += 0;
	428	}
	429
	430	wxFAIL_MSG("not implemented");
	431	}
	432
	433	// temporary - just for testing
	434	void *wxLongLongWx::asArray(void) const
	435	{
	436	static unsigned char temp[8];
	437
	438	temp[0] = (m_hi >> 24) & 0xFF;
	439	temp[1] = (m_hi >> 16) & 0xFF;
	440	temp[2] = (m_hi >> 8) & 0xFF;
	441	temp[3] = (m_hi >> 0) & 0xFF;
	442	temp[4] = (m_lo >> 24) & 0xFF;
	443	temp[5] = (m_lo >> 16) & 0xFF;
	444	temp[6] = (m_lo >> 8) & 0xFF;
	445	temp[7] = (m_lo >> 0) & 0xFF;
	446
	447	return temp;
	448	}
	449
	450	// input/output
	451
	452	ostream& operator<< (ostream& o, const wxLongLongWx& ll)
	453	{
	454	char result[65];
	455
	456	memset(result, 'A', 64);
	457
	458	result[64] = '\0';
	459
	460	for (int i = 0; i < 32; i++)
	461	{
	462	result[31 - i] = (char) ('0' + (int) ((ll.m_hi >> i) & 1));
	463	result[63 - i] = (char) ('0' + (int) ((ll.m_lo >> i) & 1));
	464	}
	465
	466	return o << result;
	467	}
	468	#endif wxUSE_LONGLONG_WX
	469