The libxo library allows an application to generate text, XML, JSON, and HTML output using a common set of function calls. The application decides at run time which output style should be produced.

Overview

libxo

libxo - A Library for Generating Text, XML, JSON, and HTML Output

The libxo library allows an application to generate text, XML, JSON, and HTML output using a common set of function calls. The application decides at run time which output style should be produced. The application calls a function "xo_emit" to product output that is described in a format string. A "field descriptor" tells libxo what the field is and what it means.

Imagine a simplified wc that emits its output fields in a single xo_emit call:

    xo_emit(" {:lines/%7ju/%ju} {:words/%7ju/%ju} "
            "{:characters/%7ju/%ju}{d:filename/%s}\n",
            linect, wordct, charct, file);

Output can then be generated in various style, using the "--libxo" option:

    % wc /etc/motd
          25     165    1140 /etc/motd
    % wc --libxo xml,pretty,warn /etc/motd
    <wc>
      <file>
        <filename>/etc/motd</filename>
        <lines>25</lines>
        <words>165</words>
        <characters>1140</characters>
      </file>
    </wc>
    % wc --libxo json,pretty,warn /etc/motd
    {
      "wc": {
        "file": [
          {
            "filename": "/etc/motd",
            "lines": 25,
            "words": 165,
            "characters": 1140
          }
        ]
      }
    }
    % wc --libxo html,pretty,warn /etc/motd
    <div class="line">
      <div class="text"> </div>
      <div class="data" data-tag="lines">     25</div>
      <div class="text"> </div>
      <div class="data" data-tag="words">    165</div>
      <div class="text"> </div>
      <div class="data" data-tag="characters">   1140</div>
      <div class="text"> </div>
      <div class="data" data-tag="filename">/etc/motd</div>
    </div>

View the beautiful documentation at:

http://juniper.github.io/libxo/libxo-manual.html

Analytics

