- Main Page
- Modules
- Data Structures
- Files
- Related Pages

# navigation.c File Reference

FAT 12/16/32 Services. More...

`#include <ctype.h>`
`#include "conf_explorer.h"`
`#include "navigation.h"`
`#include "file.h"`
`#include <LIB_CTRLACCESS>`

Include dependency graph for navigation.c:

Go to the source code of this file.

## Defines
#define | SIZE_OF_SPLIT_COPY ((1*1024*1024L)/512L)
## Functions
void | nav_string_unicode (void)
| This function selects the UNICODE mode for all routines with FS_STRING parameter.
void | nav_string_ascii (void)
| This function selects the ASCII mode for all routines with FS_STRING parameter.
void | nav_string_length_enable (void)
| This function selects the LENGTH string mode for all routines with FS_STRING parameter.
void | nav_string_length_disable (void)
| This function deselects the LENGTH string mode for all routines with FS_STRING parameter.
void | nav_checkdisk_disable (void)
| This function disables the disk check before each actions on disk.
void | nav_checkdisk_enable (void)
| This function enables the disk check before each actions on disk.
void | nav_reset (void)
| This function resets ALL navigations to init file system core.
void | nav_exit (void)
| This function flush ALL navigations before exit of file system core.
Bool | nav_select (U8 u8_idnav)
| This function selects the navigation to use.
U8 | nav_get (void)
| This function returns the navigation identifier used.
Bool | nav_copy (U8 u8_idnav)
| This function copys the navigator information to another navigator.
U8 | nav_drive_nb (void)
| This function returns the number of devices availabled.
Bool | nav_drive_set (U8 u8_number)
| This function selects a drive in navigator but don't mount the disk partition.
U8 | nav_drive_get (void)
| This function returns the selected drive number.
U8 | nav_drive_getname (void)
| This function returns the selected drive letter.
U8 | nav_partition_nb (void)
| This function returns the number of partitions present on drive.
Bool | nav_partition_set (U8 partition_number)
| This function selects a partition on drive.
Bool | nav_partition_mount (void)
| This function mounts the selected partition.
U8 | nav_partition_type (void)
| This function gives the partition type.
Bool | nav_partition_serialnumber (Bool b_action, U8 _MEM_TYPE_SLOW_ *a_u8_sn)
| This function reads or writes the serial number on the selected partition.
Bool | nav_partition_label (Bool b_action, FS_STRING sz_label)
| This function reads or writes the label of selected partition.
U32 | nav_partition_space (void)
| This function returns partition total space.
U8 | nav_partition_cluster_size (void)
| This function returns the partition cluster size.
U32 | nav_partition_freespace (void)
| This function returns the partition free space.
U8 | nav_partition_freespace_percent (void)
| This function returns the partition space free in percent.
Bool | nav_filelist_single_enable (Bool b_type)
| To display in File List only the files OR directories.
Bool | nav_filelist_single_disable (void)
| To display in File List the directories AND files.
Bool | nav_filelist_reset (void)
| This function resets the selection pointer, so "no file selected" in file list.
Bool | nav_filelist_validpos (void)
| This function checks if a file is selected.
Bool | nav_filelist_fileisnotopen (void)
| This function checks if no file is open.
Bool | nav_filelist_set (U16 u16_nb, Bool b_direction)
| This function moves the selection pointer in file list.
U16 | nav_filelist_get (void)
| This function returns the position of selected file in file list.
Bool | nav_filelist_goto (U16 u16_newpos)
| This function goes at a position in file list.
Bool | nav_filelist_findname (const FS_STRING sz_name, Bool b_match_case)
| This function searchs a file name in file list.
Bool | nav_filelist_eol (void)
| This function checks the end of file list.
Bool | nav_filelist_bol (void)
| This function checks the beginning of file list.
Bool | nav_filelist_exist (Bool b_type)
| This function checks the presence of files or directories in file list.
U16 | nav_filelist_nb (Bool b_type)
| This function computes the number of files or directories in file list.
Bool | nav_filelist_first (Bool b_type)
| This function goes to at the first file or directory in file list.
Bool | nav_filelist_last (Bool b_type)
| This function goes to at the last file or directory in file list.
Fs_index | nav_getindex (void)
| This function returns a small index on the selected file.
Bool | nav_gotoindex (const Fs_index _MEM_TYPE_SLOW_ *index)
| This function selects a file in the navigator via a file index.
Bool | nav_dir_root (void)
| This function initializes the file list on the root directory.
Bool | nav_dir_is_root (void)
| This function check the current directory.
Bool | nav_dir_cd (void)
| This function enters in the selected directory in file list.
Bool | nav_dir_gotoparent (void)
| This function goes to the parent directory.
Bool | nav_dir_name (FS_STRING sz_path, U8 u8_size_max)
| This function returns the directory name corresponding at the file list.
Bool | nav_getcwd (FS_STRING sz_path, U8 u8_size_path, Bool b_view_file_select)
| This function returns the full path of the selection.
Bool | nav_setcwd (FS_STRING sz_path, Bool b_match_case, Bool b_create)
| This function selects a disk position via a path.
Bool | nav_file_getname (FS_STRING sz_name, U8 u8_size_max)
| This function returns the name of selected file.
Bool | nav_file_name (FS_STRING sz_name, U8 u8_size_max, Bool b_mode, Bool b_match_case)
| This function returns the name of selected file or checks the string with the name of selected file.
U32 | nav_file_lgt (void)
| This function returns the size of selected file (unit byte).
U16 | nav_file_lgtsector (void)
| This function returns the size of selected file (unit sector).
Bool | nav_file_isreadonly (void)
| This function checks the write protection of disk and the attribut "read only" of selected file.
Bool | nav_file_isdir (void)
| This function returns the type of selected file.
Bool | nav_file_checkext (const FS_STRING sz_filterext)
| This function checks the extension of selected file.
Bool | nav_file_dateget (FS_STRING sz_date, Bool type_date)
| This function returns the date of selected file.
U8 | nav_file_attributget (void)
| This function returns the attribut of selected file.

## Detailed Description

FAT 12/16/32 Services.

This file defines a useful set of functions for file navigation.

Author:
  Atmel Corporation: http://www.atmel.com
  Support and FAQ: http://support.atmel.no/

Definition in file navigation.c.

## Define Documentation

#define SIZE_OF_SPLIT_COPY ((1*1024*1024L)/512L)

Definition at line 69 of file navigation.c.

## Function Documentation

void nav_string_unicode | ( | void |  | ) |

This function selects the UNICODE mode for all routines with FS_STRING parameter.

    //! If you have enabled the FS_ASCII AND FS_UNICODE define
    //! then FS_STRING parameter can be a ASCII or UNICODE string.
    //!

Definition at line 84 of file navigation.c.

    00085 {
    00086    g_b_unicode = TRUE;
    00087 }

void nav_string_ascii | ( | void |  | ) |

This function selects the ASCII mode for all routines with FS_STRING parameter.

    //! If you have enabled the FS_ASCII AND FS_UNICODE define
    //! then FS_STRING parameter can be a ASCII or UNICODE string.
    //!

Definition at line 95 of file navigation.c.

    00096 {
    00097    g_b_unicode = FALSE;
    00098 }

void nav_string_length_enable | ( | void |  | ) |

This function selects the LENGTH string mode for all routines with FS_STRING parameter.

    //! In LENGTH string mode when you call a routine with FS_STRING parameter
    //! only the size (16bits, unit ASCII or UNICODE) is returned in the first 16bits of string array.
    //!

Definition at line 108 of file navigation.c.

    00109 {
    00110    g_b_string_length = TRUE;
    00111 }

void nav_string_length_disable | ( | void |  | ) |

This function deselects the LENGTH string mode for all routines with FS_STRING parameter.

    //! In LENGTH string mode when you call a routine with FS_STRING parameter
    //! only the size (16bits, unit ASCII or UNICODE) is returned in the first 16bits of string array.
    //!

Definition at line 119 of file navigation.c.

    00120 {
    00121    g_b_string_length = FALSE;
    00122 }

void nav_checkdisk_disable | ( | void |  | ) |

This function disables the disk check before each actions on disk.

    //! By default, between each read/write access a check disk (test unit ready) is sended at device.
    //! This check can reduce the speed access on specific disk.
    //!

Definition at line 134 of file navigation.c.

    00135 {
    00136    g_b_no_check_disk = TRUE;
    00137 }

void nav_checkdisk_enable | ( | void |  | ) |

This function enables the disk check before each actions on disk.

    //! By default, between each read/write access a check disk (test unit ready) is sended at device.
    //! This check can reduce the speed access on specific disk.
    //!

Definition at line 146 of file navigation.c.

    00147 {
    00148    g_b_no_check_disk = FALSE;
    00149 }

void nav_reset | ( | void |  | ) |

This function resets ALL navigations to init file system core.

    //! Call this at the program startup or before a new session (e.g. USB Device exit)
    //!

Definition at line 162 of file navigation.c.

