1337 lines
33 KiB
Go
1337 lines
33 KiB
Go
package eqn
|
||
|
||
import (
|
||
"bytes"
|
||
"container/list"
|
||
"encoding/binary"
|
||
"fmt"
|
||
"github.com/extrame/ole2"
|
||
"io"
|
||
"log"
|
||
)
|
||
|
||
const oleCbHdr = uint16(28)
|
||
|
||
// [MTEFv5](https://docs.wiris.com/en/mathtype/mathtype_desktop/mathtype-sdk/mtef5)
|
||
type MTEFv5 struct {
|
||
mMtefVer uint8
|
||
mPlatform uint8
|
||
mProduct uint8
|
||
mVersion uint8
|
||
mVersionSub uint8
|
||
mApplication string
|
||
mInline uint8
|
||
|
||
reader io.ReadSeeker
|
||
|
||
ast *MtAST
|
||
nodes []*MtAST
|
||
|
||
//是否合法，顺利解析
|
||
Valid bool
|
||
}
|
||
|
||
func (m *MTEFv5) readRecord() (err error) {
|
||
/**
|
||
读取body的每一行数据并保存到数组里
|
||
*/
|
||
//默认设置为合法的，除非遇到不可解析数据
|
||
m.Valid = true
|
||
|
||
//Header
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &m.mMtefVer)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &m.mPlatform)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &m.mProduct)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &m.mVersion)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &m.mVersionSub)
|
||
m.mApplication, _ = m.readNullTerminatedString()
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &m.mInline)
|
||
|
||
//fmt.Println(m.mMtefVer, m.mPlatform, m.mProduct, m.mVersion, m.mVersionSub)
|
||
//fmt.Println(m.mInline)
|
||
//fmt.Println(m.reader)
|
||
|
||
//Body
|
||
for {
|
||
record := RecordType(0)
|
||
err = binary.Read(m.reader, binary.LittleEndian, &record)
|
||
|
||
// 根据future定义，>=100的后面会跟一个字节，这个字节代表需要跳过的长度
|
||
//For now, readers can assume that an unsigned integer follows the record type and is the number of bytes following it in the record
|
||
//This makes it easy for software that reads MTEF to skip these records.
|
||
if record >= FUTURE {
|
||
var skipFutureLength uint8
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &skipFutureLength)
|
||
|
||
_, _ = m.reader.Seek(int64(skipFutureLength), io.SeekCurrent)
|
||
continue
|
||
}
|
||
|
||
//debug 使用
|
||
//fmt.Println(record)
|
||
|
||
if err != nil {
|
||
break
|
||
}
|
||
switch record {
|
||
case END:
|
||
m.nodes = append(m.nodes, &MtAST{END, nil, nil})
|
||
case LINE:
|
||
line := new(MtLine)
|
||
_ = m.readLine(line)
|
||
|
||
m.nodes = append(m.nodes, &MtAST{LINE, line, nil})
|
||
case CHAR:
|
||
char := new(MtChar)
|
||
_ = m.readChar(char)
|
||
|
||
m.nodes = append(m.nodes, &MtAST{CHAR, char, nil})
|
||
case TMPL:
|
||
tmpl := new(MtTmpl)
|
||
_ = m.readTMPL(tmpl)
|
||
|
||
m.nodes = append(m.nodes, &MtAST{TMPL, tmpl, nil})
|
||
case PILE:
|
||
pile := new(MtPile)
|
||
_ = m.readPile(pile)
|
||
|
||
m.nodes = append(m.nodes, &MtAST{PILE, pile, nil})
|
||
case MATRIX:
|
||
matrix := new(MtMatrix)
|
||
_ = m.readMatrix(matrix)
|
||
|
||
m.nodes = append(m.nodes, &MtAST{MATRIX, matrix, nil})
|
||
|
||
//匹配矩阵数据下面的2个nil
|
||
m.nodes = append(m.nodes, &MtAST{LINE, new(MtLine), nil})
|
||
m.nodes = append(m.nodes, &MtAST{LINE, new(MtLine), nil})
|
||
case EMBELL:
|
||
embell := new(MtEmbellRd)
|
||
_ = m.readEmbell(embell)
|
||
|
||
m.nodes = append(m.nodes, &MtAST{tag: EMBELL, value: embell, children: nil})
|
||
case FONT_STYLE_DEF:
|
||
fsDef := new(MtfontStyleDef)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &fsDef.fontDefIndex)
|
||
fsDef.name, _ = m.readNullTerminatedString()
|
||
|
||
//读取字节，但是不关心数据，注释
|
||
//m.nodes = append(m.nodes, &MtAST{FONT_STYLE_DEF, fsDef, nil})
|
||
case SIZE:
|
||
mtSize := new(MtSize)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &mtSize.lsize)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &mtSize.dsize)
|
||
case SUB:
|
||
m.nodes = append(m.nodes, &MtAST{SUB, nil, nil})
|
||
case SUB2:
|
||
m.nodes = append(m.nodes, &MtAST{SUB2, nil, nil})
|
||
case SYM:
|
||
m.nodes = append(m.nodes, &MtAST{SYM, nil, nil})
|
||
case SUBSYM:
|
||
m.nodes = append(m.nodes, &MtAST{SUBSYM, nil, nil})
|
||
case FONT_DEF:
|
||
fdef := new(MtfontDef)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &fdef.encDefIndex)
|
||
fdef.name, _ = m.readNullTerminatedString()
|
||
|
||
m.nodes = append(m.nodes, &MtAST{FONT_DEF, fdef, nil})
|
||
case COLOR:
|
||
cIndex := new(MtColorDefIndex)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &cIndex.index)
|
||
|
||
//读取字节，但是不关心数据，注释
|
||
//m.nodes = append(m.nodes, &MtAST{tag: COLOR, value: cIndex, children: nil})
|
||
case COLOR_DEF:
|
||
cDef := new(MtColorDef)
|
||
_ = m.readColorDef(cDef)
|
||
|
||
//读取字节，但是不关心数据，注释
|
||
//m.nodes = append(m.nodes, &MtAST{tag: COLOR_DEF, value: cDef, children: nil})
|
||
case FULL:
|
||
m.nodes = append(m.nodes, &MtAST{FULL, nil, nil})
|
||
case EQN_PREFS:
|
||
prefs := new(MtEqnPrefs)
|
||
_ = m.readEqnPrefs(prefs)
|
||
|
||
m.nodes = append(m.nodes, &MtAST{EQN_PREFS, prefs, nil})
|
||
case ENCODING_DEF:
|
||
enc, _ := m.readNullTerminatedString()
|
||
|
||
m.nodes = append(m.nodes, &MtAST{ENCODING_DEF, enc, nil})
|
||
default:
|
||
m.Valid = false
|
||
log.Println("FUTURE RECORD", record)
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func (m *MTEFv5) readNullTerminatedString() (s string, err error) {
|
||
buf, p := bytes.Buffer{}, []byte{0}
|
||
for {
|
||
_, err = m.reader.Read(p)
|
||
if p[0] == 0 {
|
||
break
|
||
}
|
||
buf.WriteByte(p[0])
|
||
}
|
||
return buf.String(), err
|
||
}
|
||
|
||
func (m *MTEFv5) readLine(line *MtLine) (err error) {
|
||
options := OptionType(0)
|
||
err = binary.Read(m.reader, binary.LittleEndian, &options)
|
||
|
||
if MtefOptNudge == MtefOptNudge&options {
|
||
line.nudgeX, line.nudgeY, _ = m.readNudge()
|
||
}
|
||
if MtefOptLineLspace == MtefOptLineLspace&options {
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &line.lineSpace)
|
||
}
|
||
|
||
//RULER解析
|
||
if mtefOPT_LP_RULER == mtefOPT_LP_RULER&options {
|
||
var nStops uint8
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &nStops)
|
||
|
||
var tabList []uint8
|
||
for i := uint8(0); i < nStops; i++ {
|
||
var stopVal uint8
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &stopVal)
|
||
tabList = append(tabList, stopVal)
|
||
|
||
var tabOffset uint16
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &tabOffset)
|
||
}
|
||
}
|
||
|
||
if MtefOptLineNull == MtefOptLineNull&options {
|
||
line.null = true
|
||
}
|
||
|
||
return err
|
||
}
|
||
|
||
func (m *MTEFv5) readDimensionArrays(size int64) (array []string, err error) {
|
||
var flag = true
|
||
var tmpStr = new(bytes.Buffer)
|
||
var count = int64(0)
|
||
|
||
var fx = func(x uint8) {
|
||
if flag {
|
||
switch x {
|
||
case 0x00:
|
||
flag = false
|
||
tmpStr.WriteString("in")
|
||
case 0x01:
|
||
flag = false
|
||
tmpStr.WriteString("cm")
|
||
case 0x02:
|
||
flag = false
|
||
tmpStr.WriteString("pt")
|
||
case 0x03:
|
||
flag = false
|
||
tmpStr.WriteString("pc")
|
||
case 0x04:
|
||
flag = false
|
||
tmpStr.WriteString("%")
|
||
default:
|
||
fmt.Println("invalid bytes")
|
||
}
|
||
} else {
|
||
switch x {
|
||
case 0x00:
|
||
flag = false
|
||
tmpStr.WriteByte('0')
|
||
case 0x01:
|
||
flag = false
|
||
tmpStr.WriteByte('1')
|
||
case 0x02:
|
||
flag = false
|
||
tmpStr.WriteByte('2')
|
||
case 0x03:
|
||
flag = false
|
||
tmpStr.WriteByte('3')
|
||
case 0x04:
|
||
flag = false
|
||
tmpStr.WriteByte('4')
|
||
case 0x05:
|
||
flag = false
|
||
tmpStr.WriteByte('5')
|
||
case 0x06:
|
||
flag = false
|
||
tmpStr.WriteByte('6')
|
||
case 0x07:
|
||
flag = false
|
||
tmpStr.WriteByte('7')
|
||
case 0x08:
|
||
flag = false
|
||
tmpStr.WriteByte('8')
|
||
case 0x09:
|
||
flag = false
|
||
tmpStr.WriteByte('9')
|
||
case 0x0a:
|
||
flag = false
|
||
tmpStr.WriteByte('.')
|
||
case 0x0b:
|
||
flag = false
|
||
tmpStr.WriteByte('-')
|
||
case 0x0f:
|
||
flag = true
|
||
count += 1
|
||
array = append(array, tmpStr.String())
|
||
tmpStr.Reset()
|
||
default:
|
||
fmt.Println("invalid bytes")
|
||
}
|
||
}
|
||
}
|
||
|
||
for {
|
||
if count >= size {
|
||
//fmt.Println("break with size=", size)
|
||
break
|
||
}
|
||
ch := uint8(0)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &ch)
|
||
|
||
//fmt.Println("ch=", ch)
|
||
|
||
hi := (ch & 0xf0) / 16
|
||
lo := ch & 0x0f
|
||
fx(hi)
|
||
fx(lo)
|
||
}
|
||
return array, nil
|
||
}
|
||
|
||
func (m *MTEFv5) readEqnPrefs(eqnPrefs *MtEqnPrefs) (err error) {
|
||
options := uint8(0)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &options)
|
||
|
||
//sizes
|
||
size := uint8(0)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &size)
|
||
eqnPrefs.sizes, _ = m.readDimensionArrays(int64(size))
|
||
|
||
//spaces
|
||
size = 0
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &size)
|
||
eqnPrefs.spaces, _ = m.readDimensionArrays(int64(size))
|
||
|
||
//styles
|
||
size = 0
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &size)
|
||
styles := make([]byte, size)
|
||
for i := uint8(0); i < size; i++ {
|
||
c := uint8(0)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &c)
|
||
if c == 0 {
|
||
styles = append(styles, 0)
|
||
} else {
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &c)
|
||
styles = append(styles, c)
|
||
}
|
||
}
|
||
eqnPrefs.styles = styles
|
||
return nil
|
||
}
|
||
|
||
func (m *MTEFv5) readChar(char *MtChar) (err error) {
|
||
options := OptionType(0)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &options)
|
||
|
||
if MtefOptNudge == MtefOptNudge&options {
|
||
char.nudgeX, char.nudgeY, _ = m.readNudge()
|
||
}
|
||
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &char.typeface)
|
||
|
||
if MtefOptCharEncNoMtcode != MtefOptCharEncNoMtcode&options {
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &char.mtcode)
|
||
}
|
||
if MtefOptCharEncChar8 == MtefOptCharEncChar8&options {
|
||
//todo 强行设置值，有BUG。。。。。
|
||
//if char.mtcode >= 34528 {
|
||
// _ = binary.Read(m.reader, binary.LittleEndian, &char.bits16)
|
||
//}else {
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &char.bits8)
|
||
//}
|
||
}
|
||
if MtefOptCharEncChar16 == MtefOptCharEncChar16&options {
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &char.bits16)
|
||
}
|
||
|
||
//fmt.Println(char)
|
||
|
||
return nil
|
||
}
|
||
|
||
func (m *MTEFv5) readNudge() (nudgeX int16, nudgeY int16, err error) {
|
||
b1 := 0
|
||
b2 := 0
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &b1)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &b2)
|
||
|
||
if b1 == 128 || b2 == 128 {
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &nudgeX)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &nudgeY)
|
||
return nudgeX, nudgeY, err
|
||
} else {
|
||
nudgeX = int16(b1)
|
||
nudgeY = int16(b2)
|
||
return nudgeX, nudgeY, err
|
||
}
|
||
}
|
||
|
||
func (m *MTEFv5) readTMPL(tmpl *MtTmpl) (err error) {
|
||
options := OptionType(0)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &options)
|
||
|
||
if MtefOptNudge == MtefOptNudge&options {
|
||
tmpl.nudgeX, tmpl.nudgeY, _ = m.readNudge()
|
||
}
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &tmpl.selector)
|
||
|
||
// variation, 1 or 2 bytes
|
||
byte1 := uint8(0)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &byte1)
|
||
if 0x80 == byte1&0x80 {
|
||
byte2 := uint8(0)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &byte2)
|
||
tmpl.variation = (uint16(byte1) & 0x7F) | (uint16(byte2) << 8)
|
||
} else {
|
||
tmpl.variation = uint16(byte1)
|
||
}
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &tmpl.options)
|
||
return nil
|
||
}
|
||
|
||
func (m *MTEFv5) readPile(pile *MtPile) (err error) {
|
||
options := OptionType(0)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &options)
|
||
|
||
if MtefOptNudge == MtefOptNudge&options {
|
||
pile.nudgeX, pile.nudgeY, _ = m.readNudge()
|
||
}
|
||
|
||
//读取halign和valign
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &pile.halign)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &pile.valign)
|
||
|
||
return nil
|
||
}
|
||
|
||
func (m *MTEFv5) readMatrix(matrix *MtMatrix) (err error) {
|
||
options := OptionType(0)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &options)
|
||
|
||
if MtefOptNudge == MtefOptNudge&options {
|
||
matrix.nudgeX, matrix.nudgeY, _ = m.readNudge()
|
||
}
|
||
|
||
//读取valign和h_just、v_just
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &matrix.valign)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &matrix.h_just)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &matrix.v_just)
|
||
|
||
//读取rows和cols
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &matrix.rows)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &matrix.cols)
|
||
|
||
//fmt.Printf("%v", matrix)
|
||
return nil
|
||
}
|
||
|
||
func (m *MTEFv5) readEmbell(embell *MtEmbellRd) (err error) {
|
||
options := OptionType(0)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &options)
|
||
|
||
if MtefOptNudge == MtefOptNudge&options {
|
||
embell.nudgeX, embell.nudgeY, _ = m.readNudge()
|
||
}
|
||
|
||
//读取embellishment type
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &embell.embellType)
|
||
return nil
|
||
}
|
||
|
||
func (m *MTEFv5) readColorDef(colorDef *MtColorDef) (err error) {
|
||
options := OptionType(0)
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &options)
|
||
|
||
var color uint16
|
||
if mtefCOLOR_CMYK == mtefCOLOR_CMYK&options {
|
||
//CMYK，读4个值
|
||
for i := 0; i < 4; i++ {
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &color)
|
||
colorDef.values = append(colorDef.values, uint8(color))
|
||
}
|
||
} else {
|
||
// RGB，读3个值
|
||
for i := 0; i < 3; i++ {
|
||
_ = binary.Read(m.reader, binary.LittleEndian, &color)
|
||
colorDef.values = append(colorDef.values, uint8(color))
|
||
}
|
||
}
|
||
|
||
if mtefCOLOR_NAME == mtefCOLOR_NAME&options {
|
||
colorDef.name, _ = m.readNullTerminatedString()
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func (m *MTEFv5) Translate() string {
|
||
latexStr, err := m.makeLatex(m.ast)
|
||
if err != nil {
|
||
fmt.Println(err)
|
||
}
|
||
|
||
if m.Valid {
|
||
return latexStr
|
||
} else {
|
||
return ""
|
||
}
|
||
|
||
}
|
||
|
||
func (m *MTEFv5) makeAST() (err error) {
|
||
/**
|
||
根据数组生成出栈入栈结构
|
||
*/
|
||
ast := new(MtAST)
|
||
ast.tag = 0xff
|
||
ast.value = nil
|
||
m.ast = ast
|
||
|
||
stack := list.New()
|
||
stack.PushBack(ast)
|
||
|
||
for _, node := range m.nodes {
|
||
//debug 可用
|
||
//fmt.Printf("%+v %+v \n", node.tag, node.value)
|
||
|
||
switch node.tag {
|
||
case LINE:
|
||
if stack.Len() > 0 {
|
||
ele := stack.Back()
|
||
|
||
//将对象强制转为MtAST类型
|
||
parent := ele.Value.(*MtAST)
|
||
|
||
parent.children = append(parent.children, node)
|
||
}
|
||
if !node.value.(*MtLine).null {
|
||
//如果与0 <nil> 匹配，则需要入栈
|
||
stack.PushBack(node)
|
||
}
|
||
case TMPL:
|
||
if stack.Len() > 0 {
|
||
ele := stack.Back()
|
||
|
||
//将对象强制转为MtAST类型
|
||
parent := ele.Value.(*MtAST)
|
||
|
||
parent.children = append(parent.children, node)
|
||
}
|
||
|
||
//如果与0 <nil> 匹配，则需要入栈
|
||
stack.PushBack(node)
|
||
case PILE:
|
||
if stack.Len() > 0 {
|
||
ele := stack.Back()
|
||
|
||
//将对象强制转为MtAST类型
|
||
parent := ele.Value.(*MtAST)
|
||
|
||
parent.children = append(parent.children, node)
|
||
}
|
||
|
||
//如果与0 <nil> 匹配，则需要入栈
|
||
stack.PushBack(node)
|
||
case MATRIX:
|
||
if stack.Len() > 0 {
|
||
ele := stack.Back()
|
||
|
||
//将对象强制转为MtAST类型
|
||
parent := ele.Value.(*MtAST)
|
||
|
||
parent.children = append(parent.children, node)
|
||
}
|
||
|
||
//如果与0 <nil> 匹配，则需要入栈
|
||
stack.PushBack(node)
|
||
case END:
|
||
if stack.Len() > 0 {
|
||
ele := stack.Back()
|
||
stack.Remove(ele)
|
||
}
|
||
case CHAR:
|
||
if stack.Len() > 0 {
|
||
ele := stack.Back()
|
||
|
||
//将对象强制转为MtAST类型
|
||
parent := ele.Value.(*MtAST)
|
||
|
||
parent.children = append(parent.children, node)
|
||
} else if stack.Len() == 0 {
|
||
//never go there
|
||
ast.children = append(ast.children, node)
|
||
}
|
||
case EMBELL:
|
||
if stack.Len() > 0 {
|
||
//读取父节点
|
||
ele := stack.Back()
|
||
|
||
//并将对象强制转为MtAST类型
|
||
parent := ele.Value.(*MtAST)
|
||
parent.children = append(parent.children, node)
|
||
|
||
switch EmbellType(node.value.(*MtEmbellRd).embellType) {
|
||
//数据结构中，这些数据是在字符后面，但是在latex展示中某些字符需要在字符前面
|
||
//比如： $$ \hat y $$
|
||
//所以我们需要交换最后2位
|
||
case emb1DOT, embHAT, embOBAR:
|
||
if len(parent.children) >= 2 {
|
||
embellData := parent.children[len(parent.children)-1]
|
||
charData := parent.children[len(parent.children)-2]
|
||
parent.children = parent.children[:len(parent.children)-2]
|
||
|
||
parent.children = append(parent.children, embellData, charData)
|
||
}
|
||
}
|
||
}
|
||
|
||
//如果与0 <nil> 匹配，则需要入栈
|
||
stack.PushBack(node)
|
||
|
||
//case COLOR_DEF:
|
||
// /*
|
||
// 这个数据结构有3或4个（RGB或者CMYK）对应的nil，所以需要循环把每个值都push到栈里面
|
||
//
|
||
// 16 &{values:[0 0 0] name:}
|
||
// 0 <nil>
|
||
// 0 <nil>
|
||
// 0 <nil>
|
||
// */
|
||
//
|
||
// colorList := node.value.(*MtColorDef).values
|
||
// if len(colorList) > 0 {
|
||
// //读取每个color的值，然后入栈
|
||
// for _, val := range colorList {
|
||
// //如果与0 <nil> 匹配，则需要入栈
|
||
// stack.PushBack(val)
|
||
// }
|
||
// }
|
||
//case FONT_STYLE_DEF:
|
||
// /*
|
||
// 这个数据结构如下，所以需要配对6个入栈
|
||
// 8 &{fontDefIndex:1 name:}
|
||
// 0 <nil>
|
||
// 0 <nil>
|
||
// 0 <nil>
|
||
// 0 <nil>
|
||
// 0 <nil>
|
||
// 0 <nil>
|
||
// */
|
||
//
|
||
// fontIndex := node.value.(*MtfontStyleDef).fontDefIndex
|
||
// if fontIndex == 1 {
|
||
// for i := 0; i < 6; i++ {
|
||
// //如果与0 <nil> 匹配，则需要入栈
|
||
// stack.PushBack(0)
|
||
// }
|
||
// }
|
||
}
|
||
}
|
||
|
||
//m.ast.debug(0)
|
||
return nil
|
||
}
|
||
|
||
func (m *MTEFv5) makeLatex(ast *MtAST) (latex string, err error) {
|
||
/**
|
||
根据出栈入栈结构生成latex字符串
|
||
*/
|
||
|
||
buf := new(bytes.Buffer)
|
||
|
||
switch ast.tag {
|
||
case ROOT:
|
||
buf.WriteString("$$ ")
|
||
for _, _ast := range ast.children {
|
||
_latex, _ := m.makeLatex(_ast)
|
||
buf.WriteString(_latex)
|
||
}
|
||
buf.WriteString(" $$")
|
||
return buf.String(), nil
|
||
case CHAR:
|
||
mtcode := ast.value.(*MtChar).mtcode
|
||
typeface := ast.value.(*MtChar).typeface
|
||
char := string(mtcode)
|
||
|
||
//生成char的一些特殊集
|
||
hexExtend := ""
|
||
typefaceFmt := ""
|
||
switch typeface - 128 {
|
||
case fnMTEXTRA:
|
||
hexExtend = "/mathmode"
|
||
case fnSPACE:
|
||
hexExtend = "/mathmode"
|
||
case fnTEXT:
|
||
typefaceFmt = "{ \\rm{ %v } }"
|
||
}
|
||
|
||
//生成扩展字符的key
|
||
hexCode := fmt.Sprintf("%04x", mtcode)
|
||
hexKey := fmt.Sprintf("char/0x%v%v", hexCode, hexExtend)
|
||
|
||
//fmt.Println(char, hexKey)
|
||
|
||
//首先去找扩展字符
|
||
sChar, ok := Chars[hexKey]
|
||
if ok {
|
||
char = sChar
|
||
} else {
|
||
//如果char是特殊symbol，需要转义
|
||
sChar, ok := SpecialChar[char]
|
||
if ok {
|
||
char = sChar
|
||
}
|
||
}
|
||
|
||
//确定字符是否为文本，如果是文本，则需要包一层
|
||
if typefaceFmt != "" {
|
||
char = fmt.Sprintf(typefaceFmt, char)
|
||
}
|
||
|
||
buf.WriteString(char)
|
||
return buf.String(), nil
|
||
case TMPL:
|
||
//强制类型转换为MtTmpl
|
||
tmpl := ast.value.(*MtTmpl)
|
||
|
||
switch SelectorType(tmpl.selector) {
|
||
case tmANGLE:
|
||
mainAST := ast.children[0]
|
||
leftAST := ast.children[1]
|
||
rightAST := ast.children[2]
|
||
|
||
mainSlot, _ := m.makeLatex(mainAST)
|
||
leftSlot, _ := m.makeLatex(leftAST)
|
||
rightSlot, _ := m.makeLatex(rightAST)
|
||
|
||
//转成latex代码
|
||
var mainStr, leftStr, rightStr string
|
||
if mainSlot != "" {
|
||
mainStr = fmt.Sprintf("{ %v }", mainSlot)
|
||
}
|
||
if leftSlot != "" {
|
||
leftStr = fmt.Sprintf("\\left %v", leftSlot)
|
||
}
|
||
if rightSlot != "" {
|
||
rightStr = fmt.Sprintf("\\right %v", rightSlot)
|
||
}
|
||
|
||
buf.WriteString(fmt.Sprintf("%v %v %v", leftStr, mainStr, rightStr))
|
||
return buf.String(), nil
|
||
|
||
case tmPAREN:
|
||
mainAST := ast.children[0]
|
||
leftAST := ast.children[1]
|
||
rightAST := ast.children[2]
|
||
|
||
mainSlot, _ := m.makeLatex(mainAST)
|
||
leftSlot, _ := m.makeLatex(leftAST)
|
||
rightSlot, _ := m.makeLatex(rightAST)
|
||
|
||
//转成latex代码
|
||
var mainStr, leftStr, rightStr string
|
||
if mainSlot != "" {
|
||
mainStr = fmt.Sprintf("{ %v }", mainSlot)
|
||
}
|
||
if leftSlot != "" {
|
||
leftStr = fmt.Sprintf("\\left %v", leftSlot)
|
||
}
|
||
if rightSlot != "" {
|
||
rightStr = fmt.Sprintf("\\right %v", rightSlot)
|
||
}
|
||
|
||
buf.WriteString(fmt.Sprintf("%v %v %v", leftStr, mainStr, rightStr))
|
||
return buf.String(), nil
|
||
case tmBRACE:
|
||
var mainSlot, leftSlot, rightSlot string
|
||
for idx, astData := range ast.children {
|
||
if idx == 0 {
|
||
mainSlot, _ = m.makeLatex(astData)
|
||
} else if idx == 1 {
|
||
leftSlot, _ = m.makeLatex(astData)
|
||
} else {
|
||
rightSlot, _ = m.makeLatex(astData)
|
||
}
|
||
}
|
||
|
||
if rightSlot == "" {
|
||
rightSlot = "."
|
||
} else {
|
||
rightSlot = " " + rightSlot
|
||
}
|
||
|
||
//组装公式
|
||
buf.WriteString(fmt.Sprintf(
|
||
"\\left %v \\begin{array}{l} %v \\end{array} \\right%v",
|
||
leftSlot, mainSlot, rightSlot))
|
||
|
||
return buf.String(), nil
|
||
case tmBRACK:
|
||
mainAST := ast.children[0]
|
||
leftAST := ast.children[1]
|
||
rightAST := ast.children[2]
|
||
mainSlot, _ := m.makeLatex(mainAST)
|
||
if mainSlot == "" {
|
||
mainSlot = "\\space"
|
||
}
|
||
leftSlot, _ := m.makeLatex(leftAST)
|
||
rightSlot, _ := m.makeLatex(rightAST)
|
||
buf.WriteString(fmt.Sprintf("\\left%v %v \\right%v", leftSlot, mainSlot, rightSlot))
|
||
return buf.String(), nil
|
||
case tmBAR:
|
||
//读取数据 ParBoxClass
|
||
var mainSlot, leftSlot, rightSlot string
|
||
for idx, astData := range ast.children {
|
||
if idx == 0 {
|
||
mainSlot, _ = m.makeLatex(astData)
|
||
} else if idx == 1 {
|
||
leftSlot, _ = m.makeLatex(astData)
|
||
} else {
|
||
rightSlot, _ = m.makeLatex(astData)
|
||
}
|
||
}
|
||
|
||
if rightSlot == "" {
|
||
rightSlot = "."
|
||
} else {
|
||
rightSlot = " " + rightSlot
|
||
}
|
||
|
||
//转成latex代码
|
||
var mainStr, leftStr, rightStr string
|
||
if mainSlot != "" {
|
||
mainStr = fmt.Sprintf("{ %v }", mainSlot)
|
||
}
|
||
if leftSlot != "" {
|
||
leftStr = fmt.Sprintf("\\left %v", leftSlot)
|
||
}
|
||
if rightSlot != "" {
|
||
rightStr = fmt.Sprintf("\\right %v", rightSlot)
|
||
}
|
||
|
||
//组成整体公式
|
||
tmplStr := fmt.Sprintf("%v %v %v", leftStr, mainStr, rightStr)
|
||
buf.WriteString(tmplStr)
|
||
|
||
return buf.String(), nil
|
||
case tmINTERVAL:
|
||
//读取数据 ParBoxClass
|
||
mainAST := ast.children[0]
|
||
leftAST := ast.children[1]
|
||
rightAST := ast.children[2]
|
||
|
||
//读取latex数据
|
||
mainSlot, _ := m.makeLatex(mainAST)
|
||
leftSlot, _ := m.makeLatex(leftAST)
|
||
rightSlot, _ := m.makeLatex(rightAST)
|
||
|
||
//转成latex代码
|
||
var mainStr, leftStr, rightStr string
|
||
if mainSlot != "" {
|
||
mainStr = fmt.Sprintf("{ %v }", mainSlot)
|
||
}
|
||
if leftSlot != "" {
|
||
leftStr = fmt.Sprintf("\\left %v", leftSlot)
|
||
}
|
||
if rightSlot != "" {
|
||
rightStr = fmt.Sprintf("\\right %v", rightSlot)
|
||
}
|
||
|
||
//组成整体公式
|
||
tmplStr := fmt.Sprintf("%v %v %v", leftStr, mainStr, rightStr)
|
||
buf.WriteString(tmplStr)
|
||
|
||
return buf.String(), nil
|
||
case tmROOT:
|
||
mainAST := ast.children[0]
|
||
radiAST := ast.children[1]
|
||
mainSlot, _ := m.makeLatex(mainAST)
|
||
radiSlot, _ := m.makeLatex(radiAST)
|
||
buf.WriteString(fmt.Sprintf("\\sqrt[%v] { %v }", radiSlot, mainSlot))
|
||
return buf.String(), nil
|
||
case tmFRACT:
|
||
numAST := ast.children[0]
|
||
denAST := ast.children[1]
|
||
numSlot, _ := m.makeLatex(numAST)
|
||
denSlot, _ := m.makeLatex(denAST)
|
||
buf.WriteString(fmt.Sprintf("\\frac { %v } { %v }", numSlot, denSlot))
|
||
return buf.String(), nil
|
||
case tmARROW:
|
||
/*
|
||
variation symbol description
|
||
0×0000 tvAR_SINGLE single arrow
|
||
0×0001 tvAR_DOUBLE double arrow
|
||
0×0002 tvAR_HARPOON harpoon
|
||
0×0004 tvAR_TOP top slot is present
|
||
0×0008 tvAR_BOTTOM bottom slot is present
|
||
0×0010 tvAR_LEFT if single, arrow points left
|
||
0×0020 tvAR_RIGHT if single, arrow points right
|
||
0×0010 tvAR_LOS if double or harpoon, large over small
|
||
0×0020 tvAR_SOL if double or harpoon, small over large
|
||
*/
|
||
topAST := ast.children[0]
|
||
bottomAST := ast.children[1]
|
||
|
||
//读取latex数据
|
||
topSlot, _ := m.makeLatex(topAST)
|
||
bottomSlot, _ := m.makeLatex(bottomAST)
|
||
|
||
//转成latex代码
|
||
var topStr, bottomStr string
|
||
if topSlot != "" {
|
||
topStr = fmt.Sprintf("{\\mathrm{ %v }}", topSlot)
|
||
}
|
||
if bottomSlot != "" {
|
||
bottomStr = fmt.Sprintf("[\\mathrm{ %v }]", bottomSlot)
|
||
}
|
||
|
||
/*
|
||
variation转码
|
||
*/
|
||
variationsMap := make(map[uint16]string)
|
||
variationsMap[0x0000] = "single"
|
||
variationsMap[0x0001] = "double"
|
||
variationsMap[0x0002] = "harpoon"
|
||
variationsMap[0x0004] = "topSlotPresent"
|
||
variationsMap[0x0008] = "bottomSlotPresent"
|
||
variationsMap[0x0010] = "pointLeft"
|
||
variationsMap[0x0020] = "pointRight"
|
||
|
||
//有序循环
|
||
variationsCode := []uint16{0x0000, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020}
|
||
|
||
arrowStyle := "single"
|
||
latexFmt := "\\x"
|
||
for _, vCode := range variationsCode {
|
||
//如果存在掩码
|
||
if vCode&uint16(tmpl.variation) != 0 {
|
||
//判断类型，默认是single
|
||
if variationsMap[vCode] == "double" {
|
||
arrowStyle = "double"
|
||
} else if variationsMap[vCode] == "harpoon" {
|
||
arrowStyle = "harpoon"
|
||
}
|
||
|
||
if arrowStyle == "single" && variationsMap[vCode] == "pointLeft" {
|
||
latexFmt = latexFmt + "leftarrow"
|
||
} else if arrowStyle == "double" && variationsMap[vCode] == "pointLeft" {
|
||
fmt.Println("not implement double , large over small")
|
||
} else if arrowStyle == "harpoon" && variationsMap[vCode] == "pointLeft" {
|
||
fmt.Println("not implement harpoon, large over small")
|
||
}
|
||
|
||
if arrowStyle == "single" && variationsMap[vCode] == "pointRight" {
|
||
latexFmt = latexFmt + "rightarrow"
|
||
} else if arrowStyle == "double" && variationsMap[vCode] == "pointRight" {
|
||
fmt.Println("not implement double , small over large")
|
||
} else if arrowStyle == "harpoon" && variationsMap[vCode] == "pointRight" {
|
||
fmt.Println("not implement harpoon, small over large")
|
||
}
|
||
}
|
||
}
|
||
/*
|
||
variation转码 END
|
||
*/
|
||
|
||
//组成整体公式
|
||
tmplStr := fmt.Sprintf("%v %v %v", latexFmt, bottomStr, topStr)
|
||
buf.WriteString(tmplStr)
|
||
|
||
return buf.String(), nil
|
||
case tmUBAR:
|
||
//读取数据
|
||
mainAST := ast.children[0]
|
||
|
||
//读取latex数据
|
||
mainSlot, _ := m.makeLatex(mainAST)
|
||
|
||
//转成latex代码
|
||
var mainStr string
|
||
if mainSlot != "" {
|
||
mainStr = fmt.Sprintf(" {\\underline{ %v }} ", mainSlot)
|
||
}
|
||
|
||
//组成整体公式
|
||
tmplStr := fmt.Sprintf(" %v ", mainStr)
|
||
buf.WriteString(tmplStr)
|
||
|
||
//返回数据
|
||
return buf.String(), nil
|
||
case tmSUM:
|
||
//读取数据 BigOpBoxClass
|
||
var mainSlot, upperSlot, lowerSlot, operatorSlot string
|
||
for idx, astData := range ast.children {
|
||
if idx == 0 {
|
||
mainSlot, _ = m.makeLatex(astData)
|
||
} else if idx == 1 {
|
||
lowerSlot, _ = m.makeLatex(astData)
|
||
} else if idx == 2 {
|
||
upperSlot, _ = m.makeLatex(astData)
|
||
} else {
|
||
operatorSlot, _ = m.makeLatex(astData)
|
||
}
|
||
}
|
||
|
||
//转成latex代码
|
||
var mainStr, lowerStr, upperStr string
|
||
if mainSlot != "" {
|
||
mainStr = fmt.Sprintf("{ %v }", mainSlot)
|
||
}
|
||
if lowerSlot != "" {
|
||
lowerStr = fmt.Sprintf("\\limits_{ %v }", lowerSlot)
|
||
}
|
||
if upperSlot != "" {
|
||
upperStr = fmt.Sprintf("^ %v", upperSlot)
|
||
}
|
||
|
||
//组成整体公式
|
||
tmplStr := fmt.Sprintf("%v %v %v %v", operatorSlot, lowerStr, upperStr, mainStr)
|
||
buf.WriteString(tmplStr)
|
||
|
||
return buf.String(), nil
|
||
case tmLIM:
|
||
//读取数据 LimBoxClass
|
||
var mainSlot, lowerSlot, upperSlot string
|
||
for idx, astData := range ast.children {
|
||
if idx == 0 {
|
||
mainSlot, _ = m.makeLatex(astData)
|
||
} else if idx == 1 {
|
||
lowerSlot, _ = m.makeLatex(astData)
|
||
} else {
|
||
upperSlot, _ = m.makeLatex(astData)
|
||
}
|
||
}
|
||
|
||
//转成latex代码
|
||
var mainStr, lowerStr, upperStr string
|
||
if mainSlot != "" {
|
||
mainStr = fmt.Sprintf("\\mathop { %v }", mainSlot)
|
||
}
|
||
if lowerSlot != "" {
|
||
lowerStr = fmt.Sprintf("\\limits_{ %v }", lowerSlot)
|
||
}
|
||
if upperSlot != "" {
|
||
upperStr = ""
|
||
}
|
||
|
||
//组成整体公式
|
||
tmplStr := fmt.Sprintf("%v %v %v", mainStr, lowerStr, upperStr)
|
||
buf.WriteString(tmplStr)
|
||
|
||
return buf.String(), nil
|
||
case tmSUP:
|
||
subAST := ast.children[0]
|
||
supAST := ast.children[1]
|
||
subSlot, _ := m.makeLatex(subAST)
|
||
supSlot, _ := m.makeLatex(supAST)
|
||
|
||
buf.WriteString(" ^ { ")
|
||
buf.WriteString(supSlot)
|
||
buf.WriteString(" } ")
|
||
if subSlot != "" {
|
||
buf.WriteString(" { ")
|
||
buf.WriteString(subSlot)
|
||
buf.WriteString(" } ")
|
||
}
|
||
return buf.String(), nil
|
||
case tmSUB:
|
||
//读取下标和上标
|
||
subAST := ast.children[0]
|
||
supAST := ast.children[1]
|
||
|
||
//读取latex数据
|
||
subSlot, _ := m.makeLatex(subAST)
|
||
supSlot, _ := m.makeLatex(supAST)
|
||
|
||
//转成latex代码
|
||
var subFmt, supFmt string
|
||
if subSlot != "" {
|
||
subFmt = fmt.Sprintf("_{ %v }", subSlot)
|
||
}
|
||
if supSlot != "" {
|
||
supFmt = fmt.Sprintf("^{ %v }", supSlot)
|
||
}
|
||
|
||
//组成整体公式
|
||
tmplStr := fmt.Sprintf("%v %v", subFmt, supFmt)
|
||
buf.WriteString(tmplStr)
|
||
|
||
//返回数据
|
||
return buf.String(), nil
|
||
case tmSUBSUP:
|
||
//读取下标和上标
|
||
subAST := ast.children[0]
|
||
supAST := ast.children[1]
|
||
|
||
//读取latex数据
|
||
subSlot, _ := m.makeLatex(subAST)
|
||
supSlot, _ := m.makeLatex(supAST)
|
||
|
||
//转成latex代码
|
||
var subFmt, supFmt string
|
||
if subSlot != "" {
|
||
subFmt = fmt.Sprintf("_{ %v }", subSlot)
|
||
}
|
||
if supSlot != "" {
|
||
supFmt = fmt.Sprintf("^{ %v }", supSlot)
|
||
}
|
||
|
||
//组成整体公式
|
||
tmplStr := fmt.Sprintf("%v %v", subFmt, supFmt)
|
||
buf.WriteString(tmplStr)
|
||
|
||
//返回数据
|
||
return buf.String(), nil
|
||
case tmVEC:
|
||
/*
|
||
variations：
|
||
variation symbol description
|
||
0×0001 tvVE_LEFT arrow points left
|
||
0×0002 tvVE_RIGHT arrow points right
|
||
0×0004 tvVE_UNDER arrow under slot, else over slot
|
||
0×0008 tvVE_HARPOON harpoon
|
||
|
||
这个转换是通过掩码计算的：
|
||
比如variation的值是3，即0000 0000 0000 0011
|
||
|
||
对应的是0×0001和0×0002：
|
||
0000 0000 0000 0001
|
||
0000 0000 0000 0010
|
||
*/
|
||
|
||
//读取数据 HatBoxClass
|
||
mainAST := ast.children[0]
|
||
|
||
//读取latex数据
|
||
mainSlot, _ := m.makeLatex(mainAST)
|
||
|
||
//转成latex代码
|
||
var mainStr string
|
||
if mainSlot != "" {
|
||
mainStr = fmt.Sprintf("{ %v }", mainSlot)
|
||
}
|
||
|
||
/*
|
||
variation转码
|
||
*/
|
||
variationsMap := make(map[uint16]string)
|
||
variationsMap[0x0001] = "left"
|
||
variationsMap[0x0002] = "right"
|
||
variationsMap[0x0004] = "tvVE_UNDER"
|
||
variationsMap[0x0008] = "harpoonup"
|
||
|
||
//有序循环
|
||
variationsCode := []uint16{0x0001, 0x0002, 0x0004, 0x0008}
|
||
|
||
topStr := "\\overset\\"
|
||
for _, vCode := range variationsCode {
|
||
if vCode&uint16(tmpl.variation) != 0 {
|
||
topStr = topStr + variationsMap[vCode]
|
||
}
|
||
}
|
||
|
||
//如果variationCode小于8，则一定不是harpoon,那么默认就使用arrow
|
||
if tmpl.variation < 8 {
|
||
topStr = topStr + "arrow"
|
||
}
|
||
/*
|
||
variation转码 END
|
||
*/
|
||
|
||
//组成整体公式
|
||
tmplStr := fmt.Sprintf("%v %v", topStr, mainStr)
|
||
buf.WriteString(tmplStr)
|
||
|
||
return buf.String(), nil
|
||
case tmHAT:
|
||
//读取数据 HatBoxClass
|
||
mainAST := ast.children[0]
|
||
topAST := ast.children[1]
|
||
|
||
//读取latex数据
|
||
mainSlot, _ := m.makeLatex(mainAST)
|
||
topSlot, _ := m.makeLatex(topAST)
|
||
|
||
//转成latex代码
|
||
var mainStr, topStr string
|
||
if mainSlot != "" {
|
||
mainStr = fmt.Sprintf("{ %v }", mainSlot)
|
||
}
|
||
if topSlot != "" {
|
||
topStr = fmt.Sprintf(" %v ", topSlot)
|
||
}
|
||
|
||
//组成整体公式
|
||
tmplStr := fmt.Sprintf("%v %v", topStr, mainStr)
|
||
buf.WriteString(tmplStr)
|
||
|
||
return buf.String(), nil
|
||
case tmARC:
|
||
//读取数据 HatBoxClass
|
||
mainAST := ast.children[0]
|
||
topAST := ast.children[1]
|
||
|
||
//读取latex数据
|
||
mainSlot, _ := m.makeLatex(mainAST)
|
||
topSlot, _ := m.makeLatex(topAST)
|
||
|
||
//转成latex代码
|
||
var mainStr, topStr string
|
||
if mainSlot != "" {
|
||
mainStr = fmt.Sprintf("{ %v }", mainSlot)
|
||
}
|
||
if topSlot != "" {
|
||
topStr = fmt.Sprintf("\\overset %v", topSlot)
|
||
}
|
||
|
||
//组成整体公式
|
||
tmplStr := fmt.Sprintf("%v %v", topStr, mainStr)
|
||
buf.WriteString(tmplStr)
|
||
|
||
return buf.String(), nil
|
||
default:
|
||
m.Valid = false
|
||
log.Println("TMPL NOT IMPLEMENT", tmpl.selector, tmpl.variation)
|
||
}
|
||
for _, _ast := range ast.children {
|
||
_latex, _ := m.makeLatex(_ast)
|
||
buf.WriteString(_latex)
|
||
}
|
||
return buf.String(), nil
|
||
case PILE:
|
||
for idx, _ast := range ast.children {
|
||
_latex, _ := m.makeLatex(_ast)
|
||
|
||
//多个line字符串数据以 \\ 分割
|
||
if idx > 0 {
|
||
buf.WriteString(" \\\\ ")
|
||
}
|
||
|
||
buf.WriteString(_latex)
|
||
}
|
||
return buf.String(), nil
|
||
case MATRIX:
|
||
matrixCol := int(ast.value.(*MtMatrix).cols)
|
||
for idx, _ast := range ast.children {
|
||
_latex, _ := m.makeLatex(_ast)
|
||
|
||
if idx == 0 {
|
||
buf.WriteString(" \\begin{array} {} ")
|
||
continue
|
||
}
|
||
|
||
buf.WriteString(_latex)
|
||
|
||
if idx%matrixCol == 0 {
|
||
buf.WriteString(" \\\\ ")
|
||
} else {
|
||
buf.WriteString(" & ")
|
||
}
|
||
}
|
||
|
||
buf.WriteString(" \\end{array} ")
|
||
return buf.String(), nil
|
||
case LINE:
|
||
for _, _ast := range ast.children {
|
||
_latex, _ := m.makeLatex(_ast)
|
||
buf.WriteString(_latex)
|
||
}
|
||
return buf.String(), nil
|
||
case EMBELL:
|
||
embellType := EmbellType(ast.value.(*MtEmbellRd).embellType)
|
||
var embellStr string
|
||
|
||
switch embellType {
|
||
case emb1DOT:
|
||
embellStr = " \\dot "
|
||
case emb1PRIME:
|
||
embellStr = "'"
|
||
case emb2PRIME:
|
||
embellStr = "''"
|
||
case emb3PRIME:
|
||
embellStr = "'''"
|
||
case embHAT:
|
||
embellStr = " \\hat "
|
||
case embOBAR:
|
||
embellStr = " \\bar "
|
||
default:
|
||
log.Println("not implement embell:", embellType)
|
||
}
|
||
|
||
buf.WriteString(embellStr)
|
||
return buf.String(), nil
|
||
}
|
||
|
||
return "", nil
|
||
}
|
||
|
||
//[MTEF Storage](https://docs.wiris.com/en/mathtype/mathtype_desktop/mathtype-sdk/mtefstorage)
|
||
func Open(reader io.ReadSeeker) (eqn *MTEFv5, err error) {
|
||
//parse `mtef` stream from `ole` object
|
||
ole, err := ole2.Open(reader, "")
|
||
if err != nil {
|
||
fmt.Println(err)
|
||
}
|
||
|
||
dir, err := ole.ListDir()
|
||
if err != nil {
|
||
fmt.Println(err)
|
||
}
|
||
|
||
for _, file := range dir {
|
||
if "Equation Native" == file.Name() {
|
||
root := dir[0]
|
||
reader := ole.OpenFile(file, root)
|
||
|
||
hdrBuffer := make([]byte, oleCbHdr)
|
||
if _, err := reader.Read(hdrBuffer); err == nil {
|
||
hdrReader := bytes.NewReader(hdrBuffer)
|
||
var cbHdr = uint16(0)
|
||
var cbSize = uint32(0)
|
||
|
||
_ = binary.Read(hdrReader, binary.LittleEndian, &cbHdr)
|
||
if cbHdr != oleCbHdr {
|
||
return nil, err
|
||
}
|
||
|
||
//ignore `version: u32` and `cf: u16`
|
||
_, _ = hdrReader.Seek(4+2, io.SeekCurrent)
|
||
_ = binary.Read(hdrReader, binary.LittleEndian, &cbSize)
|
||
|
||
//body from `cbHdr` to `cbHdr + cbSize`
|
||
eqnBody := make([]byte, cbSize)
|
||
_, _ = reader.Seek(int64(cbHdr), io.SeekStart)
|
||
_, _ = reader.Read(eqnBody)
|
||
|
||
eqn = new(MTEFv5)
|
||
eqn.reader = bytes.NewReader(eqnBody)
|
||
_ = eqn.readRecord()
|
||
_ = eqn.makeAST()
|
||
return eqn, nil
|
||
}
|
||
|
||
return nil, err
|
||
}
|
||
}
|
||
return nil, err
|
||
}
|