[p5sagit/p5-mst-13.2.git] / symbian / PerlBase.cpp

/* Copyright (c) 2004-2005 Nokia. All rights reserved. */

/* The CPerlBase class is licensed under the same terms as Perl itself. */

/* See PerlBase.pod for documentation. */

#define PERLBASE_CPP

#include <e32cons.h>
#include <e32keys.h>
#include <utf.h>

#include "PerlBase.h"

const TUint KPerlConsoleBufferMaxTChars = 0x0200;
const TUint KPerlConsoleNoPos           = 0xffff;

CPerlBase::CPerlBase()
{
}

EXPORT_C void CPerlBase::Destruct()
{
    dTHX;
    iState = EPerlDestroying;
    if (iConsole) {
        iConsole->Printf(_L("[Any key to continue]"));
        iConsole->Getch();
    }
    if (iPerl)  {
        (void)perl_destruct(iPerl);
        perl_free(iPerl);
        iPerl = NULL;
        PERL_SYS_TERM();
    }
    if (iConsole) {
        delete iConsole;
        iConsole = NULL;
    }
    if (iConsoleBuffer) {
        free(iConsoleBuffer);
        iConsoleBuffer = NULL;
    }
#ifdef PERL_GLOBAL_STRUCT
    if (iVars) {
        PerlInterpreter* my_perl = NULL;
        free_global_struct(iVars);
        iVars = NULL;
    }
#endif
}

CPerlBase::~CPerlBase()
{
    Destruct();
}

EXPORT_C CPerlBase* CPerlBase::NewInterpreter(TBool aCloseStdlib,
                                               void (*aStdioInitFunc)(void*),
                                               void *aStdioInitCookie)
{
   CPerlBase* self = new (ELeave) CPerlBase;
   self->iCloseStdlib     = aCloseStdlib;
   self->iStdioInitFunc   = aStdioInitFunc;
   self->iStdioInitCookie = aStdioInitCookie;
   self->ConstructL();
   PERL_APPCTX_SET(self);
   return self;
}

EXPORT_C CPerlBase* CPerlBase::NewInterpreterL(TBool aCloseStdlib,
                                               void (*aStdioInitFunc)(void*),
                                               void *aStdioInitCookie)
{
    CPerlBase* self =
      CPerlBase::NewInterpreterLC(aCloseStdlib,
                                  aStdioInitFunc,
                                  aStdioInitCookie);
    CleanupStack::Pop(self);
    return self;
}

EXPORT_C CPerlBase* CPerlBase::NewInterpreterLC(TBool aCloseStdlib,
                                                void (*aStdioInitFunc)(void*),
                                                void *aStdioInitCookie)
{
    CPerlBase* self = new (ELeave) CPerlBase;
    CleanupStack::PushL(self);
    self->iCloseStdlib     = aCloseStdlib;
    self->iStdioInitFunc   = aStdioInitFunc;
    self->iStdioInitCookie = aStdioInitCookie;
    self->ConstructL();
    PERL_APPCTX_SET(self);
    return self;
}

static int _console_stdin(void* cookie, char* buf, int n)
{
    return ((CPerlBase*)cookie)->ConsoleRead(0, buf, n);
}

static int _console_stdout(void* cookie, const char* buf, int n)
{
    return ((CPerlBase*)cookie)->ConsoleWrite(1, buf, n);
}

static int _console_stderr(void* cookie, const char* buf, int n)
{
    return ((CPerlBase*)cookie)->ConsoleWrite(2, buf, n);
}

void CPerlBase::StdioRewire(void *arg) {
    _REENT->_sf[0]._cookie = (void*)this;
    _REENT->_sf[0]._read   = &_console_stdin;
    _REENT->_sf[0]._write  = 0;
    _REENT->_sf[0]._seek   = 0;
    _REENT->_sf[0]._close  = 0;

    _REENT->_sf[1]._cookie = (void*)this;
    _REENT->_sf[1]._read   = 0;
    _REENT->_sf[1]._write  = &_console_stdout;
    _REENT->_sf[1]._seek   = 0;
    _REENT->_sf[1]._close  = 0;

    _REENT->_sf[2]._cookie = (void*)this;
    _REENT->_sf[2]._read   = 0;
    _REENT->_sf[2]._write  = &_console_stderr;
    _REENT->_sf[2]._seek   = 0;
    _REENT->_sf[2]._close  = 0;
}

