redef fun +(o) do
var mlen = length
var slen = o.length
- var nns = new NativeString(mlen + slen)
+ var nns = new CString(mlen + slen)
items.copy_to(nns, mlen, index_from, 0)
if o isa FlatString then
o.items.copy_to(nns, slen, o.index_from, mlen)
na[i] = tmp
i += 1
end
- var ns = new NativeString(sl + 1)
+ var ns = new CString(sl + 1)
ns[sl] = '\0'
i = 0
var off = 0
end
else
# Use the prefix and the short class name
- # e.g. given the prefix Native: java.lang.String -> NativeString
+ # e.g. given the prefix Native: java.lang.String -> CString
name = prefix + id
end
using namespace emscripten;
EMSCRIPTEN_BINDINGS(my_module) {
- function("run_analysis", &NativeString_run_analysis, allow_raw_pointers());
+ function("run_analysis", &CString_run_analysis, allow_raw_pointers());
}
`}
fun show_graph(content: String) do "show_graph('{content.escape_to_c}');".run_js
end
-redef class NativeString
+redef class CString
fun run_analysis do manager.run_web to_s
end
-fun dummy_set_callbacks import NativeString.run_analysis in "C++" `{
+fun dummy_set_callbacks import CString.run_analysis in "C++" `{
`}
dummy_set_callbacks
# Returns null on success
fun file_rename_to(dest: String): nullable String import String.to_cstring,
- NativeString.to_s, String.as nullable `{
+ CString.to_s, String.as nullable `{
int res = rename(String_to_cstring(self), String_to_cstring(dest));
if (res == 0) return null_String();
- return String_as_nullable(NativeString_to_s(strerror(errno)));
+ return String_as_nullable(CString_to_s(strerror(errno)));
`}
# Replace `~` by the path to the home diretory
(*env)->DeleteLocalRef(env, class_class_loader);
`}
- private fun load_jclass_intern(instance_class_loader: JavaObject, class_loader_findClass: JMethodID, name: NativeString): JClass import jni_env `{
+ private fun load_jclass_intern(instance_class_loader: JavaObject, class_loader_findClass: JMethodID, name: CString): JClass import jni_env `{
JNIEnv *env = Sys_jni_env(self);
jobject class_name = (*env)->NewStringUTF(env, name);
private fun priority_silent: Int do return 8
# Write `text` to Android log at priority `level` with tag `tag`
-private fun log_write(level: Int, tag, text: NativeString) `{
+private fun log_write(level: Int, tag, text: CString) `{
__android_log_write(level, tag, text);
`}
fun java_native_activity: NativeActivity `{ return self->clazz; `}
# Path to this application's internal data directory.
- fun internal_data_path: NativeString `{ return (char*)self->internalDataPath; `}
+ fun internal_data_path: CString `{ return (char*)self->internalDataPath; `}
# Path to this application's external (removable/mountable) data directory.
- fun external_data_path: NativeString `{ return (char*)self->externalDataPath; `}
+ fun external_data_path: CString `{ return (char*)self->externalDataPath; `}
# The platform's SDK version code.
fun sdk_version: Int `{ return self->sdkVersion; `}
# api?
#
# TODO activate in a future module at API 11
- #fun obb_path: NativeString `{ return (char*)self->obbPath; `}
+ #fun obb_path: CString `{ return (char*)self->obbPath; `}
end
# This is the interface for the standard glue code of a threaded
extern class ASensor `{ASensorRef`}
new `{return malloc(sizeof(ASensorRef));`}
- fun name: NativeString `{return (char*)ASensor_getName(self);`}
- fun vendor: NativeString `{return (char*)ASensor_getVendor(self);`}
+ fun name: CString `{return (char*)ASensor_getName(self);`}
+ fun vendor: CString `{return (char*)ASensor_getVendor(self);`}
fun sensor_type: ASensorType `{return ASensor_getType(self);`}
fun resolution: Float `{return ASensor_getResolution(self);`}
fun min_delay: Int `{return ASensor_getMinDelay(self);`}
end
end
-redef class NativeString
+redef class CString
# Alphabet used by the base64 algorithm
private fun base64_chars : Bytes
do
# | 0x06 utf8 byte sequence # Char
# | 0x07 double(64 bits) # Float
# | 0x08 block # String
-# | 0x09 block # NativeString
+# | 0x09 block # CString
# | 0x0A flat_array; # Array[nullable Object]
#
# block = int64 int8*;
private var unclaimed_attributes = new UnrolledList[HashMap[String, nullable Object]]
# Buffer for one char
- private var char_buf: NativeString is lazy do return new NativeString(4)
+ private var char_buf: CString is lazy do return new CString(4)
# Read and deserialize the next attribute name and value
#
end
end
-redef class NativeString
+redef class CString
redef fun serialize_to_binary(v)
do
v.stream.write_byte kind_native_string
`}
end
-# Wrapper around an array of `NativeString` in C (`char**`) with length and destroy state.
-class CNativeStringArray
- super CArray[NativeString]
+# Wrapper around an array of `CString` in C (`char**`) with length and destroy state.
+class CCStringArray
+ super CArray[CString]
redef type NATIVE: NativeCStringArray
super size
end
- # Create from an `SequenceRead[NativeString]`
- new from(array: SequenceRead[NativeString])
+ # Create from an `SequenceRead[CString]`
+ new from(array: SequenceRead[CString])
do
- var carray = new CNativeStringArray(array.length)
+ var carray = new CCStringArray(array.length)
for i in array.length.times do
carray[i] = array[i]
end
end
end
-# An array of `NativeString` in C (`char**`)
+# An array of `CString` in C (`char**`)
extern class NativeCStringArray `{ char** `}
super NativeCArray
- redef type E: NativeString
+ redef type E: CString
# Initialize a new NativeCStringArray of `size` elements.
new(size: Int) `{ return calloc(size, sizeof(char*)); `}
redef fun +(offset) `{ return self + offset; `}
end
-redef class NativeString
+redef class CString
super NativeCArray
redef type E: Char
new nil in "ObjC" `{ return nil; `}
# Get an UTF8 encoded `char*` copy of `self`
- fun utf8_string: NativeString in "ObjC" `{ return (char *)[self UTF8String]; `}
+ fun utf8_string: CString in "ObjC" `{ return (char *)[self UTF8String]; `}
redef fun to_s do return utf8_string.to_s_with_copy
end
-redef class NativeString
+redef class CString
# Get a `NSString` from `self` with the specified `length`
fun to_nsstring(length: Int): NSString in "ObjC" `{
return [[NSString alloc] initWithBytes:self
extern class NSData in "ObjC" `{ NSData * `}
# Pointer to contained data
- fun bytes: NativeString in "ObjC" `{ return (char*)self.bytes; `}
+ fun bytes: CString in "ObjC" `{ return (char*)self.bytes; `}
# Number of bytes containted in `self`
fun length: Int in "ObjC" `{ return self.length; `}
super BytePattern
# Write self as a string into `ns` at position `pos`
- private fun add_digest_at(ns: NativeString, pos: Int) do
+ private fun add_digest_at(ns: CString, pos: Int) do
var tmp = (0xF0u8 & self) >> 4
ns[pos] = if tmp >= 0x0Au8 then tmp + 0x37u8 else tmp + 0x30u8
tmp = 0x0Fu8 & self
super AbstractArray[Byte]
super BytePattern
- # A NativeString being a char*, it can be used as underlying representation here.
- var items: NativeString
+ # A CString being a char*, it can be used as underlying representation here.
+ var items: CString
# Number of bytes in the array
redef var length
# var b = new Bytes.empty
# assert b.to_s == ""
init empty do
- var ns = new NativeString(0)
+ var ns = new CString(0)
init(ns, 0, 0)
end
# Init a `Bytes` with capacity `cap`
init with_capacity(cap: Int) do
- var ns = new NativeString(cap)
+ var ns = new CString(cap)
init(ns, 0, cap)
end
# ~~~
fun hexdigest: String do
var elen = length * 2
- var ns = new NativeString(elen)
+ var ns = new CString(elen)
var i = 0
var oi = 0
while i < length do
# ~~~
fun chexdigest: String do
var elen = length * 4
- var ns = new NativeString(elen)
+ var ns = new CString(elen)
var i = 0
var oi = 0
while i < length do
# ~~~
fun binarydigest: String do
var elen = length * 8
- var ns = new NativeString(elen)
+ var ns = new CString(elen)
var i = 0
var oi = 0
while i < length do
# Regenerates the buffer, necessary when it was persisted
private fun regen do
- var nns = new NativeString(capacity)
+ var nns = new CString(capacity)
items.copy_to(nns, length, 0, 0)
persisted = false
end
# Appends the `ln` first bytes of `ns` to self
- fun append_ns(ns: NativeString, ln: Int) do
+ fun append_ns(ns: CString, ln: Int) do
if persisted then regen
var nlen = length + ln
if nlen > capacity then enlarge(nlen)
end
# Appends `ln` bytes from `ns` starting at index `from` to self
- fun append_ns_from(ns: NativeString, ln, from: Int) do
+ fun append_ns_from(ns: CString, ln, from: Int) do
if persisted then regen
var nlen = length + ln
if nlen > capacity then enlarge(nlen)
if capacity >= sz then return
persisted = false
while capacity < sz do capacity = capacity * 2 + 2
- var ns = new NativeString(capacity)
+ var ns = new CString(capacity)
items.copy_to(ns, length, 0, 0)
items = ns
end
private class BytesIterator
super IndexedIterator[Byte]
- var tgt: NativeString
+ var tgt: CString
redef var index
# assert "<STRING/&rt;".hexdigest == "266C743B535452494E47262334373B2672743B"
fun hexdigest: String do
var ln = byte_length
- var outns = new NativeString(ln * 2)
+ var outns = new CString(ln * 2)
var oi = 0
for i in [0 .. ln[ do
bytes[i].add_digest_at(outns, oi)
end
end
-redef class NativeString
+redef class CString
# Creates a new `Bytes` object from `self` with `len` as length
#
# If `len` is null, strlen will determine the length of the Bytes
# If `len` is null, strlen will determine the length of the Bytes
fun to_bytes_with_copy(len: nullable Int): Bytes do
if len == null then len = cstring_length
- var nns = new NativeString(len)
+ var nns = new CString(len)
copy_to(nns, len, 0, 0)
return new Bytes(nns, len, len)
end
fun char_max_size: Int is abstract
# Transforms `c` to its representation in the format of `self`
- fun encode_char(c: Char): NativeString is abstract
+ fun encode_char(c: Char): CString is abstract
# Adds a char `c` to bytes `s`
#
# Returns the number of bytes written to `s`
- fun add_char_to(c: Char, s: NativeString): Int is abstract
+ fun add_char_to(c: Char, s: CString): Int is abstract
# Transforms `s` to the format of `self`
fun encode_string(s: Text): Bytes is abstract
# * 0 if valid
# * 1 if incomplete
# * 2 if invalid
- fun is_valid_char(ns: NativeString, position: Int): Int is abstract
+ fun is_valid_char(ns: CString, position: Int): Int is abstract
# Decodes a char from `b` to a Unicode code-point
- fun decode_char(b: NativeString): Char is abstract
+ fun decode_char(b: CString): Char is abstract
# Decodes a string `b` to UTF-8
- fun decode_string(b: NativeString, len: Int): String is abstract
+ fun decode_string(b: CString, len: Int): String is abstract
end
redef fun max_lookahead do return 1
redef fun encode_char(c) do
- var ns = new NativeString(c.u8char_len)
+ var ns = new CString(c.u8char_len)
add_char_to(c, ns)
return ns
end
redef fun max_lookahead do return 4
redef fun encode_char(c) do
- var ns = new NativeString(c.u8char_len)
+ var ns = new CString(c.u8char_len)
add_char_to(c, ns)
return ns
end
var ret = ns.to_s_with_length(len)
var rit = ret.as(FlatString).items
if rit == ns then
- var nns = new NativeString(len)
+ var nns = new CString(len)
rit.copy_to(nns, len, 0, 0)
return nns.to_s_full(ret.byte_length, ret.length)
end
end
end
-redef class NativeString
- private fun get_environ: NativeString `{ return getenv(self); `}
- private fun setenv(value: NativeString) `{
+redef class CString
+ private fun get_environ: CString `{ return getenv(self); `}
+ private fun setenv(value: CString) `{
#ifdef _WIN32
_putenv_s(self, value);
#else
end
private var data: NativeProcess
- private fun basic_exec_execute(prog, args: NativeString, argc: Int, pipeflag: Int): NativeProcess `{
+ private fun basic_exec_execute(prog, args: CString, argc: Int, pipeflag: Int): NativeProcess `{
#ifdef _WIN32
// FIXME use a higher level abstraction to support WIN32
return -1;
fun pid: Int `{ return getpid(); `}
end
-redef class NativeString
+redef class CString
# Execute self as a shell command.
#
# See the posix function system(3).
redef var is_writable = false
# Write `len` bytes from `native`.
- private fun write_native(native: NativeString, from, len: Int)
+ private fun write_native(native: CString, from, len: Int)
do
if last_error != null then return
if not _is_writable then
# Creates a file stream from a file descriptor `fd` using the file access `mode`.
#
# NOTE: The `mode` specified must be compatible with the one used in the file descriptor.
- private fun fd_to_stream(mode: NativeString): NativeFile `{
+ private fun fd_to_stream(mode: CString): NativeFile `{
return fdopen((int)self, mode);
`}
end
# Constant for read-only file streams
-private fun read_only: NativeString do return once "r".to_cstring
+private fun read_only: CString do return once "r".to_cstring
# Constant for write-only file streams
#
# If a stream is opened on a file with this method,
# it will wipe the previous file if any.
# Else, it will create the file.
-private fun wipe_write: NativeString do return once "w".to_cstring
+private fun wipe_write: CString do return once "w".to_cstring
###############################################################################
end
end
-redef class NativeString
+redef class CString
private fun file_exists: Bool `{
#ifdef _WIN32
DWORD attribs = GetFileAttributesA(self);
private fun file_chdir: Bool `{ return !chdir(self); `}
- private fun file_realpath: NativeString `{
+ private fun file_realpath: CString `{
#ifdef _WIN32
DWORD len = GetFullPathName(self, 0, NULL, NULL);
char *buf = malloc(len+1); // FIXME don't leak memory
# Instance of this class are standard FILE * pointers
private extern class NativeFile `{ FILE* `}
- fun io_read(buf: NativeString, len: Int): Int `{
+ fun io_read(buf: CString, len: Int): Int `{
return fread(buf, 1, len, self);
`}
- fun io_write(buf: NativeString, from, len: Int): Int `{
+ fun io_write(buf: CString, from, len: Int): Int `{
return fwrite(buf+from, 1, len, self);
`}
return setvbuf(self, NULL, (int)mode, buf_length);
`}
- new io_open_read(path: NativeString) `{ return fopen(path, "r"); `}
+ new io_open_read(path: CString) `{ return fopen(path, "r"); `}
- new io_open_write(path: NativeString) `{ return fopen(path, "w"); `}
+ new io_open_write(path: CString) `{ return fopen(path, "w"); `}
new native_stdin `{ return stdin; `}
private extern class NativeDir `{ DIR* `}
# Open a directory
- new opendir(path: NativeString) `{ return opendir(path); `}
+ new opendir(path: CString) `{ return opendir(path); `}
# Close a directory
fun closedir `{ closedir(self); `}
# Read the next directory entry
- fun readdir: NativeString `{
+ fun readdir: CString `{
struct dirent *de;
de = readdir(self);
if (!de) return NULL;
# Return the working (current) directory
fun getcwd: String do return native_getcwd.to_s
-private fun native_getcwd: NativeString `{ return getcwd(NULL, 0); `}
+private fun native_getcwd: CString `{ return getcwd(NULL, 0); `}
# assert ~0x2Fi8 == 0xD0i8
fun ~: Int8 is intern
- # C function to calculate the length of the `NativeString` to receive `self`
+ # C function to calculate the length of the `CString` to receive `self`
private fun to_s_len: Int `{
return snprintf(NULL, 0, "%"PRIi8, self);
`}
- # C function to convert a nit Int to a NativeString (char*)
- private fun native_to_s(nstr: NativeString, strlen: Int) `{
+ # C function to convert a nit Int to a CString (char*)
+ private fun native_to_s(nstr: CString, strlen: Int) `{
snprintf(nstr, strlen, "%"PRIi8, self);
`}
# assert (-123i8).to_s == "-123"
redef fun to_s do
var nslen = to_s_len
- var ns = new NativeString(nslen + 1)
+ var ns = new CString(nslen + 1)
ns[nslen] = 0u8
native_to_s(ns, nslen + 1)
return ns.to_s_with_length(nslen)
# assert ~0x2Fi16 == 0xFFD0i16
fun ~: Int16 is intern
- # C function to calculate the length of the `NativeString` to receive `self`
+ # C function to calculate the length of the `CString` to receive `self`
private fun to_s_len: Int `{
return snprintf(NULL, 0, "%"PRIi16, self);
`}
- # C function to convert a nit Int to a NativeString (char*)
- private fun native_to_s(nstr: NativeString, strlen: Int) `{
+ # C function to convert a nit Int to a CString (char*)
+ private fun native_to_s(nstr: CString, strlen: Int) `{
snprintf(nstr, strlen, "%"PRIi16, self);
`}
# assert (-123i16).to_s == "-123"
redef fun to_s do
var nslen = to_s_len
- var ns = new NativeString(nslen + 1)
+ var ns = new CString(nslen + 1)
ns[nslen] = 0u8
native_to_s(ns, nslen + 1)
return ns.to_s_with_length(nslen)
# assert ~0x2Fu16 == 0xFFD0u16
fun ~: UInt16 is intern
- # C function to calculate the length of the `NativeString` to receive `self`
+ # C function to calculate the length of the `CString` to receive `self`
private fun to_s_len: Int `{
return snprintf(NULL, 0, "%"PRIu16, self);
`}
- # C function to convert a nit Int to a NativeString (char*)
- private fun native_to_s(nstr: NativeString, strlen: Int) `{
+ # C function to convert a nit Int to a CString (char*)
+ private fun native_to_s(nstr: CString, strlen: Int) `{
snprintf(nstr, strlen, "%"PRIu16, self);
`}
# assert (-123u16).to_s == "65413"
redef fun to_s do
var nslen = to_s_len
- var ns = new NativeString(nslen + 1)
+ var ns = new CString(nslen + 1)
ns[nslen] = 0u8
native_to_s(ns, nslen + 1)
return ns.to_s_with_length(nslen)
# assert ~0x2Fi32 == 0xFFFFFFD0i32
fun ~: Int32 is intern
- # C function to calculate the length of the `NativeString` to receive `self`
+ # C function to calculate the length of the `CString` to receive `self`
private fun to_s_len: Int `{
return snprintf(NULL, 0, "%"PRIi32, self);
`}
- # C function to convert a nit Int to a NativeString (char*)
- private fun native_to_s(nstr: NativeString, strlen: Int) `{
+ # C function to convert a nit Int to a CString (char*)
+ private fun native_to_s(nstr: CString, strlen: Int) `{
snprintf(nstr, strlen, "%"PRIi32, self);
`}
# assert (-123i32).to_s == "-123"
redef fun to_s do
var nslen = to_s_len
- var ns = new NativeString(nslen + 1)
+ var ns = new CString(nslen + 1)
ns[nslen] = 0u8
native_to_s(ns, nslen + 1)
return ns.to_s_with_length(nslen)
# assert ~0x2Fu32 == 0xFFFFFFD0u32
fun ~: UInt32 is intern
- # C function to calculate the length of the `NativeString` to receive `self`
+ # C function to calculate the length of the `CString` to receive `self`
private fun to_s_len: Int `{
return snprintf(NULL, 0, "%"PRIu32, self);
`}
- # C function to convert a nit Int to a NativeString (char*)
- private fun native_to_s(nstr: NativeString, strlen: Int) `{
+ # C function to convert a nit Int to a CString (char*)
+ private fun native_to_s(nstr: CString, strlen: Int) `{
snprintf(nstr, strlen, "%"PRIu32, self);
`}
# assert (-123u32).to_s == "4294967173"
redef fun to_s do
var nslen = to_s_len
- var ns = new NativeString(nslen + 1)
+ var ns = new CString(nslen + 1)
ns[nslen] = 0u8
native_to_s(ns, nslen + 1)
return ns.to_s_with_length(nslen)
new from_name(name: String) import String.to_cstring `{ return getpwnam( String_to_cstring(name) ); `}
# Username
- fun name: String import NativeString.to_s `{ return NativeString_to_s(self->pw_name); `}
+ fun name: String import CString.to_s `{ return CString_to_s(self->pw_name); `}
# User password
- fun passwd: String import NativeString.to_s `{ return NativeString_to_s(self->pw_passwd); `}
+ fun passwd: String import CString.to_s `{ return CString_to_s(self->pw_passwd); `}
# User ID
fun uid: Int `{ return self->pw_uid; `}
fun gid: Int `{ return self->pw_gid; `}
# Home directory
- fun dir: String import NativeString.to_s `{ return NativeString_to_s(self->pw_dir); `}
+ fun dir: String import CString.to_s `{ return CString_to_s(self->pw_dir); `}
# Shell program
- fun shell: String import NativeString.to_s `{ return NativeString_to_s(self->pw_shell); `}
+ fun shell: String import CString.to_s `{ return CString_to_s(self->pw_shell); `}
end
# Information on a user group
new from_name(name: String) import String.to_cstring `{ return getgrnam( String_to_cstring(name) ); `}
# Name of this ground
- fun name: String import NativeString.to_s `{ return NativeString_to_s(self->gr_name); `}
+ fun name: String import CString.to_s `{ return CString_to_s(self->gr_name); `}
# Encrypted password of this group
- fun passwd: String import NativeString.to_s `{ return NativeString_to_s(self->gr_passwd); `}
+ fun passwd: String import CString.to_s `{ return CString_to_s(self->gr_passwd); `}
# Id of this group
fun gid: Int `{ return self->gr_gid; `}
# List of the members of the group
- fun mem: Array[String] import Array[String], Array[String].add, NativeString.to_s `{
+ fun mem: Array[String] import Array[String], Array[String].add, CString.to_s `{
char **mem;
int m;
Array_of_String ret;
ret = new_Array_of_String();
for (m = 0; mem[m] != NULL; m++)
- Array_of_String_add(ret, NativeString_to_s(mem[m]));
+ Array_of_String_add(ret, CString_to_s(mem[m]));
return ret;
`}
new malloc `{ return malloc(sizeof(regex_t)); `}
# Compile the regular expression `regex` into a form that is suitable for subsequent `regexec` searches
- fun regcomp(regex: NativeString, cflags: Int): Int `{
+ fun regcomp(regex: CString, cflags: Int): Int `{
return regcomp(self, regex, cflags);
`}
#
# `nmatch` and `pmatch` are used to provide information regarding the location of any matches.
# `eflags` may be the bitwise-or of one or both of `flag_notbol` and `flag_noteol`.
- fun regexec(string: NativeString, nmatch: Int, pmatch: NativeMatchArray, eflags: Int): Int `{
+ fun regexec(string: CString, nmatch: Int, pmatch: NativeMatchArray, eflags: Int): Int `{
return regexec(self, string, nmatch, pmatch, eflags);
`}
# Match `string` against the precompiled pattern buffer of `self`, do not locate matches
#
# `eflags` may be the bitwise-or of one or both of `flag_notbol` and `flag_noteol`.
- fun regexec_match_only(string: NativeString, eflags: Int): Int `{
+ fun regexec_match_only(string: CString, eflags: Int): Int `{
return regexec(self, string, 0, NULL, eflags);
`}
fun regfree `{ regfree(self); `}
# Turn the error codes that can be returned by both `regcomp` and `regexec` into error message strings
- fun regerror(errcode: Int): NativeString `{
+ fun regerror(errcode: Int): CString `{
size_t len = regerror(errcode, self, NULL, 0);
char *message = malloc(len);
regerror(errcode, self, message, len);
fun [](index: Int): NativeMatchArray `{ return self + index; `}
end
-redef extern class NativeString
- private fun substring_from(index: Int): NativeString `{ return self + index; `}
+redef extern class CString
+ private fun substring_from(index: Int): CString `{ return self + index; `}
end
redef class Text
fun read_bytes(i: Int): Bytes
do
if last_error != null then return new Bytes.empty
- var s = new NativeString(i)
+ var s = new CString(i)
var buf = new Bytes(s, 0, 0)
while i > 0 and not eof do
var c = read_byte
while c < full_len do c = c * 2 + 2
_buffer_capacity = c
end
- var nns = new NativeString(_buffer_capacity)
+ var nns = new CString(_buffer_capacity)
bf.items.copy_to(nns, bf.length, 0, 0)
_buffer.copy_to(nns, remsp, _buffer_pos, bf.length)
_buffer = nns
end
# The buffer
- private var buffer: NativeString = new NativeString(0)
+ private var buffer: CString = new CString(0)
# The current position in the buffer
private var buffer_pos = 0
# Allocate a `_buffer` for a given `capacity`.
protected fun prepare_buffer(capacity: Int)
do
- _buffer = new NativeString(capacity)
+ _buffer = new CString(capacity)
_buffer_pos = 0 # need to read
_buffer_length = 0
_buffer_capacity = capacity
redef fun read_all_bytes do
var nslen = source.length - cursor
- var nns = new NativeString(nslen)
+ var nns = new CString(nslen)
source.copy_to_native(nns, nslen, cursor, 0)
return new Bytes(nns, nslen, nslen)
end
end
# Return a null terminated char *
- fun to_cstring: NativeString is abstract
+ fun to_cstring: CString is abstract
# The index of the last occurrence of an element starting from pos (in reverse order).
#
# If no transformation is needed, return self as a string
if not has_percent then return to_s
- var buf = new NativeString(len)
+ var buf = new CString(len)
var i = 0
var l = 0
while i < length do
# Copies `n` bytes from `self` at `src_offset` into `dest` starting at `dest_offset`
#
- # Basically a high-level synonym of NativeString::copy_to
+ # Basically a high-level synonym of CString::copy_to
#
# REQUIRE: `n` must be large enough to contain `len` bytes
#
- # var ns = new NativeString(8)
+ # var ns = new CString(8)
# "Text is String".copy_to_native(ns, 8, 2, 0)
# assert ns.to_s_unsafe(8) == "xt is St"
#
- fun copy_to_native(dest: NativeString, n, src_offset, dest_offset: Int) do
+ fun copy_to_native(dest: CString, n, src_offset, dest_offset: Int) do
var mypos = src_offset
var itspos = dest_offset
while n > 0 do
#
# Warning : Might be void in some subclasses, be sure to check
# if set before using it.
- var items: NativeString is noinit
+ var items: CString is noinit
# Returns a char* starting at position `first_byte`
#
# WARNING: If you choose to use this service, be careful of the following.
#
- # Strings and NativeString are *ideally* always allocated through a Garbage Collector.
+ # Strings and CString are *ideally* always allocated through a Garbage Collector.
# Since the GC tracks the use of the pointer for the beginning of the char*, it may be
# deallocated at any moment, rendering the pointer returned by this function invalid.
# Any access to freed memory may very likely cause undefined behaviour or a crash.
#
# As always, do not modify the content of the String in C code, if this is what you want
# copy locally the char* as Nit Strings are immutable.
- fun fast_cstring: NativeString is abstract
+ fun fast_cstring: CString is abstract
redef var length = 0
# User readable representation of `self`.
fun to_s: String do return inspect
- # The class name of the object in NativeString format.
- private fun native_class_name: NativeString is intern
+ # The class name of the object in CString format.
+ private fun native_class_name: CString is intern
# The class name of the object.
#
end
redef class Byte
- # C function to calculate the length of the `NativeString` to receive `self`
+ # C function to calculate the length of the `CString` to receive `self`
private fun byte_to_s_len: Int `{
return snprintf(NULL, 0, "0x%02x", self);
`}
- # C function to convert an nit Int to a NativeString (char*)
- private fun native_byte_to_s(nstr: NativeString, strlen: Int) `{
+ # C function to convert an nit Int to a CString (char*)
+ private fun native_byte_to_s(nstr: CString, strlen: Int) `{
snprintf(nstr, strlen, "0x%02x", self);
`}
# assert (-123).to_b.to_s == "0x85"
redef fun to_s do
var nslen = byte_to_s_len
- var ns = new NativeString(nslen + 1)
+ var ns = new CString(nslen + 1)
ns[nslen] = 0u8
native_byte_to_s(ns, nslen + 1)
return ns.to_s_unsafe(nslen)
redef class Int
# Wrapper of strerror C function
- private fun strerror_ext: NativeString `{ return strerror((int)self); `}
+ private fun strerror_ext: CString `{ return strerror((int)self); `}
# Returns a string describing error number
fun strerror: String do return strerror_ext.to_s
end
end
- # C function to calculate the length of the `NativeString` to receive `self`
+ # C function to calculate the length of the `CString` to receive `self`
private fun int_to_s_len: Int `{
return snprintf(NULL, 0, "%ld", self);
`}
- # C function to convert an nit Int to a NativeString (char*)
- private fun native_int_to_s(nstr: NativeString, strlen: Int) `{
+ # C function to convert an nit Int to a CString (char*)
+ private fun native_int_to_s(nstr: CString, strlen: Int) `{
snprintf(nstr, strlen, "%ld", self);
`}
# assert 'x'.to_s == "x"
redef fun to_s do
var ln = u8char_len
- var ns = new NativeString(ln + 1)
+ var ns = new CString(ln + 1)
u8char_tos(ns, ln)
return ns.to_s_unsafe(ln)
end
return buf.to_s
end
- private fun u8char_tos(r: NativeString, len: Int) `{
+ private fun u8char_tos(r: CString, len: Int) `{
r[len] = '\0';
switch(len){
case 1:
private fun native_argc: Int is intern
# Second argument of the main C function.
- private fun native_argv(i: Int): NativeString is intern
+ private fun native_argv(i: Int): CString is intern
end
# Comparator that efficienlty use `to_s` to compare things
return sys.program_args
end
-redef class NativeString
+redef class CString
# Get a `String` from the data at `self` copied into Nit memory
#
# Require: `self` is a null-terminated string.
redef class FlatText
- # First byte of the NativeString
+ # First byte of the CString
protected fun first_byte: Int do return 0
- # Last byte of the NativeString
+ # Last byte of the CString
protected fun last_byte: Int do return first_byte + _byte_length - 1
# Cache of the latest position (char) explored in the string
var position: Int = 0
- # Cached position (bytes) in the NativeString underlying the String
+ # Cached position (bytes) in the CString underlying the String
var bytepos: Int = 0
# Index of the character `index` in `_items`
var max = last_byte
var pos = first_byte
var nlen = extra + _byte_length
- var nits = new NativeString(nlen)
+ var nits = new CString(nlen)
var outpos = 0
while pos <= max do
var c = its[pos]
var its = _items
var max = last_byte
var nlen = _byte_length + ln_extra
- var nns = new NativeString(nlen)
+ var nns = new CString(nlen)
var pos = first_byte
var opos = 0
while pos <= max do
redef fun to_cstring do
var blen = _byte_length
- var new_items = new NativeString(blen + 1)
+ var new_items = new CString(blen + 1)
_items.copy_to(new_items, blen, _first_byte, 0)
new_items[blen] = 0u8
return new_items
#
# `_items` will be used as is, without copy, to retrieve the characters of the string.
# Aliasing issues is the responsibility of the caller.
- private new with_infos(items: NativeString, byte_length, from: Int)
+ private new with_infos(items: CString, byte_length, from: Int)
do
var len = items.utf8_length(from, byte_length)
if byte_length == len then return new ASCIIFlatString.full_data(items, byte_length, from, len)
#
# `_items` will be used as is, without copy, to retrieve the characters of the string.
# Aliasing issues is the responsibility of the caller.
- private new full(items: NativeString, byte_length, from, length: Int)
+ private new full(items: CString, byte_length, from, length: Int)
do
if byte_length == length then return new ASCIIFlatString.full_data(items, byte_length, from, length)
return new UnicodeFlatString.full_data(items, byte_length, from, length)
if s isa FlatText then
var sits = s._items
var sifrom = s.first_byte
- var ns = new NativeString(nlen + 1)
+ var ns = new CString(nlen + 1)
mits.copy_to(ns, mlen, mifrom, 0)
sits.copy_to(ns, slen, sifrom, mlen)
return new FlatString.full(ns, nlen, 0, _length + o.length)
var newlen = mylen * i
var its = _items
var fb = _first_byte
- var ns = new NativeString(new_byte_length + 1)
+ var ns = new CString(new_byte_length + 1)
ns[new_byte_length] = 0u8
var offset = 0
while i > 0 do
private class UnicodeFlatString
super FlatString
- init full_data(items: NativeString, byte_length, from, length: Int) do
+ init full_data(items: CString, byte_length, from, length: Int) do
self._items = items
self._length = length
self._byte_length = byte_length
private class ASCIIFlatString
super FlatString
- init full_data(items: NativeString, byte_length, from, length: Int) do
+ init full_data(items: CString, byte_length, from, length: Int) do
self._items = items
self._length = length
self._byte_length = byte_length
var target: FlatString
- var target_items: NativeString is noautoinit
+ var target_items: CString is noautoinit
var curr_pos: Int
var target: FlatString
- var target_items: NativeString is noautoinit
+ var target_items: CString is noautoinit
var curr_pos: Int
redef fun substrings do return new FlatSubstringsIter(self)
- # Re-copies the `NativeString` into a new one and sets it as the new `Buffer`
+ # Re-copies the `CString` into a new one and sets it as the new `Buffer`
#
# This happens when an operation modifies the current `Buffer` and
# the Copy-On-Write flag `written` is set at true.
private fun reset do
- var nns = new NativeString(capacity)
+ var nns = new CString(capacity)
if _byte_length != 0 then _items.copy_to(nns, _byte_length, 0, 0)
_items = nns
written = false
var bt = _byte_length
if bt + len > capacity then
capacity = capacity * 2 + 2
- nit = new NativeString(capacity)
+ nit = new CString(capacity)
oit.copy_to(nit, 0, 0, from)
end
oit.copy_to(nit, bt - from, from, from + len)
# it does a copy of the current `Buffer`
written = false
var bln = _byte_length
- var a = new NativeString(c)
+ var a = new CString(c)
if bln > 0 then
var it = _items
if bln > 0 then it.copy_to(a, bln, 0, 0)
do
written = true
var bln = _byte_length
- if bln == 0 then _items = new NativeString(1)
+ if bln == 0 then _items = new CString(1)
return new FlatString.full(_items, bln, 0, _length)
end
redef fun to_cstring
do
var bln = _byte_length
- var new_native = new NativeString(bln + 1)
+ var new_native = new CString(bln + 1)
new_native[bln] = 0u8
if _length > 0 then _items.copy_to(new_native, bln, 0, 0)
return new_native
#
# If `_items` is shared, `written` should be set to true after the creation
# so that a modification will do a copy-on-write.
- private init with_infos(items: NativeString, capacity, byte_length, length: Int)
+ private init with_infos(items: CString, capacity, byte_length, length: Int)
do
self._items = items
self.capacity = capacity
# Create a new string copied from `s`.
init from(s: Text)
do
- _items = new NativeString(s.byte_length)
+ _items = new CString(s.byte_length)
for i in s.substrings do i._items.copy_to(_items, i._byte_length, first_byte, 0)
_byte_length = s.byte_length
_length = s.length
init with_capacity(cap: Int)
do
assert cap >= 0
- _items = new NativeString(cap)
+ _items = new CString(cap)
capacity = cap
_byte_length = 0
end
var byteto = its.char_to_byte_index(count + from - 1)
byteto += its.char_at(byteto).u8char_len - 1
var byte_length = byteto - bytefrom + 1
- var r_items = new NativeString(byte_length)
+ var r_items = new CString(byte_length)
its.copy_to(r_items, byte_length, bytefrom, 0)
return new FlatBuffer.with_infos(r_items, byte_length, byte_length, count)
end
var target: FlatBuffer
- var target_items: NativeString is noautoinit
+ var target_items: CString is noautoinit
var curr_pos: Int
var target: FlatBuffer
- var target_items: NativeString is noautoinit
+ var target_items: CString is noautoinit
var curr_pos: Int
end
-redef class NativeString
+redef class CString
redef fun to_s
do
return to_s_with_length(cstring_length)
do
var r = clean_utf8(length)
if r.items != self then return r
- var new_self = new NativeString(length + 1)
+ var new_self = new CString(length + 1)
copy_to(new_self, length, 0, 0)
var str = new FlatString.with_infos(new_self, length, 0)
new_self[length] = 0u8
return str
end
- # Cleans a NativeString if necessary
+ # Cleans a CString if necessary
fun clean_utf8(len: Int): FlatString do
var replacements: nullable Array[Int] = null
var end_length = len
end
var ret = self
if end_length != len then
- ret = new NativeString(end_length)
+ ret = new CString(end_length)
var old_repl = 0
var off = 0
var repls = replacements.as(not null)
if self == 1 then return "1"
var nslen = int_to_s_len
- var ns = new NativeString(nslen + 1)
+ var ns = new CString(nslen + 1)
ns[nslen] = 0u8
native_int_to_s(ns, nslen + 1)
return new FlatString.full(ns, nslen, 0, nslen)
i += 1
mypos += 1
end
- var ns = new NativeString(sl + 1)
+ var ns = new CString(sl + 1)
ns[sl] = 0u8
i = 0
var off = 0
i += 1
mypos += 1
end
- var ns = new NativeString(sl + 1)
+ var ns = new CString(sl + 1)
ns[sl] = 0u8
i = 0
var off = 0
end
# Native strings are simple C char *
-extern class NativeString `{ char* `}
- # Creates a new NativeString with a capacity of `length`
+extern class CString `{ char* `}
+ # Creates a new CString with a capacity of `length`
new(length: Int) is intern
# Returns a char* starting at `index`.
#
# WARNING: Unsafe for extern code, use only for temporary
# pointer manipulation purposes (e.g. write to file or such)
- fun fast_cstring(index: Int): NativeString is intern
+ fun fast_cstring(index: Int): CString is intern
# Get char at `index`.
fun [](index: Int): Byte is intern
fun []=(index: Int, item: Byte) is intern
# Copy `self` to `dest`.
- fun copy_to(dest: NativeString, length: Int, from: Int, to: Int) is intern
+ fun copy_to(dest: CString, length: Int, from: Int, to: Int) is intern
redef fun ==(o) is intern do return is_same_instance(o)
redef fun to_cstring do
var len = _byte_length
- var ns = new NativeString(len + 1)
+ var ns = new CString(len + 1)
ns[len] = 0u8
var off = 0
for i in substrings do
var sifrom = s._first_byte
var mifrom = _first_byte
var sits = s._items
- var ns = new NativeString(nlen + 1)
+ var ns = new CString(nlen + 1)
mits.copy_to(ns, mlen, mifrom, 0)
sits.copy_to(ns, slen, sifrom, mlen)
return new FlatString.full(ns, nlen, 0, length + s.length)
private class RopeByteReverseIterator
super IndexedIterator[Byte]
- # Current NativeString
- var ns: NativeString is noautoinit
- # Current position in NativeString
+ # Current CString
+ var ns: CString is noautoinit
+ # Current position in CString
var pns: Int is noautoinit
# Position in the Rope (0-indexed)
var pos: Int is noautoinit
# Position in current `String`
var pns: Int is noautoinit
# Current `String` being iterated on
- var ns: NativeString is noautoinit
+ var ns: CString is noautoinit
# Substrings of the Rope
var subs: IndexedIterator[FlatString] is noautoinit
# Maximum position to iterate on (e.g. Rope.byte_length)
private class RopeCharReverseIterator
super IndexedIterator[Char]
- # Current NativeString
+ # Current CString
var ns: String is noautoinit
- # Current position in NativeString
+ # Current position in CString
var pns: Int is noautoinit
# Position in the Rope (0-indexed)
var pos: Int is noautoinit
fun update `{ time(&self); `}
# Convert `self` to a human readable String.
- fun ctime: String import NativeString.to_s_with_copy `{
- return NativeString_to_s_with_copy( ctime(&self) );
+ fun ctime: String import CString.to_s_with_copy `{
+ return CString_to_s_with_copy( ctime(&self) );
`}
# Difference in secondes from start (self if the end time)
fun is_dst: Bool `{ return self->tm_isdst; `}
# Convert `self` to a human readable String.
- private fun asctime: NativeString `{ return asctime(self); `}
+ private fun asctime: CString `{ return asctime(self); `}
# Convert `self` to a human readable String corresponding to `format`.
# TODO document allowed format.
- fun strftime(format: String): String import String.to_cstring, NativeString.to_s_with_copy `{
+ fun strftime(format: String): String import String.to_cstring, CString.to_s_with_copy `{
char* buf, *c_format;
buf = (char*)malloc(100);
c_format = String_to_cstring(format);
strftime(buf, 100, c_format, self);
- String s = NativeString_to_s_with_copy(buf);
+ String s = CString_to_s_with_copy(buf);
free(buf);
return s;
`}
fun to_cpp_string: CppString do return to_cstring.to_cpp_string(length)
end
-redef class NativeString
+redef class CString
# Get `self` as a `CppString`
fun to_cpp_string(length: Int): CppString in "C++" `{
return new std::string(self, length);
}
`}
-redef extern class NativeString
+redef extern class CString
private fun native_callback_header(size, count: Int, target: NativeCurlCallbacks): Int
do
target.header_callback to_s_with_length(size*count)
# Request Chars internal information from the CURL session
fun easy_getinfo_chars(opt: CURLInfoChars): nullable String
do
- var answ = new Ref[NativeString]("".to_cstring)
+ var answ = new Ref[CString]("".to_cstring)
if not native_getinfo_chars(opt, answ).is_ok then return null
if answ.item.address_is_null then return null
return answ.item.to_s
end
# Internal method used to get String object information initially knowns as C Chars type
- private fun native_getinfo_chars(opt: CURLInfoChars, res: Ref[NativeString]): CURLCode
- import Ref[NativeString].item= `{
+ private fun native_getinfo_chars(opt: CURLInfoChars, res: Ref[CString]): CURLCode
+ import Ref[CString].item= `{
char *r;
CURLcode c = curl_easy_getinfo( self, opt, &r);
- if (c == CURLE_OK) Ref_of_NativeString_item__assign(res, r);
+ if (c == CURLE_OK) Ref_of_CString_item__assign(res, r);
return c;
`}
# Register `delegate` to get callbacks about the CURL transfer
fun register_callback_header(delegate: NativeCurlCallbacks): CURLCode
- import NativeString.native_callback_header `{
+ import CString.native_callback_header `{
CURLcode e;
NativeCurlCallbacks_incr_ref(delegate); // FIXME deallocated these when download completes?
- e = curl_easy_setopt(self, CURLOPT_HEADERFUNCTION, (curl_write_callback)&NativeString_native_callback_header);
+ e = curl_easy_setopt(self, CURLOPT_HEADERFUNCTION, (curl_write_callback)&CString_native_callback_header);
if(e != CURLE_OK) return e;
e = curl_easy_setopt(self, CURLOPT_WRITEHEADER, delegate);
# Register `delegate` to get callbacks about the CURL transfer
fun register_callback_body(delegate: NativeCurlCallbacks): CURLCode
- import NativeString.native_callback_body `{
+ import CString.native_callback_body `{
CURLcode e;
NativeCurlCallbacks_incr_ref(delegate);
- e = curl_easy_setopt(self, CURLOPT_WRITEFUNCTION, (curl_write_callback)&NativeString_native_callback_body);
+ e = curl_easy_setopt(self, CURLOPT_WRITEFUNCTION, (curl_write_callback)&CString_native_callback_body);
if(e != CURLE_OK) return e;
e = curl_easy_setopt(self, CURLOPT_WRITEDATA, delegate);
# Register `delegate` to get callbacks about the CURL transfer
fun register_callback_stream(delegate: NativeCurlCallbacks): CURLCode
- import NativeString.native_callback_stream `{
+ import CString.native_callback_stream `{
CURLcode e;
NativeCurlCallbacks_incr_ref(delegate);
- e = curl_easy_setopt(self, CURLOPT_WRITEFUNCTION, (curl_write_callback)&NativeString_native_callback_stream);
+ e = curl_easy_setopt(self, CURLOPT_WRITEFUNCTION, (curl_write_callback)&CString_native_callback_stream);
if(e != CURLE_OK) return e;
e = curl_easy_setopt(self, CURLOPT_WRITEDATA, delegate);
# Register `delegate` to get callbacks about the CURL transfer
fun register_callback_read(delegate: NativeCurlCallbacks): CURLCode
- import NativeString.native_callback_stream `{
+ import CString.native_callback_stream `{
NativeCurlCallbacks_incr_ref(delegate);
return curl_easy_setopt(self, CURLOPT_READFUNCTION, (curl_write_callback)&nit_curl_callback_read_func);
`}
# Convert given string to URL encoded string
- fun escape(url: String): String import String.to_cstring, NativeString.to_s_with_copy `{
+ fun escape(url: String): String import String.to_cstring, CString.to_s_with_copy `{
char *orig_url, *encoded_url = NULL;
orig_url = String_to_cstring(url);
encoded_url = curl_easy_escape( self, orig_url, strlen(orig_url));
- String b_url = NativeString_to_s_with_copy(encoded_url);
+ String b_url = CString_to_s_with_copy(encoded_url);
curl_free(encoded_url);
return b_url;
`}
fun is_valid_protocol: Bool `{ return self == CURLE_UNSUPPORTED_PROTOCOL; `}
fun is_valid_init: Bool `{ return self == CURLE_FAILED_INIT; `}
fun to_i: Int do return code end
- redef fun to_s import NativeString.to_s_with_copy `{
+ redef fun to_s import CString.to_s_with_copy `{
char *c = (char*)curl_easy_strerror(self);
- return NativeString_to_s_with_copy(c);
+ return CString_to_s_with_copy(c);
`}
end
private fun native_next_reachable(c: CURLSList): Bool `{ return (c != NULL && c->next != NULL); `}
# Internal method to get current data
- private fun native_data(c: CURLSList): String import NativeString.to_s `{ return NativeString_to_s(c->data); `}
+ private fun native_data(c: CURLSList): String import CString.to_s `{ return CString_to_s(c->data); `}
# Internal method to get next element
private fun native_next(c: CURLSList): CURLSList `{ return c->next; `}
}
`}
- private fun report_egl_error(cmsg: NativeString)
+ private fun report_egl_error(cmsg: CString)
do
var msg = cmsg.to_s
print "libEGL error: {msg}"
end
end
- private fun query_string(name: Int): String import NativeString.to_s `{
- return NativeString_to_s((char *)eglQueryString(self, name));
+ private fun query_string(name: Int): String import CString.to_s `{
+ return CString_to_s((char *)eglQueryString(self, name));
`}
fun vendor: String do return query_string(0x3053)
# Run `self` as JavaScript code
fun run_js do run_js_native(self.escape_to_js.to_cstring)
- private fun run_js_native(script: NativeString) `{ emscripten_run_script(script); `}
+ private fun run_js_native(script: CString) `{ emscripten_run_script(script); `}
# Escape the content of `self` to pass to JavaScript code
fun escape_to_js: Text do return replace('\n', "\\n")
end
end
-redef class NativeString
+redef class CString
# Sets the locale of the program running
#
# This can be set at different times in the program,
# Gettext `gettext`, SEE gettext manual for further info
fun gettext: String
- import String.to_cstring, NativeString.to_s `{
- return NativeString_to_s(gettext(String_to_cstring(self)));
+ import String.to_cstring, CString.to_s `{
+ return CString_to_s(gettext(String_to_cstring(self)));
`}
# Gettext `dgettext`, SEE gettext manual for further info
fun dgettext(domain: String): String
- import String.to_cstring, NativeString.to_s `{
- return NativeString_to_s(dgettext(String_to_cstring(domain), String_to_cstring(self)));
+ import String.to_cstring, CString.to_s `{
+ return CString_to_s(dgettext(String_to_cstring(domain), String_to_cstring(self)));
`}
end
fun active_attrib_name(index: Int): String
do
var max_size = active_attribute_max_length
- var cname = new NativeString(max_size)
+ var cname = new CString(max_size)
active_attrib_name_native(index, max_size, cname)
return cname.to_s
end
- private fun active_attrib_name_native(index, max_size: Int, name: NativeString) `{
+ private fun active_attrib_name_native(index, max_size: Int, name: CString) `{
// We get more values than we need, for compatibility. At least the
// NVidia driver tries to fill them even if NULL.
fun active_uniform_name(index: Int): String
do
var max_size = active_uniform_max_length
- var cname = new NativeString(max_size)
+ var cname = new CString(max_size)
active_uniform_name_native(index, max_size, cname)
return cname.to_s
end
- private fun active_uniform_name_native(index, max_size: Int, name: NativeString) `{
+ private fun active_uniform_name_native(index, max_size: Int, name: CString) `{
int size;
GLenum type;
glGetActiveUniform(self, index, max_size, NULL, &size, &type, name);
fun glGetProgramInfoLog(program: GLProgram): String
do
var size = glGetProgramiv(program, gl_INFO_LOG_LENGTH)
- var buf = new NativeString(size)
+ var buf = new CString(size)
native_glGetProgramInfoLog(program, size, buf)
return buf.to_s_with_length(size)
end
# Return the program information log in `buf`
-private fun native_glGetProgramInfoLog(program: GLProgram, buf_size: Int, buf: NativeString): Int `{
+private fun native_glGetProgramInfoLog(program: GLProgram, buf_size: Int, buf: CString): Int `{
int length;
glGetProgramInfoLog(program, buf_size, &length, buf);
return length;
return source_native(size).to_s
end
- private fun source_native(size: Int): NativeString `{
+ private fun source_native(size: Int): CString `{
GLchar *code = malloc(size);
glGetShaderSource(self, size, NULL, code);
return code;
fun glGetShaderInfoLog(shader: GLShader): String
do
var size = glGetShaderiv(shader, gl_INFO_LOG_LENGTH)
- var buf = new NativeString(size)
+ var buf = new CString(size)
native_glGetShaderInfoLog(shader, size, buf)
return buf.to_s_with_length(size)
end
-private fun native_glGetShaderInfoLog(shader: GLShader, buf_size: Int, buffer: NativeString): Int `{
+private fun native_glGetShaderInfoLog(shader: GLShader, buf_size: Int, buffer: CString): Int `{
int length;
glGetShaderInfoLog(shader, buf_size, &length, buffer);
return length;
`}
# Replace the source code in the `shader` object with `code`
-fun glShaderSource(shader: GLShader, code: NativeString) `{
+fun glShaderSource(shader: GLShader, code: CString) `{
glShaderSource(shader, 1, (GLchar const **)&code, NULL);
`}
new `{ return (GtkHeaderBar*)gtk_header_bar_new(); `}
fun title=(title: Text) do native_title = title.to_cstring
- private fun native_title=(title: NativeString) `{ gtk_header_bar_set_title(self, title); `}
+ private fun native_title=(title: CString) `{ gtk_header_bar_set_title(self, title); `}
fun title: String do return native_title.to_s
- private fun native_title: NativeString `{ return (gchar *)gtk_header_bar_get_title(self); `}
+ private fun native_title: CString `{ return (gchar *)gtk_header_bar_get_title(self); `}
fun subtitle=(subtitle: Text) do native_subtitle = subtitle.to_cstring
- fun native_subtitle=(subtitle: NativeString) `{ gtk_header_bar_set_subtitle(self, subtitle); `}
+ fun native_subtitle=(subtitle: CString) `{ gtk_header_bar_set_subtitle(self, subtitle); `}
fun subtitle: String do return native_subtitle.to_s
- fun native_subtitle: NativeString `{ return (gchar *)gtk_header_bar_get_subtitle(self); `}
+ fun native_subtitle: CString `{ return (gchar *)gtk_header_bar_get_subtitle(self); `}
fun custom_title=(title_widget: GtkWidget) `{ gtk_header_bar_set_custom_title(self, title_widget); `}
new `{ return (GtkStack*)gtk_stack_new(); `}
fun stack_add(child: GtkWidget, name: String) do native_stack_add(child, name.to_cstring)
- private fun native_stack_add(child: GtkWidget, name: NativeString) `{ gtk_stack_add_named(self, child, name); `}
+ private fun native_stack_add(child: GtkWidget, name: CString) `{ gtk_stack_add_named(self, child, name); `}
- fun add_titled(child: GtkWidget, name, title: NativeString) `{ gtk_stack_add_titled(self, child, name, title); `}
- fun native_add_titled(child: GtkWidget, name, title: NativeString) `{ gtk_stack_add_titled(self, child, name, title); `}
+ fun add_titled(child: GtkWidget, name, title: CString) `{ gtk_stack_add_titled(self, child, name, title); `}
+ fun native_add_titled(child: GtkWidget, name, title: CString) `{ gtk_stack_add_titled(self, child, name, title); `}
fun visible_child=(child: GtkWidget) `{ gtk_stack_set_visible_child(self, child); `}
fun visible_child: GtkWidget `{ return gtk_stack_get_visible_child(self); `}
fun visible_child_name=(name: Text) do native_visible_child_name = name.to_cstring
- fun native_visible_child_name=(name: NativeString) `{ gtk_stack_set_visible_child_name(self, name); `}
+ fun native_visible_child_name=(name: CString) `{ gtk_stack_set_visible_child_name(self, name); `}
fun visible_child_name: Text do return native_visible_child_name.to_s
- fun native_visible_child_name: NativeString `{ return (gchar *)gtk_stack_get_visible_child_name(self); `}
+ fun native_visible_child_name: CString `{ return (gchar *)gtk_stack_get_visible_child_name(self); `}
fun set_visible_child_full(name: Text, transition: GtkStackTransitionType) do native_set_visible_child_full(name.to_cstring, transition)
- fun native_set_visible_child_full(name: NativeString, transition: GtkStackTransitionType) `{
+ fun native_set_visible_child_full(name: CString, transition: GtkStackTransitionType) `{
gtk_stack_set_visible_child_full(self, name, transition);
`}
gtk_assistant_set_page_type(self, page, t);
`}
- fun get_page_title(page: GtkWidget): String import NativeString.to_s_with_copy `{
- return NativeString_to_s_with_copy((char *)gtk_assistant_get_page_title(self, page));
+ fun get_page_title(page: GtkWidget): String import CString.to_s_with_copy `{
+ return CString_to_s_with_copy((char *)gtk_assistant_get_page_title(self, page));
`}
fun set_page_title(page: GtkWidget, title: String) import String.to_cstring `{
return (GtkFrame *)gtk_frame_new(String_to_cstring(lbl));
`}
- fun frame_label: String import NativeString.to_s_with_copy `{
- return NativeString_to_s_with_copy((char *)gtk_frame_get_label(self));
+ fun frame_label: String import CString.to_s_with_copy `{
+ return CString_to_s_with_copy((char *)gtk_frame_get_label(self));
`}
fun frame_label=(lbl: String) import String.to_cstring `{
return (GtkEntry *)gtk_entry_new();
`}
- fun text: String import NativeString.to_s_with_copy `{
- return NativeString_to_s_with_copy((char *)gtk_entry_get_text(self));
+ fun text: String import CString.to_s_with_copy `{
+ return CString_to_s_with_copy((char *)gtk_entry_get_text(self));
`}
fun text=(value: String) import String.to_cstring `{
`}
# Returns the text of the label
- fun text: String import NativeString.to_s_with_copy `{
- return NativeString_to_s_with_copy((char*)gtk_label_get_text(self));
+ fun text: String import CString.to_s_with_copy `{
+ return CString_to_s_with_copy((char*)gtk_label_get_text(self));
`}
# Sets the angle of rotation for the label.
# lbl.set_markup("<span style=\"italic\">\%s</span>".to_cstring,
# "Italic content")
# ~~~
- fun set_markup(format, content: NativeString) `{
+ fun set_markup(format, content: CString) `{
char *formatted = g_markup_printf_escaped(format, content);
gtk_label_set_markup(self, formatted);
g_free(formatted);
return (GtkButton *)gtk_button_new_from_stock(String_to_cstring(stock_id));
`}
- fun text: String import NativeString.to_s_with_copy `{
- return NativeString_to_s_with_copy((char *)gtk_button_get_label(self));
+ fun text: String import CString.to_s_with_copy `{
+ return CString_to_s_with_copy((char *)gtk_button_get_label(self));
`}
fun text=(value: String) import String.to_cstring `{
gtk_expander_set_spacing(self, pixels);
`}
- fun label_text: String import NativeString.to_s_with_copy `{
- return NativeString_to_s_with_copy((char *)gtk_expander_get_label(self));
+ fun label_text: String import CString.to_s_with_copy `{
+ return CString_to_s_with_copy((char *)gtk_expander_get_label(self));
`}
fun label_text=(lbl: String) import String.to_cstring `{
gtk_combo_box_set_id_column(self, id_column);
`}
- fun active_id: String import NativeString.to_s_with_copy `{
- return NativeString_to_s_with_copy((char *)gtk_combo_box_get_active_id(self));
+ fun active_id: String import CString.to_s_with_copy `{
+ return CString_to_s_with_copy((char *)gtk_combo_box_get_active_id(self));
`}
fun active_id=(id_active: String) import String.to_cstring `{
gtk_combo_box_popdown(self);
`}
- fun title: String import NativeString.to_s_with_copy `{
- return NativeString_to_s_with_copy((char *)gtk_combo_box_get_title(self));
+ fun title: String import CString.to_s_with_copy `{
+ return CString_to_s_with_copy((char *)gtk_combo_box_get_title(self));
`}
fun title=(t: String) import String.to_cstring `{
return (GtkAboutDialog *)gtk_about_dialog_new();
`}
- fun program_name: String import NativeString.to_s_with_copy `{
- return NativeString_to_s_with_copy((char *)gtk_about_dialog_get_program_name(self));
+ fun program_name: String import CString.to_s_with_copy `{
+ return CString_to_s_with_copy((char *)gtk_about_dialog_get_program_name(self));
`}
fun program_name=(name: String) import String.to_cstring `{
gtk_about_dialog_set_program_name(self, String_to_cstring(name));
`}
- fun version: String import NativeString.to_s_with_copy `{
- return NativeString_to_s_with_copy((char *)gtk_about_dialog_get_version(self));
+ fun version: String import CString.to_s_with_copy `{
+ return CString_to_s_with_copy((char *)gtk_about_dialog_get_version(self));
`}
fun version=(v: String) import String.to_cstring `{
gtk_about_dialog_set_version(self, String_to_cstring(v));
`}
- fun copyright: String import NativeString.to_s_with_copy `{
- return NativeString_to_s_with_copy((char *)gtk_about_dialog_get_copyright(self));
+ fun copyright: String import CString.to_s_with_copy `{
+ return CString_to_s_with_copy((char *)gtk_about_dialog_get_copyright(self));
`}
fun copyright=(c: String) import String.to_cstring `{
gtk_about_dialog_set_copyright(self, String_to_cstring(c));
`}
- fun comments: String import NativeString.to_s_with_copy `{
- return NativeString_to_s_with_copy((char *)gtk_about_dialog_get_comments(self));
+ fun comments: String import CString.to_s_with_copy `{
+ return CString_to_s_with_copy((char *)gtk_about_dialog_get_comments(self));
`}
fun comments=(com: String) import String.to_cstring `{
gtk_about_dialog_set_comments(self, String_to_cstring(com));
`}
- fun license: String import NativeString.to_s_with_copy `{
- return NativeString_to_s_with_copy((char *)gtk_about_dialog_get_license(self));
+ fun license: String import CString.to_s_with_copy `{
+ return CString_to_s_with_copy((char *)gtk_about_dialog_get_license(self));
`}
fun license=(li: String) import String.to_cstring `{
# license_type
- fun website: String import NativeString.to_s_with_copy `{
- return NativeString_to_s_with_copy((char *)gtk_about_dialog_get_website(self));
+ fun website: String import CString.to_s_with_copy `{
+ return CString_to_s_with_copy((char *)gtk_about_dialog_get_website(self));
`}
fun website=(link: String) import String.to_cstring `{
gtk_about_dialog_set_website(self, String_to_cstring(link));
`}
- fun website_label: String import NativeString.to_s_with_copy `{
- return NativeString_to_s_with_copy((char *) gtk_about_dialog_get_website_label(self));
+ fun website_label: String import CString.to_s_with_copy `{
+ return CString_to_s_with_copy((char *) gtk_about_dialog_get_website_label(self));
`}
fun website_label=(link_label: String) import String.to_cstring `{
`}
# TODO
- # fun authors: String import NativeString.to_s_with_copy `{
- # return NativeString_to_s_with_copy(gtk_about_dialog_get_authors(self));
+ # fun authors: String import CString.to_s_with_copy `{
+ # return CString_to_s_with_copy(gtk_about_dialog_get_authors(self));
# `}
# TODO
fun widget: GtkWidget `{ return gtk_app_chooser_dialog_get_widget(self); `}
- fun heading: String import NativeString.to_s_with_copy `{
- return NativeString_to_s_with_copy((char *)gtk_app_chooser_dialog_get_heading(self));
+ fun heading: String import CString.to_s_with_copy `{
+ return CString_to_s_with_copy((char *)gtk_app_chooser_dialog_get_heading(self));
`}
fun heading=(text: String) import String.to_cstring `{
gtk_progress_bar_set_show_text(self, show);
`}
- fun text: String import NativeString.to_s_with_copy `{
- return NativeString_to_s_with_copy((char *)gtk_progress_bar_get_text(self));
+ fun text: String import CString.to_s_with_copy `{
+ return CString_to_s_with_copy((char *)gtk_progress_bar_get_text(self));
`}
fun text=(value: String) import String.to_cstring `{
new `{ return (GtkCheckButton *)gtk_check_button_new(); `}
- new with_label(lbl: NativeString) `{ return (GtkCheckButton *)gtk_check_button_new_with_label((gchar *)lbl); `}
+ new with_label(lbl: CString) `{ return (GtkCheckButton *)gtk_check_button_new_with_label((gchar *)lbl); `}
end
#
# Nit extracts the first arguments from the `args` sequence,
# so we need to add it back. That's why Nit's `args` is smaller than in C.
- private fun register_args(program_name: NativeString, argc: Int,
+ private fun register_args(program_name: CString, argc: Int,
argv: Sequence[String]) import Sequence[String].[], String.to_cstring in "ObjC" `{
app_nit_ios_argc = (int)(argc+1);
private fun nslog in "ObjC" `{ NSLog(@"%@", self); `}
end
-redef class NativeString
+redef class CString
# FIXME temp workaround for #1945, bypass Unicode checks
redef fun char_at(pos) do return self[pos].ascii
end
end
# Get a Java class by its name from the current `jni_env`
- fun load_jclass(name: NativeString): JClass import jni_env `{
+ fun load_jclass(name: CString): JClass import jni_env `{
JNIEnv *nit_ffi_jni_env = Sys_jni_env(self);
// retrieve the implementation Java class
# A standard Java string `java.lang.String`
#
# Converted to a Nit string using `to_s`, or to a C string with `to_cstring`.
-# Created using `String::to_java_string` or `NativeString::to_java_string`.
+# Created using `String::to_java_string` or `CString::to_java_string`.
extern class JavaString in "Java" `{ java.lang.String `}
super JavaObject
# Get the string from Java and copy it to Nit memory
- fun to_cstring: NativeString import sys, Sys.jni_env `{
+ fun to_cstring: CString import sys, Sys.jni_env `{
Sys sys = JavaString_sys(self);
JNIEnv *env = Sys_jni_env(sys);
end
end
-redef class NativeString
+redef class CString
# Get a Java string from this C string
#
# This instance is only valid until the next execution of Java code.
# Metamodel
# Class inheritance graph as a `POSet[String]` serialized to JSON
-private fun class_inheritance_metamodel_json: NativeString is intern
+private fun class_inheritance_metamodel_json: CString is intern
redef class Sys
# Class inheritance graph
end
end
-redef class NativeString
+redef class CString
redef fun accept_json_serializer(v) do to_s.accept_json_serializer(v)
end
end
private extern class JavaVMOption `{ JavaVMOption* `}
- fun string: String import NativeString.to_s `{
- return NativeString_to_s((char*)self->optionString);
+ fun string: String import CString.to_s `{
+ return CString_to_s((char*)self->optionString);
`}
fun string=(v: String) import String.to_cstring `{
self->optionString = String_to_cstring(v);
`}
- fun extra_info: String import NativeString.to_s `{
- return NativeString_to_s((char*)self->extraInfo);
+ fun extra_info: String import CString.to_s `{
+ return CString_to_s((char*)self->extraInfo);
`}
fun extra_info=(v: String) import String.to_cstring `{
self->extraInfo = String_to_cstring(v);
return jvm;
`}
- private fun jni_error(msg: NativeString, v: Int)
+ private fun jni_error(msg: CString, v: Int)
do
print "JNI Error: {msg} ({v})"
abort
return res;
`}
- # Call a method on `obj` designed by `method_id` with an array `args` of arguments returning a NativeString
- fun call_string_method(obj: JavaObject, method_id: JMethodID, args: nullable Array[nullable Object]): NativeString import convert_args_to_jni `{
+ # Call a method on `obj` designed by `method_id` with an array `args` of arguments returning a CString
+ fun call_string_method(obj: JavaObject, method_id: JMethodID, args: nullable Array[nullable Object]): CString import convert_args_to_jni `{
jvalue * args_tab = JniEnv_convert_args_to_jni(self, args);
jobject jobj = (*self)->CallObjectMethod(self, obj, method_id, args_tab);
free(args_tab);
# Represents a jni JNINNativeMethod
extern class JNINativeMethod `{ JNINativeMethod* `}
- fun name: String import NativeString.to_s `{
- return NativeString_to_s((void*)self->name);
+ fun name: String import CString.to_s `{
+ return CString_to_s((void*)self->name);
`}
fun name=(name: String) import String.to_cstring `{
self->name = String_to_cstring(name);
`}
- fun signature: String import NativeString.to_s `{
- return NativeString_to_s((void*)self->signature);
+ fun signature: String import CString.to_s `{
+ return CString_to_s((void*)self->signature);
`}
fun signature=(signature: String) import String.to_cstring `{
`}
end
-redef class NativeString
+redef class CString
redef fun to_jvalue(env)`{
jvalue value;
value.l = (*env)->NewStringUTF(env, self);
do
var evbuffer = bev.input_buffer
var len = evbuffer.length
- var buf = new NativeString(len)
+ var buf = new CString(len)
evbuffer.remove(buf, len)
var str = buf.to_s_with_length(len)
read_callback str
`}
# Convert an error code from `evutil_socket_error` to a string
-fun evutil_socket_error_to_string(error_code: Int): NativeString `{
+fun evutil_socket_error_to_string(error_code: Int): CString `{
return evutil_socket_error_to_string(error_code);
`}
# Set callbacks to `read_callback_native`, `write_callback` and `event_callback` of `conn`
fun setcb(conn: Connection) import Connection.read_callback_native,
- Connection.write_callback, Connection.event_callback, NativeString `{
+ Connection.write_callback, Connection.event_callback, CString `{
Connection_incr_ref(conn);
bufferevent_setcb(self,
(bufferevent_data_cb)c_read_cb,
`}
# Write `length` bytes of `line`
- fun write(line: NativeString, length: Int): Int `{
+ fun write(line: CString, length: Int): Int `{
return bufferevent_write(self, line, length);
`}
fun length: Int `{ return evbuffer_get_length(self); `}
# Read data from an evbuffer and drain the bytes read
- fun remove(buffer: NativeString, len: Int) `{
+ fun remove(buffer: CString, len: Int) `{
evbuffer_remove(self, buffer, len);
`}
end
# A listener acting on an interface and port, spawns `Connection` on new connections
extern class ConnectionListener `{ struct evconnlistener * `}
- private new bind_to(base: NativeEventBase, address: NativeString, port: Int, factory: ConnectionFactory)
+ private new bind_to(base: NativeEventBase, address: CString, port: Int, factory: ConnectionFactory)
import ConnectionFactory.accept_connection, error_callback `{
struct sockaddr_in sin;
# Human representation of remote client address
var addr_len = 46 # Longest possible IPv6 address + null byte
- var addr_buf = new NativeString(addr_len)
+ var addr_buf = new CString(addr_len)
addr_buf = addrin_to_address(addrin, addr_buf, addr_len)
var addr = if addr_buf.address_is_null then
"Unknown address"
end
# Put string representation of source `address` into `buf`
- private fun addrin_to_address(address: Pointer, buf: NativeString, buf_len: Int): NativeString `{
+ private fun addrin_to_address(address: Pointer, buf: CString, buf_len: Int): CString `{
struct sockaddr *addrin = (struct sockaddr*)address;
if (addrin->sa_family == AF_INET) {
fun md5: String do return to_cstring.native_md5.to_s
end
-redef class NativeString
- private fun native_md5: NativeString `{
+redef class CString
+ private fun native_md5: CString `{
md5_state_t state;
md5_byte_t digest[16]; /* result */
char *hex_output = malloc(33*sizeof(char));
extern class AndroidAsset in "C" `{struct AAsset*`}
- fun read(count: Int): nullable String import String.as nullable, NativeString.to_s `{
+ fun read(count: Int): nullable String import String.as nullable, CString.to_s `{
char *buffer = malloc(sizeof(char) * (count+1));
int read = AAsset_read(self, buffer, count);
if (read != count)
else
{
buffer[count] = '\0';
- return String_as_nullable(NativeString_to_s(buffer));
+ return String_as_nullable(CString_to_s(buffer));
}
`}
redef fun to_s do
var ns = native.to_native_string
var res = ns.to_s_with_copy
- ns.free # manual free of gc allocated NativeString
+ ns.free # manual free of gc allocated CString
return res
end
# by parsing the JSON found in `data`.
# Only a single JSON object may exist in data or an error will be set and
# `NULL` returned.
- new from_json_string(data: NativeString) import set_mongoc_error `{
+ new from_json_string(data: CString) import set_mongoc_error `{
bson_error_t error;
bson_t *bson;
bson = bson_new_from_json((uint8_t *)data, -1, &error);
# The `bson_as_json()` function shall encode bson as a JSON encoded UTF-8 string.
# The caller is responsible for freeing the resulting UTF-8 encoded string
# by calling `bson_free()` with the result.
- fun to_native_string: NativeString `{ return bson_as_json(self, NULL); `}
+ fun to_native_string: CString `{ return bson_as_json(self, NULL); `}
# Wrapper for `bson_destroy()`.
#
# Wrapper for `error.message`.
#
# The `error.message` field contains a human printable error message.
- fun message: NativeString `{ return self->message; `}
+ fun message: CString `{ return self->message; `}
end
# Wrapper for `bson_oid_t`.
`}
# Object id.
- fun id: String import NativeString.to_s_with_copy `{
+ fun id: String import CString.to_s_with_copy `{
char str[25];
bson_oid_to_string(self, str);
- return NativeString_to_s_with_copy(str);
+ return CString_to_s_with_copy(str);
`}
# Destroy `self`.
# Wrapper for `char**`.
#
-# Used to handle array of NativeString returned by MongoDB.
+# Used to handle array of CString returned by MongoDB.
redef class NativeCStringArray
# Frees `self`.
#
# Wrapper for `mongoc_client_new()`.
#
# Creates a new `mongoc_client_t` using the `uri` string provided.
- new(uri: NativeString) `{
+ new(uri: CString) `{
mongoc_init();
return mongoc_client_new(uri);
`}
# Database are automatically created on the MongoDB server upon insertion of
# the first document into a collection.
# There is no need to create a database manually.
- new(client: NativeMongoClient, db_name: NativeString) `{
+ new(client: NativeMongoClient, db_name: CString) `{
return mongoc_client_get_database(client, db_name);
`}
#
# Allocates a new `mongoc_collection_t` structure for the collection named
# `name` in database.
- fun collection(name: NativeString): NativeMongoCollection `{
+ fun collection(name: CString): NativeMongoCollection `{
return mongoc_database_get_collection(self, name);
`}
#
# This function checks to see if a collection exists on the MongoDB server
# within database.
- fun has_collection(name: NativeString): Bool import set_mongoc_error `{
+ fun has_collection(name: CString): Bool import set_mongoc_error `{
bson_error_t error;
if(!mongoc_database_has_collection(self, name, &error)) {
NativeMongoDb_set_mongoc_error(self, &error);
# Collections are automatically created on the MongoDB server upon insertion
# of the first document.
# There is no need to create a collection manually.
- new(client: NativeMongoClient, db, collection: NativeString) `{
+ new(client: NativeMongoClient, db, collection: CString) `{
return mongoc_client_get_collection(client, db, collection);
`}
# The name of the collection will also be updated internally so it is safe
# to continue using this collection after the rename.
# Additional operations will occur on renamed collection.
- fun rename(new_database, new_name: NativeString): Bool `{
+ fun rename(new_database, new_name: CString): Bool `{
bson_error_t error;
if(!mongoc_collection_rename(self, new_database, new_name, false, &error)){
NativeMongoCollection_set_mongoc_error(self, &error);
fun finalize `{ MPI_Finalize(); `}
# Name of this processor, usually the hostname
- fun processor_name: String import NativeString.to_s_with_length `{
+ fun processor_name: String import CString.to_s_with_length `{
char *name = malloc(MPI_MAX_PROCESSOR_NAME);
int size;
MPI_Get_processor_name(name, &size);
- return NativeString_to_s_with_length(name, size);
+ return CString_to_s_with_length(name, size);
`}
# Send the content of a buffer
`}
redef fun to_s do return native_to_s.to_s
- private fun native_to_s: NativeString `{
+ private fun native_to_s: CString `{
char *err = malloc(MPI_MAX_ERROR_STRING);
MPI_Error_string(self, err, NULL);
return err;
# An MPI error class
extern class ErrorClass `{ int `}
redef fun to_s do return native_to_s.to_s
- private fun native_to_s: NativeString `{
+ private fun native_to_s: CString `{
char *err = malloc(MPI_MAX_ERROR_STRING);
MPI_Error_string(self, err, NULL);
return err;
private fun as_bool: Bool `{ return self->value.as_bool; `}
private fun as_int: Int `{ return self->value.as_int; `}
private fun as_float: Float `{ return self->value.as_double; `}
- private fun as_string: String import NativeString.to_s_with_length `{
+ private fun as_string: String import CString.to_s_with_length `{
uint32_t len;
char* str = (char*)g_varInterface->VarToUtf8(*self, &len);
- return NativeString_to_s_with_length(str, len);
+ return CString_to_s_with_length(str, len);
`}
end
redef fun is_writable: Bool do return true
# Checks if there is a message in the queue, and if so the message is handled automatically.
- fun check_message: NativeString `{
+ fun check_message: CString `{
return NitHandleMessage();
`}
class PnaclApp
# Sets everything up to work, need to be called at first.
- fun initialize import PnaclApp.handle_message, PnaclApp.handle_dictionary, NativeString.to_s_with_length `{
+ fun initialize import PnaclApp.handle_message, PnaclApp.handle_dictionary, CString.to_s_with_length `{
app = self;
`}
redef extern class Passwd
# User information
- fun gecos: String import NativeString.to_s `{ return NativeString_to_s(self->pw_gecos); `}
+ fun gecos: String import CString.to_s `{ return CString_to_s(self->pw_gecos); `}
end
return !(self == PGRES_BAD_RESPONSE || self == PGRES_NONFATAL_ERROR || self == PGRES_FATAL_ERROR);
`}
- redef fun to_s import NativeString.to_s `{
+ redef fun to_s import CString.to_s `{
char * err = PQresStatus(self);
if(err == NULL) err = "";
- return NativeString_to_s(err);
+ return CString_to_s(err);
`}
end
fun status: ExecStatusType `{ return PQresultStatus(self); `}
# Returns the field name of a given column_number
- fun fname(column_number:Int):String import NativeString.to_s `{
- return NativeString_to_s( PQfname(self, column_number));
+ fun fname(column_number:Int):String import CString.to_s `{
+ return CString_to_s( PQfname(self, column_number));
`}
# Returns the column number associated with the column name
`}
# Returns a single field value of one row of the result at row_number, column_number
- fun value(row_number:Int, column_number:Int):String import NativeString.to_s `{
- return NativeString_to_s(PQgetvalue(self, row_number, column_number));
+ fun value(row_number:Int, column_number:Int):String import CString.to_s `{
+ return CString_to_s(PQgetvalue(self, row_number, column_number));
`}
# Tests wether a field is a null value
`}
# Returns the error message of the last operation on the connection
- fun error: String import NativeString.to_s `{
+ fun error: String import CString.to_s `{
char * error = PQerrorMessage(self);
- return NativeString_to_s(error);
+ return CString_to_s(error);
`}
# Returns the status of this connection
#include <readline/history.h>
`}
-private fun native_readline(prompt: NativeString): NativeString `{
+private fun native_readline(prompt: CString): CString `{
return readline(prompt);
`}
-private fun native_add_history(data: NativeString) `{
+private fun native_add_history(data: CString) `{
if (data == NULL) return;
add_history(data);
`}
return null_SDLInputEvent();
`}
- private fun new_key_event(name: NativeString, down: Bool): nullable SDLInputEvent
+ private fun new_key_event(name: CString, down: Bool): nullable SDLInputEvent
do return new SDLKeyEvent(name.to_s, down)
private fun new_mouse_motion_event(x, y, xr, yr: Float, down: Bool): nullable SDLInputEvent
if (fn == NULL)
return null_String();
else
- return String_as_nullable(NativeString_to_s(fn));
+ return String_as_nullable(CString_to_s(fn));
`}
# Return the style name of the font
if (sn == NULL)
return null_String();
else
- return String_as_nullable(NativeString_to_s(sn));
+ return String_as_nullable(CString_to_s(sn));
`}
# Return the estimated width of a String if used with the current font
- fun width_of(text: String): Int import NativeString.to_s `{
+ fun width_of(text: String): Int import CString.to_s `{
char *ctext = String_to_cstring(text);
int w;
if (TTF_SizeText(self, ctext, &w, NULL))
fun quit `{ IMG_Quit(); `}
# Get the latest image library error
- fun error: NativeString `{ return (char*)IMG_GetError(); `}
+ fun error: CString `{ return (char*)IMG_GetError(); `}
end
redef extern class SDLSurface
# Load the image at `path` inferring its type from the file extension
- new load(path: NativeString) `{ return IMG_Load(path); `}
+ new load(path: CString) `{ return IMG_Load(path); `}
end
# Flags from `sys.sdl.img.initialize`
# Returns the latest SDL error
#
# After calling this method, you should also call `clear_error`.
- fun error: NativeString `{ return (char*)SDL_GetError(); `}
+ fun error: CString `{ return (char*)SDL_GetError(); `}
# Clear the SDL error
fun clear_error `{ SDL_ClearError(); `}
fun system_ram: Int `{ return SDL_GetSystemRAM(); `}
# Show a simple message box
- fun show_simple_message_box(level: SDLMessageBoxFlags, title, content: NativeString) `{
+ fun show_simple_message_box(level: SDLMessageBoxFlags, title, content: CString) `{
SDL_ShowSimpleMessageBox(level, title, content, NULL);
`}
# A window created by SDL
extern class SDLWindow `{ SDL_Window * `}
# Create a window with the given `title`, `width` and `height`, also apply the `flags`
- new (title: NativeString, width, height: Int, flags: SDLWindowFlags) `{
+ new (title: CString, width, height: Int, flags: SDLWindowFlags) `{
return SDL_CreateWindow(title,
SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
width, height, flags);
# Show a simple message box
#
# Similar to `sys.sdl.show_simple_message_box` but attached to this window
- fun show_simple_message_box(level: SDLMessageBoxFlags, title, content: NativeString) `{
+ fun show_simple_message_box(level: SDLMessageBoxFlags, title, content: CString) `{
SDL_ShowSimpleMessageBox(level, title, content, self);
`}
extern class SDLSurface `{ SDL_Surface * `}
# Load the BMP file at `path`
- new load_bmp(path: NativeString) `{ return SDL_LoadBMP(path); `}
+ new load_bmp(path: CString) `{ return SDL_LoadBMP(path); `}
redef fun free `{ SDL_FreeSurface(self); `}
# Save this texture to a BMP file
- fun save_bmp(path: NativeString) `{ SDL_SaveBMP(self, path); `}
+ fun save_bmp(path: CString) `{ SDL_SaveBMP(self, path); `}
end
# A loaded bitmap texture
new malloc `{ return malloc(sizeof(SDL_RendererInfo)); `}
# Name of the renderer's driver
- fun name: NativeString `{ return (char*)self->name; `}
+ fun name: CString `{ return (char*)self->name; `}
# Maximum texture width supported by the renderer
fun max_texture_width: Int `{ return self->max_texture_width; `}
redef class Char super DirectSerializable end
redef class Int super DirectSerializable end
redef class Float super DirectSerializable end
-redef class NativeString super DirectSerializable end
+redef class CString super DirectSerializable end
redef class Text super DirectSerializable end
redef class SimpleCollection[E] super Serializable end
redef class Map[K, V] super Serializable end
}
`}
-redef class NativeString
- private fun sha1_intern(len: Int): NativeString `{
+redef class CString
+ private fun sha1_intern(len: Int): CString `{
sha1nfo s;
sha1_init(&s);
# Computes the SHA1 of the receiver
#
- # Returns a digest of 20 bytes as a NativeString,
+ # Returns a digest of 20 bytes as a CString,
# note that all the characters are not necessarily ASCII.
# If you want the hex string version of the digest, use
# sha1_hexdigest.
# Creates a socket connection to host `host` on port `port`
init connect(host: String, port: Int)
do
- _buffer = new NativeString(1024)
+ _buffer = new CString(1024)
_buffer_pos = 0
native = new NativeSocket.socket(new NativeSocketAddressFamilies.af_inet,
new NativeSocketTypes.sock_stream, new NativeSocketProtocolFamilies.pf_null)
if _buffer_capacity >= len then return
_buffer_capacity = len
- var ns = new NativeString(_buffer_capacity)
+ var ns = new CString(_buffer_capacity)
_buffer.copy_to(ns, _buffer_length - _buffer_pos, _buffer_pos, 0)
_buffer = ns
end
# On error, returns an empty string and sets `error` appropriately.
fun recv(length: Int): String
do
- var buf = new NativeString(length)
+ var buf = new CString(length)
var len = native.recvfrom(buf, length, 0, new NativeSocketAddrIn.nul)
if len == -1 then
error = new IOError.from_errno
fun recv_from(length: Int, sender: Ref[nullable SocketAddress]): String
do
var src = new NativeSocketAddrIn
- var buf = new NativeString(length)
+ var buf = new CString(length)
var len = native.recvfrom(buf, length, 0, src)
if len == -1 then
`}
# Write `length` bytes from `buffer`
- fun write(buffer: NativeString, length: Int): Int `{
+ fun write(buffer: CString, length: Int): Int `{
return write(*self, buffer, length);
`}
`}
# Read `length` bytes into `buffer`, returns the number of bytes read
- fun read(buffer: NativeString, length: Int): Int `{
+ fun read(buffer: CString, length: Int): Int `{
return read(*self, buffer, length);
`}
`}
# Send `len` bytes from `buf` to `dest_addr`
- fun sendto(buf: NativeString, len: Int, flags: Int, dest_addr: NativeSocketAddrIn): Int `{
+ fun sendto(buf: CString, len: Int, flags: Int, dest_addr: NativeSocketAddrIn): Int `{
return sendto(*self, buf, len, flags, (struct sockaddr*)dest_addr, sizeof(struct sockaddr_in));
`}
# Receive a message into `buf` of maximum `len` bytes
- fun recv(buf: NativeString, len: Int, flags: Int): Int `{
+ fun recv(buf: CString, len: Int, flags: Int): Int `{
return recv(*self, buf, len, flags);
`}
# Receive a message into `buf` of maximum `len` bytes and store sender info into `src_addr`
- fun recvfrom(buf: NativeString, len: Int, flags: Int, src_addr: NativeSocketAddrIn): Int `{
+ fun recvfrom(buf: CString, len: Int, flags: Int, src_addr: NativeSocketAddrIn): Int `{
socklen_t srclen = sizeof(struct sockaddr_in);
return recvfrom(*self, buf, len, flags, (struct sockaddr*)src_addr, &srclen);
`}
`}
# Internet address as then IPV4 numbers-and-dots notation
- fun address: NativeString `{ return (char*)inet_ntoa(self->sin_addr); `}
+ fun address: CString `{ return (char*)inet_ntoa(self->sin_addr); `}
# Set `address` to `INADDR_ANY`
fun address_any `{ self->sin_addr.s_addr = INADDR_ANY; `}
# Host entry information, a pointer to a `struct hostent`
extern class NativeSocketHostent `{ struct hostent* `}
- private fun native_h_aliases(i: Int): NativeString `{
+ private fun native_h_aliases(i: Int): CString `{
return self->h_aliases[i];
`}
return res
end
- fun h_addr: NativeString `{
+ fun h_addr: CString `{
return (char*)inet_ntoa(*(struct in_addr*)self->h_addr);
`}
fun h_length: Int `{ return self->h_length; `}
- fun h_name: NativeString `{ return self->h_name; `}
+ fun h_name: CString `{ return self->h_name; `}
end
extern class NativeTimeval `{ struct timeval* `}
redef class Sys
# Get network host entry
- fun gethostbyname(name: NativeString): NativeSocketHostent `{
+ fun gethostbyname(name: CString): NativeSocketHostent `{
return gethostbyname(name);
`}
return err.to_s
end
- private fun native_to_s: NativeString `{
+ private fun native_to_s: CString `{
#if SQLITE_VERSION_NUMBER >= 3007015
return (char *)sqlite3_errstr(self);
#else
return sqlite3_step(self);
`}
- fun column_name(i: Int): NativeString `{
+ fun column_name(i: Int): CString `{
return (char *)sqlite3_column_name(self, i);
`}
return sqlite3_column_int(self, i);
`}
- fun column_text(i: Int): NativeString `{
+ fun column_text(i: Int): CString `{
return (char *)sqlite3_column_text(self, i);
`}
extern class NativeSqlite3 `{sqlite3 *`}
# Open a connection to a database in UTF-8
- new open(filename: NativeString) `{
+ new open(filename: CString) `{
sqlite3 *self = NULL;
int err = sqlite3_open(filename, &self);
nit_sqlite_open_error = err;
`}
# Execute a SQL statement
- fun exec(sql: NativeString): Sqlite3Code `{
+ fun exec(sql: CString): Sqlite3Code `{
return sqlite3_exec(self, sql, NULL, NULL, NULL);
`}
# Prepare a SQL statement
- fun prepare(sql: NativeString): NativeStatement `{
+ fun prepare(sql: CString): NativeStatement `{
sqlite3_stmt *stmt;
int res = sqlite3_prepare_v2(self, sql, -1, &stmt, 0);
if (res == SQLITE_OK)
super TCPStream
init do
- _buffer = new NativeString(1024)
+ _buffer = new CString(1024)
_buffer_pos = 0
_buffer_capacity = 1024
_buffer_length = 0
end
# Unmasks a message sent by a client
- private fun unmask_message(key: NativeString, message: NativeString, len: Int): NativeString
+ private fun unmask_message(key: CString, message: CString, len: Int): CString
do
- var return_message = new NativeString(len)
+ var return_message = new CString(len)
for i in [0 .. len[ do
return_message[i] = message[i] ^ key[i % 4]
fun update: Bool `{ return xdgUpdateData(self); `}
# Base directory for user specific data files.
- fun data_home: String import NativeString.to_s `{
- return NativeString_to_s((char*)xdgDataHome(self));
+ fun data_home: String import CString.to_s `{
+ return CString_to_s((char*)xdgDataHome(self));
`}
# Base directory for user specific configuration files.
- fun config_home: String import NativeString.to_s `{
- return NativeString_to_s((char*)xdgConfigHome(self));
+ fun config_home: String import CString.to_s `{
+ return CString_to_s((char*)xdgConfigHome(self));
`}
# Base directory for user specific non-essential data files.
- fun cache_home: String import NativeString.to_s `{
- return NativeString_to_s((char*)xdgCacheHome(self));
+ fun cache_home: String import CString.to_s `{
+ return CString_to_s((char*)xdgCacheHome(self));
`}
# Preference-ordered set of base directories to search for data files
private extern class ConstPointer `{ const void * `}
# Convert a C `char **` to a Nit `Array[String]`
fun to_string_array: Array[String]
- import Array[String], Array[String].add, NativeString.to_s `{
+ import Array[String], Array[String].add, CString.to_s `{
char **strings = (char**)self;
Array_of_String aos = new_Array_of_String();
int p = 0;
while (strings[p] != NULL) {
- Array_of_String_add(aos, NativeString_to_s((char*)strings[p]));
+ Array_of_String_add(aos, CString_to_s((char*)strings[p]));
p ++;
}
end
# Return a "const char*" variable associated to the classname of the dynamic type of an object
- # NOTE: we do not return a `RuntimeVariable` "NativeString" as the class may not exist in the module/program
+ # NOTE: we do not return a `RuntimeVariable` "CString" as the class may not exist in the module/program
fun class_name_string(value: RuntimeVariable): String is abstract
# Variables handling
return res
end
- # Generates a NativeString instance fully escaped in C-style \xHH fashion
- fun native_string_instance(ns: NativeString, len: Int): RuntimeVariable do
+ # Generates a CString instance fully escaped in C-style \xHH fashion
+ fun native_string_instance(ns: CString, len: Int): RuntimeVariable do
var mtype = mmodule.native_string_type
var nat = new_var(mtype)
var byte_esc = new Buffer.with_cap(len * 4)
return "int32_t"
else if mclass.name == "UInt32" then
return "uint32_t"
- else if mclass.name == "NativeString" then
+ else if mclass.name == "CString" then
return "char*"
else if mclass.name == "NativeArray" then
return "val*"
return "i32"
else if mclass.name == "UInt32" then
return "u32"
- else if mclass.name == "NativeString" then
+ else if mclass.name == "CString" then
return "str"
else if mclass.name == "NativeArray" then
#return "{self.arguments.first.ctype}*"
v.ret(v.new_expr("(uint32_t){arguments[0]}", ret.as(not null)))
return true
end
- else if cname == "NativeString" then
+ else if cname == "CString" then
if pname == "[]" then
v.ret(v.new_expr("(unsigned char)((int){arguments[0]}[{arguments[1]}])", ret.as(not null)))
return true
v.ret(v.new_expr("!{res}", ret.as(not null)))
return true
else if pname == "new" then
- var alloc = v.nit_alloc(arguments[1].to_s, "NativeString")
+ var alloc = v.nit_alloc(arguments[1].to_s, "CString")
v.ret(v.new_expr("(char*){alloc}", ret.as(not null)))
return true
else if pname == "fetch_4_chars" then
redef fun unbox_extern(value, mtype)
do
if mtype isa MClassType and mtype.mclass.kind == extern_kind and
- mtype.mclass.name != "NativeString" then
+ mtype.mclass.name != "CString" then
var res = self.new_var_extern(mtype)
self.add "{res} = ((struct {mtype.c_name}*){value})->value; /* unboxing {value.mtype} */"
return res
redef fun box_extern(value, mtype)
do
if not mtype isa MClassType or mtype.mclass.kind != extern_kind or
- mtype.mclass.name == "NativeString" then return value
+ mtype.mclass.name == "CString" then return value
var valtype = value.mtype.as(MClassType)
var res = self.new_var(mtype)
return "double"
else if mclass.name == "Byte" then
return "byte"
- else if mclass.name == "NativeString" then
+ else if mclass.name == "CString" then
return "String"
else if mclass.name == "NativeArray" then
return "Array"
do
# Collect all bas box class
# FIXME: this is not completely fine with a separate compilation scheme
- for classname in ["Int", "Bool", "Byte", "Char", "Float", "NativeString",
+ for classname in ["Int", "Bool", "Byte", "Char", "Float", "CString",
"Pointer", "Int8", "Int16", "UInt16", "Int32", "UInt32"] do
var classes = self.mainmodule.model.get_mclasses_by_name(classname)
if classes == null then continue
#if mclass.mclass_type.ctype == "val*" or mclass.mclass_type.is_subtype(self.mainmodule, mclass.mclass_type pointer_type) then
if mclass.mclass_type.ctype_extern == "val*" then
return 0
- else if mclass.kind == extern_kind and mclass.name != "NativeString" then
+ else if mclass.kind == extern_kind and mclass.name != "CString" then
return self.box_kinds[self.mainmodule.pointer_type.mclass]
else
return self.box_kinds[mclass]
v.add("return (val*){res};")
v.add("\}")
return
- else if mtype.mclass.kind == extern_kind and mtype.mclass.name != "NativeString" then
- # Is an extern class (other than Pointer and NativeString)
- # Pointer is caught in a previous `if`, and NativeString is internal
+ else if mtype.mclass.kind == extern_kind and mtype.mclass.name != "CString" then
+ # Is an extern class (other than Pointer and CString)
+ # Pointer is caught in a previous `if`, and CString is internal
var pointer_type = mainmodule.pointer_type
return res
end
var valtype = value.mtype.as(MClassType)
- if mtype isa MClassType and mtype.mclass.kind == extern_kind and mtype.mclass.name != "NativeString" then
+ if mtype isa MClassType and mtype.mclass.kind == extern_kind and mtype.mclass.name != "CString" then
valtype = compiler.mainmodule.pointer_type
end
var res = self.new_var(mtype)
redef fun unbox_extern(value, mtype)
do
if mtype isa MClassType and mtype.mclass.kind == extern_kind and
- mtype.mclass.name != "NativeString" then
+ mtype.mclass.name != "CString" then
var pointer_type = compiler.mainmodule.pointer_type
var res = self.new_var_extern(mtype)
self.add "{res} = ((struct instance_{pointer_type.c_name}*){value})->value; /* unboxing {value.mtype} */"
redef fun box_extern(value, mtype)
do
if mtype isa MClassType and mtype.mclass.kind == extern_kind and
- mtype.mclass.name != "NativeString" then
+ mtype.mclass.name != "CString" then
var valtype = compiler.mainmodule.pointer_type
var res = self.new_var(mtype)
compiler.undead_types.add(mtype)
if not value.mtype.is_c_primitive then
self.add "{res} = {value} == NULL ? \"null\" : {type_info(value)}->name;"
else if value.mtype isa MClassType and value.mtype.as(MClassType).mclass.kind == extern_kind and
- value.mtype.as(MClassType).name != "NativeString" then
+ value.mtype.as(MClassType).name != "CString" then
self.add "{res} = \"{value.mtype.as(MClassType).mclass}\";"
else
self.require_declaration("type_{value.mtype.c_name}")
v.add("return (val*){res};")
v.add("\}")
return
- else if mtype.mclass.kind == extern_kind and mtype.mclass.name != "NativeString" then
+ else if mtype.mclass.kind == extern_kind and mtype.mclass.name != "CString" then
var pointer_type = mainmodule.pointer_type
self.provide_declaration("NEW_{c_name}", "{mtype.ctype} NEW_{c_name}();")
redef fun unbox_extern(value, mtype)
do
if mtype isa MClassType and mtype.mclass.kind == extern_kind and
- mtype.mclass.name != "NativeString" then
+ mtype.mclass.name != "CString" then
var pointer_type = compiler.mainmodule.pointer_type
var res = self.new_var_extern(mtype)
self.add "{res} = ((struct instance_{pointer_type.c_name}*){value})->value; /* unboxing {value.mtype} */"
redef fun box_extern(value, mtype)
do
if mtype isa MClassType and mtype.mclass.kind == extern_kind and
- mtype.mclass.name != "NativeString" then
+ mtype.mclass.name != "CString" then
var valtype = compiler.mainmodule.pointer_type
var res = self.new_var(mtype)
if compiler.runtime_type_analysis != null and not compiler.runtime_type_analysis.live_types.has(value.mtype.as(MClassType)) then
# The `Instance` held by this cell
fun instance=(value: Instance) is light_ffi `{ self->value_Pointer = value; `}
- # The `NativeString` held by this cell
- fun native_string: NativeString `{ return (char*)self->value_Pointer; `}
+ # The `CString` held by this cell
+ fun native_string: CString `{ return (char*)self->value_Pointer; `}
# Set the content of this cell according to `static_type`
#
else if static_type.name == "Float" then
assert value isa PrimitiveInstance[Float]
self.float = value.val
- else if static_type.name == "NativeString" then
- assert value isa PrimitiveInstance[NativeString]
+ else if static_type.name == "CString" then
+ assert value isa PrimitiveInstance[CString]
self.pointer = value.val
else if static_type isa MClassType and static_type.mclass.kind == extern_kind then
assert value isa PrimitiveInstance[Pointer] else print value.class_name
return v.uint32_instance(self.uint32)
else if name == "Float" then
return v.float_instance(self.float)
- else if name == "NativeString" then
- var instance = new PrimitiveInstance[NativeString](static_type, self.native_string)
+ else if name == "CString" then
+ var instance = new PrimitiveInstance[CString](static_type, self.native_string)
v.init_instance_primitive instance
return instance
else if static_type isa MClassType and static_type.mclass.kind == extern_kind then
# Handle to foreign code library
private extern class ForeignCodeLib
# Open and load the library at `path`
- new dlopen(path: NativeString) `{
+ new dlopen(path: CString) `{
return dlopen(path, RTLD_LOCAL | RTLD_NOW);
`}
# Find the `ForeignCodeEntry` at `symbol_name`
- fun dlsym(symbol_name: NativeString): ForeignCodeEntry `{
+ fun dlsym(symbol_name: CString): ForeignCodeEntry `{
return dlsym(self, symbol_name);
`}
end
-private fun dlerror: NativeString `{ return dlerror(); `}
+private fun dlerror: CString `{ return dlerror(); `}
# Handle to an implementation function in a `ForeignCodeLib`
private extern class ForeignCodeEntry`{ nit_foreign_lib_entry `}
end
# Return a new native string initialized with `txt`
- fun native_string_instance_from_ns(txt: NativeString, len: Int): Instance
+ fun native_string_instance_from_ns(txt: CString, len: Int): Instance
do
var instance = native_string_instance_len(len)
var val = instance.val
end
# Return a new native string initialized of `length`
- fun native_string_instance_len(length: Int): PrimitiveInstance[NativeString]
+ fun native_string_instance_len(length: Int): PrimitiveInstance[CString]
do
- var val = new NativeString(length)
+ var val = new CString(length)
var t = mainmodule.native_string_type
- var instance = new PrimitiveInstance[NativeString](t, val)
+ var instance = new PrimitiveInstance[CString](t, val)
init_instance_primitive(instance)
return instance
end
else if pname == "round" then
return v.float_instance(args[0].to_f.round)
end
- else if cname == "NativeString" then
+ else if cname == "CString" then
if pname == "new" then
return v.native_string_instance_len(args[1].to_i)
end
- var recvval = args.first.val.as(NativeString)
+ var recvval = args.first.val.as(CString)
if pname == "[]" then
var arg1 = args[1].to_i
return v.byte_instance(recvval[arg1])
recvval[arg1] = args[2].val.as(Byte)
return null
else if pname == "copy_to" then
- # sig= copy_to(dest: NativeString, length: Int, from: Int, to: Int)
- var destval = args[1].val.as(NativeString)
+ # sig= copy_to(dest: CString, length: Int, from: Int, to: Int)
+ var destval = args[1].val.as(CString)
var lenval = args[2].to_i
var fromval = args[3].to_i
var toval = args[4].to_i
var ns = recvval.fast_cstring(args[1].to_i)
return v.native_string_instance(ns.to_s)
else if pname == "fetch_4_chars" then
- return v.int_instance(args[0].val.as(NativeString).fetch_4_chars(args[1].to_i))
+ return v.int_instance(args[0].val.as(CString).fetch_4_chars(args[1].to_i))
else if pname == "fetch_4_hchars" then
- return v.int_instance(args[0].val.as(NativeString).fetch_4_hchars(args[1].to_i))
+ return v.int_instance(args[0].val.as(CString).fetch_4_hchars(args[1].to_i))
else if pname == "utf8_length" then
- return v.int_instance(args[0].val.as(NativeString).utf8_length(args[1].to_i, args[2].to_i))
+ return v.int_instance(args[0].val.as(CString).utf8_length(args[1].to_i, args[2].to_i))
end
else if cname == "NativeArray" then
if pname == "new" then
return false
end
- fun io_read(buf: NativeString, len: Int): Int do
+ fun io_read(buf: CString, len: Int): Int do
if file isa FileStream then return file.as(FileStream)._file.io_read(buf, len)
var str = file.as(Reader).read(len)
str.to_cstring.copy_to(buf, str.length, 0, 0)
return str.length
end
- fun io_write(buf: NativeString, from, len: Int): Int do
+ fun io_write(buf: CString, from, len: Int): Int do
if file isa FileStream then return file.as(FileStream)._file.io_write(buf, from, len)
file.as(Writer).write(buf.to_s_with_length(len).substring_from(from))
return len
# The primitive type `String`
var string_type: MClassType = self.get_primitive_class("String").mclass_type is lazy
- # The primitive type `NativeString`
- var native_string_type: MClassType = self.get_primitive_class("NativeString").mclass_type is lazy
+ # The primitive type `CString`
+ var native_string_type: MClassType = self.get_primitive_class("CString").mclass_type is lazy
# A primitive type of `Array`
fun array_type(elt_type: MType): MClassType do return array_class.get_mtype([elt_type])
if name == "UInt16" then return "uint16_t"
if name == "Int32" then return "int32_t"
if name == "UInt32" then return "uint32_t"
- if name == "NativeString" then return "char*"
+ if name == "CString" then return "char*"
if mclass.kind == extern_kind then
var ctype = mclass.ctype
assert ctype != null
if name == "UInt16" then return "uint16_t"
if name == "Int32" then return "int32_t"
if name == "UInt32" then return "uint32_t"
- if name == "NativeString" then return "char*"
+ if name == "CString" then return "char*"
if mclass.kind == extern_kind then return "void*"
return super
end
redef fun mangled_cname do return mclass.name
redef fun is_cprimitive do return mclass.kind == extern_kind or
- (once ["Bool", "Char", "Float", "Int", "NativeString",
+ (once ["Bool", "Char", "Float", "Int", "CString",
"Byte", "Int8", "Int16", "UInt16", "Int32", "UInt32"]).has(mclass.name)
end
var newline: nullable CallSite = null
# Regex::extended, used for suffix `b` on `re`
var extended: nullable CallSite = null
- # NativeString::to_bytes_with_copy, used for prefix `b`
+ # CString::to_bytes_with_copy, used for prefix `b`
var to_bytes_with_copy: nullable CallSite = null
redef fun accept_typing(v) do
nitlanguage / nit.git / commitdiff