Sep 25, 2024 4 min read
Program Architecture

Just a small peek at the C++ driving the cross platform layer called XPK, for xcross platform kernel.
//
// Copyright 1997-2005 Intermine Pty Ltd, All Rights Reserved.
//
// $Revision: 6721 $
// $Author: sgm $
// $Date: 2006-09-14 14:26:25 +1000 (Thu, 14 Sep 2006) $
// $URL: svn://im-svn/common/trunk/src/xpk/xpk_conversions.cpp $
//

#define svn_id "$Id: xpk_conversions.cpp 6721 2006-09-14 14:26:25 +1000 (Thu, 14 Sep 2006) sgm $"

#define XPK_MT

#include <xpk_core.h>
#include <xpk_conversions.h>
#include <ipe_logger.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/////////////////////////////////////////////////////////////////////

XPK_Trace::XPK_Trace(): _tg(XPK_GetTG()) {
  _tg->incTrace();
}

XPK_Trace::~XPK_Trace() {
  _tg->_traceTop--;
}

void XPK_Trace::add(const char *key, const char *value) {
  _tg->add(key, value);
}

void XPK_Trace::add(const char *key, I64 value) {
  _tg->add(key, value);
}

void XPK_Trace::strings_begin(I32 &handle) {
  _tg->strings_begin(handle);
}

bool XPK_Trace::strings_more(I32 &handle) {
  return _tg->strings_more(handle);
}

void XPK_Trace::strings_next(I32 &handle) {
  _tg->strings_next(handle);
}

void XPK_Trace::strings_entry(const char * &key, const char * &value, I32 &handle) {
  _tg->strings_entry(key, value, handle);
}

void XPK_Trace::numbers_begin(I32 &handle) {
  _tg->numbers_begin(handle);
}

bool XPK_Trace::numbers_more(I32 &handle) {
  return _tg->numbers_more(handle);
}

void XPK_Trace::numbers_next(I32 &handle) {
  _tg->numbers_next(handle);
}

void XPK_Trace::numbers_entry(const char * &key, I64 &value, I32 &handle) {
  _tg->numbers_entry(key, value, handle);
}

void XPK_Trace::decode(char *buffer, I32 length, const char *fmt) {
  *buffer = 0;
  char *rover = buffer, *end = buffer + length;
  XPK_SafeAppend( rover, end, fmt);
}

/////////////////////////////////////////////////////////////////////

XPK_Destructor::XPK_Destructor(XPK_DestructorFunction function, void *data,
                               I32 size): _function(function), _data(data), _size(size), _callMethod(true) {
}

XPK_Destructor::~XPK_Destructor() {
  if (_callMethod) (*_function)(_data, _size);
}

/////////////////////////////////////////////////////////////////////

void XPK_SafeAppend(char * &rover, const char *end, const char *value) {
  if ((rover + strlen(value) + 1) < end) {
    strcpy(rover, value);
    rover += strlen(value);
  }
}

void XPK_SafeAppend(char * &rover, const char *end, const char value) {
  if ((rover + 2) < end) {
    char buffer2[2];
    buffer2[0] = value;
    buffer2[1] = 0;
    strcpy(rover, buffer2);
    rover += strlen(buffer2);
  }
}

/////////////////////////////////////////////////////////////////////

I32 XPK_StringToI32(const char *rover) {
  bool negative = false;
  I32 result = 0;

  if (*rover == '-') {
    negative = true;
    rover++;
  }

  while (*rover && *rover == '0')
  rover++;

  while (*rover && *rover >= '0' && *rover <= '9') {
    result *= 10;
    I32 v = *rover - '0';
    result += v;
    rover++;
  }

  if (negative) result = -result;

  return result;
}

I64 XPK_StringToI64(const char *rover) {
  bool negative = false;
  I64 result = 0;

  if (*rover == '-') {
    negative = true;
    rover++;
  }

  while (*rover && *rover == '0')
  rover++;

  while (*rover && *rover >= '0' && *rover <= '9') {
    result *= 10;
    I64 v = *rover - '0';
    result += v;
    rover++;
  }

  if (negative) result = -result;

  return result;
}

F64 XPK_StringToF64(const char *rover) {
  return atof(rover);
}

void XPK_F64ToString(char *buffer, F64 value) {
  //sprintf(rover, "%lf", value);

        I32 size = 32;

    int ret;
    char *start, *end;
    size_t length;

    ret = _snprintf(buffer, size, "%.17f", value);
    if(ret < 0)
        return;

    length = (size_t)ret;
    if(length >= size)
        return;

    /* Make sure there's a dot or 'e' in the output. Otherwise
       a real is converted to an integer when decoding */
    if(strchr(buffer, '.') == NULL &&
       strchr(buffer, 'e') == NULL)
    {
        if(length + 3 >= size) {
            /* No space to append ".0" */
            return;
        }
        buffer[length] = '.';
        buffer[length + 1] = '0';
        buffer[length + 2] = '\0';
        length += 2;
    }

    /* Remove leading '+' from positive exponent. Also remove leading
       zeros from exponents (added by some printf() implementations) */
    start = strchr(buffer, 'e');
    if(start) {
        start++;
        end = start + 1;

        if(*start == '-')
            start++;

        while(*end == '0')
            end++;

        if(end != start) {
            memmove(start, end, length - (size_t)(end - buffer));
            length -= (size_t)(end - start);
        }
    }

        buffer[length] = 0;
}

void XPK_F64ToString(char *rover, F64 value, I32 decimal) {
  if (decimal == 2) {
    sprintf(rover, "%.2f", value);
  } else if (decimal == 1) {
    sprintf(rover, "%.1f", value);
  } else {
    char conversion[32];
    sprintf(conversion, "%%.%if", decimal);
    sprintf(rover, conversion, value);
  }
}

void XPK_I64ToString(char *rover, I64 value) {
  bool negative = value < 0;

  if (negative) {
    value = -value;
    *rover++ = '-';
  }

  char stack[128];
  I32 stackTop = 0;

  do {
    stack[stackTop++] = (char)('0' + value % 10);
    value = value / 10;
  } while(value > 0);

  while (stackTop) {
    *rover++ = stack[--stackTop];
  }

  *rover = 0;
}

void XPK_I32ToString(char *rover, I32 value) {
  bool negative = value < 0;

  if (negative) {
    value = -value;
    *rover++ = '-';
  }

  char stack[128];
  I32 stackTop = 0;

  do {
    stack[stackTop++] = (char)('0' + value % 10);
    value = value / 10;
  } while(value > 0);

  while (stackTop) {
    *rover++ = stack[--stackTop];
  }

  *rover = 0;
}