| /************************************************************************ | |
| * | |
| * display.cpp - Definitions of the result display subsystem | |
| * | |
| * $Id$ | |
| * | |
| ************************************************************************ | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one or more | |
| * contributor license agreements. See the NOTICE file distributed | |
| * with this work for additional information regarding copyright | |
| * ownership. The ASF licenses this file to you under the Apache | |
| * License, Version 2.0 (the "License"); you may not use this file | |
| * except in compliance with the License. You may obtain a copy of | |
| * the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or | |
| * implied. See the License for the specific language governing | |
| * permissions and limitations under the License. | |
| * | |
| **************************************************************************/ | |
| #include <assert.h> | |
| #include <stdio.h> /* for fflush(), printf(), puts(), ... */ | |
| #include <string.h> /* for strchr() */ | |
| #include "cmdopt.h" /* for target_name -should this be moved? */ | |
| #include "exec.h" /* for get_signame */ | |
| #include "display.h" | |
| #include "target.h" /* for target_status */ | |
| #include <time.h> /* for CLK_TCK, CLOCKS_PER_SEC */ | |
| #ifndef _WIN32 | |
| # include <unistd.h> /* for _SC_CLK_TCK, sysconf() */ | |
| #endif | |
| #if defined (_SC_CLK_TCK) | |
| /* dynamically determine the number of clock ticks per second */ | |
| static const float TICKS_PER_SEC = float (sysconf (_SC_CLK_TCK)); | |
| #elif defined CLOCKS_PER_SEC | |
| /* use the POSIX (and MSVC 6.0) CLOCKS_PER_SEC constant */ | |
| static const float TICKS_PER_SEC = CLOCKS_PER_SEC; | |
| #elif defined CLK_TCK | |
| /* use CLK_TCK if it's defined (e.g., pre-MSVC 6.0) */ | |
| static const float TICKS_PER_SEC = CLK_TCK; | |
| #else | |
| /* if all else fails, assume the standard 1 million ticks per second */ | |
| static const float TICKS_PER_SEC = 1000000UL; | |
| #endif | |
| /** | |
| ProcessStatus enum lookup table for 'short' (6 character) strings. | |
| */ | |
| static const char* const | |
| short_st_name [ST_LAST] = { | |
| "OK", /*ST_OK*/ | |
| "COMP", /*ST_COMPILE*/ | |
| "LINK", /*ST_LINK*/ | |
| "EXIST", /*ST_EXIST*/ | |
| "XPERM", /*ST_EXECUTE_FLAG*/ | |
| "EXEC", /*ST_EXECUTE*/ | |
| "NOUT", /*ST_NO_OUTPUT*/ | |
| "OUTPUT", /*ST_NO_REF*/ | |
| "BREF", /*ST_BAD_REF*/ | |
| "DIFF", /*ST_BAD_OUTPUT*/ | |
| "FORMAT", /*ST_FORMAT*/ | |
| "OFLOW", /*ST_OVERFLOW*/ | |
| "ERROR", /*ST_SYSTEM_ERROR*/ | |
| "KILLED", /*ST_KILLED*/ | |
| "NKILL" /*ST_NOT_KILLED*/ | |
| }; | |
| /** | |
| ProcessStatus enum lookup table for descriptive strings. | |
| */ | |
| static const char* const | |
| verbose_st_name [ST_LAST] = { | |
| "OK", /*ST_OK*/ | |
| "Program failed to compile.", /*ST_COMPILE*/ | |
| "Program failed to link.", /*ST_LINK*/ | |
| "Program executable not found.", /*ST_EXIST*/ | |
| "Program not executable.", /*ST_EXECUTE_FLAG*/ | |
| "Program failed to execute.", /*ST_EXECUTE*/ | |
| "Program generated no output.", /*ST_NO_OUTPUT*/ | |
| "Program reference output missing.", /*ST_NO_REF*/ | |
| "Bad reference.", /*ST_BAD_REF*/ | |
| "Program produced unexpected output.", /*ST_BAD_OUTPUT*/ | |
| "Program produced output in unexpected format.", /*ST_FORMAT*/ | |
| "Arithmetic overflow.", /*ST_OVERFLOW*/ | |
| "System error occurred.", /*ST_SYSTEM_ERROR*/ | |
| "Process killed after a timeout.", /*ST_KILLED*/ | |
| "Failed to kill process after a timeout." /*ST_NOT_KILLED*/ | |
| }; | |
| /** | |
| Prints an argv array, quoting elelemnts containing spaces. | |
| */ | |
| static int | |
| print_argv (const char* const argv[], int newline) | |
| { | |
| assert (0 != argv); | |
| const char* const* parg = argv; | |
| int nchars = 0; | |
| for (parg = argv; *parg; ++parg) { | |
| const char *fmt = "%s "; | |
| if (strchr (*parg, ' ')) | |
| fmt = "\"%s\" "; | |
| nchars += printf (fmt, *parg); | |
| } | |
| if (newline) | |
| puts (""); | |
| return nchars; | |
| } | |
| /** | |
| Generates output header, designed for text output and console viewing. | |
| */ | |
| static void | |
| print_header_plain (const char* const argv[]) | |
| { | |
| (void)&argv; | |
| puts ("NAME STATUS WARN ASSERTS " | |
| "FAILED PERCNT USER SYS REAL"); | |
| } | |
| /** | |
| Generates output header in verbose mode. | |
| */ | |
| static void | |
| print_header_verbose (const char* const argv[]) | |
| { | |
| print_argv (argv, 1 /* append newline */); | |
| } | |
| /** | |
| Generates target name listing, designed for text output and console viewing. | |
| */ | |
| static void | |
| print_target_plain (const struct target_opts *defaults) | |
| { | |
| const char* const target_name = get_target (); | |
| assert (0 == defaults->verbose); | |
| printf ("%-40.40s ", target_name); | |
| /* flush to prevent killing a signal from not displaying the text */ | |
| fflush (stdout); | |
| } | |
| /** | |
| Generates target name listing, designed for text output and console viewing. | |
| */ | |
| static void | |
| print_target_verbose (const struct target_opts *defaults) | |
| { | |
| assert (defaults->verbose); | |
| printf ("%s ", "Executing \""); | |
| print_argv (defaults->argv, 0 /* no newline */); | |
| /* print stdin, stdout, and stderr redirections */ | |
| if (defaults->infname && *defaults->infname) | |
| printf (" <%s", defaults->infname); | |
| if (defaults->outfname && *defaults->outfname) | |
| printf (" >%s 2>&1", defaults->outfname); | |
| puts ("\""); | |
| /* flush to prevent killing a signal from not displaying the text */ | |
| fflush (stdout); | |
| } | |
| /** | |
| Generates target result listing, designed for text output and console | |
| viewing. | |
| */ | |
| static void print_status_plain (const struct target_status* status) | |
| { | |
| unsigned valid_timing; | |
| assert (0 != status); | |
| assert (ST_OK <= status->status && ST_LAST > status->status); | |
| valid_timing = status->usr_time != (clock_t)-1 | |
| && status->sys_time != (clock_t)-1 | |
| && ST_NOT_KILLED != status->status; | |
| if (status->status) /* if status is set, print it */ | |
| printf ("%6s", short_st_name [status->status]); | |
| else if (status->signaled) /* if exit signal is non-zero, print it */ | |
| printf ("%6s", get_signame (status->exit)); | |
| else if (status->exit) /* if exit code is non-zero, print it */ | |
| printf ("%6d", status->exit); | |
| else | |
| printf (" 0"); | |
| printf (" %4u", status->c_warn + status->l_warn + status->t_warn); | |
| /* Print assetions, if any registered */ | |
| if ( (unsigned)-1 != status->assert | |
| && 0 == status->status | |
| && 0 == status->exit) { | |
| if (status->assert) { | |
| const int percnt = int ( 100.0 | |
| * (status->assert - status->failed) | |
| / status->assert); | |
| printf (" %7u %6u %5d%%", status->assert, status->failed, percnt); | |
| } | |
| else { | |
| printf (" 0 %6u 100%%", status->failed); | |
| } | |
| } | |
| else if (valid_timing || status->wall_time != (clock_t)-1) | |
| printf (" "); | |
| /* Print timings, if available */ | |
| if (valid_timing) | |
| printf (" %7.3f %7.3f", (float)status->usr_time / TICKS_PER_SEC, | |
| (float)status->sys_time / TICKS_PER_SEC); | |
| else if (status->wall_time != (clock_t)-1) | |
| printf (" "); | |
| if (status->wall_time != (clock_t)-1) | |
| printf (" %7.3f\n", (float)status->wall_time / TICKS_PER_SEC); | |
| else | |
| puts (""); | |
| } | |
| /** | |
| Generates verbose target result listing. | |
| */ | |
| static void | |
| print_status_verbose (const struct target_status* status) | |
| { | |
| unsigned valid_timing; | |
| assert (0 != status); | |
| assert (ST_OK <= status->status && ST_LAST > status->status); | |
| valid_timing = status->usr_time != (clock_t)-1 | |
| && status->sys_time != (clock_t)-1 | |
| && ST_NOT_KILLED != status->status; | |
| if (status->status) /* if status is set, print it */ | |
| printf (" Status: %s\n", verbose_st_name [status->status]); | |
| else if (status->signaled) /* if exit signal is non-zero, print it */ | |
| printf (" Process signalled: %s\n", get_signame (status->exit)); | |
| else { | |
| printf (" Exit status: %6d%s\n" | |
| " Compiler warnings: %6u\n" | |
| " Linker warnings: %6u\n" | |
| " Runtime warnings: %6u\n", | |
| status->exit, 0 == status->exit ? " (success)" : "", | |
| status->c_warn, | |
| status->l_warn, | |
| status->t_warn); | |
| /* Print assetions, if any registered */ | |
| if ((unsigned)-1 != status->assert && status->assert) { | |
| printf (" Failed assertions: %6u\n" | |
| " Total assertions: %6u\n", | |
| status->failed, status->assert); | |
| } | |
| } | |
| /* Print timings, if available */ | |
| if (valid_timing) { | |
| const float wall = (float)status->wall_time / TICKS_PER_SEC; | |
| const float user = (float)status->usr_time / TICKS_PER_SEC; | |
| const float sys = (float)status->sys_time / TICKS_PER_SEC; | |
| printf (" Times:\n" | |
| " Real %7.3fs\n" | |
| " User %7.3fs\n" | |
| " Sys %7.3fs\n", | |
| wall, user, sys); | |
| } | |
| puts (""); | |
| } | |
| /** | |
| Placholder output footer function, unneeded for text output and console | |
| viewing. | |
| */ | |
| static void | |
| print_footer_plain (int count, const struct target_status *summary) | |
| { | |
| /* compute cumulative times for all targets */ | |
| const float wall = (float)summary->wall_time / TICKS_PER_SEC; | |
| const float user = (float)summary->usr_time / TICKS_PER_SEC; | |
| const float sys = (float)summary->sys_time / TICKS_PER_SEC; | |
| printf ("PROGRAM SUMMARY:\n" | |
| " Programs: %9d\n" | |
| " Non-zero exit status: %9d\n" | |
| " Signalled: %9d\n" | |
| " Compiler warnings: %9u\n" | |
| " Linker warnings: %9u\n" | |
| " Runtime warnings: %9u\n", | |
| count, | |
| summary->exit, | |
| summary->signaled, | |
| summary->c_warn, | |
| summary->l_warn, | |
| summary->t_warn); | |
| if ((unsigned)-1 != summary->assert) { | |
| /* print assertion counters only when they're valid */ | |
| printf (" Assertions: %9u\n" | |
| " Failed assertions: %9u\n", | |
| summary->assert, | |
| summary->failed); | |
| } | |
| printf ( " Cumulative times:\n" | |
| " Real %7.3fs\n" | |
| " User %7.3fs\n" | |
| " Sys %7.3fs\n", | |
| wall, | |
| user, | |
| sys); | |
| } | |
| static void | |
| print_footer_verbose (int count, const struct target_status *summary) | |
| { | |
| print_footer_plain (count, summary); | |
| } | |
| /** | |
| Sets the output functions referenced. | |
| */ | |
| void set_output_format (enum OutputFmt format) | |
| { | |
| if (FMT_VERBOSE == format) { | |
| print_header = print_header_verbose; | |
| print_target = print_target_verbose; | |
| print_status = print_status_verbose; | |
| print_footer = print_footer_verbose; | |
| } | |
| else { | |
| /* only two formats implemented */ | |
| assert (FMT_PLAIN == format); | |
| print_header = print_header_plain; | |
| print_target = print_target_plain; | |
| print_status = print_status_plain; | |
| print_footer = print_footer_plain; | |
| } | |
| } | |
| void (*print_header) (const char* const[]) = print_header_plain; | |
| void (*print_target) (const struct target_opts*) = print_target_plain; | |
| void (*print_status) (const struct target_status*) = print_status_plain; | |
| void (*print_footer) (int, const struct target_status*) = print_footer_plain; |