encoding.h

Go to the documentation of this file.

#ifndef RUBY_INTERNAL_ENCODING_ENCODING_H            /*-*-C++-*-vi:se ft=cpp:*/
#define RUBY_INTERNAL_ENCODING_ENCODING_H
#include "ruby/oniguruma.h"
#include "ruby/internal/attr/const.h"
#include "ruby/internal/attr/deprecated.h"
#include "ruby/internal/attr/noalias.h"
#include "ruby/internal/attr/pure.h"
#include "ruby/internal/attr/returns_nonnull.h"
#include "ruby/internal/dllexport.h"
#include "ruby/internal/encoding/coderange.h"
#include "ruby/internal/value.h"
#include "ruby/internal/core/rbasic.h"
#include "ruby/internal/fl_type.h"
 
RBIMPL_SYMBOL_EXPORT_BEGIN()
 
 
RUBY_EXTERN VALUE rb_cEncoding;
 
enum ruby_encoding_consts {
 
    RUBY_ENCODING_INLINE_MAX = 127,
 
    RUBY_ENCODING_SHIFT = (RUBY_FL_USHIFT+10),
 
    RUBY_ENCODING_MASK = (RUBY_ENCODING_INLINE_MAX<<RUBY_ENCODING_SHIFT
                          /* RUBY_FL_USER10..RUBY_FL_USER16 */),
 
    RUBY_ENCODING_MAXNAMELEN = 42
};
 
#define ENCODING_INLINE_MAX RUBY_ENCODING_INLINE_MAX 
#define ENCODING_SHIFT RUBY_ENCODING_SHIFT           
#define ENCODING_MASK RUBY_ENCODING_MASK             
static inline void
RB_ENCODING_SET_INLINED(VALUE obj, int encindex)
{
    VALUE f = /* upcast */ RBIMPL_CAST((VALUE)encindex);
 
    f <<= RUBY_ENCODING_SHIFT;
    RB_FL_UNSET_RAW(obj, RUBY_ENCODING_MASK);
    RB_FL_SET_RAW(obj, f);
}
 
static inline int
RB_ENCODING_GET_INLINED(VALUE obj)
{
    VALUE ret = RB_FL_TEST_RAW(obj, RUBY_ENCODING_MASK) >> RUBY_ENCODING_SHIFT;
 
    return RBIMPL_CAST((int)ret);
}
 
#define ENCODING_SET_INLINED(obj,i) RB_ENCODING_SET_INLINED(obj,i) 
#define ENCODING_SET(obj,i) RB_ENCODING_SET(obj,i)                 
#define ENCODING_GET_INLINED(obj) RB_ENCODING_GET_INLINED(obj)     
#define ENCODING_GET(obj) RB_ENCODING_GET(obj)                     
#define ENCODING_IS_ASCII8BIT(obj) RB_ENCODING_IS_ASCII8BIT(obj)   
#define ENCODING_MAXNAMELEN RUBY_ENCODING_MAXNAMELEN               
typedef const OnigEncodingType rb_encoding;
 
RBIMPL_ATTR_NOALIAS()
int rb_char_to_option_kcode(int c, int *option, int *kcode);
 
int rb_define_dummy_encoding(const char *name);
 
RBIMPL_ATTR_PURE()
int rb_enc_dummy_p(rb_encoding *enc);
 
RBIMPL_ATTR_PURE()
int rb_enc_to_index(rb_encoding *enc);
 
int rb_enc_get_index(VALUE obj);
 
static inline int
RB_ENCODING_GET(VALUE obj)
{
    int encindex = RB_ENCODING_GET_INLINED(obj);
 
    if (encindex == RUBY_ENCODING_INLINE_MAX) {
        return rb_enc_get_index(obj);
    }
    else {
        return encindex;
    }
}
 
void rb_enc_set_index(VALUE obj, int encindex);
 
static inline void
RB_ENCODING_SET(VALUE obj, int encindex)
{
    rb_enc_set_index(obj, encindex);
}
 
static inline void
RB_ENCODING_CODERANGE_SET(VALUE obj, int encindex, enum ruby_coderange_type cr)
{
    RB_ENCODING_SET(obj, encindex);
    RB_ENC_CODERANGE_SET(obj, cr);
}
 
RBIMPL_ATTR_PURE()
int rb_enc_capable(VALUE obj);
 
int rb_enc_find_index(const char *name);
 
int rb_enc_alias(const char *alias, const char *orig);
 
int rb_to_encoding_index(VALUE obj);
 
rb_encoding *rb_to_encoding(VALUE obj);
 
rb_encoding *rb_find_encoding(VALUE obj);
 
rb_encoding *rb_enc_get(VALUE obj);
 
