lestes::lang::cplus::lex::file_system Class Reference

File system binding. More...

#include <file_system.hh>

Inheritance diagram for lestes::lang::cplus::lex::file_system:

List of all members.

Public Types
enum	name_type {   NM_INVALID, NM_FILE_REL, NM_FILE_ABS, NM_PATH_REL,   NM_PATH_ABS }
	The type of name for classification. More...
Public Member Functions
ptr< named_istream >	open_file (const lstring &name)
	Opens a file stream, using only working directory.
ptr< named_istream >	find_file (const lstring &path, const lstring &name, bool system)
	Opens a file stream, searching given paths.
bool	add_search_path (const lstring &path)
	Adds search path.
Static Public Member Functions
static ptr< file_system >	create (void)
	Returns new instance.
static name_type	classify_name (const lstring &name)
	Classifies path and file name.
Protected Member Functions
	file_system (void)
	Creates the object.
virtual void	gc_mark (void)
	Marks the object.
Private Types
typedef ::lestes::std::vector< lstring >	lstrings_type
	Type of sequence of strings, used for search path list.
Private Member Functions
	file_system (const file_system &)
	Hides copy constructor.
file_system &	operator= (const file_system &)
	Hides assignment operator.
Static Private Member Functions
static ptr< lstrings_type >	split (const lstring &str, hchar delimiter)
	Splits string into parts.
Private Attributes
srp< lstrings_type >	search_paths
	System search paths.

---

Detailed Description

File system binding.

Provides acces to the file system. Enables opening file streams and include path search.

Definition at line 54 of file file_system.hh.

---

Member Typedef Documentation

typedef ::lestes::std::vector<lstring> lestes::lang::cplus::lex::file_system::lstrings_type [private]

Type of sequence of strings, used for search path list.

Definition at line 90 of file file_system.hh.

---

Member Enumeration Documentation

enum lestes::lang::cplus::lex::file_system::name_type

The type of name for classification.

Enumerator:

NM_INVALID	Invalid name.
NM_FILE_REL	Relative file name.
NM_FILE_ABS	Absolute file name.
NM_PATH_REL	Relative path.
NM_PATH_ABS	Absolute path.

Definition at line 57 of file file_system.hh.

                     {
                //! Invalid name.
                NM_INVALID,
                //! Relative file name.
                NM_FILE_REL,
                //! Absolute file name.
                NM_FILE_ABS,
                //! Relative path.
                NM_PATH_REL,
                //! Absolute path.
                NM_PATH_ABS
        } name_type;

---

Constructor & Destructor Documentation

lestes::lang::cplus::lex::file_system::file_system

(

void

)

[protected]

Creates the object.

Creates the object.

Definition at line 53 of file file_system.cc.

References search_paths.

Referenced by create().

                            :
        search_paths(lstrings_type::create())
{
        // an extra path starting from base
        search_paths->push_back(lstring(""));
}

lestes::lang::cplus::lex::file_system::file_system

(

const file_system &

)

[private]

Hides copy constructor.

---

Member Function Documentation

ptr< named_istream > lestes::lang::cplus::lex::file_system::open_file

(

const lstring &

name

)

Opens a file stream, using only working directory.

Opens a stream for the given file name or standard input. Relative file name is searched for in the working directory.

Parameters:

name

Absolute or relative file name, "" used for stdin.

Returns:

The opened stream or NULL for error (file not found or not accessible).

Definition at line 135 of file file_system.cc.

References classify_name(), lestes::lang::cplus::lex::named_istream::create(), NM_FILE_ABS, and NM_FILE_REL.

Referenced by find_file().

{
        if (name.length() == 0) {
                ptr<istream_wrapper> iw = istream_wrapper::create(&::std::cin,false);
                return named_istream::create(iw,"","<stdin>");
        }
        
        name_type nt = classify_name(name);
        
        if (nt != NM_FILE_REL && nt != NM_FILE_ABS)
                return NULL;
        
        fstream *f = new fstream();
        bool error = false;
        try {
                f->open(name.c_str(),ios_base::in);
                error = f->fail();
        } catch (...) {
                error = true;
        }

        if (error) {
                delete f;
                return NULL;
        }

        ptr<istream_wrapper> iw = istream_wrapper::create(f,true);
        
        return named_istream::create(iw,name,name);
}

ptr< named_istream > lestes::lang::cplus::lex::file_system::find_file	(	const lstring &	base_path,
		const lstring &	name,
		bool	system
	)

Opens a file stream, searching given paths.

Opens a stream for the given file name. Relative names are searched for in search paths if system is set to true, otherwise in the given path, and in the search paths in this order.

Parameters:

	base_path	Absolute or relative path for the search.
	name	Absolute or relative file name of the file to open.
	system	Flag set to true for system header.

Returns:

The opened stream or NULL for error (invalid name, file not found or not accessible).

Definition at line 197 of file file_system.cc.

References classify_name(), lestes::lang::cplus::lex::named_istream::create(), lassert, NM_FILE_ABS, NM_FILE_REL, NM_PATH_ABS, NM_PATH_REL, open_file(), and search_paths.

