libui/_doc/export/ctweights

// pseudo-go

func (f *CTFont) IsRegistered() bool {
	n := f.Attribute(kCTFontRegistrationScopeAttribute)
	if n == nil {
		return false
	}
	return n.(*CFNumber).Uint32Value() == kCTFontManagerScopeNone
}

// this type is in libFontRegistry.dylib; functions like x_list.Prepend() are called things like x_list_prepend() there
type x_list struct {
	Data		interface{}
	Next		*x_list
}

func (x *x_list) Prepend(data interface{}) *x_list {
	y := malloc(sizeof (x_list))
	if y != nil {
		y.data = data
		y.next = x
		return y
	}
	return x
}

func (x *x_list) Reverse() *x_list {
	if x == nil {
		return nil
	}

	var old, next *x_list

	next = nil
	for {
		old = x
		x = old.next
		old.next = next
		next = old
		if x == nil {
			break
		}
	}
	return old
}

func (x *x_list) Concat(y *x_list) *x_list {
	if x == nil {
		return y
	}
	start := x
	z := x
	for {
		x = z
		z = z.next
		if z == nil {
			break
		}
	}
	x.next = y
	return start
}

// based on CoreGraphics dylib's _CGFontCopyName
// note that this is different from the public API function CGFontCopyPostScriptName() (which is font type-independent)
// also note that in reality these keys are strings but the implementation of the function turns them into ints and only uses them as such
const (
	kCGFontNameKeyPostScriptName = 0x6
	kCGFontNameKeyPreferredSubfamily = 0x11
	kCGFontNameKeyFontSubfamily = 0x2
	kCGFontNameKeyFullName = 0x4
	kCGFontNameKeyPreferredFamily = 0x10
	kCGFontNameKeyFontFamily = 0x1
)
func (f *CGFont) CopyName(key int) (string, bool) {
	table := f.TableForTag('name')
	b := table.Bytes()
	n := table.Len()

	// this code looks weird, but we're imitating the assembly, or the effective effects thereof
	offCount := uint16(0)
	offStringOffset := uint16(2)
	if n > 1 {
		offCount = 2
		offStringOffset = 4
	}

	count := uint16(0)
	if int(offCount) <= n {
		count = uint16be(b[offCount:offCount + 2])
	}

	offNameRecord := offStringOffset + 2
	stringOffset := uint16(0)
	if int(offNameRecord) <= n {
		stringOffset = uint16be(b[offStringOffset:offStringOffset + 2])
	}

	type NameRecord struct {
		PlatformID		uint16
		PlatformSpecificID	uint16
		LanguageID		uint16
		NameID			uint16
		Length			uint16
		Offset			uint16
	}

	var nameList *x_list

	addrStrings := offNameRecords + (12 * count)
	if addrStrings != stringOffset {
		goto hasLanguageTags
	}
	pos := offNameRecords
	if count == 0 {
		// TODO note assembly logic here
	} else {
		for {
			var nr NameRecord

			nr.PlatformID = 0
			next := pos + 2
			if int(next) <= n {
				nr.PlatformID = uint16be(b[pos:pos + 2])
				pos = next
			}

			nr.PlatformSpecificID = 0
			next = pos + 2
			if int(next) <= n {
				nr.PlatformSpecificID = uint16be(b[pos:pos + 2])
				pos = next
			}

			nr.LanguageID = 0
			next = pos + 2
			if int(next) <= n {
				nr.LanguageID = uint16be(b[pos:pos + 2])
				pos = next
			}

			nr.NameID = 0
			next = pos + 2
			if int(next) <= n {
				nr.NameID = uint16be(b[pos:pos + 2])
				pos = next
			}

			nr.Length = 0
			next = pos + 2
			if int(next) <= n {
				nr.Length = uint16be(b[pos:pos + 2])
				pos = next
			}

			nr.Offset = 0
			next = pos + 2
			if int(next) <= n {
				nr.Offset = uint16be(b[pos:pos + 2])
				pos = next
			}

			strpos := stringOffset + nr.Offset
			if strpos >= n {
				// TODO put comment about imitating the assembly comparisons here
			} else {
				realLen := nr.Length
				strend = strpos + nr.Length
				if strend > n {
					realLen = nr.Length - strpos
					strend = strpos + realLen
				}
				b := malloc(12 + realLen + 1)
				if b != nil {
					name := (*sfnt_name_t)(b)
					name.PlatformID = nr.PlatformID
					name.PlatformSpecificID = nr.PlatformSpecificID
					name.LanguageID = nr.LanguageID
					name.NameID = nr.NameID
					name.Length = realLen
					memcpy(&(name.Name), b[strpos:strend], realLen)
					name.Name[realLen] = 0
					nameList = nameList.Prepend(name)
				}
			}
			count--
			if count == 0 {
				break
			}
		}
	}
	nameList = nameList.Reverse()

hasLanguageTags:
	add_localized_names := func(platformID uint16, platformSpecificID uint16, to *x_list) *x_list {
		out := (*x_list)(nil)
		if nameList == nil {
			xx TODO logic verbatim etc.
		} else {
			x := nameList
			for {
				name := (*sfnt_name_t)(x.data)
				if name.PlatformID != platformID {
					xx TODO
				} else {
					if platformSpecificID == 0xFFFF || name.PlatformSpecificID == platformSpecificID {
						out = out.Prepend(name)
					}
				}
				x = x.next
				if x == nil {
					break
				}
			}
		}
		out = out.Reverse()
		return to.Concat(out)
	}
	localized := (*x_list)(nil)
	localized = add_localized_names(0x1, 0xFFFF, localized)
	localized = add_localized_names(0, 0xFFFF, localized)
	localized = add_localized_names(0x3, 0xFFFF, localized)
	localized = add_localized_names(0x1, 0, localized)
	localized = add_localized_names(0x3, 0x9, localized)
	localized = add_localized_names(0x3, 0x409, localized)

	sysLocale := CFLocaleGetSystem()
	
}

