saturneric/ZE-Standard-Libraries
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'develop'

Browse Source
This commit is contained in:
Saturneic 2019-01-12 08:31:37 +08:00
commit 6e547ad6ff
100 changed files with 5472 additions and 4629 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -7,3 +7,4 @@
/ZE-Standard-Libraries
/ZE-Standard-Libraries.sln
/.vs
*.xcodeproj

391
ZE-Standard-Libraries.xcodeproj/project.pbxproj
View File

@ -1,391 +0,0 @@
// !$*UTF8*$!
{
archiveVersion = 1;
classes = {
};
objectVersion = 50;
objects = {
/* Begin PBXBuildFile section */
9246995F20CE655900B4E894 /* tree.c in Sources */ = {isa = PBXBuildFile; fileRef = 9246995E20CE655900B4E894 /* tree.c */; };
9269D4E8210F1B3D00161557 /* stack_expand.c in Sources */ = {isa = PBXBuildFile; fileRef = 9269D4E7210F1B3D00161557 /* stack_expand.c */; };
9269D4EA210F1B4B00161557 /* list_expand.c in Sources */ = {isa = PBXBuildFile; fileRef = 9269D4E9210F1B4B00161557 /* list_expand.c */; };
9269D4ED210F1B5E00161557 /* test.c in Sources */ = {isa = PBXBuildFile; fileRef = 9269D4EB210F1B5E00161557 /* test.c */; };
9269D4F4210F1BB000161557 /* id.c in Sources */ = {isa = PBXBuildFile; fileRef = 9269D4F2210F1BB000161557 /* id.c */; };
9269D4F5210F1BCE00161557 /* list.c in Sources */ = {isa = PBXBuildFile; fileRef = 9246994F20CD000300B4E894 /* list.c */; };
9269D4F6210F1CD900161557 /* stack.c in Sources */ = {isa = PBXBuildFile; fileRef = 9246995920CE52A700B4E894 /* stack.c */; };
9269D4F8210F1D0B00161557 /* tree_expand.c in Sources */ = {isa = PBXBuildFile; fileRef = 9269D4F7210F1D0B00161557 /* tree_expand.c */; };
9286EB7A211400C900752977 /* error.c in Sources */ = {isa = PBXBuildFile; fileRef = 9286EB79211400C900752977 /* error.c */; };
9286EB7E2114022A00752977 /* communicate.c in Sources */ = {isa = PBXBuildFile; fileRef = 9286EB7D2114022A00752977 /* communicate.c */; };
/* End PBXBuildFile section */
/* Begin PBXCopyFilesBuildPhase section */
927993BB20CB87D6008CE3A9 /* CopyFiles */ = {
isa = PBXCopyFilesBuildPhase;
buildActionMask = 2147483647;
dstPath = /usr/share/man/man1/;
dstSubfolderSpec = 0;
files = (
);
runOnlyForDeploymentPostprocessing = 1;
};
/* End PBXCopyFilesBuildPhase section */
/* Begin PBXFileReference section */
9246994F20CD000300B4E894 /* list.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = list.c; sourceTree = "<group>"; };
9246995020CD000300B4E894 /* list_expand.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = list_expand.h; sourceTree = "<group>"; };
9246995120CD000300B4E894 /* list.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = list.h; sourceTree = "<group>"; };
9246995820CE52A700B4E894 /* stack.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = stack.h; sourceTree = "<group>"; };
9246995920CE52A700B4E894 /* stack.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = stack.c; sourceTree = "<group>"; };
9246995B20CE5C8900B4E894 /* stack_expand.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = stack_expand.h; sourceTree = "<group>"; };
9246995D20CE655900B4E894 /* tree.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = tree.h; sourceTree = "<group>"; };
9246995E20CE655900B4E894 /* tree.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = tree.c; sourceTree = "<group>"; };
9269D4E7210F1B3D00161557 /* stack_expand.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = stack_expand.c; sourceTree = "<group>"; };
9269D4E9210F1B4B00161557 /* list_expand.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = list_expand.c; sourceTree = "<group>"; };
9269D4EB210F1B5E00161557 /* test.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = test.c; sourceTree = "<group>"; };
9269D4EC210F1B5E00161557 /* test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = test.h; sourceTree = "<group>"; };
9269D4F0210F1B8000161557 /* type.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = type.h; path = type/type.h; sourceTree = "<group>"; };
9269D4F2210F1BB000161557 /* id.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = id.c; path = id/id.c; sourceTree = "<group>"; };
9269D4F3210F1BB000161557 /* id.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = id.h; path = id/id.h; sourceTree = "<group>"; };
9269D4F7210F1D0B00161557 /* tree_expand.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = tree_expand.c; sourceTree = "<group>"; };
9269D4F9210F1D0F00161557 /* tree_expand.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = tree_expand.h; sourceTree = "<group>"; };
927993BD20CB87D6008CE3A9 /* ZE-Standard-Libraries */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = "ZE-Standard-Libraries"; sourceTree = BUILT_PRODUCTS_DIR; };
9286EB79211400C900752977 /* error.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = error.c; path = error/error.c; sourceTree = "<group>"; };
9286EB7B211400D000752977 /* error.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = error.h; path = error/error.h; sourceTree = "<group>"; };
9286EB7D2114022A00752977 /* communicate.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = communicate.c; path = communicate/communicate.c; sourceTree = "<group>"; };
9286EB7F2114022F00752977 /* communicate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = communicate.h; path = communicate/communicate.h; sourceTree = "<group>"; };
/* End PBXFileReference section */
/* Begin PBXFrameworksBuildPhase section */
927993BA20CB87D6008CE3A9 /* Frameworks */ = {
isa = PBXFrameworksBuildPhase;
buildActionMask = 2147483647;
files = (
);
runOnlyForDeploymentPostprocessing = 0;
};
/* End PBXFrameworksBuildPhase section */
/* Begin PBXGroup section */
9246994E20CD000300B4E894 /* list */ = {
isa = PBXGroup;
children = (
9246994F20CD000300B4E894 /* list.c */,
9246995020CD000300B4E894 /* list_expand.h */,
9269D4E9210F1B4B00161557 /* list_expand.c */,
9246995120CD000300B4E894 /* list.h */,
);
path = list;
sourceTree = "<group>";
};
9246995720CE507900B4E894 /* stack */ = {
isa = PBXGroup;
children = (
9246995820CE52A700B4E894 /* stack.h */,
9246995920CE52A700B4E894 /* stack.c */,
9269D4E7210F1B3D00161557 /* stack_expand.c */,
9246995B20CE5C8900B4E894 /* stack_expand.h */,
);
path = stack;
sourceTree = "<group>";
};
9246995C20CE654600B4E894 /* tree */ = {
isa = PBXGroup;
children = (
9246995D20CE655900B4E894 /* tree.h */,
9246995E20CE655900B4E894 /* tree.c */,
9269D4F9210F1D0F00161557 /* tree_expand.h */,
9269D4F7210F1D0B00161557 /* tree_expand.c */,
);
path = tree;
sourceTree = "<group>";
};
9269D4EF210F1B7800161557 /* type */ = {
isa = PBXGroup;
children = (
9269D4F0210F1B8000161557 /* type.h */,
);
name = type;
sourceTree = "<group>";
};
9269D4F1210F1B9E00161557 /* id */ = {
isa = PBXGroup;
children = (
9269D4F2210F1BB000161557 /* id.c */,
9269D4F3210F1BB000161557 /* id.h */,
);
name = id;
sourceTree = "<group>";
};
927993B420CB87D6008CE3A9 = {
isa = PBXGroup;
children = (
92A15CFC211442C700826FB8 /* graph */,
9286EB7C2114021E00752977 /* communicate */,
9286EB78211400BD00752977 /* error */,
9269D4F1210F1B9E00161557 /* id */,
9269D4EF210F1B7800161557 /* type */,
9246995C20CE654600B4E894 /* tree */,
9246995720CE507900B4E894 /* stack */,
9246994E20CD000300B4E894 /* list */,
9269D4EB210F1B5E00161557 /* test.c */,
9269D4EC210F1B5E00161557 /* test.h */,
927993BE20CB87D6008CE3A9 /* Products */,
);
sourceTree = "<group>";
};
927993BE20CB87D6008CE3A9 /* Products */ = {
isa = PBXGroup;
children = (
927993BD20CB87D6008CE3A9 /* ZE-Standard-Libraries */,
);
name = Products;
sourceTree = "<group>";
};
9286EB78211400BD00752977 /* error */ = {
isa = PBXGroup;
children = (
9286EB79211400C900752977 /* error.c */,
9286EB7B211400D000752977 /* error.h */,
);
name = error;
sourceTree = "<group>";
};
9286EB7C2114021E00752977 /* communicate */ = {
isa = PBXGroup;
children = (
9286EB7F2114022F00752977 /* communicate.h */,
9286EB7D2114022A00752977 /* communicate.c */,
);
name = communicate;
sourceTree = "<group>";
};
92A15CFC211442C700826FB8 /* graph */ = {
isa = PBXGroup;
children = (
);
name = graph;
sourceTree = "<group>";
};
/* End PBXGroup section */
/* Begin PBXNativeTarget section */
927993BC20CB87D6008CE3A9 /* ZE-Standard-Libraries */ = {
isa = PBXNativeTarget;
buildConfigurationList = 927993C420CB87D6008CE3A9 /* Build configuration list for PBXNativeTarget "ZE-Standard-Libraries" */;
buildPhases = (
927993B920CB87D6008CE3A9 /* Sources */,
927993BA20CB87D6008CE3A9 /* Frameworks */,
927993BB20CB87D6008CE3A9 /* CopyFiles */,
);
buildRules = (
);
dependencies = (
);
name = "ZE-Standard-Libraries";
productName = "ZE-Standard-Libraries";
productReference = 927993BD20CB87D6008CE3A9 /* ZE-Standard-Libraries */;
productType = "com.apple.product-type.tool";
};
/* End PBXNativeTarget section */
/* Begin PBXProject section */
927993B520CB87D6008CE3A9 /* Project object */ = {
isa = PBXProject;
attributes = {
LastUpgradeCheck = 0940;
ORGANIZATIONNAME = ZE;
TargetAttributes = {
927993BC20CB87D6008CE3A9 = {
CreatedOnToolsVersion = 9.4;
};
};
};
buildConfigurationList = 927993B820CB87D6008CE3A9 /* Build configuration list for PBXProject "ZE-Standard-Libraries" */;
compatibilityVersion = "Xcode 9.3";
developmentRegion = en;
hasScannedForEncodings = 0;
knownRegions = (
en,
);
mainGroup = 927993B420CB87D6008CE3A9;
productRefGroup = 927993BE20CB87D6008CE3A9 /* Products */;
projectDirPath = "";
projectRoot = "";
targets = (
927993BC20CB87D6008CE3A9 /* ZE-Standard-Libraries */,
);
};
/* End PBXProject section */
/* Begin PBXSourcesBuildPhase section */
927993B920CB87D6008CE3A9 /* Sources */ = {
isa = PBXSourcesBuildPhase;
buildActionMask = 2147483647;
files = (
9269D4F6210F1CD900161557 /* stack.c in Sources */,
9286EB7A211400C900752977 /* error.c in Sources */,
9269D4E8210F1B3D00161557 /* stack_expand.c in Sources */,
9286EB7E2114022A00752977 /* communicate.c in Sources */,
9269D4EA210F1B4B00161557 /* list_expand.c in Sources */,
9269D4F4210F1BB000161557 /* id.c in Sources */,
9269D4F8210F1D0B00161557 /* tree_expand.c in Sources */,
9246995F20CE655900B4E894 /* tree.c in Sources */,
9269D4ED210F1B5E00161557 /* test.c in Sources */,
9269D4F5210F1BCE00161557 /* list.c in Sources */,
);
runOnlyForDeploymentPostprocessing = 0;
};
/* End PBXSourcesBuildPhase section */
/* Begin XCBuildConfiguration section */
927993C220CB87D6008CE3A9 /* Debug */ = {
isa = XCBuildConfiguration;
buildSettings = {
ALWAYS_SEARCH_USER_PATHS = NO;
CLANG_ANALYZER_NONNULL = YES;
CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
CLANG_CXX_LIBRARY = "libc++";
CLANG_ENABLE_MODULES = YES;
CLANG_ENABLE_OBJC_ARC = YES;
CLANG_ENABLE_OBJC_WEAK = YES;
CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
CLANG_WARN_BOOL_CONVERSION = YES;
CLANG_WARN_COMMA = YES;
CLANG_WARN_CONSTANT_CONVERSION = YES;
CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
CLANG_WARN_EMPTY_BODY = YES;
CLANG_WARN_ENUM_CONVERSION = YES;
CLANG_WARN_INFINITE_RECURSION = YES;
CLANG_WARN_INT_CONVERSION = YES;
CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
CLANG_WARN_STRICT_PROTOTYPES = YES;
CLANG_WARN_SUSPICIOUS_MOVE = YES;
CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
CLANG_WARN_UNREACHABLE_CODE = YES;
CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
CODE_SIGN_IDENTITY = "-";
COPY_PHASE_STRIP = NO;
DEBUG_INFORMATION_FORMAT = dwarf;
ENABLE_STRICT_OBJC_MSGSEND = YES;
ENABLE_TESTABILITY = YES;
GCC_C_LANGUAGE_STANDARD = gnu11;
GCC_DYNAMIC_NO_PIC = NO;
GCC_NO_COMMON_BLOCKS = YES;
GCC_OPTIMIZATION_LEVEL = 0;
GCC_PREPROCESSOR_DEFINITIONS = (
"DEBUG=1",
"$(inherited)",
);
GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
GCC_WARN_UNDECLARED_SELECTOR = YES;
GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
GCC_WARN_UNUSED_FUNCTION = YES;
GCC_WARN_UNUSED_VARIABLE = YES;
MACOSX_DEPLOYMENT_TARGET = 10.13;
MTL_ENABLE_DEBUG_INFO = YES;
ONLY_ACTIVE_ARCH = YES;
SDKROOT = macosx;
};
name = Debug;
};
927993C320CB87D6008CE3A9 /* Release */ = {
isa = XCBuildConfiguration;
buildSettings = {
ALWAYS_SEARCH_USER_PATHS = NO;
CLANG_ANALYZER_NONNULL = YES;
CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
CLANG_CXX_LIBRARY = "libc++";
CLANG_ENABLE_MODULES = YES;
CLANG_ENABLE_OBJC_ARC = YES;
CLANG_ENABLE_OBJC_WEAK = YES;
CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
CLANG_WARN_BOOL_CONVERSION = YES;
CLANG_WARN_COMMA = YES;
CLANG_WARN_CONSTANT_CONVERSION = YES;
CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
CLANG_WARN_EMPTY_BODY = YES;
CLANG_WARN_ENUM_CONVERSION = YES;
CLANG_WARN_INFINITE_RECURSION = YES;
CLANG_WARN_INT_CONVERSION = YES;
CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
CLANG_WARN_STRICT_PROTOTYPES = YES;
CLANG_WARN_SUSPICIOUS_MOVE = YES;
CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
CLANG_WARN_UNREACHABLE_CODE = YES;
CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
CODE_SIGN_IDENTITY = "-";
COPY_PHASE_STRIP = NO;
DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
ENABLE_NS_ASSERTIONS = NO;
ENABLE_STRICT_OBJC_MSGSEND = YES;
GCC_C_LANGUAGE_STANDARD = gnu11;
GCC_NO_COMMON_BLOCKS = YES;
GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
GCC_WARN_UNDECLARED_SELECTOR = YES;
GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
GCC_WARN_UNUSED_FUNCTION = YES;
GCC_WARN_UNUSED_VARIABLE = YES;
MACOSX_DEPLOYMENT_TARGET = 10.13;
MTL_ENABLE_DEBUG_INFO = NO;
SDKROOT = macosx;
};
name = Release;
};
927993C520CB87D6008CE3A9 /* Debug */ = {
isa = XCBuildConfiguration;
buildSettings = {
CODE_SIGN_STYLE = Automatic;
PRODUCT_NAME = "$(TARGET_NAME)";
};
name = Debug;
};
927993C620CB87D6008CE3A9 /* Release */ = {
isa = XCBuildConfiguration;
buildSettings = {
CODE_SIGN_STYLE = Automatic;
PRODUCT_NAME = "$(TARGET_NAME)";
};
name = Release;
};
/* End XCBuildConfiguration section */
/* Begin XCConfigurationList section */
927993B820CB87D6008CE3A9 /* Build configuration list for PBXProject "ZE-Standard-Libraries" */ = {
isa = XCConfigurationList;
buildConfigurations = (
927993C220CB87D6008CE3A9 /* Debug */,
927993C320CB87D6008CE3A9 /* Release */,
);
defaultConfigurationIsVisible = 0;
defaultConfigurationName = Release;
};
927993C420CB87D6008CE3A9 /* Build configuration list for PBXNativeTarget "ZE-Standard-Libraries" */ = {
isa = XCConfigurationList;
buildConfigurations = (
927993C520CB87D6008CE3A9 /* Debug */,
927993C620CB87D6008CE3A9 /* Release */,
);
defaultConfigurationIsVisible = 0;
defaultConfigurationName = Release;
};
/* End XCConfigurationList section */
};
rootObject = 927993B520CB87D6008CE3A9 /* Project object */;
}

7
ZE-Standard-Libraries.xcodeproj/project.xcworkspace/contents.xcworkspacedata generated
View File

@ -1,7 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<Workspace
version = "1.0">
<FileRef
location = "self:">
</FileRef>
</Workspace>

8
ZE-Standard-Libraries.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist
View File

@ -1,8 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>IDEDidComputeMac32BitWarning</key>
<true/>
</dict>
</plist>

148
ZE-Standard-Libraries.xcodeproj/project.xcworkspace/xcuserdata/huyibing.xcuserdatad/xcdebugger/Expressions.xcexplist
View File

@ -1,148 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<VariablesViewState
version = "1.0">
<ContextStates>
<ContextState
contextName = "init_node:list.h">
<PersistentStrings>
<PersistentString
value = "list_list">
</PersistentString>
</PersistentStrings>
</ContextState>
<ContextState
contextName = "listToSTD:communicate.c">
<PersistentStrings>
<PersistentString
value = "(int *)p_node-&gt;value">
</PersistentString>
</PersistentStrings>
</ContextState>
<ContextState
contextName = "releaseMalloc:list.h">
</ContextState>
<ContextState
contextName = "initS_id:id.c">
</ContextState>
<ContextState
contextName = "getByIntForNode:list_expand.c">
<PersistentStrings>
<PersistentString
value = "(int *)p_node-&gt;value">
</PersistentString>
</PersistentStrings>
</ContextState>
<ContextState
contextName = "listThrough:list_expand.c">
</ContextState>
<ContextState
contextName = "initStandardDBlocks:communicate.c">
</ContextState>
<ContextState
contextName = "dataForStandardDBlock:communicate.c">
<PersistentStrings>
<PersistentString
value = "(int *)p_stdb-&gt;buff">
</PersistentString>
</PersistentStrings>
</ContextState>
<ContextState
contextName = "insertInTail:list.h">
<PersistentStrings>
<PersistentString
value = "node_list">
</PersistentString>
<PersistentString
value = "list_list">
</PersistentString>
</PersistentStrings>
</ContextState>
<ContextState
contextName = "releaseNULLList:list.h">
</ContextState>
<ContextState
contextName = "asciiStringToS_id:id.c">
<PersistentStrings>
<PersistentString
value = "buff[string_len-1]">
</PersistentString>
<PersistentString
value = "5 + i * 5 + j">
</PersistentString>
<PersistentString
value = "s_id-&gt;value[i]">
</PersistentString>
<PersistentString
value = "strlen(string)">
</PersistentString>
</PersistentStrings>
</ContextState>
<ContextState
contextName = "_doStandardDBlockWrite:communicate.c">
<PersistentStrings>
<PersistentString
value = "&amp;p_stdb-&gt;blocks_num">
</PersistentString>
</PersistentStrings>
</ContextState>
<ContextState
contextName = "dataFileReadOut:communicate.c">
<PersistentStrings>
<PersistentString
value = "strlen(string_sid)">
</PersistentString>
<PersistentString
value = "(int *)content">
</PersistentString>
</PersistentStrings>
</ContextState>
<ContextState
contextName = "_doStandardDataInfoWrite:communicate.c">
</ContextState>
<ContextState
contextName = "standardDataAddBlock:communicate.c">
<PersistentStrings>
<PersistentString
value = "(int *)data">
</PersistentString>
<PersistentString
value = "(int *)p_stdb-&gt;buff">
</PersistentString>
</PersistentStrings>
</ContextState>
<ContextState
contextName = "dataFileWriteIn:communicate.c">
</ContextState>
<ContextState
contextName = "freeS_id:id.c">
</ContextState>
<ContextState
contextName = "s_idToASCIIString:id.c">
<PersistentStrings>
<PersistentString
value = "sizeof(char)">
</PersistentString>
<PersistentString
value = "buff[buff_count]">
</PersistentString>
</PersistentStrings>
</ContextState>
<ContextState
contextName = "main:test.c">
<PersistentStrings>
<PersistentString
value = "(int *)p_node-&gt;value">
</PersistentString>
<PersistentString
value = "((STD_DATA *)(p_dfiler-&gt;pf_stdlst-&gt;head-&gt;value))-&gt;pd_blocklst">
</PersistentString>
<PersistentString
value = "strlen(string)">
</PersistentString>
</PersistentStrings>
</ContextState>
<ContextState
contextName = "init_list:list.h">
</ContextState>
</ContextStates>
</VariablesViewState>

1098
ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist
View File

File diff suppressed because it is too large Load Diff

14
ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcschemes/xcschememanagement.plist
View File

@ -1,14 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>SchemeUserState</key>
<dict>
<key>ZE-Standard-Libraries.xcscheme</key>
<dict>
<key>orderHint</key>
<integer>0</integer>
</dict>
</dict>
</dict>
</plist>

338
communicate/communicate.c
View File

@ -1,338 +0,0 @@
#include "communicate.h"
STD_BLOCKS *initStandardDBlocks(SID *p_sid, unsigned int type, unsigned long long data_size){
STD_BLOCKS *p_stdb = (STD_BLOCKS *)malloc(sizeof(STD_BLOCKS));
p_stdb->sid = s_idToASCIIString(p_sid);
p_stdb->if_data = 0;
unsigned int blocks_num = (unsigned int)(data_size/sizeof(char));
p_stdb->blocks_num = blocks_num;
p_stdb->type = type;
p_stdb->buff = (char *)malloc(sizeof(char) * blocks_num);
return p_stdb;
}
int dataForStandardDBlock(STD_BLOCKS *p_stdb,void *data){
char *t_data = (char *)data;
/*unsigned int data_size = sizeof(data);*/
for(int i = 0; i < p_stdb->blocks_num; i++){
p_stdb->buff[i] = t_data[i];
}
p_stdb->if_data = 1;
return 0;
}
STD_CTN *initStandardDConnection(SID *f_sid, SID *s_sid){
STD_CTN *p_stdc = (STD_CTN *)malloc(sizeof(STD_CTN));
p_stdc->f_sid = s_idToASCIIString(f_sid);
p_stdc->s_sid = s_idToASCIIString(s_sid);
return p_stdc;
}
STD_DATA *initStandardData(unsigned int type){
STD_DATA *p_std = (STD_DATA *)malloc(sizeof(STD_DATA));
p_std->pd_blocklst = initList();
p_std->pd_ctnlst = initList();
p_std->lock = 0;
p_std->type = type;
p_std->s_id = getS_id(STANDARD_DATA, 1);
return p_std;
}
int standardDataAddBlock(STD_DATA *p_std, SID *p_sid ,unsigned int type, void *data, unsigned long long data_size){
if (p_std->lock) return -1;
STD_BLOCKS *p_stdb = initStandardDBlocks(p_sid, type,data_size);
dataForStandardDBlock(p_stdb, data);
insertInTail(p_std->pd_blocklst, nodeWithPointer(p_stdb));
return 0;
}
int standardDataAddConnection(STD_DATA *p_std, SID *f_sid, SID *s_sid){
if (p_std->lock) return -1;
STD_CTN *p_stdb = initStandardDConnection(f_sid, s_sid);
insertInTail(p_std->pd_ctnlst, nodeWithPointer(p_stdb));
return 0;
}
D_FILE *initDataFileForWrite(char *route){
D_FILE *p_dfile = (D_FILE *)malloc(sizeof(D_FILE));
p_dfile->fp = fopen(route, "wb");
p_dfile->pf_head = (F_HEAD *)malloc(sizeof(F_HEAD));
strcpy(p_dfile->pf_head->head_test,"ZESTDLIB_STDDFILE");
p_dfile->pf_head->data_num = 0;
p_dfile->pf_stdlst = initList();
return p_dfile;
}
D_FILE *initDataFileForRead(char *route){
D_FILE *p_dfile = (D_FILE *)malloc(sizeof(D_FILE));
p_dfile->fp = fopen(route, "rb");
p_dfile->pf_head = (F_HEAD *)malloc(sizeof(F_HEAD));
p_dfile->pf_head->data_num = 0;
p_dfile->pf_stdlst = initList();
return p_dfile;
}
int dataFileAddStandardData(D_FILE *p_dfile, STD_DATA *p_std){
insertInTail(p_dfile->pf_stdlst, nodeWithPointer(p_std));
p_dfile->pf_head->data_num = p_dfile->pf_stdlst->length;
return 0;
}
int dataFileWriteIn(D_FILE *p_dfile){
fwrite(p_dfile->pf_head->head_test, sizeof(char), 18, p_dfile->fp);
fwrite(&p_dfile->pf_head->data_num, sizeof(unsigned long long), 1, p_dfile->fp);
fwrite("HEAD_END", sizeof(char), 9, p_dfile->fp);
List *er_list = initList();
insertInTail(er_list, nodeWithPointer(p_dfile->fp));
/*fwrite("STDINFO", sizeof(char), 8, p_dfile->fp);
listThrough(p_dfile->pf_stdlst, _doStandardDataInfoWrite, er_list);*/
/*fwrite("STDLST", sizeof(char), 7, p_dfile->fp);*/
listThrough(p_dfile->pf_stdlst, _doStandardDataWrite, er_list);
releaseList(er_list);
return 0;
}
List *_doStandardDataInfoWrite(unsigned int type, void *value, List *er_list){
List *p_rtnlst = initList();
FILE *fp = getByPointerForNode(findByIndexForNode(er_list, 0));
STD_DATA *p_std = value;
insertInTail(p_rtnlst, nodeWithInt(0));
char *string_sid = s_idToASCIIString(p_std->s_id);
fwrite(string_sid, sizeof(char), DEEPER_LEN, fp);
free(string_sid);
fwrite(&p_std->type, sizeof(unsigned long), 1, fp);
fwrite(&p_std->pd_ctnlst->length, sizeof(unsigned long long), 1, fp);
fwrite(&p_std->pd_blocklst->length, sizeof(unsigned long long), 1, fp);
return p_rtnlst;
}
List *_doStandardDataWrite(unsigned int type, void *value, List *er_list){
List *p_rtnlst = initList();
FILE *fp = getByPointerForNode(findByIndexForNode(er_list, 0));
insertInTail(p_rtnlst, nodeWithInt(0));
STD_DATA *p_std = value;
List *erc_list = initList();
insertInTail(erc_list, nodeWithPointer(fp));
fwrite("STD", sizeof(char), 4, fp);
char *string_sid = s_idToASCIIString(p_std->s_id);
unsigned long sid_len = strlen(string_sid) + 1;
fwrite(&sid_len, sizeof(unsigned long), 1, fp);
char *sid_w = s_idToASCIIString(p_std->s_id);
fwrite(sid_w, sizeof(char), sid_len, fp);
fwrite(&p_std->type, sizeof(unsigned int), 1, fp);
fwrite(&p_std->pd_ctnlst->length, sizeof(unsigned long long), 1, fp);
fwrite(&p_std->pd_blocklst->length, sizeof(unsigned long long), 1, fp);
listThrough(p_std->pd_ctnlst, _doStandardDConnectionWrite, erc_list);
listThrough(p_std->pd_blocklst, _doStandardDBlockWrite, erc_list);
releaseList(erc_list);
free(sid_w);
free(string_sid);
return p_rtnlst;
}
List *_doStandardDConnectionWrite(unsigned int type, void *value, List *er_list){
List *p_rtnlst = initList();
insertInTail(p_rtnlst, nodeWithInt(0));
FILE *fp = getByPointerForNode(findByIndexForNode(er_list, 0));
STD_CTN *p_stdc = value;
unsigned long fsid_len = strlen(p_stdc->f_sid) + 1, ssid_len = strlen(p_stdc->s_sid)+1;
fwrite(&fsid_len, sizeof(unsigned long), 1, fp);
fwrite(p_stdc->f_sid, sizeof(char), fsid_len, fp);
fwrite(&ssid_len, sizeof(unsigned long), 1, fp);
fwrite(p_stdc->s_sid, sizeof(char), ssid_len, fp);
return p_rtnlst;
}
List *_doStandardDBlockWrite(unsigned int type, void *value, List *er_list){
List *p_rtnlst = initList();
insertInTail(p_rtnlst, nodeWithInt(0));
STD_BLOCKS *p_stdb = value;
FILE *fp = getByPointerForNode(findByIndexForNode(er_list, 0));
unsigned long sid_len = strlen(p_stdb->sid)+1, blocks_num = p_stdb->blocks_num;
fwrite(&sid_len, sizeof(unsigned long), 1, fp);
fwrite(p_stdb->sid, sizeof(char), sid_len, fp);
fwrite(&p_stdb->type, sizeof(unsigned int), 1, fp);
fwrite(&blocks_num, sizeof(unsigned long), 1, fp);
fwrite(p_stdb->buff, sizeof(char), p_stdb->blocks_num, fp);
return p_rtnlst;
}
STD_DATA *listToSTD(List *p_list){
STD_DATA *p_std = initStandardData(LIST);
Node *p_node = p_list->head;
while (p_node != NULL) {
unsigned long long data_size = 0;
if(p_node->type == INT) data_size = sizeof(int);
else if (p_node->type == DOUBLE) data_size = sizeof(double);
else if (p_node->type == STRING) data_size = strlen((char *)p_node->value) + 1;
else data_size = sizeof(void *);
standardDataAddBlock(p_std, p_node->s_id, p_node->type, p_node->value, data_size);
p_node = p_node->next;
}
return p_std;
}
int dataFileReadOut(D_FILE *p_dfile){
char test_info[FILE_TSET_LEN],head_test_info[HEAD_TEST_LEN];
fread(test_info, sizeof(char), FILE_TSET_LEN, p_dfile->fp);
strcpy(p_dfile->pf_head->head_test, test_info);
if(!strcmp(test_info, "ZESTDLIB_STDDFILE")){
unsigned long long std_num = 0;
fread(&std_num, sizeof(unsigned long long), 1, p_dfile->fp);
p_dfile->pf_head->data_num = std_num;
fread(head_test_info, sizeof(char), 9, p_dfile->fp);
if (!strcmp(head_test_info, "HEAD_END")) {
for(int i = 0; i < std_num; i++){
char std_test_info[4];
fread(std_test_info, sizeof(char), 4, p_dfile->fp);
if(!strcmp(std_test_info, "STD")){
unsigned long long sid_len = 0, ctn_num = 0, blk_num = 0;
unsigned int type = 0;
fread(&sid_len, sizeof(unsigned long), 1, p_dfile->fp);
char *string_sid = (char *)malloc(sizeof(char) * sid_len);
fread(string_sid, sizeof(char), sid_len, p_dfile->fp);
fread(&type, sizeof(unsigned int), 1, p_dfile->fp);
STD_DATA *p_std = initStandardData(type);
freeS_id(p_std->s_id);
p_std->s_id = asciiStringToS_id(string_sid);
dataFileAddStandardData(p_dfile, p_std);
free(string_sid);
fread(&ctn_num, sizeof(unsigned long long), 1, p_dfile->fp);
fread(&blk_num, sizeof(unsigned long long), 1, p_dfile->fp);
for(int j = 0; j < ctn_num; j++){
fread(&sid_len, sizeof(unsigned long), 1, p_dfile->fp);
char *fstring_sid = (char *)malloc(sizeof(char) * sid_len);
fread(fstring_sid, sizeof(char), sid_len, p_dfile->fp);
fread(&sid_len, sizeof(unsigned long), 1, p_dfile->fp);
char *sstring_sid = (char *)malloc(sizeof(char) * sid_len);
fread(sstring_sid, sizeof(char), sid_len, p_dfile->fp);
SID *fs_id = asciiStringToS_id(fstring_sid), *ss_id = asciiStringToS_id(sstring_sid);
standardDataAddConnection(p_std, fs_id,ss_id);
freeS_id(fs_id);
freeS_id(ss_id);
free(fstring_sid);
free(sstring_sid);
}
for(int k = 0; k < blk_num; k++){
fread(&sid_len, sizeof(unsigned long), 1, p_dfile->fp);
char *string_sid = (char *)malloc(sizeof(char) * sid_len);
fread(string_sid, sizeof(char), sid_len, p_dfile->fp);
unsigned long blk_len = 0;
fread(&blk_len, sizeof(unsigned long), 1, p_dfile->fp);
char *content = (char *)malloc(sizeof(char) * blk_len);
fread(content, sizeof(char), blk_len, p_dfile->fp);
SID *s_id = asciiStringToS_id(string_sid);
unsigned int type = VOID;
fread(&type, sizeof(unsigned int), 1, p_dfile->fp);
standardDataAddBlock(p_std, s_id, type, content, blk_len);
freeS_id(s_id);
free(string_sid);
free(content);
}
return 0;
}
else break;
}
}
else{
}
}
showError(pushError(DATA_FILE, STANDARD, initInfo("dataFileReadOut()", "Datafile not complete.")));
return -1;
}
int releaseSTDConnection(STD_CTN *p_stdc){
free(p_stdc->f_sid);
free(p_stdc->s_sid);
free(p_stdc);
return 0;
}
int releaseSTDBlocks(STD_BLOCKS *p_stdb){
free(p_stdb->sid);
free(p_stdb->buff);
free(p_stdb);
return 0;
}
int releaseStandardData(STD_DATA *p_std){
freeS_id(p_std->s_id);
releaseListForCustom(p_std->pd_blocklst, (int (*)(void *))releaseSTDBlocks);
releaseListForCustom(p_std->pd_ctnlst, (int (*)(void *))releaseSTDConnection);
free(p_std);
return 0;
}
int releaseDFile(D_FILE *p_dfile){
releaseListForCustom(p_dfile->pf_stdlst, (int (*)(void *))releaseStandardData);
fclose(p_dfile->fp);
free(p_dfile->pf_head);
free(p_dfile);
return 0;
}
List *standardDataToList(STD_DATA *p_std){
List *p_list = initList();
List *er_list = initList();
insertInTail(er_list, nodeWithPointer(er_list));
listThrough(p_std->pd_blocklst, _doStandardDataToList, er_list);
return p_list;
}
List *_doStandardDataToList(unsigned int type, void *value, List *er_list){
List *rtn_list = initList();
insertInTail(rtn_list, nodeWithInt(0));
List *p_list = getByPointerForNode(findByIndexForNode(er_list, 0));
STD_BLOCKS *p_stdb = value;
Node *p_node = initNode();
p_node->s_id = asciiStringToS_id(p_stdb->sid);
p_node->type = p_stdb->type;
p_node->value = malloc(sizeof(p_stdb->blocks_num));
memcpy(p_node->value, p_stdb->buff, sizeof(p_stdb->blocks_num));
insertInTail(p_list, p_node);
return rtn_list;
}
MSG *createMessage(char *title, void *data, unsigned long data_size){
MSG *p_msg = malloc(sizeof(MSG) + data_size);
p_msg->p_sid = getS_id(MESSAGE, 1);
p_msg->time = time(NULL);
return p_msg;
}
/*int sendMessageIPv4(MSG *p_msg, char *ip, unsigned int port){
int client_sockfd;
struct sockaddr_in remote_addr;
char buf[BUFSIZ];
memcpy(buf, "ZEMSG", 5);
memset(&remote_addr,0,sizeof(remote_addr));
remote_addr.sin_family=AF_INET;
remote_addr.sin_addr.s_addr=inet_addr(ip);
remote_addr.sin_port=htons(port);
client_sockfd=socket(PF_INET,SOCK_STREAM,0);
connect(client_sockfd,(struct sockaddr *)&remote_addr,sizeof(struct sockaddr));
send(client_sockfd,buf,strlen(buf),0);
unsigned long bkmsg_len = 0;
bkmsg_len = recv(client_sockfd, buf, BUFSIZ, 0);
buf[bkmsg_len] = '\0';
if(!strcmp(buf, "TITLE_REV_READY")){
memcpy(buf, p_msg->titile, strlen(p_msg->titile));
bkmsg_len = recv(client_sockfd, buf, BUFSIZ, 0);
buf[bkmsg_len] = '\0';
if(!strcmp(buf, "CONTENT_LEN_REV_READY")){
memcpy(buf, (char *)p_msg->size, sizeof(unsigned int));
send(client_sockfd,buf,sizeof(unsigned int),0);
bkmsg_len = recv(client_sockfd, buf, BUFSIZ, 0);
buf[bkmsg_len] = '\0';
if(!strcmp(buf, "CONTENT_REV_READY")){
memcpy(buf, p_msg->content, p_msg->size);
send(client_sockfd,buf,p_msg->size,0);
close(client_sockfd);
return 0;
}
}
}
close(client_sockfd);
return -1;
}*/

