quickstart-ints.cpp File Reference

#include <c4/yml/parse_engine.def.hpp>
#include <c4/yml/extra/event_handler_ints.hpp>
#include <c4/yml/extra/ints_utils.hpp>
#include <c4/std/vector.hpp>
#include <c4/yml/file.hpp>
#include <vector>

Go to the source code of this file.

Classes
struct	IntsResult
struct	IntsParser
struct	Args

Functions
void	print_usage (c4::csubstr basename)
bool	parse_args (int argc, const char **argv, Args *args, int &status)
int	main (int argc, const char *argv[])

Function Documentation

void print_usage

(

c4::csubstr

basename

)

Definition at line 96 of file quickstart-ints.cpp.

Referenced by parse_args().

{
    Args defaults = {};
    printf(R"(usage: %.*s [options] [<filename>]

   if filename is missing, we default to a preset example.

options:

   -e <size>,--events-size <size>    set size of events buffer. -1 means
                                     estimate size. default=%d
   -a <size>,--arena-size <size>     set size of arena buffer. -1 means
                                     take the source size as the arena size.
                                     default=%d
   -n,--no-retry                     do not retry parsing if any buffer size
                                     was insufficient. default=%s
   -q,--quiet                        do not print events. default=%s
)",
           static_cast<int>(basename.len), basename.str,
           defaults.events_size,
           defaults.arena_size,
           defaults.retry ? "retry" : "do not retry",
           defaults.quiet ? "quiet" : "print events");
}

bool parse_args	(	int	argc,
		const char **	argv,
		Args *	args,
		int &	status
	)

Definition at line 120 of file quickstart-ints.cpp.

Referenced by main().

{
    c4::csubstr basename = argv[0];
    // read left-to-right until we find an arg that is not an option
    int remaining = argc - 1;
    ++argv;
    auto advance = [&](int num) { argv += num; remaining -= num; };
    auto parse_arg = [&](const char *name, int *dst) {
        if(remaining > 1)
        {
            c4::csubstr val = argv[1];
            if(!c4::atoi(val, dst))
            {
                status = -1;
                printf("error: could not parse %s value: %.*s\n", name, static_cast<int>(val.len), val.str);
            }
            advance(2);
        }
        else
        {
            status = -1;
            printf("error: missing value: %s\n", name);
        }
        return true;
    };
    while(remaining > 0 && status == 0)
    {
        c4::csubstr arg = argv[0];
        if(arg == "-h" || arg == "--help")
        {
            print_usage(basename);
            status = 0;
            return false;
        }
        else if(arg == "-e" || arg == "--events-size")
        {
            parse_arg("--events-size", &args->events_size);
        }
        else if(arg == "-a" || arg == "--arena-size")
        {
            parse_arg("--arena-size", &args->arena_size);
        }
        else if(arg == "-n" || arg == "--no-retry")
        {
            args->retry = false;
            advance(1);
        }
        else if(arg == "-q" || arg == "--quiet")
        {
            args->quiet = false;
            advance(1);
        }
        else
            break;
    }
    if(remaining == 1)
    {
        if(status == 0)
            args->filename = argv[0];
    }
    else if(remaining > 1)
    {
        print_usage(basename);
        printf("error: too many arguments\n");
        status = -1;
    }
    return status == 0;
}

int main	(	int	argc,
		const char *	argv[]
	)

Definition at line 194 of file quickstart-ints.cpp.

