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(void);

void pri_master_index(void);

char *placing ( int place );

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 },

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

#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

char * place_text[] =

{

    "Zero'th",

    "First",

    "Second",

    "Third",

    "Fourth",

    "Fifth",

    "Sixth",

    "Seventh",

    "Eighth",

    "Ninth",

    "Tenth",

    "Eleventh"

};

int         sort_leg;

int         sort_mode;

bool        report_html = 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 */

unsigned    sort_num;                            /* 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 = FALSE;

    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 );

    sort_data = ( ty_s_data * ) 0;

    sort_aux = ( ty_s_aux * ) 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 )

            {

                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 ) print( "<A HREF=\"%s#Team_%04d\">", p_filename(filebase, "finish" ,"html"), team_buf.numb );

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

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

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

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

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

            if ( report_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 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;

    ty_s_data  *ptr;

    int         i, k;

    /*

     * 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();

    }

    /*

     * 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" );

    }

    /*

     * 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;

    ty_s_data  *ptr;

    int         i, k;

    /*

     * 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();

    }

    /*

     * 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" );

    }

    /*

     * 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 = TRUE;

    pri_final();

    report_html = FALSE;

}

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

 *

 *  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;

    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 )

    {

        suppress_classes = 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 */

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

    {

        if ( ptr->class == 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 )

        {

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

        }

        /*

        **  Print the basics

        **      - Place within complete field

        **      - Team number - with HTML reference to team file

        **      - Class

        */

        print( "%4.4s ", pr_place( team_buf.leg[0].l_place, ptr->flags.bad_times ) );

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

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

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

        print( " %-*s", 3, team_buf.class == 0 ? "" : config.team_class[team_buf.class - 1].abr );

        /*

        **  Print the per-leg data

        **      - Time

        **      - Leg place

        **      - End place

        */

        for( j = 1; j <= config.num_legs; j++ )

        {

            /*

            **  Ensure that non-equestrian leg data is not displayed

            */

            if ( j == config.equestrian_leg && team_buf.flags.non_equestrian )

            {

                print( "  %-8s %4.4s %4.4s", "-- NE --", "-","-");

            }

            else

            {

                print( "  %-8s %4.4s %4.4s",

                    time_a( team_buf.leg[j].elapsed ),

                    pr_place( team_buf.leg[j].l_place, ptr->flags.bad_times ),

                    pr_place( team_buf.leg[j].le_place,ptr->flags.bad_times )

                  );

            }

        }

        /*

        **  Print the trailer

        **      - Total time

        **      - Category place - with reference to category file

        */

        print( "  %-8s ",  time_a( team_buf.leg[0].elapsed ) );

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

        print( "%-4.4s", pr_place( team_buf.leg[0].lc_place, ptr->flags.bad_times ) );

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

        print( "\n" );

    }

    print_class_stats( -1, TRUE );              /* Print statistics */

    print_legend(-1);                            /* Print the legend */

    close_printer();                            /* Close the printer */

    /*

     * Now produce a breakdown on a class by class basis 

     * Now print out the class placement information

     */

    if( suppress_classes )

    {

        printf( "WARNING: Class printouts suppressed\n" );

        return;

    }

    sort_team_data( 0, S_LC );                 /* Generate class placement data */

    last_class = -1;                           /* Invalid class to start with */

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

    {

        /*

        **  Detect a change in the "class"

        **  All data is within the one array of data

        **  Use the in-memory class as this MAY differ from that stored

        **  The non-equestrian class does this.

        */

        if( last_class != ptr->class )

        {

            if( last_class >= 0 )

            {

                print_class_stats( last_class, TRUE );

                print_legend( last_class );

                close_printer();

            }

            report_title = tprintf( "Category results for : %-*s", LEN_CLASS_NAME, ptr->class == 0 ? "" : config.team_class[ptr->class - 1].full_name );

            if( !open_printer( "", config.team_class[ptr->class - 1].abr, 132, report_html, report_title ) )

                continue;

            print_class_header( last_class = ptr->class, TRUE );

        }

        /*

        **  Now read in the team record

        */

        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 )

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

        /*

        **  Print the basics

        **      - Place within the class

        **      - Team number - with HTML reference to team file

        **      - Class

        */

        print( "%4.4s ", pr_place( team_buf.leg[0].lc_place, ptr->flags.bad_times ) );

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

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

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

        print( " %-*s", 3, team_buf.class == 0 ? "" : config.team_class[team_buf.class - 1].abr );

        for( j = 1; j <= config.num_legs; j++ )

        {

            /*

            **  Ensure that non-equestrian leg data is not displayed

            */

            if ( j == config.equestrian_leg && ptr->class == config.nonequestrian_class)

            {

                print( "  %-8s %4.4s %4.4s", "-- NE --", "-","-");

            }

            else

            {

                print( "  %-8s %4.4s %4.4s", time_a( team_buf.leg[j].elapsed ),

                       pr_place( team_buf.leg[j].lc_place, ptr->flags.bad_times ),

                       pr_place( team_buf.leg[j].lec_place, ptr->flags.bad_times ) );

            }

        }

        /*

        **  Print the trailer

        **      - Total time

        **      - Overall place - with reference to overall place file

        */

        /* print( "  %-8s ", time_a( team_buf.leg[0].elapsed ) ); */

        print( "  %-8s ", time_a( ptr->lege[0] ) );

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

        print( "%4.4s", pr_place( team_buf.leg[0].l_place, ptr->flags.bad_times | (ptr->class == config.nonequestrian_class) ) );

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

        print( "\n" );

    }

    print_class_stats( last_class, TRUE );

    print_legend(last_class);

    close_printer();

    /*

    **  If we are generating an HTML report then we need to create the file

    **  that contains all the team names - the assumption is that this data

    **  is available

    */

    if ( report_html )

    {

        pri_team();

    }

    /*

    **  Generate the awards report.

    **  This is only available as an HTML report

    */

    if ( report_html )

    {

        pri_awards();

    }

    /*

    **  Generate the master index page

    */

    if ( report_html )

    {

        pri_master_index();

    }

}

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

 *

 *  Place to text

 *

 *  Purpose:

 *      This function is called to convert a place to text

 *

 *  Parameters:

 *      place

 *

 *  Returns:

 *      text

 *

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

char *placing ( int place )

{

    if ( place > MAX_PLACE )

    {

        return tprintf( "Place: %d", place);

    }

    return tprintf ("%s Place", place_text[place]);

}

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

 *

 *  Print award results

 *

 *  Purpose:

 *      This function is called to Print award results

 *

 *  Parameters:

 *      None

 *

 *  Returns:

 *      Nothing

 *

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

void pri_awards(void)

{

    int j;

    int i;

    int k;

    int windex;

    ty_s_data  *ptr;

    int         last_class;

    report_html = 1;

    if( !open_printer( "", "awards", 132, report_html, "Prizes and Awards" ) )

        return;

    /*

    **  Generate an index for this page

    */

    print( "\n");

    print( "<hr>" );

    print( "<A NAME=\"%s\"></A>","INDEX");

    print( "Award Categories");

    for( j = 1; j <= config.num_class; j++ )

    {

        /*

        **  Header for the class

        */

        if ( config.class_winners[j-1] <= 0 )

            continue;