diff options
Diffstat (limited to 'Build/source/texk/musixflx/musixflx-0.83.2/musixflx.c')
-rw-r--r-- | Build/source/texk/musixflx/musixflx-0.83.2/musixflx.c | 928 |
1 files changed, 0 insertions, 928 deletions
diff --git a/Build/source/texk/musixflx/musixflx-0.83.2/musixflx.c b/Build/source/texk/musixflx/musixflx-0.83.2/musixflx.c deleted file mode 100644 index 4c0086abba8..00000000000 --- a/Build/source/texk/musixflx/musixflx-0.83.2/musixflx.c +++ /dev/null @@ -1,928 +0,0 @@ -#define MUSIXFLXVERSION "0.83" -#define MYVERSION "/T.63dt+jh.2\0" /* Revision jh.2 jh-2 */ - /* Don't know who jh is. Bob Tennent */ - -/**************************************************************************** - Line breaking program for MusiXTeX. - (c) Ross Mitchell 1992-1997 ross.mitchell@csiro.au - (c) Copyright (C) 2009, 2010 Peter Breitenlohner <tex-live@tug.org> - - -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 2 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., -51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - -*****************************************************************************/ - -#include <config.h> -#include <stdio.h> -#include <string.h> -#include <stdlib.h> -#include <ctype.h> - -#define TRUE 1 -#define FALSE 0 - -/* FILENAME_MAX should be in stdio.h, but if your compiler loses, - here's a replacement. */ -#ifndef FILENAME_MAX -#define FILENAME_MAX 512 -#endif -#define FNL FILENAME_MAX - -/* attention: every \changecontext reports a change of \sign@skip */ - -#define MAX_SIGNS 128 /* max signature changes */ -#define MAX_SECTIONS 128 /* max sections */ -#define MAX_BARS 2048 /* max number of bars */ - -#define GETLINE fgets(linebuf, (int) sizeof(linebuf), infile) - -int zbar[MAX_BARS], lr_repeat[MAX_BARS], raggedline[MAX_BARS], - l_repeat[MAX_BARS], barno[MAX_BARS], autolines[MAX_SECTIONS], - bars[MAX_SECTIONS], mulooseness[MAX_SECTIONS], signchange[MAX_SIGNS], - /* Counters and storage needed to detect xbar sign changes. jh-1 */ - xbar_count, xbar_flag, softspace_count, xbar[MAX_BARS], - linegoal[MAX_SECTIONS], natural_lines /* jh-2 */; - -double hardbarlength[MAX_BARS], softbarlength[MAX_BARS], - width_leftrightrepeat[MAX_BARS], width_leftrepeat[MAX_BARS], - eff_hardlength[MAX_SECTIONS], eff_softlength[MAX_SECTIONS], - oldsignskip[MAX_SIGNS], signskip[MAX_SIGNS], - futuresignskip[MAX_SIGNS], tempholdskip, hardsign /* jh-1 */; - -FILE *infile, *outfile, *logfile; -char linebuf[128]; - -static void -error_exit(int error_number) -{ - switch (error_number){ - - case 0: - printf("\nFile error: Disk full ?\n"); exit(3); - case 1: - printf("\nUsage: musixflx filename [d|f|s] (optional for debug modes)\n"); - exit(3); - case 2: - printf("\nThis shouldn't happen ! Too less bars or \\mulooseness too large ?\n"); exit(3); - case 3: - printf("\nThis shouldn't happen ! Too less bars in section !\n"); exit(3); - case 4: - printf("\nMissing endmark ! Forgotten \\stop[end]piece ?\n"); exit(3); - case 5: - printf("\nDivision by zero ! Ask a wizard !\n"); exit(3); - default: - printf("!!! Can't go on !!!\n"); exit(3);}} - -int -main(int argc, char **argv) -{ - register int i, j, bar; - - int junk= -9999, - dbug= FALSE, - dbug_lines= FALSE, - dbug_logfile= FALSE, - showresult= FALSE, - detectraggedline= FALSE, - currentline= 1, - samechapter= TRUE, - line_number= 0, - chapterno= 1, - - detect_end, typ, jbar, sign, all_section, section, mark, lines, - lastbarnumber, barsinline, lastbarno, firstbarno, line_in_section; - - double lthick=.4, - flexit, linewidth, parindent, x, spc_factor, elemskip, cor_elemskip, - beforerule, cor_beforerule, afterrule, cor_afterrule, lastbar, - eff_linewidth, fill_length, hardlength, softlength, clefskip; - - char name_of_file [FNL], n_o_f [FNL], n_o_logfile[FNL], MusiXFlxVersion[6]; - - char *p; - - printf("\n <<< musixflex %s >>>\n", VERSION); - printf("\n ... decoding command line\n"); - - if (argc<2 || argc >3) error_exit(1); - -/********************************* - debugging - d debug informations on screen - f debug informations to file .mxl - s show computed lines on screen -**********************************/ - - if (argc==3){ - if (!strcmp("d",argv[2])) dbug=TRUE; - if (!strcmp("m",argv[2])) dbug_lines=TRUE; - if (!strcmp("f",argv[2])){dbug=TRUE; dbug_logfile=TRUE; dbug_lines=TRUE;} - if (!strcmp("s",argv[2])) showresult=TRUE;} - -/************************************** - search for '.', cut string, add '.mx1' -***************************************/ - - strcpy (name_of_file, argv[1]); - - p = strrchr(name_of_file, '.'); - if (p && !strchr(p + 1, '/') -#if defined(__MSDOS__) || defined(WIN32) - && !strchr(p + 1, '\\') -#endif - ) - *p = '\0'; - strcpy(n_o_f, name_of_file); - strcat(name_of_file, ".mx1"); - -/***************************************************** - Open the .mx1 file containing bar length information. -******************************************************/ - - printf(" ... open <%s> for input\n", name_of_file); - - infile = fopen( name_of_file, "r"); - if (!infile){ - printf("\nFile not found: %s\n", name_of_file); exit(3);} - -/*********************** - test versionnumber - and stop if they differ -************************/ - - strcpy(MusiXFlxVersion, MUSIXFLXVERSION); - strcat(MusiXFlxVersion, "\n"); - printf(" ... testing versionnumber\n"); - ++currentline; - if (GETLINE && strcmp(linebuf, MusiXFlxVersion)){ - printf("\n!!! Wrong version !!!\n\nMusiXTeX : %s",linebuf); - printf("musixflx : %s\n",MusiXFlxVersion); error_exit(99);} - -/********************* - Open the output file. -**********************/ - - strcpy (n_o_logfile, n_o_f); - strcat (n_o_f, ".mx2"); - - printf(" ... open <%s> for output\n",n_o_f); - outfile = fopen( n_o_f, "w" ); - if (!outfile) {printf("\nCan't create: %s\n",n_o_f); exit(3);} - -/****************** - Open the log file. -*******************/ - - if (dbug_logfile){ - strcat (n_o_logfile, ".mxl"); - - printf(" ... open <%s> for debugging\n",n_o_logfile); - logfile = fopen( n_o_logfile, "w" ); - if (!logfile) {printf("\nCan't create: %s\n",n_o_logfile); exit(3);} - fprintf(logfile,"Version %s", MusiXFlxVersion);} - -/******************* - skip startindicator -********************/ - - if (GETLINE && strcmp(linebuf,"S\n")){ - printf("\nCorrupted <%s>\n", name_of_file); error_exit(99);} - -/***************************** - do...while loop for - moretimes call of \startpiece - >>>>>>>>>>>>>>>>>>>>>>>>>>> -******************************/ - - GETLINE; - do { - -/**************** - reset all arrays -*****************/ - - if (dbug) printf("\n------- Chapter %d -------\n\n", chapterno); - if (dbug_logfile) - fprintf(logfile, "\n------- Chapter %d -------\n\n", chapterno); - - for (i=0; i<MAX_SIGNS; ++i){ - signchange[i]=junk; - oldsignskip[i]=0; - futuresignskip[i]=0; /* jh-1 */ - signskip[i]=0;} - - for (i=0; i<MAX_BARS; ++i){ - hardbarlength[i]=0; - softbarlength[i]=0; - width_leftrightrepeat[i]=0; - lr_repeat[i]=FALSE; - width_leftrepeat[i]=0; - xbar[i]=0; /* jh-1 */ - l_repeat[i]=FALSE; - zbar[i]=FALSE; - raggedline[i]=FALSE; - barno[i]=0;} - - for (i=0; i<MAX_SECTIONS; ++i){ - eff_hardlength[i]=0; - eff_softlength[i]=0; - bars[i]=0; - autolines[i]=FALSE; - linegoal[i]=0; /* jh-2 */ - mulooseness[i]=0;} - -/***************************** - Read and decode header items: - - 1. Linewidth; - 2. Parindent; - 3. Beforeruleskip; - 4. Afterruleskip; - 5. Elemskip; - 6. Clefskip; - 7. Signskip; -******************************/ - - linewidth = atof(linebuf); ++currentline; - GETLINE; parindent = atof(linebuf); ++currentline; - GETLINE; beforerule = atof(linebuf); ++currentline; - GETLINE; afterrule = atof(linebuf); ++currentline; - GETLINE; elemskip = atof(linebuf); ++currentline; - GETLINE; clefskip = atof(linebuf); ++currentline; - GETLINE; signskip[0]= atof(linebuf); ++currentline; - - futuresignskip[0] = signskip[0]; /* Initialize for xbar signs. jh-1 */ - -/****************************************************************** - Read the records specifying contributions to bar length. - Lengths are of two types: - (a) Hard or unscaleable, eg barlines, clef or meter changes (typ=0). - (b) Soft or scaleable, eg noteboxes which scale with \elemskip (typ=1). - Note that \afterruleskip and \beforerulskip are considered soft. -*******************************************************************/ - - jbar=junk; - i = 0; - sign = 0; - xbar_count = 0; /* Used to detect presence of xbars. jh-1 */ - xbar_flag = FALSE; /* True allows check for xbar. jh-1 */ - hardsign = 0; /* accumulator for hard skip from sign change. jh-1 */ - softspace_count = 0; /* Watch for softspace after bars are posted jh-1 */ - - all_section = 0; - - printf(" ... reading\n"); - - while ( samechapter && GETLINE ) - { - ++currentline; - switch (linebuf[0]) - { - -/*************** - '\startpiece' - stop reading, - compute, - write - and start again -****************/ - - case 'S': - samechapter=FALSE; - break; - -/********************************************************* - End of section. Action: - Right justify the material ending at the previous bar. - Read the number following the *, which is the 'looseness' - parameter of the section just ended. - Reset the bar test integer to JUNK in case the bar number - was reset between sections. -***********************************************************/ - - case '*': - mulooseness[all_section]= (int) atol(strchr(linebuf,' ')); - linegoal[all_section]=0; /* jh-2 + WS-1 */ - sscanf(linebuf+1," %*d %d",linegoal+all_section); /* jh-2 + WS-1 */ - if (mulooseness[all_section] != 0 && linegoal[all_section] > 0 ) { - printf( - "\\linegoal{%d} ignored because \\mulooseness not equal to zero\n" - " for section %d in chapter %d\n", - linegoal[all_section],all_section+1,chapterno); - linegoal[all_section] = 0; /* Reset to ignore it. jh-2 + WS-1 */ - } - ++all_section; - if (all_section>(MAX_SECTIONS-1)){ - printf("\nToo many sections, maximum number of sections: %d\n", - MAX_SECTIONS); exit(3);} - jbar=junk; - break; - -/********************************************************* - autolines. Action: - Right justify the material ending at the previous bar. - Set flag. - Reset the bar test integer to JUNK in case the bar number - was reset between sections. -***********************************************************/ - - case 'a': - autolines[all_section]=TRUE; - ++all_section; - if (all_section>(MAX_SECTIONS-1)){ - printf("\nToo many sections, maximum number of sections: %d\n", - MAX_SECTIONS); exit(3);} - jbar=junk; - break; - -/****************************************************** - found a raggedline, let's set a flag - I think, I'll hardly get a Nobel-Award for coding this - What a pity! :-( - but perhaps a Pulitzer-Award for my comments. :-) -*******************************************************/ - - case 'r': raggedline[i+1]=TRUE; break; - -/************************************* - found \zbar, set flag and store barno -**************************************/ - - case 'z': zbar[i]=TRUE; - barno[i]= (int) atol(strrchr(linebuf, ' ')); - ++xbar_count; /* Help detect xbars, track zbar offsets. jh-1 */ - hardsign = 0; /* reset any sign change skip accumulated. jh-1 */ - softspace_count = 0; /* Reset for next bar. jh-1 */ - break; - -/***************************************** - found a leftrightrepeat - set a flag and store the different widths -******************************************/ - - case 'l': - lr_repeat[i]=TRUE; -/* printf("l found, i=%d\n",i); */ - width_leftrightrepeat[i]=atof(strchr(linebuf, ' ')); -/* printf("width_leftright=%f\n",width_leftrightrepeat[i]); */ - width_leftrepeat[i]=atof(strrchr(linebuf, ' ')); -/* printf("width_left=%f\n",width_leftrepeat[i]); */ - break; - -/************************** - found a leftrepeat - set a flag and store width -***************************/ - - case 'L': - l_repeat[i]=TRUE; - width_leftrepeat[i]=atof(strrchr(linebuf, ' ')); - break; - -/*********** - store barno -************/ - - case 'b': - barno[i]= (int) atol(strrchr(linebuf, ' ')); - ++xbar_count; /* Track possible xbars. jh-1 */ - xbar_flag = TRUE; /* Allow check of next line to detect xbar. jh-1 */ - hardsign = 0; /* Reset accumulated hard sign skip. jh-1 */ - softspace_count = 0; /* Reset for next bar. jh-1 */ - break; - -/********************************** - enabling the use of 'hard' offsets - advance current hardwith - reduce current softwidth -***********************************/ - - case 'h': - x = atof(strrchr(linebuf, ' ')); - softbarlength[i] -= x; - hardbarlength[i] += x; - eff_softlength[all_section] -= x; - eff_hardlength[all_section] += x; - break; - -/*************************************************************** - This record began with 's' and specifies a key signature change - store the signskip, s.b. -***************************************************************/ - - case 's': /* Changes to detect xbar and signchange interaction, jh-1 */ - - tempholdskip=atof(strchr(linebuf,' ')); /* jh-1 */ - - /* We might be in the middle of an xbar setup, and we only want to - increment the sign pointer if this is the first sign change. jh-1 */ - if (!(signchange[sign]==i)){ ++sign; /* first time for this bar set jh-1 */ - signchange[sign]=i; - signskip[sign]=tempholdskip; - oldsignskip[sign]=hardsign; /* Capture accumulated hard space. jh-1 */ - ++xbar[i]; /* Increment to detect xbars with sign changes. jh-1 */ - /* Housekeeping is done... Now, one more condition to check. If there - has been any soft space since the bar was declared, then musixtex - will NOT publish a sign change notice at the end of the line for - this sign change when there is a line break in this bar. - In that case, signal that this should be treated as an xbar, which - will effectively suppress the transfer of hardspace for the sign - change notice. jh-1 */ - if (softspace_count > 0) xbar[i]=2; /* Suppress space move jh-1 */ - } - /* Always update the futuresignskip value in case this is the last */ - futuresignskip[sign]=tempholdskip; - - break; - -/* comment */ - - case '%': break; - -/******************************************************************** - This is an `ordinary' line, listing a contribution to the barlength. -*********************************************************************/ - - default: - if (!isdigit(linebuf[0])){ - printf("\nError in <%s> line %d \n", name_of_file, currentline); - error_exit(99);} - bar= (int) atol(linebuf); - typ= (int) atol(strchr(linebuf, ' ')); - x=atof(strrchr(linebuf, ' ')); - - if (typ) eff_softlength[all_section] += x; - else eff_hardlength[all_section] += x; - -/************************************** - Increment bar number if the bar number - read from the file has changed. - Accumulate current bar length. -***************************************/ - - if (bar>jbar){ - ++i; - ++bars[all_section]; - if(i>MAX_BARS){ - printf("\nToo many bars, maximum number of bars: %d\n", MAX_BARS); - exit(3);}} - - /* At this point, can check if this is an xbar... Only check once. jh-1 */ - if (xbar_flag){ - if ((xbar_count-bar-1)==0){ /* find an xbar. jh-1 */ - --xbar_count; /* adjust offset to stay on track. */ - - /* To handle the special conditions caused by possible xbars and - sign changes, the xbar logic state has to be examined and changed - only if this is the first xbar, and not for subsequent ones. jh-1 */ - if (xbar[i]==0){ /* then this is the first xbar in the set or - there has already been a sign change. jh-1 */ - xbar[i] = 1; /* jh-1 */ - } - }} - xbar_flag = FALSE; /* Reset to prevent checks until next bar. jh-1 */ - - - if (typ) { softbarlength[i] += x; - /* Count softspace entries to help in sign/linebreak decisions jh-1 */ - ++softspace_count; - hardsign = 0; /* safety - just be sure in case line break jh-1 */ - } else { /* jh-1 */ - hardbarlength[i] += x; - hardsign += x; /* accumulate hardspace, there may be a sign change. */ - } - jbar=bar; - } /* eo switch */ - } /* eo while */ - -/************************************************************** - Decrement the number of sections if the final section is void. - This will be the usual case where the input file ends with - an end of section record. - If this record has been omitted, stop going on to avoid - 'You can't use \raise....'. -***************************************************************/ - - printf(" ... compute\n"); - - if (!bars[all_section]) - --all_section; - else - error_exit(4); - -/******************************** - Summarize sectioning information. -*********************************/ - - if (dbug){ - printf("\nNumber of sections : %d\n\n",all_section+1); - - for (section=0; section<=all_section; ++section){ - if (autolines[section]) printf("---- autoline section ----\n"); - printf("Section : %d\n",section+1); - printf("Number of bars in section : %d\n",bars[section]); - printf("Length(hard) of section %d : %f\n", - section+1, eff_hardlength[section]); - printf("Length(soft) of section %d : %f\n", - section+1, eff_softlength[section]); - if (linegoal[section] != 0){ /* linegoal applies. jh-2 */ - printf("Section line goal was determined by \\linegoal value...\n"); - printf("Line Goal for section : %d\n",linegoal[section]); - } else { /* mulooseness applies. jh-2 */ - printf("Looseness of section : %d\n",mulooseness[section]);} - getchar();}} - - if (dbug_logfile){ - fprintf(logfile, "\nNumber of sections : %d\n\n", - all_section+1); - - for (section=0; section<=all_section; ++section){ - if (autolines[section]) - fprintf(logfile, "---- autoline section ----\n"); - fprintf(logfile, "Section : %d\n", - section+1); - fprintf(logfile, "Number of bars in section : %d\n", - bars[section]); - fprintf(logfile, "Length(hard) of section %d : %f\n", - section+1, eff_hardlength[section]); - fprintf(logfile, "Length(soft) of section %d : %f\n", - section+1, eff_softlength[section]); - if (linegoal[section] != 0){ /* line goal applies. jh-2 */ - fprintf(logfile, - "Section line goal was determined by \\linegoal value...\n"); - fprintf(logfile, "Line Goal for section : %d\n",linegoal[section]); - } else { /* mulooseness applies. jh-2 */ - fprintf(logfile, "Looseness of section : %d\n", - mulooseness[section]);} - }} - -/************************************************* - Loop over the sections defined in the input file. - Each section must be right justified. - LAST is the absolute number of the last bar - in the current section. -**************************************************/ - - sign = 0; - mark = 0; - lastbarnumber = 0; - - for(section=0; section<=all_section; ++section){ - line_in_section=1; - lastbarnumber += bars[section]; - -/************************************* - Find number of lines to work towards. -**************************************/ - - lines=((eff_hardlength[section]+eff_softlength[section]+parindent)/ - (linewidth-(clefskip+signskip[sign])))+.5; - if (!lines) lines=1; /* safety */ - - natural_lines = lines; /* Keep this for debug report. jh-2 */ - lines += mulooseness[section]; - if(mulooseness[section] != 0 && linegoal[section] > 0){ /* jh-2 */ - printf("Unexpected line goal reset occurred for section %d\n", section+1); - linegoal[section] = 0; /* Zero it, Safety, should not happen. jh-2 */ - } - if(linegoal[section] > 0) lines = linegoal[section]; /* jh-2 */ - - if (lines<1){lines=1; printf("Don't stress \\mulooseness to much !!!\n");} - -/************************************** - autolinesflag set in current section ? - iftrue force number of lines to 1 -***************************************/ - - if (autolines[section]) lines=1; - - if (dbug){ - printf("Section number : %d\n", section+1); - printf("Last bar in this section : %d\n", lastbarnumber); - printf("Number of bars : %d\n", bars[section]); - printf("Natural number of lines : %d\n", natural_lines); /* jh-2 */ - printf("Chosen number of lines : %d\n\n", lines);} - - if (dbug_logfile){ - fprintf(logfile, "Section number : %d\n", section+1); - fprintf(logfile, "Last bar in this section : %d\n", lastbarnumber); - fprintf(logfile, "Number of bars : %d\n", bars[section]); - fprintf(logfile, "Natural number of lines : %d\n", - natural_lines); /* jh-2 */ - fprintf(logfile, "Chosen number of lines : %d\n\n", lines);} - - if (bars[section]<1) error_exit(3); - -/************************************************************** - fill_length is the length of 'bar' material (ie excluding - signature space) required to fill the remainder - of the piece. This value will not be exact if there are - sign changes within the section. However, - fill_length is used only to keep track of the mean scale factor - for the remainder of the piece, as opposed to individual lines. - - Loop over lines, working out number of bars - and revised \elemskip for each line. - added correct computing of fill_length -****************************************************************/ - - for (j=1; j<=lines; ++j, ++line_in_section) { - ++line_number; - fill_length=(lines-j+1)*(linewidth-(clefskip+signskip[sign])); - -/**************************************************** - Work out mean element skip over remaining bars - in the current section. - EFFWID is the effective line width once - key signature have been written. - Set parindent to zero after it has been used for the - first line of the first section. -****************************************************/ - - if (!eff_softlength[section]) error_exit(5); - spc_factor=(fill_length-eff_hardlength[section])/eff_softlength[section]; - - if ((xbar[mark+1]>1) && (mark>0)) { - /* The bar is an bar+xbar with a sign change. jh-1 */ - eff_linewidth=linewidth-(clefskip+signskip[sign-1])-parindent; - } else { /* This is a normal bar. jh-1 */ - eff_linewidth=linewidth-(clefskip+signskip[sign])-parindent; - } /* jh-1 */ - signskip[sign] = futuresignskip[sign]; /* Supports xbar signs, jh-1 */ - - parindent=0; - -/**************************************************** - Fill the current line by adding bars until overflow. -*****************************************************/ - - i=mark; - firstbarno=barno[mark+1]; - hardlength= 0; - softlength = 0; - x = 0; - lastbar = 0.0; - detect_end= FALSE; - - while (x<eff_linewidth) { - if (detect_end) break; - ++i; - -/********************* - Check for raggedline. -**********************/ - - if (raggedline[i]) detectraggedline=TRUE; - -/******************************************* - Check for key signature change at this bar. -********************************************/ - - if (i==signchange[sign+1]) ++sign; - - lastbar = hardbarlength[i]+spc_factor*softbarlength[i]; - x += lastbar; - -/********************************************* - Enforce termination at last bar and last line -**********************************************/ - - if (i==lastbarnumber) detect_end=TRUE; - else if (line_in_section==lines){detect_end=FALSE; x=0;} - - hardlength += hardbarlength[i]; - softlength += softbarlength[i]; - } - -/************************************************ - If the overhang is less than half the barlength, - include the latest bar in the line, - and shrink the line accordingly. -*************************************************/ - - if ((x-eff_linewidth)<(lastbar/2)) { - barsinline=i-mark; - mark=i; - lastbarno=barno[mark]; - -/******************************************** - last bar in line a zbar? - if true -> add to the first bar in next line - the amount of afterruleskip -*********************************************/ - - if (zbar[mark]) { - softbarlength[i+1] += afterrule; - eff_softlength[section] += afterrule; - } - -/******************************************** - last bar in line a leftrightrepeat? - if true -> reduce hardwidth of current line - advance the hardwidth of next bar - advance the softwidth of next bar -*********************************************/ - - if (lr_repeat[mark]) { -/* printf("mark=%d\n",mark); - printf("width_leftright=%f\n",width_leftrightrepeat[i]); - printf("width_left=%f\n",width_leftrepeat[i]); */ - hardlength -= (width_leftrightrepeat[i]-width_leftrepeat[i]); - eff_hardlength[section] += - (width_leftrightrepeat[i]-width_leftrepeat[i]); - hardbarlength[i+1] += width_leftrepeat[i]; - softbarlength[i+1] += afterrule/2; - eff_softlength[section] += afterrule/2; - - } - -/******************************************** - last bar in line a leftrepeat? - if true -> reduce hardwidth of current line - advance the hardwidth of next bar - advance the softwidth of next bar -*********************************************/ - - if (l_repeat[mark]) { - hardlength -= (width_leftrepeat[i]-lthick); - hardbarlength[i+1] += width_leftrepeat[i]; - softbarlength[i+1] += afterrule/2; - eff_softlength[section] += afterrule/2; - } - - if (signchange[sign+1]==mark+1) { /* s.b. */ - ++sign; - /* Because the bar is staying here in the line, we look ahead - to see if the upcoming bar is a sign change, and adjust space - to account for the complimentary sign change notice that will - be posted at the end of this line. However, if the upcoming - sign change bar is really a bar+xbar set, where the sign change - is buried in the xbar, then we don't do the move because the - change notice really won't be posted in this line. jh-1 */ - if (xbar[mark+1]<2) { /* okay to do the move. jh-1 */ - hardlength += oldsignskip[sign]; - hardbarlength[mark+1] -= oldsignskip[sign]; - } - } - } - -/********************************************* - Exclude the latest bar, and stretch the line. -**********************************************/ - - else { - - barsinline=i-1-mark; - if (barsinline<1) error_exit(2); - mark=i-1; - lastbarno=barno[mark]; - hardlength -= hardbarlength[i]; - softlength -= softbarlength[i]; - - if (zbar[mark]) softbarlength[i] += afterrule; - - if (lr_repeat[mark]) { - hardlength -= (width_leftrightrepeat[i-1]-width_leftrepeat[i-1]); - eff_hardlength[section] += - (width_leftrightrepeat[i-1]-width_leftrepeat[i-1]); - hardbarlength[i] += width_leftrepeat[i-1]; - softbarlength[i] += afterrule/2; - eff_softlength[section] += afterrule/2; - } - - if (l_repeat[mark]) { - hardlength -= (width_leftrepeat[i-1]-lthick); - hardbarlength[i] += width_leftrepeat[i-1]; - softbarlength[i] += afterrule/2; - eff_softlength[section] += afterrule/2; - } - -/********************************************************************* - Error (o/u-hbox) occurs only when signature change start in next line - -> look for signature change in next line - if true then advance the hardwidth of current line - reduce next hard barlength by signature change -**********************************************************************/ - - if (signchange[sign]==mark+1) { - /* However, if the next bar is a bar+xbar set where the - sign change comes from the xbar, then don't do this - move, because the extra skip is not really there! jh-1 */ - if (xbar[mark+1]<2) { /* alright, do the move. jh-1 */ - hardlength += oldsignskip[sign]; - hardbarlength[mark+1] -= oldsignskip[sign]; - } - } - } - -/*********************************************** - Define a flex factor for this line as the ratio - of soft part of the specified line width, - to soft width in the approximate line. -************************************************/ - - if (!softlength) error_exit(5); - flexit=(eff_linewidth-hardlength)/softlength; - if (detectraggedline) {flexit=1; detectraggedline=FALSE;} - cor_elemskip = elemskip * flexit; - cor_afterrule = afterrule * flexit; - cor_beforerule = beforerule * flexit; - - if (dbug){ - printf("Line number : %d\n",line_number); - printf("Fill length : %f\n",fill_length); - printf("Effective length : %f\n", - eff_softlength[section]+eff_hardlength[section]); - printf("Mean space factor : %f\n",spc_factor); - printf("Bars in line : %d\n",barsinline); - printf("Effective linewidth : %f\n",eff_linewidth); - printf("Uncorrected hard length : %f\n",hardlength); - printf("Uncorrected soft length : %f\n",softlength); - printf("Flex factor (soft) : %f\n",flexit); - printf("Corrected elemskip : %f\n",cor_elemskip); - printf("Corrected afterrule : %f\n",cor_afterrule); - printf("Corrected beforerule : %f\n",cor_beforerule); - getchar();} - - if (dbug_logfile){ - fprintf(logfile, "Line number : %d\n",line_number); - fprintf(logfile, "Fill length : %f\n",fill_length); - fprintf(logfile, "Effective length : %f\n", - eff_softlength[section]+eff_hardlength[section]); - fprintf(logfile, "Mean space factor : %f\n",spc_factor); - fprintf(logfile, "Bars in line : %d\n",barsinline); - fprintf(logfile, "Effective linewidth : %f\n",eff_linewidth); - fprintf(logfile, "Uncorrected hard length : %f\n",hardlength); - fprintf(logfile, "Uncorrected soft length : %f\n",softlength); - fprintf(logfile, "Flex factor (soft) : %f\n",flexit); - fprintf(logfile, "Corrected elemskip : %f\n",cor_elemskip); - fprintf(logfile, "Corrected afterrule : %f\n",cor_afterrule); - fprintf(logfile, "Corrected beforerule : %f\n",cor_beforerule);} - - eff_hardlength[section] -= hardlength; - eff_softlength[section] -= softlength; - fill_length -= eff_linewidth; - -/********************************** - Write a record to the output file. -***********************************/ - - fprintf( outfile, - "\\lineset{%3d}{%2d}{%8.5fpt}{%8.5fpt}{%8.5fpt}%% %d - %d\n", - line_number, barsinline, cor_elemskip, cor_afterrule, - cor_beforerule, firstbarno, lastbarno); - - if (showresult){ - printf( - "\\lineset{%3d}{%2d}{%8.5fpt}{%8.5fpt}{%8.5fpt}%% %d - %d\n", - line_number, barsinline, cor_elemskip, cor_afterrule, - cor_beforerule, firstbarno, lastbarno);} - - if (dbug_lines) printf(" ... writing line : %d\r", line_number); - if (dbug_logfile) - fprintf(logfile, " ... writing line : %d\n", line_number); - - } /*eo for lines */ - } /* eo for sections */ - - if (dbug_lines) printf("\n"); - -/********* - <<<<<<<<< - eo do -**********/ - - samechapter=TRUE; - ++chapterno; - } while(GETLINE); - -/************* - closing files -**************/ - - fclose(infile); - if (dbug_logfile){ - fclose(logfile); - if (!logfile) error_exit(0);} - fclose(outfile); - if (!outfile) error_exit(0); - - printf(" ... thats all, bye\n"); - return(0); -} - -/*** eof ***/ - - |