You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
815 lines
18 KiB
815 lines
18 KiB
#include "lib_test.h"
|
|
|
|
#include<stdio.h>
|
|
#include<stdlib.h>
|
|
#include<ctype.h>
|
|
#include<string.h>
|
|
|
|
// FUNCTIONS
|
|
|
|
// Int
|
|
void func_V_args_V() {
|
|
|
|
}
|
|
|
|
int func_Pi_args_V() {
|
|
return 23;
|
|
}
|
|
|
|
void func_V_args_Pi(int arg1_P) {
|
|
printf("DEBUG: %i\n", arg1_P);
|
|
}
|
|
|
|
int func_Pi_args_Pi(int arg1_P) {
|
|
return ++arg1_P;
|
|
}
|
|
|
|
void func_V_args_pPi(unsigned int* const arg1_pP) {
|
|
++(*arg1_pP);
|
|
}
|
|
|
|
int func_Pi_args_Pi_pPi_pPi(int arg1_P,unsigned int* const arg2_pP, int* arg3_pP) {
|
|
++(*arg2_pP);
|
|
++(*arg3_pP);
|
|
return *arg2_pP;
|
|
}
|
|
|
|
// Char
|
|
char func_Pc_args_V() {
|
|
return 'A';
|
|
}
|
|
|
|
void func_V_args_Pc(char arg1_Pc) {
|
|
printf("DEBUG: %c\n", arg1_Pc);
|
|
}
|
|
|
|
char func_Pc_args_Pc(char arg1_Pc) {
|
|
return toupper(arg1_Pc);
|
|
}
|
|
|
|
// Char*
|
|
char* func_pPcStr_args_V() {
|
|
char *ret = (char*) calloc(4,sizeof (char));
|
|
strcpy(ret,"pEp");
|
|
return ret;
|
|
}
|
|
|
|
void func_V_args_pPcChr(char* arg1_pPc) {
|
|
*arg1_pPc = toupper(*arg1_pPc);
|
|
}
|
|
|
|
void func_V_args_pPcStr(char* arg1_pPc) {
|
|
for(int i = 0; arg1_pPc[i] != '\0'; i++) {
|
|
arg1_pPc[i] = toupper(arg1_pPc[i]);
|
|
}
|
|
}
|
|
|
|
char func_Pc_args_Pc_pPc_pPc(char arg1_Pc,char* arg2_pPc,char* arg3_pPc){
|
|
*arg2_pPc = toupper(*arg2_pPc);
|
|
*arg3_pPc = toupper(*arg3_pPc);
|
|
return 'A';
|
|
}
|
|
|
|
// String-by-value (const char*)
|
|
const char* func_pPcc_args_V() {
|
|
return "pEp";
|
|
}
|
|
|
|
void func_V_args_pPcc(const char* arg1_pPcc) {
|
|
printf("DEBUG: %s\n", arg1_pPcc);
|
|
}
|
|
|
|
const char* func_pPcc_args_pPcc(const char* arg1_pPcc) {
|
|
return arg1_pPcc;
|
|
}
|
|
|
|
const char* func_pPcc_args_pPcc_pPcc(const char* arg1_pPcc,const char* arg2_pPcc) {
|
|
printf("DEBUG: %s\n", arg1_pPcc);
|
|
printf("DEBUG: %s\n", arg2_pPcc);
|
|
return arg1_pPcc;
|
|
}
|
|
|
|
// String-by-ref (char**)
|
|
char** func_ppPc_args_V() {
|
|
char* ret = (char*)calloc(4,sizeof(char));
|
|
strcpy(ret,"pEp");
|
|
char** pp_ret = (char**)calloc(1,sizeof(char**));
|
|
pp_ret = &ret;
|
|
return pp_ret;
|
|
}
|
|
|
|
char*** func_pppPc_args_V() {
|
|
char* ret = (char*)calloc(4,sizeof(char));
|
|
strcpy(ret,"pEp");
|
|
char** pp_ret = (char**)calloc(1,sizeof(char**));
|
|
pp_ret = &ret;
|
|
char*** ppp_ret = (char***)calloc(1,sizeof(char***));
|
|
ppp_ret = &pp_ret;
|
|
return ppp_ret;
|
|
}
|
|
|
|
void func_V_args_ppPc(char** arg1_ppPc) {
|
|
*arg1_ppPc = NULL;
|
|
char* newstr = (char*) calloc(4,sizeof (char ));
|
|
strcpy(newstr,"pEp");
|
|
*arg1_ppPc = newstr;
|
|
}
|
|
|
|
char*** func_pppPc_args_pppPc(char*** arg1_ppPc) {
|
|
**arg1_ppPc = NULL;
|
|
char* newstr = (char*) calloc(4,sizeof (char ));
|
|
strcpy(newstr,"pEp");
|
|
**arg1_ppPc = newstr;
|
|
return arg1_ppPc;
|
|
}
|
|
|
|
char*** func_pppPc_args_pppPc_ppPc(char*** arg1_ppPc,char** arg2_ppPc) {
|
|
**arg1_ppPc = NULL;
|
|
*arg2_ppPc = NULL;
|
|
char* newstr = (char*) calloc(4,sizeof (char ));
|
|
strcpy(newstr,"pEp");
|
|
**arg1_ppPc = newstr;
|
|
*arg2_ppPc = newstr;
|
|
return arg1_ppPc;
|
|
}
|
|
|
|
struct _PS func__PS_args_V() {
|
|
struct _PS* ret = (struct _PS*)malloc(sizeof(struct _PS));
|
|
ret->field__P_1=23;
|
|
ret->field__P_2=23;
|
|
return *ret;
|
|
}
|
|
|
|
struct _PS func__PS_args__PS(struct _PS arg1__PS) {
|
|
arg1__PS.field__P_1 = 23;
|
|
arg1__PS.field__P_2 = 23;
|
|
return arg1__PS;
|
|
}
|
|
|
|
TTAPS func_TTAPS_args_V() {
|
|
TTAPS* ret = (TTAPS*)malloc(sizeof(TTAPS));
|
|
ret->field__P_1=23;
|
|
ret->field__P_2=23;
|
|
return *ret;
|
|
}
|
|
|
|
TTAPS func_TTAPS_args_TTAPS(TTAPS arg1_TTAPS) {
|
|
arg1_TTAPS.field__P_1 = 23;
|
|
arg1_TTAPS.field__P_2 = 23;
|
|
return arg1_TTAPS;
|
|
}
|
|
|
|
TAPS* func_pTAPS_args_V() {
|
|
TAPS* ret = (TAPS*)malloc(sizeof(TAPS));
|
|
ret->field__P_1 = 23;
|
|
ret->field__P_2 = 23;
|
|
return ret;
|
|
}
|
|
|
|
TAPS** func_ppTAPS_args_V() {
|
|
TAPS* ret = (TAPS*)malloc(sizeof(TAPS));
|
|
ret->field__P_1 = 23;
|
|
ret->field__P_2 = 23;
|
|
TAPS** pp_ret = (TAPS**) malloc(sizeof (TAPS**));
|
|
pp_ret = &ret;
|
|
return pp_ret;
|
|
}
|
|
|
|
TAPS*** func_pppTAPS_args_V() {
|
|
TAPS* ret = (TAPS*)malloc(sizeof(TAPS));
|
|
ret->field__P_1 = 23;
|
|
ret->field__P_2 = 23;
|
|
TAPS** pp_ret = (TAPS**) malloc(sizeof (TAPS**));
|
|
pp_ret = &ret;
|
|
TAPS*** ppp_ret = (TAPS***) malloc(sizeof (TAPS***));
|
|
ppp_ret = &pp_ret;
|
|
return ppp_ret;
|
|
|
|
}
|
|
|
|
void func_V_args_pTAPS(TAPS* arg1_pTAPS) {
|
|
arg1_pTAPS->field__P_1 = 23;
|
|
arg1_pTAPS->field__P_2 = 23;
|
|
}
|
|
|
|
TAPS** func_ppTAPS_args_ppTAPS(TAPS** arg1_ppTAPS) {
|
|
*arg1_ppTAPS = NULL;
|
|
TAPS* newstr = (TAPS*) malloc(sizeof (TAPS));
|
|
newstr->field__P_1 = 23;
|
|
newstr->field__P_2 = 23;
|
|
*arg1_ppTAPS = newstr;
|
|
return arg1_ppTAPS;
|
|
}
|
|
|
|
TAPS*** func_pppTAPS_args_pppTAPS(TAPS*** arg1_pppTAPS) {
|
|
**arg1_pppTAPS = NULL;
|
|
TAPS* newstr = (TAPS*) malloc(sizeof (TAPS));
|
|
newstr->field__P_1 = 23;
|
|
newstr->field__P_2 = 23;
|
|
**arg1_pppTAPS = newstr;
|
|
return arg1_pppTAPS;
|
|
}
|
|
|
|
// PSa - Primitive Structs containing array
|
|
// PSa contains a char[4] (which is an array of bytes, NOT a string)
|
|
// By value
|
|
// TODO: AMEND
|
|
TTAPSa func_TTAPSa_args_V() {
|
|
TTAPSa ret;
|
|
strcpy(ret.field__Pa_1, "pEp");
|
|
return ret;
|
|
}
|
|
|
|
TTAPSa func_TTAPSa_args_TTAPSa(TTAPSa arg1_TTAPSa) {
|
|
TTAPSa ret;
|
|
for(int i=0; i < 4; ++i) {
|
|
ret.field__Pa_1[i] = arg1_TTAPSa.field__Pa_1[i];
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
// By pointer
|
|
void func_V_args_pTTAPSa(TTAPSa* arg1_pTTAPSa) {
|
|
strcpy(arg1_pTTAPSa->field__Pa_1, "pEp");
|
|
}
|
|
|
|
TTAPSa** func_ppTTAPSa_args_ppTTAPSa(TTAPSa** arg1_ppTTAPSa) {
|
|
*arg1_ppTTAPSa = NULL;
|
|
TTAPSa* newstr = (TTAPSa*) malloc(sizeof (TTAPSa));
|
|
newstr->field__P_1 = 23;
|
|
strcpy(newstr->field__Pa_1, "pEp");
|
|
*arg1_ppTTAPSa = newstr;
|
|
return arg1_ppTTAPSa;
|
|
}
|
|
|
|
TTAPSa*** func_pppTTAPSa_args_pppTTAPSa(TTAPSa*** arg1_pppTTAPSa) {
|
|
**arg1_pppTTAPSa = NULL;
|
|
TTAPSa* newstr = (TTAPSa*) malloc(sizeof (TTAPSa));
|
|
newstr->field__P_1 = 23;
|
|
strcpy(newstr->field__Pa_1, "pEp");
|
|
**arg1_pppTTAPSa = newstr;
|
|
return arg1_pppTTAPSa;
|
|
}
|
|
|
|
// CS - Complex Structs containing array
|
|
// CS contains a PS[3] (which is an array of structs)
|
|
// By value
|
|
TACS func_TACS_args_V() {
|
|
TACS ret;
|
|
ret.field__PS_1.field__P_1 = 23;
|
|
ret.field__PS_1.field__P_2 = 23;
|
|
ret.field_APS_1[0].field__P_1 = 23;
|
|
ret.field_APS_1[0].field__P_2 = 24;
|
|
ret.field_APS_1[1].field__P_1 = 25;
|
|
ret.field_APS_1[1].field__P_2 = 26;
|
|
ret.field_APS_1[2].field__P_1 = 27;
|
|
ret.field_APS_1[2].field__P_2 = 28;
|
|
return ret;
|
|
}
|
|
|
|
TACS func_TACS_args_TACS(TACS arg1_TACS) {
|
|
|
|
}
|
|
|
|
// By pointer
|
|
void func_V_args_pTACS(TACS* arg1_pTACS) {
|
|
|
|
}
|
|
|
|
TACS** func_ppTACS_args_ppTACS(TACS** arg1_ppTACS) {
|
|
|
|
}
|
|
|
|
TACS*** func_pppTACS_args_pppTACS(TACS*** arg1_pppTACS) {
|
|
|
|
}
|
|
|
|
|
|
// Variables
|
|
// =========
|
|
// _V = Void
|
|
//void var__V;
|
|
|
|
// _P
|
|
extern char var__P = 'x';
|
|
|
|
// enums
|
|
// =====
|
|
// Incomplete types:
|
|
// enum _IE var__IE;
|
|
// enum IE var_IE;
|
|
// AIE var_AIE;
|
|
extern enum _E var__E;
|
|
extern enum E var_E;
|
|
extern AE var_AE;
|
|
extern AXE var_AXE;
|
|
|
|
|
|
// structs
|
|
// =======
|
|
// Incomplete types
|
|
// struct _IS var__IS;
|
|
// struct IS var_IS;
|
|
// AIS var_AIS;
|
|
|
|
// primitive structs
|
|
extern struct _PS var__PS;
|
|
extern struct PS var_PS;
|
|
extern APS var_APS;
|
|
|
|
// primitive structs containing arrays
|
|
extern struct _PSa var__PSa;
|
|
extern struct PSa var_PSa;
|
|
extern APSa var_APSa;
|
|
|
|
// complex structs
|
|
extern struct _CS var__CS;
|
|
extern struct CS var_CS;
|
|
extern ACS var_ACS;
|
|
|
|
extern struct _CCS var__CCS;
|
|
extern struct CCS var_CCS;
|
|
extern ACCS var_ACCS;
|
|
|
|
// nested structs / hosting structs
|
|
struct _HS var__HS;
|
|
extern AHS var_AHS;
|
|
extern struct HS var_HS;
|
|
extern struct HHS var_HHS;
|
|
extern AHHS var_AHHS;
|
|
extern struct _HHS var__HHS;
|
|
extern struct _HS1 var__HS1;
|
|
|
|
// FORBIDDEN IN C++
|
|
#ifndef __cplusplus
|
|
extern struct _NCS var__NCS;
|
|
extern struct _NPS var__NPS;
|
|
extern struct _NHS var__NHS;
|
|
extern struct _NNPS var__NNPS;
|
|
extern struct _NHS1 var__NHS1;
|
|
extern struct _NNCS var__NNCS;
|
|
extern enum _NENHS var__NENHS;
|
|
extern enum _NEHS var__NEHS;
|
|
#endif
|
|
|
|
// TYPEDEFS
|
|
// ========
|
|
|
|
// Typedefs of primitive
|
|
// ---------------------
|
|
//TV var_TV;
|
|
T_P var_T_P;
|
|
|
|
// Typedefs of structs
|
|
// ------------------
|
|
// Incomplete types
|
|
//T_IS var_T_IS;
|
|
//TIS var_TIS;
|
|
//TAIS var_TAIS;
|
|
|
|
// primitive structs
|
|
extern T_PS var_T_PS;
|
|
extern TPS var_TPS;
|
|
extern TAPS var_TAPS;
|
|
|
|
// primitive structs containing arrays
|
|
extern T_PSa var_T_PSa;
|
|
extern TPSa var_TPSa;
|
|
extern TAPSa var_TAPSa;
|
|
|
|
// complex structs
|
|
extern T_CS var_T_CS;
|
|
extern TCS var_TCS;
|
|
extern TACS var_TACS;
|
|
extern T_CCS var_T_CCS;
|
|
extern TCCS var_TCCS;
|
|
extern TACCS var_TACCS;
|
|
|
|
// nested structs / hosting structs
|
|
extern T_HS var_T_HS;
|
|
extern THS var_THS;
|
|
extern TAHS var_TAHS;
|
|
extern T_HHS var_T_HHS;
|
|
extern THHS var_THHS;
|
|
extern TAHHS var_TAHHS;
|
|
extern T_HS1 var_T_HS1;
|
|
|
|
// FORBIDDEN IN C++
|
|
#ifndef __cplusplus
|
|
extern T_NENHS var_T_NENHS;
|
|
extern T_NCS var_T_NCS;
|
|
extern T_NPS var_T_NPS;
|
|
extern T_NHS var_T_NHS;
|
|
extern T_NNPS var_T_NNPS;
|
|
extern T_NNCS var_T_NNCS;
|
|
extern T_NHS1 var_T_NHS1;
|
|
extern T_NEHS var_T_NEHS;
|
|
#endif
|
|
|
|
// Typedef of enums
|
|
// ----------------
|
|
// Incomplete types
|
|
//T_IE var_TIE;
|
|
//TIE var_TIE;
|
|
//TAIE var_TAIE;
|
|
extern T_E var_T_E;
|
|
extern TE var_TE;
|
|
extern TAE var_TAE;
|
|
extern TAXE var_TAXE;
|
|
|
|
|
|
|
|
// TYPEDEFS OF TYPEDEFS
|
|
// ====================
|
|
|
|
// Typedefs of primitive
|
|
// ---------------------
|
|
extern TT_P var_TT_P;
|
|
|
|
// typedefs of typedefs of structs
|
|
// -------------------------------
|
|
// primitive structs
|
|
extern TT_PS var_TT_PS;
|
|
extern TTPS var_TTPS;
|
|
extern TTAPS var_TTAPS;
|
|
|
|
// primitive structs containing arrays
|
|
extern TT_PSa var_TT_PSa;
|
|
extern TTPSa var_TTPSa;
|
|
extern TTAPSa var_TTAPSa;
|
|
|
|
// complex structs
|
|
extern TT_CS var_TT_CS;
|
|
extern TTCS var_TTCS;
|
|
extern TTACS var_TTACS;
|
|
extern TT_CCS var_TT_CCS;
|
|
extern TTCCS var_TTCCS;
|
|
extern TTACCS var_TTACCS;
|
|
|
|
// nested structs / hosting structs
|
|
extern TT_HS var_TT_HS;
|
|
extern TTHS var_TTHS;
|
|
extern TTAHS var_TTAHS;
|
|
extern TT_HHS var_TT_HHS;
|
|
extern TTHHS var_TTHHS;
|
|
extern TTAHHS var_TTAHHS;
|
|
extern TT_HS1 var_TT_HS1;
|
|
|
|
// FORBIDDEN IN C++
|
|
#ifndef __cplusplus
|
|
extern TT_NENHS var_TT_NENHS;
|
|
extern TT_NCS var_TT_NCS;
|
|
extern TT_NPS var_TT_NPS;
|
|
extern TT_NHS var_TT_NHS;
|
|
extern TT_NNPS var_TT_NNPS;
|
|
extern TT_NNCS var_TT_NNCS;
|
|
extern TT_NHS1 var_TT_NHS1;
|
|
extern TT_NEHS var_TT_NEHS;
|
|
#endif
|
|
|
|
// typedefs of typedefs enums
|
|
// --------------------------
|
|
extern TT_E var_TT_E;
|
|
extern TTE var_TTE;
|
|
extern TTAE var_TTAE;
|
|
extern TTAXE var_TTAXE;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ===================
|
|
// ARRAYS OF ALL ABOVE
|
|
// ===================
|
|
// only complete arrays. no []
|
|
// Variables
|
|
// =========
|
|
// _V = Void
|
|
//void var_a_V;
|
|
|
|
// _P
|
|
extern char var_a_P[4];
|
|
|
|
// enums
|
|
// =====
|
|
// Incomplete types:
|
|
// enum _IE var__IE;
|
|
// enum IE var_IE;
|
|
// AIE var_AIE;
|
|
extern enum _E var_a_E[3];
|
|
extern enum E var_aE[3];
|
|
extern AE var_aAE[3];
|
|
extern AXE var_aAXE[3];
|
|
|
|
|
|
// structs
|
|
// =======
|
|
// Incomplete types
|
|
// struct _IS var__IS;
|
|
// struct IS var_IS;
|
|
// AIS var_AIS;
|
|
|
|
// primitive structs
|
|
extern struct _PS var_a_PS[3];
|
|
extern struct PS var_aPS[3];
|
|
extern APS var_aAPS[3];
|
|
|
|
// primitive structs containing arrays
|
|
extern struct _PSa var_a_PSa[3];
|
|
extern struct PSa var_aPSa[3];
|
|
extern APSa var_aAPSa[3];
|
|
|
|
// complex structs
|
|
extern struct _CS var_a_CS[3];
|
|
extern struct CS var_aCS[3];
|
|
extern ACS var_aACS[3];
|
|
extern struct _CCS var_a_CCS[3];
|
|
extern struct CCS var_aCCS[3];
|
|
extern ACCS var_aACCS[3];
|
|
|
|
// nested structs / hosting structs
|
|
extern struct _HS var_a_HS[3];
|
|
extern struct HS var_aHS[3];
|
|
|
|
extern AHS var_aAHS[3];
|
|
extern struct _HHS var_a_HHS[3];
|
|
extern struct HHS var_aHHS[3];
|
|
extern AHHS var_aAHHS[3];
|
|
extern struct _HS1 var_a_HS1[3];
|
|
|
|
// FORBIDDEN IN C++
|
|
#ifndef __cplusplus
|
|
extern struct _NCS var_a_NCS[3];
|
|
extern struct _NPS var_a_NPS[3];
|
|
extern struct _NHS var_a_NHS[3];
|
|
extern struct _NNPS var_a_NNPS[3];
|
|
extern struct _NHS1 var_a_NHS1[3];
|
|
extern struct _NNCS var_a_NNCS[3];
|
|
extern enum _NENHS var_a_NENHS[3];
|
|
extern enum _NEHS var_a_NEHS[3];
|
|
#endif
|
|
|
|
// TYPEDEFS
|
|
// ========
|
|
|
|
// Typedefs of primitive
|
|
// ---------------------
|
|
//TV var_TV;
|
|
extern T_P var_aT_P[3];
|
|
|
|
// Typedefs of structs
|
|
// ------------------
|
|
// Incomplete types
|
|
//T_IS var_T_IS;
|
|
//TIS var_TIS;
|
|
//TAIS var_TAIS;
|
|
|
|
// primitive structs
|
|
extern T_PS var_aT_PS[3];
|
|
extern TPS var_aTPS[3];
|
|
extern TAPS var_aTAPS[3];
|
|
|
|
// primitive structs containing arrays
|
|
extern T_PSa var_aT_PSa[3];
|
|
extern TPSa var_aTPSa[3];
|
|
extern TAPSa var_aTAPSa[3];
|
|
|
|
// complex structs
|
|
extern T_CS var_aT_CS[3];
|
|
extern TCS var_aTCS[3];
|
|
extern TACS var_aTACS[3];
|
|
extern T_CCS var_aT_CCS[3];
|
|
extern TCCS var_aTCCS[3];
|
|
extern TACCS var_aTACCS[3];
|
|
|
|
// nested structs / hosting structs
|
|
extern T_HS var_aT_HS[3];
|
|
extern THS var_aTHS[3];
|
|
extern TAHS var_aTAHS[3];
|
|
extern T_HHS var_aT_HHS[3];
|
|
extern THHS var_aTHHS[3];
|
|
extern TAHHS var_aTAHHS[3];
|
|
extern T_HS1 var_aT_HS1[3];
|
|
|
|
// FORBIDDEN IN C++
|
|
#ifndef __cplusplus
|
|
extern T_NENHS var_aT_NENHS[3];
|
|
extern T_NCS var_aT_NCS[3];
|
|
extern T_NPS var_aT_NPS[3];
|
|
extern T_NHS var_aT_NHS[3];
|
|
extern T_NNPS var_aT_NNPS[3];
|
|
extern T_NNCS var_aT_NNCS[3];
|
|
extern T_NHS1 var_aT_NHS1[3];
|
|
extern T_NEHS var_aT_NEHS[3];
|
|
#endif
|
|
|
|
// Typedef of enums
|
|
// ----------------
|
|
// Incomplete types
|
|
//T_IE var_aTIE[3];
|
|
//TIE var_aTIE[3];
|
|
//TAIE var_aTAIE[3];
|
|
extern T_E var_aT_E[3];
|
|
extern TE var_aTE[3];
|
|
extern TAE var_aTAE[3];
|
|
extern TAXE var_aTAXE[3];
|
|
|
|
|
|
|
|
// TYPEDEFS OF TYPEDEFS
|
|
// ====================
|
|
|
|
// Typedefs of primitive
|
|
// ---------------------
|
|
extern TT_P var_aTT_P[3];
|
|
|
|
// typedefs of typedefs of structs
|
|
// -------------------------------
|
|
// primitive structs
|
|
extern TT_PS var_aTT_PS[3];
|
|
extern TTPS var_aTTPS[3];
|
|
extern TTAPS var_aTTAPS[3];
|
|
|
|
// primitive structs containing arrays
|
|
extern TT_PSa var_aTT_PSa[3];
|
|
extern TTPSa var_aTTPSa[3];
|
|
extern TTAPSa var_aTTAPSa[3];
|
|
|
|
// complex structs
|
|
extern TT_CS var_aTT_CS[3];
|
|
extern TTCS var_aTTCS[3];
|
|
extern TTACS var_aTTACS[3];
|
|
extern TT_CCS var_aTT_CCS[3];
|
|
extern TTCCS var_aTTCCS[3];
|
|
extern TTACCS var_aTTACCS[3];
|
|
|
|
// nested structs / hosting structs
|
|
extern TT_HS var_aTT_HS[3];
|
|
extern TTHS var_aTTHS[3];
|
|
extern TTAHS var_aTTAHS[3];
|
|
extern TT_HHS var_aTT_HHS[3];
|
|
extern TTHHS var_aTTHHS[3];
|
|
extern TTAHHS var_aTTAHHS[3];
|
|
extern TT_HS1 var_aTT_HS1[3];
|
|
|
|
// FORBIDDEN IN C++
|
|
#ifndef __cplusplus
|
|
extern TT_NENHS var_aTT_NENHS[3];
|
|
extern TT_NCS var_aTT_NCS[3];
|
|
extern TT_NPS var_aTT_NPS[3];
|
|
extern TT_NHS var_aTT_NHS[3];
|
|
extern TT_NNPS var_aTT_NNPS[3];
|
|
extern TT_NNCS var_aTT_NNCS[3];
|
|
extern TT_NHS1 var_aTT_NHS1[3];
|
|
extern TT_NEHS var_aTT_NEHS[3];
|
|
#endif
|
|
|
|
|
|
// typedefs of typedefs enums
|
|
// --------------------------
|
|
extern TT_E var_aTT_E[3];
|
|
extern TTE var_aTTE[3];
|
|
extern TTAE var_aTTAE[3];
|
|
extern TTAXE var_aTTAXE[3];
|
|
|
|
|
|
|
|
// =========================================
|
|
//AND ALL OF THE ABOVE
|
|
//
|
|
// ▄▄▄ ▄████ ▄▄▄ ██▓ ███▄ █
|
|
//▒████▄ ██▒ ▀█▒▒████▄ ▓██▒ ██ ▀█ █
|
|
//▒██ ▀█▄ ▒██░▄▄▄░▒██ ▀█▄ ▒██▒▓██ ▀█ ██▒
|
|
//░██▄▄▄▄██ ░▓█ ██▓░██▄▄▄▄██ ░██░▓██▒ ▐▌██▒
|
|
// ▓█ ▓██▒░▒▓███▀▒ ▓█ ▓██▒░██░▒██░ ▓██░
|
|
// ▒▒ ▓▒█░ ░▒ ▒ ▒▒ ▓▒█░░▓ ░ ▒░ ▒ ▒
|
|
// ▒ ▒▒ ░ ░ ░ ▒ ▒▒ ░ ▒ ░░ ░░ ░ ▒░
|
|
// ░ ▒ ░ ░ ░ ░ ▒ ▒ ░ ░ ░ ░
|
|
// ░ ░ ░ ░ ░ ░ ░
|
|
//
|
|
// ...for typedefs of arrays, but only TaT*
|
|
// ========================================
|
|
|
|
|
|
|
|
// TYPEDEFS OF TYPEDEFS
|
|
// ====================
|
|
|
|
// Typedefs of primitive
|
|
// ---------------------
|
|
extern TaT_P var_TaT_P;
|
|
|
|
// typedefs of typedefs of structs
|
|
// -------------------------------
|
|
// primitive structs
|
|
extern TaT_PS var_TaT_PS;
|
|
extern TaTPS var_TaTPS;
|
|
extern TaTAPS var_TaTAPS;
|
|
|
|
// primitive structs containing arrays
|
|
extern TaT_PSa var_TaT_PSa;
|
|
extern TaTPSa var_TaTPSa;
|
|
extern TaTAPSa var_TaTAPSa;
|
|
|
|
// complex structs
|
|
extern TaT_CS var_TaT_CS;
|
|
extern TaTCS var_TaTCS;
|
|
extern TaTACS var_TaTACS;
|
|
extern TaT_CCS var_TaT_CCS;
|
|
extern TaTCCS var_TaTCCS;
|
|
extern TaTACCS var_TaTACCS;
|
|
|
|
// nested structs / hosting structs
|
|
extern TaT_HS var_TaT_HS;
|
|
extern TaTHS var_TaTHS;
|
|
extern TaTAHS var_TaTAHS;
|
|
extern TaT_HHS var_TaT_HHS;
|
|
extern TaTHHS var_TaTHHS;
|
|
extern TaTAHHS var_TaTAHHS;
|
|
extern TaT_HS1 var_TaT_HS1;
|
|
|
|
// FORBIDDEN IN C++
|
|
#ifndef __cplusplus
|
|
extern TaT_NCS var_TaT_NCS;
|
|
extern TaT_NPS var_TaT_NPS;
|
|
extern TaT_NHS var_TaT_NHS;
|
|
extern TaT_NNPS var_TaT_NNPS;
|
|
extern TaT_NNCS var_TaT_NNCS;
|
|
extern TaT_NHS1 var_TaT_NHS1;
|
|
extern TaT_NENHS var_TaT_NENHS;
|
|
extern TaT_NEHS var_TaT_NEHS;
|
|
#endif
|
|
|
|
// typedefs of typedefs enums
|
|
// --------------------------
|
|
extern TaT_E var_TaT_E;
|
|
extern TaTE var_TaTE;
|
|
extern TaTAE var_TaTAE;
|
|
extern TaTAXE var_TaTAXE;
|
|
|
|
|
|
|
|
// TYPEDEFS OF TYPEDEFS
|
|
// ====================
|
|
|
|
// Typedefs of primitive
|
|
// ---------------------
|
|
extern TaT_P var_aTaT_P[3];
|
|
|
|
// typedefs of typedefs of structs
|
|
// -------------------------------
|
|
// primitive structs
|
|
extern TaT_PS var_aTaT_PS[3];
|
|
extern TaTPS var_aTaTPS[3];
|
|
extern TaTAPS var_aTaTAPS[3];
|
|
|
|
// primitive structs containing arrays
|
|
extern TaT_PSa var_aTaT_PSa[3];
|
|
extern TaTPSa var_aTaTPSa[3];
|
|
extern TaTAPSa var_aTaTAPSa[3];
|
|
|
|
// complex structs
|
|
extern TaT_CS var_aTaT_CS[3];
|
|
extern TaTCS var_aTaTCS[3];
|
|
extern TaTACS var_aTaTACS[3];
|
|
extern TaT_CCS var_aTaT_CCS[3];
|
|
extern TaTCCS var_aTaTCCS[3];
|
|
extern TaTACCS var_aTaTACCS[3];
|
|
|
|
// nested structs / hosting structs
|
|
extern TaT_HS var_aTaT_HS[3];
|
|
extern TaTHS var_aTaTHS[3];
|
|
extern TaT_HHS var_aTaT_HHS[3];
|
|
extern TaTAHS var_aTaTAHS[3];
|
|
extern TaTHHS var_aTaTHHS[3];
|
|
extern TaTAHHS var_aTaTAHHS[3];
|
|
extern TaT_HS1 var_aTaT_HS1[3];
|
|
|
|
// FORBIDDEN IN C++
|
|
#ifndef __cplusplus
|
|
extern TaT_NCS var_aTaT_NCS[3];
|
|
extern TaT_NPS var_aTaT_NPS[3];
|
|
extern TaT_NHS var_aTaT_NHS[3];
|
|
extern TaT_NNPS var_aTaT_NNPS[3];
|
|
extern TaT_NNCS var_aTaT_NNCS[3];
|
|
extern TaT_NENHS var_aTaT_NENHS[3];
|
|
extern TaT_NHS1 var_aTaT_NHS1[3];
|
|
extern TaT_NEHS var_aTaT_NEHS[3];
|
|
#endif
|
|
|
|
// typedefs of typedefs enums
|
|
// --------------------------
|
|
extern TaT_E var_aTaT_E[3];
|
|
extern TaTE var_aTaTE[3];
|
|
extern TaTAE var_aTaTAE[3];
|
|
extern TaTAXE var_aTaTAXE[3];
|
|
|
|
|
|
|
|
|
|
|