Referenced by ushell_task().

    00163 {
    00164 #if ( (FS_ASCII   == ENABLED) && (FS_UNICODE == ENABLED))
    00165    g_b_unicode = TRUE;
    00166 #endif
    00167    g_b_string_length = FALSE;
    00168    g_b_no_check_disk = FALSE;
    00169
    00170    fat_cache_reset();
    00171    fat_cache_clusterlist_reset();
    00172
    00173 #if (FS_NB_NAVIGATOR > 1)
    00174    {
    00175    U8 i;
    00176    // Reset variables of each navigators
    00177    for( i=0 ; i!=FS_NB_NAVIGATOR ; i++ )
    00178    {
    00179       nav_select(i);
    00180       fs_g_nav_fast.u8_type_fat = FS_TYPE_FAT_UNM; // By default the fat isn't mounted
    00181       fs_g_nav.u8_lun = 0xFF;                      // By default don't select a drive
    00182 #if (FS_MULTI_PARTITION  ==  ENABLED)
    00183       fs_g_nav.u8_partition=0;                     // By default select the first partition
    00184 #endif
    00185       Fat_file_close();                            // By default no file is opened
    00186       fs_g_nav.b_mode_nav_single = FALSE;          // By default display files and directories
    00187    }
    00188    // By default select the navigator 0
    00189    fs_g_u8_nav_selected = 0;
    00190    }
    00191 #else
    00192    fs_g_nav_fast.u8_type_fat = FS_TYPE_FAT_UNM;    // By default the fat isn't mounted
    00193    fs_g_nav.u8_lun = 0xFF;                         // By default don't select a drive
    00194 #  if (FS_MULTI_PARTITION  ==  ENABLED)
    00195    fs_g_nav.u8_partition=0;                        // By default select the first partition
    00196 #  endif
    00197    Fat_file_close();                               // By default no file is opened
    00198 #endif // (FS_NB_NAVIGATOR > 1)
    00199 }

Here is the caller graph for this function:

void nav_exit | ( | void |  | ) |

This function flush ALL navigations before exit of file system core.

    //! Call this at the program exit or before a USB Device session
    //!

Definition at line 208 of file navigation.c.

Referenced by ushell_task().

    00209 {
    00210    // If you have opened files then close them
    00211 #if (FS_NB_NAVIGATOR > 1)
    00212    U8 u8_i;
    00213    for( u8_i=0; u8_i<FS_NB_NAVIGATOR; u8_i++)
    00214    {
    00215       nav_select(u8_i);
    00216       file_close();
    00217    }
    00218 #else
    00219    nav_select(0);
    00220    file_close();
    00221 #endif
    00222    // Flush data eventually present in FAT cache
    00223    fat_cache_flush();
    00224 }

Here is the caller graph for this function:

Bool nav_select | ( | U8 | u8_idnav | ) |

This function selects the navigation to use.

Parameters:

  | u8_idnav | navigator identifier to select (0 to FS_NB_NAVIGATOR-1)

Returns:
  FALSE if ID navigator don't exist

  TRUE otherwise

Definition at line 234 of file navigation.c.

Referenced by copy_dir(), nav_exit(), nav_reset(), ushell_cmd_perform(), ushell_cmd_sync(), and ushell_task().

    00235 {
    00236    if( FS_NB_NAVIGATOR <= u8_idnav )
    00237    {
    00238       fs_g_status = FS_ERR_BAD_NAV;             // The navigator doesn't exist
    00239       return FALSE;
    00240    }
    00241 #if (FS_NB_NAVIGATOR > 1)
    00242    if( fs_g_u8_nav_selected != u8_idnav )
    00243    {
    00244       fat_invert_nav( fs_g_u8_nav_selected );   // Deselect previous navigator = Select default navigator
    00245       fat_invert_nav( u8_idnav );               // Select new navigator
    00246       fs_g_u8_nav_selected = u8_idnav;
    00247    }
    00248 #endif
    00249    return TRUE;
    00250 }

Here is the caller graph for this function:

U8 nav_get | ( | void |  | ) |

This function returns the navigation identifier used.

Returns:
  u8_idnav navigator identifier selected

Definition at line 257 of file navigation.c.

    00258 {
    00259 #if (FS_NB_NAVIGATOR > 1)
    00260    return fs_g_u8_nav_selected;
    00261 #else
    00262    return 0;
    00263 #endif
    00264 }

Bool nav_copy | ( | U8 | u8_idnav | ) |

This function copys the navigator information to another navigator.

Parameters:

  | u8_idnav | navigator identifier where the main navigator will be copied

Returns:
  FALSE in case of error, see global value "fs_g_status" for more detail

  TRUE otherwise

    //! Use this routine to select quickly the same file in another navigator
    //!

Definition at line 278 of file navigation.c.

    00279 {
    00280 #if (FS_NB_NAVIGATOR > 1)
    00281    if( fs_g_u8_nav_selected == u8_idnav )
    00282       return FALSE;                    // It is the source and destination is the same navigator
    00283    if( 0 == u8_idnav )
    00284       u8_idnav = fs_g_u8_nav_selected; // the default navigator is invert with the current navigator
    00285    if( 0 == u8_idnav)
    00286       return FALSE;                    // It is the source and destination is the same navigator
    00287    fat_copy_nav( u8_idnav );
    00288    return TRUE;
    00289 #else
    00290    u8_idnav++;
    00291    return FALSE;                       // Copy impossible because only one navigator is available
    00292 #endif
    00293 }

U8 nav_drive_nb | ( | void |  | ) |

This function returns the number of devices availabled.

Returns:
  number of devices, 0 = NO DEVICE AVAILABLED

    //! This value may be dynamic because it depends of memory drivers (e.g. Mass Storage disk on USB host mode)
    //!

Definition at line 308 of file navigation.c.

Referenced by firm_upgrade_searchfile(), ushell_cmd_free_space(), ushell_cmd_mount(), and ushell_cmd_nb_drive().

    00309 {
    00310    return get_nb_lun(); // Number of devices = Number of lun
    00311 }

Here is the caller graph for this function:

Bool nav_drive_set | ( | U8 | u8_number | ) |

This function selects a drive in navigator but don't mount the disk partition.

Parameters:

  | u8_number | device number (0 to nav_drive_nb()-1 )

Returns:
  FALSE in case of error, see global value "fs_g_status" for more detail

  TRUE otherwise

Definition at line 321 of file navigation.c.

Referenced by firm_upgrade_searchfile(), nav_gotoindex(), nav_setcwd(), ushell_cmd_format(), ushell_cmd_free_space(), ushell_cmd_mount(), and ushell_cmd_perform_alloc().

    00322 {
    00323    if ( !fat_check_noopen() )
    00324       return FALSE;
    00325
    00326    if (u8_number >= get_nb_lun() )
    00327    {
    00328       fs_g_status = FS_ERR_END_OF_DRIVE;   // The drive number is bad
    00329       return FALSE;
    00330    }
    00331
    00332    if ( fs_g_nav.u8_lun == u8_number)
    00333       return TRUE;   // It is the same drive number
    00334
    00335    // Go to the device
    00336    fs_g_nav.u8_lun = u8_number;
    00337    fs_g_nav_fast.u8_type_fat = FS_TYPE_FAT_UNM;
    00338 #if (FS_MULTI_PARTITION  ==  ENABLED)
    00339    fs_g_nav.u8_partition=0;   // by default select the first partition
    00340 #endif
    00341    return TRUE;
    00342 }

Here is the caller graph for this function:

U8 nav_drive_get | ( | void |  | ) |

This function returns the selected drive number.

Returns:
  0 to nav_drive_nb()-1

  0xFF in case of no drive selected

Definition at line 350 of file navigation.c.

Referenced by ushell_cmd_ls(), and ushell_cmd_space().

    00351 {
    00352 #if (FS_MULTI_PARTITION  ==  ENABLED)
    00353    if(0xFF == fs_g_nav.u8_lun)
    00354       return 0xFF;
    00355    return ((fs_g_nav.u8_lun*4) + fs_g_nav.u8_partition); // Maximum 4 partitions per device
    00356 #else
    00357    return (fs_g_nav.u8_lun);
    00358 #endif
    00359 }

Here is the caller graph for this function:

U8 nav_drive_getname | ( | void |  | ) |

This function returns the selected drive letter.

Returns:
  'A','B',...

  'X', in case of no drive selected

Definition at line 367 of file navigation.c.

Referenced by nav_dir_name(), and nav_getcwd().

    00368 {
    00369    if(0xFF == fs_g_nav.u8_lun)
    00370       return 'X';
    00371 #if (FS_MULTI_PARTITION  ==  ENABLED)
    00372    return ('A' + (fs_g_nav.u8_lun*4) + fs_g_nav.u8_partition); // Maximum 4 partitions per device
    00373 #else
    00374    return ('A' + fs_g_nav.u8_lun);
    00375 #endif
    00376 }

Here is the caller graph for this function:

U8 nav_partition_nb | ( | void |  | ) |

This function returns the number of partitions present on drive.

Returns:
  u8_number number of partitions

Definition at line 418 of file navigation.c.

    00419 {
    00420    return fat_get_nbpartition();
    00421 }

Bool nav_partition_set | ( | U8 | partition_number | ) |

This function selects a partition on drive.

Parameters:

  | partition_number | partition number (0 to 3)

Returns:
  FALSE in case of error, see global value "fs_g_status" for more detail

  TRUE otherwise

Definition at line 431 of file navigation.c.

Referenced by nav_gotoindex().

    00432 {
    00433    if ( fs_g_nav.u8_partition == partition_number)
    00434       return TRUE;   // It is the same
    00435
    00436    if ( !fat_check_noopen() )
    00437       return FALSE;
    00438
    00439    // Go to partition
    00440    fs_g_nav.u8_partition = partition_number;
    00441    fs_g_nav_fast.u8_type_fat = FS_TYPE_FAT_UNM;
    00442    return TRUE;
    00443 }

Here is the caller graph for this function:

Bool nav_partition_mount | ( | void |  | ) |

This function mounts the selected partition.

Returns:
  FALSE in case of error, see global value "fs_g_status" for more detail

  TRUE otherwise

    //! If the FS_MULTI_PARTITION option is disabled
    //! then the mount routine selects the first partition supported by file system. <br>
    //! After mount, the file list contains files and directories of ROOT directory
    //!

Definition at line 458 of file navigation.c.