// based on libFontRegistry.dylib's __ZNK8OS2Table15DetermineWeightERf — OS2Table::DetermineWeight(float&) const
func RegistryDetermineOS2Weight(table *CFData) (float32, bool) {
	if table == nil {
		return 0, false
	}
	if table.Len() < 78 {
		return 0, false
	}

	b := table.Bytes()
	usWeightClass := uint16be(b[4:6])
	if usWeightClass >= 10 {
		// do nothing; we are preserving the original asm comparisons
	} else {
		usWeightClass *= 100
	}
	/* TODO:
000000000000b37e         mov        dx, word [rax+4]
000000000000b382         mov        cx, dx
000000000000b385         rol        cx, 0x8
000000000000b389         movzx      esi, cx
000000000000b38c         imul       ecx, ecx, 100
000000000000b38f         cmp        esi, 10
000000000000b392         cmovae     cx, si
000000000000b396         test       dx, dx
000000000000b399         cmove      cx, si
	what's the function of the last two instructions? */

	// note that this is an unsigned comparison, so underflow will result in a number > 998
	// the effect is the same as (usWeightClass == 0) || (usWeightClass >= 1000)
	if (usWeightClass - 1) > 998 {
		// note the - 2 here; the switch cases below reflect that!
		// also note that b[0x22] and panose will be unsigned, so underflow will result in a number > 9
		panose := b[0x22] - 2
		if panose > 9 {
			return 0, false
		}
		switch panose {
		case 0:
			return float32as(-0.500000, 0xbf000000), true
		case 1:
			return float32as(-0.400000, 0xbecccccd), true
		case 2:
			// yes, this returns false; I don't know why
			return float32as(-0.300000, 0xbe99999a), false
		case 3:
			return float32as(-0.230000, 0xbe6b851f), true
		case 4:
			return float32as(0.230000, 0x3e6b851f), true
		case 5:
			return float32as(0.250000, 0x3e800000), true
		case 6:
			return float32as(0.400000, 0x3ecccccd), true
		case 7:
			return float32as(0.560000, 0x3f0f5c29), true
		case 8:
			return float32as(0.620000, 0x3f1eb852), true
		case 9:
			return float32as(0.800000, 0x3f4ccccd), true
		}
		// should not reach here
	}

	// let's mimic the assembly here too
	// the gotos avoid the massive if nesting
	// also note I'm using Go idioms and not saying "else return", imagine those if you must
	if usWeightClass > 100 {
		if usWeightClass > 200 {
			goto do201AndUp
		}
		return float32as(-0.500000, 0xbf000000), true
	}
	return float32as(-0.800000, 0xbf4ccccd), true

do201AndUp:
	if usWeightClass > 300 {
		if usWeightClass > 400 {
			goto do401AndUp
		}
		return float32as(0.000000, 0x0), true
	}
	return float32as(-0.400000, 0xbecccccd), true

do401AndUp:
	if usWeightClass > 500 {
		if usWeightClass > 600 {
			goto do601AndUp
		}
		return float32as(0.250000, 0x3e800000), true
	}
	return float32as(0.230000, 0x3e6b851f), true

do601AndUp:
	if usWeightClass > 700 {
		if usWeightClass > 800 {
			goto do801AndUp
		}
		return float32as(0.500000, 0x3f000000), true
	}
	return float32as(0.400000, 0x3ecccccd), true

do801AndUp:
	if usWeightClass > 900 {
		if usWeightClass > 950 {
			return float32(0.800000, 0x3f4ccccd), true
		}
		return float32(0.750000, 0x3f400000), true
	}
	return float32as(0.620000, 0x3f1eb852), true
}

