tagmanager/src/tm_tag.h

   1 /*
   2 *
   3 *   Copyright (c) 2001-2002, Biswapesh Chattopadhyay
   4 *
   5 *   This source code is released for free distribution under the terms of the
   6 *   GNU General Public License.
   7 *
   8 */
   9
  10 #ifndef TM_TAG_H
  11 #define TM_TAG_H
  12
  13 /* @file
  14  The TMTag structure and the associated functions are used to manipulate
  15  tags and arrays of tags. Normally, you should not create tags individually
  16  but through an external interface such as tm_source_file_parse(), which generates
  17  an array of tags for the given source file. Once the tag list is generated,
  18  you can do various operations such as:
  19         -# Extract relevant tags using tm_tags_extract()
  20         -# Sort an array of tags using tm_tags_sort()
  21         -# Deduplicate an array of tags using tm_tags_dedup().
  22
  23  An important thing to remember here is that the tags operations such as extraction,
  24  sorting and deduplication do not change the tag itself in any way, but rather,
  25  manipulate pointers to the tags structure. The tags themselves are owned by the
  26  TMSourceFile structure which created them during parsing. So, be careful, for example,
  27  while deduping the tags array of a source file directly, since this might lead to
  28  'dangling' tags whose pointers have been removed from the array. If you need to
  29  deduplicate, create a copy of the tag pointer array using tm_tags_extract().
  30 */
  31
  32 #include "tm_source_file.h"
  33 #include <glib-object.h>
  34
  35 G_BEGIN_DECLS
  36
  37 /** Use the TM_TAG() macro to cast a pointer to (TMTag *) */
  38 #define TM_TAG(tag) ((TMTag *) tag)
  39
  40 /**
  41  Types of tags. It is a bitmask so that multiple tag types can
  42  be used simultaneously by 'OR'-ing them bitwise.
  43  e.g. tm_tag_class_t | tm_tag_struct_t
  44 */
  45 typedef enum
  46 {
  47         tm_tag_undef_t = 0, /**< Unknown type */
  48         tm_tag_class_t = 1, /**< Class declaration */
  49         tm_tag_enum_t = 2, /**< Enum declaration */
  50         tm_tag_enumerator_t = 4, /**< Enumerator value */
  51         tm_tag_field_t = 8, /**< Field (Java only) */
  52         tm_tag_function_t = 16, /**< Function definition */
  53         tm_tag_interface_t = 32, /**< Interface (Java only) */
  54         tm_tag_member_t = 64, /**< Member variable of class/struct */
  55         tm_tag_method_t = 128, /**< Class method (Java only) */
  56         tm_tag_namespace_t = 256, /**< Namespace declaration */
  57         tm_tag_package_t = 512, /**< Package (Java only) */
  58         tm_tag_prototype_t = 1024, /**< Function prototype */
  59         tm_tag_struct_t = 2048, /**< Struct declaration */
  60         tm_tag_typedef_t = 4096, /**< Typedef */
  61         tm_tag_union_t = 8192, /**< Union */
  62         tm_tag_variable_t = 16384, /**< Variable */
  63         tm_tag_externvar_t = 32768, /**< Extern or forward declaration */
  64         tm_tag_macro_t = 65536, /**<  Macro (without arguments) */
  65         tm_tag_macro_with_arg_t = 131072, /**< Parameterized macro */
  66         tm_tag_file_t = 262144, /**< File (Pseudo tag) - obsolete */
  67         tm_tag_other_t = 524288, /**< Other (non C/C++/Java tag) */
  68         tm_tag_max_t = 1048575 /**< Maximum value of TMTagType */
  69 } TMTagType;
  70
  71 /**
  72  Tag Attributes. Note that some attributes are available to file
  73  pseudotags only. Attributes are useful for specifying as arguments
  74  to the builtin sort and dedup functions, and during printing or writing
  75  to file, since these functions can operate on the given set of attributes
  76  only. Tag attributes are bitmasks and can be 'OR'-ed bitwise to represent
  77  any combination (line TMTagType).
  78 */
  79 typedef enum
  80 {
  81         tm_tag_attr_none_t = 0, /**< Undefined */
  82         tm_tag_attr_name_t = 1, /**< Tag Name */
  83         tm_tag_attr_type_t = 2, /**< Tag Type */
  84         tm_tag_attr_file_t = 4, /**< File in which tag exists */
  85         tm_tag_attr_line_t = 8, /**< Line number of tag */
  86         tm_tag_attr_pos_t = 16, /**< Byte position of tag in the file (Obsolete) */
  87         tm_tag_attr_scope_t = 32, /**< Scope of the tag */
  88         tm_tag_attr_inheritance_t = 64, /**< Parent classes */
  89         tm_tag_attr_arglist_t = 128, /**< Argument list */
  90         tm_tag_attr_local_t = 256, /**< If it has local scope */
  91         tm_tag_attr_time_t = 512, /**< Modification time (File tag only) */
  92         tm_tag_attr_vartype_t = 1024, /**< Variable Type */
  93         tm_tag_attr_access_t = 2048, /**< Access type (public/protected/private) */
  94         tm_tag_attr_impl_t = 4096, /**< Implementation (e.g. virtual) */
  95         tm_tag_attr_lang_t = 8192, /**< Language (File tag only) */
  96         tm_tag_attr_inactive_t = 16384, /**< Inactive file (File tag only, obsolete) */
  97         tm_tag_attr_pointer_t = 32768, /**< Pointer type */
  98         tm_tag_attr_max_t = 65535 /**< Maximum value */
  99 } TMTagAttrType;
 100
 101 /** Tag access type for C++/Java member functions and variables */
 102 #define TAG_ACCESS_PUBLIC 'p' /**< Public member */
 103 #define TAG_ACCESS_PROTECTED 'r' /**< Protected member */
 104 #define TAG_ACCESS_PRIVATE 'v' /**< Private member */
 105 #define TAG_ACCESS_FRIEND 'f' /**< Friend members/functions */
 106 #define TAG_ACCESS_DEFAULT 'd' /**< Default access (Java) */
 107 #define TAG_ACCESS_UNKNOWN 'x' /**< Unknown access type */
 108
 109 /** Tag implementation type for functions */
 110 #define TAG_IMPL_VIRTUAL 'v' /**< Virtual implementation */
 111 #define TAG_IMPL_UNKNOWN 'x' /**< Unknown implementation */
 112
 113 typedef struct _TMTag
 114 {
 115         char *name; /**< Name of tag */
 116         TMTagType type; /**< Tag Type */
 117         gint refcount; /* the reference count of the tag */
 118
 119         /** These are tag attributes */
 120         TMSourceFile *file; /**< File in which the tag occurs; NULL for global tags */
 121         gulong line; /**< Line number of the tag */
 122         gboolean local; /**< Is the tag of local scope */
 123         guint pointerOrder;
 124         char *arglist; /**< Argument list (functions/prototypes/macros) */
 125         char *scope; /**< Scope of tag */
 126         char *inheritance; /**< Parent classes */
 127         char *var_type; /**< Variable type (maps to struct for typedefs) */
 128         char access; /**< Access type (public/protected/private/etc.) */
 129         char impl; /**< Implementation (e.g. virtual) */
 130         TMParserType lang; /* Programming language of the file */
 131 } TMTag;
 132
 133
 134 #ifdef GEANY_PRIVATE
 135
 136 /* The GType for a TMTag */
 137 #define TM_TYPE_TAG (tm_tag_get_type())
 138
 139 GType tm_tag_get_type(void) G_GNUC_CONST;
 140
 141 TMTag *tm_tag_new(void);
 142
 143 void tm_tags_remove_file_tags(TMSourceFile *source_file, GPtrArray *tags_array);
 144
 145 GPtrArray *tm_tags_merge(GPtrArray *big_array, GPtrArray *small_array,
 146         TMTagAttrType *sort_attributes, gboolean unref_duplicates);
 147
 148 gboolean tm_tags_sort(GPtrArray *tags_array, TMTagAttrType *sort_attributes,
 149         gboolean dedup, gboolean unref_duplicates);
 150
 151 GPtrArray *tm_tags_extract(GPtrArray *tags_array, guint tag_types);
 152
 153 gboolean tm_tags_prune(GPtrArray *tags_array);
 154
 155 gboolean tm_tags_dedup(GPtrArray *tags_array, TMTagAttrType *sort_attributes, gboolean unref_duplicates);
 156
 157 TMTag **tm_tags_find(const GPtrArray *tags_array, const char *name,
 158                 gboolean partial, guint * tagCount);
 159
 160 void tm_tags_array_free(GPtrArray *tags_array, gboolean free_all);
 161
 162 const TMTag *tm_get_current_tag(GPtrArray *file_tags, const gulong line, const TMTagType tag_types);
 163
 164 void tm_tag_unref(TMTag *tag);
 165
 166 TMTag *tm_tag_ref(TMTag *tag);
 167
 168 gboolean tm_tags_equal(const TMTag *a, const TMTag *b);
 169
 170 const gchar *tm_tag_context_separator(TMParserType lang);
 171
 172 gboolean tm_tag_is_anon(const TMTag *tag);
 173
 174 gboolean tm_tag_langs_compatible(TMParserType lang, TMParserType other);
 175
 176 #ifdef TM_DEBUG /* various debugging functions */
 177
 178 const char *tm_tag_type_name(const TMTag *tag);
 179
 180 TMTagType tm_tag_name_type(const char* tag_name);
 181
 182 void tm_tag_print(TMTag *tag, FILE *fp);
 183
 184 void tm_tags_array_print(GPtrArray *tags, FILE *fp);
 185
 186 gint tm_tag_scope_depth(const TMTag *t);
 187
 188 #endif /* TM_DEBUG */
 189
 190 #endif /* GEANY_PRIVATE */
 191
 192 G_END_DECLS
 193
 194 #endif /* TM_TAG_H */