Added untested parsing of function arguments

parser/func.go

@@ -2,7 +2,7 @@ package parser
 
 import "git.tebibyte.media/arf/arf/types"
 import "git.tebibyte.media/arf/arf/lexer"
-// import "git.tebibyte.media/arf/arf/infoerr"
+import "git.tebibyte.media/arf/arf/infoerr"
 
 // parseFunc parses a function section.
 func (parser *ParsingOperation) parseFuncSection () (
@@ -28,3 +28,114 @@ func (parser *ParsingOperation) parseFuncSection () (
 	return
 }
 
+// parseFuncArguments parses a function's inputs, outputs, and reciever if that
+// exists.
+func (parser *ParsingOperation) parseFuncArguments (
+	into *FuncSection,
+) (
+	err error,
+) {
+	for {
+		// if we've left the block, stop parsing
+		// TODO: throw error here, function arguments should only end
+		// on separator
+		if !parser.token.Is(lexer.TokenKindIndent) { return }
+		if parser.token.Value().(int) != 1         { return }
+
+		// determine whether this is an input, output, or the method
+		// reciever
+		err = parser.nextToken (
+			lexer.TokenKindAt,
+			lexer.TokenKindLessThan,
+			lexer.TokenKindGreaterThan,
+			lexer.TokenKindSeparator)
+		if err != nil { return }
+
+		startToken := parser.token
+		if parser.token.Is(lexer.TokenKindSeparator) {
+			// if we have encountered a separator, that means our
+			// work is done here.
+			err = parser.expect(lexer.TokenKindNewline)
+			return
+		}
+		
+		switch startToken.Kind() {
+		case lexer.TokenKindAt:
+			reciever := Declaration { }
+			reciever.location = parser.token.Location()
+			
+			// get name
+			err = parser.nextToken(lexer.TokenKindName)
+			if err != nil { return }
+			reciever.name = parser.token.Value().(string)
+			err = parser.nextToken()
+			if err != nil { return }
+			
+			if into.receiver != nil {
+				err = startToken.NewError (
+					"cannot have more than one method " +
+					"receiver",
+					infoerr.ErrorKindError)
+				return
+			} else {
+				into.receiver = &reciever
+			}
+			
+			err = parser.expect(lexer.TokenKindNewline)
+			if err != nil { return }
+			err = parser.nextToken()
+			if err != nil { return }
+			
+		case lexer.TokenKindGreaterThan:
+			input := Declaration { }
+			input.location = parser.token.Location()
+			
+			// get name
+			err = parser.nextToken(lexer.TokenKindName)
+			if err != nil { return }
+			input.name = parser.token.Value().(string)
+			err = parser.nextToken()
+			if err != nil { return }
+
+			into.inputs = append(into.inputs, input)
+			
+			err = parser.expect(lexer.TokenKindNewline)
+			if err != nil { return }
+			err = parser.nextToken()
+			if err != nil { return }
+			
+		case lexer.TokenKindLessThan:
+			output := FuncOutput { }
+			output.location = parser.token.Location()
+			
+			// get name
+			err = parser.nextToken(lexer.TokenKindName)
+			if err != nil { return }
+			output.name = parser.token.Value().(string)
+			err = parser.nextToken()
+			if err != nil { return }
+			
+			// parse default value
+			if parser.token.Is(lexer.TokenKindNewline) {
+				err = parser.nextToken()
+				if err != nil { return }
+
+				output.defaultValue, err =
+					parser.parseInitializationValues(1)
+				into.outputs = append(into.outputs, output)
+				if err != nil { return }
+			} else {
+				output.defaultValue, err =
+					parser.parseArgument()
+				into.outputs = append(into.outputs, output)
+				if err != nil { return }
+
+				err = parser.expect(lexer.TokenKindNewline)
+				if err != nil { return }
+				err = parser.nextToken()
+				if err != nil { return }
+			}
+		}
+	
+	}
+}