670 lines
11 KiB
C++
Executable File
670 lines
11 KiB
C++
Executable File
/*
|
|
* This file is a part of PikoTools
|
|
* and is distributed under the (new) BSD licence.
|
|
* Author: Tomasz Sowa <t.sowa@ttmath.org>
|
|
*/
|
|
|
|
/*
|
|
* Copyright (c) 2008-2012, Tomasz Sowa
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
*
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* * Neither the name Tomasz Sowa nor the names of contributors to this
|
|
* project may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
|
|
* THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
//#include <cstdlib>
|
|
#include <wchar.h>
|
|
#include "space.h"
|
|
#include "utf8/utf8.h"
|
|
|
|
|
|
|
|
namespace PT
|
|
{
|
|
|
|
|
|
|
|
Space::Space()
|
|
{
|
|
parent = 0;
|
|
}
|
|
|
|
|
|
Space::~Space()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
|
|
Space::Space(const Space & s)
|
|
{
|
|
operator=(s);
|
|
}
|
|
|
|
|
|
Space & Space::operator=(const Space & s)
|
|
{
|
|
Clear();
|
|
|
|
name = s.name;
|
|
table_single = s.table_single;
|
|
table = s.table;
|
|
parent = s.parent;
|
|
|
|
for(size_t i=0 ; i<s.spaces.size() ; ++i)
|
|
{
|
|
Space * pspace = new Space(*s.spaces[i]);
|
|
pspace->parent = this;
|
|
spaces.push_back(pspace);
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void Space::Clear()
|
|
{
|
|
name.clear();
|
|
table_single.clear();
|
|
table.clear();
|
|
|
|
for(size_t i=0 ; i<spaces.size() ; ++i)
|
|
delete spaces[i];
|
|
|
|
spaces.clear();
|
|
}
|
|
|
|
|
|
|
|
std::wstring * Space::GetValue(const wchar_t * name)
|
|
{
|
|
tmp_name = name;
|
|
return GetValue(tmp_name);
|
|
}
|
|
|
|
|
|
|
|
std::wstring * Space::GetValue(const std::wstring & name)
|
|
{
|
|
TableSingle::iterator i = table_single.find(name);
|
|
|
|
if( i != table_single.end() )
|
|
{
|
|
return &i->second;
|
|
}
|
|
else
|
|
{
|
|
Table::iterator t = table.find(name);
|
|
|
|
if( t == table.end() || t->second.empty() )
|
|
{
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
return &t->second[0];
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
std::wstring & Space::Text(const wchar_t * name)
|
|
{
|
|
tmp_name = name;
|
|
return Text(tmp_name, L"");
|
|
}
|
|
|
|
|
|
|
|
std::wstring & Space::Text(const wchar_t * name, const wchar_t * def)
|
|
{
|
|
tmp_name = name;
|
|
return Text(tmp_name, def);
|
|
}
|
|
|
|
|
|
std::wstring & Space::Text(const std::wstring & name, const wchar_t * def)
|
|
{
|
|
std::wstring * value = GetValue(name);
|
|
|
|
if( value )
|
|
{
|
|
return *value;
|
|
}
|
|
else
|
|
{
|
|
tmp_value_text = def;
|
|
return tmp_value_text;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
std::string & Space::AText(const wchar_t * name)
|
|
{
|
|
tmp_name = name;
|
|
return AText(tmp_name, "");
|
|
}
|
|
|
|
|
|
|
|
std::string & Space::AText(const wchar_t * name, const char * def)
|
|
{
|
|
tmp_name = name;
|
|
return AText(tmp_name, def);
|
|
}
|
|
|
|
|
|
std::string & Space::AText(const std::wstring & name, const char * def)
|
|
{
|
|
std::wstring * value = GetValue(name);
|
|
|
|
if( value )
|
|
{
|
|
PT::WideToUTF8(*value, tmp_value_text_ascii);
|
|
return tmp_value_text_ascii;
|
|
}
|
|
else
|
|
{
|
|
tmp_value_text_ascii = def;
|
|
return tmp_value_text_ascii;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
int Space::Int(const wchar_t * name)
|
|
{
|
|
tmp_name = name;
|
|
return Int(tmp_name, 0);
|
|
}
|
|
|
|
|
|
int Space::Int(const wchar_t * name, int def)
|
|
{
|
|
tmp_name = name;
|
|
return Int(tmp_name, def);
|
|
}
|
|
|
|
|
|
int Space::ToInt(const std::wstring & value)
|
|
{
|
|
long res = (value[0] == '0')? wcstol(value.c_str() + 1, 0, 8) : wcstol(value.c_str(), 0, 10);
|
|
|
|
return static_cast<int>(res);
|
|
}
|
|
|
|
|
|
int Space::Int(const std::wstring & name, int def)
|
|
{
|
|
std::wstring * value = GetValue(name);
|
|
|
|
if( value )
|
|
return ToInt(*value);
|
|
|
|
return def;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
long Space::Long(const wchar_t * name)
|
|
{
|
|
tmp_name = name;
|
|
return Long(tmp_name, 0);
|
|
}
|
|
|
|
|
|
long Space::Long(const wchar_t * name, long def)
|
|
{
|
|
tmp_name = name;
|
|
return Long(tmp_name, def);
|
|
}
|
|
|
|
|
|
long Space::ToLong(const std::wstring & value)
|
|
{
|
|
return (value[0] == '0')? wcstol(value.c_str() + 1, 0, 8) : wcstol(value.c_str(), 0, 10);
|
|
}
|
|
|
|
|
|
long Space::Long(const std::wstring & name, long def)
|
|
{
|
|
std::wstring * value = GetValue(name);
|
|
|
|
if( value )
|
|
return ToLong(*value);
|
|
|
|
return def;
|
|
}
|
|
|
|
|
|
|
|
size_t Space::Size(const wchar_t * name)
|
|
{
|
|
tmp_name = name;
|
|
return Size(tmp_name, 0);
|
|
}
|
|
|
|
|
|
size_t Space::Size(const wchar_t * name, size_t def)
|
|
{
|
|
tmp_name = name;
|
|
return Size(tmp_name, def);
|
|
}
|
|
|
|
|
|
|
|
size_t Space::ToSize(const std::wstring & value)
|
|
{
|
|
unsigned long res = (value[0] == '0')? wcstoul(value.c_str() + 1, 0, 8) : wcstoul(value.c_str(), 0, 10);
|
|
|
|
return static_cast<size_t>(res);
|
|
}
|
|
|
|
|
|
size_t Space::Size(const std::wstring & name, size_t def)
|
|
{
|
|
std::wstring * value = GetValue(name);
|
|
|
|
if( value )
|
|
return ToSize(*value);
|
|
|
|
return def;
|
|
}
|
|
|
|
|
|
|
|
|
|
bool Space::Bool(const wchar_t * name)
|
|
{
|
|
tmp_name = name;
|
|
return Bool(tmp_name, false);
|
|
}
|
|
|
|
|
|
bool Space::Bool(const wchar_t * name, bool def)
|
|
{
|
|
tmp_name = name;
|
|
return Bool(tmp_name, def);
|
|
}
|
|
|
|
|
|
|
|
bool Space::ToBool(const std::wstring & value)
|
|
{
|
|
return ( EqualNoCase(value.c_str(), L"true") ||
|
|
EqualNoCase(value.c_str(), L"yes") ||
|
|
EqualNoCase(value.c_str(), L"1")
|
|
);
|
|
}
|
|
|
|
|
|
bool Space::Bool(const std::wstring & name, bool def)
|
|
{
|
|
std::wstring * value = GetValue(name);
|
|
|
|
if( value )
|
|
return ToBool(*value);
|
|
|
|
return def;
|
|
}
|
|
|
|
|
|
std::wstring & Space::FindAdd(const wchar_t * name)
|
|
{
|
|
tmp_name = name;
|
|
std::wstring * value = GetValue(tmp_name);
|
|
|
|
if( !value )
|
|
{
|
|
value = &table_single[tmp_name];
|
|
table.erase(tmp_name);
|
|
}
|
|
|
|
return *value;
|
|
}
|
|
|
|
|
|
std::wstring & Space::FindAdd(const std::wstring & name)
|
|
{
|
|
std::wstring * value = GetValue(name);
|
|
|
|
if( !value )
|
|
{
|
|
value = &table_single[name];
|
|
table.erase(name);
|
|
}
|
|
|
|
return *value;
|
|
}
|
|
|
|
|
|
std::wstring & Space::Add(const wchar_t * name, bool value)
|
|
{
|
|
if( value )
|
|
return Add(name, L"true");
|
|
else
|
|
return Add(name, L"false");
|
|
}
|
|
|
|
|
|
std::wstring & Space::Add(const std::wstring & name, bool value)
|
|
{
|
|
return Add(name.c_str(), value);
|
|
}
|
|
|
|
|
|
std::wstring & Space::Add(const wchar_t * name, int value)
|
|
{
|
|
wchar_t value_str[50];
|
|
|
|
#if defined _WIN32 || defined _WIN64
|
|
swprintf(value_str, L"%d", value);
|
|
#else
|
|
swprintf(value_str, sizeof(value_str)/sizeof(wchar_t), L"%d", value);
|
|
#endif
|
|
|
|
return Add(name, value_str);
|
|
}
|
|
|
|
|
|
std::wstring & Space::Add(const std::wstring & name, int value)
|
|
{
|
|
return Add(name.c_str(), value);
|
|
}
|
|
|
|
|
|
std::wstring & Space::Add(const wchar_t * name, long value)
|
|
{
|
|
wchar_t value_str[50];
|
|
|
|
#if defined _WIN32 || defined _WIN64
|
|
swprintf(value_str, L"%ld", value);
|
|
#else
|
|
swprintf(value_str, sizeof(value_str)/sizeof(wchar_t), L"%ld", value);
|
|
#endif
|
|
|
|
return Add(name, value_str);
|
|
}
|
|
|
|
|
|
std::wstring & Space::Add(const std::wstring & name, long value)
|
|
{
|
|
return Add(name.c_str(), value);
|
|
}
|
|
|
|
|
|
std::wstring & Space::Add(const wchar_t * name, const wchar_t * value)
|
|
{
|
|
tmp_name = name;
|
|
std::wstring & val = table_single[tmp_name];
|
|
val = value;
|
|
|
|
return val;
|
|
}
|
|
|
|
|
|
std::wstring & Space::Add(const wchar_t * name, const std::wstring & value)
|
|
{
|
|
tmp_name = name;
|
|
std::wstring & val = table_single[tmp_name];
|
|
val = value;
|
|
|
|
return val;
|
|
}
|
|
|
|
|
|
std::wstring & Space::Add(const std::wstring & name, const std::wstring & value)
|
|
{
|
|
std::wstring & val = table_single[name];
|
|
val = value;
|
|
|
|
return val;
|
|
}
|
|
|
|
|
|
|
|
void Space::Remove(const wchar_t * name)
|
|
{
|
|
tmp_name = name;
|
|
|
|
table_single.erase(tmp_name);
|
|
table.erase(tmp_name);
|
|
}
|
|
|
|
|
|
void Space::Remove(const std::wstring & name)
|
|
{
|
|
table_single.erase(name);
|
|
table.erase(name);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Space & Space::AddSpace(const wchar_t * name)
|
|
{
|
|
spaces.push_back(new Space());
|
|
spaces.back()->name = name;
|
|
spaces.back()->parent = this;
|
|
|
|
return *spaces.back();
|
|
}
|
|
|
|
|
|
Space & Space::AddSpace(const std::wstring & name)
|
|
{
|
|
spaces.push_back(new Space());
|
|
spaces.back()->name = name;
|
|
spaces.back()->parent = this;
|
|
|
|
return *spaces.back();
|
|
}
|
|
|
|
|
|
Space * Space::FindSpace(const wchar_t * name)
|
|
{
|
|
for(size_t i=0 ; i<spaces.size() ; ++i)
|
|
{
|
|
if( spaces[i]->name == name )
|
|
return spaces[i];
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
Space * Space::FindSpace(const std::wstring & name)
|
|
{
|
|
for(size_t i=0 ; i<spaces.size() ; ++i)
|
|
{
|
|
if( spaces[i]->name == name )
|
|
return spaces[i];
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
Space & Space::FindAddSpace(const wchar_t * name)
|
|
{
|
|
Space * space = FindSpace(name);
|
|
|
|
if( space )
|
|
return *space;
|
|
|
|
return AddSpace(name);
|
|
}
|
|
|
|
|
|
Space & Space::FindAddSpace(const std::wstring & name)
|
|
{
|
|
Space * space = FindSpace(name);
|
|
|
|
if( space )
|
|
return *space;
|
|
|
|
return AddSpace(name);
|
|
}
|
|
|
|
|
|
|
|
void Space::RemoveSpace(const wchar_t * name)
|
|
{
|
|
for(size_t i=0 ; i<spaces.size() ; )
|
|
{
|
|
if( spaces[i]->name == name )
|
|
RemoveSpace(i);
|
|
else
|
|
++i;
|
|
}
|
|
}
|
|
|
|
|
|
void Space::RemoveSpace(const std::wstring & name)
|
|
{
|
|
for(size_t i=0 ; i<spaces.size() ; )
|
|
{
|
|
if( spaces[i]->name == name )
|
|
RemoveSpace(i);
|
|
else
|
|
++i;
|
|
}
|
|
}
|
|
|
|
|
|
void Space::RemoveSpace(size_t child_index)
|
|
{
|
|
if( child_index < spaces.size() )
|
|
{
|
|
delete spaces[child_index];
|
|
spaces.erase(spaces.begin() + child_index);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// in lists we don't use default values
|
|
bool Space::ListText(const wchar_t * name, std::vector<std::wstring> & list)
|
|
{
|
|
tmp_name = name;
|
|
return ListText(tmp_name, list);
|
|
}
|
|
|
|
|
|
bool Space::ListText(const std::wstring & name, std::vector<std::wstring> & list)
|
|
{
|
|
list.clear();
|
|
TableSingle::iterator i = table_single.find(name);
|
|
|
|
if( i != table_single.end() )
|
|
{
|
|
list.push_back(i->second);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
Table::iterator t = table.find(name);
|
|
|
|
if( t != table.end() )
|
|
{
|
|
list = t->second;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
wchar_t Space::ToSmall(wchar_t c)
|
|
{
|
|
if( c>='A' && c<='Z' )
|
|
c = c - 'A' + 'a';
|
|
|
|
return c;
|
|
}
|
|
|
|
|
|
bool Space::EqualNoCase(const wchar_t * str1, const wchar_t * str2)
|
|
{
|
|
while( *str1 && *str2 && ToSmall(*str1) == ToSmall(*str2) )
|
|
{
|
|
++str1;
|
|
++str2;
|
|
}
|
|
|
|
if( *str1 == 0 && *str2 == 0 )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
/*
|
|
those white characters here should be the same as in spaceparser.cpp
|
|
*/
|
|
bool Space::IsWhite(int c)
|
|
{
|
|
// dont use '\n' here
|
|
// 13 (\r) is at the end of a line in a dos file \r\n
|
|
// 160 is an unbreakable space
|
|
if( c==' ' || c=='\t' || c==13 || c==160 )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
bool Space::HasWhite(const std::wstring & str)
|
|
{
|
|
for(size_t i=0 ; i<str.size() ; ++i)
|
|
if( IsWhite(str[i]) )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
} // namespace
|
|
|
|
|
|
|