rb_encoding *rb_enc_compatible(VALUE str1, VALUE str2);
 
rb_encoding *rb_enc_check(VALUE str1,VALUE str2);
 
VALUE rb_enc_associate_index(VALUE obj, int encindex);
 
VALUE rb_enc_associate(VALUE obj, rb_encoding *enc);
 
void rb_enc_copy(VALUE dst, VALUE src);
 
 
rb_encoding *rb_enc_from_index(int idx);
 
rb_encoding *rb_enc_find(const char *name);
 
static inline const char *
rb_enc_name(rb_encoding *enc)
{
    return enc->name;
}
 
static inline int
rb_enc_mbminlen(rb_encoding *enc)
{
    return enc->min_enc_len;
}
 
static inline int
rb_enc_mbmaxlen(rb_encoding *enc)
{
    return enc->max_enc_len;
}
 
int rb_enc_mbclen(const char *p, const char *e, rb_encoding *enc);
 
int rb_enc_fast_mbclen(const char *p, const char *e, rb_encoding *enc);
 
int rb_enc_precise_mbclen(const char *p, const char *e, rb_encoding *enc);
 
#define MBCLEN_CHARFOUND_P(ret)   ONIGENC_MBCLEN_CHARFOUND_P(ret)   
#define MBCLEN_CHARFOUND_LEN(ret) ONIGENC_MBCLEN_CHARFOUND_LEN(ret) 
#define MBCLEN_INVALID_P(ret)     ONIGENC_MBCLEN_INVALID_P(ret)     
#define MBCLEN_NEEDMORE_P(ret)    ONIGENC_MBCLEN_NEEDMORE_P(ret)    
#define MBCLEN_NEEDMORE_LEN(ret)  ONIGENC_MBCLEN_NEEDMORE_LEN(ret)  
int rb_enc_ascget(const char *p, const char *e, int *len, rb_encoding *enc);
 
unsigned int rb_enc_codepoint_len(const char *p, const char *e, int *len, rb_encoding *enc);
 
static inline unsigned int
rb_enc_codepoint(const char *p, const char *e, rb_encoding *enc)
{
    return rb_enc_codepoint_len(p, e, 0, enc);
    /*                               ^^^
     * This can be `NULL` in C, `nullptr` in C++, and `0` for both.
     * We choose the most portable one here.
     */
}
 
 
static inline OnigCodePoint
rb_enc_mbc_to_codepoint(const char *p, const char *e, rb_encoding *enc)
{
    const OnigUChar *up = RBIMPL_CAST((const OnigUChar *)p);
    const OnigUChar *ue = RBIMPL_CAST((const OnigUChar *)e);
 
    return ONIGENC_MBC_TO_CODE(enc, up, ue);
}
 
int rb_enc_codelen(int code, rb_encoding *enc);
 
static inline int
rb_enc_code_to_mbclen(int c, rb_encoding *enc)
{
    OnigCodePoint uc = RBIMPL_CAST((OnigCodePoint)c);
 
    return ONIGENC_CODE_TO_MBCLEN(enc, uc);
}
 
static inline int
rb_enc_mbcput(unsigned int c, void *buf, rb_encoding *enc)
{
    OnigCodePoint uc = RBIMPL_CAST((OnigCodePoint)c);
    OnigUChar *ubuf = RBIMPL_CAST((OnigUChar *)buf);
 
    return ONIGENC_CODE_TO_MBC(enc, uc, ubuf);
}
 
static inline char *
rb_enc_prev_char(const char *s, const char *p, const char *e, rb_encoding *enc)
{
    const OnigUChar *us = RBIMPL_CAST((const OnigUChar *)s);
    const OnigUChar *up = RBIMPL_CAST((const OnigUChar *)p);
    const OnigUChar *ue = RBIMPL_CAST((const OnigUChar *)e);
    OnigUChar *ur = onigenc_get_prev_char_head(enc, us, up, ue);
 
    return RBIMPL_CAST((char *)ur);
}
 
static inline char *
rb_enc_left_char_head(const char *s, const char *p, const char *e, rb_encoding *enc)
{
    const OnigUChar *us = RBIMPL_CAST((const OnigUChar *)s);
    const OnigUChar *up = RBIMPL_CAST((const OnigUChar *)p);
    const OnigUChar *ue = RBIMPL_CAST((const OnigUChar *)e);
    OnigUChar *ur = onigenc_get_left_adjust_char_head(enc, us, up, ue);
 
    return RBIMPL_CAST((char *)ur);
}
 
