Reworked parsing object initialization values

parser/data.go

@@ -62,9 +62,13 @@ func (parser *ParsingOperation) parseInitializationValues (
 	if parser.token.Value().(int) != baseIndent + 1 { return }
 
 	initializationArgument.location = parser.token.Location()
+	
+	err = parser.nextToken()
+	if err != nil { return }
 
 	if parser.token.Is(lexer.TokenKindDot) {
 	
+		parser.previousToken()
 		var initializationValues ObjectInitializationValues
 		initializationValues, err    = parser.parseObjectInitializationValues()
 		initializationArgument.kind  = ArgumentKindObjectInitializationValues
@@ -72,6 +76,7 @@ func (parser *ParsingOperation) parseInitializationValues (
 		
 	} else {
 	
+		parser.previousToken()
 		var initializationValues ArrayInitializationValues
 		initializationValues, err    = parser.parseArrayInitializationValues()
 		initializationArgument.kind  = ArgumentKindArrayInitializationValues
@@ -85,86 +90,84 @@ func (parser *ParsingOperation) parseInitializationValues (
 // parseObjectInitializationValues parses a list of object initialization
 // values until the indentation level drops.
 func (parser *ParsingOperation) parseObjectInitializationValues () (
-	values ObjectInitializationValues,
+	initializationValues ObjectInitializationValues,
-	err    error,
+	err                  error,
 ) {
-	// println("PARSING")
+	initializationValues.attributes = make(map[string] Argument)
-	// defer println("DONE\n")
+
-	// values.attributes = make(map[string] Argument)
+	baseIndent := 0
-	// values.location   = parser.token.Location()
+	begin      := true
-// 
+	
-	// for {
+	for {
-		// // get attribute name and value
+		println(parser.token.Describe())
-		// err = parser.nextToken(lexer.TokenKindName)
+	
-		// if err != nil { return }
+		// if there is no indent we can just stop parsing
-		// name := parser.token.Value().(string)
+		if !parser.token.Is(lexer.TokenKindIndent) { break}
-		// println("  name:", name)
+		indent := parser.token.Value().(int)
-		// 
+		
-		// _, exists := values.attributes[name]
+		if begin == true {
-		// if exists {
+			initializationValues.location = parser.token.Location()
-			// err = parser.token.NewError (
+			baseIndent = indent 
-				// "duplicate member \"" + name + "\" in object " +
+			begin      = false
-				// "member initialization",
+		}
-				// file.ErrorKindError)
+
-			// return
+		// do not parse any further if the indent has changed
-		// }
+		if indent != baseIndent { break }
-		// 
+
-		// err = parser.nextToken()
+		// move on to the beginning of the line, which must contain
-		// if err != nil { return }
+		// a member initialization value
-// 
+		err = parser.nextToken(lexer.TokenKindDot)
-		// println("  parsing value argument")
+		if err != nil { return }
-		// // parse value argument
+		err = parser.nextToken(lexer.TokenKindName)
-		// var value Argument
+		if err != nil { return }
-		// if parser.token.Is(lexer.TokenKindNewline) {
+		name := parser.token.Value().(string)
-			// println("    is newline")
+
-			// // if there is none on this line, expect complex
+		// if the member has already been listed, throw an error
-			// // initialization below
+		_, exists := initializationValues.attributes[name]
-// 
+		if exists {
-			// possibleErrorLocation := parser.token.Location()
+			err = parser.token.NewError (
-			// err = parser.nextToken(lexer.TokenKindIndent)
+				"duplicate member \"" + name + "\" in object " +
+				"member initialization",
+				file.ErrorKindError)
+			return
+		}
+
+		// parse the argument determining the member initialization
+		// value
+		err = parser.nextToken()
+		if err != nil { return }
+		var value Argument
+		if parser.token.Is(lexer.TokenKindNewline) {
+		
+			// TODO: recurse
+			err = parser.nextToken(lexer.TokenKindIndent)
+			if err != nil { return }
+			// value, err = parser.parseInitializationValues()
 			// if err != nil { return }
-// 
+			
-			// value, err = parser.parseInitializationValues(indent)
+		} else {
-			// if err != nil { return }
+
-// 
+			// parse as normal argument
-			// // TODO: this doesn't seem to produce an error at the
+			value, err = parser.parseArgument()
-			// // correct location.
+			if err != nil { return }
-			// if value.value == nil {
+			err = parser.expect(lexer.TokenKindNewline)
-				// err = possibleErrorLocation.NewError (
+			if err != nil { return }
-					// "empty initialization value",
+			err = parser.nextToken()
-					// file.ErrorKindError)
+			if err != nil { return }
-				// return
+		}
-			// }
+		
-			// 
+		// store in object
-		// } else {
+		initializationValues.attributes[name] = value
-			// println("    is not newline")
+	}
-			// value, err = parser.parseArgument()
+	
-			// if err != nil { return }
-			// err = parser.expect(lexer.TokenKindNewline)
-			// if err != nil { return }
-		// }
-// 
-		// // store in object
-		// values.attributes[name] = value
-// 
-		// // if indent drops, or does something strange, stop parsing
-		// err = parser.nextToken()
-		// if err != nil { return }
-		// if !parser.token.Is(lexer.TokenKindIndent) { break }
-		// if parser.token.Value().(int) != indent { break }
-// 
-		// // the next line must start with a dot
-		// err = parser.nextToken(lexer.TokenKindDot)
-		// if err != nil { return }
-	// }
 	return
 }
 
 // parseArrayInitializationValues parses a list of array initialization values
 // until the indentation lexel drops.
 func (parser *ParsingOperation) parseArrayInitializationValues () (
-	values ArrayInitializationValues,
+	initializationValues ArrayInitializationValues,
-	err    error,
+	err                  error,
 ) {
 	baseIndent := 0
 	begin      := true
@@ -175,7 +178,7 @@ func (parser *ParsingOperation) parseArrayInitializationValues () (
 		indent := parser.token.Value().(int)
 		
 		if begin == true {
-			values.location = parser.token.Location()
+			initializationValues.location = parser.token.Location()
 			baseIndent = indent 
 			begin      = false
 		}
@@ -201,7 +204,9 @@ func (parser *ParsingOperation) parseArrayInitializationValues () (
 			var argument Argument
 			argument, err = parser.parseArgument()
 			if err != nil { return }
-			values.values = append(values.values, argument)
+			initializationValues.values = append (
+				initializationValues.values,
+				argument)
 		}
 	}