// Load and decompress NBT file
bool NBT_Reader::Load(const STRING file)
{
gzFile zload = 0;
#ifdef UNICODE
std::string sFile(file.begin(), file.end());
zload = gzopen(sFile.c_str(), "rb");
#else
zload = gzopen(file.c_str(), "rb");
#endif
BYTE buffer[BUFFER_SIZE] = {0};
std::string load;
int a = -1;
do
{
a = gzread(zload, buffer, BUFFER_SIZE);
if (a > 0)
load.append(buffer, buffer+a);
}
while (a > 0);
gzclose(zload);
// Invalid
if (load[0] != 10)
return false;
int size = load.size();
data = new BYTE[size];
memcpy(data, load.c_str(), size);
pointer = data;
return true;
}
TEST_F(is_IS_PhoneNumber, Operator) {
cxxfaker::providers::is_IS::PhoneNumber phonenumber;
phonenumber.Seed(::testing::UnitTest::GetInstance()->random_seed());
STRING number = phonenumber;
for (STRING::const_iterator iter = number.begin(); iter != number.end(); ++iter) {
if (isdigit(*iter) || *iter == '+' || *iter == ' ')
continue;
ADD_FAILURE() << "What is this \"" << *iter << "\" doing in here..";
};
};
TEST_F(pl_PL_PhoneNumber, PhoneNumber) {
cxxfaker::providers::pl_PL::PhoneNumber* phonenumber = new cxxfaker::providers::pl_PL::PhoneNumber();
phonenumber->Seed(::testing::UnitTest::GetInstance()->random_seed());
STRING number = phonenumber->phoneNumber();
for (STRING::const_iterator iter = number.begin(); iter != number.end(); ++iter) {
if (isdigit(*iter) || *iter == '+' || *iter == '(' || *iter == ')' || *iter == ' ')
continue;
ADD_FAILURE() << "What is this \"" << *iter << "\" doing in here..";
};
delete phonenumber;
};
SNORTRULEHDR void CRuleOption::FormatPattern(CDllString &out)
{
m_nFlags = CRuleOption::NOFLAG;
STRING str = out.Data();
STRING_ITER iBeg = str.begin(), iEnd = str.end();
if (*std::find_if_not(iBeg, iEnd, ISSPACE()) == '!')
{
m_nFlags |= CRuleOption::HASNOT;
}
QuotedContext(iBeg, iEnd);
out.Assign(STRING(iBeg, iEnd).c_str());
}
void searchTest(const STRING& text, const STRING *keyTbl, size_t keySize)
{
FMINDEX f;
f.init(text.begin(), text.end());
compareText(f, text, keyTbl, keySize);
std::stringstream ss;
f.save(ss);
{
FMINDEX ff;
ff.load(ss);
compareText(ff, text, keyTbl, keySize);
}
}
// Working thread
THREAD_FUNCTION(PixelMap::WorkingLevel, data)
{
GoThread * go = (GoThread*)data;
Level * level = go->level;
if (level)
{
STRING folder = *go->folder;
go->error = level->LoadWorld(folder);
if (go->error != LVL_OK)
{
go->running = false;
return 0;
}
STRING save = *go->save;
go->error = level->CreateImage(save);
if (go->error != LVL_OK)
{
go->running = false;
return 0;
}
STRING w = Port::FileName(folder);
std::string world;
world.assign(w.begin(), w.end());
// Save log
if (level->prefs.logging)
{
using namespace std;
ofstream file(level->prefs.log.c_str());
if (file.is_open())
{
INT64 total = 0;
for (int i = 0; i < DATAVALUES_AMOUNT; ++i)
total += level->amount.block[i];
int digits = 0;
{
INT64 t = level->amount.filesize;
t /= 1000000;
while (t > 0)
{
++digits;
t /= 10;
}
}
double size = level->amount.filesize;
size /= 1000000;
stringstream stream;
stream.setf(ios_base::dec, ios::floatfield);
stream.precision(2 + digits);
#define END "\n"
#define SEP(t) setSeparator(t)
stream << world << END
<< size << "MB" << END << END
<< "Map surface: " << SEP(level->blocks) << END
<< "Total blocks: " << SEP(total) << END << END
<< "Air: " << SEP(level->amount.block[AIR]) << END
<< "Stone: " << SEP(level->amount.block[STONE]) << END
<< "Dirt: " << SEP(level->amount.block[GRASS] + level->amount.block[DIRT]) << END
<< "Water: " << SEP(level->amount.block[WATER] + level->amount.block[STATIONARYWATER]) << END
<< "Clay: " << SEP(level->amount.block[CLAY]) << END
<< "Sand: " << SEP(level->amount.block[SAND]) << END
<< "Gravel: " << SEP(level->amount.block[GRAVEL]) << END << END
<< "Log: " << SEP(level->amount.block[LOG]) << END
<< "Leaves: " << SEP(level->amount.block[LEAVES]) << END
<< "Sapling: " << SEP(level->amount.block[SAPLING]) << END << END
<< "Soil: " << SEP(level->amount.block[SOIL]) << END
<< "Crops: " << SEP(level->amount.block[CROPS]) << END << END
<< "Reed: " << SEP(level->amount.block[REED]) << END
<< "Cactus: " << SEP(level->amount.block[CACTUS]) << END
<< "Red Mushroom: " << SEP(level->amount.block[REDMUSHROOM]) << END
<< "Brown Mushroom: " << SEP(level->amount.block[BROWNMUSHROOM]) << END
<< "Red rose: " << SEP(level->amount.block[REDROSE]) << END
<< "Yellow flower: " << SEP(level->amount.block[YELLOWFLOWER]) << END << END
<< "Ice: " << SEP(level->amount.block[ICE]) << END
<< "Snow: " << SEP(level->amount.block[SNOW]) << END
<< "Snow Block: " << SEP(level->amount.block[SNOWBLOCK]) << END << END
<< "Fire: " << SEP(level->amount.block[FIRE]) << END << END
<< "Diamond Ore: " << SEP(level->amount.block[DIAMONDORE]) << END
<< "Iron Ore: " << SEP(level->amount.block[IRONORE]) << END
<< "Coal Ore: " << SEP(level->amount.block[COALORE]) << END
<< "Gold Ore: " << SEP(level->amount.block[GOLDORE]) << END
<< "Redstone: " << SEP(level->amount.block[REDSTONEORE] + level->amount.block[GLOWINGREDSTONEORE]) << END
<< "Lapiz Lazuli Ore: " << SEP(level->amount.block[LAPIZLAZULIORE]) << END
<< "Obsidian: " << SEP(level->amount.block[OBSIDIAN]) << END
<< "Mossy Cobblestone: " << SEP(level->amount.block[MOSSYCOBBLESTONE]) << END
<< "Bedrock (Adminium): " << SEP(level->amount.block[BEDROCK]) << END << END
<< "Lava: " << SEP(level->amount.block[LAVA] + level->amount.block[STATIONARYLAVA]) << END << END
<< "Cobblestone: " << SEP(level->amount.block[COBBLESTONE]) << END
<< "Wood: " << SEP(level->amount.block[WOOD]) << END
<< "Glass: " << SEP(level->amount.block[GLASS]) << END
<< "Brick: " << SEP(level->amount.block[BRICK]) << END
<< "Sandstone: " << SEP(level->amount.block[SANDSTONE]) << END
<< "Cobblestone Stairs: " << SEP(level->amount.block[COBBLESTONESTAIRS]) << END
<< "Wooden Stairs: " << SEP(level->amount.block[WOODENSTAIRS]) << END
<< "Step: " << SEP(level->amount.block[SLAB_STONE]) << END
<< "Double Step: " << SEP(level->amount.block[DOUBLESLAB_STONE]) << END << END
<< "Torch: " << SEP(level->amount.block[TORCH]) << END
<< "Wooden Door: " << SEP(level->amount.block[WOODENDOOR]) << END
<< "Iron Door: " << SEP(level->amount.block[IRONDOOR]) << END
<< "Chest: " << SEP(level->amount.block[CHEST]) << END
<< "Bookcase: " << SEP(level->amount.block[BOOKSHELF]) << END
<< "Workbench: " << SEP(level->amount.block[WORKBENCH]) << END
<< "Furnace: " << SEP(level->amount.block[FURNACE] + level->amount.block[BURNINGFURNACE]) << END
<< "Dispencer: " << SEP(level->amount.block[DISPENSER]) << END
<< "Sign: " << SEP(level->amount.block[SIGNPOST] + level->amount.block[WALLSIGN]) << END
<< "Ladder: " << SEP(level->amount.block[LADDER]) << END
<< "Minecart Tracks: " << SEP(level->amount.block[MINECARTTRACK]) << END
<< "Jukebox: " << SEP(level->amount.block[JUKEBOX]) << END
<< "Note Block: " << SEP(level->amount.block[NOTEBLOCK]) << END
<< "Fence: " << SEP(level->amount.block[FENCE]) << END
<< "Wool: " << SEP(level->amount.block[WOOL]) << END << END
<< "Lapiz Lazuli Block: " << SEP(level->amount.block[LAPIZLAZULIBLOCK]) << END
<< "Diamond Block: " << SEP(level->amount.block[DIAMONDBLOCK]) << END
<< "Gold Block: " << SEP(level->amount.block[GOLDBLOCK]) << END
<< "Iron Block: " << SEP(level->amount.block[IRONBLOCK]) << END << END
<< "Redstone Torch: " << SEP(level->amount.block[REDSTONETORCHON] + level->amount.block[REDSTONETORCHOFF]) << END
<< "Redstone Wire: " << SEP(level->amount.block[REDSTONEWIRE]) << END
<< "Lever: " << SEP(level->amount.block[LEVER]) << END
<< "Stone Button: " << SEP(level->amount.block[STONEBUTTON]) << END
<< "Stone Pressure Plates: " << SEP(level->amount.block[STONEPRESSUREPLATE]) << END
<< "Wodden Pressure Plates: " << SEP(level->amount.block[WOODPRESSUREPLATE]) << END << END
<< "TNT: " << SEP(level->amount.block[TNT]) << END
<< "Sponge: " << SEP(level->amount.block[SPONGE]) << END
<< "Cake: " << SEP(level->amount.block[CAKE]) << END << END
<< "Mob Spawner: " << SEP(level->amount.block[MOBSPAWNER]) << END << END
<< "Zombies: " << SEP(level->amount.zombie) << END
<< "Creeper: " << SEP(level->amount.creeper) << END
<< "Skeletons: " << SEP(level->amount.skeleton) << END
<< "Slimes: " << SEP(level->amount.slime) << END
<< "Pig Zombies: " << SEP(level->amount.pigzombie) << END
<< "Ghast: " << SEP(level->amount.ghast) << END << END
<< "Pigs: " << SEP(level->amount.pig) << END
<< "Chickens: " << SEP(level->amount.chicken) << END
<< "Cows: " << SEP(level->amount.cow) << END
<< "Sheeps: " << SEP(level->amount.sheep);
string str = stream.str();
const char * c = str.c_str();
file << c;
file.close();
}
}
}
go->running = false;
return 0;
}
// Go through all gui controls
void PixelMap::DoArgs(GUI_Creator * gui)
{
if (!gui)
return;
using namespace std;
// Parameters
ResetArgs();
BOOL b;
if (gui->Get(GUI_ALPHA, b))
{
worldVersion = ALPHA;
}
else if (gui->Get(GUI_BETA, b))
{
worldVersion = BETA;
}
if (gui->Get(GUI_WORLD, b))
{
wstring temp;
//gui->Get(GUI_WORLDFILE, temp);
int i = 0;
gui->GetData(GUI_WORLDFILE, &i);
STRING temp2 = worlds[i];
temp.assign(temp2.begin(), temp2.end());
map = temp;
if (worldVersion == ALPHA)
{
if (map < 0 || map > 5)
map = 1;
if (map > 0 && map <= 5)
{
map = L"World" + map.s;
}
}
}
else if (gui->Get(GUI_CUSTOM, b))
{
wstring temp;
gui->Get(GUI_CUSTOMFILE, temp);
map = temp;
}
// Savefile
gui->Get(GUI_OUTPUT, saveFile);
// Texture
gui->Get(GUI_TEXTURE, texture);
// Cache
if (gui->Get(GUI_CACHE, b) && gui->Get(GUI_CACHEFILE, cache) && cache.empty())
{
// Default cache
STRING str = GetTemp();
cache.assign(str.begin(), str.end());
}
// Log
if (gui->Get(GUI_LOG, b) && gui->Get(GUI_LOGFILE, logFile) == 0)
logFile = L"log.txt";
// Bools
nether = !!gui->Get(GUI_NETHER, b);
night = !!gui->Get(GUI_NIGHT, b);
noRender = !!gui->Get(GUI_NORENDER, b);
caveMode = !!gui->Get(GUI_CAVEMODE, b);
autoClose = !!gui->Get(GUI_AUTO_CLOSE, b);
openFolder = !!gui->Get(GUI_OPEN_FOLDER, b);
noHeightMap = !!gui->Get(GUI_NOHEIGHTMAP, b);
// Rotation
{
wstring temp;
gui->Get(GUI_ROTATE, temp);
rotation = _wtoi(temp.c_str());
}
// Modes
// Normal
if (gui->Get(GUI_NORMAL, b))
height = 0;
// Height
else if (gui->Get(GUI_FREQ, b))
{
wstring temp;
gui->Get(GUI_FREQ_H, temp);
height = _wtoi(temp.c_str());
// Limit
if (height <= 1 || height > MAPZ / 8)
height = 0;
}
// Gray
else if (gui->Get(GUI_GRAY, b))
height = -1;
// Color
else if (gui->Get(GUI_COLOR, b))
height = -2;
// Solid
else if (gui->Get(GUI_SOLID, b))
height = -3;
// Threads
{
wstring temp;
if (gui->Get(GUI_THREADS, temp))
threads = _wtoi(temp.c_str());
if (threads < 1)
threads = 1;
}
// Slice
{
wstring temp;
int tt = -1;
if (gui->Get(GUI_SLICE, temp))
tt = _wtoi(temp.c_str());
if (tt < 0 || tt > MAPZ)
tt = -1;
slice.push_back(tt);
gui->Get(GUI_SLICE_SINGLE, tt);
slice.push_back(tt);
}
// Only and exclude, only one of them
{
std::string str;
int size = 0;
// Only
if (size = gui->Get(GUI_ONLY, str))
{
only = str2list(str.c_str(), size);
}
// Exclude
else if (size = gui->Get(GUI_ONLY, str))
{
exclude = str2list(str.c_str(), size);
}
}
gui->Get(GUI_TEXTURE, texture);
PrepareMap();
PrepareArgs();
}
// Command line arguments
void PixelMap::DoArgs(wchar_t ** commands, int nArgs)
{
using namespace std;
// Parameters
ResetArgs();
ParseArguments args = ParseArguments();
UINT arguments[32] = {0};
arguments[0] = args.AddParameter(L'w', PARAM_WSTRING); // World folder
arguments[1] = args.AddParameter(L'f', PARAM_WSTRING); // Output file
arguments[2] = args.AddParameter(L'l', PARAM_WSTRING); // Log file
{
wchar_t temp2[] = {
'w', WATER,
'w', STATIONARYWATER,
'l', LAVA,
'l', STATIONARYLAVA,
0};
arguments[3] = args.AddParameter(L'o', PARAM_INT | PARAM_LIST, temp2); // Only mode
arguments[4] = args.AddParameter(L'x', PARAM_INT | PARAM_LIST, temp2); // Exclude mode
}
arguments[5] = args.AddParameter(L'n', PARAM_BOOL); // Night mode
arguments[6] = args.AddParameter(L's', PARAM_INT | PARAM_LIST); // Slice mode
arguments[7] = args.AddParameter(L'h', PARAM_STRING); // Height mode
arguments[8] = args.AddParameter(L't', PARAM_INT); // Threads
arguments[9] = args.AddParameter(L'c', PARAM_BOOL); // Cave mode
arguments[14] = args.AddParameter(L'r', PARAM_INT); // Rotation mode
arguments[10] = args.AddParameter(L"texture", PARAM_WSTRING); // Texture mode
arguments[11] = args.AddParameter(L"no-render", PARAM_BOOL); // No render mode
arguments[12] = args.AddParameter(L"nether", PARAM_BOOL); // Nether mode
arguments[15] = args.AddParameter(L"no-gui", PARAM_BOOL); // No GUI mode
arguments[16] = args.AddParameter(L"silent", PARAM_BOOL); // Silent mode
arguments[17] = args.AddParameter(L"cache", PARAM_WSTRING); // Cache file
arguments[18] = args.AddParameter(L"no-heightmap", PARAM_BOOL); // Disable heightmap
arguments[19] = args.AddParameter(L"auto-close", PARAM_BOOL); // Closes application after rendering
arguments[20] = args.AddParameter(L"open-folder", PARAM_BOOL); // Opens folder where saved
arguments[21] = args.AddParameter(L"version", PARAM_STRING); // Set world version
// Parse arguments
args.PushArguments(commands, nArgs);
// Version
string t;
if (args.GetAdvancedParameter(arguments[21])->Get(&t) && !t.empty())
{
// Make lowercase
for (UINT i = 0; i < t.size(); ++i)
t[i] = tolower(t[i]);
// Alpha
if (t.compare("alpha") == 0)
{
worldVersion = ALPHA;
}
else if (t.compare("beta") == 0)
{
worldVersion = BETA;
}
}
// Get world
wstring temp;
if (args.GetParameter(0)->Get(&temp))
{
if (worldVersion == ALPHA)
{
if (temp.size())
map = temp;
if (map < 0 || map > 5)
map = 1;
if (map > 0 && map <= 5)
{
map.s = L"World" + map.s;
}
}
else
{
map = temp;
}
}
args.GetParameter(arguments[1])->Get(&saveFile);
if (args.GetParameter(arguments[2])->Get(&logFile) && logFile.empty())
logFile = L"log.txt";
args.GetParameter(arguments[3])->Get(&only);
args.GetParameter(arguments[4])->Get(&exclude);
args.GetParameter(arguments[5])->Get(&night);
if (args.GetParameter(arguments[6])->Get(&slice))
{
if (slice.size() > 2)
slice.resize(2);
if (slice.size() >= 1 && (slice.front() < 0 || slice.front() > 127))
{
slice.clear();
slice.push_back(-1);
}
}
// Height parameter
{
wstring temp;
args.GetParameter(arguments[7])->Get(&temp);
height = _wtoi(temp.c_str());
if (height == 0)
{
wchar_t t = temp[0];
switch (t)
{
// Grey
case L'g':
height = -1;
break;
// Color
case L'c':
height = -2;
break;
// Solid
case L's':
height = -3;
break;
}
}
else
{
// Limit
if (height <= 1 || height > MAPZ / 8)
height = 0;
}
}
if (args.GetParameter(arguments[8])->Get(&threads) && threads == 0)
// Automatic detection
threads = Computer::GetLogicalCores();
// Failproof
if (threads < 1 || threads > 255)
threads = 1;
args.GetParameter(arguments[9])->Get(&caveMode);
if (!args.GetParameter(arguments[14])->Get(&rotation))
rotation = 0;
args.GetAdvancedParameter(arguments[10])->Get(&texture);
args.GetAdvancedParameter(arguments[11])->Get(&noRender);
args.GetAdvancedParameter(arguments[12])->Get(&nether);
args.GetAdvancedParameter(arguments[15])->Get(&nogui);
args.GetAdvancedParameter(arguments[16])->Get(&silent);
if (args.GetAdvancedParameter(arguments[17])->Get(&cache) && cache.empty())
{
// Default cache
STRING str = GetTemp();
cache.assign(str.begin(), str.end());
}
args.GetAdvancedParameter(arguments[18])->Get(&noHeightMap);
args.GetAdvancedParameter(arguments[19])->Get(&autoClose);
args.GetAdvancedParameter(arguments[20])->Get(&openFolder);
if (nogui)
autoClose = true;
// Only one of them
if (!only.empty())
exclude.clear();
PrepareMap();
PrepareArgs();
}
SNORTRULEHDR void CPcreOption::FromPattern(const CDllString &strPat)
{
CDllString strTemp = strPat;
FormatPattern(strTemp);
if (HasFlags(CRuleOption::HASNOT))
{
return;
}
STRING str = strTemp.Data();
STRING_ITER iBeg = str.begin(), iEnd = str.end();
STRING strSuffix;
if (*iBeg == '/')
{
++iBeg;
for(--iEnd; *iEnd != '/' && iEnd != str.begin(); --iEnd);
if (iBeg >= iEnd)
{
TTHROW(TI_INVALIDDATA);
}
strSuffix = STRING(iEnd + 1, str.end());
}
m_strPcre.Assign(STRING(iBeg, iEnd).c_str());
for(STRING_ITER j = strSuffix.begin(); j != strSuffix.end(); ++j)
{
switch (*j)
{
case 'A':
AddFlags(PF_A);
if (m_strPcre[0] != '^')
{
m_strPcre.Insert(0, '^');
}
continue;
case 'R':
AddFlags(PF_R);
continue;
case 'i':
AddFlags(PF_i);
continue;
case 's':
AddFlags(PF_s);
continue;
case 'm':
AddFlags(PF_m);
continue;
case 'x':
AddFlags(PF_x);
continue;
case 'E':
AddFlags(PF_E);
continue;
case 'G':
AddFlags(PF_G);
continue;
case 'U':
AddFlags(PF_U);
continue;
case 'B':
AddFlags(PF_B);
continue;
case 'P':
AddFlags(PF_P);
continue;
case 'H':
AddFlags(PF_H);
continue;
case 'M':
AddFlags(PF_M);
continue;
case 'C':
AddFlags(PF_C);
continue;
case 'O':
AddFlags(PF_O);
continue;
case 'I':
AddFlags(PF_I);
continue;
case 'D':
AddFlags(PF_D);
continue;
case 'K':
AddFlags(PF_K);
continue;
case 'S':
AddFlags(PF_S);
continue;
case 'Y':
AddFlags(PF_Y);
continue;
default:
TTHROW(TI_INVALIDDATA);
}
}
if (m_strPcre[0] == '^')
{
AddFlags(PF_A);
}
}
inline STRING utils::strtoupper(STRING str)
{
std::transform(str.begin(), str.end(), str.begin(), toupper);
return str;
}
