text.h File Reference

#include "fc.h"

Include dependency graph for text.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	IS_SPACE(ch)   ((ch) == TEXT(' ') || (ch) == TEXT('\t'))
#define	NODE   NODE_A
#define	PrintLine   PrintLineA
#define	TextCompare   TextCompareA
#define	TAB_WIDTH   8
#define	HASH_EOF   0xFFFFFFFF
#define	HASH_MASK   0x7FFFFFFF

Functions
static LPTSTR	AllocLine (LPCTSTR pch, DWORD cch)
static NODE *	AllocNode (LPTSTR psz, DWORD lineno)
static __inline VOID	DeleteNode (NODE *node)
static VOID	DeleteList (struct list *list)
static __inline LPCTSTR	SkipSpace (LPCTSTR pch)
static __inline LPCTSTR	FindLastNonSpace (LPCTSTR pch)
static VOID	DeleteDuplicateSpaces (LPTSTR psz)
static LPTSTR	CompressSpace (LPCTSTR line)
static INT	ExpandTabLength (LPCTSTR line)
static LPTSTR	ExpandTab (LPCTSTR line)
static DWORD	GetHash (LPCTSTR psz, BOOL bIgnoreCase)
static NODE *	AllocEOFNode (DWORD lineno)
static __inline BOOL	IsEOFNode (NODE *node)
static BOOL	ConvertNode (const FILECOMPARE *pFC, NODE *node)
static FCRET	CompareNode (const FILECOMPARE *pFC, const NODE *node0, const NODE *node1)
static BOOL	FindNextLine (LPCTSTR pch, DWORD ich, DWORD cch, LPDWORD pich)
static FCRET	ParseLines (const FILECOMPARE *pFC, HANDLE *phMapping, LARGE_INTEGER *pib, const LARGE_INTEGER *pcb, struct list *list)
static VOID	ShowDiff (FILECOMPARE *pFC, INT i, struct list *begin, struct list *end)
static VOID	SkipIdentical (FILECOMPARE *pFC, struct list **pptr0, struct list **pptr1)
static DWORD	SkipIdenticalN (FILECOMPARE *pFC, struct list **pptr0, struct list **pptr1, DWORD nnnn, DWORD lineno0, DWORD lineno1)
static FCRET	ScanDiff (FILECOMPARE *pFC, struct list **pptr0, struct list **pptr1, DWORD lineno0, DWORD lineno1)
static FCRET	Resync (FILECOMPARE *pFC, struct list **pptr0, struct list **pptr1)
static FCRET	Finalize (FILECOMPARE *pFC, struct list *ptr0, struct list *ptr1, BOOL fDifferent)
FCRET	TextCompare (FILECOMPARE *pFC, HANDLE *phMapping0, const LARGE_INTEGER *pcb0, HANDLE *phMapping1, const LARGE_INTEGER *pcb1)

Macro Definition Documentation

HASH_EOF

#define HASH_EOF   0xFFFFFFFF

Definition at line 168 of file text.h.

HASH_MASK

#define HASH_MASK   0x7FFFFFFF

Definition at line 169 of file text.h.

IS_SPACE

#define IS_SPACE

(

ch

)

((ch) == TEXT(' ') || (ch) == TEXT('\t'))

Definition at line 10 of file text.h.

NODE

#define NODE   NODE_A

Definition at line 17 of file text.h.

PrintLine

#define PrintLine   PrintLineA

Definition at line 18 of file text.h.

TAB_WIDTH

#define TAB_WIDTH   8

Definition at line 125 of file text.h.

TextCompare

#define TextCompare   TextCompareA

Definition at line 19 of file text.h.

Function Documentation

AllocEOFNode()

static NODE * AllocEOFNode ( DWORD  lineno )

static

Definition at line 183 of file text.h.

{
    NODE *node = AllocNode(AllocLine(NULL, 0), 0);
    if (node == NULL)
        return NULL;
    node->pszComp = AllocLine(NULL, 0);
    if (node->pszComp == NULL)
    {
        DeleteNode(node);
        return NULL;
    }
    node->lineno = lineno;
    node->hash = HASH_EOF;
    return node;
}

Referenced by ParseLines().

AllocLine()

static LPTSTR AllocLine ( LPCTSTR  pch, DWORD  cch  )