47
communicate/communicate.h
View File

@ -1,47 +0,0 @@
#ifndef communicate_h
#define communicate_h
#include "../type/type.h"
#include "../list/list_expand.h"
typedef struct message{
SID *p_sid;
time_t time;
char titile[16];
unsigned long size;
char content[0];
}MSG;
D_FILE *initDataFileForWrite(char *route);
D_FILE *initDataFileForRead(char *route);
STD_BLOCKS *initStandardDBlocks(SID *p_sid, unsigned int type, unsigned long long data_size);
STD_CTN *initStandardDConnection(SID *f_sid, SID *s_sid);
STD_DATA *initStandardData(unsigned int type);
int dataForStandardDBlock(STD_BLOCKS *p_stdb,void *data);
int dataFileAddStandardData(D_FILE *p_dfile, STD_DATA *p_std);
int standardDataAddBlock(STD_DATA *p_std, SID *p_sid ,unsigned int type, void *data, unsigned long long data_size);
int standardDataAddConnection(STD_DATA *p_std, SID *f_sid, SID *s_sid);
int dataFileWriteIn(D_FILE *p_dfile);
int dataFileReadOut(D_FILE *p_dfile);
int releaseSTDBlocks(STD_BLOCKS *p_stdb);
int releaseStandardData(STD_DATA *p_std);
int releaseSTDConnection(STD_CTN *p_stdc);
int releaseDFile(D_FILE *p_file);
List *_doStandardDataInfoWrite(unsigned int type, void *value, List *er_list);
List *_doStandardDataWrite(unsigned int type, void *value, List *er_list);
List *_doStandardDConnectionWrite(unsigned int type, void *value, List *er_list);
List *_doStandardDBlockWrite(unsigned int type, void *value, List *er_list);
STD_DATA *listToSTD(List *);
List *standardDataToList(STD_DATA *);
List *_doStandardDataToList(unsigned int type, void *value, List *er_list);
MSG *createMessage(char *title, void *data, unsigned long data_size);
int sendMessageIPv4(MSG *p_msg, char *ip, unsigned int port);
//STD_DATA *stackToSTD(Stack *);
//STD_DATA *treeToSTD(Tree *);
#endif /* communicate_h */

253
id/id.c
View File

@ -1,253 +0,0 @@
#include "id.h"
void init_rand(void) {
srand((unsigned)time(NULL));
}
unsigned long long getId(void) {
int i;
unsigned long long id = 0;
id = ((rand() % 9) + 1);
for (i = 0; i < 15; i++) {
id *= 10;
id += rand() % 10;
}
return id;
}
SID *initS_id(unsigned int deep_level){
SID *p_sid = (SID *) malloc(sizeof(SID));
if(p_sid == NULL){
printf("\ninitS_id(): Error in getting the memory of sid.\n");
}
p_sid->type = VOID;
p_sid->deep = deep_level;
p_sid->value = NULL;
p_sid->value_deeper = NULL;
p_sid->value_deepest = NULL;
if (deep_level > 0) {
p_sid->value = (unsigned int *)malloc(sizeof(unsigned int)*DEEPC_LEN);
if(p_sid->value == NULL){
printf("\ninitS_id(): Error in getting the memory of sid.value.\n");
}
}
if (deep_level > 1){
p_sid->value_deeper = (unsigned int *)malloc(sizeof(unsigned int)*DEEPB_LEN);
if(p_sid->value_deeper == NULL){
printf("\ninitS_id(): Error in getting the memory of sid.value_deeper.\n");
}
}
if (deep_level > 2){
p_sid->value_deepest = (unsigned int *)malloc(sizeof(unsigned int)*DEEPA_LEN);
if(p_sid->value_deepest == NULL){
printf("\ninitS_id(): Error in getting the memory of sid.value_deepest.\n");
}
}
return p_sid;
}
SID *getS_id(unsigned int type, unsigned int deep_level){
SID *p_sid = initS_id(deep_level);
p_sid->type = type;
if(deep_level > 0){
for(int i = 0; i < DEEPC_LEN; i++) p_sid->value[i] = rand()%65535;
if(deep_level > 1) for(int i = 0; i < DEEPB_LEN; i++) p_sid->value_deeper[i] = rand()%65535;
if (deep_level > 2) for(int i = 0; i < DEEPA_LEN; i++) p_sid->value_deepest[i] = rand()%65535;
}
return p_sid;
}
int fitS_id(const SID *fs_id, const SID *ss_id){
if(fs_id->type == ss_id->type){
if(fs_id->deep == ss_id->deep){
if (fs_id->deep > 0)
for(int i = 0; i < DEEPC_LEN; i++){
if(fs_id->value[i] == ss_id->value[i]) continue;
else if(fs_id->value[i] > ss_id->value[i]) return 1;
else return -1;
}
if (fs_id->deep > 1)
for(int i = 0; i < DEEPB_LEN; i++){
if(fs_id->value_deeper[i] == ss_id->value_deeper[i]) continue;
else if(fs_id->value_deeper[i] > ss_id->value_deeper[i]) return 1;
else return -1;
}
if (fs_id->deep > 2)
for(int i = 0; i < DEEPA_LEN; i++){
if(fs_id->value_deepest[i] == ss_id->value_deepest[i]) continue;
else if(fs_id->value_deepest[i] > ss_id->value_deepest[i]) return 1;
else return -1;
}
}
else{
if(fs_id->deep > ss_id->deep) return 1;
else return -1;
}
}
else{
if (fs_id->type > ss_id->type) return 1;
else return -1;
}
return 0;
}
int simFitS_id(const SID *fs_id, const SID *ss_id){
return !fitS_id(fs_id, ss_id);
}
char *s_idToASCIIString(const SID *s_id){
char *string = NULL;
int deep_len = 0, temp, buff_count, string_count;
unsigned int buff[DATA_BIT];
if(s_id->deep > 0){
if (s_id->deep == DEEPC){
string = (char *) malloc(sizeof(char) * (DEEPC_LEN + 1) * DATA_BIT);
deep_len = DEEPC_LEN + 1;
deep_len *= DATA_BIT;
}
else if (s_id->deep == DEEPB){
string = (char *) malloc(sizeof(char) * (DEEPC_LEN + DEEPB_LEN + 1) * DATA_BIT);
deep_len = DEEPC_LEN + DEEPB_LEN + 1;
deep_len *= DATA_BIT;
}
else{
string = (char *)malloc(sizeof(char) * (DEEPC_LEN + DEEPB_LEN + DEEPA_LEN + 1) * DATA_BIT);
deep_len = DEEPC_LEN + DEEPB_LEN + DEEPA_LEN + 1;
deep_len *= DATA_BIT;
}
if(string == NULL){
printf("\ns_idToASCIIString(): Error in getting the memory of string.\n");
}
string[deep_len] = '\0';
temp = s_id->type;
buff_count = DATA_BIT - 1;
for (int i = 0; i < DATA_BIT; i++) buff[i] = 0;
while(buff_count >= 0){
buff[buff_count] = temp % 10;
string[buff_count] = buff[buff_count] + 48;
temp /= 10;
buff_count--;
}
deep_len -= DATA_BIT;
for(int i = 0; i < DEEPC_LEN; i++){
temp = s_id->value[i];
for (int i = 0; i < DATA_BIT; i++) buff[i] = 0;
string_count = TYPE_LEN + (i) * 5;
buff_count = DATA_BIT - 1;
while (buff_count >= 0) {
buff[buff_count] = temp % 10;
temp /= 10;
buff_count--;
}
for(int i = DATA_BIT - 1; i >= 0; i--) string[string_count + i] = buff[i] + 48;
}
deep_len -= DEEPC_LEN * DATA_BIT;
if(deep_len > 0)
for(int i = 0; i < DEEPB_LEN; i++){
temp = s_id->value_deeper[i];
for (int i = 0; i < DATA_BIT; i++) buff[i] = 0;
string_count = TYPE_LEN + DEEPC_LEN * DATA_BIT + (i) * DATA_BIT;
buff_count = DATA_BIT - 1;
while (buff_count >= 0) {
buff[buff_count] = temp % 10;
temp /= 10;
buff_count--;
}
for(int i = DATA_BIT - 1; i >= 0; i--) string[string_count + i] = buff[i] + 48;
}
deep_len -= DEEPB_LEN * DATA_BIT;
if(deep_len > 0)
for(int i = 0; i < DEEPA_LEN; i++){
temp = s_id->value_deepest[i];
for (int i = 0; i < DATA_BIT; i++) buff[i] = 0;
string_count = TYPE_LEN + (DEEPC_LEN + DEEPB_LEN) * DATA_BIT + (i) * DATA_BIT;
buff_count = DATA_BIT - 1;
while (buff_count >= 0) {
buff[buff_count] = temp % 10;
string[string_count] = buff[buff_count] + 48;
temp /= 10;
buff_count--;
}
for(int i = DATA_BIT - 1; i >= 0; i--) string[string_count + i] = buff[i] + 48;
}
return string;
}
else{
return NULL;
}
}
SID *asciiStringToS_id(const char *string){
SID *s_id = NULL;
unsigned long long string_len = strlen(string);
if (string_len == 25) s_id = initS_id(1);
else if (string_len == 65) s_id = initS_id(2);
else if (string_len == 225) s_id = initS_id(3);
else return NULL;
unsigned int *buff = (unsigned int *) malloc(sizeof(unsigned int) * (string_len));
if(buff == NULL){
printf("\ns_idToASCIIString(): Error in getting the memory of string.\n");
}
for(int i = 0; i < string_len; i++){
buff[i] = (unsigned int)string[i] - 48;
}
s_id->type = 0;
for (int i = 0; i < 5; i++){
s_id->type += buff[i] ;
s_id->type *= 10u;
}
s_id->type /= 10u;
if (string_len >= 25){
for(int i = 0; i < DEEPC_LEN; i++){
s_id->value[i] = 0;
for (int j = 0; j < 5; j++){
s_id->value[i] += (unsigned int)buff[5 + i * 5 + j];
if(j < 4) s_id->value[i] *= 10;
}
}
}
if (string_len >= 65){
for(int i = 0; i < DEEPB_LEN; i++){
s_id->value_deeper[i] = 0;
for (int j = 0; j < 5; j++){
s_id->value_deeper[i] += buff[25 + i * 5 + j];
if(j < 4) s_id->value_deeper[i] *= 10;
}
}
}
if (string_len >= 225){
for(int i = 0; i < DEEPA_LEN; i++){
s_id->value_deepest[i] = 0;
for (int j = 0; j < 5; j++){
s_id->value_deepest[i] += buff[65 + i * 5 + j];
if(j < 4) s_id->value_deepest[i] *= 10;
}
}
}
free(buff);
return s_id;
}
int freeS_id(SID *s_id){
if(s_id->value != NULL){
free(s_id->value);
s_id->value = NULL;
}
if(s_id->value_deeper != NULL){
free(s_id->value_deeper);
s_id->value_deeper = NULL;
}
if(s_id->value_deepest != NULL){
free(s_id->value_deepest);
s_id->value_deepest = NULL;
}
free(s_id);
return 0;
}

24
id/id.h
View File

@ -1,24 +0,0 @@
#ifndef id_h
#define id_h
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "../type/type.h"
void init_rand(void);
unsigned long long getId(void);
SID *getS_id(unsigned int type, unsigned int deep_level);
int fitS_id(const SID *fs_id, const SID *ss_id);
int simFitS_id(const SID *fs_id, const SID *ss_id);
char *s_idToASCIIString(const SID *s_id);
SID *asciiStringToS_id(const char *string);
SID *initS_id(unsigned int deep_level);
int freeS_id(SID *s_id);
#endif /* id_h */

7
include/block/block.h Normal file
View File

@ -0,0 +1,7 @@
#ifndef block_h
#define block_h
#include <block/block_type.h>
#endif /* block_h */

5
include/block/block_expand.h Normal file
View File

@ -0,0 +1,5 @@
#ifndef block_expand_h
#define block_expand_h
#endif /* block_expand_h */

5
include/block/block_print.h Normal file
View File

@ -0,0 +1,5 @@
#ifndef block_print_h
#define block_print_h
#endif /* block_print_h */

23
include/block/block_type.h Normal file
View File

@ -0,0 +1,23 @@
#ifndef block_type_h
#define block_type_h
#include<type.h>
#ifdef id_enable
#include <id/id.h>
#endif
/*
*块的管理及操作的结构
*/
typedef struct block{
uint64_t size;
uint64_t m_size;
uint32_t carve;
void *data;
#ifdef id_enable
SID *s_id;//栈节点的ID
#endif
} Block;
#endif /* block_type_h */

288
include/chain/chain.h Normal file
View File

@ -0,0 +1,288 @@
#ifndef chain_h
#define chain_h
#include <chain/chain_type.h>
#include <list/list.h>
/************************************************
*节点的快速初始化: 为新节点分配内存空间,
* 并使用输入值对其进行初始化.
************************************************/
/*
*为新节点获取内存空间, 并使用整型值初始化新节点
*参数if_sid指示函数是否为节点获取ID
*返回: 若成功则返回指向新节点的指针,若失败函数返回NULL.*/
extern CNode *nodeWithInt(int, _Bool if_sid);
/*
*为新节点获取内存空间, 并使用无符号整型值初始化新节点
*参数if_sid指示函数是否为节点获取ID
*返回: 若成功则返回指向新节点的指针,若失败函数返回NULL.*/
extern CNode *nodeWithUInt(unsigned int, _Bool if_sid);
/*
*为新节点获取内存空间, 并使用无符号长整型值初始化新节点
*参数if_sid指示函数是否为节点获取ID
*返回: 若成功则返回指向新节点的指针,若失败函数返回NULL.*/
extern CNode *nodeWithULLInt(unsigned long long, _Bool if_sid);
/*
*为新节点获取内存空间, 并使用浮点值初始化新节点
*参数if_sid指示函数是否为节点获取ID
*返回: 若成功则返回指向新节点的指针,若失败函数返回NULL.*/
extern CNode *nodeWithDouble(double, _Bool if_sid);
/*
*为新节点获取内存空间, 并使用字符串值初始化新节点
*参数if_sid指示函数是否为节点获取ID
*返回: 若成功则返回指向新节点的指针,若失败函数返回NULL.*/
extern CNode *nodeWithString(const char *, _Bool if_sid);
/*
*为新节点获取内存空间, 并使用指针值初始化新节点
*参数if_sid指示函数是否为节点获取ID
*返回: 若成功则返回指向新节点的指针,若失败函数返回NULL.*/
extern CNode *nodeWithPointer(const void *, _Bool if_sid);
/************************************************
*嵌套节点的快速初始化: 为嵌套节点节点分配内存空间,
* 并使用输入值对其进行初始化
*说明: 嵌套节点指储存一个链表指针的节点.
************************************************/
/*
*为新嵌套节点获取内存空间
*返回: 若成功指向新嵌套节点的指针,若失败函数返回NULL.*/
extern CNode *nodeWithComplex(void);
/*
*用输入的值初始化嵌套节点
*参数: type指明所输入值的类型,value为指向所输入值的内存空间的指针
*返回: 若成功则返回0,若失败函数返回-1.*/
extern int addValueForComplex(CNode *, int type, void *value);
/*
*用输入的整型值初始化嵌套节点
*返回: 若成功则返回0,若失败函数返回-1.*/
extern int addIntForComplex(CNode *, int);
/*
*用输入的浮点值初始化嵌套节点
*返回: 若成功则返回0,若失败函数返回-1.*/
extern int addDoubleForComplex(CNode *, double);
/*
*用输入的字符串初始化嵌套节点
*返回: 若成功则返回0,若失败函数返回-1.*/
extern int addStringForComplex(CNode *, char *);
/*
*用输入的指针值初始化嵌套节点
*返回: 若成功则返回0,若失败函数返回-1.*/
extern int addPointerForComplex(CNode *, void *);
/************************************************
*节点值的更新: 更新既有节点中的值,并用新值直接替换旧值
************************************************/
/*
*用输入的整型值更新节点中的值
*返回: 若成功则返回0,若失败函数返回-1.*/
extern int updateValueWithIntForNode(CNode *,int);
/*
*用输入的无符号长整型值更新节点中的值
*返回: 若成功则返回0,若失败函数返回-1.*/
extern int updateValueWithULLIntForNode(CNode *, uint64_t);
/*
*用输入的浮点值更新节点中的值
*返回: 若成功则返回0,若失败函数返回-1.*/
extern int updateValueWithDoubleForNode(CNode *,double);
/*
*用输入的字符串值更新节点中的值
*返回: 若成功则返回0,若失败函数返回-1.*/
extern int updateValueWithStringForNode(CNode *,char *);
/*
*用输入的指针值更新节点中的值
*返回: 若成功则返回0,若失败函数返回-1.*/
extern int updateValueWithPointerForNode(CNode *,void *);
/************************************************
*链表的查找: 依据输入值,查找链表中的多个特定类型的节点
************************************************/
/*
*通过输入的整型值,查找链表中多个含有该值的节点
*返回: 若成功则返回一个储存由这些指向这些节点指针组成的链表,若失败函数返回NULL.*/
Chain *mply_findByIntForNode(Chain*, int);
/*
*通过输入的浮点值,查找链表中多个含有该值的节点
*返回: 若成功则返回一个储存由这些指向这些节点指针组成的链表,若失败函数返回NULL.*/
Chain *mply_findByDoubleForNode(Chain*, double);
/*
*通过输入的字符串值,查找链表中多个含有该值的节点
*返回: 若成功则返回一个储存由这些指向这些节点指针组成的链表,若失败函数返回NULL.*/
Chain *mply_findByStringForNode(Chain*, char *);
/*
*通过输入的指针值,查找链表中多个含有该值的节点
*返回: 若成功则返回一个储存由这些指向这些节点指针组成的链表,若失败函数返回NULL.*/
Chain *mply_findByPointerForNode(Chain*, void *);
/************************************************
*链表的遍历: 遍历链表相关函数
************************************************/
/*
*链表的遍历
*参数: p_func为一个函数指针, 指向的回调函数的职能在于接受每个节点的类型(type)/值指针(value)/传入参数链表(args),
然后进行相关操作,并返回一个链表,其中包含返回状态,若有,也可以包含想要传递给母函数的值
expand_resources为一个链表,储存母函数想要传递给回调函数的值
*返回: 如果回调函数有需要返回给母函数的值,则返回包含这些值的链表,否则返回NULL.*/
extern Chain *listThrough(Chain *p_list, Chain *(*p_func)(unsigned int type, void *value, Chain *args), Chain *expand_resources);
/*
*回调函数相关宏操作的辅助函数,用于给回调函数给母函数返回值提供便利
*/
extern Chain *newReturn(int if_status ,int status, char *argc, ...);
/*
*回调函数相关宏操作的辅助函数,用于回调函数返回空值提供便利
*/
Chain *newCReturn(void);
/*
*回调函数相关宏操作的辅助函数,用于给回调函数获取母函数传入的参数返提供便利
*/
uint64_t getInfoForListThrough(Chain *expand_resources, int type);
/************************************************
*链表大小: 计算链表大小相关函数
************************************************/
/*
*以字节为单位计算链表的大小
*/
uint64_t calListMemory(Chain *);
/***********************************************
*链表或节点的属性:获取或更新链表或节点属性有关的函数
***********************************************/
/*
*返回链表长度*/
extern uint64_t len(Chain *p_list);
/*
*查询链表是否为空
*返回: 如果链表为空返回1,如果链表不为空则返回0.*/
extern int isListEmpty(Chain *p_list);
/*
*直接获得节点中的整型值
*返回: 返回该节点储存的整型值*/
extern int getByIntForNode(CNode *);
/*
*直接获得节点中的无符号整型值
*返回: 返回该节点储存的无符号整型值*/
extern unsigned int getByUIntForNode(CNode *);
/*
*直接获得节点中的浮点值
*返回: 返回该节点储存的浮点值*/
extern double getByDoubleForNode(CNode *);
/*
*直接获得节点中的字符串值
*返回: 返回该节点储存的字符串值*/
extern char *getByStringForNode(CNode *);
/*
*直接获得节点中的指针值
*返回: 返回该节点储存的指针值*/
extern void *getByPointerForNode(CNode *);
/*
*直接获得节点的序号
*返回: 返回该节点在链表中的序号*/
extern unsigned long long getIndexForNode(Chain *p_list,CNode *p_node);
/*
*通过节点的序号找到节点中相关的值,并更新其中的储存的值的指针.
*返回: 如果成功返回指向该节点的指针,如果失败则返回NULL*/
extern CNode *updateNodeByIndex(Chain *p_list, void *new_value, unsigned long long index);
/**********************************************
*链表或节点的复制: 链表与节点复制相关函数
*********************************************/
/*
*节点的复制,复制将会为新节点重新分配内存,并将源节点的所有值拷贝入新节点.
*注意: 源节点与新节点ID相同.
*返回: 若成功函数返回指向新节点的指针,若失败则返回NULL*/
extern CNode *copyNode(CNode *);
/*
*链表的复制,复制将会为新链表重新分配内存,并将源链表的所有节点复制.
*注意: 源链表与新链表ID相同.
*返回: 若成功函数返回指向新链表的指针,若失败则返回NULL*/
Chain *copyList(Chain *p_list);
/*
*通过序号查找相关的单个节点
*返回: 如果成功返回指向该节点的指针,如果失败则返回NULL.*/
extern CNode *findByIndexForNode(Chain *, unsigned long long);
/*
*通过整型值查找储存该值的单个节点
*返回: 如果成功返回指向该节点的指针,如果失败则返回NULL.*/
extern CNode *findByIntForNode(Chain *, int);
/*
*通过浮点值查找储存该值的单个节点
*返回: 如果成功返回指向该节点的指针,如果失败则返回NULL.*/
extern CNode *findByDoubleForNode(Chain *, double);
/*
*通过字符串中查找储存该值的单个节点.
*返回: 如果成功返回指向该节点的指针,如果失败则返回NULL.*/
extern CNode *findByStringForNode(Chain *, char *);
/*
*通过指针值查找储存该值的单个节点.
*返回: 如果成功返回指向该节点的指针,如果失败则返回NULL.*/
extern CNode *findByPointerForNode(Chain *, void *);
#endif /* chain_h */

42
include/chain/chain_print.h Normal file
View File

@ -0,0 +1,42 @@
#ifndef list_print_h
#define list_print_h
#include <chain/chain.h>
#include <event/event.h>
/************************************************
*链表或节点的输出: 格式化输出链表或节点的属性
************************************************/
/*
*输出链表及其中节点的相关信息
*参数: priority为每行输出信息前的空格数除以4*/
void printListInfo(Chain *p_list,int priority);
/*
*输出节点中的相关信息
*参数: priority为每行输出信息前的空格数乘以4*/
void printNodeInfo(CNode *p_node,int priority);
/*
*输出链表及其中节点的相关信息
*/
void printList(Chain *);
/*
*自定义输出链表及其中节点的相关信息
*参数: func为一个函数指针, 指向函数的职能在于输出节点中的用户自定义结构的相关信息*/
void printListForCustom(Chain *p_list,void (*func)(void *value));
/*
*printListForCustom函数的回调函数
*/
__CALLBACK_STATE(printListForCustom);
/*
*输出节点中的相关信息
*/
void printNode(CNode *p_node);
#endif /* list_print_h */

16
include/chain/chain_type.h Normal file
View File

@ -0,0 +1,16 @@
#ifndef chain_type_h
#define chain_type_h
#include <list/list_type.h>
/*
*节点的管理及操作的结构
*/
typedef struct Node CNode;
/*
*链表的管理及操作的结构
*/
typedef struct List Chain;
#endif /* chain_type_h */

29
include/communicate/communicate.h Normal file
View File

@ -0,0 +1,29 @@
#ifndef communicate_h
#define communicate_h
#include <communicate/communicate_type.h>
/************************************************
消息的操作: 消息的操作相关函数
************************************************/
/*
*创建消息
*返回: 处理成功则返回指向相关结构体所在内存空间的指针,不成功则返回NULL.
*/
extern MSG *createMessage(char *title, void *data, unsigned long data_size);
/*
*通过ipv4地址发送消息
*返回: 处理成功则返回0,不成功则返回-1.
*/
extern int sendMessageIPv4(MSG *p_msg, char *ip, unsigned int port);
#endif /* communicate_h */

269
include/communicate/communicate_file.h Normal file
View File

@ -0,0 +1,269 @@
#ifndef communicate_file_h
#define communicate_file_h
#include <communicate/communicate_type.h>
/************************************************
相关结构体初始化: 初始化相关结构体有关函数
************************************************/
/*
*以写的方式初始化数据文件管理结构
*参数: route指示数据文件路径
*返回: 处理成功则返回指向相关结构体所在内存空间的指针,不成功则返回NULL.
*/
extern D_FILE *initDataFileForWrite(char *route);
/*
*以读的方式初始化数据文件管理结构
*参数: route指示数据文件路径
*返回: 处理成功则返回指向相关结构体所在内存空间的指针,不成功则返回NULL.
*/
extern D_FILE *initDataFileForRead(char *route);
/*
*初始化数据块管理结构
*参数: type指示数据块储存数据的数据类型,data_size指示数据块储存数据的大小
*返回: 处理成功则返回指向相关结构体所在内存空间的指针,不成功则返回NULL.
*/
extern STD_BLOCKS *initStandardDBlocks(SID *p_sid, uint16_t type, uint32_t data_size);
/*
*初始化数据块链接关系管理结构
*参数: f_sid指示第一个数据块的SID,s_sid指示第二个数据块的SID.
*返回: 处理成功则返回指向相关结构体所在内存空间的指针,不成功则返回NULL.
*/
extern STD_CTN *initStandardDConnection(SID *f_sid, SID *s_sid);
/*
*初始化标准数据结构管理结构
*参数: type指示标准数据结构所储存的数据结构的数据类型, s_id指示所储存的数据结构的ID,
若s_id为NULL,则另外分配一个ID.为了方便管理,标准数据结构必须有ID.
*返回: 处理成功则返回指向相关结构体所在内存空间的指针,不成功则返回NULL.
*/
extern STD_DATA *initStandardData(uint16_t type, SID *s_id);
/************************************************
相关结构体的组织: 组织相关结构体有关函数
************************************************/
/*
*为数据块添加数据
*参数: data为指向所添加数据所在内存空间的指针
*返回: 处理成功则返回0,不成功则返回-1.
*/
extern int dataForStandardDBlock(STD_BLOCKS *p_stdb,void *data);
/*
*为数据文件添加标准数据结构
*返回: 处理成功则返回0,不成功则返回-1.
*/
extern int dataFileAddStandardData(D_FILE *p_dfile, STD_DATA *p_std);
/*
*为标准数据结构添加数据块
*参数: type指示所添加数据的数据类型, data为指向所添加数据所在内存空间的指针, data_size指示所添加数据的大小
*返回: 处理成功则返回0,不成功则返回-1.
*/
extern int standardDataAddBlock(STD_DATA *p_std, SID *p_sid ,uint16_t type, void *data, uint32_t data_size);
/*
*为标准数据结构添加数据块链接关系结构体
*参数: f_sid指示第一个数据块的SID,s_sid指示第二个数据块的SID.
*返回: 处理成功则返回0,不成功则返回-1.
*/
extern int standardDataAddConnection(STD_DATA *p_std, SID *f_sid, SID *s_sid);
/************************************************
数据文件管理结构的整体写入与读出: 对数据文件管理结构的操作
************************************************/
/*
*将数据文件管理结构写入到相关数据文件中,以储存.
*返回: 处理成功则返回0,不成功则返回-1.
*/
extern int dataFileWriteIn(D_FILE *p_dfile);
/*
*将相关数据文件中的内容,读出到数据文件管理结构中,等待操作.
*返回: 处理成功则返回0,不成功则返回-1.
*/
extern int dataFileReadOut(D_FILE *p_dfile);
/************************************************
相关结构的释放操作: 释放相关结构体所占内存空间的相关函数
************************************************/
/*
*释放数据块所占内存空间
*返回: 处理成功则返回0,不成功则返回-1.
*/
extern int releaseSTDBlocks(STD_BLOCKS *p_stdb);
/*
*释放标准数据结构管理结构所占的内存空间
*返回: 处理成功则返回0,不成功则返回-1.
*/
extern int releaseStandardData(STD_DATA *p_std);
/*
*释放数据块链接关系管理结构所占的内存空间
*返回: 处理成功则返回0,不成功则返回-1.
*/
extern int releaseSTDConnection(STD_CTN *p_stdc);
/*
*释放数据文件管理结构所占的内存空间
*返回: 处理成功则返回0,不成功则返回-1.
*/
extern int releaseDFile(D_FILE *p_file);
/************************************************
结构类型的转换: 其他数据结构与标准数据结构的转换相关函数
************************************************/
/*
*将链表转化为标准数据结构
*返回: 处理成功则返回指向相关结构体所在内存空间的指针,不成功则返回NULL.
*/
extern STD_DATA *listToSTD(Chain *);
/*
*将标准数据结构转换成链表
*返回: 处理成功则返回指向相关结构体所在内存空间的指针,不成功则返回NULL.
*/
extern Chain *standardDataToList(STD_DATA *);
//STD_DATA *stackToSTD(Stack *);
//STD_DATA *treeToSTD(Tree *);
/************************************************
标准数据结构的随机存取: 标准数据结构的随机存取相关函数
************************************************/
/*
*读取数据文件的简略信息,为随机存取准备必要信息
*说明: 该函数只会在数据文件管理结构中建立一个框架,不会读入实际的数据块以及数据块链接关系.
*返回: 处理成功则返回0,不成功则返回-1.
*/
extern int readDataFileInfo(D_FILE *p_dfile);
/*
*读取数据文件中的特定标准数据结构
*参数: p_std为指向框架中的相关标准数据所在内存空间的指针
*返回: 处理成功则返回0,不成功则返回-1.
*/
extern int readStandardData(D_FILE *p_dfile, STD_DATA *p_std);
/*
*读取数据文件中的特定标准数据结构中的数据块
*返回: 处理成功则返回0,不成功则返回-1.
*/
extern int readSTDBlocks(STD_BLOCKS *p_stdb);
/*
*读取文件头,检验文件是否为数据文件
*返回: 处理成功则返回0,不成功则返回-1.
*/
extern int checkIfDataFile(D_FILE *p_dfile);
/*
*通过标准数据结构的ID,在数据文件中读入特定的标准数据结构
*返回: 处理成功则返回0,不成功则返回-1.
*/
extern int readStandardDataBySid(D_FILE *p_dfile, SID *p_sid);
/************************************************
标准数据结构信息: 获取标准数据结构信息相关函数
************************************************/
/*
*打印标准数据结构信息
*/
extern void printStandardData(void *value);
/*
*计算标准数据结构在文件中占用的空间,以字节为单位.
*/
uint32_t calStandardData(STD_DATA *p_std);
/************************************************
相关回调函数声明
************************************************/
/*
*数据文件管理结构中标准数据结构管理结构的简略信息的写入函数
*/
__CALLBACK_STATE(StandardDataInfoWrite);
/*
*数据文件管理结构中标准数据结构管理结构的内容的写入函数
*/
__CALLBACK_STATE(StandardDataWrite);
/*
*标准数据结构管理结构中的数据块链接关系管理结构的写入函数
*/
__CALLBACK_STATE(StandardDConnectionWrite);
/*
*标准数据结构管理结构中的数据块管理结构的写入函数
*/
__CALLBACK_STATE(StandardDBlockWrite);
/*
*数据文件管理结构的读出函数的回调函数声明
*/
__CALLBACK_STATE(dataFileReadOut);
/*
*计算数据块链接关系在文件中的大小
*/
__CALLBACK_STATE(calStandardDataCTN);
/*
*计算数据块在文件中的大小
*/
__CALLBACK_STATE(calStandardDataBLK);
/*
*将标准数据结构转换成链表的回调函数
*/
__CALLBACK_STATE(StandardDataToList);
/*
*通过标准数据结构的ID,在数据文件中读入特定的标准数据结构函数的回调函数
*/
__CALLBACK_STATE(findStandardDataBySid);
#endif /* communicate_file_h */

77
include/communicate/communicate_type.h Normal file
View File

