framemgr.c

手写识别Chinput3.0.2源代码,可以在linux下开发手写板程序

        }
        else if (data_size == sizeof (unsigned long))
        {
            *(unsigned long *) data =
                Swap32 (fm, *(CARD32 *) (fm->area + fm->idx));
        }
        else
        {
            ; /* Should never reached */
        }
        /*endif*/
        fm->idx += 4;
        if ((fitr = _FrameIterCounterIncr (fm->iters, 4/*BIT32*/)))
            _FrameMgrRemoveIter (fm, fitr);
        /*endif*/
        return FmSuccess;

#if defined(_NEED64BIT)    
    case BIT64:
        if (data_size == sizeof (unsigned char))
        {
            *(unsigned char *) data =
                Swap64 (fm, *(CARD64 *) (fm->area + fm->idx));
        }
        else if (data_size == sizeof (unsigned short))
        {
            *(unsigned short *) data =
                Swap64 (fm, *(CARD64 *) (fm->area + fm->idx));
        }
        else if (data_size == sizeof (unsigned int))
        {
            *(unsigned int *) data =
                Swap64 (fm, *(CARD64 *) (fm->area + fm->idx));
        }
        else if (data_size == sizeof (unsigned long))
        {
            *(unsigned long *) data =
                Swap64 (fm, *(CARD64 *) (fm->area + fm->idx));
        }
        else
        {
            ; /* Should never reached */
        }
        /*endif*/
        fm->idx += 8;
        if ((fitr = _FrameIterCounterIncr (fm->iters, 8/*BIT64*/)))
            _FrameMgrRemoveIter (fm, fitr);
        /*endif*/
        return FmSuccess;
#endif

    case BARRAY:
        if (info.num == NO_VALUE)
            return FmInvalidCall;
        /*endif*/
        if (info.num > 0)
        {
            *(char **) data = fm->area + fm->idx;
            
            fm->idx += info.num;
            if ((fitr = _FrameIterCounterIncr (fm->iters, info.num)))
                _FrameMgrRemoveIter (fm, fitr);
            /*endif*/
        }
        else
        {
            *(char **) data = NULL;
        }
        /*endif*/
        return FmSuccess;

    case PADDING:
        if (info.num == NO_VALUE)
            return FmInvalidCall;
        /*endif*/
        fm->idx += info.num;
        if ((fitr = _FrameIterCounterIncr (fm->iters, info.num)))
            _FrameMgrRemoveIter (fm, fitr);
        /*endif*/
        return _FrameMgrGetToken (fm, data, data_size);

    case ITER:
        return FmInvalidCall; 	/* if comes here, it's a bug! */

    case EOL:
        return FmEOD;
    }
    /*endswitch*/
    return (FmStatus) NULL;  /* Should never be reached */
}

FmStatus FrameMgrSetSize (FrameMgr fm, int barray_size)
{
    if (FrameInstSetSize (fm->fi, barray_size) == FmSuccess)
        return FmSuccess;
    /*endif*/
    return FmNoMoreData;
}

FmStatus FrameMgrSetIterCount (FrameMgr fm, int count)
{
    if (FrameInstSetIterCount (fm->fi, count) == FmSuccess)
        return FmSuccess;
    /*endif*/
    return FmNoMoreData;
}

FmStatus FrameMgrSetTotalSize (FrameMgr fm, int total_size)
{
    fm->total_size = total_size;
    return FmSuccess;
}

int FrameMgrGetTotalSize (FrameMgr fm)
{
    return FrameInstGetTotalSize (fm->fi);
}

int FrameMgrGetSize (FrameMgr fm)
{
    register int ret_size;

    ret_size = FrameInstGetSize (fm->fi);
    if (ret_size == NO_VALID_FIELD)
        return NO_VALUE;
    /*endif*/
    return ret_size;
}