void CPerlBase::ConstructL()
{
    iState = EPerlNone;
#ifdef PERL_GLOBAL_STRUCT
    PerlInterpreter *my_perl = 0;
    iVars = init_global_struct();
    User::LeaveIfNull(iVars);
#endif
    iPerl = perl_alloc();
    User::LeaveIfNull(iPerl);
    iState = EPerlAllocated;
    perl_construct(iPerl); // returns void
    if (!iStdioInitFunc) {
        iConsole =
          Console::NewL(_L("Perl Console"),
                        TSize(KConsFullScreen, KConsFullScreen));
        iConsoleBuffer =
          (TUint16*)malloc(sizeof(TUint) *
                           KPerlConsoleBufferMaxTChars);
        User::LeaveIfNull(iConsoleBuffer);
        iConsoleUsed = 0;
#ifndef USE_PERLIO
        iStdioInitFunc = &StdioRewire;
#endif
    }
    if (iStdioInitFunc)
        iStdioInitFunc(iStdioInitCookie);
    iReadFunc  = NULL;
    iWriteFunc = NULL;
    iState = EPerlConstructed;
}

EXPORT_C PerlInterpreter* CPerlBase::GetInterpreter()
{
    return (PerlInterpreter*) iPerl;
}

#ifdef PERL_MINIPERL
static void boot_DynaLoader(pTHX_ CV* cv) { }
#else
EXTERN_C void boot_DynaLoader(pTHX_ CV* cv);
#endif

static void xs_init(pTHX)
{
    dXSUB_SYS;
    newXS("DynaLoader::boot_DynaLoader", boot_DynaLoader, __FILE__);
}

EXPORT_C TInt CPerlBase::RunScriptL(const TDesC& aFileName,
                                    int argc,
                                    char **argv,
                                    char *envp[]) {
    TBuf8<KMaxFileName> scriptUtf8;
    TInt error;
    error = CnvUtfConverter::ConvertFromUnicodeToUtf8(scriptUtf8, aFileName);
    User::LeaveIfError(error);
    char *filename = (char*)scriptUtf8.PtrZ();
    struct stat st;
    if (stat(filename, &st) == -1)
        return KErrNotFound;
    if (argc < 2)
        return KErrGeneral; /* Anything better? */
    char **Argv = (char**)malloc(argc * sizeof(char*));
    User::LeaveIfNull(Argv);
    TCleanupItem ArgvCleanupItem = TCleanupItem(free, Argv);
    CleanupStack::PushL(ArgvCleanupItem);
    Argv[0] = "perl";
    if (argv && argc > 2)
        for (int i = 2; i < argc - 1; i++)
            Argv[i] = argv[i];
    Argv[argc - 1] = filename;
    error = this->ParseAndRun(argc, Argv, envp);
    CleanupStack::PopAndDestroy(Argv);
    Argv = 0;
    return error == 0 ? KErrNone : KErrGeneral;
}


EXPORT_C int CPerlBase::Parse(int argc, char *argv[], char *envp[])
{
    if (iState == EPerlConstructed) {
        const char* const NullArgv[] = { "perl", "-e", "0" };
        if (argc == 0 || argv == 0) {
            argc = 3;
            argv = (char**) NullArgv;
        }
        PERL_SYS_INIT(&argc, &argv);
        int parsed = perl_parse(iPerl, xs_init, argc, argv, envp);
        if (parsed == 0)
            iState = EPerlParsed;
        return parsed;
    } else
        return -1;
}

EXPORT_C void CPerlBase::SetupExit()
{
    if (iState == EPerlParsed) {
        diTHX;
        PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
	// PL_perl_destruct level of 2 would be nice but
	// it causes "Unbalanced scopes" for some reason.
        PL_perl_destruct_level = 1;
    }
}

EXPORT_C int CPerlBase::Run()
{
    if (iState == EPerlParsed) {
        SetupExit();
        iState = EPerlRunning;
        int ran = perl_run(iPerl);
        iState = (ran == 0) ? EPerlSuccess : EPerlFailure;
        return ran;
    } else
        return -1;
}

EXPORT_C int CPerlBase::ParseAndRun(int argc, char *argv[], char *envp[])
{
    int parsed = Parse(argc, argv, envp);
    int ran    = (parsed == 0) ? Run() : -1;
    return ran;
}

