TDE
/
kvirc
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/kvirc
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'd804c644a2'
${ noResults }
kvirc/src/modules/config/libkviconfig.cpp

878 lines
24 KiB
Raw Blame History

//=============================================================================
//
// File : libkviconfig.cpp
// Creation date : Thu Jan 31 2002 22:50:12 GMT by Szymon Stefanek
//
// This config is part of the KVirc irc client distribution
// Copyright (C) 2002-2005 Szymon Stefanek (pragma@kvirc.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_string.h"
#include "kvi_config.h"
#include "kvi_fileutils.h"
#include "kvi_app.h"
#include "kvi_locale.h"
#include "kvi_pointerhashtable.h"
static KviPointerHashTable<TQString,KviConfig> * g_pConfigDict = 0;
static int g_iNextConfigId = 0;
/*
@doc: config.open
@type:
function
@title:
$config.open
@short:
Opens a config file
@syntax:
$config.open(<filename:string>[,<flags:string>])
@description:
Opens a config file.
If the file already exists , its contents
are parsed and available for extracting by the [fnc]$config.read[/fnc]() function.[br]
<filename> may be an absolute path or a relative path: if a relative path is used,
KVIrc will complete it with a local kvirc directory suitable for writing script config files.[br]
If the config file doesn't exist , it is opened as empty config file.[br]
Flags can contain a combination of letters 'r' and 'w'.[br]
If only 'r' is specified , the config file is opened in "read-only" mode: no changes will be written to disk.[br]
If only 'w' is specified , the config file is opened in "write-only" mode: the contents of the file on disk
are not readed.[br]
If <flags> are not specified then 'rw' is assumed.[br]
The function returns an identifier for the open config file. This identifier
is a mandatory parameter in all the other config.* functions and commands.[br]
The config section is set to the default section name: you can change it by using
[cmd]config.setsection[/cmd].[br]
After you have finished using the file , don't forget to call [cmd]config.close[/cmd]!
KVIrc tries to not open a config file twice: if the file was already opened then
the identifier of the open file is returned.[br]
You can check if a config file is already open by using the
[fnc]$config.id[/fnc]() function.[br]
@examples:
[example]
# It is a good idea to store the returned id to a variable :)
%cfg = $config.open(myscript.kvc)
%num = [fnc]$config.read[/fnc](%cfg,Number,0)
[cmd]echo[/cmd] Number of entries is %num
%num++;
[cmd]config.write[/cmd] %cfg Number %num
[cmd]config.close[/cmd] %cfg
[/example]
@seealso:
[module:config]Config module documentation[/module]
*/
static bool config_kvs_fnc_open(KviKvsModuleFunctionCall * c)
{
TQString szFile;
TQString szMode;
KVSM_PARAMETERS_BEGIN(c)
KVSM_PARAMETER("filename",KVS_PT_STRING,0,szFile)
KVSM_PARAMETER("mode",KVS_PT_STRING,KVS_PF_OPTIONAL,szMode)
KVSM_PARAMETERS_END(c)
KviConfig::FileMode fileMode;
if(szMode.contains('r'))
{
if(szMode.contains('w'))fileMode = KviConfig::ReadWrite;
else fileMode = KviConfig::Read;
} else {
if(szMode.contains('w'))fileMode = KviConfig::Write;
else fileMode = KviConfig::ReadWrite;
}
KviFileUtils::adjustFilePath(szFile);
TQString szAbsFile;
if(KviFileUtils::isAbsolutePath(szFile))szAbsFile = szFile;
else g_pApp->getLocalKvircDirectory(szAbsFile,KviApp::ConfigScripts,szFile,true);
KviPointerHashTableIterator<TQString,KviConfig> it(*g_pConfigDict);
while(it.current())
{
if(KviTQString::equalCI(it.current()->fileName(),szAbsFile))
{
c->returnValue()->setString(it.currentKey());
if(it.current()->readOnly() && (fileMode & KviConfig::Write))
{
it.current()->setReadOnly(false);
}
return true;
}
++it;
}
KviConfig * cfg = new KviConfig(szAbsFile,fileMode);
g_iNextConfigId++;
TQString tmp = TQString("%1").tqarg(g_iNextConfigId);
g_pConfigDict->insert(tmp,cfg);
c->returnValue()->setString(tmp);
return true;
}
/*
@doc: config.id
@type:
function
@title:
$config.id
@short:
Returns the id of an open config file
@syntax:
$config.id(<filename>)
@description:
Returns the id of an open config file specified by <filename>.[br]
(This is the same id that is returned by [fnc]$config.open[/fnc].[br]
If no such file is open, 0 is returned (that is an invalid config identifier).[br]
@seealso:
[module:config]Config module documentation[/module]
*/
static bool config_kvs_fnc_id(KviKvsModuleFunctionCall * c)
{
TQString szFile;
KVSM_PARAMETERS_BEGIN(c)
KVSM_PARAMETER("file",KVS_PT_STRING,0,szFile)
KVSM_PARAMETERS_END(c)
KviFileUtils::adjustFilePath(szFile);
TQString szAbsFile;
if(KviFileUtils::isAbsolutePath(szFile))szAbsFile = szFile;
else g_pApp->getLocalKvircDirectory(szAbsFile,KviApp::ConfigScripts,szFile,true);
KviPointerHashTableIterator<TQString,KviConfig> it(*g_pConfigDict);
while(it.current())
{
if(KviTQString::equalCI(it.current()->fileName(),szAbsFile))
{
c->returnValue()->setString(it.currentKey());
return true;
}
++it;
}
c->returnValue()->setString("0");
return true;
}
/*
@doc: config.read
@type:
function
@title:
$config.read
@short:
Reads an entry from a config file
@syntax:
$config.read(<id:string>,<key:string>[,<default:string>])
@description:
Reads and returns the value associated to <key> in the current section of the config
file identified by <id>.[br]
<id> must be a valid config identifier returned by [fnc]$config.open[/fnc]()
If no value is associated with <key> in the current section the return value
is an empty string or the string <default> if it has been passed.[br]
@seealso:
[module:config]Config module documentation[/module]
*/
static bool config_kvs_fnc_read(KviKvsModuleFunctionCall * c)
{
TQString szId;
TQString szKey;
TQString szDefault;
KVSM_PARAMETERS_BEGIN(c)
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
KVSM_PARAMETER("key",KVS_PT_STRING,0,szKey)
KVSM_PARAMETER("default",KVS_PT_STRING,KVS_PF_OPTIONAL,szDefault)
KVSM_PARAMETERS_END(c)
KviConfig * cfg = g_pConfigDict->find(szId);
if(cfg)
{
c->returnValue()->setString(cfg->readEntry(szKey,szDefault));
} else {
c->warning(__tr2qs("The config file with id '%Q' is not open"),&szId);
}
return true;
}
/*
@doc: config.section
@type:
function
@title:
$config.section
@short:
Returns the name of the current section of a config file
@syntax:
$config.section(<id>)
@description:
Returns the name of the current section in the config file identifier by <id>.[br]
<id> must be a valid config identifier returned by [fnc]$config.open[/fnc]()
@seealso:
[module:config]Config module documentation[/module]
*/
static bool config_kvs_fnc_section(KviKvsModuleFunctionCall * c)
{
TQString szId;
KVSM_PARAMETERS_BEGIN(c)
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
KVSM_PARAMETERS_END(c)
KviConfig * cfg = g_pConfigDict->find(szId);
if(cfg)
{
c->returnValue()->setString(cfg->group());
} else {
c->warning(__tr2qs("The config file with id '%Q' is not open"),&szId);
}
return true;
}
/*
@doc: config.readonly
@type:
function
@title:
$config.readonly
@short:
Checks wheter a config file is opened in readonly mode
@syntax:
$config.readonly(<id>)
@description:
Returns 1 if the config file identified by <id> is opened in readonly mode,
0 otherwise.[br]
<id> must be a valid config identifier returned by [fnc]$config.open[/fnc]()
If <id> does not identify an open config file, a warning is printed and 0 is returned.[br]
@seealso:
[module:config]Config module documentation[/module]
*/
static bool config_kvs_fnc_readonly(KviKvsModuleFunctionCall * c)
{
TQString szId;
KVSM_PARAMETERS_BEGIN(c)
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
KVSM_PARAMETERS_END(c)
KviConfig * cfg = g_pConfigDict->find(szId);
if(cfg)
{
c->returnValue()->setBoolean(cfg->readOnly());
} else {
c->warning(__tr2qs("The config file with id '%Q' is not open"),&szId);
c->returnValue()->setInteger(false);
}
return true;
}
/*
@doc: config.filename
@type:
function
@title:
$config.filename
@short:
Returns the filename of an open config file
@syntax:
$config.filename(<id>)
@description:
Returns the filename of the [b]open[/b] config file identifier by <id>.[br]
<id> must be a valid config identifier returned by [fnc]$config.open[/fnc]()
If the <id> doesn't match any open file, and empty string is returned.[br]
@seealso:
[module:config]Config module documentation[/module]
*/
static bool config_kvs_fnc_filename(KviKvsModuleFunctionCall * c)
{
TQString szId;
KVSM_PARAMETERS_BEGIN(c)
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
KVSM_PARAMETERS_END(c)
KviConfig * cfg = g_pConfigDict->find(szId);
if(cfg)
{
c->returnValue()->setString(cfg->fileName());
}
return true;
}
/*
@doc: config.hassection
@type:
function
@title:
$config.hassection
@short:
Checks wheter a section is present in a config file
@syntax:
$config.hassection(<id>,<section_name>)
@description:
Returns 1 if the section <section_name> exists in the config file identifier by <id>,
0 otherwise.[br]
<id> must be a valid config identifier returned by [fnc]$config.open[/fnc]()
@seealso:
[module:config]Config module documentation[/module]
*/
static bool config_kvs_fnc_hassection(KviKvsModuleFunctionCall * c)
{
TQString szId;
TQString szSect;
KVSM_PARAMETERS_BEGIN(c)
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
KVSM_PARAMETER("id",KVS_PT_STRING,0,szSect)
KVSM_PARAMETERS_END(c)
KviConfig * cfg = g_pConfigDict->find(szId);
if(cfg)
{
c->returnValue()->setBoolean(cfg->hasGroup(szSect));
} else {
c->warning(__tr2qs("The config file with id '%Q' is not open"),&szId);
}
return true;
}
/*
@doc: config.sectionlist
@type:
function
@title:
$config.sectionlist
@short:
Returns a list of the sections in a config file
@syntax:
$config.sectionlist(<id>)
@description:
Returns an array of sections present in the config file identified by <id>.[br]
<id> must be a valid config identifier returned by [fnc]$config.open[/fnc]()
@seealso:
[module:config]Config module documentation[/module]
*/
static bool config_kvs_fnc_sectionlist(KviKvsModuleFunctionCall * c)
{
TQString szId;
KVSM_PARAMETERS_BEGIN(c)
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
KVSM_PARAMETERS_END(c)
KviConfig * cfg = g_pConfigDict->find(szId);
if(cfg)
{
KviConfigIterator it(*(cfg->dict()));
KviKvsArray* pArray = new KviKvsArray();
int id=0;
while(it.current())
{
pArray->set(id++, new KviKvsVariant(it.currentKey()));
++it;
}
c->returnValue()->setArray(pArray);
} else {
c->warning(__tr2qs("The config file with id '%Q' is not open"),&szId);
}
return true;
}
/*
@doc: config.keylist
@type:
function
@title:
$config.keylist
@short:
Returns a list of keys in a config file
@syntax:
$config.keylist(<id>)
@description:
Returns an array of keys present in the current section of the config file identified by <id>.[br]
<id> must be a valid config identifier returned by [fnc]$config.open[/fnc]()
@seealso:
[module:config]Config module documentation[/module]
*/
static bool config_kvs_fnc_keylist(KviKvsModuleFunctionCall * c)
{
TQString szId;
KVSM_PARAMETERS_BEGIN(c)
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
KVSM_PARAMETERS_END(c)
KviConfig * cfg = g_pConfigDict->find(szId);
if(cfg)
{
KviConfigGroup * d = cfg->dict()->find(cfg->group());
if(!d)return true;
KviConfigGroupIterator it(*d);
KviKvsArray* pArray = new KviKvsArray();
int id=0;
while(it.current())
{
pArray->set(id++, new KviKvsVariant(it.currentKey()));
++it;
}
c->returnValue()->setArray(pArray);
} else {
c->warning(__tr2qs("The config file with id '%Q' is not open"),&szId);
}
return true;
}
/*
@doc: config.filelist
@type:
function
@title:
$config.filelist
@short:
Returns a list of open config files
@syntax:
$config.filelist
@description:
Returns an array of open config files.[br]
@seealso:
[module:config]Config module documentation[/module]
*/
static bool config_kvs_fnc_filelist(KviKvsModuleFunctionCall * c)
{
KVSM_PARAMETERS_BEGIN(c)
KVSM_PARAMETERS_END(c)
KviKvsArray* pArray = new KviKvsArray();
int id=0;
KviPointerHashTableIterator<TQString,KviConfig> it(*g_pConfigDict);
while(it.current())
{
pArray->set(id++, new KviKvsVariant(it.currentKey()));
++it;
}
c->returnValue()->setArray(pArray);
return true;
}
/*
@doc: config.close
@type:
command
@title:
config.close
@keyterms:
storing & reading configuration entries
@short:
Closes a config file
@syntax:
config.close [-q] <id>
@description:
Closes the config file identified by <id>.[br]
<id> must be a a valid config file identifier returned by [fnc]$config.open[/fnc].[br]
If the config file was opened as read-write (default), the changes will be stored
to disk. If the config was opened as read-only , changes will not be written.[br]
If the <id> does not match any open config file, a warning is printed unless
the -q switch is used.[br]
@seealso:
[module:config]Config module documentation[/module]
*/
static bool config_kvs_cmd_close(KviKvsModuleCommandCall * c)
{
TQString szId;
KVSM_PARAMETERS_BEGIN(c)
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
KVSM_PARAMETERS_END(c)
KviConfig * cfg = g_pConfigDict->find(szId);
if(cfg)
{
if(cfg->dirty() && cfg->readOnly())
{
if(!c->hasSwitch('q',"quiet"))
c->warning(__tr2qs("The config file '%Q' has been changed but is opened as read-only: changes will be lost"),&cfg->fileName());
}
g_pConfigDict->remove(szId);
} else {
if(!c->hasSwitch('q',"quiet"))
c->warning(__tr2qs("The config file with id '%Q' is not open"),&szId);
}
return true;
}
/*
@doc: config.flush
@type:
command
@title:
config.flush
@keyterms:
storing & reading configuration entries
@short:
Flushes a config file
@syntax:
config.flush <id>
@description:
Flushes the config file identified by <id>.[br]
<id> must be a a valid config file identifier returned by [fnc]$config.open[/fnc].[br]
If the config file was opened as read-write (default), the changes will be stored
to disk. If the config was opened as read-only ,an error is printed.[br]
If the <id> does not match any open config file, a warning is printed.
@seealso:
[module:config]Config module documentation[/module]
*/
static bool config_kvs_cmd_flush(KviKvsModuleCommandCall * c)
{
TQString szId;
KVSM_PARAMETERS_BEGIN(c)
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
KVSM_PARAMETERS_END(c)
KviConfig * cfg = g_pConfigDict->find(szId);
if(cfg)
{
if(cfg->readOnly())
c->warning(__tr2qs("The config file with id '%Q' is read only"),&szId);
else
cfg->sync();
} else {
c->warning(__tr2qs("The config file with id '%Q' is not open"),&szId);
}
return true;
}
/*
@doc: config.clear
@type:
command
@title:
config.clear
@keyterms:
storing & reading configuration entries
@short:
Clears a config file
@syntax:
config.clear <id>
@description:
Clears the contents of the config file identified by <id>.[br]
All the sections are removed (except for the default section) and all the key=value
pairs are destroyed.[br]
<id> must be a a valid config file identifier returned by [fnc]$config.open[/fnc].[br]
If the <id> does not match any open config file, a warning is printed.
@seealso:
[module:config]Config module documentation[/module]
*/
static bool config_kvs_cmd_clear(KviKvsModuleCommandCall * c)
{
TQString szId;
KVSM_PARAMETERS_BEGIN(c)
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
KVSM_PARAMETERS_END(c)
KviConfig * cfg = g_pConfigDict->find(szId);
if(cfg)
{
cfg->clear();
} else {
c->warning(__tr2qs("The config file with id '%Q' is not open"),&szId);
}
return true;
}
/*
@doc: config.clearsection
@type:
command
@title:
config.clearsection
@keyterms:
storing & reading configuration entries
@short:
Clears a section in a config file
@syntax:
config.clearsection <id> <section_name>
@description:
Clears the contents of the section <section_name> in the config file identified by <id>.[br]
All the key=value pairs in the section are destroyed.[br]
<id> must be a a valid config file identifier returned by [fnc]$config.open[/fnc].[br]
If the <id> does not match any open config file, a warning is printed.
If <section_name> was also the current section, the current section is set to the default one.[br]
No warning is printed if the section wasn't existing.[br]
@seealso:
[module:config]Config module documentation[/module]
*/
static bool config_kvs_cmd_clearsection(KviKvsModuleCommandCall * c)
{
TQString szId;
TQString szSect;
KVSM_PARAMETERS_BEGIN(c)
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
KVSM_PARAMETER("section",KVS_PT_STRING,0,szSect)
KVSM_PARAMETERS_END(c)
KviConfig * cfg = g_pConfigDict->find(szId);
if(cfg)
{
cfg->clearGroup(szSect);
} else {
c->warning(__tr2qs("The config file with id '%Q' is not open"),&szId);
}
return true;
}
/*
@doc: config.write
@type:
command
@title:
config.write
@keyterms:
storing & reading configuration entries
@short:
Writes a data field to a config file
@syntax:
config.write <id> <key> <value>
@description:
Writes the <key>=<value> pair to the config file identifier by <id>.[br]
<id> must be a valid config file id returned by [fnc]$config.open[/fnc]().[br]
<key> and <value> can be any strings.[br]
The <key>=<value> pair is written in the current section of the config file.[br]
If <key> already exists in the current section of the config , the corresponding value is replaced with <value>.[br]
If <value> is an empty string, the <key> is simply removed from the current section.[br]
If a section remains empty (with no keys) at file write time, that section will be removed.[br]
The changes are NOT written to disk: you must call [cmd]config.flush[/cmd] or (better) [cmd]config.close[/cmd]
for the changes to be effectively written.[br]
@seealso:
[module:config]Config module documentation[/module]
*/
static bool config_kvs_cmd_write(KviKvsModuleCommandCall * c)
{
TQString szId;
TQString szKey;
TQString szVal;
KVSM_PARAMETERS_BEGIN(c)
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
KVSM_PARAMETER("key",KVS_PT_STRING,0,szKey)
KVSM_PARAMETER("value",KVS_PT_STRING,0,szVal)
KVSM_PARAMETERS_END(c)
KviConfig * cfg = g_pConfigDict->find(szId);
if(cfg)
{
cfg->writeEntry(szKey,szVal);
} else {
c->warning(__tr2qs("The config file with id '%Q' is not open"),&szId);
}
return true;
}
/*
@doc: config.setsection
@type:
command
@title:
config.setsection
@keyterms:
storing & reading configuration entries
@short:
Changes the current section of a config file
@syntax:
config.setsection <id> <section_name>
@description:
Changes the current section of the config file <id> to <section_name>.[br]
Sections are effectively namespaces for the keys: each section can contain
a set of keys and equal keys in different sections do not collide.[br]
<id> must be a valid config file id returned by [fnc]$config.open[/fnc]().[br]
@seealso:
[module:config]Config module documentation[/module]
*/
static bool config_kvs_cmd_setsection(KviKvsModuleCommandCall * c)
{
TQString szId;
TQString szSect;
KVSM_PARAMETERS_BEGIN(c)
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
KVSM_PARAMETER("section",KVS_PT_STRING,0,szSect)
KVSM_PARAMETERS_END(c)
KviConfig * cfg = g_pConfigDict->find(szId);
if(cfg)
{
cfg->setGroup(szSect);
} else {
c->warning(__tr2qs("The config file with id '%Q' is not open"),&szId);
}
return true;
}
/*
@doc: config
@type:
module
@short:
Managing of configuration files
@title:
The config module
@body:
The config module is a powerful interface that manages text configuration files.[br]
The files are arranged in named sections and the data is stored in key=value pairs
belonging to each section.[br]
[br]
[section1_name][br]
<key1>=<value1>[br]
<key2>=<value2>[br]
<key3>=<value3>[br]
....[br]
[section2_name][br]
<key1>=<value1>[br]
....[br]
[br]
Keys and values are plain text strings. Eventual newlines in values are encoded using
a simple hexadecimal notation.[br]
The config files can be also edited by using any text editor.[br]
The config module works on config files loaded in memory. For this reason,
you must first open a config file by the means of [fnc]$config.open[/fnc]().[br]
Once you open the file , if it exists on disk , its contents are loaded into memory
and you can access the data stored in it. If the file wasn't existing, and empty
memory config file is created.[br]
The config file is opened in read-write mode by default. You can also choose
the "read-only" method: a read-only config file is never flushed to disk (but you can
set the values in memory!).[br]
It is not a good idea to keep a config file open forever: a good approach
is to keep settings in memory variables and write them all at once when it comes to
write settings: you open the config file , write all your values and close the file.[br]
You can obviously keep the config file open for some time but remember that
no change is written to the disk until [cmd]config.flush[/cmd] or [cmd]config.close[/cmd] is called.[br]
You write entries by using [cmd]config.write[/cmd] and read them by using [fnc]$config.read[/fnc]().[br]
You can change the "current" config section by using [cmd]config.setsection[/cmd].[br]
Here comes a complete list of commands and functions exported by this module:[br]
[fnc]$config.open[/fnc][br]
[fnc]$config.read[/fnc][br]
[fnc]$config.section[/fnc][br]
[fnc]$config.hassection[/fnc][br]
[fnc]$config.sectionlist[/fnc][br]
[fnc]$config.keylist[/fnc][br]
[fnc]$config.filelist[/fnc][br]
[fnc]$config.filename[/fnc][br]
[fnc]$config.id[/fnc][br]
[fnc]$config.readonly[/fnc][br]
[cmd]config.close[/cmd][br]
[cmd]config.flush[/cmd][br]
[cmd]config.clear[/cmd][br]
[cmd]config.clearsection[/cmd][br]
[cmd]config.setsection[/cmd][br]
[cmd]config.write[/cmd][br]
*/
static bool config_module_init(KviModule * m)
{
g_pConfigDict = new KviPointerHashTable<TQString,KviConfig>;
g_pConfigDict->setAutoDelete(true);
KVSM_REGISTER_FUNCTION(m,"open",config_kvs_fnc_open);
KVSM_REGISTER_FUNCTION(m,"id",config_kvs_fnc_id);
KVSM_REGISTER_FUNCTION(m,"read",config_kvs_fnc_read);
KVSM_REGISTER_FUNCTION(m,"section",config_kvs_fnc_section);
KVSM_REGISTER_FUNCTION(m,"hassection",config_kvs_fnc_hassection);
KVSM_REGISTER_FUNCTION(m,"sectionlist",config_kvs_fnc_sectionlist);
KVSM_REGISTER_FUNCTION(m,"keylist",config_kvs_fnc_keylist);
KVSM_REGISTER_FUNCTION(m,"filelist",config_kvs_fnc_filelist);
KVSM_REGISTER_FUNCTION(m,"filename",config_kvs_fnc_filename);
KVSM_REGISTER_FUNCTION(m,"readonly",config_kvs_fnc_readonly);
KVSM_REGISTER_SIMPLE_COMMAND(m,"close",config_kvs_cmd_close);
KVSM_REGISTER_SIMPLE_COMMAND(m,"flush",config_kvs_cmd_flush);
KVSM_REGISTER_SIMPLE_COMMAND(m,"clear",config_kvs_cmd_clear);
KVSM_REGISTER_SIMPLE_COMMAND(m,"clearsection",config_kvs_cmd_clearsection);
KVSM_REGISTER_SIMPLE_COMMAND(m,"setsection",config_kvs_cmd_setsection);
KVSM_REGISTER_SIMPLE_COMMAND(m,"write",config_kvs_cmd_write);
return true;
}
static bool config_module_cleanup(KviModule *m)
{
delete g_pConfigDict;
g_pConfigDict = 0;
return true;
}
static bool config_module_can_unload(KviModule *m)
{
return g_pConfigDict->isEmpty();
}
KVIRC_MODULE(
"Config", // module name
"1.0.0", // module version
"Copyright (C) 2001 Szymon Stefanek (pragma at kvirc dot net)", // author & (C)
"Config file system for KVIrc",
config_module_init,
config_module_can_unload,
0,
config_module_cleanup
)
View Git Blame Copy Permalink