FmStatus FrameMgrSkipToken (FrameMgr fm, int skip_count)
{
    XimFrameType type;
    XimFrameTypeInfoRec info;
    register int i;

    if (fm->total_size != NO_VALUE  &&  fm->idx >= fm->total_size)
        return FmNoMoreData;
    /*endif*/
    for (i = 0;  i < skip_count;  i++)
    {
        type = FrameInstGetNextType (fm->fi, &info);
        type &= ~COUNTER_MASK;

        switch (type)
        {
        case BIT8:
            fm->idx++;
            break;
            
        case BIT16:
            fm->idx += 2;
            break;
            
        case BIT32:
            fm->idx += 4;
            break;
            
        case BIT64:
            fm->idx += 8;
            break;
            
        case BARRAY:
            if (info.num == NO_VALUE)
                return FmInvalidCall;
            /*endif*/
            fm->idx += info.num;
            break;
            
        case PADDING:
            if (info.num == NO_VALUE)
                return FmInvalidCall;
            /*endif*/
            fm->idx += info.num;
            return FrameMgrSkipToken (fm, skip_count);
            
        case ITER:
            return FmInvalidCall;
            
        case EOL:
            return FmEOD;
        }
        /*endswitch*/
    }
    /*endfor*/
    return FmSuccess;
}

void FrameMgrReset (FrameMgr fm)
{
    fm->idx = 0;
    FrameInstReset (fm->fi);
}

Bool FrameMgrIsIterLoopEnd (FrameMgr fm, FmStatus* status)
{
    do
    {
        if (_FrameMgrIsIterLoopEnd (fm))
            return  True;
        /*endif*/
    }
    while (_FrameMgrProcessPadding (fm, status));

    return False;
}


/* Internal routines */

static Bool _FrameMgrIsIterLoopEnd (FrameMgr fm)
{
    return FrameInstIsIterLoopEnd (fm->fi);
}

static Bool _FrameMgrProcessPadding (FrameMgr fm, FmStatus* status)
{
    XimFrameTypeInfoRec info;
    XimFrameType next_type = FrameInstPeekNextType (fm->fi, &info);
    FrameIter fitr;

    if (next_type == PADDING)
    {
        if (info.num == NO_VALUE)
        {
            *status = FmInvalidCall;
            return True;
        }
        /*endif*/
        next_type = FrameInstGetNextType (fm->fi, &info);
        fm->idx += info.num;
        if ((fitr = _FrameIterCounterIncr (fm->iters, info.num)))
            _FrameMgrRemoveIter (fm, fitr);
        /*endif*/
        *status = FmSuccess;
        return True;
    }
    /*endif*/
    *status = FmSuccess;
    return False;
}

static FrameInst FrameInstInit (XimFrame frame)
{
    FrameInst fi;

    fi = (FrameInst) Xmalloc (sizeof (FrameInstRec));

    fi->template = frame;
    fi->cur_no = 0;
    ChainMgrInit (&fi->cm);
    return fi;
}

static void FrameInstFree (FrameInst fi)
{
    ChainIterRec ci;
    int frame_no;
    ExtraDataRec d;

    ChainIterInit (&ci, &fi->cm);

    while (ChainIterGetNext (&ci, &frame_no, &d))
    {
        register XimFrameType type;
        type = fi->template[frame_no].type;
        if (type == ITER)
        {
            if (d.iter)
                IterFree (d.iter);
            /*endif*/
        }
        else if (type == POINTER)
        {
            if (d.fi)
                FrameInstFree (d.fi);
            /*endif*/
        }
        /*endif*/
    }
    /*endwhile*/
    ChainIterFree (&ci);
    ChainMgrFree (&fi->cm);
    Xfree (fi);
}