Referenced by firm_upgrade_searchfile(), nav_dir_root(), nav_gotoindex(), nav_partition_type(), nav_setcwd(), ushell_cmd_free_space(), ushell_cmd_mount(), and ushell_cmd_perform_alloc().

    00459 {
    00460    if ( !fat_check_noopen() )
    00461       return FALSE;
    00462
    00463    if( FS_TYPE_FAT_UNM != fs_g_nav_fast.u8_type_fat)
    00464    {
    00465       // Already mounted
    00466       // Go to root directory
    00467       fs_g_nav.u32_cluster_sel_dir   = 0;
    00468       // No file is selected by default
    00469       fat_clear_entry_info_and_ptr();
    00470       return TRUE;
    00471    }
    00472
    00473    return fat_mount();
    00474 }

Here is the caller graph for this function:

U8 nav_partition_type | ( | void |  | ) |

This function gives the partition type.

Returns:
  partition type: FS_TYPE_FAT_12, FS_TYPE_FAT_16, FS_TYPE_FAT_32

  FS_TYPE_FAT_UNM, in case of error or unknow format

Definition at line 482 of file navigation.c.

Referenced by ushell_cmd_ls().

    00483 {
    00484    fat_check_device();
    00485    if( FS_TYPE_FAT_UNM == fs_g_nav_fast.u8_type_fat)
    00486    {
    00487       nav_partition_mount();
    00488    }
    00489    return fs_g_nav_fast.u8_type_fat;
    00490 }

Here is the caller graph for this function:

Bool nav_partition_serialnumber | ( | Bool | b_action,
|  | U8 _MEM_TYPE_SLOW_ * | a_u8_sn |
| ) |  |  |

This function reads or writes the serial number on the selected partition.

Parameters:

  | b_action | to select the action FS_SN_READ to read serial number FS_SN_WRITE to write serial number
  | a_u8_sn | pointer on an array (4 bytes) if FS_SN_READ, then the array is used to store the serial number if FS_SN_WRITE, then the array is used to give the new serial number

Returns:
  FALSE in case of error, see global value "fs_g_status" for more detail

  TRUE otherwise

Definition at line 505 of file navigation.c.

    00506 {
    00507    if( !fat_check_mount())
    00508       return FALSE;
    00509
    00510    return fat_serialnumber( b_action , a_u8_sn );
    00511 }

Bool nav_partition_label | ( | Bool | b_action,
|  | FS_STRING | sz_label |
| ) |  |  |

This function reads or writes the label of selected partition.

Parameters:

  | b_action | to select the action FS_LABEL_READ to read label FS_LABEL_WRITE to write label
  | sz_label | pointer on a ASCII string (11 chars + NULL terminator =12 bytes) if FS_LABEL_READ, then the string is used to store label if FS_LABEL_WRITE, then the string is used to give the new label

Returns:
  FALSE in case of error, see global value "fs_g_status" for more detail

  TRUE otherwise

Definition at line 526 of file navigation.c.

    00527 {
    00528    _MEM_TYPE_SLOW_   Fs_index index;
    00529    Bool status = TRUE;
    00530
    00531    index = nav_getindex();    // Save current position
    00532
    00533    // Go to root dir
    00534    if( nav_dir_root())
    00535    {
    00536       // Find field label
    00537       fs_g_nav_fast.u16_entry_pos_sel_file = 0; // Go to first entry
    00538       while( 1 )
    00539       {
    00540          if ( !fat_read_dir())
    00541          {
    00542             status = FALSE;
    00543             break;               // error
    00544          }
    00545          if( fat_entry_label( FS_LABEL_READ , NULL ) )
    00546             break;
    00547          if( FS_ERR_ENTRY_EMPTY == fs_g_status )
    00548             break;
    00549          fs_g_nav_fast.u16_entry_pos_sel_file++;
    00550       }
    00551       if( TRUE == status )
    00552       {
    00553          // Find OK
    00554          if( FS_LABEL_READ == b_action )
    00555          {
    00556             // Read field label
    00557             if( !fat_entry_label( FS_LABEL_READ , sz_label ) )
    00558                sz_label[0]=0;    // empty name
    00559          }else{
    00560             // Change field label
    00561             status = fat_entry_label( FS_LABEL_WRITE , sz_label );
    00562          }
    00563       }
    00564    }
    00565    nav_gotoindex( &index );   // Restore the position
    00566    return status;
    00567 }

U32 nav_partition_space | ( | void |  | ) |

This function returns partition total space.

Returns:
  number of sectors

  0, in case of error

    //! You shall mounted the partition before call this routine
    //!

Definition at line 579 of file navigation.c.

Referenced by ushell_cmd_free_space(), and ushell_cmd_space().

    00580 {
    00581    fat_check_device();
    00582    if (FS_TYPE_FAT_UNM == fs_g_nav_fast.u8_type_fat)
    00583       return 0;
    00584    return (fs_g_nav.u32_CountofCluster * fs_g_nav.u8_BPB_SecPerClus);
    00585 }

Here is the caller graph for this function:

U8 nav_partition_cluster_size | ( | void |  | ) |

This function returns the partition cluster size.

Returns:
  cluster size (unit sector)

Definition at line 592 of file navigation.c.

    00593 {
    00594    return fs_g_nav.u8_BPB_SecPerClus;
    00595 }

U32 nav_partition_freespace | ( | void |  | ) |

This function returns the partition free space.

Returns:
  number of free sectors

  0 in case of error or full partition

    //! You shall mounted the partition before call this routine
    //!

Definition at line 606 of file navigation.c.

Referenced by ushell_cmd_free_space().

    00607 {
    00608    fat_check_device();
    00609    if (FS_TYPE_FAT_UNM == fs_g_nav_fast.u8_type_fat)
    00610       return 0;
    00611    return fat_getfreespace();
    00612 }

Here is the caller graph for this function:

U8 nav_partition_freespace_percent | ( | void |  | ) |

This function returns the partition space free in percent.

Returns:
  percent of free space (0% to 100%)

  0% in case of error or full partition

    //! To speed up the compute, the resultat have an error delta of 1%
    //!

Definition at line 624 of file navigation.c.

Referenced by ushell_cmd_free_space().

    00625 {
    00626    fat_check_device();
    00627    if (FS_TYPE_FAT_UNM == fs_g_nav_fast.u8_type_fat)
    00628       return 0;
    00629    return fat_getfreespace_percent();
    00630 }

Here is the caller graph for this function:

Bool nav_filelist_single_enable | ( | Bool | b_type | ) |

To display in File List only the files OR directories.

Parameters:

  | b_type | FS_DIR to display only directories presence FS_FILE to dispaly only files presence

Returns:
  FALSE in case of error, see global value "fs_g_status" for more detail

  TRUE otherwise

Definition at line 645 of file navigation.c.

    00646 {
    00647    if ( !nav_filelist_reset())
    00648       return FALSE;
    00649
    00650    fs_g_nav.b_mode_nav_single = TRUE;
    00651    fs_g_nav.b_mode_nav        = b_type;
    00652    return TRUE;
    00653 }

Bool nav_filelist_single_disable | ( | void |  | ) |

To display in File List the directories AND files.

Returns:
  FALSE in case of error, see global value "fs_g_status" for more detail

  TRUE otherwise

Definition at line 661 of file navigation.c.

    00662 {
    00663    fs_g_nav.b_mode_nav_single = FALSE;
    00664    return nav_filelist_reset();
    00665 }

Bool nav_filelist_reset | ( | void |  | ) |

This function resets the selection pointer, so "no file selected" in file list.

Returns:
  FALSE in case of error, see global value "fs_g_status" for more detail

  TRUE otherwise

Definition at line 673 of file navigation.c.

Referenced by copy_dir(), nav_dir_cd(), nav_dir_gotoparent(), nav_filelist_exist(), nav_filelist_first(), nav_filelist_goto(), nav_filelist_nb(), nav_filelist_single_disable(), nav_filelist_single_enable(), nav_gotoindex(), nav_setcwd(), ushell_cmd_ls(), and ushell_cmd_sync().

    00674 {
    00675    if ( !fat_check_mount_noopen())
    00676       return FALSE;
    00677
    00678    // No file selected and reset navigation
    00679    fat_clear_entry_info_and_ptr();
    00680    return TRUE;
    00681 }

Here is the caller graph for this function:

Bool nav_filelist_validpos | ( | void |  | ) |

This function checks if a file is selected.

Returns:
  TRUE if a file is selected

  FALSE if no file is selected

Definition at line 689 of file navigation.c.

    00690 {
    00691    return fat_check_mount_select_noopen();
    00692 }

Bool nav_filelist_fileisnotopen | ( | void |  | ) |

This function checks if no file is open.

Returns:
  TRUE if no file is open

  FALSE if a file is open

Definition at line 700 of file navigation.c.

    00701 {
    00702    return fat_check_noopen();
    00703 }

Bool nav_filelist_set | ( | U16 | u16_nb,
|  | Bool | b_direction |
| ) |  |  |

This function moves the selection pointer in file list.

Parameters:

  | u16_nb | numbers of file to jump before stopping action 0, stop at the first file found 1, stop at the second file found
  | b_direction | search direction FS_FIND_NEXT, move to next file or directory FS_FIND_PREV, move to previous file or directory

Returns:
  FALSE in case of error, see global value "fs_g_status" for more detail

  TRUE otherwise

    //! Note: if no file is selected then nav_filelist_set( 0 , FS_NEXT ) goes to the first entry of the file list.
    //!

Definition at line 723 of file navigation.c.

