VAR/FileSync
1
1
Fork 0
Code Issues 3 Pull Requests Packages Projects Releases Wiki Activity

Fixes on directory recreation.

Browse Source 
Code formatting.
This commit is contained in:
Valeriano A.R.
2016-09-15 04:46:33 +02:00
parent 0ef16e6e9e
commit 8c50fdc8ba
15 changed files with 452 additions and 386 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
.clang-format Normal file
View File

@@ -0,0 +1,65 @@
---
Language: Cpp
# BasedOnStyle: LLVM
AccessModifierOffset: -2
AlignAfterOpenBracket: true
AlignEscapedNewlinesLeft: false
AlignOperands: true
AlignTrailingComments: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortBlocksOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: false
AllowShortIfStatementsOnASingleLine: false
AllowShortLoopsOnASingleLine: false
AllowShortFunctionsOnASingleLine: All
AlwaysBreakAfterDefinitionReturnType: false
AlwaysBreakTemplateDeclarations: false
AlwaysBreakBeforeMultilineStrings: false
BreakBeforeBinaryOperators: None
BreakBeforeTernaryOperators: true
BreakConstructorInitializersBeforeComma: false
BinPackParameters: true
BinPackArguments: true
ColumnLimit: 80
ConstructorInitializerAllOnOneLineOrOnePerLine: false
ConstructorInitializerIndentWidth: 4
DerivePointerAlignment: false
ExperimentalAutoDetectBinPacking: false
IndentCaseLabels: false
IndentWrappedFunctionNames: false
IndentFunctionDeclarationAfterType: false
MaxEmptyLinesToKeep: 1
KeepEmptyLinesAtTheStartOfBlocks: true
NamespaceIndentation: None
ObjCBlockIndentWidth: 2
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PenaltyBreakBeforeFirstCallParameter: 19
PenaltyBreakComment: 300
PenaltyBreakString: 1000
PenaltyBreakFirstLessLess: 120
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 60
PointerAlignment: Right
SpacesBeforeTrailingComments: 1
Cpp11BracedListStyle: true
Standard: Cpp11
IndentWidth: 4
TabWidth: 4
UseTab: true
BreakBeforeBraces: Attach
SpacesInParentheses: false
SpacesInSquareBrackets: false
SpacesInAngles: false
SpaceInEmptyParentheses: false
SpacesInCStyleCastParentheses: false
SpaceAfterCStyleCast: false
SpacesInContainerLiterals: true
SpaceBeforeAssignmentOperators: true
ContinuationIndentWidth: 4
CommentPragmas: '^ IWYU pragma:'
ForEachMacros: [ foreach, Q_FOREACH, BOOST_FOREACH ]
SpaceBeforeParens: ControlStatements
DisableFormat: false
...

101
src/actionfilenode.c
View File

