static int printAttribute(D4printer* out, NCD4node* attr, int depth) { int ret = NC_NOERR; int i = 0; char* fqn = NULL; INDENT(depth); CAT("<Attribute"); printXMLAttributeName(out,"name",attr->name); if(attr->basetype->subsort <= NC_MAX_ATOMIC_TYPE) printXMLAttributeName(out,"type",attr->basetype->name); else { printXMLAttributeName(out,"type",(fqn = NCD4_makeFQN(attr->basetype))); } CAT(">\n"); depth++; for(i=0;i<nclistlength(attr->attr.values);i++) { printValue(out,(const char*)nclistget(attr->attr.values,i),depth); CAT("\n"); } depth--; INDENT(depth); CAT("</Attribute>"); nullfree(fqn); return THROW(ret); }
static const char *axes_mask(uint8_t flags, char *buf, size_t maxbuf, int isEnable) { #define CAT(x) \ { if (buf[0]) strncat(buf, ", ", maxbuf); \ strncat(buf, (x), maxbuf); } if (!buf || !maxbuf) return(NULL); buf[0] = '\0'; if (isEnable) strncat(buf, (flags & 0x80) ? "+" : "-", maxbuf); if (flags != (uint8_t)0) { if (flags & 0x01) CAT("X"); if (flags & 0x02) CAT("Y"); if (flags & 0x04) CAT("Z"); if (flags & 0x08) CAT("A"); if (flags & 0x10) CAT("B"); } else strncat(buf, "<NO AXES>", maxbuf); return(buf); #undef CAT }
static int printMetaData(D4printer* out, NCD4node* node, int depth) { int ret = NC_NOERR; int i; if(nclistlength(node->dims) > 0) { for(i=0;i<nclistlength(node->dims);i++) { NCD4node* dim = (NCD4node*)nclistget(node->dims,i); printDimref(out,dim,depth); CAT("\n"); } } if(nclistlength(node->maps) > 0) { for(i=0;i<nclistlength(node->maps);i++) { NCD4node* mapref = (NCD4node*)nclistget(node->maps,i); printMap(out,mapref,depth); CAT("\n"); } } if(nclistlength(node->attributes) > 0) { for(i=0;i<nclistlength(node->attributes);i++) { NCD4node* attr = (NCD4node*)nclistget(node->attributes,i); printAttribute(out,attr,depth); CAT("\n"); } } return THROW(ret); }
static int printValue(D4printer* out, const char* value, int depth) { int ret = NC_NOERR; INDENT(depth); CAT("<Value"); printXMLAttributeString(out,"value",value); CAT("/>"); return THROW(ret); }
static int printXMLAttributeAtomics(D4printer* out, char* name, union ATOMICS* value, nc_type type) { int ret = NC_NOERR; CAT(" "); CAT(name); CAT("=\""); atomicsToString(out,value,type); CAT(ncbytescontents(out->tmp)); CAT("\""); return THROW(ret); }
int main() { int a=CAT(2,5); float f = CAT(10,e2); char str[20]= strcat(Veda,Solutions); printf(" a = %d\n",a); printf(" f = %f\n",f); printf(" str = %s\n",str); }
static int printMap(D4printer* out, NCD4node* mapref, int depth) { char* fqn = NULL; INDENT(depth); CAT("<Map"); printXMLAttributeName(out, "name", (fqn=NCD4_makeFQN(mapref))); CAT("/>"); nullfree(fqn); return THROW(NC_NOERR); }
void CMyLcd::Beep(const SPlayTone* play,bool fromProgMem) { if (fromProgMem) { CBeep<CAT(BOARDNAME, _LCD_BEEPER)>::PlayPGM(play); } else { CBeep<CAT(BOARDNAME, _LCD_BEEPER)>::Play(play); } }
static int concat(void) { #define CAT(res, args) do { char *str = ne_concat args; \ ONCMP(str, res); \ ne_free(str); } while (0) CAT("alphabeta", ("alpha", "beta", NULL)); CAT("alpha", ("alpha", "", "", NULL)); CAT("", ("", NULL)); CAT("", ("", "", "", NULL)); CAT("alpha", ("", "a", "lph", "", "a", NULL)); return OK; }
static int printGroup(D4printer* out, NCD4node* node, int depth) { int ret = NC_NOERR; INDENT(depth); CAT("<Group"); printXMLAttributeName(out,"name",node->name); CAT(">\n"); depth++; ret = printGroupBody(out,node,depth); depth--; INDENT(depth); CAT("</Group>"); return THROW(ret); }
static int printXMLAttributeName(D4printer* out, char* name, const char* value) { int ret = NC_NOERR; char* escaped = NULL; if(name == NULL) return THROW(ret); if(value == NULL) value = ""; CAT(" "); CAT(name); CAT("=\""); /* add xml entity escaping */ escaped = NCD4_entityescape(value); CAT(escaped); CAT("\""); nullfree(escaped); return THROW(ret); }
void CMyLcd::Init() { #if defined(USE_RAMPS14) _lcd_numaxis=5; #endif CBeep<(CAT(BOARDNAME, _LCD_BEEPER))>::Init(); super::Init(); _rotarybutton.SetPin(ROTARY_EN1,ROTARY_EN2); _rotarypushbutton.SetPin(ROTARY_ENC,ROTARY_ENC_ON); CHAL::pinModeInputPullUp(CAT(BOARDNAME,_LCD_KILL_PIN)); _rotarybutton.Tick(); }
static int printDataset(D4printer* out, NCD4node* node, int depth) { int ret = NC_NOERR; CAT("<Dataset\n"); depth++; INDENT(depth); printXMLAttributeName(out,"name",node->group.datasetname); CAT("\n"); INDENT(depth); printXMLAttributeName(out,"dapVersion",node->group.dapversion); CAT("\n"); INDENT(depth); printXMLAttributeName(out,"dmrVersion",node->group.dmrversion); CAT("\n"); INDENT(depth); printXMLAttributeName(out,"xmlns","http://xml.opendap.org/ns/DAP/4.0#"); CAT("\n"); INDENT(depth); printXMLAttributeName(out,"xmlns:dap","http://xml.opendap.org/ns/DAP/4.0#"); depth--; CAT(">\n"); depth++; ret = printGroupBody(out,node,depth); depth--; INDENT(depth); CAT("</Dataset>"); return THROW(ret); }
static void library_init(void) { /* This seems to be a no-op, but it makes the GHCRTS envvar work. */ static char *argv[] = { STR(MODULE) ".so", 0 }, **argv_ = argv; static int argc = 1; printf("Loading library OfxPlugin and initializing rts\n"); hs_init(&argc, &argv_); hs_add_root(CAT(__stginit_, MODULE)); }
static void library_init(void) { /* This seems to be a no-op, but it makes the GHCRTS envvar work. */ static char *argv[] = { STR(CalculatorFinance) ".so", 0 }, **argv_ = argv; static int argc = 1; hs_init(&argc, &argv_); hs_add_root(CAT(__stginit_, CalculatorFinance)); }
void ft_get_tets(t_tet *tets, t_piece **pieces) { while (*pieces) { tets->max = ft_min(*pieces); tets->blocs = CAT((*pieces)); tets->pos = 0; tets->ident = -1; pieces++; tets++; } }
int main(int argc, char *argv[]) { int i; license(stdout, "/* ", " * ", " */"); printf("#ifndef CATALOGUES_H_INCLUDED\n" "#define CATALOGUES_H_INCLUDED\n\n"); printf("static const unsigned char opcode_breaks[KIND_MAX] = {\n\t"); for (i = 0; i < sizeof(opcode_breaks)/sizeof(opcode_breaks[0]); ++i) printf("%d, ", opcode_breaks[i]); printf("\n};\n\n"); CAT(stats_catalogue); CAT(prob_catalogue); CAT(mode_catalogue); CONVERSION(conv_catalogue); CAT(clear_catalogue); CAT(displ_catalogue); CAT(more_catalogue); fprintf(stderr, "# $Rev$\n" ); fprintf(stderr, "version=%c%c\n", VERSION_STRING[0], VERSION_STRING[2]); fprintf(stderr, "maxsteps=%d\n", 1); fprintf(stderr, "maxlibsteps=%d\n", 1); dump_opcodes(stderr, 0); printf( "/* Total number of catalogue entries %d\n" " * Total number of conversion entries %d\n" " * Total number of alpha entries %d\n" " */\n", total_cat, total_conv, total_alpha); printf("#endif\n"); return 0; }
int main(){ // FILE * dump = popen("od -t d4","w"); uint8_t input[102400]; size_t inputsize; NailArena arena; pos p; inputsize = fread(input, 1, sizeof(input), stdin); //fprintf(stderr, "inputsize=%zu\ninput=", inputsize); // fwrite(input, 1, inputsize, stderr); // fprintf(stderr,"\n\n\n"); // n_trace_init(&test,4096,4096); NailArena_init(&arena,4096); // inputsize *= 8; XYZZY *object; object = CAT(parse_,XYZZY)(&arena,input,inputsize); if(object){ printf("\n Successfully parsed! Trying to generate\n"); const char *buf; size_t siz; NailStream stream; NailOutStream_init(&stream,4096); if(CAT(gen_,XYZZY)(&arena,&stream,object)<0) { fprintf(stderr,"Could not generate\n"); exit(-1); } buf = NailOutStream_buffer(&stream,&siz); printf("Output:\n"); fwrite(buf,1,siz,stdout); printf("\nEnd of output;\n"); if(siz != inputsize) return -1; } else { fprintf(stderr, "Could not parse\n"); exit(-1); } return 0; }
SDLeftStat_t * ADDSUFFIX(dleft_stat) (SDLeftArray_t * const dleftobj, FILE *stream) { fprintf(stderr,"[!]Count with[%s]\n",CAT(THETYPE)); SDLeftStat_t *pSDLeftStat = malloc(sizeof(SDLeftStat_t)); THETYPE * const pCountHistArray = calloc(sizeof(THETYPE),1+dleftobj->maxCountSeen); size_t totalDLAsize = dleftobj->SubItemCount * dleftobj->itemByte * dleftobj->ArraySize; //size_t firstlevelDLAitemsize = SDLA_ITEMARRAY*dleftobj->itemByte; const unsigned char * const pDLA = dleftobj->pDLA; THETYPE Item_CountBits=0; // set value in case SDLA_ITEMARRAY*dleftobj->itemByte == 0 (EP ?) uint128_t theItem; for (size_t i=0;i<totalDLAsize;i+=dleftobj->itemByte) { //const unsigned char * pChunk = pDLA + i; theItem = 0; for (uint_fast8_t j=0;j<dleftobj->itemByte;j++) { theItem |= ((uint128_t)*(pDLA + i + j)) << (j*8u); } Item_CountBits = theItem & dleftobj->Item_CountBitMask; ++pCountHistArray[Item_CountBits]; //++HistSum; } //THETYPE HistSum=0; // HistSum == dleftobj->ItemInsideAll DILTYPE HistSumSquared=0; double SStd; // We need to return in a fixed type for printf for (size_t p=1;p<=dleftobj->maxCountSeen;p++) { //HistSum += pCountHistArray[p]; HistSumSquared += pCountHistArray[p] * pCountHistArray[p]; } //http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance SStd = sqrtl( ( (long double)HistSumSquared-((long double)dleftobj->ItemInsideAll*(long double)dleftobj->ItemInsideAll/(long double)dleftobj->maxCountSeen) ) / (long double)(dleftobj->maxCountSeen -1) ); pSDLeftStat->HistSStd = SStd; pSDLeftStat->HistMean = (double)dleftobj->ItemInsideAll / (double)dleftobj->maxCountSeen; pSDLeftStat->HistMaxCntVal = 1; //later pSDLeftStat->HistMaxHistVal = 1; //later fprintf(stream,"#Kmer_real_count: %ld\n#Kmer_count_hist: %ld\n#Kmer_depth_mean: %f\n#Kmer_depth_sStd: %f\n\n#Kmer_frequence\tHist_value\tKmer_count\tHist_ratio\n", dleftobj->ItemInsideAll,dleftobj->maxCountSeen,pSDLeftStat->HistMean,SStd); for (size_t p=1;p<=dleftobj->maxCountSeen;p++) { fprintf(stream,"%zu\t%lu\t%lu\t%g\n",p,(uint64_t)pCountHistArray[p], (uint64_t)pCountHistArray[p]*(uint64_t)p,(double)pCountHistArray[p]/(double)dleftobj->ItemInsideAll); } free(pCountHistArray); // deal(*pextree); return pSDLeftStat; }
static int printGroupBody(D4printer* out, NCD4node* node, int depth) { int ret = NC_NOERR; int i,ngroups,nvars,ntypes,ndims,nattrs; ngroups = nclistlength(node->groups); nvars = nclistlength(node->vars); ntypes = nclistlength(node->types); ndims = nclistlength(node->dims); nattrs = nclistlength(node->attributes); if(ndims > 0) { INDENT(depth); CAT("<Dimensions>\n"); depth++; for(i=0;i<nclistlength(node->dims);i++) { NCD4node* dim = (NCD4node*)nclistget(node->dims,i); printNode(out,dim,depth); CAT("\n"); } depth--; INDENT(depth); CAT("</Dimensions>\n"); } if(ntypes > 0) { INDENT(depth); CAT("<Types>\n"); depth++; for(i=0;i<nclistlength(node->types);i++) { NCD4node* type = (NCD4node*)nclistget(node->types,i); if(type->subsort <= NC_MAX_ATOMIC_TYPE) continue; printNode(out,type,depth); CAT("\n"); } depth--; INDENT(depth); CAT("</Types>\n"); } if(nvars > 0) { INDENT(depth); CAT("<Variables>\n"); depth++; for(i=0;i<nclistlength(node->vars);i++) { NCD4node* var = (NCD4node*)nclistget(node->vars,i); printNode(out,var,depth); } depth--; INDENT(depth); CAT("</Variables>\n"); } if(nattrs > 0) { for(i=0;i<nclistlength(node->attributes);i++) { NCD4node* attr = (NCD4node*)nclistget(node->attributes,i); printAttribute(out,attr,depth); CAT("\n"); } } if(ngroups > 0) { INDENT(depth); CAT("<Groups>\n"); depth++; for(i=0;i<nclistlength(node->groups);i++) { NCD4node* g = (NCD4node*)nclistget(node->groups,i); printNode(out,g,depth); CAT("\n"); } depth--; INDENT(depth); CAT("</Groups>\n"); } return THROW(ret); }
static int printNode(D4printer* out, NCD4node* node, int depth) { int ret = NC_NOERR; int i; char* fqn = NULL; switch (node->sort) { case NCD4_GROUP: if(node->group.isdataset) printDataset(out,node,depth); else printGroup(out,node,depth); break; case NCD4_DIM: INDENT(depth); CAT("<Dimension"); if(node->name != NULL) printXMLAttributeName(out, "name", node->name); printXMLAttributeSize(out, "size", node->dim.size); if(node->dim.isunlimited) printXMLAttributeString(out, UCARTAGUNLIM, "1"); CAT("/>"); break; case NCD4_TYPE: switch (node->subsort) { default: break; case NC_OPAQUE: INDENT(depth); CAT("<Opaque"); ncbytesclear(out->tmp); printXMLAttributeName(out, "name", node->name); if(node->opaque.size > 0) printXMLAttributeSize(out, "size", node->opaque.size); CAT("/>"); break; case NC_ENUM: INDENT(depth); CAT("<Enumeration"); printXMLAttributeName(out, "name", node->name); if(node->basetype->subsort <= NC_MAX_ATOMIC_TYPE) printXMLAttributeName(out, "basetype", node->basetype->name); else { char* fqn = NULL; printXMLAttributeName(out, "basetype", (fqn = NCD4_makeFQN(node->basetype))); nullfree(fqn); } CAT(">\n"); depth++; for(i=0;i<nclistlength(node->en.econsts);i++) { NCD4node* ec = (NCD4node*)nclistget(node->en.econsts,i); INDENT(depth); CAT("<EnumConst"); printXMLAttributeName(out, "name", ec->name); printXMLAttributeAtomics(out, "value", &ec->en.ecvalue, node->basetype->subsort); CAT("/>\n"); } depth--; INDENT(depth); CAT("</Enumeration>"); break; case NC_STRUCT: INDENT(depth); CAT("<Structure"); printXMLAttributeName(out, "name", node->name); CAT(">\n"); depth++; for(i=0;i<nclistlength(node->vars);i++) { NCD4node* field = (NCD4node*)nclistget(node->vars,i); printVariable(out,field,depth); CAT("\n"); } if((ret=printMetaData(out,node,depth))) goto done; depth--; INDENT(depth); CAT("</Structure>"); break; case NC_SEQ: INDENT(depth); CAT("<Vlen"); printXMLAttributeName(out, "name", node->name); printXMLAttributeName(out, "type", (fqn=NCD4_makeFQN(node->basetype))); if(hasMetaData(node)) { CAT(">\n"); depth++; if((ret=printMetaData(out,node,depth))) goto done; depth--; INDENT(depth); CAT("</Vlen>"); } else CAT("/>"); break; } break; case NCD4_VAR: /* Only top-level vars are printed here */ if(ISTOPLEVEL(node)) { if((ret=printVariable(out,node,depth))) goto done; CAT("\n"); } break; default: abort(); break; } done: nullfree(fqn); return THROW(ret); }
http://www.boost.org/ Copyright (c) 2001-2006 Hartmut Kaiser. Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) =============================================================================*/ //O --variadics // Tests macro expansion order in conjunction with the need to skip expansion // of the same macro as it is currently expanded. #define CONCAT(a, b) a ## b #define CONCAT_INDIRECT() CONCAT //R #line 20 "t_1_004.cpp" //R CONCAT(1, 2) CONCAT(CON, CAT)(1, 2) //R #line 23 "t_1_004.cpp" //R CONCAT(1, 2) CONCAT(CON, CAT(1, 2)) //R #line 26 "t_1_004.cpp" //R 12 CONCAT(CONCAT_, INDIRECT)()(1, 2) //R #line 29 "t_1_004.cpp" //R CONCAT(1, 2) CONCAT(CONCAT_, INDIRECT())(1, 2) //R #line 32 "t_1_004.cpp" //R 1 CONCAT(2, 3) CONCAT(1, CONCAT(2, 3))
void timer_print(){ printf("---\n"); printf("TOTAL : %6.2f s \n", timer_read(TOTAL)); printf("---\n"); #define CAT(c_) timer_read(c_), timer_read(c_)/timer_read(TOTAL)*100 #ifdef _BLOCKING printf("LU : %6.2f s (%4.2f%%)\n", CAT(LU)); printf(" - PANEL : %6.2f s (%4.2f%%)\n", CAT(PANEL)); printf(" - PIVOT : %6.2f s (%4.2f%%)\n", CAT(PANEL_PIVOT)); printf(" - SWAP : %6.2f s (%4.2f%%)\n", CAT(PANEL_SWAP)); printf(" - DSCAL : %6.2f s (%4.2f%%)\n", CAT(PANEL_DSCAL)); printf(" - DGER : %6.2f s (%4.2f%%)\n", CAT(PANEL_DGER)); printf(" - DTRSM : %6.2f s (%4.2f%%)\n", CAT(PANEL_DTRSM)); printf(" - DGEMM : %6.2f s (%4.2f%%)\n", CAT(PANEL_DGEMM)); printf(" - SWAP : %6.2f s (%4.2f%%)\n", CAT(SWAP)); printf(" - DTRSM : %6.2f s (%4.2f%%)\n", CAT(DTRSM)); printf(" - DGEMM : %6.2f s (%4.2f%%)\n", CAT(DGEMM)); printf("DSOLVE : %6.2f s (%4.2f%%)\n", CAT(DSOLVE)); #else printf("LU : %6.2f s (%4.2f%%)\n", CAT(LU)); printf(" - PIVOT : %6.2f s (%4.2f%%)\n", CAT(PANEL_PIVOT)); printf(" - SWAP : %6.2f s (%4.2f%%)\n", CAT(SWAP)); printf(" - PANEL : %6.2f s (%4.2f%%)\n", CAT(PANEL)); printf(" - UPDATE : %6.2f s (%4.2f%%)\n", CAT(PANEL_DGER)); printf("DSOLVE : %6.2f s (%4.2f%%)\n", CAT(DSOLVE)); #endif printf("---\n"); fflush(stdout); }
int main(void) { /* # Comments are replaced by spaces. */ { int/* */a = 1; assert(a == 1); } /* # Newline in macro # Multiline macro Impossible: - http://stackoverflow.com/questions/10419530/multi-line-preprocessor-macros - http://stackoverflow.com/questions/98944/how-to-generate-a-newline-in-a-cpp-macro */ /* # #define You can put preprocessor directives anywhere but putting on global scope is the more standard and simple approach Use defines with discretion: they make it much harder to debug! */ { /* Syntax: the line must start with `#`, but there can be spaces after it to give indentation. */ { #define SPACE_AFTER_HASH 1 assert(SPACE_AFTER_HASH == 1); } /* # Constants Use sparingly. - constants have scope - produce meaningful error messages */ { { #define CTE 1 assert(CTE == 1); } /* Don't forget to protect arithmetic operations or associativity may get you. */ { /* Use parenthesis or order of operation might destroy you: */ #define PROTECT_FAIL 1 + 1 assert(PROTECT_FAIL * 2 == 3); #define PROTECT (1 + 1) assert(PROTECT * 2 == 4); } /* Expansion is lazy: macros do not expand in `#define` but only when the macro is used. */ { #define LAZY0 LAZY1 #define LAZY1 LAZY2 #define LAZY2 2 assert(LAZY2 == 2); } } /* # Redefine macros */ { /* Cannot redefine macros directly. */ { #define REDEFINE_FAIL 1 /* ERROR */ /*#define REDEFINE_FAIL 2*/ } /* Must first undef. */ { #define REDEFINE 1 #undef REDEFINE #define REDEFINE 2 assert(REDEFINE == 2); } } /* # Functions (preprocessor) */ { /* Generates: assert(1 + 1 == 2); Not: assert(2 == 2); */ { #define SUM(x, y) x + y assert(SUM(1, 1) == 2); } /* # Comma protection The macro engine has to do some kind of parsing to determine that the comma of the function (1) is not the comma of the macro (2). What it seems to do is simply check if the comma is between pairs of: - parenthesis - double quotes and if yes ignore it. This does not however cover C++ template parameters, and `assert` + template is a common break case http://stackoverflow.com/questions/4496842/pass-method-with-template-arguments-to-a-macro Pure C also has cases in which it is necessary to use parenthesis, for example when the comma operator is used. A more complicated case in which protecting parenthesis break: http://stackoverflow.com/questions/9187614/how-do-i-have-a-comma-inside-braces-inside-a-macro-argument-when-parentheses-cau */ { assert(SUM(int_int_int_func(1, 1), 1) == 3); /* ^ ^ */ /* 1 2 */ int i = 1; assert(SUM((i++, i), 1) == 3); /* ^ */ /* comma operator */ /* ERROR must protect the comma operator. */ /*assert(SUM(i++, i, 1) == 3);*/ #define CAT(x, y) x y /* Strings are treated as a single token, so commas inside strings are fine. */ assert(strcmp(CAT("1,", "2"), "1,2") == 0); } /* # Function inside argument - http://stackoverflow.com/questions/163365/how-do-i-make-a-c-macro-behave-like-a-function - http://stackoverflow.com/questions/154136/do-while-and-if-else-statements-in-c-c-macros */ { /* TODO */ } /* # Argument inside string # # */ { /* Strings are treated as single tokens, so arguments don't expand by default. */ #define ARG_IN_STRING_BAD(x) "x" assert(strcmp(ARG_IN_STRING_BAD("a"), "x") == 0); /* Solution: use # stringification. It simply adds "" around the argument and expands it. */ #define STRINGIFY(x) #x assert(strcmp(STRINGIFY(a), "a") == 0); assert(strcmp(STRINGIFY(""), "\"\"") == 0); /* ERROR: parsing fails because of unbalanced `"`. */ /*assert(strcmp(STRINGIFY("), "\"") == 0);*/ #define STRINGIFY_CAT(x) "a" STRINGIFY(x) "c" assert(strcmp(STRINGIFY_CAT(b), "abc") == 0); /* This fails however for macro arguments, which don't expand when `# arg` is used! Solution Use a two step expansion process... - http://stackoverflow.com/questions/8283596/whats-the-difference-between-these-two-macros?lq=1 - http://stackoverflow.com/questions/6742501/whats-the-exact-step-of-macro-expanding TODO what is the rationale for that exception of not expanding upon `#`? */ #define STRINGIFY_ARG a assert(strcmp(STRINGIFY(STRINGIFY_ARG), "STRINGIFY_ARG") == 0); } /* # variadic macro functions */ { char s[4]; #define SPRINTF(string, format, ...) sprintf(string, format, __VA_ARGS__) SPRINTF(s, "%c%c", 'a', 'b'); assert(strcmp(s, "ab") == 0); } #if __STDC_VERSION__ >= 199901L /* # Empty macro arguments http://stackoverflow.com/questions/7666344/are-empty-macro-arguments-legal-in-c11 */ { #define EMPTY(x) x ## 2 == assert(EMPTY(1) 12); /* TODO if the argument is empty, does it still count for concatenation? */ assert(EMPTY() 2); } #endif } /* # #include It is possible, and very confusing, to include any type of file, not just header files. */ { int i = 0; #include "preprocessor.inc" assert(i == 1); } } /* # #undef Undo a previous define. */ { #define UNDEF_TEST 1 #undef UNDEF_TEST #ifdef UNDEF_TEST # error #endif } /* # Concatenate # Double hash preprocessor operator # ## `##` allows to concatenate a preprocessor function arguments without spaces between them. */ { /* Basic. */ { #define CAT_NO_SPACE(x) x ## d int CAT_NO_SPACE(c_) = 1; assert(c_d == 1); } /* Multiple concatenation insanity: http://stackoverflow.com/questions/1489932/c-preprocessor-and-concatenation */ { { #define CAT_FAIL_VAR 0 #define CAT_FAIL x ## CAT_FAIL_VAR int CAT_FAIL = 1; assert(xCAT_FAIL_VAR == 1); } /* Solution. */ { #define CAT_VAR 0 #define PASTER(x,y) x ## y #define EVALUATOR(x,y) PASTER(x,y) #define CAT_OK EVALUATOR(x, CAT_VAR) int CAT_OK = 1; assert(x0 == 1); } } } /* # #ifdef Check if preprocessor variable is defined. # or and ifdef http://stackoverflow.com/questions/965700/c-preprocessor-testing-definedness-of-multiple-macros Almost the same as `#if defined()`, except you can use `#if defined()` with `|| on a single line as: #if defined(X) || defined(Y) while #ifdef(X) || ifdef(Y) #ifdef X || Y compiles but does not do what you expect: TODO legal? For `&&`, we could get away with: #ifdef(X) #ifdef(Y) but there is no alternative for `||`. # #ifndef Negation of ifdef. # #defined Like ifdef, but more flexible as you can use it inside `#if` with boolean operators. */ { #ifdef COMMANDLINE /* gcc -DCOMMANDLINE c.c */ puts("C"); #else /* gcc c.c */ puts("no C"); #endif } /* # #if # #else # #elif The preprocessor can do certain integer arithmetic operations such as: +, -, ==, <. */ { #if 1 == 0 # error #elif 1 == 1 #else # error #endif #define INIF 1 #if INIF + 1 == 2 #else # error #endif #if 16 == 0x10 #else # error #endif /* Undefined evaluate equal. */ { #if NOT_DEFINED == NOT_DEFINED2 #else # error #endif } /* Cannot compare strings directly! http://stackoverflow.com/questions/2335888/how-to-compare-string-in-c-conditional-preprocessor-directives Always define to integers. */ #define STR1 1 #define STR2 2 #define STR STR1 #if STR == STR1 #elif STR == STR2 # error #endif } /* # && preprocessor # and preprocessor */ #define C 1 #if defined(C) && C > 0 #else # error #endif /* # #error Print an error message to stderr and stop compilation. Useful to enforce preprocessor conditions. */ { /* #error "the error message" */ } /* # null directive A `#` followed by newline is ignored. */ { # } /* # #pragma C99 specifies that: # pragma X Y Z ... - if `X != STDC`, does something implementation defined, and therefore not portable. Examples: `#pragma once` - else, then the statement must take a form: # pragma STDC FP_CONTRACT on-off-switch # pragma STDC FENV_ACCESS on-off-switch # pragma STDC CX_LIMITED_RANGE on-off-switch all of which are portable. */ /* # #line Set the line and optionally filename that is seen by `__FILE__` and `__LINE__`. */ { /*#line 1*/ } /* # Predefined preprocessor macros # Standard preprocessor defines Some preprocessor vars are automatically defined by certain compilers although they are not c standards. Those are not discussed here. List of standard defines: http://gcc.gnu.org/onlinedocs/cpp/Standard-Predefined-Macros.html List all them on GCC: gcc -dM -E - < /dev/null | sort Sample output: #define _LP64 1 #define _STDC_PREDEF_H 1 #define __ATOMIC_ACQUIRE 2 #define __ATOMIC_ACQ_REL 4 #define __ATOMIC_CONSUME 1 #define __ATOMIC_HLE_ACQUIRE 65536 #define __ATOMIC_HLE_RELEASE 131072 #define __ATOMIC_RELAXED 0 #define __ATOMIC_RELEASE 3 #define __ATOMIC_SEQ_CST 5 */ { /* # STDC_VERSION # __STDC_VERSION__ String representing version of the c std lib. Format: yyyymm (base 10). Some values: - C11: 201112L - C99: 199901L http://sourceforge.net/p/predef/wiki/Standards/ Apperas undefined in C99 */ { printf("__STDC_VERSION__ = %li\n", __STDC_VERSION__); } /* # __STDC__ # STDC 1 if the implementation is conforming, 0 otherwise. TODO check: on GCC, 1 with `-std=cXX`, 0 with `-std=gnuXX`. */ { printf("__STDC__ = %d\n", __STDC__); } /* # __STDC_HOSTED__ # STDC Indicate if the compilation is hosted or not. # Hosted # Freestanding Concept defined in ANSI C. Basically, a freestanding implementation does not need to provide an stdlib. In GCC, controlled by the `-ffreestainding` option. */ { printf("__STDC_HOSTED__ = %d\n", __STDC_HOSTED__); } /* # __cplusplus Defined only if using C++ compiler. C99 says that C must not define it. */ #ifdef __cplusplus printf("__cplusplus\n"); #endif /* # __FILE__ Absolute or relative path of current file. */ { printf("__FILE__ = %s\n", __FILE__); } /* # __LINE__ Current source code line. Useful for debugging. If in a `.h`, position inside the `.h` before inclusion. */ { printf("__LINE__ = %d\n", __LINE__); } printf("__DATE__ = %s\n", __DATE__); printf("__TIME__ = %s\n", __TIME__); #ifdef __WIN32__ /* Automatically defined by certain compilers on windows: */ /* TODO gcc specific or not? if yes move out of here. */ puts("__WIN32__"); #endif #ifdef _LIBC /* TODO what is this */ /* TODO gcc specific or not? if yes move out of here. */ puts("_LIBC"); #endif #ifdef __ILP32__ /* TODO what is this */ /* TODO gcc specific or not? if yes move out of here. */ puts("__ILP32__"); #endif #ifdef ___X32_SYSCALL_BIT /* TODO what is this */ /* TODO gcc specific or not? if yes move out of here. */ puts("___X32_SYSCALL_BIT"); #endif /* # IEEE-754 IEC 60559 has the same contents as the IEEE 754-2008, Outside of the C standard it is commonly known by the IEEE name, or simply as IEEE floating point. IEEE dates from 1985. # __STDC_IEC_559__ # IEC 60599 Standard on which floating point formats and operations should be available on an implementation, and how they should work. Good overview wiki article: <http://en.wikipedia.org/wiki/IEEE_floating_point> Many CUPs implement large parts of IEC 60599, which C implementations can use if available. The C standard specifies that implementing the IEC 60599 is not mandatory. If the macro `__STDC_IEC_559__` is defined this means that the implementation is compliant to the interface specified in Annex F of the C11 standard. C99 introduced many features which allow greater conformance to IEC 60599. */ { #ifdef __STDC_IEC_559__ puts("__STDC_IEC_559__"); /* I think it guaranteed by the standard on annex F: - The float type matches the IEC 60559 single format. - The double type matches the IEC 60559 double format. - The long double type matches an IEC 60559 extended format,307) else a non-IEC 60559 extended format, else the IEC 60559 double format. */ assert(sizeof(float) == 4); assert(sizeof(double) == 8); #endif } /* # Expand macro to another macro Nope: http://stackoverflow.com/questions/1262063/preprocessor-macro-expansion-to-another-preprocessor-directive */ #ifndef __STDC_NO_ATOMICS__ /* Indicates no C11 support for `_Atomic` and `<stdatomic.h>`. */ puts("__STDC_NO_ATOMICS__"); #else #include <stdatomic.h> _Atomic int i; #endif } return EXIT_SUCCESS; }
elemptr symmodel::get_model_widx( const vector<string>& parsed, const vector<size_t>& idx, const vector<elemptr>& trace ) { //I start with it already parsed. //If parsed.size() == 0, I simply return this (with an index?) //The empty string indicates "this" model? No, when I parse it, I need to sep it, so an empty, will return in a zero-parse, of size zero, or nothing? //Either way, would result in same, so return ;) if( parsed.size() == 0 || parsed[0].compare("") == 0 ) { fprintf(stdout, "FOUND MODEL! [%s]\n", buildpath().c_str() ); elemptr t = elemptr( shared_from_this(), idx ); return t; } else { fprintf(stdout, "Model [%s], attempting to find model name [%s] widx (note, trace size is [%lu])\n", buildpath().c_str(), CAT(parsed, "/").c_str(), trace.size()); } //This is the next model I will go into string submodel = parsed[0]; vector<string> remainder( parsed.begin()+1, parsed.end() ); //same as remainder, remainder.erase(0); //REV: This is where I should iterate up the tree! This is the issue. vector<size_t> mlocs = find_model( submodel ); vector<size_t> hlocs = find_hole( submodel ); //At this point, we are finding the hole etc. normally. if( mlocs.size() >= 1 ) { if( mlocs.size() > 1 ) { fprintf(stderr, "WTF found more than one in getmodelwidx\n"); exit(1); } size_t mloc = mlocs[0]; //add model to trace? I guess? It is a submodel, so it is not necessary I guess? But it helps it find submodels I guess? Could this cause a problem? fprintf(stdout, "Model [%s], going through submodel [%s] to find [%s]\n", buildpath().c_str(), models[mloc]->localname.c_str(), CAT(remainder, "/").c_str() ); std::shared_ptr<symmodel> nextmodel = models[mloc]; //Don't add to trace because if same model, parent will cause infinite loop in combin with trace. //However //Problem is if I go through a hole, and the hole is the same model, that is the main problem vector<elemptr> newtrace = trace; //size_t idx_in_submodel = idx; //no change, b/c submodel. vector<size_t> idx_in_submodel = idx; //no change, b/c submodel. //newtrace.push_back( elemptr( shared_from_this(), idx ) ); return nextmodel->get_model_widx( remainder, idx_in_submodel, newtrace ); } else if( hlocs.size() >= 1 ) { if( hlocs.size() > 1) { fprintf(stderr, "WTF more than one HOLE found in getmodelwidx\n"); exit(1); } size_t hloc = hlocs[0]; fprintf(stdout, "Model [%s], going through hole [%s] to find [%s]\n", buildpath().c_str(), holes[hloc].name.c_str(), CAT(remainder, "/").c_str()); if( holes[ hloc ].members.size() != 1 ) { fprintf(stderr, "ERROR in get_model_widx, getting [%s] from HOLE, but hole [%s] has size [%lu], but it should be 1\n", submodel.c_str(), holes[hloc].name.c_str(), holes[hloc].members.size() ); exit(1); } //REV: so in the case it does not exist yet, we have a problem? std::shared_ptr<symmodel> nextmodel = holes[hloc].members[0]; if( check_same_toplevel_model( nextmodel ) ) { //Dont add to trace because its same model so infinite loop with going to parent.x vector<elemptr> newtrace = trace; //size_t idx_in_submodel = idx; //no change, b/c submodel. vector<size_t> idx_in_submodel = idx; //no change, b/c submodel. //newtrace.push_back( elemptr( shared_from_this(), idx ) ); return nextmodel->get_model_widx( remainder, idx_in_submodel, newtrace ); } else //not same toplevel model { //I NEED TO GO THROUGH A CORRESPONDENCE fprintf(stdout, "REV: about to go through a corresp to get a non-same model thing through a hole...\n"); //std::shared_ptr<corresp> mycorresp; auto mycorresp = getcorresp( nextmodel ); if( !mycorresp ) { fprintf(stderr, "REV: getcorresp in get_model_widx, failed, no such corresp exists between [%s] and [%s]\n", buildpath().c_str(), nextmodel->buildpath().c_str()); exit(1); } //REV; SANITY, if corresp not allocated yet, just return 0. //size_t idx_in_submodel = 0; vector<size_t> idx_in_submodel(1,0); //REV; Don't check this here, check this in the corresp struct? I.e. return dummy data if it is not existing yet (or exit?) if(mycorresp->isinit()) { fprintf(stdout, "Corresp is INIT!!!! Will attempt a GETALL...\n"); //REV: TODO HERE, just return it directly, with new IDX_IN_SUBMODEL ;0 //REV: this is it!!! This is where I vector<size_t> sanity = mycorresp->getall( idx ); fprintf(stdout, "Attempted to GETALL from the corresp!\n"); /*if( sanity.size() != 1 ) { fprintf(stderr, "SANITY check for corresp during access failed! Expected corresp for idx [%lu] of model [%s] to have only 1 corresponding element in model [%s], but it had [%lu]\n", idx, buildpath().c_str(), nextmodel->buildpath().c_str(), sanity.size() ); exit(1); } size_t idx_in_submodel = sanity[0]; //no change, b/c submodel. */ idx_in_submodel = sanity; } vector<elemptr> newtrace = trace; newtrace.push_back( elemptr( shared_from_this(), idx ) ); fprintf(stdout, "About to get next model with idx...\n"); auto toret = nextmodel->get_model_widx( remainder, idx_in_submodel, newtrace ); fprintf(stdout, "FINISHED About to get next model with idx...\n"); return toret; } } //end if not found in HOLES (or submodels) else { fprintf(stdout, "Model [%s], walking up to parent [%s] to find [%s]\n", buildpath().c_str(), parent->localname.c_str(), CAT(parsed, "/").c_str()); //Else, try to bubble up to ROOT. if( parent && (parent->parent) ) { std::shared_ptr<symmodel> nextmodel = parent; vector<elemptr> newtrace = trace; //size_t idx_in_submodel = idx; //no change, b/c submodel. vector<size_t> idx_in_submodel = idx; //no change, b/c submodel. //newtrace.push_back( elemptr( shared_from_this(), idx ) ); return nextmodel->get_model_widx( parsed, idx_in_submodel, newtrace ); } else if( parent && !(parent->parent) ) { //Couldn't find it! Return empty elemptr...bad. elemptr ep; return ep; } else { fprintf(stderr, "REV; this should never happen weird, Neither parent nor parent->parent? In searching for model with idx. Exit\n"); if( parent ) { fprintf( stderr, "Parent of me [%s] exists and is [%s]\n", buildpath().c_str(), parent->buildpath().c_str() ); } else { fprintf( stderr, "Parent does not exist... (note current model is [%s])!\n", buildpath().c_str() ); } exit(1); } } //couldn't find in "else" (i.e. not in this model, so try bubbling up parents) if(trace.size() == 0) { fprintf(stderr, "Trace size zero. This should never happen (should have been caught above)\n"); exit(1); } //REV: Did I mess something up? First it should check through all guys directly to see if it is same model? I.e. if target model matches b/c we can use that idx. fprintf(stdout, "Couldn't find model [%s] in previous model trace [%s], so moving to next! (trace size is [%lu])\n", CAT(parsed,"/").c_str(), buildpath().c_str(), trace.size() ); //Move back model and try again? vector<elemptr> newtrace = trace; //size_t idx_in_submodel = newtrace[ newtrace.size() - 1].idx; //end of trace. vector<size_t> idx_in_submodel = newtrace[ newtrace.size() - 1].idx; //end of trace. std::shared_ptr<symmodel> nextmodel = newtrace[ newtrace.size() - 1].model; newtrace.pop_back(); fprintf(stdout, "Will now try to run with new trace size [%lu]\n", newtrace.size() ); return nextmodel->get_model_widx( parsed, idx_in_submodel, newtrace ); } //end get_model_widx
static int printVariable(D4printer* out, NCD4node* var, int depth) { int ret = NC_NOERR; NCD4node* basetype = var->basetype; char* fqn = NULL; INDENT(depth); CAT("<"); switch (var->subsort) { default: CAT(basetype->name); printXMLAttributeName(out, "name", var->name); break; case NC_ENUM: CAT("Enum"); printXMLAttributeName(out, "name", var->name); printXMLAttributeName(out, "enum", (fqn=NCD4_makeFQN(basetype))); break; case NC_OPAQUE: CAT("Opaque"); printXMLAttributeName(out, "name", var->name); printXMLAttributeName(out, "type", (fqn=NCD4_makeFQN(basetype))); break; case NC_SEQ: CAT("Seq"); printXMLAttributeName(out, "name", var->name); printXMLAttributeName(out, "type", (fqn=NCD4_makeFQN(basetype))); break; case NC_STRUCT: CAT("Struct"); printXMLAttributeName(out, "name", var->name); printXMLAttributeName(out, "type", (fqn=NCD4_makeFQN(basetype))); break; } if(hasMetaData(var)) { CAT(">\n"); depth++; if((ret=printMetaData(out,var,depth))) goto done; depth--; INDENT(depth); CAT("</"); if(basetype->subsort == NC_ENUM) CAT("Enum"); else if(basetype->subsort == NC_OPAQUE) CAT("Opaque"); else if(basetype->subsort == NC_STRUCT) CAT("Struct"); else if(basetype->subsort == NC_SEQ) CAT("Sequence"); else CAT(basetype->name); CAT(">"); } else CAT("/>"); done: nullfree(fqn); return THROW(ret); }