static XimFrameType FrameInstGetNextType(FrameInst fi, XimFrameTypeInfo info)
{
    XimFrameType ret_type;

    ret_type = fi->template[fi->cur_no].type;

    switch (ret_type)
    {
    case BIT8:
    case BIT16:
    case BIT32:
    case BIT64:
    case EOL:
        fi->cur_no = _FrameInstIncrement(fi->template, fi->cur_no);
        break;

    case COUNTER_BIT8:
    case COUNTER_BIT16:
    case COUNTER_BIT32:
    case COUNTER_BIT64:
        if (info)
        {
            register int offset, iter_idx;

            info->counter.is_byte_len =
                (((int) fi->template[fi->cur_no].data & 0xFF)) == FmCounterByte;
            offset = ((int) fi->template[fi->cur_no].data) >> 8;
            iter_idx = fi->cur_no + offset;
            if (fi->template[iter_idx].type == ITER)
            {
                ExtraData d;
                ExtraDataRec dr;

                if ((d = ChainMgrGetExtraData (&fi->cm, iter_idx)) == NULL)
                {
                    dr.iter = IterInit (&fi->template[iter_idx + 1], NO_VALUE);
                    d = ChainMgrSetData (&fi->cm, iter_idx, dr);
                }
                /*endif*/
                info->counter.iter = d->iter;
            }
            else
            {
                /* Should never reach here */
            }
            /*endif*/
        }
        /*endif*/
        fi->cur_no = _FrameInstIncrement (fi->template, fi->cur_no);
        break;

    case BARRAY:
        if (info)
        {
            ExtraData d;

            if ((d = ChainMgrGetExtraData (&fi->cm, fi->cur_no)) == NULL)
                info->num = NO_VALUE;
            else
                info->num = d->num;
            /*endif*/
        }
        /*endif*/
        fi->cur_no = _FrameInstIncrement (fi->template, fi->cur_no);
        break;

    case PADDING:
        if (info)
        {
            register int unit;
            register int number;
            register int size;
            register int i;

            unit = _UNIT ((int) fi->template[fi->cur_no].data);
            number = _NUMBER ((int) fi->template[fi->cur_no].data);

            i = fi->cur_no;
            size = 0;
            while (number > 0)
            {
                i = _FrameInstDecrement (fi->template, i);
                size += _FrameInstGetItemSize (fi, i);
                number--;
            }
            /*endwhile*/
            info->num = (unit - (size%unit))%unit;
        }
        /*endif*/
        fi->cur_no = _FrameInstIncrement (fi->template, fi->cur_no);
        break;

    case ITER:
        {
            ExtraData d;
            ExtraDataRec dr;
            XimFrameType sub_type;


            if ((d = ChainMgrGetExtraData (&fi->cm, fi->cur_no)) == NULL)
            {
                dr.iter = IterInit (&fi->template[fi->cur_no + 1], NO_VALUE);
                d = ChainMgrSetData (&fi->cm, fi->cur_no, dr);
            }
            /*endif*/
            sub_type = IterGetNextType (d->iter, info);
            if (sub_type == EOL)
            {
                fi->cur_no = _FrameInstIncrement (fi->template, fi->cur_no);
                ret_type = FrameInstGetNextType (fi, info);
            }
            else
            {
                ret_type = sub_type;
            }
            /*endif*/
        }
        break;

    case POINTER:
        {
            ExtraData d;
            ExtraDataRec dr;
            XimFrameType sub_type;

            if ((d = ChainMgrGetExtraData (&fi->cm, fi->cur_no)) == NULL)
            {
                dr.fi = FrameInstInit (fi->template[fi->cur_no + 1].data);
                d = ChainMgrSetData (&fi->cm, fi->cur_no, dr);
            }
            /*endif*/
            sub_type = FrameInstGetNextType (d->fi, info);
            if (sub_type == EOL)
            {
                fi->cur_no = _FrameInstIncrement (fi->template, fi->cur_no);
                ret_type = FrameInstGetNextType (fi, info);
            }
            else
            {
                ret_type = sub_type;
            }
            /*endif*/
        }
        break;
    }
    /*endswitch*/
    return ret_type;
}

