← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/monodevelop/oneiric-updates

« back to all changes in this revision

Viewing changes to src/addins/CBinding/Parser/Function.cs

  • Committer: Bazaar Package Importer
  • Author(s): Jo Shields
  • Date: 2009-02-18 08:40:51 UTC
  • mfrom: (1.2.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20090218084051-gh8m6ukvokbwj7cf
Tags: 1.9.2+dfsg-1ubuntu1
https://launchpad.net/bugs/330519
* Merge from Debian Experimental (LP: #330519), remaining Ubuntu changes:
  + debian/control:
    - Update for Gnome# 2.24
    - Add libmono-cairo1.0-cil to build-deps to fool pkg-config check

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/addins/CBinding/Parser/Function.cs
46
46
                        signature = tag.Signature;
47
47
                        ParseSignature (tag.Signature);
48
48
                        
49
 
                        if (tag.Kind == TagKind.Prototype) {
50
 
                                Access = tag.Access;
51
 
                                if (GetNamespace (tag, ctags_output)) return;
52
 
                                if (GetClass (tag, ctags_output)) return;
53
 
                                if (GetStructure (tag, ctags_output)) return;
54
 
                                if (GetUnion (tag, ctags_output)) return;
55
 
                        } else {
56
 
                                // If it is not a prototype tag, we attempt to get the prototype tag
57
 
                                // we need the prototype tag because the implementation tag
58
 
                                // marks the belonging namespace as a if it were a class
59
 
                                // and it does not have the access field.
60
 
                                Tag prototypeTag = TagDatabaseManager.Instance.FindTag (Name, TagKind.Prototype, ctags_output);
61
 
                                
62
 
                                if (prototypeTag == null) {
63
 
                                        // It does not have a prototype tag which means it is inline
64
 
                                        // and when it is inline it does have all the info we need
65
 
                                        
66
 
                                        if (GetNamespace (tag, ctags_output)) return;
67
 
                                        if (GetClass (tag, ctags_output)) return;
68
 
                                        if (GetStructure (tag, ctags_output)) return;
69
 
                                        if (GetUnion (tag, ctags_output)) return;
70
 
                                        
71
 
                                        return;
72
 
                                }
73
 
                                
74
 
                                // we need to re-get the access
75
 
                                Access = prototypeTag.Access;
76
 
                                
77
 
                                if (GetNamespace (prototypeTag, ctags_output)) return;
78
 
                                if (GetClass (prototypeTag, ctags_output)) return;
79
 
                                if (GetStructure (prototypeTag, ctags_output)) return;
80
 
                                if (GetUnion (prototypeTag, ctags_output)) return;
81
 
                        }
 
49
                        if (GetNamespace (tag, ctags_output)) return;
 
50
                        if (GetClass (tag, ctags_output)) return;
 
51
                        if (GetStructure (tag, ctags_output)) return;
 
52
                        if (GetUnion (tag, ctags_output)) return;
 
53
 
 
54
                        // TODO: Remove all this when sure it is no longer needed
 
55
                        // (because we no longer generate prototype tags).
 
56
//                      if (tag.Kind == TagKind.Prototype) {
 
57
//                              Access = tag.Access;
 
58
//                              if (GetNamespace (tag, ctags_output)) return;
 
59
//                              if (GetClass (tag, ctags_output)) return;
 
60
//                              if (GetStructure (tag, ctags_output)) return;
 
61
//                              if (GetUnion (tag, ctags_output)) return;
 
62
//                      } else {
 
63
//                              // If it is not a prototype tag, we attempt to get the prototype tag
 
64
//                              // we need the prototype tag because the implementation tag
 
65
//                              // marks the belonging namespace as a if it were a class
 
66
//                              // and it does not have the access field.
 
67
//                              Tag prototypeTag = TagDatabaseManager.Instance.FindTag (Name, TagKind.Prototype, ctags_output);
 
68
//                              
 
69
//                              if (prototypeTag == null) {
 
70
//                                      // It does not have a prototype tag which means it is inline
 
71
//                                      // and when it is inline it does have all the info we need
 
72
//                                      
 
73
//                                      if (GetNamespace (tag, ctags_output)) return;
 
74
//                                      if (GetClass (tag, ctags_output)) return;
 
75
//                                      if (GetStructure (tag, ctags_output)) return;
 
76
//                                      if (GetUnion (tag, ctags_output)) return;
 
77
//                                      
 
78
//                                      return;
 
79
//                              }
 
80
//                              
 
81
//                              // we need to re-get the access
 
82
//                              Access = prototypeTag.Access;
 
83
//                              
 
84
//                              if (GetNamespace (prototypeTag, ctags_output)) return;
 
85
//                              if (GetClass (prototypeTag, ctags_output)) return;
 
86
//                              if (GetStructure (prototypeTag, ctags_output)) return;
 
87
//                              if (GetUnion (prototypeTag, ctags_output)) return;
 
88
//                      }
82
89
                }
83
90
                
84
91
                private void ParseSignature (string signature)