string.h

Go to the documentation of this file.

#ifndef RBIMPL_INTERN_STRING_H                       /*-*-C++-*-vi:se ft=cpp:*/
#define RBIMPL_INTERN_STRING_H
#include "ruby/internal/config.h"
 
#ifdef STDC_HEADERS
# include <stddef.h>
#endif
 
#ifdef HAVE_STRING_H
# include <string.h>
#endif
 
#ifdef HAVE_STDINT_H
# include <stdint.h>
#endif
 
#include "ruby/internal/attr/deprecated.h"
#include "ruby/internal/attr/nonnull.h"
#include "ruby/internal/attr/pure.h"
#include "ruby/internal/constant_p.h"
#include "ruby/internal/dllexport.h"
#include "ruby/internal/value.h"
#include "ruby/internal/variable.h" /* rb_gvar_setter_t */
#include "ruby/st.h"         /* st_index_t */
 
RBIMPL_SYMBOL_EXPORT_BEGIN()
 
/* string.c */
 
 
VALUE rb_str_new(const char *ptr, long len);
 
VALUE rb_str_new_cstr(const char *ptr);
 
VALUE rb_str_new_shared(VALUE str);
 
VALUE rb_str_new_frozen(VALUE str);
 
VALUE rb_str_new_with_class(VALUE obj, const char *ptr, long len);
 
VALUE rb_external_str_new(const char *ptr, long len);
 
RBIMPL_ATTR_NONNULL(())
VALUE rb_external_str_new_cstr(const char *ptr);
 
VALUE rb_locale_str_new(const char *ptr, long len);
 
RBIMPL_ATTR_NONNULL(())
VALUE rb_locale_str_new_cstr(const char *ptr);
 
VALUE rb_filesystem_str_new(const char *ptr, long len);
 
RBIMPL_ATTR_NONNULL(())
VALUE rb_filesystem_str_new_cstr(const char *ptr);
 
VALUE rb_str_buf_new(long capa);
 
RBIMPL_ATTR_NONNULL(())
VALUE rb_str_buf_new_cstr(const char *ptr);
 
VALUE rb_str_tmp_new(long len);
 
VALUE rb_str_no_gvl_safe_acquire(VALUE orig);
 
void rb_str_no_gvl_safe_release(VALUE orig, VALUE tmp);
 
VALUE rb_usascii_str_new(const char *ptr, long len);
 
VALUE rb_usascii_str_new_cstr(const char *ptr);
 
VALUE rb_utf8_str_new(const char *ptr, long len);
 
VALUE rb_utf8_str_new_cstr(const char *ptr);
 
VALUE rb_str_new_static(const char *ptr, long len);
 
VALUE rb_usascii_str_new_static(const char *ptr, long len);
 
VALUE rb_utf8_str_new_static(const char *ptr, long len);
 
VALUE rb_str_to_interned_str(VALUE str);
 
VALUE rb_interned_str(const char *ptr, long len);
 
RBIMPL_ATTR_NONNULL(())
VALUE rb_interned_str_cstr(const char *ptr);
 
void rb_str_free(VALUE str);
 
void rb_str_shared_replace(VALUE dst, VALUE src);
 
VALUE rb_str_buf_append(VALUE dst, VALUE src);
 
VALUE rb_str_buf_cat(VALUE, const char*, long);
 
VALUE rb_str_buf_cat2(VALUE, const char*);
 
RBIMPL_ATTR_NONNULL(())
VALUE rb_str_buf_cat_ascii(VALUE dst, const char *src);
 
VALUE rb_obj_as_string(VALUE obj);
 
VALUE rb_check_string_type(VALUE obj);
 
void rb_must_asciicompat(VALUE obj);
 
VALUE rb_str_dup(VALUE str);
 
VALUE rb_str_resurrect(VALUE str);
 
VALUE rb_str_locktmp(VALUE str);
 
VALUE rb_str_unlocktmp(VALUE str);
 
VALUE rb_str_dup_frozen(VALUE);
 
#define rb_str_dup_frozen rb_str_new_frozen
 
VALUE rb_str_plus(VALUE lhs, VALUE rhs);
 
VALUE rb_str_times(VALUE str, VALUE num);
 
long rb_str_sublen(VALUE str, long pos);
 
VALUE rb_str_substr(VALUE str, long beg, long len);
 
VALUE rb_str_subseq(VALUE str, long beg, long len);
 
