NodeLoader.cc File Reference

#include "common_priv.h"
#include <cpn/bits/NodeLoader.h>
#include <cpn/NodeFactory.h>
#include <cpn/utils/ThrowingAssert.h>
#include <cpn/utils/PathUtils.h>
#include <cpn/utils/Directory.h>
#include <cpn/threading/PthreadMutex.h>
#include <fstream>
#include <stdexcept>
#include <ltdl.h>

Include dependency graph for NodeLoader.cc:

Go to the source code of this file.

Namespaces
	CPN

Functions
void	Loader (const std::string &ldfile, std::map< std::string, std::string > &data)
void	ProcessLine (vector< string > &stack, const string &curdir, map< string, string > &data, unsigned rep)
void	Loader (const string &ldfile, map< string, string > &data, unsigned rep)

Variables
static PthreadMutex	lock

Detailed Description

Author

John Bridgman

Definition in file NodeLoader.cc.

Function Documentation

void Loader	(	const std::string &	ldfile,
		std::map< std::string, std::string > &	data
	)

Definition at line 314 of file NodeLoader.cc.

Referenced by CPN::NodeLoader::LoadNodeList(), and ProcessLine().

                                                             {
    Loader(ldfile, data, 0);
}

Here is the caller graph for this function:

void Loader	(	const string &	ldfile,
		map< string, string > &	data,
		unsigned	rep
	)

Definition at line 198 of file NodeLoader.cc.

References ASSERT, DirName(), ProcessLine(), and RealPath().

                                                                           {
    ASSERT(rep < 100, "Loader include overflow");
    ifstream f;
    f.open(ldfile.c_str());
    ASSERT(f.is_open(), "Failed to open %s", ldfile.c_str());
    string curdir = DirName(RealPath(ldfile));
    vector<char> token_stack;
    vector<string> stack;
    bool in_comment = false;
    bool escape = false;
    bool in_single_quote = false;
    bool in_double_quote = false;
    while (f.good()) {
        int c = f.get();
        if (!f.good()) {
            break;
        }
        if (in_comment) {
            if (c == '\n' || c == '\r') {
                in_comment = false;
            } else {
                continue;
            }
        }
        if (in_single_quote) {
            if (c == '\'') {
                in_single_quote = false;
            } else {
                token_stack.push_back(c);
            }
        } else if (escape) {
            token_stack.push_back(c);
            escape = false;
        } else if (in_double_quote) {
            if (c == '"') {
                in_double_quote = false;
            } else {
                token_stack.push_back(c);
            }
        } else {
            switch (c) {
            case '#':
                in_comment = true;
                break;
            case '\'':
                in_single_quote = true;
                break;
            case '"':
                in_double_quote = true;
                break;
            case '\\':
                escape = true;
                break;
            case ';':
                if (!token_stack.empty()) {
                    stack.push_back(string(&token_stack[0], token_stack.size()));
                    token_stack.clear();
                }
                ProcessLine(stack, curdir, data, rep);
                break;
            case '\n':
            case '\r':
                // end of line
            case ' ':
            case '\t':
            case '\v':
            case '\f':
                // white space
                if (!token_stack.empty()) {
                    // end the current token, otherwise nothing
                    stack.push_back(string(&token_stack[0], token_stack.size()));
                    token_stack.clear();
                }
                break;
            default:
                token_stack.push_back(c);
                break;
            }
        }
    }
    ProcessLine(stack, curdir, data, rep);
}

Here is the call graph for this function:

void ProcessLine	(	vector< string > &	stack,
		const string &	curdir,
		map< string, string > &	data,
		unsigned	rep
	)

Definition at line 281 of file NodeLoader.cc.

References IsAbsPath(), Loader(), PathConcat(), and RealPath().

Referenced by Loader().

                                                 {
    if (stack.empty()) return;
    vector<string>::iterator itr = stack.begin();
    if (*itr == "lib") {
        ++itr;
        if (itr != stack.end()) {
            string libname = *itr;
            if (!IsAbsPath(libname)) {
                libname = RealPath(PathConcat(curdir, libname));
            }
            if (!libname.empty()) {
                ++itr;
                while (itr != stack.end()) {
                    data[*itr] = libname;
                    ++itr;
                }
            }
        }
    } else if (*itr == "include") {
        ++itr;
        while (itr != stack.end()) {
            string inc = *itr;
            if (!IsAbsPath(inc)) {
                inc = RealPath(PathConcat(curdir, inc));
            }
            Loader(inc, data, rep + 1);
            ++itr;
        }
    }
    stack.clear();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

PthreadMutex lock

static

Definition at line 36 of file NodeLoader.cc.

Referenced by CPN::QueueBase::Lock(), CPN::QueueBase::Unlock(), and CPN::QueueBase::Wait().