167 lines
4 KiB
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")
|
|
}
|