/* * Copyright (c) 2003-2009, John Wiegley. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are * met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * - Neither the name of New Artisans LLC nor the names of its * contributors may be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include // Read this file for a top-level overview #include "work.h" // This is where the meat of main() is, which // was moved there for the sake of clarity using namespace ledger; namespace { class global_scope_t : public noncopyable, public scope_t { scoped_ptr session_ptr; ptr_list report_stack; public: path script_file; global_scope_t() { session_ptr.reset(new LEDGER_SESSION_T); set_session_context(session_ptr.get()); // Create the report object, which maintains state relating to each // command invocation. Because we're running from main(), the // distinction between session and report doesn't really matter, but if // a GUI were calling into Ledger it would have one session object per // open document, with a separate report_t object for each report it // generated. report_stack.push_front(new report_t(*session_ptr.get())); } ~global_scope_t() { // If memory verification is being performed (which can be very slow), // clean up everything by closing the session and deleting the session // object, and then shutting down the memory tracing subsystem. // Otherwise, let it all leak because we're about to exit anyway. IF_VERIFY() { set_session_context(NULL); INFO("Ledger ended (Boost/libstdc++ may still hold memory)"); shutdown_memory_tracing(); } else { // Don't free anything, just let it all leak. INFO("Ledger ended"); } } char * prompt_string() { static char prompt[32]; std::size_t i; for (i = 0; i < report_stack.size(); i++) prompt[i] = ']'; prompt[i++] = ' '; prompt[i] = '\0'; return prompt; } session_t& session() { return *session_ptr.get(); } report_t& report() { return report_stack.front(); } void push_report() { report_stack.push_front(new report_t(report_stack.front())); } void pop_report() { if (! report_stack.empty()) report_stack.pop_front(); } value_t push_report_cmd(call_scope_t&) { // Make a copy at position 2, because the topmost report object has an // open output stream at this point. We want it to get popped off as // soon as this command terminate so that the stream is closed cleanly. report_stack.insert(++report_stack.begin(), new report_t(report_stack.front())); return true; } value_t pop_report_cmd(call_scope_t&) { pop_report(); return true; } value_t option_script_(call_scope_t& args) { script_file = args[0].as_string(); return true; } value_t ignore(call_scope_t&) { return true; } virtual expr_t::ptr_op_t lookup(const string& name) { const char * p = name.c_str(); switch (*p) { case 'l': if (std::strncmp(p, "ledger_precmd_", 14) == 0) { p = p + 14; switch (*p) { case 'p': if (std::strcmp(p, "push") == 0) return MAKE_FUNCTOR(global_scope_t::push_report_cmd); else if (std::strcmp(p, "pop") == 0) return MAKE_FUNCTOR(global_scope_t::pop_report_cmd); break; } } break; case 'o': if (std::strncmp(p, "opt_", 4) == 0) { p = p + 4; switch (*p) { case 'd': if (std::strcmp(p, "debug_") == 0) return MAKE_FUNCTOR(global_scope_t::ignore); break; case 's': if (std::strcmp(p, "script_") == 0) return MAKE_FUNCTOR(global_scope_t::option_script_); break; case 't': if (std::strcmp(p, "trace_") == 0) return MAKE_FUNCTOR(global_scope_t::ignore); break; case 'v': if (! *(p + 1) || std::strcmp(p, "verbose") == 0) return MAKE_FUNCTOR(global_scope_t::ignore); else if (std::strcmp(p, "verify") == 0) return MAKE_FUNCTOR(global_scope_t::ignore); break; } } } // If you're wondering how symbols from report() will be found, it's // because of the bind_scope_t object in execute_command() below. return expr_t::ptr_op_t(); } }; strings_list split_arguments(char * line) { strings_list args; // jww (2009-02-04): This is too naive for (char * p = std::strtok(line, " \t"); p; p = std::strtok(NULL, " \t")) args.push_back(p); return args; } void report_error(const std::exception& err) { std::cout.flush(); // first display anything that was pending if (caught_signal == NONE_CAUGHT) { // Display any pending error context information string context = error_context(); if (! context.empty()) std::cerr << context << std::endl; std::cerr << "Error: " << err.what() << std::endl; } else { caught_signal = NONE_CAUGHT; } } /** * @return \c true if a command was actually executed; otherwise, it probably * just resulted in setting some options. */ void execute_command(global_scope_t& global_scope, strings_list args, bool at_repl) { // Process the command verb, arguments and options args = read_command_arguments(global_scope.report(), args); if (args.empty()) return; string_iterator arg = args.begin(); string verb = *arg++; // Look for a precommand first, which is defined as any defined function // whose name starts with "ledger_precmd_". The difference between a // precommand and a regular command is that precommands ignore the journal // data file completely, nor is the user's init file read. // // Here are some examples of pre-commands: // // parse STRING ; show how a value expression is parsed // eval STRING ; simply evaluate a value expression // format STRING ; show how a format string is parsed // // If such a command is found, create the output stream for the result and // then invoke the command. function_t command; bool is_precommand = false; bind_scope_t bound_scope(global_scope, global_scope.report()); if (bool(command = look_for_precommand(bound_scope, verb))) is_precommand = true; else if (! bool(command = look_for_command(bound_scope, verb))) throw_(std::logic_error, "Unrecognized command '" << verb << "'"); // If it is not a pre-command, then parse the user's ledger data at this // time if not done alreday (i.e., if not at a REPL). Then patch up the // report options based on the command verb. if (! is_precommand) { if (! at_repl) read_journal_files(global_scope.session(), global_scope.report().account); // jww (2009-02-02): This is a complete hack, and a leftover from long, // long ago. The question is, how best to remove its necessity... normalize_report_options(global_scope.report(), verb); } // Create the output stream (it might be a file, the console or a PAGER // subprocess) and invoke the report command. The output stream is closed // by the caller of this function. global_scope.report() .output_stream.initialize(global_scope.report().output_file, global_scope.session().pager_path); // Create an argument scope containing the report command's arguments, and // then invoke the command. The bound scope causes lookups to happen // first in the global scope, and then in the report scope. call_scope_t command_args(bound_scope); for (string_iterator i = arg; i != args.end(); i++) command_args.push_back(string_value(*i)); INFO_START(command, "Finished executing command"); command(command_args); INFO_FINISH(command); } int execute_command_wrapper(global_scope_t& global_scope, strings_list args, bool at_repl) { int status = 1; try { global_scope.push_report(); execute_command(global_scope, args, at_repl); global_scope.pop_report(); // If we've reached this point, everything succeeded fine. Ledger uses // exceptions to notify of error conditions, so if you're using gdb, // just type "catch throw" to find the source point of any error. status = 0; } catch (const std::exception& err) { global_scope.pop_report(); report_error(err); } return status; } } int main(int argc, char * argv[], char * envp[]) { int status; // The very first thing we do is handle some very special command-line // options, since they affect how the environment is setup: // // --verify ; turns on memory tracing // --verbose ; turns on logging // --debug CATEGORY ; turns on debug logging // --trace LEVEL ; turns on trace logging handle_debug_options(argc, argv); IF_VERIFY() initialize_memory_tracing(); INFO("Ledger starting"); // Initialize global Boost/C++ environment std::ios::sync_with_stdio(false); filesystem::path::default_name_check(filesystem::portable_posix_name); std::signal(SIGINT, sigint_handler); std::signal(SIGPIPE, sigpipe_handler); // Create the session object, which maintains nearly all state relating to // this invocation of Ledger; and register all known journal parsers. std::auto_ptr global_scope(new global_scope_t); try { // Read the user's options, in the following order: // // 1. environment variables (LEDGER_