summaryrefslogtreecommitdiffstats
path: root/src/modules/file
diff options
context:
space:
mode:
authortpearson <tpearson@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2010-02-24 02:13:59 +0000
committertpearson <tpearson@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2010-02-24 02:13:59 +0000
commita6d58bb6052ac8cb01805a48c4ad2f129126116f (patch)
treedd867a099fcbb263a8009a9fb22695b87855dad6 /src/modules/file
downloadkvirc-a6d58bb6052ac8cb01805a48c4ad2f129126116f.tar.gz
kvirc-a6d58bb6052ac8cb01805a48c4ad2f129126116f.zip
Added KDE3 version of kvirc
git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/kvirc@1095341 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'src/modules/file')
-rw-r--r--src/modules/file/Makefile.am18
-rw-r--r--src/modules/file/libkvifile.cpp1260
2 files changed, 1278 insertions, 0 deletions
diff --git a/src/modules/file/Makefile.am b/src/modules/file/Makefile.am
new file mode 100644
index 00000000..1545a63a
--- /dev/null
+++ b/src/modules/file/Makefile.am
@@ -0,0 +1,18 @@
+###############################################################################
+# KVirc IRC client Makefile - 10.03.2000 Szymon Stefanek <stefanek@tin.it>
+###############################################################################
+
+AM_CPPFLAGS = -I$(SS_TOPSRCDIR)/src/kvilib/include/ -I$(SS_TOPSRCDIR)/src/kvirc/include/ \
+$(SS_INCDIRS) $(SS_CPPFLAGS) -DGLOBAL_KVIRC_DIR=\"$(globalkvircdir)\"
+
+pluglib_LTLIBRARIES = libkvifile.la
+
+libkvifile_la_LDFLAGS = -module -avoid-version $(SS_LDFLAGS) $(SS_LIBDIRS)
+
+libkvifile_la_SOURCES = libkvifile.cpp
+libkvifile_la_LIBADD = $(SS_LIBLINK) ../../kvilib/build/libkvilib.la
+
+# noinst_HEADERS=
+
+%.moc: %.h
+ $(SS_QT_MOC) $< -o $@
diff --git a/src/modules/file/libkvifile.cpp b/src/modules/file/libkvifile.cpp
new file mode 100644
index 00000000..8b8dd9ec
--- /dev/null
+++ b/src/modules/file/libkvifile.cpp
@@ -0,0 +1,1260 @@
+//=============================================================================
+//
+// File : libkvifile.cpp
+// Creation date : Fri Nov 9 03:27:59 2001 GMT by Szymon Stefanek
+//
+// This file is part of the KVirc irc client distribution
+// Copyright (C) 2001-2005 Szymon Stefanek (pragma at kvirc dot net)
+//
+// This program is FREE software. You can redistribute it and/or
+// modify it under the terms of the GNU General Public License
+// as published by the Free Software Foundation; either version 2
+// of the License, or (at your opinion) any later version.
+//
+// This program is distributed in the HOPE that it will be USEFUL,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, write to the Free Software Foundation,
+// Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//=============================================================================
+
+#include "kvi_module.h"
+#include "kvi_fileutils.h"
+#include "kvi_locale.h"
+#include "kvi_malloc.h"
+#include "kvi_app.h"
+#include "kvi_options.h"
+#include "kvi_qcstring.h"
+
+#include "kvi_kvs_arraycast.h"
+
+#include <qfileinfo.h>
+#include "kvi_file.h"
+#include <qdir.h>
+#include <qtextstream.h>
+
+/*
+ @doc: file.copy
+ @type:
+ command
+ @title:
+ file.copy
+ @keyterms:
+ copying files
+ @short:
+ Makes a copy of a file
+ @syntax:
+ file.copy [-o] <source:string> <destination:string>
+ @switches:
+ !sw: -o | --overwrite
+ Overwrites the file even if it already exists.
+ @description:
+ Makes a copy of the <source> file as <destination>.[br]
+ If the [-o] switch is used , the <destination> file is overwritten , if already exists.[br]
+ With no [-o] switch , this command does not overwrite files.[br]
+ The destination path must be already existing: if you want to ensure this, use [fnc]$file.mkdir[/fnc] first.[br]
+ The paths (<source> and <destination>) are adjusted according to the system that KVIrc
+ is running on so you don't have to bother about portability: it *should* be automatically
+ guaranteed. Just use UNIX style paths for them.[br]
+ @seealso:
+ [cmd]file.rename[/cmd], [fnc]$file.exists[/fnc]
+*/
+
+static bool file_kvs_cmd_copy(KviKvsModuleCommandCall * c)
+{
+ QString szSrc,szDst;
+ KVSM_PARAMETERS_BEGIN(c)
+ KVSM_PARAMETER("source",KVS_PT_NONEMPTYSTRING,0,szSrc)
+ KVSM_PARAMETER("destination",KVS_PT_NONEMPTYSTRING,0,szDst)
+ KVSM_PARAMETERS_END(c)
+ KviFileUtils::adjustFilePath(szSrc);
+ KviFileUtils::adjustFilePath(szDst);
+ if(KviFileUtils::fileExists(szDst) && !c->switches()->find('o',"overwrite"))
+ {
+ c->warning(__tr2qs("Destinaion file exists: no copy made"));
+ return true;
+ }
+ if(!KviFileUtils::copyFile(szSrc,szDst))
+ {
+ c->warning(__tr2qs("Failed to copy from %Q to %Q"),&szSrc,&szDst);
+ c->warning(__tr2qs("Either the source doesn't exist or the destination can not be created"));
+ }
+ return true;
+}
+
+
+/*
+ @doc: file.addimagepath
+ @type:
+ command
+ @title:
+ file.addimagepath
+ @short:
+ Adds an image search path
+ @syntax:
+ file.addimagepath <path:string>
+ @description:
+ Adds <path> to the image search path list.[br]
+ KVIrc will look for images files (also) in that path (when a relative image file name is used).[br]
+ Yes, this function is a bit misplaced...
+ @seealso:
+ [cmd]file.delimagepath[/cmd]
+*/
+
+static bool file_kvs_cmd_addimagepath(KviKvsModuleCommandCall * c)
+{
+ QString szDst;
+ KVSM_PARAMETERS_BEGIN(c)
+ KVSM_PARAMETER("path",KVS_PT_NONEMPTYSTRING,0,szDst)
+ KVSM_PARAMETERS_END(c)
+ KviFileUtils::adjustFilePath(szDst);
+
+ QStringList::Iterator it = KVI_OPTION_STRINGLIST(KviOption_stringlistImageSearchPaths).find(szDst);
+ if(it == KVI_OPTION_STRINGLIST(KviOption_stringlistImageSearchPaths).end())
+ KVI_OPTION_STRINGLIST(KviOption_stringlistImageSearchPaths).append(szDst);
+ return true;
+}
+
+
+
+/*
+ @doc: file.delimagepath
+ @type:
+ command
+ @title:
+ file.delimagepath
+ @short:
+ Removes an image search path
+ @syntax:
+ file.delimagepath <path:string>
+ @description:
+ Removes <path> from the image search path list.[br]
+ Yes, this function is a bit misplaced...
+ @seealso:
+ [cmd]file.addimagepath[/cmd]
+*/
+
+static bool file_kvs_cmd_delimagepath(KviKvsModuleCommandCall * c)
+{
+ QString szDst;
+ KVSM_PARAMETERS_BEGIN(c)
+ KVSM_PARAMETER("path",KVS_PT_NONEMPTYSTRING,0,szDst)
+ KVSM_PARAMETERS_END(c)
+ KviFileUtils::adjustFilePath(szDst);
+
+ QStringList::Iterator it = KVI_OPTION_STRINGLIST(KviOption_stringlistImageSearchPaths).find(szDst);
+ if(it == KVI_OPTION_STRINGLIST(KviOption_stringlistImageSearchPaths).end())
+ KVI_OPTION_STRINGLIST(KviOption_stringlistImageSearchPaths).remove(szDst);
+ return true;
+}
+
+
+/*
+ @doc: file.write
+ @type:
+ command
+ @title:
+ file.write
+ @keyterms:
+ writing data to files
+ @short:
+ Writes an ascii data string to a file
+ @syntax:
+ file.write [-a] [-l] <filename:string> <data:string>
+ @switches:
+ !sw: -a | --append
+ If the file already exists, append the data instead of overwriting the original contents.
+ !sw: -l | --local-8-bit
+ Causes the file to be written in the local 8 bit character set instead of the
+ default utf8.
+ @description:
+ Writes <data> (which is an ASCII string) to the file <filename>.[br]
+ It does NOT append a traling LF character: if you want it you must explicitly specify it in the <data> parameter.[br]
+ -a causes the command to append the <data> to the file instead of overwriting the entire file.[br]
+ The path is adjusted according to the system that KVIrc
+ is running on so you don't have to bother about portability: it *should* be automatically
+ guaranteed. Just use UNIX style paths for them.[br]
+ The file is saved in utf8 unless the -l switch is specified (in that case the local 8 bit encoding is used).
+ Please note that uf8 is the only character set that preserves ALL the possible characters.
+ @seealso:
+ [cmd]file.rename[/cmd], [fnc]$file.exists[/fnc]
+*/
+
+static bool file_kvs_cmd_write(KviKvsModuleCommandCall * c)
+{
+ QString szFileName,szData;
+ KVSM_PARAMETERS_BEGIN(c)
+ KVSM_PARAMETER("filename",KVS_PT_NONEMPTYSTRING,0,szFileName)
+ KVSM_PARAMETER("data",KVS_PT_NONEMPTYSTRING,0,szData)
+ KVSM_PARAMETERS_END(c)
+ KviFileUtils::adjustFilePath(szFileName);
+
+ bool bRet;
+ if(c->switches()->find('l',"local-8-bit"))
+ bRet = KviFileUtils::writeFileLocal8Bit(szFileName,szData,c->switches()->find('a',"append"));
+ else
+ bRet = KviFileUtils::writeFile(szFileName,szData,c->switches()->find('a',"append"));
+
+ if(!bRet)
+ c->warning(__tr2qs("Failed to write to file %Q: the destination couldn't be opened"),&szFileName);
+
+ return true;
+}
+
+
+/*
+ @doc: file.rename
+ @type:
+ command
+ @title:
+ file.rename
+ @keyterms:
+ copying files
+ @short:
+ Makes a copy of a file
+ @syntax:
+ file.rename <oldname:string> <newname:string>
+ @description:
+ Renames a file from <oldname> to <newname>.[br]
+ This command can also rename directories.[br]
+ If the <newname> file already exists , this command fails.[br]
+ The paths (<oldname> and <newname>) are adjusted according to the system that KVIrc
+ is running on so you don't have to bother about portability: it *should* be automatically
+ guaranteed.Just use UNIX style paths for them.[br]
+ @seealso:
+ [cmd]file.copy[/cmd], [fnc]$file.exists[/fnc]
+*/
+
+static bool file_kvs_cmd_rename(KviKvsModuleCommandCall * c)
+{
+ QString szOld,szNew;
+ KVSM_PARAMETERS_BEGIN(c)
+ KVSM_PARAMETER("oldname",KVS_PT_NONEMPTYSTRING,0,szOld)
+ KVSM_PARAMETER("newname",KVS_PT_NONEMPTYSTRING,0,szNew)
+ KVSM_PARAMETERS_END(c)
+
+ KviFileUtils::adjustFilePath(szOld);
+ KviFileUtils::adjustFilePath(szNew);
+
+ if(KviFileUtils::fileExists(szNew))
+ c->warning(__tr2qs("Destination file exists: file not renamed"));
+
+ if(!KviFileUtils::renameFile(szOld,szNew))
+ c->warning(__tr2qs("Failed to rename %Q to %Q"),&szOld,&szNew);
+ return true;
+}
+
+
+/*
+ @doc: file.mkdir
+ @type:
+ command
+ @title:
+ file.mkdir
+ @keyterms:
+ creating directories
+ @short:
+ Creates a directory
+ @syntax:
+ file.mkdir <directory:string>
+ @description:
+ Creates the <directory>.[br]
+ The path is adjusted according to the system that KVIrc
+ is running on so you don't have to bother about portability: it *should* be automatically
+ guaranteed. Just use an UNIX style path.[br]
+ @seealso:
+ [fnc]$file.exists[/fnc]
+*/
+
+static bool file_kvs_cmd_mkdir(KviKvsModuleCommandCall * c)
+{
+ QString szDir;
+ KVSM_PARAMETERS_BEGIN(c)
+ KVSM_PARAMETER("directory",KVS_PT_NONEMPTYSTRING,0,szDir)
+ KVSM_PARAMETERS_END(c)
+ KviFileUtils::adjustFilePath(szDir);
+ if(!KviFileUtils::makeDir(szDir))
+ c->warning(__tr2qs("Failed to make the directory %Q"),&szDir);
+ return true;
+}
+
+
+
+/*
+ @doc: file.remove
+ @type:
+ command
+ @title:
+ file.remove
+ @keyterms:
+ removing files
+ @short:
+ Removes a file
+ @syntax:
+ file.remove [-q] <name:string>
+ @switches:
+ !sw: -q | --quiet
+ Suppresses any warning message
+ @description:
+ Removes the file <name>.[br]
+ -q suppresses any warning message (about non existing file , for example).[br]
+ The path is adjusted according to the system that KVIrc
+ is running on so you don't have to bother about portability: it *should* be automatically
+ guaranteed. Just use an UNIX style path.[br]
+ @seealso:
+ [fnc]$file.exists[/fnc]
+*/
+
+static bool file_kvs_cmd_remove(KviKvsModuleCommandCall * c)
+{
+ QString szName;
+ KVSM_PARAMETERS_BEGIN(c)
+ KVSM_PARAMETER("name",KVS_PT_NONEMPTYSTRING,0,szName)
+ KVSM_PARAMETERS_END(c)
+ KviFileUtils::adjustFilePath(szName);
+ if(!KviFileUtils::removeFile(szName))
+ {
+ if(!c->switches()->find('q',"quiet"))
+ c->warning(__tr2qs("Failed to remove the file %Q"),&szName);
+ }
+ return true;
+}
+
+
+/*
+ @doc: file.rmdir
+ @type:
+ command
+ @title:
+ file.rmdir
+ @keyterms:
+ removing directories
+ @short:
+ Removes a directory
+ @syntax:
+ file.rmdir [-q] <name:string>
+ @switches:
+ !sw: -q | --quiet
+ Suppresses any warning message
+ @description:
+ Removes the directory <name>.[br]
+ The directory must be empty for this command to success.[br]
+ -q suppresses any warning message (about non existing directory , for example).[br]
+ The path is adjusted according to the system that KVIrc
+ is running on so you don't have to bother about portability: it *should* be automatically
+ guaranteed. Just use an UNIX style path.[br]
+ @seealso:
+ [fnc]$file.exists[/fnc]
+ [cmd]file.remove[/cmd]
+*/
+
+static bool file_kvs_cmd_rmdir(KviKvsModuleCommandCall * c)
+{
+ QString szName;
+ KVSM_PARAMETERS_BEGIN(c)
+ KVSM_PARAMETER("name",KVS_PT_NONEMPTYSTRING,0,szName)
+ KVSM_PARAMETERS_END(c)
+ KviFileUtils::adjustFilePath(szName);
+ if(!KviFileUtils::removeDir(szName))
+ {
+ if(!c->switches()->find('q',"quiet"))
+ c->warning(__tr2qs("Failed to remove the directory %Q"),&szName);
+ }
+ return true;
+}
+
+
+/*
+ @doc: file.exists
+ @type:
+ function
+ @title:
+ $file.exists
+ @short:
+ Check if a file exists
+ @syntax:
+ <boolean> $file.exists(<filename:string>)
+ @description:
+ Returns true if the file <filename> exists (this is also valid for directories!).[br]
+ The <filename> should be an unix-style file path and is adjusted according to the system that KVIrc is running on.[br]
+*/
+
+static bool file_kvs_fnc_exists(KviKvsModuleFunctionCall * c)
+{
+ QString szName;
+ KVSM_PARAMETERS_BEGIN(c)
+ KVSM_PARAMETER("filename",KVS_PT_STRING,0,szName)
+ KVSM_PARAMETERS_END(c)
+ KviFileUtils::adjustFilePath(szName);
+ QFileInfo f(szName);
+ c->returnValue()->setBoolean(f.exists());
+ return true;
+}
+
+
+/*
+ @doc: file.type
+ @type:
+ function
+ @title:
+ $file.type
+ @short:
+ Checks the type of a path
+ @syntax:
+ <string> $file.type(<filename:string>)
+ @description:
+ Returns "f" if the <filename> points to a real file , "d" if <filename>
+ is the name of a directory or "l" if it is a symbolic link.[br]
+ The <filename> should be an unix-style file path and is adjusted according to the system that KVIrc is running on.[br]
+*/
+
+static bool file_kvs_fnc_type(KviKvsModuleFunctionCall * c)
+{
+ QString szName;
+ KVSM_PARAMETERS_BEGIN(c)
+ KVSM_PARAMETER("filename",KVS_PT_NONEMPTYSTRING,0,szName)
+ KVSM_PARAMETERS_END(c)
+ KviFileUtils::adjustFilePath(szName);
+ QFileInfo f(szName);
+ if(f.isFile())c->returnValue()->setString("f");
+ else if(f.isDir())c->returnValue()->setString("d");
+ else if(f.isSymLink())c->returnValue()->setString("l");
+ return true;
+}
+
+
+/*
+ @doc: file.size
+ @type:
+ function
+ @title:
+ $file.size
+ @short:
+ Returns the size of a file
+ @syntax:
+ <integer> $file.size(<filename:string>)
+ @description:
+ Returns the size of the file pointed by <filename>.[br]
+ If the file does not exist , this function returns 0.[br]
+ The <filename> should be an unix-style file path and is adjusted according to the system that KVIrc is running on.[br]
+*/
+
+static bool file_kvs_fnc_size(KviKvsModuleFunctionCall * c)
+{
+ QString szName;
+ KVSM_PARAMETERS_BEGIN(c)
+ KVSM_PARAMETER("filename",KVS_PT_NONEMPTYSTRING,0,szName)
+ KVSM_PARAMETERS_END(c)
+ KviFileUtils::adjustFilePath(szName);
+ QFileInfo f(szName);
+ c->returnValue()->setInteger(f.size());
+ return true;
+}
+/*
+ @doc: file.allSizese
+ @type:
+ function
+ @title:
+ $file.allSizes
+ @short:
+ Returns all sizes of a specified directory.
+ @syntax:
+ <array> $file.allSize(<dirname:string>)
+ @description:
+ Returns the size of every files of the specified directory as an array.[br]
+*/
+
+static bool file_kvs_fnc_allSizes(KviKvsModuleFunctionCall * c)
+{
+ QString szDir;
+ KVSM_PARAMETERS_BEGIN(c)
+ KVSM_PARAMETER("directory",KVS_PT_NONEMPTYSTRING,0,szDir)
+ KVSM_PARAMETERS_END(c)
+ KviFileUtils::adjustFilePath(szDir);
+
+ QDir d(szDir);
+ if(!d.exists())
+ {
+ c->warning(__tr2qs("The specified directory does not exist '%Q'"),&szDir);
+ return true;
+ }
+
+ QStringList sl;
+ sl = d.entryList(QDir::Files);
+
+ KviKvsArray * a = new KviKvsArray();
+ QString szFile;
+ if(!sl.isEmpty())
+ {
+ int idx = 0;
+ for(QStringList::Iterator it = sl.begin();it != sl.end();++it)
+ {
+ szFile=szDir+(*it);
+ QFileInfo f(szFile);
+ a->set(idx,new KviKvsVariant((kvs_int_t)f.size()));
+ idx++;
+ }
+ }
+ c->returnValue()->setArray(a);
+
+
+
+
+ return true;
+}
+
+/*
+ @doc: file.fixpath
+ @type:
+ function
+ @title:
+ $file.fixpath
+ @short:
+ Converts file paths
+ @syntax:
+ <string> $file.fixpath(<filename:string>)
+ @description:
+ Returns the <filename> adjusted to match the current operating
+ system file path conventions.[br] This means that on UNIX , a path like "C:\folder\file.mp3"
+ will be returned as "/folder/file.mp3" and vice-versa.[br]
+ There is a minor problem with unix paths converted to the windows system: unix
+ has no "drive" concept thus the unix paths do not contain a drive. KVIrc will
+ always map the paths to the "default" C: drive.[br]
+ This is a good reason to avoid using absolute hard-coded paths :).[br]
+ Please note that you DON'T NEED to call this function on paths that you
+ pass to the other file.* functions: they are adjusted automatically.[br]
+ @seealso:
+ [fnc]$file.ps[/fnc]
+*/
+
+
+static bool file_kvs_fnc_fixpath(KviKvsModuleFunctionCall * c)
+{
+ QString szName;
+ KVSM_PARAMETERS_BEGIN(c)
+ KVSM_PARAMETER("filename",KVS_PT_STRING,0,szName)
+ KVSM_PARAMETERS_END(c)
+ KviFileUtils::adjustFilePath(szName);
+ c->returnValue()->setString(szName);
+ return true;
+}
+
+
+/*
+ @doc: file.ps
+ @type:
+ function
+ @title:
+ $file.ps
+ @short:
+ Returns the file path separator
+ @syntax:
+ <string> $file.ps()
+ @description:
+ Returns the file path separator for the current operating system.[br]
+ On windows , '\' is returned , on UNIX , '/'.[br]
+ @seealso:
+ [fnc]$file.fixpath[/fnc]
+*/
+
+static bool file_kvs_fnc_ps(KviKvsModuleFunctionCall * c)
+{
+ c->returnValue()->setString(QString(QChar(KVI_PATH_SEPARATOR_CHAR)));
+ return true;
+}
+
+
+/*
+ @doc: file.ls
+ @type:
+ function
+ @title:
+ $file.ls
+ @short:
+ Returns a directory listing
+ @syntax:
+ <array> $file.ls(<directory:string>,[<flags:string>[,<namefilter:string>]])
+ @description:
+ Returns the listing of the specified directory as an array.[br]
+ The <directory> should be an unix-style file path and is adjusted according to the system that KVIrc is running on.[br]
+ <flags> may be a combination of the following characters:[br]
+ d: list directories[br]
+ f: list files[br]
+ l: list symbolic links[br]
+ r: list readable files[br]
+ w: list writeable files[br]
+ x: list executable files[br]
+ h: list hidden files[br]
+ s: list system files[br]
+ n: sort files by name[br]
+ t: sort files by file time[br]
+ b: sort files by file size[br]
+ z: put the directories first, then the files[br]
+ k: invert sort order[br]
+ i: case insensitive sort[br]
+ If <flags> is empty then a default of 'dfrwxhs'.[br]
+ If none of r,w,x is set then KVIrc sets all of them by default.[br]
+ If <namefilter> is passed then it is interpreted as a wildcard string
+ that must match the entries to be returned.[br]
+ @example:
+ [example]
+ %dir[]=$file.ls(/,"d")
+ [cmd]foreach[/cmd](%f,%dir[])echo %f
+ %dir[]=$file.ls(/usr/include,"f","t*.h");
+ [cmd]foreach[/cmd](%f,%dir[])echo %f
+ %dir[]=$file.ls($file.homedir,"dfr");
+ [cmd]foreach[/cmd](%f,%dir[])echo %f
+ [/example]
+*/
+
+static bool file_kvs_fnc_ls(KviKvsModuleFunctionCall * c)
+{
+ QString szDir,szFlags,szFilter;
+ KVSM_PARAMETERS_BEGIN(c)
+ KVSM_PARAMETER("directory",KVS_PT_NONEMPTYSTRING,0,szDir)
+ KVSM_PARAMETER("flags",KVS_PT_STRING,KVS_PF_OPTIONAL,szFlags)
+ KVSM_PARAMETER("filter",KVS_PT_STRING,KVS_PF_OPTIONAL,szFilter)
+ KVSM_PARAMETERS_END(c)
+
+ KviFileUtils::adjustFilePath(szDir);
+
+ QDir d(szDir);
+ if(!d.exists())
+ {
+ c->warning(__tr2qs("The specified directory does not exist '%Q'"),&szDir);
+ return true;
+ }
+
+#ifdef COMPILE_USE_QT4
+ QFlags<QDir::Filter> iFlags = 0;
+#else
+ int iFlags = 0;
+#endif
+ if(szFlags.isEmpty())iFlags = QDir::Dirs | QDir::Files | QDir::NoSymLinks | QDir::Readable | QDir::Writable | QDir::Executable | QDir::Hidden | QDir::System;
+ else {
+ if(szFlags.find('d',false) != -1)iFlags |= QDir::Dirs;
+ if(szFlags.find('f',false) != -1)iFlags |= QDir::Files;
+ if(szFlags.find('l',false) == -1)iFlags |= QDir::NoSymLinks;
+ if(szFlags.find('r',false) != -1)iFlags |= QDir::Readable;
+ if(szFlags.find('w',false) != -1)iFlags |= QDir::Writable;
+ if(szFlags.find('x',false) != -1)iFlags |= QDir::Executable;
+ if(szFlags.find('h',false) != -1)iFlags |= QDir::Hidden;
+ if(szFlags.find('s',false) != -1)iFlags |= QDir::System;
+ }
+#ifdef COMPILE_USE_QT4
+ QFlags<QDir::SortFlag> iSort = 0;
+#else
+ int iSort = 0;
+#endif
+ if(szFlags.isEmpty())iSort = QDir::Unsorted;
+ else {
+ if(szFlags.find('n',false) != -1)iSort |= QDir::Name;
+ if(szFlags.find('t',false) != -1)iSort |= QDir::Time;
+ if(szFlags.find('b',false) != -1)iSort |= QDir::Size;
+ if(szFlags.find('z',false) != -1)iSort |= QDir::DirsFirst;
+ if(szFlags.find('k',false) != -1)iSort |= QDir::Reversed;
+ if(szFlags.find('i',false) != -1)iSort |= QDir::IgnoreCase;
+ }
+
+ QStringList sl;
+ if(!szFilter.isEmpty())sl = d.entryList(szFilter,iFlags,iSort);
+ else sl = d.entryList(iFlags,iSort);
+
+ KviKvsArray * a = new KviKvsArray();
+ if(!sl.isEmpty())
+ {
+ int idx = 0;
+ for(QStringList::Iterator it = sl.begin();it != sl.end();++it)
+ {
+ a->set(idx,new KviKvsVariant(*it));
+ idx++;
+ }
+ }
+ c->returnValue()->setArray(a);
+
+ return true;
+}
+
+/*
+ @doc: file.read
+ @type:
+ function
+ @title:
+ $file.read
+ @short:
+ Reads a text file
+ @syntax:
+ <string> $file.read(<filename:string>[,<size:integer>[,<flags:string>]])
+ @description:
+ Reads at most <size> bytes of the file pointed by <filename>.[br]
+ <size> is an upper limit but may be not reached if the real file is smaller.[br]
+ The data read is returned as a string , so if the file contains binary data,
+ expect strange results.[br] If <size> is not specified, then KVIrc tries to read
+ the whole file up to the 1 MB limit (so if you want to read a file that is
+ bigger thatn 1 MB then you MUST specify the <size>).[br]
+ WARNING: always check the file size before attemting to read a whole file...
+ reading a CDROM iso image may sit down your system :) (and will prolly crash while
+ allocating memory , before attempting to read anything)[br]
+ An empty string is returned if a serious error occures.[br]
+ The <filename> is adjusted according to the system that KVIrc is running on.[br]
+ Flags are actually limited to the single letter 'l'. By default the file
+ is decoded from the ut8 characters set. If 'l' is present the the file
+ is decoded by using the local 8 bit character set instead.
+ @examples:
+ [example]
+ echo $file.read(/proc/cpuinfo)
+ [/example]
+ @seealso:
+ [fnc]$file.readbinary[/fnc]
+*/
+
+static bool file_kvs_fnc_read(KviKvsModuleFunctionCall * c)
+{
+ QString szNameZ;
+ kvs_uint_t uSize;
+ QString szFlags;
+ KVSM_PARAMETERS_BEGIN(c)
+ KVSM_PARAMETER("filename",KVS_PT_NONEMPTYSTRING,0,szNameZ)
+ KVSM_PARAMETER("size",KVS_PT_UINT,KVS_PF_OPTIONAL,uSize)
+ KVSM_PARAMETER("flags",KVS_PT_STRING,KVS_PF_OPTIONAL,szFlags)
+ KVSM_PARAMETERS_END(c)
+ KviFileUtils::adjustFilePath(szNameZ);
+
+ QFile f(szNameZ);
+ if(!f.open(IO_ReadOnly))
+ {
+ c->warning(__tr2qs("Can't open the file \"%Q\" for reading"),&szNameZ);
+ return true;
+ }
+
+ if(c->params()->count() < 2)uSize = 1024 * 1024; // 1 meg file default
+
+ char * buf = (char *)kvi_malloc(sizeof(char) * (uSize + 1));
+ unsigned int uReaded = 0;
+ unsigned int uRetries = 0;
+
+ while((uReaded < uSize) && (!f.atEnd()))
+ {
+ int readedNow = f.readBlock(buf + uReaded,uSize - uReaded);
+ if(readedNow < 0)
+ {
+ kvi_free(buf);
+ c->warning(__tr2qs("Read error for file %Q"),&szNameZ);
+ return true;
+ } else readedNow += uReaded;
+ uRetries ++;
+ if(uRetries > 1000)
+ {
+ // ops
+ kvi_free(buf);
+ c->warning(__tr2qs("Read error for file %Q (have been unable to read the requested size in 1000 retries)"),&szNameZ);
+ return true;
+ }
+ uReaded += readedNow;
+ }
+
+ buf[uReaded] = '\0';
+
+ if(szFlags.find('l',false) == -1)
+ c->returnValue()->setString(QString::fromUtf8(buf));
+ else
+ c->returnValue()->setString(QString::fromLocal8Bit(buf));
+
+ kvi_free(buf);
+
+ return true;
+}
+
+
+/*
+ @doc: file.readLines
+ @type:
+ function
+ @title:
+ $file.readLines
+ @short:
+ Reads lines of a text file
+ @syntax:
+ <array> $file.readLines(<filename:string>[,<startline:integer>,[<count:integer>[,<flags:string>]]])
+ @description:
+ Reads lines from the specified file and returns them as an array of strings.
+ The lines are assumed to be separated by linefeed characters (which are NOT returned).
+ Eventual terminating carriage return characters at the end of the line are stripped.
+ If <startline> is specified, then all the lines with indexes lower that <startline> are
+ discarded. If <count> is specified then a maximum of <count> lines is returned.
+ If <count> is not specified then all the lines until the end are read.
+ The <filename> is adjusted according to the system that KVIrc is running on.[br]
+ Flags are actually limited to the single letter 'l'. By default the file
+ is decoded from the ut8 characters set. If 'l' is present the the file
+ is decoded by using the local 8 bit character set instead.
+ WARNING: Always check the size of the file you're going to read: it is not
+ a good idea attempting to read a 700 MB binary file with this function since
+ it will probably sit down your system and exhaust your virtual memory.
+ @examples:
+ [example]
+ echo $file.readLines(/proc/cpuinfo)
+ [/example]
+ @seealso:
+ [fnc]$file.read[/fnc], [cmd]file.writeLines[/cmd], [fnc]$lf[/fnc]
+*/
+
+
+
+static bool file_kvs_fnc_readLines(KviKvsModuleFunctionCall * c)
+{
+ QString szName;
+ QString szFlags;
+ kvs_int_t iStartLine;
+ kvs_int_t iCount;
+ KVSM_PARAMETERS_BEGIN(c)
+ KVSM_PARAMETER("filename",KVS_PT_NONEMPTYSTRING,0,szName)
+ KVSM_PARAMETER("startline",KVS_PT_INT,KVS_PF_OPTIONAL,iStartLine)
+ KVSM_PARAMETER("count",KVS_PT_INT,KVS_PF_OPTIONAL,iCount)
+ KVSM_PARAMETER("flags",KVS_PT_STRING,KVS_PF_OPTIONAL,szFlags)
+ KVSM_PARAMETERS_END(c)
+ KviFileUtils::adjustFilePath(szName);
+
+ QFile f(szName);
+ if(!f.open(IO_ReadOnly))
+ {
+ c->warning(__tr2qs("Can't open the file \"%Q\" for reading"),&szName);
+ return true;
+ }
+
+ if(c->params()->count() < 2)iStartLine = 0;
+ if(c->params()->count() < 3)iCount = -1;
+
+ bool bLocal8Bit = szFlags.find('l',0,false) != -1;
+
+ KviKvsArray * a = new KviKvsArray();
+
+ int iIndex=0;
+
+ QTextStream stream( &f );
+
+ stream.setEncoding(bLocal8Bit ? QTextStream::Locale : QTextStream::UnicodeUTF8);
+ for(int i=0;i<iStartLine;i++)
+ stream.readLine();
+
+ if(iCount>0)
+ {
+ for(; (iCount>0 && !stream.atEnd()) ; iCount-- )
+ a->set(iIndex,new KviKvsVariant(stream.readLine()));
+ iIndex++;
+ } else {
+ while(!stream.atEnd()) {
+ a->set(iIndex,new KviKvsVariant(stream.readLine()));
+ iIndex++;
+ }
+ }
+
+ f.close();
+
+ c->returnValue()->setArray(a);
+
+ return true;
+}
+
+
+/*
+ @doc: file.writelines
+ @type:
+ command
+ @title:
+ file.writeLines
+ @short:
+ Writes an array of lines to a file
+ @syntax:
+ file.writeLines [-l] [-a] [-c] <filename:string> <lines:array>
+ @switches:
+ !sw: -l | --local-8-bit
+ Causes the lines to be saved in local 8 bit character set instead
+ of the default unicode encoding.
+ !sw: -a | --append
+ If the file already exists, then the lines are appended to the end
+ instead of overwriting the file.
+ !sw: -c | --crlf
+ The lines are separated by a carriage-return+line-feed character
+ combination, compatible with windows text mode files.
+ This is the only way to make the file readable in windows notepad, for example.
+ Please note that this is broken design: do NOT use it :)
+ !sw: -n | --no-separator
+ Do not separate the lines at all (either the separators are already
+ inside the lines array or no line separation is desired at all).
+ -n takes precedence over -c.
+ !sw: -q | --quiet
+ Don't complain if the file can't be opened: just fail silently
+ @description:
+ Writes the array of <lines> to the specified file.
+ The lines are separated by a single linefeed character (see also [fnc]$lf[/fnc])
+ unless the -c or -n switches are used. If the file already exists then it is
+ overwritten with the new data unless the -a switch is used.
+ The lines array is encoded in the ut8 character set unless the -l switch is used.
+ @seealso:
+ [fnc]$file.readLines[/fnc]
+*/
+
+
+
+static bool file_kvs_cmd_writeLines(KviKvsModuleCommandCall * c)
+{
+ QString szFile,szFlags;
+ KviKvsArrayCast a;
+ KVSM_PARAMETERS_BEGIN(c)
+ KVSM_PARAMETER("filename",KVS_PT_NONEMPTYSTRING,0,szFile)
+ KVSM_PARAMETER("lines",KVS_PT_ARRAYCAST,0,a)
+ KVSM_PARAMETERS_END(c)
+
+ KviFileUtils::adjustFilePath(szFile);
+
+ KviFile f(szFile);
+ int iFlags = IO_WriteOnly;
+
+ if(!f.openForWriting(c->switches()->find('a',"append")))
+ {
+ if(!c->switches()->find('q',"quiet"))
+ c->warning(__tr2qs("Can't open the file \"%Q\" for writing"),&szFile);
+ return true;
+ }
+
+ bool bLocal8Bit = c->switches()->find('l',"local-8-bit");
+ bool bNoSeparator = c->switches()->find('n',"no-separator");
+ bool bAddCR = c->switches()->find('c',"crlf");
+
+ unsigned int u = 0;
+ while(u < a.array()->size())
+ {
+ KviKvsVariant * v = a.array()->at(u);
+ KviQCString dat;
+ if(v)
+ {
+ QString szDat;
+ v->asString(szDat);
+ KviQCString dat = bLocal8Bit ? szDat.local8Bit() : szDat.utf8();
+ }
+ if(!bNoSeparator)
+ {
+ if(bAddCR)dat += "\r\n";
+ else dat += '\n';
+ }
+ f.writeBlock(dat.data(),dat.length());
+ u++;
+ }
+
+ f.close();
+
+ return true;
+}
+
+
+/*
+ @doc: file.localdir
+ @type:
+ function
+ @title:
+ $file.localdir
+ @short:
+ Get the KVIrc local directory
+ @syntax:
+ <string> $file.localdir([relative_path:string])
+ @description:
+ Returns the path to the KVIrc local data directory.[br]
+ The KVIrc local data directory is always writeable and contains
+ the various subdirectories that KVIrc uses internally: audio , avatars ,
+ config , help , incoming , log , modules , msgcolors and pics.[br]
+ If <relative_path> is passed , then it is appended at the end of the directory
+ to form a complete filepath.[br]
+ The path is adjusted to contain single separators suitable for the platform
+ that KVIrc is atually running on (thus you not need to care about path
+ separators in the <relative_path> , KVIrc will adjust them).[br]
+ @examples:
+ [example]
+ echo KVIrc looks for pictures in $file.localdir(pics)
+ echo panic.png would be translated to $file.localdir(pics/panic.png)
+ [/example]
+*/
+
+static bool file_kvs_fnc_localdir(KviKvsModuleFunctionCall * c)
+{
+ QString szName;
+ KVSM_PARAMETERS_BEGIN(c)
+ KVSM_PARAMETER("relative_path",KVS_PT_STRING,KVS_PF_OPTIONAL,szName)
+ KVSM_PARAMETERS_END(c)
+ if(szName.isEmpty())szName.append(KVI_PATH_SEPARATOR_CHAR);
+ QString szPath;
+ g_pApp->getLocalKvircDirectory(szPath,KviApp::None,szName);
+ KviFileUtils::adjustFilePath(szPath);
+ c->returnValue()->setString(szPath);
+ return true;
+}
+
+
+
+/*
+ @doc: file.homedir
+ @type:
+ function
+ @title:
+ $file.homedir
+ @short:
+ Get the user's HOME directory
+ @syntax:
+ <string> $file.homedir([relative_path:string])
+ @description:
+ Returns the user's HOME directory path.[br]
+ If <relative_path> is passed , then it is appended at the end of the directory
+ to form a complete filepath.[br]
+ The path is adjusted to contain single separators suitable for the platform
+ that KVIrc is atually running on (thus you not need to care about path
+ separators in the <relative_path> , KVIrc will adjust them).[br]
+*/
+
+static bool file_kvs_fnc_homedir(KviKvsModuleFunctionCall * c)
+{
+ QString szName;
+ KVSM_PARAMETERS_BEGIN(c)
+ KVSM_PARAMETER("relative_path",KVS_PT_STRING,KVS_PF_OPTIONAL,szName)
+ KVSM_PARAMETERS_END(c)
+ if(szName.isEmpty())szName.append(KVI_PATH_SEPARATOR_CHAR);
+ QString szPath = QDir::homeDirPath();
+ KviQString::ensureLastCharIs(szPath,KVI_PATH_SEPARATOR_CHAR);
+ szPath.append(szName);
+ KviFileUtils::adjustFilePath(szPath);
+ c->returnValue()->setString(szPath);
+ return true;
+}
+
+
+
+/*
+ @doc: file.rootdir
+ @type:
+ function
+ @title:
+ $file.rootdir
+ @short:
+ Get the system root directory
+ @syntax:
+ $file.rootdir(<relative_path>)
+ $file.rootdir
+ @description:
+ Returns the system's root directory (/ on UNIX and C:/ on Windows).[br]
+ If <relative_path> is passed , then it is appended at the end of the directory
+ to form a complete filepath.[br]
+ The path is adjusted to contain single separators suitable for the platform
+ that KVIrc is atually running on (thus you not need to care about path
+ separators in the <relative_path> , KVIrc will adjust them).[br]
+*/
+
+static bool file_kvs_fnc_rootdir(KviKvsModuleFunctionCall * c)
+{
+ QString szName;
+ KVSM_PARAMETERS_BEGIN(c)
+ KVSM_PARAMETER("relative_path",KVS_PT_STRING,KVS_PF_OPTIONAL,szName)
+ KVSM_PARAMETERS_END(c)
+ if(szName.isEmpty())szName.append(KVI_PATH_SEPARATOR_CHAR);
+ QString szPath = QDir::rootDirPath();
+ KviQString::ensureLastCharIs(szPath,KVI_PATH_SEPARATOR_CHAR);
+ szPath.append(szName);
+ KviFileUtils::adjustFilePath(szPath);
+ c->returnValue()->setString(szPath);
+ return true;
+}
+
+
+/*
+ @doc: file.cwd
+ @type:
+ function
+ @title:
+ $file.currentdir
+ @short:
+ Get the current directory
+ @syntax:
+ <string> $file.cwd([relative_path:string])
+ @description:
+ Returns the current working directory.[br]
+ If <relative_path> is passed , then it is appended at the end of the directory
+ to form a complete filepath.[br]
+ The path is adjusted to contain single separators suitable for the platform
+ that KVIrc is atually running on (thus you not need to care about path
+ separators in the <relative_path> , KVIrc will adjust them).[br]
+*/
+
+static bool file_kvs_fnc_cwd(KviKvsModuleFunctionCall * c)
+{
+ QString szName;
+ KVSM_PARAMETERS_BEGIN(c)
+ KVSM_PARAMETER("relative_path",KVS_PT_STRING,KVS_PF_OPTIONAL,szName)
+ KVSM_PARAMETERS_END(c)
+ if(szName.isEmpty())szName.append(KVI_PATH_SEPARATOR_CHAR);
+ QString szPath = QDir::currentDirPath();
+ KviQString::ensureLastCharIs(szPath,KVI_PATH_SEPARATOR_CHAR);
+ szPath.append(szName);
+ KviFileUtils::adjustFilePath(szPath);
+ c->returnValue()->setString(szPath);
+ return true;
+}
+
+
+/*
+ @doc: file.globaldir
+ @type:
+ function
+ @title:
+ $file.globaldir
+ @short:
+ Get the KVIrc global directory
+ @syntax:
+ $file.globaldir(<relative_path>)
+ $file.globaldir
+ @description:
+ Returns the path to the KVIrc global data directory.[br]
+ The KVIrc local data directory is always readable but usually not writeable and contains
+ the various subdirectories that KVIrc uses internally: audio , avatars ,
+ config , help , incoming , log , modules , msgcolors and pics.[br]
+ If <relative_path> is passed , then it is appended at the end of the directory
+ to form a complete filepath.[br]
+ The path is adjusted to contain single separators suitable for the platform
+ that KVIrc is atually running on (thus you not need to care about path
+ separators in the <relative_path> , KVIrc will adjust them).[br]
+ @examples:
+ [example]
+ echo KVIrc looks for pictures in $file.globaldir(pics)
+ echo panic.png would be translated to $file.globaldir(pics/panic.png)
+ [/example]
+*/
+
+static bool file_kvs_fnc_globaldir(KviKvsModuleFunctionCall * c)
+{
+ QString szName;
+ KVSM_PARAMETERS_BEGIN(c)
+ KVSM_PARAMETER("relative_path",KVS_PT_STRING,KVS_PF_OPTIONAL,szName)
+ KVSM_PARAMETERS_END(c)
+ if(szName.isEmpty())szName.append(KVI_PATH_SEPARATOR_CHAR);
+ QString szPath;
+ g_pApp->getGlobalKvircDirectory(szPath,KviApp::None,szName);
+ KviFileUtils::adjustFilePath(szPath);
+ c->returnValue()->setString(szPath);
+ return true;
+}
+
+/*
+ @doc: file.extractpath
+ @type:
+ function
+ @title:
+ $file.extractpath
+ @short:
+ Extract the path from a filename
+ @syntax:
+ <string> $file.extractpath(<filepath:string>)
+ @description:
+ Returns the path part of the <filepath> translated to match the current
+ platform filesystem conventions.[br]
+ The path will NOT contain a trailing path separator.[br]
+ For example, if <filepath> is /usr/arch/mp3/Carisma_SuonoDelSilenzio.mp3 then
+ this function will return /usr/arch/mp3 on UNIX and C:\usr\arch\mp3 on Windows.
+ @seealso:
+ [fnc]$file.extractFileName[/fnc]
+*/
+
+static bool file_kvs_fnc_extractpath(KviKvsModuleFunctionCall * c)
+{
+ QString szName;
+ KVSM_PARAMETERS_BEGIN(c)
+ KVSM_PARAMETER("filepath",KVS_PT_NONEMPTYSTRING,0,szName)
+ KVSM_PARAMETERS_END(c)
+ c->returnValue()->setString(QFileInfo(szName).dirPath(TRUE));
+ return true;
+}
+
+
+/*
+ @doc: file.extractfilename
+ @type:
+ function
+ @title:
+ $file.extractfilename
+ @short:
+ Extract the filename from a file path
+ @syntax:
+ <string> $file.extractpath(<filepath:string>)
+ @description:
+ Returns the filename part of the filepath translated to match the current
+ platform filesystem conventions.[br]
+ For example, if <filepath> is /usr/arch/mp3/Carisma_SuonoDelSilenzio.mp3 then
+ this function will return Carisma_SuonoDelSilenzio.mp3
+ @seealso:
+ [fnc]$file.extractPath[/fnc]
+*/
+
+static bool file_kvs_fnc_extractfilename(KviKvsModuleFunctionCall * c)
+{
+ QString szName;
+ KVSM_PARAMETERS_BEGIN(c)
+ KVSM_PARAMETER("filepath",KVS_PT_NONEMPTYSTRING,0,szName)
+ KVSM_PARAMETERS_END(c)
+ KviFileUtils::extractFileName(szName);
+ KviQString::cutToLast(szName,KVI_PATH_SEPARATOR_CHAR);
+ c->returnValue()->setString(szName);
+ return true;
+}
+
+
+
+static bool file_module_init(KviModule * m)
+{
+
+ KVSM_REGISTER_SIMPLE_COMMAND(m,"copy",file_kvs_cmd_copy);
+ KVSM_REGISTER_SIMPLE_COMMAND(m,"rename",file_kvs_cmd_rename);
+ KVSM_REGISTER_SIMPLE_COMMAND(m,"mkdir",file_kvs_cmd_mkdir);
+ KVSM_REGISTER_SIMPLE_COMMAND(m,"write",file_kvs_cmd_write);
+ KVSM_REGISTER_SIMPLE_COMMAND(m,"remove",file_kvs_cmd_remove);
+ KVSM_REGISTER_SIMPLE_COMMAND(m,"rmdir",file_kvs_cmd_rmdir);
+ KVSM_REGISTER_SIMPLE_COMMAND(m,"addimagepath",file_kvs_cmd_addimagepath);
+ KVSM_REGISTER_SIMPLE_COMMAND(m,"delimagepath",file_kvs_cmd_delimagepath);
+ KVSM_REGISTER_SIMPLE_COMMAND(m,"writeLines",file_kvs_cmd_writeLines);
+
+ KVSM_REGISTER_FUNCTION(m,"exists",file_kvs_fnc_exists);
+ KVSM_REGISTER_FUNCTION(m,"type",file_kvs_fnc_type);
+ KVSM_REGISTER_FUNCTION(m,"size",file_kvs_fnc_size);
+
+ KVSM_REGISTER_FUNCTION(m,"allsizes",file_kvs_fnc_allSizes);
+
+ KVSM_REGISTER_FUNCTION(m,"fixpath",file_kvs_fnc_fixpath);
+ KVSM_REGISTER_FUNCTION(m,"ps",file_kvs_fnc_ps);
+ KVSM_REGISTER_FUNCTION(m,"read",file_kvs_fnc_read);
+ KVSM_REGISTER_FUNCTION(m,"localdir",file_kvs_fnc_localdir);
+ KVSM_REGISTER_FUNCTION(m,"homedir",file_kvs_fnc_homedir);
+ KVSM_REGISTER_FUNCTION(m,"rootdir",file_kvs_fnc_rootdir);
+ KVSM_REGISTER_FUNCTION(m,"cwd",file_kvs_fnc_cwd);
+ KVSM_REGISTER_FUNCTION(m,"globaldir",file_kvs_fnc_globaldir);
+ KVSM_REGISTER_FUNCTION(m,"extractpath",file_kvs_fnc_extractpath);
+ KVSM_REGISTER_FUNCTION(m,"extractfilename",file_kvs_fnc_extractfilename);
+ KVSM_REGISTER_FUNCTION(m,"ls",file_kvs_fnc_ls);
+ KVSM_REGISTER_FUNCTION(m,"readLines",file_kvs_fnc_readLines);
+
+
+ return true;
+}
+
+static bool file_module_cleanup(KviModule *m)
+{
+ return true;
+}
+
+KVIRC_MODULE(
+ "File", // module name
+ "1.0.0", // module version
+ "Copyright (C) 2001 Szymon Stefanek (pragma at kvirc dot net)", // author & (C)
+ "Interface to the file system",
+ file_module_init,
+ 0,
+ 0,
+ file_module_cleanup
+)