@ -0,0 +1,77 @@
#ifndef communicate_type_h
#define communicate_type_h
#include<type.h>
/*
*文件头信息的管理及操作的结构
*/
typedef struct file_head{
char head_test[18];//数据文件头部的验证信息
uint32_t data_num;//数据文件中的标准数据结构的数目
}F_HEAD;
/*
*数据文件的管理及操作的结构
*/
typedef struct data_file{
FILE *fp;//数据文件
F_HEAD *pf_head;//数据文件头
Chain *pf_stdlst;//数据文件的标志数据结构的储存链表
}D_FILE;
/*
*标准数据结构的管理及操作的结构
*/
typedef struct standard_data_blocks{
uint16_t type;//数据块的类型
uint32_t location;//数据块在数据文件中的定位
char *sid;//数据块的ID
_Bool if_data;//数据块是否赋值
unsigned int blocks_num;//数据块字节大小
char *buff;//指向数据块储存值内存空间的指针
}STD_BLOCKS;
/*
*标准数据结构中数据块的连接关系的管理及操作的结构
*/
typedef struct standard_data_connection{
uint32_t location;//数据块链接关系结构在文件中的定位
char *f_sid;//前一个数据块的ID
char *s_sid;//后一个数据块的ID
}STD_CTN;
/*
*标准数据结构头的管理及操作的结构
*/
typedef struct standard_data_head{
uint32_t data_blk_num;//数据块的数目
uint32_t data_ctn_num;//数据块链接关系结构的数目
}STD_HEAD;
/*
*标准数据结构的管理及操作的结构
*/
typedef struct standard_data{
SID *s_id;//标准数据结构的ID
int read_data;//标准数据结构是否已经读取完整
uint16_t type;//标准数据结构所对应的类型
uint32_t size;//标准数据结构在数据文件中的大小
uint32_t location;//标准数据结构的头在数据文件中的定位
_Bool lock;//标准数据文件是否被锁住
Chain *pd_blocklst;//数据块储存链表
Chain *pd_ctnlst;//数据块连接关系结构的储存链表
}STD_DATA;
/*
*消息的管理及操作的结构
*/
typedef struct message{
SID *p_sid;//消息的ID
time_t time;//消息的产生时间
char titile[16];//消息标题
unsigned long size;//消息的大小
char content[0];//消息的正文
}MSG;
#endif /* communicate_type_h */

54
include/error/error.h Normal file
View File

@ -0,0 +1,54 @@
#ifndef error_h
#define error_h
#include <type.h>
/*
*错误管理中信息的管理及操作的结构
*/
typedef struct Info{
char head[64];//信息头
char body[256];//信息内容
}Info;
/*
*错误管理中错误的管理及操作的结构
*/
typedef struct Error{
unsigned int type;//错误类型号
int priority;//优先级
time_t time;//错误产生的时间
Info info;//信息指针
}Error;
/*
*错误管理中警告的管理及操作的结构
*/
typedef struct Notice{
unsigned int type;//警告类型号
time_t time;//警告产生的时间
Info info;//信息指针
}Notice;
/***********************************************
*错误的提示:出现错误时,以下函数用于快捷地通报错误信息,
* 以便根据信息快速找到错误原因.
**********************************************/
extern int pushInfo(Info *p_info, const char *head,const char *body);
extern Error *pushError(unsigned int type, int pri, Info *p_info);
extern Notice *pushNotice(unsigned int type, Info *p_info);
extern Info *initInfo(const char *head, const char *body);
extern Error *createError(Info *info,unsigned int type,int pri);
extern Notice *createWarning(Info *info, unsigned int type, int pri);
extern int showError(Error *);
extern int showWarning(Notice *);
#endif /* error_h */

14
error/error.h → include/error/error_file.h
View File

@ -1,8 +1,18 @@
#ifndef ERROR_H
#define ERROR_H
#include "../type/type.h"
#include "../list/list_expand.h"
#include <type.h>
#include <list/list.h>
#include <error/error.h>
/*
*错误管理中日志信息的管理及操作的结构
*/
typedef struct Log{
FILE *fp;//日志文件的指针
int if_enable;//日志文件是否启用
unsigned long int id;//日志文件的ID
}Log;
Log logfile;
List *error_list = NULL;

228
include/event/event.h Normal file
View File

@ -0,0 +1,228 @@
#ifndef list_expand_1_h
#define list_expand_1_h
#include <chain/chain.h>
/************************************************
*节点快速初始化相关宏,提供函数名较为简单的调用方式
************************************************/
/****
*不带ID模块相关宏
*/
/*直接获取一个以整型值初始化的节点不带ID的缩略*/
#define lni(x) nodeWithInt(x,0)
/*直接获取一个以无符号整型值初始化的不带ID节点的缩略*/
#define lnu(x) nodeWithUInt(x,0)
/*直接获取一个以无符号长整形值初始化的节点的缩略*/
#define lnull(x) nodeWithULLInt(x,0)
/*直接获取一个以浮点值初始化的不带ID节点的缩略*/
#define lnd(x) nodeWithDouble(x,0)
/*直接获取一个以字符串值初始化的不带ID节点的缩略*/
#define lns(x) nodeWithString(x,0)
/*直接获取一个以指针值初始化的不带ID节点的缩略*/
#define lnp(x) nodeWithPointer(x,0)
/****
*带ID模块的相关宏
*/
/*直接获取一个以整型值初始化的带ID节点的缩略*/
#define lsni(x) nodeWithInt(x,1)
/*直接获取一个以浮点值初始化的带ID节点的缩略*/
#define lsnd(x) nodeWithDouble(x,1)
/*直接获取一个以字符串值初始化的带ID节点的缩略*/
#define lsns(x) nodeWithString(x,1)
/*直接获取一个以指针值初始化的节点的缩略*/
#define lsnp(x) nodeWithPointer(x,1)
/************************************************
*链表快速插入相关宏
************************************************/
/****
*尾部相关
*/
/*在链表尾部直接加入一个已经用整型值初始化的不带ID的节点*/
#define lisrti(list, x) insertInTail(list, lni(x));
/*在链表尾部直接加入一个已经用浮点值初始化的不带ID的节点*/
#define lisrtd(list, x) insertInTail(list, lnd(x));
/*在链表尾部直接加入一个已经用无符号整型值初始化的不带ID的节点*/
#define lisrtu(list, x) insertInTail(list, lnu(x));
/*在链表尾部直接加入一个已经用无符号长整型值初始化的不带ID的节点*/
#define lisrtull(list, x) insertInTail(list, lnull(x));
/*在链表尾部直接加入一个已经用指针值初始化的不带ID的节点*/
#define lisrtp(list, x) insertInTail(list, lnp(x));
/*在链表尾部直接加入一个已经用字符串值初始化的不带ID的节点*/
#define lisrts(list, x) insertInTail(list, lns(x));
/****
*头部相关
*/
/*在链表头部直接加入一个已经用整型值初始化的不带ID的节点*/
#define lisrhi(list, x) insertInHead(list, lni(x));
/*在链表头部直接加入一个已经用浮点值初始化的不带ID的节点*/
#define lisrhd(list, x) insertInHead(list, lnd(x));
/*在链表头部直接加入一个已经用无符号整型值初始化的不带ID的节点*/
#define lisrhu(list, x) insertInHead(list, lnu(x));
/*在链表头部直接加入一个已经用无符号长整型值初始化的不带ID的节点*/
#define lisrhull(list, x) insertInHead(list, lnull(x));
/*在链表头部直接加入一个已经用指针值初始化的不带ID的节点*/
#define lisrhp(list, x) insertInHead(list, lnp(x));
/*在链表头部直接加入一个已经用字符串值初始化的不带ID的节点*/
#define lisrhs(list, x) insertInHead(list, lns(x));
/************************************************
*节点快速获得储存值相关宏
************************************************/
/*快速获得指针类型的节点所储存的值*/
#define lidxp(list, x) getByPointerForNode(findByIndexForNode(list, x))
/*快速获得整型类型的节点所储存的值*/
#define lidxi(list, x) getByIntForNode(findByIndexForNode(list, x))
/*快速获得浮点类型的节点所储存的值*/
#define lidxd(list, x) getByDoubleForNode(findByIndexForNode(list, x))
/*快速获得字符串类型的节点所储存的值*/
#define lidxs(list, x) getByStringForNode(findByIndexForNode(list, x))
/*快速获得无符号长整型类型的节点所储存的值*/
#define lupdull(list,x,value) updateValueWithULLIntForNode(findByIndexForNode(list, x),value)
/************************************************
*其他快速操作相关宏
************************************************/
/*通过节点的序号直接得到它的值*/
#define lidxvle(list,x) (findByIndexForNode(list, x)->value)
/*通过节点序号直接移除节点*/
#define lrmvidx(list,x) removeByNode(list, findByIndexForNode(list, x)
/*从列表头移除节点的缩略*/
#define lpoph(list) popFromHead(list)
/*从列表尾移除节点的缩略*/
#define lpopt(list) popFromTail(list)
/*通过节点的ID直接获得节点的值*/
#define lfndsid(list,sid) (findByIdForNode(list,sid)->value)
/*创建一个不带ID的链表的缩略*/
#define lstns() initList(0);
/*创建一个带有ID的链表缩略*/
#define lstn() initList(1);
#endif /* list_expand_1_h */
/************************************************
*回调函数的便捷操作相关宏
************************************************/
/****
*母函数相关
*/
/*
*若需要母函数需要向毁掉函数传递相关参数则使用该宏
*参数: argc指示传递参数的类型格式;args为需要返回的参数.*/
#define __SEND_ARG(argc, args...) newReturn(0, -1, argc , args)
/*
*若快速声明回调函数则使用该宏
*参数: name为回调函数名.*/
#define __CALLBACK_STATE(name) List *_do##name(unsigned int, void *, List *)
/*
*若快速定义回调函数则使用该宏
*参数: name为回调函数名.*/
#define __CALLBACK_DEFINE(name) List *_do##name(unsigned int type, void *value, List *expand_resources)
/*
*若传递回调函数指针则使用该宏
*参数: name为回调函数名.*/
#define __CALLBACK_CALL(name) _do##name
/*
*若母函数获取回调函数返回的指针则使用该宏
*参数: x为该值的顺序号, type为获取的指针值的类型.*/
#define __RTN_ARGS_P(list,x,type) (type *) lidxp(list, x);
/*
*若母函数获取回调函数返回的值则使用该宏
*参数: x为该值的顺序号, type为获取的值的类型.*/
#define __RTN_ARGS(list,x,type) *((type *) lidxp(list, x));
/****
*回调函数相关
*/
/*
*若回调函数获取遍历链表中的当前节点的值则使用该宏
*参数: c_type为获取值的类型.*/
#define __VALUE(c_type) (c_type)value
/*
*若回调函数获取母函数传递的参数则使用该宏
*参数: x为该值的顺序号, type为获取值的类型.*/
#define __ARGS(x, type) *((type *) lidxp(expand_resources, x));
/*
*若回调函数获取母函数传递的指针参数则使用该宏
*参数: x为该值的顺序号, type为获取的指针值的类型.*/
#define __ARGS_P(x, type) (type *) lidxp(expand_resources, x);
/*
*若回调函数获取遍历链表的长度则使用该宏
*/
#define __LIST_LEN getInfoForListThrough(expand_resources,0)
/*
*若回调函数获取遍历链表中当前节点的序号则使用该宏
*/
#define __NOW_INDEX getInfoForListThrough(expand_resources,1)
/*
*若需要终止遍历或终止遍历并向母函数返回相关参数则使用该宏
*参数: argc指示返回参数的个数;args为需要返回的参数.*/
#define __RETURN(argc, args...) newReturn(1, -1, argc , args)
/*
*若继续遍历则使用该宏
*/
#define __CRETURN__ newCReturn()

123
include/id/id.h Normal file
View File

@ -0,0 +1,123 @@
#ifndef id_h
#define id_h
#include <type.h>
#include <id/md5.h>
/*
*SID的初始值管理及操作的结构
*/
struct sid_raw{
unsigned int type;
unsigned int *value;//4
unsigned int *value_deeper;//8
unsigned int *value_deepest;//32
};
/*
*SID的管理及操作的结构
*/
typedef struct s_id{
struct sid_raw *sr;//指向SID初始值
unsigned int deep;//SID初始值的复杂度
MD5_CTX *md5;//指向MD5结构
unsigned char *decrypt_hex;//指向MD5的Hex信息
char *decrypt_str;//指向MD5的Hex信息转化成的字符串
}SID;
/************************************************
初始化: 初始化有关函数
************************************************/
/*
*获得一个新的SID
*参数: deep_level指示原始ID的复杂度,type指示SID所绑定的数据结构的数据类型
*返回: 处理成功则返回指向相关结构体所在内存空间的指针,不成功则返回NULL.
*/
extern SID *getS_id(unsigned int type, unsigned int deep_level);
/*
*通过SID原始数据转换而成的字符串形式的MD5获得一个新的SID
*返回: 处理成功则返回指向相关结构体所在内存空间的指针,不成功则返回NULL.
*/
extern SID *setS_idWithString(char *);
/*
*获得一个新的ID
*/
extern unsigned long long getId(void);
/************************************************
比较: ID的比较函数
************************************************/
/*
*比较两个SID
*返回: 返回strcmp风格的返回值
*/
extern int fitS_id(SID * const fs_id, SID * const ss_id);\
/*
*比较两个SID
*返回: 相同返回1,不相同返回0
*/
extern int simFitS_id(SID * fs_id, SID * ss_id);
/************************************************
比较: ID的转换函数
************************************************/
/*
*将SID中的Hex形式的MD5数据转化成字符串形式的MD5
*/
extern void setSidToASCIIString(SID * const s_id);
char *s_idToASCIIString(SID * const s_id);
/************************************************
复制: 复制ID的函数
************************************************/
/*
*复制一个既有的SID,得到一个相同的崭新的SID
*/
extern SID *copyS_id(SID *f_sid);
/************************************************
释放: 释放ID的函数
************************************************/
/*
*释放SID原始数据所占的内存空间
*/
extern int freeSidRaw(SID *s_id);
/*
*释放SID所有已占用的内存空间
*/
extern int freeS_id(SID *s_id);
#endif /* id_h */

53
include/id/md5.h Normal file
View File

@ -0,0 +1,53 @@
#ifndef md5_h
#define md5_h
#include <type.h>
#define F(x,y,z) ((x & y) | (~x & z))
#define G(x,y,z) ((x & z) | (y & ~z))
#define H(x,y,z) (x^y^z)
#define I(x,y,z) (y ^ (x | ~z))
#define ROTATE_LEFT(x,n) ((x << n) | (x >> (32-n)))
#define FF(a,b,c,d,x,s,ac) { \
a += F(b, c, d) + x + ac; \
a = ROTATE_LEFT(a, s); \
a += b; \
}
#define GG(a,b,c,d,x,s,ac) { \
a += G(b, c, d) + x + ac; \
a = ROTATE_LEFT(a, s); \
a += b; \
}
#define HH(a,b,c,d,x,s,ac) { \
a += H(b, c, d) + x + ac; \
a = ROTATE_LEFT(a, s); \
a += b; \
}
#define II(a,b,c,d,x,s,ac) { \
a += I(b, c, d) + x + ac; \
a = ROTATE_LEFT(a, s); \
a += b; \
}
/*
*MD5的管理及操作的结构
*/
typedef struct md5_ctx{
unsigned int count[2];
unsigned int state[4];
unsigned char buffer[64];
}MD5_CTX;
void MD5Init(MD5_CTX *context);
void MD5Update(MD5_CTX *context, unsigned char *input, unsigned long inputlen);
void MD5Final(MD5_CTX *context, unsigned char digest[16]);
void MD5Transform(unsigned int state[4], unsigned char block[64]);
void MD5Encode(unsigned char *output, unsigned int *input, unsigned long len);
void MD5Decode(unsigned int *output, unsigned char *input, unsigned long len);
#endif /* md5_h */

209
include/list/list.h Normal file
View File

@ -0,0 +1,209 @@
#ifndef list_h
#define list_h
#include <list/list_type.h>
/************************************************
*链表的初始化相关函数
************************************************/
/*
*初始化链表,并返回指向新链表的指针,参数if_sid指示是否为新链表分配ID号
*返回: 如果成功返回指向该节点的指针,如果失败则返回NULL.*/
#ifdef id_enable
extern List *initList(_Bool if_sid);
#else
extern List *initList(void);
#endif
/*
*初始化节点,并返回指向新链表的指针,参数if_sid指示是否为新节点分配ID号
*返回: 如果成功返回指向该节点的指针,如果失败则返回NULL.*/
#ifdef id_enable
extern Node *initNode(_Bool if_sid);
#else
extern Node *initNode(void);
#endif
/*库中内部调用函数,旨在为新节点的储存值获取内存,并将相应的储存值储存在获取到的内存中,并指明储存值的类型.*/
extern int initMallocValueForNode(Node *,unsigned int,const void *);
/*************************************************
*节点的插入: 节点的插入操作相关函数
*************************************************/
/*
*在链表的头部插入一个节点*
*返回: 若成功函数返回0,若失败函数返回-1.*/
extern int insertInHead(List *p_list, Node *p_node);
/*
*在链表的尾部插入一个节点
*返回: 若成功函数返回0,若失败函数返回-1.*/
extern int insertInTail(List *p_list, Node *p_node);
/*
*在一个节点的后面插入一个节点
*参数说明: t_node为指向目标节点的指针;p_node为指向新节点的指针;
*返回: 若成功函数返回0,若失败函数返回-1.*/
extern int insertAfterNode(List *p_list, Node *t_node, Node *p_node);
/*
*在一个节点的前面插入一个节点
*参数: t_node为指向目标节点的指针;p_node为指向新节点的指针;
*返回: 若成功函数返回0,若失败函数返回-1.*/
extern int insertBeforeNode(List *p_list, Node*t_node, Node *p_node);
/***********************************************
节点的替换与调换: 节点的替换与调换相关的函数
***********************************************/
/*
*用一个新节点,替换掉链表中已经存在的节点
*参数: t_node为指向目标节点的指针;p_node为指向新节点的指针;
*/
extern int replaceNode(List *p_list, Node *t_node, Node *p_node);
/*
*交换两个已经在链表中的节点的位置
*参数: t_node为指向目标节点的指针;p_node为指向新节点的指针;
*/
extern int exchangeNode(List *p_list, Node *f_node, Node *s_node);
/***********************************************
*节点的删除: 节点移除相关函数
***********************************************/
#ifdef id_enable
/*
*通过ID查找链表中的特定节点并从链表中移除相关节点,但并不释放节点内存.
*若成功函数返回0,若失败函数返回-1.*/
extern int removeById(List *p_list, SID *s_id);
#endif
/*
*通过指向节点的指针直接从链表中移除相关节点,但不释放节点内存
*若成功函数返回0,若失败函数返回-1.*/
extern int removeByNode(List *p_list, Node *p_node);
/*
*从链表头部移除第一个节点,不释放节点内存,返回节点指向该节点的指针,方便后续操作
*返回: 如果成功返回指向该节点的指针,如果失败则返回NULL.*/
extern Node *popFromHead(List *p_list);
/*
*从链表尾部移除最后一个节点,不释放节点内存,返回节点指向该节点的指针,方便后续操作
*返回: 如果成功返回指向该节点的指针,如果失败则返回NULL.*/
extern Node *popFromTail(List *p_list);
/***********************************************
*链表查找:查找链表中的指定节点有关的函数
**********************************************/
#ifdef id_enable
/*
*通过ID查找链表中相关的单个节点
*返回: 如果成功返回指向该节点的指针,如果失败则返回NULL.*/
extern Node *findByIdForNode(List *p_list, SID * s_id);
#endif
/*
*通过节点中的值查找相关单个节点
*参数: type指明相关值的类型;value为指向储存相关值的内存的指针.
*返回: 如果成功返回指向该节点的指针,如果失败则返回NULL.*/
extern Node *findByValue(List *p_list, unsigned int type, const void *value);
//void *findByIdForCustom(List *p_list, SID *s_id, int func(SID *));
/*
*通过节点中的值查找相关多个节点.
*参数: type指明相关值的类型;value为指向储存相关值的内存的指针.
*返回: 如果成功返回一个链表,储存所有满足该值的节点的指针.如果失败则返回NULL.*/
extern List *mply_findByValue(List *p_list, unsigned int type, const void *value);
/***********************************************
*链表的排序: 使用快速排序算法,按照指定规则排序链表
**********************************************/
/*
*自定义排序链表.
*参数: func是一个函数指针, 指向的函数接受两个指向链表中节点的指针,并对他们进行比较
如果前一的相关值个大于后一个得相关值则返会大于0的数, 反之则返回小于0的数.
*返回: 如果成功返回0,如果失败则返回-1.*/
extern int sortListForCustom(List *p_list, int(*func)(Node *f_node, Node *s_node));
/***********************************************
*链表或节点的释放: 释放链表或节点所占内存的相关函数
**********************************************/
/*
*释放链表所占的内存空间
*返回: 如果成功返回0, 失败则返回-1.*/
extern int releaseList(List *p_list);
/*
*自定义释放链表所占的内存空间
*参数: func是一个函数指针,它指向的函数现在每次释放节点时调用,用于释放用户自定义的结构体的所占用内存.
*返回: 如果成功返回0, 失败则返回-1.*/
extern int releaseListForCustom(List *p_list, int (*func)(void *));
/*
*释放链表所占的内存,但不释放链表中的节点所占的内存空间
*返回: 如果成功返回0, 失败则返回-1.*/
extern int releaseListForSingle(List *p_list);
/*
*释放相关节点所占的内存空间
*返回: 如果成功返回0, 失败则返回-1.*/
extern int releaseNode(Node *p_node);
/*
*自定义释放节点所占的内存空间
*参数: func是一个函数指针,它指向的函数现在每次释放节点时调用,
* 接收储存在节点中的值的指针,释放用户自定义的结构体的所占用内存.
* 回调函数返回0代表释放成功,返回-1代表释放失败.
*返回: 如果成功返回0, 失败则返回-1.*/
extern int releaseNodeForCustom(Node *p_node, int (*func)(void *));
/*
*释放节点所占的内存空间,不释放节点所储存的值所占的内存空间
*返回: 如果成功返回0, 失败则返回-1.*/
extern int releaseOnlyNode(Node *p_node);
extern int isListEmpty(List *p_list);
/***********************************************
*相关的全局变量
***********************************************/
static int if_safeModeForNode;
static List *node_list;
static List *list_list;
#endif

79
include/list/list_simple.h Normal file
View File

@ -0,0 +1,79 @@
#ifndef list_simple_h
#define list_simple_h
#include <list/list_type.h>
/************************************************
*单向节点的快速初始化: 为新节点分配内存空间,
* 并使用输入值对其进行初始化.
************************************************/
/*
*为新单向节点获取内存空间, 并使用整型值初始化新单向节点
*返回: 若成功则返回指向新单向节点的指针,若失败函数返回NULL.*/
extern s_Node *s_nodeWithInt(int);
/*
*为新单向节点获取内存空间, 并使用无符号整型值初始化新单向节点
*返回: 若成功则返回指向新单向节点的指针,若失败函数返回NULL.*/
extern s_Node *s_nodeWithUInt(unsigned int);
/*
*为新单向节点获取内存空间, 并使用浮点值初始化新单向节点
*返回: 若成功则返回指向新单向节点的指针,若失败函数返回NULL.*/
extern s_Node *s_nodeWithDouble(double);
/*
*为新单向节点获取内存空间, 并使用字符串值初始化新单向节点
*返回: 若成功则返回指向新单向节点的指针,若失败函数返回NULL.*/
extern s_Node *s_nodeWithString(const char *);
/*
*为新单向节点获取内存空间, 并使用指针值初始化新单向节点
*返回: 若成功则返回指向新单向节点的指针,若失败函数返回NULL.*/
extern s_Node *s_nodeWithPointer(const void *);
/*
*初始化单向链表节点,该种类节点可以与普通储存在List结构中.
*单向链表的引入主要在于对于简单问题提供更小开销的解决方案.但相应的操作函数较少,不如一般链表方便.
*返回: 如果成功返回指向该节点的指针,如果失败则返回NULL.*/
extern s_Node *s_initNode(void);
/*在单项链表的头部插入一个节点
*返回: 若成功函数返回0,若失败函数返回-1.*/
extern int s_insertInHead(List *p_list, s_Node *s_p_node);
/*
*在单项链表的尾部插入一个节点
*返回: 若成功函数返回0,若失败函数返回-1.*/
extern int s_insertInTail(List *p_list, s_Node *s_p_node);
/*
*释放单向节点所占的内存空间
*返回: 如果成功返回0, 失败则返回-1.*/
extern int s_releaseNode(s_Node *s_p_node);
/*
*释放单向链表所占的内存空间
*返回: 如果成功返回0, 失败则返回-1.*/
extern int s_releaseList(List *p_list);
/*
*自定义释放单向链表所占的内存空间
*参数: func是一个函数指针,它指向的函数现在每次释放节点时调用,
* 接收储存在节点中的值的指针,释放用户自定义的结构体的所占用内存.
* 回调函数返回0代表释放成功,返回-1代表释放失败.
*返回: 如果成功返回0, 失败则返回-1.*/
extern int s_releaseListForCustom(List *p_list, int (*func)(void *));
/*
*自定义释放单向节点所占的内存空间
*参数: func是一个函数指针,它指向的函数现在每次释放单项节点时调用,
* 接收储存在单项节点中的值得指针,释放用户自定义的结构体的所占用内存.
* 回调函数返回0代表释放成功,返回-1代表释放失败.
*返回: 如果成功返回0, 失败则返回-1.*/
extern int s_releaseNodeForCustom(s_Node *s_p_node, int (*func)(void *));
#endif /* list_simple_h */

33
include/list/list_type.h Normal file
View File

@ -0,0 +1,33 @@
#ifndef list_type_h
#define list_type_h
#ifdef id_enable
#include <id/id.h>
#endif
/*
*节点的管理及操作的结构
*/
typedef struct Node{
unsigned int type;//类型
void *value;//值指针
struct Node *next;//指向下一个节点
struct Node *last;//指向上一个节点
#ifdef id_enable
SID *s_id;
#endif
} Node;
/*
*链表的管理及操作的结构
*/
typedef struct List{
Node *head;//指向第一个节点
Node *tail;//指向最后一个节点
uint64_t length;
#ifdef id_enable
SID *s_id;
#endif
} List;
#endif /* list_type_h */

17
include/list/safe_mode.h Normal file
View File

@ -0,0 +1,17 @@
#ifndef safe_mode_h
#define safe_mode_h
#include <list/list_type.h>
/*********************************************************************************************************
*安全模式开启函数:在开启安全模式后,记录代码段区间所有用户已经分配过内存的链表和节点.在结束时,释放记录在案的还未释放的链表和节点.
*注意:在开启后,只有使用库提供的初始化函数的时候才有效.安全模式打开后,只有调用安全模式结束函数后,才可以重新打开.
*运用:可以在逻辑较为复杂的代码段使用,预防内存泄漏的情况发生.可以免去繁琐的内存泄漏检查过程.
*返回: 若成功函数返回0,若失败函数返回-1.
********************************************************************************************************/
extern int safeModeForNode(int ifon);
/*安全模式结束时调用,调用后将会释放所有在安全模式区间内用户已经分配过的链表和节点,安全模式将会关闭.*/
extern int releaseAllForNode(void);
#endif /* safe_mode_h */

35
tree/tree.h → include/tree/tree.h
View File

@ -1,8 +1,39 @@
#ifndef TREE_H
#define TREE_H
#include <stdio.h>
#include "../list/list_expand.h"
#include <list/list_type.h>
/*
*超级树节点的管理及操作的结构
*/
typedef struct tree_node
{
SID *s_id;//超级树节点的ID
List *home;//超级树节点的子节点列表
struct tree_node *father;//超级树节点的父节点
Node *room;//超级树节点的父节点的子节点列表
unsigned long long child_num;//超级树节点的子节点数量
unsigned int type;//超级树节点的类型
void *value;//值指针
}TNode;
/*
*二叉树节点的管理及操作的结构
*/
typedef struct simple_tree_node{
void *value;//值指针
struct simple_tree_node *childs[2];//子节点
}s_TNode;
/*
*树的管理及操作的结构
*/
typedef struct tree
{
SID *s_id;//超级树的SID
TNode *root;//超级树根节点
s_TNode *s_root;//二叉树的根节点
}Tree;
int safeModeForTree(int ifon);
int releaseAllForTree(void);

92
include/type.h Normal file
View File

@ -0,0 +1,92 @@
#ifndef type_h
#define type_h
#define list_quick_enable
#define id_enable
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
#include <unistd.h>
#include <inttypes.h>
#include <stdarg.h>
#include <stdint.h>
#ifdef UNIX
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#endif
/************************************************
*库相关类型的编号
************************************************/
#define VOID 0
#define INT 1
#define DOUBLE 2
#define STRING 3
#define POINTER 4
#define LIST 5
#define STACK 6
#define TREE 7
#define LIST_NODE 8
#define TREE_NODE 9
#define STACK_NODE 10
#define T_SID 11
#define UINT 12
#define STANDARD_DATA 13
#define DATA_FILE 14
#define MESSAGE 15
#define HOLE 16
#define ULLINT 17
/************************************************
*库相关参数的定义
************************************************/
#define DEEPC 1
#define DEEPB 2
#define DEEPA 3
#define TYPE_LEN 5
#define DEEPC_LEN 4
#define DEEPB_LEN 8
#define DEEPA_LEN 32
#define DATA_BIT 5
#define DEEP_LEN 25
#define DEEPER_LEN 65
#define DEEPEST_LEN 225
#define SID_LEN 33
#define FILE_TSET_LEN 18
#define HEAD_TEST_LEN 9
#define INFO_TEST_LEN 8
#define ENABLE_LIST_QUICK 65535
#define FN_NODE_SPARE 500
#define INDEX_CHANGE_MAX 500
#define INDEX_DISTANCE_MAX 120
#define STD_TEXT_LEN 4
#define HIGH 0x3
#define STANDARD 0x2
#define LOW 0x1
/************************************************
*库相关操作宏的定义
************************************************/
#define ABS(x) ((x>0)?(x):(-x))
#endif /* type_h */

567
list/list.c
View File