static

Definition at line 22 of file text.h.

{
    LPTSTR pszNew = malloc((cch + 1) * sizeof(TCHAR));
    if (!pszNew)
        return NULL;
    memcpy(pszNew, pch, cch * sizeof(TCHAR));
    pszNew[cch] = 0;
    return pszNew;
}

Referenced by AllocEOFNode(), CompressSpace(), and ParseLines().

AllocNode()

static NODE * AllocNode ( LPTSTR  psz, DWORD  lineno  )

static

Definition at line 32 of file text.h.

{
    NODE *node;
    if (!psz)
        return NULL;
    node = calloc(1, sizeof(NODE));
    if (!node)
    {
        free(psz);
        return NULL;
    }
    node->pszLine = psz;
    node->lineno = lineno;
    return node;
}

Referenced by AllocEOFNode(), and ParseLines().

CompareNode()

static FCRET CompareNode ( const FILECOMPARE *  pFC, const NODE *  node0, const NODE *  node1  )

static

Definition at line 226 of file text.h.

{
    DWORD dwCmpFlags;
    LPTSTR psz0, psz1;
    INT ret;
    if (node0->hash != node1->hash)
        return FCRET_DIFFERENT;
 
    psz0 = (pFC->dwFlags & FLAG_W) ? node0->pszComp : node0->pszLine;
    psz1 = (pFC->dwFlags & FLAG_W) ? node1->pszComp : node1->pszLine;
    dwCmpFlags = ((pFC->dwFlags & FLAG_C) ? NORM_IGNORECASE : 0);
    ret = CompareString(LOCALE_USER_DEFAULT, dwCmpFlags, psz0, -1, psz1, -1);
    return (ret == CSTR_EQUAL) ? FCRET_IDENTICAL : FCRET_DIFFERENT;
}

Referenced by Resync(), SkipIdentical(), and SkipIdenticalN().

CompressSpace()

static LPTSTR CompressSpace ( LPCTSTR  line )

static

Definition at line 107 of file text.h.

{
    LPTSTR pszNew;
    LPCTSTR pchLast;
 
    line = SkipSpace(line);
    pchLast = FindLastNonSpace(line);
    if (pchLast == NULL)
        return AllocLine(NULL, 0);
 
    pszNew = AllocLine(line, (DWORD)(pchLast - line) + 1);
    if (!pszNew)
        return NULL;
 
    DeleteDuplicateSpaces(pszNew);
    return pszNew;
}

Referenced by ConvertNode().

ConvertNode()

static BOOL ConvertNode ( const FILECOMPARE *  pFC, NODE *  node  )

static

Definition at line 204 of file text.h.

{
    if (!(pFC->dwFlags & FLAG_T))
    {
        LPTSTR tmp = ExpandTab(node->pszLine);
        if (!tmp)
            return FALSE;
        free(node->pszLine);
        node->pszLine = tmp;
        if (!(pFC->dwFlags & FLAG_W))
            node->hash = GetHash(node->pszLine, !!(pFC->dwFlags & FLAG_C));
    }
    if (pFC->dwFlags & FLAG_W)
    {
        node->pszComp = CompressSpace(node->pszLine);
        if (!node->pszComp)
            return FALSE;
        node->hash = GetHash(node->pszComp, !!(pFC->dwFlags & FLAG_C));
    }
    return TRUE;
}

Referenced by ParseLines().

DeleteDuplicateSpaces()

static VOID DeleteDuplicateSpaces ( LPTSTR  psz )

static

Definition at line 89 of file text.h.

{
    LPTSTR pch0, pch1;
    for (pch0 = pch1 = psz; *pch0; ++pch0)
    {
        *pch1++ = *pch0;
        if (IS_SPACE(*pch0))
        {
            do
            {
                ++pch0;
            } while (IS_SPACE(*pch0));
            --pch0;
        }
    }
    *pch1 = 0;
}

Referenced by CompressSpace().

DeleteList()

static VOID DeleteList ( struct list *  list )

static

Definition at line 58 of file text.h.

{
    struct list *ptr;
    NODE *node;
    while ((ptr = list_head(list)) != NULL)
    {
        list_remove(ptr);
        node = LIST_ENTRY(ptr, NODE, entry);
        DeleteNode(node);
    }
}

