TESTS = \
basic-types/gassert.vala \
basic-types/integer-literals.vala \
+ basic-types/integer-signed-binary-erange.test \
basic-types/integer-signed-erange.test \
+ basic-types/integer-signed-erange2.test \
+ basic-types/integer-signed-octal-erange.test \
+ basic-types/integer-unsigned-binary-erange.test \
basic-types/integer-unsigned-erange.test \
basic-types/integer-unsigned-invalid.test \
+ basic-types/integer-unsigned-octal-erange.test \
+ basic-types/integers-binary-invalid.test \
+ basic-types/integers-binary.vala \
basic-types/integers.vala \
basic-types/integers-boxed-cast.vala \
+ basic-types/integers-octal-invalid.test \
+ basic-types/integers-octal.vala \
basic-types/escape-chars.vala \
basic-types/float-literals.vala \
basic-types/floats.vala \
--- /dev/null
+Invalid Code
+
+void main () {
+ int64 foo = -0b1111111111111111111111111111111111111111111111111111111111111111;
+}
--- /dev/null
+Invalid Code
+
+void main () {
+ int64 foo = 9223372036854775808;
+}
--- /dev/null
+Invalid Code
+
+void main () {
+ int64 foo = 0o1000000000000000000000;
+}
--- /dev/null
+Invalid Code
+
+void main () {
+ var foo = 0b111111111111111111111111111111111111111111111111111111111111111111;
+}
--- /dev/null
+Invalid Code
+
+void main () {
+ var foo = 0o7777777777777777777777;
+}
--- /dev/null
+Invalid Code
+
+void main () {
+ var foo = 0b123;
+}
--- /dev/null
+/* basic_types_integers_binary.c generated by valac, the Vala compiler
+ * generated from basic_types_integers_binary.vala, do not modify */
+
+#include <glib.h>
+
+#define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
+#define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; }
+#define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; }
+#define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
+
+static void _vala_main (void);
+
+static void
+_vala_main (void)
+{
+ gint a = 0;
+ guint b = 0U;
+ gint c = 0;
+ guint64 d = 0ULL;
+ gint64 e = 0LL;
+ a = 9;
+ _vala_assert (a == 9, "a == 9");
+ b = 314U;
+ _vala_assert (b == ((guint) 314), "b == 314");
+ c = -666;
+ _vala_assert (c == -666, "c == -666");
+ d = 18446744073709551615ULL;
+ _vala_assert (d == 0xffffffffffffffffULL, "d == 0xffffffffffffffff");
+ e = 3740122863LL;
+ _vala_assert (e == 0xdeedbeefLL, "e == 0xdeedbeef");
+}
+
+int
+main (int argc,
+ char ** argv)
+{
+ _vala_main ();
+ return 0;
+}
+
--- /dev/null
+void main () {
+ var a = 0b1001;
+ assert (a == 9);
+
+ var b = 0b100111010u;
+ assert (b == 314);
+
+ var c = -0b1010011010;
+ assert (c == -666);
+
+ uint64 d = 0b1111111111111111111111111111111111111111111111111111111111111111;
+ assert (d == 0xffffffffffffffff);
+
+ int64 e = 0b11011110111011011011111011101111;
+ assert (e == 0xdeedbeef);
+}
--- /dev/null
+Invalid Code
+
+void main () {
+ var foo = 0o987;
+}
--- /dev/null
+/* basic_types_integers_octal.c generated by valac, the Vala compiler
+ * generated from basic_types_integers_octal.vala, do not modify */
+
+#include <glib.h>
+
+#define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
+#define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; }
+#define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; }
+#define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
+
+static void _vala_main (void);
+
+static void
+_vala_main (void)
+{
+ gint a = 0;
+ guint b = 0U;
+ gint c = 0;
+ guint64 d = 0ULL;
+ gint64 e = 0LL;
+ a = 0644;
+ _vala_assert (a == 420, "a == 420");
+ b = 0105264631U;
+ _vala_assert (b == 18180505U, "b == 18180505u");
+ c = -01322;
+ _vala_assert (c == -722, "c == -722");
+ d = 01777777777777777777777ULL;
+ _vala_assert (d == 0xffffffffffffffffULL, "d == 0xffffffffffffffff");
+ e = -033653337357LL;
+ _vala_assert (e == -0xdeadbeefLL, "e == -0xdeadbeef");
+}
+
+int
+main (int argc,
+ char ** argv)
+{
+ _vala_main ();
+ return 0;
+}
+
--- /dev/null
+void main () {
+ var a = 0o644;
+ assert (a == 420);
+
+ var b = 0o105264631u;
+ assert (b == 18180505u);
+
+ var c = -0o1322;
+ assert (c == -722);
+
+ var d = 0o1777777777777777777777ll;
+ assert (d == 0xffffffffffffffff);
+
+ var e = -0o33653337357;
+ assert (e == -0xdeadbeef);
+}
gint args_length1)
{
gint a = 0;
+ gint64 b = 0LL;
+ gint64 c = 0LL;
+ guint d = 0U;
+ gint e = 0;
a = 101;
_vala_assert (a == 101, "a == 101");
+ b = 0xdeadbeefLL;
+ _vala_assert (b == 3735928559LL, "b == 3735928559");
+ c = 2003LL;
+ _vala_assert (c == 2003LL, "c == 2003ll");
+ d = 01307U;
+ _vala_assert (d == 711U, "d == 711u");
+ e = -0110157032;
+ _vala_assert (e == (-18931226), "e == -18931226");
}
int
init
a:int = 101
assert( a == 101 )
+
+ b:int64 = 0xdeadbeef
+ assert( b == 3735928559 )
+
+ var c = 0b11111010011ll
+ assert( c == 2003ll )
+
+ var d = 0o1307u
+ assert( d == 711u )
+
+ var e = -0o110157032
+ assert( e == -18931226 )
current++;
}
type = TokenType.INTEGER_LITERAL;
- if (current < end && current[0].tolower () == 'l') {
- current++;
- if (current < end && current[0].tolower () == 'l') {
- current++;
- }
- } else if (current < end && current[0].tolower () == 'u') {
- current++;
- if (current < end && current[0].tolower () == 'l') {
- current++;
- if (current < end && current[0].tolower () == 'l') {
- current++;
- }
- }
- } else if (current < end - 1 && current[0] == '.' && current[1].isdigit ()) {
+ if (current < end - 1 && current[0] == '.' && current[1].isdigit ()) {
current++;
while (current < end && current[0].isdigit ()) {
current++;
current++;
}
}
- if (current < end && current[0].tolower () == 'f') {
+ type = TokenType.REAL_LITERAL;
+ } else if (current < end && current[0].tolower () == 'e') {
+ current++;
+ if (current < end && (current[0] == '+' || current[0] == '-')) {
+ current++;
+ }
+ while (current < end && current[0].isdigit ()) {
current++;
}
type = TokenType.REAL_LITERAL;
} else if (current < end && current == begin + 1
- && begin[0] == '0' && begin[1] == 'x' && begin[2].isxdigit ()) {
+ && begin[0] == '0'
+ && (begin[1] == 'x' || begin[1] == 'X')
+ && begin[2].isxdigit ()) {
// hexadecimal integer literal
current++;
while (current < end && current[0].isxdigit ()) {
current++;
}
- } else if (current < end && is_ident_char (current[0])) {
- // allow identifiers to start with a digit
- // as long as they contain at least one char
- while (current < end && is_ident_char (current[0])) {
+ } else if (current < end && current == begin + 1
+ && begin[0] == '0'
+ && (begin[1] == 'b' || begin[1] == 'B' || begin[1] == 'o' || begin[1] == 'O')
+ && begin[2].isdigit ()) {
+ // binary or octal integer literal
+ current++;
+ while (current < end && current[0].isdigit ()) {
current++;
}
- type = TokenType.IDENTIFIER;
+ }
+ if (current < end) {
+ bool real_literal = (type == TokenType.REAL_LITERAL);
+
+ switch (current[0]) {
+ case 'l':
+ case 'L':
+ if (type == TokenType.INTEGER_LITERAL) {
+ current++;
+ if (current < end && current[0].tolower () == 'l') {
+ current++;
+ }
+ }
+ break;
+ case 'u':
+ case 'U':
+ if (type == TokenType.INTEGER_LITERAL) {
+ current++;
+ if (current < end && current[0].tolower () == 'l') {
+ current++;
+ if (current < end && current[0].tolower () == 'l') {
+ current++;
+ }
+ }
+ }
+ break;
+ case 'f':
+ case 'F':
+ case 'd':
+ case 'D':
+ type = TokenType.REAL_LITERAL;
+ current++;
+ break;
+ }
+
+ if (!real_literal && is_ident_char (current[0])) {
+ // allow identifiers to start with a digit
+ // as long as they contain at least one char
+ while (current < end && is_ident_char (current[0])) {
+ current++;
+ }
+ type = TokenType.IDENTIFIER;
+ }
}
} else {
switch (current[0]) {
uint64 un = 0ULL;
errno = 0;
- if (negative) {
- n = int64.parse (value);
+ if (value.has_prefix ("0b") || value.has_prefix ("0B")
+ || value.has_prefix ("-0b") || value.has_prefix ("-0B")) {
+ string v;
+ if (negative) {
+ v = "-" + value.substring (3);
+ } else {
+ v = value.substring (2);
+ }
+ string unparsed;
+ if (negative) {
+ int64.try_parse (v, out n, out unparsed, 2);
+ value = n.to_string ();
+ } else {
+ uint64.try_parse (v, out un, out unparsed, 2);
+ value = un.to_string ();
+ }
+ if (unparsed != "") {
+ Report.error (source_reference, "invalid digit '%c' in binary literal", unparsed[0]);
+ error = true;
+ }
+ } else if ((value[0] == '0' && value.length > 1
+ && (value[1] == 'o' || value[1] == 'O' || value[1].isdigit ()))
+ || (value.has_prefix ("-0") && value.length > 3
+ && (value[2] == 'o' || value[2] == 'O' || value[2].isdigit ()))) {
+ if (negative) {
+ if (!value[2].isdigit ()) {
+ value = "-0" + value.substring (3);
+ }
+ } else {
+ if (!value[1].isdigit ()) {
+ value = "0" + value.substring (2);
+ }
+ }
+ string unparsed;
+ if (negative) {
+ int64.try_parse (value, out n, out unparsed, 8);
+ } else {
+ uint64.try_parse (value, out un, out unparsed, 8);
+ }
+ if (unparsed != "") {
+ Report.error (source_reference, "invalid digit '%c' in octal literal", unparsed[0]);
+ error = true;
+ }
} else {
- un = uint64.parse (value);
+ // hexademical and decimal literal
+ if (negative) {
+ n = int64.parse (value);
+ } else {
+ un = uint64.parse (value);
+ }
}
+
if (errno == ERANGE) {
Report.error (source_reference, "integer literal is too large for its type");
error = true;
var type = TokenType.INTEGER_LITERAL;
// integer part
- if (current < end - 2 && current[0] == '0'
- && current[1] == 'x' && current[2].isxdigit ()) {
- // hexadecimal integer literal
- current += 2;
- while (current < end && current[0].isxdigit ()) {
- current++;
+ if (current < end - 2 && current[0] == '0') {
+ switch (current[1]) {
+ case 'x':
+ case 'X':
+ // hexadecimal integer literal
+ current += 2;
+ while (current < end && current[0].isxdigit ()) {
+ current++;
+ }
+ break;
+ case 'b':
+ case 'B':
+ case 'o':
+ case 'O':
+ // binary integer literal or octal integer literal
+ current += 2;
+ while (current < end && current[0].isdigit ()) {
+ current++;
+ }
+ break;
+ default:
+ // decimal number (also may be octal integer)
+ while (current < end && current[0].isdigit ()) {
+ current++;
+ }
+ break;
}
} else {
// decimal number
projects / thirdparty / vala.git / commitdiff
