1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
/*
* 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 <ledger.h> // 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
int main(int argc, char * argv[], char * envp[])
{
using namespace ledger;
session_t * session = NULL;
report_t * report = NULL;
int status = 1;
try {
// 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);
// Create the session object, which maintains nearly all state relating to
// this invocation of Ledger; and register all known journal parsers.
session = new LEDGER_SESSION_T;
set_session_context(session);
// 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 = new report_t(*session);
session->global_scope = report;
// Read the user's options, in the following order:
//
// 1. environment variables (LEDGER_<option>)
// 2. initialization file (~/.ledgerrc)
// 3. command-line (--option or -o)
//
// Before processing command-line options, we must notify the session
// object that such options are beginning, since options like -f cause a
// complete override of files found anywhere else.
read_environment_settings(*report, envp);
session->read_init();
session->now_at_command_line(true);
strings_list args = read_command_line_arguments(*report, argc, argv);
// 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.
string_iterator arg = args.begin();
string verb = *arg++;
if (function_t command = look_for_precommand(*report, verb)) {
// Create the output stream (it might be a file, the console or a PAGER
// subprocess) and invoke the report command.
create_output_stream(*report);
invoke_command_verb(*report, command, arg, args.end());
}
else if (function_t command = look_for_command(*report, verb)) {
// This is regular command verb, so parse the user's data.
if (journal_t * journal = read_journal_files(*session, report->account)) {
normalize_report_options(*report, verb); // jww (2009-02-02): a hack
// Create the output stream (it might be a file, the console or a
// PAGER subprocess) and invoke the report command.
create_output_stream(*report);
invoke_command_verb(*report, command, arg, args.end());
// Write out a binary cache of the journal data, if needful and
// appropriate to do so.
write_binary_cache(*session, journal);
}
}
else {
throw_(std::logic_error, "Unrecognized command '" << verb << "'");
}
// 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) {
std::cout.flush(); // first display anything that was pending
// 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;
}
catch (int _status) {
status = _status; // used for a "quick" exit, and is used only
// if help text (such as --help) was displayed
}
// Close the output stream, waiting on the pager process to exit if need be
report->output_stream.close();
// 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);
if (session != NULL)
checked_delete(session);
if (report != NULL)
checked_delete(report);
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");
}
// Return the final status to the operating system, either 1 for error or 0
// for a successful completion.
return status;
}
// main.cc ends here.
|
