Subversion Repositories svn1-original

/*************************************************************************

*           Copyright (C) 1995 Embedded Solutions

*                       All rights reserved

*

* file:     src\report.c

*

* purpose:  PREFIX -

*

* functions

*       report                  - Report menu

*       pri_team                - Print in team order

*       pri_leg                 - Print in given leg finishing time

*       p_place                 - Print place information

*       p_team                  - Print team information

*       pri_eleg                - Print on elapsed times for given leg

*       pe_place                - Print place and elapsed time information

*       pe_team                 - Print team and elapsed time information

*       pri_final               - Print final results

*       pri_interim             - Print interim results

*       print_class_header      - Print a class header

*       print_class_stats       - Generate the class stats

*       print_legend            - Print the legend

*       pi_place                - Return place data

*       pr_place                - Return place data

*       ck_data                 - Check data for bad times

*       srt_place               - Update placing information

*       do_big_sort             - Main sort routine for final data

*       sort                    - Sort in memory buffer

*       sort_comp               - qsort comparison function

*       load                    - load report data into memory

*       gen_stats               - Generate all the stats

*

* programmer: David Purdie

*

* revision  date        by      reason

*    e388   11-Oct-88           Option in the final printout to only

*                               produce the main result sheet. The leg

*                               placing printout is not produced.

*

*                               Changes to the display format of unknown

*                               times of disqualified teams. Only affects

*                               the leg-printouts.

*                               Disqualified teams show as -- -- --

*                               Otherwise they show as     ** ** **

*                               or a valid time.

*

*   e339    31-Oct-88   DDP     Added the "Interim Report" facility

*   00.0    27/01/95    DDP     Tidies up the program and formatted the file

*   00.1    06-sep-02   DDP     Added support for HTML report generation

*

**************************************************************************/

#include    <stdio.h>

#if defined(HI_TECH_C) || defined(__TURBOC__)

#include    <alloc.h>

#endif

#include    "consts.h"

#include    "structs.h"

#include    "proto.h"

void pri_awards_html(void);

void pri_awards(void);

void pri_master_index(void);

char *placing ( int place );

void pri_name_index(void);

void pri_name_index_body( void );

void pri_all_reports (void );

void pri_leg_body(int leg);

void pri_eleg_body(int leg);

void pri_csv_data ( void );

//menu_table  rpt_menu[] = {

//    { '1', "Print team order", pri_team },

//    { '2', "Print end leg times", pri_leg },

//    { '3', "Print elapsed leg times", pri_eleg },

//    { '4', "Print final results", pri_final },

//    { '5', "Print final results(All-HTML)", pri_final_html },

//    { '6', "Print Interim results", pri_interim },

//    { '7', "Update event and class placings", srt_place },

//    { '8', "Display summary information", display_summary },

//    { '9', "Print summary information", pri_summary },

//    { 'a', "Print Awards only", pri_awards_html },

//    { 'b', "Print Master Index only", pri_master_index },

//    { 'c', "Print Name Index only", pri_name_index },

//    { 'e', "Export CSV Report Data", pri_csv_data },

//    { 'z', "Print all reports", pri_all_reports },

//#if defined(HI_TECH_C) || defined(__TURBOC__)

//    { 'S', "MS-DOS system", ms_system },

//#endif

//    { 'q', "Return to main menu", 0 },

//    { '\0' }

//};

#define MAX_PLACE 11

const char * place_text[] =

{

    "Zero'th",

    "First",

    "Second",

    "Third",

    "Fourth",

    "Fifth",

    "Sixth",

    "Seventh",

    "Eighth",

    "Ninth",

    "Tenth",

    "Eleventh"

};

int         sort_leg;

int         sort_mode;

report_type report_html = text;

bool        report_all = FALSE;

/* Parameters used by the sort routine to govern its actions */

#define S_L     1                                /* Elasped times */

#define S_LE    2                                /* Leg end time */

#define S_LC    3                                /* Elapsed times per class */