Referenced by TextCompare().

DeleteNode()

static __inline VOID DeleteNode ( NODE *  node )

static

Definition at line 48 of file text.h.

{
    if (node)
    {
        free(node->pszLine);
        free(node->pszComp);
        free(node);
    }
}

Referenced by _CmdWndProc(), AllocEOFNode(), DeleteList(), ParseLines(), and RtlpDeleteAvlTreeNode().

ExpandTab()

static LPTSTR ExpandTab ( LPCTSTR  line )

static

Definition at line 141 of file text.h.

{
    INT spaces, cch = ExpandTabLength(line), ich;
    LPTSTR pszNew = malloc((cch + 1) * sizeof(TCHAR));
    LPCTSTR pch;
    if (!pszNew)
        return NULL;
    ich = 0;
    for (pch = line; *pch; ++pch)
    {
        if (*pch == TEXT('\t'))
        {
            spaces = TAB_WIDTH - (ich % TAB_WIDTH);
            while (spaces-- > 0)
            {
                pszNew[ich++] = TEXT(' ');
            }
        }
        else
        {
            pszNew[ich++] = *pch;
        }
    }
    pszNew[ich] = 0;
    return pszNew;
}

Referenced by ConPagerWorker(), and ConvertNode().

ExpandTabLength()

static INT ExpandTabLength ( LPCTSTR  line )

static

Definition at line 127 of file text.h.

{
    LPCTSTR pch;
    INT cch = 0;
    for (pch = line; *pch; ++pch)
    {
        if (*pch == TEXT('\t'))
            cch += TAB_WIDTH - (cch % TAB_WIDTH);
        else
            ++cch;
    }
    return cch;
}

Referenced by ExpandTab().

Finalize()

static FCRET Finalize ( FILECOMPARE *  pFC, struct list *  ptr0, struct list *  ptr1, BOOL  fDifferent  )

static

Definition at line 515 of file text.h.

{
    if (!ptr0 && !ptr1)
    {
        if (fDifferent)
            return Different(pFC->file[0], pFC->file[1]);
        return NoDifference();
    }
    else
    {
        ShowDiff(pFC, 0, ptr0, NULL);
        ShowDiff(pFC, 1, ptr1, NULL);
        PrintEndOfDiff();
        return FCRET_DIFFERENT;
    }
}

Referenced by CheckLogOrSourceExistence(), and TextCompare().

FindLastNonSpace()

static __inline LPCTSTR FindLastNonSpace ( LPCTSTR  pch )

static

Definition at line 77 of file text.h.

{
    LPCTSTR pchLast = NULL;
    while (*pch)
    {
        if (!IS_SPACE(*pch))
            pchLast = pch;
        ++pch;
    }
    return pchLast;
}

Referenced by CompressSpace().

FindNextLine()

static BOOL FindNextLine ( LPCTSTR  pch, DWORD  ich, DWORD  cch, LPDWORD  pich  )

static

Definition at line 241 of file text.h.

{
    while (ich < cch)
    {
        if (pch[ich] == TEXT('\n') || pch[ich] == TEXT('\0'))
        {
            *pich = ich;
            return TRUE;
        }
        ++ich;
    }
    *pich = cch;
    return FALSE;
}

Referenced by ParseLines().

GetHash()

static DWORD GetHash ( LPCTSTR  psz, BOOL  bIgnoreCase  )

static

Definition at line 171 of file text.h.

{
    DWORD ret = 0xDEADFACE;
    while (*psz)
    {
        ret += (bIgnoreCase ? towupper(*psz) : *psz);
        ret <<= 2;
        ++psz;
    }
    return (ret & HASH_MASK);
}

Referenced by ConvertNode().

IsEOFNode()

static __inline BOOL IsEOFNode ( NODE *  node )

static

Definition at line 199 of file text.h.

{
    return !node || node->hash == HASH_EOF;
}

Referenced by ShowDiff(), and TextCompare().

ParseLines()

static FCRET ParseLines ( const FILECOMPARE *  pFC, HANDLE *  phMapping, LARGE_INTEGER *  pib, const LARGE_INTEGER *  pcb, struct list *  list  )

static

Definition at line 257 of file text.h.