int CPerlBase::ConsoleReadLine()
{
    if (!iConsole)
        return -EIO;

    TUint currX  = KPerlConsoleNoPos;
    TUint currY  = KPerlConsoleNoPos;
    TUint prevX  = KPerlConsoleNoPos;
    TUint prevY  = KPerlConsoleNoPos;
    TUint maxX   = KPerlConsoleNoPos;
    TUint offset = 0;

    for (;;) {
        TKeyCode code = iConsole->Getch();

        if (code == EKeyLineFeed || code == EKeyEnter) {
            if (offset < KPerlConsoleBufferMaxTChars) {
                iConsoleBuffer[offset++] = '\n';
                iConsole->Printf(_L("\n"));
                iConsoleBuffer[offset++] = 0;
            }
            break;
        }
        else {
            TBool doBackward  = EFalse;
            TBool doBackspace = EFalse;

            prevX = currX;
            prevY = currY;
            if (code == EKeyBackspace) {
                if (offset > 0) {
                    iConsoleBuffer[--offset] = 0;
                    doBackward  = ETrue;
                    doBackspace = ETrue;
                }
            }
            else if (offset < KPerlConsoleBufferMaxTChars) {
                TChar ch = TChar(code);

                if (ch.IsPrint()) {
                    iConsoleBuffer[offset++] = (unsigned short)code;
                    iConsole->Printf(_L("%c"), code);
                }
            }
            currX = iConsole->WhereX();
            currY = iConsole->WhereY();
            if (maxX  == KPerlConsoleNoPos && prevX != KPerlConsoleNoPos &&
                prevY != KPerlConsoleNoPos && currY == prevY + 1)
                maxX = prevX;
            if (doBackward) {
                if (currX > 0)
                    iConsole->SetPos(currX - 1);
                else if (currY > 0)
                    iConsole->SetPos(maxX, currY - 1);
                if (doBackspace) {
                    TUint nowX = iConsole->WhereX();
                    TUint nowY = iConsole->WhereY();
                    iConsole->Printf(_L(" ")); /* scrub */
                    iConsole->SetPos(nowX, nowY);
                }
            }
         }
    }

    return offset;
}

int CPerlBase::ConsoleRead(const int fd, char* buf, int n)
{
    if (iReadFunc)
        return iReadFunc(fd, buf, n);

    if (!iConsole) {
        errno = EIO;
        return -1;
    }

    if (n < 0) {
        errno = EINVAL;
        return -1;
    }

    if (n == 0)
        return 0;

    TBuf8<4 * KPerlConsoleBufferMaxTChars> aBufferUtf8;
    TBuf16<KPerlConsoleBufferMaxTChars>    aBufferUtf16;
    int length = ConsoleReadLine();
    int i;

    iConsoleUsed += length;

    aBufferUtf16.SetLength(length);
    for (i = 0; i < length; i++)
        aBufferUtf16[i] = iConsoleBuffer[i];
    aBufferUtf8.SetLength(4 * length);

    CnvUtfConverter::ConvertFromUnicodeToUtf8(aBufferUtf8, aBufferUtf16);

    char *pUtf8 = (char*)aBufferUtf8.PtrZ();
    int nUtf8 = aBufferUtf8.Size();
    if (nUtf8 > n)
        nUtf8 = n; /* Potential data loss. */
#ifdef PERL_SYMBIAN_CONSOLE_UTF8
    for (i = 0; i < nUtf8; i++)
        buf[i] = pUtf8[i];
#else
    dTHX;
    for (i = 0; i < nUtf8; i+= UTF8SKIP(pUtf8 + i)) {
        unsigned long u = utf8_to_uvchr((U8*)(pUtf8 + i), 0);
        if (u > 0xFF) {
            iConsole->Printf(_L("(keycode > 0xFF)\n"));
            buf[i] = 0;
            return -1;
        }
        buf[i] = u;
    }
#endif
    if (nUtf8 < n)
        buf[nUtf8] = 0;
    return nUtf8;
}