static XimFrameType FrameInstPeekNextType (FrameInst fi, XimFrameTypeInfo info)
{
    XimFrameType ret_type;

    ret_type = fi->template[fi->cur_no].type;

    switch (ret_type)
    {
    case BIT8:
    case BIT16:
    case BIT32:
    case BIT64:
    case EOL:
        break;

    case COUNTER_BIT8:
    case COUNTER_BIT16:
    case COUNTER_BIT32:
    case COUNTER_BIT64:
        if (info)
        {
            register int offset;
	    register int iter_idx;

            info->counter.is_byte_len =
                (((int) fi->template[fi->cur_no].data) & 0xFF) == FmCounterByte;
            offset = ((int)fi->template[fi->cur_no].data) >> 8;
            iter_idx = fi->cur_no + offset;
            if (fi->template[iter_idx].type == ITER)
            {
                ExtraData d;
                ExtraDataRec dr;

                if ((d = ChainMgrGetExtraData (&fi->cm, iter_idx)) == NULL)
                {
                    dr.iter = IterInit (&fi->template[iter_idx + 1], NO_VALUE);
                    d = ChainMgrSetData (&fi->cm, iter_idx, dr);
                }
                /*endif*/
                info->counter.iter = d->iter;
            }
            else
            {
                /* Should not be reached here */
            }
            /*endif*/
        }
        /*endif*/
        break;

    case BARRAY:
        if (info)
        {
            ExtraData d;

            if ((d = ChainMgrGetExtraData (&fi->cm, fi->cur_no)) == NULL)
                info->num = NO_VALUE;
            else
                info->num = d->num;
            /*endif*/
        }
        /*endif*/
        break;

    case PADDING:
        if (info)
        {
            register int unit;
            register number;
            register size;
            register i;

            unit = _UNIT ((int) fi->template[fi->cur_no].data);
            number = _NUMBER ((int) fi->template[fi->cur_no].data);

            i = fi->cur_no;
            size = 0;
            while (number > 0)
            {
                i = _FrameInstDecrement (fi->template, i);
                size += _FrameInstGetItemSize (fi, i);
                number--;
            }
            /*endwhile*/
            info->num = (unit - (size%unit))%unit;
        }
        /*endif*/
        break;

    case ITER:
        {
            ExtraData d;
            ExtraDataRec dr;
            XimFrameType sub_type;

            if ((d = ChainMgrGetExtraData (&fi->cm, fi->cur_no)) == NULL)
            {
                dr.iter = IterInit (&fi->template[fi->cur_no + 1], NO_VALUE);
                d = ChainMgrSetData (&fi->cm, fi->cur_no, dr);
            }
            /*endif*/
            sub_type = IterPeekNextType (d->iter, info);
            if (sub_type == EOL)
                ret_type = FrameInstPeekNextType (fi, info);
            else
                ret_type = sub_type;
            /*endif*/
        }
        break;

    case POINTER:
        {
            ExtraData d;
            ExtraDataRec dr;
            XimFrameType sub_type;

            if ((d = ChainMgrGetExtraData (&fi->cm, fi->cur_no)) == NULL)
            {
                dr.fi = FrameInstInit (fi->template[fi->cur_no + 1].data);
                d = ChainMgrSetData (&fi->cm, fi->cur_no, dr);
            }
            /*endif*/
            sub_type = FrameInstPeekNextType (d->fi, info);
            if (sub_type == EOL)
                ret_type = FrameInstPeekNextType (fi, info);
            else
                ret_type = sub_type;
            /*endif*/
        }
        break;
    }
    /*endswitch*/
    return ret_type;
}

static Bool FrameInstIsIterLoopEnd (FrameInst fi)
{
    Bool ret = False;

    if (fi->template[fi->cur_no].type == ITER)
    {
        ExtraData d = ChainMgrGetExtraData (&fi->cm, fi->cur_no);
        Bool yourself;

        if (d)
        {
            ret = IterIsLoopEnd (d->iter, &yourself);
            if (ret  &&  yourself)
                fi->cur_no = _FrameInstIncrement (fi->template, fi->cur_no);
            /*endif*/
        }
        /*endif*/
    }
    /*endif*/
    return (ret);
}

static FrameIter _FrameMgrAppendIter (FrameMgr fm, Iter it, int end)
{
    FrameIter p = fm->iters;

    while (p  &&  p->next)
        p = p->next;
    /*endwhile*/
    
    if (!p)
    {