{
    DWORD lineno = 1, ich, cch, ichNext, cbView, cchNode;
    LPTSTR psz, pszLine;
    BOOL fLast, bCR;
    NODE *node;
 
    if (*phMapping == NULL)
        return FCRET_NO_MORE_DATA;
 
    if (pib->QuadPart >= pcb->QuadPart)
    {
        CloseHandle(*phMapping);
        *phMapping = NULL;
        return FCRET_NO_MORE_DATA;
    }
 
    cbView = (DWORD)min(pcb->QuadPart - pib->QuadPart, MAX_VIEW_SIZE);
    psz = MapViewOfFile(*phMapping, FILE_MAP_READ, pib->HighPart, pib->LowPart, cbView);
    if (!psz)
    {
        return OutOfMemory();
    }
 
    ich = 0;
    cch = cbView / sizeof(TCHAR);
    fLast = (pib->QuadPart + cbView >= pcb->QuadPart);
    while (ich < cch &&
           (FindNextLine(psz, ich, cch, &ichNext) ||
            (ichNext == cch && (fLast || ich == 0))))
    {
        bCR = (ichNext > 0) && (psz[ichNext - 1] == TEXT('\r'));
        cchNode = ichNext - ich - bCR;
        pszLine = AllocLine(&psz[ich], cchNode);
        node = AllocNode(pszLine, lineno++);
        if (!node || !ConvertNode(pFC, node))
        {
            DeleteNode(node);
            UnmapViewOfFile(psz);
            return OutOfMemory();
        }
        list_add_tail(list, &node->entry);
        ich = ichNext + 1;
    }
 
    UnmapViewOfFile(psz);
 
    pib->QuadPart += ichNext * sizeof(WCHAR);
 
    if (pib->QuadPart < pcb->QuadPart)
        return FCRET_IDENTICAL;
 
    // append EOF node
    node = AllocEOFNode(lineno);
    if (!node)
        return OutOfMemory();
    list_add_tail(list, &node->entry);
 
    return FCRET_NO_MORE_DATA;
}

Referenced by TextCompare().

Resync()

static FCRET Resync ( FILECOMPARE *  pFC, struct list **  pptr0, struct list **  pptr1  )

static

Definition at line 443 of file text.h.

{
    FCRET ret;
    struct list *ptr0, *ptr1, *save0 = NULL, *save1 = NULL;
    NODE *node0, *node1;
    struct list *list0 = &pFC->list[0], *list1 = &pFC->list[1];
    DWORD lineno0, lineno1;
    INT penalty, i0, i1, min_penalty = MAXLONG;
 
    node0 = LIST_ENTRY(*pptr0, NODE, entry);
    node1 = LIST_ENTRY(*pptr1, NODE, entry);
    lineno0 = node0->lineno + pFC->n;
    lineno1 = node1->lineno + pFC->n;
 
    // ``If the files that you are comparing have more than pFC->n consecutive
    //   differing lines, FC cancels the comparison,,
    // ``If the number of matching lines in the files is less than pFC->nnnn,
    //   FC displays the matching lines as differences,,
    for (ptr1 = list_next(list1, *pptr1), i1 = 0; ptr1; ptr1 = list_next(list1, ptr1), ++i1)
    {
        node1 = LIST_ENTRY(ptr1, NODE, entry);
        if (node1->lineno >= lineno1)
            break;
        for (ptr0 = list_next(list0, *pptr0), i0 = 0; ptr0; ptr0 = list_next(list0, ptr0), ++i0)
        {
            node0 = LIST_ENTRY(ptr0, NODE, entry);
            if (node0->lineno >= lineno0)
                break;
            if (CompareNode(pFC, node0, node1) == FCRET_IDENTICAL)
            {
                penalty = min(i0, i1) + abs(i1 - i0);
                if (min_penalty > penalty)
                {
                    min_penalty = penalty;
                    save0 = ptr0;
                    save1 = ptr1;
                }
            }
        }
    }
 
    if (save0 && save1)
    {
        *pptr0 = save0;
        *pptr1 = save1;
        ret = ScanDiff(pFC, &save0, &save1, lineno0, lineno1);
        if (save0 && save1)
        {
            *pptr0 = save0;
            *pptr1 = save1;
        }
        return ret;
    }
 
    for (ptr0 = *pptr0; ptr0; ptr0 = list_next(list0, ptr0))
    {
        node0 = LIST_ENTRY(ptr0, NODE, entry);
        if (node0->lineno == lineno0)
            break;
    }
    for (ptr1 = *pptr1; ptr1; ptr1 = list_next(list1, ptr1))
    {
        node1 = LIST_ENTRY(ptr1, NODE, entry);
        if (node1->lineno == lineno1)
            break;
    }
    *pptr0 = ptr0;
    *pptr1 = ptr1;
    return FCRET_DIFFERENT;
}

