package yomichan import ( "strings" "git.foosoft.net/alex/jmdict" "golang.org/x/exp/slices" ) type sequence = int type jmdictMetadata struct { language string condensedGlosses map[senseID]string seqToSenseCount map[sequence]int seqToPartsOfSpeech map[sequence][]string seqToMainHeadword map[sequence]headword expHashToReadings map[hash][]string headwordHashToSeqs map[hash][]sequence references []string referenceToSeq map[string]sequence hashToSearchValues map[hash][]searchValue seqToSearchHashes map[sequence][]searchHash entryDepth map[sequence]int hasMultipleForms map[sequence]bool maxSenseCount int extraMode bool } type senseID struct { sequence sequence number int } func (meta *jmdictMetadata) CalculateEntryDepth(headwords []headword, seq sequence) { // This is to ensure that terms are grouped among their // entries of origin and displayed in correct sequential order maxDepth := 0 for _, headword := range headwords { hash := headword.Hash() for _, seq := range meta.headwordHashToSeqs[hash] { seqDepth := meta.entryDepth[seq] if seqDepth == 0 { meta.entryDepth[seq] = 1 seqDepth = 1 } if maxDepth < seqDepth+1 { maxDepth = seqDepth + 1 } } } meta.entryDepth[seq] = maxDepth } func (meta *jmdictMetadata) AddEntry(entry jmdict.JmdictEntry) { partsOfSpeech := []string{} senseCount := 0 for _, sense := range entry.Sense { // Only English-language senses contain part-of-speech info, // but other languages need them for deinflection rules. for _, pos := range sense.PartsOfSpeech { if !slices.Contains(partsOfSpeech, pos) { partsOfSpeech = append(partsOfSpeech, pos) } } if glossaryContainsLanguage(sense.Glossary, meta.language) { senseCount += 1 } else { continue } for _, reference := range sense.References { meta.references = append(meta.references, reference) } for _, antonym := range sense.Antonyms { meta.references = append(meta.references, antonym) } currentSenseID := senseID{entry.Sequence, senseCount} glosses := []string{} for _, gloss := range sense.Glossary { if glossContainsLanguage(gloss, meta.language) && gloss.Type == nil { glosses = append(glosses, gloss.Content) } } meta.condensedGlosses[currentSenseID] = strings.Join(glosses, "; ") } meta.seqToPartsOfSpeech[entry.Sequence] = partsOfSpeech meta.seqToSenseCount[entry.Sequence] = senseCount } func (meta *jmdictMetadata) AddHeadword(headword headword, seq sequence) { if meta.seqToSenseCount[seq] == 0 { return } // main headwords (first ones that are found in entries). if _, ok := meta.seqToMainHeadword[seq]; !ok { meta.seqToMainHeadword[seq] = headword } // hash the term pair so we can determine if it's used // in more than one JMdict entry later. headwordHash := headword.Hash() if !slices.Contains(meta.headwordHashToSeqs[headwordHash], seq) { meta.headwordHashToSeqs[headwordHash] = append(meta.headwordHashToSeqs[headwordHash], seq) } // hash the expression so that we can determine if we // need to disambiguate it by displaying its reading // in reference notes later. expHash := headword.ExpHash() if !slices.Contains(meta.expHashToReadings[expHash], headword.Reading) { meta.expHashToReadings[expHash] = append(meta.expHashToReadings[expHash], headword.Reading) } // e.g. for JMdict (English) we expect to end up with // seqToHashedHeadwords[1260670] == 【元・もと】、【元・元】、【もと・もと】、【本・もと】、【本・本】、【素・もと】、【素・素】、【基・もと】、【基・基】 // used for correlating references to sequence numbers later. searchHashes := []searchHash{ searchHash{headwordHash, headword.IsPriority}, searchHash{expHash, headword.IsPriority}, searchHash{headword.ReadingHash(), headword.IsPriority}, } for _, x := range searchHashes { if !slices.Contains(meta.seqToSearchHashes[seq], x) { meta.seqToSearchHashes[seq] = append(meta.seqToSearchHashes[seq], x) } } } func newJmdictMetadata(dictionary jmdict.Jmdict, languageName string) jmdictMetadata { meta := jmdictMetadata{ language: langNameToCode[languageName], seqToSenseCount: make(map[sequence]int), seqToPartsOfSpeech: make(map[sequence][]string), condensedGlosses: make(map[senseID]string), seqToMainHeadword: make(map[sequence]headword), expHashToReadings: make(map[hash][]string), seqToSearchHashes: make(map[sequence][]searchHash), headwordHashToSeqs: make(map[hash][]sequence), references: []string{}, hashToSearchValues: nil, referenceToSeq: nil, entryDepth: make(map[sequence]int), hasMultipleForms: make(map[sequence]bool), maxSenseCount: 0, extraMode: languageName == "english_extra", } for _, entry := range dictionary.Entries { meta.AddEntry(entry) headwords := extractHeadwords(entry) formCount := 0 for _, headword := range headwords { meta.AddHeadword(headword, entry.Sequence) if !headword.IsSearchOnly { formCount += 1 } } meta.CalculateEntryDepth(headwords, entry.Sequence) meta.hasMultipleForms[entry.Sequence] = (formCount > 1) } // this correlation process will be unnecessary once JMdict // includes sequence numbers in its cross-reference data meta.MakeReferenceToSeqMap() for _, senseCount := range meta.seqToSenseCount { if meta.maxSenseCount < senseCount { meta.maxSenseCount = senseCount } } return meta }