Max 5 API Reference

jit.charset.c

/*
 *  jit.charset.c
 *  JitterAPI
 *
 *  Created by Jeremy Bernstein on 24.05.06.
 *  Copyright 2006 Cycling '74. All rights reserved.
 *
 */

#include "ext.h"
#include "ext_obex.h"
#include "ext_strings.h"
#include "jit.common.h"
#include "jit.charset.h"

#ifdef MAC_VERSION
#if !TARGET_RT_MAC_MACHO
#include "jit.charset.iconv.h"
static CFBundleRef sysBundle;
#else
#define LIBICONV_STATIC // this is necessary on PPC
#include <iconv.h>
#endif
#else
#include <windows.h>
#endif

#ifdef MAC_VERSION
typedef iconv_t (*iconv_openPtr)(const char* tocode, const char* fromcode);
typedef size_t (*iconvPtr)(iconv_t cd, const char* * inbuf, size_t *inbytesleft, char* * outbuf, size_t *outbytesleft);
typedef int (*iconv_closePtr)(iconv_t cd);

iconv_openPtr   jit_charset_iconv_open;
iconvPtr        jit_charset_iconv;
iconv_closePtr  jit_charset_iconv_close;

#define charset_iso_8859_1  "ISO-8859-1"
#define charset_utf_8       "UTF-8"
#define charset_utf_16      "UTF-16BE" // we'll use big-endian by default
#define charset_utf_16be    "UTF-16BE"
#define charset_utf_16le    "UTF-16LE"
#define charset_us_ascii    "US-ASCII"
#define charset_macroman    "MACROMAN"
#define charset_ms_ansi     "MS-ANSI" // WINDOWS-1252
#else
#define charset_iso_8859_1  28591 // "ISO-8859-1"
#define charset_utf_8       CP_UTF8
#define charset_utf_16      1201 // "UTF-16", big-endian :: 1200, little-endian
#define charset_utf_16be    1201 // "UTF-16", big-endian :: 1200, little-endian
#define charset_utf_16le    1200 // "UTF-16", big-endian :: 1200, little-endian
#define charset_us_ascii    20127
#define charset_macroman    CP_MACCP
#define charset_ms_ansi     1252 // WINDOWS-1252
#endif

t_symbol *ps_utf_8;
t_symbol *ps_utf_16;
t_symbol *ps_utf_16be;
t_symbol *ps_utf_16le;
t_symbol *ps_iso_8859_1;
t_symbol *ps_us_ascii;
t_symbol *ps_ms_ansi;
t_symbol *ps_macroman;

t_symbol *ps_convert;
t_symbol *ps_jit_charset_converter;

t_class *_jit_charset_converter_class=NULL;

t_jit_err jit_charset_init(void);
t_jit_charset_converter *jit_charset_converter_new(t_symbol *src, t_symbol *dst);
void jit_charset_converter_free(t_jit_charset_converter *x);
t_jit_err jit_charset_converter_convert(t_jit_charset_converter *x, const char *in, long inbytes, char **out, long *outbytes);
void *jit_charset_encoding_sym2enc(t_symbol *encoding);
#ifdef MAC_VERSION
void jit_charset_converter_initialize(t_jit_charset_converter *x);
#if !TARGET_RT_MAC_MACHO
void jit_charset_framework_init(void);
#endif
#endif


t_jit_err jit_charset_init(void)
{
    t_class *c;
    long attrflags=0;
    void *attr;
    
    c = jit_class_new("jit_charset_converter", (method)jit_charset_converter_new, (method)jit_charset_converter_free, 
        (short)sizeof(t_jit_charset_converter), A_CANT, 0);

    jit_class_addmethod(c,(method)jit_charset_converter_convert,            "convert",                  A_CANT, 0);

    jit_class_register(c);  
    _jit_charset_converter_class = c;   

    ps_utf_8        = gensym("utf-8");
    ps_utf_16       = gensym("utf-16");
    ps_utf_16be     = gensym("utf-16be");
    ps_utf_16le     = gensym("utf-16le");
    ps_iso_8859_1   = gensym("iso-8859-1");
    ps_us_ascii     = gensym("us-ascii");
    ps_macroman     = gensym("macroman");
    ps_ms_ansi      = gensym("ms-ansi");
    
    ps_convert      = gensym("convert");
    ps_jit_charset_converter = gensym("jit_charset_converter");
    
    #ifdef MAC_VERSION
    #if !TARGET_RT_MAC_MACHO
    jit_charset_framework_init();
    #else
    jit_charset_iconv_open = iconv_open;
    jit_charset_iconv = iconv;
    jit_charset_iconv_close = iconv_close;
    #endif
    #endif
    
    return 0;
}