Referenced by copy_dir(), nav_dir_gotoparent(), nav_filelist_bol(), nav_filelist_eol(), nav_filelist_exist(), nav_filelist_findname(), nav_filelist_first(), nav_filelist_goto(), nav_filelist_last(), nav_filelist_nb(), nav_gotoindex(), ushell_cmd_ls(), and ushell_cmd_sync().

    00724 {
    00725    U16   u16_ptr_save_entry;
    00726    U16   u16_save_pos_sel_file;
    00727    Bool  b_save_entry_type;
    00728    Bool  b_find_last_entry = FALSE;
    00729
    00730    if ( !fat_check_mount_noopen())
    00731       return FALSE;
    00732
    00733    // Save the current selection
    00734    u16_ptr_save_entry      = fs_g_nav_fast.u16_entry_pos_sel_file;
    00735    u16_save_pos_sel_file   = fs_g_nav.u16_pos_sel_file;
    00736    b_save_entry_type       = fs_g_nav.b_mode_nav;
    00737
    00738    // Loop in directory
    00739    while( 1 )
    00740    {
    00741       if(( FS_FIND_NEXT == b_direction )
    00742       || ( b_find_last_entry ) )
    00743       {
    00744          if ( FS_END_FIND == fs_g_nav_fast.u16_entry_pos_sel_file )
    00745          {
    00746             // Too many files in directory (case impossible)
    00747             fs_g_status = FS_ERR_FS;
    00748             break;
    00749          }
    00750          fs_g_nav_fast.u16_entry_pos_sel_file++;      // Update entry position
    00751       }
    00752       else
    00753       {
    00754          if ( FS_NO_SEL == fs_g_nav_fast.u16_entry_pos_sel_file )
    00755          {
    00756             // No selected file then previous action impossible
    00757             fs_g_status = FS_ERR_NO_FIND;
    00758             break;
    00759          }
    00760          if ( 0 == fs_g_nav_fast.u16_entry_pos_sel_file )
    00761          {
    00762             // beginning of directory
    00763             if ( (FS_DIR == fs_g_nav.b_mode_nav ) || fs_g_nav.b_mode_nav_single )
    00764             {
    00765                // End of directory scan, then no previous action possible
    00766                fs_g_status = FS_ERR_NO_FIND;
    00767                break;
    00768             }
    00769             // End of file scan, then find last directory
    00770             b_find_last_entry = TRUE;
    00771          }else{
    00772             fs_g_nav_fast.u16_entry_pos_sel_file--;   // Update entry position
    00773          }
    00774       }
    00775
    00776       if( !fat_read_dir())
    00777       {
    00778          if( FS_ERR_OUT_LIST != fs_g_status )
    00779             break; // Error
    00780       }else{
    00781          if ( fat_entry_check( fs_g_nav.b_mode_nav ) )
    00782          {
    00783            // HERE, the file entry match with the type seached
    00784
    00785            if( b_find_last_entry )
    00786              continue;  // The search of last directory is on going then continue the search
    00787
    00788            // Update position in directory
    00789            if ( FS_FIND_NEXT == b_direction )
    00790               fs_g_nav.u16_pos_sel_file++;
    00791            else
    00792               fs_g_nav.u16_pos_sel_file--;
    00793
    00794            if (0 == u16_nb)
    00795            {
    00796               // It is the end of move then update file information
    00797               fat_get_entry_info();
    00798               return TRUE;         // NB FILE FIND
    00799            }
    00800            u16_nb--;
    00801            continue;
    00802          }
    00803       }
    00804
    00805       // Here error, check type of error
    00806       if(( FS_ERR_ENTRY_EMPTY == fs_g_status )
    00807       || ( FS_ERR_OUT_LIST    == fs_g_status ) )
    00808       {
    00809          // Here, end of the directory
    00810          if( b_find_last_entry )
    00811          {
    00812             // Re enable the previous command at the end of directory to find the last directory entry
    00813             b_find_last_entry = FALSE;
    00814             fs_g_nav.b_mode_nav = FS_DIR;
    00815             continue;
    00816          }
    00817          // Here, a next action is on going
    00818          if ( (FS_FILE == fs_g_nav.b_mode_nav) || fs_g_nav.b_mode_nav_single )
    00819          {
    00820             // End of next file action then end of next action
    00821             fs_g_status = FS_ERR_NO_FIND; // No file found
    00822             break;                        // end of search
    00823          }else{
    00824             // End of next dir action then starts the next file action at the beginning of directory
    00825             fs_g_nav_fast.u16_entry_pos_sel_file = 0xFFFF;
    00826             fs_g_nav.b_mode_nav = FS_FILE;
    00827          }
    00828       }
    00829    }  // end of loop while(1)
    00830
    00831    fs_g_nav.b_mode_nav                    = b_save_entry_type;
    00832    fs_g_nav_fast.u16_entry_pos_sel_file   = u16_ptr_save_entry;
    00833    fs_g_nav.u16_pos_sel_file              = u16_save_pos_sel_file;
    00834    return FALSE;
    00835 }

Here is the caller graph for this function:

U16 nav_filelist_get | ( | void |  | ) |

This function returns the position of selected file in file list.

Returns:
  position of selected file (0 is the first position)

  FS_NO_SEL, in case of no file selected

Definition at line 843 of file navigation.c.

Referenced by nav_filelist_goto().

    00844 {
    00845    return fs_g_nav.u16_pos_sel_file;
    00846 }

Here is the caller graph for this function:

Bool nav_filelist_goto | ( | U16 | u16_newpos | ) |

This function goes at a position in file list.

Parameters:

  | u16_newpos | new position to select (0 is the first position)

Returns:
  FALSE in case of error, see global value "fs_g_status" for more detail

  TRUE otherwise

Definition at line 856 of file navigation.c.

    00857 {
    00858    U16 u16_current_pos;
    00859
    00860    if( FS_NO_SEL == u16_newpos )
    00861       return nav_filelist_reset();
    00862
    00863    u16_current_pos = nav_filelist_get();
    00864    if( u16_newpos < (u16_current_pos/2) )
    00865    {
    00866       // Restart at the beginning of list to accelerate the search
    00867       if( !nav_filelist_reset() )
    00868          return FALSE;
    00869       u16_current_pos = FS_NO_SEL;
    00870    }
    00871    if (FS_NO_SEL == u16_current_pos)
    00872    {
    00873       return nav_filelist_set( u16_newpos, FS_FIND_NEXT );
    00874    }
    00875    else
    00876    {
    00877       if (u16_newpos < u16_current_pos)
    00878       {
    00879          return nav_filelist_set( u16_current_pos -u16_newpos -1 , FS_FIND_PREV );
    00880       }
    00881       if (u16_newpos > u16_current_pos)
    00882       {
    00883          return nav_filelist_set( u16_newpos -u16_current_pos - 1 , FS_FIND_NEXT );
    00884       }
    00885    }
    00886    return TRUE;
    00887 }

Bool nav_filelist_findname | ( | const FS_STRING | sz_name,
|  | Bool | b_match_case |
| ) |  |  |

This function searchs a file name in file list.

Parameters:

  | sz_name | name to search (UNICODE or ASCII) It must be terminate by NULL or '*' value
  | b_match_case | FALSE to ignore the case

Returns:
  FALSE in case of error, see global value "fs_g_status" for more detail

  TRUE otherwise

    //! This function starts a search at the next position of the current in file list
    //!

Definition at line 903 of file navigation.c.

Referenced by nav_setcwd().

    00904 {
    00905    while( 1 )
    00906    {
    00907       if ( !nav_filelist_set( 0, FS_FIND_NEXT ))
    00908          return FALSE;
    00909       if ( nav_file_name( sz_name , 0 , FS_NAME_CHECK , b_match_case ))
    00910          return TRUE;
    00911    }
    00912 }

Here is the caller graph for this function:

Bool nav_filelist_eol | ( | void |  | ) |

This function checks the end of file list.

Returns:
  FALSE, NO end of file list

  TRUE, in case of end of list or error

Definition at line 920 of file navigation.c.

    00921 {
    00922    if( FALSE == nav_filelist_set( 0 , FS_FIND_NEXT ) )
    00923       return TRUE;   // End of list or error (remark: the position haven't changed)
    00924
    00925    if( 0 != fs_g_nav.u16_pos_sel_file )
    00926    {
    00927       // Go to previous position
    00928       nav_filelist_set( 0 , FS_FIND_PREV );
    00929    }else{
    00930       // No select file before, then reset position
    00931       fs_g_nav_fast.u16_entry_pos_sel_file= FS_NO_SEL;
    00932       fs_g_nav.u16_pos_sel_file           = FS_NO_SEL;
    00933       fs_g_nav.b_mode_nav                 = FS_DIR;
    00934    }
    00935    return FALSE;
    00936 }

Bool nav_filelist_bol | ( | void |  | ) |

This function checks the beginning of file list.

Returns:
  FALSE, it is not the beginning of file list

  TRUE, in case of the file selected is the first file, or in case of error

Definition at line 944 of file navigation.c.

    00945 {
    00946    if( FALSE == nav_filelist_set( 0 , FS_FIND_PREV ) )
    00947       return TRUE;   // End of list or error (remark: the position haven't changed)
    00948    // Go to previous position
    00949    nav_filelist_set( 0 , FS_FIND_NEXT );
    00950    return FALSE;
    00951 }

Bool nav_filelist_exist | ( | Bool | b_type | ) |

This function checks the presence of files or directories in file list.

Parameters:

  | b_type | FS_DIR to check the directory presence FS_FILE to check the file presence

Returns:
  TRUE, in case of a file or a directory exists

  FALSE, in case of no file or no directory exists, or error

Definition at line 962 of file navigation.c.

    00963 {
    00964    Bool status;
    00965    U16   u16_save_position;
    00966
    00967    // Save current position
    00968    u16_save_position = fs_g_nav.u16_pos_sel_file;
    00969    // Go to first file or directory
    00970    status = nav_filelist_first( b_type );
    00971    // Restore previous position
    00972    nav_filelist_reset();
    00973    if ( u16_save_position != FS_NO_SEL )
    00974    {
    00975       nav_filelist_set( u16_save_position , FS_FIND_NEXT );
    00976    }
    00977    return status;
    00978 }