Referenced by TextCompare().

ScanDiff()

static FCRET ScanDiff ( FILECOMPARE *  pFC, struct list **  pptr0, struct list **  pptr1, DWORD  lineno0, DWORD  lineno1  )

static

Definition at line 407 of file text.h.

{
    struct list *ptr0 = *pptr0, *ptr1 = *pptr1, *tmp0, *tmp1;
    NODE *node0, *node1;
    INT count;
    while (ptr0 && ptr1)
    {
        node0 = LIST_ENTRY(ptr0, NODE, entry);
        node1 = LIST_ENTRY(ptr1, NODE, entry);
        if (node0->lineno >= lineno0)
            return FCRET_DIFFERENT;
        if (node1->lineno >= lineno1)
            return FCRET_DIFFERENT;
        tmp0 = ptr0;
        tmp1 = ptr1;
        count = SkipIdenticalN(pFC, &tmp0, &tmp1, pFC->nnnn, lineno0, lineno1);
        if (count >= pFC->nnnn)
            break;
        if (count > 0)
        {
            ptr0 = tmp0;
            ptr1 = tmp1;
        }
        else
        {
            ptr0 = list_next(&pFC->list[0], ptr0);
            ptr1 = list_next(&pFC->list[1], ptr1);
        }
    }
    *pptr0 = ptr0;
    *pptr1 = ptr1;
    return FCRET_IDENTICAL;
}

Referenced by Resync().

ShowDiff()

static VOID ShowDiff ( FILECOMPARE *  pFC, INT  i, struct list *  begin, struct list *  end  )

static

Definition at line 320 of file text.h.

{
    NODE* node;
    struct list *list = &pFC->list[i];
    struct list *first = NULL, *last = NULL;
    PrintCaption(pFC->file[i]);
    if (begin && end && list_prev(list, begin))
        begin = list_prev(list, begin);
    while (begin != end)
    {
        node = LIST_ENTRY(begin, NODE, entry);
        if (IsEOFNode(node))
            break;
        if (!first)
            first = begin;
        last = begin;
        if (!(pFC->dwFlags & FLAG_A))
            PrintLine(pFC, node->lineno, node->pszLine);
        begin = list_next(list, begin);
    }
    if ((pFC->dwFlags & FLAG_A) && first)
    {
        node = LIST_ENTRY(first, NODE, entry);
        PrintLine(pFC, node->lineno, node->pszLine);
        first = list_next(list, first);
        if (first != last)
        {
            if (list_next(list, first) == last)
            {
                node = LIST_ENTRY(first, NODE, entry);
                PrintLine(pFC, node->lineno, node->pszLine);
            }
            else
            {
                PrintDots();
            }
        }
        node = LIST_ENTRY(last, NODE, entry);
        PrintLine(pFC, node->lineno, node->pszLine);
    }
}

Referenced by Finalize(), and TextCompare().

SkipIdentical()

static VOID SkipIdentical ( FILECOMPARE *  pFC, struct list **  pptr0, struct list **  pptr1  )

static

Definition at line 363 of file text.h.

{
    struct list *ptr0 = *pptr0, *ptr1 = *pptr1;
    while (ptr0 && ptr1)
    {
        NODE *node0 = LIST_ENTRY(ptr0, NODE, entry);
        NODE *node1 = LIST_ENTRY(ptr1, NODE, entry);
        if (CompareNode(pFC, node0, node1) != FCRET_IDENTICAL)
            break;
        ptr0 = list_next(&pFC->list[0], ptr0);
        ptr1 = list_next(&pFC->list[1], ptr1);
    }
    *pptr0 = ptr0;
    *pptr1 = ptr1;
}

Referenced by TextCompare().

SkipIdenticalN()

