Method parseRuleStatement

pkg/dsl/parser/parser.go:301–414

parseRuleStatement is responsible for parsing a rule statement in the form: rule name(typ1 string, typ2 boolean) { EXPRESSION } This method assumes the current token points to the 'rule' token when it is called.

()

//
// This method assumes the current token points to the 'rule' token when it is called.
func (p *Parser) parseRuleStatement() (*ast.RuleStatement, error) {
	// Create a new RuleStatement
	stmt := &ast.RuleStatement{Rule: p.currentToken}

	// Expect the next token to be an identifier (the name of the rule).
	// If it's not an identifier, return an error.
	if !p.expectAndNext(token.IDENT) {
		return nil, p.Error()
	}
	stmt.Name = p.currentToken

	// Expect the next token to be a left parenthesis '(' starting the argument list.
	if !p.expectAndNext(token.LP) {
		return nil, p.Error()
	}

	arguments := map[token.Token]ast.AttributeTypeStatement{}
	args := map[string]string{}

	// Loop over the tokens until a right parenthesis ')' is encountered.
	// In each iteration, two tokens are processed: an identifier (arg name) and its type.
	for !p.peekTokenIs(token.RP) {
		// Expect the first token to be the parameter's identifier.
		if !p.expectAndNext(token.IDENT) {
			return nil, p.Error()
		}
		argument := p.currentToken
		arg := p.currentToken.Literal

		// Expect the second token to be the parameter's type.
		if !p.expectAndNext(token.IDENT) {
			return nil, p.Error()
		}

		if p.peekTokenIs(token.LSB) { // Check if the next token is '['
			arguments[argument] = ast.AttributeTypeStatement{
				Type:    p.currentToken,
				IsArray: true, // Marking the type as an array
			}
			args[arg] = p.currentToken.Literal + "[]" // Store the argument type as string with "[]" suffix
			p.next()                                  // Move to the '[' token
			if !p.expectAndNext(token.RSB) {          // Expect and move to the ']' token
				return nil, p.Error()
			}
		} else {
			arguments[argument] = ast.AttributeTypeStatement{
				Type:    p.currentToken,
				IsArray: false, // Marking the type as not an array
			}
			args[arg] = p.currentToken.Literal // Store the regular argument type
		}

		// If the next token is a comma, there are more parameters to parse.
		// Continue to the next iteration.
		if p.peekTokenIs(token.COMMA) {
			p.next()
			continue
		} else if !p.peekTokenIs(token.RP) {