package rui import ( "strings" "unicode" ) // DataValue interface of a data node value type DataValue interface { IsObject() bool Object() DataObject Value() string } // DataObject interface of a data object type DataObject interface { DataValue Tag() string PropertyCount() int Property(index int) DataNode PropertyByTag(tag string) DataNode PropertyValue(tag string) (string, bool) PropertyObject(tag string) DataObject SetPropertyValue(tag, value string) SetPropertyObject(tag string, object DataObject) ToParams() Params } const ( // TextNode - node is the pair "tag - text value". Syntax: = TextNode = 0 // ObjectNode - node is the pair "tag - object". Syntax: = {...} ObjectNode = 1 // ArrayNode - node is the pair "tag - object". Syntax: = [...] ArrayNode = 2 ) // DataNode interface of a data node type DataNode interface { Tag() string Type() int Text() string Object() DataObject ArraySize() int ArrayElement(index int) DataValue ArrayElements() []DataValue ArrayAsParams() []Params } /******************************************************************************/ type dataStringValue struct { value string } func (value *dataStringValue) Value() string { return value.value } func (value *dataStringValue) IsObject() bool { return false } func (value *dataStringValue) Object() DataObject { return nil } /******************************************************************************/ type dataObject struct { tag string property []DataNode } // NewDataObject create new DataObject with the tag and empty property list func NewDataObject(tag string) DataObject { obj := new(dataObject) obj.tag = tag obj.property = []DataNode{} return obj } func (object *dataObject) Value() string { return "" } func (object *dataObject) IsObject() bool { return true } func (object *dataObject) Object() DataObject { return object } func (object *dataObject) Tag() string { return object.tag } func (object *dataObject) PropertyCount() int { if object.property != nil { return len(object.property) } return 0 } func (object *dataObject) Property(index int) DataNode { if object.property == nil || index < 0 || index >= len(object.property) { return nil } return object.property[index] } func (object *dataObject) PropertyByTag(tag string) DataNode { if object.property != nil { for _, node := range object.property { if node.Tag() == tag { return node } } } return nil } func (object *dataObject) PropertyValue(tag string) (string, bool) { if node := object.PropertyByTag(tag); node != nil && node.Type() == TextNode { return node.Text(), true } return "", false } func (object *dataObject) PropertyObject(tag string) DataObject { if node := object.PropertyByTag(tag); node != nil && node.Type() == ObjectNode { return node.Object() } return nil } func (object *dataObject) setNode(node DataNode) { if len(object.property) == 0 { object.property = []DataNode{node} } else { tag := node.Tag() for i, p := range object.property { if p.Tag() == tag { object.property[i] = node return } } object.property = append(object.property, node) } } // SetPropertyValue - set a string property with tag by value func (object *dataObject) SetPropertyValue(tag, value string) { val := new(dataStringValue) val.value = value node := new(dataNode) node.tag = tag node.value = val object.setNode(node) } // SetPropertyObject - set a property with tag by object func (object *dataObject) SetPropertyObject(tag string, obj DataObject) { node := new(dataNode) node.tag = tag node.value = obj object.setNode(node) } func (object *dataObject) ToParams() Params { params := Params{} for _, node := range object.property { switch node.Type() { case TextNode: if text := node.Text(); text != "" { params[node.Tag()] = text } case ObjectNode: if obj := node.Object(); obj != nil { params[node.Tag()] = node.Object() } case ArrayNode: array := []any{} for i := 0; i < node.ArraySize(); i++ { if data := node.ArrayElement(i); data != nil { if data.IsObject() { if obj := data.Object(); obj != nil { array = append(array, obj) } } else if text := data.Value(); text != "" { array = append(array, text) } } } if len(array) > 0 { params[node.Tag()] = array } } } return params } /******************************************************************************/ type dataNode struct { tag string value DataValue array []DataValue } func (node *dataNode) Tag() string { return node.tag } func (node *dataNode) Type() int { if node.array != nil { return ArrayNode } if node.value.IsObject() { return ObjectNode } return TextNode } func (node *dataNode) Text() string { if node.value != nil { return node.value.Value() } return "" } func (node *dataNode) Object() DataObject { if node.value != nil { return node.value.Object() } return nil } func (node *dataNode) ArraySize() int { if node.array != nil { return len(node.array) } return 0 } func (node *dataNode) ArrayElement(index int) DataValue { if node.array != nil && index >= 0 && index < len(node.array) { return node.array[index] } return nil } func (node *dataNode) ArrayElements() []DataValue { if node.array != nil { return node.array } return []DataValue{} } func (node *dataNode) ArrayAsParams() []Params { result := []Params{} if node.array != nil { for _, data := range node.array { if data.IsObject() { if obj := data.Object(); obj != nil { if params := obj.ToParams(); len(params) > 0 { result = append(result, params) } } } } } return result } // ParseDataText - parse text and return DataNode func ParseDataText(text string) DataObject { if strings.ContainsAny(text, "\r") { text = strings.Replace(text, "\r\n", "\n", -1) text = strings.Replace(text, "\r", "\n", -1) } data := append([]rune(text), rune(0)) pos := 0 size := len(data) - 1 line := 1 lineStart := 0 skipSpaces := func(skipNewLine bool) { for pos < size { switch data[pos] { case '\n': if !skipNewLine { return } line++ lineStart = pos + 1 case '/': if pos+1 < size { switch data[pos+1] { case '/': pos += 2 for pos < size && data[pos] != '\n' { pos++ } pos-- case '*': pos += 3 for { if pos >= size { ErrorLog("Unexpected end of file") return } if data[pos-1] == '*' && data[pos] == '/' { break } if data[pos-1] == '\n' { line++ lineStart = pos } pos++ } default: return } } case ' ', '\t': // do nothing default: if !unicode.IsSpace(data[pos]) { return } } pos++ } } parseTag := func() (string, bool) { skipSpaces(true) startPos := pos if data[pos] == '`' { pos++ startPos++ for data[pos] != '`' { pos++ if pos >= size { ErrorLog("Unexpected end of text") return string(data[startPos:size]), false } } str := string(data[startPos:pos]) pos++ return str, true } else if data[pos] == '\'' || data[pos] == '"' { stopSymbol := data[pos] pos++ startPos++ slash := false for stopSymbol != data[pos] { if data[pos] == '\\' { pos += 2 slash = true } else { pos++ } if pos >= size { ErrorLog("Unexpected end of text") return string(data[startPos:size]), false } } if !slash { str := string(data[startPos:pos]) pos++ skipSpaces(false) return str, true } buffer := make([]rune, pos-startPos+1) n1 := 0 n2 := startPos invalidEscape := func() (string, bool) { str := string(data[startPos:pos]) pos++ ErrorLogF("Invalid escape sequence in \"%s\" (position %d)", str, n2-2-startPos) return str, false } for n2 < pos { if data[n2] != '\\' { buffer[n1] = data[n2] n2++ } else { n2 += 2 switch data[n2-1] { case 'n': buffer[n1] = '\n' case 'r': buffer[n1] = '\r' case 't': buffer[n1] = '\t' case '"': buffer[n1] = '"' case '\'': buffer[n1] = '\'' case '\\': buffer[n1] = '\\' case 'x', 'X': if n2+2 > pos { return invalidEscape() } x := 0 for i := 0; i < 2; i++ { ch := data[n2] if ch >= '0' && ch <= '9' { x = x*16 + int(ch-'0') } else if ch >= 'a' && ch <= 'f' { x = x*16 + int(ch-'a'+10) } else if ch >= 'A' && ch <= 'F' { x = x*16 + int(ch-'A'+10) } else { return invalidEscape() } n2++ } buffer[n1] = rune(x) case 'u', 'U': if n2+4 > pos { return invalidEscape() } x := 0 for i := 0; i < 4; i++ { ch := data[n2] if ch >= '0' && ch <= '9' { x = x*16 + int(ch-'0') } else if ch >= 'a' && ch <= 'f' { x = x*16 + int(ch-'a'+10) } else if ch >= 'A' && ch <= 'F' { x = x*16 + int(ch-'A'+10) } else { return invalidEscape() } n2++ } buffer[n1] = rune(x) default: str := string(data[startPos:pos]) ErrorLogF("Invalid escape sequence in \"%s\" (position %d)", str, n2-2-startPos) return str, false } } n1++ } pos++ skipSpaces(false) return string(buffer[0:n1]), true } stopSymbol := func(symbol rune) bool { if unicode.IsSpace(symbol) { return true } for _, sym := range []rune{'=', '{', '}', '[', ']', ',', ' ', '\t', '\n', '\'', '"', '`', '/'} { if sym == symbol { return true } } return false } for pos < size && !stopSymbol(data[pos]) { pos++ } endPos := pos skipSpaces(false) if startPos == endPos { //ErrorLog("empty tag") return "", true } return string(data[startPos:endPos]), true } var parseObject func(tag string) DataObject var parseArray func() []DataValue parseNode := func() DataNode { var tag string var ok bool if tag, ok = parseTag(); !ok { return nil } skipSpaces(true) if data[pos] != '=' { ErrorLogF("expected '=' after a tag name (line: %d, position: %d)", line, pos-lineStart) return nil } pos++ skipSpaces(true) switch data[pos] { case '[': node := new(dataNode) node.tag = tag if node.array = parseArray(); node.array == nil { return nil } return node case '{': node := new(dataNode) node.tag = tag if node.value = parseObject("_"); node.value == nil { return nil } return node case '}', ']', '=': ErrorLogF("Expected '[', '{' or a tag name after '=' (line: %d, position: %d)", line, pos-lineStart) return nil default: var str string if str, ok = parseTag(); !ok { return nil } node := new(dataNode) node.tag = tag if data[pos] == '{' { if node.value = parseObject(str); node.value == nil { return nil } } else { val := new(dataStringValue) val.value = str node.value = val } return node } } parseObject = func(tag string) DataObject { if data[pos] != '{' { ErrorLogF("Expected '{' (line: %d, position: %d)", line, pos-lineStart) return nil } pos++ obj := new(dataObject) obj.tag = tag obj.property = []DataNode{} for pos < size { var node DataNode skipSpaces(true) if data[pos] == '}' { pos++ skipSpaces(false) return obj } if node = parseNode(); node == nil { return nil } obj.property = append(obj.property, node) if data[pos] == '}' { pos++ skipSpaces(true) return obj } else if data[pos] != ',' && data[pos] != '\n' { ErrorLogF(`Expected '}', '\n' or ',' (line: %d, position: %d)`, line, pos-lineStart) return nil } if data[pos] != '\n' { pos++ } skipSpaces(true) for data[pos] == ',' { pos++ skipSpaces(true) } } ErrorLog("Unexpected end of text") return nil } parseArray = func() []DataValue { pos++ skipSpaces(true) array := []DataValue{} for pos < size { var tag string var ok bool skipSpaces(true) for data[pos] == ',' && pos < size { pos++ skipSpaces(true) } if pos >= size { break } if data[pos] == ']' { pos++ skipSpaces(true) return array } if tag, ok = parseTag(); !ok { return nil } if data[pos] == '{' { obj := parseObject(tag) if obj == nil { return nil } array = append(array, obj) } else { val := new(dataStringValue) val.value = tag array = append(array, val) } switch data[pos] { case ']', ',', '\n': default: ErrorLogF("Expected ']' or ',' (line: %d, position: %d)", line, pos-lineStart) return nil } /* if data[pos] == ']' { pos++ skipSpaces() return array, nil } else if data[pos] != ',' { return nil, fmt.Errorf("Expected ']' or ',' (line: %d, position: %d)", line, pos-lineStart) } pos++ skipSpaces() */ } ErrorLog("Unexpected end of text") return nil } if tag, ok := parseTag(); ok { return parseObject(tag) } return nil }