U16 nav_filelist_nb | ( | Bool | b_type | ) |

This function computes the number of files or directories in file list.

Parameters:

  | b_type | FS_DIR to compute the number of directories FS_FILE to compute the number of files

Returns:
  number of files or directories in file list

Definition at line 988 of file navigation.c.

Referenced by nav_filelist_last().

    00989 {
    00990    U16   u16_save_position;
    00991    U16   u16_save_number_dir;
    00992    U16   u16_save_number_file;
    00993
    00994    // Save current position
    00995    u16_save_position = fs_g_nav.u16_pos_sel_file;
    00996    // Reset position
    00997    if ( !nav_filelist_reset())
    00998       return 0;
    00999    // Scan all directory
    01000    u16_save_number_dir  = 0;
    01001    u16_save_number_file = 0;
    01002    while( nav_filelist_set( 0 , FS_FIND_NEXT ) )
    01003    {
    01004       if( FS_FILE == fs_g_nav.b_mode_nav )
    01005          u16_save_number_file++;    // It is a file
    01006       else
    01007          u16_save_number_dir++;     // It is a directory
    01008    }
    01009    // Restore previous position
    01010    nav_filelist_reset();
    01011    if ( u16_save_position != FS_NO_SEL )
    01012    {
    01013       nav_filelist_set( u16_save_position , FS_FIND_NEXT );
    01014    }
    01015    // Return the value asked
    01016    if( FS_FILE == b_type )
    01017       return u16_save_number_file;
    01018    else
    01019       return u16_save_number_dir;
    01020 }

Here is the caller graph for this function:

Bool nav_filelist_first | ( | Bool | b_type | ) |

This function goes to at the first file or directory in file list.

Parameters:

  | b_type | FS_DIR to go at the first directory FS_FILE to go at the first file

Returns:
  FALSE in case of error, see global value "fs_g_status" for more detail

  TRUE otherwise

Definition at line 1031 of file navigation.c.

Referenced by nav_filelist_exist(), and nav_filelist_last().

    01032 {
    01033    // Reset position
    01034    if ( !nav_filelist_reset())
    01035       return FALSE;
    01036    // Find the first file or directory
    01037    while( nav_filelist_set( 0 , FS_FIND_NEXT ) )
    01038    {
    01039       if( b_type == fs_g_nav.b_mode_nav )
    01040          return TRUE;   // First file or directory found
    01041    }
    01042    fs_g_status = FS_ERR_NO_FIND;
    01043    return FALSE;
    01044 }

Here is the caller graph for this function:

Bool nav_filelist_last | ( | Bool | b_type | ) |

This function goes to at the last file or directory in file list.

Parameters:

  | b_type | FS_DIR to go at the last directory FS_FILE to go at the last file

Returns:
  FALSE in case of error, see global value "fs_g_status" for more detail

  TRUE otherwise

Definition at line 1055 of file navigation.c.

    01056 {
    01057    U16 u16_nb;
    01058
    01059    // Get number of file or directory
    01060    u16_nb = nav_filelist_nb( b_type  );
    01061    if( 0 == u16_nb )
    01062    {
    01063       fs_g_status = FS_ERR_NO_FIND;
    01064       return FALSE;  // NO FILE FOUND
    01065    }
    01066    // Go to the first file or directory
    01067    if ( !nav_filelist_first( b_type ))
    01068       return FALSE;
    01069    // If there are more one file or directory, then go to at the last of list
    01070    if( 1 == u16_nb )
    01071       return TRUE;
    01072    u16_nb -= 2;
    01073    return nav_filelist_set( u16_nb , FS_FIND_NEXT );
    01074 }

Fs_index nav_getindex | ( | void |  | ) |

This function returns a small index on the selected file.

Returns:
  It is a small index structure with information on selected file (disk, partition, dir, file/dir selected)

    //! This routine is interresting to save a file position in small variable.
    //! This pointer allow to reinit a navigator quickly with nav_gotoindex() routine.
    //!

Definition at line 1090 of file navigation.c.

Referenced by copy_dir(), firm_upgrade_run(), nav_getcwd(), nav_partition_label(), nav_setcwd(), ushell_cmd_copy(), ushell_cmd_free_space(), ushell_cmd_mount(), ushell_cmd_perform(), ushell_cmd_rm(), ushell_cmd_sync(), and ushell_task().

    01091 {
    01092    Fs_index index;
    01093
    01094    // Fill index structure
    01095    index.u8_lun                  = fs_g_nav.u8_lun;
    01096 #if (FS_MULTI_PARTITION  ==  ENABLED)
    01097    index.u8_partition            = fs_g_nav.u8_partition;
    01098 #endif
    01099    index.u32_cluster_sel_dir     = fs_g_nav.u32_cluster_sel_dir;
    01100    index.u16_entry_pos_sel_file  = fs_g_nav_fast.u16_entry_pos_sel_file;
    01101    return index;
    01102 }

Here is the caller graph for this function:

Bool nav_gotoindex | ( | const Fs_index _MEM_TYPE_SLOW_ * | index | ) |

This function selects a file in the navigator via a file index.

Parameters:

  | index | structure with information about file to select (disk, partition, dir, file/dir selected )

Returns:
  FALSE in case of error, see global value "fs_g_status" for more detail

  TRUE otherwise

    //! This routine allow to reinit a navigator quickly via a file index (disk, partition, dir, file/dir selected )
    //! To get a file index, you shall used the routine nav_getindex().
    //!

Definition at line 1117 of file navigation.c.

Referenced by copy_dir(), firm_upgrade_run(), nav_getcwd(), nav_partition_label(), nav_setcwd(), ushell_cmd_copy(), ushell_cmd_free_space(), ushell_cmd_mount(), ushell_cmd_perform(), ushell_cmd_rm(), ushell_cmd_sync(), and ushell_task().

    01118 {
    01119    // Select the drive and partition corresponding at file index
    01120    if( !nav_drive_set( index->u8_lun ))
    01121       return FALSE;
    01122 #if (FS_MULTI_PARTITION  ==  ENABLED)
    01123    if( !nav_partition_set(index->u8_partition))
    01124       return FALSE;
    01125 #endif
    01126    if( !nav_partition_mount())
    01127       return FALSE;
    01128
    01129    // Select the directory corresponding at file index
    01130    fs_g_nav.u32_cluster_sel_dir   = index->u32_cluster_sel_dir;
    01131
    01132    // Search the file position corresponding at file index
    01133    if ( !nav_filelist_reset())
    01134       return FALSE;
    01135    while( fs_g_nav_fast.u16_entry_pos_sel_file != index->u16_entry_pos_sel_file )
    01136    {
    01137       if( !nav_filelist_set( 0 , FS_FIND_NEXT ) )
    01138       {
    01139          nav_filelist_reset();
    01140          return FALSE;
    01141       }
    01142    }
    01143    return TRUE;
    01144 }

Here is the caller graph for this function:

Bool nav_dir_root | ( | void |  | ) |

This function initializes the file list on the root directory.

Returns:
  FALSE in case of error, see global value "fs_g_status" for more detail

  TRUE otherwise

Definition at line 1156 of file navigation.c.

Referenced by nav_partition_label(), and nav_setcwd().

    01157 {
    01158    return nav_partition_mount();
    01159 }

Here is the caller graph for this function:

Bool nav_dir_is_root | ( | void |  | ) |

This function check the current directory.

Returns:
  FALSE the current directory selected is not the root directory

  TRUE the current directory selected is the root directory

Definition at line 1167 of file navigation.c.

    01168 {
    01169    if (!fat_check_mount_noopen())
    01170       return FALSE;
    01171
    01172    return (0 == fs_g_nav.u32_cluster_sel_dir);
    01173 }

Bool nav_dir_cd | ( | void |  | ) |

This function enters in the selected directory in file list.

Returns:
  FALSE in case of error, see global value "fs_g_status" for more detail

  TRUE otherwise

    //! After this routine the file list changes and contains the files and directories of the new directory.
    //! By default no file is selected.
    //!

Definition at line 1186 of file navigation.c.

Referenced by copy_dir(), nav_setcwd(), and ushell_cmd_sync().

    01187 {
    01188    if ( !fat_check_mount_select_noopen())
    01189       return FALSE;
    01190
    01191    // The current selection, is it a directory ?
    01192    if ( !fat_entry_is_dir())
    01193       return FALSE;
    01194
    01195    // Select the current directory
    01196    fs_g_nav.u16_entry_pos_sel_dir = fs_g_nav_fast.u16_entry_pos_sel_file;
    01197    fs_g_nav.u32_cluster_sel_dir = fs_g_nav_entry.u32_cluster;
    01198
    01199    // Reset file list
    01200    if( FALSE == nav_filelist_reset())
    01201       return FALSE;
    01202    return TRUE;
    01203 }

Here is the caller graph for this function:

Bool nav_dir_gotoparent | ( | void |  | ) |

This function goes to the parent directory.

Returns:
  FALSE in case of error, see global value "fs_g_status" for more detail

  TRUE otherwise

    //! After, the file list changes and contains the files and directories of the new directory.
    //! By default, the file selected in file list is the previous (children) directory.
    //!

Definition at line 1216 of file navigation.c.

