/**
* read a tiff image by name
* return a pointer to an image struct
*/
image *readTIFF(char* filename) {
// /*Using Sam Leffler's libtiff library */
// TIFFRGBAImage img;
// image *im;
// uint32 *raster;
//
// size_t npixels;
// int imgwidth, imgheight, imgcomponents;
//
// TIFF *tif;
// char emsg[1024];
//
// tif = TIFFOpen(filename, "r");
// if (tif == NULL){
// fprintf(stderr, "tif == NULL\n");
// return NULL;
// }
// if (TIFFRGBAImageBegin(&img, tif, 0,emsg)){
// npixels = img.width*img.height;
// raster = (uint32 *)_TIFFmalloc(npixels*sizeof(uint32));
// if (raster != NULL){
// if (TIFFRGBAImageGet(&img, raster, img.width, img.height) == 0){
// TIFFError(name, emsg);
// exit(1);
// }
// }
// TIFFRGBAImageEnd(&img);
// }
// else {
// TIFFError(name, emsg);
// return NULL;
// }
//
// /* reverse from abgr to rgb */
// int i;
// im = createImage(img.width,img.height,3);
// for (i = 0; i < npixels; i++) {
// register unsigned char *cp = (unsigned char *) &raster[i];
//
// im.pixels[i][0] = (unsigned short) cp[0];
//
// t = cp[3];
// cp[3] = cp[0];
// cp[0] = t;
// t = cp[2];
// cp[2] = cp[1];
// cp[1] = t;
// }
//
// return im;
notSupported();
return NULL;
}
common::Error CommandHandler::execute(int argc, char** argv, FastoObject* out) {
char* input_cmd = argv[0];
for(size_t i = 0; i < commands_.size(); ++i) {
commands_t cmd = commands_[i];
if (cmd.isCommand(input_cmd)) {
int argc_to_call = argc - 1;
char** argv_to_call = argv + 1;
if (argc_to_call > cmd.maxArgumentsCount() || argc_to_call < cmd.minArgumentsCount()) {
std::string buff = common::MemSPrintf("Invalid input argument for command: %s", input_cmd);
return common::make_error_value(buff, common::ErrorValue::E_ERROR);
}
return cmd.execute(this, argc_to_call, argv_to_call, out);
}
}
return notSupported(input_cmd);
}
/**
* write a freesurfer curvature file
*/
int writeMGHCurvatureFile(surface *surf, char *filename) {
return notSupported();
}
/**
* write a freesurfer label file
*/
int writeMGHLabelFile(surface *surf, char *filename) {
return notSupported();
}
/*
* For each non-const attribute in template t, print the appropriate args
* in the call to evl_log_write().
*/
static void
printAttArgs(const evltemplate_t *t, const char *prefix)
{
evl_listnode_t *head = t->tm_attributes, *end, *p;
const evltemplate_t *st; /* struct attribute's template */
for (end=NULL, p=head; p!=end; end=head, p=p->li_next) {
evlattribute_t *att = (evlattribute_t*) p->li_data;
int ty;
if (isConstAtt(att)) {
continue;
}
if (isBitField(att)) {
notSupported("bit-fields");
continue;
}
ty = evlatt_gettype(att);
if (isArray(att)) {
char *dimString;
dimString = getDimensionString(att, prefix);
if (ty == TY_STRUCT) {
/* Array of structs */
st = att->ta_type->u.st_template;
if ((st->tm_flags & TMPL_TF_ALIGNED) != 0) {
/* Array of aligned structs */
printf(
"\t\"char[]\",\t%s*sizeof(struct %s),\t%s%s,\n",
dimString, st->tm_name, prefix,
att->ta_name);
} else {
notSupported("arrays of unaligned structs");
}
} else {
/* Array of scalars or strings */
printf(
"\t\"%s[]\",\t%s,\t%s%s,\n",
typeName(ty), dimString, prefix,
att->ta_name);
}
free(dimString);
} else {
/* Not an array */
if (ty == TY_STRUCT) {
st = att->ta_type->u.st_template;
if ((st->tm_flags & TMPL_TF_ALIGNED) != 0) {
printf(
"\t\"char[]\",\tsizeof(struct %s),\t%s%s,\n",
st->tm_name, prefix,
att->ta_name);
} else {
/* Unaligned struct. Print all its members. */
size_t newPrefixSize = strlen(prefix)
+ strlen(att->ta_name) + 1;
char *newPrefix = (char*)
malloc(newPrefixSize);
assert(newPrefix != NULL);
snprintf(newPrefix, newPrefixSize, "%s%s.", prefix,
att->ta_name);
printAttArgs(st, newPrefix);
free(newPrefix);
}
} else {
/* Not an array or struct */
printf(
"\t\"%s\",\t%s%s,\n",
typeName(ty), prefix, att->ta_name);
}
}
}
}
/**
* write an image struct to a dicom image file
* return SUCCESS or FAILURE
*/
int writeDICOM(image *img, char *filename) {
return notSupported();
}
/**
* save a 8 bit per pixel pNm image from an image struct
* return SUCCESS or FAILURE
*/
image *readPNM(char *filename) {
notSupported();
return NULL;
}
common::Error RocksdbRaw::help(int argc, char** argv) {
return notSupported("HELP");
}
void UserConnection::on(BufferedSocketListener::Line, const string& aLine) throw () {
if(aLine.length() < 2)
return;
if(aLine[0] == 'C' && !isSet(FLAG_NMDC)) {
dispatch(aLine);
return;
} else if(aLine[0] == '$') {
setFlag(FLAG_NMDC);
} else {
// We shouldn't be here?
dcdebug("Unknown UserConnection command: %.50s\n", aLine.c_str());
return;
}
string cmd;
string param;
string::size_type x;
if( (x = aLine.find(' ')) == string::npos) {
cmd = aLine;
} else {
cmd = aLine.substr(0, x);
param = aLine.substr(x+1);
}
if(cmd == "$MyNick") {
if(!param.empty())
fire(UserConnectionListener::MyNick(), this, Text::acpToUtf8(param));
} else if(cmd == "$Direction") {
x = param.find(" ");
if(x != string::npos) {
fire(UserConnectionListener::Direction(), this, param.substr(0, x), param.substr(x+1));
}
} else if(cmd == "$Error") {
if(Util::stricmp(param.c_str(), FILE_NOT_AVAILABLE) == 0 ||
param.rfind(/*path/file*/" no more exists") != string::npos) {
fire(UserConnectionListener::FileNotAvailable(), this);
} else {
fire(UserConnectionListener::Failed(), this, param);
}
} else if(cmd == "$FileLength") {
if(!param.empty())
fire(UserConnectionListener::FileLength(), this, Util::toInt64(param));
} else if(cmd == "$GetListLen") {
fire(UserConnectionListener::GetListLength(), this);
} else if(cmd == "$Get") {
notSupported();
disconnect();
StringMap params;
params["user"] = getUser()->getNick();
params["hub"] = getUser()->getClientUrl();
params["ip"] = getRemoteIp();
string tmp = Util::formatParams(STRING(OLD_CLIENT), params, false);
LogManager::getInstance()->message(tmp);
} else if(cmd == "$GetZBlock" || cmd == "$UGetZBlock" || cmd == "$UGetBlock") {
notSupported();
disconnect();
StringMap params;
params["user"] = getUser()->getNick();
params["hub"] = getUser()->getClientUrl();
params["ip"] = getRemoteIp();
string tmp = Util::formatParams(STRING(OLD_CLIENT), params, false);
LogManager::getInstance()->message(tmp);
} else if(cmd == "$Key") {
if(!param.empty())
fire(UserConnectionListener::Key(), this, param);
} else if(cmd == "$Lock") {
if(!param.empty()) {
x = param.find(" Pk=");
if(x != string::npos) {
fire(UserConnectionListener::CLock(), this, param.substr(0, x), param.substr(x + 4));
} else {
// Workaround for faulty linux clients...
x = param.find(' ');
if(x != string::npos) {
setFlag(FLAG_INVALIDKEY);
fire(UserConnectionListener::CLock(), this, param.substr(0, x), Util::emptyString);
} else {
fire(UserConnectionListener::CLock(), this, param, Util::emptyString);
}
}
}
} else if(cmd == "$Send") {
fire(UserConnectionListener::Send(), this);
} else if(cmd == "$Sending") {
int64_t bytes = -1;
if(!param.empty())
bytes = Util::toInt64(param);
fire(UserConnectionListener::Sending(), this, bytes);
} else if(cmd == "$MaxedOut") {
fire(UserConnectionListener::MaxedOut(), this);
} else if(cmd == "$Supports") {
if(!param.empty()) {
fire(UserConnectionListener::Supports(), this, StringTokenizer<string>(param, ' ').getTokens());
}
} else if(cmd.compare(0, 4, "$ADC") == 0) {
dispatch(aLine, true);
} else {
dcdebug("Unknown NMDC command: %.50s\n", aLine.c_str());
}
}
/*******************************************************
Function: initialize, set color, hide cursor, get system language, copy icon data
Argument: none
Return : void
*******************************************************/
void initialize() {
// console settings
char con_size[30] = {};
sprintf(con_size, "mode con cols=%d lines=%d", ABSOLUTE_RIGHT + 1, ABSOLUTE_BOTTOM + 1);
system (con_size);
system ("title Tetris Game by Lane at ZDS");
system ("color 3e"); // set color
system ("cls"); // clean screen
HideCursor(); // hide cursor
// get random seed
srand((unsigned)time(NULL)); // Random number seed initial
// initialize global varibals
memset(g_GRID, 0, sizeof(g_GRID));
memset(g_GRID_BAK, 0, sizeof(g_GRID_BAK));
g_SCORE = 0;
// initialize icons
getLocalLanguage(); // get local language information
if(!strcmp(g_Local_Language, "CHS") && !strcmp(g_Local_Language, "JPN")) {
notSupported(); // if not supported, stop in NotSupport() function
}
else if(!strcmp(g_Local_Language, "CHS")) {
g_const_circ_b = CIRC_CHA_B;
g_const_rect_b = RECT_CHA_B;
g_const_rect_w = RECT_CHA_W;
g_const_star_b = STAR_CHA_B;
g_const_star_w = STAR_CHA_W;
}
else if(!strcmp(g_Local_Language, "JPN")) {
g_const_circ_b = CIRC_JPN_B;
g_const_rect_b = RECT_JPN_B;
g_const_rect_w = RECT_JPN_W;
g_const_star_b = STAR_JPN_B;
g_const_star_w = STAR_JPN_W;
}
// load shapes
g_CubeGenerator = new CubeGenerator();
g_CubeGenerator->loadShape(SHAPE_O);
g_CubeGenerator->loadShape(SHAPE_I);
g_CubeGenerator->loadShape(SHAPE_T);
g_CubeGenerator->loadShape(SHAPE_S);
g_CubeGenerator->loadShape(SHAPE_2);
g_CubeGenerator->loadShape(SHAPE_L);
g_CubeGenerator->loadShape(SHAPE_J);
// initialize global cubes
COORD ref_coord = {4, 2};
Shape *next = createShape();
Shape *curr = createShape();
g_NEXT_CUBE = new Cube(ref_coord, next->shape, next->types);
g_CUR_CUBE = new Cube(ref_coord, curr->shape, curr->types);
setShape(g_CUR_CUBE);
// draw initial game screen
drawGame();
}
Options::Status Options::parse(int argc, const char **argv) {
bool test = false;
bool recursive = false;
bool ultra = false;
bool forceStdout = false;
// Local copy of input files, which are pointers into argv.
std::vector<const char *> localInputFiles;
for (int i = 1; i < argc; ++i) {
const char *arg = argv[i];
// Protect against empty arguments
if (arg[0] == 0) {
continue;
}
// Everything after "--" is an input file
if (!std::strcmp(arg, "--")) {
++i;
std::copy(argv + i, argv + argc, std::back_inserter(localInputFiles));
break;
}
// Long arguments that don't have a short option
{
bool isLongOption = true;
if (!std::strcmp(arg, "--rm")) {
keepSource = false;
} else if (!std::strcmp(arg, "--ultra")) {
ultra = true;
maxWindowLog = 0;
} else if (!std::strcmp(arg, "--no-check")) {
checksum = false;
} else if (!std::strcmp(arg, "--sparse")) {
writeMode = WriteMode::Sparse;
notSupported("Sparse mode");
return Status::Failure;
} else if (!std::strcmp(arg, "--no-sparse")) {
writeMode = WriteMode::Regular;
notSupported("Sparse mode");
return Status::Failure;
} else if (!std::strcmp(arg, "--dictID")) {
notSupported(arg);
return Status::Failure;
} else if (!std::strcmp(arg, "--no-dictID")) {
notSupported(arg);
return Status::Failure;
} else {
isLongOption = false;
}
if (isLongOption) {
continue;
}
}
// Arguments with a short option simply set their short option.
const char *options = nullptr;
if (!std::strcmp(arg, "--processes")) {
options = "p";
} else if (!std::strcmp(arg, "--version")) {
options = "V";
} else if (!std::strcmp(arg, "--help")) {
options = "h";
} else if (!std::strcmp(arg, "--decompress")) {
options = "d";
} else if (!std::strcmp(arg, "--force")) {
options = "f";
} else if (!std::strcmp(arg, "--stdout")) {
options = "c";
} else if (!std::strcmp(arg, "--keep")) {
options = "k";
} else if (!std::strcmp(arg, "--verbose")) {
options = "v";
} else if (!std::strcmp(arg, "--quiet")) {
options = "q";
} else if (!std::strcmp(arg, "--check")) {
options = "C";
} else if (!std::strcmp(arg, "--test")) {
options = "t";
} else if (arg[0] == '-' && arg[1] != 0) {
options = arg + 1;
} else {
localInputFiles.emplace_back(arg);
continue;
}
assert(options != nullptr);
bool finished = false;
while (!finished && *options != 0) {
// Parse the compression level
if (*options >= '0' && *options <= '9') {
compressionLevel = parseUnsigned(&options);
continue;
}
switch (*options) {
case 'h':
case 'H':
usage();
return Status::Message;
case 'V':
std::fprintf(stderr, "PZSTD version: %s.\n", ZSTD_VERSION_STRING);
return Status::Message;
case 'p': {
finished = true;
const char *optionArgument = getArgument(options, argv, i, argc);
if (optionArgument == nullptr) {
return Status::Failure;
}
if (*optionArgument < '0' || *optionArgument > '9') {
std::fprintf(stderr, "Option -p expects a number, but %s provided\n",
optionArgument);
return Status::Failure;
}
numThreads = parseUnsigned(&optionArgument);
if (*optionArgument != 0) {
std::fprintf(stderr,
"Option -p expects a number, but %u%s provided\n",
numThreads, optionArgument);
return Status::Failure;
}
break;
}
case 'o': {
finished = true;
const char *optionArgument = getArgument(options, argv, i, argc);
if (optionArgument == nullptr) {
return Status::Failure;
}
outputFile = optionArgument;
break;
}
case 'C':
checksum = true;
break;
case 'k':
keepSource = true;
break;
case 'd':
decompress = true;
break;
case 'f':
overwrite = true;
forceStdout = true;
break;
case 't':
test = true;
decompress = true;
break;
#ifdef UTIL_HAS_CREATEFILELIST
case 'r':
recursive = true;
break;
#endif
case 'c':
outputFile = kStdOut;
forceStdout = true;
break;
case 'v':
++verbosity;
break;
case 'q':
--verbosity;
// Ignore them for now
break;
// Unsupported options from Zstd
case 'D':
case 's':
notSupported("Zstd dictionaries.");
return Status::Failure;
case 'b':
case 'e':
case 'i':
case 'B':
notSupported("Zstd benchmarking options.");
return Status::Failure;
default:
std::fprintf(stderr, "Invalid argument: %s\n", arg);
return Status::Failure;
}
if (!finished) {
++options;
}
} // while (*options != 0);
} // for (int i = 1; i < argc; ++i);
// Input file defaults to standard input if not provided.
if (localInputFiles.empty()) {
localInputFiles.emplace_back(kStdIn);
}
// Check validity of input files
if (localInputFiles.size() > 1) {
const auto it = std::find(localInputFiles.begin(), localInputFiles.end(),
std::string{kStdIn});
if (it != localInputFiles.end()) {
std::fprintf(
stderr,
"Cannot specify standard input when handling multiple files\n");
return Status::Failure;
}
}
if (localInputFiles.size() > 1 || recursive) {
if (!outputFile.empty() && outputFile != nullOutput) {
std::fprintf(
stderr,
"Cannot specify an output file when handling multiple inputs\n");
return Status::Failure;
}
}
// Translate input files/directories into files to (de)compress
if (recursive) {
char *scratchBuffer = nullptr;
unsigned numFiles = 0;
const char **files =
UTIL_createFileList(localInputFiles.data(), localInputFiles.size(),
&scratchBuffer, &numFiles);
if (files == nullptr) {
std::fprintf(stderr, "Error traversing directories\n");
return Status::Failure;
}
auto guard =
makeScopeGuard([&] { UTIL_freeFileList(files, scratchBuffer); });
if (numFiles == 0) {
std::fprintf(stderr, "No files found\n");
return Status::Failure;
}
inputFiles.resize(numFiles);
std::copy(files, files + numFiles, inputFiles.begin());
} else {
inputFiles.resize(localInputFiles.size());
std::copy(localInputFiles.begin(), localInputFiles.end(),
inputFiles.begin());
}
localInputFiles.clear();
assert(!inputFiles.empty());
// If reading from standard input, default to standard output
if (inputFiles[0] == kStdIn && outputFile.empty()) {
assert(inputFiles.size() == 1);
outputFile = "-";
}
if (inputFiles[0] == kStdIn && IS_CONSOLE(stdin)) {
assert(inputFiles.size() == 1);
std::fprintf(stderr, "Cannot read input from interactive console\n");
return Status::Failure;
}
if (outputFile == "-" && IS_CONSOLE(stdout) && !(forceStdout && decompress)) {
std::fprintf(stderr, "Will not write to console stdout unless -c or -f is "
"specified and decompressing\n");
return Status::Failure;
}
// Check compression level
{
unsigned maxCLevel =
ultra ? ZSTD_maxCLevel() : kMaxNonUltraCompressionLevel;
if (compressionLevel > maxCLevel || compressionLevel == 0) {
std::fprintf(stderr, "Invalid compression level %u.\n", compressionLevel);
return Status::Failure;
}
}
// Check that numThreads is set
if (numThreads == 0) {
std::fprintf(stderr, "Invalid arguments: # of threads not specified "
"and unable to determine hardware concurrency.\n");
return Status::Failure;
}
// Modify verbosity
// If we are piping input and output, turn off interaction
if (inputFiles[0] == kStdIn && outputFile == kStdOut && verbosity == 2) {
verbosity = 1;
}
// If we are in multi-file mode, turn off interaction
if (inputFiles.size() > 1 && verbosity == 2) {
verbosity = 1;
}
// Set options for test mode
if (test) {
outputFile = nullOutput;
keepSource = true;
}
return Status::Success;
}
bool Kleo::KpgpBackendBase::checkForSMIME( QString * reason ) const {
if ( reason ) *reason = notSupported();
return false;
}
