自学教程：C++ vfs_path_as_str函数代码示例

voidsymlink_dialog (const vfs_path_t * existing_vpath, const vfs_path_t * new_vpath,                char **ret_existing, char **ret_new){    quick_widget_t quick_widgets[] = {        /* *INDENT-OFF* */        QUICK_LABELED_INPUT (N_("Existing filename (filename symlink will point to):"),                             input_label_above, vfs_path_as_str (existing_vpath), "input-2",                             ret_existing, NULL, FALSE, FALSE, INPUT_COMPLETE_FILENAMES),        QUICK_SEPARATOR (FALSE),        QUICK_LABELED_INPUT (N_("Symbolic link filename:"), input_label_above,                             vfs_path_as_str (new_vpath), "input-1",                             ret_new, NULL, FALSE, FALSE, INPUT_COMPLETE_FILENAMES),        QUICK_BUTTONS_OK_CANCEL,        QUICK_END        /* *INDENT-ON* */    };    quick_dialog_t qdlg = {        -1, -1, 64,        N_("Symbolic link"), "[File Menu]",        quick_widgets, NULL, NULL    };    if (quick_dialog (&qdlg) == B_CANCEL)    {        *ret_new = NULL;        *ret_existing = NULL;    }}

/* *INDENT-OFF* */END_TEST/* *INDENT-ON* *//* --------------------------------------------------------------------------------------------- *//* @Test *//* *INDENT-OFF* */START_TEST (test_mc_mkstemps)/* *INDENT-ON* */{    /* given */    vfs_path_t *pname_vpath = NULL;    char *begin_pname;    int fd;    /* when */    fd = mc_mkstemps (&pname_vpath, "mctest-", NULL);    begin_pname = g_build_filename (mc_tmpdir (), "mctest-", NULL);    /* then */    close (fd);    mctest_assert_int_ne (fd, -1);    fail_unless (g_file_test                 (vfs_path_as_str (pname_vpath), G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR),                 "/nNo such file: %s/n", vfs_path_as_str (pname_vpath));    unlink (vfs_path_as_str (pname_vpath));    fail_unless (strncmp (vfs_path_as_str (pname_vpath), begin_pname, strlen (begin_pname)) == 0,                 "/nstart of %s should be equal to %s/n", vfs_path_as_str (pname_vpath),                 begin_pname);    vfs_path_free (pname_vpath);}