@ -1,567 +0,0 @@
#include "list.h"
static int if_safeModeForNode = 0;
static List *node_list = NULL;
static List *list_list = NULL;
int safeModeForNode(int ifon) {
if (ifon == 1) {
if (node_list == NULL && list_list == NULL) {
node_list = (List *)malloc(sizeof(List));
if(node_list == NULL){
showError(pushError(LIST, HIGH, initInfo("safeModeForNode()", "Error in getting the memory of node_list.")));
return -1;
}
list_list = (List *)malloc(sizeof(List));
if(list_list == NULL){
showError(pushError(LIST, HIGH, initInfo("safeModeForNode()", "Error in getting the memory of list_list.")));
return -1;
}
list_list->head = NULL;
list_list->length = 0;
list_list->tail = NULL;
node_list->head = NULL;
node_list->length = 0;
node_list->tail = NULL;
if_safeModeForNode = 1;
}
else {
return -1;
}
}
return ifon;
}
int releaseSingleListForsafeModeForNode(List *p_list) {
Node *p_node = p_list->head;
List *plv_node = NULL;
while (p_node != NULL) {
plv_node = (List *)p_node->value;
freeS_id(plv_node->s_id);
plv_node->head = NULL;
plv_node->length = 0;
plv_node->tail = NULL;
free(plv_node);
p_node = p_node->next;
}
p_list->head = NULL;
p_list->length = 0;
p_list->tail = NULL;
freeS_id(p_list->s_id);
free(p_list);
return 0;
}
int releaseSingleNodeForsafeModeForNode(List *p_list) {
Node *p_node = p_list->head;
Node *pnv_node = NULL;
while (p_node != NULL) {
pnv_node = (Node *)p_node->value;
freeS_id(pnv_node->s_id);
pnv_node->if_malloc = 0;
pnv_node->last = NULL;
pnv_node->next = NULL;
pnv_node->type = VOID;
pnv_node->value = NULL;
free(pnv_node);
p_node = p_node->next;
}
free(p_list->s_id);
p_list->head = NULL;
p_list->length = 0;
p_list->tail = NULL;
free(p_list);
return 0;
}
int releaseAllForNode(void) {
if (if_safeModeForNode == 1) {
if_safeModeForNode = 0;
releaseSingleNodeForsafeModeForNode(node_list);
releaseSingleListForsafeModeForNode(list_list);
}
return 0;
}
Node *initNode(void) {
Node *p_node = (Node *)malloc(sizeof(Node));
if(p_node == NULL){
showError(pushError(LIST_NODE, STANDARD, initInfo("initNode()", "Error in getting the memory of node.")));
return NULL;
}
Node *prec_node = NULL;
p_node->s_id = getS_id(LIST_NODE, 1);
p_node->if_sid = 1;
p_node->if_malloc = 0;
p_node->next = NULL;
p_node->last = NULL;
p_node->type = VOID;
if (if_safeModeForNode) {
if_safeModeForNode = 0;
prec_node = initNode();
if_safeModeForNode = 1;
initMallocValueForNode(prec_node, POINTER, (void *)p_node);
insertInTail(node_list, prec_node);
}
return p_node;
}
List *initList(void) {
Node *p_node = NULL;
List *p_list = (List *)malloc(sizeof(List));
if(p_list == NULL){
showError(pushError(LIST_NODE, STANDARD, initInfo("initList()", "Error in getting the memory of list.")));
return NULL;
}
p_list->s_id = getS_id(LIST, 1);
p_list->if_sid = 1;
p_list->head = NULL;
p_list->tail = NULL;
p_list->length = 0;
if (if_safeModeForNode) {
if_safeModeForNode = 0;
p_node = initNode();
if_safeModeForNode = 1;
initMallocValueForNode(p_node, POINTER, (void *)p_list);
insertInTail(list_list, p_node);
}
return p_list;
}
int initMallocValueForNode(Node *p_node, unsigned int type, const void *p_value) {
p_node->if_malloc = 1;
p_node->type = type;
p_node->value = (void *)p_value;
return 0;
}
int insertInHead(List *p_list, Node *p_node) {
if (isListEmpty(p_list)) {
p_list->head = p_node;
p_list->tail = p_node;
}
else {
p_list->head->last = p_node;
p_node->last = NULL;
p_node->next = p_list->head;
p_list->head = p_node;
}
p_list->length += 1;
return 0;
}
int insertInTail(List *p_list, Node *p_node) {
if (isListEmpty(p_list)) {
p_list->head = p_node;
p_list->tail = p_node;
}
else {
p_list->tail->next = p_node;
p_node->next = NULL;
p_node->last = p_list->tail;
p_list->tail = p_node;
}
p_list->length += 1;
return 0;
}
int releaseNode(Node *p_node) {
if (if_safeModeForNode == 1) {
removeByNode(node_list, p_node);
}
if (p_node->if_malloc == 1) {
if (p_node->type != POINTER) {
if (p_node->type == LIST) {
releaseList((List *)p_node->value);
}
else {
free(p_node->value);
}
}
p_node->value = NULL;
}
p_node->last = NULL;
p_node->next = NULL;
p_node->type = VOID;
p_node->value = NULL;
freeS_id(p_node->s_id);
p_node->if_malloc = 0;
free(p_node);
return 0;
}
int releaseList(List *p_list) {
Node *p_node, *pl_node;
p_node = p_list->head;
if (if_safeModeForNode == 1) {
Node *tar_list = findByValue(list_list, POINTER, (void *)p_list);//turn pointer in to int to compare.
removeByNode(list_list, tar_list);
}
while (p_node != NULL) {
pl_node = p_node;
p_node = p_node->next;
pl_node->next = NULL;
pl_node->last = NULL;
releaseNode(pl_node);
}
p_list->head = NULL;
p_list->tail = NULL;
p_list->length = 0;
freeS_id(p_list->s_id);
free(p_list);
return 0;
}
int releaseListForSingle(List *p_list) {
p_list->head = NULL;
p_list->tail = NULL;
freeS_id(p_list->s_id);
p_list->length = 0;
free(p_list);
return 0;
}
unsigned long long len(List *p_list) {
return p_list->length;
}
int removeById(List *p_list, const SID *s_id) {
Node *tmp = p_list->head;
if (isListEmpty(p_list))
return -1;
do {
if (simFitS_id(tmp->s_id, s_id)) {
if (tmp != p_list->head) {
tmp->last->next = tmp->next;
}
else {
p_list->head = tmp->next;
}
if (tmp != p_list->tail) {
tmp->next->last = tmp->last;
}
else {
p_list->tail = tmp->last;
}
p_list->length -= 1;
return 1;//found
}
else {
tmp = tmp->next;
}
} while (tmp != NULL);
return 0;//not find
}
int removeByNode(List *p_list, Node *p_node) {
Node *tmp = p_list->head;
if (isListEmpty(p_list))
return -1;
do {
if (tmp == p_node) {
tmp->last->next = tmp->next;
tmp->next->last = tmp->last;
p_list->length -= 1;
return 1;//found
}
else {
tmp = tmp->next;
}
} while (tmp != NULL);
return 0;//not find
}
int popFromHead(List *p_list) {
if (isListEmpty(p_list))
return -1;
else {
//Node *tmp = p_list->head;
p_list->head->next->last = NULL;
p_list->head = p_list->head->next;
//releaseNode(tmp); not necessary
p_list->length -= 1;
}
if (isListEmpty(p_list)) {
p_list->head = NULL;
p_list->tail = NULL;
}
return 0;
}
int popFromTail(List *p_list) {
if (isListEmpty(p_list))
return -1;
else {
//Node *tmp = p_list->tail;
p_list->tail->last->next = NULL;
p_list->tail = p_list->tail->last;
//releaseNode(tmp); not necessary
p_list->length -= 1;
}
if (isListEmpty(p_list)) {
p_list->head = NULL;
p_list->tail = NULL;
}
return 0;
}
Node *findByIdForNode(List *p_list, const SID *s_id) {
Node *ph_node = p_list->head;
Node *pt_node = p_list->tail;
int direction = 0;
while (ph_node != pt_node) {
if (direction == 0) {
if (simFitS_id(ph_node->s_id, s_id)) {
return ph_node;
}
else {
ph_node = ph_node->next;
}
direction = 1;
}
else {
if (simFitS_id(pt_node->s_id, s_id)) {
return pt_node;
}
else {
pt_node = pt_node->last;
}
}
}
return NULL;
}
Node *findByValue(List *p_list, unsigned int type, const void *value) {
Node *p_node = p_list->head;
while (p_node != NULL) {
if (p_node->type != type) {
p_node = p_node->next;
continue;
}
if (type == INT) {
if (*((int *)p_node->value) == *((int *)value)) {
return copyNode(p_node);
}
}
else if (type == DOUBLE) {
if (*((double *)p_node->value) == *((double *)value)) {
return copyNode(p_node);
}
}
else if (type == STRING) {
if (!strcmp((char *)p_node->value, (char *)value))
{
return copyNode(p_node);
}
}
else if (type == POINTER) {
if (p_node->value == value) {
return copyNode(p_node);
}
}
p_node = p_node->next;
}
return NULL;
}
List *mply_findByValue(List *p_list, unsigned int type, const void *value) {
List *f_list = initList();
Node *p_node = p_list->head;
while (p_node != NULL) {
if (p_node->type != type) {
p_node = p_node->next;
continue;
}
if (type == INT) {
if (*((int *)p_node->value) == *((int *)value)) {
Node *f_node = copyNode(p_node);
insertInTail(f_list, f_node);
}
}
else if (type == DOUBLE) {
if (*((double *)p_node->value) == *((double *)value)) {
Node *f_node = copyNode(p_node);
insertInTail(f_list, f_node);
}
}
else if (type == STRING) {
if (!strcmp((char *)p_node->value, (char *)value))
{
Node *f_node = copyNode(p_node);
insertInTail(f_list, f_node);
}
}
else if (type == POINTER) {
if (p_node->value == value) {
Node *f_node = copyNode(p_node);
insertInTail(f_list, f_node);
}
}
p_node = p_node->next;
}
return f_list;
}
int isListEmpty(List *p_list) {
if (p_list->head == NULL || p_list->tail == NULL)// If its head or tail is NULL,it would be thought as empty.
return 1; // But we should ensure that both of them are NULL when we
return 0; // want to make a list empty.
}
int exchangeLocation(Node *p_node, Node *t_node) {
Node *temp_next = p_node->next;
Node *temp_last = p_node->last;
p_node->last->next = t_node;
p_node->next->last = t_node;
t_node->last->next = p_node;
t_node->next->last = p_node;
p_node->next = t_node->next;
p_node->last = t_node->last;
t_node->next = temp_next;
t_node->last = temp_last;
return 0;
}
Node *copyNode(Node *p_node) {
Node *t_node = initNode();
t_node->s_id = p_node->s_id;
t_node->last = p_node->last;
t_node->next = p_node->next;
t_node->if_malloc = p_node->if_malloc;
t_node->type = p_node->type;
t_node->value = p_node->value;
return t_node;
}
List *copyList(List *p_list) {
Node *p_node;
Node *t_node;
List *t_list = initList();
t_list->head = p_list->head;
t_list->tail = p_list->tail;
t_list->s_id = p_list->s_id;
p_node = p_list->head;
while (p_node != NULL) {
t_node = copyNode(p_node);
insertInTail(t_list, t_node);
p_node = p_node->next;
}
return t_list;
}
int releaseOnlyNode(Node *p_node) {
freeS_id(p_node->s_id);
p_node->if_malloc = 0;
p_node->last = NULL;
p_node->next = NULL;
p_node->type = VOID;
p_node->value = NULL;
free(p_node);
return 0;
}
int releaseNodeForCustom(Node *p_node, int (*func)(void *)){
if (if_safeModeForNode == 1) {
removeByNode(node_list, p_node);
}
if (p_node->if_malloc == 1) {
if (func(p_node->value))
showError(pushError(LIST_NODE, STANDARD, initInfo("releaseNodeForCustom()", "Error in using custom freeing value function.")));
p_node->value = NULL;
}
p_node->last = NULL;
p_node->next = NULL;
p_node->type = VOID;
p_node->value = NULL;
freeS_id(p_node->s_id);
p_node->if_malloc = 0;
free(p_node);
return 0;
}
int releaseListForCustom(List *p_list, int (*func)(void *)){
Node *p_node, *pl_node;
p_node = p_list->head;
if (if_safeModeForNode == 1) {
Node *tar_list = findByValue(list_list, POINTER, (void *)p_list);
removeByNode(list_list, tar_list);
}
while (p_node != NULL) {
pl_node = p_node;
p_node = p_node->next;
pl_node->next = NULL;
pl_node->last = NULL;
releaseNodeForCustom(pl_node,func);
}
p_list->head = NULL;
p_list->tail = NULL;
p_list->length = 0;
freeS_id(p_list->s_id);
free(p_list);
return 0;
}
int pushInfo(Info *p_info, const char *head, const char *body) {
strcpy(p_info->head, head);
strcpy(p_info->body, body);
return 0;
}
Error *pushError(unsigned int type, int pri, Info *p_info) {
Error *p_error = (Error *)malloc(sizeof(Error));
p_error->type = type;
p_error->priority = pri;
p_error->info = *p_info;
p_error->time = time(NULL);
free(p_info);
return p_error;
}
Notice *pushNotice(unsigned int type, Info *p_info) {
Notice *p_notice = (Notice *)malloc(sizeof(Notice));
p_notice->type = type;
p_notice->info = *p_info;
p_notice->time = time(NULL);
free(p_info);
return p_notice;
}
Info *initInfo(const char *head, const char *body){
Info *p_info = (Info *)malloc(sizeof(Info));
pushInfo(p_info, head, body);
return p_info;
}
int showError(Error *p_error){
printf("\n");
for (int i = 0; i < p_error->priority; i++) {
printf("!");
}
printf("(Error) %s\n",asctime(localtime(&p_error->time)));
printf("%s: %s.\n",p_error->info.head,p_error->info.body);
free(p_error);
return 0;
}
int showWarning(Notice *p_notice){
printf("\n@");
printf("(Warning) %s\n",asctime(localtime(&p_notice->time)));
printf("%s: %s.\n",p_notice->info.head,p_notice->info.body);
free(p_notice);
return 0;
}

58
list/list.h
View File

@ -1,58 +0,0 @@
#ifndef LIST_H
#define LIST_H
#include "../type/type.h"
#include "../id/id.h"
int safeModeForNode(int ifon);
int releaseSingleListForsafeModeForNode(List *p_list);
int releaseSingleNodeForsafeModeForNode(List *p_list);
int releaseAllForNode(void);
List *initList(void);
Node *initNode(void);
int initMallocValueForNode(Node *,unsigned int,const void *);
int insertInHead(List *p_list, Node *p_node);
int insertInTail(List *p_list, Node *p_node);
int exchangeLocation(Node *p_node,Node *t_node);
Node *copyNode(Node *);
int removeById(List *p_list, const SID *s_id);
int removeByNode(List *p_list, Node *p_node);
int popFromHead(List *p_list);
int popFromTail(List *p_list);
unsigned long long len(List *p_list);
Node *findByIdForNode(List *p_list, const SID *s_id);
Node *findByValue(List *p_list, unsigned int type, const void *value);
List *mply_findByValue(List *p_list, unsigned int type, const void *value);
int releaseList(List *p_list);
int releaseListForCustom(List *p_list, int (*func)(void *));
int releaseListForSingle(List *p_list);
int releaseNode(Node *p_node);
int releaseNodeForCustom(Node *p_node, int (*func)(void *));
int releaseOnlyNode(Node *p_node);
int isListEmpty(List *p_list);
List *copyList(List *p_list);
int pushInfo(Info *p_info, const char *head,const char *body);
Error *pushError(unsigned int type, int pri, Info *p_info);
Notice *pushNotice(unsigned int type, Info *p_info);
Info *initInfo(const char *head, const char *body);
Error *createError(Info *info,unsigned int type,int pri);
Notice *createWarning(Info *info, unsigned int type, int pri);
int showError(Error *);
int showWarning(Notice *);
static int if_safeModeForNode;
static List *node_list;
static List *list_list;
#endif

475
list/list_expand.c
View File

@ -1,475 +0,0 @@
#include "list_expand.h"
Node *nodeWithInt(int m_int) {
Node *p_node;
int *p_int = (int *)malloc(sizeof(int));
if(p_int == NULL){
showError(pushError(INT, STANDARD, initInfo("nodeWithInt()", "Error in getting the memory of int.")));
return NULL;
}
*p_int = m_int;
p_node = initNode();
initMallocValueForNode(p_node, INT, (void *)p_int);
return p_node;
}
Node *nodeWithUInt(unsigned int m_uint){
Node *p_node;
unsigned int *pu_int = (unsigned int *)malloc(sizeof(unsigned int));
if(pu_int == NULL){
showError(pushError(INT, STANDARD, initInfo("nodeWithUInt()", "Error in getting the memory of int.")));
return NULL;
}
*pu_int = m_uint;
p_node = initNode();
initMallocValueForNode(p_node, INT, (void *)pu_int);
return p_node;
}
Node *nodeWithDouble(double m_double) {
Node *p_node;
double *p_double = (double *)malloc(sizeof(double));
if(p_double == NULL){
showError(pushError(DOUBLE, STANDARD, initInfo("nodeWithDouble()", "Error in getting the memory of double.")));
return NULL;
}
*p_double = m_double;
p_node = initNode();
initMallocValueForNode(p_node, DOUBLE, (void *)p_double);
return p_node;
}
Node *nodeWithString(const char *m_string) {
Node *p_node;
char *p_string = (char *)malloc(sizeof(char)*(strlen(m_string) + 1));
if(p_string == NULL){
showError(pushError(STRING, STANDARD, initInfo("initWithString()", "Error in getting the memory of string.")));
return NULL;
}
strcpy(p_string, m_string);
p_node = initNode();
initMallocValueForNode(p_node, STRING, (void *)p_string);
return p_node;
}
Node *nodeWithPointer(const void *m_pointer) {
Node *p_node = initNode();
initMallocValueForNode(p_node, POINTER, m_pointer);
return p_node;
}
Node *nodeWithComplex(void) {
Node *p_node = initNode();
p_node->type = LIST;
p_node->value = initList();
p_node->if_malloc = 1;
return p_node;
}
Node *findByIndexForNode(List *p_list, unsigned long long m_index) {
Node *p_node = p_list->head;
unsigned long long i;
for (i = 0; i < m_index; i++) {
p_node = p_node->next;
}
return p_node;
}
List *listThrough(List *p_list, List *(*p_func)(unsigned int, void *, List *), List *expand_resources) {
Node *p_node = p_list->head;
List *m_rtnlst = NULL;
while (p_node != NULL) {
if (p_node->if_malloc == 1) {
List *m_rtnlst = (*p_func)(p_node->type, p_node->value, expand_resources);
int status = getByIntForNode(findByIndexForNode(m_rtnlst, 0));
if (status == -1) break;
else if (status == 1) {
p_node = p_node->last;
releaseList(m_rtnlst);
m_rtnlst = NULL;
continue;
}
else {
releaseList(m_rtnlst);
m_rtnlst = NULL;
}
}
p_node = p_node->next;
}
return m_rtnlst;
}
int getByIntForNode(Node *p_node) {
if (p_node->type == INT) return *(int *)(p_node->value);
else return -1;
}
unsigned int getByUIntForNode(Node *p_node){
if (p_node->type == UINT) return *(unsigned int *)(p_node->value);
else return -1;
}
char *getByStringForNode(Node *p_node) {
if (p_node->type == STRING) return (char *)(p_node->value);
else return NULL;
}
double getByDoubleForNode(Node *p_node) {
if (p_node->type == DOUBLE) return *(double *)(p_node->value);
else return -1;
}
void *getByPointerForNode(Node *p_node) {
if (p_node->type == POINTER) return (void *)(p_node->value);
else return NULL;
}
void printListInfo(List *p_list, int priority) {
int i = 0;
Node *p_node;
for (i = 0; i < priority; i++) printf(" ");
printf("###LIST(location:%p, id:%s){\n", p_list, s_idToASCIIString(p_list->s_id));
for (i = 0; i < priority + 1; i++) printf(" ");
printf("HEAD->%p / Tail->%p / Length:%llu\n", p_list->head, p_list->tail, p_list->length);
p_node = p_list->head;
while (p_node != NULL) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("%d.... \n", i);
printNodeInfo(p_node, priority + 1);
p_node = p_node->next;
i++;
}
for (i = 0; i < priority; i++) printf(" ");
printf("}\n");
}
void printList(List *p_list) {
int if_nearLast = 0;
Node *p_node = p_list->head;
printf("[");
while (p_node != NULL) {
if (!if_nearLast && p_node->next == NULL) if_nearLast = 1;
if (p_node->type == INT) {
printf("%d", *(int *)(p_node->value));
}
else if (p_node->type == DOUBLE) {
printf("%a", *(double *)(p_node->value));
}
else if (p_node->type == STRING) {
printf("%s", (char *)(p_node->value));
}
else if (p_node->type == POINTER) {
printf("%p", (char *)(p_node->value));
}
else if (p_node->type == LIST) {
printList((List *)p_node->value);
}
if (!if_nearLast) {
printf(", ");
}
p_node = p_node->next;
}
printf("]");
}
void printNodeInfo(Node *p_node, int priority) {
int i;
for (i = 0; i < priority; i++) printf(" ");
printf("#NODE(location:%p, id:%s){\n", p_node, s_idToASCIIString(p_node->s_id));
for (i = 0; i < priority + 1; i++) printf(" ");
printf("NEXT->%p / LAST->%p / MALLOC:%d\n", p_node->next, p_node->last, p_node->if_malloc);
if (p_node->type == INT) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("VALUE(int):%d\n", *(int *)(p_node->value));
}
else if (p_node->type == DOUBLE) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("VALUE(double):%a\n", *(double *)(p_node->value));
}
else if (p_node->type == STRING) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("VALUE(string):%s\n", (char *)(p_node->value));
}
else if (p_node->type == POINTER) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("VALUE(pointer):%s\n", (char *)(p_node->value));
}
else if (p_node->type == LIST) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("VALUE(List):\n");
printListInfo((List *)p_node->value, priority + 2);
}
for (i = 0; i < priority; i++) printf(" ");
printf("}\n");
}
void printNode(Node *p_node) {
int i;
printf("#NODE(location:%p, id:%s){\n", p_node, s_idToASCIIString(p_node->s_id));
printf(" ");
printf("NEXT->%p / LAST->%p\n", p_node->next, p_node->last);
for (i = 0; i < 1; i++) printf(" ");
printf("ifMalloc: ");
if (p_node->if_malloc) {
printf("YES\n");
for (i = 0; i < 1; i++) printf(" ");
printf("Value(type: %d): ", p_node->type);
if (p_node->type == INT) {
printf("%d", *(int *)(p_node->value));
}
else if (p_node->type == DOUBLE) {
printf("%a\n", *(double *)(p_node->value));
}
else if (p_node->type == STRING) {
printf("%s\n", (char *)(p_node->value));
}
else if (p_node->type == POINTER) {
printf("%p\n", (char *)(p_node->value));
}
else if (p_node->type == LIST) {
printList((List *)p_node->value);
}
}
else printf("NO\n");
printf("}\n");
}
Node *findByIntForNode(List *p_list, int target) {
Node *t_node;
int *p_target = (int *)malloc(sizeof(int));
*p_target = target;
t_node = findByValue(p_list, INT, p_target);
free(p_target);
return t_node;
}
Node *findByDoubleForNode(List *p_list, double target) {
Node *t_node;
double *p_target = (double *)malloc(sizeof(double));
*p_target = target;
t_node = findByValue(p_list, DOUBLE, p_target);
free(p_target);
return t_node;
}
Node *findByStringForNode(List *p_list, char *target) {
Node *t_node;
char *p_temp = (char *)malloc(sizeof(char)*(strlen(target) + 1));
strcpy(p_temp, target);
t_node = findByValue(p_list, STRING, p_temp);
free(p_temp);
return t_node;
}
Node *findByPointerForNode(List *p_list, void *target) {
Node *t_node = findByValue(p_list, POINTER, target);
return t_node;
}
int addValueForComplex(Node * p_node, int type, void *value) {
List *c_list;
Node *c_node;
if (p_node->type == LIST) {
c_list = (List *)p_node->value;
c_node = initNode();
initMallocValueForNode(c_node, type, value);
insertInTail(c_list, c_node);
return 0;
}
return -1;
}
int addIntForComplex(Node *p_node, int temp) {
if (p_node->type == LIST) {
int *p_temp = (int *)malloc(sizeof(int));
if(p_temp == NULL){
showError(pushError(INT, STANDARD, initInfo("addIntForComplex()", "Error in getting the memory of int.")));
return -1;
}
*p_temp = temp;
addValueForComplex(p_node, INT, p_temp);
return 0;
}
return -1;
}
int addDoubleForComplex(Node *p_node, double temp) {
if (p_node->type == LIST) {
double *p_temp = (double *)malloc(sizeof(double));
if(p_temp == NULL){
showError(pushError(DOUBLE, STANDARD, initInfo("addDoubleForComplex()", "Error in getting the memory of double.")));
return -1;
}
*p_temp = temp;
addValueForComplex(p_node, DOUBLE, p_temp);
return 0;
}
return -1;
}
int addStringForComplex(Node *p_node, char *temp) {
if (p_node->type == LIST) {
char *p_temp = (char *)malloc(sizeof(strlen(temp) + 1));
if(p_temp == NULL){
showError(pushError(STRING, STANDARD, initInfo("addStringForComplex()", "Error in getting the memory of string.")));
return -1;
}
strcpy(p_temp, temp);
addValueForComplex(p_node, STRING, p_temp);
return 0;
}
return -1;
}
int addPointerForComplex(Node *p_node, void *temp) {
if (p_node->type == LIST) {
addValueForComplex(p_node, POINTER, temp);
return 0;
}
return -1;
}
List *m_findByInt(List* p_list, int temp) {
int *p_temp = (int *)malloc(sizeof(int));
if(p_temp == NULL){
showError(pushError(INT, STANDARD, initInfo("m_findByInt()", "Error in getting the memory of int.")));
return NULL;
}
List *t_list;
*p_temp = temp;
t_list = mply_findByValue(p_list, INT, (void *)p_temp);
free(p_temp);
return t_list;
}
List *m_findByDouble(List* p_list, double temp) {
List *t_list;
double *p_temp = (double *)malloc(sizeof(double));
if(p_temp == NULL){
showError(pushError(DOUBLE, STANDARD, initInfo("m_findByDouble()", "Error in getting the memory of double.")));
return NULL;
}
*p_temp = temp;
t_list = mply_findByValue(p_list, DOUBLE, (void *)p_temp);
free(p_temp);
return t_list;
}
List *m_findByString(List* p_list, char *temp) {
List *t_list;
char *p_temp = (char *)malloc(sizeof(char)*(strlen(temp) + 1));
if(p_temp == NULL){
showError(pushError(STRING, STANDARD, initInfo("m_findByString()", "Error in getting the memory of string.")));
return NULL;
}
strcpy(p_temp, temp);
t_list = mply_findByValue(p_list, STRING, (void *)p_temp);
free(p_temp);
return t_list;
}
List *m_findByPointer(List* p_list, void *temp) {
List *t_list = mply_findByValue(p_list, DOUBLE, (void *)temp);
return t_list;
}
unsigned long long getIndexByNode(List *p_list, Node *p_node) {
Node *t_node = p_list->head;
unsigned long long index = 0;
while (t_node != NULL) {
if (p_node->s_id == t_node->s_id) return index;
index++;
t_node = t_node->next;
}
return 0;
}
List *m_findByIntForNode(List* p_list, int temp) {
int *p_temp = (int *)malloc(sizeof(int));
if(p_temp == NULL){
showError(pushError(INT, STANDARD, initInfo("m_findByIntForNode()", "Error in getting the memory of int.")));
return NULL;
}
*p_temp = temp;
return mply_findByValue(p_list, INT, (void *)p_temp);
}
List *m_findByDoubleForNode(List* p_list, double temp) {
double *p_temp = (double *)malloc(sizeof(double));
if(p_temp == NULL){
showError(pushError(DOUBLE, STANDARD, initInfo("m_findByDoubleForNode()", "Error in getting the memory of double.")));
return NULL;
}
*p_temp = temp;
return mply_findByValue(p_list, DOUBLE, (void *)p_temp);
}
List *m_findByStringForNode(List* p_list, char *temp) {
char *p_temp = (char *)malloc(sizeof(char) * (strlen(temp) + 1));
if(p_temp == NULL){
showError(pushError(STRING, STANDARD, initInfo("m_findByStringForNode()", "Error in getting the memory of string.")));
return NULL;
}
strcpy(p_temp, temp);
return mply_findByValue(p_list, STRING, (void *)p_temp);
}
List *m_findByPointerForNode(List* p_list, void *temp) {
return mply_findByValue(p_list, POINTER, (void *)temp);
}
unsigned long long calListMemory(List * p_list){
Node *p_node = p_list->head;
unsigned long long nodes_size = 0LL;
unsigned long long list_size = sizeof(p_list);
while(p_node != NULL){
nodes_size += sizeof(p_node);
p_node = p_node->next;
}
return list_size + nodes_size;
}
int updateValueWithInt(Node *p_node,int value){
int *p_value = (int *)malloc(sizeof(int));
if(p_value == NULL){
showError(pushError(INT, STANDARD, initInfo("updateValueWithInt()", "Error in getting the memory of int.")));
return -1;
}
*p_value = value;
free(p_node->value);
p_node->value = p_value;
return 0;
}
int updateValueWithDouble(Node *p_node, double value){
double *p_value = (double *)malloc(sizeof(double));
if(p_value == NULL){
showError(pushError(DOUBLE, STANDARD, initInfo("updateValueWithDouble()", "Error in getting the memory of double.")));
return -1;
}
*p_value = value;
free(p_node->value);
p_node->value = p_value;
return 0;
}
int updateValueWithString(Node *p_node, char *string){
char *p_value = (char *)malloc(sizeof(strlen(string)) + 1);
if(p_value == NULL){
showError(pushError(STRING, STANDARD, initInfo("updateValueWithString()", "Error in getting the memory of string.")));
return -1;
}
strcpy(p_value, string);
free(p_node->value);
p_node->value = p_value;
return 0;
}
int updateValueWithPointer(Node *p_node, void *pointer){
free(p_node->value);
p_node->value = pointer;
return 0;
}

50
list/list_expand.h
View File

@ -1,50 +0,0 @@
#ifndef LIST_EXPAND_H
#define LIST_EXPAND_H
#include "list.h"
Node *nodeWithInt(int);
Node *nodeWithUInt(unsigned int);
Node *nodeWithDouble(double);
Node *nodeWithString(const char *);
Node *nodeWithPointer(const void *);
Node *nodeWithComplex(void);
int addValueForComplex(Node *, int type, void *value);
int addIntForComplex(Node *, int);
int addDoubleForComplex(Node *, double);
int addStringForComplex(Node *, char *);
int addPointerForComplex(Node *, void *);
int updateValueWithInt(Node *,int);
int updateValueWithDouble(Node *,double);
int updateValueWithString(Node *,char *);
int updateValueWithPointer(Node *,void *);
Node *findByIndexForNode(List *, unsigned long long);
Node *findByIntForNode(List *, int);
Node *findByDoubleForNode(List *, double);
Node *findByStringForNode(List *, char *);
Node *findByPointerForNode(List *, void *);
List *m_findByIntForNode(List*, int);
List *m_findByDoubleForNode(List*, double);
List *m_findByStringForNode(List*, char *);
List *m_findByPointerForNode(List*, void *);
void printListInfo(List *p_list,int priority);
void printNodeInfo(Node *p_node,int priority);
void printList(List *);
void printNode(Node *p_node);
int getByIntForNode(Node *);
unsigned int getByUIntForNode(Node *);
double getByDoubleForNode(Node *);
char *getByStringForNode(Node *);
void *getByPointerForNode(Node *);
unsigned long long getIndexByNode(List *p_list,Node *p_node);
List *listThrough(List *p_list, List *(*p_func)(unsigned int type, void *value, List *), List *expand_resources);
unsigned long long calListMemory(List *);
#endif

49
src/communicate/communicate.c Normal file
View File

@ -0,0 +1,49 @@
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>
MSG *createMessage(char *title, void *data, unsigned long data_size){
MSG *p_msg = malloc(sizeof(MSG) + data_size);
p_msg->p_sid = getS_id(MESSAGE, 1);
p_msg->time = time(NULL);
return p_msg;
}
/*int sendMessageIPv4(MSG *p_msg, char *ip, unsigned int port){
int client_sockfd;
struct sockaddr_in remote_addr;
char buf[BUFSIZ];
memcpy(buf, "ZEMSG", 5);
memset(&remote_addr,0,sizeof(remote_addr));
remote_addr.sin_family=AF_INET;
remote_addr.sin_addr.s_addr=inet_addr(ip);
remote_addr.sin_port=htons(port);
client_sockfd=socket(PF_INET,SOCK_STREAM,0);
connect(client_sockfd,(struct sockaddr *)&remote_addr,sizeof(struct sockaddr));
send(client_sockfd,buf,strlen(buf),0);
unsigned long bkmsg_len = 0;
bkmsg_len = recv(client_sockfd, buf, BUFSIZ, 0);
buf[bkmsg_len] = '\0';
if(!strcmp(buf, "TITLE_REV_READY")){
memcpy(buf, p_msg->titile, strlen(p_msg->titile));
bkmsg_len = recv(client_sockfd, buf, BUFSIZ, 0);
buf[bkmsg_len] = '\0';
if(!strcmp(buf, "CONTENT_LEN_REV_READY")){
memcpy(buf, (char *)p_msg->size, sizeof(unsigned int));
send(client_sockfd,buf,sizeof(unsigned int),0);
bkmsg_len = recv(client_sockfd, buf, BUFSIZ, 0);
buf[bkmsg_len] = '\0';
if(!strcmp(buf, "CONTENT_REV_READY")){
memcpy(buf, p_msg->content, p_msg->size);
send(client_sockfd,buf,p_msg->size,0);
close(client_sockfd);
return 0;
}
}
}
close(client_sockfd);
return -1;
}*/

49
src/communicate/dfile/dfile_in.c Normal file
View File

@ -0,0 +1,49 @@
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>
int dataFileReadOut(D_FILE *p_dfile){
if(!readDataFileInfo(p_dfile)){
listThrough(p_dfile->pf_stdlst, __CALLBACK_CALL(dataFileReadOut), __SEND_ARG("%p", p_dfile));
}
return -1;
}
__CALLBACK_DEFINE(dataFileReadOut){
D_FILE *p_dfile = __ARGS_P(0, D_FILE);
readStandardData(p_dfile, __VALUE(STD_DATA *));
return __CRETURN__;
}
int readDataFileInfo(D_FILE *p_dfile){
if(checkIfDataFile(p_dfile)){
uint32_t std_num = 0,std_size;
uint16_t std_type = VOID;
char info_begin[INFO_TEST_LEN], s_id[SID_LEN];
uint32_t location = 0;
fread(&std_num, sizeof(uint32_t), 1, p_dfile->fp);
fread(info_begin, sizeof(char),INFO_TEST_LEN,p_dfile->fp);
location += INFO_TEST_LEN + sizeof(uint32_t) + FILE_TSET_LEN;
if(!strcmp(info_begin, "STDINFO")){
location += std_num * 45 + 7;
for(int i = 0; i < std_num; i++){
fread(s_id, sizeof(char), SID_LEN, p_dfile->fp);
fread(&std_type, sizeof(uint16_t), 1, p_dfile->fp);
fread(&std_size, sizeof(uint32_t), 1, p_dfile->fp);
SID *temp_sid = setS_idWithString(s_id);
STD_DATA *p_std = initStandardData(std_type,temp_sid);
freeS_id(temp_sid);
p_std->size = std_size;
p_std->type = std_type;
p_std->location = location;
dataFileAddStandardData(p_dfile, p_std);
location += std_size;
}
}
}
return 0;
}

13
src/communicate/dfile/dfile_info.c Normal file
View File

@ -0,0 +1,13 @@
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>
int checkIfDataFile(D_FILE *p_dfile){
char test_info[FILE_TSET_LEN];
fread(test_info, sizeof(char), FILE_TSET_LEN, p_dfile->fp);
strcpy(p_dfile->pf_head->head_test, test_info);
if(!strcmp(test_info, "ZESTDLIB_STDDFILE"))return 1;
return 0;
}

24
src/communicate/dfile/dfile_init.c Normal file
View File

@ -0,0 +1,24 @@
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>
D_FILE *initDataFileForWrite(char *route){
D_FILE *p_dfile = (D_FILE *)malloc(sizeof(D_FILE));
p_dfile->fp = fopen(route, "wb");
p_dfile->pf_head = (F_HEAD *)malloc(sizeof(F_HEAD));
strcpy(p_dfile->pf_head->head_test,"ZESTDLIB_STDDFILE");
p_dfile->pf_head->data_num = 0;
p_dfile->pf_stdlst = initList(0);
return p_dfile;
}
D_FILE *initDataFileForRead(char *route){
D_FILE *p_dfile = (D_FILE *)malloc(sizeof(D_FILE));
p_dfile->fp = fopen(route, "rb");
p_dfile->pf_head = (F_HEAD *)malloc(sizeof(F_HEAD));
p_dfile->pf_head->data_num = 0;
p_dfile->pf_stdlst = initList(0);
return p_dfile;
}

11
src/communicate/dfile/dfile_insert.c Normal file
View File

@ -0,0 +1,11 @@
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>
int dataFileAddStandardData(D_FILE *p_dfile, STD_DATA *p_std){
insertInTail(p_dfile->pf_stdlst, nodeWithPointer(p_std,0));
p_dfile->pf_head->data_num = (uint32_t)p_dfile->pf_stdlst->length;
return 0;
}

15
src/communicate/dfile/dfile_out.c Normal file
View File

@ -0,0 +1,15 @@
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>
int dataFileWriteIn(D_FILE *p_dfile){
fwrite(p_dfile->pf_head->head_test, sizeof(char), 18, p_dfile->fp);
fwrite(&p_dfile->pf_head->data_num, sizeof(uint32_t), 1, p_dfile->fp);
fwrite("STDINFO", sizeof(char), 8, p_dfile->fp);
listThrough(p_dfile->pf_stdlst, __CALLBACK_CALL(StandardDataInfoWrite), __SEND_ARG("%p", p_dfile->fp));
fwrite("STDLST", sizeof(char), 7, p_dfile->fp);
listThrough(p_dfile->pf_stdlst, __CALLBACK_CALL(StandardDataWrite), __SEND_ARG("%p", p_dfile->fp));
return 0;
}

13
src/communicate/dfile/dfile_release.c Normal file
View File

@ -0,0 +1,13 @@
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>
int releaseDFile(D_FILE *p_dfile){
releaseListForCustom(p_dfile->pf_stdlst, (int (*)(void *))releaseStandardData);
fclose(p_dfile->fp);
free(p_dfile->pf_head);
free(p_dfile);
return 0;
}

14
src/communicate/std/std_find.c Normal file
View File

@ -0,0 +1,14 @@
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>
__CALLBACK_DEFINE(findStandardDataBySid){
SID *t_sid = __ARGS_P(0, SID);
STD_DATA *p_std = __VALUE(STD_DATA *);
if(simFitS_id(p_std->s_id, t_sid)){
return __RETURN("%p", p_std);
}
return __CRETURN__;
}

59
src/communicate/std/std_in.c Normal file
View File

@ -0,0 +1,59 @@
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>
int readStandardData(D_FILE *p_dfile,STD_DATA *p_std){
char s_id[SID_LEN],std_text[STD_TEXT_LEN];
fseek(p_dfile->fp, p_std->location, SEEK_SET);
fread(std_text, sizeof(char), STD_TEXT_LEN, p_dfile->fp);
if(strcmp(std_text, "STD")) return -1;
fread(s_id, sizeof(char), SID_LEN, p_dfile->fp);
if(!strcmp(s_id, p_std->s_id->decrypt_str)){
uint32_t ctn_num = 0, blk_num = 0;
fread(&ctn_num, sizeof(uint32_t), 1, p_dfile->fp);
fread(&blk_num, sizeof(uint32_t), 1, p_dfile->fp);
for(int i = 0; i < ctn_num; i++){
SID *fs_id = NULL, *ss_id = NULL;
char t_sid[SID_LEN];
fread(t_sid, sizeof(char), SID_LEN, p_dfile->fp);
fs_id = setS_idWithString(t_sid);
fread(t_sid, sizeof(char), SID_LEN, p_dfile->fp);
ss_id = setS_idWithString(t_sid);
standardDataAddConnection(p_std, fs_id, ss_id);
freeS_id(fs_id);
freeS_id(ss_id);
}
for(int i = 0; i < blk_num; i++){
int if_sid = 0;
uint16_t type = VOID;
uint32_t blk_size = 0;
char t_sid[SID_LEN];
fread(&if_sid, sizeof(int32_t), 1, p_dfile->fp);
if(if_sid){
fread(t_sid, sizeof(char), SID_LEN, p_dfile->fp);
}
fread(&type, sizeof(int32_t), 1, p_dfile->fp);
fread(&blk_size, sizeof(uint32_t), 1, p_dfile->fp);
char *buff = malloc(sizeof(char) * blk_size);
fread(buff, sizeof(char), blk_size, p_dfile->fp);
SID *sb_sid = NULL;
if (if_sid) setS_idWithString(t_sid);
standardDataAddBlock(p_std, sb_sid, type, buff, blk_size);
free(buff);
freeS_id(sb_sid);
}
}
p_std->read_data = 1;
return 0;
}
int readStandardDataBySid(D_FILE *p_dfile, SID *p_sid){
List *rtn = listThrough(p_dfile->pf_stdlst, __CALLBACK_CALL(findStandardDataBySid), __SEND_ARG("%p", p_sid));
//STD_DATA *p_std = __RTN_ARGS_P(rtn, 0, STD_DATA);
releaseList(rtn);
//if(p_std != NULL) readStandardData(p_dfile, p_std);
return 0;
}

