drgn/libdrgn/build-aux/checkmk

#! /usr/bin/awk -f
# Generated from checkmk.in;FILEPATH by configure.

# checkmk - translate more concise versions of test suite specifications
#           into C programs suitable for use with the Check unit test
#           framework.

# -- LICENSE --
#
# Written by Micah Cowan <micah@cowan.name>
# Copyright (c) 2006, 2010  Micah Cowan
#
# Redistribution of this program in any form, with or without
# modifications, is permitted, provided that the above copyright is
# retained in distributions of this program in source form.
#
# (This is a free, non-copyleft license compatible with pretty much any
# other free or proprietary license, including the GPL. It's essentially
# a scaled-down version of the "modified" BSD license.)

BEGIN {
    progname="checkmk";
    is_stdin=0;
    outfname="/dev/stdout";

    # Tokens
    pp_ws            = "[ \\t\\f\\v\\r\\n]+";
    pp_ws_op         = "[ \\t\\f\\v\\r\\n]*";
    pp_digit         = "[0-9]+"
    pp_prefix        = pp_ws_op "#" pp_ws_op;
    pp_sep           = "[ \\t\\f\\v\\r\\n]+";
    pp_name          = ".+";
    pp_hex_quad      = "[A-F0-9a-f][A-F0-9a-f][A-F0-9a-f][A-F0-9a-f]"
    pp_ucn           = "\\\\(u" pp_hex_quad "|U" pp_hex_quad pp_hex_quad ")";
    pp_test_name     = "([A-Za-z_]|" pp_ucn ")([A-Za-z0-9_]|" pp_ucn ")*";
    pp_tag           = "([Ss][Uu][Ii][Tt][Ee]|[Tt][Cc][Aa][Ss][Ee])";
    pp_test_tag      = "[Tt][Ee][Ss][Tt]";
    pp_main_pre_tag  = "[Mm][Aa][Ii][Nn]-[Pp][Rr][Ee]";
    pp_main_post_tag = "[Mm][Aa][Ii][Nn]-[Pp][Oo][Ss][Tt]";

    # Tests with arguments
    pp_test_exit_tag = "[Tt][Ee][Ss][Tt]-[Ee][Xx][Ii][Tt]" pp_ws_op "[(]" \
        pp_ws_op "[+-]?" pp_ws_op pp_digit pp_ws_op "[)]";

    pp_test_signal_tag = "[Tt][Ee][Ss][Tt]-[Ss][Ii][Gg][Nn][Aa][Ll]" pp_ws_op \
        "[(]" pp_ws_op "[+-]?" pp_ws_op pp_digit pp_ws_op "[)]";

    pp_test_loop_tag = "[Tt][Ee][Ss][Tt]-[Ll][Oo][Oo][Pp]" pp_ws_op "[(]" \
        pp_ws_op "[+-]?" pp_ws_op pp_digit pp_ws_op "[,]" pp_ws_op \
        "[+-]?" pp_ws_op pp_digit pp_ws_op "[)]";

    pp_test_loop_exit_tag = "[Tt][Ee][Ss][Tt]-[Ll][Oo][Oo][Pp]-[Ee][Xx][Ii][Tt]" \
        pp_ws_op "[(]" pp_ws_op "[+-]?" pp_ws_op pp_digit pp_ws_op \
        "[,]" pp_ws_op "[+-]?" pp_ws_op pp_digit pp_ws_op "[,]" \
        pp_ws_op "[+-]?" pp_ws_op pp_digit pp_ws_op "[)]";

    pp_test_loop_signal_tag = "[Tt][Ee][Ss][Tt]-[Ll][Oo][Oo][Pp]-[Ss][Ii][Gg]" \
        "[Nn][Aa][Ll]" pp_ws_op "[(]" pp_ws_op "[+-]?" pp_ws_op pp_digit \
        pp_ws_op "[,]" pp_ws_op "[+-]?" pp_ws_op pp_digit pp_ws_op \
        "[,]" pp_ws_op "[+-]?" pp_ws_op pp_digit pp_ws_op "[)]";

    pp_suite_or_tcase_line = "^" pp_prefix pp_tag pp_ws pp_name "$";
    pp_test_line_prefix = "^" pp_prefix pp_test_tag pp_ws;
    pp_test_exit_line_prefix = "^" pp_prefix pp_test_exit_tag pp_ws;
    pp_test_signal_line_prefix = "^" pp_prefix pp_test_signal_tag pp_ws;
    pp_test_loop_line_prefix = "^" pp_prefix pp_test_loop_tag pp_ws;
    pp_test_loop_exit_line_prefix = "^" pp_prefix pp_test_loop_exit_tag pp_ws;
    pp_test_loop_signal_line_prefix = "^" pp_prefix pp_test_loop_signal_tag pp_ws;
    pp_test_line = pp_test_line_prefix pp_name pp_ws_op "$";
    pp_test_exit_line = pp_test_exit_line_prefix pp_name pp_ws_op "$";
    pp_test_signal_line = pp_test_signal_line_prefix pp_name pp_ws_op "$";
    pp_test_loop_line = pp_test_loop_line_prefix pp_name pp_ws_op "$";
    pp_test_loop_exit_line = pp_test_loop_exit_line_prefix pp_name pp_ws_op "$";
    pp_test_loop_signal_line = pp_test_loop_signal_line_prefix pp_name pp_ws_op "$";
    pp_main_pre_line = "^" pp_prefix pp_main_pre_tag pp_ws_op "$";
    pp_main_post_line = "^" pp_prefix pp_main_post_tag pp_ws_op "$";

    # Global vars
    in_test = needs_line_decl = 0;
    cur_suite = cur_tcase = "Core";
    cur_test = "";
    exit_okay = start = 1;
    num_cur_tcases = num_cur_tests = 0;
    test_type = num_tests = 0;
    arg1 = 0;
    arg2 = 1;
    arg3 = 2;
    test_name = 0;
    test_type_flag = 1;
}