static intcompare_files (const vfs_path_t * vpath1, const vfs_path_t * vpath2, off_t size){    int file1;    int result = -1;            /* Different by default */    if (size == 0)        return 0;    file1 = open (vfs_path_as_str (vpath1), O_RDONLY);    if (file1 >= 0)    {        int file2;        file2 = open (vfs_path_as_str (vpath2), O_RDONLY);        if (file2 >= 0)        {#ifdef HAVE_MMAP            char *data1;            /* Ugly if jungle */            data1 = mmap (0, size, PROT_READ, MAP_FILE | MAP_PRIVATE, file1, 0);            if (data1 != (char *) -1)            {                char *data2;                data2 = mmap (0, size, PROT_READ, MAP_FILE | MAP_PRIVATE, file2, 0);                if (data2 != (char *) -1)                {                    rotate_dash (TRUE);                    result = memcmp (data1, data2, size);                    munmap (data2, size);                }                munmap (data1, size);            }#else            /* Don't have mmap() :( Even more ugly :) */            char buf1[BUFSIZ], buf2[BUFSIZ];            int n1, n2;            rotate_dash (TRUE);            do            {                while ((n1 = read (file1, buf1, sizeof (buf1))) == -1 && errno == EINTR)                    ;                while ((n2 = read (file2, buf2, sizeof (buf2))) == -1 && errno == EINTR)                    ;            }            while (n1 == n2 && n1 == sizeof (buf1) && memcmp (buf1, buf2, sizeof (buf1)) == 0);            result = (n1 != n2) || memcmp (buf1, buf2, n1);#endif /* !HAVE_MMAP */            close (file2);        }        close (file1);    }    rotate_dash (FALSE);    return result;}

static gbooleanexecute_prepare_with_vfs_arg (const vfs_path_t * filename_vpath, vfs_path_t ** localcopy_vpath,                              time_t * mtime){    struct stat st;    /* Simplest case, this file is local */    if ((filename_vpath == NULL && vfs_file_is_local (vfs_get_raw_current_dir ()))        || vfs_file_is_local (filename_vpath))        return TRUE;    /* FIXME: Creation of new files on VFS is not supported */    if (filename_vpath == NULL)        return FALSE;    *localcopy_vpath = mc_getlocalcopy (filename_vpath);    if (*localcopy_vpath == NULL)    {        message (D_ERROR, MSG_ERROR, _("Cannot fetch a local copy of %s"),                 vfs_path_as_str (filename_vpath));        return FALSE;    }    mc_stat (*localcopy_vpath, &st);    *mtime = st.st_mtime;    return TRUE;}

voidmcview_toggle_magic_mode (mcview_t * view){    char *filename, *command;    dir_list *dir;    int *dir_idx;    mcview_altered_magic_flag = 1;    view->magic_mode = !view->magic_mode;    /* reinit view */    filename = g_strdup (vfs_path_as_str (view->filename_vpath));    command = g_strdup (view->command);    dir = view->dir;    dir_idx = view->dir_idx;    view->dir = NULL;    view->dir_idx = NULL;    mcview_done (view);    mcview_init (view);    mcview_load (view, command, filename, 0);    view->dir = dir;    view->dir_idx = dir_idx;    g_free (filename);    g_free (command);    view->dpy_bbar_dirty = TRUE;    view->dirty++;}

static intmy_mkdir_rec (const vfs_path_t * s_vpath, mode_t mode){    vfs_path_t *q;    int result;    if (mc_mkdir (s_vpath, mode) == 0)        return 0;    if (errno != ENOENT)        return (-1);    /* FIXME: should check instead if s_vpath is at the root of that filesystem */    if (!vfs_file_is_local (s_vpath))        return (-1);    if (strcmp (vfs_path_as_str (s_vpath), PATH_SEP_STR) == 0)    {        errno = ENOTDIR;        return (-1);    }    q = vfs_path_append_new (s_vpath, "..", NULL);    result = my_mkdir_rec (q, mode);    vfs_path_free (q);    if (result == 0)        result = mc_mkdir (s_vpath, mode);    return result;}

voidhotlist_cmd (void){    char *target;    target = hotlist_show (LIST_HOTLIST);    if (!target)        return;    if (get_current_type () == view_tree)        tree_chdir (the_tree, target);    else    {        vfs_path_t *deprecated_vpath;        char *cmd;        deprecated_vpath = vfs_path_from_str_flags (target, VPF_USE_DEPRECATED_PARSER);        cmd = g_strconcat ("cd ", vfs_path_as_str (deprecated_vpath), (char *) NULL);        vfs_path_free (deprecated_vpath);        do_cd_command (cmd);        g_free (cmd);    }    g_free (target);}

static voidexec_extension_view (void *target, char *cmd, const vfs_path_t * filename_vpath, int start_line){    int def_hex_mode = mcview_default_hex_mode, changed_hex_mode = 0;    int def_nroff_flag = mcview_default_nroff_flag, changed_nroff_flag = 0;    mcview_altered_hex_mode = 0;    mcview_altered_nroff_flag = 0;    if (def_hex_mode != mcview_default_hex_mode)        changed_hex_mode = 1;    if (def_nroff_flag != mcview_default_nroff_flag)        changed_nroff_flag = 1;    if (target == NULL)        mcview_viewer (cmd, filename_vpath, start_line);    else        mcview_load ((mcview_t *) target, cmd, vfs_path_as_str (filename_vpath), start_line);    if (changed_hex_mode && !mcview_altered_hex_mode)        mcview_default_hex_mode = def_hex_mode;    if (changed_nroff_flag && !mcview_altered_nroff_flag)        mcview_default_nroff_flag = def_nroff_flag;    dialog_switch_process_pending ();}

gbooleanmcview_viewer (const char *command, const vfs_path_t * file_vpath, int start_line,               off_t search_start, off_t search_end){    gboolean succeeded;    WView *lc_mcview;    WDialog *view_dlg;    /* Create dialog and widgets, put them on the dialog */    view_dlg = dlg_create (FALSE, 0, 0, 1, 1, WPOS_FULLSCREEN, FALSE, NULL, mcview_dialog_callback,                           NULL, "[Internal File Viewer]", NULL);    widget_want_tab (WIDGET (view_dlg), TRUE);    lc_mcview = mcview_new (0, 0, LINES - 1, COLS, FALSE);    add_widget (view_dlg, lc_mcview);    add_widget (view_dlg, buttonbar_new (TRUE));    view_dlg->get_title = mcview_get_title;    succeeded =        mcview_load (lc_mcview, command, vfs_path_as_str (file_vpath), start_line, search_start,                     search_end);    if (succeeded)        dlg_run (view_dlg);    else        dlg_stop (view_dlg);    if (widget_get_state (WIDGET (view_dlg), WST_CLOSED))        dlg_destroy (view_dlg);    return succeeded;}

gbooleanmcview_viewer (const char *command, const vfs_path_t * file_vpath, int start_line){    gboolean succeeded;    mcview_t *lc_mcview;    WDialog *view_dlg;    /* Create dialog and widgets, put them on the dialog */    view_dlg = dlg_create (FALSE, 0, 0, LINES, COLS, NULL, mcview_dialog_callback, NULL,                           "[Internal File Viewer]", NULL, DLG_WANT_TAB);    lc_mcview = mcview_new (0, 0, LINES - 1, COLS, FALSE);    add_widget (view_dlg, lc_mcview);    add_widget (view_dlg, buttonbar_new (TRUE));    view_dlg->get_title = mcview_get_title;    succeeded = mcview_load (lc_mcview, command, vfs_path_as_str (file_vpath), start_line);    if (succeeded)        dlg_run (view_dlg);    else        view_dlg->state = DLG_CLOSED;    if (view_dlg->state == DLG_CLOSED)        dlg_destroy (view_dlg);    return succeeded;}

char *tree_box (const char *current_dir){    WTree *mytree;    WDialog *dlg;    Widget *wd;    char *val = NULL;    WButtonBar *bar;    (void) current_dir;    /* Create the components */    dlg = dlg_create (TRUE, 0, 0, LINES - 9, COLS - 20, dialog_colors, tree_callback, NULL,                      "[Directory Tree]", _("Directory tree"), DLG_CENTER);    wd = WIDGET (dlg);    mytree = tree_new (2, 2, wd->lines - 6, wd->cols - 5, FALSE);    add_widget_autopos (dlg, mytree, WPOS_KEEP_ALL, NULL);    add_widget_autopos (dlg, hline_new (wd->lines - 4, 1, -1), WPOS_KEEP_BOTTOM, NULL);    bar = buttonbar_new (TRUE);    add_widget (dlg, bar);    /* restore ButtonBar coordinates after add_widget() */    WIDGET (bar)->x = 0;    WIDGET (bar)->y = LINES - 1;    if (dlg_run (dlg) == B_ENTER)    {        const vfs_path_t *selected_name;        selected_name = tree_selected_name (mytree);        val = g_strdup (vfs_path_as_str (selected_name));    }    dlg_destroy (dlg);    return val;}

/* *INDENT-OFF* */END_PARAMETRIZED_TEST/* *INDENT-ON* *//* --------------------------------------------------------------------------------------------- *//* @Test(dataSource = "test_vfs_path_relative_ds") *//* *INDENT-OFF* */START_PARAMETRIZED_TEST (test_vfs_path_relative_clone, test_vfs_path_relative_ds)/* *INDENT-ON* */{    /* given */    vfs_path_t *vpath, *cloned_vpath;    vpath = vfs_path_from_str_flags (data->input_path, VPF_NO_CANON);    /* when */    cloned_vpath = vfs_path_clone (vpath);    /* then */    mctest_assert_int_eq (cloned_vpath->relative, TRUE);    mctest_assert_str_eq (vfs_path_get_last_path_str (cloned_vpath),                          data->expected_last_path_in_element);    mctest_assert_str_eq (vfs_path_as_str (cloned_vpath), data->expected_path);    vfs_path_free (vpath);    vfs_path_free (cloned_vpath);}

voiddir_list_load (dir_list * list, const vfs_path_t * vpath, GCompareFunc sort,               const dir_sort_options_t * sort_op, const char *fltr){    DIR *dirp;    struct dirent *dp;    int link_to_dir, stale_link;    struct stat st;    file_entry_t *fentry;    /* ".." (if any) must be the first entry in the list */    if (!dir_list_init (list))        return;    fentry = &list->list[0];    if (dir_get_dotdot_stat (vpath, &st))        fentry->st = st;    dirp = mc_opendir (vpath);    if (dirp == NULL)    {        message (D_ERROR, MSG_ERROR, _("Cannot read directory contents"));        return;    }    tree_store_start_check (vpath);    {        const char *vpath_str;        vpath_str = vfs_path_as_str (vpath);        /* Do not add a ".." entry to the root directory */        if ((vpath_str[0] == PATH_SEP) && (vpath_str[1] == '/0'))            list->len--;    }    while ((dp = mc_readdir (dirp)) != NULL)    {        if (!handle_dirent (dp, fltr, &st, &link_to_dir, &stale_link))            continue;        if (!dir_list_append (list, dp->d_name, &st, link_to_dir != 0, stale_link != 0))            goto ret;        if ((list->len & 31) == 0)            rotate_dash (TRUE);    }    dir_list_sort (list, sort, sort_op);  ret:    mc_closedir (dirp);    tree_store_end_check ();    rotate_dash (FALSE);}

static char *sftpfs_correct_file_name (const char *filename){    vfs_path_t *vpath;    char *ret_value;    ret_value = tilde_expand (filename);    vpath = vfs_path_from_str (ret_value);    g_free (ret_value);    ret_value = g_strdup (vfs_path_as_str (vpath));    vfs_path_free (vpath);    return ret_value;}

gbooleancheck_for_default (const vfs_path_t * default_file_vpath, const vfs_path_t * file_vpath){    if (!exist_file (vfs_path_as_str (file_vpath)))    {        file_op_context_t *ctx;        file_op_total_context_t *tctx;        if (!exist_file (vfs_path_as_str (default_file_vpath)))            return FALSE;        ctx = file_op_context_new (OP_COPY);        tctx = file_op_total_context_new ();        file_op_context_create_ui (ctx, 0, FALSE);        copy_file_file (tctx, ctx, vfs_path_as_str (default_file_vpath),                        vfs_path_as_str (file_vpath));        file_op_total_context_destroy (tctx);        file_op_context_destroy (ctx);    }    return TRUE;}

voidsave_panel_dir (int idx){    panel_view_mode_t type = get_display_type (idx);    Widget *widget = get_panel_widget (idx);    if ((type == view_listing) && (widget != NULL))    {        WPanel *w = PANEL (widget);        g_free (panels[idx].last_saved_dir);    /* last path no needed */        /* Because path can be nonlocal */        panels[idx].last_saved_dir = g_strdup (vfs_path_as_str (w->cwd_vpath));    }}

voidsave_setup_cmd (void){    vfs_path_t *vpath;    const char *path;    vpath = vfs_path_from_str_flags (mc_config_get_path (), VPF_STRIP_HOME);    path = vfs_path_as_str (vpath);    if (save_setup (TRUE, TRUE))        message (D_NORMAL, _("Setup"), _("Setup saved to %s"), path);    else        message (D_ERROR, _("Setup"), _("Unable to save setup to %s"), path);    vfs_path_free (vpath);}

static voidedit_window_list (const WDialog * h){    const size_t offset = 2;    /* skip menu and buttonbar */    const size_t dlg_num = g_list_length (h->widgets) - offset;    int lines, cols;    Listbox *listbox;    GList *w;    int i = 0;    int rv;    lines = min ((size_t) (LINES * 2 / 3), dlg_num);    cols = COLS * 2 / 3;    listbox = create_listbox_window (lines, cols, _("Open files"), "[Open files]");    for (w = h->widgets; w != NULL; w = g_list_next (w))        if (edit_widget_is_editor (WIDGET (w->data)))        {            WEdit *e = (WEdit *) w->data;            char *fname;            if (e->filename_vpath == NULL)                fname = g_strdup_printf ("%c [%s]", e->modified ? '*' : ' ', _("NoName"));            else                fname =                    g_strdup_printf ("%c%s", e->modified ? '*' : ' ',                                     vfs_path_as_str (e->filename_vpath));            listbox_add_item (listbox->list, LISTBOX_APPEND_AT_END, get_hotkey (i++),                              str_term_trim (fname, WIDGET (listbox->list)->cols - 2), NULL, FALSE);            g_free (fname);        }    rv = g_list_position (h->widgets, h->current) - offset;    listbox_select_entry (listbox->list, rv);    rv = run_listbox (listbox);    if (rv >= 0)    {        w = g_list_nth (h->widgets, rv + offset);        dlg_set_top_widget (w->data);    }}

char *mcview_get_title (const WDialog * h, size_t len){    const mcview_t *view = (const mcview_t *) find_widget_type (h, mcview_callback);    const char *modified = view->hexedit_mode && (view->change_list != NULL) ? "(*) " : "    ";    const char *file_label;    const char *view_filename;    char *ret_str;    view_filename = vfs_path_as_str (view->filename_vpath);    len -= 4;    file_label = view_filename != NULL ? view_filename : view->command != NULL ? view->command : "";    file_label = str_term_trim (file_label, len - str_term_width1 (_("View: ")));    ret_str = g_strconcat (_("View: "), modified, file_label, (char *) NULL);    return ret_str;}

static char *edit_get_title (const WDialog * h, size_t len){    const WEdit *edit = find_editor (h);    const char *modified = edit->modified ? "(*) " : "    ";    const char *file_label;    char *filename;    len -= 4;    if (edit->filename_vpath == NULL)        filename = g_strdup (_("[NoName]"));    else        filename = g_strdup (vfs_path_as_str (edit->filename_vpath));    file_label = str_term_trim (filename, len - str_term_width1 (_("Edit: ")));    g_free (filename);    return g_strconcat (_("Edit: "), modified, file_label, (char *) NULL);}

/* *INDENT-OFF* */START_PARAMETRIZED_TEST (test_empty_mean_home, test_empty_mean_home_ds)/* *INDENT-ON* */{    /* given */    get_current_type__return_value = view_listing;    do_cd__return_value = TRUE;    mc_config_get_home_dir__return_value = "/home/test";    /* when */    {        char *input_command;        input_command = g_strdup (data->command);        do_cd_command (input_command);        g_free (input_command);    }    /* then */    mctest_assert_str_eq (mc_config_get_home_dir__return_value,                          vfs_path_as_str (do_cd__new_dir_vpath__captured));    mctest_assert_int_eq (do_cd__cd_type__captured, cd_parse_command);}

voidfile_progress_show_target (file_op_context_t * ctx, const vfs_path_t * s_vpath){    file_op_context_ui_t *ui;    if (ctx == NULL || ctx->ui == NULL)        return;    ui = ctx->ui;    if (s_vpath != NULL)    {        label_set_text (ui->tgt_file_label, _("Target"));        label_set_text (ui->tgt_file,                        truncFileStringSecure (ui->op_dlg, vfs_path_as_str (s_vpath)));    }    else    {        label_set_text (ui->tgt_file_label, "");        label_set_text (ui->tgt_file, "");    }}

char *get_panel_dir_for (const WPanel * widget){    int i;    for (i = 0; i < MAX_VIEWS; i++)        if (PANEL (get_panel_widget (i)) == widget)            break;    if (i >= MAX_VIEWS)        return g_strdup (".");    if (get_display_type (i) == view_listing)    {        vfs_path_t *cwd_vpath;        cwd_vpath = PANEL (get_panel_widget (i))->cwd_vpath;        return g_strdup (vfs_path_as_str (cwd_vpath));    }    return g_strdup (panels[i].last_saved_dir);}