update to ida 7.6, add builds

idasdk76/include/ida_highlighter.hpp

@@ -0,0 +1,146 @@
+#ifndef IDA_HIGHLIGHTER
+#define IDA_HIGHLIGHTER
+
+#include <expr.hpp>
+
+idaman void ida_export code_highlight_block(void *context, highlighter_cbs_t *highlighter_cbs, const qstring &text);
+
+// returns the length of text to colorize
+// negative values may have special meaning in the future.
+typedef ssize_t idaapi external_colorizer_t(syntax_highlight_style *color, const char *str);
+typedef qvector<external_colorizer_t *> external_colorizers_t;
+
+// returns true if identifier is colorized
+typedef bool idaapi external_ident_colorizer_t(syntax_highlight_style *color, const qstring &ident);
+typedef qvector<external_ident_colorizer_t *> external_ident_colorizers_t;
+
+
+#define MLTCMTMASK    0xF
+#define PREPROC_FLAG  0x10
+
+// Common implementation of syntax_highlighter_t used in different parts of IDA
+//-V:ida_syntax_highlighter_t:730 not all members of a class are initialized inside the constructor
+struct ida_syntax_highlighter_t : syntax_highlighter_t
+{
+protected:
+  // keys of keywords_t point to memory from keyword_strings.
+  // once allocated, this buffer won't be moved in the memory.
+  qstrvec_t keyword_memory;
+  // helper class so that keywords_t gets sorted by string contents, not pointer values.
+  struct plain_char_ptr_t
+  {
+    const char *ptr;
+    plain_char_ptr_t(const char *p = NULL) : ptr(p) {}
+    bool operator <(const plain_char_ptr_t &r) const
+    {
+      return strcmp(ptr, r.ptr) < 0;
+    }
+    bool operator ==(const plain_char_ptr_t &r) const
+    {
+      return strcmp(ptr, r.ptr) == 0;
+    }
+  };
+  struct multicmt_t
+  {
+    qstring open_multicmt;
+    qstring close_multicmt;
+    multicmt_t() {}
+    multicmt_t(const char *_open_multicmt, const char *_close_multicmt) :
+      open_multicmt(_open_multicmt),
+      close_multicmt(_close_multicmt)
+    {}
+  };
+
+  // typedef std::map<plain_char_ptr_t, syntax_highlight_style> keywords_t;
+  struct keywords_style_t
+  {
+    qvector<plain_char_ptr_t> keywords;
+    syntax_highlight_style style;
+  };
+  typedef qvector<keywords_style_t> keywords_t;
+  //typedef qvector<plain_char_ptr_t> keywords_t;
+  typedef qvector<multicmt_t> multicmtvec_t;
+  keywords_t keywords;
+
+  qstring open_cmt;             // string that opens a regular line comment
+  multicmtvec_t multicmts;
+  char literal_closer;          // either close_strconst or close_chrconst for the current literal
+
+  // color mappings
+  syntax_highlight_style text_color = HF_DEFAULT;
+  syntax_highlight_style comment_color = HF_COMMENT;
+  syntax_highlight_style string_color = HF_STRING;
+  syntax_highlight_style preprocessor_color = HF_PREPROC;
+
+  external_colorizers_t external_colorizers;
+  external_ident_colorizers_t external_ident_colorizers;
+
+  // work variables
+  const char *input;                  // pointer to the start of the input buffer
+  const char *pending;                // pointer in the input buffer
+  syntax_highlight_style style = HF_DEFAULT; // current highlighting style
+
+  bool pending_nonspaces_present(const char *end)
+  {
+    for ( const char *p = pending; p != end; ++p )
+      if ( !qisspace(*p) )
+        return true;
+    return false;
+  }
+
+  const char *parse_literal_const(highlighter_cbs_t *highlighter_cbs, const char *ptr, char literal_closer);
+  void flush_output(highlighter_cbs_t *highlighter_cbs, const char *ptr, syntax_highlight_style style);
+  void handle_cmt(highlighter_cbs_t *highlighter_cbs, int mcmt_idx, const char **ptr);
+  void handle_preproc(highlighter_cbs_t *highlighter_cbs, const char **ptr);
+
+public:
+  // if any of the following features is not needed, just zero them out:
+  char open_strconst;           // character that opens a string constant
+  char close_strconst;          // character that closes a string constant
+  char open_chrconst;           // character that closes a character constant
+  char close_chrconst;          // character that opens a character constant
+  char escape_char;             // backslash
+  char preprocessor_char;       // #
+
+  ida_syntax_highlighter_t() : syntax_highlighter_t(&code_highlight_block) {}
+
+  void highlight_block_ex(highlighter_cbs_t *highlighter_cbs, const qstring &text);
+  void add_external_colorizer(external_colorizer_t *th) { external_colorizers.push_back(th); }
+  void add_external_ident_colorizer(external_ident_colorizer_t *th) { external_ident_colorizers.push_back(th); }
+  void set_open_cmt(const char *begin) { open_cmt = begin; }
+  void add_multi_line_comment(const char *begin, const char *end)
+  {
+    multicmt_t &mcmt = multicmts.push_back();
+    mcmt.open_multicmt = begin;
+    mcmt.close_multicmt = end;
+  }
+
+  void add_keywords(const char *kwstr, syntax_highlight_style _style)
+  {
+    char *ctx;
+    // in order not to allocate every keyword separately, we allocate the whole
+    // kwstr string at once and will just store pointers to it in the map.
+    qstring &mem = keyword_memory.push_back();
+    mem = kwstr;
+    keywords_style_t *pair_p = NULL;
+    for ( int i = 0; i < keywords.size(); i++ )
+    {
+      if ( keywords[i].style == _style )
+      {
+        pair_p = &keywords[i];
+        break;
+      }
+    }
+    if ( pair_p == NULL )
+    {
+      keywords_style_t &pair = keywords.push_back();
+      pair_p = &pair;
+      pair_p->style = _style;
+    }
+    for ( char *kw = qstrtok(mem.begin(), "|", &ctx); kw != NULL; kw = qstrtok(NULL, "|", &ctx) )
+      pair_p->keywords.push_back(kw);
+  }
+};
+
+
+#endif // IDA_HIGHLIGHTER