int CPerlBase::ConsoleWrite(const int fd, const char* buf, int n)
{
    if (iWriteFunc)
        return iWriteFunc(fd, buf, n);

    if (!iConsole) {
        errno = EIO;
        return -1;
    }

    if (n < 0) {
        errno = EINVAL;
        return -1;
    }

    if (n == 0)
        return 0;

    int wrote = 0;
#ifdef PERL_SYMBIAN_CONSOLE_UTF8
    dTHX;
    if (is_utf8_string((U8*)buf, n)) {
        for (int i = 0; i < n; i += UTF8SKIP(buf + i)) {
            TChar u = utf8_to_uvchr((U8*)(buf + i), 0);
            iConsole->Printf(_L("%c"), u);
            wrote++;
        }
    } else {
        iConsole->Printf(_L("(malformed utf8: "));
        for (int i = 0; i < n; i++)
            iConsole->Printf(_L("%02x "), buf[i]);
        iConsole->Printf(_L(")\n"));
    }
#else
    for (int i = 0; i < n; i++) {
        iConsole->Printf(_L("%c"), buf[i]);
    }
    wrote = n;
#endif
    iConsoleUsed += wrote;
    return n;
}
Commit	Line	Data
27da23d5	1	/* Copyright (c) 2004-2005 Nokia. All rights reserved. */
d1dd14d1	2
27da23d5	3	/* The CPerlBase class is licensed under the same terms as Perl itself. */
	4
	5	/* See PerlBase.pod for documentation. */
	6
	7	#define PERLBASE_CPP
	8
	9	#include <e32cons.h>
	10	#include <e32keys.h>
	11	#include <utf.h>
	12
	13	#include "PerlBase.h"
	14
	15	const TUint KPerlConsoleBufferMaxTChars = 0x0200;
	16	const TUint KPerlConsoleNoPos = 0xffff;
	17
	18	CPerlBase::CPerlBase()
	19	{
	20	}
	21
	22	EXPORT_C void CPerlBase::Destruct()
	23	{
4dc4bba6	24	dTHX;
27da23d5	25	iState = EPerlDestroying;
	26	if (iConsole) {
	27	iConsole->Printf(_L("[Any key to continue]"));
	28	iConsole->Getch();
	29	}
	30	if (iPerl) {
	31	(void)perl_destruct(iPerl);
	32	perl_free(iPerl);
	33	iPerl = NULL;
	34	PERL_SYS_TERM();
	35	}
	36	if (iConsole) {
	37	delete iConsole;
	38	iConsole = NULL;
	39	}
	40	if (iConsoleBuffer) {
	41	free(iConsoleBuffer);
	42	iConsoleBuffer = NULL;
	43	}
	44	#ifdef PERL_GLOBAL_STRUCT
	45	if (iVars) {
	46	PerlInterpreter* my_perl = NULL;
	47	free_global_struct(iVars);
	48	iVars = NULL;
	49	}
	50	#endif
	51	}
	52
	53	CPerlBase::~CPerlBase()
	54	{
	55	Destruct();
	56	}
	57
43639bac	58	EXPORT_C CPerlBase* CPerlBase::NewInterpreter(TBool aCloseStdlib,
	59	void (aStdioInitFunc)(void),
	60	void *aStdioInitCookie)
	61	{
	62	CPerlBase* self = new (ELeave) CPerlBase;
	63	self->iCloseStdlib = aCloseStdlib;
	64	self->iStdioInitFunc = aStdioInitFunc;
	65	self->iStdioInitCookie = aStdioInitCookie;
	66	self->ConstructL();
	67	PERL_APPCTX_SET(self);
	68	return self;
	69	}
	70