static DWORD SkipIdenticalN ( FILECOMPARE *  pFC, struct list **  pptr0, struct list **  pptr1, DWORD  nnnn, DWORD  lineno0, DWORD  lineno1  )

static

Definition at line 380 of file text.h.

{
    struct list *ptr0 = *pptr0, *ptr1 = *pptr1;
    DWORD count = 0;
    while (ptr0 && ptr1)
    {
        NODE *node0 = LIST_ENTRY(ptr0, NODE, entry);
        NODE *node1 = LIST_ENTRY(ptr1, NODE, entry);
        if (node0->lineno >= lineno0)
            break;
        if (node1->lineno >= lineno1)
            break;
        if (CompareNode(pFC, node0, node1) != FCRET_IDENTICAL)
            break;
        ptr0 = list_next(&pFC->list[0], ptr0);
        ptr1 = list_next(&pFC->list[1], ptr1);
        ++count;
        if (count >= nnnn)
            break;
    }
    *pptr0 = ptr0;
    *pptr1 = ptr1;
    return count;
}

Referenced by ScanDiff().

SkipSpace()

static __inline LPCTSTR SkipSpace ( LPCTSTR  pch )

static

Definition at line 70 of file text.h.

{
    while (IS_SPACE(*pch))
        ++pch;
    return pch;
}

Referenced by CompressSpace().

TextCompare()

FCRET TextCompare	(	FILECOMPARE *	pFC,
		HANDLE *	phMapping0,
		const LARGE_INTEGER *	pcb0,
		HANDLE *	phMapping1,
		const LARGE_INTEGER *	pcb1
	)

Definition at line 533 of file text.h.

{
    FCRET ret, ret0, ret1;
    struct list *ptr0, *ptr1, *save0, *save1, *next0, *next1;
    NODE* node0, * node1;
    BOOL fDifferent = FALSE;
    LARGE_INTEGER ib0 = { .QuadPart = 0 }, ib1 = { .QuadPart = 0 };
    struct list *list0 = &pFC->list[0], *list1 = &pFC->list[1];
    list_init(list0);
    list_init(list1);
 
    do
    {
        ret0 = ParseLines(pFC, phMapping0, &ib0, pcb0, list0);
        if (ret0 == FCRET_INVALID)
        {
            ret = ret0;
            goto cleanup;
        }
        ret1 = ParseLines(pFC, phMapping1, &ib1, pcb1, list1);
        if (ret1 == FCRET_INVALID)
        {
            ret = ret1;
            goto cleanup;
        }
 
        ptr0 = list_head(list0);
        ptr1 = list_head(list1);
        for (;;)
        {
            if (!ptr0 || !ptr1)
                goto quit;
 
            // skip identical (sync'ed)
            SkipIdentical(pFC, &ptr0, &ptr1);
            if (ptr0 || ptr1)
                fDifferent = TRUE;
            node0 = LIST_ENTRY(ptr0, NODE, entry);
            node1 = LIST_ENTRY(ptr1, NODE, entry);
            if (IsEOFNode(node0) || IsEOFNode(node1))
                goto quit;
 
            // try to resync
            save0 = ptr0;
            save1 = ptr1;
            ret = Resync(pFC, &ptr0, &ptr1);
            if (ret == FCRET_INVALID)
                goto cleanup;
            if (ret == FCRET_DIFFERENT)
            {
                // resync failed
                ret = ResyncFailed();
                // show the difference
                ShowDiff(pFC, 0, save0, ptr0);
                ShowDiff(pFC, 1, save1, ptr1);
                PrintEndOfDiff();
                goto cleanup;
            }
 
            // show the difference
            fDifferent = TRUE;
            next0 = ptr0 ? list_next(list0, ptr0) : ptr0;
            next1 = ptr1 ? list_next(list1, ptr1) : ptr1;
            ShowDiff(pFC, 0, save0, (next0 ? next0 : ptr0));
            ShowDiff(pFC, 1, save1, (next1 ? next1 : ptr1));
            PrintEndOfDiff();
 
            // now resync'ed
        }
    } while (ret0 != FCRET_NO_MORE_DATA || ret1 != FCRET_NO_MORE_DATA);
 
quit:
    ret = Finalize(pFC, ptr0, ptr1, fDifferent);
cleanup:
    DeleteList(list0);
    DeleteList(list1);
    return ret;
}