#define S_LEC   4                                /* Leg end time per class */

#define S_FIN   5                                /* Sort on finish time at given leg */

#define S_TEAM  6                                /* Sort on team order */

#define S_CLASS 7                                /* Sort on class/team order */

/*

**  Various checking modes

*/

#define C_ELAPSED   1                            /* Check elapsed times */

#define C_END       2                            /* Check end times */

#define C_DISQUAL   3                            /* Check disqualified teams */

/*

**  Data

*/

ty_s_data  *sort_data = 0;                       /* pointer to memory */

ty_s_aux   *sort_aux = 0;                        /* pointer to aux sort info */

ty_s_namedata *sort_name_data = 0;                /* pointer to name info */

unsigned    int sort_num;                            /* Number in the array */

unsigned    int sort_num_data;                       /* Number in the array */

/*

**  A structure to hold statistical information

*/

typedef struct

{

    int         team[MAX_LEGS + 1][MAX_CLASS + 1];

    struct

    {

        int     team[MAX_LEGS + 1][MAX_CLASS + 1];

        time_t  time[MAX_LEGS + 1][MAX_CLASS + 1];

    } fast;

    time_t      average[MAX_LEGS + 1][MAX_CLASS + 1];

} ty_stats;

ty_stats        stats;                           /* Holds statistics */

/*========================================================================

 *

 *  Report menu

 *

 *  Purpose:

 *      This function is called to produce the "Report Menu"

 *

 *  Parameters:

 *      None

 *

 *  Returns:

 *      Nothing

 *

 *========================================================================*/

//void report(void)

//{

//    report_html = text;

//    if( load_report_data() )

//        do_menu( "Report generation", "Select option", rpt_menu );

//    if( sort_data )

//        free( ( char * ) sort_data );

//    if( sort_aux )

//        free( ( char * ) sort_aux );

//    if ( sort_name_data )

//        free( ( char * ) sort_name_data );

//    sort_data = ( ty_s_data * ) 0;

//    sort_aux = ( ty_s_aux * ) 0;

//    sort_name_data = ( ty_s_namedata * ) 0;

//}

/*========================================================================

 *

 *  Print in team order

 *

 *  Purpose:

 *      This function is called to Print in team order

 *      This function may also be used to create an HTML suite of files

 *      within the result set

 *

 *  Parameters:

 *      None

 *

 *  Returns:

 *      Nothing

 *

 *========================================================================*/

void pri_team(void)

