root/test/manual/etags/cp-src/c.C

DEFINITIONS

1. execute
2. main
3. base
4. f
5. f
6. f
7. f
8. is_muldiv_operation
9. f
10. ff
11. g
12. AST_Decl
13. foo
14. b

     1 template <typename ipc3dIslandHierarchy, typename ipc3dChannelType, unsigned numOfChannels, typename ipc3dLinkControl, typename ipc3dLinkControlSetup>
     2 class CMultiChannelCSC19_3D
     3 {
     4 private:
     5         ipc3dLinkControlSetup setup;
     6         ipc3dCSC19<ipc3dIslandHierarchy,ipcMultiChannel<ipc3dChannelType,numOfChannels>,ipcMultiChannel<ipc3dChannelType,numOfChannels>,ipc3dLinkControl> mcCSC;
     7         advTimer cscInitTime;
     8         advTimer cscSegmentationTime;
     9         advTimer outputTime;
    10 public:
    11         void execute(CPluginCSCState& p, int w, int h, int d, const ipcMultiChannel<ipc3dChannelType,numOfChannels>* orgImage, ipcMultiChannel<ipc3dChannelType,numOfChannels>* regionImage, unsigned int* mapImage, ipc3dBlockCompressedLabelImage* compressedMapImage=NULL)
    12         {
    13                 if (orgImage!=NULL)
    14                 {
    15                                   //do something
    16                 }
    17         }
    18 
    19 class foo {
    20   int const_func() const;
    21   int b;
    22   int non_const_func2(void);
    23 };
    24 static void my_function1(int var1) const;
    25 int main (void) { my_function0(0); my_function1(1); return; }
    26 double base (void) const { return rng_base;  }
    27 
    28 template <typename T> MDiagArray2<T>&
    29 operator += (MDiagArray2<T>& a, const MDiagArray2<T>& b);
    30 
    31 class TestRecord;
    32 typedef struct s1 {
    33    int counter;
    34 } t1;
    35 struct s2 {
    36    int counter;
    37 };
    38 typedef struct s2 t2;
    39 class A {
    40   enum { rosso, giallo, verde } colori;
    41   const A& operator+(const A&);
    42 };
    43 const A& A::operator+(const A&) { }
    44 void operator+(int, int) {}
    45 void operator -(int, int) {}
    46 void operator int(int, int) {}
    47 
    48 A<int>* f() {}
    49 int f(A<int> x) {}
    50 int A<int>::f(A<int>* x) {}
    51 A<float,B<int> > A<B<float>,int>::f(A<int>* x) {}
    52 template <class C, int n> class AT { C t[n]; };
    53 class AU { T x; };
    54 class B<int> { void f() {} };
    55 const A::B::T& abt = abc;
    56 class A { class B { int f(); }; };
    57 class A {
    58   int get_data() const;
    59   A operator+(A& a) {};
    60 };
    61 is_muldiv_operation(pc)
    62 {
    63 }
    64 #ifdef __cplusplus
    65 extern "C" {
    66 #endif
    67 
    68 domain foo {
    69      void f() {}
    70 };
    71 
    72 void A::A() {}
    73 struct A { A(); }
    74 struct B { B(); };
    75 void B::B() {}
    76 void BE_Node::BE_Node() {}
    77 class BE_Node {};
    78 
    79 struct foo {
    80   int x;
    81 };
    82 
    83 #ifdef __cplusplus
    84 }
    85 #endif
    86 class test {
    87   int f(){return 0;};           // first comment
    88                                 // second comment
    89   int ff(){return 1;};
    90   int g(){return 2;};
    91 }
    92 class   AST_Root : public virtual AST_Module
    93 {
    94 };
    95 
    96 class   AST_Root;                       // The root of an AST 112,3888
    97 // etags finds
    98 
    99 AST_ConcreteType::AST_ConcreteType(AST_Decl::NodeType nt, UTL_ScopedName *n,
   100                                      UTL_StrList *p)
   101                  : AST_Decl(nt, n, p)
   102 {
   103 }
   104 
   105 // and
   106 
   107 AST_Array::AST_Array(UTL_ScopedName *n, unsigned long nd, UTL_ExprList *ds)
   108          : pd_n_dims(nd), pd_base_type(NULL),
   109            AST_Decl(AST_Decl::NT_array, n, NULL)
   110 {
   111 }
   112 
   113 // as definitions of AST_Decl.
   114 class {
   115      void f() {}
   116 };
   117 struct A {
   118     ~A();
   119 };
   120 A::~A() {}
   121 
   122 struct B {
   123     ~B() {};
   124 };
   125 
   126 enum {dog, cat} animals;
   127 struct {int teats;} cow;
   128 
   129 class Boo {
   130     enum {dog, cat} animals;
   131     struct {int treats;} cow;
   132     int i,a,b;
   133     foo() {
   134         cout << "hi";
   135     }
   136 
   137     Boo(int _i, int _a, int _b) : i(_i), a(_a), b(_b) {}
   138     Boo(Boo);
   139 };
   140 
   141 Boo::Boo(Boo) :
   142     i(i),
   143     a(a),
   144     b(b)
   145 {}
   146 
   147 /* extern "C" grot: */
   148 extern "C" {
   149 typedef int should_see_this_one_enclosed_in_extern_C;
   150 }
   151 
   152 /* Typedefs: */
   153 typedef int (*should_see_this_function_pointer) (
   154         void *but_not_this_argument);
   155 
   156 typedef int should_see_this_array_type[but_not_this_subscript];