#if defined (MAC_VERSION) && (!TARGET_RT_MAC_MACHO)
void jit_charset_framework_init(void)
{
    OSStatus err;
    
    err = LoadFrameworkBundle(CFSTR("System.framework"), &sysBundle);
    if (err == noErr) {
        jit_charset_iconv_open = (iconv_openPtr)CFBundleGetFunctionPointerForName
                    (sysBundle, CFSTR("iconv_open"));
        jit_charset_iconv = (iconvPtr)CFBundleGetFunctionPointerForName
                    (sysBundle, CFSTR("iconv"));
        jit_charset_iconv_close = (iconv_closePtr)CFBundleGetFunctionPointerForName
                    (sysBundle, CFSTR("iconv_close"));
    } else {
        error("jit.charset: error %d in framework_init");
    }
}
#endif

t_jit_charset_converter *jit_charset_converter_new(t_symbol *src, t_symbol *dst)
{
    t_jit_charset_converter *x;

    if (x = (t_jit_charset_converter *)object_alloc(_jit_charset_converter_class)) {
        x->src_encoding = NULL;
        x->dst_encoding = NULL;
        x->conv         = NULL;

        if (src && dst) {
            x->src_encoding = jit_charset_encoding_sym2enc(src);
            x->dst_encoding = jit_charset_encoding_sym2enc(dst);
        }
        if (!(x->src_encoding && x->dst_encoding)) {
            error("jit.charset: could not create new converter (bad or no character set supplied)");
            freeobject((t_object *)x);
            return NULL;
        }
#ifdef MAC_VERSION
        jit_charset_converter_initialize(x);
        if (!x->conv) {
            error("jit.charset: could not create new converter (error initializing converter)");
            freeobject((t_object *)x);
            return NULL;
        }
#endif
    }

    return x;   
}

void jit_charset_converter_free(t_jit_charset_converter *x)
{
#ifdef MAC_VERSION
    if (x->conv) {
        jit_charset_iconv_close(x->conv);
        x->conv = NULL;
    }
#endif
}

#ifdef MAC_VERSION
void jit_charset_converter_initialize(t_jit_charset_converter *x)
{
    x->conv = jit_charset_iconv_open((char *)x->dst_encoding, (char *)x->src_encoding);
    if (!x->conv || x->conv == (void *)0xFFFFFFFF)
        x->conv = NULL;
}
#endif

