TypePrinter.h

#pragma once

#include <stdio.h>

namespace

type_printer

{

template

typename

struct

TypePrinter

;

enum

class

TypeSource

{

TopLevel

Reference

Qualified

Array

Function

, };

#define PRINT_TYPE(...) \

do{ \

TypePrinter<__VA_ARGS__>::PrintPrefix(TypeSource::TopLevel); \

TypePrinter<__VA_ARGS__>::PrintPostfix(TypeSource::TopLevel); \

printf("\n"); \

}while(false) \

// primitive types

template

typename

TThis

struct

PrimitiveTypePrinter

{

static

void

PrintPrefix

(

TypeSource

source

) {

printf

(

TThis

::Name);

(

source

TypeSource

Qualified

)

printf

(

" "

); }

static

void

PrintPostfix

(

TypeSource

source

) { } };

#define MAKE_PRIMITIVE_TYPE(NAME) \

template<> \

struct TypePrinter<NAME> : PrimitiveTypePrinter<TypePrinter<NAME>> \

{ \

static const char* const Name; \

}; \

const char* const TypePrinter<NAME>::Name = #NAME \

MAKE_PRIMITIVE_TYPE(bool);

template

struct

TypePrinter

bool

> :

PrimitiveTypePrinter

TypePrinter

bool

>> {

static

const

char

const

Name

; };

const

char

const

TypePrinter

bool

>::

Name

"bool"

;

MAKE_PRIMITIVE_TYPE(char);

template

struct

TypePrinter

char

> :

PrimitiveTypePrinter

TypePrinter

char

>> {

static

const

char

const

Name

; };

const

char

const

TypePrinter

char

>::

Name

"char"

;

MAKE_PRIMITIVE_TYPE(int);

template

struct

TypePrinter

int

> :

PrimitiveTypePrinter

TypePrinter

int

>> {

static

const

char

const

Name

; };

const

char

const

TypePrinter

int

>::

Name

"int"

;

MAKE_PRIMITIVE_TYPE(float);

template

struct

TypePrinter

float

> :

PrimitiveTypePrinter

TypePrinter

float

>> {

static

const

char

const

Name

; };

const

char

const

TypePrinter

float

>::

Name

"float"

;

MAKE_PRIMITIVE_TYPE(double);

template

struct

TypePrinter

double

> :

PrimitiveTypePrinter

TypePrinter

double

>> {

static

const

char

const

Name

; };

const

char

const

TypePrinter

double

>::

Name

"double"

;

#undef MAKE_PRIMITIVE_TYPE

// references

template

typename

TThis

typename

struct

ReferenceTypePrinter

{

static

void

PrintPrefix

(

TypeSource

source

) {

TypePrinter

>::

PrintPrefix

(

TypeSource

Reference

);

printf

(

TThis

::Reference); }

static

void

PrintPostfix

(

TypeSource

source

) {

TypePrinter

>::

PrintPostfix

(

TypeSource

Reference

); } };

#define MAKE_REFERENCE_TYPE(REFERENCE) \

template<typename T> \

struct TypePrinter<T REFERENCE> : ReferenceTypePrinter<TypePrinter<T REFERENCE>, T> \

{ \

static const char* const Reference; \

}; \

template<typename T> \

const char* const TypePrinter<T REFERENCE>::Reference = #REFERENCE \

MAKE_REFERENCE_TYPE(*);

template

typename

struct

TypePrinter

*> :

ReferenceTypePrinter

TypePrinter

*>,

> {

static

const

char

const

Reference

; };

template

typename

const

char

const

TypePrinter

*>::

Reference

"*"

;

MAKE_REFERENCE_TYPE(&);

template

typename

struct

TypePrinter

&> :

ReferenceTypePrinter

TypePrinter

&>,

> {

static

const

char

const

Reference

; };

template

typename

const

char

const

TypePrinter

&>::

Reference

"&"

;

MAKE_REFERENCE_TYPE(&&);

template

typename

struct

TypePrinter

&&> :

ReferenceTypePrinter

TypePrinter

&&>,

> {

static

const

char

const

Reference

; };

template

typename

const

char

const

TypePrinter

&&>::

Reference

"&&"

;

#undef MAKE_REFERENCE_TYPE

// qualifieds

template

typename

TThis

typename

struct

QualifiedTypePrinter

{

static

void

PrintPrefix

(

TypeSource

source

) {

TypePrinter

>::

PrintPrefix

(

TypeSource

Qualified

);

printf

(

TThis

::Qualifier); }

static

void

PrintPostfix

(

TypeSource

source

) {

TypePrinter

>::

PrintPostfix

(

TypeSource

Qualified

); } };

#define MAKE_QUALIFIED_TYPE(QUALIFIER) \

template<typename T> \

struct TypePrinter<T QUALIFIER> : QualifiedTypePrinter<TypePrinter<T QUALIFIER>, T> \

{ \

static const char* const Qualifier; \

}; \

template<typename T> \

const char* const TypePrinter<T QUALIFIER>::Qualifier = #QUALIFIER \

MAKE_QUALIFIED_TYPE(const);

template

typename

struct

TypePrinter

const

> :

QualifiedTypePrinter

TypePrinter

const

> {

static

const

char

const

Qualifier

; };

template

typename

const

char

const

TypePrinter

const

>::

Qualifier

"const"

;

MAKE_QUALIFIED_TYPE(volatile);

template

typename

struct

TypePrinter

volatile

> :

QualifiedTypePrinter

TypePrinter

volatile

> {

static

const

char

const

Qualifier

; };

template

typename

const

char

const

TypePrinter

volatile

>::

Qualifier

"volatile"

;

MAKE_QUALIFIED_TYPE(const volatile);

template

typename

struct

TypePrinter

const

volatile

> :

QualifiedTypePrinter

TypePrinter

const

volatile

> {

static

const

char

const

Qualifier

; };

template

typename

const

char

const

TypePrinter

const

volatile

>::

Qualifier

"const volatile"

;

#undef MAKE_QUALIFIED_TYPE

// arrays

template

typename

int

Size

struct

ArrayTypePrinter

{

static

void

PrintPrefix

(

TypeSource

source

) {

TypePrinter

>::

PrintPrefix

(

TypeSource

Array

);

(

source

TypeSource

TopLevel

source

TypeSource

Array

)

printf

(

"("

); }

static

void

PrintPostfix

(

TypeSource

source

) {

(

source

TypeSource

TopLevel

source

TypeSource

Array

)

printf

(

")"

);

printf

(

"[%d]"

Size

);

TypePrinter

>::

PrintPostfix

(

TypeSource

Array

); } }; #pragma warning (push) #pragma warning (disable:

4003

)

