void print_object (STREAM stream, D instance, BOOL escape_p, int print_depth) {
enum dylan_type_enum type = dylan_type(instance);
switch (type) {
case integer_type:
print_integer(stream, instance, escape_p, print_depth); break;
case character_type:
print_character(stream, instance, escape_p, print_depth); break;
case float_type:
print_float (stream, instance, escape_p, print_depth); break;
case dylan_boolean_type:
print_boolean(stream, instance, escape_p, print_depth); break;
case string_type:
print_string (stream, instance, escape_p, print_depth); break;
case vector_type:
print_vector(stream, instance, escape_p, print_depth); break;
case pair_type:
print_pair(stream, instance, escape_p, print_depth); break;
case empty_list_type:
print_empty_list(stream, instance, escape_p, print_depth); break;
case symbol_type:
print_symbol(stream, instance, escape_p, print_depth); break;
case simple_condition_type:
print_simple_condition(stream, instance, escape_p, print_depth); break;
case class_type:
print_class(stream, instance, escape_p, print_depth); break;
case function_type:
print_function(stream, instance, escape_p, print_depth); break;
case unknown_type:
format(stream, "?%lx", instance); break;
default:
print_user_defined(stream, instance, escape_p, print_depth); break;
}
}
void print_counts(count_map counts) {
str_size longest{get_longest_key(counts)};
for (count_pair pair : counts) {
print_pair(pair, longest);
}
}
void print_pair(ptr x) {
pair* p = to_pair(x);
print_ptr_rec(p->car);
if (is_pair(p->cdr)) {
printf(" ");
print_pair(p->cdr);
} else if (is_null(p->cdr)) {
/*pass*/
} else {
printf(" . ");
print_ptr_rec(p->cdr);
}
}
void walk_data::operator () (const tag &t)
{
std::cout << "Tag:" << t.id << '\n';
std::cout << "Attributes\n";
std::for_each
(
t.attributes.begin(),
t.attributes.end(),
print_pair()
);
std::cout << "Children:\n";
std::for_each
(
t.children.begin(),
t.children.end(),
boost::apply_visitor(*this)
);
std::cout << "End of tag:" << t.id << '\n';
}
void print_ptr_rec(ptr x) {
/*printf("%u\n", x);*/
if (is_fixnum(x)) {
printf("%d", to_fixnum(x));
} else if (x == bool_f) {
printf("#f");
} else if (x == bool_t) {
printf("#t");
} else if (is_null(x)) {
print_null();
} else if (is_char(x)) {
printf("%s", beautify(to_char(x)));
} else if (is_pair(x)) {
printf("(");
print_pair(x);
printf(")");
} else {
printf("#<unknown 0x%08x>", x);
}
}
int main(void)
{
char ch;
int i = 1;
printf("Enter text to print:\n");
while ((ch = getchar()) != EOF)
{
print_pair(ch);
if (i == 10)
{
printf("\n");
i = 0;
}
else if (ch == '\n')
printf("\n");
i++;
}
return 0;
}
void mel_print( struct mel_value* value ) {
if( value == 0 ) {
printf("nil");
return;
}
switch( value->mel_type ) {
case mel_pairt:
print_pair( value );
break;
case mel_intt:
print_int( value );
break;
case mel_flot:
print_float( value );
break;
case mel_symt:
print_sym( value );
break;
case mel_strt:
print_string( value );
break;
case mel_cfunt:
print_cfunc( value );
break;
case mel_chart:
print_char( value );
break;
case mel_lisp_funt:
print_lispfun( value );
break;
case mel_true:
printf("true");
break;
default:
break;
}
}
/*
* Run a single test: n = size
* - add test data to the heap
* - extract all elements from the heap and print them
*/
static void run_test(uint32_t n) {
pair_t *p, *q;
uint32_t i;
for (i=0; i<n; i++) {
ptr_heap_add(&heap, test + i);
}
// extract the data
q = NULL;
i = 0;
for (;;) {
p = ptr_heap_get_min(&heap);
if (p == NULL) break;
print_pair(p);
if (q != NULL && ! compare(q, p)) {
printf("*** BUG: incorrect heap order ***\n");
}
q = p;
i ++;
}
assert(i == n);
}
void fl_print_child(ios_t *f, value_t v)
{
char *name, *str;
char buf[64];
if (print_level >= 0 && P_LEVEL >= print_level &&
(iscons(v) || isvector(v) || isclosure(v))) {
outc('#', f);
return;
}
P_LEVEL++;
switch (tag(v)) {
case TAG_NUM :
case TAG_NUM1: //HPOS+=ios_printf(f, "%ld", numval(v)); break;
str = uint2str(&buf[1], sizeof(buf)-1, labs(numval(v)), 10);
if (numval(v)<0)
*(--str) = '-';
outs(str, f);
break;
case TAG_SYM:
name = symbol_name(v);
if (print_princ)
outs(name, f);
else if (ismanaged(v)) {
outsn("#:", f, 2);
outs(name, f);
}
else
print_symbol_name(f, name);
break;
case TAG_FUNCTION:
if (v == FL_T) {
outsn("#t", f, 2);
}
else if (v == FL_F) {
outsn("#f", f, 2);
}
else if (v == FL_NIL) {
outsn("()", f, 2);
}
else if (v == FL_EOF) {
outsn("#<eof>", f, 6);
}
else if (isbuiltin(v)) {
if (!print_princ)
outsn("#.", f, 2);
outs(builtin_names[uintval(v)], f);
}
else {
assert(isclosure(v));
if (!print_princ) {
if (print_circle_prefix(f, v)) break;
function_t *fn = (function_t*)ptr(v);
outs("#fn(", f);
char *data = cvalue_data(fn->bcode);
size_t i, sz = cvalue_len(fn->bcode);
for(i=0; i < sz; i++) data[i] += 48;
fl_print_child(f, fn->bcode);
for(i=0; i < sz; i++) data[i] -= 48;
outc(' ', f);
fl_print_child(f, fn->vals);
if (fn->env != NIL) {
outc(' ', f);
fl_print_child(f, fn->env);
}
if (fn->name != LAMBDA) {
outc(' ', f);
fl_print_child(f, fn->name);
}
outc(')', f);
}
else {
outs("#<function>", f);
}
}
break;
case TAG_CVALUE:
case TAG_CPRIM:
if (v == UNBOUND) { outs("#<undefined>", f); break; }
case TAG_VECTOR:
case TAG_CONS:
if (print_circle_prefix(f, v)) break;
if (isvector(v)) {
outc('[', f);
int newindent = HPOS, est;
int i, sz = vector_size(v);
for(i=0; i < sz; i++) {
if (print_length >= 0 && i >= print_length && i < sz-1) {
outsn("...", f, 3);
break;
}
fl_print_child(f, vector_elt(v,i));
if (i < sz-1) {
if (!print_pretty) {
outc(' ', f);
}
else {
est = lengthestimate(vector_elt(v,i+1));
if (HPOS > SCR_WIDTH-4 ||
(est!=-1 && (HPOS+est > SCR_WIDTH-2)) ||
(HPOS > SCR_WIDTH/2 &&
!smallp(vector_elt(v,i+1)) &&
!tinyp(vector_elt(v,i))))
newindent = outindent(newindent, f);
else
outc(' ', f);
}
}
}
outc(']', f);
break;
}
if (iscvalue(v) || iscprim(v))
cvalue_print(f, v);
else
print_pair(f, v);
break;
}
P_LEVEL--;
}
void Print( const Value* value, std::ostream& result )
{
// TODO: switch on typeid?
if( !value )
{
return;
}
const IntegerValue* integervalue = dynamic_cast<const IntegerValue*>(
value );
if( integervalue )
{
print_integer( integervalue, result );
return;
}
const DecimalValue* decimalvalue = dynamic_cast<const DecimalValue*>(
value );
if( decimalvalue )
{
print_decimal( decimalvalue, result );
return;
}
const StringValue* stringvalue = dynamic_cast<const StringValue*>(
value );
if( stringvalue )
{
print_string( stringvalue, result );
return;
}
const TrueValue* truevalue = dynamic_cast<const TrueValue*>(
value );
if( truevalue )
{
print_true( truevalue, result );
return;
}
const FalseValue* falsevalue = dynamic_cast<const FalseValue*>(
value );
if( falsevalue )
{
print_false( falsevalue, result );
return;
}
const NilValue* nilvalue = dynamic_cast<const NilValue*>(
value );
if( nilvalue )
{
print_nil( nilvalue, result );
return;
}
const CombinationValue* combovalue = dynamic_cast<
const CombinationValue*>( value );
if( combovalue )
{
print_combination( combovalue, result );
return;
}
const SymbolValue* symbolvalue = dynamic_cast<
const SymbolValue*>( value );
if( symbolvalue )
{
print_symbol( symbolvalue, result );
return;
}
const NativeFunctionValue* fnvalue = dynamic_cast<
const NativeFunctionValue*>( value );
if( fnvalue )
{
print_built_in_procedure( fnvalue, result );
return;
}
const CompoundProcedureValue* procvalue = dynamic_cast<
const CompoundProcedureValue*>( value );
if( procvalue )
{
print_compound_procedure( procvalue, result );
return;
}
const PairValue* pairvalue = dynamic_cast<
const PairValue*>( value );
if( pairvalue )
{
print_pair( pairvalue, result );
return;
}
result << "<<UNPRINTABLE TYPE " << typeid(value).name() << ">>";
}
/* Print tags... limiting the UTF-8 to ASCII, if necessary. */
void print_id3_tag(mpg123_handle *mh, int long_id3, FILE *out)
{
char genre_from_v1 = 0;
enum tagcode ti;
mpg123_string tag[FIELDS];
size_t len[FIELDS];
mpg123_id3v1 *v1;
mpg123_id3v2 *v2;
/* no memory allocated here, so return is safe */
for(ti=0; ti<FIELDS; ++ti){ len[ti]=0; mpg123_init_string(&tag[ti]); }
/* extract the data */
mpg123_id3(mh, &v1, &v2);
/* Only work if something there... */
if(v1 == NULL && v2 == NULL) return;
if(v2 != NULL) /* fill from ID3v2 data */
{
len[TITLE] = transform(&tag[TITLE], v2->title);
len[ARTIST] = transform(&tag[ARTIST], v2->artist);
len[ALBUM] = transform(&tag[ALBUM], v2->album);
len[COMMENT] = transform(&tag[COMMENT], v2->comment);
len[YEAR] = transform(&tag[YEAR], v2->year);
len[GENRE] = transform(&tag[GENRE], v2->genre);
}
if(v1 != NULL) /* fill gaps with ID3v1 data */
{
/* I _could_ skip the recalculation of fill ... */
id3_gap(&tag[TITLE], 30, v1->title, &len[TITLE]);
id3_gap(&tag[ARTIST], 30, v1->artist, &len[ARTIST]);
id3_gap(&tag[ALBUM], 30, v1->album, &len[ALBUM]);
id3_gap(&tag[COMMENT], 30, v1->comment, &len[COMMENT]);
id3_gap(&tag[YEAR], 4, v1->year, &len[YEAR]);
/*
genre is special... v1->genre holds an index, id3v2 genre may contain indices in textual form and raw textual genres...
*/
if(!tag[GENRE].fill)
{
if(tag[GENRE].size >= 31 || mpg123_resize_string(&tag[GENRE],31))
{
if(v1->genre <= genre_count)
{
strncpy(tag[GENRE].p, genre_table[v1->genre], 30);
}
else
{
strncpy(tag[GENRE].p,"Unknown",30);
}
tag[GENRE].p[30] = 0;
/* V1 was plain ASCII, so strlen is fine. */
len[GENRE] = strlen(tag[GENRE].p);
tag[GENRE].fill = len[GENRE] + 1;
genre_from_v1 = 1;
}
}
}
if(tag[GENRE].fill && !genre_from_v1)
{
/*
id3v2.3 says (id)(id)blabla and in case you want ot have (blabla) write ((blabla)
also, there is
(RX) Remix
(CR) Cover
id3v2.4 says
"one or several of the ID3v1 types as numerical strings"
or define your own (write strings), RX and CR
Now I am very sure that I'll encounter hellishly mixed up id3v2 frames, so try to parse both at once.
*/
mpg123_string tmp;
mpg123_init_string(&tmp);
debug1("interpreting genre: %s\n", tag[GENRE].p);
if(mpg123_copy_string(&tag[GENRE], &tmp))
{
size_t num = 0;
size_t nonum = 0;
size_t i;
enum { nothing, number, outtahere } state = nothing;
tag[GENRE].fill = 0; /* going to be refilled */
/* number\n -> id3v1 genre */
/* (number) -> id3v1 genre */
/* (( -> ( */
for(i = 0; i < tmp.fill; ++i)
{
debug1("i=%lu", (unsigned long) i);
switch(state)
{
case nothing:
nonum = i;
if(tmp.p[i] == '(')
{
num = i+1; /* number starting as next? */
state = number;
debug1("( before number at %lu?", (unsigned long) num);
}
/* you know an encoding where this doesn't work? */
else if(tmp.p[i] >= '0' && tmp.p[i] <= '9')
{
num = i;
state = number;
debug1("direct number at %lu", (unsigned long) num);
}
else state = outtahere;
break;
case number:
/* fake number alert: (( -> ( */
if(tmp.p[i] == '(')
{
nonum = i;
state = outtahere;
debug("no, it was ((");
}
else if(tmp.p[i] == ')' || tmp.p[i] == '\n' || tmp.p[i] == 0)
{
if(i-num > 0)
{
/* we really have a number */
int gid;
char* genre = "Unknown";
tmp.p[i] = 0;
gid = atoi(tmp.p+num);
/* get that genre */
if(gid >= 0 && gid <= genre_count) genre = genre_table[gid];
debug1("found genre: %s", genre);
if(tag[GENRE].fill) mpg123_add_string(&tag[GENRE], ", ");
mpg123_add_string(&tag[GENRE], genre);
nonum = i+1; /* next possible stuff */
state = nothing;
debug1("had a number: %i", gid);
}
else
{
/* wasn't a number, nonum is set */
state = outtahere;
debug("no (num) thing...");
}
}
else if(!(tmp.p[i] >= '0' && tmp.p[i] <= '9'))
{
/* no number at last... */
state = outtahere;
debug("nothing numeric here");
}
else
{
debug("still number...");
}
break;
default: break;
}
if(state == outtahere) break;
}
if(nonum < tmp.fill-1)
{
if(tag[GENRE].fill) mpg123_add_string(&tag[GENRE], ", ");
mpg123_add_string(&tag[GENRE], tmp.p+nonum);
}
/* Do not like that ... assumes plain ASCII ... */
len[GENRE] = strlen(tag[GENRE].p);
}
mpg123_free_string(&tmp);
}
if(long_id3)
{
fprintf(out,"\n");
/* print id3v2 */
print_oneline(out, tag, TITLE, TRUE);
print_oneline(out, tag, ARTIST, TRUE);
print_oneline(out, tag, ALBUM, TRUE);
print_oneline(out, tag, YEAR, TRUE);
print_oneline(out, tag, GENRE, TRUE);
print_oneline(out, tag, COMMENT, TRUE);
fprintf(out,"\n");
}
else
{
/* We are trying to be smart here and conserve some vertical space.
So we will skip tags not set, and try to show them in two parallel
columns if they are short, which is by far the most common case. */
int linelimit;
/* Overhead is Name + ": " and also plus " " for right column. */
const int overhead[2] = { namelen[0]+2, namelen[1]+4 };
int climit[2];
/* Adapt formatting width to terminal if possible. */
linelimit = term_width(fileno(out));
if(linelimit < 0)
linelimit=overhead[0]+30+overhead[1]+30; /* the old style, based on ID3v1 */
if(linelimit > 200)
linelimit = 200; /* Not too wide. Also for format string safety. */
/* Divide the space between the two columns, not wasting any. */
climit[1] = linelimit/2-overhead[0];
climit[0] = linelimit-linelimit/2-overhead[1];
debug3("linelimits: %i < %i | %i >", linelimit, climit[0], climit[1]);
if(climit[0] <= 0 || climit[1] <= 0)
{
/* Ensure disabled column printing, no play with signedness in comparisons. */
climit[0] = 0;
climit[1] = 0;
}
fprintf(out,"\n"); /* Still use one separator line. Too ugly without. */
print_pair(out, climit, tag, len, TITLE, ARTIST);
print_pair(out, climit, tag, len, COMMENT, ALBUM );
print_pair(out, climit, tag, len, YEAR, GENRE );
}
for(ti=0; ti<FIELDS; ++ti) mpg123_free_string(&tag[ti]);
if(v2 != NULL && APPFLAG(MPG123APP_LYRICS))
{
/* find and print texts that have USLT IDs */
size_t i;
for(i=0; i<v2->texts; ++i)
{
if(!memcmp(v2->text[i].id, "USLT", 4))
{
/* split into lines, ensure usage of proper local line end */
size_t a=0;
size_t b=0;
char lang[4]; /* just a 3-letter ASCII code, no fancy encoding */
mpg123_string innline;
mpg123_string outline;
mpg123_string *uslt = &v2->text[i].text;
memcpy(lang, &v2->text[i].lang, 3);
lang[3] = 0;
printf("Lyrics begin, language: %s; %s\n\n", lang, v2->text[i].description.fill ? v2->text[i].description.p : "");
mpg123_init_string(&innline);
mpg123_init_string(&outline);
while(a < uslt->fill)
{
b = a;
while(b < uslt->fill && uslt->p[b] != '\n' && uslt->p[b] != '\r') ++b;
/* Either found end of a line or end of the string (null byte) */
mpg123_set_substring(&innline, uslt->p, a, b-a);
transform(&outline, &innline);
printf(" %s\n", outline.p);
if(uslt->p[b] == uslt->fill) break; /* nothing more */
/* Swallow CRLF */
if(uslt->fill-b > 1 && uslt->p[b] == '\r' && uslt->p[b+1] == '\n') ++b;
a = b + 1; /* next line beginning */
}
mpg123_free_string(&innline);
mpg123_free_string(&outline);
printf("\nLyrics end.\n");
}
}
}
}