# Run on the first line of the input file.
start {
    print_boilerplate();
    start = 0;
}

# (Executed every line:)
{
    print_line = 1;
}

$0 ~ pp_suite_or_tcase_line {
    if (in_main())
        in_main_error();

    # Skip to the start of the tag ("suite" or "tcase").
    match($0, pp_prefix);
    rol = substr($0, RLENGTH+1);

    # Save away the tag.
    match(rol, "^" pp_tag);
    tag = substr(rol, 1, RLENGTH);

    # Advance past the ws following tag.
    rol = substr(rol, RLENGTH+1);
    match(rol, pp_ws);
    rol = substr(rol, RLENGTH+1);

    # The suite or tcase name is the rest of the line, minus any
    # trailing ws.
    if (match(rol, pp_ws "$")) {
        name = substr(rol, 1, RSTART-1);
    } else {
        name = rol;
    }

    if (tolower(tag) == "suite") {
        # Does this suite already exist?
        if ((name, 0) in suite_tcase_map) {
            error_with_line("Suite \"" name "\" already exists.");
        }
        cur_suite = name;
        num_cur_tcases = 0;
    }
    else if ((name, 0, 0) in tcase_test_map) {
        error_with_line("Test Case \"" name "\" already exists.");
    }
    cur_tcase = name;
    num_cur_tests = 0;

    finish_test();
    print_line = 0;
    if (!clean_mode)
        needs_line_decl = 1;
}

$0 ~ pp_test_line {

    # Pre checks
    test_pre();

    # Get the test name
    match($0, pp_test_line_prefix)
    cur_test = substr($0, RLENGTH+1);

    # Remove trailing ws.
    sub(pp_ws_op "$", "", cur_test);

    # Check for duplicate tests / cases and valid names
    duplicate_check();

    # Boilerplate printing code
    test_post();

    # Set type before calling register
    test_type = 0;
    register_test();

    print_line = 0;
    in_test = 1;
}

$0 ~ pp_test_loop_line {

    test_pre();

    match($0, pp_test_loop_line_prefix)
    cur_test = substr($0, RLENGTH+1);
    sub(pp_ws_op "$", "", cur_test);

    duplicate_check();

    # Split the line into an array to extract the arguments
    split($0, arr, pp_ws_op "[(),]" pp_ws_op);

    # Eliminate possible whitespace between sign and numbers
    gsub(pp_ws_op, "", arr[2]);
    gsub(pp_ws_op, "", arr[3]);

    test_post();

    test_type = 1;
    register_test();

    print_line = 0;
    in_test = 1;
}

$0 ~ pp_test_exit_line {

    test_pre();

    match($0, pp_test_exit_line_prefix)
    cur_test = substr($0, RLENGTH+1);
    sub(pp_ws_op "$", "", cur_test);

    duplicate_check();

    split($0, arr, pp_ws_op "[(),]" pp_ws_op);
    gsub(pp_ws_op, "", arr[2]);

    test_post();

    test_type = 2;
    register_test();

    print_line = 0;
    in_test = 1;
}