Comments
  • 'plain' output with a defined field-separator

    'plain' output with a defined field-separator

    Hi. I notice that the output from "df" is tricky to parse, when the mount "device" and/or the mount-point contain spaces.. (yeah, i know... don't ask!!! )

    "mount -p" uses (one or more) tab characters to separate fields, UNLESS the field is over 24 character in which case it uses space. (arrrrgh)

    I see that the idea behind libxo is to enable processing of data, by not having to try and parse human-readable output. This is great, and just what I'd want.

    'df' does indeed have libxo functionality, and whilst this would do the trick, parsing xml or json is overkill. I was hoping it would be possible to have something like:

    --libxo=delimited,delimiter="",record-separator=""

    e.g.

    --libxo=delimited,delimiter="\0",record-separator="\n"

    or maybe being able to pass a format string in printf format?

    Is this kind of thing generally useful?

    In my particular case, I ended up writing a small C function just to grab the mount "device" and mount-point I needed, but it seemed to me that this what exactly the sort of thing libxo was meant to solve.

    Am I missing something?

    Cheers, Jamie

    opened by Jamie-Landeg-Jones 9
  • add color role

    add color role

    Oleg Ginzburg writes:

    I wanted to ask - is there some method to be used in the output xo ANSII codes? For normal human text sometimes you want to draw a conclusion in color to make it more human output ;)

    Color would be a useful enhancement, but it can't be done by intermixing escape sequnces with data. It would need to be something more explicit and meaningful, something like:

    xo_emit("The {k:name} {C:green}weighs{C:} {:weight/%d} pounds\n", name, weight);
    

    The new "C" role would accept a name that would appear as escape sequences for text and "style" attributes for HTML. The list of color names should be freakishly small, to keep it portable, and unknown colors would be ignored (with a warning).

    Hmm... instead of directly making a color style attribute, I'd probably opt for a color class, allowing CSS files to adjust it when/if needed.

    And no, it won't support blinking ;^)

    Thanks, Phil

    enhancement 
    opened by philshafer 8
  • libxo/xo_syslog: fix obtaining HOST_NAME_MAX

    libxo/xo_syslog: fix obtaining HOST_NAME_MAX

    _SC_HOST_NAME_MAX has been incorrectly treated as the HOST_NAME_MAX length. This leads to gethostname(3) being passed an accidental value of '72' instead of the actual maximum length allowed for the hostname.

    Fall back to using _POSIX_HOST_NAME_MAX as the remaining code is not ready for introducing sysconf(3) while _POSIX_HOST_NAME_MAX can be used as a proper drop in replacement.

    While here we fix improper accounting that could lead to hostname ending up as an unterminated string. Documentation for gethostname(3) states:

    The gethostname() function returns the standard host name for the current processor, as previously set by sethostname(). The namelen argument specifies the size of the name array. The returned name is null- terminated unless insufficient space is provided.

    We can also read in the sysconf(3) manual:

    _SC_HOST_NAME_MAX Maximum length of a host name (not including the terminating null) as returned from the gethostname() function.

    Hence, to properly store the result of gethostname(3) we need an array of size HOST_NAME_MAX+1 to store the terminating null byte. If we fail to do this we can end up with a non-terminated C string in situations where the current hostname hits the limit.

    Using sysconf(3) API is not a drop in replacement as that would lead to the introduction of variable length arrays (VLA) in the code. To do this properly we would have to call sysconf(3) to obtain hostmax length then malloc(hostmax+1) for the hostname, remember to pass hostmax+1 to gethostname(3) and finally to free it after use.

    Sponsored by: Fudo Security

    opened by mulander 6
  • No man page for xo_emit_field()

    No man page for xo_emit_field()

    ~~libxo seems to have convenient APIs to allow various compile-time field names to be used. However, sometimes in life, I have a set of dynamically determined field names, and it wasn't clear to me that the API made that convenient. Possibly I've suffered a documentation spelunking fail, in which case please just point me in the right direction and close. But here is an example:~~

    #include <libxo/xo.h>
    
    /*
     * Sometimes with libxo, I have a set of field names only known at run time.
     * For example, if a program self instruments using hardware performance
     * counters, and because of a limited number of hardware counter registers,
     * the user has to select up to 6 at a time, but we need to support hundreds
     * of potential values.  In this example code, I want to allow the field name
     * to be a string generated at run time .. but I wasn't sure how to do that in 
     * a way that was elegant with libxo.
     */
    void
    what_I_wanted_to_do(const char *variable, const char *value)
    {
    
            xo_open_container("wanted_to_do");
            xo_emit("{:%s/%s}", variable, value);
            xo_close_container("wanted_to_do");
    }
    
    void
    what_I_did(const char *variable, const char *value)
    {
            char buffer[128];
    
            snprintf(buffer, sizeof(buffer), "{:%s/%%s}", variable);
            xo_open_container("did");
            xo_emit(buffer, value);
            xo_close_container("did");
    }
    
    int
    main(int argc, char *argv[])
    {
    
            xo_set_style(NULL, XO_STYLE_JSON);
            xo_set_flags(NULL, XOF_PRETTY);
            what_I_wanted_to_do("L1D_CACHE_ACCESS", "10");
            what_I_did("L1D_CACHE_ACCESS", "10");
            xo_finish();
            return(0);
    }
    

    Which outputs:

    {
      "wanted_to_do": {
        "%s": "L1D_CACHE_ACCESS"
      },
      "did": {
        "L1D_CACHE_ACCESS": "10"
      }
    }
    

    ~~In this scenario, the A72 core we're using has dozens of performance counter events that can be configured, but due to an architectural limit, only 6 can be used at a time. The strings for those registers are already defined in other headers, and I definitely don't want to retype them or do anything to replicate that. Instead, I want to have the user pass the names via the command line, validate them using the PMC library, and then use them as field names with libxo.~~

    ~~Pointers most welcome!~~

    bug 
    opened by rwatson 6
  • Better translation support

    Better translation support

    [ Writing up summary of discussion from the Ottawa departure lounge ]

    It would be nice to make the formatting strings more amenable to translation, referring to fields by name and allowing reordering in the translated version. For example, if I want to print the string:

    Push the red button.
    

    In French this is:

    Poussez le bouton rouge.
    

    I want to translate this in two chunks, because the button colour is locale-dependent. This is typically done now with gettext as something like:

    printf(_("Push the %s button."), _(red));
    

    This becomes more complex in C if you have multiple formats, because you need to use the printf modifies to reorder them. Languages like Python that have dictionaries as first-class citizens make this a bit easier, by passing a dictionary for the arguments with the format string including them by name.

    It would be nice to change the xo_emit() calls to do the next best thing in C, where each of the variadic parameters are pairs of name and format string, followed by the variadic parameter. For example:

    xo_emit("Push the {colour} button", "color,s", "red");
    

    The translation of the format string would also allow other utilities to do the transformation, for example if we emit HTML, transform it, and then want to translate it at the end of a pipeline. libxo should assume that all format strings (though probably not all strings that are inserted, unless they have a modifier character) should be translated.

    opened by davidchisnall 6
  • releases don't include manpages

    releases don't include manpages

    Release tarballs have makefiles that reference manpages and they exist in the repository, but the manpages themselves are in the tarballs so the release don't build without patching.

    opened by brooksdavis 6
  • xo_emit(3) in FreeBSD points to github page for manual and is not versioned appropriately; can diverge from source code

    xo_emit(3) in FreeBSD points to github page for manual and is not versioned appropriately; can diverge from source code

    xo_emit(3) on FreeBSD points the reader to the github manual instead of providing a description of the lexicon, or an in-depth description of the APIs. The problem with this is that one day when libxo has matured enough in FreeBSD, and the libxo project has been under development long enough, the manual will diverge from the source code.

    The documentation needs to be versioned appropriately, or needs to be distributed with FreeBSD and needs to reference appropriate paths under /usr/share/doc/... .

    opened by ngie-eign 6
  • Output containing reserved characters isn't escaped allowing invalid JSON and XML

    Output containing reserved characters isn't escaped allowing invalid JSON and XML

    Some code we were running that used libxo added single quote characters to a string that ended up in a value (via a few levels of indirection) and we were surprised to find that invalid XML was produced. It would be helpful if libxo did this for us or at a minimum least provided a simple vis(3) like function that did the escaping required for the current format mode.

    In our case I ended up using a strsnvis() to blindly encode XML and JSON special characters.

    opened by brooksdavis 5
  • Apply the __printflike attribute to xo_emit variants

    Apply the __printflike attribute to xo_emit variants

    This allows clang to detect type mismatches and generate proper warnings:

    error: format specifies type 'char *' but the argument has type 'int' [-Werror,-Wformat] xo_emit("%s", 1); ~~ ^ %d

    opened by allanjude 4
  • Feature request: binary output

    Feature request: binary output

    We're using libxo as part of the SOAAP project to output the results of our security-oriented static analysis. It's working quite well, but when we apply the tool to applications like Chromium we get JSON files of over 1GB. These are hard to work with, not just because they're large, but because we can't seek in the file without parsing.

    It would be helpful if libxo also supported a binary output format with some kind of length encoding so that we could skip large objects and arrays that we're not currently interested in. Perhaps an existing encoding could be employed... for instance, there are C bindings for Cap'n Proto (MIT license).

    opened by trombonehero 4
  • libxo output breaks if buffer exceeds 8kb

    libxo output breaks if buffer exceeds 8kb

    While converting the FreeBSD procstat utility to libxo, I noticed that if the output exceeds 8kb, and stdout is a file or a pipe, the content is truncated.

    to reproduce, run some command that produces more than 8192 bytes of data via libxo, and redirect stdout to a file, or pipe it to less or similar. The output will be truncated.

    opened by allanjude 4
  • libxo inconsistent field truncation

    libxo inconsistent field truncation

    Hi again Phil!

    Tested on FreeBSD 12-stable and 13.0-RELEASE:

    I noticed that "ps" sets the maximum length of the command field to 2048 characters [POSIX2_MAX_LENGTH] via the instructlion "{:command/%-0..2048s}", even when"-ww" is specified. "procstat -e" doesn't. Sigh.

    Anyway, that's another issue, but in the process of checking this, I discovered that whilst libxo honours the maxlength for text, and html, it doesn't for XML, JSON, or CSV

    As an example, try running this, and replacing the libxo output format as appropriate:

    env -i $(jot 500 | awk '{print "testvar_"$0"=dummydummydummydummy"}') sh -c 'ps -wwe -p $$ --libxo xml'

    Is this intentional? I couldn't find anything in the docs mentioning this.

    Is this related to a kludgy fix for https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=246514 ?

    In my opinion, when or if or how fields should be truncated is a thorny issue, but whilst I find many implementations are messy, I still think it should be solely the responsibility of the calling program.

    I.E. I don't think libxo should ignore the max width for some formats and not others...

    Thoughts?

    Cheers, Jamie

    opened by Jamie-Landeg-Jones 3
  • xo/xo.c#L99: add missing UNUSED marker for all unused flags

    xo/xo.c#L99: add missing UNUSED marker for all unused flags

    int lflag UNUSED = 0;
    int hflag = 0, jflag = 0, tflag = 0,
    zflag = 0, qflag = 0,
    

    are all set but not used, however only lflag is marked as such. Compilers complain :(

    opened by pstef 2
  • check width of unicode characters

    check width of unicode characters

    [potential problem which I want to record]

    Perhaps a problem with unicode "variation selectors"?

    \u+e29c85 \u+e284b9 \u+efb88f

    should be:

    ✅ ℹ️

    but maybe the second isn't zero width?

    question 
    opened by philshafer 0
  • Add FreeBSD to TravisCI config

    Add FreeBSD to TravisCI config

    TravisCI supports FreeBSD nowadays. Let's see how well it works.

    This is an alterantive to #66 in case you don't want to sign up the repo with CirrusCI or maintain two CI configs.

    opened by jbeich 5
  • Fails to build with GCC on FreeBSD

    Fails to build with GCC on FreeBSD

    Affects at least FreeBSD 11.3-RELEASE, 12.1-RELEASE, 13.0-RELEASE.

    $ pkg install automake libtool gmake gcc9
    $ sh bin/setup.sh
    $ cd build
    $ export MAKE=gmake CC=gcc9
    $ ../configure --enable-warnings
    $ gmake
    [...]
    ../../libxo/xo_encoder.c: In function 'xo_encoder_discover':
    ../../libxo/xo_encoder.c:237:9: error: cast between incompatible function types from 'dlfunc_t' {aka 'void (*)(struct __dlfunc_arg)'} to 'int (*)(xo_encoder_init_args_t *)' {aka 'int (*)(struct xo_encoder_init_args_s *)'} [-Werror=cast-function-type]
      237 |  func = (xo_encoder_init_func_t) dlfunc(dlp, XO_ENCODER_INIT_NAME);
          |         ^
    
    opened by jbeich 2
Releases(1.6.0)
  • 1.6.0(Jun 3, 2021)

  • 1.5.1(May 28, 2021)

  • 1.5.0(May 26, 2021)

    • #77 add docs for xo_emit_field and friends
    • Fix a couple of typos in docs
    • Merge branch 'patch-1' of git://github.com/0mp/libxo into develop
    • The It macro should be used for list elements.
    • add comments to calls that are supposed to produce warnings
    • add documentation for csv encoder
    • add options docs to libxo(3)
    • apply "underscores" behavior to list and container open names; #80
    • change "top" to "top-level" for testing #80
    • fix issue where "xolint.rst" was both the doc and the list of errors, in a terribly incompatible way (read: I clobbered xolint.rst)
    • fix typo in xo.1 man page (from Tomohiro Hosaka) #70
    • new tests for "--libxo json,underscores" (#80)
    • update tests
    • use "\n" for format strings in man pages
    Source code(tar.gz)
    Source code(zip)
    libxo-1.5.0.tar.gz(686.53 KB)
  • 1.4.0(Jan 23, 2020)

    • Two changes to encoder options:

      • encoder options may use plus or colon, but only one

      • encoder names can be specified as "@name" This results in the syntax:

        df --libxo @csv:no-header:leafs=name.available-blocks /

    • If xo_set_program is called before xo_parse_args, honor the requested value

    • add xo_errorn* function; repair newline-adding-on-xo_error bug

    • test programs now use fixed name, since linux libtool prefixs "lt-"

    • Fix "horse butt" comment in source code

    • update test cases

    Source code(tar.gz)
    Source code(zip)
    libxo-1.4.0.tar.gz(683.00 KB)
  • 1.3.1(Nov 7, 2019)

  • 1.3.0(Nov 5, 2019)

  • 1.2.0(Nov 4, 2019)

  • 1.1.0(Oct 30, 2019)

    • follow freebsd's setlocale logic for non-freebsd platforms; use setlocale("") for freebsd
    • Add a "CSV" encoder
    • Docs: Add "simplified wc" comment
    • Add fixes from PVS-Studio
    • Docs: Fix intro; add note re:xo
    • Docs [conf.py] Instead of hardcoding the version number here, we read it from the project's configure script
    • add "options" op for encoders
    • add missing version initialization for cbor encoder
    • Docs: add new encoders docs
    • add out-of-order test for encoder (csv)
    • add test cases for CSV encoder
    • add top-link.html.in (becomes libxo.html)
    • better encoder failure error messages for encoder init failure
    • change encoder handler to use xo_xff_flags_t
    • expose xo_failure at part of API (really just for encoders)
    • Docs: fix "::"
    • Docs: fix RFC reference; add more words
    • Docs: fix index for API
    • fix quoting logic in csv encoder
    • Docs: fix LIBXO_OPTIONS reference
    • indent tables; document the new "xo --instance" option
    • Docs: move to RST/Sphinx based documentation
    • update test cases
    • Docs: add "-N -E" to sphinx
    • use ssize_t for buffer offsets
    • use xo_streq
    • xo: new "--instance" option
    Source code(tar.gz)
    Source code(zip)
    libxo-1.1.0.tar.gz(989.32 KB)
  • 1.0.4(Apr 24, 2019)

  • 1.0.3(Apr 9, 2019)

  • 1.0.2(Apr 3, 2019)

  • 1.0.1(Apr 2, 2019)

  • 1.0.0(Apr 2, 2019)

    • Add "continuation" flag, to allow multiple "xo" invocations in a single line of output (#58)
    • Add --top-wrap to make top-level JSON wrappers
    • Add --{open,close}-{list,instace} options
    • Add xo_xml_leader(), to detect use of some bogus XML tags. It's still bad form, but it's a little safer now
    • Avoid call to xo_write before xo_flush, since the latter calls the former
    • Check return code from xo_flush_h properly (<0) (FreeBSD Bug 236937)
    • For JSON output, avoid newline before a container's close brace (#62)
    • Merge branch 'text_only' of https://github.com/zvr/libxo into zvr-text_only
    • Use XO_USE_INT_RETURN_CODES, not USE_INT_RETURN_CODES
    • add docs for --continuation
    • add docs for --not-first
    • call xo_state_set_flags before values and close containers; add XOIF_MADE_OUTPUT flag to track state; make proper empty JSON objects in xo_finish
    • color_map code has to be #ifdef'd out, since the struct definition
    • correct xo_flush_func_t (doesn't use xo_ssize_t)
    • make depth change for --top-wrap only for JSON
    • fix to handle --top-wrap in "xo" by being more consistent with handling trailing newlines
    • fix to handle text-only version #64 (from zvr)
    • fix xo_buf_has_room for round up to the next XO_BUFSIZ, not just add XO_BUFSIZ to the size (FreeBSD Bug 236937)
    • update docs for new "xo" options
    • update functions to use xo_ssize_t
    • update test cases
    Source code(tar.gz)
    Source code(zip)
    libxo-1.0.0.tar.gz(974.30 KB)
  • 0.9.0(May 21, 2018)

  • 0.8.4(Aug 3, 2017)

    • avoid anchor width optimization when we have a custom formatter (https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=221130)
    • make "{[:/18}" do the right thing (also allows "{[:/%s}", wide ? 40 : 10)
    • Can't skip anchor formatting in non-display styles
    • add test case for {[:/18}
    • add upload-xohtml-files to 'make upload'
    Source code(tar.gz)
    Source code(zip)
    libxo-0.8.4.tar.gz(966.31 KB)
  • 0.8.3(Jun 15, 2017)

  • 0.8.2(Jun 14, 2017)

    This release is malformed; the configure.ac (with the new version number) was not committed as part of the "new-release" process.

    • xohtml: Add div.units as standard CSS text
    • Don't treat values as format strings; they are not
    • add "-p" to "mkdir -p build" in setup.sh
    • add test case for {U:%%} (from df.c)
    • detect end-of-string in '%' and '' escaping
    • make xo_simple_field, for common simple cases
    • xohtml: nuke "n" in "echo" commands
    • rename "format" to "fmt" for consistency; same for "str" to "value"
    • update test cases
    Source code(tar.gz)
    Source code(zip)
    libxo-0.8.2.tar.gz(964.72 KB)
  • 0.8.1(Jun 8, 2017)

  • 0.8.0(Jun 3, 2017)

    • 6 bytes utf-8 values are historical; limit them to 4
    • make xo_utf8_len_bits to avoid shifting to make it's values
    • man pages: Short options first
    • add "flags" parameter to encoder functions
    • add E saved test case output
    • add colors=xxx color mapping
    • add comments to utf8 functions (xo_utf8_emit_char()
    • add no-color argument to skip force of coloring
    • Makefile: add targets for sanitize*
    • add unit test case for {C:/}
    • address static analysis issue
    • man pages: fix ORs
    • fix UTF-8 message
    • fix option .man issues
    • tests: force colors for testing
    • init XOF_COLOR after parsing --libxo options
    • add color-force flag
    • docs: mangle the docs a bit
    • allow LIBXO_OPTIONS to only set limited flags
    • two fixes from -fsanitize=address: move buffer cleanup after last reference, and check max_fields before indirecting off pointer
    Source code(tar.gz)
    Source code(zip)
    libxo-0.8.0.tar.gz(964.09 KB)
  • 0.7.2(May 16, 2017)

  • 0.7.0(May 12, 2017)

    • Add --enable-int-return-codes for users that want the old API
    • Add xo_options.7
    • Can't start line with "--enable-warnings" or oxtradoc gets cornfuxed
    • Protect redef of HOST_NAME_MAX
    • Use attribute for linux PRINTFLIKE
    • add flush-line and flush
    • add verbose option info
    • fix "- " in docs
    • fix size_t/int issues (#55)
    Source code(tar.gz)
    Source code(zip)
    libxo-0.7.0.tar.gz(954.97 KB)
  • 0.6.5(Oct 22, 2016)

  • 0.6.4(Oct 19, 2016)

  • 0.6.3(Jun 29, 2016)

  • 0.6.2(May 28, 2016)

  • 0.6.1(Apr 15, 2016)

  • 0.6.0(Apr 15, 2016)

    • Add --with-retain-size to set the size (in bits) of the retain hash buckets
    • Add The Argument Modifier ({a:})
    • Add retain and no-retain to --libxo
    • autoconf: Add test for monitor.h
    • Document quote heuristic
    • go deep with nroff backslashes
    • Use "ULL" for 32 bit check
    • add xo_retain_clear and xo_retain_clear_all
    • docs: combine two 'handles' section; move command line argument section
    • handle GETTEXT when msgfmt isn't where it's supposed to be (FreeBSD)
    • make 'retain' a flag (XOEF_RETAIN) instead of a role; it's simpler, and doesn't feel as tacky. "{R:}" was painful to document, which means it's painful to use.
    • new xo_emit_f functions
    • nuke some unused UNUSEDs
    • test code: path must be static
    • update test cases
    Source code(tar.gz)
    Source code(zip)
    libxo-0.6.0.tar.gz(951.41 KB)
  • 0.5.0(Mar 16, 2016)

    • document "trim" modifier
    • add xo_emit_field functions
    • Add xo_set_file{,_h} functions
    • Fix LIBXO_* variables; add -L and -I as needed
    • add --disable-silent-rules and an explicit make; s/PACKAGE-NAME/PACKAGE_NAME/; add /download/ to 'url'
    • fix silliness where xo_flush_h emitted closing tag (html); make the caller (xo_message) do it
    • flush after transitions; fix flush call in xo_do_emit
    • mkdir the version-specific packaging dir
    • use "XO__" instead of LIBXO__
    Source code(tar.gz)
    Source code(zip)
    libxo-0.5.0.tar.gz(944.08 KB)
  • 0.4.7(Dec 30, 2015)

A Cobalt Strike Beacon Object File (BOF) project which uses direct system calls to enumerate processes for specific loaded modules or process handles.

FindObjects-BOF A Cobalt Strike Beacon Object File (BOF) project which uses direct system calls to enumerate processes for specific modules or process

Outflank B.V. 245 Nov 9, 2022
A Beacon Object File (BOF) for Cobalt Strike which uses direct system calls to enable WDigest credential caching.

WdToggle A Proof of Concept Cobalt Strike Beacon Object File which uses direct system calls to enable WDigest credential caching and circumvent Creden

Outflank B.V. 203 Nov 15, 2022
This library support run-time type casting faster than dynamic_cast ( similar to unreal engine's CastTo )

Fast Runtime Type Casting This library give you C++ Fast Runtime Type Casting faster than dynamic_cast ( similar to Unreal Engine's CastTo, IsChildOf

SungJinKang 7 Jun 11, 2022
VMPImportFixer is a tool aimed to resolve import calls in a VMProtect'd (3.x) binary.

VMPImportFixer VMPImportFixer is a tool aimed to resolve import calls in a VMProtect'd (3.x) binary. Information VMPImportFixer attempts to resolve al

null 251 Nov 11, 2022
Repair UTF-8 codes and problematic HTML in Eudora mailboxes

Eudora_fix_mbx: Repair UTF-8 character codes and problematic HTML in Eudora mailboxes

Len Shustek 5 Aug 8, 2022
Very fast Markdown parser and HTML generator implemented in WebAssembly, based on md4c

Very fast Markdown parser and HTML generator implemented in WebAssembly, based on md4c

Rasmus 1.2k Nov 25, 2022
Tau is a fast syntax highlighter capable of emitting HTML.

tau - a reasonably fast (wip) syntax highlighter. Tau is a fast syntax highlighter capable of emitting HTML. It highlights the following languages: py

Palaiologos 12 Nov 16, 2022
A compile-time enabled Modern C++ library that provides compile-time dimensional analysis and unit/quantity manipulation.

mp-units - A Units Library for C++ The mp-units library is the subject of ISO standardization for C++23/26. More on this can be found in ISO C++ paper

Mateusz Pusz 657 Nov 11, 2022
Utilities and common code for use with raylib

Utilities and shared components for use with raylib

Jeffery Myers 85 Nov 18, 2022
Isaac ROS common utilities and scripts for use in conjunction with the Isaac ROS suite of packages.

Isaac ROS Common Isaac ROS common utilities and scripts for use in conjunction with the Isaac ROS suite of packages. Docker Scripts run_dev.sh creates

NVIDIA Isaac ROS 58 Nov 16, 2022
An easy-to-use C library for displaying text progress bars.

What is this thing? progressbar is a C-class (it's a convention, dammit) for displaying attractive progress bars on the command line. It's heavily inf

Trevor Fountain 439 Nov 9, 2022
Library for writing text-based user interfaces

IMPORTANT This library is no longer maintained. It's pretty small if you have a big project that relies on it, just maintain it yourself. Or look for

null 1.9k Nov 23, 2022
Rich text library supporting customizable Markdown formatting

Rich text library supporting customizable Markdown formatting

Brace Yourself Games 96 Nov 20, 2022
Sqrt OS is a simulation of an OS scheduler and memory manager using different scheduling algorithms including Highest Priority First (non-preemptive), Shortest Remaining Time Next, and Round Robin.

A CPU scheduler determines an order for the execution of its scheduled processes; it decides which process will run according to a certain data structure that keeps track of the processes in the system and their status. A process, upon creation, has one of the three states: Running, Ready, Blocked (doing I/O, using other resources than CPU or waiting on unavailable resource).

Abdallah Hemdan 18 Apr 15, 2022
A docker image where you can run a judge program and a converter for multiple sequence alignment

genocon2021-docker 本リポジトリでは、ジャッジプログラム(eval.c)と Multiple Sequence Alignment (MSA) 変換プログラム(decode_cigar.py)を同梱した Docker イメージを提供しています。 また、サンプル解答プログラム(sam

Sakamoto, Kazunori 4 Sep 20, 2021
A c++ file just to show how can we change color of Background and Text in C++...

A c++ file just to show how can we change color of Background and Text in C++...

null 1 Nov 2, 2021
Run GTA:SA multiple times

Multi Process GTASA With this ASI mod you are able to run GTASA multiple times If you also wish to have windowed mode ability, you can use https://git

iAmir 13 Nov 8, 2021
Modify Android linker to provide loading module and hook function

fake-linker Chinese document click here Project description Modify Android linker to provide loading module and plt hook features.Please check the det

sanfengAndroid 212 Nov 14, 2022