44
src/communicate/std/std_info.c Normal file
View File

@ -0,0 +1,44 @@
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>
uint32_t calStandardData(STD_DATA *p_std){
List *rtn_lst = NULL;
uint32_t size = 4 + sizeof(unsigned long long) * 2;
if(p_std->s_id != NULL) size += SID_LEN * sizeof(char);
rtn_lst = listThrough(p_std->pd_ctnlst, __CALLBACK_CALL(calStandardDataCTN), __SEND_ARG("%d", size));
if(rtn_lst != NULL){
size = __RTN_ARGS(rtn_lst, 0, uint32_t);
releaseList(rtn_lst);
}
rtn_lst = listThrough(p_std->pd_blocklst, __CALLBACK_CALL(calStandardDataBLK), __SEND_ARG("%d", size));
if(rtn_lst != NULL){
size = __RTN_ARGS(rtn_lst, 0, uint32_t);
releaseList(rtn_lst);
}
return size;
}
__CALLBACK_DEFINE(calStandardDataBLK){
uint32_t size = __ARGS(0, uint32_t);
STD_BLOCKS *p_stdb = __VALUE(STD_BLOCKS *);
if(p_stdb->sid != NULL) size += SID_LEN + sizeof(int32_t);
else size += sizeof(int32_t);
size += p_stdb->blocks_num + sizeof(uint16_t) + sizeof(uint32_t);
//unsigned long long temp = __NOW_INDEX;
if(__NOW_INDEX == __LIST_LEN - 1){
return __RETURN("%ull", size);
}
return __CRETURN__;
}
void printStandardData(void *value){
STD_DATA *p_std = (STD_DATA *)value;
printf("SID:%s\n",p_std->s_id->decrypt_str);
printf("Loaction:%u\n",p_std->location);
printf("Size:%u\n",p_std->size);
printf("Ctn number:%llu\n",p_std->pd_ctnlst->length);
printf("Blk number:%llu\n",p_std->pd_blocklst->length);
}

31
src/communicate/std/std_init.c Normal file
View File

@ -0,0 +1,31 @@
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>
STD_CTN *initStandardDConnection(SID *f_sid, SID *s_sid){
STD_CTN *p_stdc = (STD_CTN *)malloc(sizeof(STD_CTN));
p_stdc->f_sid = s_idToASCIIString(f_sid);
p_stdc->s_sid = s_idToASCIIString(s_sid);
p_stdc->location = 0;
return p_stdc;
}
STD_DATA *initStandardData(uint16_t type, SID *s_id){
STD_DATA *p_std = (STD_DATA *)malloc(sizeof(STD_DATA));
p_std->pd_blocklst = initList(0);
p_std->pd_ctnlst = initList(0);
p_std->lock = 0;
p_std->type = type;
p_std->size = 0;
p_std->location = 0;
p_std->read_data = 0;
if(s_id == NULL) p_std->s_id = getS_id(STANDARD_DATA, 2);
else p_std->s_id = copyS_id(s_id);
setSidToASCIIString(p_std->s_id);
return p_std;
}

20
src/communicate/std/std_insert.c Normal file
View File

@ -0,0 +1,20 @@
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>
int standardDataAddBlock(STD_DATA *p_std, SID *p_sid ,uint16_t type, void *data, uint32_t data_size){
if (p_std->lock) return -1;
STD_BLOCKS *p_stdb = initStandardDBlocks(p_sid, type,data_size);
dataForStandardDBlock(p_stdb, data);
insertInTail(p_std->pd_blocklst, nodeWithPointer(p_stdb,0));
return 0;
}
int standardDataAddConnection(STD_DATA *p_std, SID *f_sid, SID *s_sid){
if (p_std->lock) return -1;
STD_CTN *p_stdb = initStandardDConnection(f_sid, s_sid);
insertInTail(p_std->pd_ctnlst, nodeWithPointer(p_stdb,0));
return 0;
}

29
src/communicate/std/std_out.c Normal file
View File

@ -0,0 +1,29 @@
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>
__CALLBACK_DEFINE(StandardDataInfoWrite){
FILE *fp = __ARGS_P(0, FILE);
STD_DATA *p_std = __VALUE(STD_DATA *);
fwrite(p_std->s_id->decrypt_str, sizeof(char), SID_LEN, fp);
fwrite(&p_std->type, sizeof(uint16_t), 1, fp);
uint32_t std_size = calStandardData(p_std);
p_std->size = std_size;
fwrite(&std_size, sizeof(uint32_t), 1, fp);
return __CRETURN__;
}
__CALLBACK_DEFINE(StandardDataWrite){
FILE *fp = __ARGS_P(0, FILE);
STD_DATA *p_std = __VALUE(STD_DATA *);
fwrite("STD", sizeof(char), 4, fp);
fwrite(p_std->s_id->decrypt_str, sizeof(char), SID_LEN, fp);
fwrite(&p_std->pd_ctnlst->length, sizeof(uint32_t), 1, fp);
fwrite(&p_std->pd_blocklst->length, sizeof(uint32_t), 1, fp);
listThrough(p_std->pd_ctnlst, __CALLBACK_CALL(StandardDConnectionWrite), __SEND_ARG("%p", fp));
listThrough(p_std->pd_blocklst, __CALLBACK_CALL(StandardDBlockWrite), __SEND_ARG("%p", fp));
return __CRETURN__;
}

13
src/communicate/std/std_relaese.c Normal file
View File

@ -0,0 +1,13 @@
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>
int releaseStandardData(STD_DATA *p_std){
releaseListForCustom(p_std->pd_blocklst, (int (*)(void *))releaseSTDBlocks);
releaseListForCustom(p_std->pd_ctnlst, (int (*)(void *))releaseSTDConnection);
freeS_id(p_std->s_id);
free(p_std);
return 0;
}

6
src/communicate/stdb/stdb_in.c Normal file
View File

@ -0,0 +1,6 @@
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>

30
src/communicate/stdb/stdb_init.c Normal file
View File

@ -0,0 +1,30 @@
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>
STD_BLOCKS *initStandardDBlocks(SID *p_sid, uint16_t type, uint32_t data_size){
STD_BLOCKS *p_stdb = (STD_BLOCKS *)malloc(sizeof(STD_BLOCKS));
if(p_sid != NULL){
p_stdb->sid = s_idToASCIIString(p_sid);
}
else p_stdb->sid = NULL;
p_stdb->if_data = 0;
p_stdb->location = 0;
uint32_t blocks_num = (uint32_t)(data_size/sizeof(char));
p_stdb->blocks_num = blocks_num;
p_stdb->type = type;
p_stdb->buff = (char *)malloc(sizeof(char) * blocks_num);
return p_stdb;
}
int dataForStandardDBlock(STD_BLOCKS *p_stdb,void *data){
char *t_data = (char *)data;
/*unsigned int data_size = sizeof(data);*/
for(int i = 0; i < p_stdb->blocks_num; i++){
p_stdb->buff[i] = t_data[i];
}
p_stdb->if_data = 1;
return 0;
}

24
src/communicate/stdb/stdb_out.c Normal file
View File

@ -0,0 +1,24 @@
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>
__CALLBACK_DEFINE(StandardDBlockWrite){
STD_BLOCKS *p_stdb = value;
FILE *fp = __ARGS_P(0, FILE);
unsigned long blocks_num = p_stdb->blocks_num;
int if_sid = 0;
if(p_stdb->sid != NULL){
if_sid = 1;
fwrite(&if_sid, sizeof(int), 1, fp);
fwrite(p_stdb->sid, sizeof(char), SID_LEN, fp);
}
else{
fwrite(&if_sid, sizeof(int), 1, fp);
}
fwrite(&p_stdb->type, sizeof(uint16_t), 1, fp);
fwrite(&blocks_num, sizeof(uint32_t), 1, fp);
fwrite(p_stdb->buff, sizeof(char), p_stdb->blocks_num, fp);
return __CRETURN__;
}

12
src/communicate/stdb/stdb_release.c Normal file
View File

@ -0,0 +1,12 @@
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>
int releaseSTDBlocks(STD_BLOCKS *p_stdb){
free(p_stdb->buff);
free(p_stdb->sid);
free(p_stdb);
return 0;
}

14
src/communicate/stdc/stdc_in.c Normal file
View File

@ -0,0 +1,14 @@
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>
__CALLBACK_DEFINE(StandardDConnectionWrite){
FILE *fp = __ARGS_P(0, FILE);
STD_CTN *p_stdc = __VALUE(STD_CTN *);
fwrite(p_stdc->f_sid, sizeof(char), SID_LEN, fp);
fwrite(p_stdc->s_sid, sizeof(char), SID_LEN, fp);
return __CRETURN__;
}

15
src/communicate/stdc/stdc_info.c Normal file
View File

@ -0,0 +1,15 @@
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>
__CALLBACK_DEFINE(calStandardDataCTN){
uint32_t size = __ARGS(0, uint32_t);
size += 64;
//unsigned long long temp = __NOW_INDEX;
if(__NOW_INDEX == __LIST_LEN - 1){
__RETURN("%ull", size);
}
return __CRETURN__;
}

6
src/communicate/stdc/stdc_init.c Normal file
View File

@ -0,0 +1,6 @@
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>

6
src/communicate/stdc/stdc_out.c Normal file
View File

@ -0,0 +1,6 @@
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>

12
src/communicate/stdc/stdc_release.c Normal file
View File

@ -0,0 +1,12 @@
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>
int releaseSTDConnection(STD_CTN *p_stdc){
free(p_stdc->f_sid);
free(p_stdc->s_sid);
free(p_stdc);
return 0;
}

25
src/communicate/stdcvt/stcvt_in.c Normal file
View File

@ -0,0 +1,25 @@
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>
STD_DATA *listToSTD(List *p_list){
Node *p_node = p_list->head;
STD_DATA *p_std = NULL;
if (p_list->s_id != NULL){
p_std = initStandardData(LIST,p_list->s_id);
}
else p_std = initStandardData(LIST, NULL);
while (p_node != NULL) {
if(p_node->type == HOLE) continue;
uint32_t data_size = 0;
if(p_node->type == INT) data_size = sizeof(int);
else if (p_node->type == DOUBLE) data_size = sizeof(double);
else if (p_node->type == STRING) data_size = (uint32_t)strlen((char *)p_node->value) + 1;
else data_size = sizeof(void *);
standardDataAddBlock(p_std, p_node->s_id, p_node->type, p_node->value, data_size);
p_node = p_node->next;
}
return p_std;
}

23
src/communicate/stdcvt/stdcvt_out.c Normal file
View File

@ -0,0 +1,23 @@
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>
List *standardDataToList(STD_DATA *p_std){
List *p_list = initList(0);
listThrough(p_std->pd_blocklst, __CALLBACK_CALL(StandardDataToList), __SEND_ARG("%p", p_list));
return p_list;
}
__CALLBACK_DEFINE(StandardDataToList){
List *p_list = __ARGS_P(0, List);
STD_BLOCKS *p_stdb = __VALUE(STD_BLOCKS *);
Node *p_node = initNode(0);
p_node->s_id = setS_idWithString(p_stdb->sid);
p_node->type = p_stdb->type;
p_node->value = malloc(sizeof(p_stdb->blocks_num));
memcpy(p_node->value, p_stdb->buff, sizeof(p_stdb->blocks_num));
insertInTail(p_list, p_node);
return __CRETURN__;
}

20
src/datastruct/chain/chain_calculate.c Normal file
View File

@ -0,0 +1,20 @@
#include <type.h>
#include <chain/chain_type.h>
/**
计算链表占用的内存空间大小，以字节为单位输出。
@param p_list 指向目标链表的指针
@return 以字节为单位返回链表及链表内包含的节点所占的内存空间
*/
uint64_t calListMemory(Chain * p_list){
Node *p_node = p_list->head;
uint64_t nodes_size = 0LL;
uint64_t list_size = sizeof(p_list);
while(p_node != NULL){
nodes_size += sizeof(p_node);
p_node = p_node->next;
}
return list_size + nodes_size;
}

116
src/datastruct/chain/chain_complex.c Normal file
View File

@ -0,0 +1,116 @@
#include <type.h>
#include <chain/chain.h>
/**
创建一个新的且内容为链表的节点
@return 返回指向新节点的指针
*/
CNode *nodeWithComplex(void) {
CNode *p_node = initNode(0);
p_node->type = LIST;
p_node->value = initList(0);
return p_node;
}
/**
为一个内容为链表的节点中的链表中添加节点并指定内容
@param p_node 指向该节点的指针
@param type 内容的类型
@param value 指向该内容所在内存的指针
@return 操作成功则返回一个非负整数
*/
int addValueForComplex(CNode * p_node, int type, void *value) {
List *c_list;
CNode *c_node;
if (p_node->type == LIST) {
c_list = (List *)p_node->value;
c_node = initNode(0);
initMallocValueForNode(c_node, type, value);
insertInTail(c_list, c_node);
return 0;
}
return -1;
}
/**
为一个内容为链表的节点中的链表中添加整型类型的节点并初始化为相应的值
@param p_node 指向该节点的指针
@param temp 相应的整型值
@return 操作成功则返回非负整数
*/
int addIntForComplex(CNode *p_node, int temp) {
if (p_node->type == LIST) {
int *p_temp = (int *)malloc(sizeof(int));
if(p_temp == NULL){
return -1;
}
*p_temp = temp;
addValueForComplex(p_node, INT, p_temp);
return 0;
}
return -1;
}
/**
为一个内容为链表的节点中的链表中添加双精度浮点类型的节点并初始化为相应的值
@param p_node 指向该节点的指针
@param temp 相应的双精度浮点值
@return 操作成功则返回非负整数
*/
int addDoubleForComplex(CNode *p_node, double temp) {
if (p_node->type == LIST) {
double *p_temp = (double *)malloc(sizeof(double));
if(p_temp == NULL){
return -1;
}
*p_temp = temp;
addValueForComplex(p_node, DOUBLE, p_temp);
return 0;
}
return -1;
}
/**
为一个内容为链表的节点中的链表中添加字符串类型的节点并初始化为相应的值
@param p_node 指向该节点的指针
@param temp 相应的字符数组
@return 操作成功则返回非负整数
*/
int addStringForComplex(CNode *p_node, char *temp) {
if (p_node->type == LIST) {
char *p_temp = (char *)malloc(sizeof(strlen(temp) + 1));
if(p_temp == NULL){
return -1;
}
strcpy(p_temp, temp);
addValueForComplex(p_node, STRING, p_temp);
return 0;
}
return -1;
}
/**
为一个内容为链表的节点中的链表中添加指针类型的节点并初始化为相应的值
@param p_node 指向该节点的指针
@param temp 相应的指针
@return 操作成功则返回非负整数
*/
int addPointerForComplex(CNode *p_node, void *temp) {
if (p_node->type == LIST) {
addValueForComplex(p_node, POINTER, temp);
return 0;
}
return -1;
}

198
src/datastruct/chain/chain_find.c Normal file
View File

@ -0,0 +1,198 @@
#include <type.h>
#include <chain/chain.h>
/**
通过节点中储存的整型值来找到链表中第一个符合条件的节点
@param p_list 指向目标链表的指针
@param target 目标节点中储存的整型值
@return 返回指向目标节点的指针
*/
CNode *findByIntForNode(Chain *p_list, int target) {
CNode *t_node;
int *p_target = (int *)malloc(sizeof(int));
*p_target = target;
t_node = findByValue(p_list, INT, p_target);
free(p_target);
return t_node;
}
/**
通过节点中储存的双精度浮点值来找到链表中第一个符合条件的节点
@param p_list 指向目标链表的指针
@param target 目标节点中储存的双精度浮点值
@return 返回指向目标节点的指针
*/
CNode *findByDoubleForNode(Chain *p_list, double target) {
CNode *t_node;
double *p_target = (double *)malloc(sizeof(double));
*p_target = target;
t_node = findByValue(p_list, DOUBLE, p_target);
free(p_target);
return t_node;
}
/**
通过节点中储存的字符串值来找到链表中第一个符合条件的节点
@param p_list 指向目标链表的指针
@param target 目标节点中储存的字符数组值
@return 返回指向目标节点的指针
*/
CNode *findByStringForNode(Chain *p_list, char *target) {
CNode *t_node;
char *p_temp = (char *)malloc(sizeof(char)*(strlen(target) + 1));
strcpy(p_temp, target);
t_node = findByValue(p_list, STRING, p_temp);
free(p_temp);
return t_node;
}
/**
通过节点中储存的指针值来找到链表中第一个符合条件的节点
@param p_list 指向目标链表的指针
@param target 目标节点中储存的字符指针值
@return 返回指向目标节点的指针
*/
CNode *findByPointerForNode(Chain *p_list, void *target) {
CNode *t_node = findByValue(p_list, POINTER, target);
return t_node;
}
/**
通过节点中储存的整型值来找到链表中所有符合条件的节点
@param p_list 指向目标链表的指针
@param temp 目标节点中储存的整型值
@return 返回包含所有符合条件的节点的新的重组链表
*/
Chain *mply_findByInt(Chain* p_list, int temp) {
int *p_temp = (int *)malloc(sizeof(int));
if(p_temp == NULL){
return NULL;
}
Chain *t_list;
*p_temp = temp;
t_list = mply_findByValue(p_list, INT, (void *)p_temp);
free(p_temp);
return t_list;
}
/**
通过节点中储存的双精度浮点值来找到链表中所有符合条件的节点
@param p_list 指向目标链表的指针
@param temp 目标节点中储存的双精度浮点值
@return 返回包含所有符合条件的节点的新的重组链表
*/
Chain *mply_findByDouble(Chain* p_list, double temp) {
Chain *t_list;
double *p_temp = (double *)malloc(sizeof(double));
if(p_temp == NULL){
return NULL;
}
*p_temp = temp;
t_list = mply_findByValue(p_list, DOUBLE, (void *)p_temp);
free(p_temp);
return t_list;
}
/**
通过节点中储存的字符串值来找到链表中所有符合条件的节点
@param p_list 指向目标链表的指针
@param temp 目标节点中储存的字符串值
@return 返回包含所有符合条件的节点的新的重组链表
*/
Chain *mply_findByString(Chain* p_list, char *temp) {
Chain *t_list;
char *p_temp = (char *)malloc(sizeof(char)*(strlen(temp) + 1));
if(p_temp == NULL){
return NULL;
}
strcpy(p_temp, temp);
t_list = mply_findByValue(p_list, STRING, (void *)p_temp);
free(p_temp);
return t_list;
}
/**
通过节点中储存的指针值来找到链表中所有符合条件的节点
@param p_list 指向目标链表的指针
@param temp 目标节点中储存的指针值
@return 返回包含所有符合条件的节点的新的重组链表
*/
Chain *mply_findByPointer(Chain* p_list, void *temp) {
Chain *t_list = mply_findByValue(p_list, DOUBLE, (void *)temp);
return t_list;
}
/**
通过节点中储存的整型值来找到链表中所有符合条件的节点
@param p_list 指向目标链表的指针
@param temp 目标节点中储存的整型值
@return 返回包含所有符合条件的节点的新的重组链表
*/
inline Chain *mply_findByIntForNode(Chain* p_list, int temp) {
return mply_findByInt(p_list, temp);
}
/**
通过节点中储存的双精度浮点值来找到链表中所有符合条件的节点
@param p_list 指向目标链表的指针
@param temp 目标节点中储存的双精度浮点值
@return 返回包含所有符合条件的节点的新的重组链表
*/
inline Chain *mply_findByDoubleForNode(Chain* p_list, double temp) {
return mply_findByDouble(p_list, temp);
}
/**
通过节点中储存的字符串值来找到链表中所有符合条件的节点
@param p_list 指向目标链表的指针
@param temp 目标节点中储存的字符串值
@return 返回包含所有符合条件的节点的新的重组链表
*/
inline Chain *mply_findByStringForNode(Chain* p_list, char *temp) {
return mply_findByString(p_list, temp);
}
/**
通过节点中储存的指针值来找到链表中所有符合条件的节点
@param p_list 指向目标链表的指针
@param temp 目标节点中储存的指针值
@return 返回包含所有符合条件的节点的新的重组链表
*/
inline Chain *mply_findByPointerForNode(Chain* p_list, void *temp) {
return mply_findByPointer(p_list, temp);
}
/**
通过节点在链表中的序号位置来找到符合条件的节点
@param p_list 指向目标链表的指针
@param m_index 序号位置
@return 返回指向符合条件的链表的指针
*/
CNode *findByIndexForNode(Chain *p_list, unsigned long long m_index) {
if(p_list == NULL) return NULL;
CNode *p_node = p_list->head;
unsigned long long i;
for (i = 0; i < m_index; i++) {
p_node = p_node->next;
}
return p_node;
}

80
src/datastruct/chain/chain_get.c Normal file
View File

@ -0,0 +1,80 @@
#include <type.h>
#include <chain/chain.h>
/**
直接获取储存整型数据的节点的值
@param p_node 指向目标节点的指针
@return 成功则返回对应整型值，失败返回0
*/
int getByIntForNode(CNode *p_node) {
if (p_node->type == INT) return *(int *)(p_node->value);
else return 0;
}
/**
直接获取储存无符号整型数据的节点的值
@param p_node 指向目标节点的指针
@return 成功则返回对应无符号整型值，失败返回0
*/
unsigned int getByUIntForNode(CNode *p_node){
if (p_node->type == UINT) return *(unsigned int *)(p_node->value);
else return 0;
}
/**
直接获得节点中储存的字符串
@param p_node 指向目标节点的指针
@return 返回节点中储存的字符串
*/
char *getByStringForNode(CNode *p_node) {
if (p_node->type == STRING) return (char *)(p_node->value);
else return NULL;
}
/**
直接获得节点中储存的双精度浮点值
@param p_node 指向目标节点的指针
@return 返回节点中储存的双精度浮点值
*/
double getByDoubleForNode(CNode *p_node) {
if (p_node->type == DOUBLE) return *(double *)(p_node->value);
else return -1.0;
}
/**
直接获得节点中储存的指针值
@param p_node 指向目标节点的指针
@return 返回节点中储存的指针值
*/
void *getByPointerForNode(CNode *p_node) {
return (void *)(p_node->value);
}
/**
通过链表中相应的节点获得其在链表中的排列序号
@param p_list 指向目标链表
@param p_node 指向目标节点的指针
@return 成功返回相应排列序号，失败则会返回0
*/
unsigned long long getIndexByNode(Chain *p_list, CNode *p_node) {
register CNode *t_node = p_list->head;
register unsigned long long index = 0;
while (t_node != NULL) {
// id模块可能启用的时候则编译以下代码
#ifdef id_enable
if (p_node->s_id == t_node->s_id) return index;
#endif
index++;
t_node = t_node->next;
}
return 0;
}

117
src/datastruct/chain/chain_node.c Normal file
View File

@ -0,0 +1,117 @@
#include <type.h>
#include <chain/chain.h>
/**
直接使用一个整型值初始化一个新的节点
@param m_int 整型值
@param if_sid 新的节点有无id
@return 返回指向新节点的指针
*/
CNode *nodeWithInt(int m_int, _Bool if_sid) {
CNode *p_node;
int *p_int = (int *)malloc(sizeof(int));
if(p_int == NULL){
return NULL;
}
*p_int = m_int;
p_node = initNode(if_sid);
initMallocValueForNode(p_node, INT, (void *)p_int);
return p_node;
}
/**
直接使用一个无符号整型值初始化一个新的节点
@param m_uint 无符号整型值
@param if_sid 新的节点有无id
@return 返回指向新节点的指针
*/
CNode *nodeWithUInt(uint32_t m_uint, _Bool if_sid){
CNode *p_node;
unsigned int *pu_int = (uint32_t *)malloc(sizeof(uint32_t));
if(pu_int == NULL){
return NULL;
}
*pu_int = m_uint;
p_node = initNode(if_sid);
initMallocValueForNode(p_node, UINT, (void *)pu_int);
return p_node;
}
/**
直接使用一个无符号长整型值（占用8个字节）初始化一个新的节点
@param m_ullint 无符号长整型值
@param if_sid 新的节点有无id
@return 返回指向新节点的指针
*/
CNode *nodeWithULLInt(uint64_t m_ullint, _Bool if_sid) {
CNode *p_node;
unsigned long long *p_ullint = (uint64_t *)malloc(sizeof(uint64_t));
if(p_ullint == NULL){
return NULL;
}
*p_ullint = m_ullint;
p_node = initNode(if_sid);
initMallocValueForNode(p_node, ULLINT, (void *)p_ullint);
return p_node;
}
/**
直接使用一个双精度浮点值初始化一个新的节点
@param m_double 双精度浮点值
@param if_sid 新的节点有无id
@return 返回指向新节点的指针
*/
CNode *nodeWithDouble(double m_double, _Bool if_sid) {
CNode *p_node;
double *p_double = (double *)malloc(sizeof(double));
if(p_double == NULL){
return NULL;
}
*p_double = m_double;
p_node = initNode(if_sid);
initMallocValueForNode(p_node, DOUBLE, (void *)p_double);
return p_node;
}
/**
直接使用一个字符串值初始化一个新的节点
@param m_string 字符串值
@param if_sid 新的节点有无id
@return 返回指向新节点的指针
*/
CNode *nodeWithString(const char *m_string, _Bool if_sid) {
CNode *p_node;
char *p_string = (char *)malloc(sizeof(char)*(strlen(m_string) + 1));
if(p_string == NULL){
return NULL;
}
strcpy(p_string, m_string);
p_node = initNode(if_sid);
initMallocValueForNode(p_node, STRING, (void *)p_string);
return p_node;
}
/**
直接使用一个指针值初始化一个新的节点
@param m_pointer 指针值
@param if_sid 新的节点有无id
@return 返回指向新节点的指针
*/
CNode *nodeWithPointer(const void *m_pointer, _Bool if_sid) {
CNode *p_node = initNode(if_sid);
initMallocValueForNode(p_node, POINTER, m_pointer);
return p_node;
}

179
src/datastruct/chain/chain_print.c Normal file
View File

@ -0,0 +1,179 @@
#include <type.h>
#include <chain/chain.h>
#include <chain/chain_print.h>
/**
打印链表及链表中节点的相关数据
@param p_list 指向目标链表的指针
@param priority 行缩进次数
*/
void printListInfo(Chain *p_list, int priority) {
int i = 0;
CNode *p_node;
for (i = 0; i < priority; i++) printf(" ");
printf("###LIST(location:%p",p_list);
// 如果可能使用到ID模块则编译以下代码
#ifdef id_enable
printf(",id:%s",s_idToASCIIString(p_list->s_id));
#endif
printf("){\n");
for (i = 0; i < priority + 1; i++) printf(" ");
printf("HEAD->%p / Tail->%p / Length:%llu\n", p_list->head, p_list->tail, p_list->length);
p_node = p_list->head;
while (p_node != NULL) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("%d.... \n", i);
printNodeInfo(p_node, priority + 1);
p_node = p_node->next;
i++;
}
for (i = 0; i < priority; i++) printf(" ");
printf("}\n");
}
/**
打印链表及其节点写详细信息
@param p_list 指向目标链表的指针
*/
void printList(Chain *p_list) {
int if_nearLast = 0;
CNode *p_node = p_list->head;
printf("[");
while (p_node != NULL) {
if (!if_nearLast && p_node->next == NULL) if_nearLast = 1;
if (p_node->type == INT) {
printf("%d", *(int *)(p_node->value));
}
else if (p_node->type == DOUBLE) {
printf("%a", *(double *)(p_node->value));
}
else if (p_node->type == STRING) {
printf("%s", (char *)(p_node->value));
}
else if (p_node->type == POINTER) {
printf("%p", (char *)(p_node->value));
}
else if (p_node->type == LIST) {
printList((Chain *)p_node->value);
}
if (!if_nearLast) {
printf(", ");
}
p_node = p_node->next;
}
printf("]");
}
/**
打印节点的信息
@param p_node 指向目标节点的指针
@param priority 行缩进次数
*/
void printNodeInfo(CNode *p_node, int priority) {
int i;
for (i = 0; i < priority; i++) printf(" ");
printf("#NODE(location:%p",p_node);
#ifdef id_enable
printf(", id:%s", s_idToASCIIString(p_node->s_id));
#endif
printf("){\n");
for (i = 0; i < priority + 1; i++) printf(" ");
printf("NEXT->%p / LAST->%p\n", p_node->next, p_node->last);
if (p_node->type == INT) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("VALUE(int):%d\n", *(int *)(p_node->value));
}
else if (p_node->type == DOUBLE) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("VALUE(double):%a\n", *(double *)(p_node->value));
}
else if (p_node->type == STRING) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("VALUE(string):%s\n", (char *)(p_node->value));
}
else if (p_node->type == POINTER) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("VALUE(pointer):%s\n", (char *)(p_node->value));
}
else if (p_node->type == LIST) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("VALUE(Chain):\n");
printListInfo((Chain *)p_node->value, priority + 2);
}
for (i = 0; i < priority; i++) printf(" ");
printf("}\n");
}
/**
打印节点的详细信息
@param p_node 指向目标节点的指针
*/
void printNode(CNode *p_node) {
int i;
printf("#NODE(location:%p",p_node);
#ifdef id_enable
printf(", id:%s",s_idToASCIIString(p_node->s_id));
#endif
printf("){\n");
printf(" ");
printf("NEXT->%p / LAST->%p\n", p_node->next, p_node->last);
for (i = 0; i < 1; i++) printf(" ");
printf("ifMalloc: ");
if (p_node->value != NULL) {
printf("YES\n");
for (i = 0; i < 1; i++) printf(" ");
printf("Value(type: %d): ", p_node->type);
if (p_node->type == INT) {
printf("%d", *(int *)(p_node->value));
}
else if (p_node->type == DOUBLE) {
printf("%a\n", *(double *)(p_node->value));
}
else if (p_node->type == STRING) {
printf("%s\n", (char *)(p_node->value));
}
else if (p_node->type == POINTER) {
printf("%p\n", (char *)(p_node->value));
}
else if (p_node->type == LIST) {
printList((Chain *)p_node->value);
}
}
else printf("NO\n");
printf("}\n");
}
/**
遍历链表并自定义打印节点信息
@param p_list 指向目标链表的指针
@param func 指向自定义打印函数的指针，函数接受指向目标节点的指针
*/
void printListForCustom(Chain *p_list,void (*func)(void *value)){
printf("###LIST (LEN:%llu ",p_list->length);
#ifdef id_enable
if(p_list->s_id != NULL) printf("SID:%s",p_list->s_id->decrypt_str);
#endif
printf(")\n");
listThrough(p_list, __CALLBACK_CALL(printListForCustom), __SEND_ARG("%p", func));
}
__CALLBACK_DEFINE(printListForCustom){
void (*func)(void *) = __ARGS_P(0, void);
printf("NODE (IDX:%llu ",__NOW_INDEX);
printf(")\n");
func(__VALUE(void *));
printf("\n");
return __CRETURN__;
}

61
src/datastruct/chain/chain_sort.c Normal file
View File

@ -0,0 +1,61 @@
#include <type.h>
#include <chain/chain.h>
/*
*内部函数: 通过节点中的值查找相关多个节点.
*参数: type指明相关值的类型;value为指向储存相关值的内存的指针.
*返回: 如果成功返回0,如果失败则返回-1.*/
static int sortList(Chain *p_list, uint64_t begin, uint64_t end, int(*func)(CNode *f_node, CNode *s_node));
/**
链表排序函数，该函数不直接对用户开放。采用快速排序的算法。
@param p_list 指向需要操作的链表的指针
@param begin 开始的节点的序号
@param end 结束的节点的序号
@param func 指向判断条件的函数的函数指针，接受两个指向相关节点的指针，比较他们的大小并返回正负值。
@return 成功进行操作则返回0
*/
static int sortList(Chain *p_list, uint64_t begin, uint64_t end, int(*func)(CNode *f_node, CNode *s_node)){
unsigned long long target_index = begin;
register CNode *t_node = findByIndexForNode(p_list, target_index);
register CNode *i_node = NULL, *j_node = NULL;
register unsigned long long i = end,j = begin;
for(; i >= begin; i--){
if(i <= j) break;
i_node = findByIndexForNode(p_list, i);
if(func(t_node, i_node) < 0){
exchangeNode(p_list, t_node, i_node);
for(; j <= end; j++){
if(j >= i) break;
j_node = findByIndexForNode(p_list, j);
if(func(t_node, j_node) > 0){
exchangeNode(p_list, t_node, j_node);
break;
}
}
}
}
if(end - begin > 3){
if(getIndexForNode(p_list, t_node) - begin > 2)
sortList(p_list, begin, getIndexForNode(p_list, t_node), func);
if(end - getIndexForNode(p_list, t_node) > 2)
sortList(p_list, getIndexForNode(p_list, t_node), end, func);
}
return 0;
}
/**
向用户开放的链表排序函数
@param p_list 指向需要操作的链表
@param func 指向判断条件的函数的函数指针，接受两个指向相关节点的指针，比较他们的大小并返回正负值。
@return 成功进行操作则返回0
*/
int sortListForCustom(Chain *p_list, int(*func)(CNode *f_node, CNode *s_node)){
sortList(p_list, 0, p_list->length-1, func);
return 0;
}

92
src/datastruct/chain/chain_update.c Normal file
View File

