void do_getabsolute(char* result, const char* value, const char* relative_to)
{
int i;
char* ch;
char* prev;
char buffer[0x4000] = { '\0' };
/* if the path is not already absolute, base it on working dir */
if (!do_isabsolute(value)) {
if (relative_to) {
strcpy(buffer, relative_to);
}
else {
do_getcwd(buffer, 0x4000);
}
strcat(buffer, "/");
}
/* normalize the path */
strcat(buffer, value);
do_translate(buffer, '/');
/* process it part by part */
result[0] = '\0';
if (buffer[0] == '/') {
strcat(result, "/");
}
prev = NULL;
ch = strtok(buffer, "/");
while (ch) {
/* remove ".." where I can */
if (strcmp(ch, "..") == 0 && (prev == NULL || (prev[0] != '$' && prev[0] != '%' && strcmp(prev, "..") != 0))) {
i = strlen(result) - 2;
while (i >= 0 && result[i] != '/') {
--i;
}
if (i >= 0) {
result[i + 1] = '\0';
}
ch = NULL;
}
/* allow everything except "." */
else if (strcmp(ch, ".") != 0) {
strcat(result, ch);
strcat(result, "/");
}
prev = ch;
ch = strtok(NULL, "/");
}
/* remove trailing slash */
i = strlen(result) - 1;
if (result[i] == '/') {
result[i] = '\0';
}
}
int do_getcwd(char* buffer, size_t size)
{
int result;
#if PLATFORM_WINDOWS
result = (GetCurrentDirectory(size, buffer) != 0);
if (result) {
do_translate(buffer, '/');
}
#else
result = (getcwd(buffer, size) != 0);
#endif
return result;
}
int SIO_WriteBuffer(SIO_INFO *s,char *buf,int len)
{
#ifndef __palmos__
int ret;
#endif
if (s!=NULL) {
do_translate(s,buf,len,1);
#ifdef WINDOWS
{
DWORD got,err;
sio_init_overlapped(s);
if (WriteFile(s->fd,buf,len,&got,s->overlapped)) {
ret=got;
} else {
/* handle overlapped stuff */
err=GetLastError();
if (err==ERROR_IO_PENDING) {
/* TODO: write timeout should be handled differently! */
if (sio_wait_overlapped(s,s->read_timeout))
ret=len;
else
ret=(-1);
} else {
/* some error other than overlapped I/O not yet
* complete is a real error
*/
ret=(-1);
}
}
}
return(ret);
#elif defined( __palmos__ )
if( SerSend10( s->fd, buf, (ULong)len )==0 ) {
if( SerSendWait( s->fd, -1 )==0 ) return( len );
else return(-2);
} else return(-3);
#else /* !WINDOWS && !__palmos__ */
ret=write(s->fd,buf,len);
return(ret);
#endif /* WINDOWS */
}
return(-1);
}
static void normalize(char* buffer, const char* path)
{
char* src;
char* dst;
char last;
strcpy(buffer, path);
do_translate(buffer, '/');
/* remove any duplicate slashes within the path */
src = buffer;
dst = buffer;
last = '\0';
while (*src != '\0') {
/* if I don't have consecutive slashes, keep the char */
if (*src != '/' || last != '/') {
*(dst++) = *src;
}
/* Allow double-slash at the start of the string, so absolute
* UNC paths can be expressed, but nowhere else */
if (src != buffer) {
last = (*src);
}
/* check the next one */
++src;
}
/* remove any trailing slashes */
for (--src; src > buffer && *src == '/'; --src) {
*src = '\0';
}
*dst = '\0';
}
int path_getrelative(lua_State* L)
{
int i, last, count;
char src[0x4000];
char dst[0x4000];
const char* p1 = luaL_checkstring(L, 1);
const char* p2 = luaL_checkstring(L, 2);
/* normalize the paths */
strcpy(src, p1);
do_translate(src, '/');
strcpy(dst, p2);
do_translate(dst, '/');
/* same directory? */
if (strcmp(src, dst) == 0) {
lua_pushstring(L, ".");
return 1;
}
/* dollar macro? Can't tell what the real path might be, so treat
* as absolute. This enables paths like $(SDK_ROOT)/include to
* work as expected. */
if (dst[0] == '$') {
lua_pushstring(L, dst);
return 1;
}
/* find the common leading directories */
strcat(src, "/");
strcat(dst, "/");
last = -1;
i = 0;
while (src[i] && dst[i] && src[i] == dst[i]) {
if (src[i] == '/') {
last = i;
}
++i;
}
/* if they have nothing in common return absolute path */
if (last <= 0) {
dst[strlen(dst) - 1] = '\0';
lua_pushstring(L, dst);
return 1;
}
/* count remaining levels in src */
count = 0;
for (i = last + 1; src[i] != '\0'; ++i) {
if (src[i] == '/') {
++count;
}
}
/* start my result by backing out that many levels */
src[0] = '\0';
for (i = 0; i < count; ++i) {
strcat(src, "../");
}
/* append what's left */
strcat(src, dst + last + 1);
/* remove trailing slash and done */
src[strlen(src) - 1] = '\0';
lua_pushstring(L, src);
return 1;
}
static void translate(char* result, const char* value, const char sep)
{
strcpy(result, value);
do_translate(result, sep);
}
inline char* Allocator::translate(ref_type ref) const noexcept
{
return do_translate(ref);
}
int SIO_ReadChar(SIO_INFO *s)
{
unsigned char ch;
if (s!=NULL) {
#ifdef WINDOWS
if (SIO_WaitForData(s,s->read_timeout)>0) {
DWORD got,err;
sio_init_overlapped(s);
if (!ReadFile(s->fd,&ch,1,&got,s->overlapped)) {
/* handle overlapped stuff */
err=GetLastError();
if (err==ERROR_IO_PENDING) {
if (!sio_wait_overlapped(s,s->read_timeout)) {
got=0;
}
} else return(-1);
}
if (got==0)
return(-1);
#elif defined( __palmos__ )
Long timeout;
timeout = (( s->read_timeout * sysTicksPerSecond ) / 1000000 ) + 1;
if( SerReceive10( s->fd, &ch, 1, timeout )==0 ) {
#else /* !WINDOWS && !__palmos__ */
if (SIO_WaitForData(s,s->read_timeout)>0) {
if (read(s->fd,&ch,1)!=1)
return (-1);
#endif /* WINDOWS */
do_translate(s,&ch,1,0);
return (ch);
}
}
return(-1);
}
int SIO_ReadBuffer(SIO_INFO *s,char *buf,int len)
{
int i,ch;
/* the following simply calls into SIO_ReadChar and works
* fine ... I've changed to this as the Win32 stuff wasn't
* behaving the way I expected for multiple chars and at
* the moment I don't want to think too hard about it
*/
/* Also fine for PalmOS 1 compatibility.
*/
for(i=0;i<len;i++) {
ch=SIO_ReadChar(s);
if (ch==-1)
break;
buf[i]=ch & 0xff;
}
if (i==0)
return(-1);
else
return (i);
}
int SIO_WriteChar(SIO_INFO *s,int data)
{
#ifndef __palmos__
int ret;
#endif
unsigned char ch;
if (s!=NULL) {
ch=data & 0xff;
do_translate(s,&ch,1,1);
#ifdef WINDOWS
{
DWORD got,err;
sio_init_overlapped(s);
if (WriteFile(s->fd,&ch,1,&got,s->overlapped)) {
ret=got;
} else {
/* handle overlapped stuff */
err=GetLastError();
if (err==ERROR_IO_PENDING) {
/* TODO: write timeout should be handled differently! */
if (sio_wait_overlapped(s,s->read_timeout))
ret=1;
else
ret=(-1);
} else {
/* some error other than overlapped I/O not yet
* complete is a real error
*/
ret=(-1);
}
}
}
return(ret);
#elif defined( __palmos__ )
if( SerSend10( s->fd, &ch, 1 )==0 )
if( SerSendWait( s->fd, -1 )==0 ) return( 1 );
#else /* !WINDOWS && !__palmos__ */
ret=write(s->fd,&ch,1);
return(ret);
#endif /* WINDOWS */
}
return(-1);
}
inline void SpatialSceneBuilder::translate(double x, double y, double z)
{
do_translate(math::Vec3(x,y,z));
}
inline void SpatialSceneBuilder::translate(math::Vec3 v)
{
do_translate(v);
}