#define MAKE_ARRAY_TYPE(QUALIFIER) \

template<typename T, int Size> \

struct TypePrinter<T QUALIFIER[Size]> : ArrayTypePrinter<T QUALIFIER, Size> \

{ \

} \

MAKE_ARRAY_TYPE();

template

typename

int

Size

struct

TypePrinter

[

Size

]> :

ArrayTypePrinter

Size

> { };

#pragma warning (pop)

MAKE_ARRAY_TYPE(const);

template

typename

int

Size

struct

TypePrinter

const

[

Size

]> :

ArrayTypePrinter

const

Size

> { };

MAKE_ARRAY_TYPE(volatile);

template

typename

int

Size

struct

TypePrinter

volatile

[

Size

]> :

ArrayTypePrinter

volatile

Size

> { };

MAKE_ARRAY_TYPE(const volatile);

template

typename

int

Size

struct

TypePrinter

const

volatile

[

Size

]> :

ArrayTypePrinter

const

volatile

Size

> { };

#undef MAKE_ARRAY_TYPE

// functions

template

typename

...

struct

TypeListPrinter

;

template

struct

TypeListPrinter

<> {

static

void

PrintTypeList

() {} };

template

typename

struct

TypeListPrinter

> {

static

void

PrintTypeList

() {

TypePrinter

>::

PrintPrefix

(

TypeSource

TopLevel

);

TypePrinter

>::

PrintPostfix

(

TypeSource

TopLevel

); } };

template

typename

...

struct

TypeListPrinter

...> {

static

void

PrintTypeList

() {

TypePrinter

>::

PrintPrefix

(

TypeSource

TopLevel

);

TypePrinter

>::

PrintPostfix

(

TypeSource

TopLevel

);

printf

(

", "

);

TypeListPrinter

...>::

PrintTypeList

(); } };

template

typename

...

struct

TypePrinter

(

...)> {

static

void

PrintPrefix

(

TypeSource

source

) {

TypePrinter

>::

PrintPrefix

(

TypeSource

Function

);

(

source

TypeSource

TopLevel

)

printf

(

"("

); }

static

void

PrintPostfix

(

TypeSource

source

) {

(

source

TypeSource

TopLevel

)

printf

(

")"

);

printf

(

"("

);

TypeListPrinter

...>::

PrintTypeList

();

printf

(

")"

);

TypePrinter

>::

PrintPostfix

(

TypeSource

Function

); } }; }