ctags/main/promise.c

   1 /*
   2  *
   3  *  Copyright (c) 2016, Red Hat, Inc.
   4  *  Copyright (c) 2016, Masatake YAMATO
   5  *
   6  *  Author: Masatake YAMATO <yamato@redhat.com>
   7  *
   8  *   This source code is released for free distribution under the terms of the
   9  *   GNU General Public License version 2 or (at your option) any later version.
  10  *
  11  */
  12
  13 #include "general.h"
  14 #include "promise.h"
  15 #include "debug.h"
  16 #include "xtag.h"
  17
  18
  19 struct promise {
  20         langType lang;
  21         unsigned long startLine;
  22         int startCharOffset;
  23         unsigned long endLine;
  24         int endCharOffset;
  25         unsigned long sourceLineOffset;
  26 };
  27
  28 static struct promise *promises;
  29 static int promise_count;
  30 static int promise_allocated;
  31
  32 int  makePromise   (const char *parser,
  33                     unsigned long startLine, int startCharOffset,
  34                     unsigned long endLine, int endCharOffset,
  35                     unsigned long sourceLineOffset)
  36 {
  37         struct promise *p;
  38         int r;
  39         langType lang;
  40
  41 /* GEANY DIFF */
  42 /*
  43         if (!isXtagEnabled (XTAG_TAGS_GENERATED_BY_SUB_PARSERS))
  44                 return -1;
  45 */
  46 /* GEANY DIFF END */
  47
  48         lang = getNamedLanguage (parser, 0);
  49         if (lang == LANG_IGNORE)
  50                 return -1;
  51
  52         if ( promise_count == promise_allocated)
  53         {
  54                 size_t c = promise_allocated? (promise_allocated * 2): 8;
  55                 promises = xRealloc (promises, c, struct promise);
  56                 promise_allocated = c;
  57         }
  58
  59         p = promises + promise_count;
  60
  61         p->lang = lang;
  62         p->startLine = startLine;
  63         p->startCharOffset = startCharOffset;
  64         p->endLine = endLine;
  65         p->endCharOffset = endCharOffset;
  66         p->sourceLineOffset = sourceLineOffset;
  67
  68         r = promise_count;
  69         promise_count++;
  70         return r;
  71 }
  72
  73 void breakPromisesAfter (int promise)
  74 {
  75         Assert (promise_count >= promise);
  76
  77         promise_count = promise;
  78 }
  79
  80 bool forcePromises (void)
  81 {
  82         int i;
  83         bool tagFileResized = false;
  84
  85         for (i = 0; i < promise_count; ++i)
  86         {
  87                 struct promise *p = promises + i;
  88                 tagFileResized = runParserInNarrowedInputStream (p->lang,
  89                                                                  p->startLine,
  90                                                                  p->startCharOffset,
  91                                                                  p->endLine,
  92                                                                  p->endCharOffset,
  93                                                                  p->sourceLineOffset)
  94                         ? true
  95                         : tagFileResized;
  96         }
  97
  98         promise_count = 0;
  99         return tagFileResized;
 100 }
 101
 102
 103 int getLastPromise (void)
 104 {
 105         return promise_count - 1;
 106 }