// code generated: do not modify

package lex

type Keyword int

func (K Keyword) Discard() bool {
    return false
}

var _ Token = (Keyword)(0)

type Mapper func(rune) (Mapper, Keyword)

{{define "makeMapper" -}}
    {{range $char, $sub := .Map -}}
        {{template "makeMapper" $sub}}
    {{end -}}

    func mapper{{.Id}}(char rune) (Mapper, Keyword) {
        switch char {
            {{range $char, $sub := .Map -}}
                case '{{printf "%c" $char}}'
                {{- if not (eq (toUpper $char) $char) -}}
                    , '{{printf "%c" (toUpper $char)}}'
                {{- else if not (eq (toLower $char) $char) -}}
                    , '{{printf "%c" (toLower $char)}}'
                {{- end -}}
                :
                    return mapper{{$sub.Id}}, {{if $sub.Default -}}
                        Keyword{{camelCase $sub.Default}}
                    {{- else -}}
                        InvalidKeyword
                    {{- end}}
            {{end -}}
            default:
                return nil, {{if .Default -}}
                    Keyword{{camelCase .Default}}
                {{- else -}}
                    InvalidKeyword
                {{- end}}
        }
    }
{{end -}}

{{$tokenMap := buildTokenMap .Keywords -}}

{{template "makeMapper" $tokenMap}}

type KeywordBuilder struct {
    mapper Mapper
    token  Keyword
}

func NewKeywordBuilder() *KeywordBuilder {
    return &KeywordBuilder{
        mapper: mapper{{$tokenMap.Id}},
        token:  InvalidKeyword,
    }
}

func (T *KeywordBuilder) Append(char rune) BuilderState {
    T.mapper, T.token = T.mapper(char)
    if T.mapper == nil {
        return Failed
    }
    return Ok
}

func (T *KeywordBuilder) Finish() Token {
	if T.token == InvalidKeyword {
		return nil
	}
	return T.token
}

var _ Builder = (*KeywordBuilder)(nil)

const (
    {{range $name, $words := .Keywords -}}
        Keyword{{camelCase $name}} Keyword = iota
    {{end -}}
    InvalidKeyword
)