unicode/bidi/bracket.go - text - Git at Google

 // Copyright 2015 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 package bidi

 import (
 	"container/list"
 	"fmt"
 	"sort"
 )

 // This file contains a port of the reference implementation of the
 // Bidi Parentheses Algorithm:
 // https://www.unicode.org/Public/PROGRAMS/BidiReferenceJava/BidiPBAReference.java
 //
 // The implementation in this file covers definitions BD14-BD16 and rule N0
 // of UAX#9.
 //
 // Some preprocessing is done for each rune before data is passed to this
 // algorithm:
 //  - opening and closing brackets are identified
 //  - a bracket pair type, like '(' and ')' is assigned a unique identifier that
 //    is identical for the opening and closing bracket. It is left to do these
 //    mappings.
 //  - The BPA algorithm requires that bracket characters that are canonical
 //    equivalents of each other be able to be substituted for each other.
 //    It is the responsibility of the caller to do this canonicalization.
 //
 // In implementing BD16, this implementation departs slightly from the "logical"
 // algorithm defined in UAX#9. In particular, the stack referenced there
 // supports operations that go beyond a "basic" stack. An equivalent
 // implementation based on a linked list is used here.

 // Bidi_Paired_Bracket_Type
 // BD14. An opening paired bracket is a character whose
 // Bidi_Paired_Bracket_Type property value is Open.
 //
 // BD15. A closing paired bracket is a character whose
 // Bidi_Paired_Bracket_Type property value is Close.
 type bracketType byte

 const (
 	bpNone bracketType = iota
 	bpOpen
 	bpClose
 )

 // bracketPair holds a pair of index values for opening and closing bracket
 // location of a bracket pair.
 type bracketPair struct {
 	opener int
 	closer int
 }

 func (b *bracketPair) String() string {
 	return fmt.Sprintf("(%v, %v)", b.opener, b.closer)
 }

 // bracketPairs is a slice of bracketPairs with a sort.Interface implementation.
 type bracketPairs []bracketPair

 func (b bracketPairs) Len() int           { return len(b) }
 func (b bracketPairs) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
 func (b bracketPairs) Less(i, j int) bool { return b[i].opener < b[j].opener }

 // resolvePairedBrackets runs the paired bracket part of the UBA algorithm.
 //
 // For each rune, it takes the indexes into the original string, the class the
 // bracket type (in pairTypes) and the bracket identifier (pairValues). It also
 // takes the direction type for the start-of-sentence and the embedding level.
 //
 // The identifiers for bracket types are the rune of the canonicalized opening
 // bracket for brackets (open or close) or 0 for runes that are not brackets.
 func resolvePairedBrackets(s *isolatingRunSequence) {
 	p := bracketPairer{
 		sos:              s.sos,
 		openers:          list.New(),
 		codesIsolatedRun: s.types,
 		indexes:          s.indexes,
 	}
 	dirEmbed := L
 	if s.level&1 != 0 {
 		dirEmbed = R
 	}
 	p.locateBrackets(s.p.pairTypes, s.p.pairValues)
 	p.resolveBrackets(dirEmbed, s.p.initialTypes)
 }

 type bracketPairer struct {
 	sos Class // direction corresponding to start of sequence

 	// The following is a restatement of BD 16 using non-algorithmic language.
 	//
 	// A bracket pair is a pair of characters consisting of an opening
 	// paired bracket and a closing paired bracket such that the
 	// Bidi_Paired_Bracket property value of the former equals the latter,
 	// subject to the following constraints.
 	// - both characters of a pair occur in the same isolating run sequence
 	// - the closing character of a pair follows the opening character
 	// - any bracket character can belong at most to one pair, the earliest possible one
 	// - any bracket character not part of a pair is treated like an ordinary character
 	// - pairs may nest properly, but their spans may not overlap otherwise

 	// Bracket characters with canonical decompositions are supposed to be
 	// treated as if they had been normalized, to allow normalized and non-
 	// normalized text to give the same result. In this implementation that step
 	// is pushed out to the caller. The caller has to ensure that the pairValue
 	// slices contain the rune of the opening bracket after normalization for
 	// any opening or closing bracket.

 	openers *list.List // list of positions for opening brackets

 	// bracket pair positions sorted by location of opening bracket
 	pairPositions bracketPairs

 	codesIsolatedRun []Class // directional bidi codes for an isolated run
 	indexes          []int   // array of index values into the original string

 }

 // matchOpener reports whether characters at given positions form a matching
 // bracket pair.
 func (p *bracketPairer) matchOpener(pairValues []rune, opener, closer int) bool {
 	return pairValues[p.indexes[opener]] == pairValues[p.indexes[closer]]
 }

 const maxPairingDepth = 63

 // locateBrackets locates matching bracket pairs according to BD16.
 //
 // This implementation uses a linked list instead of a stack, because, while
 // elements are added at the front (like a push) they are not generally removed
 // in atomic 'pop' operations, reducing the benefit of the stack archetype.
 func (p *bracketPairer) locateBrackets(pairTypes []bracketType, pairValues []rune) {
 	// traverse the run
 	// do that explicitly (not in a for-each) so we can record position
 	for i, index := range p.indexes {

 		// look at the bracket type for each character
 		if pairTypes[index] == bpNone || p.codesIsolatedRun[i] != ON {
 			// continue scanning
 			continue
 		}
 		switch pairTypes[index] {
 		case bpOpen:
 			// check if maximum pairing depth reached
 			if p.openers.Len() == maxPairingDepth {
 				p.openers.Init()
 				return
 			}
 			// remember opener location, most recent first
 			p.openers.PushFront(i)

 		case bpClose:
 			// see if there is a match
 			count := 0
 			for elem := p.openers.Front(); elem != nil; elem = elem.Next() {
 				count++
 				opener := elem.Value.(int)
 				if p.matchOpener(pairValues, opener, i) {
 					// if the opener matches, add nested pair to the ordered list
 					p.pairPositions = append(p.pairPositions, bracketPair{opener, i})
 					// remove up to and including matched opener
 					for ; count > 0; count-- {
 						p.openers.Remove(p.openers.Front())
 					}
 					break
 				}
 			}
 			sort.Sort(p.pairPositions)
 			// if we get here, the closing bracket matched no openers
 			// and gets ignored
 		}
 	}
 }

 // Bracket pairs within an isolating run sequence are processed as units so
 // that both the opening and the closing paired bracket in a pair resolve to
 // the same direction.
 //
 // N0. Process bracket pairs in an isolating run sequence sequentially in
 // the logical order of the text positions of the opening paired brackets
 // using the logic given below. Within this scope, bidirectional types EN
 // and AN are treated as R.
 //
 // Identify the bracket pairs in the current isolating run sequence
 // according to BD16. For each bracket-pair element in the list of pairs of
 // text positions:
 //
 // a Inspect the bidirectional types of the characters enclosed within the
 // bracket pair.
 //
 // b If any strong type (either L or R) matching the embedding direction is
 // found, set the type for both brackets in the pair to match the embedding
 // direction.
 //
 // o [ e ] o -> o e e e o
 //
 // o [ o e ] -> o e o e e
 //
 // o [ NI e ] -> o e NI e e
 //
 // c Otherwise, if a strong type (opposite the embedding direction) is
 // found, test for adjacent strong types as follows: 1 First, check
 // backwards before the opening paired bracket until the first strong type
 // (L, R, or sos) is found. If that first preceding strong type is opposite
 // the embedding direction, then set the type for both brackets in the pair
 // to that type. 2 Otherwise, set the type for both brackets in the pair to
 // the embedding direction.
 //
 // o [ o ] e -> o o o o e
 //
 // o [ o NI ] o -> o o o NI o o
 //
 // e [ o ] o -> e e o e o
 //
 // e [ o ] e -> e e o e e
 //
 // e ( o [ o ] NI ) e -> e e o o o o NI e e
 //
 // d Otherwise, do not set the type for the current bracket pair. Note that
 // if the enclosed text contains no strong types the paired brackets will
 // both resolve to the same level when resolved individually using rules N1
 // and N2.
 //
 // e ( NI ) o -> e ( NI ) o

 // getStrongTypeN0 maps character's directional code to strong type as required
 // by rule N0.
 //
 // TODO: have separate type for "strong" directionality.
 func (p *bracketPairer) getStrongTypeN0(index int) Class {
 	switch p.codesIsolatedRun[index] {
 	// in the scope of N0, number types are treated as R
 	case EN, AN, AL, R:
 		return R
 	case L:
 		return L
 	default:
 		return ON
 	}
 }

 // classifyPairContent reports the strong types contained inside a Bracket Pair,
 // assuming the given embedding direction.
 //
 // It returns ON if no strong type is found. If a single strong type is found,
 // it returns this type. Otherwise it returns the embedding direction.
 //
 // TODO: use separate type for "strong" directionality.
 func (p *bracketPairer) classifyPairContent(loc bracketPair, dirEmbed Class) Class {
 	dirOpposite := ON
 	for i := loc.opener + 1; i < loc.closer; i++ {
 		dir := p.getStrongTypeN0(i)
 		if dir == ON {
 			continue
 		}
 		if dir == dirEmbed {
 			return dir // type matching embedding direction found
 		}
 		dirOpposite = dir
 	}
 	// return ON if no strong type found, or class opposite to dirEmbed
 	return dirOpposite
 }

 // classBeforePair determines which strong types are present before a Bracket
 // Pair. Return R or L if strong type found, otherwise ON.
 func (p *bracketPairer) classBeforePair(loc bracketPair) Class {
 	for i := loc.opener - 1; i >= 0; i-- {
 		if dir := p.getStrongTypeN0(i); dir != ON {
 			return dir
 		}
 	}
 	// no strong types found, return sos
 	return p.sos
 }

 // assignBracketType implements rule N0 for a single bracket pair.
 func (p *bracketPairer) assignBracketType(loc bracketPair, dirEmbed Class, initialTypes []Class) {
 	// rule "N0, a", inspect contents of pair
 	dirPair := p.classifyPairContent(loc, dirEmbed)

 	// dirPair is now L, R, or N (no strong type found)

 	// the following logical tests are performed out of order compared to
 	// the statement of the rules but yield the same results
 	if dirPair == ON {
 		return // case "d" - nothing to do
 	}

 	if dirPair != dirEmbed {
 		// case "c": strong type found, opposite - check before (c.1)
 		dirPair = p.classBeforePair(loc)
 		if dirPair == dirEmbed || dirPair == ON {
 			// no strong opposite type found before - use embedding (c.2)
 			dirPair = dirEmbed
 		}
 	}
 	// else: case "b", strong type found matching embedding,
 	// no explicit action needed, as dirPair is already set to embedding
 	// direction

 	// set the bracket types to the type found
 	p.setBracketsToType(loc, dirPair, initialTypes)
 }

 func (p *bracketPairer) setBracketsToType(loc bracketPair, dirPair Class, initialTypes []Class) {
 	p.codesIsolatedRun[loc.opener] = dirPair
 	p.codesIsolatedRun[loc.closer] = dirPair

 	for i := loc.opener + 1; i < loc.closer; i++ {
 		index := p.indexes[i]
 		if initialTypes[index] != NSM {
 			break
 		}
 		p.codesIsolatedRun[i] = dirPair
 	}

 	for i := loc.closer + 1; i < len(p.indexes); i++ {
 		index := p.indexes[i]
 		if initialTypes[index] != NSM {
 			break
 		}
 		p.codesIsolatedRun[i] = dirPair
 	}
 }

 // resolveBrackets implements rule N0 for a list of pairs.
 func (p *bracketPairer) resolveBrackets(dirEmbed Class, initialTypes []Class) {
 	for _, loc := range p.pairPositions {
 		p.assignBracketType(loc, dirEmbed, initialTypes)
 	}
 }
	// Copyright 2015 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	package bidi

	import (
	"container/list"
	"fmt"
	"sort"
	)

	// This file contains a port of the reference implementation of the
	// Bidi Parentheses Algorithm:
	// https://www.unicode.org/Public/PROGRAMS/BidiReferenceJava/BidiPBAReference.java
	//
	// The implementation in this file covers definitions BD14-BD16 and rule N0
	// of UAX#9.
	//
	// Some preprocessing is done for each rune before data is passed to this
	// algorithm:
	// - opening and closing brackets are identified
	// - a bracket pair type, like '(' and ')' is assigned a unique identifier that
	// is identical for the opening and closing bracket. It is left to do these
	// mappings.
	// - The BPA algorithm requires that bracket characters that are canonical
	// equivalents of each other be able to be substituted for each other.
	// It is the responsibility of the caller to do this canonicalization.
	//
	// In implementing BD16, this implementation departs slightly from the "logical"
	// algorithm defined in UAX#9. In particular, the stack referenced there
	// supports operations that go beyond a "basic" stack. An equivalent
	// implementation based on a linked list is used here.

	// Bidi_Paired_Bracket_Type
	// BD14. An opening paired bracket is a character whose
	// Bidi_Paired_Bracket_Type property value is Open.
	//
	// BD15. A closing paired bracket is a character whose
	// Bidi_Paired_Bracket_Type property value is Close.
	type bracketType byte

	const (
	bpNone bracketType = iota
	bpOpen
	bpClose
	)

	// bracketPair holds a pair of index values for opening and closing bracket
	// location of a bracket pair.
	type bracketPair struct {
	opener int
	closer int
	}

	func (b *bracketPair) String() string {
	return fmt.Sprintf("(%v, %v)", b.opener, b.closer)
	}

	// bracketPairs is a slice of bracketPairs with a sort.Interface implementation.
	type bracketPairs []bracketPair

	func (b bracketPairs) Len() int { return len(b) }
	func (b bracketPairs) Swap(i, j int) { b[i], b[j] = b[j], b[i] }
	func (b bracketPairs) Less(i, j int) bool { return b[i].opener < b[j].opener }

	// resolvePairedBrackets runs the paired bracket part of the UBA algorithm.
	//
	// For each rune, it takes the indexes into the original string, the class the
	// bracket type (in pairTypes) and the bracket identifier (pairValues). It also
	// takes the direction type for the start-of-sentence and the embedding level.
	//
	// The identifiers for bracket types are the rune of the canonicalized opening
	// bracket for brackets (open or close) or 0 for runes that are not brackets.
	func resolvePairedBrackets(s *isolatingRunSequence) {
	p := bracketPairer{
	sos: s.sos,
	openers: list.New(),
	codesIsolatedRun: s.types,
	indexes: s.indexes,
	}
	dirEmbed := L
	if s.level&1 != 0 {
	dirEmbed = R
	}
	p.locateBrackets(s.p.pairTypes, s.p.pairValues)
	p.resolveBrackets(dirEmbed, s.p.initialTypes)
	}

	type bracketPairer struct {
	sos Class // direction corresponding to start of sequence

	// The following is a restatement of BD 16 using non-algorithmic language.
	//
	// A bracket pair is a pair of characters consisting of an opening
	// paired bracket and a closing paired bracket such that the
	// Bidi_Paired_Bracket property value of the former equals the latter,
	// subject to the following constraints.
	// - both characters of a pair occur in the same isolating run sequence
	// - the closing character of a pair follows the opening character
	// - any bracket character can belong at most to one pair, the earliest possible one
	// - any bracket character not part of a pair is treated like an ordinary character
	// - pairs may nest properly, but their spans may not overlap otherwise

	// Bracket characters with canonical decompositions are supposed to be
	// treated as if they had been normalized, to allow normalized and non-
	// normalized text to give the same result. In this implementation that step
	// is pushed out to the caller. The caller has to ensure that the pairValue
	// slices contain the rune of the opening bracket after normalization for
	// any opening or closing bracket.

	openers *list.List // list of positions for opening brackets

	// bracket pair positions sorted by location of opening bracket
	pairPositions bracketPairs

	codesIsolatedRun []Class // directional bidi codes for an isolated run
	indexes []int // array of index values into the original string

	}

	// matchOpener reports whether characters at given positions form a matching
	// bracket pair.
	func (p *bracketPairer) matchOpener(pairValues []rune, opener, closer int) bool {
	return pairValues[p.indexes[opener]] == pairValues[p.indexes[closer]]
	}

	const maxPairingDepth = 63

	// locateBrackets locates matching bracket pairs according to BD16.
	//
	// This implementation uses a linked list instead of a stack, because, while
	// elements are added at the front (like a push) they are not generally removed
	// in atomic 'pop' operations, reducing the benefit of the stack archetype.
	func (p *bracketPairer) locateBrackets(pairTypes []bracketType, pairValues []rune) {
	// traverse the run
	// do that explicitly (not in a for-each) so we can record position
	for i, index := range p.indexes {

	// look at the bracket type for each character
	if pairTypes[index] == bpNone \|\| p.codesIsolatedRun[i] != ON {
	// continue scanning
	continue
	}
	switch pairTypes[index] {
	case bpOpen:
	// check if maximum pairing depth reached
	if p.openers.Len() == maxPairingDepth {
	p.openers.Init()
	return
	}
	// remember opener location, most recent first
	p.openers.PushFront(i)

	case bpClose:
	// see if there is a match
	count := 0
	for elem := p.openers.Front(); elem != nil; elem = elem.Next() {
	count++
	opener := elem.Value.(int)
	if p.matchOpener(pairValues, opener, i) {
	// if the opener matches, add nested pair to the ordered list
	p.pairPositions = append(p.pairPositions, bracketPair{opener, i})
	// remove up to and including matched opener
	for ; count > 0; count-- {
	p.openers.Remove(p.openers.Front())
	}
	break
	}
	}
	sort.Sort(p.pairPositions)
	// if we get here, the closing bracket matched no openers
	// and gets ignored
	}
	}
	}

	// Bracket pairs within an isolating run sequence are processed as units so
	// that both the opening and the closing paired bracket in a pair resolve to
	// the same direction.
	//
	// N0. Process bracket pairs in an isolating run sequence sequentially in
	// the logical order of the text positions of the opening paired brackets
	// using the logic given below. Within this scope, bidirectional types EN
	// and AN are treated as R.
	//
	// Identify the bracket pairs in the current isolating run sequence
	// according to BD16. For each bracket-pair element in the list of pairs of
	// text positions:
	//
	// a Inspect the bidirectional types of the characters enclosed within the
	// bracket pair.
	//
	// b If any strong type (either L or R) matching the embedding direction is
	// found, set the type for both brackets in the pair to match the embedding
	// direction.
	//
	// o [ e ] o -> o e e e o
	//
	// o [ o e ] -> o e o e e
	//
	// o [ NI e ] -> o e NI e e
	//
	// c Otherwise, if a strong type (opposite the embedding direction) is
	// found, test for adjacent strong types as follows: 1 First, check
	// backwards before the opening paired bracket until the first strong type
	// (L, R, or sos) is found. If that first preceding strong type is opposite
	// the embedding direction, then set the type for both brackets in the pair
	// to that type. 2 Otherwise, set the type for both brackets in the pair to
	// the embedding direction.
	//
	// o [ o ] e -> o o o o e
	//
	// o [ o NI ] o -> o o o NI o o
	//
	// e [ o ] o -> e e o e o
	//
	// e [ o ] e -> e e o e e
	//
	// e ( o [ o ] NI ) e -> e e o o o o NI e e
	//
	// d Otherwise, do not set the type for the current bracket pair. Note that
	// if the enclosed text contains no strong types the paired brackets will
	// both resolve to the same level when resolved individually using rules N1
	// and N2.
	//
	// e ( NI ) o -> e ( NI ) o

	// getStrongTypeN0 maps character's directional code to strong type as required
	// by rule N0.
	//
	// TODO: have separate type for "strong" directionality.
	func (p *bracketPairer) getStrongTypeN0(index int) Class {
	switch p.codesIsolatedRun[index] {
	// in the scope of N0, number types are treated as R
	case EN, AN, AL, R:
	return R
	case L:
	return L
	default:
	return ON
	}
	}

	// classifyPairContent reports the strong types contained inside a Bracket Pair,
	// assuming the given embedding direction.
	//
	// It returns ON if no strong type is found. If a single strong type is found,
	// it returns this type. Otherwise it returns the embedding direction.
	//
	// TODO: use separate type for "strong" directionality.
	func (p *bracketPairer) classifyPairContent(loc bracketPair, dirEmbed Class) Class {
	dirOpposite := ON
	for i := loc.opener + 1; i < loc.closer; i++ {
	dir := p.getStrongTypeN0(i)
	if dir == ON {
	continue
	}
	if dir == dirEmbed {
	return dir // type matching embedding direction found
	}
	dirOpposite = dir
	}
	// return ON if no strong type found, or class opposite to dirEmbed
	return dirOpposite
	}

	// classBeforePair determines which strong types are present before a Bracket
	// Pair. Return R or L if strong type found, otherwise ON.
	func (p *bracketPairer) classBeforePair(loc bracketPair) Class {
	for i := loc.opener - 1; i >= 0; i-- {
	if dir := p.getStrongTypeN0(i); dir != ON {
	return dir
	}
	}
	// no strong types found, return sos
	return p.sos
	}

	// assignBracketType implements rule N0 for a single bracket pair.
	func (p *bracketPairer) assignBracketType(loc bracketPair, dirEmbed Class, initialTypes []Class) {
	// rule "N0, a", inspect contents of pair
	dirPair := p.classifyPairContent(loc, dirEmbed)

	// dirPair is now L, R, or N (no strong type found)

	// the following logical tests are performed out of order compared to
	// the statement of the rules but yield the same results
	if dirPair == ON {
	return // case "d" - nothing to do
	}

	if dirPair != dirEmbed {
	// case "c": strong type found, opposite - check before (c.1)
	dirPair = p.classBeforePair(loc)
	if dirPair == dirEmbed \|\| dirPair == ON {
	// no strong opposite type found before - use embedding (c.2)
	dirPair = dirEmbed
	}
	}
	// else: case "b", strong type found matching embedding,
	// no explicit action needed, as dirPair is already set to embedding
	// direction

	// set the bracket types to the type found
	p.setBracketsToType(loc, dirPair, initialTypes)
	}

	func (p *bracketPairer) setBracketsToType(loc bracketPair, dirPair Class, initialTypes []Class) {
	p.codesIsolatedRun[loc.opener] = dirPair
	p.codesIsolatedRun[loc.closer] = dirPair

	for i := loc.opener + 1; i < loc.closer; i++ {
	index := p.indexes[i]
	if initialTypes[index] != NSM {
	break
	}
	p.codesIsolatedRun[i] = dirPair
	}

	for i := loc.closer + 1; i < len(p.indexes); i++ {
	index := p.indexes[i]
	if initialTypes[index] != NSM {
	break
	}
	p.codesIsolatedRun[i] = dirPair
	}
	}

	// resolveBrackets implements rule N0 for a list of pairs.
	func (p *bracketPairer) resolveBrackets(dirEmbed Class, initialTypes []Class) {
	for _, loc := range p.pairPositions {
	p.assignBracketType(loc, dirEmbed, initialTypes)
	}
	}