Commit | Line | Data |
---|---|---|
69695f33 MW |
1 | |
2 | /* Copyright (c) 1995, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 by Arkkra Enterprises */ | |
3 | /* All rights reserved */ | |
4 | ||
5 | ||
6 | ||
7 | /* routines for printing info for debugging purposes */ | |
8 | /* It would be nicer to write a program to read the header files and | |
9 | * generate most of these routines from there to keep them up to date, | |
10 | * but this will do for now. */ | |
11 | ||
12 | ||
13 | #include "defines.h" | |
14 | #include "structs.h" | |
15 | #include "globals.h" | |
16 | ||
17 | ||
18 | /* for number-to-English name translations, if we fall off the bottom of | |
19 | * a switch without a match, need to return something, so use "unknown" */ | |
20 | static char Unknown[] = "unknown"; | |
21 | ||
22 | ||
23 | /* static functions */ | |
24 | static void print_ssv P((struct SSV *ssv_p)); | |
25 | static void print_markorder P((struct SSV *ssv_p, int place)); | |
26 | static void print_printdata P((struct PRINTDATA *printdata_p)); | |
27 | static void print_bar P((struct BAR *bar_p)); | |
28 | static void print_chhead P((struct CHORD *ch_p)); | |
29 | static void print_staff P((struct STAFF *staff_p)); | |
30 | static void print_grpsyl P((struct GRPSYL *g_p, char *gstype, int vno)); | |
31 | static void print_slurtolist P((struct NOTE *note_p)); | |
32 | static void pr_stuff P((struct STUFF *stuff_p)); | |
33 | static char *xlate_place P((int place)); | |
34 | static char *xlate_stufftype P((int stuff_type)); | |
35 | static char * xlate_linetype P((int ltype)); | |
36 | static char *xlate_gvalue P((int grpvalue)); | |
37 | static char *xlate_gsize P((int grpsize)); | |
38 | static char *xlate_gcont P((int gcont)); | |
39 | static char *xlate_item P((int item)); | |
40 | static char *xlate_dir P((int dir)); | |
41 | static void print_curve P((struct CURVE *curve_p)); | |
42 | static char *xlate_coordtype P((int coordtype)); | |
43 | \f | |
44 | ||
45 | /* tell what is in the main linked list. Walk down the list and print | |
46 | * things of interest. */ | |
47 | ||
48 | void | |
49 | print_mainll() | |
50 | ||
51 | { | |
52 | struct MAINLL *mll_p; /* to walk through list */ | |
53 | register int i; /* count number of items in list */ | |
54 | int s; /* walk through staffs */ | |
55 | ||
56 | ||
57 | /* only do this stuff if debug level 128 is on */ | |
58 | if (debug_on(128) == 0) { | |
59 | return; | |
60 | } | |
61 | ||
62 | debug(128, "\n\t\t==== Contents of main linked list ====\n"); | |
63 | ||
64 | /* walk down the main linked list, printing things about each struct | |
65 | * in it */ | |
66 | for (i = 0, mll_p = Mainllhc_p; mll_p != (struct MAINLL *) 0; | |
67 | mll_p = mll_p->next, i++) { | |
68 | ||
69 | debug(128, "\nmainll %d: type %s", i, stype_name(mll_p->str)); | |
70 | if (mll_p->inputfile != (char *) 0 && mll_p->inputlineno > 0) { | |
71 | debug(128, "from file %s inputlineno %d", | |
72 | mll_p->inputfile, mll_p->inputlineno); | |
73 | } | |
74 | ||
75 | /* print info of interest based on struct type */ | |
76 | switch (mll_p->str) { | |
77 | ||
78 | case S_SSV: | |
79 | print_ssv(mll_p->u.ssv_p); | |
80 | break; | |
81 | ||
82 | case S_BAR: | |
83 | print_bar(mll_p->u.bar_p); | |
84 | break; | |
85 | ||
86 | case S_CURVE: | |
87 | print_curve(mll_p->u.curve_p); | |
88 | break; | |
89 | ||
90 | case S_LINE: | |
91 | if (mll_p->u.line_p->linetype != L_NORMAL) { | |
92 | debug(128, "\t%s\n", | |
93 | xlate_linetype(mll_p->u.line_p->linetype)); | |
94 | } | |
95 | break; | |
96 | ||
97 | case S_PRHEAD: | |
98 | print_printdata(mll_p->u.prhead_p->printdata_p); | |
99 | break; | |
100 | ||
101 | case S_FEED: | |
102 | debug(128, "\tfeed at (%f, %f) with%s pagefeed\n\tnorth %f, south %f, west %f, east %f", | |
103 | mll_p->u.feed_p->c[AX], mll_p->u.feed_p->c[AY], | |
104 | mll_p->u.feed_p->pagefeed ? "" : "out", | |
105 | mll_p->u.feed_p->c[AN], mll_p->u.feed_p->c[AS], | |
106 | mll_p->u.feed_p->c[AW], mll_p->u.feed_p->c[AE]); | |
107 | debug(128, "\tleftmargin %f rightmargin %f", | |
108 | mll_p->u.feed_p->leftmargin, | |
109 | mll_p->u.feed_p->rightmargin); | |
110 | if (mll_p->u.feed_p->top_p != 0) { | |
111 | debug(128, "\ttop block: height %f", | |
112 | mll_p->u.feed_p->top_p->height); | |
113 | print_printdata(mll_p->u.feed_p->top_p->printdata_p); | |
114 | } | |
115 | if (mll_p->u.feed_p->bot_p != 0) { | |
116 | debug(128, "\tbot block: height %f", | |
117 | mll_p->u.feed_p->bot_p->height); | |
118 | print_printdata(mll_p->u.feed_p->bot_p->printdata_p); | |
119 | } | |
120 | /* Note: after placment top2/bot2 are only meaningful | |
121 | * on final FEED when doing gridsatend with more than | |
122 | * one page worth of grids. */ | |
123 | if (mll_p->u.feed_p->top2_p != 0) { | |
124 | debug(128, "\ttop2 block: height %f", | |
125 | mll_p->u.feed_p->top2_p->height); | |
126 | print_printdata(mll_p->u.feed_p->top2_p->printdata_p); | |
127 | } | |
128 | if (mll_p->u.feed_p->bot2_p != 0) { | |
129 | debug(128, "\tbot2 block: height %f", | |
130 | mll_p->u.feed_p->bot2_p->height); | |
131 | print_printdata(mll_p->u.feed_p->bot2_p->printdata_p); | |
132 | } | |
133 | break; | |
134 | ||
135 | case S_CLEFSIG: | |
136 | debug(128, "\twest at %f, prtimesig %d, hide %d", | |
137 | mll_p->u.clefsig_p->wclefsiga, | |
138 | mll_p->u.clefsig_p->prtimesig, | |
139 | mll_p->u.clefsig_p->hide); | |
140 | if (mll_p->u.clefsig_p->bar_p != (struct BAR *) 0) { | |
141 | debug(128, " clefsig includes pseudo bar:"); | |
142 | print_bar(mll_p->u.clefsig_p->bar_p); | |
143 | } | |
144 | for (s = 1; s <= Score.staffs; s++) { | |
145 | debug(128, " staff %d: prclef %d, %d sharps, %d naturals", | |
146 | s, mll_p->u.clefsig_p->prclef[s], | |
147 | mll_p->u.clefsig_p->sharps[s], | |
148 | mll_p->u.clefsig_p->naturals[s]); | |
149 | } | |
150 | break; | |
151 | ||
152 | case S_CHHEAD: | |
153 | print_chhead(mll_p->u.chhead_p->ch_p); | |
154 | break; | |
155 | ||
156 | case S_STAFF: | |
157 | print_staff(mll_p->u.staff_p); | |
158 | break; | |
159 | ||
160 | case S_BLOCKHEAD: | |
161 | debug(128, "height %f\n", mll_p->u.blockhead_p->height); | |
162 | print_printdata(mll_p->u.blockhead_p->printdata_p); | |
163 | break; | |
164 | default: | |
165 | break; | |
166 | } | |
167 | } | |
168 | } | |
169 | \f | |
170 | ||
171 | /* translate S_* numbers used for the str field of MAINLL struct to names */ | |
172 | ||
173 | char * | |
174 | stype_name(stype) | |
175 | ||
176 | int stype; /* the S_* number to translate */ | |
177 | ||
178 | { | |
179 | switch(stype) { | |
180 | case S_SSV: | |
181 | return("S_SSV"); | |
182 | case S_CHHEAD: | |
183 | return("S_CHHEAD"); | |
184 | case S_PRHEAD: | |
185 | return("S_PRHEAD"); | |
186 | case S_LINE: | |
187 | return("S_LINE"); | |
188 | case S_CURVE: | |
189 | return("S_CURVE"); | |
190 | case S_BAR: | |
191 | return("S_BAR"); | |
192 | case S_CLEFSIG: | |
193 | return("S_CLEFSIG"); | |
194 | case S_FEED: | |
195 | return("S_FEED"); | |
196 | case S_STAFF: | |
197 | return("S_STAFF"); | |
198 | case S_BLOCKHEAD: | |
199 | return("S_BLOCKHEAD"); | |
200 | default: | |
201 | return(Unknown); | |
202 | } | |
203 | } | |
204 | \f | |
205 | ||
206 | /* print some useful info from SSV struct */ | |
207 | ||
208 | static void | |
209 | print_ssv(ssv_p) | |
210 | ||
211 | struct SSV *ssv_p; /* which struct to report on */ | |
212 | ||
213 | { | |
214 | debug(128, "\tcontext = %s", contextname(ssv_p->context)); | |
215 | debug(128, "\tstaffno = %d", ssv_p->staffno); | |
216 | debug(128, "\tvoiceno = %d", ssv_p->voiceno); | |
217 | if (ssv_p->strinfo != (struct STRINGINFO *) 0) { | |
218 | int i; | |
219 | ||
220 | for (i = 0; i < ssv_p->stafflines; i++) { | |
221 | debug(128, "\t\ttab string %d: %c%c nticks=%d, oct=%d", | |
222 | i, ssv_p->strinfo[i].letter, | |
223 | ssv_p->strinfo[i].accidental == '\0' | |
224 | ? ' ' : ssv_p->strinfo[i].accidental, | |
225 | ssv_p->strinfo[i].nticks, | |
226 | ssv_p->strinfo[i].octave); | |
227 | } | |
228 | } | |
229 | if (ssv_p->used[ABOVEORDER] == YES) { | |
230 | print_markorder(ssv_p, PL_ABOVE); | |
231 | } | |
232 | if (ssv_p->used[BELOWORDER] == YES) { | |
233 | print_markorder(ssv_p, PL_BELOW); | |
234 | } | |
235 | if (ssv_p->used[BETWEENORDER] == YES) { | |
236 | print_markorder(ssv_p, PL_BETWEEN); | |
237 | } | |
238 | } | |
239 | ||
240 | static void | |
241 | print_markorder(ssv_p, place) | |
242 | ||
243 | struct SSV *ssv_p; | |
244 | int place; | |
245 | ||
246 | { | |
247 | int m; | |
248 | ||
249 | debug(128, "\tmarkorder %s: ", xlate_place(place)); | |
250 | for (m = 0; m < NUM_MARK; m++) { | |
251 | debug(128, "\t\t%d ", ssv_p->markorder[place][m]); | |
252 | } | |
253 | debug(128, "\n"); | |
254 | } | |
255 | \f | |
256 | ||
257 | /* print useful info from STAFF struct */ | |
258 | ||
259 | static void | |
260 | print_staff(staff_p) | |
261 | ||
262 | struct STAFF *staff_p; /* which to report on */ | |
263 | ||
264 | { | |
265 | register int i; /* index to walk down a list */ | |
266 | ||
267 | ||
268 | debug(128, "\tstaffno = %d, visible = %s", staff_p->staffno, | |
269 | staff_p->visible == YES ? "y" : "n"); | |
270 | ||
271 | /* print each group */ | |
272 | for ( i = 0; i < MAXVOICES; i++) { | |
273 | if (staff_p->groups_p[i] != (struct GRPSYL *) 0) { | |
274 | print_grpsyl(staff_p->groups_p[i], "GROUP", i + 1); | |
275 | } | |
276 | } | |
277 | ||
278 | /* print each lyrics syllable */ | |
279 | for (i = 0; i < staff_p->nsyllists; i++) { | |
280 | debug(128, "\n\tsylplace = %s", | |
281 | xlate_place(staff_p->sylplace[i])); | |
282 | print_grpsyl(staff_p->syls_p[i], "SYLLABLE", | |
283 | staff_p->syls_p[i]->vno); | |
284 | } | |
285 | ||
286 | pr_stuff(staff_p->stuff_p); | |
287 | } | |
288 | \f | |
289 | ||
290 | /* print info from a list of GRPSYL structs */ | |
291 | ||
292 | static void | |
293 | print_grpsyl(g_p, gstype, vno) | |
294 | ||
295 | struct GRPSYL *g_p; /* which GRPSYL */ | |
296 | char *gstype; /* "GROUP" or "SYLLABLE" */ | |
297 | int vno; /* voice number or verse number */ | |
298 | ||
299 | { | |
300 | register int i; /* index through list */ | |
301 | char *sylbuff; /* syllable with all ASCII characters */ | |
302 | ||
303 | ||
304 | if (debug_on(128) == 0) { | |
305 | return; | |
306 | } | |
307 | ||
308 | (void) fprintf(stderr, "\tgrpsyl = %s, vno = %d\n", gstype, vno); | |
309 | ||
310 | /* print info about the stuff in GRPSYL structs */ | |
311 | for ( ; g_p != (struct GRPSYL *) 0; g_p = g_p->next) { | |
312 | ||
313 | (void) fprintf(stderr, "\n\t\tbasictime = %d, dots = %d, fulltime = %ld/%ld\n", | |
314 | g_p->basictime, g_p->dots, | |
315 | g_p->fulltime.n, g_p->fulltime.d); | |
316 | (void) fprintf(stderr, "\t\tc[AX] = %f, c[AY] = %f\n", | |
317 | g_p->c[AX], g_p->c[AY]); | |
318 | (void) fprintf(stderr, "\t\tc[AW] = %f, c[AE] = %f\n", | |
319 | g_p->c[AW], g_p->c[AE]); | |
320 | (void) fprintf(stderr, "\t\tc[AN] = %f, c[AS] = %f\n", | |
321 | g_p->c[AN], g_p->c[AS]); | |
322 | if (g_p->ho_usage != HO_NONE) { | |
323 | (void) fprintf(stderr, "\t\tho_usage = %d", g_p->ho_usage); | |
324 | if (g_p->ho_usage == HO_VALUE) { | |
325 | (void) fprintf(stderr, ", ho_value = %f", | |
326 | g_p->ho_value); | |
327 | } | |
328 | (void) fprintf(stderr, "\n"); | |
329 | } | |
330 | ||
331 | /* if group, print info about it, including the list of | |
332 | * notes if any */ | |
333 | if (g_p->grpsyl == GS_GROUP) { | |
334 | ||
335 | (void) fprintf(stderr, "\t\tclef = %d, xdotr = %f, stemx = %f\n", | |
336 | g_p->clef, g_p->xdotr, g_p->stemx); | |
337 | (void) fprintf(stderr, "\t\tgrpvalue = %s, grpsize = %s, headshape = %d,\n\t\tgrpcont = %s, beamloc = %s, beamslope=%f\n", | |
338 | xlate_gvalue(g_p->grpvalue), | |
339 | xlate_gsize(g_p->grpsize), | |
340 | g_p->headshape, | |
341 | xlate_gcont(g_p->grpcont), | |
342 | xlate_item(g_p->beamloc), | |
343 | g_p->beamslope); | |
344 | if (g_p->roll != NOITEM) { | |
345 | (void) fprintf(stderr, "\t\troll = %s, rolldir = %s\n", | |
346 | xlate_item(g_p->roll), | |
347 | xlate_dir(g_p->rolldir)); | |
348 | } | |
349 | ||
350 | if( g_p->padding != 0.0) { | |
351 | (void) fprintf(stderr, "\t\tpadding=%f\n", g_p->padding); | |
352 | } | |
353 | (void) fprintf(stderr, "\t\tis_meas=%d, uncompressible=%d\n", | |
354 | g_p->is_meas, g_p->uncompressible); | |
355 | ||
356 | (void) fprintf(stderr, "\t\tstemlen=%f, stemdir=%s\n", | |
357 | g_p->stemlen, xlate_dir(g_p->stemdir)); | |
358 | (void) fprintf(stderr, "\t\ttie=%d, slash_alt=%d\n", | |
359 | g_p->tie, g_p->slash_alt); | |
360 | ||
361 | /* if part of tuplet, print info about that */ | |
362 | if (g_p->tuploc != NOITEM) { | |
363 | (void) fprintf(stderr, "\t\ttuploc=%s, tupcont=%d\n", | |
364 | xlate_item(g_p->tuploc), g_p->tupcont); | |
365 | (void) fprintf(stderr, "\t\tprinttup=%d, tupside=%s, tupextend=%f\n", | |
366 | g_p->printtup, xlate_place(g_p->tupside), | |
367 | g_p->tupextend); | |
368 | } | |
369 | ||
370 | /* print a bit about "with" lists */ | |
371 | if (g_p->nwith) { | |
372 | int w; | |
373 | (void) fprintf(stderr, "\t\t%d items in 'with' list (normwith=%d):\n", | |
374 | g_p->nwith, g_p->normwith); | |
375 | for (w = 0; w < g_p->nwith; w++) { | |
376 | (void) fprintf(stderr, "\t\t\t\"%s\"\n", | |
377 | ascii_str(g_p->withlist[w], | |
378 | YES, NO, TM_NONE)); | |
379 | } | |
380 | } | |
381 | ||
382 | (void) fprintf(stderr, "\t\tnnotes = %d, beamto = %d, stemto = %d, stemto_idx = %d\n", | |
383 | g_p->nnotes, g_p->beamto, | |
384 | g_p->stemto, g_p->stemto_idx); | |
385 | for (i = 0; i < g_p->nnotes; i++) { | |
386 | if (is_tab_staff(g_p->staffno) == YES) { | |
387 | (void) fprintf(stderr, "\t\t\tstring %d, fret %d, bend %d %d/%d, fret_paren %d\n", | |
388 | g_p->notelist[i].STRINGNO, | |
389 | g_p->notelist[i].FRETNO, | |
390 | BENDINT(g_p->notelist[i]), | |
391 | BENDNUM(g_p->notelist[i]), | |
392 | BENDDEN(g_p->notelist[i]), | |
393 | g_p->notelist[i].FRET_HAS_PAREN); | |
394 | continue; | |
395 | } | |
396 | (void) fprintf(stderr, "\t\t\t%c %c %d steps %d", | |
397 | g_p->notelist[i].letter, | |
398 | g_p->notelist[i].accidental == '\0' | |
399 | ? ' ' : g_p->notelist[i].accidental, | |
400 | g_p->notelist[i].octave, | |
401 | g_p->notelist[i].stepsup); | |
402 | if (g_p->notelist[i].note_has_paren == YES) { | |
403 | (void) fprintf(stderr, " note_paren (%f, %f)", | |
404 | g_p->notelist[i].wlparen, | |
405 | g_p->notelist[i].erparen); | |
406 | } | |
407 | if (g_p->notelist[i].acc_has_paren == YES) { | |
408 | (void) fprintf(stderr, " acc_paren"); | |
409 | } | |
410 | if (g_p->notelist[i].tie == YES) { | |
411 | (void) fprintf(stderr, " tie(style %d)", | |
412 | g_p->notelist[i].tiestyle); | |
413 | } | |
414 | ||
415 | (void) fprintf(stderr, " (headshape %d, headchar %d, headfont %d)", | |
416 | g_p->notelist[i].headshape, | |
417 | g_p->notelist[i].headchar, | |
418 | g_p->notelist[i].headfont); | |
419 | if (g_p->notelist[i].notesize != GS_NORMAL) { | |
420 | (void) fprintf(stderr, " (size %s)", | |
421 | xlate_gsize(g_p->notelist[i] | |
422 | .notesize)); | |
423 | } | |
424 | if (g_p->notelist[i].is_bend == YES) { | |
425 | fprintf(stderr, " is_bend"); | |
426 | } | |
427 | if (g_p->notelist[i].smallbend == YES) { | |
428 | fprintf(stderr, " smallbend"); | |
429 | } | |
430 | print_slurtolist( &(g_p->notelist[i]) ); | |
431 | (void) fprintf(stderr, "\n"); | |
432 | } | |
433 | } | |
434 | ||
435 | ||
436 | /* if syllable, print it */ | |
437 | if (g_p->syl != (char *) 0) { | |
438 | sylbuff = ascii_str(g_p->syl, YES, NO, TM_NONE); | |
439 | (void) fprintf(stderr, "\t\tsyllable = '%s', font %d, size %d\n", | |
440 | sylbuff, g_p->syl[0], g_p->syl[1]); | |
441 | } | |
442 | } | |
443 | } | |
444 | \f | |
445 | ||
446 | /* print any slurtolist entries */ | |
447 | ||
448 | static void | |
449 | print_slurtolist(note_p) | |
450 | ||
451 | struct NOTE *note_p; | |
452 | ||
453 | { | |
454 | register int n; | |
455 | ||
456 | if ( (note_p->nslurto == 0) || (debug_on(128) == 0) ) { | |
457 | return; | |
458 | } | |
459 | ||
460 | (void) fprintf(stderr, " slurred to:"); | |
461 | for (n = note_p->nslurto - 1; n >= 0; n--) { | |
462 | switch (note_p->slurtolist[n].octave) { | |
463 | case IN_UPWARD: | |
464 | (void) fprintf(stderr, " IN_UPWARD"); | |
465 | break; | |
466 | case IN_DOWNWARD: | |
467 | (void) fprintf(stderr, " IN_DOWNWARD"); | |
468 | break; | |
469 | case OUT_UPWARD: | |
470 | (void) fprintf(stderr, " OUT_UPWARD"); | |
471 | break; | |
472 | case OUT_DOWNWARD: | |
473 | (void) fprintf(stderr, " OUT_DOWNWARD"); | |
474 | break; | |
475 | default: | |
476 | (void) fprintf(stderr, " %c%d", | |
477 | note_p->slurtolist[n].letter, | |
478 | note_p->slurtolist[n].octave); | |
479 | } | |
480 | } | |
481 | } | |
482 | \f | |
483 | ||
484 | /* given a GV_* value, return its English name */ | |
485 | ||
486 | static char * | |
487 | xlate_gvalue(grpvalue) | |
488 | ||
489 | int grpvalue; | |
490 | ||
491 | { | |
492 | switch (grpvalue) { | |
493 | case GV_NORMAL: | |
494 | return("NORMAL"); | |
495 | case GV_ZERO: | |
496 | return("ZERO"); | |
497 | default: | |
498 | return(Unknown); | |
499 | } | |
500 | } | |
501 | \f | |
502 | ||
503 | /* given a GS_* value, return its English name */ | |
504 | ||
505 | static char * | |
506 | xlate_gsize(grpsize) | |
507 | ||
508 | int grpsize; | |
509 | ||
510 | { | |
511 | switch(grpsize) { | |
512 | case GS_NORMAL: | |
513 | return("NORMAL"); | |
514 | case GS_SMALL: | |
515 | return("SMALL"); | |
516 | default: | |
517 | return(Unknown); | |
518 | } | |
519 | } | |
520 | \f | |
521 | ||
522 | /* given a GC_* grpcont value, return its English name */ | |
523 | ||
524 | static char * | |
525 | xlate_gcont(grpcont) | |
526 | ||
527 | int grpcont; | |
528 | ||
529 | { | |
530 | switch(grpcont) { | |
531 | case GC_NOTES: | |
532 | return("NOTES"); | |
533 | case GC_REST: | |
534 | return("REST"); | |
535 | case GC_SPACE: | |
536 | return("SPACE"); | |
537 | default: | |
538 | return(Unknown); | |
539 | } | |
540 | } | |
541 | \f | |
542 | ||
543 | /* given an "ITEM" value, return its English name */ | |
544 | ||
545 | static char * | |
546 | xlate_item(item) | |
547 | ||
548 | int item; | |
549 | ||
550 | { | |
551 | switch(item) { | |
552 | case NOITEM: | |
553 | return("NOITEM"); | |
554 | case INITEM: | |
555 | return("INITEM"); | |
556 | case STARTITEM: | |
557 | return("STARTITEM"); | |
558 | case ENDITEM: | |
559 | return("ENDITEM"); | |
560 | case LONEITEM: | |
561 | return("LONEITEM"); | |
562 | default: | |
563 | return(Unknown); | |
564 | } | |
565 | } | |
566 | \f | |
567 | ||
568 | /* translate direction to name */ | |
569 | ||
570 | static char * | |
571 | xlate_dir(dir) | |
572 | ||
573 | int dir; | |
574 | ||
575 | { | |
576 | switch(dir) { | |
577 | case UP: | |
578 | return("UP"); | |
579 | case DOWN: | |
580 | return("DOWN"); | |
581 | default: | |
582 | return("UNKNOWN"); | |
583 | } | |
584 | } | |
585 | \f | |
586 | ||
587 | /* recursively print info from a list of PRINTDATA structs */ | |
588 | ||
589 | static void | |
590 | print_printdata(printdata_p) | |
591 | ||
592 | struct PRINTDATA *printdata_p; | |
593 | ||
594 | { | |
595 | char *buff; /* for all-ASCII version. */ | |
596 | ||
597 | ||
598 | if (printdata_p == (struct PRINTDATA *) 0) { | |
599 | /* we're at the end of the line... */ | |
600 | return; | |
601 | } | |
602 | ||
603 | buff = ascii_str(printdata_p->string, YES, NO, TM_NONE); | |
604 | debug(128, "\tprint (isPostScript %d, justify %d, width %.2f, font %d, size %d) '%s'", | |
605 | printdata_p->isPostScript, printdata_p->justifytype, | |
606 | printdata_p->width, (int) printdata_p->string[0], | |
607 | (int) printdata_p->string[1], buff); | |
608 | ||
609 | /* recurse down the list */ | |
610 | print_printdata(printdata_p->next); | |
611 | } | |
612 | \f | |
613 | ||
614 | /* print useful info from a bar struct */ | |
615 | ||
616 | static void | |
617 | print_bar(bar_p) | |
618 | ||
619 | struct BAR *bar_p; | |
620 | ||
621 | { | |
622 | char *type; | |
623 | struct TIMEDSSV *tssv_p; /* list of mid-meas param changes */ | |
624 | ||
625 | switch(bar_p->bartype) { | |
626 | case INVISBAR: | |
627 | type = "INVISBAR"; | |
628 | break; | |
629 | case SINGLEBAR: | |
630 | type = "SINGLEBAR"; | |
631 | break; | |
632 | case DOUBLEBAR: | |
633 | type = "DOUBLEBAR"; | |
634 | break; | |
635 | case REPEATSTART: | |
636 | type = "REPEATSTART"; | |
637 | break; | |
638 | case REPEATEND: | |
639 | type = "REPEATEND"; | |
640 | break; | |
641 | case REPEATBOTH: | |
642 | type = "REPEATBOTH"; | |
643 | break; | |
644 | case ENDBAR: | |
645 | type = "ENDBAR"; | |
646 | break; | |
647 | case RESTART: | |
648 | type = "RESTART"; | |
649 | break; | |
650 | default: | |
651 | type = Unknown; | |
652 | break; | |
653 | } | |
654 | ||
655 | debug(128, "\tbartype = %d (%s), endingloc=%d", bar_p->bartype, type, | |
656 | bar_p->endingloc); | |
657 | debug(128, "\tx = %f, y = %f, mnum = %d", bar_p->c[AX], bar_p->c[AY], | |
658 | bar_p->mnum); | |
659 | if (bar_p->reh_string != 0) { | |
660 | debug(128, "\treh_string = '%s'", | |
661 | ascii_str(bar_p->reh_string, YES, NO, TM_NONE)); | |
662 | } | |
663 | ||
664 | for (tssv_p = bar_p->timedssv_p; tssv_p != 0; tssv_p = tssv_p->next) { | |
665 | debug(128, "\tTimed SSV, time_off %d/%d\n", tssv_p->time_off.n, | |
666 | tssv_p->time_off.d); | |
667 | print_ssv(&tssv_p->ssv); | |
668 | } | |
669 | } | |
670 | \f | |
671 | ||
672 | /* recursively print coord info about chords in chord list */ | |
673 | ||
674 | static void | |
675 | print_chhead(ch_p) | |
676 | ||
677 | struct CHORD *ch_p; | |
678 | ||
679 | { | |
680 | struct GRPSYL * gs_p; | |
681 | ||
682 | ||
683 | if (ch_p != (struct CHORD *) 0) { | |
684 | debug(128, "\tchord at (%f, %f), width %f, fullwidth %f", | |
685 | ch_p->c[AX], ch_p->c[AY], ch_p->width, ch_p->fullwidth); | |
686 | debug(128, "\tc[RW] = %f, c[RE] = %f", ch_p->c[RW], ch_p->c[RE]); | |
687 | debug(128, "\tstarttime %d/%d, duration %d/%d, pseudodur %f", | |
688 | ch_p->starttime.n, ch_p->starttime.d, | |
689 | ch_p->duration.n, ch_p->duration.d, | |
690 | ch_p->pseudodur); | |
691 | for (gs_p = ch_p->gs_p; gs_p != (struct GRPSYL *) 0; | |
692 | gs_p = gs_p->gs_p) { | |
693 | debug(128, "\t\t%s, staff %d, vno %d", | |
694 | gs_p->grpsyl == GS_GROUP ? "GROUP" | |
695 | : "SYLLABLE", gs_p->staffno, | |
696 | gs_p->vno); | |
697 | } | |
698 | print_chhead(ch_p->ch_p); | |
699 | } | |
700 | } | |
701 | \f | |
702 | ||
703 | /* print information about a STUFF list */ | |
704 | ||
705 | static void | |
706 | pr_stuff(stuff_p) | |
707 | ||
708 | struct STUFF *stuff_p; | |
709 | ||
710 | { | |
711 | char *buff; /* for all-ASCII version */ | |
712 | ||
713 | ||
714 | for ( ; stuff_p != (struct STUFF *) 0; stuff_p = stuff_p->next) { | |
715 | ||
716 | debug(128, "\nSTUFF: %s %s %s: start=%f (%d) [%f], end=%dm+%f, all=%d, x=%f, y=%f", | |
717 | xlate_stufftype(stuff_p->stuff_type), | |
718 | (stuff_p->stuff_type == ST_PHRASE | |
719 | ? xlate_linetype(stuff_p->modifier) | |
720 | : stuff_modifier(stuff_p->modifier)), | |
721 | xlate_place(stuff_p->place), stuff_p->start.count, | |
722 | stuff_p->gracebackup, stuff_p->start.steps, | |
723 | stuff_p->end.bars, stuff_p->end.count, stuff_p->all, | |
724 | stuff_p->c[AX], stuff_p->c[AY]); | |
725 | ||
726 | if (stuff_p->string != (char *) 0) { | |
727 | buff = ascii_str(stuff_p->string, YES, NO, stuff_p->modifier); | |
728 | debug(128, "\tstring = \"%s\"", buff); | |
729 | } | |
730 | } | |
731 | } | |
732 | \f | |
733 | ||
734 | /* given a PL_* place value, return its English name */ | |
735 | ||
736 | static char * | |
737 | xlate_place(place) | |
738 | ||
739 | int place; | |
740 | ||
741 | { | |
742 | switch(place) { | |
743 | case PL_ABOVE: | |
744 | return("above"); | |
745 | case PL_BELOW: | |
746 | return("below"); | |
747 | case PL_BETWEEN: | |
748 | return("between"); | |
749 | case PL_UNKNOWN: | |
750 | return("unknown"); | |
751 | default: | |
752 | return("invalid place"); | |
753 | } | |
754 | } | |
755 | \f | |
756 | ||
757 | /* given a ST_* stufftype, return its English name */ | |
758 | ||
759 | ||
760 | static char * | |
761 | xlate_stufftype(stuff_type) | |
762 | ||
763 | int stuff_type; | |
764 | ||
765 | { | |
766 | switch (stuff_type) { | |
767 | case ST_ROM: | |
768 | return("rom"); | |
769 | case ST_BOLD: | |
770 | return("bold"); | |
771 | case ST_ITAL: | |
772 | return("ital"); | |
773 | case ST_BOLDITAL: | |
774 | return("boldital"); | |
775 | case ST_CRESC: | |
776 | return("cresc"); | |
777 | case ST_DECRESC: | |
778 | return("decresc"); | |
779 | case ST_MUSSYM: | |
780 | return("mussym"); | |
781 | case ST_PHRASE: | |
782 | return("phrase"); | |
783 | case ST_PEDAL: | |
784 | return("pedal"); | |
785 | case ST_OCTAVE: | |
786 | return("octave"); | |
787 | case ST_MIDI: | |
788 | return("MIDI"); | |
789 | case ST_TIESLUR: | |
790 | return("TIESLUR"); | |
791 | case ST_TABSLUR: | |
792 | return("TABSLUR"); | |
793 | case ST_BEND: | |
794 | return("BEND"); | |
795 | default: | |
796 | return("unknown stuff_type"); | |
797 | } | |
798 | } | |
799 | \f | |
800 | ||
801 | /* Translate L_ line type to name */ | |
802 | ||
803 | static char * | |
804 | xlate_linetype(ltype) | |
805 | ||
806 | int ltype; /* L_* value */ | |
807 | ||
808 | { | |
809 | switch(ltype) { | |
810 | case L_NORMAL: | |
811 | return(""); | |
812 | case L_MEDIUM: | |
813 | return("medium"); | |
814 | case L_WIDE: | |
815 | return("wide"); | |
816 | case L_DOTTED: | |
817 | return("dotted"); | |
818 | case L_DASHED: | |
819 | return("dashed"); | |
820 | case L_WAVY: | |
821 | return("wavy"); | |
822 | default: | |
823 | return("unknown"); | |
824 | } | |
825 | } | |
826 | \f | |
827 | ||
828 | static void | |
829 | print_curve(curve_p) | |
830 | ||
831 | struct CURVE *curve_p; | |
832 | ||
833 | { | |
834 | struct COORD_INFO *cinfo_p; | |
835 | int n; | |
836 | ||
837 | if (debug_on(128) == 0) { | |
838 | return; | |
839 | } | |
840 | ||
841 | for (n = 0; n < curve_p->ncoord; n++) { | |
842 | if ((cinfo_p = find_coord(curve_p->coordlist[n].hor_p)) != 0) { | |
843 | debug(128, "\thor_p = 0x%lx, page = %d, score = %d, pseudo_bar_p = %lx", | |
844 | curve_p->coordlist[n].hor_p, | |
845 | cinfo_p->page, cinfo_p->scorenum, | |
846 | cinfo_p->pseudo_bar_p); | |
847 | } | |
848 | debug(128, "\thtype = %s, hsteps = %f, counts = %f", | |
849 | xlate_coordtype(curve_p->coordlist[n].htype), | |
850 | curve_p->coordlist[n].hsteps, | |
851 | curve_p->coordlist[n].counts); | |
852 | if ((cinfo_p = find_coord(curve_p->coordlist[n].vert_p)) != 0) { | |
853 | debug(128, "\tvert_p = 0x%lx, page = %d, score = %d, pseudo_bar_p = %lx", | |
854 | curve_p->coordlist[n].vert_p, | |
855 | cinfo_p->page, cinfo_p->scorenum, | |
856 | cinfo_p->pseudo_bar_p); | |
857 | } | |
858 | debug(128, "\tvtype = %s, vsteps = %f\n", | |
859 | xlate_coordtype(curve_p->coordlist[n].vtype), | |
860 | curve_p->coordlist[n].vsteps); | |
861 | } | |
862 | } | |
863 | ||
864 | /* given an absolute coordinate type like AX, return its name */ | |
865 | ||
866 | static char | |
867 | *xlate_coordtype(coordtype) | |
868 | ||
869 | int coordtype; | |
870 | ||
871 | { | |
872 | switch(coordtype) { | |
873 | case AX: | |
874 | return("AX"); | |
875 | case AY: | |
876 | return("AY"); | |
877 | case AN: | |
878 | return("AN"); | |
879 | case AS: | |
880 | return("AS"); | |
881 | case AE: | |
882 | return("AE"); | |
883 | case AW: | |
884 | return("AW"); | |
885 | default: | |
886 | return(Unknown); | |
887 | } | |
888 | } |