27da23d5	71	EXPORT_C CPerlBase* CPerlBase::NewInterpreterL(TBool aCloseStdlib,
	72	void (aStdioInitFunc)(void),
	73	void *aStdioInitCookie)
	74	{
	75	CPerlBase* self =
	76	CPerlBase::NewInterpreterLC(aCloseStdlib,
	77	aStdioInitFunc,
	78	aStdioInitCookie);
	79	CleanupStack::Pop(self);
	80	return self;
	81	}
	82
	83	EXPORT_C CPerlBase* CPerlBase::NewInterpreterLC(TBool aCloseStdlib,
	84	void (aStdioInitFunc)(void),
	85	void *aStdioInitCookie)
	86	{
	87	CPerlBase* self = new (ELeave) CPerlBase;
	88	CleanupStack::PushL(self);
	89	self->iCloseStdlib = aCloseStdlib;
	90	self->iStdioInitFunc = aStdioInitFunc;
	91	self->iStdioInitCookie = aStdioInitCookie;
	92	self->ConstructL();
	93	PERL_APPCTX_SET(self);
	94	return self;
	95	}
	96
	97	static int _console_stdin(void* cookie, char* buf, int n)
	98	{
	99	return ((CPerlBase*)cookie)->ConsoleRead(0, buf, n);
	100	}
	101
	102	static int _console_stdout(void* cookie, const char* buf, int n)
	103	{
	104	return ((CPerlBase*)cookie)->ConsoleWrite(1, buf, n);
	105	}
	106
	107	static int _console_stderr(void* cookie, const char* buf, int n)
	108	{
	109	return ((CPerlBase*)cookie)->ConsoleWrite(2, buf, n);
	110	}
	111
	112	void CPerlBase::StdioRewire(void *arg) {
	113	_REENT->_sf[0]._cookie = (void*)this;
	114	_REENT->_sf[0]._read = &_console_stdin;
	115	_REENT->_sf[0]._write = 0;
	116	_REENT->_sf[0]._seek = 0;
	117	_REENT->_sf[0]._close = 0;
	118
	119	_REENT->_sf[1]._cookie = (void*)this;
	120	_REENT->_sf[1]._read = 0;
	121	_REENT->_sf[1]._write = &_console_stdout;
	122	_REENT->_sf[1]._seek = 0;
	123	_REENT->_sf[1]._close = 0;
	124
	125	_REENT->_sf[2]._cookie = (void*)this;
	126	_REENT->_sf[2]._read = 0;
	127	_REENT->_sf[2]._write = &_console_stderr;
	128	_REENT->_sf[2]._seek = 0;
	129	_REENT->_sf[2]._close = 0;
	130	}
	131
	132	void CPerlBase::ConstructL()
	133	{
	134	iState = EPerlNone;
135	#ifdef PERL_GLOBAL_STRUCT
136	PerlInterpreter *my_perl = 0;
137	iVars = init_global_struct();
138	User::LeaveIfNull(iVars);
139	#endif
140	iPerl = perl_alloc();
141	User::LeaveIfNull(iPerl);
142	iState = EPerlAllocated;
143	perl_construct(iPerl); // returns void
144	if (!iStdioInitFunc) {
145	iConsole =
146	Console::NewL(_L("Perl Console"),
147	TSize(KConsFullScreen, KConsFullScreen));
148	iConsoleBuffer =
149	(TUint16)malloc(sizeof(TUint)
150	KPerlConsoleBufferMaxTChars);
151	User::LeaveIfNull(iConsoleBuffer);
152	iConsoleUsed = 0;
153	#ifndef USE_PERLIO
154	iStdioInitFunc = &StdioRewire;
155	#endif
156	}
157	if (iStdioInitFunc)
158	iStdioInitFunc(iStdioInitCookie);
159	iReadFunc = NULL;
160	iWriteFunc = NULL;
161	iState = EPerlConstructed;
162	}
163
164	EXPORT_C PerlInterpreter* CPerlBase::GetInterpreter()
165	{
166	return (PerlInterpreter*) iPerl;
167	}
168
169	#ifdef PERL_MINIPERL
170	static void boot_DynaLoader(pTHX_ CV* cv) { }
171	#else
172	EXTERN_C void boot_DynaLoader(pTHX_ CV* cv);
173	#endif
174
175	static void xs_init(pTHX)
176	{
177	dXSUB_SYS;
178	newXS("DynaLoader::boot_DynaLoader", boot_DynaLoader, __FILE__);
179	}
180
181	EXPORT_C TInt CPerlBase::RunScriptL(const TDesC& aFileName,
182	int argc,
183	char **argv,
184	char *envp[]) {
185	TBuf8<KMaxFileName> scriptUtf8;
186	TInt error;
187	error = CnvUtfConverter::ConvertFromUnicodeToUtf8(scriptUtf8, aFileName);
188	User::LeaveIfError(error);
189	char filename = (char)scriptUtf8.PtrZ();
190	struct stat st;
191	if (stat(filename, &st) == -1)
192	return KErrNotFound;
193	if (argc < 2)
194	return KErrGeneral; /* Anything better? */
195	char Argv = (char)malloc(argc * sizeof(char*));
196	User::LeaveIfNull(Argv);
197	TCleanupItem ArgvCleanupItem = TCleanupItem(free, Argv);
198	CleanupStack::PushL(ArgvCleanupItem);
199	Argv[0] = "perl";
200	if (argv && argc > 2)
201	for (int i = 2; i < argc - 1; i++)
202	Argv[i] = argv[i];
203	Argv[argc - 1] = filename;
204	error = this->ParseAndRun(argc, Argv, envp);
205	CleanupStack::PopAndDestroy(Argv);
206	Argv = 0;
207	return error == 0 ? KErrNone : KErrGeneral;
208	}
d1dd14d1	209
27da23d5	210
	211	EXPORT_C int CPerlBase::Parse(int argc, char argv[], char envp[])
	212	{
	213	if (iState == EPerlConstructed) {
	214	const char* const NullArgv[] = { "perl", "-e", "0" };
	215	if (argc == 0 \|\| argv == 0) {
	216	argc = 3;
	217	argv = (char**) NullArgv;
	218	}
	219	PERL_SYS_INIT(&argc, &argv);
	220	int parsed = perl_parse(iPerl, xs_init, argc, argv, envp);
	221	if (parsed == 0)
	222	iState = EPerlParsed;
	223	return parsed;
	224	} else
	225	return -1;
	226	}
	227
	228	EXPORT_C void CPerlBase::SetupExit()
	229	{
	230	if (iState == EPerlParsed) {
	231	diTHX;
	232	PL_exit_flags \|= PERL_EXIT_DESTRUCT_END;
	233	// PL_perl_destruct level of 2 would be nice but
	234	// it causes "Unbalanced scopes" for some reason.
	235	PL_perl_destruct_level = 1;
	236	}
	237	}
	238
	239	EXPORT_C int CPerlBase::Run()
	240	{
	241	if (iState == EPerlParsed) {
	242	SetupExit();
	243	iState = EPerlRunning;
	244	int ran = perl_run(iPerl);
	245	iState = (ran == 0) ? EPerlSuccess : EPerlFailure;
d1dd14d1	246	return ran;
27da23d5	247	} else
	248	return -1;
	249	}
	250
	251	EXPORT_C int CPerlBase::ParseAndRun(int argc, char argv[], char envp[])
	252	{
	253	int parsed = Parse(argc, argv, envp);
	254	int ran = (parsed == 0) ? Run() : -1;
	255	return ran;
	256	}
	257
	258	int CPerlBase::ConsoleReadLine()
	259	{
	260	if (!iConsole)
	261	return -EIO;
	262
	263	TUint currX = KPerlConsoleNoPos;
	264	TUint currY = KPerlConsoleNoPos;
	265	TUint prevX = KPerlConsoleNoPos;
	266	TUint prevY = KPerlConsoleNoPos;
	267	TUint maxX = KPerlConsoleNoPos;
	268	TUint offset = 0;
	269
	270	for (;;) {
	271	TKeyCode code = iConsole->Getch();
	272
	273	if (code == EKeyLineFeed \|\| code == EKeyEnter) {
	274	if (offset < KPerlConsoleBufferMaxTChars) {
	275	iConsoleBuffer[offset++] = '\n';
	276	iConsole->Printf(_L("\n"));
	277	iConsoleBuffer[offset++] = 0;
	278	}
	279	break;
d1dd14d1	280	}
27da23d5	281	else {
	282	TBool doBackward = EFalse;
	283	TBool doBackspace = EFalse;
	284
	285	prevX = currX;
	286	prevY = currY;
	287	if (code == EKeyBackspace) {
	288	if (offset > 0) {
	289	iConsoleBuffer[--offset] = 0;
	290	doBackward = ETrue;
	291	doBackspace = ETrue;
	292	}
	293	}
	294	else if (offset < KPerlConsoleBufferMaxTChars) {
	295	TChar ch = TChar(code);
	296
	297	if (ch.IsPrint()) {
	298	iConsoleBuffer[offset++] = (unsigned short)code;
	299	iConsole->Printf(_L("%c"), code);
	300	}
	301	}
	302	currX = iConsole->WhereX();
	303	currY = iConsole->WhereY();
	304	if (maxX == KPerlConsoleNoPos && prevX != KPerlConsoleNoPos &&
	305	prevY != KPerlConsoleNoPos && currY == prevY + 1)
	306	maxX = prevX;
	307	if (doBackward) {
	308	if (currX > 0)
	309	iConsole->SetPos(currX - 1);
	310	else if (currY > 0)
	311	iConsole->SetPos(maxX, currY - 1);
	312	if (doBackspace) {
	313	TUint nowX = iConsole->WhereX();
	314	TUint nowY = iConsole->WhereY();
	315	iConsole->Printf(_L(" ")); /* scrub */
	316	iConsole->SetPos(nowX, nowY);
	317	}
	318	}
	319	}
	320	}
	321
	322	return offset;
	323	}
	324
	325	int CPerlBase::ConsoleRead(const int fd, char* buf, int n)
	326	{
	327	if (iReadFunc)
	328	return iReadFunc(fd, buf, n);
	329
	330	if (!iConsole) {
	331	errno = EIO;
	332	return -1;
	333	}
d1dd14d1	334
27da23d5	335	if (n < 0) {
	336	errno = EINVAL;
	337	return -1;
	338	}
d1dd14d1	339
27da23d5	340	if (n == 0)
27da23d5	341	return 0;
d1dd14d1	342
27da23d5	343	TBuf8<4 * KPerlConsoleBufferMaxTChars> aBufferUtf8;
	344	TBuf16<KPerlConsoleBufferMaxTChars> aBufferUtf16;
	345	int length = ConsoleReadLine();
d1dd14d1	346	int i;
27da23d5	347
	348	iConsoleUsed += length;
	349
	350	aBufferUtf16.SetLength(length);
	351	for (i = 0; i < length; i++)
	352	aBufferUtf16[i] = iConsoleBuffer[i];
d1dd14d1	353	aBufferUtf8.SetLength(4 * length);
27da23d5	354
	355	CnvUtfConverter::ConvertFromUnicodeToUtf8(aBufferUtf8, aBufferUtf16);
	356
	357	char pUtf8 = (char)aBufferUtf8.PtrZ();
	358	int nUtf8 = aBufferUtf8.Size();
	359	if (nUtf8 > n)
	360	nUtf8 = n; /* Potential data loss. */
	361	#ifdef PERL_SYMBIAN_CONSOLE_UTF8
	362	for (i = 0; i < nUtf8; i++)
	363	buf[i] = pUtf8[i];
	364	#else
	365	dTHX;
	366	for (i = 0; i < nUtf8; i+= UTF8SKIP(pUtf8 + i)) {
	367	unsigned long u = utf8_to_uvchr((U8*)(pUtf8 + i), 0);
	368	if (u > 0xFF) {
	369	iConsole->Printf(_L("(keycode > 0xFF)\n"));
	370	buf[i] = 0;
	371	return -1;
	372	}
	373	buf[i] = u;
d1dd14d1	374	}
27da23d5	375	#endif
	376	if (nUtf8 < n)
	377	buf[nUtf8] = 0;
	378	return nUtf8;
	379	}
	380
	381	int CPerlBase::ConsoleWrite(const int fd, const char* buf, int n)
	382	{
	383	if (iWriteFunc)
	384	return iWriteFunc(fd, buf, n);
	385
	386	if (!iConsole) {
	387	errno = EIO;
	388	return -1;
	389	}
	390
	391	if (n < 0) {
	392	errno = EINVAL;
	393	return -1;
	394	}
	395
	396	if (n == 0)
	397	return 0;
	398
	399	int wrote = 0;
	400	#ifdef PERL_SYMBIAN_CONSOLE_UTF8
	401	dTHX;
	402	if (is_utf8_string((U8*)buf, n)) {
	403	for (int i = 0; i < n; i += UTF8SKIP(buf + i)) {
	404	TChar u = utf8_to_uvchr((U8*)(buf + i), 0);
	405	iConsole->Printf(_L("%c"), u);
	406	wrote++;
	407	}
	408	} else {
	409	iConsole->Printf(_L("(malformed utf8: "));
	410	for (int i = 0; i < n; i++)
	411	iConsole->Printf(_L("%02x "), buf[i]);
	412	iConsole->Printf(_L(")\n"));
	413	}
	414	#else
	415	for (int i = 0; i < n; i++) {
	416	iConsole->Printf(_L("%c"), buf[i]);
	417	}
	418	wrote = n;
	419	#endif
	420	iConsoleUsed += wrote;
	421	return n;
	422	}
	423