diff --git a/.gitignore b/.gitignore index 9db3cb7..ba9c358 100644 --- a/.gitignore +++ b/.gitignore @@ -7,3 +7,4 @@ /ZE-Standard-Libraries /ZE-Standard-Libraries.sln /.vs +*.xcodeproj diff --git a/README.md b/README.md index 720dd88..947b1f5 100644 --- a/README.md +++ b/README.md @@ -1,22 +1,62 @@ # ZE-Standard-Libraries -### --我们需要更快更方便的基于C语言的软件工程 +## 概要说明文档 +### 梗概 +该库提供了C语言环境下的内存管理、高级数据结构的使用、网络传输、文件储存、子程序管理、回调机制、错误管理的一套完整的解决方案，用于加快基于C语言的软件的开发进程，并为基于网络的分布式软件系统的开发提供了新的且简便的思路和方式。 -## 简介 -该函数库用于提供一些基础的数据结构的操作、运算、储存的函数，旨在加快基于C语言的软件工程的构建速度。运用该函数库提供的操作函数，可以省去工程中遇到的大量繁复的的高级数据结构的建构操作以及内存储存管理操作。 +### 详细梗概 +该库以模块化的方式来组织，主要模块包括内存管理模块、高级数据结构模块、文件储存模块、网络传输模块、子程序管理模块、回调机制实现模块、错误管理模块、在主要模块还会被分为几个小模块。模块之间有对应的依赖关系。 -## 特性 -- 函数库提供高级数据结构实体以及配套的多样的操作函数，开发者得以主要注意力集中在主要的功能实现上。 -- 函数库提供相关函数，可以对高级数据结构快速进行基于文件的储存和基于网络的传输等工作。 -- 函数库中构建的高级数据结构有唯一的识别码，很方便可以进行查找，替换操作。 -- 函数库还提供工程的错误管理功能，使得开发者可以及时定位错误，或者让程序自动储存错误或者警告消息至文件。 +#### 内存管理模块 +该库以内存管理模块为基础，通过两种内存管理结构，对于储存在内存中的数据进行组织、操作。该模块的子模块主要分为链式内存管理，块式内存管理。链式内存管理对于内存中离散的数据进行组织和管理；块式内存管理对于内存中的整块数据进行管理。这两个子模块会分别实现链式和块式的内存管理的管理结构及相关操作。该模块的第三个子模块是内存泄露管理模块，该模块对于已经分配的内存空间进行全面地监控，及时地完全地释放不需要的内存空间。内存泄漏管理对于长期运行的软件系统来说至关重要。链式和块式内存管理具体要实现的基本操作函数有：初始化类函数、赋值类函数、复制类函数、插入类函数、删除类函数、查询类函数、释放类函数。 -## 分类 -该函数库主要提供以下基本数据结构操作、运算和储存函数： -- 链表 list -- 词典 dict -- 树 tree -- 图 graph -- 栈 stack -- 信息 message -## 代码风格 -本函数库秉承着可视性、稳定性与扩展性优先的原则，将在基本框架不变的情况下不断进行的优化。 +#### 高级数据结构模块 +高级数据结构模块是对于内存管理模块的一次封装和抽象，它依赖于内存管理模块所提供的链式内存和块式内存管理结构和相关操作方法，运用相关方法来实现高级数据结构及其基本操作和算法。这些高级数据结构包括：目录树、二叉树、堆、栈、队列、有向图、无向图、链表、字典、字符串。通过高级数据模块，使得库能够更加快速地对于实际问题进行建模，更加有效率的解决实际问题。高级数据结构的子模块包含：基本操作子模块和算法子模块。前者完成了对于高级数据结构的基本操作：初始化数据结构、插入数据、删除数据、更新数据；后者将提供高级数据结构常用的高级算法：查找算法、排序算法、优化算法、转换算法。 + +#### 文件储存模块 +文件储存模块依赖内存管理模块、回调机制模块和高级数据结构模块，该模块实现将内存数据管理结构与高级数据结构的信息及其中储存的数据储存到到文件中。该模块中定义的文件管理结构分为两类：关系型文件管理结构，非关系型文件管理结构。这两个结构的区别是是否记录所储存信息之间的关系。前者将有专门的数据结构来储存所储存的数据之间的联系，后者按照块的形式来叠放数据。模块内部将专门实现这两个数据管理结构写入文件、从文件读出的操作方法。并且，将实现各个高级数据结构与文件管理结构之间的转化。这样，能够直接将高级数据结构转化为文件管理结构，从而储存到文件中。或者，将文件中的数据读出，独处的数据在内存中的表现形式为对应的文件管理结构，而后再将文件管理结构转化为对应的高级数据结构。模块将实现对于这两种结构的操作方法：初始化，转化，写入，读取，释放。 + +#### 网络传输模块 +网路传输模块依赖内存管理模块、回调机制模块、高级数据结构模块和文件储存模块，此模块主要提供将高级数据结构转化为文件信息管理结构，文件管理结构转化为网络信息块管理结构，将信息分块进行传输。对于简单的字符信息，该模块也提供网络消息管理结构，通过该结构能够在一台计算机和另外一台计算机之间传递字符串消息。模块将实现对于这两种结构的操作方法：初始化、转化、赋值、传输、释放。 + +#### 回调机制模块 +回调机制模块依赖内存管理模块和高级数据结构，该模块实现一种方法调用机制，将实现回调函数的注册、传参、返回值传参的标准化宏与相关支撑函数。高级模块中的相关方法，通过使用以上的宏和函数，中能够以更加标准的、更加优雅的方法来实现相关功能。这也使得，事件机制的运用能够更加便捷有效，从而跨计算机之间的函数调用与传参成为可能。 + +#### 错误管理模块 +错误管理模块依赖内存管理模块和回调机制模块，该模块提供程序输出信息的分类：严重错误、错误、警告、提示。该模块将实现错误的处理函数的注册，在严重错误或者错误出现的情况下，根据开发者通过该模块的错误处理函数的注册信息，调用相应的错误处理函数并提供关键信息来辅助错误修复。该模块将提供相应的管理结构与方法来建立程序中的相关信息的日志文件，并且提供更加方便的方法来管理与更新相应的日志文件，实现程序输出信息的更加规范的清晰地产生与显示。 + +#### 子程序管理模块 +该模块依赖以上的所有模块，该模块也为该库的最高级的部分。该模块提供子程序的注册，调用，传输以及依赖关系的管理。子程序是一个独立的软件系统的所有功能的一部分，具有相对的独立性。一个程序的子程序可以储存在相同的计算机上，也可以储存在不同的计算机上，子程序之间不论储存的地方在何处，只要能够通过内存或者网络的方式访问到，则可以进行传参和调用。位置信息的记录与子程序的调用由相应的管理结构与操作方法来实现。对于一个要由多个子程序之间协调合作来完成的复杂任务的情景，该模块将通过子程序依赖关系管理结构及其方法来进行相应的系统性的有序调用。对于一个大任务中两个不互为依赖的过程，在允许的情况下模块将进行并行调用。通过子程序的传输方法，子程序能够更加方便地通过网络在计算机之间进行转移。总之，通过该模块，实现了一个独立的软件系统在不同的计算机中储存并且运行在不同计算机的内存中却可以虚拟出在同一计算机中储存运行的效果，能够并行执行软件系统中的某些功能，也可以让软件系统的设计者随时根据具体情况来转移子程序。 + +### 通信模块 +由于实际原因，网络传输模块与文件储存模块合为通信模块。 + +### 目录结构管理方式 +- src：源文件 + - memory：内存管理模块 + - list 链式内存管理 + - block 块式内存管理 + - communicate：通信模块 + - datastruct：高级数据结构 + - event：回调机制模块 + - error：错误管理模块 + - subfunc：子程序管理模块 +- include：头文件 + - memory：内存管理模块 + - file：文件储存模块 + - network：网络传输模块 + - chain：链表 + - event：回调机制模块 + - list 链式内存管理 + - tree 目录树 + - error：错误管理模块 + - subfunc：子程序管理模块 + - type.h：全局信息头文件 +- document：文档 + - info：工程说明及计划文档 + - raw design：模块概要设计文档 + - design：模块详细设计文档 + - test：测试方案及数据文档 +- test：不同平台下的测试程序文件 + - unix + - windows +- bin：编译后的二进制文件 diff --git a/ZE-Standard-Libraries.xcodeproj/project.pbxproj b/ZE-Standard-Libraries.xcodeproj/project.pbxproj deleted file mode 100644 index a485e40..0000000 --- a/ZE-Standard-Libraries.xcodeproj/project.pbxproj +++ /dev/null @@ -1,393 +0,0 @@ -// !$*UTF8*$! -{ - archiveVersion = 1; - classes = { - }; - objectVersion = 50; - objects = { - -/* Begin PBXBuildFile section */ - 9233C310212292B000FB2485 /* md5.c in Sources */ = {isa = PBXBuildFile; fileRef = 9233C30F212292B000FB2485 /* md5.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 */; }; - 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 */ - 9233C30E212292B000FB2485 /* md5.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = md5.h; path = id/md5.h; sourceTree = ""; }; - 9233C30F212292B000FB2485 /* md5.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; name = md5.c; path = id/md5.c; sourceTree = ""; }; - 9246994F20CD000300B4E894 /* list.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = list.c; sourceTree = ""; }; - 9246995020CD000300B4E894 /* list_expand.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = list_expand.h; sourceTree = ""; }; - 9246995120CD000300B4E894 /* list.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = list.h; sourceTree = ""; }; - 9246995820CE52A700B4E894 /* stack.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = stack.h; sourceTree = ""; }; - 9246995920CE52A700B4E894 /* stack.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = stack.c; sourceTree = ""; }; - 9246995B20CE5C8900B4E894 /* stack_expand.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = stack_expand.h; sourceTree = ""; }; - 9246995D20CE655900B4E894 /* tree.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = tree.h; sourceTree = ""; }; - 9246995E20CE655900B4E894 /* tree.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = tree.c; sourceTree = ""; }; - 9269D4E7210F1B3D00161557 /* stack_expand.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = stack_expand.c; sourceTree = ""; }; - 9269D4E9210F1B4B00161557 /* list_expand.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = list_expand.c; sourceTree = ""; }; - 9269D4EB210F1B5E00161557 /* test.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = test.c; sourceTree = ""; }; - 9269D4EC210F1B5E00161557 /* test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = test.h; sourceTree = ""; }; - 9269D4F0210F1B8000161557 /* type.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = type.h; path = type/type.h; sourceTree = ""; }; - 9269D4F2210F1BB000161557 /* id.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = id.c; path = id/id.c; sourceTree = ""; }; - 9269D4F3210F1BB000161557 /* id.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = id.h; path = id/id.h; sourceTree = ""; }; - 9269D4F7210F1D0B00161557 /* tree_expand.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = tree_expand.c; sourceTree = ""; }; - 9269D4F9210F1D0F00161557 /* tree_expand.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = tree_expand.h; sourceTree = ""; }; - 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 = ""; }; - 9286EB7B211400D000752977 /* error.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = error.h; path = error/error.h; sourceTree = ""; }; - 9286EB7D2114022A00752977 /* communicate.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; lineEnding = 0; name = communicate.c; path = communicate/communicate.c; sourceTree = ""; }; - 9286EB7F2114022F00752977 /* communicate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = communicate.h; path = communicate/communicate.h; sourceTree = ""; }; -/* 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 = ( - 9246995120CD000300B4E894 /* list.h */, - 9246994F20CD000300B4E894 /* list.c */, - 9246995020CD000300B4E894 /* list_expand.h */, - 9269D4E9210F1B4B00161557 /* list_expand.c */, - ); - path = list; - sourceTree = ""; - }; - 9246995720CE507900B4E894 /* stack */ = { - isa = PBXGroup; - children = ( - 9246995820CE52A700B4E894 /* stack.h */, - 9246995920CE52A700B4E894 /* stack.c */, - 9269D4E7210F1B3D00161557 /* stack_expand.c */, - 9246995B20CE5C8900B4E894 /* stack_expand.h */, - ); - path = stack; - sourceTree = ""; - }; - 9246995C20CE654600B4E894 /* tree */ = { - isa = PBXGroup; - children = ( - 9246995D20CE655900B4E894 /* tree.h */, - 9246995E20CE655900B4E894 /* tree.c */, - 9269D4F9210F1D0F00161557 /* tree_expand.h */, - 9269D4F7210F1D0B00161557 /* tree_expand.c */, - ); - path = tree; - sourceTree = ""; - }; - 9269D4EF210F1B7800161557 /* type */ = { - isa = PBXGroup; - children = ( - 9269D4F0210F1B8000161557 /* type.h */, - ); - name = type; - sourceTree = ""; - }; - 9269D4F1210F1B9E00161557 /* id */ = { - isa = PBXGroup; - children = ( - 9269D4F3210F1BB000161557 /* id.h */, - 9269D4F2210F1BB000161557 /* id.c */, - 9233C30E212292B000FB2485 /* md5.h */, - 9233C30F212292B000FB2485 /* md5.c */, - ); - name = id; - sourceTree = ""; - }; - 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 = ""; - }; - 927993BE20CB87D6008CE3A9 /* Products */ = { - isa = PBXGroup; - children = ( - 927993BD20CB87D6008CE3A9 /* ZE-Standard-Libraries */, - ); - name = Products; - sourceTree = ""; - }; - 9286EB78211400BD00752977 /* error */ = { - isa = PBXGroup; - children = ( - 9286EB79211400C900752977 /* error.c */, - 9286EB7B211400D000752977 /* error.h */, - ); - name = error; - sourceTree = ""; - }; - 9286EB7C2114021E00752977 /* communicate */ = { - isa = PBXGroup; - children = ( - 9286EB7F2114022F00752977 /* communicate.h */, - 9286EB7D2114022A00752977 /* communicate.c */, - ); - name = communicate; - sourceTree = ""; - }; - 92A15CFC211442C700826FB8 /* graph */ = { - isa = PBXGroup; - children = ( - ); - name = graph; - sourceTree = ""; - }; -/* 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 = ( - 9233C310212292B000FB2485 /* md5.c in Sources */, - 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 */, - 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 */; -} diff --git a/ZE-Standard-Libraries.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/ZE-Standard-Libraries.xcodeproj/project.xcworkspace/contents.xcworkspacedata deleted file mode 100644 index 919434a..0000000 --- a/ZE-Standard-Libraries.xcodeproj/project.xcworkspace/contents.xcworkspacedata +++ /dev/null @@ -1,7 +0,0 @@ - - - - - diff --git a/ZE-Standard-Libraries.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/ZE-Standard-Libraries.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist deleted file mode 100644 index 18d9810..0000000 --- a/ZE-Standard-Libraries.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist +++ /dev/null @@ -1,8 +0,0 @@ - - - - - IDEDidComputeMac32BitWarning - - - diff --git a/ZE-Standard-Libraries.xcodeproj/project.xcworkspace/xcuserdata/huyibing.xcuserdatad/xcdebugger/Expressions.xcexplist b/ZE-Standard-Libraries.xcodeproj/project.xcworkspace/xcuserdata/huyibing.xcuserdatad/xcdebugger/Expressions.xcexplist deleted file mode 100644 index 52a1b4f..0000000 --- a/ZE-Standard-Libraries.xcodeproj/project.xcworkspace/xcuserdata/huyibing.xcuserdatad/xcdebugger/Expressions.xcexplist +++ /dev/null @@ -1,197 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist b/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist deleted file mode 100644 index 9781d19..0000000 --- a/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist +++ /dev/null @@ -1,1608 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcschemes/xcschememanagement.plist b/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcschemes/xcschememanagement.plist deleted file mode 100644 index 2045221..0000000 --- a/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcschemes/xcschememanagement.plist +++ /dev/null @@ -1,14 +0,0 @@ - - - - - SchemeUserState - - ZE-Standard-Libraries.xcscheme - - orderHint - 0 - - - - diff --git a/communicate/communicate.c b/communicate/communicate.c deleted file mode 100644 index 72a05ce..0000000 --- a/communicate/communicate.c +++ /dev/null @@ -1,426 +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)); - 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; - 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); - p_stdc->location = 0; - return p_stdc; -} - -STD_DATA *initStandardData(unsigned int 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; -} - -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,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; -} - -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; -} - -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 = 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("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; -} - -__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(unsigned int), 1, fp); - unsigned long long std_size = calStandardData(p_std); - p_std->size = std_size; - fwrite(&std_size, sizeof(unsigned long long), 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(unsigned long long), 1, fp); - fwrite(&p_std->pd_blocklst->length, sizeof(unsigned long long), 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__; -} - -__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__; -} - -__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(unsigned int), 1, fp); - fwrite(&blocks_num, sizeof(unsigned long), 1, fp); - fwrite(p_stdb->buff, sizeof(char), p_stdb->blocks_num, fp); - return __CRETURN__; -} - -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; - 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){ - if(!readDataFileInfo(p_dfile)){ - listThrough(p_dfile->pf_stdlst, __CALLBACK_CALL(dataFileReadOut), __SEND_ARG("%p", p_dfile)); - - } - showError(pushError(DATA_FILE, STANDARD, initInfo("dataFileReadOut()", "Datafile not complete."))); - return -1; -} - -__CALLBACK_DEFINE(dataFileReadOut){ - D_FILE *p_dfile = __ARGS_P(0, D_FILE); - readStandardData(p_dfile, __VALUE(STD_DATA *)); - return __CRETURN__; -} - -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->buff); - free(p_stdb->sid); - free(p_stdb); - return 0; -} - -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; -} - -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(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__; -} - -unsigned long long calStandardData(STD_DATA *p_std){ - List *rtn_lst = NULL; - unsigned long long 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, unsigned long long); - 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, unsigned long long); - releaseList(rtn_lst); - } - return size; -} - -__CALLBACK_DEFINE(calStandardDataCTN){ - unsigned long long size = __ARGS(0, unsigned long long); - size += 64; - //unsigned long long temp = __NOW_INDEX; - if(__NOW_INDEX == __LIST_LEN - 1){ - __RETURN("%ull", size); - } - return __CRETURN__; -} - -__CALLBACK_DEFINE(calStandardDataBLK){ - unsigned long long size = __ARGS(0, unsigned long long); - STD_BLOCKS *p_stdb = __VALUE(STD_BLOCKS *); - if(p_stdb->sid != NULL) size += SID_LEN + sizeof(int); - else size += sizeof(int); - size += p_stdb->blocks_num + sizeof(unsigned int) + sizeof(unsigned long); - //unsigned long long temp = __NOW_INDEX; - if(__NOW_INDEX == __LIST_LEN - 1){ - return __RETURN("%ull", size); - } - return __CRETURN__; -} - -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; -}*/ - -int readDataFileInfo(D_FILE *p_dfile){ - if(checkIfDataFile(p_dfile)){ - unsigned long long std_num = 0,std_size; - unsigned int std_type = VOID; - char info_begin[INFO_TEST_LEN], s_id[SID_LEN]; - unsigned long long location = 0; - fread(&std_num, sizeof(unsigned long long), 1, p_dfile->fp); - fread(info_begin, sizeof(char),INFO_TEST_LEN,p_dfile->fp); - location += INFO_TEST_LEN + sizeof(unsigned long long) + 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(unsigned int), 1, p_dfile->fp); - fread(&std_size, sizeof(unsigned long long), 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; -} - -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)){ - unsigned long long ctn_num = 0, blk_num = 0; - fread(&ctn_num, sizeof(unsigned long long), 1, p_dfile->fp); - fread(&blk_num, sizeof(unsigned long long), 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; - unsigned int type = VOID; - unsigned long blk_size = 0; - char t_sid[SID_LEN]; - fread(&if_sid, sizeof(int), 1, p_dfile->fp); - if(if_sid){ - fread(t_sid, sizeof(char), SID_LEN, p_dfile->fp); - } - fread(&type, sizeof(int), 1, p_dfile->fp); - fread(&blk_size, sizeof(unsigned long), 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 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; -} - -void printStandardData(void *value){ - STD_DATA *p_std = (STD_DATA *)value; - printf("SID:%s\n",p_std->s_id->decrypt_str); - printf("Loaction:%llu\n",p_std->location); - printf("Size:%llu\n",p_std->size); - printf("Ctn number:%llu\n",p_std->pd_ctnlst->length); - printf("Blk number:%llu\n",p_std->pd_blocklst->length); -} - -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; -} - -__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__; -} diff --git a/communicate/communicate.h b/communicate/communicate.h deleted file mode 100644 index 991bf3b..0000000 --- a/communicate/communicate.h +++ /dev/null @@ -1,59 +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, SID *s_id); - -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); -__CALLBACK_STATE(dataFileReadOut); - -int releaseSTDBlocks(STD_BLOCKS *p_stdb); -int releaseStandardData(STD_DATA *p_std); -int releaseSTDConnection(STD_CTN *p_stdc); -int releaseDFile(D_FILE *p_file); -unsigned long long calStandardData(STD_DATA *p_std); -__CALLBACK_STATE(calStandardDataCTN); -__CALLBACK_STATE(calStandardDataBLK); - -__CALLBACK_STATE(StandardDataInfoWrite); -__CALLBACK_STATE(StandardDataWrite); -__CALLBACK_STATE(StandardDConnectionWrite); -__CALLBACK_STATE(StandardDBlockWrite); - -STD_DATA *listToSTD(List *); -List *standardDataToList(STD_DATA *); -__CALLBACK_STATE(StandardDataToList); - -int readDataFileInfo(D_FILE *p_dfile); -int readStandardData(D_FILE *p_dfile, STD_DATA *p_std); -int readSTDBlocks(STD_BLOCKS *p_stdb); -int checkIfDataFile(D_FILE *p_dfile); -int readStandardDataBySid(D_FILE *p_dfile, SID *p_sid); -__CALLBACK_STATE(findStandardDataBySid); - -MSG *createMessage(char *title, void *data, unsigned long data_size); -int sendMessageIPv4(MSG *p_msg, char *ip, unsigned int port); -void printStandardData(void *value); -//STD_DATA *stackToSTD(Stack *); -//STD_DATA *treeToSTD(Tree *); - -#endif /* communicate_h */ diff --git a/id/id.h b/id/id.h deleted file mode 100644 index fdda689..0000000 --- a/id/id.h +++ /dev/null @@ -1,34 +0,0 @@ -#ifndef id_h -#define id_h - -#include -#include -#include -#include -#include "../type/type.h" -#include "md5.h" - -void init_rand(void); -unsigned long long getId(void); - -SID *getS_id(unsigned int type, unsigned int deep_level); - -int fitS_id(SID * const fs_id, SID * const ss_id); -int simFitS_id(SID * fs_id, SID * ss_id); - -char *s_idToASCIIString(SID * const s_id); -void setSidToASCIIString(SID * const s_id); -SID *asciiRawStringToS_id(char * const string); -SID *setS_idWithString(char *); - -void s_idToMD5(SID *s_id); -char hexToChar(unsigned int); -SID *copyS_id(SID *f_sid); -void getRawS_id(SID *s_id, unsigned int type, unsigned int deep_level); - -SID *initS_id(unsigned int deep_level); -int freeSidRaw(SID *s_id); -int freeS_id(SID *s_id); - -static _Bool if_rand; -#endif /* id_h */ diff --git a/include/block/block.h b/include/block/block.h new file mode 100644 index 0000000..21e11a9 --- /dev/null +++ b/include/block/block.h @@ -0,0 +1,7 @@ +#ifndef block_h +#define block_h + +#include + + +#endif /* block_h */ diff --git a/include/block/block_expand.h b/include/block/block_expand.h new file mode 100644 index 0000000..c1140a4 --- /dev/null +++ b/include/block/block_expand.h @@ -0,0 +1,5 @@ +#ifndef block_expand_h +#define block_expand_h + + +#endif /* block_expand_h */ diff --git a/include/block/block_print.h b/include/block/block_print.h new file mode 100644 index 0000000..f92e524 --- /dev/null +++ b/include/block/block_print.h @@ -0,0 +1,5 @@ +#ifndef block_print_h +#define block_print_h + + +#endif /* block_print_h */ diff --git a/include/block/block_type.h b/include/block/block_type.h new file mode 100644 index 0000000..8b47b61 --- /dev/null +++ b/include/block/block_type.h @@ -0,0 +1,23 @@ +#ifndef block_type_h +#define block_type_h + +#include +#ifdef id_enable +#include +#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 */ diff --git a/include/chain/chain.h b/include/chain/chain.h new file mode 100644 index 0000000..2e26ba0 --- /dev/null +++ b/include/chain/chain.h @@ -0,0 +1,433 @@ +#ifndef chain_h +#define chain_h + +#include +#include + +/************************************************ + *节点的快速初始化: 为新节点分配内存空间, + * 并使用输入值对其进行初始化. + ************************************************/ + +/* + *为新节点获取内存空间, 并使用整型值初始化新节点 + *参数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 *); + + + + +/************************************************ + *节点快速初始化相关宏,提供函数名较为简单的调用方式 + ************************************************/ + +/**** + *不带ID模块相关宏 + */ + +/*直接获取一个以整型值初始化的节点不带ID的缩略*/ +#define lni(cn) nodeWithInt(cn,0) + +/*直接获取一个以无符号整型值初始化的不带ID节点的缩略*/ +#define lnu(cn) nodeWithUInt(cn,0) + +/*直接获取一个以无符号长整形值初始化的节点的缩略*/ +#define lnull(cn) nodeWithULLInt(cn,0) + +/*直接获取一个以浮点值初始化的不带ID节点的缩略*/ +#define lnd(cn) nodeWithDouble(cn,0) + +/*直接获取一个以字符串值初始化的不带ID节点的缩略*/ +#define lns(cn) nodeWithString(cn,0) + +/*直接获取一个以指针值初始化的不带ID节点的缩略*/ +#define lnp(cn) nodeWithPointer(cn,0) + +/**** + *带ID模块的相关宏 + */ + +/*直接获取一个以整型值初始化的带ID节点的缩略*/ +#define lsni(cn) nodeWithInt(cn,1) + +/*直接获取一个以浮点值初始化的带ID节点的缩略*/ +#define lsnd(cn) nodeWithDouble(cn,1) + +/*直接获取一个以字符串值初始化的带ID节点的缩略*/ +#define lsns(cn) nodeWithString(cn,1) + +/*直接获取一个以指针值初始化的节点的缩略*/ +#define lsnp(cn) nodeWithPointer(cn,1) + + + + +/************************************************ + *链表快速插入相关宏 + ************************************************/ + +/**** + *尾部相关 + */ + +/*在链表尾部直接加入一个已经用整型值初始化的不带ID的节点*/ +#define lisrti(chain, cn) insertInTail(chain, lni(cn)); + +/*在链表尾部直接加入一个已经用浮点值初始化的不带ID的节点*/ +#define lisrtd(chain, cn) insertInTail(chain, lnd(cn)); + +/*在链表尾部直接加入一个已经用无符号整型值初始化的不带ID的节点*/ +#define lisrtu(chain, cn) insertInTail(chain, lnu(cn)); + +/*在链表尾部直接加入一个已经用无符号长整型值初始化的不带ID的节点*/ +#define lisrtull(chain, cn) insertInTail(chain, lnull(cn)); + +/*在链表尾部直接加入一个已经用指针值初始化的不带ID的节点*/ +#define lisrtp(chain, cn) insertInTail(chain, lnp(cn)); + +/*在链表尾部直接加入一个已经用字符串值初始化的不带ID的节点*/ +#define lisrts(chain, cn) insertInTail(chain, lns(cn)); + +/**** + *头部相关 + */ + +/*在链表头部直接加入一个已经用整型值初始化的不带ID的节点*/ +#define lisrhi(chain, cn) insertInHead(chain, lni(cn)); + +/*在链表头部直接加入一个已经用浮点值初始化的不带ID的节点*/ +#define lisrhd(chain, cn) insertInHead(chain, lnd(cn)); + +/*在链表头部直接加入一个已经用无符号整型值初始化的不带ID的节点*/ +#define lisrhu(chain, cn) insertInHead(chain, lnu(cn)); + +/*在链表头部直接加入一个已经用无符号长整型值初始化的不带ID的节点*/ +#define lisrhull(chain, cn) insertInHead(chain, lnull(cn)); + +/*在链表头部直接加入一个已经用指针值初始化的不带ID的节点*/ +#define lisrhp(chain, cn) insertInHead(chain, lnp(cn)); + +/*在链表头部直接加入一个已经用字符串值初始化的不带ID的节点*/ +#define lisrhs(chain, cn) insertInHead(chain, lns(cn)); + + + + +/************************************************ + *节点快速获得储存值相关宏 + ************************************************/ + +/*快速获得指针类型的节点所储存的值*/ +#define lidxp(chain, cn) getByPointerForNode(findByIndexForNode(chain, cn)) + +/*快速获得整型类型的节点所储存的值*/ +#define lidxi(chain, cn) getByIntForNode(findByIndexForNode(chain, cn)) + +/*快速获得浮点类型的节点所储存的值*/ +#define lidxd(chain, cn) getByDoubleForNode(findByIndexForNode(chain, cn)) + +/*快速获得字符串类型的节点所储存的值*/ +#define lidxs(chain, cn) getByStringForNode(findByIndexForNode(chain, cn)) + +/*快速获得无符号长整型类型的节点所储存的值*/ +#define lupdull(chain,cn,value) updateValueWithULLIntForNode(findByIndexForNode(chain, cn),value) + + + + +/************************************************ + *其他快速操作相关宏 + ************************************************/ + +/*通过节点的序号直接得到它的值*/ +#define lidxvle(chain,cn) (findByIndexForNode(chain, cn)->value) + +/*通过节点序号直接移除节点*/ +#define lrmvidx(chain,cn) removeByNode(chain, findByIndexForNode(chain, cn) + +/*从列表头移除节点的缩略*/ +#define lpoph(chain) popFromHead(chain) + +/*从列表尾移除节点的缩略*/ +#define lpopt(chain) popFromTail(chain) + +/*通过节点的ID直接获得节点的值*/ +#define lfndsid(chain,sid) (findByIdForNode(chain,sid)->value) + +/*创建一个不带ID的链表的缩略*/ +#define lstns() initList(0); + +/*创建一个带有ID的链表缩略*/ +#define lstn() initList(1); + +#endif /* chain_h */ diff --git a/include/chain/chain_print.h b/include/chain/chain_print.h new file mode 100644 index 0000000..d5e5bc7 --- /dev/null +++ b/include/chain/chain_print.h @@ -0,0 +1,42 @@ +#ifndef chain_print_h +#define chain_print_h + +#include +#include + +/************************************************ + *链表或节点的输出: 格式化输出链表或节点的属性 + ************************************************/ + +/* + *输出链表及其中节点的相关信息 + *参数: 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 /* chain_h */ diff --git a/include/chain/chain_type.h b/include/chain/chain_type.h new file mode 100644 index 0000000..a826571 --- /dev/null +++ b/include/chain/chain_type.h @@ -0,0 +1,16 @@ +#ifndef chain_type_h +#define chain_type_h + +#include + +/** + *节点的管理及操作的结构 + */ +typedef struct Node CNode; + +/** + *链表的管理及操作的结构 + */ +typedef struct List Chain; + +#endif /* chain_type_h */ diff --git a/include/communicate/communicate.h b/include/communicate/communicate.h new file mode 100644 index 0000000..ab7be74 --- /dev/null +++ b/include/communicate/communicate.h @@ -0,0 +1,29 @@ +#ifndef communicate_h +#define communicate_h + +#include + + + + + +/************************************************ + 消息的操作: 消息的操作相关函数 + ************************************************/ + +/* + *创建消息 + *返回: 处理成功则返回指向相关结构体所在内存空间的指针,不成功则返回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 */ diff --git a/include/communicate/communicate_file.h b/include/communicate/communicate_file.h new file mode 100644 index 0000000..0646f59 --- /dev/null +++ b/include/communicate/communicate_file.h @@ -0,0 +1,269 @@ +#ifndef communicate_file_h +#define communicate_file_h + +#include + +/************************************************ + 相关结构体初始化: 初始化相关结构体有关函数 + ************************************************/ + +/* + *以写的方式初始化数据文件管理结构 + *参数: 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 */ diff --git a/include/communicate/communicate_type.h b/include/communicate/communicate_type.h new file mode 100644 index 0000000..b6372bb --- /dev/null +++ b/include/communicate/communicate_type.h @@ -0,0 +1,77 @@ +#ifndef communicate_type_h +#define communicate_type_h + +#include + +/* + *文件头信息的管理及操作的结构 + */ +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 */ diff --git a/include/error/error.h b/include/error/error.h new file mode 100644 index 0000000..8dbf137 --- /dev/null +++ b/include/error/error.h @@ -0,0 +1,54 @@ +#ifndef error_h +#define error_h + +#include + +/* + *错误管理中信息的管理及操作的结构 + */ +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 */ diff --git a/error/error.h b/include/error/error_file.h similarity index 53% rename from error/error.h rename to include/error/error_file.h index f1e8d41..25d2a11 100644 --- a/error/error.h +++ b/include/error/error_file.h @@ -1,8 +1,18 @@ #ifndef ERROR_H #define ERROR_H -#include "../type/type.h" -#include "../list/list_expand.h" +#include +#include +#include + +/* + *错误管理中日志信息的管理及操作的结构 + */ +typedef struct Log{ + FILE *fp;//日志文件的指针 + int if_enable;//日志文件是否启用 + unsigned long int id;//日志文件的ID +}Log; Log logfile; List *error_list = NULL; diff --git a/include/event/event.h b/include/event/event.h new file mode 100644 index 0000000..f796350 --- /dev/null +++ b/include/event/event.h @@ -0,0 +1,83 @@ +#ifndef event_h +#define event_h + +#include + +/************************************************ + *回调函数的便捷操作相关宏 + ************************************************/ + +/**** + *母函数相关 + */ + +/* + *若需要母函数需要向毁掉函数传递相关参数则使用该宏 + *参数: 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() + +#endif /* event_h */ diff --git a/include/id/id.h b/include/id/id.h new file mode 100644 index 0000000..63f15d2 --- /dev/null +++ b/include/id/id.h @@ -0,0 +1,123 @@ +#ifndef id_h +#define id_h + +#include +#include + + +/* + *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 */ diff --git a/id/md5.h b/include/id/md5.h similarity index 85% rename from id/md5.h rename to include/id/md5.h index 35a686d..a6b4e93 100644 --- a/id/md5.h +++ b/include/id/md5.h @@ -1,7 +1,7 @@ #ifndef md5_h #define md5_h -#include "../type/type.h" +#include #define F(x,y,z) ((x & y) | (~x & z)) #define G(x,y,z) ((x & z) | (y & ~z)) @@ -32,6 +32,15 @@ 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); diff --git a/include/list/list.h b/include/list/list.h new file mode 100644 index 0000000..e5919de --- /dev/null +++ b/include/list/list.h @@ -0,0 +1,209 @@ +#ifndef list_h +#define list_h + +#include + + +/************************************************ + *链表的初始化相关函数 + ************************************************/ + +/* + *初始化链表,并返回指向新链表的指针,参数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 diff --git a/include/list/list_type.h b/include/list/list_type.h new file mode 100644 index 0000000..2bb2295 --- /dev/null +++ b/include/list/list_type.h @@ -0,0 +1,33 @@ +#ifndef list_type_h +#define list_type_h + +#ifdef id_enable +#include +#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 */ diff --git a/include/list/safe_mode.h b/include/list/safe_mode.h new file mode 100644 index 0000000..d74cb27 --- /dev/null +++ b/include/list/safe_mode.h @@ -0,0 +1,17 @@ +#ifndef safe_mode_h +#define safe_mode_h + +#include + +/********************************************************************************************************* + *安全模式开启函数:在开启安全模式后,记录代码段区间所有用户已经分配过内存的链表和节点.在结束时,释放记录在案的还未释放的链表和节点. + *注意:在开启后,只有使用库提供的初始化函数的时候才有效.安全模式打开后,只有调用安全模式结束函数后,才可以重新打开. + *运用:可以在逻辑较为复杂的代码段使用,预防内存泄漏的情况发生.可以免去繁琐的内存泄漏检查过程. + *返回: 若成功函数返回0,若失败函数返回-1. + ********************************************************************************************************/ +extern int safeModeForNode(int ifon); + +/*安全模式结束时调用,调用后将会释放所有在安全模式区间内用户已经分配过的链表和节点,安全模式将会关闭.*/ +extern int releaseAllForNode(void); + +#endif /* safe_mode_h */ diff --git a/tree/tree.h b/include/tree/tree.h similarity index 69% rename from tree/tree.h rename to include/tree/tree.h index d4b8a3d..d7807a1 100644 --- a/tree/tree.h +++ b/include/tree/tree.h @@ -1,8 +1,39 @@ #ifndef TREE_H #define TREE_H -#include -#include "../list/list_expand.h" +#include + +/* + *超级树节点的管理及操作的结构 + */ +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); diff --git a/include/type.h b/include/type.h new file mode 100644 index 0000000..da588d2 --- /dev/null +++ b/include/type.h @@ -0,0 +1,92 @@ +#ifndef type_h +#define type_h + +#define list_quick_enable +#define id_enable + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef UNIX +#include +#include +#include +#include +#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 */ diff --git a/list/list.c b/list/list.c deleted file mode 100644 index d627027..0000000 --- a/list/list.c +++ /dev/null @@ -1,985 +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->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(_Bool if_sid) { - 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; - if (if_sid)p_node->s_id = getS_id(LIST_NODE, 1); - else p_node->s_id = NULL; - p_node->next = NULL; - p_node->last = NULL; - p_node->type = VOID; - p_node->f_number = 0; - 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; -} - -inline s_Node *s_initNode(void){ - s_Node *s_p_node = (s_Node *)malloc(sizeof(s_Node)); - s_p_node->next = NULL; - return s_p_node; -} - -List *initList(_Bool if_sid) { - 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; - } - if(if_sid) p_list->s_id = getS_id(LIST, 1); - else p_list->s_id = NULL; - p_list->head = NULL; - p_list->tail = NULL; - p_list->length = 0; - p_list->p_lq = NULL; - p_list->s_head = 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; -} - -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; -} - -int insertInHead(List *p_list, Node *p_node) { - if(p_list->p_lq != NULL && p_list->p_lq->if_sort) return -1; - if(p_list->p_lq != NULL){ - if(p_list->head->type == HOLE){ - Node *t_node = p_list->head; - while(t_node->type == HOLE) t_node = t_node->next; - replaceNode(p_list, t_node->last, p_node); - p_list->p_lq->fn_node[t_node->last->f_number] = p_node; - indexChange(p_list, t_node->last->f_number, 1); - releaseNode(t_node->last); - return 0; - } - indexChange(p_list, 0, 1); - } - 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; -} - -inline int s_insertInHead(List *p_list, s_Node *s_p_node){ - if(p_list->s_head == NULL && p_list->s_tail == NULL){ - p_list->s_head = s_p_node; - p_list->s_tail = s_p_node; - } - else{ - s_p_node->next = p_list->s_head; - p_list->s_head = s_p_node; - } - return 0; -} - -int insertInTail(List *p_list, Node *p_node) { - if(p_list->p_lq != NULL && p_list->p_lq->if_sort) return -1; - 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; - } - - if(p_list->p_lq != NULL){ - p_node->f_number = p_list->p_lq->rlst_len; - if(p_list->p_lq->rlst_len >= p_list->p_lq->fn_len){ - p_list->p_lq->fn_node = realloc(p_list->p_lq->fn_node, sizeof(Node *) * (p_list->p_lq->fn_len + FN_NODE_SPARE)); - p_list->p_lq->fn_len += FN_NODE_SPARE; - } - p_list->p_lq->fn_node[p_list->p_lq->rlst_len] = p_node; - p_list->p_lq->rlst_len++; - } - - p_list->length += 1; - return 0; -} - -inline int s_insertInTail(List *p_list, s_Node *s_p_node){ - if(p_list->s_head == NULL && p_list->s_tail == NULL){ - p_list->s_head = s_p_node; - p_list->s_tail = s_p_node; - } - else{ - p_list->s_tail->next = s_p_node; - p_list->s_tail = s_p_node; - } - return 0; -} - -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->f_number = 0; - p_node->last = NULL; - p_node->next = NULL; - p_node->type = VOID; - p_node->value = NULL; - if (p_node->s_id != NULL) freeS_id(p_node->s_id); - free(p_node); - return 0; -} - -inline int s_releaseNode(s_Node *s_p_node){ - free(s_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; - p_list->s_head = NULL; - p_list->s_tail = NULL; - if (p_list->s_id != NULL) freeS_id(p_list->s_id); - if(p_list->p_lq != NULL) disableListQuick(p_list); - free(p_list); - return 0; -} - -int releaseListForSingle(List *p_list) { - releaseList(p_list); - return 0; -} - -unsigned long long len(List *p_list) { - return p_list->length; -} - -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 -} - -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; - } - if(p_list->p_lq == NULL){ - p_node->last->next = p_node->next; - p_node->next->last = p_node->last; - } - else{ - if(p_node->f_number == 0){ - Node *fn_node = findFnNode(p_list, p_node); - indexChange(p_list, fn_node->f_number, -1); - p_node->last->next = p_node->next; - p_node->next->last = p_node->last; - } - else{ - digHole(p_list, p_node); - } - 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; - if(p_list->p_lq != NULL){ - if(p_list->head->type == HOLE){ - Node *t_node = p_list->head; - while(t_node->type == HOLE) t_node = t_node->next; - if(t_node->f_number != 0){ - Node *r_node = t_node; - digHole(p_list, t_node); - return r_node; - } - p_node = t_node; - } - else{ - if(p_list->p_lq->fn_node[0] == p_list->head){ - Node *r_node = p_list->head; - digHole(p_list, p_list->head); - return r_node; - } - } - } - else{ - //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 { - if(p_list->p_lq != NULL){ - if(p_list->p_lq->fn_node[p_list->p_lq->rlst_len - 1] == p_list->tail){ - p_list->p_lq->fn_node[p_list->p_lq->rlst_len - 1] = NULL; - p_list->p_lq->rlst_len--; - if(p_list->p_lq->fn_len - p_list->p_lq->rlst_len > FN_NODE_SPARE * 2){ - p_list->p_lq->fn_node = realloc(p_list->p_lq->fn_node, sizeof(p_list->p_lq->fn_len - FN_NODE_SPARE)); - p_list->p_lq->fn_len -= FN_NODE_SPARE; - } - } - } - //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; -} - -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; -} - -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(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 = 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. -} - -Node *copyNode(Node *p_node) { - Node *t_node = NULL; - 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); - t_node->last = p_node->last; - t_node->next = p_node->next; - t_node->type = p_node->type; - t_node->value = p_node->value; - t_node->f_number = p_node->f_number; - return t_node; -} - -List *copyList(List *p_list) { - Node *p_node; - Node *t_node; - List *t_list = NULL; - if (p_list->s_id == NULL) t_list = initList(0); - else t_list = initList(p_list->s_id->deep); - t_list->head = p_list->head; - t_list->tail = p_list->tail; - t_list->s_id = p_list->s_id; - t_list->s_head = p_list->s_head; - t_list->length = p_list->length; - t_list->s_tail = p_list->s_tail; - 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; -} - -int releaseOnlyNode(Node *p_node) { - if (p_node->s_id != NULL) freeS_id(p_node->s_id); - 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) { - removeByNode(node_list, p_node); - } - if (p_node->value != NULL) { - 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; - if (p_node->s_id != NULL) freeS_id(p_node->s_id); - free(p_node); - return 0; -} - -inline int s_releaseNodeForCustom(s_Node *s_p_node, int (*func)(void *)){ - func(s_p_node->value); - free(s_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; - if (p_list->s_id != NULL) freeS_id(p_list->s_id); - if(p_list->p_lq != NULL) disableListQuick(p_list); - free(p_list); - return 0; -} - -int s_releaseListForCustom(List *p_list, int (*func)(void *)){ - register s_Node *s_p_node, *s_pl_node; - s_p_node = p_list->s_head; - while (s_p_node != NULL) { - s_pl_node = s_p_node; - s_p_node = s_p_node->next; - s_pl_node->next = NULL; - s_releaseNodeForCustom(s_pl_node,func); - } - 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; -} - -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; - - if(p_list->p_lq != NULL){ - if(pt_node->f_number == 0 && p_list->p_lq->fn_node[0] != pt_node){ - p_node->f_number = pt_node->f_number; - } - else{ - p_list->p_lq->fn_node[pt_node->f_number] = p_node; - p_node->f_number = pt_node->f_number; - } - } - 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; - if(p_list->p_lq != NULL){ - p_list->p_lq->fn_node[f_node->f_number] = s_node; - p_list->p_lq->fn_node[s_node->f_number] = f_node; - unsigned long long temp = f_node->f_number; - f_node->f_number = s_node->f_number; - s_node->f_number = temp; - } - return 0; -} - -int sortList(List *p_list, unsigned long long begin, unsigned long long end, int(*func)(Node *f_node, Node *s_node)){ - unsigned long long target_index = begin; - register Node *t_node = findByIndexForNode(p_list, target_index); - register Node *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(t_node->f_number - begin > 2) - sortList(p_list, begin, t_node->f_number, func); - if(end - t_node->f_number > 2) - sortList(p_list, t_node->f_number, end, func); - } - return 0; -} - -int sortListForCustom(List *p_list, int(*func)(Node *f_node, Node *s_node)){ - if(p_list->p_lq != NULL && !p_list->p_lq->if_sort) p_list->p_lq->if_sort = 1; - sortList(p_list, 0, p_list->length-1, func); - return 0; -} - -int enableListQuick(List *p_list){ - if(p_list->length > ENABLE_LIST_QUICK){ - p_list->p_lq = malloc(sizeof(struct list_quick)); - register struct list_quick *p_lq = p_list->p_lq; - p_lq->rlst_len = p_list->length; - p_lq->fn_node = NULL; - p_lq->if_sort = 0; - p_lq->idxc_count = 0; - p_lq->stdid_lst = initList(0); - for(int i = 0; i < INDEX_CHANGE_MAX; i++) p_lq->idxc_lst[i] = NULL; - refreshFnNode(p_list); - //sortListById(p_list, 0, p_list->length); - } - return 0; -} - -int refreshFnNode(List *p_list){ - if(p_list->p_lq != NULL){ - struct list_quick *blk_plq = p_list->p_lq; - initIdxcList(p_list); - if(p_list->p_lq->fn_node != NULL) free(p_list->p_lq->fn_node); - p_list->p_lq->fn_node = malloc(sizeof(Node *) * (p_list->length + FN_NODE_SPARE)); - p_list->p_lq->fn_len = p_list->length + FN_NODE_SPARE; - p_list->p_lq->rlst_len = p_list->length; - register Node *p_node = p_list->head; - unsigned long long i = 0; - p_list->p_lq = NULL; - while (p_node != NULL) { - if(p_node->type == HOLE){ - removeByNode(p_list, p_node); - releaseNode(p_node); - p_node = p_node->next; - continue; - } - p_node->f_number = i; - blk_plq->fn_node[i] = p_node; - p_node = p_node->next; - i++; - } - p_list->p_lq = blk_plq; - return 0; - } - return -1; -} - -int indexChange(List *p_list, unsigned long long c_index, int move){ - if(p_list->p_lq != NULL){ - struct index_change *t_idxc; - struct list_quick *p_lq = p_list->p_lq; - if(p_lq->idxc_count >= INDEX_CHANGE_MAX){ - refreshFnNode(p_list); - for(int i = 0; i < INDEX_CHANGE_MAX; i++){ - free(p_lq->idxc_lst[i]); - p_lq->idxc_lst[i] = NULL; - } - return 0; - } - for(int i = 0; p_lq->idxc_lst[i] != NULL; i++){ - if(p_lq->idxc_lst[i]->c_index == c_index){ - p_lq->idxc_lst[i]->f_count += move; - return 0; - } - } - if(p_lq->idxc_count == 0) { - p_lq->idxc_lst[0] = malloc(sizeof(struct index_change)); - t_idxc = p_lq->idxc_lst[0]; - } - else { - p_lq->idxc_lst[p_lq->idxc_count] = malloc(sizeof(struct index_change)); - t_idxc = p_lq->idxc_lst[p_lq->idxc_count]; - } - t_idxc->c_index = c_index; - t_idxc->f_count = move; - p_lq->idxc_count++; - } - return 0; -} - -int indexTransfromer(List *p_list, unsigned long long m_index){ - int total_move = 0; - struct list_quick *p_lq = p_list->p_lq; - struct index_change **p_idxclst = p_lq->idxc_lst; - if(p_lq->idxc_lst[0] != NULL){ - for (int i = 0; p_idxclst[i] != NULL && i < INDEX_CHANGE_MAX; i++) { - if(p_idxclst[i]->c_index <= m_index) total_move += p_idxclst[i]->f_count; - if(total_move >= 65535){ - refreshFnNode(p_list); - return 0; - } - } - } - return total_move; -} - -Node *getNodeByFnNode(List *p_list, unsigned long long index){ - if(p_list->p_lq != NULL){ - struct list_quick *p_lq = p_list->p_lq; - Node *p_node = NULL; - if(p_lq->rlst_len > index) p_node = p_lq->fn_node[index]; - else p_node = p_lq->fn_node[p_lq->rlst_len - 1]; - if(p_lq->idxc_count > 0){ - int total_move = indexTransfromer(p_list, index); - int temp = ABS(total_move); - if(p_lq->rlst_len > index){ - if(total_move >=0){ - for(int i = 0; i < temp; ){ - p_node = p_node->last; - if(p_node->type != HOLE) i++; - } - } - else{ - for(int i = 0; i < temp; ){ - p_node = p_node->next; - if(p_node->type != HOLE) i--; - } - } - } - else{ - unsigned long long jump = index - temp; - for(int i = 0; i < jump; i++) p_node = p_node->next; - } - return p_node; - } - else{ - return p_lq->fn_node[index]; - } - - } - return NULL; -} - -int insertAfterNode(List *p_list, Node *t_node, Node *p_node){ - if(t_node == p_list->tail){ - insertInTail(p_list, p_node); - return 0; - } - if(p_list->p_lq != NULL){ - if(t_node->next->type == HOLE){ - Node *temp_node = t_node->next; - replaceNode(p_list, t_node->next, p_node); - p_node->f_number = temp_node->f_number; - releaseNode(temp_node); - p_list->p_lq->fn_node[p_node->f_number] = p_node; - indexChange(p_list, p_node->f_number, 1); - } - } - p_node->next = t_node->next; - p_node->last = t_node; - if(p_list->tail != t_node) - t_node->next->last = p_node; - else - p_list->tail = p_node; - - t_node->next = p_node; - - if(p_list->p_lq != NULL){ - Node *fn_node = findFnNode(p_list, p_node); - indexChange(p_list, fn_node->f_number, 1); - } - p_list->length += 1; - return 0; -} - -int insertBeforeNode(List *p_list, Node*t_node, Node *p_node){ - if(t_node == p_list->head){ - insertInHead(p_list, p_node); - return 0; - } - if(p_list->p_lq != NULL){ - if(t_node->last->type == HOLE){ - Node *temp_node = t_node->last; - replaceNode(p_list, t_node->last, p_node); - p_node->f_number = temp_node->f_number; - releaseNode(temp_node); - p_list->p_lq->fn_node[p_node->f_number] = p_node; - indexChange(p_list, p_node->f_number, 1); - return 0; - } - } - p_node->last = t_node->last; - p_node->next = t_node; - if(p_list->head != t_node) - t_node->last->next = p_node; - else - p_list->head = p_node; - t_node->last = p_node; - if(p_list->p_lq != NULL){ - Node *fn_node = findFnNode(p_list, p_node); - indexChange(p_list, fn_node->f_number, 1); - } - p_list->length += 1; - return 0; -} - -Node *findFnNode(List *p_list, Node *p_node){ - Node *fn_node = p_node; - while(fn_node->f_number == 0) fn_node = fn_node->next; - return fn_node; -} - -void initIdxcList(List *p_list){ - struct list_quick *p_lq = p_list->p_lq; - for(int i = 0; i < INDEX_CHANGE_MAX; i++){ - if(p_lq->idxc_lst[i] != NULL) free(p_lq->idxc_lst[i]); - p_lq->idxc_lst[i] = NULL; - } - p_lq->idxc_count = 0; -} - -void digHole(List *p_list, Node *p_node){ - Node *c_node = copyNode(p_node); - freeS_id(c_node->s_id); - replaceNode(p_list, p_node, c_node); - c_node->value = NULL; - c_node->type = HOLE; - indexChange(p_list, p_node->f_number, -1); -} - -int disableListQuick(List *p_list){ - free(p_list->p_lq->fn_node); - initIdxcList(p_list); - free(p_list->p_lq); - return 0; -} diff --git a/list/list.h b/list/list.h deleted file mode 100644 index c9265f1..0000000 --- a/list/list.h +++ /dev/null @@ -1,553 +0,0 @@ -#ifndef LIST_H -#define LIST_H -#include "../type/type.h" -#include "../id/id.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); - -/********************************************************************************************************/ - -/********************************************************************************************************* - *安全模式开启函数:在开启安全模式后,记录代码段区间所有用户已经分配过内存的链表和节点.在结束时,释放记录在案的还未释放的链表和节点. - *注意:在开启后,只有使用库提供的初始化函数的时候才有效.安全模式打开后,只有调用安全模式结束函数后,才可以重新打开. - *运用:可以在逻辑较为复杂的代码段使用,预防内存泄漏的情况发生.可以免去繁琐的内存泄漏检查过程. - *返回: 若成功函数返回0,若失败函数返回-1. - ********************************************************************************************************/ -extern int safeModeForNode(int ifon); - -/*属于安全模式操作内部调用,释放链表而不释放其中的值.*/ -static int releaseSingleListForsafeModeForNode(List *p_list); - -/*属于安全模式操作内部调用,释放节点而不释放其中的值.*/ -static int releaseSingleNodeForsafeModeForNode(List *p_list); - -/*安全模式结束时调用,调用后将会释放所有在安全模式区间内用户已经分配过的链表和节点,安全模式将会关闭.*/ -extern int releaseAllForNode(void); - -/* - *初始化链表,并返回指向新链表的指针,参数if_sid指示是否为新链表分配ID号 - *返回: 如果成功返回指向该节点的指针,如果失败则返回NULL.*/ -extern List *initList(_Bool if_sid); - -/* - *初始化节点,并返回指向新链表的指针,参数if_sid指示是否为新节点分配ID号 - *返回: 如果成功返回指向该节点的指针,如果失败则返回NULL.*/ -extern Node *initNode(_Bool if_sid); - - - - -/************************************************ - *链表的初始化相关函数 - ************************************************/ - -/* - *初始化单向链表节点,该种类节点可以与普通储存在List结构中. - *单向链表的引入主要在于对于简单问题提供更小开销的解决方案.但相应的操作函数较少,不如一般链表方便. - *返回: 如果成功返回指向该节点的指针,如果失败则返回NULL.*/ -extern s_Node *s_initNode(void); - -/*库中内部调用函数,旨在为新节点的储存值获取内存,并将相应的储存值储存在获取到的内存中,并指明储存值的类型.*/ -static 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); - -/*在单项链表的头部插入一个节点 - *返回: 若成功函数返回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); - - - - -/*********************************************** - 节点的替换与调换: 节点的替换与调换相关的函数 - ***********************************************/ - -/* - *用一个新节点,替换掉链表中已经存在的节点 - *参数: 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); - - - - -/********************************************** - *链表或节点的复制: 链表与节点复制相关函数 - *********************************************/ - -/* - *节点的复制,复制将会为新节点重新分配内存,并将源节点的所有值拷贝入新节点. - *注意: 源节点与新节点ID相同. - *返回: 若成功函数返回指向新节点的指针,若失败则返回NULL*/ -extern Node *copyNode(Node *); - -/* - *链表的复制,复制将会为新链表重新分配内存,并将源链表的所有节点复制. - *注意: 源链表与新链表ID相同. - *返回: 若成功函数返回指向新链表的指针,若失败则返回NULL*/ -List *copyList(List *p_list); - - - - -/*********************************************** - *节点的删除: 节点移除相关函数 - ***********************************************/ - -/* - *通过ID查找链表中的特定节点并从链表中移除相关节点,但并不释放节点内存. - *若成功函数返回0,若失败函数返回-1.*/ -extern int removeById(List *p_list, SID *s_id); - -/* - *通过指向节点的指针直接从链表中移除相关节点,但不释放节点内存 - *若成功函数返回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); - - - - -/*********************************************** - *链表或节点的属性:获取或更新链表或节点属性有关的函数 - ***********************************************/ - -/* - *返回链表长度*/ -extern unsigned long long len(List *p_list); - -/* - *查询链表是否为空 - *返回: 如果链表为空返回1,如果链表不为空则返回0.*/ -int isListEmpty(List *p_list); - -/* - *直接获得节点中的整型值 - *返回: 返回该节点储存的整型值*/ -int getByIntForNode(Node *); - -/* - *直接获得节点中的无符号整型值 - *返回: 返回该节点储存的无符号整型值*/ -unsigned int getByUIntForNode(Node *); - -/* - *直接获得节点中的浮点值 - *返回: 返回该节点储存的浮点值*/ -double getByDoubleForNode(Node *); - -/* - *直接获得节点中的字符串值 - *返回: 返回该节点储存的字符串值*/ -char *getByStringForNode(Node *); - -/* - *直接获得节点中的指针值 - *返回: 返回该节点储存的指针值*/ -void *getByPointerForNode(Node *); - -/* - *直接获得节点的序号 - *返回: 返回该节点在链表中的序号*/ -unsigned long long getIndexForNode(List *p_list,Node *p_node); - -/* - *通过节点的序号找到节点中相关的值,并更新其中的储存的值的指针. - *返回: 如果成功返回指向该节点的指针,如果失败则返回NULL*/ -Node *updateNodeByIndex(List *p_list, void *new_value, unsigned long long index); - - - - -/*********************************************** - *链表查找:查找链表中的指定节点有关的函数 - **********************************************/ - -/* - *通过ID查找链表中相关的单个节点 - *返回: 如果成功返回指向该节点的指针,如果失败则返回NULL.*/ -extern Node *findByIdForNode(List *p_list, SID * s_id); - -/* - *通过节点中的值查找相关单个节点 - *参数: type指明相关值的类型;value为指向储存相关值的内存的指针. - *返回: 如果成功返回指向该节点的指针,如果失败则返回NULL.*/ -extern Node *findByValue(List *p_list, unsigned int type, const void *value); - -/* - *通过序号查找相关的单个节点 - *返回: 如果成功返回指向该节点的指针,如果失败则返回NULL.*/ -extern Node *findByIndexForNode(List *, unsigned long long); - -/* - *通过整型值查找储存该值的单个节点 - *返回: 如果成功返回指向该节点的指针,如果失败则返回NULL.*/ -extern Node *findByIntForNode(List *, int); - -/* - *通过浮点值查找储存该值的单个节点 - *返回: 如果成功返回指向该节点的指针,如果失败则返回NULL.*/ -extern Node *findByDoubleForNode(List *, double); - -/* - *通过字符串中查找储存该值的单个节点. - *返回: 如果成功返回指向该节点的指针,如果失败则返回NULL.*/ -extern Node *findByStringForNode(List *, char *); - -/* - *通过指针值查找储存该值的单个节点. - *返回: 如果成功返回指向该节点的指针,如果失败则返回NULL.*/ -extern Node *findByPointerForNode(List *, void *); - -//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); - - - - -/*********************************************** - *链表的排序: 使用快速排序算法,按照指定规则排序链表 - **********************************************/ - -/* - *内部函数: 通过节点中的值查找相关多个节点. - *参数: type指明相关值的类型;value为指向储存相关值的内存的指针. - *返回: 如果成功返回0,如果失败则返回-1.*/ -static int sortList(List *p_list, unsigned long long begin, unsigned long long end, int(*func)(Node *f_node, Node *s_node)); - -/* - *自定义排序链表. - *参数: 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); - -/* - *释放单向链表所占的内存空间 - *返回: 如果成功返回0, 失败则返回-1.*/ -extern int s_releaseList(List *p_list); - -/* - *自定义释放链表所占的内存空间 - *参数: func是一个函数指针,它指向的函数现在每次释放节点时调用,用于释放用户自定义的结构体的所占用内存. - *返回: 如果成功返回0, 失败则返回-1.*/ -extern int releaseListForCustom(List *p_list, int (*func)(void *)); - -/* - *自定义释放单向链表所占的内存空间 - *参数: func是一个函数指针,它指向的函数现在每次释放节点时调用, - * 接收储存在节点中的值的指针,释放用户自定义的结构体的所占用内存. - * 回调函数返回0代表释放成功,返回-1代表释放失败. - *返回: 如果成功返回0, 失败则返回-1.*/ -extern int s_releaseListForCustom(List *p_list, int (*func)(void *)); - -/* - *释放链表所占的内存,但不释放链表中的节点所占的内存空间 - *返回: 如果成功返回0, 失败则返回-1.*/ -extern int releaseListForSingle(List *p_list); - -/* - *释放相关节点所占的内存空间 - *返回: 如果成功返回0, 失败则返回-1.*/ -extern int releaseNode(Node *p_node); - -/* - *释放单向节点所占的内存空间 - *返回: 如果成功返回0, 失败则返回-1.*/ -extern int s_releaseNode(s_Node *s_p_node); - -/* - *自定义释放节点所占的内存空间 - *参数: func是一个函数指针,它指向的函数现在每次释放节点时调用, - * 接收储存在节点中的值的指针,释放用户自定义的结构体的所占用内存. - * 回调函数返回0代表释放成功,返回-1代表释放失败. - *返回: 如果成功返回0, 失败则返回-1.*/ -extern int releaseNodeForCustom(Node *p_node, int (*func)(void *)); - -/* - *自定义释放单向节点所占的内存空间 - *参数: func是一个函数指针,它指向的函数现在每次释放单项节点时调用, - * 接收储存在单项节点中的值得指针,释放用户自定义的结构体的所占用内存. - * 回调函数返回0代表释放成功,返回-1代表释放失败. - *返回: 如果成功返回0, 失败则返回-1.*/ -extern int s_releaseNodeForCustom(s_Node *s_p_node, int (*func)(void *)); - -/* - *释放节点所占的内存空间,不释放节点所储存的值所占的内存空间 - *返回: 如果成功返回0, 失败则返回-1.*/ -extern int releaseOnlyNode(Node *p_node); - -/*********************************************** - *错误的提示:出现错误时,以下函数用于快捷地通报错误信息, - * 以便根据信息快速找到错误原因. - **********************************************/ - -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 *); - -/*********************************************** - *长链表模式:当链表长度很长时,链表查找的代价将会很大. - * 该模式用于优化长链表的查找过程.降低时间复杂度. - ***********************************************/ -/* - *打开长链表模式 - *返回: 如果成功返回0, 失败则返回-1.*/ -extern int enableListQuick(List *p_list); - -/* - *关闭长链表模式 - *返回: 如果成功返回0, 失败则返回-1.*/ -extern int disableListQuick(List *p_list); - -static int refreshFnNode(List *p_list); - -static int indexTransfromer(List *p_list, unsigned long long m_index); - -static int indexChange(List *p_list, unsigned long long c_index, int move); - -static Node *getNodeByFnNode(List *p_list, unsigned long long index); - -static Node *findFnNode(List *p_list, Node *p_node); - -static void initIdxcList(List *p_list); - -static void digHole(List *p_list, Node *p_node); - - -//Node *getListTail(List *); - - - - -/*********************************************** - *相关的全局变量 - ***********************************************/ - -static int if_safeModeForNode; -static List *node_list; -static List *list_list; - - - - -#endif diff --git a/list/list_expand.c b/list/list_expand.c deleted file mode 100644 index 72426b0..0000000 --- a/list/list_expand.c +++ /dev/null @@ -1,650 +0,0 @@ -#include "list_expand.h" - -Node *nodeWithInt(int m_int, _Bool if_sid) { - Node *p_node; - int *p_int = (int *)malloc(sizeof(int)); - if(p_int == NULL){ - showError(pushError(INT, STANDARD, initInfo(__FUNCTION__, "Error in getting the memory of int."))); - return NULL; - } - *p_int = m_int; - p_node = initNode(if_sid); - initMallocValueForNode(p_node, INT, (void *)p_int); - return p_node; -} - -Node *nodeWithUInt(unsigned int m_uint, _Bool if_sid){ - Node *p_node; - unsigned int *pu_int = (unsigned int *)malloc(sizeof(unsigned int)); - if(pu_int == NULL){ - showError(pushError(INT, STANDARD, initInfo(__FUNCTION__, "Error in getting the memory of int."))); - return NULL; - } - *pu_int = m_uint; - p_node = initNode(if_sid); - initMallocValueForNode(p_node, INT, (void *)pu_int); - return p_node; -} - -Node *nodeWithULLInt(unsigned long long m_ullint, _Bool if_sid) { - Node *p_node; - unsigned long long *p_ullint = (unsigned long long *)malloc(sizeof(unsigned long long)); - if(p_ullint == NULL){ - showError(pushError(INT, STANDARD, initInfo(__FUNCTION__, "Error in getting the memory of int."))); - return NULL; - } - *p_ullint = m_ullint; - p_node = initNode(if_sid); - initMallocValueForNode(p_node, ULLINT, (void *)p_ullint); - return p_node; -} - -Node *nodeWithDouble(double m_double, _Bool if_sid) { - Node *p_node; - double *p_double = (double *)malloc(sizeof(double)); - if(p_double == NULL){ - showError(pushError(DOUBLE, STANDARD, initInfo(__FUNCTION__, "Error in getting the memory of double."))); - return NULL; - } - *p_double = m_double; - p_node = initNode(if_sid); - initMallocValueForNode(p_node, DOUBLE, (void *)p_double); - return p_node; -} - -Node *nodeWithString(const char *m_string, _Bool if_sid) { - 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(if_sid); - initMallocValueForNode(p_node, STRING, (void *)p_string); - return p_node; -} - -Node *nodeWithPointer(const void *m_pointer, _Bool if_sid) { - Node *p_node = initNode(if_sid); - initMallocValueForNode(p_node, POINTER, m_pointer); - return p_node; -} - -Node *nodeWithComplex(void) { - Node *p_node = initNode(0); - p_node->type = LIST; - p_node->value = initList(0); - return p_node; -} - -Node *findByIndexForNode(List *p_list, unsigned long long m_index) { - if(p_list == NULL) return NULL; - if(p_list->p_lq != NULL){ - register struct list_quick *p_lq = p_list->p_lq; - if(p_lq->fn_node != NULL) return getNodeByFnNode(p_list, 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; -} - -s_Node *s_findByIndexForNode(List *p_list, unsigned long long m_index) { - s_Node *s_p_node = p_list->s_head; - unsigned long long i; - for (i = 0; i < m_index; i++) { - s_p_node = s_p_node->next; - } - return s_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; - unsigned long long 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; -} - -unsigned long long getInfoForListThrough(List *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 *((unsigned long long *)p_node->value); -} - -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) { - return (void *)(p_node->value); -} - -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\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"); -} - -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->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"); -} - - -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(0); - 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 *mply_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 *mply_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 *mply_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 *mply_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) { - if (p_list->p_lq != NULL){ - register Node **p_fn_node = p_list->p_lq->fn_node; - register Node *rp_node = p_node; - for (register int i = 0; i < p_list->length; i++) if (p_fn_node[i] == rp_node) return i; - } - else{ - register Node *t_node = p_list->head; - register 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 *mply_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 *mply_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 *mply_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 *mply_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 updateValueWithIntForNode(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 updateValueWithULLIntForNode(Node *p_node, unsigned long long value){ - unsigned long long *p_value = (unsigned long long *)malloc(sizeof(unsigned long long)); - if(p_value == NULL){ - showError(pushError(INT, STANDARD, initInfo(__FUNCTION__, "Error in getting the memory of int."))); - return -1; - } - *p_value = value; - free(p_node->value); - p_node->value = p_value; - return 0; -} - -int updateValueWithDoubleForNode(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 updateValueWithStringForNode(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 updateValueWithPointerForNode(Node *p_node, void *pointer){ - free(p_node->value); - p_node->value = pointer; - return 0; -} - -inline s_Node *s_nodeWithInt(int t_int){ - s_Node *s_p_node = s_initNode(); - int *pt_int = malloc(sizeof(int)); - *pt_int = t_int; - s_p_node->value = pt_int; - return s_p_node; -} - -inline s_Node *s_nodeWithUInt(unsigned int t_uint){ - s_Node *s_p_node = s_initNode(); - unsigned int *pt_uint = malloc(sizeof(unsigned int)); - *pt_uint = t_uint; - s_p_node->value = pt_uint; - return s_p_node; -} - -inline s_Node *s_nodeWithDouble(double t_double){ - s_Node *s_p_node = s_initNode(); - unsigned int *pt_double = malloc(sizeof(double)); - *pt_double = t_double; - s_p_node->value = pt_double; - return s_p_node; -} - -inline s_Node *s_nodeWithString(const char *t_string){ - s_Node *s_p_node = s_initNode(); - char *pt_string = malloc(strlen(t_string) + 1); - strcpy(pt_string, t_string); - s_p_node->value = pt_string; - return s_p_node; -} - -inline s_Node *s_nodeWithPointer(const void *t_pointer){ - s_Node *s_p_node = s_initNode(); - s_p_node->value = (void *) t_pointer; - return s_p_node; -} - - - -List *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; -} - -List *newCReturn(void){ - return newReturn(1, 0, NULL); -} - -void printListForCustom(List *p_list,void (*func)(void *value)){ - printf("###LIST (LEN:%llu ",p_list->length); - if(p_list->s_id != NULL) printf("SID:%s",p_list->s_id->decrypt_str); - 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__; -} diff --git a/list/list_expand.h b/list/list_expand.h deleted file mode 100644 index 9136b7f..0000000 --- a/list/list_expand.h +++ /dev/null @@ -1,349 +0,0 @@ -#ifndef LIST_EXPAND_H -#define LIST_EXPAND_H - -#include "list.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() - - - - -/************************************************ - *节点的快速初始化: 为新节点分配内存空间, - * 并使用输入值对其进行初始化. - ************************************************/ - -/* - *为新节点获取内存空间, 并使用整型值初始化新节点 - *参数if_sid指示函数是否为节点获取ID - *返回: 若成功则返回指向新节点的指针,若失败函数返回NULL.*/ -extern Node *nodeWithInt(int, _Bool if_sid); - -/* - *为新节点获取内存空间, 并使用无符号整型值初始化新节点 - *参数if_sid指示函数是否为节点获取ID - *返回: 若成功则返回指向新节点的指针,若失败函数返回NULL.*/ -extern Node *nodeWithUInt(unsigned int, _Bool if_sid); - -/* - *为新节点获取内存空间, 并使用无符号长整型值初始化新节点 - *参数if_sid指示函数是否为节点获取ID - *返回: 若成功则返回指向新节点的指针,若失败函数返回NULL.*/ -extern Node *nodeWithULLInt(unsigned long long, _Bool if_sid); - -/* - *为新节点获取内存空间, 并使用浮点值初始化新节点 - *参数if_sid指示函数是否为节点获取ID - *返回: 若成功则返回指向新节点的指针,若失败函数返回NULL.*/ -extern Node *nodeWithDouble(double, _Bool if_sid); - -/* - *为新节点获取内存空间, 并使用字符串值初始化新节点 - *参数if_sid指示函数是否为节点获取ID - *返回: 若成功则返回指向新节点的指针,若失败函数返回NULL.*/ -extern Node *nodeWithString(const char *, _Bool if_sid); - -/* - *为新节点获取内存空间, 并使用指针值初始化新节点 - *参数if_sid指示函数是否为节点获取ID - *返回: 若成功则返回指向新节点的指针,若失败函数返回NULL.*/ -extern Node *nodeWithPointer(const void *, _Bool if_sid); - - - - - -/************************************************ - *单向节点的快速初始化: 为新节点分配内存空间, - * 并使用输入值对其进行初始化. - ************************************************/ - -/* - *为新单向节点获取内存空间, 并使用整型值初始化新单向节点 - *返回: 若成功则返回指向新单向节点的指针,若失败函数返回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 *); - - - - -/************************************************ - *嵌套节点的快速初始化: 为嵌套节点节点分配内存空间, - * 并使用输入值对其进行初始化 - *说明: 嵌套节点指储存一个链表指针的节点. - ************************************************/ - -/* - *为新嵌套节点获取内存空间 - *返回: 若成功指向新嵌套节点的指针,若失败函数返回NULL.*/ -extern Node *nodeWithComplex(void); - -/* - *用输入的值初始化嵌套节点 - *参数: type指明所输入值的类型,value为指向所输入值的内存空间的指针 - *返回: 若成功则返回0,若失败函数返回-1.*/ -extern int addValueForComplex(Node *, int type, void *value); - -/* - *用输入的整型值初始化嵌套节点 - *返回: 若成功则返回0,若失败函数返回-1.*/ -extern int addIntForComplex(Node *, int); - -/* - *用输入的浮点值初始化嵌套节点 - *返回: 若成功则返回0,若失败函数返回-1.*/ -extern int addDoubleForComplex(Node *, double); - -/* - *用输入的字符串初始化嵌套节点 - *返回: 若成功则返回0,若失败函数返回-1.*/ -extern int addStringForComplex(Node *, char *); - -/* - *用输入的指针值初始化嵌套节点 - *返回: 若成功则返回0,若失败函数返回-1.*/ -extern int addPointerForComplex(Node *, void *); - - - - -/************************************************ - *节点值的更新: 更新既有节点中的值,并用新值直接替换旧值 - ************************************************/ - -/* - *用输入的整型值更新节点中的值 - *返回: 若成功则返回0,若失败函数返回-1.*/ -extern int updateValueWithIntForNode(Node *,int); - -/* - *用输入的无符号长整型值更新节点中的值 - *返回: 若成功则返回0,若失败函数返回-1.*/ -extern int updateValueWithULLIntForNode(Node *, unsigned long long); - -/* - *用输入的浮点值更新节点中的值 - *返回: 若成功则返回0,若失败函数返回-1.*/ -extern int updateValueWithDoubleForNode(Node *,double); - -/* - *用输入的字符串值更新节点中的值 - *返回: 若成功则返回0,若失败函数返回-1.*/ -extern int updateValueWithStringForNode(Node *,char *); - -/* - *用输入的指针值更新节点中的值 - *返回: 若成功则返回0,若失败函数返回-1.*/ -extern int updateValueWithPointerForNode(Node *,void *); - - - - -/************************************************ - *链表的查找: 依据输入值,查找链表中的多个特定类型的节点 - ************************************************/ - -/* - *通过输入的整型值,查找链表中多个含有该值的节点 - *返回: 若成功则返回一个储存由这些指向这些节点指针组成的链表,若失败函数返回NULL.*/ -List *mply_findByIntForNode(List*, int); - -/* - *通过输入的浮点值,查找链表中多个含有该值的节点 - *返回: 若成功则返回一个储存由这些指向这些节点指针组成的链表,若失败函数返回NULL.*/ -List *mply_findByDoubleForNode(List*, double); - -/* - *通过输入的字符串值,查找链表中多个含有该值的节点 - *返回: 若成功则返回一个储存由这些指向这些节点指针组成的链表,若失败函数返回NULL.*/ -List *mply_findByStringForNode(List*, char *); - -/* - *通过输入的指针值,查找链表中多个含有该值的节点 - *返回: 若成功则返回一个储存由这些指向这些节点指针组成的链表,若失败函数返回NULL.*/ -List *mply_findByPointerForNode(List*, void *); - - - - - -/************************************************ - *链表或节点的输出: 格式化输出链表或节点的属性 - ************************************************/ - -/* - *输出链表及其中节点的相关信息 - *参数: priority为每行输出信息前的空格数除以4*/ -void printListInfo(List *p_list,int priority); - -/* - *输出节点中的相关信息 - *参数: priority为每行输出信息前的空格数乘以4*/ -void printNodeInfo(Node *p_node,int priority); - -/* - *输出链表及其中节点的相关信息 - */ -void printList(List *); - -/* - *自定义输出链表及其中节点的相关信息 - *参数: func为一个函数指针, 指向函数的职能在于输出节点中的用户自定义结构的相关信息*/ -void printListForCustom(List *p_list,void (*func)(void *value)); - -/* - *printListForCustom函数的回调函数 - */ -__CALLBACK_STATE(printListForCustom); - -/* - *输出节点中的相关信息 - */ -void printNode(Node *p_node); - - - - - -/************************************************ - *链表的遍历: 遍历链表相关函数 - ************************************************/ - -/* - *链表的遍历 - *参数: p_func为一个函数指针, 指向的回调函数的职能在于接受每个节点的类型(type)/值指针(value)/传入参数链表(args), - 然后进行相关操作,并返回一个链表,其中包含返回状态,若有,也可以包含想要传递给母函数的值 - expand_resources为一个链表,储存母函数想要传递给回调函数的值 - *返回: 如果回调函数有需要返回给母函数的值,则返回包含这些值的链表,否则返回NULL.*/ -extern List *listThrough(List *p_list, List *(*p_func)(unsigned int type, void *value, List *args), List *expand_resources); - -/* - *回调函数相关宏操作的辅助函数,用于给回调函数给母函数返回值提供便利 - */ -extern List *newReturn(int if_status ,int status, char *argc, ...); - -/* - *回调函数相关宏操作的辅助函数,用于回调函数返回空值提供便利 - */ -List *newCReturn(void); - -/* - *回调函数相关宏操作的辅助函数,用于给回调函数获取母函数传入的参数返提供便利 - */ -unsigned long long getInfoForListThrough(List *expand_resources, int type); - - - - - -/************************************************ - *链表大小: 计算链表大小相关函数 - ************************************************/ - -/* - *以字节为单位计算链表的大小 - */ -unsigned long long calListMemory(List *); - - - - - -#endif diff --git a/src/communicate/communicate.c b/src/communicate/communicate.c new file mode 100644 index 0000000..7939d7d --- /dev/null +++ b/src/communicate/communicate.c @@ -0,0 +1,49 @@ +#include +#include +#include +#include +#include + + +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; +}*/ diff --git a/src/communicate/dfile/dfile_in.c b/src/communicate/dfile/dfile_in.c new file mode 100644 index 0000000..ffee14e --- /dev/null +++ b/src/communicate/dfile/dfile_in.c @@ -0,0 +1,49 @@ +#include +#include +#include +#include +#include + + +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; +} + diff --git a/src/communicate/dfile/dfile_info.c b/src/communicate/dfile/dfile_info.c new file mode 100644 index 0000000..ea92cba --- /dev/null +++ b/src/communicate/dfile/dfile_info.c @@ -0,0 +1,13 @@ +#include +#include +#include +#include +#include + +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; +} diff --git a/src/communicate/dfile/dfile_init.c b/src/communicate/dfile/dfile_init.c new file mode 100644 index 0000000..60481e8 --- /dev/null +++ b/src/communicate/dfile/dfile_init.c @@ -0,0 +1,24 @@ +#include +#include +#include +#include +#include + +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; +} diff --git a/src/communicate/dfile/dfile_insert.c b/src/communicate/dfile/dfile_insert.c new file mode 100644 index 0000000..87f0f60 --- /dev/null +++ b/src/communicate/dfile/dfile_insert.c @@ -0,0 +1,11 @@ +#include +#include +#include +#include +#include + +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; +} diff --git a/src/communicate/dfile/dfile_out.c b/src/communicate/dfile/dfile_out.c new file mode 100644 index 0000000..64e1bcd --- /dev/null +++ b/src/communicate/dfile/dfile_out.c @@ -0,0 +1,15 @@ +#include +#include +#include +#include +#include + +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; +} diff --git a/src/communicate/dfile/dfile_release.c b/src/communicate/dfile/dfile_release.c new file mode 100644 index 0000000..096e2db --- /dev/null +++ b/src/communicate/dfile/dfile_release.c @@ -0,0 +1,13 @@ +#include +#include +#include +#include +#include + +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; +} diff --git a/src/communicate/std/std_find.c b/src/communicate/std/std_find.c new file mode 100644 index 0000000..8a1c8cd --- /dev/null +++ b/src/communicate/std/std_find.c @@ -0,0 +1,14 @@ +#include +#include +#include +#include +#include + +__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__; +} diff --git a/src/communicate/std/std_in.c b/src/communicate/std/std_in.c new file mode 100644 index 0000000..caaa887 --- /dev/null +++ b/src/communicate/std/std_in.c @@ -0,0 +1,59 @@ +#include +#include +#include +#include +#include + +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; +} diff --git a/src/communicate/std/std_info.c b/src/communicate/std/std_info.c new file mode 100644 index 0000000..d98d6d1 --- /dev/null +++ b/src/communicate/std/std_info.c @@ -0,0 +1,44 @@ +#include +#include +#include +#include +#include + +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); +} diff --git a/src/communicate/std/std_init.c b/src/communicate/std/std_init.c new file mode 100644 index 0000000..6314a25 --- /dev/null +++ b/src/communicate/std/std_init.c @@ -0,0 +1,31 @@ +#include +#include +#include +#include +#include + +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; +} + + diff --git a/src/communicate/std/std_insert.c b/src/communicate/std/std_insert.c new file mode 100644 index 0000000..e210ed7 --- /dev/null +++ b/src/communicate/std/std_insert.c @@ -0,0 +1,20 @@ +#include +#include +#include +#include +#include + +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; +} diff --git a/src/communicate/std/std_out.c b/src/communicate/std/std_out.c new file mode 100644 index 0000000..9fd7023 --- /dev/null +++ b/src/communicate/std/std_out.c @@ -0,0 +1,29 @@ +#include +#include +#include +#include +#include + + +__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__; +} diff --git a/src/communicate/std/std_relaese.c b/src/communicate/std/std_relaese.c new file mode 100644 index 0000000..6b4adcf --- /dev/null +++ b/src/communicate/std/std_relaese.c @@ -0,0 +1,13 @@ +#include +#include +#include +#include +#include + +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; +} diff --git a/src/communicate/stdb/stdb_in.c b/src/communicate/stdb/stdb_in.c new file mode 100644 index 0000000..f7a2ab4 --- /dev/null +++ b/src/communicate/stdb/stdb_in.c @@ -0,0 +1,6 @@ +#include +#include +#include +#include +#include + diff --git a/src/communicate/stdb/stdb_init.c b/src/communicate/stdb/stdb_init.c new file mode 100644 index 0000000..7e18371 --- /dev/null +++ b/src/communicate/stdb/stdb_init.c @@ -0,0 +1,30 @@ +#include +#include +#include +#include +#include + +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; +} diff --git a/src/communicate/stdb/stdb_out.c b/src/communicate/stdb/stdb_out.c new file mode 100644 index 0000000..f0504e1 --- /dev/null +++ b/src/communicate/stdb/stdb_out.c @@ -0,0 +1,24 @@ +#include +#include +#include +#include +#include + +__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__; +} diff --git a/src/communicate/stdb/stdb_release.c b/src/communicate/stdb/stdb_release.c new file mode 100644 index 0000000..d63092c --- /dev/null +++ b/src/communicate/stdb/stdb_release.c @@ -0,0 +1,12 @@ +#include +#include +#include +#include +#include + +int releaseSTDBlocks(STD_BLOCKS *p_stdb){ + free(p_stdb->buff); + free(p_stdb->sid); + free(p_stdb); + return 0; +} diff --git a/src/communicate/stdc/stdc_in.c b/src/communicate/stdc/stdc_in.c new file mode 100644 index 0000000..d2457c8 --- /dev/null +++ b/src/communicate/stdc/stdc_in.c @@ -0,0 +1,14 @@ +#include +#include +#include +#include +#include + + +__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__; +} diff --git a/src/communicate/stdc/stdc_info.c b/src/communicate/stdc/stdc_info.c new file mode 100644 index 0000000..4dce30f --- /dev/null +++ b/src/communicate/stdc/stdc_info.c @@ -0,0 +1,15 @@ +#include +#include +#include +#include +#include + +__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__; +} diff --git a/src/communicate/stdc/stdc_init.c b/src/communicate/stdc/stdc_init.c new file mode 100644 index 0000000..f7a2ab4 --- /dev/null +++ b/src/communicate/stdc/stdc_init.c @@ -0,0 +1,6 @@ +#include +#include +#include +#include +#include + diff --git a/src/communicate/stdc/stdc_out.c b/src/communicate/stdc/stdc_out.c new file mode 100644 index 0000000..f7a2ab4 --- /dev/null +++ b/src/communicate/stdc/stdc_out.c @@ -0,0 +1,6 @@ +#include +#include +#include +#include +#include + diff --git a/src/communicate/stdc/stdc_release.c b/src/communicate/stdc/stdc_release.c new file mode 100644 index 0000000..5f81d2c --- /dev/null +++ b/src/communicate/stdc/stdc_release.c @@ -0,0 +1,12 @@ +#include +#include +#include +#include +#include + +int releaseSTDConnection(STD_CTN *p_stdc){ + free(p_stdc->f_sid); + free(p_stdc->s_sid); + free(p_stdc); + return 0; +} diff --git a/src/communicate/stdcvt/stcvt_in.c b/src/communicate/stdcvt/stcvt_in.c new file mode 100644 index 0000000..2e65d1c --- /dev/null +++ b/src/communicate/stdcvt/stcvt_in.c @@ -0,0 +1,25 @@ +#include +#include +#include +#include +#include + +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; +} diff --git a/src/communicate/stdcvt/stdcvt_out.c b/src/communicate/stdcvt/stdcvt_out.c new file mode 100644 index 0000000..e22ea8a --- /dev/null +++ b/src/communicate/stdcvt/stdcvt_out.c @@ -0,0 +1,23 @@ +#include +#include +#include +#include +#include + +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__; +} diff --git a/src/datastruct/chain/chain_calculate.c b/src/datastruct/chain/chain_calculate.c new file mode 100644 index 0000000..64a66d3 --- /dev/null +++ b/src/datastruct/chain/chain_calculate.c @@ -0,0 +1,20 @@ +#include +#include + + +/** + 计算链表占用的内存空间大小，以字节为单位输出。 + + @param p_list 指向目标链表的指针 + @return 以字节为单位返回链表及链表内包含的节点所占的内存空间 + */ +uint64_t calListMemory(Chain * p_list){ + CNode *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; +} diff --git a/src/datastruct/chain/chain_complex.c b/src/datastruct/chain/chain_complex.c new file mode 100644 index 0000000..cf490aa --- /dev/null +++ b/src/datastruct/chain/chain_complex.c @@ -0,0 +1,116 @@ +#include +#include + + +/** + 创建一个新的且内容为链表的节点 + + @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; +} diff --git a/src/datastruct/chain/chain_find.c b/src/datastruct/chain/chain_find.c new file mode 100644 index 0000000..2af4a58 --- /dev/null +++ b/src/datastruct/chain/chain_find.c @@ -0,0 +1,198 @@ +#include +#include + + +/** + 通过节点中储存的整型值来找到链表中第一个符合条件的节点 + + @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; +} diff --git a/src/datastruct/chain/chain_get.c b/src/datastruct/chain/chain_get.c new file mode 100644 index 0000000..440bf29 --- /dev/null +++ b/src/datastruct/chain/chain_get.c @@ -0,0 +1,80 @@ +#include +#include + + +/** + 直接获取储存整型数据的节点的值 + + @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; +} diff --git a/src/datastruct/chain/chain_node.c b/src/datastruct/chain/chain_node.c new file mode 100644 index 0000000..18b1110 --- /dev/null +++ b/src/datastruct/chain/chain_node.c @@ -0,0 +1,117 @@ +#include +#include + + +/** + 直接使用一个整型值初始化一个新的节点 + + @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; +} + diff --git a/src/datastruct/chain/chain_print.c b/src/datastruct/chain/chain_print.c new file mode 100644 index 0000000..98c508a --- /dev/null +++ b/src/datastruct/chain/chain_print.c @@ -0,0 +1,179 @@ +#include +#include +#include + + +/** + 打印链表及链表中节点的相关数据 + + @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__; +} diff --git a/src/datastruct/chain/chain_sort.c b/src/datastruct/chain/chain_sort.c new file mode 100644 index 0000000..2a49ac3 --- /dev/null +++ b/src/datastruct/chain/chain_sort.c @@ -0,0 +1,61 @@ +#include +#include + +/* + *内部函数: 通过节点中的值查找相关多个节点. + *参数: 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; +} diff --git a/src/datastruct/chain/chain_update.c b/src/datastruct/chain/chain_update.c new file mode 100644 index 0000000..f12a808 --- /dev/null +++ b/src/datastruct/chain/chain_update.c @@ -0,0 +1,92 @@ +#include +#include + + +/** + 用一个整型值更新一个现有节点的值 + + @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; +} diff --git a/graph/graph.c b/src/datastruct/graph/graph.c similarity index 100% rename from graph/graph.c rename to src/datastruct/graph/graph.c diff --git a/graph/graph.h b/src/datastruct/graph/graph.h similarity index 100% rename from graph/graph.h rename to src/datastruct/graph/graph.h diff --git a/tree/tree.c b/src/datastruct/tree/tree.c similarity index 96% rename from tree/tree.c rename to src/datastruct/tree/tree.c index 87794fa..87e5e51 100644 --- a/tree/tree.c +++ b/src/datastruct/tree/tree.c @@ -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; } diff --git a/tree/tree_expand.c b/src/datastruct/tree/tree_expand.c similarity index 96% rename from tree/tree_expand.c rename to src/datastruct/tree/tree_expand.c index 5d9992d..0a584df 100644 --- a/tree/tree_expand.c +++ b/src/datastruct/tree/tree_expand.c @@ -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; diff --git a/tree/tree_expand.h b/src/datastruct/tree/tree_expand.h similarity index 97% rename from tree/tree_expand.h rename to src/datastruct/tree/tree_expand.h index bec0086..8649f82 100644 --- a/tree/tree_expand.h +++ b/src/datastruct/tree/tree_expand.h @@ -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 diff --git a/src/error/error.c b/src/error/error.c new file mode 100644 index 0000000..0d059b5 --- /dev/null +++ b/src/error/error.c @@ -0,0 +1,53 @@ +#include +#include + +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; +} diff --git a/error/error.c b/src/error/error_file.c similarity index 96% rename from error/error.c rename to src/error/error_file.c index 9756a3c..fb035ec 100644 --- a/error/error.c +++ b/src/error/error_file.c @@ -1,4 +1,4 @@ -#include "error.h" +#include int initErrorSystem(void) { error_list = initList(0); @@ -8,7 +8,9 @@ int initErrorSystem(void) { } 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); diff --git a/src/event/event_callback.c b/src/event/event_callback.c new file mode 100644 index 0000000..a703024 --- /dev/null +++ b/src/event/event_callback.c @@ -0,0 +1,131 @@ +#include +#include +#include + + +/** + 顺序遍历链表的操作函数。回调函数返回-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 指向构造的参数列表的指针 + */ +inline Chain *newCReturn(void){ + return newReturn(1, 0, NULL); +} diff --git a/id/id.c b/src/id/id.c similarity index 89% rename from id/id.c rename to src/id/id.c index a2182b0..0b2a12f 100644 --- a/id/id.c +++ b/src/id/id.c @@ -1,8 +1,50 @@ -#include "id.h" +#include +#include static _Bool if_rand = 0; -void init_rand(void) { +/* + *用当前时间初始化伪随机数发生器 + */ +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)); } @@ -17,7 +59,7 @@ unsigned long long getId(void) { return id; } -SID *initS_id(unsigned int deep_level){ +static SID *initS_id(unsigned int deep_level){ if (!if_rand){ init_rand(); if_rand = 1; @@ -197,7 +239,8 @@ char *s_idToASCIIRawString(SID * const s_id){ } } -SID *asciiRawStringToS_id(char * const string){ + +static SID *asciiRawStringToS_id(char * const string){ SID *s_id = NULL; unsigned long long string_len = strlen(string); diff --git a/id/md5.c b/src/id/md5.c similarity index 100% rename from id/md5.c rename to src/id/md5.c diff --git a/src/memory/block/block.c b/src/memory/block/block.c new file mode 100644 index 0000000..91b351f --- /dev/null +++ b/src/memory/block/block.c @@ -0,0 +1,2 @@ +#include + diff --git a/src/memory/block/block_expand.c b/src/memory/block/block_expand.c new file mode 100644 index 0000000..0284594 --- /dev/null +++ b/src/memory/block/block_expand.c @@ -0,0 +1,2 @@ +#include +#include diff --git a/src/memory/list/list_copy.c b/src/memory/list/list_copy.c new file mode 100644 index 0000000..2dc950e --- /dev/null +++ b/src/memory/list/list_copy.c @@ -0,0 +1,53 @@ +#include +#include + + +/** + 以一个已存在的链式结构节点为模板创建一个相同的新的链式结构节点 + + @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; +} diff --git a/src/memory/list/list_find.c b/src/memory/list/list_find.c new file mode 100644 index 0000000..360c462 --- /dev/null +++ b/src/memory/list/list_find.c @@ -0,0 +1,130 @@ +#include +#include + +//如果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; +} diff --git a/src/memory/list/list_info.c b/src/memory/list/list_info.c new file mode 100644 index 0000000..bf70e4a --- /dev/null +++ b/src/memory/list/list_info.c @@ -0,0 +1,25 @@ +#include +#include + + +/** + 返回链式结构的长度 + + @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. +} diff --git a/src/memory/list/list_init.c b/src/memory/list/list_init.c new file mode 100644 index 0000000..db4bfab --- /dev/null +++ b/src/memory/list/list_init.c @@ -0,0 +1,87 @@ +#include +#include + + +/** + 创建一个新的链式结构节点，并为其分配内存空间 + + @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; +} diff --git a/src/memory/list/list_insert.c b/src/memory/list/list_insert.c new file mode 100644 index 0000000..a38ef2b --- /dev/null +++ b/src/memory/list/list_insert.c @@ -0,0 +1,46 @@ +#include +#include + +/** + 在链式结构的头部插入链式结构节点 + + @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) { + 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; +} diff --git a/src/memory/list/list_print.c b/src/memory/list/list_print.c new file mode 100644 index 0000000..877f207 --- /dev/null +++ b/src/memory/list/list_print.c @@ -0,0 +1,182 @@ +#include +#include +#include + +#ifdef id_enable +#include +#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__; +} diff --git a/src/memory/list/list_release.c b/src/memory/list/list_release.c new file mode 100644 index 0000000..70d6586 --- /dev/null +++ b/src/memory/list/list_release.c @@ -0,0 +1,109 @@ +#include +#include + +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; +} diff --git a/src/memory/list/list_remove.c b/src/memory/list/list_remove.c new file mode 100644 index 0000000..e83522b --- /dev/null +++ b/src/memory/list/list_remove.c @@ -0,0 +1,86 @@ +#include +#include + +#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; +} diff --git a/src/memory/list/list_replace.c b/src/memory/list/list_replace.c new file mode 100644 index 0000000..42e4e91 --- /dev/null +++ b/src/memory/list/list_replace.c @@ -0,0 +1,30 @@ +#include +#include + +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; +} diff --git a/src/memory/list/safe_mode.c b/src/memory/list/safe_mode.c new file mode 100644 index 0000000..a5abe1a --- /dev/null +++ b/src/memory/list/safe_mode.c @@ -0,0 +1,100 @@ +#include +#include + +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; +} diff --git a/stack/stack.c b/stack/stack.c deleted file mode 100644 index 320ff40..0000000 --- a/stack/stack.c +++ /dev/null @@ -1,73 +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->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->value = NULL; - p_snode->type = VOID; - free(p_snode); - return 0; -} - -int initMallocValueForSNode(SNode *p_snode, unsigned int type, void *value) { - p_snode->type = type; - p_snode->value = value; - return 0; -} diff --git a/stack/stack.h b/stack/stack.h deleted file mode 100644 index ef36892..0000000 --- a/stack/stack.h +++ /dev/null @@ -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 */ diff --git a/stack/stack_expand.c b/stack/stack_expand.c deleted file mode 100644 index b0b3aa1..0000000 --- a/stack/stack_expand.c +++ /dev/null @@ -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; -} diff --git a/stack/stack_expand.h b/stack/stack_expand.h deleted file mode 100644 index 95978c1..0000000 --- a/stack/stack_expand.h +++ /dev/null @@ -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 */ diff --git a/test.c b/test.c deleted file mode 100644 index 3438b13..0000000 --- a/test.c +++ /dev/null @@ -1,103 +0,0 @@ -#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 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 time_avg(void){ - List *t_list = initList(0); - int64_t time_all = 0; - for(int i = 0; i < 65535; i++) insertInTail(t_list,nodeWithInt(i, 0)); - for(int i = 0; i < 65535; i++) insertInTail(t_list,nodeWithInt(i, 0)); - for(int i = 0; i < 65535; i++) insertInTail(t_list,nodeWithInt(i, 0)); - for(int i = 0; i < 65535; i++) insertInTail(t_list,nodeWithInt(i, 0)); - for(int i = 0; i < 65535; i++) insertInTail(t_list,nodeWithInt(i, 0)); - enableListQuick(t_list); - for (int i = 0; i < 100; i++){ - struct timeval start,stop; - gettimeofday(&start,0); - findByIndexForNode(t_list, 200000); - gettimeofday(&stop,0); - time_all += (int64_t)(stop.tv_usec-start.tv_usec); - - } - double avg_time = (double) (time_all/(int64_t)100); - printf("TIME: %fus\n",avg_time); - releaseList(t_list); - return 0; -} - -int main(int argc, char **argv) { - //time_avg(); - List *t_list = initList(0); - for(int i = 0; i < 65535; i++) lisrti(t_list, i); - for(int i = 0; i < 65535; i++) lisrti(t_list, i); - for(int i = 0; i < 65535; i++) lisrti(t_list, i); - for(int i = 0; i < 65535; i++) lisrti(t_list, i); - for(int i = 0; i < 65535; i++) lisrti(t_list, i); - enableListQuick(t_list); - findByIndexForNode(t_list, 300000); - lisrhi(t_list, -1); - insertBeforeNode(t_list, findByIndexForNode(t_list, 5), lni(6)); - popFromHead(t_list); - Node *p_node = findByIndexForNode(t_list, 7); - releaseList(t_list); - return 0; -} diff --git a/test.h b/test.h deleted file mode 100644 index 8993740..0000000 --- a/test.h +++ /dev/null @@ -1,17 +0,0 @@ -#ifndef TEST_H -#define TEST_H - -#include - -#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); -int time_avg(void); - -#endif // TEST_H diff --git a/test/test.c b/test/test.c new file mode 100644 index 0000000..33f2bb7 --- /dev/null +++ b/test/test.c @@ -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; +} diff --git a/test/test.h b/test/test.h new file mode 100644 index 0000000..0d51055 --- /dev/null +++ b/test/test.h @@ -0,0 +1,16 @@ +#ifndef TEST_H +#define TEST_H + +#include + +#include +#include +#include +#include +#include + +int stack(void); +int list(void); +int tree(void); + +#endif // TEST_H diff --git a/type/type.h b/type/type.h deleted file mode 100644 index 9cc4887..0000000 --- a/type/type.h +++ /dev/null @@ -1,340 +0,0 @@ -#ifndef type_h -#define type_h - -#include -#include -#include -#include -#include -#include -#include - -/* -#include -#include -#include -#include -*/ - - - - -/************************************************ - *库相关类型的编号 - ************************************************/ - -#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)) - - - - - -/************************************************ - *库相关结构的定义 - ************************************************/ - -/* - *MD5的管理及操作的结构 - */ -typedef struct md5_ctx{ - unsigned int count[2]; - unsigned int state[4]; - unsigned char buffer[64]; -}MD5_CTX; - -/* - *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; - -/* - *节点的管理及操作的结构 - */ -typedef struct Node{ - unsigned long long f_number;//长链表模式下,分派的数组节点编号 - unsigned int type;//类型 - void *value;//值指针 - struct Node *next;//指向下一个节点 - struct Node *last;//指向上一个节点 - SID *s_id; -} Node; - -/* - *单向节点的管理及操作的结构 - */ -typedef struct simple_Node{ - void *value;//值指针 - struct simple_Node *next;//指向下一个节点 -}s_Node; - -/* - *长链表模式下链表缓存块的记录结构 - */ -struct lst_std_id{ - unsigned long long start_idx; - unsigned long long end_idx; - SID *sid; -}; - -struct list_quick; - -/* - *链表的管理及操作的结构 - */ -typedef struct List{ - Node *head;//指向第一个节点 - Node *tail;//指向最后一个节点 - s_Node *s_head;//指向第一个单向节点 - s_Node *s_tail;//指向最后一个单向节点 - /*如果长链表模式开启则指向对应的长链表模式的管理结构,如果未开启则为NULL*/ - struct list_quick *p_lq; - unsigned long long length;//链表的长度 - SID *s_id; -} List; - -/* - *长链表模式下链表改动偏移量的记录结构 - */ -struct index_change{ - unsigned long long c_index;//偏移量,有正负之分 - int f_count;//偏移量所对应的数组对的节点 -}; - -/* - *长链表模式的管理及操作的结构 - */ -struct list_quick{ - Node **fn_node;//指向链表各个节点的映射数组 - unsigned long long fn_len;//映射数组的总长度 - unsigned long long rlst_len;//在映射数组实际被占用的长度 - _Bool if_sort;//链表是否有序 - unsigned int idxc_count;//链的删减增的操作次数 - struct index_change *idxc_lst[INDEX_CHANGE_MAX];//储存链表的删减增操作的记录 - FILE *fp;//链表缓存文件 - List *stdid_lst; -}; - -/* - *错误管理中信息的管理及操作的结构 - */ -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; - -/* - *错误管理中日志信息的管理及操作的结构 - */ -typedef struct Log{ - FILE *fp;//日志文件的指针 - int if_enable;//日志文件是否启用 - unsigned long int id;//日志文件的ID -}Log; - -/* - *栈节点的管理及操作的结构 - */ -typedef struct stack_node{ - unsigned int type;//栈节点的类型 - void *value;//值指针 - struct stack_node *next;//下一个栈节点 - SID *s_id;//栈节点的ID -} SNode; - -/* - *栈的管理及操作的结构 - */ -typedef struct stack{ - unsigned long long length;//栈的长度 - SNode *top;//指向栈顶的栈节点 - SID *s_id;//栈的ID -} Stack; - -/* - *超级树节点的管理及操作的结构 - */ -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; - -/* - *文件头信息的管理及操作的结构 - */ -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;//数据块的类型 - unsigned long long location;//数据块在数据文件中的定位 - char *sid;//数据块的ID - _Bool if_data;//数据块是否赋值 - unsigned int blocks_num;//数据块字节大小 - char *buff;//指向数据块储存值内存空间的指针 -}STD_BLOCKS; - -/* - *标准数据结构中数据块的连接关系的管理及操作的结构 - */ -typedef struct standard_data_connection{ - unsigned long long location;//数据块链接关系结构在文件中的定位 - char *f_sid;//前一个数据块的ID - char *s_sid;//后一个数据块的ID -}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;//标准数据结构的ID - int read_data;//标准数据结构是否已经读取完整 - unsigned int type;//标准数据结构所对应的类型 - unsigned long long size;//标准数据结构在数据文件中的大小 - unsigned long long location;//标准数据结构的头在数据文件中的定位 - _Bool lock;//标准数据文件是否被锁住 - List *pd_blocklst;//数据块储存链表 - List *pd_ctnlst;//数据块连接关系结构的储存链表 -}STD_DATA; - -#endif /* type_h */