{

    int         i, k;

    //cur( 0, 5 );

    printf( "Team information - in team order\n" );

    printf( "\nPrinting team names\n" );

    //flush_out();

    if( !open_printer( "", "name", 132, report_html, "Team Names" ) )

        return;

    /*

     * Print out the data 

     * Print out the header

     */

    print( "\n" );

    print_underline( TRUE );

    print( "%-*s %-*s %-*s", MAX_TM_NAME + 5, "Entry number and name",

               LEN_CLASS_NAME, "Category",

               config.num_countries == 0 ? 1 : LEN_CNTRY_NAME,

               config.num_countries == 0 ? "" : "Country" );

    for( k = 0; k < MAX_MEMB; k++ )

    {

        print( " %-*s", MAX_PERSON_NAME, config.leg_name[k] ? config.leg_name[k] : "Competitor"  );

    }

    print_underline( FALSE ) ;

    print( "\n" );

    for( i = config.min_team; i <= config.max_team; i++ )

    {

        if( valid_field( i ) && g_record( i, &team_buf ) )

        {

            /*

            **  If printing an HTML report then we need to mark

            **  the entry with a reference so that we can link to it

            */

            if ( report_html == html )

            {

                print( "<A NAME=\"Team_%04d\">",team_buf.numb );

                print( "</A>" );

            }

            /*

            **  Basic information

            **      - Team number - with Xref back to full result

            **      - Full team name

            **      - Full categoray name - with Xref to category results

            **      - Country name

            */

            if ( report_html == html ) print( "<A HREF=\"%s#Team_%04d\">", url_encode(p_filename(filebase, "finish" ,"html")), team_buf.numb );

            print( "%4d",       team_buf.numb );

            if ( report_html == html ) print( "</A>" );

            print( " %-*s ",     MAX_TM_NAME, team_buf.name );

            if ( report_html == html ) print( "<A HREF=\"%s#Team_%04d\">",url_encode(p_filename(filebase, config.team_class[team_buf.teamclass - 1].abr ,"html")), team_buf.numb );

            print( "%-*s",     LEN_CLASS_NAME, team_buf.teamclass == 0 ? "" : config.team_class[team_buf.teamclass - 1].full_name );

            if ( report_html == html ) print( "</A>" );

            print( " %-*s",     config.num_countries == 0 ? 1 : LEN_CNTRY_NAME,

                                config.num_countries == 0

                                || team_buf.country ==

            for( k = 0; k < MAX_MEMB; k++ )

                print( " %-*s", MAX_PERSON_NAME, team_buf.members[k].name );

            print( "\n" );

        }

    }

    close_printer();

}

/*========================================================================

 *

 *  Print in name order

 *

 *  Purpose:

 *      This function is called to print a list of all known competitors

 *      This function may also be used to create an HTML suite of files

 *      within the result set

 *

 *  Parameters:

 *      None

 *

 *  Returns:

 *      Nothing

 *

 *========================================================================*/

void pri_name_index( void )

{

    //cur( 0, 5 );

    printf( "Team Member information - in name order\n" );

    printf( "\nPrinting competitor names\n" );

    //flush_out();

    pri_name_index_body();

    printf( "Found %d names\n", sort_num_data );

    printf( "\nAny key to continue" );

    getinp();

}

/*========================================================================

 *

 *  Print in name order

 *

 *  Purpose:

 *      This function is called to print a list of all known competitors

 *      This function may also be used to create an HTML suite of files

 *      within the result set

 *

 *  Parameters:

 *      None

 *

 *  Returns:

 *      Nothing

 *

 *========================================================================*/

void pri_name_index_body( void )

{

    ty_s_namedata *ptr;

    unsigned    num;

    int i;

    unsigned int k;

    int num_names;

    /*

    **  Determine the number of names to allow for

    *   Based on the total number of teams

    */

    num = config.max_team - config.min_team + 1 ;

    num *= MAX_MEMB;

    sort_name_data = ( ty_s_namedata * ) calloc ( num , sizeof( ty_s_namedata ) );

    if( sort_name_data == 0 )

    {

        printf( "\n\nError in allocating memory\n" );

        sleep( 5 );

        return;

    }

    /*

    **  Read all teams an extract name information

    */

    ptr = sort_name_data;

    for( i = config.min_team; i <= config.max_team; i++ )

    {

        if( valid_field( i ) && g_record( i, &team_buf ) )

        {

            num_names = 0;

            for( k = 0; k < MAX_MEMB; k++ )

            {

                if ( team_buf.members[k].name[0] )

                {

                    ptr->team = i;

                    ptr->leg = k;

                    ptr->teamclass = team_buf.teamclass;

                    strncpy( ptr->name,team_buf.members[k].name, sizeof(team_buf.members[k].name));

                    ptr++;

                    num_names++;

                }

            }

            if ( num_names == 0 )

            {

                ptr->team = i;

                ptr->leg = 0;

                ptr->teamclass = team_buf.teamclass;

                strncpy( ptr->name,team_buf.name, sizeof(team_buf.members[k].name));

                ptr++;

            }

        }

    }

    sort_num_data = ptr - sort_name_data;

    /*

    **  Now stort the entries by name:team:leg

    */

    qsort( ( char * ) sort_name_data, sort_num_data, sizeof( ty_s_namedata ), sort_comp_cname );

    /*

    **  Now generate the report

    */

    if( !open_printer( "", "competitor", 80, report_html, "Competitor Names" ) )

        return;

    /*

     * Print out the data 

     * Print out the header

     */

    print( "\n" );

    print_underline( TRUE );

    print( "%-*s %-*s %-*s %-*s", MAX_TM_NAME + 5, "Competitor name",

               6, "Leg",

               5, "Team",

               LEN_CLASS_NAME, "Category"

               );

    print_underline( FALSE ) ;

    print( "\n" );

    ptr = sort_name_data;

    for( k = 1; k <= sort_num_data; k++, ptr++ )

    {

        print( "%-*s", MAX_TM_NAME + 5, ptr->name );

        print( " " );

        if ( report_html == html ) print( "<A HREF=\"%s#Team_%04d\">", url_encode(p_filename(filebase, "finish" ,"html")), ptr->team );

        print( "%-*d", 6, ptr->leg + 1 );

        if ( report_html == html ) print( "</A>" );

        print( " " );

        if ( report_html == html ) print( "<A HREF=\"%s#Team_%04d\">", url_encode(p_filename(filebase, "name" ,"html")), ptr->team );

        print( "%-*d", 5, ptr->team );

        if ( report_html == html ) print( "</A>" );

        print( " " );

        if ( report_html == html ) print( "<A HREF=\"%s#Team_%04d\">",(p_filename(filebase, config.team_class[ptr->teamclass - 1].abr ,"html")), ptr->team );

        print( "%-*s", LEN_CLASS_NAME, ptr->teamclass == 0 ? "" : config.team_class[ptr->teamclass - 1].abr );

        if ( report_html == html ) print( "</A>" );

        print( " " );

        if ( ptr->multi ) print( "* ");

        print( "\n" );

    }

    print_legend( -1, 0 );

    close_printer();

}

/*========================================================================

 *

 *  Print in given leg finishing time

 *

 *  Purpose:

 *      This function is called to Print in given leg finishing time

 *

 *  Parameters:

 *      None

 *

 *  Returns:

 *      Nothing

 *

 *========================================================================*/

//void pri_leg(void)

//{

//    int         leg = 0;

//    /*

//     * This function is used to provide interum print-outs

//     * The team data is sorted by time at leg-end and the times printed are

//     * real times at leg end.

//     * This operation is designed to be quick - it doesn't update the disk file

//     * and is not available in an HTML version - yet

//     */

//    cur( 0, 5 );

//    printf( "Leg finishing time report\n" );

//    while( TRUE )

//    {

//        d_field( 0, 7, "Enter leg to print :", D_NUMBER, 1, ( char * ) &leg,

//                 TRUE, M_UPDATE );

//        if( abort_flag )

//            return;

//        if( leg <= config.num_legs )

//            break;

//        beep();

//    }

//    pri_leg_body ( leg );

//}

void pri_leg_body(int leg)    

{

    ty_s_data  *ptr;

    int         i, k;

    /*

     * Sort the data in finishing order 

     */

    printf( "\nSorting the data\n" );

    //flush_out();

    if( ck_data( leg, C_END ) )

        return;                                  /* Check data for this leg */

    sort_team_data( leg, S_FIN );                /* Sort the data */

    /*

     * Now print the data on the printer 

     */

    if( !open_printer( "",

                        tprintf("lg%1.1d", leg ),

                        80,

                        report_html,

                        leg ? tprintf ("Finish order for Leg %d.", leg)

                            : "Final team finish order"

                     ) )

    {

        return;

    }

    /*

     * Print out the data 

     */

    print( "PRELIMINARY RESULTS ONLY\n\n" );

    print_underline( TRUE );

    print( "%4s %4s %-8s  ", "Plce", "Team", "Time" );

    print( "%4s %4s %-8s  ", "Plce", "Team", "Time" );

    print( "|" );

    print( "%4s %4s %-8s  ", "Team", "Plce", "Time" );

    print( "%4s %4s %-8s\n", "Team", "Plce", "Time" );

    print_underline( FALSE );

    for( ptr = sort_data, k = 0, i = config.min_team; i <= config.max_team; )

    {

        p_place( ptr++, leg, k++ );

        p_place( ptr++, leg, k++ );

        print( "|" );

        while( i <= config.max_team && !valid_field( i ) )

            i++;

        p_team( i++, leg );

        while( i <= config.max_team && !valid_field( i ) )

            i++;

        p_team( i++, leg );

        print( "\n" );

    }

    printf( "\n\n" );

    print_underline( TRUE );

    print( "%4s %4s %-8s  ", "Plce", "Team", "Time" );

//    print( "%4s %4s %-8s  ", "Plce", "Team", "Time" );

    print( "|" );

//    print( "%4s %4s %-8s  ", "Team", "Plce", "Time" );

    print( "%4s %4s %-8s\n", "Team", "Plce", "Time" );

    print_underline( FALSE );

    for( ptr = sort_data, k = 0, i = config.min_team; i <= config.max_team; )

    {

        p_place( ptr++, leg, k++ );

//        p_place( ptr++, leg, k++ );

        print( "|" );

        while( i <= config.max_team && !valid_field( i ) )

            i++;

        p_team( i++, leg );

//        while( i <= config.max_team && !valid_field( i ) )

//            i++;

//        p_team( i++, leg );

        print( "\n" );

    }

    /*

     * Insert the leg statistics 

     */

    gen_stats();                               /* Generate all stats */

    print( "\nLeg statistics\n" );

    print( "Fastest team: %4d time : %s.",

           stats.fast.team[leg][0], time_a( stats.fast.time[leg][0] ) );

    print( " Average time: %s\n", time_a( stats.average[leg][0] ) );

    close_printer();

}

/*========================================================================

 *

 *  Print place information

 *

 *  Purpose:

 *      This helper function is called to Print place information

 *      in a 20-character field

 *

 *  Parameters:

 *      ptr         Address of the place data

 *      leg         Leg to print

 *      k           Current index into sorted array. Simply

 *                  used to determine if the entry is valid

 *                  or if it should be space-filled

 *

 *  Returns:

 *      Nothing

 *

 *========================================================================*/

void p_place( ty_s_data * ptr, int leg, unsigned k )

{

    if( k < sort_num )

    {

        print( "%4.4s %4d %8s  ",

               pr_place( ptr->place, ptr->flags.bad_times ),

               ptr->team, time_fa( ptr->leg[leg], ptr->flags.disqualified ) );

    }

    else

    {

        print( "%20s", "" );

    }

}

/*========================================================================

 *

 *  Print team information

 *

 *  Purpose:

 *      This helper function is called to Print team information

 *      in a 20-character field

 *

 *  Parameters:

 *      i           team to print

 *      leg         Leg to print

 *

 *  Returns:

 *      Nothing

 *

 *========================================================================*/

void p_team( int i, int leg )

{

    ty_s_data  *ptra;                            /* Pointer to sort data */

    int         found = FALSE;

    unsigned    j;

    if( valid_field( i ) )

    {

        ptra = sort_data;

        for( j = 1; j <= sort_num; j++, ptra++ )

            if( i == ptra->team )

            {

                found = TRUE;

                break;

            }

    }

    if( found )

    {

        print( "%4d %4.4s %8s  ",

               ptra->team,

               pr_place( ptra->place, ptra->flags.bad_times ),

               time_fa( ptra->leg[leg], ptra->flags.disqualified ) );

    }

    else

    {

        print( "%20s", "" );

    }

}

/*========================================================================

 *

 *  Print on elapsed times for given leg

 *

 *  Purpose:

 *      This function is called to Print on elapsed times for given leg

 *

 *  Parameters:

 *      None

 *

 *  Returns:

 *      Nothing

 *

 *========================================================================*/

//void pri_eleg(void)

//{

//    int         leg = 0;

//    /*

//     * This function is used to provide interum print-outs

//     * The team data is sorted by time at leg-elapsed and the times printed are

//     * real times at leg end.

//     * This operation is designed to be quick - it doesn't update the disk file

//     * and is not available in an HTML version - yet

//     */

//    cur( 0, 5 );

//    printf( "Leg elapsed time report\n" );

//    while( TRUE )

//    {

//        d_field( 0, 7, "Enter leg to print :", D_NUMBER, 1, ( char * ) &leg,

//                 TRUE, M_UPDATE );

//        if( abort_flag )

//            return;

//        if( leg <= config.num_legs )

//            break;

//        beep();

//    }

//    pri_eleg_body(leg);

//}

void pri_eleg_body( int leg)

{

    ty_s_data  *ptr;

    int         i, k;

    /*

     * Sort the data in finishing order

     */

    printf( "\nSorting the data\n" );

    //flush_out();

    if( ck_data( leg, C_ELAPSED ) )

        return;                                  /* Check data for this leg */

    sort_team_data( leg, S_L );                  /* Sort the data on elapsed time */

    /*

     * Now print the data on the printer

     */

    if( !open_printer( "", tprintf( "le%1.1d", leg ),

                       80,

                       report_html,

                       leg ? tprintf( "Elapsed time order for Leg %d.", leg )

                           : tprintf( "Final elapsed team finishing order." )

                     ) )

    {

        return;

    }

    /*

     * Print out the data

     */

    print( "PRELIMINARY RESULTS ONLY\n\n" );

    print_underline( TRUE );

    print( "%4s %4s %-8s  ", "Plce", "Team", "Time" );

    print( "%4s %4s %-8s  ", "Plce", "Team", "Time" );

    print( "|" );

    print( "%4s %4s %-8s  ", "Team", "Plce", "Time" );

    print( "%4s %4s %-8s\n", "Team", "Plce", "Time" );

    print_underline( FALSE );

    for( ptr = sort_data, k = 0, i = config.min_team; i <= config.max_team; )

    {

        pe_place( ptr++, leg, k++ );

        pe_place( ptr++, leg, k++ );

        print( "|" );

        while( i <= config.max_team && !valid_field( i ) )

            i++;

        pe_team( i++, leg );

        while( i <= config.max_team && !valid_field( i ) )

            i++;

        pe_team( i++, leg );

        print( "\n" );

    }

    print( "\n\n" );

    print_underline( TRUE );

    print( "%4s %4s %-8s  ", "Plce", "Team", "Time" );

//    print( "%4s %4s %-8s  ", "Plce", "Team", "Time" );

    print( "|" );

//    print( "%4s %4s %-8s  ", "Team", "Plce", "Time" );

    print( "%4s %4s %-8s\n", "Team", "Plce", "Time" );

    print_underline( FALSE );

    for( ptr = sort_data, k = 0, i = config.min_team; i <= config.max_team; )

    {

        pe_place( ptr++, leg, k++ );

//        pe_place( ptr++, leg, k++ );

        print( "|" );

        while( i <= config.max_team && !valid_field( i ) )

            i++;

        pe_team( i++, leg );

//        while( i <= config.max_team && !valid_field( i ) )

//            i++;

//        pe_team( i++, leg );

        print( "\n" );

    }

    /*

     * Insert the leg statistics

     */

    gen_stats();                               /* Generate all stats */

    print( "\nLeg statistics\n" );

    print( "Fastest team: %4d time : %s.",

           stats.fast.team[leg][0], time_a( stats.fast.time[leg][0] ) );

    print( " Average time: %s\n", time_a( stats.average[leg][0] ) );

    close_printer();

}

///*========================================================================

// *

// *  Print place information

// *

// *  Purpose:

// *      This helper function is called to Print place and elapsed information

// *      in a 20-character field

// *

// *  Parameters:

// *      ptr         Address of the place data

// *      leg         Leg to print

// *      k           Current index into sorted array. Simply

// *                  used to determine if the entry is valid

// *                  or if it should be space-filled

// *

// *  Returns:

// *      Nothing

// *

// *========================================================================*/

void pe_place( ty_s_data * ptr, int leg, unsigned k )

{

    if( k < sort_num )

    {

        print( "%4.4s %4d %8s  ",

               pr_place( ptr->place, ptr->flags.bad_times ),

               ptr->team,

               time_fa( ptr->lege[leg], ptr->flags.disqualified ) );

    }

    else

    {

        print( "%20s", "" );

    }

}

/*========================================================================

 *

 *  Print team information

 *

 *  Purpose:

 *      This helper function is called to Print team and elapsed time

 *      information

 *      in a 20-character field

 *

 *  Parameters:

 *      i           Team to print

 *      leg         Leg to print

 *

 *  Returns:

 *      Nothing

 *

 *========================================================================*/

void pe_team( int i, int leg )

{

    ty_s_data  *ptra;                            /* Pointer to sort data */

    int         found = FALSE;

    unsigned    j;

    if( valid_field( i ) )

    {

        ptra = sort_data;

        for( j = 1; j <= sort_num; j++, ptra++ )

            if( i == ptra->team )

            {

                found = TRUE;

                break;

            }

    }

    if( found )

    {

        print( "%4d %4.4s %8s  ",

               ptra->team,

               pr_place( ptra->place, ptra->flags.bad_times ),

               time_fa( ptra->lege[leg], ptra->flags.disqualified ) );

    }

    else

    {

        print( "%20s", "" );

    }

}

/*========================================================================

 *

 *  Print final results in HTML

 *

 *  Purpose:

 *      This function is called to Print final results with HTML formatting

 *      All result files are created

 *

 *  Parameters:

 *      None

 *

 *  Returns:

 *      Nothing

 *

 *========================================================================*/

void pri_final_html(void)

{

    /*

    **  Generate ALL results with HTML tags

    */

    report_html = html;

    pri_final();

    report_html = printed;

    pri_final();

    report_html = text;

}

/*========================================================================

 *

 *  Print final results

 *

 *  Purpose:

 *      This function is called to Print final results

 *

 *  Parameters:

 *      None

 *

 *  Returns:

 *      Nothing

 *

 *========================================================================*/

void pri_final(void)

{

    ty_s_data  *ptr;

    unsigned    i;

    int         j, last_class;

    char        suppress_classes;                /* Boolean. Printout class files too */

    char        *report_title;

    bool        class_done[MAX_CLASS+1];

    int         lcount;

    //cur( 0, 5 );

    printf( "Generate final result printouts\n" );

    if( ck_data( -1, C_ELAPSED ) )

        return;

                                     /* check data for all legs */

    /*

    **  If a non HTML report then ask if the user want to supress the class

    **  printout. For an HTML report always do the class reports as the two

    **  are interlinked

    */

    if ( ! report_html  && ! report_all)

    {

        suppress_classes = FALSE; //getyes( "Do you want to suppress class printouts" );

    }

    else

    {

        suppress_classes = FALSE;

    }

    /*

    **  Sort on every thing

    **  Then generate all the stats too

    */

    printf( "\nSorting the data\n" );

    do_big_sort();

    gen_stats();

    /*

     * Now print the data on the printer 

     */

    printf( "\nGenerating the printed output\n" );

    if( !open_printer( "", "finish", 132, report_html, "Finishing Order" ) )

        return;

    /*

     * Print out the data 

     */

    print_class_header( -1, TRUE );                      /* Print the header */

    ptr = sort_data;

    sort_team_data( 0, S_L );                     /* Re-sort on elapsed time */

    lcount = 0;

    for( ptr = sort_data, i = 0; i < sort_num; i++, ptr++ )

    {

        if ( ptr->teamclass == config.nonequestrian_class )

            continue;

        g_record( ptr->team, &team_buf );

        /*

        **  If printing an HTML report then we need to mark

        **  the entry with a reference so that we can link to it

        */

        if ( report_html == html )

        {

            print( "<A NAME=\"Team_%04d\"></A>",team_buf.numb );

        }