{
    Args args = {};
    int status = 0;
    if(!parse_args(argc, argv, &args, status))
        return status;

    // if no filename is given, we run a demo,
    // and show the result is as expected.
    bool is_demo = args.filename == nullptr;

    // YAML code to be parsed in place
    char demo_yaml[] = ""
        "doe: a deer, a female deer\n"
        "ray: a drop of golden sun\n"
        "me : a name I call myself\n"
        "far: a long long way to run\n"
        "";

    // these are the events we expect from parsing the demo YAML
    auto STR = c4::yml::extra::ievt::PSTR; // PSTR does not work in windows
    const int demo_expected[] = {
        BSTR,
        BDOC,
        VAL_|BMAP|BLCK,
        KEY_|SCLR|PLAI,      0,  3,  // "doe"
        VAL_|SCLR|PLAI|STR,  5, 21,  // "a deer, a female deer"
        KEY_|SCLR|PLAI|STR, 27,  3,  // "ray"
        VAL_|SCLR|PLAI|STR, 32, 20,  // "a drop of golden sun"
        KEY_|SCLR|PLAI|STR, 53,  2,  // "me"
        VAL_|SCLR|PLAI|STR, 58, 20,  // "a name I call myself"
        KEY_|SCLR|PLAI|STR, 79,  3,  // "far"
        VAL_|SCLR|PLAI|STR, 84, 22,  // "a long long way to run"
        EMAP|STR,
        EDOC,
        ESTR,
    };

    /* the output should be this:
     *
     * pos=0    event[0]:                   BSTR = 0x00000001
     * pos=1    event[1]:                   BDOC = 0x00000004
     * pos=2    event[2]:         VAL_|BMAP|BLCK = 0x00140010
     * pos=3    event[3]:         KEY_|SCLR|PLAI = 0x00081100   str=(0,3)   'doe'
     * pos=6    event[4]:    VAL_|SCLR|PLAI|PSTR = 0x04101100   str=(5,21)  'a deer, a female deer'
     * pos=9    event[5]:    KEY_|SCLR|PLAI|PSTR = 0x04081100   str=(27,3)  'ray'
     * pos=12   event[6]:    VAL_|SCLR|PLAI|PSTR = 0x04101100   str=(32,20) 'a drop of golden sun'
     * pos=15   event[7]:    KEY_|SCLR|PLAI|PSTR = 0x04081100   str=(53,2)  'me'
     * pos=18   event[8]:    VAL_|SCLR|PLAI|PSTR = 0x04101100   str=(58,20) 'a name I call myself'
     * pos=21   event[9]:    KEY_|SCLR|PLAI|PSTR = 0x04081100   str=(79,3)  'far'
     * pos=24   event[10]:   VAL_|SCLR|PLAI|PSTR = 0x04101100   str=(84,22) 'a long long way to run'
     * pos=27   event[11]:             EMAP|PSTR = 0x04000020
     * pos=28   event[12]:                  EDOC = 0x00000008
     * pos=29   event[13]:                  ESTR = 0x00000002
     */

    IntsParser parser;
    IntsResult result;

    const char *filename = args.filename;
    std::vector<char> yaml_file;
    c4::substr yaml;

    if(is_demo)
    {
        yaml = demo_yaml;
        filename = "demo";
    }
    else
    {
        c4::csubstr filename_ = c4::to_csubstr(filename);
        if(filename_ == "-" || filename_ == "stdin")
            c4::yml::stdin_get_contents(&yaml_file); // LCOV_EXCL_LINE lcov fail
        else
            c4::yml::file_get_contents(&yaml_file, args.filename);
        yaml = c4::to_substr(yaml_file);
    }

    if(args.events_size == -1)
        args.events_size = c4::yml::extra::estimate_events_ints_size(yaml);
    if(args.arena_size == -1)
        args.arena_size = static_cast<int>(yaml.size());

    result.resize_buffers(args.events_size, static_cast<size_t>(args.arena_size));

    // parse now. since we did not set up the error callbacks, if
    // there is a parse error, we will get the default behavior, which
    // is abort on error
    if( ! args.retry)
    {
        if( ! parser.parse_in_place(filename, yaml, &result))
            return 1;
    }
    else
    {
        if( ! parser.parse_or_resize_and_then_parse(filename, yaml, &result))
            return 1; // this is really not expected   LCOV_EXCL_LINE
    }

    if( ! is_demo)
    {
        if( ! args.quiet)
        {
            c4::csubstr actual_buffer = args.retry ? yaml : c4::to_csubstr(result.yaml);
            c4::yml::extra::events_ints_print(actual_buffer, c4::to_csubstr(result.arena),
                                              result.events.data(),
                                              static_cast<c4::yml::extra::evt_size>(result.events.size()));
        }
        return 0;
    }

    // we have the demo. ensure the result is as expected
    bool success = true;

    // example iterating through the events array: compare and print
    // the result
    char flags[100]; // buffer for converting event flags to string
    for (size_t pos = 0, evt = 0, sz = static_cast<size_t>(parser.handler.required_size_events());
         pos < sz;
         ++pos, ++evt)
    {
        bool ok = (result.events[pos] == demo_expected[pos]);
        // print the event
        if( ! args.quiet)
        {
            // let's format the event flags to print them as string.
            size_t len = c4::yml::extra::ievt::to_str(flags, result.events[pos]);
            printf("pos=%zu\tevent[%zu]:\t%.*s = 0x%08x", pos, evt, static_cast<int>(len), flags, result.events[pos]);
        }
        if(result.events[pos] & WSTR) // the event has a string following it
        {
            int offset = result.events[pos + 1];
            int length = result.events[pos + 2];
            bool in_arena = (result.events[pos] & AREN);
            // WATCHOUT! the string is NOT ZERO TERMINATED!
            const char *ptr = in_arena ? result.arena.data() : yaml.str;
            const char *str = ptr + offset;
            if( ! args.quiet)
                printf("\tstr=(%d,%d)\t'%.*s'", offset, length, length, str);
            ok = ok && (offset == demo_expected[pos + 1]);
            ok = ok && (length == demo_expected[pos + 2]);
            pos += 2; // advance the two ints from the string
        }
        if(!ok)
        {
            if( ! args.quiet)          // LCOV_EXCL_LINE
                printf("  ... fail!"); // LCOV_EXCL_LINE
            success = false;           // LCOV_EXCL_LINE
        }
        if( ! args.quiet)          // LCOV_EXCL_LINE
            printf("\n");
    }

    return success ? 0 : 1;
}