2308miniz压缩文件的用法

参考

//创建`默认压缩`级的新压缩文档.
构 压缩型*压缩=打开压缩("福.压缩",压缩默认压缩级,'w');
{
    打开压缩项(压缩,"福1.文本");
    {
        常 符*缓冲="一些数据";
        写压缩项(压缩,缓冲,串长(缓冲));
    }
    关闭压缩项(压缩);

    打开压缩项(压缩,"福2.文本");
    {
        //合并3个文件为一个`项`并即时压缩.
        压缩项写文件(压缩,"福2.1.文本");
        压缩项写文件(压缩,"福2.2.文本");
        压缩项写文件(压缩,"福2.3.文本");
    }
    关闭压缩项(压缩);
}
关闭压缩(压缩);

//附加到现有的压缩文档.
构 压缩型*压缩=打开压缩("福.压缩",压缩默认压缩级,'a');
{
    打开压缩项(压缩,"福3.文本");
    {
        常 符*缓冲="附加数据";
        写压缩项(压缩,缓冲,串长(缓冲));
    }
    关闭压缩项(压缩);
}
关闭压缩(压缩);

//提取压缩文档包至目录.
整 提取项时(常 符*文件名,空*参){
    静 整 i=0;整 n=*(整*)参;
    打印格式("提取:%s(%d的%d)\n",文件名,++i,n);

    中 0;
}

整 参=2;
提取压缩("福.压缩","/临",提取项时,&参);

//解压缩压缩项到内存中.
空*缓冲=无效;
大小型 缓冲大小;

构 压缩型*压缩=打开压缩("福.压缩",0,'r');
{
    打开压缩项(压缩,"福1.文本");
    {
        读压缩项(压缩,&缓冲,&缓冲大小);
    }
    关闭压缩项(压缩);
}
关闭压缩(压缩);
释放(缓冲);

//(无内部分配)解压缩压缩项到内存中.
正 符*缓冲;
大小型 缓冲大小;

构 压缩型*压缩=打开压缩("福.压缩",0,'r');
{
    打开压缩项(压缩,"福1.文本");
    {
        缓冲大小=压缩项大小(压缩);
        缓冲=清零分配(的大小(正 符),缓冲大小);

        不分配读压缩项(压缩,(空*)缓冲,缓冲大小);
    }
    关闭压缩项(压缩);
}
关闭压缩(压缩);
释放(缓冲);

//使用回调提取压缩项到内存中.
构 缓冲型{
    符*数据;
    大小型 大小;
};

静 大小型 提取时(空*参,正 长 长 偏移,常 空*数据,大小型 大小){
    构 缓冲型*缓冲=(构 缓冲型*)参;
    缓冲->数据=再分配(缓冲->数据,缓冲->大小+大小+1);
    断定(无效!=缓冲->数据);

    复制内存(&(缓冲->数据[缓冲->大小]),数据,大小);
    缓冲->大小+=大小;
    缓冲->数据[缓冲->大小]=0;
    中 大小;
}

构 缓冲型 缓冲={0};
构 压缩型*压缩=打开压缩("福.压缩",0,'r');
{
    打开压缩项(压缩,"福1.文本");
    {
        提取压缩项(压缩,提取时,&缓冲);
    }
    关闭压缩项(压缩);
}
关闭压缩(压缩);

释放(缓冲.数据);

//提取压缩项到文件中.
构 压缩型*压缩=打开压缩("福.压缩",0,'r');
{
    打开压缩项(压缩,"福2.文本");
    {
        压缩项读文件(压缩,"福2.文本");
    }
    关闭压缩项(压缩);
}
关闭压缩(压缩);

//在内存中`创建`新压缩文档(流接口).
符*出缓冲=无效;
大小型 出缓冲大小=0;

常 符*进缓冲="附加数据";
构 压缩型*压缩=打开压缩流(无效,0,压缩默认压缩级,'w');
{
    打开压缩项(压缩,"福1.文本");
    {
        写压缩项(压缩,进缓冲,串长(进缓冲));
    }
    关闭压缩项(压缩);

    /*复制`压缩流`到输出*/
    复制压缩流(压缩,(空**)&出缓冲,&出缓冲大小);
}
关闭压缩流(压缩);

释放(出缓冲);
//提取压缩项到内存中(流接口).
符*缓冲=无效;
大小型 缓冲大小=0;

构 压缩型*压缩=打开压缩流(压缩流,压缩流大小,0,'r');
{
    打开压缩项(压缩,"福1.文本");
    {
        读压缩项(压缩,(空**)&缓冲,&缓冲大小);
    }
    关闭压缩项(压缩);
}
关闭压缩流(压缩);

释放(缓冲);
//所有压缩项的列表
构 压缩型*压缩=打开压缩("福.压缩",0,'r');
整 i,n=总压缩项(压缩);
对(i=0;i<n;++i){
    按索引打开压缩项(压缩,i);
    {
        常 符*名=压缩项名(压缩);
        整 是目录=压缩项是目录(压缩);
        正 长 长 大小=压缩项大小(压缩);
        正 整 循校32=循校压缩项32(压缩);
    }
    关闭压缩项(压缩);
}
关闭压缩(压缩);

//压缩目录(递归)
空 遍历压缩(构 压缩型*压缩,常 符*路径){
    目录*目录;
    构 目录项*项;
    符 全径[最大路径];
    构 状态 s;

    设置内存(全径,0,最大路径);
    目录=打开目录(路径);断定(目录);

    当((项=读目录(目录))){
      //跳过"."和".."
      如(!比较串(项->d名,".\0")||!比较串(项->d名,"..\0"))
        下;

      串几打印格式(全径,的大小(全径),"%s/%s",路径,项->d名);
      状态(全径,&s);
      如(s是目录(s.状态模式))
        遍历压缩(压缩,全径);
      异{
        打开压缩项(压缩,全径);
        压缩项写文件(压缩,全径);
        关闭压缩项(压缩);
      }
    }

    关闭目录(目录);
}

//删除压缩文档项.
符*项[]={"未用.文本","移除.初化","删.me"};

构 压缩型*压缩=打开压缩("福.压缩",0,'d');
{
    删压缩项(压缩,项,3);
}
关闭压缩(压缩);