t_jit_err jit_charset_converter_convert(t_jit_charset_converter *x, const char *in, long inbytes, char **out, long *outbytes)
{
    char *cvtbuffer = NULL;
    long cvtbuffersize = 0;
    long result;
    t_jit_err rv = JIT_ERR_GENERIC;
#ifdef MAC_VERSION
    char *src, *dst;
    size_t srcbytes, dstbytes;
    char *tmpbuffer = NULL;
    long tmpbuffersize = 0;
    char *srcenc;
    char *dstenc;
#else
    WCHAR *widebuffer = NULL;
    long widebuffersize = 0;
    UINT srcenc;
    UINT dstenc;
#endif

    if (!(x && in && inbytes && out && outbytes))
        return JIT_ERR_GENERIC;
    
#ifdef MAC_VERSION
    srcenc = (char *)x->src_encoding;
    dstenc = (char *)x->dst_encoding;
#else
    srcenc = (UINT)x->src_encoding;
    dstenc = (UINT)x->dst_encoding;
#endif

    if (!(srcenc && dstenc))
        return JIT_ERR_GENERIC;
        
#ifdef MAC_VERSION
    tmpbuffersize = inbytes * 4; // UTF-8 can occupy up to 4 bytes per character
    tmpbuffer = sysmem_newptr(tmpbuffersize);
    if (!tmpbuffer) {
        error("jit.charset: memory error allocating temporary character buffer");
        return JIT_ERR_OUT_OF_MEM;
    }
    
    src = (char *)in;
    srcbytes = inbytes;
    dst = tmpbuffer;
    dstbytes = tmpbuffersize;
        
    result = jit_charset_iconv(x->conv, (const char **)&src, &srcbytes, &dst, &dstbytes);
    if (result) {
        error("jit.charset: error %d converting character encodings", result);
        rv = JIT_ERR_GENERIC;
    } else {
        long bytecount = dst - tmpbuffer;
        
        cvtbuffer = sysmem_newptr(bytecount);
        if (!cvtbuffer) {
            error("jit.charset: memory error allocating output character buffer");
            rv = JIT_ERR_OUT_OF_MEM;
        } else {
            sysmem_copyptr(tmpbuffer, cvtbuffer, bytecount);
            *out = cvtbuffer;
            *outbytes = bytecount;
            return JIT_ERR_NONE;
        }
    }
    if (tmpbuffer && tmpbuffersize)
        sysmem_freeptr(tmpbuffer);
    if (cvtbuffer && cvtbuffersize)
        sysmem_freeptr(cvtbuffer);
        
    return rv;
#else
    result = MultiByteToWideChar(srcenc, 0, in, inbytes, NULL, 0);
    if (!result) {
        error("jit.charset: error getting wide character buffer size");
        return JIT_ERR_GENERIC;
    }

    widebuffersize = result * sizeof(WCHAR);
    widebuffer = (WCHAR *)sysmem_newptr(widebuffersize);
    if (!widebuffer) {
        error("jit.charset: memory error allocating wide character buffer");
        return JIT_ERR_OUT_OF_MEM;
    }
    
    result = MultiByteToWideChar(srcenc, 0, in, inbytes, widebuffer, widebuffersize);
    if (!result) {
        error("jit.charset: error converting string to wide character buffer");
        rv = JIT_ERR_GENERIC;
        goto bail;
    }

    result = WideCharToMultiByte(dstenc, 0, widebuffer, widebuffersize / sizeof(WCHAR), NULL, 0, NULL, NULL);
    if (!result) {
        error("jit.charset: error getting multibyte character buffer size");
        rv = JIT_ERR_GENERIC;
        goto bail;
    }

    cvtbuffersize = result;
    cvtbuffer = sysmem_newptr(cvtbuffersize);
    if (!cvtbuffer) {
        error("jit.charset: memory error allocating multibyte character buffer");
        rv = JIT_ERR_OUT_OF_MEM;
        goto bail;
    }
    result = WideCharToMultiByte(dstenc, 0, widebuffer, widebuffersize / sizeof(WCHAR), cvtbuffer, cvtbuffersize, NULL, NULL);
    if (!result) {
        error("jit.charset: error converting wide string to multibyte character buffer");
        rv = JIT_ERR_GENERIC;
        goto bail;
    }
    sysmem_freeptr(widebuffer);
    *out = cvtbuffer;
    *outbytes = cvtbuffersize;
    return JIT_ERR_NONE;
    
bail:
    if (widebuffer && widebuffersize)
        sysmem_freeptr(widebuffer);
    if (cvtbuffer && cvtbuffersize)
        sysmem_freeptr(cvtbuffer);

    return rv;
#endif
}

void *jit_charset_encoding_sym2enc(t_symbol *encoding)
{
    if (encoding == ps_utf_8)
        return (void *)charset_utf_8;
    if (encoding == ps_utf_16)
        return (void *)charset_utf_16;
    if (encoding == ps_iso_8859_1)
        return (void *)charset_iso_8859_1;
    if (encoding == ps_us_ascii)
        return (void *)charset_us_ascii;
    if (encoding == ps_ms_ansi)
        return (void *)charset_ms_ansi;
    if (encoding == ps_macroman)
        return (void *)charset_macroman;
    if (encoding == ps_utf_16be)
        return (void *)charset_utf_16be;
    if (encoding == ps_utf_16le)
        return (void *)charset_utf_16le;
        
    return NULL;
}

t_symbol *jit_charset_encoding_checkvalid(t_symbol *encoding)
{
    if (encoding == ps_utf_8 ||
        encoding == ps_utf_16 ||
        encoding == ps_iso_8859_1 ||
        encoding == ps_us_ascii ||
        encoding == ps_ms_ansi ||
        encoding == ps_macroman ||
        encoding == ps_utf_16be ||
        encoding == ps_utf_16le)
    {
        return encoding;
    }
    return NULL;
}

Copyright © 2008, Cycling '74