This PR is a first step in trying to handle exceptions in Nit, replacing the behaviour of `abort` if it happens within a do ... catch ... end.
In the compiler, setjmp() et longjmp() are used to jump directly from the `abort` to the nearest `catch` bloc.
Pull-Request: #2011
Reviewed-by: Jean Privat <jean@pryen.org>
Reviewed-by: Alexis Laferrière <alexis.laf@xymus.net>
do
var stmt = select("ROWID, name, desc FROM beers WHERE ROWID = {id}")
if stmt == null then return null
- for row in stmt do return row.to_beer
- return null
+
+ var res = null
+ for row in stmt do
+ res = row.to_beer
+ break
+ end
+ return res
end
# Days where `beer` was available, all known days if `beer == null`
var user_id = row[0].to_i
var token = new_token(user_id)
var u = new User(user_id, row[1].to_s)
+ stmt.close
return new LoginResult(u, token)
end
return null
# TODO update token timestamp and platform/client hint of last connection.
# These informations could help detect malicious access to the account.
- for row in stmt do return row[0].to_i
- return null
+ var res = null
+ for row in stmt do
+ res = row[0].to_i
+ break
+ end
+ return res
end
# Get `User` data from the integer `id`
var stmt = select("name FROM users WHERE ROWID = {id}")
assert stmt != null
- for row in stmt do return new User(id, row[0].to_s)
- return null
+ var res = null
+ for row in stmt do
+ res = new User(id, row[0].to_s)
+ break
+ end
+ return res
end
# Try to sign up a new user, return `true` on success
var b = beer_from_id(beer)
if b == null then return null
- for row in stmt do return new BeerStats(b, row[0].to_f, row[1].to_i)
- return null
+ var res = null
+ for row in stmt do
+ res = new BeerStats(b, row[0].to_f, row[1].to_i)
+ break
+ end
+ return res
end
# Fetch the most recent rating left by `user_id` about `beer`
do
var stmt = select("rating FROM reviews WHERE author = {user_id} AND beer = {beer} ORDER BY ROWID DESC LIMIT 1")
assert stmt != null else print_error "Select 'rating' failed with: {error or else "?"}"
- for row in stmt do return row[0].to_i
- return null
+
+ var res = null
+ for row in stmt do
+ res = row[0].to_i
+ break
+ end
+ return res
end
# Register that `user_from` follows `user_to`
assert stmt != null else
print_error "Select 'follows' failed with: {error or else "?"}"
end
- for row in stmt do return true
+
+ for row in stmt.iterator.to_a do return true
return false
end
# List reciprocal friends of `user_id`
fun followed_followers(user_id: Int): nullable Array[User]
do
- var stmt = select("ROWID, name FROM users WHERE " +
- "ROWID in (SELECT user_from FROM follows WHERE user_to = {user_id}) AND " +
- "ROWID in (SELECT user_to FROM follows WHERE user_from = {user_id})")
+ var stmt = select("""
+ROWID, name FROM users WHERE
+ users.ROWID in (SELECT user_from FROM follows WHERE user_to = {{{user_id}}}) AND
+ users.ROWID in (SELECT user_to FROM follows WHERE user_from = {{{user_id}}})""")
assert stmt != null else print_error "Select 'followed_followers' failed with: {error or else "?"}"
var users = new Array[User]
var sql = """
ROWID, name FROM users
WHERE 1 in (SELECT is_in FROM checkins WHERE user = users.ROWID ORDER BY ROWID DESC LIMIT 1)
- AND ROWID in (SELECT user_from FROM follows WHERE user_to = {user_id})
- AND ROWID in (SELECT user_to FROM follows WHERE user_from = {user_id})"""
+ AND ROWID in (SELECT user_from FROM follows WHERE user_to = {{{user_id}}})
+ AND ROWID in (SELECT user_to FROM follows WHERE user_from = {{{user_id}}})"""
var stmt = select(sql)
if stmt == null then
# Update the screen to show the new `posts`
fun apply_update(posts: Array[Post])
do
- layout.remove list_posts
- list_posts = new ListLayout(parent=layout)
+ list_posts.clear
for post in posts do
var line = new VerticalLayout(parent=list_posts)
var author = new LabelAuthor(parent=line, text="@"+post.user)
# Is `item` in `self`?
fun has(item: Control): Bool do return items.has(item)
+ # Remove all items from `self`
+ fun clear do for item in items.to_a do remove item
+
redef fun on_create do for i in items do i.on_create
redef fun on_start do for i in items do i.on_start
return slice(from, length)
end
- # Returns self as a hexadecimal digest
+ # Returns self as an hexadecimal digest.
+ #
+ # Also known as plain hexdump or postscript hexdump.
+ #
+ # ~~~
+ # var b = "abcd".to_bytes
+ # assert b.hexdigest == "61626364"
+ # assert b.hexdigest.hexdigest_to_bytes == b
+ # ~~~
fun hexdigest: String do
var elen = length * 2
var ns = new NativeString(elen)
return new FlatString.full(ns, elen, 0, elen)
end
+ # Return self as a C hexadecimal digest where bytes are prefixed by `\x`
+ #
+ # The output is compatible with literal stream of bytes for most languages
+ # including C and Nit.
+ #
+ # ~~~
+ # var b = "abcd".to_bytes
+ # assert b.chexdigest == "\\x61\\x62\\x63\\x64"
+ # assert b.chexdigest.unescape_to_bytes == b
+ # ~~~
+ fun chexdigest: String do
+ var elen = length * 4
+ var ns = new NativeString(elen)
+ var i = 0
+ var oi = 0
+ while i < length do
+ ns[oi] = 0x5Cu8 # b'\\'
+ ns[oi+1] = 0x78u8 # b'x'
+ self[i].add_digest_at(ns, oi+2)
+ i += 1
+ oi += 4
+ end
+ return new FlatString.full(ns, elen, 0, elen)
+ end
+
+
+ # Returns self as a stream of bits (0 and 1)
+ #
+ # ~~~
+ # var b = "abcd".to_bytes
+ # assert b.binarydigest == "01100001011000100110001101100100"
+ # assert b.binarydigest.binarydigest_to_bytes == b
+ # ~~~
+ fun binarydigest: String do
+ var elen = length * 8
+ var ns = new NativeString(elen)
+ var i = 0
+ var oi = 0
+ while i < length do
+ var c = self[i]
+ var b = 128u8
+ while b > 0u8 do
+ if c & b == 0u8 then
+ ns[oi] = 0x30u8 # b'0'
+ else
+ ns[oi] = 0x31u8 # b'1'
+ end
+ oi += 1
+ b = b >> 1
+ end
+ i += 1
+ end
+ return new FlatString.full(ns, elen, 0, elen)
+ end
+
# var b = new Bytes.with_capacity(1)
# b[0] = 101u8
# assert b.to_s == "e"
# Returns a new `Bytes` instance with the digest as content
#
# assert "0B1F4D".hexdigest_to_bytes == [0x0Bu8, 0x1Fu8, 0x4Du8]
+ # assert "0B1F4D".hexdigest_to_bytes.hexdigest == "0B1F4D"
+ #
+ # Characters that are not hexadecimal digits are ignored.
+ #
+ # assert "z0B1 F4\nD".hexdigest_to_bytes.hexdigest == "0B1F4D"
+ # assert "\\x0b1 \\xf4d".hexdigest_to_bytes.hexdigest == "0B1F4D"
+ #
+ # When the number of hexadecimal digit is not even, then a leading 0 is
+ # implicitly considered to fill the left byte (the most significant one).
#
- # REQUIRE: `self` is a valid hexdigest and hexdigest.length % 2 == 0
+ # assert "1".hexdigest_to_bytes.hexdigest == "01"
+ # assert "FFF".hexdigest_to_bytes.hexdigest == "0FFF"
+ #
+ # `Bytes::hexdigest` is a loosely reverse method since its
+ # results contain only pairs of uppercase hexadecimal digits.
+ #
+ # assert "ABCD".hexdigest_to_bytes.hexdigest == "ABCD"
+ # assert "a b c".hexdigest_to_bytes.hexdigest == "0ABC"
fun hexdigest_to_bytes: Bytes do
var b = bytes
- var pos = 0
var max = bytelen
- var ret = new Bytes.with_capacity(max / 2)
+
+ var dlength = 0 # Number of hex digits
+ var pos = 0
while pos < max do
- ret.add((b[pos].hexdigit_to_byteval << 4) |
- b[pos + 1].hexdigit_to_byteval)
- pos += 2
+ var c = b[pos]
+ if c.is_valid_hexdigit then dlength += 1
+ pos += 1
+ end
+
+ # Allocate the result buffer
+ var ret = new Bytes.with_capacity((dlength+1) / 2)
+
+ var i = (dlength+1) % 2 # current hex digit (1=high, 0=low)
+ var byte = 0u8 # current accumulated byte value
+
+ pos = 0
+ while pos < max do
+ var c = b[pos]
+ if c.is_valid_hexdigit then
+ byte = byte << 4 | c.hexdigit_to_byteval
+ i -= 1
+ if i < 0 then
+ # Last digit known: store and restart
+ ret.add byte
+ i = 1
+ byte = 0u8
+ end
+ end
+ pos += 1
end
return ret
end
# Return a `Bytes` instance where Nit escape sequences are transformed.
#
# assert "B\\n\\x41\\u0103D3".unescape_to_bytes.hexdigest == "420A41F0908F93"
+ #
+ # `Bytes::chexdigest` is a loosely reverse methods since its result is only made
+ # of `"\x??"` escape sequences.
+ #
+ # assert "\\x41\\x42\\x43".unescape_to_bytes.chexdigest == "\\x41\\x42\\x43"
+ # assert "B\\n\\x41\\u0103D3".unescape_to_bytes.chexdigest == "\\x42\\x0A\\x41\\xF0\\x90\\x8F\\x93"
fun unescape_to_bytes: Bytes do
var res = new Bytes.with_capacity(self.bytelen)
var was_slash = false
end
return res
end
+
+ # Return a `Bytes` by reading 0 and 1.
+ #
+ # assert "1010101100001101".binarydigest_to_bytes.hexdigest == "AB0D"
+ #
+ # Note that characters that are neither 0 or 1 are just ignored.
+ #
+ # assert "a1B01 010\n1100あ001101".binarydigest_to_bytes.hexdigest == "AB0D"
+ # assert "hello".binarydigest_to_bytes.is_empty
+ #
+ # When the number of bits is not divisible by 8, then leading 0 are
+ # implicitly considered to fill the left byte (the most significant one).
+ #
+ # assert "1".binarydigest_to_bytes.hexdigest == "01"
+ # assert "1111111".binarydigest_to_bytes.hexdigest == "7F"
+ # assert "1000110100".binarydigest_to_bytes.hexdigest == "0234"
+ #
+ # `Bytes::binarydigest` is a loosely reverse method since its
+ # results contain only 1 and 0 by blocks of 8.
+ #
+ # assert "1010101100001101".binarydigest_to_bytes.binarydigest == "1010101100001101"
+ # assert "1".binarydigest_to_bytes.binarydigest == "00000001"
+ fun binarydigest_to_bytes: Bytes
+ do
+ var b = bytes
+ var max = bytelen
+
+ # Count bits
+ var bitlen = 0
+ var pos = 0
+ while pos < max do
+ var c = b[pos]
+ pos += 1
+ if c == 0x30u8 or c == 0x31u8 then bitlen += 1 # b'0' or b'1'
+ end
+
+ # Allocate (and take care of the padding)
+ var ret = new Bytes.with_capacity((bitlen+7) / 8)
+
+ var i = (bitlen+7) % 8 # current bit (7th=128, 0th=1)
+ var byte = 0u8 # current accumulated byte value
+
+ pos = 0
+ while pos < max do
+ var c = b[pos]
+ pos += 1
+ if c == 0x30u8 then # b'0'
+ byte = byte << 1
+ else if c == 0x31u8 then # b'1'
+ byte = byte << 1 | 1u8
+ else
+ continue
+ end
+
+ i -= 1
+ if i < 0 then
+ # Last bit known: store and restart
+ ret.add byte
+ i = 7
+ byte = 0u8
+ end
+ end
+ return ret
+ end
end
redef class FlatText
res.add(item)
next
end
+ finish
return res
end
end
# A single row of a `GtkListBox`
extern class GtkListBoxRow `{ GtkListBoxRow* `}
- super GtkWidget
+ super GtkBin
new `{ return (GtkListBoxRow*)gtk_list_box_row_new(); `}
# Container inside `native`
var native_list_box = new GtkListBox
+ # `GtkListBoxRow` used to contains children `View`s
+ var native_rows = new Map[View, GtkListBoxRow]
+
init do
native_list_box.selection_mode = new GtkSelectionMode.none
native.add native_list_box
redef fun add(item)
do
super
- if item isa View then native_list_box.add item.native
+ if item isa View then
+ var native_row = new GtkListBoxRow
+ #native_row.activable = false # TODO with GTK 3.14
+ #native_row.selectable = false
+ native_row.add item.native
+
+ native_rows[item] = native_row
+ native_list_box.add native_row
+ native_row.show
+ end
end
redef fun remove(item)
do
super
- if item isa View then native_list_box.remove item.native
+ if item isa View then
+ var native_row = native_rows.get_or_null(item)
+ if native_row == null then
+ print_error "Error: {self} does not contains {item}"
+ return
+ end
+
+ native_list_box.remove native_row
+ native_rows.keys.remove item
+ native_row.destroy
+ end
end
end
# Close this connection to the DB and all open statements
fun close
do
+ if not is_open then return
+
is_open = false
# close open statements
fun last_insert_rowid: Int do return native_connection.last_insert_rowid
end
-# A prepared Sqlite3 statement, created from `Sqlite3DB::prepare` or `Sqlite3DB::select`
+# Prepared Sqlite3 statement
+#
+# Instances of this class are created from `Sqlite3DB::prepare` and
+# its shortcuts: `create_table`, `insert`, `replace` and `select`.
+# The results should be explored with an `iterator`,
+# and each call to `iterator` resets the request.
+# If `close_with_iterator` the iterator calls `close`
+# on this request upon finishing.
class Statement
private var native_statement: NativeStatement
# Is this statement usable?
var is_open = true
+ # Should any `iterator` close this statement on `Iterator::finish`?
+ #
+ # If `true`, the default, any `StatementIterator` created by calls to
+ # `iterator` invokes `close` on this request when finished iterating.
+ # Otherwise, `close` must be called manually.
+ var close_with_iterator = true is writable
+
# Close and finalize this statement
fun close
do
+ if not is_open then return
+
is_open = false
native_statement.finalize
end
is_ok = false
end
end
+
+ redef fun finish do if statement.close_with_iterator then statement.close
end
# A data type supported by Sqlite3
curr_instances[i] = currFra.map[i]
end
end
- if v.returnmark == f then
- v.returnmark = null
+ if v.is_escape(self.return_mark) then
var res = v.escapevalue
- v.escapevalue = null
return res
end
return null
return self.modelbuilder.force_get_primitive_method(current_node, name, recv.mclass, self.mainmodule)
end
- # Is a return executed?
- # Set this mark to skip the evaluation until the end of the specified method frame
- var returnmark: nullable FRAME = null
-
- # Is a break or a continue executed?
+ # Is a return, a break or a continue executed?
# Set this mark to skip the evaluation until a labeled statement catch it with `is_escape`
var escapemark: nullable EscapeMark = null
# Is a return or a break or a continue executed?
# Use this function to know if you must skip the evaluation of statements
- fun is_escaping: Bool do return returnmark != null or escapemark != null
+ fun is_escaping: Bool do return escapemark != null
# The value associated with the current return/break/continue, if any.
# Set the value when you set a escapemark.
var f = v.new_frame(self, mpropdef, args)
var res = call_commons(v, mpropdef, args, f)
v.frames.shift
- if v.returnmark == f then
- v.returnmark = null
+ if v.is_escape(self.return_mark) then
res = v.escapevalue
- v.escapevalue = null
return res
end
return res
val = v.expr(nexpr)
else if nblock != null then
v.stmt(nblock)
- assert v.returnmark == f
+ assert v.escapemark == return_mark
val = v.escapevalue
- v.returnmark = null
- v.escapevalue = null
+ v.escapemark = null
else
abort
end
end
end
-redef class AReturnExpr
- redef fun stmt(v)
- do
- var ne = self.n_expr
- if ne != null then
- var i = v.expr(ne)
- if i == null then return
- v.escapevalue = i
- end
- v.returnmark = v.frame
- end
-end
-
redef class AAbortExpr
redef fun stmt(v)
do
# A `return` statement. eg `return x`
class AReturnExpr
- super AExpr
+ super AEscapeExpr
# The `return` keyword
var n_kwreturn: nullable TKwreturn = null is writable
-
- # The return value, if any
- var n_expr: nullable AExpr = null is writable
end
# A `yield` statement. eg `yield x`
# The tool context used to display errors
var toolcontext: ToolContext
+ # The analysed property
+ var propdef: APropdef
+
var selfvariable = new Variable("self")
init
end
redef class APropdef
+ # The break escape mark associated with the return
+ var return_mark: nullable EscapeMark
+
# Entry point of the scope analysis
fun do_scope(toolcontext: ToolContext)
do
- var v = new ScopeVisitor(toolcontext)
+ var v = new ScopeVisitor(toolcontext, self)
v.enter_visit(self)
v.shift_scope
end
end
end
+redef class AReturnExpr
+ redef fun accept_scope_visitor(v)
+ do
+ super
+
+ var escapemark = v.propdef.return_mark
+ if escapemark == null then
+ escapemark = new EscapeMark
+ v.propdef.return_mark = escapemark
+ end
+
+ escapemark.escapes.add(self)
+ self.escapemark = escapemark
+ end
+end
redef class ADoExpr
# The break escape mark associated with the 'do' block
--- /dev/null
+# This file is part of NIT ( http://www.nitlanguage.org ).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import core::kernel
+
+class A
+ var a = 5
+ fun start do
+ var a = new A
+ 1.output
+ end
+ fun finish do
+ var a = new A
+ 3.output
+ end
+end
+
+fun foo
+do
+ with new A do
+ 2.output
+ return
+ end
+end
+
+foo
+4.output
--- /dev/null
+1
+2
+3
+4
-Runtime error: Cast failed. Expected `E`, got `Bool` (../lib/core/collection/array.nit:988)
+Runtime error: Cast failed. Expected `E`, got `Bool` (../lib/core/collection/array.nit:989)
NativeString
0x4e
Nit