@@ -17,8 +17,8 @@ ActionFileNode ActionFileNode_Create() {
ActionFileNode actionFileNodeFreeAux;
int i;
// Allocate block
actionFileNodeFreeAux = malloc(
sizeof(TActionFileNode) * AccionFileNode_Block);
actionFileNodeFreeAux =
malloc(sizeof(TActionFileNode) * AccionFileNode_Block);
if (actionFileNodeFreeAux == NULL) {
return NULL;
}
@@ -48,8 +48,7 @@ void AccionFileNode_Destroy(ActionFileNode actionFileNode) {
}
ActionFileNode ActionFileNode_CreateNormal(FileNode fileNodeLeft,
FileNode fileNodeRight)
{
FileNode fileNodeRight) {
ActionFileNode actionFileNode;
actionFileNode = ActionFileNode_Create();
actionFileNode->action = ActionFileCmp_Nothing;
@@ -59,11 +58,9 @@ ActionFileNode ActionFileNode_CreateNormal(FileNode fileNodeLeft,
}
void AccionFileNode_CompareChilds(
ActionFileNode actionFileNodeRoot,
ActionFileNode *actionFileNodeQueue,
ActionFileNode actionFileNodeRoot, ActionFileNode *actionFileNodeQueue,
void (*CheckPair)(FileNode fileNodeLeft, FileNode fileNodeRight,
ActionFileNode *actionFileNodeQueue))
{
ActionFileNode *actionFileNodeQueue)) {
FileNode fileNodeLeft;
FileNode fileNodeRight;
FileNode fileNodeRightQueue;
@@ -111,8 +108,7 @@ void AccionFileNode_CompareChilds(
// Match, extract right child FileNode to the processed chain
if (fileNodeRightPrevious) {
fileNodeRightPrevious->next = fileNodeRight->next;
}
else {
} else {
fileNodeRightQueue = fileNodeRight->next;
}
fileNodeRight->next = fileNodeRightProcessed;
@@ -120,8 +116,7 @@ void AccionFileNode_CompareChilds(
CheckPair(fileNodeLeft, fileNodeRight, actionFileNodeQueue);
break;
}
else {
} else {
// Next right child
fileNodeRightPrevious = fileNodeRight;
fileNodeRight = fileNodeRight->next;
@@ -146,8 +141,7 @@ void AccionFileNode_CompareChilds(
}
int ActionFileNode_Statistics(ActionFileNode actionFileNode,
ActionQueueStatistics *statistics)
{
ActionQueueStatistics *statistics) {
statistics->readLeft = 0;
statistics->writeLeft = 0;
statistics->readRight = 0;
@@ -198,12 +192,8 @@ int ActionFileNode_Statistics(ActionFileNode actionFileNode,
actionFileNode = actionFileNode->next;
}
return (
statistics->fullCopyCount +
statistics->dateCopyCount +
statistics->directoryCount +
statistics->deleteCount
);
return (statistics->fullCopyCount + statistics->dateCopyCount +
statistics->directoryCount + statistics->deleteCount);
}
void ActionFileNode_Print(ActionFileNode actionFileNode) {
@@ -211,8 +201,7 @@ void ActionFileNode_Print(ActionFileNode actionFileNode) {
while (actionFileNode != NULL) {
if (actionFileNode->left) {
FileNode_GetFullPath(actionFileNode->left, "", showPath);
}
else {
} else {
FileNode_GetFullPath(actionFileNode->right, "", showPath);
}
@@ -259,45 +248,40 @@ void AccionFileNodeAux_CopyDate(char *pathOrig, char *pathDest) {
void AccionFileNodeAux_Copy(char *pathOrig, char *pathDest) {
if (File_Copy(pathOrig, pathDest)) {
AccionFileNodeAux_CopyDate(pathOrig, pathDest);
}
else {
} else {
File_Delete(pathDest);
Print("Error Copying to: %s", pathDest);
Print("Error Copying to: %s\n", pathDest);
}
}
void AccionFileNodeAux_Delete(char *pathOrig, char *pathDest) {
if (File_IsDirectory(pathDest)) {
File_DeleteDirectory(pathDest);
}
else {
} else {
File_Delete(pathDest);
}
}
void AccionFileNodeAux_MakeDir(char *pathOrig, char *pathDest) {
if (File_MakeDirectory(pathDest) == 0) {
Print("Error Making Directory: %s", pathDest);
Print("Error Making Directory: %s\n", pathDest);
}
}
int ActionFileNode_RunList(ActionFileNode actionFileNode, char *pathLeft,
char *pathRight)
{
char *pathRight) {
int numActions = 0;
char fullPathLeft[MaxPath], fullPathRight[MaxPath], showPath[MaxPath];
while (actionFileNode != NULL) {
if (actionFileNode->left) {
FileNode_GetFullPath(actionFileNode->left, pathLeft, fullPathLeft);
FileNode_GetFullPath(actionFileNode->left, "", showPath);
}
else {
} else {
FileNode_GetFullPath(actionFileNode->right, pathLeft, fullPathLeft);
FileNode_GetFullPath(actionFileNode->right, "", showPath);
}
if (actionFileNode->right) {
FileNode_GetFullPath(actionFileNode->right, pathRight,
fullPathRight);
}
else {
} else {
FileNode_GetFullPath(actionFileNode->left, pathRight,
fullPathRight);
}
@@ -308,35 +292,43 @@ int ActionFileNode_RunList(ActionFileNode actionFileNode, char *pathLeft,
break;
case ActionFileCmp_LeftToRight:
Print(" => %s\n", showPath);
AccionFileNodeAux_Copy(fullPathLeft, fullPathRight); numActions++;
AccionFileNodeAux_Copy(fullPathLeft, fullPathRight);
numActions++;
break;
case ActionFileCmp_RightToLeft:
Print(" <= %s\n", showPath);
AccionFileNodeAux_Copy(fullPathRight, fullPathLeft); numActions++;
AccionFileNodeAux_Copy(fullPathRight, fullPathLeft);
numActions++;
break;
case ActionFileCmp_DeleteLeft:
Print(" *- %s\n", showPath);
AccionFileNodeAux_Delete(fullPathRight, fullPathLeft); numActions++;
AccionFileNodeAux_Delete(fullPathRight, fullPathLeft);
numActions++;
break;
case ActionFileCmp_DeleteRight:
Print(" -* %s\n", showPath);
AccionFileNodeAux_Delete(fullPathLeft, fullPathRight); numActions++;
AccionFileNodeAux_Delete(fullPathLeft, fullPathRight);
numActions++;
break;
case ActionFileCmp_DateLeftToRight:
Print(" -> %s\n", showPath);
AccionFileNodeAux_CopyDate(fullPathLeft, fullPathRight); numActions++;
AccionFileNodeAux_CopyDate(fullPathLeft, fullPathRight);
numActions++;
break;
case ActionFileCmp_DateRightToLeft:
Print(" <- %s\n", showPath);
AccionFileNodeAux_CopyDate(fullPathRight, fullPathLeft); numActions++;
AccionFileNodeAux_CopyDate(fullPathRight, fullPathLeft);
numActions++;
break;
case ActionFileCmp_MakeRightDirectory:
Print(" -D %s\n", showPath);
AccionFileNodeAux_MakeDir(fullPathLeft, fullPathRight); numActions++;
AccionFileNodeAux_MakeDir(fullPathLeft, fullPathRight);
numActions++;
break;
case ActionFileCmp_MakeLeftDirectory:
Print(" D- %s\n", showPath);
AccionFileNodeAux_MakeDir(fullPathRight, fullPathLeft); numActions++;
AccionFileNodeAux_MakeDir(fullPathRight, fullPathLeft);
numActions++;
break;
}
@@ -349,13 +341,14 @@ int ActionFileNode_RunList(ActionFileNode actionFileNode, char *pathLeft,
// ----------------------------------------------------------------------------
// Common utilities
#define QueueNode(queue,node) (queue)->next = (node); (queue) = (node);
#define QueueNode(queue, node) \
(queue)->next = (node); \
(queue) = (node);
void AccionFileNode_DeletePair(FileNode fileNodeLeft, FileNode fileNodeRight,
ActionFileNode *actionFileNodeQueue)
{
ActionFileNode actionFileNodeNew = ActionFileNode_CreateNormal(
fileNodeLeft, fileNodeRight);
ActionFileNode *actionFileNodeQueue) {
ActionFileNode actionFileNodeNew =
ActionFileNode_CreateNormal(fileNodeLeft, fileNodeRight);
if (!fileNodeLeft && !fileNodeRight) {
AccionFileNode_Destroy(actionFileNodeNew);
@@ -372,8 +365,7 @@ void AccionFileNode_DeletePair(FileNode fileNodeLeft, FileNode fileNodeRight,
// Node delete action
actionFileNodeNew->action = ActionFileCmp_DeleteRight;
QueueNode(*actionFileNodeQueue, actionFileNodeNew);
}
else {
} else {
AccionFileNode_Destroy(actionFileNodeNew);
}
}
@@ -388,14 +380,13 @@ void AccionFileNode_DeletePair(FileNode fileNodeLeft, FileNode fileNodeRight,
// Node delete action
actionFileNodeNew->action = ActionFileCmp_DeleteLeft;
QueueNode(*actionFileNodeQueue, actionFileNodeNew);
}
else {
} else {
AccionFileNode_Destroy(actionFileNodeNew);
}
}
if (fileNodeLeft && fileNodeRight) {
if ((fileNodeLeft->flags & FileFlag_Directory)
|| (fileNodeRight->flags & FileFlag_Directory)) {
if ((fileNodeLeft->flags & FileFlag_Directory) ||
(fileNodeRight->flags & FileFlag_Directory)) {
// One is Directory
// Iterate childs for deletion
@@ -411,8 +402,8 @@ void AccionFileNode_DeletePair(FileNode fileNodeLeft, FileNode fileNodeRight,
}
if (fileNodeRight->status != FileStatus_Deleted) {
if (!actionFileNodeNew) {
actionFileNodeNew = ActionFileNode_CreateNormal(fileNodeLeft,
fileNodeRight);
actionFileNodeNew =
ActionFileNode_CreateNormal(fileNodeLeft, fileNodeRight);
}
// Right node delete action
actionFileNodeNew->action = ActionFileCmp_DeleteRight;

3
src/actionfilenode.h
View File

@@ -29,8 +29,7 @@ ActionFileNode ActionFileNode_CreateNormal(FileNode fileNodeLeft,
FileNode fileNodeRight);
void AccionFileNode_CompareChilds(
ActionFileNode actionFileNodeRoot,
ActionFileNode *actionFileNodeQueue,
ActionFileNode actionFileNodeRoot, ActionFileNode *actionFileNodeQueue,
void (*CheckPair)(FileNode fileNodeLeft, FileNode fileNodeRight,
ActionFileNode *actionFileNodeQueue));

79
src/actionfilenodecopy.c
View File

@@ -11,13 +11,14 @@
#define MaxDeltaTime 0
#define QueueNode(queue,node) (queue)->next = (node); (queue) = (node);
#define QueueNode(queue, node) \
(queue)->next = (node); \
(queue) = (node);
void AccionFileNode_CopyPair(FileNode fileNodeLeft, FileNode fileNodeRight,
ActionFileNode *actionFileNodeQueue)
{
ActionFileNode actionFileNodeNew = ActionFileNode_CreateNormal(
fileNodeLeft, fileNodeRight);
ActionFileNode *actionFileNodeQueue) {
ActionFileNode actionFileNodeNew =
ActionFileNode_CreateNormal(fileNodeLeft, fileNodeRight);
if (!fileNodeLeft && !fileNodeRight) {
AccionFileNode_Destroy(actionFileNodeNew);
@@ -31,8 +32,7 @@ void AccionFileNode_CopyPair(FileNode fileNodeLeft, FileNode fileNodeRight,
if (fileNodeRight->status != FileStatus_Deleted) {
actionFileNodeNew->action = ActionFileCmp_DeleteRight;
}
else {
} else {
actionFileNodeNew->action = ActionFileCmp_Nothing;
}
QueueNode(*actionFileNodeQueue, actionFileNodeNew);
@@ -41,58 +41,59 @@ void AccionFileNode_CopyPair(FileNode fileNodeLeft, FileNode fileNodeRight,
if (fileNodeLeft->status != FileStatus_Deleted) {
if (fileNodeLeft->flags & FileFlag_Directory) {
actionFileNodeNew->action = ActionFileCmp_MakeRightDirectory;
(*actionFileNodeQueue)->next = actionFileNodeNew;
(*actionFileNodeQueue) = actionFileNodeNew;
QueueNode(*actionFileNodeQueue, actionFileNodeNew);
AccionFileNode_CompareChilds(actionFileNodeNew,
actionFileNodeQueue, AccionFileNode_CopyPair);
actionFileNodeNew = ActionFileNode_CreateNormal(fileNodeLeft,
fileNodeRight);
actionFileNodeQueue,
AccionFileNode_CopyPair);
actionFileNodeNew =
ActionFileNode_CreateNormal(fileNodeLeft, fileNodeRight);
actionFileNodeNew->action = ActionFileCmp_DateLeftToRight;
}
else {
} else {
actionFileNodeNew->action = ActionFileCmp_LeftToRight;
}
}
else {
} else {
actionFileNodeNew->action = ActionFileCmp_Nothing;
}
QueueNode(*actionFileNodeQueue, actionFileNodeNew);
}
if (fileNodeLeft && fileNodeRight) {
if ((fileNodeLeft->flags & FileFlag_Directory)
|| (fileNodeRight->flags & FileFlag_Directory))
{
if ((fileNodeLeft->flags & FileFlag_Directory) ||
(fileNodeRight->flags & FileFlag_Directory)) {
if (fileNodeLeft->status != FileStatus_Deleted) {
AccionFileNode_CompareChilds(actionFileNodeNew,
actionFileNodeQueue, AccionFileNode_CopyPair);
if (abs((int)(fileNodeLeft->fileTime - fileNodeRight->fileTime))
<= MaxDeltaTime) { // appox. equal
actionFileNodeNew->action = ActionFileCmp_Nothing;
if (fileNodeRight->status == FileStatus_Deleted) {
actionFileNodeNew->action =
ActionFileCmp_MakeRightDirectory;
QueueNode(*actionFileNodeQueue, actionFileNodeNew);
actionFileNodeNew = ActionFileNode_CreateNormal(
fileNodeLeft, fileNodeRight);
}
else {
AccionFileNode_CompareChilds(actionFileNodeNew,
actionFileNodeQueue,
AccionFileNode_CopyPair);
if (abs((int)(fileNodeLeft->fileTime -
fileNodeRight->fileTime)) <=
MaxDeltaTime) { // appox. equal
actionFileNodeNew->action = ActionFileCmp_Nothing;
} else {
actionFileNodeNew->action = ActionFileCmp_DateLeftToRight;
}
}
else {
} else {
AccionFileNode_CompareChilds(actionFileNodeNew,
actionFileNodeQueue, AccionFileNode_DeletePair);
actionFileNodeQueue,
AccionFileNode_DeletePair);
if (fileNodeRight->status != FileStatus_Deleted) {
actionFileNodeNew->action = ActionFileCmp_DeleteRight;
}
}
}
else {
} else {
if (fileNodeLeft->status != FileStatus_Deleted) {
if (abs((int)(fileNodeLeft->fileTime - fileNodeRight->fileTime))
<= MaxDeltaTime)
{
if (abs((int)(fileNodeLeft->fileTime -
fileNodeRight->fileTime)) <= MaxDeltaTime) {
actionFileNodeNew->action = ActionFileCmp_Nothing;
}
else {
} else {
actionFileNodeNew->action = ActionFileCmp_LeftToRight;
}
}
else {
} else {
if (fileNodeRight->status != FileStatus_Deleted) {
actionFileNodeNew->action = ActionFileCmp_DeleteRight;
}
@@ -104,8 +105,8 @@ void AccionFileNode_CopyPair(FileNode fileNodeLeft, FileNode fileNodeRight,
ActionFileNode ActionFileNode_BuildCopy(FileNode fileNodeLeft,
FileNode fileNodeRight) {
ActionFileNode actionFileNodeRoot = ActionFileNode_CreateNormal(
fileNodeLeft, fileNodeRight);
ActionFileNode actionFileNodeRoot =
ActionFileNode_CreateNormal(fileNodeLeft, fileNodeRight);
ActionFileNode actionFileNodeQueue = actionFileNodeRoot;
AccionFileNode_CompareChilds(actionFileNodeRoot, &actionFileNodeQueue,
AccionFileNode_CopyPair);

152
src/actionfilenodesync.c
View File

@@ -11,46 +11,44 @@
#define MaxDeltaTime 0
#define QueueNode(queue,node) (queue)->next = (node); (queue) = (node);
#define QueueNode(queue, node) \
(queue)->next = (node); \
(queue) = (node);
void AccionFileNode_SyncPair(FileNode fileNodeLeft, FileNode fileNodeRight,
ActionFileNode *actionFileNodeQueue)
{
ActionFileNode actionFileNodeNew = ActionFileNode_CreateNormal(
fileNodeLeft, fileNodeRight);
ActionFileNode *actionFileNodeQueue) {
if (!fileNodeLeft && !fileNodeRight) {
AccionFileNode_Destroy(actionFileNodeNew);
return;
}
ActionFileNode actionFileNodeNew =
ActionFileNode_CreateNormal(fileNodeLeft, fileNodeRight);
if (!fileNodeLeft && fileNodeRight) {
if (fileNodeRight->flags & FileFlag_Directory) {
// Directory
if (fileNodeRight->status == FileStatus_Deleted) {
actionFileNodeNew->action = ActionFileCmp_Nothing;
QueueNode(*actionFileNodeQueue, actionFileNodeNew);
}
else {
} else {
actionFileNodeNew->action = ActionFileCmp_MakeLeftDirectory;
QueueNode(*actionFileNodeQueue, actionFileNodeNew);
// Iterate childs
AccionFileNode_CompareChilds(actionFileNodeNew,
actionFileNodeQueue, AccionFileNode_SyncPair);
actionFileNodeQueue,
AccionFileNode_SyncPair);
// Creatre new action for date copy
actionFileNodeNew = ActionFileNode_CreateNormal(fileNodeLeft,
fileNodeRight);
// Create new action for date copy
actionFileNodeNew =
ActionFileNode_CreateNormal(fileNodeLeft, fileNodeRight);
actionFileNodeNew->action = ActionFileCmp_DateRightToLeft;
QueueNode(*actionFileNodeQueue, actionFileNodeNew);
}
}
else {
} else {
// File
if (fileNodeRight->status == FileStatus_Deleted) {
actionFileNodeNew->action = ActionFileCmp_Nothing;
}
else {
} else {
actionFileNodeNew->action = ActionFileCmp_RightToLeft;
}
QueueNode(*actionFileNodeQueue, actionFileNodeNew);
@@ -62,111 +60,115 @@ void AccionFileNode_SyncPair(FileNode fileNodeLeft, FileNode fileNodeRight,
if (fileNodeLeft->status == FileStatus_Deleted) {
actionFileNodeNew->action = ActionFileCmp_Nothing;
QueueNode(*actionFileNodeQueue, actionFileNodeNew);
}
else {
} else {
actionFileNodeNew->action = ActionFileCmp_MakeRightDirectory;
QueueNode(*actionFileNodeQueue, actionFileNodeNew);
// Iterate childs
AccionFileNode_CompareChilds(actionFileNodeNew,
actionFileNodeQueue, AccionFileNode_SyncPair);
actionFileNodeQueue,
AccionFileNode_SyncPair);
// Create new action for date copy
actionFileNodeNew = ActionFileNode_CreateNormal(fileNodeLeft,
fileNodeRight);
actionFileNodeNew =
ActionFileNode_CreateNormal(fileNodeLeft, fileNodeRight);
actionFileNodeNew->action = ActionFileCmp_DateLeftToRight;
QueueNode(*actionFileNodeQueue, actionFileNodeNew);
}
}
else {
} else {
// File
if (fileNodeLeft->status == FileStatus_Deleted) {
actionFileNodeNew->action = ActionFileCmp_Nothing;
}
else {
} else {
actionFileNodeNew->action = ActionFileCmp_LeftToRight;
}
QueueNode(*actionFileNodeQueue, actionFileNodeNew);
}
}
if (fileNodeLeft && fileNodeRight) {
if ((fileNodeLeft->flags & FileFlag_Directory)
&& (fileNodeRight->flags & FileFlag_Directory))
{
if ((fileNodeLeft->flags & FileFlag_Directory) &&
(fileNodeRight->flags & FileFlag_Directory)) {
// Directory
// Prepare action for directory pair
if (abs((int)(fileNodeLeft->fileTime - fileNodeRight->fileTime)) <= MaxDeltaTime) { // aprox. equal
if (fileNodeRight->status == FileStatus_Deleted
&& fileNodeLeft->status == FileStatus_Deleted) {
if (abs((int)(fileNodeLeft->fileTime - fileNodeRight->fileTime)) <=
MaxDeltaTime) { // aprox. equal
if (fileNodeRight->status == FileStatus_Deleted &&
fileNodeLeft->status == FileStatus_Deleted) {
actionFileNodeNew->action = ActionFileCmp_Nothing;
}
else if (fileNodeRight->status == FileStatus_Deleted) {
} else if (fileNodeRight->status == FileStatus_Deleted) {
actionFileNodeNew->action = ActionFileCmp_DeleteLeft;
}
else if (fileNodeLeft->status == FileStatus_Deleted) {
} else if (fileNodeLeft->status == FileStatus_Deleted) {
actionFileNodeNew->action = ActionFileCmp_DeleteRight;
}
else {
} else {
actionFileNodeNew->action = ActionFileCmp_Nothing;
}
} else if (fileNodeLeft->fileTime < fileNodeRight->fileTime) {
if (fileNodeRight->status == FileStatus_Deleted) {
actionFileNodeNew->action = ActionFileCmp_DeleteLeft;
if (fileNodeLeft->status == FileStatus_Deleted) {
actionFileNodeNew->action = ActionFileCmp_Nothing;
}
} else {
if (fileNodeLeft->status == FileStatus_Deleted) {
actionFileNodeNew->action =
ActionFileCmp_MakeLeftDirectory;
QueueNode(*actionFileNodeQueue, actionFileNodeNew);
actionFileNodeNew = ActionFileNode_CreateNormal(
fileNodeLeft, fileNodeRight);
}
else if (fileNodeLeft->fileTime < fileNodeRight->fileTime) {
actionFileNodeNew->action = ActionFileCmp_DateRightToLeft;
if (fileNodeRight->status == FileStatus_Deleted) {
actionFileNodeNew->action = ActionFileCmp_DeleteLeft;
if (fileNodeLeft->status == FileStatus_Deleted) {
actionFileNodeNew->action = ActionFileCmp_Nothing;
}
}
}
else if (fileNodeLeft->fileTime > fileNodeRight->fileTime) {
actionFileNodeNew->action = ActionFileCmp_DateLeftToRight;
} else if (fileNodeLeft->fileTime > fileNodeRight->fileTime) {
if (fileNodeLeft->status == FileStatus_Deleted) {
actionFileNodeNew->action = ActionFileCmp_DeleteRight;
if (fileNodeRight->status == FileStatus_Deleted) {
actionFileNodeNew->action = ActionFileCmp_Nothing;
}
} else {
if (fileNodeRight->status == FileStatus_Deleted) {
actionFileNodeNew->action =
ActionFileCmp_MakeRightDirectory;
QueueNode(*actionFileNodeQueue, actionFileNodeNew);
actionFileNodeNew = ActionFileNode_CreateNormal(
fileNodeLeft, fileNodeRight);
}
actionFileNodeNew->action = ActionFileCmp_DateLeftToRight;
}
}
// Process child nodes
if (actionFileNodeNew->action == ActionFileCmp_DeleteRight
|| actionFileNodeNew->action == ActionFileCmp_DeleteLeft
|| (fileNodeLeft->status == FileStatus_Deleted
&& fileNodeRight->status == FileStatus_Deleted)) {
if (actionFileNodeNew->action == ActionFileCmp_DeleteRight ||
actionFileNodeNew->action == ActionFileCmp_DeleteLeft) {
// Iterate child nodes for deletion
AccionFileNode_CompareChilds(actionFileNodeNew,
actionFileNodeQueue, AccionFileNode_DeletePair);
}
else {
actionFileNodeQueue,
AccionFileNode_DeletePair);
} else {
AccionFileNode_CompareChilds(actionFileNodeNew,
actionFileNodeQueue, AccionFileNode_SyncPair);
actionFileNodeQueue,
AccionFileNode_SyncPair);
}
QueueNode(*actionFileNodeQueue, actionFileNodeNew);
}
else if ((fileNodeLeft->flags & FileFlag_Normal)
&& (fileNodeRight->flags & FileFlag_Normal))
{
} else if ((fileNodeLeft->flags & FileFlag_Normal) &&
(fileNodeRight->flags & FileFlag_Normal)) {
// Files
// Prepare action for file pair
if (abs((int)(fileNodeLeft->fileTime - fileNodeRight->fileTime)) <= MaxDeltaTime) { // aprox. equal
if (fileNodeRight->status == FileStatus_Deleted
&& fileNodeLeft->status == FileStatus_Deleted) {
if (abs((int)(fileNodeLeft->fileTime - fileNodeRight->fileTime)) <=
MaxDeltaTime) { // aprox. equal
if (fileNodeRight->status == FileStatus_Deleted &&
fileNodeLeft->status == FileStatus_Deleted) {
actionFileNodeNew->action = ActionFileCmp_Nothing;
}
else if (fileNodeRight->status == FileStatus_Deleted) {
} else if (fileNodeRight->status == FileStatus_Deleted) {
actionFileNodeNew->action = ActionFileCmp_DeleteLeft;
}
else if (fileNodeLeft->status == FileStatus_Deleted) {
} else if (fileNodeLeft->status == FileStatus_Deleted) {
actionFileNodeNew->action = ActionFileCmp_DeleteRight;
}
else {
} else {
actionFileNodeNew->action = ActionFileCmp_Nothing;
}
}
else if (fileNodeLeft->fileTime < fileNodeRight->fileTime) {
} else if (fileNodeLeft->fileTime < fileNodeRight->fileTime) {
// FIXME: Check size to determine y further checks are necessary
actionFileNodeNew->action = ActionFileCmp_RightToLeft;
if (fileNodeRight->status == FileStatus_Deleted) {
@@ -175,8 +177,7 @@ void AccionFileNode_SyncPair(FileNode fileNodeLeft, FileNode fileNodeRight,
actionFileNodeNew->action = ActionFileCmp_Nothing;
}
}
}
else if (fileNodeLeft->fileTime > fileNodeRight->fileTime) {
} else if (fileNodeLeft->fileTime > fileNodeRight->fileTime) {
// FIXME: Check size to determine y further checks are necessary
actionFileNodeNew->action = ActionFileCmp_LeftToRight;
if (fileNodeLeft->status == FileStatus_Deleted) {
@@ -187,8 +188,7 @@ void AccionFileNode_SyncPair(FileNode fileNodeLeft, FileNode fileNodeRight,
}
}
QueueNode(*actionFileNodeQueue, actionFileNodeNew);
}
else {
} else {
// FIXME: !!!!!
// Directory vs File
}
@@ -196,8 +196,8 @@ void AccionFileNode_SyncPair(FileNode fileNodeLeft, FileNode fileNodeRight,
}
ActionFileNode ActionFileNode_BuildSync(FileNode izquierda, FileNode derecha) {
ActionFileNode actionFileNodeRoot = ActionFileNode_CreateNormal(izquierda,
derecha);
ActionFileNode actionFileNodeRoot =
ActionFileNode_CreateNormal(izquierda, derecha);
ActionFileNode actionFileNodeQueue = actionFileNodeRoot;
AccionFileNode_CompareChilds(actionFileNodeRoot, &actionFileNodeQueue,
AccionFileNode_SyncPair);

6
src/crc.c
View File

@@ -28,8 +28,7 @@ void CRCTable_Init() {
}
unsigned long CRC_BufferInternal(unsigned char *buffer, unsigned long len,
unsigned long crc)
{
unsigned long crc) {
unsigned char *p;
// Calculate CRC from buffer
@@ -43,7 +42,8 @@ unsigned long CRC_BufferInternal(unsigned char *buffer, unsigned long len,
return (crc);
}
unsigned long CRC_Buffer(unsigned char *buffer, unsigned long len, unsigned long crc) {
unsigned long CRC_Buffer(unsigned char *buffer, unsigned long len,
unsigned long crc) {
CRCTable_Init();
return (CRC_BufferInternal(buffer, len, crc));
}

3
src/crc.h
View File

@@ -3,7 +3,8 @@
#include <stdio.h>
unsigned long CRC_Buffer(unsigned char *buffer, unsigned long len, unsigned long crc);
unsigned long CRC_Buffer(unsigned char *buffer, unsigned long len,
unsigned long crc);
unsigned long CRC_File(FILE *file);
#endif

82
src/filenode.c
View File

@@ -95,10 +95,20 @@ void FileNode_AddChild(FileNode fileNode, FileNode fileNodeChild) {
fileNodeChild->parent = fileNode;
}
FileNode FileNode_GetRoot(FileNode fileNode) {
FileNode fileNodeParent = fileNode->parent;
while (fileNodeParent != NULL && fileNodeParent->parent != NULL) {
fileNodeParent = fileNodeParent->parent;
}
return fileNodeParent;
}
void FileNode_SetStatusRec(FileNode fileNode, FileStatus status) {
FileNode fileNodeChild;
if (status == FileStatus_Deleted && fileNode->status != status) {
fileNode->fileTime = Time_GetCurrentTime();
FileNode fileNodeRoot = FileNode_GetRoot(fileNode);
fileNode->fileTime = fileNodeRoot->fileTime;
;
fileNode->flags |= FileFlag_HasTime;
}
fileNode->status = status;
@@ -113,8 +123,7 @@ void FileNode_GetPath_Rec(FileNode fileNode, char **pathNode) {
if (fileNode->parent) {
pathNode[0] = fileNode->parent->name;
FileNode_GetPath_Rec(fileNode->parent, pathNode + 1);
}
else {
} else {
pathNode[0] = NULL;
}
}
@@ -123,7 +132,9 @@ char *FileNode_GetPath(FileNode fileNode, char *path) {
char *pathNodes[MaxPathNodes];
int levels, i;
char *pathPtr = tempPath;
if (path) { pathPtr = path; }
if (path) {
pathPtr = path;
}
FileNode_GetPath_Rec(fileNode, pathNodes);
levels = 0;
@@ -195,8 +206,7 @@ void FileNode_SaveNode(FileNode fileNode, FILE *file) {
fwrite((void *)&nameLen, sizeof(nameLen), 1, file);
if (nameLen > 0 && nameLen < MaxFilename) {
fputs(fileNode->name, file);
}
else {
} else {
return;
}
@@ -213,7 +223,8 @@ void FileNode_SaveNode(FileNode fileNode, FILE *file) {
// Write date
if (fileNode->flags & FileFlag_HasTime) {
fwrite((void *)&fileNode->fileTime, sizeof(fileNode->fileTime), 1, file);
fwrite((void *)&fileNode->fileTime, sizeof(fileNode->fileTime), 1,
file);
}
// Write CRC
@@ -224,7 +235,8 @@ void FileNode_SaveNode(FileNode fileNode, FILE *file) {
// Write files of directory
if (fileNode->flags & FileFlag_Directory) {
FileNode fileNodeChild;
fwrite((void *)&fileNode->childCount, sizeof(fileNode->childCount), 1, file);
fwrite((void *)&fileNode->childCount, sizeof(fileNode->childCount), 1,
file);
fileNodeChild = fileNode->child;
int cnt = 0;
while (fileNodeChild) {
@@ -306,7 +318,8 @@ FileNode FileNode_LoadNode(FILE *file) {
if (fileNode->flags & FileFlag_Directory) {
FileNode fileNodeChildAux = NULL;
FileNode fileNodeChild;
fread((void *)&fileNode->childCount, sizeof(fileNode->childCount), 1, file);
fread((void *)&fileNode->childCount, sizeof(fileNode->childCount), 1,
file);
for (i = 0; i < fileNode->childCount; i++) {
fileNodeChild = FileNode_LoadNode(file);
if (fileNodeChild == NULL) {
@@ -316,8 +329,7 @@ FileNode FileNode_LoadNode(FILE *file) {
fileNodeChild->parent = fileNode;
if (!fileNodeChildAux) {
fileNode->child = fileNodeChild;
}
else {
} else {
fileNodeChildAux->next = fileNodeChild;
}
fileNodeChildAux = fileNodeChild;
@@ -362,8 +374,7 @@ void FileNode_PrintNode(FileNode fileNode) {
Print(FileNode_GetPath(fileNode, NULL));
if (fileNode->flags & FileFlag_Normal) {
Print(" File");
}
else {
} else {
Print(" Dir");
}
Print(" %d", fileNode->status);
@@ -382,7 +393,9 @@ void FileNode_PrintNode(FileNode fileNode) {
Print("\\-Size : %lld\n", fileNode->size);
}
if (fileNode->flags & FileFlag_HasTime) {
Print("\\-Date : "); FileTime_Print(fileNode->fileTime); Print("\n");
Print("\\-Date : ");
FileTime_Print(fileNode->fileTime);
Print("\n");
}
if (fileNode->flags & FileFlag_HasCRC) {
Print("\\-CRC : [%08X]\n", fileNode->crc);
@@ -400,8 +413,7 @@ void FileNode_Print(FileNode fileNode) {
if (fileNodeAux->child) {
fileNodeAux = fileNodeAux->child;
}
else {
} else {
while (fileNodeAux->next == NULL) {
fileNodeAux = fileNodeAux->parent;
if (fileNodeAux == fileNode || fileNodeAux == NULL) {
@@ -428,14 +440,15 @@ FileNode FileNode_Build(char *path) {
// Create node
fileNode = FileNode_Create();
File_GetName(path, fileNode->name);
fileNode->fileTime = Time_GetCurrentTime();
fileNode->flags |= FileFlag_HasTime;
if (File_IsDirectory(path)) {
// Get information data from directories, and child files
fileNode->flags |= FileFlag_Directory;
FileNode_LoadTime(fileNode, path);
File_IterateDir(path, FileNode_Build_Iterate, fileNode);
}
else {
} else {
// Get information data from files
fileNode->flags |= FileFlag_Normal;
FileNode_LoadSizeAndTime(fileNode, path);
@@ -461,26 +474,22 @@ int FileNode_Build_Iterate(char *path, char *name, void *d) {
int FileNode_Refresh_Iterate(char *path, char *name, void *d);
FileNode FileNode_Refresh(FileNode fileNode, char *filePath) {
if (!fileNode) {
Print("FileNode_Refresh: Error NULL FileNode\n");
return NULL;
}
if (!File_ExistsPath(filePath)) {
// The file/directory has been deleted
if (!fileNode) {
fileNode = FileNode_Create();
File_GetName(filePath, fileNode->name);
}
FileNode_SetStatusRec(fileNode, FileStatus_Deleted);
return (fileNode);
}
if (!fileNode) {
// The file has been created
fileNode = FileNode_Build(filePath);
FileNode_SetStatusRec(fileNode, FileStatus_New);
}
else {
// Check modification
FileTime fileTime;
long long size;
// Mark
// Remove mark
fileNode->flags &= ~FileFlag_MarkerForReview;
if (File_IsDirectory(filePath)) {
@@ -520,8 +529,7 @@ FileNode FileNode_Refresh(FileNode fileNode, char *filePath) {
}
fileNodeChild = fileNodeChild->next;
}
}
else {
} else {
// Comprar datos de los ficheros
if (!(fileNode->flags & FileFlag_Normal)) {
fileNode->status = FileStatus_Modified;
@@ -544,7 +552,13 @@ FileNode FileNode_Refresh(FileNode fileNode, char *filePath) {
fileNode->flags &= ~FileFlag_HasCRC;
}
}
// Save update time on root FileNode
if (fileNode->parent == NULL) {
fileNode->fileTime = Time_GetCurrentTime();
fileNode->flags |= FileFlag_HasTime;
}
return (fileNode);
}
@@ -567,10 +581,10 @@ int FileNode_Refresh_Iterate(char *path, char *name, void *d) {
if (fileNodeChild) {
// Exists, Refresh
FileNode_Refresh(fileNodeChild, path);
}
else {
} else {
// New, Build
fileNodeChild = FileNode_Refresh(NULL, path);
fileNodeChild = FileNode_Build(path);
FileNode_SetStatusRec(fileNodeChild, FileStatus_New);
FileNode_AddChild(fileNode, fileNodeChild);
}

1
src/filenode.h
View File

@@ -42,6 +42,7 @@ FileNode FileNode_Create();
FileNode FileNode_Copy(FileNode fileNode);
void FileNode_Delete(FileNode fileNode);
void FileNode_AddChild(FileNode file, FileNode file2);
FileNode FileNode_GetRoot(FileNode fileNode);
char *FileNode_GetFullPath(FileNode fileNode, char *basePath, char *path);

39
src/fileutil.c
View File

@@ -123,9 +123,8 @@ void FileTime_Print(FileTime fileTime) {
struct tm *tms;
tms = localtime((time_t *)&fileTime);
Print("%04d-%02d-%02d %02d:%02d:%02d", tms->tm_year + 1900,
tms->tm_mon + 1, tms->tm_mday, tms->tm_hour, tms->tm_min,
tms->tm_sec);
Print("%04d-%02d-%02d %02d:%02d:%02d", tms->tm_year + 1900, tms->tm_mon + 1,
tms->tm_mday, tms->tm_hour, tms->tm_min, tms->tm_sec);
}
#ifdef WIN32
@@ -178,8 +177,7 @@ void File_GetName(char *path, char *name) {
if (path[i] == '/' || path[i] == '\\') {
i++;
break;
}
else {
} else {
i--;
}
}
@@ -265,19 +263,16 @@ int File_IsFile(char *fileName) {
#endif
#ifdef WIN32
int File_MakeDirectory(char *path) {
return (CreateDirectory(path, NULL));
}
int File_MakeDirectory(char *path) { return (CreateDirectory(path, NULL)); }
#else
int File_MakeDirectory(char *path) {
return (mkdir(path, 0777));
}
int File_MakeDirectory(char *path) { return (mkdir(path, 0777)); }
#endif
#ifdef WIN32
void File_IterateDir(char *path,
int(*func)(char *path, char *name, void *data), void *data) {
int (*func)(char *path, char *name, void *data),
void *data) {
intptr_t handle;
struct _finddata_t fileinfo;
char f_path[MaxPath];
@@ -305,7 +300,8 @@ void File_IterateDir(char *path,
#else
void File_IterateDir(char *path,
int(*func)(char *path, char *name, void *data), void *data) {
int (*func)(char *path, char *name, void *data),
void *data) {
DIR *directorio;
struct dirent *entidad_dir;
char f_path[MaxPath];
@@ -320,9 +316,8 @@ void File_IterateDir(char *path,
do {
entidad_dir = readdir(directorio);
if (entidad_dir != NULL) {
if (strcmp(entidad_dir->d_name, ".")
&& strcmp(entidad_dir->d_name, ".."))
{
if (strcmp(entidad_dir->d_name, ".") &&
strcmp(entidad_dir->d_name, "..")) {
// Each item
snprintf(f_path, MaxPath, "%s/%s", path, entidad_dir->d_name);
fin = func(f_path, entidad_dir->d_name, data);
@@ -387,8 +382,14 @@ int File_Copy(const char *pathOrig, const char *pathDest) {
}
cleanup:
if (fOrig != NULL) { fclose(fOrig); }
if (fDest != NULL) { fclose(fDest); }
if (buffer != NULL) { free(buffer); }
if (fOrig != NULL) {
fclose(fOrig);
}
if (fDest != NULL) {
fclose(fDest);
}
if (buffer != NULL) {
free(buffer);
}
return status;
}

3
src/fileutil.h
View File

@@ -45,7 +45,8 @@ int File_IsFile(char *path);
int File_MakeDirectory(char *path);
void File_IterateDir(char *path,
int(*func)(char *path, char *name, void *data), void *data);
int (*func)(char *path, char *name, void *data),
void *data);
void File_Delete(char *path);
void File_DeleteDirectory(char *path);

87
src/main.c
View File

@@ -42,7 +42,8 @@ int main(int argc, char *argv[]) {
return 0;
}
Print("\n================================ FileSync ===================================\n");
Print("\n================================ FileSync "
"===================================\n");
if (!strcmp(argv[1], "info") && argc >= 3) {
// Informacion de ficheros
int i;
@@ -53,18 +54,18 @@ int main(int argc, char *argv[]) {
FileNode_PrintNode(fileNode);
}
}
}
else if (!strcmp(argv[1], "scan") && argc == 4) {
} else if (!strcmp(argv[1], "scan") && argc == 4) {
// Scan directory information tree and save
long long tScan = Time_GetTime();
FileNode fileNode;
Print("Building FileNode..\n");
fileNode = FileNode_Build(argv[2]);
tScan = Time_GetTime() - tScan;
Print("\ttScan :"); PrintElapsedTime(tScan); Print("\n");
Print("\ttScan :");
PrintElapsedTime(tScan);
Print("\n");
FileNode_Save(fileNode, argv[3]);
}
else if (!strcmp(argv[1], "rescan") && argc == 4) {
} else if (!strcmp(argv[1], "rescan") && argc == 4) {
// Scan directory information and save tree
FileNode fileNode;
Print("Loading FileNode..\n");
@@ -74,26 +75,27 @@ int main(int argc, char *argv[]) {
long long tScan = Time_GetTime();
fileNode = FileNode_Refresh(fileNode, argv[2]);
tScan = Time_GetTime() - tScan;
Print("\ttScan :"); PrintElapsedTime(tScan); Print("\n");
Print("\ttScan :");
PrintElapsedTime(tScan);
Print("\n");
FileNode_Save(fileNode, argv[3]);
}
else {
} else {
Print("Building FileNode..\n");
long long tScan = Time_GetTime();
fileNode = FileNode_Build(argv[2]);
tScan = Time_GetTime() - tScan;
Print("\ttScan :"); PrintElapsedTime(tScan); Print("\n");
Print("\ttScan :");
PrintElapsedTime(tScan);
Print("\n");
FileNode_Save(fileNode, argv[3]);
}
}
else if (!strcmp(argv[1], "read") && argc >= 3) {
} else if (!strcmp(argv[1], "read") && argc >= 3) {
// Read information tree from file
FileNode fileNode;
fileNode = FileNode_Load(argv[2]);
if (fileNode)
FileNode_Print(fileNode);
}
else if (!strcmp(argv[1], "dir") && argc == 3) {
} else if (!strcmp(argv[1], "dir") && argc == 3) {
// Read directory information tree
char *path = argv[2];
FileNode fileNode;
@@ -102,44 +104,34 @@ int main(int argc, char *argv[]) {
if (fileNode) {
FileNode_Print(fileNode);
}
}
else if (!strcmp(argv[1], "check") && argc == 3) {
} else if (!strcmp(argv[1], "check") && argc == 3) {
// Read directory information tree
char *path = argv[2];
FileNode fileNode;
fileNode = CheckDir(path, 1);
}
else if (argc == 4) {
} else if (argc == 4) {
char *cmd = argv[1];
char *pathLeft = argv[2];
char *pathRight = argv[3];
if (!strcmp(cmd, "sync")) {
Sync(pathLeft, pathRight, 1, 0);
}
else if (!strcmp(cmd, "resync")) {
} else if (!strcmp(cmd, "resync")) {
Sync(pathLeft, pathRight, 0, 0);
}
else if (!strcmp(cmd, "synctest")) {
} else if (!strcmp(cmd, "synctest")) {
Sync(pathLeft, pathRight, 1, 1);
}
else if (!strcmp(cmd, "resynctest")) {
} else if (!strcmp(cmd, "resynctest")) {
Sync(pathLeft, pathRight, 0, 1);
}
else if (!strcmp(cmd, "copy")) {
} else if (!strcmp(cmd, "copy")) {
Copy(pathLeft, pathRight, 1, 0);
}
else if (!strcmp(cmd, "recopy")) {
} else if (!strcmp(cmd, "recopy")) {
Copy(pathLeft, pathRight, 0, 0);
}
else if (!strcmp(cmd, "copytest")) {
} else if (!strcmp(cmd, "copytest")) {
Copy(pathLeft, pathRight, 1, 1);
}
else if (!strcmp(cmd, "recopytest")) {
} else if (!strcmp(cmd, "recopytest")) {
Copy(pathLeft, pathRight, 0, 1);
}
}
else {
} else {
Help(argv[0]);
}
@@ -158,15 +150,15 @@ FileNode CheckDir(char *path, int recheck) {
fileNode = FileNode_Load(dirNodesFile);
if (fileNode) {
fileNode = FileNode_Refresh(fileNode, path);
}
else {
} else {
fileNode = FileNode_Build(path);
}
tScan = Time_GetTime() - tScan;
Print("\ttScan :"); PrintElapsedTime(tScan); Print("\n");
Print("\ttScan :");
PrintElapsedTime(tScan);
Print("\n");
FileNode_Save(fileNode, dirNodesFile);
}
else {
} else {
Print("Loading Directory.. %s\n", path);
fileNode = FileNode_Load(dirNodesFile);
if (!fileNode) {
@@ -185,8 +177,7 @@ void PrintStatistics(ActionFileNode actionFileNode) {
}
Print("Statistics\n");
Print(" % 8s % 8s % 8s\n",
"Read", "Write", "Delete");
Print(" % 8s % 8s % 8s\n", "Read", "Write", "Delete");
Print("Left :");
PrintDataSize(statistics.readLeft);
PrintDataSize(statistics.writeLeft);
@@ -233,14 +224,15 @@ int Sync(char *pathLeft, char *pathRight, int reCheck, int dryRun) {
ActionFileNode actionFileNode = NULL;
actionFileNode = ActionFileNode_BuildSync(fileNodeLeft, fileNodeRight);
tBuild = Time_GetTime() - tBuild;
Print("\ttBuild:"); PrintElapsedTime(tBuild); Print("\n");
Print("\ttBuild:");
PrintElapsedTime(tBuild);
Print("\n");
if (dryRun) {
// Show action list
ActionFileNode_Print(actionFileNode);
PrintStatistics(actionFileNode);
}
else {
} else {
// Run action list
if (ActionFileNode_RunList(actionFileNode, pathLeft, pathRight)) {
CheckDir(pathLeft, reCheck);
@@ -279,14 +271,15 @@ int Copy(char *pathLeft, char *pathRight, int reCheck, int dryRun) {
ActionFileNode actionFileNode = NULL;
actionFileNode = ActionFileNode_BuildCopy(fileNodeLeft, fileNodeRight);
tBuild = Time_GetTime() - tBuild;
Print("\ttBuild:"); PrintElapsedTime(tBuild); Print("\n");
Print("\ttBuild:");
PrintElapsedTime(tBuild);
Print("\n");
if (dryRun) {
// Show action list
ActionFileNode_Print(actionFileNode);
PrintStatistics(actionFileNode);
}
else {
} else {
// Run action list
if (ActionFileNode_RunList(actionFileNode, pathLeft, pathRight)) {
CheckDir(pathLeft, reCheck);

3
src/util.c
View File

@@ -51,8 +51,7 @@ void Time_Pause(int pausa) {
diff = tend - t;
if (diff > 1000) {
Sleep((int)diff / 1000);
}
else {
} else {
Sleep(0);
}
t = Time_GetTime();