mirror of
https://github.com/KingDuckZ/kamokan.git
synced 2024-11-27 00:43:47 +00:00
594 lines
20 KiB
C++
594 lines
20 KiB
C++
/*
|
|
* Copyright (C) 1999-2009 Lorenzo Bettini <http://www.lorenzobettini.it>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
|
|
// this is glib related so don't use it when compiling with qmake
|
|
#include "progname.h"
|
|
|
|
#else
|
|
|
|
#define set_program_name(x) ;
|
|
|
|
#endif
|
|
|
|
#include <cstdlib>
|
|
#include <iostream>
|
|
#include <exception>
|
|
#include <boost/shared_ptr.hpp>
|
|
|
|
#include "srchilite/sourcehighlight.h"
|
|
|
|
#include "srchilite/fileutil.h"
|
|
#include "srchilite/verbosity.h"
|
|
#include "srchilite/langmap.h"
|
|
#include "srchilite/languageinfer.h"
|
|
#include "srchilite/utils.h"
|
|
#include "srchilite/highlightbuilderexception.h"
|
|
#include "srchilite/parserexception.h"
|
|
#include "srchilite/debuglistener.h"
|
|
#include "srchilite/ctagsmanager.h"
|
|
#include "srchilite/stopwatch.h"
|
|
#include "srchilite/lineranges.h"
|
|
#include "srchilite/regexranges.h"
|
|
#include "srchilite/versions.h"
|
|
#include "srchilite/settings.h"
|
|
|
|
#include "cmdline.h"
|
|
|
|
using namespace std;
|
|
using namespace srchilite;
|
|
|
|
/**
|
|
* how language inference should be made: NOINFERENCE = no inference at all,
|
|
* INFERFIRST = inference has priority (e.g., if --infer-lang is specified),
|
|
* INFERATLAST = try inference as the last chance
|
|
*/
|
|
enum InferPolicy {
|
|
NOINFERENCE = 0, INFERFIRST, INFERATLAST
|
|
};
|
|
|
|
static void print_copyright();
|
|
static void print_reportbugs();
|
|
static void print_version();
|
|
static string inferLang(const string &inputFileName);
|
|
static string getMappedLang(const string &s, LangMap &langmap);
|
|
static void printError(const string &s);
|
|
static void print_cgi_header();
|
|
|
|
/**
|
|
* Exits for a generic error (i.e., file not found)
|
|
*/
|
|
static void exitError(const string &s);
|
|
|
|
static string getLangFileName(InferPolicy infer, const string &inputFileName,
|
|
const string &langFileName, const string &langName, LangMap &langMap);
|
|
|
|
static bool verbose = false;
|
|
static bool failsafe = false;
|
|
|
|
#ifdef BUILD_AS_CGI
|
|
#include "envmapper.h"
|
|
#endif // BUILD_AS_CGI
|
|
/**
|
|
* Print progress status information (provided --quiet is not specified)
|
|
* @param message
|
|
*/
|
|
#define PROGRESSINFO(message) if (!args_info.quiet_given) cerr << message;
|
|
|
|
int main(int argc, char * argv[]) {
|
|
set_program_name(argv[0]);
|
|
gengetopt_args_info args_info; // command line structure
|
|
bool is_cgi = false;
|
|
|
|
#ifdef BUILD_AS_CGI
|
|
// map environment to parameters if used as CGI
|
|
char **temp_argv;
|
|
temp_argv = map_environment(&argc, argv);
|
|
is_cgi = temp_argv != argv;
|
|
argv = temp_argv;
|
|
#endif // BUILD_AS_CGI
|
|
if (cmdline_parser(argc, argv, &args_info) != 0) {
|
|
// calls cmdline parser. The user gived bag args if it doesn't return -1
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
if (args_info.version_given) {
|
|
print_version();
|
|
print_copyright();
|
|
cmdline_parser_free(&args_info);
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
if (args_info.help_given || args_info.detailed_help_given) {
|
|
cout << "GNU ";
|
|
if (args_info.detailed_help_given) {
|
|
cmdline_parser_print_detailed_help();
|
|
} else {
|
|
cmdline_parser_print_help();
|
|
}
|
|
print_reportbugs();
|
|
cmdline_parser_free(&args_info);
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
// set possible line ranges
|
|
boost::shared_ptr<LineRanges> lineRanges;
|
|
if (args_info.line_range_given) {
|
|
lineRanges = boost::shared_ptr<LineRanges>(new LineRanges);
|
|
for (unsigned int i = 0; i < args_info.line_range_given; ++i) {
|
|
if (lineRanges->addRange(args_info.line_range_arg[i]) != NO_ERROR) {
|
|
string invalid_range = args_info.line_range_arg[i];
|
|
cmdline_parser_free(&args_info);
|
|
exitError("invalid line range: " + invalid_range);
|
|
}
|
|
}
|
|
}
|
|
|
|
// set possible regex ranges
|
|
boost::shared_ptr<RegexRanges> regexRanges;
|
|
if (args_info.regex_range_given) {
|
|
regexRanges = boost::shared_ptr<RegexRanges>(new RegexRanges);
|
|
for (unsigned int i = 0; i < args_info.regex_range_given; ++i) {
|
|
if (!regexRanges->addRegexRange(args_info.regex_range_arg[i])) {
|
|
string invalid_range = args_info.regex_range_arg[i];
|
|
cmdline_parser_free(&args_info);
|
|
exitError("invalid regex range: " + invalid_range);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (args_info.range_context_given) {
|
|
lineRanges->setContextLines(args_info.range_context_arg);
|
|
}
|
|
|
|
// if a stopwatch is created, when it is deleted (automatically
|
|
// since we're using a shared pointer, it will print the
|
|
// elapsed seconds.
|
|
boost::shared_ptr<StopWatch> stopwatch;
|
|
if (args_info.statistics_given) {
|
|
stopwatch = boost::shared_ptr<StopWatch>(new StopWatch);
|
|
}
|
|
|
|
verbose = args_info.verbose_given;
|
|
failsafe = args_info.failsafe_given;
|
|
|
|
string inputFile;
|
|
string outputFile;
|
|
string srcLang;
|
|
string outputFormat;
|
|
string langFile;
|
|
string outLangFile;
|
|
string dataDir;
|
|
string outputDir;
|
|
|
|
Verbosity::setVerbosity(verbose);
|
|
|
|
if (args_info.input_given)
|
|
inputFile = args_info.input_arg;
|
|
|
|
if (args_info.output_given)
|
|
outputFile = args_info.output_arg;
|
|
|
|
// for cgi force output to standard output
|
|
if (is_cgi)
|
|
outputFile = "STDOUT";
|
|
|
|
if (args_info.src_lang_given)
|
|
srcLang = args_info.src_lang_arg;
|
|
|
|
if (args_info.lang_def_given)
|
|
langFile = args_info.lang_def_arg;
|
|
|
|
if (args_info.outlang_def_given)
|
|
outLangFile = args_info.outlang_def_arg;
|
|
|
|
// the default for output format is html
|
|
outputFormat = args_info.out_format_arg;
|
|
|
|
if (args_info.data_dir_given) {
|
|
dataDir = args_info.data_dir_arg;
|
|
}
|
|
|
|
if (args_info.output_dir_given) {
|
|
outputDir = args_info.output_dir_arg;
|
|
}
|
|
|
|
/*
|
|
the starting default path to search for files is computed at
|
|
run-time: it is
|
|
the path of the binary + ".." + RELATIVEDATADIR
|
|
this should make the package relocable (i.e., not stuck
|
|
with a fixed installation directory).
|
|
Of course, the GNU standards for installation directories
|
|
should be followed, but this is not a problem if you use
|
|
configure and make install features.
|
|
If no path is specified in the running program we go back to
|
|
the absolute datadir.
|
|
*/
|
|
// this is defined in fileutil.cc
|
|
string prefix_dir = get_file_path(argv[0]);
|
|
if (prefix_dir.size())
|
|
start_path = get_file_path(argv[0]) + RELATIVEDATADIR;
|
|
else
|
|
start_path = Settings::retrieveDataDir();
|
|
|
|
// if datadir is not specified, we rely on start_path?
|
|
|
|
try {
|
|
// initialize map files
|
|
LangMap langmap(dataDir, args_info.lang_map_arg);
|
|
|
|
// just print the input language list and associations
|
|
if (args_info.lang_list_given) {
|
|
langmap.open();
|
|
langmap.print();
|
|
return (EXIT_SUCCESS);
|
|
}
|
|
|
|
LangMap outlangmap(dataDir, args_info.outlang_map_arg);
|
|
|
|
// just print the input language list and associations
|
|
if (args_info.outlang_list_given) {
|
|
outlangmap.open();
|
|
outlangmap.print();
|
|
return (EXIT_SUCCESS);
|
|
}
|
|
|
|
string cssUrl;
|
|
if (args_info.css_given)
|
|
cssUrl = args_info.css_arg;
|
|
|
|
string docTitle;
|
|
if (args_info.title_given)
|
|
docTitle = args_info.title_arg;
|
|
|
|
if (args_info.check_lang_given || args_info.check_outlang_given
|
|
|| args_info.show_regex_given
|
|
|| args_info.show_lang_elements_given
|
|
|| args_info.lang_list_given || args_info.outlang_list_given) {
|
|
// FIXME just a bogus outlang file specification not to search in outlang.map
|
|
outLangFile = "html.outlang";
|
|
}
|
|
|
|
// initialize the main source highlight object
|
|
SourceHighlight sourcehighlight(getLangFileName(NOINFERENCE,
|
|
outputFile, outLangFile, outputFormat
|
|
+ (cssUrl.size() ? +"-css" : ""), outlangmap));
|
|
|
|
// and sets all its properties according to the command line args
|
|
sourcehighlight.setDataDir(dataDir);
|
|
|
|
boost::shared_ptr<DebugListener> debugListener;
|
|
|
|
// if a simple check is required...
|
|
if (args_info.check_lang_given) {
|
|
cout << "checking " << args_info.check_lang_arg << "... ";
|
|
sourcehighlight.checkLangDef(args_info.check_lang_arg);
|
|
// if we're here, everything went fine!
|
|
cout << "OK" << endl;
|
|
// otherwise an exception has already been thrown
|
|
return (EXIT_SUCCESS);
|
|
}
|
|
|
|
if (args_info.check_outlang_given) {
|
|
cout << "checking " << args_info.check_outlang_arg << "... ";
|
|
sourcehighlight.checkOutLangDef(args_info.check_outlang_arg);
|
|
// if we're here, everything went fine!
|
|
cout << "OK" << endl;
|
|
// otherwise an exception has already been thrown
|
|
return (EXIT_SUCCESS);
|
|
}
|
|
|
|
// just print the highlightstate if show-regex is specified
|
|
if (args_info.show_regex_given) {
|
|
sourcehighlight.printHighlightState(args_info.show_regex_arg, cout);
|
|
return (EXIT_SUCCESS);
|
|
}
|
|
|
|
// just print the lang elems if show-lang-elements is specified
|
|
if (args_info.show_lang_elements_given) {
|
|
sourcehighlight.printLangElems(args_info.show_lang_elements_arg,
|
|
cout);
|
|
return (EXIT_SUCCESS);
|
|
}
|
|
|
|
sourcehighlight.setGenerateEntireDoc((!args_info.no_doc_given)
|
|
&& (args_info.doc_given || (docTitle.size()) || cssUrl.size()));
|
|
sourcehighlight.setStyleDefaultFile(args_info.style_defaults_arg);
|
|
sourcehighlight.setStyleFile(args_info.style_file_arg);
|
|
if (args_info.style_css_file_given)
|
|
sourcehighlight.setStyleCssFile(args_info.style_css_file_arg);
|
|
sourcehighlight.setGenerateVersion(args_info.gen_version_flag != 0);
|
|
sourcehighlight.setCss(cssUrl);
|
|
sourcehighlight.setTitle(docTitle);
|
|
sourcehighlight.setOutputDir(outputDir);
|
|
sourcehighlight.setLineRanges(lineRanges.get());
|
|
sourcehighlight.setRegexRanges(regexRanges.get());
|
|
sourcehighlight.setBinaryOutput(args_info.binary_output_given);
|
|
|
|
if (args_info.debug_langdef_given) {
|
|
debugListener = boost::shared_ptr<DebugListener>(new DebugListener);
|
|
const string debugType = args_info.debug_langdef_arg;
|
|
if (debugType == "interactive")
|
|
debugListener->setInteractive(true);
|
|
sourcehighlight.setHighlightEventListener(debugListener.get());
|
|
// during debugging disable optimizations
|
|
sourcehighlight.setOptimize(false);
|
|
}
|
|
|
|
int tabs = 0;
|
|
if (args_info.tab_given) {
|
|
tabs = args_info.tab_arg;
|
|
}
|
|
|
|
if (args_info.header_given)
|
|
sourcehighlight.setHeaderFileName(args_info.header_arg);
|
|
|
|
if (args_info.footer_given)
|
|
sourcehighlight.setFooterFileName(args_info.footer_arg);
|
|
|
|
bool generateLineNumbers = args_info.line_number_given
|
|
|| args_info.line_number_ref_given;
|
|
sourcehighlight.setGenerateLineNumbers(generateLineNumbers);
|
|
|
|
if (args_info.line_number_given) {
|
|
// set the line number padding char (default is always '0')
|
|
sourcehighlight.setLineNumberPad(args_info.line_number_arg[0]);
|
|
}
|
|
|
|
if (args_info.line_number_ref_given) {
|
|
sourcehighlight.setGenerateLineNumberRefs(true);
|
|
sourcehighlight.setLineNumberAnchorPrefix(
|
|
args_info.line_number_ref_arg);
|
|
}
|
|
|
|
if (generateLineNumbers) {
|
|
// when generating line numbers tabs must be translated
|
|
// otherwise the output line will not be aligned
|
|
// due to the presence of line numbers
|
|
sourcehighlight.setTabSpaces(tabs ? tabs : 8);
|
|
}
|
|
|
|
if (tabs) {
|
|
sourcehighlight.setTabSpaces(tabs);
|
|
}
|
|
|
|
// whether to give precedence to language inference
|
|
InferPolicy inferPolicy = (args_info.infer_lang_given ? INFERFIRST
|
|
: INFERATLAST);
|
|
|
|
RefPosition refposition = INLINE;
|
|
string gen_references_arg = args_info.gen_references_arg;
|
|
if (gen_references_arg == "inline")
|
|
refposition = INLINE;
|
|
else if (gen_references_arg == "postline")
|
|
refposition = POSTLINE;
|
|
else if (gen_references_arg == "postdoc")
|
|
refposition = POSTDOC;
|
|
|
|
boost::shared_ptr<CTagsManager> ctagsManager;
|
|
if (args_info.gen_references_given) {
|
|
string ctags = args_info.ctags_arg;
|
|
string ctags_file = args_info.ctags_file_arg;
|
|
|
|
// build the additional arguments for the ctags command
|
|
if (args_info.gen_references_given && ctags != "") {
|
|
if (inputFile.size()) {
|
|
ctags += " ";
|
|
ctags += inputFile;
|
|
} else if (args_info.inputs_num) {
|
|
for (unsigned int i = 0; i < (args_info.inputs_num); ++i) {
|
|
ctags += " ";
|
|
ctags += args_info.inputs[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
// the ctags command must be executed if --ctags is specified with an empty string
|
|
ctagsManager = boost::shared_ptr<CTagsManager>(new CTagsManager(
|
|
ctags_file, ctags, ctags != "", refposition));
|
|
sourcehighlight.setCTagsManager(ctagsManager.get());
|
|
}
|
|
|
|
if (args_info.range_separator_given) {
|
|
sourcehighlight.setRangeSeparator(args_info.range_separator_arg);
|
|
}
|
|
|
|
// OK, let's highlight!
|
|
|
|
if (args_info.inputs_num && (args_info.input_given
|
|
|| args_info.output_given)) {
|
|
// do not mix command line invocation modes
|
|
cerr << "Please, use one of the two syntaxes for invocation: "
|
|
<< endl;
|
|
cerr
|
|
<< "source-highlight [OPTIONS]... -i input_file -o output_file"
|
|
<< endl;
|
|
cerr << "source-highlight [OPTIONS]... [FILES]..." << endl;
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
// for cgi we can only process one file specified with --input
|
|
if (args_info.inputs_num && !is_cgi) {
|
|
// the output file name is empty, but we don't want to generate to stdout
|
|
sourcehighlight.setCanUseStdOut(false);
|
|
// in case multiple input files were specified (without --input)
|
|
for (unsigned int i = 0; i < (args_info.inputs_num); ++i) {
|
|
PROGRESSINFO(string("Processing ")+ args_info.inputs[i] + " ... ");
|
|
sourcehighlight.highlight(args_info.inputs[i], "",
|
|
getLangFileName(inferPolicy, args_info.inputs[i],
|
|
langFile, srcLang, langmap));
|
|
PROGRESSINFO("created " + sourcehighlight.createOutputFileName(args_info.inputs[i]) + "\n");
|
|
}
|
|
} else {
|
|
if (is_cgi)
|
|
print_cgi_header();
|
|
|
|
// in case only one input file was specified with --input
|
|
sourcehighlight.highlight(inputFile, outputFile, getLangFileName(
|
|
inferPolicy, inputFile, langFile, srcLang, langmap));
|
|
}
|
|
} catch (const HighlightBuilderException &e) {
|
|
cerr << e << endl;
|
|
exit(EXIT_FAILURE);
|
|
} catch (const ParserException &e) {
|
|
cerr << e << endl;
|
|
exit(EXIT_FAILURE);
|
|
} catch (const exception &e) {
|
|
exitError(e.what());
|
|
}
|
|
|
|
cmdline_parser_free(&args_info);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void print_copyright() {
|
|
int i;
|
|
int copyright_text_length = 5;
|
|
const char *copyright_text[] = {
|
|
"copyright.text",
|
|
"Copyright (C) 1999-2008 Lorenzo Bettini <http://www.lorenzobettini.it>",
|
|
"This program comes with ABSOLUTELY NO WARRANTY.",
|
|
"This is free software; you may redistribute copies of the program",
|
|
"under the terms of the GNU General Public License.",
|
|
"For more information about these matters, see the file named COPYING.",
|
|
0 };
|
|
|
|
for (i = 1; i <= copyright_text_length; ++i)
|
|
cout << copyright_text[i] << endl;;
|
|
}
|
|
|
|
void print_reportbugs() {
|
|
int i;
|
|
int reportbugs_text_length = 3;
|
|
const char *reportbugs_text[] = {
|
|
"reportbugs.text",
|
|
"",
|
|
"Maintained by Lorenzo Bettini <http://www.lorenzobettini.it>",
|
|
"Report bugs to <bug-source-highlight at gnu.org>",
|
|
0 };
|
|
|
|
for (i = 1; i <= reportbugs_text_length; ++i)
|
|
cout << reportbugs_text[i] << endl;
|
|
}
|
|
|
|
void print_version() {
|
|
cout << Versions::getCompleteVersion() << endl;
|
|
}
|
|
|
|
string inferLang(const string &inputFileName) {
|
|
VERBOSELN("inferring input language...");
|
|
if (!inputFileName.size()) {
|
|
printError("missing feature: language inference requires input file");
|
|
return "";
|
|
}
|
|
|
|
LanguageInfer languageInfer;
|
|
|
|
const string &result = languageInfer.infer(inputFileName);
|
|
if (result.size()) {
|
|
VERBOSELN("inferred input language: " + result);
|
|
} else {
|
|
VERBOSELN("couldn't infer input language");
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
string getMappedLang(const string &s, LangMap &langmap) {
|
|
// OK now map it into a .lang file
|
|
string mapped_lang = langmap.getMappedFileName(s);
|
|
|
|
if (!mapped_lang.size()) {
|
|
// try the lower version
|
|
mapped_lang = langmap.getFileName(Utils::tolower(s));
|
|
}
|
|
|
|
return mapped_lang;
|
|
}
|
|
|
|
string getLangFileName(InferPolicy infer, const string &inputFileName,
|
|
const string &langFileName, const string &langName, LangMap &langMap) {
|
|
string langFile;
|
|
|
|
// language inference has the precedence
|
|
if (infer == INFERFIRST) {
|
|
langFile = inferLang(inputFileName);
|
|
langFile = getMappedLang(langFile, langMap);
|
|
if (langFile.size())
|
|
return langFile;
|
|
}
|
|
|
|
// then if a lang file name was specified we're done
|
|
if (langFileName.size())
|
|
return langFileName;
|
|
|
|
// now try with the langName
|
|
langFile = getMappedLang(langName, langMap);
|
|
if (langFile.size())
|
|
return langFile;
|
|
|
|
// otherwise try with the inputFileName (its file extension
|
|
// and its name)
|
|
langFile = langMap.getMappedFileNameFromFileName(inputFileName);
|
|
if (langFile.size())
|
|
return langFile;
|
|
|
|
// OK, as a last chance let's try with language infer
|
|
if (infer == INFERATLAST) {
|
|
langFile = getMappedLang(inferLang(inputFileName), langMap);
|
|
if (langFile.size())
|
|
return langFile;
|
|
}
|
|
|
|
// if we're here we failed all checks
|
|
// if failsafe is specified we default to default.lang
|
|
if (failsafe)
|
|
langFile = "default.lang";
|
|
|
|
if (!langFile.size()) {
|
|
// if we're here we must exit with failure
|
|
if (langName.size())
|
|
exitError("could not find a language definition for " + langName);
|
|
else
|
|
exitError("could not find a language definition for input file "
|
|
+ inputFileName);
|
|
}
|
|
|
|
return langFile;
|
|
}
|
|
|
|
void printError(const string &s) {
|
|
cerr << PACKAGE << ": " << s << endl;
|
|
}
|
|
|
|
void exitError(const string &s) {
|
|
printError(s);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
void print_cgi_header() {
|
|
cout << "Content-type: text/html\n";
|
|
cout << "\n";
|
|
}
|
|
|
|
|