size_t JsonWriteJoinReply(char* dest, size_t maxLen, const char* userId, int reply, int nonce)
{
JsonWriter writer(dest, maxLen);
{
WriteObject obj(writer);
WriteKey(writer, "cmd");
if (reply == DISCORD_REPLY_YES) {
writer.String("SEND_ACTIVITY_JOIN_INVITE");
}
else {
writer.String("CLOSE_ACTIVITY_JOIN_REQUEST");
}
WriteKey(writer, "args");
{
WriteObject args(writer);
WriteKey(writer, "user_id");
writer.String(userId);
}
JsonWriteNonce(writer, nonce);
}
return writer.Size();
}
bool StoreBeaconKeys(
const std::string &cpid,
const std::string &pubKey,
const std::string &privKey)
{
if ( !WriteKey("publickey" + cpid + GetNetSuffix(), pubKey)
|| !WriteKey("privatekey" + cpid + GetNetSuffix(), privKey)
)
return false;
else
return true;
}
size_t JsonWriteHandshakeObj(char* dest, size_t maxLen, int version, const char* applicationId)
{
JsonWriter writer(dest, maxLen);
{
WriteObject obj(writer);
WriteKey(writer, "v");
writer.Int(version);
WriteKey(writer, "client_id");
writer.String(applicationId);
}
return writer.Size();
}
static void JsonWriteNonce(JsonWriter& writer, int nonce)
{
WriteKey(writer, "nonce");
char nonceBuffer[32];
NumberToString(nonceBuffer, nonce);
writer.String(nonceBuffer);
}
size_t JsonWriteUnsubscribeCommand(char* dest, size_t maxLen, int nonce, const char* evtName)
{
JsonWriter writer(dest, maxLen);
{
WriteObject obj(writer);
JsonWriteNonce(writer, nonce);
WriteKey(writer, "cmd");
writer.String("UNSUBSCRIBE");
WriteKey(writer, "evt");
writer.String(evtName);
}
return writer.Size();
}
void _cdecl CScript::WriteKeyFormat( LPCTSTR pszKey, LPCTSTR pszVal, ... )
{
ADDTOCALLSTACK_INTENSIVE("CScript::WriteKeyFormat");
TemporaryString pszTemp;
va_list vargs;
va_start( vargs, pszVal );
_vsnprintf(pszTemp, pszTemp.realLength(), pszVal, vargs);
WriteKey(pszKey, pszTemp);
va_end( vargs );
}
static void
InsertSectionKey (const char *section, const char *var,
const char *var_name, FILE * file, int saut)
{
if (saut)
fwrite ("\n", 1, 1, file);
fwrite ("*", 1, 1, file);
fwrite (section, strlen (section), 1, file);
fwrite ("?\n", 2, 1, file);
WriteKey (var, var_name, file);
}
void IniFile::WriteEntryAsString ( wchar_t *section, wchar_t *entry, wchar_t *value)
{
// sets an entry in a dictionary. If the given entry can be found in the dictionary, it is
// modified to contain the provided value. If it cannot be found, it is created.
int length;
int i;
wchar_t key[256];
if (section == NULL)
section = INIFile_default_section; // if no section was provided, use empty section name
// if we were given an entry, build a key as section#entry
if (entry != NULL)
{
WriteKey ( section, NULL); // create the section if it doesn't exist
swprintf (key, 256, L"%s%c%s", section, INI_SECTION_SEPARATOR, entry); // compose the key
i = (int) wcslen (key); // get the key string length
if (i < sizeof (key))
length = i;
else
length = sizeof (key) - 1; // clamp it to a max value
// for each character in the string after the section separator...
for (i = (int) wcslen (section) + 1; i < length; i++)
key[i] = towlower (key[i]); // convert it to lowercase
key[i] = 0; // terminate the string
}
// else it must be a section name
else
wcscpy_s (key, 256, section); // copy the name into the key
WriteKey ( key, value); // write the new key in the dictionary
return; // finished
}
WrittenArraySampleIDPtr
WriteStringArrayT( WrittenArraySampleMap &iMap,
hid_t iGroup,
const std::string &iName,
const AbcA::ArraySample &iSamp,
const AbcA::ArraySample::Key &iKey,
int iCompressionLevel )
{
// because strings are packed together, always write out the dimensions
Dimensions dims = iSamp.getDimensions();
ABCA_ASSERT( dims.rank() > 0,
"String type can not have a rank-0 array sample" );
std::string dimsName = iName + ".dims";
WriteDimensions( iGroup, dimsName, dims );
// See whether or not we've already stored this.
WrittenArraySampleIDPtr writeID = iMap.find( iKey );
if ( writeID )
{
CopyWrittenArray( iGroup, iName, writeID );
return writeID;
}
// Okay, need to actually store it.
// It will be a dataset with an internal attribute for storing
// the hash id.
bool hasData = dims.numPoints() > 0;
hid_t dspaceId = -1;
Dimensions wdims; // Used to store the "fake" dimensions.
std::vector<CharT> charBuffer;
// Get the dimensions, validate sample size.
if ( hasData )
{
size_t extent = iSamp.getDataType().getExtent();
size_t numStrings = dims.numPoints() * extent;
ABCA_ASSERT( dims.rank() > 0 && numStrings > 0,
"Degenerate array sample in WriteStringArrayT" );
// Get the data out of the array sample.
const StringT *strings =
reinterpret_cast<const StringT *>( iSamp.getData() );
ABCA_ASSERT( strings,
"Degenerate strings in WriteStringArrayT" );
// Compact the strings in the string array.
CompactStrings( strings, numStrings, charBuffer );
// Create the dataspace.
size_t len = charBuffer.size();
assert( len >= numStrings );
wdims = Dimensions( len );
HDimensions hdims( wdims );
dspaceId = H5Screate_simple( hdims.rank(),
hdims.rootPtr(), NULL );
}
else
{
dspaceId = H5Screate( H5S_NULL );
}
ABCA_ASSERT( dspaceId >= 0,
"WriteStringsT() Failed in dataspace constructor" );
DspaceCloser dspaceCloser( dspaceId );
hid_t dsetId = -1;
if ( iCompressionLevel >= 0 && hasData )
{
// Make a compression plist
hid_t zipPlist = DsetGzipCreatePlist( wdims,
iCompressionLevel > 9 ? 9 : iCompressionLevel );
PlistCloser plistCloser( zipPlist );
//std::cout << "Creating compressed data set named: "
// << iName << " in group named: " << iGroup.name()
// << std::endl;
// Make the dataset.
dsetId = H5Dcreate2( iGroup, iName.c_str(), GetFileDtype<CharT>(),
dspaceId, H5P_DEFAULT, zipPlist, H5P_DEFAULT );
}
else
{
//std::cout << "Creating uncompressed data set named: "
// << iName << " in group named: " << iGroup.name()
// << std::endl;
dsetId = H5Dcreate2( iGroup, iName.c_str(), GetFileDtype<CharT>(),
dspaceId, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT );
}
DsetCloser dsetCloser(dsetId);
ABCA_ASSERT( dsetId >= 0,
"WriteArray() Failed in dataset constructor" );
// Write the data.
if ( hasData )
{
H5Dwrite( dsetId, GetNativeDtype<CharT>(), H5S_ALL,
H5S_ALL, H5P_DEFAULT, &charBuffer.front() );
}
// Write the key
WriteKey( dsetId, "key", iKey );
writeID.reset( new WrittenArraySampleID( iKey, dsetId ) );
iMap.store( writeID );
// Return the reference.
return writeID;
}
int GTIFWriteKeys(GTIF *gt)
{
int i;
GeoKey *keyptr;
KeyEntry *entptr;
KeyHeader *header;
TempKeyData tempData;
int sortkeys[MAX_KEYS];
if (!(gt->gt_flags & FLAG_FILE_MODIFIED)) return 1;
if( gt->gt_tif == NULL )
return 0;
tempData.tk_asciiParams = 0;
tempData.tk_asciiParamsLength = 0;
tempData.tk_asciiParamsOffset = 0;
/* Sort the Keys into numerical order */
if (!SortKeys(gt,sortkeys))
{
/* XXX error: a key was not recognized */
}
/* Set up header of ProjectionInfo tag */
header = (KeyHeader *)gt->gt_short;
header->hdr_num_keys = (pinfo_t) gt->gt_num_keys;
header->hdr_version = GvCurrentVersion;
header->hdr_rev_major = GvCurrentRevision;
header->hdr_rev_minor = GvCurrentMinorRev;
/* Sum up the ASCII tag lengths */
for (i = 0; i < gt->gt_num_keys; i++)
{
keyptr = gt->gt_keys + sortkeys[i];
if (keyptr->gk_type == TYPE_ASCII)
{
tempData.tk_asciiParamsLength += keyptr->gk_count;
}
}
if (tempData.tk_asciiParamsLength > 0)
{
tempData.tk_asciiParams =
(char *)_GTIFcalloc(tempData.tk_asciiParamsLength + 1);
tempData.tk_asciiParams[tempData.tk_asciiParamsLength] = '\0';
}
/* Set up the rest of SHORT array properly */
keyptr = gt->gt_keys;
entptr = (KeyEntry*)(gt->gt_short + 4);
for (i=0; i< gt->gt_num_keys; i++,entptr++)
{
if (!WriteKey(gt,&tempData,entptr,keyptr+sortkeys[i])) return 0;
}
/* Write out the Key Directory */
(gt->gt_methods.set)(gt->gt_tif, GTIFF_GEOKEYDIRECTORY, gt->gt_nshorts, gt->gt_short );
/* Write out the params directories */
if (gt->gt_ndoubles)
(gt->gt_methods.set)(gt->gt_tif, GTIFF_DOUBLEPARAMS, gt->gt_ndoubles, gt->gt_double );
if (tempData.tk_asciiParamsLength > 0)
{
/* just to be safe */
tempData.tk_asciiParams[tempData.tk_asciiParamsLength] = '\0';
(gt->gt_methods.set)(gt->gt_tif,
GTIFF_ASCIIPARAMS, 0, tempData.tk_asciiParams);
}
gt->gt_flags &= ~FLAG_FILE_MODIFIED;
if (tempData.tk_asciiParamsLength > 0)
{
_GTIFFree (tempData.tk_asciiParams);
}
return 1;
}
//-*****************************************************************************
WrittenArraySampleIDPtr
WriteArray( WrittenArraySampleMap &iMap,
hid_t iGroup,
const std::string &iName,
const AbcA::ArraySample &iSamp,
const AbcA::ArraySample::Key &iKey,
hid_t iFileType,
hid_t iNativeType,
int iCompressionLevel )
{
// Dispatch to string writing utils.
const AbcA::DataType &dataType = iSamp.getDataType();
if ( dataType.getPod() == kStringPOD )
{
return WriteStringArray( iMap, iGroup, iName, iSamp, iKey,
iCompressionLevel );
}
else if ( dataType.getPod() == kWstringPOD )
{
return WriteWstringArray( iMap, iGroup, iName, iSamp, iKey,
iCompressionLevel );
}
// write the dimensions as necessary
Dimensions dims = iSamp.getDimensions();
size_t rank = dims.rank();
ABCA_ASSERT( rank > 0, "Cannot have a rank-0 array sample" );
// rank 1 is the most common case, and we can easily infer it's size
// from the dataspace for non-strings, so don't bother writing it out
if (rank > 1)
{
std::string dimsName = iName + ".dims";
WriteDimensions( iGroup, dimsName, dims );
}
// See whether or not we've already stored this.
WrittenArraySampleIDPtr writeID = iMap.find( iKey );
if ( writeID )
{
CopyWrittenArray( iGroup, iName, writeID );
return writeID;
}
// Okay, need to actually store it.
// It will be a dataset with an internal attribute for storing
// the hash id.
bool hasData = dims.numPoints() > 0;
hid_t dspaceId = -1;
if ( hasData )
{
hsize_t hdim = dims.numPoints() * dataType.getExtent();
dspaceId = H5Screate_simple( 1, &hdim, NULL );
}
else
{
dspaceId = H5Screate( H5S_NULL );
}
ABCA_ASSERT( dspaceId >= 0,
"WriteArray() Failed in dataspace construction" );
DspaceCloser dspaceCloser( dspaceId );
hid_t dsetId = -1;
if ( iCompressionLevel >= 0 && hasData )
{
// Make a compression plist
hid_t zipPlist = DsetGzipCreatePlist( dims,
iCompressionLevel > 9 ? 9 : iCompressionLevel );
PlistCloser plistCloser( zipPlist );
// Make the dataset.
dsetId = H5Dcreate2( iGroup, iName.c_str(), iFileType, dspaceId,
H5P_DEFAULT, zipPlist, H5P_DEFAULT );
}
else
{
dsetId = H5Dcreate2( iGroup, iName.c_str(),
iFileType, dspaceId,
H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT );
}
DsetCloser dsetCloser(dsetId);
ABCA_ASSERT( dsetId >= 0,
"WriteArray() Failed in dataset constructor" );
// Write the data.
if ( hasData )
{
H5Dwrite( dsetId, iNativeType, H5S_ALL, H5S_ALL, H5P_DEFAULT,
iSamp.getData() );
}
// Write the array sample key.
WriteKey( dsetId, "key", iKey );
writeID.reset( new WrittenArraySampleID( iKey, dsetId ) );
iMap.store( writeID );
// Return the reference.
return writeID;
}
/*!
This is a recursive function that gets the type of the \c value object and
calls several protected functions depending on the type:
\li \c WriteNullvalue for type NULL
\li \c WriteStringValue() for STRING and CSTRING types
\li \c WriteIntValue for INT types
\li \c WriteUIntValue for UINT types
\li \c WriteBoolValue for BOOL types
\li \c WriteDoubleValue for DOUBLE types
\li \c WriteMemoryBuff for MEMORYBUFF types
If the value is an array or key/value map (types ARRAY and OBJECT), the function
iterates through all JSON value object in the array/map and calls itself for every
item in the container.
*/
int
wxJSONWriter::DoWrite( wxOutputStream& os, const wxJSONValue& value, const wxString* key, bool comma )
{
// note that this function is recursive
// some variables that cannot be allocated in the switch statement
const wxJSONInternalMap* map = 0;
int size;
m_colNo = 1; m_lineNo = 1;
// determine the comment position; it is one of:
//
// wxJSONVALUE_COMMENT_BEFORE
// wxJSONVALUE_COMMENT_AFTER
// wxJSONVALUE_COMMENT_INLINE
//
// or -1 if comments have not to be written
int commentPos = -1;
if ( value.GetCommentCount() > 0 && (m_style & wxJSONWRITER_WRITE_COMMENTS)) {
commentPos = value.GetCommentPos();
if ( ( m_style & wxJSONWRITER_COMMENTS_BEFORE) != 0 ) {
commentPos = wxJSONVALUE_COMMENT_BEFORE;
}
else if ( (m_style & wxJSONWRITER_COMMENTS_AFTER) != 0 ) {
commentPos = wxJSONVALUE_COMMENT_AFTER;
}
}
int lastChar = 0; // check if WriteComment() writes the last LF char
// first write the comment if it is BEFORE
if ( commentPos == wxJSONVALUE_COMMENT_BEFORE ) {
lastChar = WriteComment( os, value, true );
if ( lastChar < 0 ) {
return lastChar;
}
else if ( lastChar != '\n' ) {
WriteSeparator( os );
}
}
lastChar = WriteIndent( os );
if ( lastChar < 0 ) {
return lastChar;
}
// now write the key if it is not NULL
if ( key ) {
lastChar = WriteKey( os, *key );
}
if ( lastChar < 0 ) {
return lastChar;
}
// now write the value
wxJSONInternalMap::const_iterator it; // declare the map object
long int count = 0;
wxJSONType t = value.GetType();
switch ( t ) {
case wxJSONTYPE_INVALID :
WriteInvalid( os );
wxFAIL_MSG( _T("wxJSONWriter::WriteEmpty() cannot be called (not a valid JSON text"));
break;
case wxJSONTYPE_INT :
case wxJSONTYPE_SHORT :
case wxJSONTYPE_LONG :
case wxJSONTYPE_INT64 :
lastChar = WriteIntValue( os, value );
break;
case wxJSONTYPE_UINT :
case wxJSONTYPE_USHORT :
case wxJSONTYPE_ULONG :
case wxJSONTYPE_UINT64 :
lastChar = WriteUIntValue( os, value );
break;
case wxJSONTYPE_NULL :
lastChar = WriteNullValue( os );
break;
case wxJSONTYPE_BOOL :
lastChar = WriteBoolValue( os, value );
break;
case wxJSONTYPE_DOUBLE :
lastChar = WriteDoubleValue( os, value );
break;
case wxJSONTYPE_STRING :
case wxJSONTYPE_CSTRING :
lastChar = WriteStringValue( os, value.AsString());
break;
case wxJSONTYPE_MEMORYBUFF :
lastChar = WriteMemoryBuff( os, value.AsMemoryBuff());
break;
case wxJSONTYPE_ARRAY :
++m_level;
os.PutC( '[' );
// the inline comment for objects and arrays are printed in the open char
if ( commentPos == wxJSONVALUE_COMMENT_INLINE ) {
commentPos = -1; // we have already written the comment
lastChar = WriteComment( os, value, false );
if ( lastChar < 0 ) {
return lastChar;
}
if ( lastChar != '\n' ) {
lastChar = WriteSeparator( os );
}
}
else { // comment is not to be printed inline, so write a LF
lastChar = WriteSeparator( os );
if ( lastChar < 0 ) {
return lastChar;
}
}
// now iterate through all sub-items and call DoWrite() recursively
size = value.Size();
for ( int i = 0; i < size; i++ ) {
bool comma = false;
if ( i < size - 1 ) {
comma = true;
}
wxJSONValue v = value.ItemAt( i );
lastChar = DoWrite( os, v, 0, comma );
if ( lastChar < 0 ) {
return lastChar;
}
}
--m_level;
lastChar = WriteIndent( os );
if ( lastChar < 0 ) {
return lastChar;
}
os.PutC( ']' );
break;
case wxJSONTYPE_OBJECT :
++m_level;
os.PutC( '{' );
// the inline comment for objects and arrays are printed in the open char
if ( commentPos == wxJSONVALUE_COMMENT_INLINE ) {
commentPos = -1; // we have already written the comment
lastChar = WriteComment( os, value, false );
if ( lastChar < 0 ) {
return lastChar;
}
if ( lastChar != '\n' ) {
WriteSeparator( os );
}
}
else {
lastChar = WriteSeparator( os );
}
map = value.AsMap();
size = value.Size();
count = 0;
for ( it = map->begin(); it != map->end(); ++it ) {
// get the key and the value
wxString key = it->first;
const wxJSONValue& v = it->second;
bool comma = false;
if ( count < size - 1 ) {
comma = true;
}
lastChar = DoWrite( os, v, &key, comma );
if ( lastChar < 0 ) {
return lastChar;
}
count++;
}
--m_level;
lastChar = WriteIndent( os );
if ( lastChar < 0 ) {
return lastChar;
}
os.PutC( '}' );
break;
default :
// a not yet defined wxJSONType: we FAIL
wxFAIL_MSG( _T("wxJSONWriter::DoWrite() undefined wxJSONType type"));
break;
}
// writes the comma character before the inline comment
if ( comma ) {
os.PutC( ',' );
}
if ( commentPos == wxJSONVALUE_COMMENT_INLINE ) {
lastChar = WriteComment( os, value, false );
if ( lastChar < 0 ) {
return lastChar;
}
}
else if ( commentPos == wxJSONVALUE_COMMENT_AFTER ) {
WriteSeparator( os );
lastChar = WriteComment( os, value, true );
if ( lastChar < 0 ) {
return lastChar;
}
}
if ( lastChar != '\n' ) {
lastChar = WriteSeparator( os );
}
return lastChar;
}
size_t JsonWriteRichPresenceObj(char* dest,
size_t maxLen,
int nonce,
int pid,
const DiscordRichPresence* presence)
{
JsonWriter writer(dest, maxLen);
{
WriteObject top(writer);
JsonWriteNonce(writer, nonce);
WriteKey(writer, "cmd");
writer.String("SET_ACTIVITY");
{
WriteObject args(writer, "args");
WriteKey(writer, "pid");
writer.Int(pid);
if (presence != nullptr) {
WriteObject activity(writer, "activity");
WriteOptionalString(writer, "state", presence->state);
WriteOptionalString(writer, "details", presence->details);
if (presence->startTimestamp || presence->endTimestamp) {
WriteObject timestamps(writer, "timestamps");
if (presence->startTimestamp) {
WriteKey(writer, "start");
writer.Int64(presence->startTimestamp);
}
if (presence->endTimestamp) {
WriteKey(writer, "end");
writer.Int64(presence->endTimestamp);
}
}
if ((presence->largeImageKey && presence->largeImageKey[0]) ||
(presence->largeImageText && presence->largeImageText[0]) ||
(presence->smallImageKey && presence->smallImageKey[0]) ||
(presence->smallImageText && presence->smallImageText[0])) {
WriteObject assets(writer, "assets");
WriteOptionalString(writer, "large_image", presence->largeImageKey);
WriteOptionalString(writer, "large_text", presence->largeImageText);
WriteOptionalString(writer, "small_image", presence->smallImageKey);
WriteOptionalString(writer, "small_text", presence->smallImageText);
}
if ((presence->partyId && presence->partyId[0]) || presence->partySize ||
presence->partyMax) {
WriteObject party(writer, "party");
WriteOptionalString(writer, "id", presence->partyId);
if (presence->partySize && presence->partyMax) {
WriteArray size(writer, "size");
writer.Int(presence->partySize);
writer.Int(presence->partyMax);
}
}
if ((presence->matchSecret && presence->matchSecret[0]) ||
(presence->joinSecret && presence->joinSecret[0]) ||
(presence->spectateSecret && presence->spectateSecret[0])) {
WriteObject secrets(writer, "secrets");
WriteOptionalString(writer, "match", presence->matchSecret);
WriteOptionalString(writer, "join", presence->joinSecret);
WriteOptionalString(writer, "spectate", presence->spectateSecret);
}
writer.Key("instance");
writer.Bool(presence->instance != 0);
}
}
}
return writer.Size();
}
WriteArray(JsonWriter& w, T& name)
: writer(w)
{
WriteKey(writer, name);
writer.StartArray();
}
WriteObject(JsonWriter& w, T& name)
: writer(w)
{
WriteKey(writer, name);
writer.StartObject();
}
void
WritePrivateProfileString (const char *section, const char *var,
const char *var_name, const char *filename)
{
FILE *file;
struct stat sb;
int res;
res = stat (filename, &sb);
if (-1 == res) // fichier n'existe pas
{
file = fopen (filename, "w");
InsertSectionKey (section, var, var_name, file, 0);
fclose (file);
}
else
{
int filesize;
filesize = sb.st_size - 1; // on ne lit pas EOT
if (filesize >= 0)
{
char *buf;
char *section_begin;
int size1, size2;
buf = file2buf (filename);
section_begin = SearchSection (buf, section);
if (NULL != section_begin) //section existe déjà
{
char *key_begin;
key_begin = SearchKey (section_begin, var);
if (NULL != key_begin) // la clé existe : on copie la partie d'avant l'ancienne clé, la nouvelle clé, puis la partie d'après l'ancienne clé
{
int old_key_size;
char *key_end;
size1 = key_begin - buf;
key_end = strstr (key_begin, "\n");
if (NULL != key_end)
{
old_key_size = key_end - key_begin + 1;
size2 = filesize - (size1 + old_key_size);
file = fopen (filename, "w");
fwrite (buf, size1, 1, file);
WriteKey (var, var_name, file);
fwrite (buf + size1 + old_key_size, size2, 1, file);
fclose (file);
}
else
{ // la clé est la dernière du fichier
file = fopen (filename, "w");
fwrite (buf, size1, 1, file);
WriteKey (var, var_name, file);
fclose (file);
}
}
else
{ // clé n'existe pas : on la rajoute avant la prochaine section
char *next_section_begin;
next_section_begin = strstr (section_begin, "*");
if (NULL == next_section_begin) // la section recherchée est unique : il suffit de copier la clé à la fin du fichier
{
file = fopen (filename, "a");
WriteKey (var, var_name, file);
fclose (file);
}
else
{ // on insère la clé avant la prochaine section
size1 = next_section_begin - buf;
size2 = filesize - size1;
file = fopen (filename, "w");
fwrite (buf, size1, 1, file);
WriteKey (var, var_name, file);
fwrite (buf + size1, size2, 1, file);
fclose (file);
}
}
}
else
{ //section n'existe pas : on la rajoute ainsi que la clé
file = fopen (filename, "a");
InsertSectionKey (section, var, var_name, file, 1);
fclose (file);
}
free (buf);
}
else
{ //taille fichier < 0
file = fopen (filename, "w");
InsertSectionKey (section, var, var_name, file, 0);
fclose (file);
}
}
}
