parser

package
v0.0.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 18, 2021 License: MIT Imports: 6 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var BooleanValue = newGenericValueType(func(l *Lexer) (interface{}, error) {

	err := l.readWord()
	if err != nil {
		return nil, err
	}

	token, err := consumeValue(l)
	if err != nil {
		return nil, err
	}

	switch strings.ToLower(token.Content) {
	case "yes", "true", "ja", "oui", "si", "ita vero", "hija'", "hislah":
		return true, nil
	case "no", "false", "nein", "non", "minime", "ghobe'":
		return false, nil
	default:
		return nil, token.Errorf("Expected boolean but found %s", token.Content)
	}
})
View Source 
var ColorValue = newGenericValueType(func(l *Lexer) (interface{}, error) {

	err := l.readLine()
	if err != nil {
		return nil, err
	}

	token, err := consumeValue(l)
	if err != nil {
		return nil, err
	}

	parts := strings.Split(token.Content, " ")
	if len(parts) != 3 {
		return nil, token.Errorf("Expected vec3d but found %d parts", len(parts))
	}

	a, err := strconv.Atoi(parts[0])
	if err != nil {
		return nil, token.Errorf("Failed to parse int %s (%v)", parts[0], err)
	}

	b, err := strconv.Atoi(parts[1])
	if err != nil {
		return nil, token.Errorf("Failed to parse int %s (%v)", parts[1], err)
	}

	c, err := strconv.Atoi(parts[2])
	if err != nil {
		return nil, token.Errorf("Failed to parse int %s (%v)", parts[2], err)
	}

	if a > 255 || a < 0 || b > 255 || b < 0 || c > 255 || c < 0 {
		return nil, token.Errorf("One of these values is outside the valid range of 0-255: %d %d %d", a, b, c)
	}

	return []int{a, b, c}, nil
})
View Source 
var FlagValue = newGenericValueType(func(l *Lexer) (interface{}, error) {

	return true, nil
})
View Source 
var FloatValue = newGenericValueType(func(l *Lexer) (interface{}, error) {
	if err := l.skipWhitespace(); err != nil {
		return nil, err
	}

	if err := l.readNumber(); err != nil {
		return nil, err
	}

	token, err := consumeValue(l)
	if err != nil {
		return nil, err
	}

	value, err := strconv.ParseFloat(token.Content, 64)
	if err != nil {
		return nil, token.Errorf("Not a float: %s (%v)", token.Content, err)
	}

	return value, nil
})
View Source 
var IntegerValue = newGenericValueType(func(l *Lexer) (interface{}, error) {
	if err := l.skipWhitespace(); err != nil {
		return nil, err
	}

	if err := l.readNumber(); err != nil {
		return nil, err
	}

	token, err := consumeValue(l)
	if err != nil {
		return nil, err
	}

	value, err := strconv.Atoi(token.Content)
	if err != nil {
		return nil, token.Errorf("Not an integer: %s (%v)", token.Content, err)
	}

	return value, nil
})
View Source 
var MultilineStringValue = newGenericValueType(func(l *Lexer) (interface{}, error) {
	result, err := l.ReadMultilineText("$end_multi_text")
	if err != nil {
		return nil, err
	}

	return strings.Trim(result, " \n\t"), nil
})
View Source 
var StringFlag = newGenericValueType(func(lex *Lexer) (interface{}, error) {

	err := lex.readString()
	if err != nil {
		return nil, err
	}

	token, err := consumeValue(lex)
	if err != nil {
		return nil, err
	}

	result := strings.Trim(token.Content, " \n\t")
	return result, nil
})
View Source 
var StringValue = newGenericValueType(func(lex *Lexer) (interface{}, error) {

	err := lex.readLine()
	if err != nil {
		return nil, err
	}

	token, err := consumeValue(lex)
	if err != nil {
		return nil, err
	}

	result := strings.Trim(token.Content, " \n\t")

	return result, nil
})
View Source 
var SubsystemValue = newGenericValueType(func(l *Lexer) (interface{}, error) {
	data, err := l.readUntil(",\n")
	if err != nil {
		return nil, err
	}

	result := Subsystem{
		Name: strings.Trim(data, " \t"),
	}

	found, err := l.optionalRune(',')
	if err != nil {
		return nil, err
	}

	if !found {
		return result, nil
	}

	l.PushPosition()
	token, err := l.Next()
	if err != nil {
		return nil, err
	}

	if token.Type != Number {
		l.PopPosition()
		return result, nil
	}

	l.DropPosition()
	result.HitPercent, err = strconv.ParseFloat(token.Content, 64)
	if err != nil {
		return nil, token.Errorf("Failed to parse hit percent %s (%s)", token.Content, err)
	}

	found, err = l.optionalRune(',')
	if err != nil {
		return nil, err
	}

	if !found {
		return result, nil
	}

	l.PushPosition()
	token, err = l.Next()
	if err != nil {
		return nil, err
	}

	if token.Type != Number {
		l.PopPosition()
		return result, nil
	}
	l.DropPosition()

	result.TurnRate, err = strconv.ParseFloat(token.Content, 64)
	if err != nil {
		return nil, token.Errorf("Failed to parse turn rate %s (%s)", token.Content, err)
	}

	return result, nil
})
View Source 
var Vec3dValue = newGenericValueType(func(l *Lexer) (interface{}, error) {
	result := []float64{0, 0, 0}
	for idx := range result {
		if err := l.skipWhitespace(); err != nil {
			return nil, err
		}

		if _, err := l.optionalRune(','); err != nil {
			return nil, err
		}

		err := l.readWord()
		if err != nil {
			return nil, err
		}

		token, err := l.Next()
		if err != nil {
			return nil, err
		}

		value, err := strconv.ParseFloat(token.Content, 64)
		if err != nil {
			return nil, token.Errorf("Failed to parse float %s (%v)", token.Content, err)
		}

		result[idx] = value
	}
	return result, nil
})
View Source 
var WeaponBankList = newGenericValueType(func(l *Lexer) (interface{}, error) {
	banks := make([][]string, 0, 2)
	for {
		if err := l.skipWhitespace(); err != nil {
			return nil, err
		}

		found, err := l.optionalRune('(')
		if err != nil {
			return nil, err
		}

		if !found {
			break
		}

		b := make([]string, 0)
		for {
			if err := l.skipWhitespace(); err != nil {
				return nil, err
			}

			found, err := l.optionalRune('"')
			if err != nil {
				return nil, err
			}

			if !found {
				break
			}

			value, err := l.readUntil("\"")
			if err != nil {
				return nil, err
			}

			b = append(b, value)

			if err = l.requireRune('"'); err != nil {
				return nil, err
			}
		}

		banks = append(banks, b)
		if err = l.requireRune(')'); err != nil {
			return nil, err
		}
	}

	return banks, nil
})
View Source 
var WordValue = newGenericValueType(func(lex *Lexer) (interface{}, error) {

	err := lex.readWord()
	if err != nil {
		return nil, err
	}

	token, err := consumeValue(lex)
	if err != nil {
		return nil, err
	}

	return token.Content, nil
})

