int main(void) { do_mult("1", "3"); do_mult("9", "2"); do_mult("10", "42"); do_mult("9", "99"); do_convert("101010", "01"); do_convert("2A", "0123456789ABCDEF"); do_substract("10", "5"); do_substract("11", "9"); do_substract("100", "99"); do_divide("10", "2"); do_divide("21", "2"); do_divide("500", "4"); do_divide("500", "25"); do_divide("500000000000000005", "5"); do_divide("500000000500000005", "5"); do_divide("500000000500000005", "2"); do_divide("833", "42"); do_divide("50458", "357"); do_divide("80303", "42"); do_mod("10", "2"); do_mod("11", "2"); do_mod("50", "4"); do_mod("50000", "7"); do_mod("50000", "365"); converter("101010", "01", "0123456789ABCDEF"); converter("101010", "01", "0123456789"); converter("11101110", "01", "abcdefghij"); converter("99989998", "89", "abcdefghij"); return 0; }
static void convert(struct snd_pcm_plugin *plugin, const struct snd_pcm_plugin_channel *src_channels, struct snd_pcm_plugin_channel *dst_channels, snd_pcm_uframes_t frames) { struct linear_priv *data = (struct linear_priv *)plugin->extra_data; int channel; int nchannels = plugin->src_format.channels; for (channel = 0; channel < nchannels; ++channel) { char *src; char *dst; int src_step, dst_step; snd_pcm_uframes_t frames1; if (!src_channels[channel].enabled) { if (dst_channels[channel].wanted) snd_pcm_area_silence(&dst_channels[channel].area, 0, frames, plugin->dst_format.format); dst_channels[channel].enabled = 0; continue; } dst_channels[channel].enabled = 1; src = src_channels[channel].area.addr + src_channels[channel].area.first / 8; dst = dst_channels[channel].area.addr + dst_channels[channel].area.first / 8; src_step = src_channels[channel].area.step / 8; dst_step = dst_channels[channel].area.step / 8; frames1 = frames; while (frames1-- > 0) { do_convert(data, dst, src); src += src_step; dst += dst_step; } } }
int main(object me,string arg) //arg should be like this: "/d/fy/ 15,4,3" like this { string *files; string dir; int i; int size; set_eval_limit(1); seteuid(getuid()); return notify_fail(" 此命令用于转换相对坐标,破坏性极大, 风云4.0已完成此项工作,如果需要使用此命令请阅读修改此文件后执行。\n"); sscanf(arg,"%s %d,%d,%d",dir,xcenter,ycenter,zcenter); files= get_dir(dir); for(i=0; i<sizeof(files); i++) { size=sizeof(files[i]); if(files[i][(size-2)..size]==".c") { do_convert(dir+files[i]); } } return 1; }
bool cdio_charset_to_utf8(char *src, size_t src_len, cdio_utf8_t **dst, const char * src_charset) { iconv_t ic; bool result; ic = iconv_open("UTF-8", src_charset); result = do_convert(ic, src, src_len, dst, NULL); iconv_close(ic); return result; }
bool cdio_charset_from_utf8(cdio_utf8_t * src, char ** dst, int * dst_len, const char * dst_charset) { iconv_t ic; bool result; ic = iconv_open(dst_charset, "UTF-8"); result = do_convert(ic, src, -1, dst, dst_len); iconv_close(ic); return result; }
int dropbearconvert_main(int argc, char ** argv) { #else int main(int argc, char ** argv) { #endif int intype, outtype; const char* infile; const char* outfile; crypto_init(); seedrandom(); #if DEBUG_TRACE /* It's hard for it to get in the way _too_ much */ debug_trace = 1; #endif /* get the commandline options */ if (argc != 5) { fprintf(stderr, "All arguments must be specified\n"); goto usage; } /* input type */ if (argv[1][0] == 'd') { intype = KEYFILE_DROPBEAR; } else if (argv[1][0] == 'o') { intype = KEYFILE_OPENSSH; } else { fprintf(stderr, "Invalid input key type\n"); goto usage; } /* output type */ if (argv[2][0] == 'd') { outtype = KEYFILE_DROPBEAR; } else if (argv[2][0] == 'o') { outtype = KEYFILE_OPENSSH; } else { fprintf(stderr, "Invalid output key type\n"); goto usage; } /* we don't want output readable by others */ umask(077); infile = argv[3]; outfile = argv[4]; return do_convert(intype, infile, outtype, outfile); usage: printhelp(argv[0]); return 1; }
int main(int argc, char **argv) { int opt; struct state st; memset(&st, 0, sizeof(st)); st.bytes = 0x23d0; while ((opt = getopt(argc, argv, "i:o:s:v")) != -1) { switch(opt) { case 'i': if (st.in_fd) close(st.in_fd); st.in_fd = open(optarg, O_RDONLY); if (-1 == st.in_fd) { perror("Unable to open ram stream"); return 1; } break; case 'o': if (st.out_fd) close(st.out_fd); st.out_fd = open(optarg, O_WRONLY | O_CREAT | O_TRUNC, 0644); if (-1 == st.out_fd) { perror("Unable to open output stream"); return 1; } break; case 'v': st.verbose++; break; case 'b': st.bytes = strtoul(optarg, NULL, 0); break; case 'h': default: return print_usage(argv[0]); } } if (!st.out_fd || !st.in_fd) return print_usage(argv[0]); argv += optind; argc -= optind; return do_convert(&st); }
/* * take the input as a pascal string and return a converted c-string in UTF-8 * returns the number of bytes read, return -1 if fatal error * the converted UTF-8 will be saved in ret * Return: *ret != NULL */ gint qq_get_vstr(gchar **ret, const gchar *from_charset, guint8 *data) { guint8 len; g_return_val_if_fail(data != NULL && from_charset != NULL, -1); len = data[0]; if (len == 0) { *ret = g_strdup(""); return 1; } *ret = do_convert((gchar *) (data + 1), (gssize) len, UTF8, from_charset); return len + 1; }
int dropbearconvert_main(int argc, char ** argv) { #else int main(int argc, char ** argv) { #endif int intype, outtype; const char* infile; const char* outfile; /* get the commandline options */ if (argc != 5) { fprintf(stderr, "All arguments must be specified\n"); goto usage; } /* input type */ if (argv[1][0] == 'd') { intype = KEYFILE_DROPBEAR; } else if (argv[1][0] == 'o') { intype = KEYFILE_OPENSSH; } else { fprintf(stderr, "Invalid input key type\n"); goto usage; } /* output type */ if (argv[2][0] == 'd') { outtype = KEYFILE_DROPBEAR; } else if (argv[2][0] == 'o') { outtype = KEYFILE_OPENSSH; } else { fprintf(stderr, "Invalid output key type\n"); goto usage; } /* we don't want output readable by others */ umask(077); infile = argv[3]; outfile = argv[4]; return do_convert(intype, infile, outtype, outfile); usage: printhelp(argv[0]); return 1; }
gint qq_put_vstr(guint8 *buf, const gchar *str_utf8, const gchar *to_charset) { gchar *str; guint8 len; if (str_utf8 == NULL || (len = strlen(str_utf8)) == 0) { buf[0] = 0; return 1; } str = do_convert(str_utf8, -1, to_charset, UTF8); len = strlen(str_utf8); buf[0] = len; if (len > 0) { memcpy(buf + 1, str, len); } return 1 + len; }
int do_cgi_data() { int a; char data[1024]; char part[255]; int partnum; char *lenstr; long len; long cgipos; char datfelder[16][255]; lenstr= getenv("CONTENT_LENGTH"); if(lenstr==NULL) { printf("<BR>ERROR!<BR>"); if(system("relayi2c -a 0 -b 0 -c 0 -d 0 -a 0 -b 0 -c 0 -d 0")){ printf ("error: relais off\n"); }else{ printf("<BR>relay off<BR>"); } } else { sscanf(lenstr,"%ld",&len); printf("<BR>%ld<BR>",len); fgets(data,len+1,stdin); printf("<BR>%s<BR>",data); for(a=0;a<16;a++) // l�sche Felder { datfelder[a][0]=0; } cgipos=0; partnum=0; while(cgipos != -1) { cgipos=do_convert(data,cgipos,part); printf("<BR>%d %s %ld<BR>",partnum,part,cgipos); // debug sprintf(datfelder[partnum],"%s",part); partnum++; } action_switch(datfelder[1],datfelder[3],datfelder[5],datfelder[7],datfelder[9],datfelder[11],datfelder[13],datfelder[15]); } return(0); }
char *convert(int_array_t *pconversions, char *line) { conversion *cur_conv = NULL; cv_off *cv_offsets = NULL; int conv_index; int conv_req; int new_len = 0; int cur_n_cv_matches = 0; char *new_string = NULL; int offset_old = 0, offset_new = 0; int old_len = strlen(line); int n_conversions = get_iat_size(pconversions); if (n_conversions == 0) return line; for(conv_req=0; conv_req < n_conversions; conv_req++) { cur_conv = &conversions[get_iat_element(pconversions, conv_req)]; /* find where they match */ for(conv_index=0; conv_index<cur_conv -> n; conv_index++) { int offset = 0; do { int cur_match_index; int cur_offset = offset; regmatch_t matches[MAX_N_RE_MATCHES]; /* FIXME: what to do with regexp errors? */ if (regexec(&(cur_conv -> pcb)[conv_index].regex, &line[offset], MAX_N_RE_MATCHES, matches, offset?REG_NOTBOL:0) != 0) break; for(cur_match_index=1; cur_match_index<MAX_N_RE_MATCHES; cur_match_index++) { char *dummy; int dummylen; int match_start, match_end; match_start = matches[cur_match_index].rm_so + cur_offset; match_end = matches[cur_match_index].rm_eo + cur_offset; offset = max(offset + 1, match_end); if (matches[cur_match_index].rm_so == -1) break; (cur_conv -> pcb)[conv_index].match_count++; cv_offsets = (cv_off *)myrealloc(cv_offsets, sizeof(cv_off) * (cur_n_cv_matches + 1)); cv_offsets[cur_n_cv_matches].start = match_start; cv_offsets[cur_n_cv_matches].end = match_end; dummylen = match_end - match_start; dummy = mymalloc(dummylen + 1); memcpy(dummy, &line[match_start], dummylen); dummy[dummylen] = 0x00; cv_offsets[cur_n_cv_matches].newstr = do_convert(dummy, dummylen, (cur_conv -> pcb)[conv_index].type, &(cur_conv -> pcs)[conv_index]); myfree(dummy); cur_n_cv_matches++; } } while (offset < old_len); } } if (cur_n_cv_matches) { int n_copy; /* sort */ if (cur_n_cv_matches > 1) qsort(cv_offsets, cur_n_cv_matches, sizeof(cv_off), cv_offsets_compare); /* create new string */ for(conv_index=0; conv_index < cur_n_cv_matches; conv_index++) { n_copy = cv_offsets[conv_index].start - offset_old; if (n_copy > 0) { new_string = myrealloc(new_string, new_len + n_copy + 1); memcpy(&new_string[offset_new], &line[offset_old], n_copy); new_string[offset_new + n_copy] = 0x00; new_len += n_copy; offset_new += n_copy; } offset_old = cv_offsets[conv_index].end; n_copy = strlen(cv_offsets[conv_index].newstr); new_string = myrealloc(new_string, new_len + n_copy + 1); memcpy(&new_string[offset_new], cv_offsets[conv_index].newstr, n_copy); new_string[offset_new + n_copy] = 0x00; myfree(cv_offsets[conv_index].newstr); new_len += n_copy; offset_new += n_copy; } n_copy = old_len - offset_old; if (n_copy) { new_string = myrealloc(new_string, new_len + n_copy + 1); memcpy(&new_string[offset_new], &line[offset_old], n_copy); new_string[offset_new + n_copy] = 0x00; } } else { new_string = line; } myfree(cv_offsets); return new_string; }
bool cdio_charset_convert(cdio_charset_coverter_t*cnv, char * src, int src_len, char ** dst, int * dst_len) { return do_convert(cnv->ic, src, src_len, dst, dst_len); }
/* Warning: do not return NULL */ gchar *qq_to_utf8(const gchar *str, const gchar *from_charset) { return do_convert(str, -1, UTF8, from_charset); }
/* Warning: do not return NULL */ gchar *utf8_to_qq(const gchar *str, const gchar *to_charset) { return do_convert(str, -1, to_charset, UTF8); }
static int do_check_and_conv (unsigned char *to, unsigned char *from) { static unsigned char tmp[BUFSIZ]; unsigned char *tmp_p = &tmp[0]; int p1, p2, i, j; int kanji = TRUE; switch (DetectKanjiCode (from)) { case NEW: debug ("Kanji code is New JIS."); do_convert (&tmp_p, &from, NEWJISSTR); break; case OLD: debug ("Kanji code is Old JIS."); do_convert (&tmp_p, &from, OLDJISSTR); break; case ESCI: debug ("This string includes Hankaku-Kana (jisx0201) escape sequence [ESC] + ( + I."); do_convert (&tmp_p, &from, NEWJISSTR); break; case NEC: debug ("Kanji code is NEC Kanji."); error ("cannot convert NEC Kanji."); ustrcpy (tmp, from); kanji = FALSE; break; case EUC: debug ("Kanji code is EUC."); ustrcpy (tmp, from); break; case SJIS: debug ("Kanji code is SJIS."); do_convert (&tmp_p, &from, SJISSTR); break; case EUCORSJIS: debug ("Kanji code is EUC or SJIS."); ustrcpy (tmp, from); kanji = FALSE; break; case ASCII: debug ("This is ASCII string."); ustrcpy (tmp, from); kanji = FALSE; break; default: debug ("This string includes unknown code."); ustrcpy (tmp, from); kanji = FALSE; break; } /* Hankaku Kana ---> Zenkaku Kana */ if (kanji) { j = 0; for (i = 0; tmp[i] != '\0' && j < BUFSIZ; i++) { if (tmp[i] == SS2) { p1 = tmp[++i]; if (tmp[i + 1] == SS2) { p2 = tmp[i + 2]; if (p2 == 222 || p2 == 223) i += 2; else p2 = 0; } else p2 = 0; han2zen (&p1, &p2); SJIStoJIS (&p1, &p2); to[j++] = p1 + 128; to[j++] = p2 + 128; } else to[j++] = tmp[i]; } if (j >= BUFSIZ) { error ("output buffer overflow at Hankaku --> Zenkaku"); ustrcpy (to, tmp); } else to[j] = '\0'; } else ustrcpy (to, tmp); return kanji; }
/** Handle loading of diagrams given on command line, including conversions. * Returns TRUE if any automatic conversions were performed. * Note to future hackers: 'size' is currently the only argument that can be * sent to exporters. If more arguments are desired, please don't just add * even more arguments, but create a more general system. */ static gboolean handle_initial_diagram(const char *in_file_name, const char *out_file_name, const char *export_file_format, const char *size, char* show_layers, const char *outdir) { Diagram *diagram = NULL; gboolean made_conversions = FALSE; if (export_file_format) { char *export_file_name = NULL; DiaExportFilter *ef = NULL; /* First try guessing based on extension */ export_file_name = build_output_file_name(in_file_name, export_file_format, outdir); /* to make the --size hack even uglier but work again for the only filter supporting it */ if ( size && strcmp(export_file_format, "png") == 0) ef = filter_export_get_by_name ("png-libart"); if (!ef) ef = filter_guess_export_filter(export_file_name); if (ef == NULL) { ef = filter_export_get_by_name(export_file_format); if (ef == NULL) { g_critical(_("Can't find output format/filter %s\n"), export_file_format); return FALSE; } g_free (export_file_name); export_file_name = build_output_file_name(in_file_name, ef->extensions[0], outdir); } made_conversions |= do_convert(in_file_name, (out_file_name != NULL?out_file_name:export_file_name), ef, size, show_layers); g_free(export_file_name); } else if (out_file_name) { DiaExportFilter *ef = NULL; /* if this looks like an ugly hack to you, agreed ;) */ if (size && strstr(out_file_name, ".png")) ef = filter_export_get_by_name ("png-libart"); made_conversions |= do_convert(in_file_name, out_file_name, ef, size, show_layers); } else { if (g_file_test(in_file_name, G_FILE_TEST_EXISTS)) { diagram = diagram_load (in_file_name, NULL); } else { diagram = new_diagram (in_file_name); } if (diagram != NULL) { diagram_update_extents(diagram); if (app_is_interactive()) { layer_dialog_set_diagram(diagram); /* the display initial diagram holds two references */ new_display(diagram); } else { g_object_unref(diagram); } } } return made_conversions; }
static int convert_video(FTSENT *ftsent) { char dir[MAXPATHLEN]; char webm_name[MAXPATHLEN] = {}; int offset; char webm[MAXPATHLEN]; char arch[MAXPATHLEN]; char *last_slash; strncpy(dir, ftsent->fts_path, sizeof(dir)); last_slash = rindex(dir, '/'); assert( NULL != last_slash ); *last_slash = '\0'; time_t dt; int ret; ret = probe_setmtime(dir, &dt); if ( ret < 0 ) return ret; dir_to_restore = dir; time_to_restore = dt; if ( '.' == ftsent->fts_name[0] ) { offset = 1; strncpy(arch, ftsent->fts_path, sizeof(arch)); } else { offset = 0; snprintf(arch, sizeof(arch), "%s/.%s", dir, ftsent->fts_name); struct stat st; ret = stat(arch, &st); if ( 0 == ret ) { char target[MAXPATHLEN]; snprintf(target, sizeof(target), "%s~", arch); WARNING("%s already exists, %s moved as %s", arch, ftsent->fts_path, target); ret = rename(ftsent->fts_path, target); if ( ret < 0 ) { ERROR("rename(%s, %s): %s", ftsent->fts_path, target, strerror(errno)); ret = 1; goto end; } ret = 0; goto end; } else if ( errno != ENOENT ) { ERROR("stat(%s): %s", arch, strerror(errno)); ret = 1; goto end; } ret = rename(ftsent->fts_path, arch); if ( ret < 0 ) { ERROR("rename(%s, %s): %s", ftsent->fts_path, arch, strerror(errno)); ret = 1; goto end; } } memcpy(webm_name, ftsent->fts_name + offset, ftsent->fts_namelen-4-offset); snprintf(webm, sizeof(webm), "%s/%s.webm", dir, webm_name); struct stat st_webm, st_arch; ret = stat(webm, &st_webm); if ( ret < 0 ) { if ( errno != ENOENT ) { ERROR("stat(%s): %s", webm, strerror(errno)); ret = 1; goto end; } memset(&st_webm, 0, sizeof(st_webm)); } ret = stat(arch, &st_arch); if ( ret < 0 ) { ERROR("stat(%s): %s", arch, strerror(errno)); ret = 1; goto end; } if ( st_arch.st_mtim.tv_sec >= st_webm.st_mtim.tv_sec || force_update ) { MESSAGE("UPDATE OF: %s", arch); ret = do_convert(arch, webm); } end: if ( setmtime(dir, dt) != 0 ) { ERROR("Failed to restore %s timestamp", dir); return 1; } dir_to_restore = NULL; time_to_restore = 0; return ret; }
static void process_item(GtkTreeIter *iter, Settings *user_settings, gboolean skip_done, int is_first) { gchar *in_file, *out_full, *ancillary_file, *meta_file, *status, *polsarpro_aux_info, *interferogram_file, *coherence_file, *slave_metadata_file, *baseline_file, *uavsar_type; int pid, isPolSARPro = FALSE; pid = getpid(); gtk_tree_model_get(GTK_TREE_MODEL(list_store), iter, COL_INPUT_FILE, &in_file, COL_ANCILLARY_FILE, &ancillary_file, COL_METADATA_FILE, &meta_file, COL_OUTPUT_FILE, &out_full, COL_STATUS, &status, COL_POLSARPRO_INFO, &polsarpro_aux_info, COL_INTERFEROGRAM, &interferogram_file, COL_COHERENCE, &coherence_file, COL_SLAVE_METADATA, &slave_metadata_file, COL_BASELINE, &baseline_file, COL_UAVSAR_TYPE, &uavsar_type, -1); int image_data_type = extract_image_data_type(polsarpro_aux_info); if (image_data_type >= 0 && image_data_type < 3) isPolSARPro = TRUE; if (strcmp(status, "Done") != 0 || !skip_done) { //char *in_basename = stripExt(in_file); char *out_basename = stripExt(out_full); char *out_nameonly = get_basename(out_full); char *output_dir = getPath(out_full); char *config_file, *cmd_output, *tmp_dir, *intermediates_file; gchar *err_string; /* Ensure we have access to the output directory */ if (!have_access_to_dir(output_dir, &err_string)) { /* We don't -- issue a message in the "Status" column. */ gtk_list_store_set(list_store, iter, COL_STATUS, err_string, -1); g_free(err_string); //free(in_basename); free(out_basename); free(output_dir); return; } tmp_dir = MALLOC(sizeof(char)* (strlen(output_dir)+strlen(out_nameonly)+32)); if (strlen(output_dir) > 0) { sprintf(tmp_dir, "%s%c%s-%s", output_dir, DIR_SEPARATOR, out_nameonly, time_stamp_dir()); } else { sprintf(tmp_dir, "%s-%s", out_nameonly, time_stamp_dir()); } create_clean_dir(tmp_dir); set_asf_tmp_dir(tmp_dir); config_file = settings_to_config_file(user_settings, in_file, ancillary_file, meta_file, out_full, output_dir, tmp_dir, polsarpro_aux_info, interferogram_file, coherence_file, slave_metadata_file, baseline_file, uavsar_type); if (!config_file) { err_string = "Error creating configuration file."; gtk_list_store_set(list_store, iter, COL_STATUS, err_string, -1); free(out_basename); free(output_dir); free(tmp_dir); return; } cmd_output = do_convert(pid, iter, config_file, TRUE, user_settings->keep_files, &intermediates_file); err_string = check_for_error(cmd_output); if (err_string) { // unsuccessful gtk_list_store_set(list_store, iter, COL_STATUS, err_string, COL_LOG, cmd_output, -1); FREE(err_string); } else { // successful -- move to "completed" list GtkTreeIter completed_iter; move_to_completed_files_list(iter, &completed_iter, cmd_output, intermediates_file); set_thumbnail(&completed_iter, tmp_dir, out_full, isPolSARPro); input_data_formats_changed(); refresh_file_names(); } // for subsequent runs, save the imported dem & mask settings_update_dem(user_settings, output_dir); settings_update_mask(user_settings, output_dir); free(config_file); free(out_basename); free(output_dir); free(out_nameonly); free(intermediates_file); g_free(cmd_output); if (!user_settings->keep_files) remove_dir(tmp_dir); free(tmp_dir); } g_free(status); g_free(out_full); g_free(ancillary_file); g_free(meta_file); g_free(in_file); g_free(polsarpro_aux_info); }
gchar *Conv_ToInternal(Converter *conv, const gchar *ext_str, int len) { return do_convert(conv->ext_codeset, int_codeset, ext_str, len); }