char *rb_str_subpos(VALUE str, long beg, long *len);
 
void rb_str_modify(VALUE str);
 
void rb_str_modify_expand(VALUE str, long capa);
 
VALUE rb_str_freeze(VALUE str);
 
void rb_str_set_len(VALUE str, long len);
 
VALUE rb_str_resize(VALUE str, long len);
 
VALUE rb_str_cat(VALUE dst, const char *src, long srclen);
 
VALUE rb_str_cat_cstr(VALUE dst, const char *src);
 
VALUE rb_str_cat2(VALUE, const char*);
 
VALUE rb_str_append(VALUE dst, VALUE src);
 
VALUE rb_str_concat(VALUE dst, VALUE src);
 
/* random.c */
 
st_index_t rb_memhash(const void *ptr, long len);
 
st_index_t rb_hash_start(st_index_t i);
 
#define rb_hash_uint32(h, i) st_hash_uint32((h), (i))
 
#define rb_hash_uint(h, i) st_hash_uint((h), (i))
 
#define rb_hash_end(h) st_hash_end(h)
 
/* string.c */
 
st_index_t rb_str_hash(VALUE str);
 
int rb_str_hash_cmp(VALUE str1, VALUE str2);
 
int rb_str_comparable(VALUE str1, VALUE str2);
 
int rb_str_cmp(VALUE lhs, VALUE rhs);
 
VALUE rb_str_equal(VALUE str1, VALUE str2);
 
VALUE rb_str_drop_bytes(VALUE str, long len);
 
void rb_str_update(VALUE dst, long beg, long len, VALUE src);
 
VALUE rb_str_replace(VALUE dst, VALUE src);
 
VALUE rb_str_inspect(VALUE str);
 
VALUE rb_str_dump(VALUE str);
 
VALUE rb_str_split(VALUE str, const char *delim);
 
rb_gvar_setter_t rb_str_setter;
 
/* symbol.c */
 
VALUE rb_str_intern(VALUE str);
 
/* string.c */
 
VALUE rb_sym_to_s(VALUE sym);
 
long rb_str_strlen(VALUE str);
 
VALUE rb_str_length(VALUE);
 
long rb_str_offset(VALUE str, long pos);
 
RBIMPL_ATTR_PURE()
size_t rb_str_capacity(VALUE str);
 
VALUE rb_str_ellipsize(VALUE str, long len);
 
VALUE rb_str_scrub(VALUE str, VALUE repl);
 
VALUE rb_str_succ(VALUE orig);
 
RBIMPL_ATTR_NONNULL(())
static inline long
rbimpl_strlen(const char *str)
{
    return RBIMPL_CAST((long)strlen(str));
}
 
RBIMPL_ATTR_NONNULL(())
static inline VALUE
rbimpl_str_new_cstr(const char *str)
{
    long len = rbimpl_strlen(str);
    return rb_str_new_static(str, len);
}
 
RBIMPL_ATTR_NONNULL(())
static inline VALUE
rbimpl_usascii_str_new_cstr(const char *str)
{
    long len = rbimpl_strlen(str);
    return rb_usascii_str_new_static(str, len);
}
 
RBIMPL_ATTR_NONNULL(())
static inline VALUE
rbimpl_utf8_str_new_cstr(const char *str)
{
    long len = rbimpl_strlen(str);
    return rb_utf8_str_new_static(str, len);
}
 
RBIMPL_ATTR_NONNULL(())
static inline VALUE
rbimpl_external_str_new_cstr(const char *str)
{
    long len = rbimpl_strlen(str);
    return rb_external_str_new(str, len);
}
 
RBIMPL_ATTR_NONNULL(())
static inline VALUE
rbimpl_locale_str_new_cstr(const char *str)
{
    long len = rbimpl_strlen(str);
    return rb_locale_str_new(str, len);
}
 
RBIMPL_ATTR_NONNULL(())
static inline VALUE
rbimpl_str_buf_new_cstr(const char *str)
{
    long len = rbimpl_strlen(str);
    VALUE buf = rb_str_buf_new(len);
    return rb_str_buf_cat(buf, str, len);
}
 
RBIMPL_ATTR_NONNULL(())
static inline VALUE
rbimpl_str_cat_cstr(VALUE buf, const char *str)
{
    long len = rbimpl_strlen(str);
    return rb_str_cat(buf, str, len);
}
 