static inline char *
rb_enc_right_char_head(const char *s, const char *p, const char *e, rb_encoding *enc)
{
    const OnigUChar *us = RBIMPL_CAST((const OnigUChar *)s);
    const OnigUChar *up = RBIMPL_CAST((const OnigUChar *)p);
    const OnigUChar *ue = RBIMPL_CAST((const OnigUChar *)e);
    OnigUChar *ur = onigenc_get_right_adjust_char_head(enc, us, up, ue);
 
    return RBIMPL_CAST((char *)ur);
}
 
static inline char *
rb_enc_step_back(const char *s, const char *p, const char *e, int n, rb_encoding *enc)
{
    const OnigUChar *us = RBIMPL_CAST((const OnigUChar *)s);
    const OnigUChar *up = RBIMPL_CAST((const OnigUChar *)p);
    const OnigUChar *ue = RBIMPL_CAST((const OnigUChar *)e);
    const OnigUChar *ur = onigenc_step_back(enc, us, up, ue, n);
 
    return RBIMPL_CAST((char *)ur);
}
 
static inline int
rb_enc_asciicompat_inline(rb_encoding *enc)
{
    return rb_enc_mbminlen(enc)==1 && !rb_enc_dummy_p(enc);
}
 
static inline bool
rb_enc_asciicompat(rb_encoding *enc)
{
    if (rb_enc_mbminlen(enc) != 1) {
        return false;
    }
    else if (rb_enc_dummy_p(enc)) {
        return false;
    }
    else {
        return true;
    }
}
 
static inline bool
rb_enc_str_asciicompat_p(VALUE str)
{
    rb_encoding *enc = rb_enc_get(str);
 
    return rb_enc_asciicompat(enc);
}
 
VALUE rb_enc_from_encoding(rb_encoding *enc);
 
RBIMPL_ATTR_PURE()
int rb_enc_unicode_p(rb_encoding *enc);
 
RBIMPL_ATTR_RETURNS_NONNULL()
rb_encoding *rb_ascii8bit_encoding(void);
 
RBIMPL_ATTR_RETURNS_NONNULL()
rb_encoding *rb_utf8_encoding(void);
 
RBIMPL_ATTR_RETURNS_NONNULL()
rb_encoding *rb_usascii_encoding(void);
 
rb_encoding *rb_locale_encoding(void);
 
rb_encoding *rb_filesystem_encoding(void);
 
rb_encoding *rb_default_external_encoding(void);
 
rb_encoding *rb_default_internal_encoding(void);
 
#ifndef rb_ascii8bit_encindex
RBIMPL_ATTR_CONST()
int rb_ascii8bit_encindex(void);
#endif
 
static inline bool
RB_ENCODING_IS_ASCII8BIT(VALUE obj)
{
    return RB_ENCODING_GET_INLINED(obj) == rb_ascii8bit_encindex();
}
 
#ifndef rb_utf8_encindex
RBIMPL_ATTR_CONST()
int rb_utf8_encindex(void);
#endif
 
#ifndef rb_usascii_encindex
RBIMPL_ATTR_CONST()
int rb_usascii_encindex(void);
#endif
 
int rb_locale_encindex(void);
 
int rb_filesystem_encindex(void);
 
VALUE rb_enc_default_external(void);
 
VALUE rb_enc_default_internal(void);
 
void rb_enc_set_default_external(VALUE encoding);
 
void rb_enc_set_default_internal(VALUE encoding);
 
VALUE rb_locale_charmap(VALUE klass);
 
RBIMPL_SYMBOL_EXPORT_END()
 
 
#define RB_ENCODING_GET          RB_ENCODING_GET
#define RB_ENCODING_GET_INLINED  RB_ENCODING_GET_INLINED
#define RB_ENCODING_IS_ASCII8BIT RB_ENCODING_IS_ASCII8BIT
#define RB_ENCODING_SET          RB_ENCODING_SET
#define RB_ENCODING_SET_INLINED  RB_ENCODING_SET_INLINED
#define rb_enc_asciicompat       rb_enc_asciicompat
#define rb_enc_code_to_mbclen    rb_enc_code_to_mbclen
#define rb_enc_codepoint         rb_enc_codepoint
#define rb_enc_left_char_head    rb_enc_left_char_head
#define rb_enc_mbc_to_codepoint  rb_enc_mbc_to_codepoint
#define rb_enc_mbcput            rb_enc_mbcput
#define rb_enc_mbmaxlen          rb_enc_mbmaxlen
#define rb_enc_mbminlen          rb_enc_mbminlen
#define rb_enc_name              rb_enc_name
#define rb_enc_prev_char         rb_enc_prev_char
#define rb_enc_right_char_head   rb_enc_right_char_head
#define rb_enc_step_back         rb_enc_step_back
#define rb_enc_str_asciicompat_p rb_enc_str_asciicompat_p
#endif /* RUBY_INTERNAL_ENCODING_ENCODING_H */