parser/body.go

@@ -32,9 +32,9 @@ func (parser *ParsingOperation) parseBody () (err error) {
 		case "objt":
 			var section *ObjtSection
 			section, err = parser.parseObjtSection()
-			if parser.tree.objtSections == nil {
+			if parser.tree.typeSections == nil {
-				parser.tree.objtSections =
+				parser.tree.typeSections =
-					make(map[string] *ObjtSection)
+					make(map[string] *TypeSection)
 			}
 			parser.tree.objtSections[section.name] = section
 			if err != nil { return }

parser/objt.go

@@ -1,103 +0,0 @@
-package parser
-
-import "git.tebibyte.media/sashakoshka/arf/types"
-import "git.tebibyte.media/sashakoshka/arf/lexer"
-import "git.tebibyte.media/sashakoshka/arf/infoerr"
-
-// parseObjtSection parses an object type definition. This allows for structured
-// types to be defined, and for member variables to be added and overridden.
-func (parser *ParsingOperation) parseObjtSection () (
-	section *ObjtSection,
-	err     error,
-) {
-	err = parser.expect(lexer.TokenKindName)
-	if err != nil { return }
-	
-	section = &ObjtSection { location: parser.token.Location() }
-
-	// get permission
-	err = parser.nextToken(lexer.TokenKindPermission)
-	if err != nil { return }
-	section.permission = parser.token.Value().(types.Permission)
-
-	// get name
-	err = parser.nextToken(lexer.TokenKindName)
-	if err != nil { return }
-	section.name = parser.token.Value().(string)
-
-	// parse inherited type
-	err = parser.nextToken(lexer.TokenKindColon)
-	if err != nil { return }
-	err = parser.nextToken()
-	if err != nil { return }
-	section.inherits, err = parser.parseType()
-	if err != nil { return }
-	err = parser.nextToken(lexer.TokenKindNewline)
-	if err != nil { return }
-
-	// parse members
-	err = parser.parseObjtMembers(section)
-	
-	if len(section.members) == 0 {
-		infoerr.NewError (
-			section.location,
-			"defining an object with no members",
-			infoerr.ErrorKindWarn).Print()
-	}
-	return
-}
-
-func (parser *ParsingOperation) parseObjtMembers (
-	into *ObjtSection,
-) (
-	err     error,
-) {
-	for {
-		// if we've left the block, stop parsing
-		if !parser.token.Is(lexer.TokenKindIndent) { return }
-		if parser.token.Value().(int) != 1         { return }
-
-		// get permission
-		err = parser.nextToken(lexer.TokenKindPermission)
-		if err != nil { return }
-		member := ObjtMember { }
-		member.permission = parser.token.Value().(types.Permission)
-
-		// get name
-		err = parser.nextToken(lexer.TokenKindName)
-		if err != nil { return }
-		member.name = parser.token.Value().(string)
-
-		// get type
-		err = parser.nextToken(lexer.TokenKindColon)
-		if err != nil { return }
-		err = parser.nextToken()
-		if err != nil { return }
-		member.what, err = parser.parseType()
-		if err != nil { return }
-		
-		// parse default value
-		if parser.token.Is(lexer.TokenKindNewline) {
-			err = parser.nextToken()
-			if err != nil { return }
-
-			member.defaultValue,
-			err = parser.parseInitializationValues(1)
-			if err != nil { return }
-		} else {
-			member.defaultValue, err = parser.parseArgument()
-			if err != nil { return }
-
-			err = parser.expect(lexer.TokenKindNewline)
-			if err != nil { return }
-			err = parser.nextToken()
-			if err != nil { return }
-		}
-
-		// go onto the next line
-		err = parser.nextToken(lexer.TokenKindNewline)
-		if err != nil { return }
-		err = parser.nextToken()
-		if err != nil { return }
-	}
-}

parser/type.go

@@ -2,10 +2,9 @@ package parser
 
 import "git.tebibyte.media/sashakoshka/arf/types"
 import "git.tebibyte.media/sashakoshka/arf/lexer"
-// import "git.tebibyte.media/sashakoshka/arf/infoerr"
+import "git.tebibyte.media/sashakoshka/arf/infoerr"
 
-// parseTypeSection parses a blind type definition, meaning it can inherit from
+// parseTypeSection parses a type definition.
-// anything including primitives, but cannot define structure.
 func (parser *ParsingOperation) parseTypeSection () (
 	section *TypeSection,
 	err     error,
@@ -15,33 +14,50 @@ func (parser *ParsingOperation) parseTypeSection () (
 	
 	section = &TypeSection { location: parser.token.Location() }
 
-	// get permission
+	// parse root node
-	err = parser.nextToken(lexer.TokenKindPermission)
+	err = parser.nextToken()
 	if err != nil { return }
-	section.permission = parser.token.Value().(types.Permission)
+	section.root, err = parser.parseTypeNode(0)
+
+	return
+}
+
+// parseTypeNode parses a single type definition node recursively.
+func (parser *ParsingOperation) parseTypeNode (
+	baseIndent int,
+) (
+	node TypeNode,
+	err  error,
+) {
+	node.children = make(map[string] TypeNode)
+
+	// get permission
+	err = parser.expect(lexer.TokenKindPermission)
+	if err != nil { return }
+	node.permission = parser.token.Value().(types.Permission)
 
 	// get name
 	err = parser.nextToken(lexer.TokenKindName)
 	if err != nil { return }
-	section.name = parser.token.Value().(string)
+	node.name = parser.token.Value().(string)
 
-	// parse inherited type
+	// get inherited type
 	err = parser.nextToken(lexer.TokenKindColon)
 	if err != nil { return }
 	err = parser.nextToken()
 	if err != nil { return }
-	section.inherits, err = parser.parseType()
+	node.what, err = parser.parseType()
 	if err != nil { return }
 
-	// parse default values
+	// get value, or child nodes
 	if parser.token.Is(lexer.TokenKindNewline) {
 		err = parser.nextToken()
 		if err != nil { return }
 
-		section.defaultValue, err = parser.parseInitializationValues(0)
+		err = parser.parseTypeNodeBlock(baseIndent, &node)
 		if err != nil { return }
 	} else {
-		section.defaultValue, err = parser.parseArgument()
+		node.defaultValue, err = parser.parseArgument()
 		if err != nil { return }
 
 		err = parser.expect(lexer.TokenKindNewline)
@@ -51,3 +67,101 @@ func (parser *ParsingOperation) parseTypeSection () (
 	}
 	return
 }
+
+// parseTypeNodeBlock starts on the line after a type node, and parses what
+// could be either an array initialization, an object initialization, or more
+// child nodes. It is similar to parseInitializationValues. If none of these
+// things were found the parser stays at the beginning of the line and the
+// method returns.
+func (parser *ParsingOperation) parseTypeNodeBlock (
+	baseIndent int,
+	parent     *TypeNode,
+) (
+	err error,
+) {
+	// check if line is indented one more than baseIndent
+	if !parser.token.Is(lexer.TokenKindIndent) { return }
+	if parser.token.Value().(int) != baseIndent + 1 { return }
+
+	thingLocation := parser.token.Location()
+	
+	err = parser.nextToken()
+	if err != nil { return }
+
+	if parser.token.Is(lexer.TokenKindDot) {
+
+		// object initialization
+		parser.previousToken()
+		initializationArgument := Argument { location: thingLocation }
+		var initializationValues ObjectInitializationValues
+		initializationValues, err    = parser.parseObjectInitializationValues()
+		initializationArgument.kind  = ArgumentKindObjectInitializationValues
+		initializationArgument.value = &initializationValues
+		parent.defaultValue = initializationArgument
+		
+	} else if parser.token.Is(lexer.TokenKindPermission) {
+
+		// child members
+		parser.previousToken()
+		err = parser.parseTypeNodeChildren(parent)
+		
+	} else {
+	
+		// array initialization
+		parser.previousToken()
+		initializationArgument := Argument { location: thingLocation }
+		var initializationValues ArrayInitializationValues
+		initializationValues, err    = parser.parseArrayInitializationValues()
+		initializationArgument.kind  = ArgumentKindArrayInitializationValues
+		initializationArgument.value = &initializationValues
+		parent.defaultValue = initializationArgument
+	}
+	
+	return
+}
+
+// parseTypeNodeChildren parses child type nodes into a parent type node.
+func (parser *ParsingOperation) parseTypeNodeChildren (
+	parent *TypeNode,
+) (
+	err error,
+) {
+	baseIndent := 0
+	begin      := true
+	
+	for {
+		// if there is no indent we can just stop parsing
+		if !parser.token.Is(lexer.TokenKindIndent) { break }
+		indent := parser.token.Value().(int)
+		
+		if begin == true {
+			baseIndent = indent 
+			begin      = false
+		}
+
+		// do not parse any further if the indent has changed
+		if indent != baseIndent { break }
+
+		// move on to the beginning of the line, which must contain
+		// a type node
+		err = parser.nextToken()
+		if err != nil { return }
+		var child TypeNode
+		child, err = parser.parseTypeNode(baseIndent)
+
+		// if the member has already been listed, throw an error
+		_, exists := parent.children[child.name]
+		if exists {
+			err = parser.token.NewError (
+				"duplicate member \"" + child.name +
+				"\" in object member initialization",
+				infoerr.ErrorKindError)
+			return
+		}
+
+		// store in parent
+		parent.children[child.name] = child
+	}
+	
+	return
+}