#
# This file is free software, which comes along with NIT. This software is
# distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
-# without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE. You can modify it is you want, provided this header
# is kept unaltered, and a notification of the changes is added.
# You are allowed to redistribute it and sell it, alone or is a part of
intrude import ropes
import string_search
import time
+import gc
in "C Header" `{
#include <dirent.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>
+ #include <poll.h>
+ #include <errno.h>
`}
# File Abstract Stream
private var file: nullable NativeFile = null
# The status of a file. see POSIX stat(2).
- fun file_stat: FileStat do return _file.file_stat
+ fun file_stat: NativeFileStat do return _file.file_stat
# File descriptor of this file
fun fd: Int do return _file.fileno
+
+ # Sets the buffering mode for the current FStream
+ #
+ # If the buf_size is <= 0, its value will be 512 by default
+ #
+ # The mode is any of the buffer_mode enumeration in `Sys`:
+ # - buffer_mode_full
+ # - buffer_mode_line
+ # - buffer_mode_none
+ fun set_buffering_mode(buf_size, mode: Int) do
+ if buf_size <= 0 then buf_size = 512
+ if _file.set_buffering_type(buf_size, mode) != 0 then
+ last_error = new IOError("Error while changing buffering type for FStream, returned error {sys.errno.strerror}")
+ end
+ end
end
# File input stream
# The original path is reused, therefore the reopened file can be a different file.
fun reopen
do
- if not eof then close
+ if not eof and not _file.address_is_null then close
+ last_error = null
_file = new NativeFile.io_open_read(path.to_cstring)
+ if _file.address_is_null then
+ last_error = new IOError("Error: Opening file at '{path.as(not null)}' failed with '{sys.errno.strerror}'")
+ end_reached = true
+ return
+ end
end_reached = false
_buffer_pos = 0
_buffer.clear
redef fun close
do
- _file.io_close
+ if _file.address_is_null then return
+ var i = _file.io_close
_buffer.clear
end_reached = true
end
_buffer.length = nb
_buffer_pos = 0
end
-
+
# End of file?
redef var end_reached: Bool = false
self.path = path
prepare_buffer(10)
_file = new NativeFile.io_open_read(path.to_cstring)
- assert not _file.address_is_null else
- print "Error: Opening file at '{path}' failed with '{sys.errno.strerror}'"
+ if _file.address_is_null then
+ last_error = new IOError("Error: Opening file at '{path}' failed with '{sys.errno.strerror}'")
+ end_reached = true
end
end
+ init from_fd(fd: Int) do
+ self.path = ""
+ prepare_buffer(1)
+ _file = fd.fd_to_stream(read_only)
+ if _file.address_is_null then
+ last_error = new IOError("Error: Converting fd {fd} to stream failed with '{sys.errno.strerror}'")
+ end_reached = true
+ end
+ end
end
# File output stream
class OFStream
super FStream
super OStream
-
+
redef fun write(s)
do
- assert _is_writable
+ if last_error != null then return
+ if not _is_writable then
+ last_error = new IOError("Cannot write to non-writable stream")
+ return
+ end
if s isa FlatText then
write_native(s.to_cstring, s.length)
else
for i in s.substrings do write_native(i.to_cstring, i.length)
end
+ _file.flush
end
redef fun close
do
- _file.io_close
+ if _file.address_is_null then
+ if last_error != null then return
+ last_error = new IOError("Cannot close unopened write stream")
+ _is_writable = false
+ return
+ end
+ var i = _file.io_close
+ if i != 0 then
+ last_error = new IOError("Close failed due to error {sys.errno.strerror}")
+ end
_is_writable = false
end
-
redef var is_writable = false
-
+
# Write `len` bytes from `native`.
private fun write_native(native: NativeString, len: Int)
do
- assert _is_writable
+ if last_error != null then return
+ if not _is_writable then
+ last_error = new IOError("Cannot write to non-writable stream")
+ return
+ end
+ if _file.address_is_null then
+ last_error = new IOError("Writing on a null stream")
+ _is_writable = false
+ return
+ end
var err = _file.io_write(native, len)
if err != len then
# Big problem
- printn("Problem in writing : ", err, " ", len, "\n")
+ last_error = new IOError("Problem in writing : {err} {len} \n")
end
end
-
+
# Open the file at `path` for writing.
init open(path: String)
do
_file = new NativeFile.io_open_write(path.to_cstring)
- assert not _file.address_is_null else
- print "Error: Opening file at '{path}' failed with '{sys.errno.strerror}'"
- end
self.path = path
_is_writable = true
+ if _file.address_is_null then
+ last_error = new IOError("Error: Opening file at '{path}' failed with '{sys.errno.strerror}'")
+ is_writable = false
+ end
+ end
+
+ # Creates a new File stream from a file descriptor
+ init from_fd(fd: Int) do
+ self.path = ""
+ _file = fd.fd_to_stream(wipe_write)
+ _is_writable = true
+ if _file.address_is_null then
+ last_error = new IOError("Error: Opening stream from file descriptor {fd} failed with '{sys.errno.strerror}'")
+ _is_writable = false
+ end
end
end
+redef class Int
+ # 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 is extern "file_int_fdtostream"
+end
+
+# Constant for read-only file streams
+private fun read_only: NativeString do return "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 "w".to_cstring
+
###############################################################################
# Standard input stream.
end
end
-redef class String
- # return true if a file with this names exists
- fun file_exists: Bool do return to_cstring.file_exists
+# Utility class to access file system services
+#
+# Usually created with `Text::to_path`.
+class Path
- # The status of a file. see POSIX stat(2).
- fun file_stat: FileStat do return to_cstring.file_stat
+ private var path: String
- # The status of a file or of a symlink. see POSIX lstat(2).
- fun file_lstat: FileStat do return to_cstring.file_lstat
+ # Path to this file
+ redef fun to_s do return path
- # Remove a file, return true if success
- fun file_delete: Bool do return to_cstring.file_delete
+ # Name of the file name at `to_s`
+ #
+ # ~~~
+ # var path = "/tmp/somefile".to_path
+ # assert path.filename == "somefile"
+ # ~~~
+ var filename: String = path.basename("") is lazy
- # Copy content of file at `self` to `dest`
- fun file_copy_to(dest: String)
+ # Does the file at `path` exists?
+ fun exists: Bool do return stat != null
+
+ # Information on the file at `self` following symbolic links
+ #
+ # Returns `null` if there is no file at `self`.
+ #
+ # ~~~
+ # var p = "/tmp/".to_path
+ # var stat = p.stat
+ # if stat != null then # Does `p` exist?
+ # print "It's size is {stat.size}"
+ # if stat.is_dir then print "It's a directory"
+ # end
+ # ~~~
+ fun stat: nullable FileStat
do
- var input = new IFStream.open(self)
- var output = new OFStream.open(dest)
+ var stat = path.to_cstring.file_stat
+ if stat.address_is_null then return null
+ return new FileStat(stat)
+ end
+
+ # Information on the file or link at `self`
+ #
+ # Do not follow symbolic links.
+ fun link_stat: nullable FileStat
+ do
+ var stat = path.to_cstring.file_lstat
+ if stat.address_is_null then return null
+ return new FileStat(stat)
+ end
+
+ # Delete a file from the file system, return `true` on success
+ #
+ # Require: `exists`
+ fun delete: Bool do return path.to_cstring.file_delete
+
+ # Copy content of file at `path` to `dest`
+ #
+ # Require: `exists`
+ fun copy(dest: Path)
+ do
+ var input = open_ro
+ var output = dest.open_wo
while not input.eof do
var buffer = input.read(1024)
output.close
end
+ # Open this file for reading
+ #
+ # Require: `exists and not link_stat.is_dir`
+ fun open_ro: IFStream
+ do
+ # TODO manage streams error when they are merged
+ return new IFStream.open(path)
+ end
+
+ # Open this file for writing
+ #
+ # Require: `not exists or not stat.is_dir`
+ fun open_wo: OFStream
+ do
+ # TODO manage streams error when they are merged
+ return new OFStream.open(path)
+ end
+
+ # Lists the name of the files contained within the directory at `path`
+ #
+ # Require: `exists and is_dir`
+ fun files: Array[Path]
+ do
+ var files = new Array[Path]
+ for filename in path.files do
+ files.add new Path(path / filename)
+ end
+ return files
+ end
+
+ # Delete a directory and all of its content, return `true` on success
+ #
+ # Does not go through symbolic links and may get stuck in a cycle if there
+ # is a cycle in the file system.
+ fun rmdir: Bool
+ do
+ var ok = true
+ for file in self.files do
+ var stat = file.link_stat
+ if stat.is_dir then
+ ok = file.rmdir and ok
+ else
+ ok = file.delete and ok
+ end
+ end
+
+ # Delete the directory itself
+ if ok then path.to_cstring.rmdir
+
+ return ok
+ end
+
+ redef fun ==(other) do return other isa Path and path.simplify_path == other.path.simplify_path
+ redef fun hash do return path.simplify_path.hash
+end
+
+# Information on a file
+#
+# Created by `Path::stat` and `Path::link_stat`.
+#
+# The information within this class is gathered when the instance is initialized
+# it will not be updated if the targeted file is modified.
+class FileStat
+ super Finalizable
+
+ # TODO private init
+
+ # The low-level status of a file
+ #
+ # See: POSIX stat(2)
+ private var stat: NativeFileStat
+
+ private var finalized = false
+
+ redef fun finalize
+ do
+ if not finalized then
+ stat.free
+ finalized = true
+ end
+ end
+
+ # Returns the last access time in seconds since Epoch
+ fun last_access_time: Int
+ do
+ assert not finalized
+ return stat.atime
+ end
+
+ # Returns the last modification time in seconds since Epoch
+ fun last_modification_time: Int
+ do
+ assert not finalized
+ return stat.mtime
+ end
+
+ # Size of the file at `path`
+ fun size: Int
+ do
+ assert not finalized
+ return stat.size
+ end
+
+ # Is this a regular file and not a device file, pipe, socket, etc.?
+ fun is_file: Bool
+ do
+ assert not finalized
+ return stat.is_reg
+ end
+
+ # Is this a directory?
+ fun is_dir: Bool
+ do
+ assert not finalized
+ return stat.is_dir
+ end
+
+ # Is this a symbolic link?
+ fun is_link: Bool
+ do
+ assert not finalized
+ return stat.is_lnk
+ end
+
+ # FIXME Make the following POSIX only? or implement in some other way on Windows
+
+ # Returns the last status change time in seconds since Epoch
+ fun last_status_change_time: Int
+ do
+ assert not finalized
+ return stat.ctime
+ end
+
+ # Returns the permission bits of file
+ fun mode: Int
+ do
+ assert not finalized
+ return stat.mode
+ end
+
+ # Is this a character device?
+ fun is_chr: Bool
+ do
+ assert not finalized
+ return stat.is_chr
+ end
+
+ # Is this a block device?
+ fun is_blk: Bool
+ do
+ assert not finalized
+ return stat.is_blk
+ end
+
+ # Is this a FIFO pipe?
+ fun is_fifo: Bool
+ do
+ assert not finalized
+ return stat.is_fifo
+ end
+
+ # Is this a UNIX socket
+ fun is_sock: Bool
+ do
+ assert not finalized
+ return stat.is_sock
+ end
+end
+
+redef class Text
+ # Access file system related services on the path at `self`
+ fun to_path: Path do return new Path(to_s)
+end
+
+redef class String
+ # return true if a file with this names exists
+ fun file_exists: Bool do return to_cstring.file_exists
+
+ # The status of a file. see POSIX stat(2).
+ fun file_stat: NativeFileStat do return to_cstring.file_stat
+
+ # The status of a file or of a symlink. see POSIX lstat(2).
+ fun file_lstat: NativeFileStat do return to_cstring.file_lstat
+
+ # Remove a file, return true if success
+ fun file_delete: Bool do return to_cstring.file_delete
+
+ # Copy content of file at `self` to `dest`
+ fun file_copy_to(dest: String) do to_path.copy(dest.to_path)
+
# Remove the trailing extension `ext`.
#
# `ext` usually starts with a dot but could be anything.
# trainling "/" is removed
#
# Note that the method only wonrk on the string:
+ #
# * no I/O access is performed
# * the validity of the path is not checked
#
- # assert "some/./complex/../../path/from/../to/a////file//".simplify_path == "path/to/a/file"
- # assert "../dir/file".simplify_path == "../dir/file"
- # assert "dir/../../".simplify_path == ".."
- # assert "dir/..".simplify_path == "."
- # assert "//absolute//path/".simplify_path == "/absolute/path"
- # assert "//absolute//../".simplify_path == "/"
+ # ~~~
+ # assert "some/./complex/../../path/from/../to/a////file//".simplify_path == "path/to/a/file"
+ # assert "../dir/file".simplify_path == "../dir/file"
+ # assert "dir/../../".simplify_path == ".."
+ # assert "dir/..".simplify_path == "."
+ # assert "//absolute//path/".simplify_path == "/absolute/path"
+ # assert "//absolute//../".simplify_path == "/"
+ # ~~~
fun simplify_path: String
do
var a = self.split_with("/")
#
# Does not go through symbolic links and may get stuck in a cycle if there
# is a cycle in the filesystem.
- fun rmdir: Bool
- do
- var ok = true
- for file in self.files do
- var file_path = self.join_path(file)
- var stat = file_path.file_lstat
- if stat.is_dir then
- ok = file_path.rmdir and ok
- else
- ok = file_path.file_delete and ok
- end
- stat.free
- end
-
- # Delete the directory itself
- if ok then to_cstring.rmdir
-
- return ok
- end
+ fun rmdir: Bool do return to_path.rmdir
# Change the current working directory
#
redef class NativeString
private fun file_exists: Bool is extern "string_NativeString_NativeString_file_exists_0"
- private fun file_stat: FileStat is extern "string_NativeString_NativeString_file_stat_0"
- private fun file_lstat: FileStat `{
+ private fun file_stat: NativeFileStat is extern "string_NativeString_NativeString_file_stat_0"
+ private fun file_lstat: NativeFileStat `{
struct stat* stat_element;
int res;
stat_element = malloc(sizeof(struct stat));
end
# This class is system dependent ... must reify the vfs
-extern class FileStat `{ struct stat * `}
+extern class NativeFileStat `{ struct stat * `}
# Returns the permission bits of file
fun mode: Int is extern "file_FileStat_FileStat_mode_0"
# Returns the last access time
fun atime: Int is extern "file_FileStat_FileStat_atime_0"
- # Returns the last status change time
+ # Returns the last status change time
fun ctime: Int is extern "file_FileStat_FileStat_ctime_0"
# Returns the last modification time
fun mtime: Int is extern "file_FileStat_FileStat_mtime_0"
fun io_read(buf: NativeString, len: Int): Int is extern "file_NativeFile_NativeFile_io_read_2"
fun io_write(buf: NativeString, len: Int): Int is extern "file_NativeFile_NativeFile_io_write_2"
fun io_close: Int is extern "file_NativeFile_NativeFile_io_close_0"
- fun file_stat: FileStat is extern "file_NativeFile_NativeFile_file_stat_0"
+ fun file_stat: NativeFileStat is extern "file_NativeFile_NativeFile_file_stat_0"
fun fileno: Int `{ return fileno(recv); `}
+ # Flushes the buffer, forcing the write operation
+ fun flush: Int is extern "fflush"
+ # Used to specify how the buffering will be handled for the current stream.
+ fun set_buffering_type(buf_length: Int, mode: Int): Int is extern "file_NativeFile_NativeFile_set_buffering_type_0"
new io_open_read(path: NativeString) is extern "file_NativeFileCapable_NativeFileCapable_io_open_read_1"
new io_open_write(path: NativeString) is extern "file_NativeFileCapable_NativeFileCapable_io_open_write_1"
redef class Sys
+ init do
+ if stdout isa FStream then stdout.as(FStream).set_buffering_mode(256, buffer_mode_line)
+ end
+
# Standard input
var stdin: PollableIStream = new Stdin is protected writable
# Standard output for errors
var stderr: OStream = new Stderr is protected writable
+ # Enumeration for buffer mode full (flushes when buffer is full)
+ fun buffer_mode_full: Int is extern "file_Sys_Sys_buffer_mode_full_0"
+ # Enumeration for buffer mode line (flushes when a `\n` is encountered)
+ fun buffer_mode_line: Int is extern "file_Sys_Sys_buffer_mode_line_0"
+ # Enumeration for buffer mode none (flushes ASAP when something is written)
+ fun buffer_mode_none: Int is extern "file_Sys_Sys_buffer_mode_none_0"
+
+ # returns first available stream to read or write to
+ # return null on interruption (possibly a signal)
+ protected fun poll( streams : Sequence[FStream] ) : nullable FStream
+ do
+ var in_fds = new Array[Int]
+ var out_fds = new Array[Int]
+ var fd_to_stream = new HashMap[Int,FStream]
+ for s in streams do
+ var fd = s.fd
+ if s isa IFStream then in_fds.add( fd )
+ if s isa OFStream then out_fds.add( fd )
+
+ fd_to_stream[fd] = s
+ end
+
+ var polled_fd = intern_poll( in_fds, out_fds )
+
+ if polled_fd == null then
+ return null
+ else
+ return fd_to_stream[polled_fd]
+ end
+ end
+
+ private fun intern_poll(in_fds: Array[Int], out_fds: Array[Int]) : nullable Int is extern import Array[Int].length, Array[Int].[], Int.as(nullable Int) `{
+ int in_len, out_len, total_len;
+ struct pollfd *c_fds;
+ sigset_t sigmask;
+ int i;
+ int first_polled_fd = -1;
+ int result;
+
+ in_len = Array_of_Int_length( in_fds );
+ out_len = Array_of_Int_length( out_fds );
+ total_len = in_len + out_len;
+ c_fds = malloc( sizeof(struct pollfd) * total_len );
+
+ /* input streams */
+ for ( i=0; i<in_len; i ++ ) {
+ int fd;
+ fd = Array_of_Int__index( in_fds, i );
+
+ c_fds[i].fd = fd;
+ c_fds[i].events = POLLIN;
+ }
+
+ /* output streams */
+ for ( i=0; i<out_len; i ++ ) {
+ int fd;
+ fd = Array_of_Int__index( out_fds, i );
+
+ c_fds[i].fd = fd;
+ c_fds[i].events = POLLOUT;
+ }
+
+ /* poll all fds, unlimited timeout */
+ result = poll( c_fds, total_len, -1 );
+
+ if ( result > 0 ) {
+ /* analyse results */
+ for ( i=0; i<total_len; i++ )
+ if ( c_fds[i].revents & c_fds[i].events || /* awaited event */
+ c_fds[i].revents & POLLHUP ) /* closed */
+ {
+ first_polled_fd = c_fds[i].fd;
+ break;
+ }
+
+ return Int_as_nullable( first_polled_fd );
+ }
+ else if ( result < 0 )
+ fprintf( stderr, "Error in Stream:poll: %s\n", strerror( errno ) );
+
+ return null_Int();
+ `}
+
end
# Print `objects` on the standard output (`stdout`).
# assert "\na\nb\tc\t".trim == "a\nb\tc"
fun trim: SELFTYPE do return (self.l_trim).r_trim
- # Returns `self` removed from its last `\n` (if any).
+ # Returns `self` removed from its last line terminator (if any).
#
# assert "Hello\n".chomp == "Hello"
# assert "Hello".chomp == "Hello"
- # assert "\n\n\n".chomp == "\n\n"
#
- # This method is mainly used to remove the LINE_FEED character from lines of text.
+ # assert "\n".chomp == ""
+ # assert "".chomp == ""
+ #
+ # Line terminators are `"\n"`, `"\r\n"` and `"\r"`.
+ # A single line terminator, the last one, is removed.
+ #
+ # assert "\r\n".chomp == ""
+ # assert "\r\n\n".chomp == "\r\n"
+ # assert "\r\n\r\n".chomp == "\r\n"
+ # assert "\r\n\r".chomp == "\r\n"
+ #
+ # Note: unlike with most IO methods like `IStream::read_line`,
+ # a single `\r` is considered here to be a line terminator and will be removed.
fun chomp: SELFTYPE
do
- if self.chars.last != '\n' then return self
- return substring(0, length-1)
+ var len = length
+ if len == 0 then return self
+ var l = self.chars.last
+ if l == '\r' then
+ return substring(0, len-1)
+ else if l != '\n' then
+ return self
+ else if len > 1 and self.chars[len-2] == '\r' then
+ return substring(0, len-2)
+ else
+ return substring(0, len-1)
+ end
end
# Justify a self in a space of `length`
# * 1.0 for right-justified (all spaces at the left)
# * 0.5 for centered (half the spaces at the left)
#
+ # Examples
+ #
# assert "hello".justify(10, 0.0) == "hello "
# assert "hello".justify(10, 1.0) == " hello"
# assert "hello".justify(10, 0.5) == " hello "
#
# assert "hello".justify(2, 0.0) == "hello"
#
- # REQUIRE: left >= 0.0 and left <= 1.0
+ # REQUIRE: `left >= 0.0 and left <= 1.0`
# ENSURE: `self.length <= length implies result.length == length`
- # ENSURE: `self.length >= length implies result == self
+ # ENSURE: `self.length >= length implies result == self`
fun justify(length: Int, left: Float): SELFTYPE
do
var diff = length - self.length
#
# SEE : `Char::is_letter` for the definition of letter.
#
- # assert "jAVASCRIPT".capitalized == "Javascript"
- # assert "i am root".capitalized == "I Am Root"
- # assert "ab_c -ab0c ab\nc".capitalized == "Ab_C -Ab0C Ab\nC"
+ # assert "jAVASCRIPT".capitalized == "Javascript"
+ # assert "i am root".capitalized == "I Am Root"
+ # assert "ab_c -ab0c ab\nc".capitalized == "Ab_C -Ab0C Ab\nC"
fun capitalized: SELFTYPE do
if length == 0 then return self
#
# SEE: `Char::is_letter` for the definition of a letter.
#
- # var b = new FlatBuffer.from("jAVAsCriPt")
- # b.capitalize
- # assert b == "Javascript"
- # b = new FlatBuffer.from("i am root")
- # b.capitalize
- # assert b == "I Am Root"
- # b = new FlatBuffer.from("ab_c -ab0c ab\nc")
- # b.capitalize
- # assert b == "Ab_C -Ab0C Ab\nC"
+ # var b = new FlatBuffer.from("jAVAsCriPt")
+ # b.capitalize
+ # assert b == "Javascript"
+ # b = new FlatBuffer.from("i am root")
+ # b.capitalize
+ # assert b == "I Am Root"
+ # b = new FlatBuffer.from("ab_c -ab0c ab\nc")
+ # b.capitalize
+ # assert b == "Ab_C -Ab0C Ab\nC"
fun capitalize do
if length == 0 then return
var c = self[0].to_upper
# The class name of the object.
#
- # assert 5.class_name == "Int"
+ # assert 5.class_name == "Int"
fun class_name: String do return native_class_name.to_s
# Developer readable representation of `self`.
# Returns true if the char is a numerical digit
#
- # assert '0'.is_numeric
- # assert '9'.is_numeric
- # assert not 'a'.is_numeric
- # assert not '?'.is_numeric
+ # assert '0'.is_numeric
+ # assert '9'.is_numeric
+ # assert not 'a'.is_numeric
+ # assert not '?'.is_numeric
fun is_numeric: Bool
do
return self >= '0' and self <= '9'
# Returns true if the char is an alpha digit
#
- # assert 'a'.is_alpha
- # assert 'Z'.is_alpha
- # assert not '0'.is_alpha
- # assert not '?'.is_alpha
+ # assert 'a'.is_alpha
+ # assert 'Z'.is_alpha
+ # assert not '0'.is_alpha
+ # assert not '?'.is_alpha
fun is_alpha: Bool
do
return (self >= 'a' and self <= 'z') or (self >= 'A' and self <= 'Z')
# Returns true if the char is an alpha or a numeric digit
#
- # assert 'a'.is_alphanumeric
- # assert 'Z'.is_alphanumeric
- # assert '0'.is_alphanumeric
- # assert '9'.is_alphanumeric
- # assert not '?'.is_alphanumeric
+ # assert 'a'.is_alphanumeric
+ # assert 'Z'.is_alphanumeric
+ # assert '0'.is_alphanumeric
+ # assert '9'.is_alphanumeric
+ # assert not '?'.is_alphanumeric
fun is_alphanumeric: Bool
do
return self.is_numeric or self.is_alpha
nitlanguage / nit.git / commitdiff