/* Parse a single argument with matching templates. */
static int
parse_arg(struct fuse_args* args, int *argi, const char* arg,
struct fuse_args *outargs, void *data,
const struct fuse_opt *opts, fuse_opt_proc_t proc, bool is_opt)
{
int sep_idx;
const struct fuse_opt *opt = find_opt(opts, arg, &sep_idx);
if (opt) {
/* An argument can match to multiple templates. Process them
* all. */
for (; opt != NULL && opt->templ != NULL;
opt = find_opt(++opt, arg, &sep_idx)) {
if (sep_idx > 0 && opt->templ[sep_idx] == ' ' &&
arg[sep_idx] == '\0') {
/* The template "-x %y" requests a separate
* parameter "%y". Try to find one. */
char *new_arg;
int rv;
if (next_arg(args, argi) == -1)
return -1;
/* ...but processor callbacks expect a concatenated
* argument "-xfoo". */
if ((new_arg = malloc(sep_idx +
strlen(args->argv[*argi]) + 1)) == NULL)
return -1;
strncpy(new_arg, arg, sep_idx); /* -x */
strcpy(new_arg + sep_idx, args->argv[*argi]); /* foo */
rv = parse_matched_arg(new_arg, outargs, opt, sep_idx,
data, proc, is_opt);
free(new_arg);
if (rv == -1)
return -1;
}
else {
int rv;
rv = parse_matched_arg(arg, outargs, opt, sep_idx,
data, proc, is_opt);
if (rv == -1)
return -1;
}
}
return 0;
}
else {
/* No templates matched to it so just invoke the callback. */
return call_proc(proc, data, arg, FUSE_OPT_KEY_OPT, outargs, is_opt);
}
}
void
test ()
{
HSTMT hstmt;
SQLRETURN rc;
rc = SQLAllocHandle (SQL_HANDLE_STMT, (SQLHANDLE) hdbc,
(SQLHANDLE *) & hstmt);
if (rc != SQL_SUCCESS)
{
err_printf ("SQLAllocHandle() failed.\n");
return;
}
rc = SQLPrepare (hstmt, "burstoff_rs_proc ()", SQL_NTS);
if (rc != SQL_SUCCESS)
{
err_printf ("prepare failed.\n");
error (SQL_HANDLE_STMT, (SQLHANDLE) hstmt);
exit (1);
}
call_proc (10);
printf ("test: SQLExecute\n");
rc = SQLExecute (hstmt);
if (rc != SQL_SUCCESS)
{
err_printf ("exec failed.\n");
error (SQL_HANDLE_STMT, (SQLHANDLE) hstmt);
exit (1);
}
printf ("test: SQLFetch\n");
rc = SQLFetch (hstmt);
if (rc != SQL_SUCCESS)
{
err_printf ("fetch failed.\n");
error (SQL_HANDLE_STMT, (SQLHANDLE) hstmt);
exit (1);
}
printf ("test: SQLCancel\n");
rc = SQLCancel (hstmt);
if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO)
{
err_printf ("SQLCancel() failed.\n");
exit (-1);
}
printf ("test: SQLFreeHandle\n");
rc = SQLFreeHandle (SQL_HANDLE_STMT, (SQLHANDLE) hstmt);
}
/* Parse a single argument with a matched template. */
static int
parse_matched_arg(const char* arg, struct fuse_args *outargs,
const struct fuse_opt* opt, int sep_idx, void* data,
fuse_opt_proc_t proc, bool is_opt)
{
if (opt->offset == -1) {
/* The option description does not want any variables to be
* updated.*/
if (call_proc(proc, data, arg, opt->value, outargs, is_opt) == -1)
return -1;
}
else {
void *var = (char*)data + opt->offset;
if (sep_idx > 0 && opt->templ[sep_idx + 1] == '%') {
/* "foo=%y" or "-x %y" */
const char* param =
opt->templ[sep_idx] == '=' ? &arg[sep_idx + 1] : &arg[sep_idx];
if (opt->templ[sep_idx + 2] == 's') {
char* dup = strdup(param);
if (dup == NULL)
return -1;
*(char **)var = dup;
}
else {
/* The format string is not a literal. We all know
* this is a bad idea but it's exactly what fuse_opt
* wants to do... */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
if (sscanf(param, &opt->templ[sep_idx + 1], var) == -1) {
#pragma GCC diagnostic pop
(void)fprintf(stderr, "fuse: '%s' is not a "
"valid parameter for option '%.*s'\n",
param, sep_idx, opt->templ);
return -1;
}
}
}
else {
/* No parameter format is given. */
*(int *)var = opt->value;
}
}
return 0;
}
static int process_gopt(struct fuse_opt_context *ctx, const char *arg, int iso)
{
unsigned sep;
const struct fuse_opt *opt = find_opt(ctx->opt, arg, &sep);
if (opt) {
for (; opt; opt = find_opt(opt + 1, arg, &sep)) {
int res;
if (sep && opt->templ[sep] == ' ' && !arg[sep])
res = process_opt_sep_arg(ctx, opt, sep, arg, iso);
else
res = process_opt(ctx, opt, sep, arg, iso);
if (res == -1)
return -1;
}
return 0;
} else
return call_proc(ctx, arg, FUSE_OPT_KEY_OPT, iso);
}
static int process_opt(struct fuse_opt_context *ctx,
const struct fuse_opt *opt, unsigned sep,
const char *arg, int iso)
{
if (opt->offset == -1U) {
if (call_proc(ctx, arg, opt->value, iso) == -1)
return -1;
} else {
void *var = ctx->data + opt->offset;
if (sep && opt->templ[sep + 1]) {
const char *param = arg + sep;
if (opt->templ[sep] == '=')
param ++;
if (process_opt_param(var, opt->templ + sep + 1,
param, arg) == -1)
return -1;
} else
*(int *)var = opt->value;
}
return 0;
}
static int process_one(struct fuse_opt_context *ctx, const char *arg)
{
if (ctx->nonopt || arg[0] != '-')
return call_proc(ctx, arg, FUSE_OPT_KEY_NONOPT, 0);
else if (arg[1] == 'o') {
if (arg[2])
return process_option_group(ctx, arg + 2);
else {
if (next_arg(ctx, arg) == -1)
return -1;
return process_option_group(ctx, ctx->argv[ctx->argctr]);
}
} else if (arg[1] == '-' && !arg[2]) {
if (add_arg(ctx, arg) == -1)
return -1;
ctx->nonopt = ctx->outargs.argc;
return 0;
} else
return process_gopt(ctx, arg, 0);
}
static int
parse_all(struct fuse_args *args, struct fuse_args *outargs, void *data,
const struct fuse_opt *opts, fuse_opt_proc_t proc)
{
bool nonopt = false; /* Have we seen the "--" marker? */
int i;
/* The first argument, the program name, is implicitly
* FUSE_OPT_KEY_KEEP. */
if (args->argc > 0) {
if (fuse_opt_add_arg(outargs, args->argv[0]) == -1)
return -1;
}
/* the real loop to process the arguments */
for (i = 1; i < args->argc; i++) {
const char *arg = args->argv[i];
/* argvn != -foo... */
if (nonopt || arg[0] != '-') {
if (call_proc(proc, data, arg, FUSE_OPT_KEY_NONOPT,
outargs, false) == -1)
return -1;
}
/* -o or -ofoo */
else if (arg[1] == 'o') {
/* -oblah,foo... */
if (arg[2] != '\0') {
/* skip -o */
if (parse_opts(args, &i, arg + 2, outargs,
data, opts, proc) == -1)
return -1;
}
/* -o blah,foo... */
else {
if (next_arg(args, &i) == -1)
return -1;
if (parse_opts(args, &i, args->argv[i], outargs,
data, opts, proc) == -1)
return -1;
}
}
/* -- */
else if (arg[1] == '-' && arg[2] == '\0') {
if (fuse_opt_add_arg(outargs, arg) == -1)
return -1;
nonopt = true;
}
/* -foo */
else {
if (parse_arg(args, &i, arg, outargs,
data, opts, proc, false) == -1)
return -1;
}
}
/* The "--" marker at the last of outargs should be removed */
if (nonopt && strcmp(outargs->argv[outargs->argc - 1], "--") == 0) {
free(outargs->argv[outargs->argc - 1]);
outargs->argv[--outargs->argc] = NULL;
}
return 0;
}
/* * @brief * 本函数实现向数据库中存放Books的信息 * @name Add * @arg * pObj QObject* ：@class Books*, 需要添加到数据库的信息 * @return bool * true 执行成功 * false 执行失败 * @author * QiumingLu Email:[email protected] * @test * no */ bool DaoBooks::Add(Books *pObj) { Q_ASSERT(pObj != NULL); QStringList outFields("BOOK_ID"); //primary key return call_proc(pObj, "BOOKS_INSERT_PROC", outFields); }
int main(int argc, char** argv)
{
int ret;
setup_dir();
/* init globals */
gcc = sa_concat(gcc, "gcc"); /* replaced laterwards if c++ */
gcc = sa_concat(gcc, "-I.");
src_lines =
sa_concat(src_lines,
"#define __LARGE_C__ " VERSION_INT_STR "\n"
"#ifdef __cplusplus\n"
"extern \"C\" {\n"
"#endif\n"
"#include <stdio.h>\n"
"#include <stdlib.h>\n"
"#ifdef __cplusplus\n"
"}\n"
"#include <iostream>\n"
"using namespace std;\n"
"#endif\n"
"\n"
"__LARGE_C_PREFIX__\n");
argv++;
{ /* parse args, determine cache dir */
char** new_argv = parse_args(argv, NULL, 0);
for (; argv != new_argv; argv++) {
add_spec(*argv, strlen(*argv) + 1);
}
if (! keep_files && (oneliner || *argv != NULL)) {
struct stat st;
if (oneliner) {
build_store_dir();
} else if (stat(*argv, &st) == 0) {
add_spec(*argv, strlen(*argv) + 1);
add_spec(&st.st_size, sizeof(st.st_size));
add_spec(&st.st_mtime, sizeof(st.st_mtime));
build_store_dir();
}
}
}
/* use cache if possible */
if (store_dir != NULL && check_specs()) {
char** child_argv = NULL;
#ifdef _WIN32
_utime(store_dir, NULL); /* update mtime of the directory */
#else
utimes(store_dir, NULL); /* update mtime of the directory */
#endif
exec_file = str_concat(str_dup(store_dir), "/"A_OUT);
child_argv = sa_concat(child_argv, exec_file);
#ifdef _WIN32
{
int status;
ret = spawn_w32(child_argv, &status);
if (status == 0) exit(ret);
}
#else
execv(exec_file, child_argv);
#endif
// if execv failed, we compile
free(exec_file);
remove_dir(store_dir);
}
/* prepare files */
make_temp_dir();
exec_file = str_concat(str_dup(temp_dir), "/"A_OUT);
c_file = str_concat(str_dup(temp_dir), "/source.c");
if ((src_fp = fopen(c_file, "wt")) == NULL) {
cmd_error("failed to create temporary file: %s : %s\n", c_file,
strerror(errno));
}
while (src_lines != NULL && *src_lines != NULL) {
fputs(*src_lines++, src_fp);
}
/* write source with adjustments */
if (! oneliner) {
FILE* fp;
char* file;
char* line;
int line_no = 0;
if (argv[0] == NULL) {
fp = stdin;
file = "stdin";
} else if (strcmp(argv[0], "-") == 0) {
fp = stdin;
argv++;
file = "stdin";
} else {
file = *argv++;
if ((fp = fopen(file, "rt")) == NULL) {
cmd_error("cannot open file: %s : %s\n", file, strerror(errno));
}
fprintf(src_fp, "# 1 \"%s\" 1\n", file);
}
while ((line = get_line(fp)) != NULL) {
int comment_out = 0;
line_no++;
if (line_no == 1 && strncmp(line, "#!", 2) == 0) {
comment_out = 1;
} else if (line[0] == '#') {
char* buf = str_dup(line + 1);
char** tokens = split_tokens(buf);
if (*tokens != NULL) {
if (strcmp(tokens[0], "option") == 0) {
parse_args(tokens + 1, file, line_no);
comment_out = 1;
}
}
free(buf);
free(tokens);
}
if (comment_out == 1) {
fprintf(src_fp, "// ");
}
fputs(line, src_fp);
}
fputs("\n", src_fp);
if (fp != stdin) {
fclose(fp);
}
}
/* close source file */
fputs("__LARGE_C_SUFFIX__\n", src_fp);
fclose(src_fp);
src_fp = NULL;
/* compile */
if (use_plusplus) {
gcc[0] = "g++";
}
if (use_main) {
gcc = sa_concat(gcc, "-D__LARGE_C_PREFIX__=");
gcc = sa_concat(gcc, "-D__LARGE_C_SUFFIX__=");
} else {
gcc =
sa_concat(gcc, "-D__LARGE_C_PREFIX__=int main(int argc, char** argv) {");
gcc = sa_concat(gcc, "-D__LARGE_C_SUFFIX__=; return 0; }");
}
gcc = sa_concat(gcc, "-o");
gcc = sa_concat(gcc, show_disassembly ? "-" : exec_file);
gcc = sa_concat(gcc, c_file);
gcc = sa_merge(gcc, lopts);
if ((ret = call_proc(gcc, "could not execute compiler")) != 0) {
cleanup();
exit(ret);
}
if (show_disassembly) {
cleanup();
exit(0);
}
{ /* execute */
char** child_argv = NULL;
if (use_debugger) {
child_argv = sa_concat(child_argv, "gdb");
}
child_argv = sa_concat(child_argv, exec_file);
child_argv = sa_merge(child_argv, argv);
ret = call_proc(child_argv, "could not spawn child process");
}
/* move temp_dir to store_dir, if possible.
* or, remove work_dir
*/
if (store_dir == NULL) {
cleanup();
} else {
save_specs();
update_cache();
if (rename(temp_dir, store_dir) != 0) {
cleanup();
}
}
return ret;
}
