LR(1) parser with implement actions

Grammar

NSPACE -> namespace <NAMESPACE> SPC COMM_NAME { <LEVEL_U> } <LEVEL_D>
NSPACE -> namespace <NAMESPACE> SPC COMM_NAME { <LEVEL_U> NSPACE } <LEVEL_D>
NSPACE -> DEFS <CHECK>
NSPACE -> NSPACE NSPACE
NSPACE -> SPC
 
DEFS    -> FUNC_SB <REAL> | FUNC_S <PROTO>
FUNC_SB -> FUNC { } | FUNC SPC { }  | FUNC { SPC } | FUNC SPC { SPC } 
FUNC_S  -> FUNC ; 
 
FUNC    -> FUNC_ID SPC ( ) | FUNC_ID SPC ( SPC ) SPC | FUNC_ID ( ) | FUNC_ID ( SPC ) | FUNC_ID ( ) SPC
FUNC    -> FUNC_ID SPC ( ARG_LIST <CHECKARGLIST> ) SPC | FUNC_ID SPC ( ARG_LIST <CHECKARGLIST> ) | FUNC_ID ( ARG_LIST <CHECKARGLIST> ) SPC | FUNC_ID ( ARG_LIST <CHECKARGLIST> ) 
 
FUNC_ID -> ARG_TYPE <ADDFUNCNAME>
 
ARG_LIST -> ARG_TYPE <ADDPARAM> | ARG_MID
ARG_MID  -> ARG_TYPE <ADDPARAM> , | ARG_MID ARG_MID | ARG_MID ARG_TYPE <ADDPARAM> | ARG_MID ARG_FL <ADDPARAM>
ARG_FL   -> SPC DOTS SPC | DOTS SPC | SPC DOTS | DOTS 
DOTS     -> ... <LIT>
 
ARG_TYPE -> ARG | ARG SPC | SPC ARG | SPC ARG SPC | ARG_PTR 
ARG_TYPE -> ARG_PTR | ARG_PTR SPC | SPC ARG_PTR | SPC ARG_PTR SPC 
ARG_TYPE -> ARG_LINK | ARG_LINK SPC | SPC ARG_LINK | SPC ARG_LINK SPC 
 
ARG      -> KEYWORD IDENTIF | void <TYPE> SPC IDENTIF | void <TYPE> SPC | void <TYPE> | KEYWORD | KEYWORD DIGIT_ARRAY | KEYWORD DIGIT_ARRAY SPC 

ARG_PTR  -> KEYWORD AST IDENTIF | KEYWORD AST SPC IDENTIF | void <TYPE> SPC AST IDENTIF | void <TYPE> AST IDENTIF | void <TYPE> SPC AST SPC IDENTIF | void <TYPE> AST SPC IDENTIF | KEYWORD AST | KEYWORD AST SPC | KEYWORD AST DIGIT_ARRAY | KEYWORD AST SPC DIGIT_ARRAY | void <TYPE> SPC AST DIGIT_ARRAY | void <TYPE> AST DIGIT_ARRAY | void <TYPE> SPC AST SPC DIGIT_ARRAY 

ARG_LINK -> KEYWORD AMP IDENTIF | KEYWORD AMP SPC IDENTIF | KEYWORD AMP | KEYWORD AMP SPC 
AST      -> * <TYPE> | AST AST | AST SPC AST
AMP      -> & <TYPE>  | AMP AMP | AMP SPC AMP
 
