277 lines
7.6 KiB
C++
277 lines
7.6 KiB
C++
/*
|
|
Copyright (c) 2013 Microsoft Corporation. All rights reserved.
|
|
Released under Apache 2.0 license as described in the file LICENSE.
|
|
|
|
Author: Soonho Kong
|
|
*/
|
|
#include "sexpr.h"
|
|
#include "format.h"
|
|
#include "sexpr_funcs.h"
|
|
|
|
namespace lean {
|
|
static int default_width = 78;
|
|
std::ostream & layout(std::ostream & out, sexpr const & s) {
|
|
lean_assert(!is_nil(s));
|
|
switch (format::sexpr_kind(s)) {
|
|
case format::format_kind::NEST:
|
|
case format::format_kind::CHOICE:
|
|
case format::format_kind::COMPOSE:
|
|
lean_unreachable();
|
|
break;
|
|
|
|
case format::format_kind::NIL:
|
|
out << "";
|
|
break;
|
|
|
|
case format::format_kind::LINE:
|
|
out << std::endl;
|
|
break;
|
|
|
|
case format::format_kind::TEXT:
|
|
{
|
|
sexpr const & v = cdr(s);
|
|
if(is_string(v)) {
|
|
out << to_string(v);
|
|
} else {
|
|
out << v;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case format::format_kind::COLOR_BEGIN:
|
|
{
|
|
format::format_color c = static_cast<format::format_color>(to_int(cdr(s)));
|
|
out << "\e[" << (31 + c % 7) << "m";
|
|
break;
|
|
}
|
|
|
|
case format::format_kind::COLOR_END:
|
|
out << "\e[0m";
|
|
break;
|
|
}
|
|
return out;
|
|
}
|
|
|
|
std::ostream & layout_list(std::ostream & out, sexpr const & s) {
|
|
foreach(s, [&out](sexpr const & s) {
|
|
layout(out, s);
|
|
});
|
|
return out;
|
|
}
|
|
|
|
format compose(format const & f1, format const & f2) {
|
|
return format(format::sexpr_compose({f1.m_value, f2.m_value}));
|
|
}
|
|
format nest(int i, format const & f) {
|
|
return format(format::sexpr_nest(i, f.m_value));
|
|
}
|
|
format highlight(format const & f, format::format_color const c) {
|
|
return format(format::sexpr_highlight(f.m_value, c));
|
|
}
|
|
format line() {
|
|
return format(format::sexpr_line());
|
|
}
|
|
|
|
sexpr format::flatten(sexpr const & s) {
|
|
lean_assert(is_cons(s));
|
|
switch (sexpr_kind(s)) {
|
|
case format_kind::NIL:
|
|
/* flatten NIL = NIL */
|
|
return s;
|
|
case format_kind::NEST:
|
|
/* flatten (NEST i x) = flatten x */
|
|
return flatten(sexpr_nest_s(s));
|
|
case format_kind::COMPOSE:
|
|
/* flatten (s_1 <> ... <> s_n ) = flatten s_1 <> ... <> flatten s_n */
|
|
return sexpr_compose(map(sexpr_compose_list(s),
|
|
[](sexpr const & s) {
|
|
return flatten(s);
|
|
}));
|
|
case format_kind::CHOICE:
|
|
/* flatten (x <|> y) = flatten x */
|
|
return flatten(sexpr_choice_1(s));
|
|
case format_kind::LINE:
|
|
return sexpr_text(sexpr(" "));
|
|
case format_kind::TEXT:
|
|
case format_kind::COLOR_BEGIN:
|
|
case format_kind::COLOR_END:
|
|
return s;
|
|
}
|
|
lean_unreachable();
|
|
return s;
|
|
}
|
|
format format::flatten(format const & f){
|
|
return format(flatten(f.m_value));
|
|
}
|
|
format group(format const & f) {
|
|
return choice(format::flatten(f), f);
|
|
}
|
|
format above(format const & f1, format const & f2) {
|
|
return format{f1, line(), f2};
|
|
}
|
|
format bracket(std::string const l, format const & x, std::string const r) {
|
|
return group(format{format(l),
|
|
nest(2, format(line(), x)),
|
|
line(),
|
|
format(r)});
|
|
}
|
|
format paren(format const & x) {
|
|
return bracket("(", x, ")");
|
|
}
|
|
|
|
// wrap = <+/>
|
|
// wrap x y = x <> (text " " :<|> line) <> y
|
|
format wrap(format const & f1, format const & f2) {
|
|
return format{f1,
|
|
choice(format(" "), line()),
|
|
f2};
|
|
}
|
|
|
|
unsigned format::space_upto_line_break_list(sexpr const & r, bool & found) {
|
|
// r : list of (int * format)
|
|
lean_assert(!found);
|
|
if (is_nil(r)) {
|
|
found = true;
|
|
return 0;
|
|
}
|
|
return format::space_upto_line_break(cdr(car(r)), cdr(r), found);
|
|
}
|
|
|
|
unsigned format::space_upto_line_break(sexpr const & s, sexpr const & r, bool & found) {
|
|
// s : format
|
|
// r : list of (int * format)
|
|
lean_assert(!found);
|
|
if(is_nil(s)) {
|
|
found = true;
|
|
return 0;
|
|
}
|
|
|
|
switch (sexpr_kind(s)) {
|
|
case format_kind::NIL:
|
|
case format_kind::COLOR_BEGIN:
|
|
case format_kind::COLOR_END:
|
|
return 0 + space_upto_line_break_list(r, found);
|
|
case format_kind::COMPOSE:
|
|
{
|
|
sexpr list = sexpr_compose_list(s);
|
|
unsigned len = 0;
|
|
while(!is_nil(list) && !found) {
|
|
sexpr const & h = car(list);
|
|
list = cdr(list);
|
|
len += space_upto_line_break(h, nil(), found);
|
|
}
|
|
if (found) {
|
|
return len;
|
|
} else {
|
|
return len + space_upto_line_break_list(r, found);
|
|
}
|
|
}
|
|
case format_kind::NEST:
|
|
{
|
|
sexpr const & x = sexpr_nest_s(s);
|
|
unsigned len = space_upto_line_break(x, nil(), found);
|
|
if (found) {
|
|
return len;
|
|
} else {
|
|
return len + space_upto_line_break_list(r, found);
|
|
}
|
|
}
|
|
case format_kind::TEXT:
|
|
return sexpr_text_length(s) + space_upto_line_break_list(r, found);
|
|
case format_kind::LINE:
|
|
found = true;
|
|
return 0;
|
|
case format_kind::CHOICE:
|
|
{
|
|
sexpr const & x = sexpr_choice_1(s);
|
|
return space_upto_line_break(x, r, found);
|
|
}
|
|
}
|
|
std::cerr << "!!!!!!!!!!!!!!!" << s << std::endl;
|
|
lean_unreachable();
|
|
return 0;
|
|
}
|
|
|
|
sexpr format::be(unsigned w, unsigned k, sexpr const & s, sexpr const & r) {
|
|
/* be w k [] = Nil */
|
|
if(is_nil(s)) {
|
|
if(is_nil(r)) {
|
|
// s == Nil && r == Nil
|
|
return sexpr();
|
|
} else {
|
|
// s == Nil && r != Nil
|
|
return be(w, k, car(r), cdr(r));
|
|
}
|
|
}
|
|
|
|
/* s = (i, v) :: z, where h has the type int x format */
|
|
sexpr const & h = car(s);
|
|
sexpr const & z = cdr(s);
|
|
int i = to_int(car(h));
|
|
sexpr const & v = cdr(h);
|
|
|
|
switch (sexpr_kind(v)) {
|
|
case format_kind::NIL:
|
|
return be(w, k, z, r);
|
|
case format_kind::COLOR_BEGIN:
|
|
case format_kind::COLOR_END:
|
|
return sexpr(v, be(w, k, z, r));
|
|
case format_kind::COMPOSE:
|
|
{
|
|
sexpr const & list = sexpr_compose_list(v);
|
|
sexpr const & list_ = map(list,
|
|
[i](sexpr const & s) {
|
|
return sexpr(i, s);
|
|
});
|
|
return be(w, k, list_, sexpr(z, r));
|
|
}
|
|
case format_kind::NEST:
|
|
{
|
|
int j = sexpr_nest_i(v);
|
|
sexpr const & x = sexpr_nest_s(v);
|
|
return be(w, k, sexpr(sexpr(i + j, x), z), r);
|
|
}
|
|
case format_kind::TEXT:
|
|
return sexpr(v, be(w, k + sexpr_text_length(v), z, r));
|
|
case format_kind::LINE:
|
|
return sexpr(v, sexpr(sexpr_text(std::string(i, ' ')), be(w, i, z, r)));
|
|
case format_kind::CHOICE:
|
|
{
|
|
sexpr const & x = sexpr_choice_1(v);
|
|
sexpr const & y = sexpr_choice_2(v);;
|
|
bool found = false;
|
|
int d = static_cast<int>(w) - static_cast<int>(k) - space_upto_line_break(x, r, found);
|
|
if(d >= 0) {
|
|
sexpr const & s1 = be(w, k, sexpr(sexpr(i, x), z), r);
|
|
return s1;
|
|
}
|
|
sexpr const & s2 = be(w, k, sexpr(sexpr(i, y), z), r);
|
|
return s2;
|
|
}
|
|
}
|
|
lean_unreachable();
|
|
return sexpr();
|
|
}
|
|
|
|
sexpr format::best(unsigned w, unsigned k, sexpr const & s) {
|
|
return be(w, k, sexpr{sexpr(0, s)}, sexpr());
|
|
}
|
|
|
|
std::ostream & operator<<(std::ostream & out, format const & f)
|
|
{
|
|
return pretty(out, default_width, f);
|
|
}
|
|
|
|
format operator+(format const & f1, format const & f2) {
|
|
return format{f1, f2};
|
|
}
|
|
|
|
format operator^(format const & f1, format const & f2) {
|
|
return format{f1, format(" "), f2};
|
|
}
|
|
|
|
std::ostream & pretty(std::ostream & out, unsigned w, format const & f) {
|
|
sexpr const & b = format::best(w, 0, f.m_value);
|
|
return layout_list(out, b);
|
|
}
|
|
}
|