RBIMPL_ATTR_NONNULL(())
static inline VALUE
rbimpl_exc_new_cstr(VALUE exc, const char *str)
{
    long len = rbimpl_strlen(str);
    return rb_exc_new(exc, str, len);
}
 
#define rb_str_new(str, len)                    \
    ((RBIMPL_CONSTANT_P(str) &&                 \
      RBIMPL_CONSTANT_P(len) ?                  \
      rb_str_new_static      :                  \
      rb_str_new) ((str), (len)))
 
#define rb_str_new_cstr(str)                    \
    ((RBIMPL_CONSTANT_P(str) ?                  \
      rbimpl_str_new_cstr    :                  \
      rb_str_new_cstr) (str))
 
#define rb_usascii_str_new(str, len)            \
    ((RBIMPL_CONSTANT_P(str)    &&              \
      RBIMPL_CONSTANT_P(len)    ?               \
      rb_usascii_str_new_static :               \
      rb_usascii_str_new) ((str), (len)))
 
#define rb_utf8_str_new(str, len)               \
    ((RBIMPL_CONSTANT_P(str) &&                 \
      RBIMPL_CONSTANT_P(len) ?                  \
      rb_utf8_str_new_static :                  \
      rb_utf8_str_new) ((str), (len)))
 
#define rb_usascii_str_new_cstr(str)            \
    ((RBIMPL_CONSTANT_P(str)      ?             \
      rbimpl_usascii_str_new_cstr :             \
      rb_usascii_str_new_cstr) (str))
 
#define rb_utf8_str_new_cstr(str)               \
    ((RBIMPL_CONSTANT_P(str)   ?                \
      rbimpl_utf8_str_new_cstr :                \
      rb_utf8_str_new_cstr) (str))
 
#define rb_external_str_new_cstr(str)           \
    ((RBIMPL_CONSTANT_P(str)       ?            \
      rbimpl_external_str_new_cstr :            \
      rb_external_str_new_cstr) (str))
 
#define rb_locale_str_new_cstr(str)             \
    ((RBIMPL_CONSTANT_P(str)     ?              \
      rbimpl_locale_str_new_cstr :              \
      rb_locale_str_new_cstr) (str))
 
#define rb_str_buf_new_cstr(str)                \
    ((RBIMPL_CONSTANT_P(str)  ?                 \
      rbimpl_str_buf_new_cstr :                 \
      rb_str_buf_new_cstr) (str))
 
#define rb_str_cat_cstr(buf, str)               \
    ((RBIMPL_CONSTANT_P(str) ?                  \
      rbimpl_str_cat_cstr    :                  \
      rb_str_cat_cstr) ((buf), (str)))
 
#define rb_exc_new_cstr(exc, str)               \
    ((RBIMPL_CONSTANT_P(str) ?                  \
      rbimpl_exc_new_cstr    :                  \
      rb_exc_new_cstr) ((exc), (str)))
 
#define rb_str_new2 rb_str_new_cstr                  
#define rb_str_new3 rb_str_new_shared                
#define rb_str_new4 rb_str_new_frozen                
#define rb_str_new5 rb_str_new_with_class            
#define rb_str_buf_new2 rb_str_buf_new_cstr          
#define rb_usascii_str_new2 rb_usascii_str_new_cstr  
#define rb_str_buf_cat rb_str_cat                    
#define rb_str_buf_cat2 rb_str_cat_cstr              
#define rb_str_cat2 rb_str_cat_cstr                  
#define rb_strlen_lit(str) ((sizeof(str "") / sizeof(str ""[0])) - 1)
 
#define rb_str_new_lit(str) rb_str_new_static((str), rb_strlen_lit(str))
 
#define rb_usascii_str_new_lit(str) rb_usascii_str_new_static((str), rb_strlen_lit(str))
 
#define rb_utf8_str_new_lit(str) rb_utf8_str_new_static((str), rb_strlen_lit(str))
 
#define rb_enc_str_new_lit(str, enc) rb_enc_str_new_static((str), rb_strlen_lit(str), (enc))
 
#define rb_str_new_literal(str) rb_str_new_lit(str)                    
#define rb_usascii_str_new_literal(str) rb_usascii_str_new_lit(str)    
#define rb_utf8_str_new_literal(str) rb_utf8_str_new_lit(str)          
#define rb_enc_str_new_literal(str, enc) rb_enc_str_new_lit(str, enc)  
RBIMPL_SYMBOL_EXPORT_END()
 
#endif /* RBIMPL_INTERN_STRING_H */