KEYWORD -> int <TYPE> SPC | KEYWORD_MOD_SIZE SPC | KEYWORD_MOD_SIGN SPC | KEYWORD_MOD_SIZE SPC KEYWORD_MOD_SIGN SPC | KEYWORD_MOD_SIGN SPC KEYWORD_MOD_SIZE SPC | KEYWORD_MOD_SIZE SPC int <TYPE> SPC | int <TYPE> SPC KEYWORD_MOD_SIZE SPC | KEYWORD_MOD_SIGN SPC int <TYPE> SPC | int <TYPE> SPC KEYWORD_MOD_SIGN SPC | KEYWORD_MOD_SIGN SPC KEYWORD_MOD_SIZE SPC int <TYPE> SPC | KEYWORD_MOD_SIZE SPC KEYWORD_MOD_SIGN SPC int <TYPE> SPC | KEYWORD_MOD_SIGN SPC int <TYPE> SPC KEYWORD_MOD_SIZE SPC | KEYWORD_MOD_SIZE SPC int <TYPE> SPC KEYWORD_MOD_SIGN SPC | int <TYPE> SPC KEYWORD_MOD_SIGN SPC KEYWORD_MOD_SIZE SPC | int <TYPE> SPC KEYWORD_MOD_SIZE SPC KEYWORD_MOD_SIGN SPC | int <TYPE> | KEYWORD_MOD_SIZE | KEYWORD_MOD_SIGN | KEYWORD_MOD_SIZE SPC KEYWORD_MOD_SIGN | KEYWORD_MOD_SIGN SPC KEYWORD_MOD_SIZE | KEYWORD_MOD_SIZE SPC int <TYPE> | int <TYPE> SPC KEYWORD_MOD_SIZE | KEYWORD_MOD_SIGN SPC int <TYPE> | int <TYPE> SPC KEYWORD_MOD_SIGN | KEYWORD_MOD_SIGN SPC KEYWORD_MOD_SIZE SPC int <TYPE> | KEYWORD_MOD_SIZE SPC KEYWORD_MOD_SIGN SPC int <TYPE> | KEYWORD_MOD_SIGN SPC int <TYPE> SPC KEYWORD_MOD_SIZE | KEYWORD_MOD_SIZE SPC int <TYPE> SPC KEYWORD_MOD_SIGN | int <TYPE> SPC KEYWORD_MOD_SIGN SPC KEYWORD_MOD_SIZE | int <TYPE> SPC KEYWORD_MOD_SIZE SPC KEYWORD_MOD_SIGN 


KEYWORD -> char <TYPE> SPC KEYWORD_MOD_SIGN SPC | KEYWORD_MOD_SIGN SPC char <TYPE> SPC| char <TYPE> SPC | char <TYPE> SPC KEYWORD_MOD_SIGN | KEYWORD_MOD_SIGN SPC char <TYPE> | char <TYPE> 
KEYWORD -> float <TYPE> SPC | double <TYPE> SPC | float <TYPE> | double <TYPE> 
KEYWORD -> bool <TYPE> SPC | bool <TYPE> 

KEYWORD_MOD_SIGN -> signed <TYPE> | unsigned <TYPE> 
KEYWORD_MOD_SIZE -> short <TYPE> | long <TYPE> 

COMM_NAME -> COMM_NAME2 <ADDNAMESPACE><CHECK>
COMM_NAME2 -> START | START SYMB | START SPC | START SYMB SPC
IDENTIF -> START | START SYMB | IDENTIF DIGIT_ARRAY
 
SYMB    -> START   | \d <LIT> | SYMB SYMB
START   -> _ <LIT> | a-z <LIT> | A-Z <LIT> 
 
DIGIT_ARRAY -> [ <LIT> DIGIT_TRIM ] <LIT> | [ <LIT> ] <LIT> | [ <LIT> SPC ] <LIT> | DIGIT_ARRAY DIGIT_ARRAY | DIGIT_ARRAY SPC DIGIT_ARRAY
DIGIT_TRIM -> DIGIT | SPC DIGIT | DIGIT SPC  | SPC DIGIT SPC
 
DIGIT   -> \d <LIT> | DIGIT DIGIT
SPC   -> SPC SPC
SPC   -> \s

Example input

int f1(int a, double b, char c[10]){}
int f1(int *a, double b, char c[10]){}
int f1(int &a, double b, char c[10]){}
namespace N1 { 
	namespace N2 { 
		void f2(void); 
		void f3(); 
		int f4(long int, ...);
		int f4(long int, ...);
	}
	void f5(int, unsigned char) {} 
	void N1(int) {} 
	void f5(double) {}
	namespace N2 {
		void f5(double) {}
		
	}
}