$0 ~ pp_test_signal_line {

    test_pre();

    match($0, pp_test_signal_line_prefix)
    cur_test = substr($0, RLENGTH+1);
    sub(pp_ws_op "$", "", cur_test);

    duplicate_check();

    split($0, arr, pp_ws_op "[(),]" pp_ws_op);
    gsub(pp_ws_op, "", arr[2]);

    test_post();

    test_type = 3;
    register_test();

    print_line = 0;
    in_test = 1;
}

$0 ~ pp_test_loop_exit_line {

    test_pre();

    match($0, pp_test_loop_exit_line_prefix)
    cur_test = substr($0, RLENGTH+1);
    sub(pp_ws_op "$", "", cur_test);

    duplicate_check();

    split($0, arr, pp_ws_op "[(),]" pp_ws_op);
    gsub(pp_ws_op, "", arr[2]);
    gsub(pp_ws_op, "", arr[3]);
    gsub(pp_ws_op, "", arr[4]);

    test_post();

    test_type = 4;
    register_test();

    print_line = 0;
    in_test = 1;
}

$0 ~ pp_test_loop_signal_line {

    test_pre();

    match($0, pp_test_loop_signal_line_prefix)
    cur_test = substr($0, RLENGTH+1);
    sub(pp_ws_op "$", "", cur_test);

    duplicate_check();

    split($0, arr, pp_ws_op "[(),]" pp_ws_op);
    gsub(pp_ws_op, "", arr[2]);
    gsub(pp_ws_op, "", arr[3]);
    gsub(pp_ws_op, "", arr[4]);

    test_post();

    test_type = 5;
    register_test();

    print_line = 0;
    in_test = 1;
}

$0 ~ pp_main_pre_line {
    main_pre();

    print "";
    print "    /* User-specified pre-run code */";

    if (!clean_mode)
        needs_line_decl = 1;
    print_line = 0;
}

$0 ~ pp_main_post_line {
    main_post();

    print "";
    print "    /* User-specified post-run code */";

    if (!clean_mode)
        needs_line_decl = 1;
    print_line = 0;
}

print_line {
    if (/[^ \t\f\v\r\n]/ && needs_line_decl && !clean_mode) {
        print "#line " FNR;
        needs_line_decl = 0;
    }
    print;
}

END {
    if (!exit_okay) {
        # We're exiting due to an error. Don't do anything else.
    }
    else if (num_tests) {
        if (!main_post_done) {
            main_post();
            print "";
            print "    return nf == 0 ? 0 : 1;";
        }
        print "}";
    }
    else {
        error("Expected at least one #test line.");
    }
}

### Functions ###

function test_pre()
{
    if (in_main())
        in_main_error();

    if (in_test) {
        finish_test();
        print "";
    }
    ++num_tests;
}

function duplicate_check()
{
    # Confirm that the test name is a valid C identifier.
    if (!match(cur_test, "^" pp_test_name "$")) {
        error_with_line("Malformed test name \"" cur_test \
                        "\" (must be a C identifier).");
    }

    # Verify that it has not already been used.
    if (cur_test in test_registry) {
        error_with_line("Test \"" cur_test "\" already exists.");
    }

    # Verify that any implied test case is not a repeat.
    if (num_cur_tests == 0 && (cur_tcase, 0, 0) in tcase_test_map) {
        error_with_line("Test Case \"" name "\" already exists.");
    }
}

function test_post()
{
    print "START_TEST(" cur_test ")";
    print "{";
    if (!clean_mode)
        print "#line " FNR+1;

    needs_line_decl = 0;
}

function main_post()
{
    if (main_post_done)
        error_with_line("main-post specified multiple times.");
    if (!main_pre_done)
        main_pre();
    main_post_done = 1;

    print "";

    print_runner_bindings();

    print "";
    print "    srunner_run_all(sr, CK_ENV);";
    print "    nf = srunner_ntests_failed(sr);";
    print "    srunner_free(sr);";
}

function in_main()
{
    return main_pre_done || main_post_done;
}

function in_main_error()
{
    error_with_line("Cannot specify tests after main-pre or main-post.");
}

function main_pre()
{
    if (main_post_done)
        error_with_line("main-pre specified after main-post.");
    if (main_pre_done)
        error_with_line("main-pre specified multiple times.");
    main_pre_done = 1;
    finish_test();
    print "";
    print "int main(void)";
    print "{";

    print_main_declarations();
}

function suite_var_name(num)
{
    return "s" num+1;
}

function tcase_var_name(snum, tcnum)
{
    return "tc" snum+1 "_" tcnum+1;
}

