2016-04-21 14:00:54 +08:00
|
|
|
// The fish_indent program.
|
2007-04-22 18:03:12 +08:00
|
|
|
/*
|
2014-12-24 07:29:42 +08:00
|
|
|
Copyright (C) 2014 ridiculous_fish
|
2007-04-22 18:03:12 +08:00
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License version 2 as
|
|
|
|
published by the Free Software Foundation.
|
|
|
|
|
|
|
|
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
|
2013-12-14 04:51:52 +08:00
|
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
2007-04-22 18:03:12 +08:00
|
|
|
*/
|
2016-03-04 07:36:17 +08:00
|
|
|
#include <getopt.h>
|
2007-04-22 18:03:12 +08:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <wchar.h>
|
2014-12-24 07:29:42 +08:00
|
|
|
#include <vector>
|
2015-07-25 23:14:25 +08:00
|
|
|
#include <assert.h>
|
|
|
|
#include <locale.h>
|
|
|
|
#include <stddef.h>
|
|
|
|
#include <string>
|
2016-04-21 14:00:54 +08:00
|
|
|
#include <memory>
|
|
|
|
#include <wctype.h>
|
|
|
|
#include <stdbool.h>
|
2007-04-22 18:03:12 +08:00
|
|
|
|
2015-07-25 23:14:25 +08:00
|
|
|
#include "color.h"
|
|
|
|
#include "highlight.h"
|
|
|
|
#include "parse_constants.h"
|
2016-04-21 14:00:54 +08:00
|
|
|
#include "wutil.h" // IWYU pragma: keep
|
2014-12-24 07:29:42 +08:00
|
|
|
#include "common.h"
|
|
|
|
#include "output.h"
|
|
|
|
#include "env.h"
|
|
|
|
#include "input.h"
|
|
|
|
#include "parse_tree.h"
|
2007-04-22 18:03:12 +08:00
|
|
|
#include "print_help.h"
|
2014-05-01 15:46:27 +08:00
|
|
|
#include "fish_version.h"
|
2007-04-22 18:03:12 +08:00
|
|
|
|
2014-12-24 07:29:42 +08:00
|
|
|
#define SPACES_PER_INDENT 4
|
2007-04-22 18:03:12 +08:00
|
|
|
|
2016-04-06 06:43:24 +08:00
|
|
|
// An indent_t represents an abstract indent depth. 2 means we are in a doubly-nested block, etc.
|
2014-12-24 07:29:42 +08:00
|
|
|
typedef unsigned int indent_t;
|
2016-04-06 06:43:24 +08:00
|
|
|
static bool dump_parse_tree = false;
|
2014-12-24 07:29:42 +08:00
|
|
|
|
2016-04-06 06:43:24 +08:00
|
|
|
// Read the entire contents of a file into the specified string.
|
2014-12-24 07:29:42 +08:00
|
|
|
static wcstring read_file(FILE *f)
|
2007-04-22 18:03:12 +08:00
|
|
|
{
|
2014-12-24 07:29:42 +08:00
|
|
|
wcstring result;
|
2012-11-19 08:30:30 +08:00
|
|
|
while (1)
|
2012-11-18 18:23:22 +08:00
|
|
|
{
|
2012-11-19 08:30:30 +08:00
|
|
|
wint_t c = fgetwc(f);
|
|
|
|
if (c == WEOF)
|
|
|
|
{
|
2014-10-05 05:27:08 +08:00
|
|
|
if (ferror(f))
|
2012-11-19 08:30:30 +08:00
|
|
|
{
|
|
|
|
wperror(L"fgetwc");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2014-12-24 07:29:42 +08:00
|
|
|
result.push_back((wchar_t)c);
|
2012-11-18 18:23:22 +08:00
|
|
|
}
|
2014-12-24 07:29:42 +08:00
|
|
|
return result;
|
2007-04-22 18:03:12 +08:00
|
|
|
}
|
|
|
|
|
2016-04-06 06:43:24 +08:00
|
|
|
// Append whitespace as necessary. If we have a newline, append the appropriate indent. Otherwise,
|
|
|
|
// append a space.
|
|
|
|
static void append_whitespace(indent_t node_indent, bool do_indent, bool has_new_line,
|
|
|
|
wcstring *out_result)
|
2007-04-22 18:03:12 +08:00
|
|
|
{
|
2016-04-06 06:43:24 +08:00
|
|
|
if (!has_new_line)
|
2014-12-24 07:29:42 +08:00
|
|
|
{
|
|
|
|
out_result->push_back(L' ');
|
|
|
|
}
|
|
|
|
else if (do_indent)
|
|
|
|
{
|
|
|
|
out_result->append(node_indent * SPACES_PER_INDENT, L' ');
|
|
|
|
}
|
2007-04-22 18:03:12 +08:00
|
|
|
}
|
|
|
|
|
2016-04-06 06:43:24 +08:00
|
|
|
// Dump a parse tree node in a form helpful to someone debugging the behavior of this program.
|
|
|
|
static void dump_node(indent_t node_indent, const parse_node_t &node, const wcstring &source)
|
|
|
|
{
|
|
|
|
int nextc_idx = node.source_start + node.source_length;
|
|
|
|
wchar_t prevc = node.source_start > 0 ? source[node.source_start - 1] : L' ';
|
|
|
|
wchar_t nextc = nextc_idx < source.size() ? source[nextc_idx] : L' ';
|
|
|
|
wchar_t prevc_str[4] = {prevc, 0, 0, 0};
|
|
|
|
wchar_t nextc_str[4] = {nextc, 0, 0, 0};
|
|
|
|
if (prevc < L' ')
|
|
|
|
{
|
|
|
|
prevc_str[0] = L'\\';
|
|
|
|
prevc_str[1] = L'c';
|
|
|
|
prevc_str[2] = prevc + '@';
|
|
|
|
}
|
|
|
|
if (nextc < L' ')
|
|
|
|
{
|
|
|
|
nextc_str[0] = L'\\';
|
|
|
|
nextc_str[1] = L'c';
|
|
|
|
nextc_str[2] = nextc + '@';
|
|
|
|
}
|
2016-04-10 09:56:13 +08:00
|
|
|
fwprintf(stderr, L"{off %4d, len %4d, indent %2u, kw %ls, %ls} [%ls|%ls|%ls]\n",
|
2016-04-06 06:43:24 +08:00
|
|
|
node.source_start, node.source_length, node_indent,
|
2016-04-11 10:08:07 +08:00
|
|
|
keyword_description(node.keyword), token_type_description(node.type),
|
2016-04-10 09:56:13 +08:00
|
|
|
prevc_str, source.substr(node.source_start, node.source_length).c_str(), nextc_str);
|
2016-04-06 06:43:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void prettify_node_recursive(const wcstring &source, const parse_node_tree_t &tree,
|
|
|
|
node_offset_t node_idx, indent_t node_indent, parse_token_type_t parent_type,
|
|
|
|
bool *has_new_line, wcstring *out_result, bool do_indent)
|
2007-04-22 18:03:12 +08:00
|
|
|
{
|
2014-12-24 07:29:42 +08:00
|
|
|
const parse_node_t &node = tree.at(node_idx);
|
|
|
|
const parse_token_type_t node_type = node.type;
|
2016-04-06 06:43:24 +08:00
|
|
|
const parse_token_type_t prev_node_type = node_idx > 0 ?
|
|
|
|
tree.at(node_idx - 1).type : token_type_invalid;
|
|
|
|
|
|
|
|
// Increment the indent if we are either a root job_list, or root case_item_list, or in an if or
|
|
|
|
// while header (#1665).
|
|
|
|
const bool is_root_job_list = node_type == symbol_job_list && parent_type != symbol_job_list;
|
|
|
|
const bool is_root_case_list = node_type == symbol_case_item_list &&
|
|
|
|
parent_type != symbol_case_item_list;
|
|
|
|
const bool is_if_while_header = \
|
|
|
|
(node_type == symbol_job || node_type == symbol_andor_job_list) &&
|
|
|
|
(parent_type == symbol_if_clause || parent_type == symbol_while_header);
|
|
|
|
|
|
|
|
if (is_root_job_list || is_root_case_list || is_if_while_header)
|
2012-11-18 18:23:22 +08:00
|
|
|
{
|
2014-12-24 07:29:42 +08:00
|
|
|
node_indent += 1;
|
|
|
|
}
|
2012-11-19 08:30:30 +08:00
|
|
|
|
2016-04-06 06:43:24 +08:00
|
|
|
if (dump_parse_tree) dump_node(node_indent, node, source);
|
|
|
|
|
|
|
|
if (node.has_comments()) // handle comments, which come before the text
|
2014-12-24 07:29:42 +08:00
|
|
|
{
|
2016-04-06 06:43:24 +08:00
|
|
|
const parse_node_tree_t::parse_node_list_t comment_nodes = (
|
|
|
|
tree.comment_nodes_for_node(node));
|
|
|
|
for (size_t i = 0; i < comment_nodes.size(); i++)
|
2012-11-19 08:30:30 +08:00
|
|
|
{
|
2014-12-24 07:29:42 +08:00
|
|
|
const parse_node_t &comment_node = *comment_nodes.at(i);
|
|
|
|
append_whitespace(node_indent, do_indent, *has_new_line, out_result);
|
|
|
|
out_result->append(source, comment_node.source_start, comment_node.source_length);
|
|
|
|
}
|
|
|
|
}
|
2012-11-18 18:23:22 +08:00
|
|
|
|
2014-12-24 07:29:42 +08:00
|
|
|
if (node_type == parse_token_type_end)
|
|
|
|
{
|
|
|
|
out_result->push_back(L'\n');
|
|
|
|
*has_new_line = true;
|
|
|
|
}
|
2016-04-06 06:43:24 +08:00
|
|
|
else if ((node_type >= FIRST_PARSE_TOKEN_TYPE && node_type <= LAST_PARSE_TOKEN_TYPE) ||
|
|
|
|
node_type == parse_special_type_parse_error)
|
2014-12-24 07:29:42 +08:00
|
|
|
{
|
2016-04-10 09:56:13 +08:00
|
|
|
if (node.keyword != parse_keyword_none)
|
|
|
|
{
|
|
|
|
append_whitespace(node_indent, do_indent, *has_new_line, out_result);
|
|
|
|
out_result->append(keyword_description(node.keyword));
|
|
|
|
*has_new_line = false;
|
|
|
|
}
|
|
|
|
else if (node.has_source())
|
2014-12-24 07:29:42 +08:00
|
|
|
{
|
2016-04-06 06:43:24 +08:00
|
|
|
// Some type representing a particular token.
|
|
|
|
if (prev_node_type != parse_token_type_redirection)
|
|
|
|
{
|
|
|
|
append_whitespace(node_indent, do_indent, *has_new_line, out_result);
|
|
|
|
}
|
2014-12-24 07:29:42 +08:00
|
|
|
out_result->append(source, node.source_start, node.source_length);
|
|
|
|
*has_new_line = false;
|
|
|
|
}
|
|
|
|
}
|
2012-11-19 16:31:03 +08:00
|
|
|
|
2016-04-06 06:43:24 +08:00
|
|
|
// Recurse to all our children.
|
2014-12-24 07:29:42 +08:00
|
|
|
for (node_offset_t idx = 0; idx < node.child_count; idx++)
|
|
|
|
{
|
2016-04-06 06:43:24 +08:00
|
|
|
// Note we pass our type to our child, which becomes its parent node type.
|
|
|
|
prettify_node_recursive(source, tree, node.child_start + idx, node_indent, node_type,
|
|
|
|
has_new_line, out_result, do_indent);
|
2014-12-24 07:29:42 +08:00
|
|
|
}
|
|
|
|
}
|
2012-11-19 08:30:30 +08:00
|
|
|
|
2014-12-24 07:29:42 +08:00
|
|
|
/* Entry point for prettification. */
|
|
|
|
static wcstring prettify(const wcstring &src, bool do_indent)
|
|
|
|
{
|
|
|
|
parse_node_tree_t tree;
|
|
|
|
if (! parse_tree_from_string(src, parse_flag_continue_after_error | parse_flag_include_comments | parse_flag_leave_unterminated | parse_flag_show_blank_lines, &tree, NULL /* errors */))
|
|
|
|
{
|
|
|
|
/* We return the initial string on failure */
|
|
|
|
return src;
|
|
|
|
}
|
2012-11-19 16:31:03 +08:00
|
|
|
|
2014-12-24 07:29:42 +08:00
|
|
|
/* We may have a forest of disconnected trees on a parse failure. We have to handle all nodes that have no parent, and all parse errors. */
|
|
|
|
bool has_new_line = true;
|
|
|
|
wcstring result;
|
2014-12-24 08:16:37 +08:00
|
|
|
for (node_offset_t i=0; i < tree.size(); i++)
|
2014-12-24 07:29:42 +08:00
|
|
|
{
|
|
|
|
const parse_node_t &node = tree.at(i);
|
|
|
|
if (node.parent == NODE_OFFSET_INVALID || node.type == parse_special_type_parse_error)
|
|
|
|
{
|
|
|
|
/* A root node */
|
|
|
|
prettify_node_recursive(src, tree, i, 0, symbol_job_list, &has_new_line, &result, do_indent);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
2012-11-19 08:30:30 +08:00
|
|
|
|
|
|
|
|
2014-12-24 07:29:42 +08:00
|
|
|
// Helper for output_set_writer
|
|
|
|
static std::string output_receiver;
|
|
|
|
static int write_to_output_receiver(char c)
|
|
|
|
{
|
|
|
|
output_receiver.push_back(c);
|
|
|
|
return 0;
|
|
|
|
}
|
2012-11-19 08:30:30 +08:00
|
|
|
|
2014-12-24 07:29:42 +08:00
|
|
|
/* Given a string and list of colors of the same size, return the string with ANSI escape sequences representing the colors. */
|
|
|
|
static std::string ansi_colorize(const wcstring &text, const std::vector<highlight_spec_t> &colors)
|
|
|
|
{
|
|
|
|
assert(colors.size() == text.size());
|
|
|
|
assert(output_receiver.empty());
|
2012-11-18 18:23:22 +08:00
|
|
|
|
2014-12-24 07:29:42 +08:00
|
|
|
int (*saved)(char) = output_get_writer();
|
|
|
|
output_set_writer(write_to_output_receiver);
|
2012-11-18 18:23:22 +08:00
|
|
|
|
2014-12-24 07:29:42 +08:00
|
|
|
highlight_spec_t last_color = highlight_spec_normal;
|
|
|
|
for (size_t i=0; i < text.size(); i++)
|
|
|
|
{
|
|
|
|
highlight_spec_t color = colors.at(i);
|
|
|
|
if (color != last_color)
|
|
|
|
{
|
2014-12-25 04:43:00 +08:00
|
|
|
set_color(highlight_get_color(color, false), rgb_color_t::normal());
|
2014-12-24 07:29:42 +08:00
|
|
|
last_color = color;
|
2012-11-19 08:30:30 +08:00
|
|
|
}
|
2014-12-24 07:29:42 +08:00
|
|
|
writech(text.at(i));
|
|
|
|
}
|
2012-11-18 18:23:22 +08:00
|
|
|
|
2014-12-24 07:29:42 +08:00
|
|
|
output_set_writer(saved);
|
|
|
|
std::string result;
|
|
|
|
result.swap(output_receiver);
|
|
|
|
return result;
|
|
|
|
}
|
2012-11-18 18:23:22 +08:00
|
|
|
|
2014-12-24 07:29:42 +08:00
|
|
|
/* Given a string and list of colors of the same size, return the string with HTML span elements for the various colors. */
|
|
|
|
static const wchar_t *html_class_name_for_color(highlight_spec_t spec)
|
|
|
|
{
|
|
|
|
#define P(x) L"fish_color_" #x
|
|
|
|
switch (spec & HIGHLIGHT_SPEC_PRIMARY_MASK)
|
|
|
|
{
|
|
|
|
case highlight_spec_normal: return P(normal);
|
|
|
|
case highlight_spec_error: return P(error);
|
|
|
|
case highlight_spec_command: return P(command);
|
|
|
|
case highlight_spec_statement_terminator: return P(statement_terminator);
|
|
|
|
case highlight_spec_param: return P(param);
|
|
|
|
case highlight_spec_comment: return P(comment);
|
|
|
|
case highlight_spec_match: return P(match);
|
|
|
|
case highlight_spec_search_match: return P(search_match);
|
|
|
|
case highlight_spec_operator: return P(operator);
|
|
|
|
case highlight_spec_escape: return P(escape);
|
|
|
|
case highlight_spec_quote: return P(quote);
|
|
|
|
case highlight_spec_redirection: return P(redirection);
|
|
|
|
case highlight_spec_autosuggestion: return P(autosuggestion);
|
|
|
|
case highlight_spec_selection: return P(selection);
|
|
|
|
|
|
|
|
default: return P(other);
|
2012-11-19 08:30:30 +08:00
|
|
|
}
|
2007-04-22 18:03:12 +08:00
|
|
|
}
|
|
|
|
|
2014-12-24 07:29:42 +08:00
|
|
|
static std::string html_colorize(const wcstring &text, const std::vector<highlight_spec_t> &colors)
|
2007-04-23 02:54:29 +08:00
|
|
|
{
|
2014-12-24 07:29:42 +08:00
|
|
|
if (text.empty())
|
|
|
|
{
|
|
|
|
return "";
|
|
|
|
}
|
2007-04-23 02:54:29 +08:00
|
|
|
|
2014-12-24 07:29:42 +08:00
|
|
|
assert(colors.size() == text.size());
|
2014-12-25 05:08:16 +08:00
|
|
|
wcstring html = L"<pre><code>";
|
2014-12-24 07:29:42 +08:00
|
|
|
highlight_spec_t last_color = highlight_spec_normal;
|
|
|
|
for (size_t i=0; i < text.size(); i++)
|
|
|
|
{
|
|
|
|
/* Handle colors */
|
|
|
|
highlight_spec_t color = colors.at(i);
|
|
|
|
if (i > 0 && color != last_color)
|
|
|
|
{
|
|
|
|
html.append(L"</span>");
|
|
|
|
}
|
|
|
|
if (i == 0 || color != last_color)
|
|
|
|
{
|
|
|
|
append_format(html, L"<span class=\"%ls\">", html_class_name_for_color(color));
|
|
|
|
}
|
|
|
|
last_color = color;
|
2012-11-18 18:23:22 +08:00
|
|
|
|
2014-12-24 07:29:42 +08:00
|
|
|
/* Handle text */
|
|
|
|
wchar_t wc = text.at(i);
|
|
|
|
switch (wc)
|
|
|
|
{
|
|
|
|
case L'&':
|
|
|
|
html.append(L"&");
|
|
|
|
break;
|
|
|
|
case L'\'':
|
|
|
|
html.append(L"'");
|
|
|
|
break;
|
|
|
|
case L'"':
|
|
|
|
html.append(L""");
|
|
|
|
break;
|
|
|
|
case L'<':
|
|
|
|
html.append(L"<");
|
|
|
|
break;
|
|
|
|
case L'>':
|
|
|
|
html.append(L">");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
html.push_back(wc);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2014-12-25 06:17:06 +08:00
|
|
|
html.append(L"</span></code></pre>");
|
2014-12-24 07:29:42 +08:00
|
|
|
return wcs2string(html);
|
2007-04-23 02:54:29 +08:00
|
|
|
}
|
|
|
|
|
2014-12-24 07:29:42 +08:00
|
|
|
static std::string no_colorize(const wcstring &text)
|
|
|
|
{
|
|
|
|
return wcs2string(text);
|
|
|
|
}
|
2007-04-23 02:54:29 +08:00
|
|
|
|
2014-12-24 07:29:42 +08:00
|
|
|
int main(int argc, char *argv[])
|
2012-11-18 18:23:22 +08:00
|
|
|
{
|
2012-11-19 08:30:30 +08:00
|
|
|
set_main_thread();
|
2012-03-08 03:35:22 +08:00
|
|
|
setup_fork_guards();
|
2012-11-18 18:23:22 +08:00
|
|
|
|
2012-11-19 08:30:30 +08:00
|
|
|
wsetlocale(LC_ALL, L"");
|
|
|
|
program_name=L"fish_indent";
|
2012-11-18 18:23:22 +08:00
|
|
|
|
2014-12-24 07:29:42 +08:00
|
|
|
env_init();
|
|
|
|
input_init();
|
|
|
|
|
|
|
|
/* Types of output we support */
|
|
|
|
enum
|
|
|
|
{
|
|
|
|
output_type_plain_text,
|
|
|
|
output_type_ansi,
|
|
|
|
output_type_html
|
|
|
|
} output_type = output_type_plain_text;
|
|
|
|
bool do_indent = true;
|
|
|
|
|
2016-04-06 06:43:24 +08:00
|
|
|
const char *short_opts = "+dhvi";
|
2016-03-04 07:36:17 +08:00
|
|
|
const struct option long_opts[] =
|
|
|
|
{
|
2016-04-06 06:43:24 +08:00
|
|
|
{ "dump", no_argument, NULL, 'd' },
|
2016-03-04 07:36:17 +08:00
|
|
|
{ "no-indent", no_argument, NULL, 'i' },
|
|
|
|
{ "help", no_argument, NULL, 'h' },
|
|
|
|
{ "version", no_argument, NULL, 'v' },
|
|
|
|
{ "html", no_argument, NULL, 1 },
|
|
|
|
{ "ansi", no_argument, NULL, 2 },
|
|
|
|
{ NULL, 0, NULL, 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
int opt;
|
|
|
|
while ((opt = getopt_long(argc, argv, short_opts, long_opts, NULL)) != -1)
|
2012-11-19 08:30:30 +08:00
|
|
|
{
|
|
|
|
switch (opt)
|
2012-11-18 18:23:22 +08:00
|
|
|
{
|
2012-11-19 16:31:03 +08:00
|
|
|
case 0:
|
|
|
|
{
|
2016-03-04 07:36:17 +08:00
|
|
|
fwprintf(stderr, _(L"getopt_long() unexpectedly returned zero\n"));
|
|
|
|
exit_without_destructors(127);
|
2012-11-19 16:31:03 +08:00
|
|
|
}
|
2012-11-19 08:30:30 +08:00
|
|
|
|
2016-04-06 06:43:24 +08:00
|
|
|
case 'd':
|
|
|
|
{
|
|
|
|
dump_parse_tree = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2012-11-19 16:31:03 +08:00
|
|
|
case 'h':
|
|
|
|
{
|
|
|
|
print_help("fish_indent", 1);
|
2016-03-04 07:36:17 +08:00
|
|
|
exit_without_destructors(0);
|
2012-11-19 16:31:03 +08:00
|
|
|
}
|
2012-11-18 18:23:22 +08:00
|
|
|
|
2012-11-19 16:31:03 +08:00
|
|
|
case 'v':
|
|
|
|
{
|
2014-12-24 07:29:42 +08:00
|
|
|
fwprintf(stderr, _(L"%ls, version %s\n"), program_name, get_fish_version());
|
2012-11-19 16:31:03 +08:00
|
|
|
exit(0);
|
2014-10-31 13:40:35 +08:00
|
|
|
assert(0 && "Unreachable code reached");
|
|
|
|
break;
|
2012-11-19 16:31:03 +08:00
|
|
|
}
|
2012-11-18 18:23:22 +08:00
|
|
|
|
2012-11-19 16:31:03 +08:00
|
|
|
case 'i':
|
|
|
|
{
|
2014-12-24 07:29:42 +08:00
|
|
|
do_indent = false;
|
2012-11-19 16:31:03 +08:00
|
|
|
break;
|
|
|
|
}
|
2012-11-18 18:23:22 +08:00
|
|
|
|
2014-12-24 07:29:42 +08:00
|
|
|
case 1:
|
|
|
|
{
|
|
|
|
output_type = output_type_html;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
{
|
|
|
|
output_type = output_type_ansi;
|
|
|
|
break;
|
|
|
|
}
|
2012-11-18 18:23:22 +08:00
|
|
|
|
2016-03-04 07:36:17 +08:00
|
|
|
default:
|
2012-11-19 16:31:03 +08:00
|
|
|
{
|
2016-03-04 07:36:17 +08:00
|
|
|
// We assume getopt_long() has already emitted a diagnostic msg.
|
|
|
|
exit_without_destructors(1);
|
2012-11-19 16:31:03 +08:00
|
|
|
}
|
2012-11-19 08:30:30 +08:00
|
|
|
}
|
2012-11-18 18:23:22 +08:00
|
|
|
}
|
2007-04-22 18:03:12 +08:00
|
|
|
|
2014-12-24 07:29:42 +08:00
|
|
|
const wcstring src = read_file(stdin);
|
|
|
|
const wcstring output_wtext = prettify(src, do_indent);
|
2012-11-18 18:23:22 +08:00
|
|
|
|
2014-12-24 07:29:42 +08:00
|
|
|
/* Maybe colorize */
|
|
|
|
std::vector<highlight_spec_t> colors;
|
|
|
|
if (output_type != output_type_plain_text)
|
2012-11-19 08:30:30 +08:00
|
|
|
{
|
2014-12-24 07:29:42 +08:00
|
|
|
highlight_shell_no_io(output_wtext, colors, output_wtext.size(), NULL, env_vars_snapshot_t::current());
|
2012-11-19 08:30:30 +08:00
|
|
|
}
|
2014-12-24 07:29:42 +08:00
|
|
|
|
|
|
|
std::string colored_output;
|
|
|
|
switch (output_type)
|
2012-11-19 08:30:30 +08:00
|
|
|
{
|
2014-12-24 07:29:42 +08:00
|
|
|
case output_type_plain_text:
|
|
|
|
colored_output = no_colorize(output_wtext);
|
|
|
|
break;
|
2012-11-18 18:23:22 +08:00
|
|
|
|
2014-12-24 07:29:42 +08:00
|
|
|
case output_type_ansi:
|
|
|
|
colored_output = ansi_colorize(output_wtext, colors);
|
|
|
|
break;
|
2012-11-18 18:23:22 +08:00
|
|
|
|
2014-12-24 07:29:42 +08:00
|
|
|
case output_type_html:
|
|
|
|
colored_output = html_colorize(output_wtext, colors);
|
|
|
|
break;
|
|
|
|
}
|
2012-11-18 18:23:22 +08:00
|
|
|
|
2014-12-24 07:29:42 +08:00
|
|
|
fputs(colored_output.c_str(), stdout);
|
2012-11-19 08:30:30 +08:00
|
|
|
return 0;
|
2007-04-22 18:03:12 +08:00
|
|
|
}
|