1. 26 Oct, 2018 1 commit
    • parse: Do not initialize the content in context to NULL · e1295400
      String operations in libgit2 are supposed to never receive `NULL`, e.g.
      they are not `NULL`-save. In the case of `git__linenlen()`, invocation
      with `NULL` leads to undefined behavior.
      
      In a `git_parse_ctx` however, the `content` field used in these
      operations was initialized to `NULL` if the `git_parse_ctx_init()` was
      called with `NULL` for `content` or `0` for `content_len`. For the
      latter case, the initialization function even contained some logic for
      initializing `content` with `NULL`.
      
      This commit mitigates triggering undefined behavior by rewriting the
      logic. Now `content` is always initialized to a non-null buffer. Instead
      of a null buffer, an empty string is used for denoting an empty buffer.
      
      (cherry picked from commit d1bfe614)
      Julian Ganz committed
  2. 11 Nov, 2017 4 commits
    • parse: always initialize line pointer · 7bdfc0a6
      Upon initializing the parser context, we do not currently initialize the
      current line, line length and line number. Do so in order to make the
      interface easier to use and more obvious for future consumers of the
      parsing API.
      Patrick Steinhardt committed
    • parse: implement `git_parse_peek` · e72cb769
      Some code parts need to inspect the next few bytes without actually
      consuming it yet, for example to examine what content it has to expect
      next. Create a new function `git_parse_peek` which returns the next byte
      without modifying the parsing context and use it at multiple call sites.
      Patrick Steinhardt committed
    • parse: implement and use `git_parse_advance_digit` · 252f2eee
      The patch parsing code has multiple recurring patterns where we want to
      parse an actual number. Create a new function `git_parse_advance_digit`
      and use it to avoid code duplication.
      Patrick Steinhardt committed
    • parse: extract parse module · ef1395f3
      The `git_patch_parse_ctx` encapsulates both parser state as well as
      options specific to patch parsing. To advance this state and keep it
      consistent, we provide a few functions which handle advancing the
      current position and accessing bytes of the patch contents. In fact,
      these functions are quite generic and not related to patch-parsing by
      themselves. Seeing that we have similar logic inside of other modules,
      it becomes quite enticing to extract this functionality into its own
      parser module.
      
      To do so, we create a new module `parse` with a central struct called
      `git_parse_ctx`. It encapsulates both the content that is to be parsed
      as well as its lengths and the current position. `git_patch_parse_ctx`
      now only contains this `parse_ctx` only, which is then accessed whenever
      we need to touch the current parser. This is the first step towards
      re-using this functionality across other modules which require parsing
      functionality and remove code-duplication.
      Patrick Steinhardt committed