// based on libFontRegistry.dylib's __ZN11TFontTraitsC2EP6CGFontRK13TFontMetadata — TFontTraits::TFontTraits(CGFont*, TFontMetadata const&)
func (f *Font) WeightFromFontRegistry32() float32 {
	var weight float32
	var hasWeight bool = false

	cgfont := f.CGFont()
	if f.RegistryHasMetadata() {
		wv := f.RegistryMetadataValueForKey("MTD_Typeface_Weight_VisualDescriptor")
		if wv != nil {
			if wn, ok := wv.(string); ok {
				// note: uses CFStringCompare(0)
				switch wn {
				case "reg":
					weight = float32as(0.000000, 0x0)
					hasWeight = true
				case "semi":
					weight = float32as(0.300000, 0x3e99999a)
					hasWeight = true
				case "bold":
					weight = float32as(0.400000, 0x3ecccccd)
					hasWeight = true
				case "light":
					weight = float32as(-0.400000, 0xbecccccd)
					hasWeight = true
				case "med":
					weight = float32as(0.230000, 0x3e6b851f)
					hasWeight = true
				case "heavy":
					weight = float32as(0.560000, 0x3f0f5c29)
					hasWeight = true
				case "black":
					weight = float32as(0.620000, 0x3f1eb852)
					hasWeight = true
				case "thin":
					weight = float32as(-0.600000, 0xbf19999a)
					hasWeight = true
				case "ulight":
					weight = float32as(-0.800000, 0xbf4ccccd)
					hasWeight = true
				}
			}
		}
	}

	cgpsname, ok := cgfont.CopyName(kCGFontNameKeyPostScriptName)
	if ok {
		// note: uses CFStringCompare(0)
		switch cgpsname {
		case "LucidaGrande",
			".LucidaGrandeUI",
			".Keyboard":
			weight = float32as(0.000000, 0x0)
			hasWeight = true
		case "STHeiti":
			weight = float32as(0.240000, 0x3e75c28f)
			hasWeight = true
		case "STXihei":
			weight = float32as(-0.100000, 0xbdcccccd)
			hasWeight = true
		case "TimesNewRomanPSMT":
			weight = float32as(0.000000, 0x0)
			hasWeight = true
		}
	}

	styleGlossaryStrings := []int{
		kCGFontNameKeyPreferredSubfamily,
		kCGFontNameKeyFontSubfamily,
		kCGFontNameKeyFullName,
		kCGFontNameKeyPreferredFamily,
		kCGFontNameKeyFontFamily,
	}
	weightNameMap := []struct {
		key		string
		val		float32
	}{
		{ "Ultra Light", float32as(-0.800000f, 0xbf4ccccd) },
		{ "Ultra Black", float32as(0.750000f, 0x3f400000) },
		{ "Extra Light", float32as(-0.500000f, 0xbf000000) },
		{ "UltraBlack", float32as(0.750000f, 0x3f400000) },
		{ "ExtraBlack", float32as(0.800000f, 0x3f4ccccd) },
		{ "UltraLight", float32as(-0.800000f, 0xbf4ccccd) },
		{ "ExtraLight", float32as(-0.500000f, 0xbf000000) },
		{ "Ultra Thin", float32as(-0.800000f, 0xbf4ccccd) },
		{ "Extra Thin", float32as(-0.800000f, 0xbf4ccccd) },
		{ "Heavy Face", float32as(0.560000f, 0x3f0f5c29) },
		{ "Semi Light", float32as(-0.200000f, 0xbe4ccccd) },
		{ "Extra Bold", float32as(0.500000f, 0x3f000000) },
		{ "Ultra Bold", float32as(0.700000f, 0x3f333333) },
		{ "HeavyFace", float32as(0.560000f, 0x3f0f5c29) },
		{ "ExtraBold", float32as(0.500000f, 0x3f000000) },
		{ "UltraBold", float32as(0.700000f, 0x3f333333) },
		{ "Ext Black", float32as(0.800000f, 0x3f4ccccd) },
		{ "SemiLight", float32as(-0.200000f, 0xbe4ccccd) },
		{ "Demi Bold", float32as(0.250000f, 0x3e800000) },
		{ "Semi Bold", float32as(0.300000f, 0x3e99999a) },
		{ "Ext Light", float32as(-0.500000f, 0xbf000000) },
		{ "Ext Bold", float32as(0.500000f, 0x3f000000) },
		{ "DemiBold", float32as(0.250000f, 0x3e800000) },
		{ "SemiBold", float32as(0.300000f, 0x3e99999a) },
		{ "HairLine", float32as(-0.800000f, 0xbf4ccccd) },
		{ "Ext Thin", float32as(-0.800000f, 0xbf4ccccd) },
		{ "Medium", float32as(0.230000f, 0x3e6b851f) },
		{ "Poster", float32as(0.800000f, 0x3f4ccccd) },
		{ "Light", float32as(-0.400000f, 0xbecccccd) },
		{ "Ultra", float32as(0.500000f, 0x3f000000) },
		{ "Heavy", float32as(0.560000f, 0x3f0f5c29) },
		{ "Extra", float32as(0.500000f, 0x3f000000) },
		{ "Black", float32as(0.620000f, 0x3f1eb852) },
		{ "Super", float32as(0.620000f, 0x3f1eb852) },
		{ "Obese", float32as(0.850000f, 0x3f59999a) },
		{ "Lite", float32as(-0.400000f, 0xbecccccd) },
		{ "Book", float32as(-0.230000f, 0xbe6b851f) },
		{ "Demi", float32as(0.250000f, 0x3e800000) },
		{ "Semi", float32as(0.300000f, 0x3e99999a) },
		{ "Thin", float32as(-0.500000f, 0xbf000000) },
		{ "Bold", float32as(0.400000f, 0x3ecccccd) },
		{ "Nord", float32as(0.800000f, 0x3f4ccccd) },
		{ "Fat", float32as(0.750000f, 0x3f400000) },
		{ "W1", float32as(-0.230000f, 0xbe6b851f) },
		{ "W2", float32as(-0.500000f, 0xbf000000) },
		{ "W3", float32as(-0.230000f, 0xbe6b851f) },
		{ "W4", float32as(0.000000f, 0x0) },
		{ "W5", float32as(0.230000f, 0x3e6b851f) },
		{ "W6", float32as(0.300000f, 0x3e99999a) },
		{ "W7", float32as(0.440000f, 0x3ee147ae) },
		{ "W8", float32as(0.540000f, 0x3f0a3d71) },
		{ "W9", float32as(0.620000f, 0x3f1eb852) },
	}
	for _, key := range styleGlossaryStrings {
		if hasWeight {
			break
		}
		str, ok := cgfont.CopyName(key)
		if !ok {
			continue
		}
		for _, m := range weightNameMap {
			if str.FindWithOptions(m.key, CFRangeMake(0, str.CFStringLength()), kCFCompareCaseInsensitive | kCFCompareBackwards | kCFCompareNonliteral, nil) {
				weight = m.val
				hasWeight = true
				break
			}
		}
	}

	if !hasWeight {
		os2table := cgfont.TableForTag('OS/2')
		weight, hasWeight = RegistryDetermineOS2Weight(os2table)
	}

	if !hasWeight {
		headtable := cgfont.TableForTag('head')
		if headtable != nil {
			if headtable.Len() >= 54 {
				b := headtable.Bytes()
				if (b[0x2d] & 1) != 0 {
					weight = float32as(0.400000, 0x3ecccccd)
					hasWeight = true
				}
			}
		}
	}

	styleGlossaryAbbreviationKeys := []int{
		kCGFontNameKeyPreferredSubfamily,
		kCGFontNameKeyFontSubfamily,
	}
	abbreviatedWeightNameMap := []struct {
		key		string
		val		float32
	}{
		{ "EL", float32as(-0.200000, 0xbe4ccccd) },
		{ "EB", float32as(0.500000, 0x3f000000) },
		{ "SB", float32as(0.300000, 0x3e99999a) },
		{ "UH", float32as(0.800000, 0x3f4ccccd) },
		{ "U", float32as(0.700000, 0x3f333333) },
		{ "L", float32as(-0.400000, 0xbecccccd) },
		{ "H", float32as(0.560000, 0x3f0f5c29) },
		{ "B", float32as(0.400000, 0x3ecccccd) },
		{ "M", float32as(0.230000, 0x3e6b851f) },
		{ "R", float32as(0.000000, 0x0) },
	}
	if !hasWeight {
		for _, key := range styleGlossaryAbbreviationStrings {
			str, ok := cgfont.CopyName(key)
			if !ok {
				continue
			}
			for _, m := range abbreviatedWeightNameMap {
				if str.Compare(m.key, kCFCompareCaseInsensitive) == kCFCompareEqualTo {
					weight = m.val
					hasWeight = true
					break
				}
			}
			if hasWeight {
				break
			}
		}
	}

	if !hasWeight {
		return float32as(0.000000, 0x0)
	}
	return weight
}

