[perl5.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
    {
	PerlInterpreter *my_perl = iPerl;
	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
    }
    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_buf((U8*)(pUtf8 + i),
                                            (U8*)(pUtf8 + nUtf8),
                                            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 = valid_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 JH	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 JH	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 AR	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 JH	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
8e920bd3 Z	144	{
	145	PerlInterpreter *my_perl = iPerl;
	146	PL_exit_flags \|= PERL_EXIT_DESTRUCT_END;
	147	}
27da23d5 JH	148	if (!iStdioInitFunc) {
	149	iConsole =
	150	Console::NewL(_L("Perl Console"),
	151	TSize(KConsFullScreen, KConsFullScreen));
	152	iConsoleBuffer =
	153	(TUint16)malloc(sizeof(TUint)
	154	KPerlConsoleBufferMaxTChars);
	155	User::LeaveIfNull(iConsoleBuffer);
	156	iConsoleUsed = 0;
	157	#ifndef USE_PERLIO
	158	iStdioInitFunc = &StdioRewire;
	159	#endif
	160	}
	161	if (iStdioInitFunc)
	162	iStdioInitFunc(iStdioInitCookie);
	163	iReadFunc = NULL;
	164	iWriteFunc = NULL;
	165	iState = EPerlConstructed;
	166	}
	167
	168	EXPORT_C PerlInterpreter* CPerlBase::GetInterpreter()
	169	{
	170	return (PerlInterpreter*) iPerl;
	171	}
	172
	173	#ifdef PERL_MINIPERL
	174	static void boot_DynaLoader(pTHX_ CV* cv) { }
	175	#else
	176	EXTERN_C void boot_DynaLoader(pTHX_ CV* cv);
	177	#endif
	178
	179	static void xs_init(pTHX)
	180	{
	181	dXSUB_SYS;
	182	newXS("DynaLoader::boot_DynaLoader", boot_DynaLoader, __FILE__);
	183	}
	184
	185	EXPORT_C TInt CPerlBase::RunScriptL(const TDesC& aFileName,
	186	int argc,
	187	char **argv,
	188	char *envp[]) {
	189	TBuf8<KMaxFileName> scriptUtf8;
	190	TInt error;
	191	error = CnvUtfConverter::ConvertFromUnicodeToUtf8(scriptUtf8, aFileName);
	192	User::LeaveIfError(error);
	193	char filename = (char)scriptUtf8.PtrZ();
	194	struct stat st;
	195	if (stat(filename, &st) == -1)
	196	return KErrNotFound;
	197	if (argc < 2)
	198	return KErrGeneral; /* Anything better? */
	199	char Argv = (char)malloc(argc * sizeof(char*));
	200	User::LeaveIfNull(Argv);
	201	TCleanupItem ArgvCleanupItem = TCleanupItem(free, Argv);
	202	CleanupStack::PushL(ArgvCleanupItem);
	203	Argv[0] = "perl";
	204	if (argv && argc > 2)
	205	for (int i = 2; i < argc - 1; i++)
	206	Argv[i] = argv[i];
	207	Argv[argc - 1] = filename;
	208	error = this->ParseAndRun(argc, Argv, envp);
	209	CleanupStack::PopAndDestroy(Argv);
	210	Argv = 0;
	211	return error == 0 ? KErrNone : KErrGeneral;
212	}
d1dd14d1	213
27da23d5 JH	214
	215	EXPORT_C int CPerlBase::Parse(int argc, char argv[], char envp[])
	216	{
	217	if (iState == EPerlConstructed) {
	218	const char* const NullArgv[] = { "perl", "-e", "0" };
	219	if (argc == 0 \|\| argv == 0) {
	220	argc = 3;
	221	argv = (char**) NullArgv;
	222	}
	223	PERL_SYS_INIT(&argc, &argv);
	224	int parsed = perl_parse(iPerl, xs_init, argc, argv, envp);
	225	if (parsed == 0)
	226	iState = EPerlParsed;
	227	return parsed;
	228	} else
	229	return -1;
	230	}
	231
	232	EXPORT_C void CPerlBase::SetupExit()
	233	{
	234	if (iState == EPerlParsed) {
	235	diTHX;
	236	PL_exit_flags \|= PERL_EXIT_DESTRUCT_END;
	237	// PL_perl_destruct level of 2 would be nice but
	238	// it causes "Unbalanced scopes" for some reason.
	239	PL_perl_destruct_level = 1;
	240	}
	241	}
	242
	243	EXPORT_C int CPerlBase::Run()
	244	{
	245	if (iState == EPerlParsed) {
	246	SetupExit();
	247	iState = EPerlRunning;
	248	int ran = perl_run(iPerl);
	249	iState = (ran == 0) ? EPerlSuccess : EPerlFailure;
d1dd14d1	250	return ran;
27da23d5 JH	251	} else
	252	return -1;
	253	}
	254
	255	EXPORT_C int CPerlBase::ParseAndRun(int argc, char argv[], char envp[])
	256	{
	257	int parsed = Parse(argc, argv, envp);
	258	int ran = (parsed == 0) ? Run() : -1;
	259	return ran;
	260	}
	261
	262	int CPerlBase::ConsoleReadLine()
	263	{
	264	if (!iConsole)
	265	return -EIO;
	266
	267	TUint currX = KPerlConsoleNoPos;
	268	TUint currY = KPerlConsoleNoPos;
	269	TUint prevX = KPerlConsoleNoPos;
	270	TUint prevY = KPerlConsoleNoPos;
	271	TUint maxX = KPerlConsoleNoPos;
	272	TUint offset = 0;
	273
	274	for (;;) {
	275	TKeyCode code = iConsole->Getch();
	276
	277	if (code == EKeyLineFeed \|\| code == EKeyEnter) {
	278	if (offset < KPerlConsoleBufferMaxTChars) {
	279	iConsoleBuffer[offset++] = '\n';
	280	iConsole->Printf(_L("\n"));
	281	iConsoleBuffer[offset++] = 0;
	282	}
	283	break;
d1dd14d1	284	}
27da23d5 JH	285	else {
	286	TBool doBackward = EFalse;
	287	TBool doBackspace = EFalse;
	288
	289	prevX = currX;
	290	prevY = currY;
	291	if (code == EKeyBackspace) {
	292	if (offset > 0) {
	293	iConsoleBuffer[--offset] = 0;
	294	doBackward = ETrue;
	295	doBackspace = ETrue;
	296	}
	297	}
	298	else if (offset < KPerlConsoleBufferMaxTChars) {
	299	TChar ch = TChar(code);
	300
	301	if (ch.IsPrint()) {
	302	iConsoleBuffer[offset++] = (unsigned short)code;
	303	iConsole->Printf(_L("%c"), code);
	304	}
	305	}
	306	currX = iConsole->WhereX();
	307	currY = iConsole->WhereY();
	308	if (maxX == KPerlConsoleNoPos && prevX != KPerlConsoleNoPos &&
	309	prevY != KPerlConsoleNoPos && currY == prevY + 1)
	310	maxX = prevX;
	311	if (doBackward) {
	312	if (currX > 0)
	313	iConsole->SetPos(currX - 1);
	314	else if (currY > 0)
	315	iConsole->SetPos(maxX, currY - 1);
	316	if (doBackspace) {
	317	TUint nowX = iConsole->WhereX();
	318	TUint nowY = iConsole->WhereY();
	319	iConsole->Printf(_L(" ")); /* scrub */
	320	iConsole->SetPos(nowX, nowY);
	321	}
	322	}
	323	}
	324	}
	325
	326	return offset;
	327	}
	328
	329	int CPerlBase::ConsoleRead(const int fd, char* buf, int n)
	330	{
	331	if (iReadFunc)
	332	return iReadFunc(fd, buf, n);
	333
	334	if (!iConsole) {
	335	errno = EIO;
	336	return -1;
	337	}
d1dd14d1	338
27da23d5 JH	339	if (n < 0) {
	340	errno = EINVAL;
	341	return -1;
	342	}
d1dd14d1	343
27da23d5 JH	344	if (n == 0)
27da23d5 JH	345	return 0;
d1dd14d1	346
27da23d5 JH	347	TBuf8<4 * KPerlConsoleBufferMaxTChars> aBufferUtf8;
	348	TBuf16<KPerlConsoleBufferMaxTChars> aBufferUtf16;
	349	int length = ConsoleReadLine();
d1dd14d1	350	int i;
27da23d5 JH	351
	352	iConsoleUsed += length;
	353
	354	aBufferUtf16.SetLength(length);
	355	for (i = 0; i < length; i++)
	356	aBufferUtf16[i] = iConsoleBuffer[i];
d1dd14d1	357	aBufferUtf8.SetLength(4 * length);
27da23d5 JH	358
	359	CnvUtfConverter::ConvertFromUnicodeToUtf8(aBufferUtf8, aBufferUtf16);
	360
	361	char pUtf8 = (char)aBufferUtf8.PtrZ();
	362	int nUtf8 = aBufferUtf8.Size();
	363	if (nUtf8 > n)
	364	nUtf8 = n; /* Potential data loss. */
	365	#ifdef PERL_SYMBIAN_CONSOLE_UTF8
	366	for (i = 0; i < nUtf8; i++)
	367	buf[i] = pUtf8[i];
	368	#else
	369	dTHX;
	370	for (i = 0; i < nUtf8; i+= UTF8SKIP(pUtf8 + i)) {
4b88fb76 KW	371	unsigned long u = utf8_to_uvchr_buf((U8*)(pUtf8 + i),
	372	(U8*)(pUtf8 + nUtf8),
	373	0);
27da23d5 JH	374	if (u > 0xFF) {
	375	iConsole->Printf(_L("(keycode > 0xFF)\n"));
	376	buf[i] = 0;
	377	return -1;
	378	}
	379	buf[i] = u;
d1dd14d1	380	}
27da23d5 JH	381	#endif
	382	if (nUtf8 < n)
	383	buf[nUtf8] = 0;
	384	return nUtf8;
	385	}
	386
	387	int CPerlBase::ConsoleWrite(const int fd, const char* buf, int n)
	388	{
	389	if (iWriteFunc)
	390	return iWriteFunc(fd, buf, n);
	391
	392	if (!iConsole) {
	393	errno = EIO;
	394	return -1;
	395	}
	396
	397	if (n < 0) {
	398	errno = EINVAL;
	399	return -1;
	400	}
	401
	402	if (n == 0)
	403	return 0;
	404
	405	int wrote = 0;
	406	#ifdef PERL_SYMBIAN_CONSOLE_UTF8
	407	dTHX;
	408	if (is_utf8_string((U8*)buf, n)) {
	409	for (int i = 0; i < n; i += UTF8SKIP(buf + i)) {
4b88fb76	410	TChar u = valid_utf8_to_uvchr((U8*)(buf + i), 0);
27da23d5 JH	411	iConsole->Printf(_L("%c"), u);
	412	wrote++;
	413	}
	414	} else {
	415	iConsole->Printf(_L("(malformed utf8: "));
	416	for (int i = 0; i < n; i++)
	417	iConsole->Printf(_L("%02x "), buf[i]);
	418	iConsole->Printf(_L(")\n"));
	419	}
	420	#else
	421	for (int i = 0; i < n; i++) {
	422	iConsole->Printf(_L("%c"), buf[i]);
	423	}
	424	wrote = n;
	425	#endif
	426	iConsoleUsed += wrote;
	427	return n;
	428	}
	429