@ -0,0 +1,92 @@
#include <type.h>
#include <chain/chain.h>
/**
用一个整型值更新一个现有节点的值
@param p_node 指向目标节点的指针
@param value 整型值
@return 操作成功则返回0
*/
int updateValueWithIntForNode(CNode *p_node,int value){
int *p_value = (int *)malloc(sizeof(int));
if(p_value == NULL){
return -1;
}
*p_value = value;
free(p_node->value);
p_node->value = p_value;
return 0;
}
/**
用一个无符号长整型（8个字节）更新一个现有节点的值
@param p_node 指向目标节点的指针
@param value 无符号长整型值
@return 操作成功则返回0
*/
int updateValueWithULLIntForNode(CNode *p_node, uint64_t value){
uint64_t *p_value = (uint64_t *)malloc(sizeof(uint64_t));
if(p_value == NULL){
return -1;
}
*p_value = value;
free(p_node->value);
p_node->value = p_value;
return 0;
}
/**
用一个双精度浮点值更新一个现有节点的值
@param p_node 指向目标节点的指针
@param value 双精度浮点值
@return 操作成功则返回0
*/
int updateValueWithDoubleForNode(CNode *p_node, double value){
double *p_value = (double *)malloc(sizeof(double));
if(p_value == NULL){
return -1;
}
*p_value = value;
free(p_node->value);
p_node->value = p_value;
return 0;
}
/**
用一个字符串值更新一个现有节点的值
@param p_node 指向目标节点的指针
@param string 字符串值
@return 操作成功则返回0
*/
int updateValueWithStringForNode(CNode *p_node, char *string){
char *p_value = (char *)malloc(sizeof(strlen(string)) + 1);
if(p_value == NULL){
return -1;
}
strcpy(p_value, string);
free(p_node->value);
p_node->value = p_value;
return 0;
}
/**
用一个指针值更新一个现有节点的值
@param p_node 指向目标节点的指针
@param pointer 指针值
@return 操作成功则返回0
*/
int updateValueWithPointerForNode(CNode *p_node, void *pointer){
free(p_node->value);
p_node->value = pointer;
return 0;
}

0
graph/graph.c → src/datastruct/graph/graph.c
View File

0
graph/graph.h → src/datastruct/graph/graph.h
View File

892
tree/tree.c → src/datastruct/tree/tree.c
View File

@ -1,497 +1,497 @@
#include"tree.h"
static int if_safeModeForTree = 0;
int safeModeForTree(int ifon) {
if (ifon == 1) {
if (tnode_list == NULL && tree_list == NULL) {
#include"tree.h"
static int if_safeModeForTree = 0;
int safeModeForTree(int ifon) {
if (ifon == 1) {
if (tnode_list == NULL && tree_list == NULL) {
tnode_list = (List *)malloc(sizeof(List));
if(tnode_list == NULL){
showError(pushError(TREE_NODE, HIGH, initInfo("safeModeForTree()", "Error in get the memory of tnode_list.")));
return -1;
}
tree_list = (List *)malloc(sizeof(List));
}
tree_list = (List *)malloc(sizeof(List));
if(tree_list == NULL){
showError(pushError(TREE_NODE, HIGH, initInfo("safeModeForTree()", "Error in get the memory of tree_list.")));
return -1;
}
tree_list->head = NULL;
tree_list->length = 0;
tree_list->tail = NULL;
tnode_list->head = NULL;
tnode_list->length = 0;
tnode_list->tail = NULL;
if_safeModeForTree = 1;
}
else {
return -1;
}
}
return ifon;
}
TNode *initTNode(void) {
Node *s_node;
}
tree_list->head = NULL;
tree_list->length = 0;
tree_list->tail = NULL;
tnode_list->head = NULL;
tnode_list->length = 0;
tnode_list->tail = NULL;
if_safeModeForTree = 1;
}
else {
return -1;
}
}
return ifon;
}
TNode *initTNode(void) {
Node *s_node;
TNode *p_tnode = (TNode *)malloc(sizeof(TNode));
if(p_tnode == NULL){
showError(pushError(TREE_NODE, STANDARD, initInfo("initTNode()", "Error in getting the memory of tnode.")));
return NULL;
}
p_tnode->s_id = getS_id(TREE_NODE, 1);
p_tnode->if_sid = 1;
p_tnode->child_num = 0;
p_tnode->father = NULL;
p_tnode->if_malloc = 0;
p_tnode->value = NULL;
p_tnode->type = VOID;
p_tnode->home = initList();
p_tnode->room = NULL;
if (if_safeModeForTree) {
if (if_safeModeForNode) {
if_safeModeForNode = 0;
s_node = initNode();
initMallocValueForNode(s_node, POINTER, (void *)p_tnode);
insertInTail(tnode_list, s_node);
if_safeModeForNode = 1;
}
else
{
s_node = initNode();
initMallocValueForNode(s_node, POINTER, (void *)p_tnode);
insertInTail(tnode_list, s_node);
}
}
return p_tnode;
}
Tree *initTree(void) {
Node *s_node;
p_tnode->if_sid = 1;
p_tnode->child_num = 0;
p_tnode->father = NULL;
p_tnode->if_malloc = 0;
p_tnode->value = NULL;
p_tnode->type = VOID;
p_tnode->home = initList();
p_tnode->room = NULL;
if (if_safeModeForTree) {
if (if_safeModeForNode) {
if_safeModeForNode = 0;
s_node = initNode();
initMallocValueForNode(s_node, POINTER, (void *)p_tnode);
insertInTail(tnode_list, s_node);
if_safeModeForNode = 1;
}
else
{
s_node = initNode();
initMallocValueForNode(s_node, POINTER, (void *)p_tnode);
insertInTail(tnode_list, s_node);
}
}
return p_tnode;
}
Tree *initTree(void) {
Node *s_node;
Tree *p_tree = (Tree *)malloc(sizeof(Tree));
if(p_tree == NULL){
showError(pushError(TREE, STANDARD, initInfo("initTree()", "Error in getting the memory of tree.")));
return NULL;
}
p_tree->s_id = getS_id(TREE, 1);
p_tree->if_sid = 1;
p_tree->root = NULL;
if (if_safeModeForTree) {
if (if_safeModeForNode) {
if_safeModeForNode = 0;
s_node = initNode();
initMallocValueForNode(s_node, POINTER, (void *)p_tree);
if_safeModeForNode = 1;
insertInTail(tree_list, s_node);
}
else
{
s_node = initNode();
initMallocValueForNode(s_node, POINTER, (void *)p_tree);
insertInTail(tree_list, s_node);
}
}
return p_tree;
}
int *initMallocValueForTNode(TNode *p_tnode, unsigned int type, void *value) {
p_tnode->type = type;
p_tnode->value = value;
p_tnode->if_malloc = 1;
return 0;
}
int addChildInLeft(TNode *f_tnode, TNode *c_tnode) {
Node *p_node = initNode();
initMallocValueForNode(p_node, POINTER, c_tnode);
insertInHead(f_tnode->home, p_node);
c_tnode->father = f_tnode;
c_tnode->room = p_node;
f_tnode->child_num++;
return 0;
}
int addChildInRight(TNode *f_tnode, TNode *c_tnode) {
Node *p_node = initNode();
initMallocValueForNode(p_node, POINTER, c_tnode);
insertInTail(f_tnode->home, p_node);
c_tnode->father = f_tnode;
c_tnode->room = p_node;
f_tnode->child_num++;
return 0;
}
TNode *getBrotherInLeft(TNode *p_tnode) {
List *p_home = p_tnode->father->home;
Node *p_node = p_tnode->room;
unsigned long long index = getIndexByNode(p_home, p_node);
if (index > 0) return (TNode *)(findByIndexForNode(p_home, index - 1)->value);
return NULL;
}
TNode *getBrotherInRight(TNode *p_tnode) {
List *p_home = p_tnode->father->home;
Node *p_node = p_home->head;
unsigned long long index = getIndexByNode(p_home, p_node);
if (index < p_home->length - 1) return (TNode *)(findByIndexForNode(p_home, index + 1)->value);
return NULL;
}
int removeChildInLeft(TNode *p_tnode) {
TNode *c_tnode = (TNode *)p_tnode->home->head->value;
c_tnode->father = NULL;
releaseOnlyNode(c_tnode->room);
c_tnode->room = NULL;
p_tnode->child_num--;
popFromHead(p_tnode->home);
return 0;
}
int removeChildInRight(TNode *p_tnode) {
TNode *c_tnode = (TNode *)p_tnode->home->tail->value;
c_tnode->father = NULL;
releaseOnlyNode(c_tnode->room);
c_tnode->room = NULL;
p_tnode->child_num--;
popFromTail(p_tnode->home);
return 0;
}
TNode *getChildById(TNode *p_tnode, const SID *s_id) {
List *p_home = p_tnode->home;
p_tree->if_sid = 1;
p_tree->root = NULL;
if (if_safeModeForTree) {
if (if_safeModeForNode) {
if_safeModeForNode = 0;
s_node = initNode();
initMallocValueForNode(s_node, POINTER, (void *)p_tree);
if_safeModeForNode = 1;
insertInTail(tree_list, s_node);
}
else
{
s_node = initNode();
initMallocValueForNode(s_node, POINTER, (void *)p_tree);
insertInTail(tree_list, s_node);
}
}
return p_tree;
}
int *initMallocValueForTNode(TNode *p_tnode, unsigned int type, void *value) {
p_tnode->type = type;
p_tnode->value = value;
p_tnode->if_malloc = 1;
return 0;
}
int addChildInLeft(TNode *f_tnode, TNode *c_tnode) {
Node *p_node = initNode();
initMallocValueForNode(p_node, POINTER, c_tnode);
insertInHead(f_tnode->home, p_node);
c_tnode->father = f_tnode;
c_tnode->room = p_node;
f_tnode->child_num++;
return 0;
}
int addChildInRight(TNode *f_tnode, TNode *c_tnode) {
Node *p_node = initNode();
initMallocValueForNode(p_node, POINTER, c_tnode);
insertInTail(f_tnode->home, p_node);
c_tnode->father = f_tnode;
c_tnode->room = p_node;
f_tnode->child_num++;
return 0;
}
TNode *getBrotherInLeft(TNode *p_tnode) {
List *p_home = p_tnode->father->home;
Node *p_node = p_tnode->room;
unsigned long long index = getIndexByNode(p_home, p_node);
if (index > 0) return (TNode *)(findByIndexForNode(p_home, index - 1)->value);
return NULL;
}
TNode *getBrotherInRight(TNode *p_tnode) {
List *p_home = p_tnode->father->home;
Node *p_node = p_home->head;
unsigned long long index = getIndexByNode(p_home, p_node);
if (index < p_home->length - 1) return (TNode *)(findByIndexForNode(p_home, index + 1)->value);
return NULL;
}
int removeChildInLeft(TNode *p_tnode) {
TNode *c_tnode = (TNode *)p_tnode->home->head->value;
c_tnode->father = NULL;
releaseOnlyNode(c_tnode->room);
c_tnode->room = NULL;
p_tnode->child_num--;
popFromHead(p_tnode->home);
return 0;
}
int removeChildInRight(TNode *p_tnode) {
TNode *c_tnode = (TNode *)p_tnode->home->tail->value;
c_tnode->father = NULL;
releaseOnlyNode(c_tnode->room);
c_tnode->room = NULL;
p_tnode->child_num--;
popFromTail(p_tnode->home);
return 0;
}
TNode *getChildById(TNode *p_tnode, const SID *s_id) {
List *p_home = p_tnode->home;
target_value_sid = NULL;
List *er_list = initList();
insertInTail(er_list, nodeWithPointer(s_id));
insertInTail(er_list, nodeWithPointer(s_id));
List *rtnc_list = listThrough(p_home, _dogetChildById, er_list);
free(er_list);
Node *p_node= findByIndexForNode(rtnc_list, 1);
Node *p_node= findByIndexForNode(rtnc_list, 1);
if (p_node != NULL) {
TNode *p_tnode = getByPointerForNode(p_node);
free(rtnc_list);
return p_tnode;
}
return NULL;
}
free(rtnc_list);
return p_tnode;
}
return NULL;
}
List *_dogetChildById(unsigned int type, void *value, List *er_list) {
SID *target_sid = getByPointerForNode(findByIndexForNode(er_list, 0));
List *rtn_list = initList();
if (type == POINTER) {
TNode *p_tode = (TNode *)value;
if (simFitS_id(p_tode->s_id, target_sid)) {
List *rtn_list = initList();
if (type == POINTER) {
TNode *p_tode = (TNode *)value;
if (simFitS_id(p_tode->s_id, target_sid)) {
target_value_sid = p_tode;
insertInTail(rtn_list, nodeWithInt(-1));
insertInTail(rtn_list, nodeWithPointer(target_value_sid));
return rtn_list;
}
insertInTail(rtn_list, nodeWithPointer(target_value_sid));
return rtn_list;
}
}
insertInTail(rtn_list, nodeWithInt(0));
return rtn_list;
}
TNode *getChildByValue(TNode *p_tnode, unsigned int type, void *value) {
List *p_home = p_tnode->home;
target_value = value;
target_type = type;
insertInTail(rtn_list, nodeWithInt(0));
return rtn_list;
}
TNode *getChildByValue(TNode *p_tnode, unsigned int type, void *value) {
List *p_home = p_tnode->home;
target_value = value;
target_type = type;
target_value_value = NULL;
List *er_list = initList();
insertInTail(er_list, nodeWithUInt(type));
insertInTail(er_list, nodeWithPointer(value));
List *rtnc_list = listThrough(p_home, _dogetChildByValue,er_list);
free(er_list);
Node *p_node = NULL;
Node *p_node = NULL;
if ((p_node = findByIndexForNode(rtnc_list, 1)) != NULL) {
TNode *p_tnode = getByPointerForNode(p_node);
free(rtnc_list);
return p_tnode;
}
return NULL;
}
free(rtnc_list);
return p_tnode;
}
return NULL;
}
List *_dogetChildByValue(unsigned int type, void *value, List *er_list) {
List *rtn_list = initList();
unsigned int target_type = getByUIntForNode(findByIndexForNode(rtn_list, 0));
void *target_value = getByPointerForNode(findByIndexForNode(rtn_list, 1));
if (type == target_type) {
TNode *p_tode = (TNode *)value;
if (target_type == INT) {
if (*(int *)p_tode->value == *(int *)target_value)
void *target_value = getByPointerForNode(findByIndexForNode(rtn_list, 1));
if (type == target_type) {
TNode *p_tode = (TNode *)value;
if (target_type == INT) {
if (*(int *)p_tode->value == *(int *)target_value)
{
insertInTail(rtn_list, nodeWithInt(-1));
insertInTail(rtn_list, nodeWithPointer(p_tode));
return rtn_list;
}
}
else if (target_type == DOUBLE)
{
if (*(double *)p_tode->value == *(double *)target_value)
insertInTail(rtn_list, nodeWithPointer(p_tode));
return rtn_list;
}
}
else if (target_type == DOUBLE)
{
if (*(double *)p_tode->value == *(double *)target_value)
{
insertInTail(rtn_list, nodeWithInt(-1));
insertInTail(rtn_list, nodeWithPointer(p_tode));
return rtn_list;
}
}
else if (target_type == STRING)
{
if (!strcmp((char *)p_tode->value, (char *)target_value))
insertInTail(rtn_list, nodeWithPointer(p_tode));
return rtn_list;
}
}
else if (target_type == STRING)
{
if (!strcmp((char *)p_tode->value, (char *)target_value))
{
insertInTail(rtn_list, nodeWithInt(-1));
insertInTail(rtn_list, nodeWithPointer(p_tode));
return rtn_list;
}
}
else if (target_type == POINTER)
{
if (p_tode->value == target_value)
insertInTail(rtn_list, nodeWithPointer(p_tode));
return rtn_list;
}
}
else if (target_type == POINTER)
{
if (p_tode->value == target_value)
{
insertInTail(rtn_list, nodeWithInt(-1));
insertInTail(rtn_list, nodeWithPointer(p_tode));
return rtn_list;
}
}
insertInTail(rtn_list, nodeWithPointer(p_tode));
return rtn_list;
}
}
}
insertInTail(rtn_list, nodeWithInt(0));
return rtn_list;
}
int removeChildById(TNode *p_tnode, const SID *s_id) {
TNode *t_tnode = getChildById(p_tnode, s_id);
if (t_tnode != NULL) {
TNode *p_fnode = t_tnode->father;
p_fnode->child_num--;
removeById(p_fnode->home, t_tnode->room->s_id);
releaseOnlyNode(t_tnode->room);
t_tnode->room = NULL;
return 0;
}
return -1;
}
int removeChildByValue(TNode *p_tnode, unsigned int type, void *value) {
TNode *t_tnode = getChildByValue(p_tnode, type, value);
if (t_tnode != NULL) {
TNode *p_fnode = t_tnode->father;
p_fnode->child_num--;
removeById(p_fnode->home, t_tnode->room->s_id);
releaseOnlyNode(t_tnode->room);
t_tnode->room = NULL;
return 0;
}
return -1;
}
TNode *getChildByIndex(TNode *p_tnode, unsigned long long index) {
List *p_home = p_tnode->home;
Node *p_node = p_home->head;
int m_index = 0;
if (index < p_tnode->child_num)
{
while (p_node != NULL && m_index < index) {
m_index++;
p_node = p_node->next;
}
return (TNode *)p_node->value;
}
return NULL;
}
unsigned long long getIndexByChild(TNode *f_tnode, TNode *c_tnode) {
List *p_home = f_tnode->home;
Node *p_node = p_home->head;
int m_index = 0;
while (p_node != NULL) {
TNode *p_tnode = (TNode *)p_node->value;
if (p_tnode->s_id == c_tnode->s_id) {
return m_index;
}
m_index++;
p_node = p_node->next;
}
return -1;
}
int removeChildByIndex(TNode *p_tnode, unsigned long long index) {
TNode *t_tnode = getChildByIndex(p_tnode, index);
if (t_tnode != NULL) {
TNode *p_fnode = t_tnode->father;
p_fnode->child_num--;
removeById(p_fnode->home, t_tnode->room->s_id);
releaseOnlyNode(t_tnode->room);
t_tnode->room = NULL;
return 0;
}
return -1;
}
int TreeThroughUp(Tree *p_tree, int(*func)(TNode *, unsigned long long height)) {
int i;
TNode *p_tnode = p_tree->root;
if (p_tnode != NULL) {
if (p_tnode->child_num > 0) {
for (i = 0; i < p_tnode->child_num; i++) {
if (_doTreeThroughUp(getChildByIndex(p_tnode, i), 1, func) == -1) {
break;
}
}
}
func(p_tnode, 0);
}
return 0;
}
int _doTreeThroughUp(TNode *p_tnode, int height, int(*func)(TNode *, unsigned long long height)) {
int i, func_back;
if (p_tnode->child_num > 0) {
for (i = 0; i < p_tnode->child_num; i++) {
if (_doTreeThroughUp(getChildByIndex(p_tnode, i), height + 1, func)) return -1;
}
}
func_back = func(p_tnode, height);
if (func_back == -1)return -1;
return 0;
}
int TreeThroughDown(Tree *p_tree, int(*func)(TNode *, unsigned long long height)) {
int i;
TNode *p_tnode = p_tree->root;
if (p_tree->root != NULL) {
func(p_tnode, 0);
if (p_tree->root->child_num > 0) {
for (i = 0; i < p_tnode->child_num; i++) {
if (_doTreeThroughDown(getChildByIndex(p_tnode, i), 1, func) == -1) {
break;
}
}
}
}
return 0;
}
int _doTreeThroughDown(TNode *p_tnode, int height, int(*func)(TNode *, unsigned long long height)) {
int i;
int func_back = func(p_tnode, height);
if (p_tnode->child_num > 0) {
for (i = 0; i < p_tnode->child_num; i++) {
if (_doTreeThroughDown(getChildByIndex(p_tnode, i), height + 1, func)) return -1;
}
}
if (func_back == -1)return -1;
return 0;
}
int TreeTravel(Tree *p_tree, int(*func)(TNode *, unsigned long long height)) {
TNode *p_tnode = p_tree->root;
unsigned long long height = 0;
if (p_tnode != NULL) {
int func_back = func(p_tnode, height);
while (func_back > -2) {
if (func_back > -1) {
p_tnode = getChildByIndex(p_tnode, func_back);
func(p_tnode, height + 1);
}
else
{
p_tnode = p_tnode->father;
func(p_tnode, height - 1);
}
}
}
return 0;
}
int releaseTNode(TNode *p_tnode) {
if (p_tnode->child_num == 0) {
releaseList(p_tnode->home);
if (p_tnode->father != NULL) {
removeChildById(p_tnode->father, p_tnode->s_id);
}
if (p_tnode->type != POINTER) {
if (p_tnode->type == LIST) {
releaseList((List *)p_tnode->value);
}
else {
free(p_tnode->value);
}
}
p_tnode->value = NULL;
p_tnode->type = VOID;
freeS_id(p_tnode->s_id);
p_tnode->if_malloc = 0;
free(p_tnode);
}
return 0;
}
int releaseTree(Tree *p_tree) {
TreeThroughUp(p_tree, _doreleaseTree);
p_tree->root = NULL;
freeS_id(p_tree->s_id);
free(p_tree);
return 0;
}
int _doreleaseTree(TNode *p_tnode, unsigned long long height) {
releaseTNode(p_tnode);
return 0;
}
int releaseOnlyTree(Tree *p_tree) {
freeS_id(p_tree->s_id);
p_tree->root = NULL;
free(p_tree);
return 0;
}
int releaseOnlyTNode(TNode *p_tnode) {
releaseList(p_tnode->home);
if (p_tnode->if_malloc) {
if (p_tnode->type != STRING) {
if (p_tnode->type == LIST) {
releaseList((List *)p_tnode->value);
}
else {
free(p_tnode->value);
}
}
}
p_tnode->value = NULL;
p_tnode->type = VOID;
freeS_id(p_tnode->s_id);
p_tnode->if_malloc = 0;
free(p_tnode);
return 0;
}
int releaseAllForTree(void) {
Node *p_node;
Tree *p_tree;
if (if_safeModeForTree) {
if_safeModeForTree = 0;
p_node = tnode_list->head;
while (p_node != NULL) {
TNode *p_tnode = (TNode *)p_node->value;
releaseOnlyTNode(p_tnode);
p_node = p_node->next;
}
p_node = tree_list->head;
while (p_node != NULL) {
p_tree = (Tree *)p_node->value;
releaseOnlyTree(p_tree);
p_node = p_node->next;
}
releaseList(tnode_list);
releaseList(tree_list);
}
return 0;
}
int setRoot(Tree *p_tree, TNode *p_tnode) {
p_tree->root = p_tnode;
return 0;
insertInTail(rtn_list, nodeWithInt(0));
return rtn_list;
}
int removeChildById(TNode *p_tnode, const SID *s_id) {
TNode *t_tnode = getChildById(p_tnode, s_id);
if (t_tnode != NULL) {
TNode *p_fnode = t_tnode->father;
p_fnode->child_num--;
removeById(p_fnode->home, t_tnode->room->s_id);
releaseOnlyNode(t_tnode->room);
t_tnode->room = NULL;
return 0;
}
return -1;
}
int removeChildByValue(TNode *p_tnode, unsigned int type, void *value) {
TNode *t_tnode = getChildByValue(p_tnode, type, value);
if (t_tnode != NULL) {
TNode *p_fnode = t_tnode->father;
p_fnode->child_num--;
removeById(p_fnode->home, t_tnode->room->s_id);
releaseOnlyNode(t_tnode->room);
t_tnode->room = NULL;
return 0;
}
return -1;
}
TNode *getChildByIndex(TNode *p_tnode, unsigned long long index) {
List *p_home = p_tnode->home;
Node *p_node = p_home->head;
int m_index = 0;
if (index < p_tnode->child_num)
{
while (p_node != NULL && m_index < index) {
m_index++;
p_node = p_node->next;
}
return (TNode *)p_node->value;
}
return NULL;
}
unsigned long long getIndexByChild(TNode *f_tnode, TNode *c_tnode) {
List *p_home = f_tnode->home;
Node *p_node = p_home->head;
int m_index = 0;
while (p_node != NULL) {
TNode *p_tnode = (TNode *)p_node->value;
if (p_tnode->s_id == c_tnode->s_id) {
return m_index;
}
m_index++;
p_node = p_node->next;
}
return -1;
}
int removeChildByIndex(TNode *p_tnode, unsigned long long index) {
TNode *t_tnode = getChildByIndex(p_tnode, index);
if (t_tnode != NULL) {
TNode *p_fnode = t_tnode->father;
p_fnode->child_num--;
removeById(p_fnode->home, t_tnode->room->s_id);
releaseOnlyNode(t_tnode->room);
t_tnode->room = NULL;
return 0;
}
return -1;
}
int TreeThroughUp(Tree *p_tree, int(*func)(TNode *, unsigned long long height)) {
int i;
TNode *p_tnode = p_tree->root;
if (p_tnode != NULL) {
if (p_tnode->child_num > 0) {
for (i = 0; i < p_tnode->child_num; i++) {
if (_doTreeThroughUp(getChildByIndex(p_tnode, i), 1, func) == -1) {
break;
}
}
}
func(p_tnode, 0);
}
return 0;
}
int _doTreeThroughUp(TNode *p_tnode, int height, int(*func)(TNode *, unsigned long long height)) {
int i, func_back;
if (p_tnode->child_num > 0) {
for (i = 0; i < p_tnode->child_num; i++) {
if (_doTreeThroughUp(getChildByIndex(p_tnode, i), height + 1, func)) return -1;
}
}
func_back = func(p_tnode, height);
if (func_back == -1)return -1;
return 0;
}
int TreeThroughDown(Tree *p_tree, int(*func)(TNode *, unsigned long long height)) {
int i;
TNode *p_tnode = p_tree->root;
if (p_tree->root != NULL) {
func(p_tnode, 0);
if (p_tree->root->child_num > 0) {
for (i = 0; i < p_tnode->child_num; i++) {
if (_doTreeThroughDown(getChildByIndex(p_tnode, i), 1, func) == -1) {
break;
}
}
}
}
return 0;
}
int _doTreeThroughDown(TNode *p_tnode, int height, int(*func)(TNode *, unsigned long long height)) {
int i;
int func_back = func(p_tnode, height);
if (p_tnode->child_num > 0) {
for (i = 0; i < p_tnode->child_num; i++) {
if (_doTreeThroughDown(getChildByIndex(p_tnode, i), height + 1, func)) return -1;
}
}
if (func_back == -1)return -1;
return 0;
}
int TreeTravel(Tree *p_tree, int(*func)(TNode *, unsigned long long height)) {
TNode *p_tnode = p_tree->root;
unsigned long long height = 0;
if (p_tnode != NULL) {
int func_back = func(p_tnode, height);
while (func_back > -2) {
if (func_back > -1) {
p_tnode = getChildByIndex(p_tnode, func_back);
func(p_tnode, height + 1);
}
else
{
p_tnode = p_tnode->father;
func(p_tnode, height - 1);
}
}
}
return 0;
}
int releaseTNode(TNode *p_tnode) {
if (p_tnode->child_num == 0) {
releaseList(p_tnode->home);
if (p_tnode->father != NULL) {
removeChildById(p_tnode->father, p_tnode->s_id);
}
if (p_tnode->type != POINTER) {
if (p_tnode->type == LIST) {
releaseList((List *)p_tnode->value);
}
else {
free(p_tnode->value);
}
}
p_tnode->value = NULL;
p_tnode->type = VOID;
freeS_id(p_tnode->s_id);
p_tnode->if_malloc = 0;
free(p_tnode);
}
return 0;
}
int releaseTree(Tree *p_tree) {
TreeThroughUp(p_tree, _doreleaseTree);
p_tree->root = NULL;
freeS_id(p_tree->s_id);
free(p_tree);
return 0;
}
int _doreleaseTree(TNode *p_tnode, unsigned long long height) {
releaseTNode(p_tnode);
return 0;
}
int releaseOnlyTree(Tree *p_tree) {
freeS_id(p_tree->s_id);
p_tree->root = NULL;
free(p_tree);
return 0;
}
int releaseOnlyTNode(TNode *p_tnode) {
releaseList(p_tnode->home);
if (p_tnode->if_malloc) {
if (p_tnode->type != STRING) {
if (p_tnode->type == LIST) {
releaseList((List *)p_tnode->value);
}
else {
free(p_tnode->value);
}
}
}
p_tnode->value = NULL;
p_tnode->type = VOID;
freeS_id(p_tnode->s_id);
p_tnode->if_malloc = 0;
free(p_tnode);
return 0;
}
int releaseAllForTree(void) {
Node *p_node;
Tree *p_tree;
if (if_safeModeForTree) {
if_safeModeForTree = 0;
p_node = tnode_list->head;
while (p_node != NULL) {
TNode *p_tnode = (TNode *)p_node->value;
releaseOnlyTNode(p_tnode);
p_node = p_node->next;
}
p_node = tree_list->head;
while (p_node != NULL) {
p_tree = (Tree *)p_node->value;
releaseOnlyTree(p_tree);
p_node = p_node->next;
}
releaseList(tnode_list);
releaseList(tree_list);
}
return 0;
}
int setRoot(Tree *p_tree, TNode *p_tnode) {
p_tree->root = p_tnode;
return 0;
}

428
tree/tree_expand.c → src/datastruct/tree/tree_expand.c
View File