// because Core Text gets registry traits as a CFDictionary, convert the float to a double with CFNumber as that is what actually would be done
func (f *Font) WeightFromFontRegistry() float64 {
	return CFNumberWithFloat32(f.WeightFromFontRegistry32()).Float64Value()
}

// based on CoreText dylib's __Z13WeightOfClasst — WeightOfClass(unsigned short)
func CoreText_WeightOfClass(usWeightClass uint16) float64 {
	if usWeightClass >= 11 {
		// do nothing; we are preserving the original asm comparisons
		// and yes, this one is 11, but the one above is 10
	} else {
		usWeightClass *= 100
	}

	// figure out what two floats our weight will be between
	i := usWeightClass / 100
	j := i + 1
	if j > 10 {
		j = 10
	}
	b := float64(i * 100)
	c := float64(j * 100)

	a := float64(0)
	if b != c {
		a = float64(usWeightClass)
		a -= b
		c -= b
		a /= c
	}
	scales := []float32{
		float32as(-1.000000, 0xbf800000),
		float32as(-0.700000, 0xbf333333),
		float32as(-0.500000, 0xbf000000),
		float32as(-0.230000, 0xbe6b851f),
		float32as(0.000000, 0x0),
		float32as(0.200000, 0x3e4ccccd),
		float32as(0.300000, 0x3e99999a),
		float32as(0.400000, 0x3ecccccd),
		float32as(0.600000, 0x3f19999a),
		float32as(0.800000, 0x3f4ccccd),
		float32as(1.000000, 0x3f800000),
	}
	c = float64(scale[i])
	b = float64[scale[j])
	return fma(a, b, c)
}

