vala r1476 - in trunk: . vala

[jamiemcc svn gnome org]

Author: jamiemcc
Date: Thu May 29 02:55:18 2008
New Revision: 1476
URL: http://svn.gnome.org/viewvc/vala?rev=1476&view=rev

Log:
2008-05-29  Jamie McCracken  <jamiemcc gnome org>

	* vala/valagenietokentype.vala:
	* vala/valageniescanner.vala:
	* vala/valagenieparser.vala:
	
	Revamped array syntax



Modified:
   trunk/ChangeLog
   trunk/vala/valagenieparser.vala
   trunk/vala/valageniescanner.vala
   trunk/vala/valagenietokentype.vala

Modified: trunk/vala/valagenieparser.vala
==============================================================================
--- trunk/vala/valagenieparser.vala	(original)
+++ trunk/vala/valagenieparser.vala	Thu May 29 02:55:18 2008
@@ -339,7 +339,7 @@
 
 	public void parse_file (SourceFile source_file) {
 		scanner = new Scanner (source_file);
-
+		scanner.indent_spaces = 0;
 		index = -1;
 		size = 0;
 		
@@ -395,6 +395,11 @@
 		accept (TokenType.DYNAMIC);
 
 		accept (TokenType.WEAK);
+		
+		if (accept (TokenType.ARRAY)) {
+			accept (TokenType.OF);
+		}
+		
 		skip_symbol_name ();
 		skip_type_argument_list ();
 		while (accept (TokenType.OPEN_BRACKET)) {	
@@ -427,6 +432,14 @@
 			value_owned = !accept (TokenType.WEAK);
 		}
 
+		/* handle arrays */
+		bool is_array = false;
+		
+		if (accept (TokenType.ARRAY)) {
+			expect (TokenType.OF);
+			is_array = true;
+		}
+
 		var sym = parse_symbol_name ();
 		Gee.List<DataType> type_arg_list = parse_type_argument_list (false);
 
@@ -445,24 +458,36 @@
 			type.nullable = accept (TokenType.INTERR);
 		}
 