Referenced by copy_dir(), nav_dir_name(), nav_getcwd(), nav_setcwd(), ushell_cmd_gotoparent(), and ushell_cmd_sync().

    01217 {
    01218    U32 u32_cluster_old_dir;
    01219
    01220    if (!fat_check_mount_noopen())
    01221       return FALSE;
    01222
    01223    if (0 == fs_g_nav.u32_cluster_sel_dir)
    01224    {
    01225       fs_g_status = FS_ERR_IS_ROOT;        // There aren't parent
    01226       return FALSE;
    01227    }
    01228
    01229    // Select and read information about directory ".."
    01230    fs_g_nav_fast.u16_entry_pos_sel_file = 1;
    01231    if ( !fat_read_dir())
    01232       return FALSE;
    01233    fat_get_entry_info();
    01234    // Save the children directory cluster
    01235    u32_cluster_old_dir = fs_g_nav.u32_cluster_sel_dir;
    01236
    01237    // Select the parent directory via information present in the current directory ".."
    01238    fs_g_nav.u32_cluster_sel_dir = fs_g_nav_entry.u32_cluster;
    01239
    01240    // Select the children directory in new directory (=parent directory)
    01241    if( FALSE == nav_filelist_reset())
    01242       return FALSE;
    01243    if( fs_g_nav.b_mode_nav_single && (FS_DIR != fs_g_nav.b_mode_nav) )
    01244       return TRUE;
    01245
    01246    while( nav_filelist_set( 0 , FS_FIND_NEXT ) )
    01247    {
    01248       if (fs_g_nav_entry.u32_cluster == u32_cluster_old_dir)
    01249          return TRUE;         // It is the children directory
    01250    }
    01251    fs_g_status = FS_ERR_FS;
    01252    return FALSE;
    01253 }

Here is the caller graph for this function:

Bool nav_dir_name | ( | FS_STRING | sz_path,
|  | U8 | u8_size_max |
| ) |  |  |

This function returns the directory name corresponding at the file list.

Parameters:

  | sz_path | string to store the name (ASCII or UNICODE )
  | u8_size_max | string size (unit ASCII or UNICODE )

Returns:
  FALSE in case of error, see global value "fs_g_status" for more detail

  TRUE otherwise

Definition at line 1264 of file navigation.c.

Referenced by ushell_cmd_ls().

    01265 {
    01266    U8 u8_i, u8_character;
    01267    Bool status = FALSE;
    01268    U16 save_u16_entry_pos_sel_file;
    01269    U32 save_u32_cluster_sel_dir;
    01270    U8  save_u8_attr          ;
    01271    U32 save_u32_cluster      ;
    01272    U32 save_u32_size         ;
    01273    Bool b_mode_nav_single_save;
    01274    Bool b_mode_nav_mode_save;
    01275
    01276    if ( !fat_check_mount_noopen())
    01277       return FALSE;
    01278
    01279    if (0 != fs_g_nav.u32_cluster_sel_dir)
    01280    {
    01281       // Save context
    01282       save_u16_entry_pos_sel_file= fs_g_nav_fast.u16_entry_pos_sel_file;
    01283       save_u32_cluster_sel_dir   = fs_g_nav.u32_cluster_sel_dir        ;
    01284       save_u8_attr               = fs_g_nav_entry.u8_attr              ;
    01285       save_u32_cluster           = fs_g_nav_entry.u32_cluster          ;
    01286       save_u32_size              = fs_g_nav_entry.u32_size             ;
    01287       b_mode_nav_single_save = fs_g_nav.b_mode_nav_single;
    01288       b_mode_nav_mode_save   = fs_g_nav.b_mode_nav;
    01289       fs_g_nav.b_mode_nav_single = TRUE;
    01290       fs_g_nav.b_mode_nav = FS_FILE;
    01291       // Go to parent directory and select the children directory
    01292       if( !nav_dir_gotoparent() )
    01293       {
    01294          fs_g_nav.b_mode_nav_single = b_mode_nav_single_save;
    01295          fs_g_nav.b_mode_nav = b_mode_nav_mode_save;
    01296          return FALSE;
    01297       }
    01298       fs_g_nav.b_mode_nav_single = b_mode_nav_single_save ;
    01299       fs_g_nav.b_mode_nav = b_mode_nav_mode_save;
    01300       // Go to directory name position
    01301       fs_g_nav_fast.u16_entry_pos_sel_file = fs_g_nav.u16_entry_pos_sel_dir;
    01302       status = nav_file_name( sz_path  , u8_size_max , FS_NAME_GET , FALSE  );
    01303       // Restore previous context
    01304       fs_g_nav_fast.u16_entry_pos_sel_file= save_u16_entry_pos_sel_file;
    01305       fs_g_nav.u32_cluster_sel_dir        = save_u32_cluster_sel_dir   ;
    01306       fs_g_nav_entry.u8_attr              = save_u8_attr               ;
    01307       fs_g_nav_entry.u32_cluster          = save_u32_cluster           ;
    01308       fs_g_nav_entry.u32_size             = save_u32_size              ;
    01309    }
    01310    else
    01311    {
    01312       // No parent directory, then it is the root directory
    01313       if( g_b_string_length )
    01314       {
    01315          ((FS_STR_UNICODE)sz_path )[0] = 3;  // 3 chars for path "x:"
    01316          status = TRUE;
    01317       }else
    01318
    01319       // Create a device name
    01320       for( u8_i = 0 ; u8_i<3 ; u8_i++ )
    01321       {
    01322          switch( u8_i )
    01323          {
    01324             case 0:
    01325             u8_character = nav_drive_getname();    // Letter
    01326             break;
    01327             case 1:
    01328             u8_character = ':';                     // ":"
    01329             break;
    01330             case 2:
    01331             default:
    01332             u8_character = 0;                       // end of string
    01333             break;
    01334          }
    01335          if( Is_unicode )
    01336          {
    01337             ((FS_STR_UNICODE)sz_path )[0] = u8_character;
    01338          }else{
    01339             sz_path [0] = u8_character;
    01340          }
    01341          sz_path  += (Is_unicode? 2 : 1 );
    01342       }
    01343       status = TRUE;
    01344
    01345    }
    01346    return status;
    01347 }

Here is the caller graph for this function:

Bool nav_getcwd | ( | FS_STRING | sz_path,
|  | U8 | u8_size_path,
|  | Bool | b_view_file_select |
| ) |  |  |

This function returns the full path of the selection.

Parameters:

  | sz_path | string to store the path (ASCII or UNICODE )
  | u8_size_path | string size (unit ASCII or UNICODE )
  | b_view_file_select | TRUE, to include in path the selected file name

Returns:
  FALSE in case of error, see global value "fs_g_status" for more detail

  TRUE otherwise

Definition at line 1408 of file navigation.c.

    01409 {
    01410    _MEM_TYPE_SLOW_   Fs_index index;
    01411    _MEM_TYPE_SLOW_   U16 u16_lgt=0;    // Only used if LENGTH string mode enabled
    01412    U8 u8_save_size_path=0, u8_i;
    01413    Bool status = FALSE;                // Error by default
    01414
    01415    if ( !fat_check_mount_noopen())
    01416       return FALSE;
    01417
    01418    index = nav_getindex();             // Save current position
    01419
    01420    if( g_b_string_length )
    01421    {
    01422       u16_lgt = 1;   // 1 for NULL terminate
    01423    }
    01424    else
    01425    {
    01426       u8_save_size_path = u8_size_path;
    01427       // Set NULL terminator at the end of path
    01428       u8_size_path--;
    01429       if( Is_unicode )
    01430       {
    01431          ((FS_STR_UNICODE)sz_path )[u8_size_path] = 0;
    01432       }else{
    01433          sz_path [u8_size_path]   = 0;
    01434       }
    01435    }
    01436
    01437    // For each directory of path
    01438    while( 1 )
    01439    {
    01440       if( b_view_file_select )
    01441       {
    01442          // Write the selected file or directory in path
    01443          b_view_file_select = FALSE;
    01444          if( !fat_check_select() )
    01445             continue;   // No selected file or directory, then restart loop to go at the first directory of path
    01446       }
    01447       else
    01448       {
    01449          // Go to parent directory and selects the children directory
    01450          if( !nav_dir_gotoparent() )
    01451             break;
    01452       }
    01453
    01454       // Read name of selected file or directory
    01455       if( !nav_file_name( sz_path  , u8_size_path , FS_NAME_GET, FALSE  ))
    01456          break;
    01457
    01458       if( g_b_string_length )
    01459       {
    01460          // Update total length
    01461          u16_lgt += ((FS_STR_UNICODE)sz_path )[0]; // 0 = -1 to remove NULL terminated and +1 for '\\'
    01462          continue;
    01463       }
    01464
    01465       // Compute the size of name
    01466       u8_i = 0;
    01467       while( 1 )
    01468       {
    01469          if( Is_unicode )
    01470          {
    01471             if( 0 == ((FS_STR_UNICODE)sz_path )[u8_i])
    01472                break;
    01473          }else{
    01474             if( 0 == sz_path [u8_i])
    01475                break;
    01476          }
    01477          u8_i++;
    01478       }
    01479
    01480       // Check the string size
    01481       if( (u8_i+1) == u8_size_path )
    01482       {
    01483          fs_g_status = FS_ERR_BUFFER_FULL;   // The path string is full
    01484          break;
    01485       }
    01486
    01487       // Move the name at the end of path
    01488       while( 0 != u8_i )
    01489       {
    01490          u8_i--;
    01491          u8_size_path--;
    01492          if( Is_unicode )
    01493          {
    01494             ((FS_STR_UNICODE)sz_path )[u8_size_path] = ((FS_STR_UNICODE)sz_path )[u8_i];
    01495          }else{
    01496             sz_path [u8_size_path]   = sz_path [u8_i];
    01497          }
    01498       }
    01499       // Set '\' char before the name
    01500       u8_size_path--;
    01501       if( Is_unicode )
    01502       {
    01503          ((FS_STR_UNICODE)sz_path )[u8_size_path] = '\\';
    01504       }else{
    01505          sz_path [u8_size_path]   = '\\';
    01506       }
    01507    }
    01508
    01509    if ( FS_ERR_IS_ROOT == fs_g_status )
    01510    {
    01511       if( g_b_string_length )
    01512       {
    01513          // Update and write total length
    01514          ((FS_STR_UNICODE)sz_path )[0] = u16_lgt +2 ; //+2 for "x:"
    01515          status = TRUE;
    01516       }
    01517       else
    01518       {
    01519          // End of path then add device name
    01520          if( 2 > u8_size_path )
    01521          {
    01522             fs_g_status = FS_ERR_BUFFER_FULL;   // The path string is full
    01523          }
    01524          else
    01525          {
    01526             // Create a device name
    01527             if( Is_unicode )
    01528             {
    01529                ((FS_STR_UNICODE)sz_path )[0] = nav_drive_getname();    // Letter
    01530                ((FS_STR_UNICODE)sz_path )[1] = ':';                   // ":"
    01531             }else{
    01532                sz_path [0] = nav_drive_getname();    // Letter
    01533                sz_path [1] = ':';                      // ":"
    01534             }
    01535
    01536             // The path is stored at the end, then move the path at the beginning
    01537             u8_i = 2;
    01538             while( u8_save_size_path != u8_size_path )
    01539             {
    01540                if( Is_unicode )
    01541                {
    01542                   ((FS_STR_UNICODE)sz_path )[u8_i] = ((FS_STR_UNICODE)sz_path )[u8_size_path];
    01543                }else{
    01544                   sz_path [u8_i] = sz_path [u8_size_path];
    01545                }
    01546                u8_i++;
    01547                u8_size_path++;
    01548             }
    01549             status = TRUE;
    01550          }
    01551       }
    01552    } // else Error system
    01553
    01554    nav_gotoindex( &index );   // Restore the position
    01555    return status;
    01556 }

