Parser_Progress_2012_03_11

// INPUT

int (killed)(int);
const int a = 10 + 20 + 30, b, c = 5;
double d, e, f = 10;
namespace justdefineit {
  long unsigned g;
  long unsigned int h;
  long unsigned long k;
}
long double i;
class koalacub {
  int leavesEaten;
  int chutesEaten;
};
class koala: koalacub {
  koalacub *children[10]; // A koala can have at most ten children because of reasons.
};

int *level1_simple[10];
unsigned long const int   (  *  level2_better )  [ 10+5+7+9 / 3 ] ;
int* (*(*level3_confusing)[10][12])[15];
long double (*(&*level4_whatthefuck[10])[2][4])(char, short, int, long, double, long double);
long double (*(&*(***level5_okaycutitout[1^2^4^8])(int illegalnest, char (*but)(int oh, int well))[10])[2][4])(char, short, int, long, double, long double);


int my_implemented_function(int) {
  implementation
}

int my_implemented_function_2(int, double, char) {
  implementation
}
int (my_implemented_function_3)(const long double) {
  implementation
}

/*
int function(int,int) {
  implementation 2
}

template<typename a> int function2(a b) { }

template<typename b> class templateclass { b aidu; }

#if false
#error Failure
#endif
*/

int zzzzz_success;



// OUTPUT

============================================================================
=: Test simple macros :=====================================================
============================================================================

#define one_arg_function(x) \
  (1/(1-(\
  x\
  )))
#define scalar_macro
  simple value
#define simple_function() \
  Takes no parameters
#define two_arg_function(a, b) \
  (-(\
  b\
  )/(2*(\
  a\
  )))
#define variadic_three_arg_function(a, b, c...) \
  printf(\
  a\
  ,\
  b\
  ,\
  c\
  )




============================================================================
=: Metrics :================================================================
============================================================================

sizeof(jdip::macro_type):       4
sizeof(jdip::macro_function):   56
sizeof(jdip::macro_scalar):     16




============================================================================
=: Test expression evaluator :==============================================
============================================================================

10
20
30
40
50
60
1
12
123




============================================================================
=: Test parser :============================================================
============================================================================

Parse finished in 224 microseconds.
const int a;
const int b;
const int c;
double d;
double e;
double f;
long double i;
namespace justdefineit {
  unsigned long g;
  unsigned long int h;
  unsigned long long k;
}
int killed(int);
class koala: private koalacub {
  koalacub *children[10];
}
class koalacub {
  int chutesEaten;
  int leavesEaten;
}
int *level1_simple[10];
const unsigned long int (*level2_better)[25];
int *(*(*level3_confusing)[10][12])[15];
long double (*(&*level4_whatthefuck[10])[2][4])(char, short, int, long, double, long double);
long double (*(&*(***level5_okaycutitout[15])(int illegalnest, char (*but)(int oh, int well))[10])[2][4])(char, short, int, long, double, long double);
int my_implemented_function(int);
int my_implemented_function_2(int, double, char);
int my_implemented_function_3(const long double);
int zzzzz_success;

====[++++++++++++++++++++++++++++++ SUCCESS! ++++++++++++++++++++++++++++++]====


Process returned 0 (0x0)   execution time : 0.016 s
Press ENTER to continue.