@ -1,231 +1,231 @@
#include "tree_expand.h"
TNode *tnodeWithInt(int temp) {
TNode *p_tnode = initTNode();
#include "tree_expand.h"
TNode *tnodeWithInt(int temp) {
TNode *p_tnode = initTNode();
int *p_temp = (int *)malloc(sizeof(int));
if(p_temp == NULL){
showError(pushError(INT, STANDARD, initInfo("tnodeWithInt()", "Error in getting the memory of int.")));
return NULL;
}
*p_temp = temp;
initMallocValueForTNode(p_tnode, INT, p_temp);
return p_tnode;
}
TNode *tnodeWithDouble(double temp) {
TNode *p_tnode = initTNode();
}
*p_temp = temp;
initMallocValueForTNode(p_tnode, INT, p_temp);
return p_tnode;
}
TNode *tnodeWithDouble(double temp) {
TNode *p_tnode = initTNode();
double *p_temp = (double *)malloc(sizeof(double));
if(p_temp == NULL){
showError(pushError(DOUBLE, STANDARD, initInfo("tnodeWithDouble()", "Error in getting the memory of double.")));
return NULL;
}
*p_temp = temp;
initMallocValueForTNode(p_tnode, DOUBLE, p_temp);
return p_tnode;
}
TNode *tnodeWithString(char *temp) {
TNode *p_tnode = initTNode();
}
*p_temp = temp;
initMallocValueForTNode(p_tnode, DOUBLE, p_temp);
return p_tnode;
}
TNode *tnodeWithString(char *temp) {
TNode *p_tnode = initTNode();
char *p_temp = (char *)malloc(sizeof(temp));
if(p_temp == NULL){
showError(pushError(STRING, STANDARD, initInfo("tnodeWithString()", "Error in getting the memory of string.")));
return NULL;
}
strcpy(p_temp, temp);
initMallocValueForTNode(p_tnode, STRING, p_temp);
return p_tnode;
}
TNode *tnodeWithPointer(void *temp) {
TNode *p_tnode = initTNode();
initMallocValueForTNode(p_tnode, POINTER, temp);
return p_tnode;
}
int getValueByIntForTree(TNode *p_tnode) {
if (p_tnode->type == INT) {
return *(int *)p_tnode->value;
}
return -1;
}
double getValueByDoubleForTree(TNode *p_tnode) {
if (p_tnode->type == DOUBLE) {
return *(double *)p_tnode->value;
}
return -1;
}
char *getValueByStringForTree(TNode *p_tnode) {
if (p_tnode->type == STRING) {
return (char *)p_tnode->value;
}
return NULL;
}
void *getValueByPointerForTree(TNode *p_tnode) {
if (p_tnode->type == POINTER) {
return p_tnode->value;
}
return NULL;
}
int printTNode(TNode *p_tnode, int priority) {
int i;
if (p_tnode != NULL) {
for (i = 0; i < priority; i++) printf(" ");
if (priority == 0) printf("###");
else printf("#");
printf("TNode(id: %s)\n", s_idToASCIIString(p_tnode->s_id));
for (i = 0; i < priority + 1; i++) printf(" ");
printf("ifMalloc: ");
if (p_tnode->if_malloc) {
printf("YES\n");
for (i = 0; i < priority + 1; i++) printf(" ");
printf("Value(type: %d): ", p_tnode->type);
if (p_tnode->type == INT) {
printf("%d\n", *(int *)(p_tnode->value));
}
else if (p_tnode->type == DOUBLE) {
printf("%a\n", *(double *)(p_tnode->value));
}
else if (p_tnode->type == STRING) {
printf("%s\n", (char *)(p_tnode->value));
}
else if (p_tnode->type == POINTER) {
printf("%p\n", (char *)(p_tnode->value));
}
}
else printf("NO\n");
if (p_tnode->child_num > 0) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("Child number: %llu\n", p_tnode->child_num);
}
return 0;
}
return -1;
}
int printTNodeWithHome(TNode *p_tnode,int priority) {
int i;
List *p_home;
Node *p_node;
if (p_tnode != NULL) {
if (priority == 0) printf("###");
else printf("#");
printf("TNode(id: %s)\n", s_idToASCIIString(p_tnode->s_id));
for (i = 0; i < priority + 1; i++) printf(" ");
printf("ifMalloc: ");
if (p_tnode->if_malloc) {
printf("YES\n");
for (i = 0; i < priority + 1; i++) printf(" ");
printf("Value(type: %d): ", p_tnode->type);
if (p_tnode->type == INT) {
printf("%d\n", *(int *)(p_tnode->value));
}
else if (p_tnode->type == DOUBLE) {
printf("%a\n", *(double *)(p_tnode->value));
}
else if (p_tnode->type == STRING) {
printf("%s\n", (char *)(p_tnode->value));
}
else if (p_tnode->type == POINTER) {
printf("%p\n", (char *)(p_tnode->value));
}
}
else printf("NO\n");
if (p_tnode->father != NULL) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("Father id: %s\n", s_idToASCIIString(p_tnode->father->s_id));
}
else
{
for (i = 0; i < priority + 1; i++) printf(" ");
printf("Father: NO\n");
}
if (p_tnode->child_num > 0) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("Child(number: %llu):\n", p_tnode->child_num);
}
p_home = p_tnode->home;
p_node = p_home->head;
while (p_node != NULL) {
printTNode((TNode *)p_node->value, priority + 2);
p_node = p_node->next;
}
return 0;
}
return -1;
}
int printTNodeWithFamily(TNode *p_tnode, int priority) {
int i;
List *p_home;
Node *p_node;
if (p_tnode != NULL) {
for (i = 0; i < priority; i++) printf(" ");
if (priority == 0) printf("###");
else printf("#");
printf("TNode(id: %s)\n", s_idToASCIIString(p_tnode->s_id));
for (i = 0; i < priority + 1; i++) printf(" ");
printf("ifMalloc: ");
if (p_tnode->if_malloc) {
printf("YES\n");
for (i = 0; i < priority + 1; i++) printf(" ");
printf("Value(type: %d): ", p_tnode->type);
if (p_tnode->type == INT) {
printf("%d\n", *(int *)(p_tnode->value));
}
else if (p_tnode->type == DOUBLE) {
printf("%a\n", *(double *)(p_tnode->value));
}
else if (p_tnode->type == STRING) {
printf("%s\n", (char *)(p_tnode->value));
}
else if (p_tnode->type == POINTER) {
printf("%p\n", (char *)(p_tnode->value));
}
}
else printf("NO\n");
if (p_tnode->father != NULL) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("Father id: %s\n", s_idToASCIIString(p_tnode->father->s_id));
}
else
{
for (i = 0; i < priority + 1; i++) printf(" ");
printf("Father: NO\n");
}
if (p_tnode->child_num > 0) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("Child(number: %llu):\n", p_tnode->child_num);
}
p_home = p_tnode->home;
p_node = p_home->head;
while (p_node != NULL) {
printTNodeWithFamily((TNode *)p_node->value, priority + 2);
p_node = p_node->next;
}
return 0;
}
return -1;
}
int printTree(Tree *p_tree) {
printf("###");
printf("Tree(id: %s)",s_idToASCIIString(p_tree->s_id));
printTNodeWithFamily(p_tree->root,0);
return 0;
}
strcpy(p_temp, temp);
initMallocValueForTNode(p_tnode, STRING, p_temp);
return p_tnode;
}
static unsigned long long tnodes_size = 0LL;
TNode *tnodeWithPointer(void *temp) {
TNode *p_tnode = initTNode();
initMallocValueForTNode(p_tnode, POINTER, temp);
return p_tnode;
}
int getValueByIntForTree(TNode *p_tnode) {
if (p_tnode->type == INT) {
return *(int *)p_tnode->value;
}
return -1;
}
double getValueByDoubleForTree(TNode *p_tnode) {
if (p_tnode->type == DOUBLE) {
return *(double *)p_tnode->value;
}
return -1;
}
char *getValueByStringForTree(TNode *p_tnode) {
if (p_tnode->type == STRING) {
return (char *)p_tnode->value;
}
return NULL;
}
void *getValueByPointerForTree(TNode *p_tnode) {
if (p_tnode->type == POINTER) {
return p_tnode->value;
}
return NULL;
}
int printTNode(TNode *p_tnode, int priority) {
int i;
if (p_tnode != NULL) {
for (i = 0; i < priority; i++) printf(" ");
if (priority == 0) printf("###");
else printf("#");
printf("TNode(id: %s)\n", s_idToASCIIString(p_tnode->s_id));
for (i = 0; i < priority + 1; i++) printf(" ");
printf("ifMalloc: ");
if (p_tnode->if_malloc) {
printf("YES\n");
for (i = 0; i < priority + 1; i++) printf(" ");
printf("Value(type: %d): ", p_tnode->type);
if (p_tnode->type == INT) {
printf("%d\n", *(int *)(p_tnode->value));
}
else if (p_tnode->type == DOUBLE) {
printf("%a\n", *(double *)(p_tnode->value));
}
else if (p_tnode->type == STRING) {
printf("%s\n", (char *)(p_tnode->value));
}
else if (p_tnode->type == POINTER) {
printf("%p\n", (char *)(p_tnode->value));
}
}
else printf("NO\n");
if (p_tnode->child_num > 0) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("Child number: %llu\n", p_tnode->child_num);
}
return 0;
}
return -1;
}
int printTNodeWithHome(TNode *p_tnode,int priority) {
int i;
List *p_home;
Node *p_node;
if (p_tnode != NULL) {
if (priority == 0) printf("###");
else printf("#");
printf("TNode(id: %s)\n", s_idToASCIIString(p_tnode->s_id));
for (i = 0; i < priority + 1; i++) printf(" ");
printf("ifMalloc: ");
if (p_tnode->if_malloc) {
printf("YES\n");
for (i = 0; i < priority + 1; i++) printf(" ");
printf("Value(type: %d): ", p_tnode->type);
if (p_tnode->type == INT) {
printf("%d\n", *(int *)(p_tnode->value));
}
else if (p_tnode->type == DOUBLE) {
printf("%a\n", *(double *)(p_tnode->value));
}
else if (p_tnode->type == STRING) {
printf("%s\n", (char *)(p_tnode->value));
}
else if (p_tnode->type == POINTER) {
printf("%p\n", (char *)(p_tnode->value));
}
}
else printf("NO\n");
if (p_tnode->father != NULL) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("Father id: %s\n", s_idToASCIIString(p_tnode->father->s_id));
}
else
{
for (i = 0; i < priority + 1; i++) printf(" ");
printf("Father: NO\n");
}
if (p_tnode->child_num > 0) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("Child(number: %llu):\n", p_tnode->child_num);
}
p_home = p_tnode->home;
p_node = p_home->head;
while (p_node != NULL) {
printTNode((TNode *)p_node->value, priority + 2);
p_node = p_node->next;
}
return 0;
}
return -1;
}
int printTNodeWithFamily(TNode *p_tnode, int priority) {
int i;
List *p_home;
Node *p_node;
if (p_tnode != NULL) {
for (i = 0; i < priority; i++) printf(" ");
if (priority == 0) printf("###");
else printf("#");
printf("TNode(id: %s)\n", s_idToASCIIString(p_tnode->s_id));
for (i = 0; i < priority + 1; i++) printf(" ");
printf("ifMalloc: ");
if (p_tnode->if_malloc) {
printf("YES\n");
for (i = 0; i < priority + 1; i++) printf(" ");
printf("Value(type: %d): ", p_tnode->type);
if (p_tnode->type == INT) {
printf("%d\n", *(int *)(p_tnode->value));
}
else if (p_tnode->type == DOUBLE) {
printf("%a\n", *(double *)(p_tnode->value));
}
else if (p_tnode->type == STRING) {
printf("%s\n", (char *)(p_tnode->value));
}
else if (p_tnode->type == POINTER) {
printf("%p\n", (char *)(p_tnode->value));
}
}
else printf("NO\n");
if (p_tnode->father != NULL) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("Father id: %s\n", s_idToASCIIString(p_tnode->father->s_id));
}
else
{
for (i = 0; i < priority + 1; i++) printf(" ");
printf("Father: NO\n");
}
if (p_tnode->child_num > 0) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("Child(number: %llu):\n", p_tnode->child_num);
}
p_home = p_tnode->home;
p_node = p_home->head;
while (p_node != NULL) {
printTNodeWithFamily((TNode *)p_node->value, priority + 2);
p_node = p_node->next;
}
return 0;
}
return -1;
}
int printTree(Tree *p_tree) {
printf("###");
printf("Tree(id: %s)",s_idToASCIIString(p_tree->s_id));
printTNodeWithFamily(p_tree->root,0);
return 0;
}
static unsigned long long tnodes_size = 0LL;
unsigned long long calTreeMemory(Tree *p_tree){
tnodes_size = 0LL;

42
tree/tree_expand.h → src/datastruct/tree/tree_expand.h
View File

@ -1,27 +1,27 @@
#ifndef TREE_EXPAND_H
#define TREE_EXPAND_H
#include "tree.h"
TNode *tnodeWithInt(int);
TNode *tnodeWithDouble(double);
TNode *tnodeWithString(char *);
TNode *tnodeWithPointer(void *);
int getValueByIntForTree(TNode *);
double getValueByDoubleForTree(TNode *);
char *getValueByStringForTree(TNode *);
void *getValueByPointerForTree(TNode *);
int printTree(Tree *p_tree);
int printTNodeWithHome(TNode *p_tnode, int priority);
int printTNodeWithFamily(TNode *p_tnode, int priority);
int printTNode(TNode *p_tnode, int priority);
#ifndef TREE_EXPAND_H
#define TREE_EXPAND_H
#include "tree.h"
TNode *tnodeWithInt(int);
TNode *tnodeWithDouble(double);
TNode *tnodeWithString(char *);
TNode *tnodeWithPointer(void *);
int getValueByIntForTree(TNode *);
double getValueByDoubleForTree(TNode *);
char *getValueByStringForTree(TNode *);
void *getValueByPointerForTree(TNode *);
int printTree(Tree *p_tree);
int printTNodeWithHome(TNode *p_tnode, int priority);
int printTNodeWithFamily(TNode *p_tnode, int priority);
int printTNode(TNode *p_tnode, int priority);
unsigned long long calTreeMemory(Tree *);
int _doCalTreeMemory(TNode *p_tnode, unsigned long long height);
List *treeToList(Tree *p_tree);
#endif
#endif

53
src/error/error.c Normal file
View File

@ -0,0 +1,53 @@
#include <type.h>
#include <error/error.h>
int pushInfo(Info *p_info, const char *head, const char *body) {
strcpy(p_info->head, head);
strcpy(p_info->body, body);
return 0;
}
Error *pushError(unsigned int type, int pri, Info *p_info) {
Error *p_error = (Error *)malloc(sizeof(Error));
p_error->type = type;
p_error->priority = pri;
p_error->info = *p_info;
p_error->time = time(NULL);
free(p_info);
return p_error;
}
Notice *pushNotice(unsigned int type, Info *p_info) {
Notice *p_notice = (Notice *)malloc(sizeof(Notice));
p_notice->type = type;
p_notice->info = *p_info;
p_notice->time = time(NULL);
free(p_info);
return p_notice;
}
Info *initInfo(const char *head, const char *body){
Info *p_info = (Info *)malloc(sizeof(Info));
pushInfo(p_info, head, body);
return p_info;
}
int showError(Error *p_error){
printf("\n");
for (int i = 0; i < p_error->priority; i++) {
printf("!");
}
printf("(Error) %s\n",asctime(localtime(&p_error->time)));
printf("%s: %s.\n",p_error->info.head,p_error->info.body);
free(p_error);
return 0;
}
int showWarning(Notice *p_notice){
printf("\n@");
printf("(Warning) %s\n",asctime(localtime(&p_notice->time)));
printf("%s: %s.\n",p_notice->info.head,p_notice->info.body);
free(p_notice);
return 0;
}

8
error/error.c → src/error/error_file.c
View File

@ -1,14 +1,16 @@
#include "error.h"
#include <error/error_file.h>
int initErrorSystem(void) {
error_list = initList();
notice_list = initList();
error_list = initList(0);
notice_list = initList(0);
if_error = 1;
return 1;
}
int setLogDirectory(const char *path) {
#ifdef id_enable
logfile.id = getId();
#endif
unsigned long memory_space = strlen(path) + 256;
char *file_path = (char *)malloc(sizeof(char)*memory_space);

135
src/event/event_callback.c Normal file
View File

@ -0,0 +1,135 @@
#include <type.h>
#include <chain/chain.h>
#include <event/event.h>
/**
顺序遍历链表的操作函数。回调函数返回-1退出遍历，返回1继续向后遍历，返回其他值则暂停向下遍历。
回调函数接受一个整数、一个指向节点内容的指针、一个而外的参数链表，且回调函数需要返回一个链表，链表的第一个值作为函数的实际返回值。
一般配合宏使用
@param p_list 指向目标链表的指针
@param p_func 指向回调函数的指针
@return 返回参数链表
*/
Chain *listThrough(Chain *p_list, Chain *(*p_func)(uint32_t, void *, Chain *), Chain *expand_resources) {
Node *p_node = p_list->head;
List *m_rtnlst = NULL;
uint64_t index = 0;
insertInTail(expand_resources, nodeWithULLInt(index, 0));
insertInTail(expand_resources, nodeWithULLInt(p_list->length, 0));
while (p_node != NULL) {
if (p_node->value != NULL) {
m_rtnlst = (*p_func)(p_node->type, p_node->value, expand_resources);
int status = getByIntForNode(findByIndexForNode(m_rtnlst, 0));
if (status == -1) break;
else if (status == 1) {
p_node = p_node->last;
releaseList(m_rtnlst);
m_rtnlst = NULL;
continue;
}
else {
releaseList(m_rtnlst);
m_rtnlst = NULL;
}
}
lupdull(expand_resources,expand_resources->length-2,++index);
p_node = p_node->next;
}
releaseList(expand_resources);
if(m_rtnlst != NULL) releaseNode(popFromHead(m_rtnlst));
return m_rtnlst;
}
/**
回调宏相关函数，type为1时用于回调函数获取当前参数列表的参数个数。
type为2时用于获取当前节点在链表中的序号
@param expand_resources 指向参数列表的指针
@param type 模式
@return 返回需要获取的数据
*/
uint64_t getInfoForListThrough(Chain *expand_resources, int type){
Node *p_node = NULL;
if (type == 0) {
p_node = findByIndexForNode(expand_resources, expand_resources->length-1);
}else{
p_node = findByIndexForNode(expand_resources, expand_resources->length-2);
}
return *((uint64_t *)p_node->value);
}
/**
回调宏相关函数，构造回调函数的返回参数列表
@param if_status 模式参数
@param status 模式参数
@param argc 参数说明
@param ... 参数
@return 指向构造的参数列表的指针
*/
Chain *newReturn(int if_status ,int status, char *argc, ...){
List *p_list = initList(0);
if(if_status){
lisrti(p_list, status);
}
if(status != 0){
va_list args;
va_start(args, argc);
char p_ch = argc[0];
char t_ch[256];
int count = 0, t_count = 0;
while(p_ch != '\0'){
if(p_ch == '%'){
switch (argc[count + 1]) {
case 'd':
lisrti(p_list, va_arg(args, int));
break;
case 's':
t_count = 0;
while ((t_ch[t_count] = va_arg(args, int)) != '\0') t_count++;
t_ch[t_count] = '\0';
lisrts(p_list, t_ch);
break;
case 'f':
lisrtd(p_list, va_arg(args, double));
break;
case 'p':
lisrtp(p_list, va_arg(args, void *));
break;
case 'u':
if(argc[count + 2] == 'l'){
if(argc[count + 3] == 'l'){
lisrtull(p_list, va_arg(args, unsigned long long));
count += 2;
}
else{
count++;
}
}
else{
lisrtu(p_list, va_arg(args, unsigned int));
}
break;
default:
break;
}
count++;
}
p_ch = argc[++count];
}
va_end(args);
}
return p_list;
}
/**
回调宏相关函数，用于回调函数不带而外参数的返回
@return 指向构造的参数列表的指针
*/
Chain *newCReturn(void){
return newReturn(1, 0, NULL);
}

381
src/id/id.c Normal file
View File

@ -0,0 +1,381 @@
#include <type.h>
#include <id/id.h>
static _Bool if_rand = 0;
/*
*用当前时间初始化伪随机数发生器
*/
static void init_rand(void);
/*
*为一个新的SID管理结构分配内存空间
*参数: deep_level指示原始ID的复杂度
*返回: 处理成功则返回指向相关结构体所在内存空间的指针,不成功则返回NULL.
*/
static SID *initS_id(unsigned int deep_level);
/*
*将原始SID数据转化成MD5的Hex形式的数据
*/
static void s_idToMD5(SID *s_id);
/*
*将原始SID数据转化成字符串
*返回: 执行成功相关字符串,不成功则返回NULL
*/
static char *s_idToASCIIRawString(SID * const s_id);
/*
*将10进制数字,转化成字符型的16位进制数字
*/
static char hexToChar(unsigned int);
/*
*将原始SID数据转换成的SID转化回原始SID数据
*返回: 执行成功相关指向数据结构内存空间的指针,不成功则返回NULL
*/
static SID *asciiRawStringToS_id(char * const string);
/*
*获得一个新的SID原始数据
*/
static void getRawS_id(SID *s_id, unsigned int type, unsigned int deep_level);
static void init_rand(void) {
srand((unsigned)time(NULL));
}
unsigned long long getId(void) {
int i;
unsigned long long id = 0;
id = ((rand() % 9) + 1);
for (i = 0; i < 15; i++) {
id *= 10;
id += rand() % 10;
}
return id;
}
static SID *initS_id(unsigned int deep_level){
if (!if_rand){
init_rand();
if_rand = 1;
}
SID *p_sid = (SID *) malloc(sizeof(SID));
if(p_sid == NULL){
printf("\ninitS_id(): Error in getting the memory of sid.\n");
}
p_sid->sr = malloc(sizeof(struct sid_raw));
p_sid->sr->type = VOID;
p_sid->deep = deep_level;
p_sid->sr->value = NULL;
p_sid->sr->value_deeper = NULL;
p_sid->sr->value_deepest = NULL;
p_sid->md5 = NULL;
p_sid->decrypt_str = NULL;
p_sid->decrypt_hex = NULL;
return p_sid;
}
void getRawS_id(SID *p_sid, unsigned int type, unsigned int deep_level){
if (deep_level > 0) {
p_sid->sr->value = (unsigned int *)malloc(sizeof(unsigned int)*DEEPC_LEN);
if(p_sid->sr->value == NULL){
printf("\ninitS_id(): Error in getting the memory of sid.value.\n");
}
}
if (deep_level > 1){
p_sid->sr->value_deeper = (unsigned int *)malloc(sizeof(unsigned int)*DEEPB_LEN);
if(p_sid->sr->value_deeper == NULL){
printf("\ninitS_id(): Error in getting the memory of sid.value_deeper.\n");
}
}
if (deep_level > 2){
p_sid->sr->value_deepest = (unsigned int *)malloc(sizeof(unsigned int)*DEEPA_LEN);
if(p_sid->sr->value_deepest == NULL){
printf("\ninitS_id(): Error in getting the memory of sid.value_deepest.\n");
}
}
p_sid->sr->type = type;
if(deep_level > 0){
for(register int i = 0; i < DEEPC_LEN; i++) p_sid->sr->value[i] = rand()%65535;
if(deep_level > 1) for(register int i = 0; i < DEEPB_LEN; i++) p_sid->sr->value_deeper[i] = rand()%65535;
if (deep_level > 2) for(register int i = 0; i < DEEPA_LEN; i++) p_sid->sr->value_deepest[i] = rand()%65535;
}
}
SID *getS_id(unsigned int type, unsigned int deep_level){
SID *p_sid = initS_id(deep_level);
getRawS_id(p_sid, type, deep_level);
s_idToMD5(p_sid);
setSidToASCIIString(p_sid);
return p_sid;
}
int fitS_id(SID * const fs_id, SID * const ss_id){
if(fs_id->decrypt_str == NULL) setSidToASCIIString(fs_id);
if(ss_id->decrypt_str == NULL) setSidToASCIIString(ss_id);
return strcmp(fs_id->decrypt_str, ss_id->decrypt_str);
}
void setSidToASCIIString(SID * const s_id){
if(s_id->decrypt_str == NULL){
s_id->decrypt_str = malloc(sizeof(char) * 33);
s_id->decrypt_str[32] = '\0';
for(register int i = 0; i < 16; i++){
unsigned int temp_dyt = s_id->decrypt_hex[i];
//printf("%d\n",(unsigned int)temp_dyt);
unsigned int k = 0;
for (k = 0; (temp_dyt - (k * 16)) >= 16; k++);
s_id->decrypt_str[i * 2] = hexToChar(k);
//printf("HEX:%c",hexToChar(k));
s_id->decrypt_str[i * 2 + 1] = hexToChar(temp_dyt - k * 16);
//printf("HEX:%c",hexToChar(temp_dyt - k * 16));
}
}
}
int simFitS_id(SID * fs_id, SID * ss_id){
return !fitS_id(fs_id, ss_id);
}
char *s_idToASCIIString(SID * const s_id){
if(s_id->decrypt_str == NULL){
setSidToASCIIString(s_id);
}
free(s_id->md5);
s_id->md5 = NULL;
//printf("s_id->decrypt_str: %s",s_id->decrypt_str);
char *rtn_str = malloc(sizeof(char) * 33);
strcpy(rtn_str, s_id->decrypt_str);
free(s_id->decrypt_hex);
s_id->decrypt_hex = NULL;
return rtn_str;
}
char *s_idToASCIIRawString(SID * const s_id){
char *string = NULL;
int deep_len = 0, temp, buff_count, string_count;
unsigned int buff[DATA_BIT];
if(s_id->deep > 0){
if (s_id->deep == DEEPC){
string = (char *) malloc(sizeof(char) * (DEEPC_LEN + 1) * DATA_BIT);
deep_len = DEEPC_LEN + 1;
deep_len *= DATA_BIT;
}
else if (s_id->deep == DEEPB){
string = (char *) malloc(sizeof(char) * (DEEPC_LEN + DEEPB_LEN + 1) * DATA_BIT);
deep_len = DEEPC_LEN + DEEPB_LEN + 1;
deep_len *= DATA_BIT;
}
else{
string = (char *)malloc(sizeof(char) * (DEEPC_LEN + DEEPB_LEN + DEEPA_LEN + 1) * DATA_BIT);
deep_len = DEEPC_LEN + DEEPB_LEN + DEEPA_LEN + 1;
deep_len *= DATA_BIT;
}
if(string == NULL){
printf("\ns_idToASCIIString(): Error in getting the memory of string.\n");
}
string[deep_len] = '\0';
temp = s_id->sr->type;
buff_count = DATA_BIT - 1;
for (int i = 0; i < DATA_BIT; i++) buff[i] = 0;
while(buff_count >= 0){
buff[buff_count] = temp % 10;
string[buff_count] = buff[buff_count] + 48;
temp /= 10;
buff_count--;
}
deep_len -= DATA_BIT;
for(int i = 0; i < DEEPC_LEN; i++){
temp = s_id->sr->value[i];
for (int i = 0; i < DATA_BIT; i++) buff[i] = 0;
string_count = TYPE_LEN + (i) * 5;
buff_count = DATA_BIT - 1;
while (buff_count >= 0) {
buff[buff_count] = temp % 10;
temp /= 10;
buff_count--;
}
for(int i = DATA_BIT - 1; i >= 0; i--) string[string_count + i] = buff[i] + 48;
}
deep_len -= DEEPC_LEN * DATA_BIT;
if(deep_len > 0)
for(int i = 0; i < DEEPB_LEN; i++){
temp = s_id->sr->value_deeper[i];
for (int i = 0; i < DATA_BIT; i++) buff[i] = 0;
string_count = TYPE_LEN + DEEPC_LEN * DATA_BIT + (i) * DATA_BIT;
buff_count = DATA_BIT - 1;
while (buff_count >= 0) {
buff[buff_count] = temp % 10;
temp /= 10;
buff_count--;
}
for(int i = DATA_BIT - 1; i >= 0; i--) string[string_count + i] = buff[i] + 48;
}
deep_len -= DEEPB_LEN * DATA_BIT;
if(deep_len > 0)
for(int i = 0; i < DEEPA_LEN; i++){
temp = s_id->sr->value_deepest[i];
for (int i = 0; i < DATA_BIT; i++) buff[i] = 0;
string_count = TYPE_LEN + (DEEPC_LEN + DEEPB_LEN) * DATA_BIT + (i) * DATA_BIT;
buff_count = DATA_BIT - 1;
while (buff_count >= 0) {
buff[buff_count] = temp % 10;
string[string_count] = buff[buff_count] + 48;
temp /= 10;
buff_count--;
}
for(int i = DATA_BIT - 1; i >= 0; i--) string[string_count + i] = buff[i] + 48;
}
return string;
}
else{
return NULL;
}
}
static SID *asciiRawStringToS_id(char * const string){
SID *s_id = NULL;
unsigned long long string_len = strlen(string);
if (string_len == 25) s_id = initS_id(1);
else if (string_len == 65) s_id = initS_id(2);
else if (string_len == 225) s_id = initS_id(3);
else return NULL;
unsigned int *buff = (unsigned int *) malloc(sizeof(unsigned int) * (string_len));
if(buff == NULL){
printf("\ns_idToASCIIString(): Error in getting the memory of string.\n");
}
for(int i = 0; i < string_len; i++){
buff[i] = (unsigned int)string[i] - 48;
}
s_id->sr->type = 0;
for (int i = 0; i < 5; i++){
s_id->sr->type += buff[i] ;
s_id->sr->type *= 10u;
}
s_id->sr->type /= 10u;
if (string_len >= 25){
for(int i = 0; i < DEEPC_LEN; i++){
s_id->sr->value[i] = 0;
for (int j = 0; j < 5; j++){
s_id->sr->value[i] += (unsigned int)buff[5 + i * 5 + j];
if(j < 4) s_id->sr->value[i] *= 10;
}
}
}
if (string_len >= 65){
for(int i = 0; i < DEEPB_LEN; i++){
s_id->sr->value_deeper[i] = 0;
for (int j = 0; j < 5; j++){
s_id->sr->value_deeper[i] += buff[25 + i * 5 + j];
if(j < 4) s_id->sr->value_deeper[i] *= 10;
}
}
}
if (string_len >= 225){
for(int i = 0; i < DEEPA_LEN; i++){
s_id->sr->value_deepest[i] = 0;
for (int j = 0; j < 5; j++){
s_id->sr->value_deepest[i] += buff[65 + i * 5 + j];
if(j < 4) s_id->sr->value_deepest[i] *= 10;
}
}
}
free(buff);
return s_id;
}
int freeS_id(SID *s_id){
if(s_id == NULL) return 0;
if(s_id->decrypt_hex != NULL) free(s_id->decrypt_hex);
freeSidRaw(s_id);
if (s_id->md5 != NULL) free(s_id->md5);
free(s_id->decrypt_str);
free(s_id);
return 0;
}
int freeSidRaw(SID *s_id){
if (s_id != NULL && s_id->sr != NULL){
if(s_id->sr->value != NULL){
free(s_id->sr->value);
s_id->sr->value = NULL;
}
if(s_id->sr->value_deeper != NULL){
free(s_id->sr->value_deeper);
s_id->sr->value_deeper = NULL;
}
if(s_id->sr->value_deepest != NULL){
free(s_id->sr->value_deepest);
s_id->sr->value_deepest = NULL;
}
free(s_id->sr);
s_id->sr = NULL;
}
return 0;
}
void s_idToMD5(SID *s_id){
if(s_id->md5 == NULL) s_id->md5 = malloc(sizeof(MD5_CTX));
char *sid_string = s_idToASCIIRawString(s_id);
s_id->decrypt_hex = malloc(sizeof(unsigned char) * 16);
//printf("%s\n",sid_string);
MD5Init(s_id->md5);
MD5Update(s_id->md5, (unsigned char *) sid_string, strlen(sid_string));
MD5Final(s_id->md5, s_id->decrypt_hex);
freeSidRaw(s_id);
free(sid_string);
}
char hexToChar(unsigned int n){
switch (n) {
case 1:return '1';
case 2:return '2';
case 3:return '3';
case 4:return '4';
case 5:return '5';
case 6:return '6';
case 7:return '7';
case 8:return '8';
case 9:return '9';
case 10:return 'a';
case 11:return 'b';
case 12:return 'c';
case 13:return 'd';
case 14:return 'e';
case 15:return 'f';
default:
break;
}
return '0';
}
SID *copyS_id(SID *f_sid){
SID *s_sid = initS_id(f_sid->deep);
if(s_sid->decrypt_str == NULL) s_sid->decrypt_str = malloc(sizeof(char) * SID_LEN);
if (f_sid->decrypt_str != NULL) strcpy(s_sid->decrypt_str, f_sid->decrypt_str);
else{
freeS_id(s_sid);
return NULL;
};
return s_sid;
}
SID *setS_idWithString(char *p_string){
if(p_string == NULL) return NULL;
SID *p_sid = initS_id(0);
if(p_sid->decrypt_str == NULL) p_sid->decrypt_str = malloc(sizeof(char) * SID_LEN);
strcpy(p_sid->decrypt_str, p_string);
return p_sid;
}

167
src/id/md5.c Normal file
View File

@ -0,0 +1,167 @@
#include "md5.h"
unsigned char PADDING[] = {
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
void MD5Init(MD5_CTX *context)
{
context->count[0] = 0;
context->count[1] = 0;
context->state[0] = 0x67452301;
context->state[1] = 0xEFCDAB89;
context->state[2] = 0x98BADCFE;
context->state[3] = 0x10325476;
}
void MD5Update(MD5_CTX *context, unsigned char *input, unsigned long inputlen)
{
unsigned int i = 0, index = 0, partlen = 0;
index = (context->count[0] >> 3) & 0x3F;
partlen = 64 - index;
context->count[0] += inputlen << 3;
if (context->count[0] < (inputlen << 3))
context->count[1]++;
context->count[1] += inputlen >> 29;
if (inputlen >= partlen)
{
memcpy(&context->buffer[index], input, partlen);
MD5Transform(context->state, context->buffer);
for (i = partlen; i + 64 <= inputlen; i += 64)
MD5Transform(context->state, &input[i]);
index = 0;
}
else
{
i = 0;
}
memcpy(&context->buffer[index], &input[i], inputlen - i);
}
void MD5Final(MD5_CTX *context, unsigned char digest[16])
{
unsigned int index = 0, padlen = 0;
unsigned char bits[8];
index = (context->count[0] >> 3) & 0x3F;
padlen = (index < 56) ? (56 - index) : (120 - index);
MD5Encode(bits, context->count, 8);
MD5Update(context, PADDING, padlen);
MD5Update(context, bits, 8);
MD5Encode(digest, context->state, 16);
}
void MD5Encode(unsigned char *output, unsigned int *input, unsigned long len)
{
unsigned int i = 0, j = 0;
while (j < len)
{
output[j] = input[i] & 0xFF;
output[j + 1] = (input[i] >> 8) & 0xFF;
output[j + 2] = (input[i] >> 16) & 0xFF;
output[j + 3] = (input[i] >> 24) & 0xFF;
i++;
j += 4;
}
}
void MD5Decode(unsigned int *output, unsigned char *input, unsigned long len)
{
unsigned int i = 0, j = 0;
while (j < len)
{
output[i] = (input[j]) |
(input[j + 1] << 8) |
(input[j + 2] << 16) |
(input[j + 3] << 24);
i++;
j += 4;
}
}
void MD5Transform(unsigned int state[4], unsigned char block[64])
{
unsigned int a = state[0];
unsigned int b = state[1];
unsigned int c = state[2];
unsigned int d = state[3];
unsigned int x[64];
MD5Decode(x, block, 64);
FF(a, b, c, d, x[0], 7, 0xd76aa478);
FF(d, a, b, c, x[1], 12, 0xe8c7b756);
FF(c, d, a, b, x[2], 17, 0x242070db);
FF(b, c, d, a, x[3], 22, 0xc1bdceee);
FF(a, b, c, d, x[4], 7, 0xf57c0faf);
FF(d, a, b, c, x[5], 12, 0x4787c62a);
FF(c, d, a, b, x[6], 17, 0xa8304613);
FF(b, c, d, a, x[7], 22, 0xfd469501);
FF(a, b, c, d, x[8], 7, 0x698098d8);
FF(d, a, b, c, x[9], 12, 0x8b44f7af);
FF(c, d, a, b, x[10], 17, 0xffff5bb1);
FF(b, c, d, a, x[11], 22, 0x895cd7be);
FF(a, b, c, d, x[12], 7, 0x6b901122);
FF(d, a, b, c, x[13], 12, 0xfd987193);
FF(c, d, a, b, x[14], 17, 0xa679438e);
FF(b, c, d, a, x[15], 22, 0x49b40821);
GG(a, b, c, d, x[1], 5, 0xf61e2562);
GG(d, a, b, c, x[6], 9, 0xc040b340);
GG(c, d, a, b, x[11], 14, 0x265e5a51);
GG(b, c, d, a, x[0], 20, 0xe9b6c7aa);
GG(a, b, c, d, x[5], 5, 0xd62f105d);
GG(d, a, b, c, x[10], 9, 0x2441453);
GG(c, d, a, b, x[15], 14, 0xd8a1e681);
GG(b, c, d, a, x[4], 20, 0xe7d3fbc8);
GG(a, b, c, d, x[9], 5, 0x21e1cde6);
GG(d, a, b, c, x[14], 9, 0xc33707d6);
GG(c, d, a, b, x[3], 14, 0xf4d50d87);
GG(b, c, d, a, x[8], 20, 0x455a14ed);
GG(a, b, c, d, x[13], 5, 0xa9e3e905);
GG(d, a, b, c, x[2], 9, 0xfcefa3f8);
GG(c, d, a, b, x[7], 14, 0x676f02d9);
GG(b, c, d, a, x[12], 20, 0x8d2a4c8a);
HH(a, b, c, d, x[5], 4, 0xfffa3942);
HH(d, a, b, c, x[8], 11, 0x8771f681);
HH(c, d, a, b, x[11], 16, 0x6d9d6122);
HH(b, c, d, a, x[14], 23, 0xfde5380c);
HH(a, b, c, d, x[1], 4, 0xa4beea44);
HH(d, a, b, c, x[4], 11, 0x4bdecfa9);
HH(c, d, a, b, x[7], 16, 0xf6bb4b60);
HH(b, c, d, a, x[10], 23, 0xbebfbc70);
HH(a, b, c, d, x[13], 4, 0x289b7ec6);
HH(d, a, b, c, x[0], 11, 0xeaa127fa);
HH(c, d, a, b, x[3], 16, 0xd4ef3085);
HH(b, c, d, a, x[6], 23, 0x4881d05);
HH(a, b, c, d, x[9], 4, 0xd9d4d039);
HH(d, a, b, c, x[12], 11, 0xe6db99e5);
HH(c, d, a, b, x[15], 16, 0x1fa27cf8);
HH(b, c, d, a, x[2], 23, 0xc4ac5665);
II(a, b, c, d, x[0], 6, 0xf4292244);
II(d, a, b, c, x[7], 10, 0x432aff97);
II(c, d, a, b, x[14], 15, 0xab9423a7);
II(b, c, d, a, x[5], 21, 0xfc93a039);
II(a, b, c, d, x[12], 6, 0x655b59c3);
II(d, a, b, c, x[3], 10, 0x8f0ccc92);
II(c, d, a, b, x[10], 15, 0xffeff47d);
II(b, c, d, a, x[1], 21, 0x85845dd1);
II(a, b, c, d, x[8], 6, 0x6fa87e4f);
II(d, a, b, c, x[15], 10, 0xfe2ce6e0);
II(c, d, a, b, x[6], 15, 0xa3014314);
II(b, c, d, a, x[13], 21, 0x4e0811a1);
II(a, b, c, d, x[4], 6, 0xf7537e82);
II(d, a, b, c, x[11], 10, 0xbd3af235);
II(c, d, a, b, x[2], 15, 0x2ad7d2bb);
II(b, c, d, a, x[9], 21, 0xeb86d391);
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
}

2
src/memory/block/block.c Normal file
View File

@ -0,0 +1,2 @@
#include <block/block.h>

2
src/memory/block/block_expand.c Normal file
View File

@ -0,0 +1,2 @@
#include <block/block.h>
#include <block/block_expand.h>

53
src/memory/list/list_copy.c Normal file
View File

@ -0,0 +1,53 @@
#include <type.h>
#include <list/list.h>
/**
以一个已存在的节点为模板创建一个相同的新的节点
@param p_node 指向作为模板的节点的指针
@return 返回指向新的节点的指针
*/
Node *copyNode(Node *p_node) {
Node *t_node = NULL;
//当开启ID模块的时候编译
#ifdef id_enable
if (p_node->s_id == NULL) t_node = initNode(0);
else t_node = initNode(p_node->s_id->deep);
t_node->s_id = copyS_id(p_node->s_id);
#endif
t_node->last = p_node->last;
t_node->next = p_node->next;
t_node->type = p_node->type;
t_node->value = p_node->value;
return t_node;
}
/**
根据已存在的链表创建一个相同的新的链表
@param p_list 指向作为模板的链表的指针
@return 返回指向新链表的指针
*/
List *copyList(List *p_list) {
Node *p_node;
Node *t_node;
List *t_list = NULL;
#ifdef id_enable
if (p_list->s_id == NULL) t_list = initList(0);
else t_list = initList(p_list->s_id->deep);
#endif
t_list->head = p_list->head;
t_list->tail = p_list->tail;
t_list->length = p_list->length;
if(p_list->head != NULL && p_list->tail != NULL){
p_node = p_list->head;
while (p_node != NULL) {
t_node = copyNode(p_node);
insertInTail(t_list, t_node);
p_node = p_node->next;
}
}
return t_list;
}

130
src/memory/list/list_find.c Normal file
View File

@ -0,0 +1,130 @@
#include <type.h>
#include <list/list.h>
//如果ID模块可能启用则编译以下代码
#ifdef id_enable
/**
通过ID查找链表中符合条件的第一个节点
@param p_list 指向目标链表的指针
@param s_id ID值
@return 成功返回指向符合条件的节点的指针，不成功则返回NULL
*/
Node *findByIdForNode(List *p_list, SID * s_id) {
Node *ph_node = p_list->head;
Node *pt_node = p_list->tail;
int direction = 0;
while (ph_node != pt_node) {
if (direction == 0) {
if (simFitS_id(ph_node->s_id, s_id)) {
return ph_node;
}
else {
ph_node = ph_node->next;
}
direction = 1;
}
else {
if (simFitS_id(pt_node->s_id, s_id)) {
return pt_node;
}
else {
pt_node = pt_node->last;
}
}
}
return NULL;
}
#endif
/**
通过值来查找链表中符合条件的第一个节点
@param p_list 指向目标链表的指针
@param type 值的类型
@param value 值
@return 成功返回指向符合条件的节点的指针，不成功则返回NULL
*/
Node *findByValue(List *p_list, uint type, const void *value) {
Node *p_node = p_list->head;
while (p_node != NULL) {
if (p_node->type != type) {
p_node = p_node->next;
continue;
}
if (type == INT) {
if (*((int *)p_node->value) == *((int *)value)) {
return p_node;
}
}
else if (type == DOUBLE) {
if (*((double *)p_node->value) == *((double *)value)) {
return p_node;
}
}
else if (type == STRING) {
if (!strcmp((char *)p_node->value, (char *)value))
{
return p_node;
}
}
else if (type == POINTER) {
if (p_node->value == value) {
return p_node;
}
}
p_node = p_node->next;
}
return NULL;
}
/**
通过值来查找链表中符合条件的所有节点
@param p_list 指向目标链表的指针
@param type 值的类型
@param value 值
@return 返回含有所有符合条件的节点的重组链表
*/
List *mply_findByValue(List *p_list, unsigned int type, const void *value) {
List *f_list = initList(0);
Node *p_node = p_list->head;
while (p_node != NULL) {
if (p_node->type != type) {
p_node = p_node->next;
continue;
}
if (type == INT) {
if (*((int *)p_node->value) == *((int *)value)) {
Node *f_node = p_node;
insertInTail(f_list, f_node);
}
}
else if (type == DOUBLE) {
if (*((double *)p_node->value) == *((double *)value)) {
Node *f_node = p_node;
insertInTail(f_list, f_node);
}
}
else if (type == STRING) {
if (!strcmp((char *)p_node->value, (char *)value))
{
Node *f_node = p_node;
insertInTail(f_list, f_node);
}
}
else if (type == POINTER) {
if (p_node->value == value) {
Node *f_node = p_node;
insertInTail(f_list, f_node);
}
}
p_node = p_node->next;
}
return f_list;
}

25
src/memory/list/list_info.c Normal file
View File

@ -0,0 +1,25 @@
#include <type.h>
#include <list/list.h>
/**
返回链表的长度
@param p_list 指向目标链表的指针
@return 返回目标链表的长度
*/
uint64_t len(List *p_list) {
return p_list->length;
}
/**
检查链表是否为空
@param p_list 指向目标链表的指针
@return 目标链表为空返回1，不为空返回0
*/
int isListEmpty(List *p_list) {
if (p_list->head == NULL || p_list->tail == NULL)// If its head or tail is NULL,it would be thought as empty.
return 1; // But we should ensure that both of them are NULL when we
return 0; // want to make a list empty.
}

87
src/memory/list/list_init.c Normal file
View File

@ -0,0 +1,87 @@
#include <type.h>
#include <list/list.h>
/**
创建一个新的节点，并为其分配内存空间
@param if_sid 新的节点是否带ID
@return 返回指向新的节点的内存地址指针
*/
#ifdef id_enable
Node *initNode(_Bool if_sid)
#else
Node *initNode(void)
#endif
{
Node *p_node = (Node *)malloc(sizeof(Node));
if(p_node == NULL){
return NULL;
}
Node *prec_node = NULL;
//如果ID模块可能启用则编译以下代码
#ifdef id_enable
if (if_sid)p_node->s_id = getS_id(LIST_NODE, 1);
else p_node->s_id = NULL;
#endif
p_node->next = NULL;
p_node->last = NULL;
p_node->type = VOID;
// 链表内存安全模式相关操作
if (if_safeModeForNode) {
if_safeModeForNode = 0;
prec_node = initNode(0);
if_safeModeForNode = 1;
initMallocValueForNode(prec_node, POINTER, (void *)p_node);
insertInTail(node_list, prec_node);
}
return p_node;
}
/**
创建一个新的链表，并为其分配内存空间
@param if_sid 新的链表是否带ID
@return 返回指向新的链表的内存地址指针
*/
#ifdef id_enable
List *initList(_Bool if_sid)
#else
List *initList(void)
#endif
{
Node *p_node = NULL;
List *p_list = (List *)malloc(sizeof(List));
if(p_list == NULL){
return NULL;
}
//如果ID模块可能启用则编译以下代码
#ifdef id_enable
if(if_sid) p_list->s_id = getS_id(LIST, 1);
else p_list->s_id = NULL;
#endif
p_list->head = NULL;
p_list->tail = NULL;
if (if_safeModeForNode) {
if_safeModeForNode = 0;
p_node = initNode(0);
if_safeModeForNode = 1;
initMallocValueForNode(p_node, POINTER, (void *)p_list);
insertInTail(list_list, p_node);
}
return p_list;
}
/**
为新的节点设定初始值
@param p_node 指向目标节点的指针
@param type 值得类型
@param p_value 指向目标值的内存空间的指针
@return 执行成功则返回0
*/
inline int initMallocValueForNode(Node *p_node, unsigned int type, const void *p_value) {
p_node->type = type;
p_node->value = (void *)p_value;
return 0;
}

52
src/memory/list/list_insert.c Normal file
View File

@ -0,0 +1,52 @@
#include <type.h>
#include <list/list.h>
/**
在链表的头部插入节点
@param p_list 指向目标链表的指针
@param p_node 指向目标节点的指针
@return 函数执行成功返回0
*/
int insertInHead(List *p_list, Node *p_node) {
if (isListEmpty(p_list)) {
p_list->head = p_node;
p_list->tail = p_node;
}
else {
p_list->head->last = p_node;
p_node->last = NULL;
p_node->next = p_list->head;
p_list->head = p_node;
}
p_list->length += 1;
return 0;
}
/**
在链表的尾部插入节点
@param p_list 指向目标链表的指针
@param p_node 指向目标节点的指针
@return 函数执行成功返回0
*/
int insertInTail(List *p_list, Node *p_node) {
// 如果可能需要使用长链表模块则编译以下代码
/*
#ifdef list_quick_enable
if(p_list->p_lq != NULL && p_list->p_lq->if_sort) return -1;
#endif
*/
if (isListEmpty(p_list)) {
p_list->head = p_node;
p_list->tail = p_node;
}
else {
p_list->tail->next = p_node;
p_node->next = NULL;
p_node->last = p_list->tail;
p_list->tail = p_node;
}
p_list->length += 1;
return 0;
}

182
src/memory/list/list_print.c Normal file
View File

@ -0,0 +1,182 @@
#include <type.h>
#include <list/list.h>
#include <list/list_print.h>
#ifdef id_enable
#include <id/id.h>
#endif
/**
打印链表及链表中节点的相关数据
@param p_list 指向目标链表的指针
@param priority 行缩进次数
*/
void printListInfo(List *p_list, int priority) {
int i = 0;
Node *p_node;
for (i = 0; i < priority; i++) printf(" ");
printf("###LIST(location:%p",p_list);
// 如果可能使用到ID模块则编译以下代码
#ifdef id_enable
printf(",id:%s",s_idToASCIIString(p_list->s_id));
#endif
printf("){\n");
for (i = 0; i < priority + 1; i++) printf(" ");
printf("HEAD->%p / Tail->%p / Length:%llu\n", p_list->head, p_list->tail, p_list->length);
p_node = p_list->head;
while (p_node != NULL) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("%d.... \n", i);
printNodeInfo(p_node, priority + 1);
p_node = p_node->next;
i++;
}
for (i = 0; i < priority; i++) printf(" ");
printf("}\n");
}
/**
打印链表及其节点写详细信息
@param p_list 指向目标链表的指针
*/
void printList(List *p_list) {
int if_nearLast = 0;
Node *p_node = p_list->head;
printf("[");
while (p_node != NULL) {
if (!if_nearLast && p_node->next == NULL) if_nearLast = 1;
if (p_node->type == INT) {
printf("%d", *(int *)(p_node->value));
}
else if (p_node->type == DOUBLE) {
printf("%a", *(double *)(p_node->value));
}
else if (p_node->type == STRING) {
printf("%s", (char *)(p_node->value));
}
else if (p_node->type == POINTER) {
printf("%p", (char *)(p_node->value));
}
else if (p_node->type == LIST) {
printList((List *)p_node->value);
}
if (!if_nearLast) {
printf(", ");
}
p_node = p_node->next;
}
printf("]");
}
/**
打印节点的信息
@param p_node 指向目标节点的指针
@param priority 行缩进次数
*/
void printNodeInfo(Node *p_node, int priority) {
int i;
for (i = 0; i < priority; i++) printf(" ");
printf("#NODE(location:%p",p_node);
#ifdef id_enable
printf(", id:%s", s_idToASCIIString(p_node->s_id));
#endif
printf("){\n");
for (i = 0; i < priority + 1; i++) printf(" ");
printf("NEXT->%p / LAST->%p\n", p_node->next, p_node->last);
if (p_node->type == INT) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("VALUE(int):%d\n", *(int *)(p_node->value));
}
else if (p_node->type == DOUBLE) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("VALUE(double):%a\n", *(double *)(p_node->value));
}
else if (p_node->type == STRING) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("VALUE(string):%s\n", (char *)(p_node->value));
}
else if (p_node->type == POINTER) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("VALUE(pointer):%s\n", (char *)(p_node->value));
}
else if (p_node->type == LIST) {
for (i = 0; i < priority + 1; i++) printf(" ");
printf("VALUE(List):\n");
printListInfo((List *)p_node->value, priority + 2);
}
for (i = 0; i < priority; i++) printf(" ");
printf("}\n");
}
/**
打印节点的详细信息
@param p_node 指向目标节点的指针
*/
void printNode(Node *p_node) {
int i;
printf("#NODE(location:%p",p_node);
#ifdef id_enable
printf(", id:%s",s_idToASCIIString(p_node->s_id));
#endif
printf("){\n");
printf(" ");
printf("NEXT->%p / LAST->%p\n", p_node->next, p_node->last);
for (i = 0; i < 1; i++) printf(" ");
printf("ifMalloc: ");
if (p_node->value != NULL) {
printf("YES\n");
for (i = 0; i < 1; i++) printf(" ");
printf("Value(type: %d): ", p_node->type);
if (p_node->type == INT) {
printf("%d", *(int *)(p_node->value));
}
else if (p_node->type == DOUBLE) {
printf("%a\n", *(double *)(p_node->value));
}
else if (p_node->type == STRING) {
printf("%s\n", (char *)(p_node->value));
}
else if (p_node->type == POINTER) {
printf("%p\n", (char *)(p_node->value));
}
else if (p_node->type == LIST) {
printList((List *)p_node->value);
}
}
else printf("NO\n");
printf("}\n");
}
/**
遍历链表并自定义打印节点信息
@param p_list 指向目标链表的指针
@param func 指向自定义打印函数的指针，函数接受指向目标节点的指针
*/
void printListForCustom(List *p_list,void (*func)(void *value)){
printf("###LIST (LEN:%llu ",p_list->length);
#ifdef id_enable
if(p_list->s_id != NULL) printf("SID:%s",p_list->s_id->decrypt_str);
#endif
printf(")\n");
listThrough(p_list, __CALLBACK_CALL(printListForCustom), __SEND_ARG("%p", func));
}
__CALLBACK_DEFINE(printListForCustom){
void (*func)(void *) = __ARGS_P(0, void);
printf("NODE (IDX:%llu ",__NOW_INDEX);
printf(")\n");
func(__VALUE(void *));
printf("\n");
return __CRETURN__;
}