Functions

This section is empty.

Types

type ContainerChild 

type ContainerChild interface {
	ParseItem
	GetNames() []string
}

type ContainerItem 

type ContainerItem struct {
	Value             ParseItem
	Name              string
	DeprecatedMessage string
	Properties        []ContainerChild
	Multi             bool
	Required          bool
	BooleanContainer  bool
}

func (ContainerItem) GetNames 

func (c ContainerItem) GetNames() []string

func (ContainerItem) Parse 

func (c ContainerItem) Parse(lex *Lexer) (interface{}, error)

func (ContainerItem) ParseOne 

func (c ContainerItem) ParseOne(lex *Lexer, required bool) (interface{}, error)

type FixedList 

type FixedList struct {
	ValueParser ParseItem
	Size        int
}

func (FixedList) Parse 

func (i FixedList) Parse(lex *Lexer) (interface{}, error)

type Lexer 

type Lexer struct {
	// contains filtered or unexported fields
}

func NewLexer 

func NewLexer(ctx context.Context, buffer Scanner) *Lexer

func (*Lexer) DropPosition 

func (l *Lexer) DropPosition()

func (*Lexer) Errors 

func (l *Lexer) Errors() []error

func (*Lexer) Expect 

func (l *Lexer) Expect(tt TokenType, content string) error

func (*Lexer) Next 

func (l *Lexer) Next() (Token, error)

func (*Lexer) PopPosition 

func (l *Lexer) PopPosition()

func (*Lexer) PushPosition 

func (l *Lexer) PushPosition()

func (*Lexer) ReadList 

func (l *Lexer) ReadList(cb func() error) error

func (*Lexer) ReadMultilineText 

func (l *Lexer) ReadMultilineText(end string) (string, error)

func (*Lexer) Report 

func (l *Lexer) Report(e error)

func (*Lexer) ReportWarning 

func (l *Lexer) ReportWarning(e error)

func (*Lexer) ScopeInfos 

func (l *Lexer) ScopeInfos() []ScopeInfo

func (*Lexer) Warnings 

func (l *Lexer) Warnings() []error

type ParseItem 

type ParseItem interface {
	Parse(lex *Lexer) (interface{}, error)
}

type ParserError 

type ParserError struct {
	// contains filtered or unexported fields
}

func NewParserError 

func NewParserError(msg string, location [4]int) ParserError

func (ParserError) Error 

func (e ParserError) Error() string

func (ParserError) Location 

func (e ParserError) Location() [4]int

type Scanner 

type Scanner interface {
	io.RuneScanner
	io.Seeker
}

type ScopeInfo 

type ScopeInfo struct {
	HoverText string
	Start     [2]int
	End       [2]int
}

type Subsystem 

type Subsystem struct {
	Name       string
	HitPercent float64
	TurnRate   float64
}

type SwitchItem 

type SwitchItem struct {
	Items []ContainerChild
}

func (SwitchItem) GetNames 

func (i SwitchItem) GetNames() []string

func (*SwitchItem) Parse 

func (i *SwitchItem) Parse(lex *Lexer) (interface{}, error)

type Token 

type Token struct {
	Content  string
	Location [2]int
	Type     TokenType
}

func (Token) Errorf 

func (t Token) Errorf(msg string, args ...interface{}) error

func (Token) GetLabel 

func (t Token) GetLabel() string

func (Token) Range 

func (t Token) Range() [4]int

type TokenType 

type TokenType uint16
const (
	HashLabel TokenType = iota + 1
	DollarLabel
	PlusLabel
	Line
	String
	Number
	Comment
	BlockComment
	HashEnd
)

func (TokenType) String 

func (i TokenType) String() string

type ValueList 

type ValueList struct {
	ValueParser ParseItem
}

func (ValueList) Parse 

func (i ValueList) Parse(lex *Lexer) (interface{}, error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.