youtubebeat/vendor/github.com/elastic/beats/libbeat/common/dtfmt/prog.go

167 lines
4 KiB
Go

// Licensed to Elasticsearch B.V. under one or more contributor
// license agreements. See the NOTICE file distributed with
// this work for additional information regarding copyright
// ownership. Elasticsearch B.V. licenses this file to you under
// the Apache License, Version 2.0 (the "License"); you may
// not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
package dtfmt
import (
"errors"
"time"
)
type prog struct {
p []byte
}
const (
opNone byte = iota
opCopy1 // copy next byte
opCopy2 // copy next 2 bytes
opCopy3 // copy next 3 bytes
opCopy4 // copy next 4 bytes
opCopyShort // [op, len, content[len]]
opCopyLong // [op, len1, len, content[len1<<8 + len]]
opNum // [op, ft]
opNumPadded // [op, ft, digits]
opExtNumPadded // [op, ft, div, digits]
opZeros // [op, count]
opTwoDigit // [op, ft]
opTextShort // [op, ft]
opTextLong // [op, ft]
)
func (p prog) eval(bytes []byte, ctx *ctx, t time.Time) ([]byte, error) {
for i := 0; i < len(p.p); {
op := p.p[i]
i++
switch op {
case opNone:
case opCopy1:
bytes = append(bytes, p.p[i])
i++
case opCopy2:
bytes = append(bytes, p.p[i], p.p[i+1])
i += 2
case opCopy3:
bytes = append(bytes, p.p[i], p.p[i+1], p.p[i+2])
i += 3
case opCopy4:
bytes = append(bytes, p.p[i], p.p[i+1], p.p[i+2], p.p[i+3])
i += 4
case opCopyShort:
l := int(p.p[i])
i++
bytes = append(bytes, p.p[i:i+l]...)
i += l
case opCopyLong:
l := int(p.p[i])<<8 | int(p.p[i+1])
i += 2
bytes = append(bytes, p.p[i:i+l]...)
i += l
case opNum:
ft := fieldType(p.p[i])
i++
v, err := getIntField(ft, ctx, t)
if err != nil {
return bytes, err
}
bytes = appendUnpadded(bytes, v)
case opNumPadded:
ft, digits := fieldType(p.p[i]), int(p.p[i+1])
i += 2
v, err := getIntField(ft, ctx, t)
if err != nil {
return bytes, err
}
bytes = appendPadded(bytes, v, digits)
case opExtNumPadded:
ft, div, digits := fieldType(p.p[i]), int(p.p[i+1]), int(p.p[i+2])
i += 3
v, err := getIntField(ft, ctx, t)
if err != nil {
return bytes, err
}
bytes = appendPadded(bytes, v/div, digits)
case opZeros:
digits := int(p.p[i])
i++
for x := 0; x < digits; x++ {
bytes = append(bytes, '0')
}
case opTwoDigit:
ft := fieldType(p.p[i])
i++
v, err := getIntField(ft, ctx, t)
if err != nil {
return bytes, err
}
bytes = appendPadded(bytes, v%100, 2)
case opTextShort:
ft := fieldType(p.p[i])
i++
s, err := getTextFieldShort(ft, ctx, t)
if err != nil {
return bytes, err
}
bytes = append(bytes, s...)
case opTextLong:
ft := fieldType(p.p[i])
i++
s, err := getTextField(ft, ctx, t)
if err != nil {
return bytes, err
}
bytes = append(bytes, s...)
default:
return bytes, errors.New("unknown opcode")
}
}
return bytes, nil
}
func makeProg(b ...byte) (prog, error) {
return prog{b}, nil
}
func makeCopy(b []byte) (prog, error) {
l := len(b)
switch l {
case 0:
return prog{}, nil
case 1:
return makeProg(opCopy1, b[0])
case 2:
return makeProg(opCopy2, b[0], b[1])
case 3:
return makeProg(opCopy2, b[0], b[1], b[2])
case 4:
return makeProg(opCopy2, b[0], b[1], b[2], b[3])
}
if l < 256 {
return prog{append([]byte{opCopyShort, byte(l)}, b...)}, nil
}
if l < (1 << 16) {
l1 := byte(l >> 8)
l2 := byte(l)
return prog{append([]byte{opCopyLong, l1, l2}, b...)}, nil
}
return prog{}, errors.New("literal too long")
}