redef fun accept_pretty_printer(v) do
v.visit n_atid
if not n_args.is_empty then
- v.visit n_opar
+ if n_opar == null then
+ v.adds
+ else
+ v.visit n_opar
+ end
v.visit_list n_args
v.visit n_cpar
end
super
v.visit n_kwvar
v.adds
- if n_id != null then v.visit n_id
- if n_id2 != null then v.visit n_id2
+ v.visit n_id2
if n_type != null then
v.consume ":"
v.visit n_type
end
- if n_readable != null then
- v.adds
- v.visit n_readable
- end
-
- if n_writable != null then
- v.adds
- v.visit n_writable
- end
-
if n_expr != null then
v.adds
v.consume "="
redef class AMethPropdef
redef fun accept_pretty_printer(v) do
+ # TODO: Handle extern annotations
+
+ var before = v.indent
+ var can_inline = v.can_inline(self)
super
if n_kwinit != null then v.visit n_kwinit
if n_kwmeth != null then v.visit n_kwmeth
else
v.adds
end
- end
- # Can be inlined if:
- # * block is empty or can be inlined
- # * contains no comments
- redef fun is_inlinable do
- if not super then return false
- if n_annotations != null and not n_annotations.is_inlinable then return false
- if n_block != null and not n_block.is_inlinable then return false
- if not collect_comments.is_empty then return false
- return true
- end
-end
-
-redef class AMainMethPropdef
- redef fun accept_pretty_printer(v) do
- v.visit n_block
- v.addn
- end
-end
-
-redef class ADeferredMethPropdef
- redef fun accept_pretty_printer(v) do
- super
- if n_annotations == null then
- while not v.current_token isa TKwis do v.skip
- v.consume "is"
- v.adds
- while not v.current_token isa TKwabstract do v.skip
- v.consume "abstract"
- end
- v.finish_line
- v.addn
- end
-end
-
-redef class AExternPropdef
- redef fun accept_pretty_printer(v) do
- super
- while v.current_token isa TEol do v.skip
-
- if v.current_token isa TKwis then
- v.consume "is"
- v.adds
- end
-
- if v.current_token isa TKwextern then
- v.consume "extern"
- v.adds
+ if n_extern_calls != null or n_extern_code_block != null then
+ if n_annotations != null then v.adds
+ if n_extern_calls != null then v.visit n_extern_calls
+ if n_extern_code_block != null then v.visit n_extern_code_block
end
- if n_extern != null then v.visit n_extern
- if n_extern_calls != null then v.visit n_extern_calls
- if n_extern_code_block != null then v.visit n_extern_code_block
- v.finish_line
- v.addn
- end
-
- redef fun is_inlinable do
- if not super then return false
- if n_block != null and not n_block.is_inlinable then return false
- if n_extern_calls != null and not n_extern_calls.is_inlinable then return false
- if n_extern_code_block != null and not n_extern_code_block.is_inlinable then return false
- return true
- end
-
- redef fun must_be_inline do
- if super then return true
- return n_extern != null
- end
-end
-
-redef class AInternMethPropdef
- redef fun accept_pretty_printer(v) do
- super
- v.consume "is"
- v.adds
- v.consume "intern"
- v.finish_line
- v.addn
- end
-end
-
-redef class AConcreteMethPropdef
- redef fun accept_pretty_printer(v) do
- var before = v.indent
- var can_inline = v.can_inline(self)
- super
var n_block = self.n_block
if n_block != null then
v.addn
assert v.indent == before
end
+
+ # Can be inlined if:
+ # * block is empty or can be inlined
+ # * contains no comments
+ redef fun is_inlinable do
+ if not super then return false
+ if n_annotations != null and not n_annotations.is_inlinable then return false
+ if n_block != null and not n_block.is_inlinable then return false
+ if n_extern_calls != null and not n_extern_calls.is_inlinable then return false
+ if n_extern_code_block != null and not n_extern_code_block.is_inlinable then return false
+ if not collect_comments.is_empty then return false
+ return true
+ end
+end
+
+redef class AMainMethPropdef
+ redef fun accept_pretty_printer(v) do
+ v.visit n_block
+ v.addn
+ end
end
redef class ASignature
end
end
-redef class AAble
- redef fun accept_pretty_printer(v) do
- if n_kwredef != null then
- v.visit n_kwredef
- v.adds
- end
-
- if not n_visibility isa APublicVisibility then
- v.visit n_visibility
- v.adds
- end
- end
-end
-
-redef class AReadAble
- redef fun accept_pretty_printer(v) do
- super
- v.visit n_kwreadable
- end
-end
-
-redef class AWriteAble
- redef fun accept_pretty_printer(v) do
- super
- v.visit n_kwwritable
- end
-end
-
# Exprs
redef class AVardeclExpr
--- /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 end
+intrude import standard::kernel
+private import standard::string
+
+`{`}
+
+`{
+#ifdef truc
+ #undef truc
+#endif
+`}
+
+in "C headers" `{
+ #include <errno.h>
+`}
+
+fun err: Int is extern `{ return 1; `}
+
+fun errno: Int is extern `{
+ return errno;
+`}
+
+fun errnoooooooooooooooooooooooooooooooooooooooooooooooooooooooooo: Int is extern `{
+ return errno;
+`}
+
+private class A
+ var my_attr = 1234
+
+ fun baz(msg: String) import String.length, String.to_cstring, my_attr, my_attr= `{
+ char *c_msg;
+ int msg_len;
+
+ /* String_to_cstring isa a allback to msg.to_cstring */
+ c_msg = String_to_cstring( msg );
+
+ /* String_length is a callback to msg.length */
+ msg_len = String_length( msg );
+
+ printf( "received msg: %s, of length = %d\n", c_msg, msg_len );
+
+ /* A_my_attr is a callback to the getter of self.my_attr */
+ printf( "old attr %d\n", A_my_attr(recv) );
+
+ if(chose)
+ truc;
+ else
+ chose;
+
+ /* A_my_attr is a callback to the setter of self.my_attr= */
+ A_my_attr__assign( recv, msg_len );
+ `}
+end
+
+extern class TimeT `{time_t`}
+ new `{ return time(NULL); `}
+ new from_i(i: Int) `{ return i; `}
+ fun update `{ time(&recv); `}
+
+ fun ctime: String import NativeString.to_s_with_copy `{
+ return NativeString_to_s_with_copy( ctime(&recv) );
+ `}
+
+ # Difference in secondes from start (self if the end time)
+ fun difftime(start: TimeT): Float `{ return difftime(recv, start); `}
+
+ private fun intern_poll(in_fds: Array[Int], out_fds: Array[Int]): nullable Int is import
+ Array[Int].length, Array[Int].[], Int.as(nullable Int) `{`}
+end
+
+fun address_is_null: Bool is extern "address_is_null"
+
+fun free `{ free(recv); `}