Beispiel #1
0
        public unsafe TNode Lookup(char *begin, char *end, MeCabLattice <TNode> lattice)
        {
            CharInfo cInfo;
            int      cLen;

            if (end - begin > ushort.MaxValue)
            {
                end = begin + ushort.MaxValue;
            }
            char *begin2 = property.SeekToOtherType(begin, end, this.space, &cInfo, &cLen);

            if (begin2 >= end)
            {
                return(null);
            }

            TNode resultNode = null;
            var   daResults  = stackalloc DoubleArray.ResultPair[DAResultSize];

            foreach (MeCabDictionary it in this.dic)
            {
                int n = it.CommonPrefixSearch(begin2, (int)(end - begin2), daResults, DAResultSize);
                for (int i = 0; i < n; i++)
                {
#if MMF_DIC
                    var tokenSize = it.GetTokenSize(daResults->Value);
                    var tokens    = it.GetTokens(daResults->Value);
                    for (int j = 0; j < tokenSize; j++)
#else
                    var seg    = it.GetTokens(daResults->Value);
                    var tokens = seg.Array;
                    for (int j = seg.Offset; j < seg.Offset + seg.Count; j++)
#endif
                    {
                        var newNode = lattice.CreateNewNode();
                        this.ReadNodeInfo(it, tokens[j], newNode);
                        newNode.Length   = daResults->Length;
                        newNode.RLength  = (int)(begin2 - begin) + daResults->Length;
                        newNode.Surface  = new string(begin2, 0, newNode.Length);
                        newNode.Stat     = MeCabNodeStat.Nor;
                        newNode.CharType = cInfo.DefaultType;
                        newNode.BNext    = resultNode;
                        resultNode       = newNode;
                    }
                    daResults++;
                }
            }

            if (resultNode != null && !cInfo.Invoke)
            {
                return(resultNode);
            }

            char *begin3      = begin2 + 1;
            char *groupBegin3 = null;

            if (cInfo.Group)
            {
                char *   tmp = begin3;
                CharInfo fail;
                begin3 = this.property.SeekToOtherType(begin3, end, cInfo, &fail, &cLen);
                if (cLen <= lattice.Param.MaxGroupingSize)
                {
                    this.AddUnknown(ref resultNode, cInfo, begin, begin2, begin3, lattice);
                }
                groupBegin3 = begin3;
                begin3      = tmp;
            }

            for (int i = 1; i <= cInfo.Length; i++)
            {
                if (begin3 > end)
                {
                    break;
                }
                if (begin3 == groupBegin3)
                {
                    continue;
                }
                cLen = i;
                this.AddUnknown(ref resultNode, cInfo, begin, begin2, begin3, lattice);
                if (!cInfo.IsKindOf(this.property.GetCharInfo(*begin3)))
                {
                    break;
                }
                begin3 += 1;
            }

            if (resultNode == null)
            {
                this.AddUnknown(ref resultNode, cInfo, begin, begin2, begin3, lattice);
            }

            return(resultNode);
        }