Bool nav_setcwd | ( | FS_STRING | sz_path,
|  | Bool | b_match_case,
|  | Bool | b_create |
| ) |  |  |

This function selects a disk position via a path.

Parameters:

  | sz_path | path string (ASCII or UNICODE )
  | b_match_case | FALSE to ignore the case
  | b_create | TRUE, if path no exists then create it FALSE, no create path

Returns:
  FALSE in case of error, see global value "fs_g_status" for more detail

  TRUE otherwise

    //! The syntact "./../../file_name" is supported.
    //! With syntact "./dir_parent/directory_name"  the file list corresponding at "dir_parent" and "directory_name" is selected.
    //! With syntact "./dir_parent/directory_name/" the file list corresponding at "directory_name" and no file is selected.
    //!

Definition at line 1575 of file navigation.c.

Referenced by firm_upgrade_searchfile(), goto_code_name(), ushell_cmd_append_file(), ushell_cmd_cat(), ushell_cmd_cd(), ushell_cmd_copy(), ushell_cmd_rename(), ushell_cmd_rm(), ushell_cmd_sync(), and ushell_cmddfu_load().

    01576 {
    01577    _MEM_TYPE_SLOW_   Fs_index index;
    01578 #if (FSFEATURE_WRITE == (FS_LEVEL_FEATURES & FSFEATURE_WRITE)) ||              \
    01579     (FSFEATURE_WRITE_COMPLET == (FS_LEVEL_FEATURES & FSFEATURE_WRITE_COMPLET))
    01580    FS_STRING sz_save_path = 0;
    01581 #endif
    01582    Bool b_create_name = FALSE;
    01583
    01584    if ( !fat_check_noopen())
    01585       return FALSE;
    01586
    01587    index = nav_getindex();             // Save current position
    01588
    01589    // Check syntact "\path..."
    01590    if( (( Is_unicode) && (('\\'  == ((FS_STR_UNICODE)sz_path )[0]) || ('/'  == ((FS_STR_UNICODE)sz_path )[0])) )
    01591    ||  ((!Is_unicode) && (('\\'  == sz_path [0]) || ('/'  == sz_path [0])) ) )
    01592    {
    01593       // Go to the root of current drive
    01594       if( !nav_dir_root())
    01595          goto nav_setcwd_fail;
    01596       sz_path  += (Is_unicode? 2 : 1 );
    01597    }else
    01598
    01599    // Check syntact "x:\path..."
    01600    if( (( Is_unicode) && (( ':'  == ((FS_STR_UNICODE)sz_path )[1] ) && (('\\'  == ((FS_STR_UNICODE)sz_path )[2] ) || ('/'  == ((FS_STR_UNICODE)sz_path )[2]))) )
    01601    ||  ((!Is_unicode) && (( ':'  == sz_path [1] ) && (('\\'  == sz_path [2] ) || ('/'  == sz_path [2]))) ) )
    01602    {
    01603       // Go to the drive
    01604       if( Is_unicode )
    01605       {
    01606          if( !nav_drive_set( toupper(((FS_STR_UNICODE)sz_path )[0])-'A' ) )
    01607             goto nav_setcwd_fail;
    01608       }else{
    01609          if( !nav_drive_set( toupper(sz_path [0])-'A' ) )
    01610             goto nav_setcwd_fail;
    01611       }
    01612       if( !nav_partition_mount())
    01613          goto nav_setcwd_fail;
    01614       sz_path  += 3*(Is_unicode? 2 : 1 );
    01615    }else
    01616
    01617    // Check syntact ".\path..."
    01618    if( (( Is_unicode) && (( '.'  == ((FS_STR_UNICODE)sz_path )[0] ) && (('\\'  == ((FS_STR_UNICODE)sz_path )[1] ) || ('/'  == ((FS_STR_UNICODE)sz_path )[1] ))) )
    01619    ||  ((!Is_unicode) && (( '.'  == sz_path [0] ) && (('\\'  == sz_path [1] ) || ('/'  == sz_path [1] ))) ) )
    01620    {
    01621       // Search in current directory
    01622       sz_path  += 2*(Is_unicode? 2 : 1 );
    01623    }else
    01624
    01625    {
    01626       // Check syntact "..\..\path..."
    01627       if( Is_unicode )
    01628       {
    01629          while(( '.'  == ((FS_STR_UNICODE)sz_path )[0] )
    01630          &&    ( '.'  == ((FS_STR_UNICODE)sz_path )[1] )
    01631          &&    (('\\'  == ((FS_STR_UNICODE)sz_path )[2]) || ('/'  == ((FS_STR_UNICODE)sz_path )[2]) || (0  == ((FS_STR_UNICODE)sz_path )[2])) )
    01632          {
    01633             // Go to parent directory
    01634             if( !nav_dir_gotoparent() )
    01635                goto nav_setcwd_fail;
    01636             sz_path  += (2*2); // jump ".."
    01637             if( 0 != ((FS_STR_UNICODE)sz_path )[0])
    01638                sz_path  += (2*1); // jump "/"
    01639          }
    01640       }else{
    01641          while(( '.'  == sz_path [0] )
    01642          &&    ( '.'  == sz_path [1] )
    01643          &&    (('\\'  == sz_path [2]) || ('/'  == sz_path [2]) || (0  == sz_path [2])) )
    01644          {
    01645          // Go to parent directory
    01646          if( !nav_dir_gotoparent() )
    01647             goto nav_setcwd_fail;
    01648             sz_path  += 2; // jump ".."
    01649             if( 0 != sz_path [0])
    01650                sz_path  +=1; // jump "/"
    01651          }
    01652       }
    01653    }
    01654
    01655    // Reset list to start the search at the beginning
    01656    if( !nav_filelist_reset())
    01657       goto nav_setcwd_fail;
    01658
    01659    while( 1 )
    01660    {
    01661       if( (( Is_unicode) && ( 0 == ((FS_STR_UNICODE)sz_path )[0] ) )
    01662       ||  ((!Is_unicode) && ( 0 == sz_path [0] ) ) )
    01663       {
    01664          return TRUE;   // path (without file) is found or create
    01665       }
    01666       if( !nav_filelist_findname( sz_path  , b_match_case  ))
    01667       {
    01668          // The file or directory is not found
    01669          if( !b_create )
    01670             goto nav_setcwd_fail;   // don't creat the directory then exit
    01671          // Set flag to create the directory
    01672          b_create_name = TRUE;
    01673 #if (FSFEATURE_WRITE == (FS_LEVEL_FEATURES & FSFEATURE_WRITE)) ||              \
    01674     (FSFEATURE_WRITE_COMPLET == (FS_LEVEL_FEATURES & FSFEATURE_WRITE_COMPLET))
    01675          sz_save_path = sz_path;
    01676 #endif
    01677       }
    01678
    01679       while( 1 )
    01680       {
    01681          sz_path  += (Is_unicode? 2 : 1 );
    01682          if( (( Is_unicode) && ( 0 == ((FS_STR_UNICODE)sz_path )[0] ) )
    01683          ||  ((!Is_unicode) && ( 0 == sz_path [0] ) ) )
    01684          {
    01685             // Is it the last name of path and it is a file
    01686             if( b_create_name )
    01687             {
    01688 #if (FSFEATURE_WRITE == (FS_LEVEL_FEATURES & FSFEATURE_WRITE))
    01689                // The file must be created
    01690                if( !nav_file_create( sz_save_path ) )
    01691                   goto nav_setcwd_fail;
    01692 #else
    01693                goto nav_setcwd_fail;
    01694 #endif
    01695             }
    01696             break;   // The file include in path is found or created, then end of set_cwd
    01697          }
    01698
    01699          if( (( Is_unicode) && (('\\' == ((FS_STR_UNICODE)sz_path )[0] ) || ('/' == ((FS_STR_UNICODE)sz_path )[0] )) )
    01700          ||  ((!Is_unicode) && (('\\' == sz_path [0] ) || ('/' == sz_path [0] )) ) )
    01701          {
    01702             // Is it a folder name
    01703             if( b_create_name )
    01704             {
    01705 #if (FSFEATURE_WRITE_COMPLET == (FS_LEVEL_FEATURES & FSFEATURE_WRITE_COMPLET))
    01706                // The folder doesn't exist and it must be created
    01707                if( !nav_dir_make( sz_save_path ))
    01708                   goto nav_setcwd_fail;
    01709 #else
    01710                goto nav_setcwd_fail;
    01711 #endif
    01712             }
    01713             if( !fat_entry_is_dir() )
    01714                goto nav_setcwd_fail;
    01715             // jump '\'
    01716             sz_path  += (Is_unicode? 2 : 1 );
    01717             if( !nav_dir_cd())
    01718                goto nav_setcwd_fail;
    01719             break;
    01720          }
    01721       }
    01722
    01723    }
    01724
    01725 nav_setcwd_fail:
    01726    nav_gotoindex( &index );   // Restore the position
    01727    return FALSE;
    01728 }