// based on CoreText dylib's __ZL33CreateTraitsByStyleGlossaryStringPK10__CFString — CreateTraitsByStyleGlossaryString(__CFString const*)
func CoreText_WeightByStyleGlossaryString(str string) (weight float64, ok bool) {
	str.Fold(kCFCompareCaseInsensitive, nil)
	weightNameMap := []struct {
		key		string
		val		float32
	}{
		{ "ultra light", float32as(-0.800000, 0xbf4ccccd) },
		{ "ultra black", float32as(0.750000, 0x3f400000) },
		{ "extra light", float32as(-0.500000, 0xbf000000) },
		{ "ultralight", float32as(-0.800000, 0xbf4ccccd) },
		{ "ultrablack", float32as(0.750000, 0x3f400000) },
		{ "extrablack", float32as(0.800000, 0x3f4ccccd) },
		{ "extralight", float32as(-0.500000, 0xbf000000) }
		{ "heavy face", float32as(0.560000, 0x3f0f5c29) },
		{ "semi light", float32as(-0.200000, 0xbe4ccccd) },
		{ "extra bold", float32as(0.500000, 0x3f000000) },
		{ "ultra bold", float32as(0.700000, 0x3f333333) },
		{ "heavyface", float32as(0.560000, 0x3f0f5c29) },
		{ "extrabold", float32as(0.500000, 0x3f000000) },
		{ "ultrabold", float32as(0.700000, 0x3f333333) },
		{ "semilight", float32as(-0.200000, 0xbe4ccccd) },
		{ "demi bold", float32as(0.250000, 0x3e800000) },
		{ "semi bold", float32as(0.300000, 0x3e99999a) },
		{ "demibold", float32as(0.250000, 0x3e800000) },
		{ "semibold", float32as(0.300000, 0x3e99999a) },
		{ "hairline", float32as(-0.700000, 0xbf333333) },
		{ "medium", float32as(0.230000, 0x3e6b851f) },
		{ "poster", float32as(0.800000, 0x3f4ccccd) },
		{ "light", float32as(-0.400000, 0xbecccccd) },
		{ "heavy", float32as(0.560000, 0x3f0f5c29) },
		{ "extra", float32as(0.500000, 0x3f000000) },
		{ "black", float32as(0.620000, 0x3f1eb852) },
		{ "super", float32as(0.620000, 0x3f1eb852) },
		{ "obese", float32as(0.850000, 0x3f59999a) },
		{ "lite", float32as(-0.400000, 0xbecccccd) },
		{ "book", float32as(-0.230000, 0xbe6b851f) },
		{ "demi", float32as(0.250000, 0x3e800000) },
		{ "semi", float32as(0.300000, 0x3e99999a) },
		{ "thin", float32as(-0.500000, 0xbf000000) },
		{ "bold", float32as(0.400000, 0x3ecccccd) },
		{ "nord", float32as(0.800000, 0x3f4ccccd) },
		{ "fat", float32as(0.750000, 0x3f400000) },
		{ "w1", float32as(-0.700000, 0xbf333333) },
		{ "w2", float32as(-0.500000, 0xbf000000) },
		{ "w3", float32as(-0.230000, 0xbe6b851f) },
		{ "w4", float32as(0.000000, 0x0) },
		{ "w5", float32as(0.230000, 0x3e6b851f) },
		{ "w6", float32as(0.300000, 0x3e99999a) },
		{ "w7", float32as(0.440000, 0x3ee147ae) },
		{ "w8", float32as(0.540000, 0x3f0a3d71) },
		{ "w9", float32as(0.620000, 0x3f1eb852) },
	}
	for _, m := range weightNameMap {
		if strstr(str, m.key) != nil {
			val := CFNumberWithFloat32(m.val)
			return val.Float64Value(), true
		}
	}
	return 0, false
}