109
src/memory/list/list_release.c Normal file
View File

@ -0,0 +1,109 @@
#include <type.h>
#include <list/list.h>
int releaseNode(Node *p_node) {
if (if_safeModeForNode == 1) {
removeByNode(node_list, p_node);
}
if (p_node->value != NULL) {
if (p_node->type != POINTER && p_node->type != HOLE) {
if (p_node->type == LIST) {
releaseList((List *)p_node->value);
}
else {
free(p_node->value);
}
}
p_node->value = NULL;
}
p_node->last = NULL;
p_node->next = NULL;
p_node->type = VOID;
p_node->value = NULL;
#ifdef id_enable
if (p_node->s_id != NULL) freeS_id(p_node->s_id);
#endif
free(p_node);
return 0;
}
int releaseOnlyNode(Node *p_node) {
#ifdef id_enable
if (p_node->s_id != NULL) freeS_id(p_node->s_id);
#endif
p_node->last = NULL;
p_node->next = NULL;
p_node->type = VOID;
p_node->value = NULL;
free(p_node);
return 0;
}
int releaseList(List *p_list) {
Node *p_node, *pl_node;
p_node = p_list->head;
if (if_safeModeForNode == 1) {
Node *tar_list = findByValue(list_list, POINTER, (void *)p_list);//turn pointer in to int to compare.
removeByNode(list_list, tar_list);
}
while (p_node != NULL) {
pl_node = p_node;
p_node = p_node->next;
pl_node->next = NULL;
pl_node->last = NULL;
releaseNode(pl_node);
}
p_list->head = NULL;
p_list->tail = NULL;
p_list->length = 0;
free(p_list);
return 0;
}
int releaseListForSingle(List *p_list) {
releaseList(p_list);
return 0;
}
int releaseNodeForCustom(Node *p_node, int (*func)(void *)){
if (if_safeModeForNode) {
removeByNode(node_list, p_node);
}
if (p_node->value != NULL) {
if (func(p_node->value))
p_node->value = NULL;
}
p_node->last = NULL;
p_node->next = NULL;
p_node->type = VOID;
p_node->value = NULL;
#ifdef id_enable
if (p_node->s_id != NULL) freeS_id(p_node->s_id);
#endif
free(p_node);
return 0;
}
int releaseListForCustom(List *p_list, int (*func)(void *)){
Node *p_node, *pl_node;
p_node = p_list->head;
if (if_safeModeForNode == 1) {
Node *tar_list = findByValue(list_list, POINTER, (void *)p_list);
removeByNode(list_list, tar_list);
}
while (p_node != NULL) {
pl_node = p_node;
p_node = p_node->next;
pl_node->next = NULL;
pl_node->last = NULL;
releaseNodeForCustom(pl_node,func);
}
p_list->head = NULL;
p_list->tail = NULL;
p_list->length = 0;
#ifdef id_enable
if (p_list->s_id != NULL) freeS_id(p_list->s_id);
#endif
free(p_list);
return 0;
}

86
src/memory/list/list_remove.c Normal file
View File

@ -0,0 +1,86 @@
#include <type.h>
#include <list/list.h>
#ifdef id_enable
int removeById(List *p_list, SID *s_id) {
Node *tmp = p_list->head;
if (isListEmpty(p_list))
return -1;
do {
if (simFitS_id(tmp->s_id, s_id)) {
if (tmp != p_list->head) {
tmp->last->next = tmp->next;
}
else {
p_list->head = tmp->next;
}
if (tmp != p_list->tail) {
tmp->next->last = tmp->last;
}
else {
p_list->tail = tmp->last;
}
p_list->length -= 1;
return 1;//found
}
else {
tmp = tmp->next;
}
} while (tmp != NULL);
return 0;//not find
}
#endif
int removeByNode(List *p_list, Node *p_node) {
if (isListEmpty(p_list))
return -1;
if(p_node == p_list->head){
popFromHead(p_list);
return 0;
}
else if(p_node == p_list->tail){
popFromTail(p_list);
return 0;
}
p_node->last->next = p_node->next;
p_node->next->last = p_node->last;
p_list->length -= 1;
return 0;//not find
}
Node *popFromHead(List *p_list) {
if (isListEmpty(p_list))
return NULL;
Node *p_node = p_list->head;
//Node *tmp = p_list->head;
p_list->head->next->last = NULL;
p_list->head = p_list->head->next;
//releaseNode(tmp); not necessary
if (isListEmpty(p_list)) {
p_list->head = NULL;
p_list->tail = NULL;
}
p_list->length -= 1;
return p_node;
}
Node *popFromTail(List *p_list) {
Node *p_node = p_list->tail;
if (isListEmpty(p_list))
return NULL;
else {
//Node *tmp = p_list->tail;
p_list->tail->last->next = NULL;
p_list->tail = p_list->tail->last;
//releaseNode(tmp); not necessary
}
if (isListEmpty(p_list)) {
p_list->head = NULL;
p_list->tail = NULL;
}
p_list->length -= 1;
return p_node;
}

30
src/memory/list/list_replace.c Normal file
View File

@ -0,0 +1,30 @@
#include <type.h>
#include <list/list.h>
int replaceNode(List *p_list, Node *pt_node, Node *p_node){
p_node->next = pt_node->next;
p_node->last = pt_node->last;
if (p_list->head != pt_node) pt_node->last->next = p_node;
else p_list->head = p_node;
if(p_list->tail != pt_node) pt_node->next->last = p_node;
else p_list->tail = p_node;
return 0;
}
int exchangeNode(List *p_list, Node *f_node, Node *s_node){
Node *fl_node = f_node->last, *fn_node = f_node->next;
if(p_list->head != f_node) f_node->last->next = s_node;
else p_list->head = s_node;
if(p_list->tail != f_node) f_node->next->last = s_node;
else p_list->tail = s_node;
if(p_list->head != s_node) s_node->last->next = f_node;
else p_list->head = f_node;
if(p_list->tail != s_node) s_node->next->last = f_node;
else p_list->tail = f_node;
f_node->next = s_node->next;
f_node->last = s_node->last;
s_node->next = fn_node;
s_node->last = fl_node;
return 0;
}

101
src/memory/list/safe_mode.c Normal file
View File

@ -0,0 +1,101 @@
#include <type.h>
#include <list/list.h>
#include <chain/chain_quick.h>
static int if_safeModeForNode = 0;
static List *node_list = NULL;
static List *list_list = NULL;
/*属于安全模式操作内部调用,释放节点而不释放其中的值.*/
static int releaseSingleNodeForsafeModeForNode(List *p_list);
/*属于安全模式操作内部调用,释放链表而不释放其中的值.*/
static int releaseSingleListForsafeModeForNode(List *p_list);
int safeModeForNode(int ifon) {
if (ifon == 1) {
if (node_list == NULL && list_list == NULL) {
node_list = (List *)malloc(sizeof(List));
if(node_list == NULL){
return -1;
}
list_list = (List *)malloc(sizeof(List));
if(list_list == NULL){
return -1;
}
list_list->head = NULL;
list_list->length = 0;
list_list->tail = NULL;
node_list->head = NULL;
node_list->length = 0;
node_list->tail = NULL;
if_safeModeForNode = 1;
}
else {
return -1;
}
}
return ifon;
}
static int releaseSingleListForsafeModeForNode(List *p_list) {
Node *p_node = p_list->head;
List *plv_node = NULL;
while (p_node != NULL) {
plv_node = (List *)p_node->value;
#ifdef id_enable
freeS_id(plv_node->s_id);
#endif
plv_node->head = NULL;
plv_node->length = 0;
plv_node->tail = NULL;
free(plv_node);
p_node = p_node->next;
}
p_list->head = NULL;
p_list->length = 0;
p_list->tail = NULL;
#ifdef id_enable
freeS_id(p_list->s_id);
#endif
free(p_list);
return 0;
}
static int releaseSingleNodeForsafeModeForNode(List *p_list) {
Node *p_node = p_list->head;
Node *pnv_node = NULL;
while (p_node != NULL) {
pnv_node = (Node *)p_node->value;
#ifdef id_enable
freeS_id(pnv_node->s_id);
#endif
pnv_node->last = NULL;
pnv_node->next = NULL;
pnv_node->type = VOID;
pnv_node->value = NULL;
free(pnv_node);
p_node = p_node->next;
}
#ifdef id_enable
free(p_list->s_id);
#endif
p_list->head = NULL;
p_list->length = 0;
p_list->tail = NULL;
free(p_list);
return 0;
}
int releaseAllForNode(void) {
if (if_safeModeForNode == 1) {
if_safeModeForNode = 0;
releaseSingleNodeForsafeModeForNode(node_list);
releaseSingleListForsafeModeForNode(list_list);
}
return 0;
}

76
stack/stack.c
View File

@ -1,76 +0,0 @@
#include "stack.h"
Stack *initStack(void) {
Stack *p_stack = (Stack *)malloc(sizeof(Stack));
if(p_stack == NULL){
showError(pushError(STACK, STANDARD, initInfo("initStack()", "Error in getting the memory of stack.")));
return NULL;
}
p_stack->s_id = getS_id(STACK, 1);
p_stack->length = 0;
p_stack->top = NULL;
return p_stack;
}
SNode *initSNode(void) {
SNode *p_snode = (SNode *)malloc(sizeof(SNode));
if(p_snode == NULL){
showError(pushError(STACK_NODE, STANDARD, initInfo("initSNode()", "Error in getting the memory of snode.")));
return NULL;
}
p_snode->s_id = getS_id(STACK_NODE, 1);
p_snode->if_malloc = 0;
p_snode->next = NULL;
p_snode->value = NULL;
return p_snode;
}
SNode *popStack(Stack *p_stack) {
if (p_stack->top != NULL) {
SNode *p_snode = p_stack->top;
p_stack->top = p_snode->next;
p_snode->next = NULL;
p_stack->length -= 1;
return p_snode;
}
else return NULL;
}
int pushStack(Stack *p_stack, SNode *p_snode) {
SNode *pn_snode = p_stack->top;
p_stack->top = p_snode;
p_snode->next = pn_snode;
p_stack->length -= 1;
return 0;
}
int releaseStack(Stack *p_stack) {
SNode *p_sndoe = p_stack->top;
while (p_sndoe != NULL) {
SNode *pl_snode = p_sndoe;
p_sndoe = p_sndoe->next;
releaseSNode(pl_snode);
}
freeS_id(p_stack->s_id);
p_stack->top = NULL;
p_stack->length = 0;
free(p_stack);
return 0;
}
int releaseSNode(SNode *p_snode) {
freeS_id(p_snode->s_id);
free(p_snode->value);
p_snode->if_malloc = 0;
p_snode->value = NULL;
p_snode->type = VOID;
free(p_snode);
return 0;
}
int initMallocValueForSNode(SNode *p_snode, unsigned int type, void *value) {
p_snode->if_malloc = 1;
p_snode->type = type;
p_snode->value = value;
return 0;
}

16
stack/stack.h
View File

@ -1,16 +0,0 @@
#ifndef STACK_H
#define STACK_H
#include "../type/type.h"
#include "../list/list_expand.h"
Stack *initStack(void);
SNode *initSNode(void);
int initMallocValueForSNode(SNode *p_snode, unsigned int type, void *value);
SNode *popStack(Stack *p_stack);
int pushStack(Stack *p_stack, SNode *p_snode);
int releaseStack(Stack *p_stack);
int releaseSNode(SNode *p_snode);
#endif /* stack_h */

63
stack/stack_expand.c
View File

@ -1,63 +0,0 @@
#include "stack_expand.h"
SNode *snodeWithInt(int temp) {
SNode *p_snode = initSNode();
int *p_temp = (int *)malloc(sizeof(int));
if(p_temp == NULL){
showError(pushError(INT, STANDARD, initInfo("snodeWithInt()", "Error in getting the memory of int.")));
return NULL;
}
*p_temp = temp;
initMallocValueForSNode(p_snode, INT, p_temp);
return p_snode;
}
SNode *snodeWithDouble(double temp) {
SNode *p_snode = initSNode();
double *p_temp = (double *)malloc(sizeof(double));
if(p_temp == NULL){
showError(pushError(DOUBLE, STANDARD, initInfo("snodeWithDouble()", "Error in getting the memory of double.")));
return NULL;
}
*p_temp = temp;
initMallocValueForSNode(p_snode, DOUBLE, p_temp);
return p_snode;
}
SNode *snodeWithString(char *temp) {
SNode *p_snode = initSNode();
char *p_temp = (char *)malloc(sizeof(char)*(strlen(temp) + 1));
if(p_temp == NULL){
showError(pushError(STRING, STANDARD, initInfo("snodeWithString()", "Error in getting the memory of string.")));
return NULL;
}
strcpy(p_temp, temp);
initMallocValueForSNode(p_snode, STRING, p_temp);
return p_snode;
}
SNode *snodeWithPointer(void *temp) {
SNode *p_snode = initSNode();
initMallocValueForSNode(p_snode, POINTER, temp);
return p_snode;
}
int getValueByIntForSNode(SNode *p_snode) {
if (p_snode->type == INT) return *(int *)p_snode->value;
else return -1;
}
double getValueByDoubleForSNode(SNode *p_snode) {
if (p_snode->type == DOUBLE) return *(double *)p_snode->value;
else return -1;
}
char *getValueByStringForSNode(SNode *p_snode) {
if (p_snode->type == STRING) return (char *)p_snode->value;
else return NULL;
}
void *getValueByPointerForSNode(SNode *p_snode) {
if (p_snode->type == POINTER) return (void *)p_snode->value;
else return NULL;
}

16
stack/stack_expand.h
View File

@ -1,16 +0,0 @@
#ifndef STACK_EXPAND_H
#define STACK_EXPAND_H
#include "stack.h"
SNode *snodeWithInt(int);
SNode *snodeWithDouble(double);
SNode *snodeWithString(char *);
SNode *snodeWithPointer(void *);
int getValueByIntForSNode(SNode *);
double getValueByDoubleForSNode(SNode *);
char *getValueByStringForSNode(SNode *);
void *getValueByPointerForSNode(SNode *);
#endif /* stack_expand_h */

100
test.c
View File

@ -1,100 +0,0 @@
#include "test.h"
int list(void) {
List *t_list, *m_list;;
safeModeForNode(1);
t_list = initList();
/*for(int i = 0; i < 9; i++){
Node *t_node = initNode();
int *t_i = (int *)malloc(sizeof(int));
*t_i = i;
initMallocValue(t_node,"int",(void *)t_i);
insertInTail(t_list,t_node);
}*/
/*Node *t_node = initNode();
insertInTail(t_list,t_node);
initMalllocValue(t_node,(void *)"there");*/
for (int i = 0; i < 12; i++) {
insertInHead(t_list, nodeWithInt(i));
insertInTail(t_list, nodeWithInt(i));
}
printListInfo(t_list, 0);
printList(t_list);
m_list = m_findByIntForNode(t_list, 5);
printList(m_list);
printf("\n");
releaseAllForNode();
return 0;
}
int _useTreeThroughDown(TNode *p_tnode, unsigned long long height) {
printTNode(p_tnode,0);
return 0;
}
int tree(void) {
TNode *t_tnode, *cr_tnode, *cl_tnode;
Tree *t_tree;
TNode *gs_tnode;
safeModeForTree(1);
t_tree = initTree();
t_tnode = tnodeWithInt(1);
cr_tnode = tnodeWithInt(3);
cl_tnode = tnodeWithInt(2);
addChildInRight(t_tnode, cl_tnode);
addChildInRight(t_tnode, cr_tnode);
addChildInRight(cl_tnode, tnodeWithInt(4));
gs_tnode = tnodeWithInt(5);
addChildInRight(cl_tnode,gs_tnode);
addChildInRight(cr_tnode, tnodeWithInt(6));
addChildInRight(cr_tnode, tnodeWithInt(7));
addChildInRight(gs_tnode, tnodeWithInt(8));
setRoot(t_tree, t_tnode);
TreeThroughUp(t_tree, _useTreeThroughDown);
//printTNodeWithFamily(t_tnode, 0);
releaseAllForTree();
return 0;
}
int stack(void) {
int i;
Stack *t_stack = initStack();
for (i = 0; i < 10; i++) {
pushStack(t_stack, snodeWithInt(i));
}
for (i = 0; i < 10; i++) {
printf("%d", getValueByIntForSNode(popStack(t_stack)));
}
releaseStack(t_stack);
return 0;
}
int main(int argc, char **argv) {
init_rand();
List *t_list = initList();
for (int i = 0; i < 100; i++) {
insertInHead(t_list, nodeWithInt(i));
}
STD_DATA *p_std = listToSTD(t_list);
D_FILE *p_dfilew = initDataFileForWrite("data.df");
dataFileAddStandardData(p_dfilew, p_std);
dataFileWriteIn(p_dfilew);
releaseDFile(p_dfilew);
D_FILE *p_dfiler = initDataFileForRead("data.df");
dataFileReadOut(p_dfiler);
releaseDFile(p_dfiler);
releaseList(t_list);
return 0;
}

14
test.h
View File

@ -1,14 +0,0 @@
#ifndef TEST_H
#define TEST_H
#include "type/type.h"
#include "list/list_expand.h"
#include "stack/stack_expand.h"
#include "tree/tree_expand.h"
#include "communicate/communicate.h"
int stack(void);
int list(void);
int tree(void);
#endif // TEST_H

60
test/test.c Normal file
View File

@ -0,0 +1,60 @@
#include "test.h"
int list(void) {
List *p_list = initList(1);
for(int i = 0; i < 12; i++){
insertInTail(p_list, nodeWithInt(i, 0));
}
D_FILE *pd_file = initDataFileForWrite("data.db");
STD_DATA *p_std = listToSTD(p_list);
STD_DATA *pa_std = listToSTD(p_list);
dataFileAddStandardData(pd_file, p_std);
dataFileAddStandardData(pd_file, pa_std);
dataFileWriteIn(pd_file);
releaseList(p_list);
releaseDFile(pd_file);
return 0;
}
/*int _useTreeThroughDown(TNode *p_tnode, unsigned long long height) {
printTNode(p_tnode,0);
return 0;
}*/
/*int tree(void) {
TNode *t_tnode, *cr_tnode, *cl_tnode;
Tree *t_tree;
TNode *gs_tnode;
safeModeForTree(1);
t_tree = initTree();
t_tnode = tnodeWithInt(1);
cr_tnode = tnodeWithInt(3);
cl_tnode = tnodeWithInt(2);
addChildInRight(t_tnode, cl_tnode);
addChildInRight(t_tnode, cr_tnode);
addChildInRight(cl_tnode, tnodeWithInt(4));
gs_tnode = tnodeWithInt(5);
addChildInRight(cl_tnode,gs_tnode);
addChildInRight(cr_tnode, tnodeWithInt(6));
addChildInRight(cr_tnode, tnodeWithInt(7));
addChildInRight(gs_tnode, tnodeWithInt(8));
setRoot(t_tree, t_tnode);
TreeThroughUp(t_tree, _useTreeThroughDown);
//printTNodeWithFamily(t_tnode, 0);
releaseAllForTree();
return 0;
}*/
int main(int argc, char **argv) {
while(1){
List *p_list = initList(0);
for(int i = 0; i < 65535; i++){
insertInTail(p_list, nodeWithInt(i, 1));
}
releaseList(p_list);
}
return 0;
}

16
test/test.h Normal file
View File

@ -0,0 +1,16 @@
#ifndef TEST_H
#define TEST_H
#include <sys/time.h>
#include <type.h>
#include <id/id.h>
#include <chain/chain.h>
#include <event/event.h>
#include <communicate/communicate_file.h>
int stack(void);
int list(void);
int tree(void);
#endif // TEST_H

178
type/type.h
View File

@ -1,178 +0,0 @@
#ifndef type_h
#define type_h
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
#include <unistd.h>
#include <inttypes.h>
/*
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
*/
#define VOID 0
#define INT 1
#define DOUBLE 2
#define STRING 3
#define POINTER 4
#define LIST 5
#define STACK 6
#define TREE 7
#define LIST_NODE 8
#define TREE_NODE 9
#define STACK_NODE 10
#define T_SID 11
#define UINT 12
#define STANDARD_DATA 13
#define DATA_FILE 14
#define MESSAGE 15
#define DEEPC 1
#define DEEPB 2
#define DEEPA 3
#define TYPE_LEN 5
#define DEEPC_LEN 4
#define DEEPB_LEN 8
#define DEEPA_LEN 32
#define DATA_BIT 5
#define DEEP_LEN 25
#define DEEPER_LEN 65
#define DEEPEST_LEN 225
#define FILE_TSET_LEN 18
#define HEAD_TEST_LEN 9
#define HIGH 0x3
#define STANDARD 0x2
#define LOW 0x1
typedef struct s_id{
unsigned int type;
unsigned int *value;//4
unsigned int *value_deeper;//8
unsigned int *value_deepest;//32
unsigned int deep;
}SID;
typedef struct Node{
SID *s_id;
void *value;
_Bool if_malloc;
_Bool if_sid;
unsigned int type;
struct Node *next;
struct Node *last;
} Node;
typedef struct List{
SID *s_id;
Node *head;
Node *tail;
_Bool if_sid;
unsigned long long length;
} List;
typedef struct Info{
char head[64];
char body[256];
}Info;
typedef struct Error{
unsigned int type;
int priority;
Info info;
time_t time;
}Error;
typedef struct Notice{
unsigned int type;
Info info;
time_t time;
}Notice;
typedef struct Log{
FILE *fp;
int if_enable;
unsigned long int id;
}Log;
typedef struct stack_node{
SID *s_id;
_Bool if_malloc;
_Bool if_sid;
unsigned int type;
void *value;
struct stack_node *next;
} SNode;
typedef struct stack{
SID *s_id;
unsigned long long length;
SNode *top;
_Bool if_sid;
} Stack;
typedef struct tree_node
{
SID *s_id;
List *home;
struct tree_node *father;
Node *room;
unsigned long long child_num;
unsigned int type;
void *value;
_Bool if_malloc;
_Bool if_sid;
}TNode;
typedef struct tree
{
SID *s_id;
_Bool if_sid;
TNode *root;
}Tree;
typedef struct file_head{
char head_test[18];
unsigned long long data_num;
}F_HEAD;
typedef struct data_file{
FILE *fp;
F_HEAD *pf_head;
List *pf_stdlst;
}D_FILE;
typedef struct standard_data_blocks{
unsigned int type;
char *sid;
_Bool if_data;
unsigned int blocks_num;
char *buff;
}STD_BLOCKS;
typedef struct standard_data_connection{
char *f_sid;
char *s_sid;
}STD_CTN;
typedef struct standard_data_head{
unsigned long long data_blk_num;
unsigned long long data_ctn_num;
}STD_HEAD;
typedef struct standard_data{
SID *s_id;
unsigned int type;
_Bool lock;
List *pd_blocklst;
List *pd_ctnlst;
}STD_DATA;
#endif /* type_h */