Here is the caller graph for this function:

Bool nav_file_getname | ( | FS_STRING | sz_name,
|  | U8 | u8_size_max |
| ) |  |  |

This function returns the name of selected file.

Parameters:

  | sz_name | string to store the name file (ASCII or UNICODE )
  | u8_size_max | string size (unit ASCII or UNICODE )

Returns:
  FALSE in case of error, see global value "fs_g_status" for more detail

  TRUE otherwise

Definition at line 1745 of file navigation.c.

Referenced by firm_upgrade_run().

    01746 {
    01747    return nav_file_name( sz_name, u8_size_max, FS_NAME_GET, FALSE );
    01748 }

Here is the caller graph for this function:

Bool nav_file_name | ( | FS_STRING | sz_name,
|  | U8 | u8_size_max,
|  | Bool | b_mode,
|  | Bool | b_match_case |
| ) |  |  |

This function returns the name of selected file or checks the string with the name of selected file.

Parameters:

  | b_mode | action mode: FS_NAME_GET to get the name of selected file FS_NAME_CHECK to check the name of selected file
  | sz_name | if FS_NAME_GET then string to store the file name (ASCII or UNICODE ) if FS_NAME_CHECK then string to match with file name (ASCII or UNICODE), it must be terminated by NULL or '*' value
  | b_match_case | FALSE, ignore the case (only used in "FS_NAME_CHECK" action)
  | u8_size_max | string size (unit ASCII or UNICODE ), only used in "FS_NAME_GET" action

Returns:
  FALSE in case of error, see global value "fs_g_status" for more detail

  TRUE otherwise

Definition at line 1766 of file navigation.c.

Referenced by copy_dir(), nav_dir_name(), nav_file_getname(), nav_filelist_findname(), nav_getcwd(), ushell_cmd_copy(), ushell_cmd_ls(), and ushell_cmd_sync().

    01767 {
    01768    _MEM_TYPE_SLOW_   U16 u16_lgt;   // Only used if LENGTH string mode enabled
    01769    U16  u16_ptr_save_entry;
    01770    Bool  b_readshortname = FALSE;
    01771
    01772    if ( !fat_check_mount_select())
    01773       return FALSE;
    01774
    01775    // Check if the string size is not 0
    01776    if( (FS_NAME_GET == b_mode)
    01777    &&  (0 == u8_size_max) )
    01778    {
    01779       return TRUE;
    01780    }
    01781
    01782    // Save the current entry position
    01783    u16_ptr_save_entry = fs_g_nav_fast.u16_entry_pos_sel_file;
    01784    // if it is the beginning of the directory
    01785    if ( 0 == fs_g_nav_fast.u16_entry_pos_sel_file )
    01786    {
    01787       b_readshortname = TRUE;                   // It isn't possibled to have a long name
    01788    }
    01789    else
    01790    {
    01791       fs_g_nav_fast.u16_entry_pos_sel_file--;   // Initialize entry position to search the first long name entry
    01792    }
    01793
    01794    // Loop in directory entry
    01795    u16_lgt = 0;
    01796    while( 1 )
    01797    {
    01798       if ( !fat_read_dir())
    01799          break; // error
    01800
    01801       if ( b_readshortname )
    01802       {
    01803          // No long name present then read short name
    01804          return fat_entry_shortname( sz_name , u8_size_max , b_mode  );
    01805       }
    01806
    01807       // Check or read the part of long file name in this entry
    01808       if ( fat_entry_longname( sz_name , u8_size_max , b_mode , b_match_case  ))
    01809       {
    01810          if( g_b_string_length )
    01811          {
    01812             ((FS_STR_UNICODE)sz_name )[0] += u16_lgt;
    01813          }
    01814          fs_g_nav_fast.u16_entry_pos_sel_file = u16_ptr_save_entry;
    01815          return TRUE;
    01816       }
    01817
    01818       if ( FS_NO_LAST_LFN_ENTRY != fs_g_status )
    01819       {
    01820          // Go to the main entry file (=short name entry)
    01821          fs_g_nav_fast.u16_entry_pos_sel_file = u16_ptr_save_entry;
    01822
    01823          if ( FS_ERR_ENTRY_BAD == fs_g_status )
    01824          {
    01825             // It isn't a long name entry then there aren't long file name
    01826             b_readshortname = TRUE;   // It is mandatory to use the short name
    01827             continue;                 // restart the loop
    01828          }
    01829          // here, it is a error system or the string don't match with the file name
    01830          break;
    01831       }
    01832       if( g_b_string_length )
    01833       {
    01834          u16_lgt += FS_SIZE_LFN_ENTRY;
    01835       }
    01836       else
    01837       {
    01838          // Increment the string to store the next part of file name
    01839          sz_name += FS_SIZE_LFN_ENTRY * (Is_unicode? 2 : 1 );
    01840          u8_size_max -= FS_SIZE_LFN_ENTRY;
    01841       }
    01842       fs_g_nav_fast.u16_entry_pos_sel_file--;   // Go to the next part of long file name
    01843
    01844    }  // end of loop while(1)
    01845    return FALSE;
    01846 }

Here is the caller graph for this function:

U32 nav_file_lgt | ( | void |  | ) |

This function returns the size of selected file (unit byte).

Returns:
  Size of selected file (unit byte)

Definition at line 1853 of file navigation.c.

Referenced by ushell_cmd_ls().

    01854 {
    01855    return fs_g_nav_entry.u32_size;
    01856 }

Here is the caller graph for this function:

U16 nav_file_lgtsector | ( | void |  | ) |

This function returns the size of selected file (unit sector).

Returns:
  Size of selected file (unit 512B)

Definition at line 1863 of file navigation.c.

    01864 {
    01865    return (fs_g_nav_entry.u32_size >> FS_512B_SHIFT_BIT);
    01866 }

Bool nav_file_isreadonly | ( | void |  | ) |

This function checks the write protection of disk and the attribut "read only" of selected file.

Returns:
  FALSE, it is possible to modify the selected file

  TRUE, in other case

Definition at line 1874 of file navigation.c.

    01875 {
    01876    if( !fat_check_mount_select() )
    01877       return TRUE;   // No file selected
    01878    if( mem_wr_protect( fs_g_nav.u8_lun ) )
    01879       return TRUE;   // Disk protected
    01880    return (0!=(FS_ATTR_READ_ONLY & fs_g_nav_entry.u8_attr));   // Check attribut "read only"
    01881 }

Bool nav_file_isdir | ( | void |  | ) |

This function returns the type of selected file.

Returns:
  TRUE, it is a directory

  FALSE, in other case

Definition at line 1889 of file navigation.c.

Referenced by copy_dir(), ushell_cmd_ls(), and ushell_cmd_sync().

    01890 {
    01891    return fat_entry_is_dir();
    01892 }

Here is the caller graph for this function:

Bool nav_file_checkext | ( | const FS_STRING | sz_filterext | ) |

This function checks the extension of selected file.

Parameters:

  | sz_filterext | extension filter (ASCII format, e.g.: "txt" or "txt,d*,wk" )

Returns:
  TRUE, the file extension match with extension filter

  FALSE, in other case

Definition at line 1902 of file navigation.c.

Referenced by ushell_cmd_ls().

    01903 {
    01904    if ( fat_check_mount_select() )
    01905    {
    01906       // Read selected entry (=short name entry) in directory
    01907       if ( fat_read_dir())
    01908       {
    01909          // Check the extension with filter
    01910          if ( fat_entry_checkext( (FS_STRING) sz_filterext ) )
    01911             return TRUE;
    01912       }
    01913    }
    01914    return FALSE;
    01915 }

Here is the caller graph for this function:

Bool nav_file_dateget | ( | FS_STRING | sz_date,
|  | Bool | type_date |
| ) |  |  |

This function returns the date of selected file.

Parameters:

  | type_date | FS_DATE_LAST_WRITE, to get the date of last write access FS_DATE_CREATION, to get the date of file creation
  | sz_date | ASCCI string (>17B) to store the information about date "YYYYMMDDHHMMSSMS" = year, month, day, hour, minute, seconde, miliseconde

Returns:
  FALSE in case of error, see global value "fs_g_status" for more detail

  TRUE otherwise

Definition at line 1928 of file navigation.c.

    01929 {
    01930    if ( !fat_check_mount_select())
    01931       return FALSE;
    01932
    01933    // Read selected entry in directory
    01934    if ( !fat_read_dir())
    01935       return FALSE;
    01936    fat_get_date( sz_date , type_date );
    01937    return TRUE;
    01938 }

U8 nav_file_attributget | ( | void |  | ) |

This function returns the attribut of selected file.

Returns:
  attribut of selected file, see masks "FS_ATTR_" in fs_com.h file.

Definition at line 1945 of file navigation.c.

    01946 {
    01947    return fs_g_nav_entry.u8_attr;
    01948 }