355 lines
9.2 KiB
Go
355 lines
9.2 KiB
Go
package parser
|
|
|
|
import "git.tebibyte.media/arf/arf/lexer"
|
|
|
|
// operatorTokens lists all symbolic tokens that can act as a command to a
|
|
// phrase.
|
|
var operatorTokens = []lexer.TokenKind {
|
|
lexer.TokenKindColon,
|
|
lexer.TokenKindPlus,
|
|
lexer.TokenKindMinus,
|
|
lexer.TokenKindIncrement,
|
|
lexer.TokenKindDecrement,
|
|
lexer.TokenKindAsterisk,
|
|
lexer.TokenKindSlash,
|
|
lexer.TokenKindExclamation,
|
|
lexer.TokenKindPercent,
|
|
lexer.TokenKindPercentAssignment,
|
|
lexer.TokenKindTilde,
|
|
lexer.TokenKindTildeAssignment,
|
|
lexer.TokenKindAssignment,
|
|
lexer.TokenKindEqualTo,
|
|
lexer.TokenKindNotEqualTo,
|
|
lexer.TokenKindLessThanEqualTo,
|
|
lexer.TokenKindLessThan,
|
|
lexer.TokenKindLShift,
|
|
lexer.TokenKindLShiftAssignment,
|
|
lexer.TokenKindGreaterThan,
|
|
lexer.TokenKindGreaterThanEqualTo,
|
|
lexer.TokenKindRShift,
|
|
lexer.TokenKindRShiftAssignment,
|
|
lexer.TokenKindBinaryOr,
|
|
lexer.TokenKindBinaryOrAssignment,
|
|
lexer.TokenKindLogicalOr,
|
|
lexer.TokenKindBinaryAnd,
|
|
lexer.TokenKindBinaryAndAssignment,
|
|
lexer.TokenKindLogicalAnd,
|
|
lexer.TokenKindBinaryXor,
|
|
lexer.TokenKindBinaryXorAssignment,
|
|
}
|
|
|
|
// isTokenOperator returns whether or not the token is an operator token.
|
|
func isTokenOperator (token lexer.Token) (isOperator bool) {
|
|
for _, kind := range operatorTokens {
|
|
if token.Is(kind) {
|
|
isOperator = true
|
|
return
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// validPhraseStartTokens lists all tokens that are expected when parsing the
|
|
// first part of a phrase.
|
|
var validPhraseStartTokens = append (
|
|
operatorTokens,
|
|
lexer.TokenKindLBracket,
|
|
lexer.TokenKindName,
|
|
lexer.TokenKindString)
|
|
|
|
// validBlockLevelPhraseTokens lists all tokens that are expected when parsing
|
|
// a block level phrase.
|
|
var validBlockLevelPhraseTokens = append (
|
|
validArgumentStartTokens,
|
|
lexer.TokenKindNewline,
|
|
lexer.TokenKindReturnDirection)
|
|
|
|
// validDelimitedPhraseTokens is like validBlockLevelPhraseTokens, but it also
|
|
// includes a right brace token.
|
|
var validDelimitedPhraseTokens = append (
|
|
validArgumentStartTokens,
|
|
lexer.TokenKindNewline,
|
|
lexer.TokenKindIndent,
|
|
lexer.TokenKindRBracket,
|
|
lexer.TokenKindReturnDirection)
|
|
|
|
// controlFlowKinds contains a list of all phrase kinds that must have a block
|
|
// underneath them.
|
|
var controlFlowKinds = []PhraseKind {
|
|
PhraseKindIf,
|
|
PhraseKindElse,
|
|
PhraseKindElseIf,
|
|
PhraseKindFor,
|
|
PhraseKindWhile,
|
|
PhraseKindDefer,
|
|
PhraseKindCase,
|
|
}
|
|
|
|
// parseBlock parses an indented block of phrases
|
|
func (parser *ParsingOperation) parseBlock (
|
|
indent int,
|
|
) (
|
|
block Block,
|
|
err error,
|
|
) {
|
|
for {
|
|
// if we've left the block, stop parsing
|
|
if !parser.token.Is(lexer.TokenKindIndent) { return }
|
|
if parser.token.Value().(int) != indent { return }
|
|
|
|
var phrase Phrase
|
|
phrase, err = parser.parseBlockLevelPhrase(indent)
|
|
block = append(block, phrase)
|
|
if err != nil { return }
|
|
}
|
|
}
|
|
|
|
// parseBlockLevelPhrase parses a phrase that is not being used as an argument
|
|
// to something else. This method is allowed to do things like parse return
|
|
// directions, and indented blocks beneath the phrase.
|
|
func (parser *ParsingOperation) parseBlockLevelPhrase (
|
|
indent int,
|
|
) (
|
|
phrase Phrase,
|
|
err error,
|
|
) {
|
|
if !parser.token.Is(lexer.TokenKindIndent) { return }
|
|
if parser.token.Value().(int) != indent { return }
|
|
err = parser.nextToken(validPhraseStartTokens...)
|
|
if err != nil { return }
|
|
|
|
expectRightBracket := false
|
|
if parser.token.Is(lexer.TokenKindLBracket) {
|
|
expectRightBracket = true
|
|
err = parser.nextToken()
|
|
if err != nil { return }
|
|
}
|
|
|
|
// get command
|
|
err = parser.expect(validPhraseStartTokens...)
|
|
if err != nil { return }
|
|
phrase.command, phrase.kind, err = parser.parsePhraseCommand()
|
|
if err != nil { return }
|
|
|
|
for {
|
|
if expectRightBracket {
|
|
// delimited
|
|
// [someFunc arg1 arg2 arg3] -> someVariable
|
|
err = parser.expect(validDelimitedPhraseTokens...)
|
|
if err != nil { return }
|
|
|
|
if parser.token.Is(lexer.TokenKindRBracket) {
|
|
// this is an ending delimiter
|
|
err = parser.nextToken()
|
|
if err != nil { return }
|
|
break
|
|
|
|
} else if parser.token.Is(lexer.TokenKindNewline) {
|
|
// we are delimited, so we can safely skip
|
|
// newlines
|
|
err = parser.nextToken()
|
|
if err != nil { return }
|
|
continue
|
|
|
|
} else if parser.token.Is(lexer.TokenKindIndent) {
|
|
// we are delimited, so we can safely skip
|
|
// indents
|
|
err = parser.nextToken()
|
|
if err != nil { return }
|
|
continue
|
|
}
|
|
} else {
|
|
// not delimited
|
|
// someFunc arg1 arg2 arg3 -> someVariable
|
|
err = parser.expect(validBlockLevelPhraseTokens...)
|
|
if err != nil { return }
|
|
|
|
if parser.token.Is(lexer.TokenKindReturnDirection) {
|
|
// we've reached a return direction, so that
|
|
// means this is the end of the phrase
|
|
break
|
|
} else if parser.token.Is(lexer.TokenKindNewline) {
|
|
// we've reached the end of the line, so that
|
|
// means this is the end of the phrase.
|
|
break
|
|
}
|
|
}
|
|
|
|
// this is an argument
|
|
var argument Argument
|
|
argument, err = parser.parseArgument()
|
|
phrase.arguments = append(phrase.arguments, argument)
|
|
}
|
|
|
|
// expect newline or return direction
|
|
err = parser.expect (
|
|
lexer.TokenKindNewline,
|
|
lexer.TokenKindReturnDirection)
|
|
if err != nil { return }
|
|
expectReturnDirection := parser.token.Is(lexer.TokenKindReturnDirection)
|
|
|
|
// if we have hit a return direction, parse it...
|
|
if expectReturnDirection {
|
|
err = parser.nextToken()
|
|
if err != nil { return }
|
|
|
|
for {
|
|
err = parser.expect (
|
|
lexer.TokenKindNewline,
|
|
lexer.TokenKindName)
|
|
if err != nil { return }
|
|
// ...until we hit a newline
|
|
if parser.token.Is(lexer.TokenKindNewline) { break }
|
|
|
|
var returnTo Argument
|
|
returnTo, err = parser.parseArgument()
|
|
if err != nil { return }
|
|
|
|
phrase.returnsTo = append(phrase.returnsTo, returnTo)
|
|
}
|
|
}
|
|
|
|
err = parser.nextToken()
|
|
if err != nil { return }
|
|
|
|
// if this is a set phrase, parse initialization values under it
|
|
if phrase.kind == PhraseKindAssign {
|
|
var values Argument
|
|
values, err = parser.parseInitializationValues(indent)
|
|
|
|
if values.kind != ArgumentKindNil {
|
|
phrase.arguments = append(phrase.arguments, values)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// if this is a control flow phrase, parse block under it
|
|
isControlFlow := false
|
|
for _, kind := range controlFlowKinds {
|
|
if phrase.kind == kind {
|
|
isControlFlow = true
|
|
break
|
|
}
|
|
}
|
|
|
|
if !isControlFlow { return }
|
|
|
|
// if it is any of those, parse the block under it
|
|
phrase.block, err = parser.parseBlock(indent + 1)
|
|
|
|
return
|
|
}
|
|
|
|
// parseArgumentLevelPhrase parses a phrase that is being used as an argument to
|
|
// something. It is forbidden from using return direction, and it must be
|
|
// delimited by brackets.
|
|
func (parser *ParsingOperation) parseArgumentLevelPhrase () (
|
|
phrase Phrase,
|
|
err error,
|
|
) {
|
|
err = parser.expect(lexer.TokenKindLBracket)
|
|
if err != nil { return }
|
|
|
|
// get command
|
|
err = parser.nextToken(validPhraseStartTokens...)
|
|
if err != nil { return }
|
|
phrase.command, phrase.kind, err = parser.parsePhraseCommand()
|
|
if err != nil { return }
|
|
|
|
for {
|
|
// delimited
|
|
// [someFunc arg1 arg2 arg3] -> someVariable
|
|
err = parser.expect(validDelimitedPhraseTokens...)
|
|
if err != nil { return }
|
|
|
|
if parser.token.Is(lexer.TokenKindRBracket) {
|
|
// this is an ending delimiter
|
|
err = parser.nextToken()
|
|
if err != nil { return }
|
|
return
|
|
|
|
} else if parser.token.Is(lexer.TokenKindNewline) {
|
|
// we are delimited, so we can safely skip
|
|
// newlines
|
|
err = parser.nextToken()
|
|
if err != nil { return }
|
|
continue
|
|
|
|
} else if parser.token.Is(lexer.TokenKindIndent) {
|
|
// we are delimited, so we can safely skip
|
|
// indents
|
|
err = parser.nextToken()
|
|
if err != nil { return }
|
|
continue
|
|
}
|
|
|
|
// this is an argument
|
|
var argument Argument
|
|
argument, err = parser.parseArgument()
|
|
phrase.arguments = append(phrase.arguments, argument)
|
|
}
|
|
}
|
|
|
|
// parsePhraseCommand parses the command argument of a phrase.
|
|
func (parser *ParsingOperation) parsePhraseCommand () (
|
|
command Argument,
|
|
kind PhraseKind,
|
|
err error,
|
|
) {
|
|
if isTokenOperator(parser.token) {
|
|
err = parser.expect(operatorTokens...)
|
|
if err != nil { return }
|
|
|
|
command.location = parser.token.Location()
|
|
command.kind = ArgumentKindOperator
|
|
command.value = parser.token.Kind()
|
|
|
|
if parser.token.Is(lexer.TokenKindColon) {
|
|
kind = PhraseKindCase
|
|
} else if parser.token.Is(lexer.TokenKindAssignment) {
|
|
kind = PhraseKindAssign
|
|
} else {
|
|
kind = PhraseKindOperator
|
|
}
|
|
|
|
err = parser.nextToken()
|
|
return
|
|
}
|
|
|
|
// phrase command is not an operator, it is just a normal argument
|
|
command, err = parser.parseArgument()
|
|
if err != nil { return }
|
|
|
|
// determine semantic role of phrase
|
|
if command.kind == ArgumentKindString {
|
|
kind = PhraseKindCallExternal
|
|
|
|
} else if command.kind == ArgumentKindIdentifier {
|
|
identifier := command.value.(Identifier)
|
|
if len(identifier.trail) == 1 {
|
|
switch identifier.trail[0] {
|
|
case "loc":
|
|
kind = PhraseKindReference
|
|
case "defer":
|
|
kind = PhraseKindDefer
|
|
case "if":
|
|
kind = PhraseKindIf
|
|
case "elseif":
|
|
kind = PhraseKindElseIf
|
|
case "else":
|
|
kind = PhraseKindElse
|
|
case "switch":
|
|
kind = PhraseKindSwitch
|
|
case "while":
|
|
kind = PhraseKindWhile
|
|
case "for":
|
|
kind = PhraseKindFor
|
|
}
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|