AC++ Compiler Manual

class World{
  public: void __a0_after() {
    std::cout << "World" << std::endl;
  }
};

inline void __exec_old_hello(){
  std::cout << "Hello" << std::endl;
}

void hello(){
  ::__exec_old_hello(); // print “Hello”
  AC::invoke_World_World__a0_after (); // print “World”
}

int main(){
  hello();
  return 0;
}

class Hello{
  public: void __a0_before() {
    std::cout << "Hello" << std::endl;
  }
};

void world(){
  std::cout << "World" << std::endl;
}

inline void __Call__Z4mainv_0_0 (){
  AC::invoke_Hello_Hello__a0_before (); // print “Hello”
  ::world(); // print “World”
}

int main(){
  __Call__Z4mainv_0_0 ( );
  return 0;
}

class Hello{
  public: void __a0_after() {
  std::cout << "- Hello World" << std::endl;
  }
};

class World{
  public: World(){
    this->__exec_old_C1(); // Call old constructor
    AC::invoke_Hello_Hello__a0_after (); // Call advice
  }
  inline void __exec_old_C1(){std::cout << “New World created”;} 
};

int main(){
  World A = World(); // Construct temporary World instance
  return 0;
}

class Goodbye{
  public: void __a0_after() {
    std::cout << "- Goodbye World" << std::endl;
  }
};

class World{
  public: inline ~World () {
    this->__exec_old_D1(); // Call old destructor
    AC::invoke_Goodbye_Goodbye__a0_after (); // Call advice
  }
  // Old destructor
  inline void __exec_old_D1(){std::cout << “Cleanup”;}
};

int main(){
  World A = World(); // World instance
  return 0;
} // World gets destructed at end of main

// Aspect class empty besides default content (aspectof getter)
class Example {};
class ShopItem{int price;};

// New base class, new variable, new getter
class Laptop:  public ShopItem{
  private: int threads; 
  private: typedef Laptop SL; // Typedef for slice name SL
  private : int ram ; 
  public : int get_ram ( ) { return ram ; }
};

int main(){
  Laptop abc = Laptop();
  return 0;
}

class Hello {
  public: inline void __a0_before() {
    std::cout << "Hello World"; 
  }
};

char exclamation = ’!’;

template <typename TResult, typename TEntity>
  inline TResult __Get__Z4mainv_0_0 (TEntity &ent, AC::RT<TResult>)
{
  TResult __result_buffer;
  AC::invoke_Hello_Hello__a0_before (); //print Hello World
  __result_buffer = ::exclamation; 
  return (TResult &)__result_buffer; 
}

int main(){
  std::cout << 
  __Get__Z4mainv_0_0<  > (exclamation, __AC_TYPEOF((exclamation)) ) 
  << std::endl;
  return 0;
}

class Hello {
  public: inline void __a0_before() {
    std::cout << "Hello World";
  }
};

template <typename TResult, typename TEntity>
  inline TResult __Ref__Z4mainv_1_0 (TEntity &ent, AC::RT<TResult>)
{
  TResult __result_buffer;
  AC::invoke_Hello_Hello__a0_before (); // call advice
  __result_buffer = &( ::exclamation ); // buffers reference
  return (TResult &)__result_buffer; // returns buffered reference
}

char exclamation = ’!’;

int main(){
  char * exclamation_mark = __Ref__Z4mainv_1_0<  > 
    (exclamation, __AC_TYPEOF((&exclamation)) );
  std::cout << *exclamation_mark << std::endl;
  return 0;
}

class Example {
  public: inline void __a0_after() {
    std::cout << "Finished" << std::endl;
  }
};

template <typename TArg0, typename TEntity>
  inline void __Set__Z4mainv_1_0 (TEntity &ent, TArg0 arg0)
{
  ::i = (arg0); // Setting value
  AC::invoke_Example_Example__a0_after (); // Calling advice
}

template <typename TArg0, typename TArg1, typename TResult>
  inline TResult &__Builtin__Z4mainv_0_0
  (TArg0 arg0, TArg1 arg1, AC::RT<TResult>)
{
  TResult *__result_buffer; 
  __Set__Z4mainv_1_0< int > (arg0, arg1 ); // Calling set function
  __result_buffer = &arg0;
  return *(TResult *&)__result_buffer;
}

int i;
int main(){
  __Builtin__Z4mainv_0_0< int &, int > 
    (i , 42, __AC_TYPEOF((i = 42)) );
  return 0;
}

void give_int(int i){
  std::cout <<  "Got the Int!" << std::endl; 
}

int main(){
  give_int(42);
  return 0;
}

class Example {
  public: 
    template <typename JoinPoint> void __a0_before(JoinPoint *tjp) {
      std::cout << *tjp->template arg<0>() << std::endl;
  }
};

namespace AC { // different invoke function passing JoinPoint Type
  template <class JoinPoint> __attribute((always_inline)) 
    inline void invoke_Example_Example__a0_before (JoinPoint *tjp) 
  { ::Example::aspectof()->__a0_before (tjp); }
} 

inline void __exec_old_give_int(int i){
  std::cout <<  "Got the Int!" << std::endl; 
}

void give_int(int i)
{
  typedef TJP__Z8give_inti_0< void, void, void, void (int),  
    AC::TL< int, AC::TLE > > __TJP;
  __TJP tjp;
  tjp._args[0] = (void*)&i;
  AC::invoke_Example_Example__a0_before<__TJP> (&tjp);
  ::__exec_old_give_int(i);
}

int main(){
  give_int(42);
  return 0;
}

class Example{
  public: void __a0_before(int wert) {
    std::cout << wert << std::endl;
  }
};

// Invoke function typecasting JoinPoint to advice parameter 
namespace AC {
  template <class JoinPoint> __attribute((always_inline)) inline 
    void invoke_Example_Example__a0_before (JoinPoint *tjp) 
  {
    typedef typename JoinPoint::Binding_Example_Example\
      __a0_before::template Arg<0> Arg0;
    ::Example::aspectof()->__a0_before ((int)Arg0::val (tjp));
  }
} 

inline void __exec_old_give_int(int i){
  std::cout <<  "Got the Int!" << std::endl; 
}

void give_int(int i){ // Wrapper function
  typedef TJP__Z8give_inti_0< void, void, void, void (int),  
    AC::TL< int, AC::TLE > > __TJP;
  __TJP tjp;
  tjp._args[0] = (void*)&i;
  AC::invoke_Example_Example__a0_before<__TJP> (&tjp); // Advice
  ::__exec_old_give_int(i); // Calling old code
}

int main(){
  give_int(42);
  return 0;
}