public Enumeration (Tag tag, Project project, string ctags_output) : base (tag, project)
{
if (GetNamespace (tag, ctags_output)) return;
if (GetClass (tag, ctags_output)) return;
if (GetStructure (tag, ctags_output)) return;
if (GetUnion (tag, ctags_output)) return;
}
/// <summary>
/// Attempts to get the namespace encompasing the function
/// returns true on success and false if it does not have one.
/// NOTE: if it's a method then even if the class it belongs to
/// has a namespace the method will not have a namespace since
/// it should be placed under the class node and not the namespace node
/// </summary>
protected bool GetNamespace (Tag tag, string ctags_output)
{
string n;
if ((n = tag.Namespace) != null) {
int index = n.LastIndexOf (':');
if (index > 0)
n = n.Substring (index + 1);
try {
Tag namespaceTag = TagDatabaseManager.Instance.FindTag (
n, TagKind.Namespace, ctags_output);
if (namespaceTag != null)
parent = new Namespace (namespaceTag, project, ctags_output);
} catch (IOException ex) {
LoggingService.LogInternalError (ex);
return false;
}
return true;
}
return false;
}
public LanguageItem (Tag tag, Project project)
{
this.project = project;
this.name = tag.Name;
this.file = tag.File;
this.line = tag.Line;
this.access = tag.Access;
}
public LanguageItem (Tag tag, Project project)
{
this.project = project;
this.name = tag.Name;
this.file = tag.File;
this.pattern = tag.Pattern;
this.access = tag.Access;
}
public Member (Tag tag, Project project, string ctags_output) : base (tag, project)
{
GetInstanceType (tag);
if (GetClass (tag, ctags_output)) return;
if (GetStructure (tag, ctags_output)) return;
if (GetUnion (tag, ctags_output)) return;
}
public Function(Tag tag, Project project, string ctags_output)
: base(tag, project)
{
signature = tag.Signature;
ParseSignature (tag.Signature);
if (GetNamespace (tag, ctags_output)) return;
if (GetClass (tag, ctags_output)) return;
if (GetStructure (tag, ctags_output)) return;
if (GetUnion (tag, ctags_output)) return;
// TODO: Remove all this when sure it is no longer needed
// (because we no longer generate prototype tags).
// if (tag.Kind == TagKind.Prototype) {
// Access = tag.Access;
// if (GetNamespace (tag, ctags_output)) return;
// if (GetClass (tag, ctags_output)) return;
// if (GetStructure (tag, ctags_output)) return;
// if (GetUnion (tag, ctags_output)) return;
// } else {
// // If it is not a prototype tag, we attempt to get the prototype tag
// // we need the prototype tag because the implementation tag
// // marks the belonging namespace as a if it were a class
// // and it does not have the access field.
// Tag prototypeTag = TagDatabaseManager.Instance.FindTag (Name, TagKind.Prototype, ctags_output);
//
// if (prototypeTag == null) {
// // It does not have a prototype tag which means it is inline
// // and when it is inline it does have all the info we need
//
// if (GetNamespace (tag, ctags_output)) return;
// if (GetClass (tag, ctags_output)) return;
// if (GetStructure (tag, ctags_output)) return;
// if (GetUnion (tag, ctags_output)) return;
//
// return;
// }
//
// // we need to re-get the access
// Access = prototypeTag.Access;
//
// if (GetNamespace (prototypeTag, ctags_output)) return;
// if (GetClass (prototypeTag, ctags_output)) return;
// if (GetStructure (prototypeTag, ctags_output)) return;
// if (GetUnion (prototypeTag, ctags_output)) return;
// }
}
/// <summary>
/// Populates an instance's instanceType and isPointer fields
/// by matching its pattern against InstanceTypeExpression
/// </summary>
/// <param name="tag">
/// The partially-populated tag of an instance
/// <see cref="Tag"/>
/// </param>
/// <returns>
/// Whether the regex was successfully matched
/// <see cref="System.Boolean"/>
/// </returns>
protected bool GetInstanceType (Tag tag) {
try {
string declaration = null;
using (StreamReader reader = new StreamReader (tag.File)) {
for (ulong i=0; i<tag.Line; ++i) {
declaration = reader.ReadLine ();
}
}
Match m = InstanceTypeExpression.Match (declaration);
if (null != m) {
instanceType = m.Groups["type"].Value;
isPointer = m.Groups["pointer"].Success;
return true;
}
} catch { }
return false;
}
public Enumerator (Tag tag, Project project, string ctags_output) : base (tag, project)
{
GetEnumeration (tag, ctags_output);
}
protected bool GetClass (Tag tag, string ctags_output)
{
string c;
if ((c = tag.Class) != null) {
int index = c.LastIndexOf (':');
if (index > 0)
c = c.Substring (index + 1);
try {
Tag classTag = TagDatabaseManager.Instance.FindTag (
c, TagKind.Class, ctags_output);
if (classTag != null)
parent = new Class (classTag, project, ctags_output);
} catch (IOException ex) {
LoggingService.LogInternalError (ex);
return false;
}
return true;
}
return false;
}
protected bool GetUnion (Tag tag, string ctags_output)
{
string u;
if ((u = tag.Union) != null) {
int index = u.LastIndexOf (':');
if (index > 0)
u = u.Substring (index + 1);
try {
Tag unionTag = TagDatabaseManager.Instance.FindTag (
u, TagKind.Union, ctags_output);
if (unionTag != null)
parent = new Union (unionTag, project, ctags_output);
} catch (IOException ex) {
LoggingService.LogInternalError (ex);
return false;
}
return true;
}
return false;
}
Tag BinarySearch(string[] ctags_lines, TagKind kind, string name)
{
int low;
int high = ctags_lines.Length - 2; // last element is an empty string (because of the Split)
int mid;
int start_index = 0;
// Skip initial comment lines
while (ctags_lines[start_index].StartsWith("!_"))
{
start_index++;
}
low = start_index;
while (low <= high)
{
mid = (low + high) / 2;
string entry = ctags_lines[mid];
string tag_name = entry.Substring(0, entry.IndexOf('\t'));
int res = string.CompareOrdinal(tag_name, name);
if (res < 0)
{
low = mid + 1;
}
else if (res > 0)
{
high = mid - 1;
}
else
{
// The tag we are at has the same name than the one we are looking for
// but not necessarily the same type, the actual tag we are looking
// for might be higher up or down, so we try both, starting with going down.
int save = mid;
bool going_down = true;
bool eof = false;
while (true)
{
Tag tag = ctags.ParseTag(entry);
if (tag == null)
{
return(null);
}
if (tag.Kind == kind && tag_name == name)
{
return(tag);
}
if (going_down)
{
mid++;
if (mid >= ctags_lines.Length - 1)
{
eof = true;
}
if (!eof)
{
entry = ctags_lines[mid];
tag_name = entry.Substring(0, entry.IndexOf('\t'));
if (tag_name != name)
{
going_down = false;
mid = save - 1;
}
}
else
{
going_down = false;
mid = save - 1;
}
}
else // going up
{
mid--;
if (mid < start_index)
{
return(null);
}
entry = ctags_lines[mid];
tag_name = entry.Substring(0, entry.IndexOf('\t'));
if (tag_name != name)
{
return(null);
}
}
}
}
}
return(null);
}
protected bool GetStructure (Tag tag, string ctags_output)
{
string s;
if ((s = tag.Structure) != null) {
int index = s.LastIndexOf (':');
if (index > 0)
s = s.Substring (index + 1);
try {
Tag classTag = TagDatabaseManager.Instance.FindTag (
s, TagKind.Structure, ctags_output);
if (classTag != null)
parent = new Structure (classTag, project, ctags_output);
} catch (IOException ex) {
LoggingService.LogInternalError (ex);
return false;
}
return true;
}
return false;
}
private void AddInfo (FileInformation info, Tag tag, string ctags_output)
{
switch (tag.Kind)
{
case TagKind.Class:
Class c = new Class (tag, info.Project, ctags_output);
if (!info.Classes.Contains (c))
info.Classes.Add (c);
break;
case TagKind.Enumeration:
Enumeration e = new Enumeration (tag, info.Project, ctags_output);
if (!info.Enumerations.Contains (e))
info.Enumerations.Add (e);
break;
case TagKind.Enumerator:
Enumerator en= new Enumerator (tag, info.Project, ctags_output);
if (!info.Enumerators.Contains (en))
info.Enumerators.Add (en);
break;
case TagKind.ExternalVariable:
break;
case TagKind.Function:
Function f = new Function (tag, info.Project, ctags_output);
if (!info.Functions.Contains (f))
info.Functions.Add (f);
break;
case TagKind.Local:
Local lo = new Local (tag, info.Project, ctags_output);
if(!info.Locals.Contains (lo))
info.Locals.Add (lo);
break;
case TagKind.Macro:
Macro m = new Macro (tag, info.Project);
if (!info.Macros.Contains (m))
info.Macros.Add (m);
break;
case TagKind.Member:
Member me = new Member (tag, info.Project, ctags_output);
if (!info.Members.Contains (me))
info.Members.Add (me);
break;
case TagKind.Namespace:
Namespace n = new Namespace (tag, info.Project, ctags_output);
if (!info.Namespaces.Contains (n))
info.Namespaces.Add (n);
break;
case TagKind.Prototype:
Function fu = new Function (tag, info.Project, ctags_output);
if (!info.Functions.Contains (fu))
info.Functions.Add (fu);
break;
case TagKind.Structure:
Structure s = new Structure (tag, info.Project, ctags_output);
if (!info.Structures.Contains (s))
info.Structures.Add (s);
break;
case TagKind.Typedef:
Typedef t = new Typedef (tag, info.Project, ctags_output);
if (!info.Typedefs.Contains (t))
info.Typedefs.Add (t);
break;
case TagKind.Union:
Union u = new Union (tag, info.Project, ctags_output);
if (!info.Unions.Contains (u))
info.Unions.Add (u);
break;
case TagKind.Variable:
Variable v = new Variable (tag, info.Project);
if (!info.Variables.Contains (v))
info.Variables.Add (v);
break;
default:
break;
}
}
public Local (Tag tag, Project project, string ctags_output) : base (tag, project, ctags_output)
{
}
public Macro (Tag tag, Project project) : base (tag, project)
{
}
protected bool GetEnumeration (Tag tag, string ctags_output)
{
string e;
if ((e = tag.Enum) != null) {
int index = e.LastIndexOf (':');
if (index > 0)
e = e.Substring (index + 1);
try {
Tag enumTag = TagDatabaseManager.Instance.FindTag (
e, TagKind.Enumeration, ctags_output);
if (enumTag != null)
parent = new Enumeration (enumTag, project, ctags_output);
} catch (IOException ex) {
LoggingService.LogInternalError (ex);
return false;
}
return true;
}
return false;
}
public Namespace (Tag tag, Project project, string ctags_output) : base (tag, project)
{
GetNamespace (tag, ctags_output);
}
public Variable (Tag tag, Project project) : base (tag, project)
{
}