{
        name_type nt = classify_name(base_path);
        lassert(nt == NM_PATH_REL || nt == NM_PATH_ABS);
        
        nt = classify_name(name);
        
        if (nt == NM_FILE_ABS)
                return open_file(name);

        if (nt != NM_FILE_REL)
                return NULL;
        
        lstrings_type::iterator it = search_paths->begin(), end = search_paths->end();
        
        if (system) {
                // skip the placeholder
                ++it;
        } else {
                // extra entry to enable uniform processing
                (*search_paths)[0] = base_path;
        }
        
        fstream *f = new fstream();
        
        for ( ; it != end; ++it) {
                
                lstring full_name(*it);
                full_name.append(name);

                bool error = false;

                try {
                        f->open(full_name.c_str(),ios_base::in);
                        error = f->fail();
                } catch (...) {
                        error = true;
                }

                if (!error) {
                        ptr<istream_wrapper> iw = istream_wrapper::create(f,true);
                        return named_istream::create(iw,full_name,full_name);
                }
        }
        
        // the resource is not in use
        delete f;

        // failure
        return NULL;
}

bool lestes::lang::cplus::lex::file_system::add_search_path

(

const lstring &

a_path

)

Adds search path.

Adds search path for file searching.

Parameters:

a_path

A path to add.

Returns:

false If the path is invalid.

Definition at line 254 of file file_system.cc.

References classify_name(), lassert2, NM_FILE_ABS, NM_FILE_REL, NM_INVALID, NM_PATH_ABS, NM_PATH_REL, and search_paths.

{
        name_type nt = classify_name(a_path);
        lstring path(a_path); 
        
        switch (nt) {
                case NM_INVALID:
                        return false;
                case NM_FILE_REL:
                case NM_FILE_ABS:
                        path.append("/");
                        // fall through
                case NM_PATH_REL:
                case NM_PATH_ABS:
                        search_paths->push_back(path);
                        break;
                default:
                        lassert2(false,"You should never get here");
        }
        return true;
}

ptr< file_system > lestes::lang::cplus::lex::file_system::create

(

void

)

[static]

Returns new instance.

Returns new instance.

Returns:

The new instance.

Definition at line 289 of file file_system.cc.

References file_system().

Referenced by lestes::lang::cplus::syn::do_it().

{
        return new file_system();
}

file_system::name_type lestes::lang::cplus::lex::file_system::classify_name

(

const lstring &

name

)

[static]

Classifies path and file name.

Classifies the name according to its properties. Distinguishes relative and absolute path and file names.

Parameters:

str

The string to classify.

Returns:

The kind of name represented by the string.

Definition at line 106 of file file_system.cc.

References NM_FILE_ABS, NM_FILE_REL, NM_INVALID, NM_PATH_ABS, NM_PATH_REL, and split().

Referenced by add_search_path(), find_file(), and open_file().

{
        ptr<lstrings_type> parts = split(name,'/');
        ulint len = parts->size();
        
        if (!len) return NM_PATH_REL;

        bool absolute = parts->at(0).length() == 0;
        bool pathname = parts->at(len - 1).length() == 0;
        
        // check nonempty directory names
        for (ulint i = 1; i < len - 1; i++) {
                if (parts->at(i).length() == 0)
                        return NM_INVALID;
        }

        if (absolute) {
                return pathname ? NM_PATH_ABS : NM_FILE_ABS;
        }
          
        return pathname ? NM_PATH_REL : NM_FILE_REL;
}

void lestes::lang::cplus::lex::file_system::gc_mark

(

void

)

[protected, virtual]

Marks the object.

Marks the object.

Reimplemented from lestes::std::mem::keystone.

Definition at line 279 of file file_system.cc.

References lestes::std::mem::keystone::gc_mark(), and search_paths.

{
        search_paths.gc_mark();
	::lestes::std::object::gc_mark();
}

ptr< file_system::lstrings_type > lestes::lang::cplus::lex::file_system::split	(	const lstring &	str,
		hchar	delimiter
	)			[static, private]

Splits string into parts.

Splits string into sequence of parts separated by delimiter. If delimiter is found at the beginning, or at the end of the string, or two delimiters are adjacent, an empty string is added to the appropriate place. So empty string results in empty sequence, while string containing sole delimiter results in sequence containing two empty strings.

Parameters:

	str	The string to split.
	delimiter	The delimiter to separate the parts.

Returns:

The sequence of parts, in the original order, without the delimiters.

Definition at line 70 of file file_system.cc.

References lestes::std::vector< T >::create().

Referenced by classify_name().

{
        ptr< lstrings_type > v = lstrings_type::create();
        
        lstring::size_type len = str.length();
        
        // no data means no output
        if (!len) return v;
        
        lstring::size_type i, j;

        i = 0;
        
        // the condition is set so that find is called even after
        // the delimiter was found at the end of the string
        while (i <= len) {
                j = str.find(delimiter,i);
                if (j == lstring::npos)
                        // pretend delimiter just after the end
                        j = len;

                // the part starts at i and ends at j - 1
                v->push_back(str.substr(i,j-i));
                // skip the delimiter
                i = j + 1;
        }

        return v;
}

file_system& lestes::lang::cplus::lex::file_system::operator=

(

const file_system &

)

[private]

Hides assignment operator.

---

Member Data Documentation

srp<lstrings_type> lestes::lang::cplus::lex::file_system::search_paths [private]

System search paths.

Definition at line 94 of file file_system.hh.

Referenced by add_search_path(), file_system(), find_file(), and gc_mark().

---

The documentation for this class was generated from the following files:

• file_system.hh
• file_system.cc

---