int CvArrTest::write_default_params( CvFileStorage* fs ) { int code = CvTest::write_default_params( fs ); if( code < 0 ) return code; if( ts->get_testing_mode() == CvTS::CORRECTNESS_CHECK_MODE ) { write_param( fs, "test_case_count", test_case_count ); write_param( fs, "min_log_array_size", min_log_array_size ); write_param( fs, "max_log_array_size", max_log_array_size ); } else if( ts->get_testing_mode() == CvTS::TIMING_MODE ) { int i; start_write_param( fs ); // make sure we have written the entry header containing the test name if( size_list ) { cvStartWriteStruct( fs, "size", CV_NODE_SEQ+CV_NODE_FLOW ); for( i = 0; size_list[i].width >= 0; i++ ) { cvStartWriteStruct( fs, 0, CV_NODE_SEQ+CV_NODE_FLOW ); cvWriteInt( fs, 0, size_list[i].width ); cvWriteInt( fs, 0, size_list[i].height ); if( whole_size_list && (whole_size_list[i].width > size_list[i].width || whole_size_list[i].height > size_list[i].height) ) { cvWriteInt( fs, 0, whole_size_list[i].width ); cvWriteInt( fs, 0, whole_size_list[i].height ); } cvEndWriteStruct( fs ); } cvEndWriteStruct(fs); } if( depth_list ) { cvStartWriteStruct( fs, "depth", CV_NODE_SEQ+CV_NODE_FLOW ); for( i = 0; depth_list[i] >= 0; i++ ) cvWriteString( fs, 0, cvTsGetTypeName(depth_list[i]) ); cvEndWriteStruct(fs); } write_int_list( fs, "channels", cn_list, -1, -1 ); if( optional_mask ) { static const int use_mask[] = { 0, 1 }; write_int_list( fs, "use_mask", use_mask, 2 ); } } return 0; }
int CV_BaseHistTest::write_default_params( CvFileStorage* fs ) { CvTest::write_default_params( fs ); if( ts->get_testing_mode() != CvTS::TIMING_MODE ) { write_param( fs, "test_case_count", test_case_count ); write_param( fs, "max_log_size", max_log_size ); write_param( fs, "max_log_array_size", img_max_log_size ); write_param( fs, "max_dims", max_cdims ); } return 0; }
static ssize_t dsm_ctrl_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) { int rc=0; static u8 param[DSM_PARAM_SZIE]; int x; mutex_lock(&rx_lock); //pr_info("%s enter. (count:%d)\n", __func__, count); rc = copy_from_user(param, buf, count); if (rc != 0) { //pr_info("copy_from_user failed. (rc=%d)", rc); mutex_unlock(&rx_lock); return rc; } //pr_info("----------------------------------------------------\n"); for(x=0;x<80;x+=4) { //pr_info("[RYAN] dsm_ctrl_write[%d] %d %d %d %d\n", x, param[x], param[x+1], param[x+2], param[x+3]); } write_param(param); mutex_unlock(&rx_lock); //pr_info("%s out.(count=%d, rc=%d)\n", __func__, count, rc); return rc; }
void Quadrotor::write() { int n = (ti_f_ > 0) ? ti_f_ : N_; brain_->write(n); //brain_->pos_->write(ti_f_); //brain_->att_->write(ti_f_); plant_->write(n); telem_->write(n); write_param(); }
void write_params(list_p p, FILE* f) { list_iter_p iter; param_p d; if(p == NULL || f == NULL) return; fprintf(f, "%s", BEGIN_TABULAR); iter = list_iterator(p); for(d = list_next(iter); d != NULL; d = list_next(iter)) { write_param(d, f); } fprintf(f, "%s", END_TABULAR); }
/* * Shared between the interface class declaration and the NS_DECL_IFOO macro * provided to aid declaration of implementation classes. * mode... * AS_DECL writes 'NS_IMETHOD foo(string bar, long sil)' * AS_IMPL writes 'NS_IMETHODIMP className::foo(string bar, long sil)' * AS_CALL writes 'foo(bar, sil)' */ static gboolean write_method_signature(IDL_tree method_tree, FILE *outfile, int mode, const char *className) { struct _IDL_OP_DCL *op = &IDL_OP_DCL(method_tree); gboolean no_generated_args = TRUE; gboolean op_notxpcom = (IDL_tree_property_get(op->ident, "notxpcom") != NULL); const char *name; IDL_tree iter; if (mode == AS_DECL) { if (op_notxpcom) { fputs("NS_IMETHOD_(", outfile); if (!write_type(op->op_type_spec, FALSE, outfile)) return FALSE; fputc(')', outfile); } else { fputs("NS_IMETHOD", outfile); } fputc(' ', outfile); } else if (mode == AS_IMPL) { if (op_notxpcom) { fputs("NS_IMETHODIMP_(", outfile); if (!write_type(op->op_type_spec, FALSE, outfile)) return FALSE; fputc(')', outfile); } else { fputs("NS_IMETHODIMP", outfile); } fputc(' ', outfile); } name = IDL_IDENT(op->ident).str; if (mode == AS_IMPL) { fprintf(outfile, "%s::%c%s(", className, toupper(*name), name + 1); } else { fprintf(outfile, "%c%s(", toupper(*name), name + 1); } for (iter = op->parameter_dcls; iter; iter = IDL_LIST(iter).next) { if (mode == AS_DECL || mode == AS_IMPL) { if (!write_param(IDL_LIST(iter).data, outfile)) return FALSE; } else { fputs(IDL_IDENT(IDL_PARAM_DCL(IDL_LIST(iter).data) .simple_declarator).str, outfile); } if ((IDL_LIST(iter).next || (!op_notxpcom && op->op_type_spec) || op->f_varargs)) fputs(", ", outfile); no_generated_args = FALSE; } /* make IDL return value into trailing out argument */ if (op->op_type_spec && !op_notxpcom) { IDL_tree fake_param = IDL_param_dcl_new(IDL_PARAM_OUT, op->op_type_spec, IDL_ident_new("_retval")); if (!fake_param) return FALSE; if (mode == AS_DECL || mode == AS_IMPL) { if (!write_param(fake_param, outfile)) return FALSE; } else { fputs("_retval", outfile); } if (op->f_varargs) fputs(", ", outfile); no_generated_args = FALSE; } /* varargs go last */ if (op->f_varargs) { if (mode == AS_DECL || mode == AS_IMPL) { fputs("nsVarArgs *", outfile); } fputs("_varargs", outfile); no_generated_args = FALSE; } /* * If generated method has no arguments, output 'void' to avoid C legacy * behavior of disabling type checking. */ if (no_generated_args && mode == AS_DECL) { fputs("void", outfile); } fputc(')', outfile); return TRUE; }
void generate_receiver( FILE *file, struct function *f ) { struct param *p; struct external *e; if( strcmp(f->name->text,pattern_complete(f->options->remote_name->text,f->name->text)) ) { fprintf(file,"\t\t/* %s uses the same receiver as %s */\n\n",f->name->text,pattern_complete(f->options->remote_name->text,f->name->text)); return; } fprintf(file,"\t\tcase BYPASS_CALL_%s:\n",f->name->text); fprintf(file,"\t\t{\n"); if(!is_void(f->type)) { fprintf(file,"\t\t%s result;\n",type_string(f->type)); } /* Declare all the params */ for( p=f->params; p; p=p->next ) { fprintf(file,"\t\t%s %s=0;\n",type_string_noconst(p->type),p->name->text); } /* Get the params */ e=f->options->external; for( p=f->params; p; p=p->next ) { if( p->control->in ) { write_param( file, "bypass_packet", "EXTERNAL_IN", p, e ); } if(e) e=e->next; } /* Allocate space for any out-only parameters */ for( p=f->params; p; p=p->next ) { if( p->control->out && !p->control->in ) { write_alloc_param( file, "bypass_response", p ); } } fprintf(file,"\t\terrno = 0;\n"); /* If the function is not supported, send back an error. */ /* Otherwise, invoke the shadow action */ if( f->options->not_supported ) { fprintf(file,"\t\terrno = EINVAL;\n\n"); } else { if(!is_void(f->type)) { fprintf(file,"\t\tresult ="); } else { fprintf(file,"\t\t"); } fprintf(file,"bypass_shadow_action_%s( %s );\n",f->name->text,arg_string(f->params)); } fprintf(file,"\t\tbypass_errno = errno;\n"); /* Send back errno, then result, then out params */ fprintf(file,"\t\tTRY(external_errno_map(bypass_response,EXTERNAL_OUT,&bypass_errno));\n"); if(!is_void(f->type)) { fprintf(file,"\t\tTRY(external(bypass_response,EXTERNAL_OUT,&result));\n"); } e=f->options->external; for( p=f->params; p; p=p->next ) { if( p->control->out ) { write_param( file, "bypass_response", "EXTERNAL_OUT", p, e); } if(e) e=e->next; } /* All done. */ fprintf(file,"\t\t}\n"); fprintf(file,"\t\tbreak;\n\n"); }
void generate_sender( FILE *file, struct function *f ) { struct param *p; char *fail_string; struct external *e; /* Create an appropriate exception handler */ if(f->type->stars) { fail_string="0"; } else if(!is_void(f->type)) { fail_string="-1"; } else { fail_string=""; } /* Write the function header */ fprintf(file,"extern \"C\" %s bypass_shadow_%s( %s )\n{\n",type_string(f->type),f->name->text,param_string_noconst(f->params)); /* Declare private bypass values */ fprintf(file,"\tstruct packet *bypass_packet=0;\n"); fprintf(file,"\tint bypass_errno=0;\n"); fprintf(file,"\tint bypass_number = BYPASS_CALL_%s;\n",f->name->text); if(!is_void(f->type)) { fprintf(file,"%s result;\n",type_string(f->type)); } write_vararg_decls(file,f->params); /* If the connection has not been made, do it now. */ fprintf(file,"\tif(!bypass_rpc_init()) goto fail;\n"); /* Start up a new packet */ fprintf(file,"\tTRY(bypass_packet = packet_create(0));\n"); /* Send the number of this call */ fprintf(file,"\tTRY(external(bypass_packet,EXTERNAL_OUT,&bypass_number));\n"); /* Send the params */ e = f->options->external; for( p=f->params; p; p=p->next ) { if( p->control->in ) { write_param( file, "bypass_packet", "EXTERNAL_OUT", p, e ); } if(e) e=e->next; } /* Finally, fire off the packet */ fprintf(file,"\tTRY(packet_put(bypass_rpc_fd_get(),bypass_packet));\n"); fprintf(file,"\tpacket_delete(bypass_packet);\n"); fprintf(file,"\tbypass_packet=0;\n\n"); /* Grab the result packet */ fprintf(file,"\tTRY(bypass_packet = packet_get(bypass_rpc_fd_get()));\n"); /* Get errno, then result, then out parameters */ fprintf(file,"\tTRY(external_errno_map(bypass_packet,EXTERNAL_IN,&bypass_errno));\n"); if(!is_void(f->type)) { fprintf(file,"\t\tTRY(external(bypass_packet,EXTERNAL_IN,&result));\n"); } e = f->options->external; for( p=f->params; p; p=p->next ) { if( p->control->out ) { write_param( file, "bypass_packet", "EXTERNAL_IN", p, e ); } if(e) e=e->next; } fprintf(file,"\tpacket_delete(bypass_packet);\n"); fprintf(file,"\terrno = bypass_errno;\n"); if(!is_void(f->type)) { fprintf(file,"\treturn result;\n"); } else { fprintf(file,"\treturn;\n"); } fprintf(file,"\n"); /* In the event of a network failure, clean up, and close the connection */ fprintf(file,"\tfail:\n"); fprintf(file,"\tbypass_errno = errno;\n"); fprintf(file,"\tif(bypass_packet) packet_delete(bypass_packet);\n"); fprintf(file,"\tbypass_rpc_close();\n"); /* If retries are turned on, put a message and sleep */ fprintf(file,"\tchar message[1024];\n"); fprintf(file,"\tsprintf(message,\"couldn't execute %%s: %%s\\n\",bypass_call_string(bypass_number),strerror(bypass_errno));\n"); fprintf(file,"\tif(bypass_failure_passthrough) {\n"); fprintf(file,"\t\tbypass_debug(message);\n"); fprintf(file,"\t} else {\n"); fprintf(file,"\t\tbypass_fatal(message);\n"); fprintf(file,"\t}\n"); fprintf(file,"\terrno = bypass_errno;\n"); fprintf(file,"\treturn %s;\n",fail_string); fprintf(file,"}\n\n"); }
/** * Perform a read, write or just a listing of a parameter * * \param[in] popt list,set,get parameter options * \param[in] pattern search filter for the path of the parameter * \param[in] value value to set the parameter if write operation * \param[in] mode what operation to perform with the parameter * * \retval number of bytes written on success. * \retval -errno on error and prints error message. */ static int param_display(struct param_opts *popt, char *pattern, char *value, enum parameter_operation mode) { int dir_count = 0; char **dir_cache; glob_t paths; char *opname = parameter_opname[mode]; int rc, i; rc = cfs_get_param_paths(&paths, "%s", pattern); if (rc != 0) { rc = -errno; if (!popt->po_recursive) { fprintf(stderr, "error: %s: param_path '%s': %s\n", opname, pattern, strerror(errno)); } return rc; } dir_cache = calloc(paths.gl_pathc, sizeof(char *)); if (dir_cache == NULL) { rc = -ENOMEM; fprintf(stderr, "error: %s: allocating '%s' dir_cache[%zd]: %s\n", opname, pattern, paths.gl_pathc, strerror(-rc)); goto out_param; } for (i = 0; i < paths.gl_pathc; i++) { char *param_name = NULL, *tmp; char pathname[PATH_MAX]; struct stat st; int rc2; if (stat(paths.gl_pathv[i], &st) == -1) { fprintf(stderr, "error: %s: stat '%s': %s\n", opname, paths.gl_pathv[i], strerror(errno)); if (rc == 0) rc = -errno; continue; } if (popt->po_only_dir && !S_ISDIR(st.st_mode)) continue; param_name = display_name(paths.gl_pathv[i], &st, popt); if (param_name == NULL) { fprintf(stderr, "error: %s: generating name for '%s': %s\n", opname, paths.gl_pathv[i], strerror(ENOMEM)); if (rc == 0) rc = -ENOMEM; continue; } /** * For the upstream client the parameter files locations * are split between under both /sys/kernel/debug/lustre * and /sys/fs/lustre. The parameter files containing * small amounts of data, less than a page in size, are * located under /sys/fs/lustre and in the case of large * parameter data files, think stats for example, are * located in the debugfs tree. Since the files are split * across two trees the directories are often duplicated * which means these directories are listed twice which * leads to duplicate output to the user. To avoid scanning * a directory twice we have to cache any directory and * check if a search has been requested twice. */ if (S_ISDIR(st.st_mode)) { int j; for (j = 0; j < dir_count; j++) { if (!strcmp(dir_cache[j], param_name)) break; } if (j != dir_count) { free(param_name); param_name = NULL; continue; } dir_cache[dir_count++] = strdup(param_name); } switch (mode) { case GET_PARAM: /* Read the contents of file to stdout */ if (S_ISREG(st.st_mode)) read_param(paths.gl_pathv[i], param_name, popt); break; case SET_PARAM: if (S_ISREG(st.st_mode)) { rc2 = write_param(paths.gl_pathv[i], param_name, popt, value); if (rc2 < 0 && rc == 0) rc = rc2; } break; case LIST_PARAM: if (popt->po_show_path) printf("%s\n", param_name); break; } /* Only directories are searched recursively if * requested by the user */ if (!S_ISDIR(st.st_mode) || !popt->po_recursive) { free(param_name); param_name = NULL; continue; } /* Turn param_name into file path format */ rc2 = clean_path(popt, param_name); if (rc2 < 0) { fprintf(stderr, "error: %s: cleaning '%s': %s\n", opname, param_name, strerror(-rc2)); free(param_name); param_name = NULL; if (rc == 0) rc = rc2; continue; } /* Use param_name to grab subdirectory tree from full path */ tmp = strstr(paths.gl_pathv[i], param_name); /* cleanup paramname now that we are done with it */ free(param_name); param_name = NULL; /* Shouldn't happen but just in case */ if (tmp == NULL) { if (rc == 0) rc = -EINVAL; continue; } rc2 = snprintf(pathname, sizeof(pathname), "%s/*", tmp); if (rc2 < 0) { /* snprintf() should never an error, and if it does * there isn't much point trying to use fprintf() */ continue; } if (rc2 >= sizeof(pathname)) { fprintf(stderr, "error: %s: overflow processing '%s'\n", opname, pathname); if (rc == 0) rc = -EINVAL; continue; } rc2 = param_display(popt, pathname, value, mode); if (rc2 != 0 && rc2 != -ENOENT) { /* errors will be printed by param_display() */ if (rc == 0) rc = rc2; continue; } } for (i = 0; i < dir_count; i++) free(dir_cache[i]); free(dir_cache); out_param: cfs_free_param_data(&paths); return rc; }
/* * Shared between the interface class declaration and the NS_DECL_IFOO macro * provided to aid declaration of implementation classes. * mode... */ static gboolean write_method_signature(IDL_tree method_tree, FILE *outfile, const char *className) { struct _IDL_OP_DCL *op = &IDL_OP_DCL(method_tree); gboolean no_generated_args = TRUE; gboolean op_notxpcom = (IDL_tree_property_get(op->ident, "notxpcom") != NULL); const char *name; IDL_tree iter; if (op_notxpcom && !op->op_type_spec) fputs("procedure ", outfile); else fputs("function ", outfile); name = IDL_IDENT(op->ident).str; if( is_reserved(name) ) fputc('_', outfile); fprintf(outfile, "%c%s(", toupper(*name), name + 1); for (iter = op->parameter_dcls; iter; iter = IDL_LIST(iter).next) { if (!write_param(IDL_LIST(iter).data, outfile)) return FALSE; if ((IDL_LIST(iter).next || (!op_notxpcom && op->op_type_spec) || op->f_varargs)) fputs("; ", outfile); no_generated_args = FALSE; } /* make IDL return value into trailing out argument */ if (op->op_type_spec && !op_notxpcom) { IDL_tree fake_param = IDL_param_dcl_new(IDL_PARAM_OUT, op->op_type_spec, IDL_ident_new("_retval")); if (!fake_param) return FALSE; if (!write_param(fake_param, outfile)) return FALSE; if (op->f_varargs) fputs("; ", outfile); no_generated_args = FALSE; } /* varargs go last */ if (op->f_varargs) { fputs("_varargs : PVarArgs", outfile); no_generated_args = FALSE; } fputc(')', outfile); if (op_notxpcom) { if (!interface_write_type(op->op_type_spec, FALSE, FALSE, FALSE, FALSE, NULL, outfile)) return FALSE; } else { fputs(": nsresult", outfile); } fputs("; stdcall", outfile); return TRUE; }