function print_main_declarations()
{
    for (i=0; i != num_suites; ++i) {
        s = suite_names[i];
        svar = suite_var_name(i);
        print "    Suite *" svar " = suite_create(" string_encode(s) ");";
        for (j=0; j != suite_num_tcases[s]; ++j) {
            tc = suite_tcase_map[s, j];
            tcvar = tcase_var_name(i, j);
            print "    TCase *" tcvar " = tcase_create(" \
                    string_encode(tc) ");";
        }
    }
    print "    SRunner *sr = srunner_create(s1);";
    print "    int nf;";
}

function string_encode(raw)
{
    # The next line might look funny, but remember that the first
    # argument will go through both string interpolation /and/ regex
    # interpolation, so the backslashes must be double-escaped. The
    # substitution string is supposed to result in an actual
    # double-backslash.
    gsub("\\\\", "", raw);
    gsub("\"", "\\\"", raw);
    return "\"" raw "\"";
}

function print_runner_bindings()
{
    for (i=0; i != num_suites; ++i) {
        s = suite_names[i];
        svar = suite_var_name(i);
        for (j=0; j != suite_num_tcases[s]; ++j) {
            tc = suite_tcase_map[s, j];
            tcvar = tcase_var_name(i, j);
            print "    suite_add_tcase(" svar ", " tcvar ");";
            for (k=0; k != tcase_num_tests[tc]; ++k) {
                t = tcase_test_map[tc, k, test_name];
                test_type = tcase_test_map[tc, k, test_type_flag];
                if (test_type == 0) {
                    print "    tcase_add_test(" tcvar ", " t ");";
                }
                else if (test_type == 1) {
                    print "    tcase_add_loop_test(" tcvar ", " t ", " \
                        test_parameters[t, arg1] ", " test_parameters[t, arg2] \
                        ");";
                }
                else if (test_type == 2) {
                    print "    tcase_add_exit_test(" tcvar ", " t ", " \
                        test_parameters[t, arg1] ");";
                }
                else if (test_type == 3) {
                    print "    tcase_add_test_raise_signal(" tcvar ", " t ", " \
                        test_parameters[t, arg1] ");";
                }
                else if (test_type == 4) {
                    print "    tcase_add_loop_exit_test(" tcvar ", " t ", " \
                        test_parameters[t, arg1] ", " test_parameters[t, arg2] \
                        ", " test_parameters[t, arg3] ");";
                }
                else if (test_type == 5) {
                    print "    tcase_add_loop_test_raise_signal(" tcvar ", " t \
                        ", " test_parameters[t, arg1] ", " test_parameters[t, arg2] \
                        ", " test_parameters[t, arg3] ");";
                }
            }
        }
    }
    if (num_suites > 1) {
        print "";
        for (i=1; i != num_suites; ++i) {
            svar = suite_var_name(i);
            print "    srunner_add_suite(sr, " svar ");";
        }
    }
}

function register_test()
{
    if (num_cur_tcases == 0) {
        suite_names[num_suites++] = cur_suite;
    }
    if (num_cur_tests == 0) {
        suite_tcase_map[cur_suite, num_cur_tcases++] = cur_tcase;
        suite_num_tcases[cur_suite] = num_cur_tcases;
    }
    tcase_test_map[cur_tcase, num_cur_tests, test_name] = cur_test;
    tcase_test_map[cur_tcase, num_cur_tests++, test_type_flag] = test_type;
    tcase_num_tests[cur_tcase] = num_cur_tests;
    test_registry[cur_test] = 1;

    # Store arguments to array
    test_parameters[cur_test, arg1] = arr[2];
    test_parameters[cur_test, arg2] = arr[3];
    test_parameters[cur_test, arg3] = arr[4];
}

function finish_test()
{
    if (in_test) {
        in_test = 0;
        print "}";
        print "END_TEST";
    }
}

function print_boilerplate()
{
    print "/*";
    print " * DO NOT EDIT THIS FILE. Generated by " progname ".";
    if (!FILENAME || FILENAME == "-") {
        clean_mode=1;
        is_stdin=1;
    }
    if (is_stdin)
        srcfile = "(standard input)";
    else
        srcfile = "\"" FILENAME "\"";
    print " * Edit the original source file " srcfile " instead.";
    print " */";
    print "";
    print "#include <check.h>";
    print "";
    if (!clean_mode)
        print "#line 1 " string_encode(FILENAME)
}

function error_with_line(err)
{
    error((is_stdin ? "(standard input)" : FILENAME) " line " FNR ": " err);
}

function error(err)
{
    print progname ": " err > "/dev/stderr";
    exit_okay = 0;
    exit 1;
}