-		while (accept (TokenType.OPEN_BRACKET)) {
-			int array_rank = 0;
-			do {
-				array_rank++;
-				// support for stack-allocated arrays
-				// also required for decision between expression and declaration statement
-				if (current () != TokenType.COMMA && current () != TokenType.CLOSE_BRACKET) {
-					parse_expression ();
+		if (is_array) {
+			
+			if (!accept (TokenType.OPEN_BRACKET)) {
+				type.value_owned = true;
+				type = new ArrayType (type, 1, get_src (begin));
+				type.nullable = accept (TokenType.INTERR);
+			
+			} else {
+				prev ();
+			
+				while (accept (TokenType.OPEN_BRACKET))	{		
+					int array_rank = 0;
+					do {
+						array_rank++;
+						// support for stack-allocated arrays
+						// also required for decision between expression and declaration statement
+						if (current () != TokenType.COMMA && current () != TokenType.CLOSE_BRACKET) {
+							parse_expression ();
+						}
+					}
+					while (accept (TokenType.COMMA));
+					expect (TokenType.CLOSE_BRACKET);
+
+					type.value_owned = true;
+					type = new ArrayType (type, array_rank, get_src (begin));
+					type.nullable = accept (TokenType.INTERR);
 				}
 			}
-			while (accept (TokenType.COMMA));
-			expect (TokenType.CLOSE_BRACKET);
-
-			type.value_owned = true;
-			type = new ArrayType (type, array_rank, get_src (begin));
-			type.nullable = accept (TokenType.INTERR);
 		}
-
+		
 		if (!owned_by_default) {
 			value_owned = accept (TokenType.HASH);
 		}
@@ -782,13 +807,18 @@
 	Expression parse_object_or_array_creation_expression () throws ParseError {
 		var begin = get_location ();
 		expect (TokenType.NEW);
+		
+		if (accept (TokenType.ARRAY)) {
+			expect (TokenType.OF);
+			var m = parse_member_name ();
+			var expr = parse_array_creation_expression (begin, m);
+			return expr;
+		}
+		
 		var member = parse_member_name ();
 		if (accept (TokenType.OPEN_PARENS)) {
 			var expr = parse_object_creation_expression (begin, member);
 			return expr;
-		} else if (accept (TokenType.OPEN_BRACKET)) {
-			var expr = parse_array_creation_expression (begin, member);
-			return expr;
 		} else {
 			throw new ParseError.SYNTAX (get_error ("expected ( or ["));
 		}
@@ -815,6 +845,9 @@
 		Gee.List<Expression> size_specifier_list;
 		bool first = true;
 		DataType element_type = UnresolvedType.new_from_expression (member);
+		
+		var has_bracket = accept (TokenType.OPEN_BRACKET);
+		
 		do {
 			if (!first) {
  				// array of arrays: new T[][42]
@@ -826,17 +859,21 @@
 			size_specifier_list = new ArrayList<Expression> ();
 			do {
 				Expression size = null;
-				if (current () != TokenType.CLOSE_BRACKET && current () != TokenType.COMMA) {
+				if (has_bracket && current () != TokenType.CLOSE_BRACKET && current () != TokenType.COMMA) {
 					size = parse_expression ();
 					size_specified = true;
 				}
 				size_specifier_list.add (size);
 			} while (accept (TokenType.COMMA));
-			expect (TokenType.CLOSE_BRACKET);
+			
+			if (has_bracket) {
+				expect (TokenType.CLOSE_BRACKET);
+			}
 		} while (accept (TokenType.OPEN_BRACKET));
 
 		InitializerList initializer = null;
-		if (current () == TokenType.OPEN_BRACE) {
+		if (accept (TokenType.ASSIGN)) {
+
 			initializer = parse_initializer ();
 		}
 		var expr = new ArrayCreationExpression (element_type, size_specifier_list.size, initializer, get_src (begin));
@@ -1615,6 +1652,10 @@
 		Expression initializer = null;
 		if (accept (TokenType.ASSIGN)) {
 			initializer = parse_variable_initializer ();
+			var array_type = variable_type as ArrayType;
+			if (array_type != null && initializer is InitializerList) {
+				initializer = new ArrayCreationExpression (array_type.element_type.copy (), array_type.rank, (InitializerList) initializer, initializer.source_reference);
+			}
 		}
 		return new LocalVariable (variable_type, id, initializer, get_src_com (begin));
 	}
@@ -2227,9 +2268,13 @@
 		var type_param_list = parse_type_parameter_list ();
 		var base_types = new ArrayList<DataType> ();
 		if (accept (TokenType.COLON)) {
-			do {
-				base_types.add (parse_type ());
-			} while (accept (TokenType.COMMA));
+			base_types.add (parse_type ());
+			
+			if (accept (TokenType.IMPLEMENTS)) {
+				do {
+					base_types.add (parse_type ());
+				} while (accept (TokenType.COMMA));
+			}
 		}
 
 		accept (TokenType.EOL);
@@ -2391,19 +2436,45 @@
 
 	InitializerList parse_initializer () throws ParseError {
 		var begin = get_location ();
-		expect (TokenType.OPEN_BRACE);
+		if  (!accept (TokenType.OPEN_PARENS)) {
+			expect (TokenType.OPEN_BRACE);
+		}
 		var initializer = new InitializerList (get_src (begin));
 		if (current () != TokenType.DEDENT) {
 			do {
 				initializer.append (parse_variable_initializer ());
 			} while (accept (TokenType.COMMA));
 		}
-		expect (TokenType.CLOSE_BRACE);
+		if  (!accept (TokenType.CLOSE_PARENS)) {
+			expect (TokenType.CLOSE_BRACE);
+		}
 		return initializer;
 	}
+	
+	bool is_initializer () throws ParseError { 
+		if (current () == TokenType.OPEN_BRACE) {
+			return true;
+		}
+		
+		if (current () == TokenType.OPEN_PARENS) {
+			var begin = get_location ();
+			var is_array = false;
+						
+			next ();
+						
+			var expr = parse_expression ();
+			is_array = (accept (TokenType.COMMA));
+			
+			rollback (begin);
+			
+			return is_array;
+		}
+		return false;
+	}
+	
 
 	Expression parse_variable_initializer () throws ParseError {
-		if (current () == TokenType.OPEN_BRACE) {
+		if (is_initializer ()) {
 			var expr = parse_initializer ();
 			return expr;
 		} else {

Modified: trunk/vala/valageniescanner.vala
==============================================================================
--- trunk/vala/valageniescanner.vala	(original)
+++ trunk/vala/valageniescanner.vala	Thu May 29 02:55:18 2008
@@ -210,6 +210,9 @@
 			break;
 		case 5:
 			switch (begin[0]) {
+			case 'a':
+				if (matches (begin, "array")) return TokenType.ARRAY;
+				break;
 			case 'b':
 				if (matches (begin, "break")) return TokenType.BREAK;
 				break;
@@ -401,7 +404,13 @@
 				break;
 			}
 			break;
-
+		case 10:
+			switch (begin[0]) {
+			case 'i':
+				if (matches (begin, "implements")) return TokenType.IMPLEMENTS;
+				break;	
+			}
+			break;
 		}
 		return TokenType.IDENTIFIER;
 	}

Modified: trunk/vala/valagenietokentype.vala
==============================================================================
--- trunk/vala/valagenietokentype.vala	(original)
+++ trunk/vala/valagenietokentype.vala	Thu May 29 02:55:18 2008
@@ -26,6 +26,7 @@
 public enum Vala.Genie.TokenType {
 	NONE,
 	ABSTRACT,
+	ARRAY,
 	AS,
 	ASSERT,
 	ASSIGN,
@@ -82,6 +83,7 @@
 	HASH,
 	IDENTIFIER,
 	IF,
+	IMPLEMENTS,
 	IN,
 	INDENT,
 	INIT,
@@ -158,6 +160,7 @@
 	public weak string to_string () {
 		switch (this) {
 		case ABSTRACT: return "`abstract'";
+		case ARRAY: return "`array'";
 		case AS: return "`as'";
 		case ASSERT: return "`assert'";
 		case ASSIGN: return "`='";
@@ -214,6 +217,7 @@
 		case HASH: return "`hash'";
 		case IDENTIFIER: return "identifier";
 		case IF: return "`if'";
+		case IMPLEMENTS: return "`implements'";
 		case IN: return "`in'";
 		case INDENT: return "`tab indent'";
 		case INIT: return "`init'";