// based on CoreText dylib's __ZNK9TBaseFont29CreateTraitsValuesPerFontInfoEP12MetadataFlag — TBaseFont::CreateTraitsValuesPerFontInfo(MetadataFlag*) const
func (f *CTFont) Weight() float64 {
	if f.IsRegistered() {
		return f.WeightFromFontRegistry()
	}

	weight := float64as(2.0, 0x4000000000000000)
	ebx := -1
	hasWeight := false

	name := f.Name(kCTFontPostScriptNameKey)
	if name != nil {
		switch *name {
		case "LucidaGrande":
			weight = float64as(0.000000, 0x0)
			hasWeight = true
		case ".LucidaGrandeUI":
			weight = float64as(0.000000, 0x0)
			hasWeight = true
		case "STHeiti":
			weight = float64as(0.240000, 0x3fceb851eb851eb8)
			hasWeight = true
		case "STXihei":
			weight = float64as(-0.100000, 0xbfb999999999999a)
			hasWeight = true
		case "TimesNewRomanPSMT":
			weight = float64as(0.000000, 0x0)
			hasWeight = true
		// there is one more hardcoded case, for "Times-Roman", but that will only set the class style, not the weight
		}
	}

	os2table := f.Table('OS/2')
	if os2table != nil {
		if !hasWeight {
			var usWeightClass uint16

			valid := false
			if os2table.Len() > 77 {
				b := os2table.Bytes()
				usWeightClass = uint16be(b[4:6])
				if usWeightClass > 1000 {
					weight = 0
					hasWeight = false
				} else {
					valid = true
				}
			} else {
				usWeightClass = 0
				valid = true
			}
			if valid {
				weight = CoreText_WeightOfClass(usWeightClass)
				hasWeight = true
			}
		}
	}

	styleGlossaryNames := []string{
		kCTFontSubFamilyNameKey,
		kCTFontFullNameKey,
		kCTFontFamilyNameKey,
	}
	for _, key := range styleGlossaryNames {
		name := f.Name(key)
		if name == nil {
			continue
		}
		candidate, ok := CoreText_WeightByStyleGlossaryString(*name)
		if !ok {
			continue
		}
		if !hasWeight {
			weight = candidate
			hasWeight = true
		}
	}

	if hasWeight {
		return weight
	}
	return 0
}

func (f *Font) ShouldEnableBoldSymbolicTrait() bool {
	if f.IsRegistered() {
		return f.ShouldEnableBoldSymbolicTraitFromRegistry()
	}
	no := f.Weight() <= float64as(0.239000, 0x3fce978d4fdf3b64)
	return !no
}