attr.c#383 NC_attr **tmp;
#394 tmp = NC_findattr(ncapname);
#395 if(tmp == NULL)
#399 *attrpp = *tmp;
#494 NC_attr **tmp;
#516 tmp = NC_findattr(ncapname);
#517 if(tmp == NULL)
#519 attrp = *tmp;
atttests.c#77    static struct cdfatt tmp; /* attribute */
#118       &tmp.type, &tmp.len) == -1) {
#122 if (atts[ia].type != tmp.type || atts[ia].len != tmp.len) {
#128 tmp.val = emalloc(atts[ia].len * nctypelen(atts[ia].type));
#129 if (ncattget(cdfidNC_GLOBALatts[ia].nametmp.val) == -1) {
#133 if (val_cmp(tmp.typetmp.lentmp.valatts[ia].val) != 0) {
#138 free (tmp.val);
#162       &tmp.type, &tmp.len) == -1) {
#166 if (atts[ia].type != tmp.type || atts[ia].len != tmp.len) {
#172 tmp.val = emalloc(atts[ia].len * nctypelen(atts[ia].type));
#173 if (ncattget(cdfidww_idatts[ia].nametmp.val) == -1) {
#177 if (val_cmp(tmp.typetmp.lentmp.valatts[ia].val) != 0) {
#182 free (tmp.val);
#189    tmp.name = (char *) emalloc(MAX_NC_NAME);
#196 tmp.var = atts[ia].var;
#197 (void) strcpy (tmp.nameatts[ia-1].name);
#198 tmp.type = atts[ia].type;
#199 tmp.len = atts[ia].len;
#200 tmp.val = atts[ia].val;
#201 add_att(&testww_id, &tmp); /* keep in-memory netcdf updated */
#206       &tmp.type, &tmp.len) == -1) {
#210 if (atts[ia].type != tmp.type || atts[ia].len != tmp.len) {
#216 tmp.val = emalloc(atts[ia].len * nctypelen(atts[ia].type));
#217 if (ncattget(cdfidww_idatts[ia-1].nametmp.val) == -1) {
#221 if (val_cmp(tmp.typetmp.lentmp.valatts[ia].val) != 0) {
#226 free (tmp.val);
#276 tmp.var = atts[ia].var;
#277 (void) strcpy (tmp.nameatts[ia+1].name);
#278 tmp.type = atts[ia].type;
#279 tmp.len = atts[ia].len;
#280 tmp.val = atts[ia].val;
#281 add_att(&testww_id, &tmp); /* keep in-memory netcdf updated */
#285 if (ncattinq(cdfidww_idatts[ia+1].name, &tmp.type, &tmp.len)
#291 if (atts[ia].type != tmp.type || atts[ia].len != tmp.len) {
#297 tmp.val = emalloc(atts[ia].len * nctypelen(atts[ia].type));
#298 if (ncattget(cdfidww_idatts[ia+1].nametmp.val) == -1) {
#303 if (val_cmp(tmp.typetmp.lentmp.valatts[ia].val) != 0) {
#307 free (tmp.val);
#325    free(tmp.name);
#465    static struct cdfatt tmp; /* attribute */
#509       &tmp.type, &tmp.len) == -1) {
#513 if (tmp.type != test.atts[ia].type) {
#518 if (tmp.len != test.atts[ia].len) {
#523 tmp.val = emalloc(tmp.len * nctypelen(tmp.type));
#524 if (ncattget(cdfidtest.atts[ia].vartest.atts[ia].nametmp.val)
#530 if (val_cmp(tmp.typetmp.lentmp.valtest.atts[ia].val) != 0) {
#539     val_out(tmp.typetmp.lentmp.val);
#542 free (tmp.val);
#552       &tmp.type, &tmp.len) == -1) {
#557 if (tmp.type != test.atts[ia].type) {
#562 if (tmp.len != test.atts[ia].len) {
#568 tmp.val = emalloc(tmp.len * nctypelen(tmp.type));
#569 if (ncattget(cdfidtest.atts[ia].vartest.atts[ia].nametmp.val)
#575 if (val_cmp(tmp.typetmp.lentmp.valtest.atts[ia].val) != 0) {
#584     val_out(tmp.typetmp.lentmp.val);
#587 free (tmp.val);
#651    static struct cdfatt tmp;  /* attribute */
#729    if (ncattinq(cdfid2NC_GLOBALatt.name, &tmp.type, &tmp.len) == -1) {
#733    if (att.type != tmp.type || att.len != tmp.len) {
#738    tmp.val = emalloc(att.len * nctypelen(att.type));
#739    if (ncattget(cdfid2NC_GLOBALatt.nametmp.val) == -1) {
#743    if (val_cmp(tmp.typetmp.lentmp.valatt.val) != 0) {
#748    free (tmp.val);
#755    if (ncattinq(cdfid2tu2_idatt.name, &tmp.type, &tmp.len) == -1) {
#759    if (att.type != tmp.type || att.len != tmp.len) {
#764    tmp.val = emalloc(att.len * nctypelen(att.type));
#765    if (ncattget(cdfid2tu2_idatt.nametmp.val) == -1) {
#769    if (val_cmp(tmp.typetmp.lentmp.valatt.val) != 0) {
#774    free (tmp.val);
#798    if (ncattinq(cdfid2tu2_idatt2.name, &tmp.type, &tmp.len) == -1) {
#802    if (att2.type != tmp.type || att2.len != tmp.len) {
#807    tmp.val = emalloc(att2.len * nctypelen(att2.type));
#808    if (ncattget(cdfid2tu2_idatt2.nametmp.val) == -1) {
#812    if (val_cmp(tmp.typetmp.lentmp.valatt2.val) != 0) {
#817    free (tmp.val);
#827    if (ncattinq(cdfidtu_idatt2.name, &tmp.type, &tmp.len) == -1) {
#831    if (att2.type != tmp.type || att2.len != tmp.len) {
#836    tmp.val = emalloc(att2.len * nctypelen(att2.type));
#837    if (ncattget(cdfidtu_idatt2.nametmp.val) == -1) {
#841    if (val_cmp(tmp.typetmp.lentmp.valatt2.val) != 0) {
#846    free (tmp.val);
#917    struct cdfatt tmp; /* attributes */
#991    tmp.name = (char *) emalloc(MAX_NC_NAME);
#992    if (ncattname(cdfidNC_GLOBALtest.ngatts-1, tmp.name) == -1) {
#996    if (strcmp(att.nametmp.name) != 0) {
#998       pnametmp.nameatt.name);
#1076    free (tmp.name);
#1105    struct cdfatt tmp; /* attributes */
#1146    if (ncattinq(cdfidNC_GLOBALnewname, &tmp.type, &tmp.len) == -1) {
#1150    if (atty.type != tmp.type || atty.len != tmp.len) {
#1155    tmp.val = emalloc(atty.len * nctypelen(atty.type));
#1156    if (ncattget(cdfidNC_GLOBALnewnametmp.val) == -1) {
#1160    if (val_cmp(tmp.typetmp.lentmp.valatty.val) != 0) {
#1165    if (ncattinq(cdfidNC_GLOBALatty.name, &tmp.type, &tmp.len) != -1) {
#1203    if (ncattget(cdfidNC_GLOBAL, "plugh", tmp.val) == -1) {
#1207    if (val_cmp(tmp.typetmp.lentmp.valatty.val) != 0) {
#1212    free (tmp.val);
bytebuffer.c#162  char tmp[2];
#163  tmp[0]=elem;
#164  return bbInsertn(bb,index,tmp,1);
cache.c#428              char *tmp = ocfqn(var->ocnode);
#430                    tmp,(unsigned long)nelems);
#431              free(tmp);
cdf.c#184     char tmp[3*NC_MAX_NAME];
#186     snprintf(tmp,sizeof(tmp),"%s%s%s",map->container->ncbasename,
#190            map->ncbasename = nulldup(tmp);
constraints.c#530    NClisttmp = nclistnew(); /* misc. uses */
#571     nclistclear(tmp);
#572     collectnodepath((CDFnode*)p2->var->annotation,tmp,WITHDATASET);
#573     for(k=0;k<nclistlength(tmp);k++) {
#574 void* candidate = (void*)nclistget(tmp,k);
#587 nclistclear(tmp);
#597 if(!nclistcontains(tmp,(void*)target))
#598                    nclistpush(tmp,(void*)target);
#602 if(nclistlength(tmp) == 0) break; /*done*/
#604        for(i=0;i<nclistlength(tmp);i++) {
#605            DCEprojectioncontainer = (DCEprojection*)nclistget(tmp,i);
#629    nclistfree(tmp);
cvt.c#18    Constvalue tmp;
#59    tmp.charv  = src->value.charv;
#62    tmp.int8v  = (unsigned char)src->value.charv;
#65    tmp.uint8v = (unsigned char)src->value.charv;
#68    tmp.uint16v = (unsigned short)src->value.charv;
#71    tmp.uint32v = (unsigned int)src->value.charv;
#74    tmp.uint64v  = (unsigned long long)src->value.charv;
#77    tmp.int16v = (short)src->value.charv;
#80    tmp.int32v = (int)src->value.charv;
#83    tmp.int64v  = (long long)src->value.charv;
#86    tmp.floatv = (float)src->value.charv;
#89    tmp.doublev = (double)src->value.charv;
#93    tmp.charv = (char)src->value.uint8v;
#96    tmp.uint8v = (unsigned char)src->value.uint8v;
#99    tmp.uint8v = (unsigned char)src->value.uint8v;
#102    tmp.uint16v = (unsigned short)src->value.uint8v;
#105    tmp.uint32v = (unsigned int)src->value.uint8v;
#108    tmp.uint64v  = (unsigned long long)src->value.uint8v;
#111    tmp.int16v = (short)src->value.uint8v;
#114    tmp.int32v = (int)src->value.uint8v;
#117    tmp.int64v  = (long long)src->value.uint8v;
#120    tmp.floatv = (float)src->value.uint8v;
#123    tmp.doublev = (double)src->value.uint8v;
#127    tmp.charv = (char)src->value.uint8v;
#130    tmp.uint8v = (unsigned char)src->value.uint8v;
#133    tmp.uint8v = (unsigned char)src->value.uint8v;
#136    tmp.uint16v = (unsigned short)src->value.uint8v;
#139    tmp.uint32v = (unsigned int)src->value.uint8v;
#142    tmp.uint64v  = (unsigned long long)src->value.uint8v;
#145    tmp.int16v = (short)src->value.uint8v;
#148    tmp.int32v = (int)src->value.uint8v;
#151    tmp.int64v  = (long long)src->value.uint8v;
#154    tmp.floatv = (float)src->value.uint8v;
#157    tmp.doublev = (double)src->value.uint8v;
#161    tmp.uint8v = (unsigned char)src->value.uint16v;
#164    tmp.uint8v = (unsigned char)src->value.uint16v;
#167    tmp.uint16v = (unsigned short)src->value.uint16v;
#170    tmp.uint32v = (unsigned int)src->value.uint16v;
#173    tmp.uint64v  = (unsigned long long)src->value.uint16v;
#176    tmp.int16v = (short)src->value.uint16v;
#179    tmp.int32v = (int)src->value.uint16v;
#182    tmp.int64v  = (long long)src->value.uint16v;
#185    tmp.floatv = (float)src->value.uint16v;
#188    tmp.doublev = (double)src->value.uint16v;
#192    tmp.uint8v = (unsigned char)src->value.uint32v;
#195    tmp.uint8v = (unsigned char)src->value.uint32v;
#198    tmp.uint16v = (unsigned short)src->value.uint32v;
#201    tmp.uint32v = (unsigned int)src->value.uint32v;
#204    tmp.uint64v  = (unsigned long long)src->value.uint32v;
#207    tmp.int16v = (short)src->value.uint32v;
#210    tmp.int32v = (int)src->value.uint32v;
#213    tmp.int64v  = (long long)src->value.uint32v;
#216    tmp.floatv = (float)src->value.uint32v;
#219    tmp.doublev = (double)src->value.uint32v;
#223    tmp.uint8v = (unsigned char)src->value.uint64v;
#226    tmp.uint8v = (unsigned char)src->value.uint64v;
#229    tmp.uint16v = (unsigned short)src->value.uint64v;
#232    tmp.uint32v = (unsigned int)src->value.uint64v;
#235    tmp.uint64v  = (unsigned long long)src->value.uint64v;
#238    tmp.int16v = (short)src->value.uint64v;
#241    tmp.int32v = (int)src->value.uint64v;
#244    tmp.int64v  = (long long)src->value.uint64v;
#247    tmp.floatv = (float)src->value.uint64v;
#250    tmp.doublev = (double)src->value.uint64v;
#254    tmp.uint8v = (unsigned char)src->value.int16v;
#257    tmp.uint8v = (unsigned char)src->value.int16v;
#260    tmp.uint16v = (unsigned short)src->value.int16v;
#263    tmp.uint32v = (unsigned int)src->value.int16v;
#266    tmp.uint64v  = (unsigned long long)src->value.int16v;
#269    tmp.int16v = (short)src->value.int16v;
#272    tmp.int32v = (int)src->value.int16v;
#275    tmp.int64v  = (long long)src->value.int16v;
#278    tmp.floatv = (float)src->value.int16v;
#281    tmp.doublev = (double)src->value.int16v;
#285    tmp.uint8v = (unsigned char)src->value.int32v;
#288    tmp.uint8v = (unsigned char)src->value.int32v;
#291    tmp.uint16v = (unsigned short)src->value.int32v;
#294    tmp.uint32v = (unsigned int)src->value.int32v;
#297    tmp.uint64v  = (unsigned long long)src->value.int32v;
#300    tmp.int16v = (short)src->value.int32v;
#303    tmp.int32v = (int)src->value.int32v;
#306    tmp.int64v  = (long long)src->value.int32v;
#309    tmp.floatv = (float)src->value.int32v;
#312    tmp.doublev = (double)src->value.int32v;
#316    tmp.uint8v = (unsigned char)src->value.int64v;
#319    tmp.uint8v = (unsigned char)src->value.int64v;
#322    tmp.uint16v = (unsigned short)src->value.int64v;
#325    tmp.uint32v = (unsigned int)src->value.int64v;
#328    tmp.uint64v  = (unsigned long long)src->value.int64v;
#331    tmp.int16v = (short)src->value.int64v;
#334    tmp.int32v = (int)src->value.int64v;
#337    tmp.int64v  = (long long)src->value.int64v;
#340    tmp.floatv = (float)src->value.int64v;
#343    tmp.doublev = (double)src->value.int64v;
#347    tmp.uint8v = (unsigned char)src->value.floatv;
#350    tmp.uint8v = (unsigned char)src->value.floatv;
#353    tmp.uint16v = (unsigned short)src->value.floatv;
#356    tmp.uint32v = (unsigned int)src->value.floatv;
#359    tmp.uint64v  = (unsigned long long)src->value.floatv;
#362    tmp.int16v = (short)src->value.floatv;
#365    tmp.int32v = (int)src->value.floatv;
#368    tmp.int64v  = (long long)src->value.floatv;
#371    tmp.floatv = src->value.floatv;
#374    tmp.doublev = (isnan(src->value.floatv)?NAN:(double)src->value.floatv);
#377    tmp.uint8v = (unsigned char)src->value.doublev;
#380    tmp.uint8v = (unsigned char)src->value.doublev;
#383    tmp.uint16v = (unsigned short)src->value.doublev;
#386    tmp.uint32v = (unsigned int)src->value.doublev;
#389    tmp.uint64v  = (unsigned long long)src->value.doublev;
#392    tmp.int16v = (short)src->value.doublev;
#395    tmp.int32v = (int)src->value.doublev;
#398    tmp.int64v  = (long long)src->value.doublev;
#401    tmp.floatv = (isnan(src->value.doublev)?NANF:(float)src->value.doublev);
#404    tmp.doublev = (double)src->value.doublev;
#409    sscanf(src->value.stringv.stringv,"%hhd",&tmp.int8v); break;
#411    sscanf(src->value.stringv.stringv,"%hhu",&tmp.uint8v); break;
#413    sscanf(src->value.stringv.stringv,"%hu",&tmp.uint16v); break;
#415    sscanf(src->value.stringv.stringv,"%u",&tmp.uint32v); break;
#417    sscanf(src->value.stringv.stringv,"%llu",&tmp.uint64v); break;
#419    sscanf(src->value.stringv.stringv,"%hd",&tmp.int16v); break;
#421    sscanf(src->value.stringv.stringv,"%d",&tmp.int32v); break;
#423    sscanf(src->value.stringv.stringv,"%lld",&tmp.int64v); break;
#425    sscanf(src->value.stringv.stringv,"%g",&tmp.floatv); break;
#427    sscanf(src->value.stringv.stringv,"%lg",&tmp.doublev); break;
#429     tmp.charv = src->value.stringv.stringv[0];
#433    tmp.stringv.len = src->value.stringv.len;
#434    tmp.stringv.stringv = (char*)malloc(src->value.stringv.len+1);
#435    memcpy((void*)tmp.stringv.stringv,
#437           tmp.stringv.len);
#438    tmp.stringv.stringv[tmp.stringv.len] = '\0';
#444    tmp.stringv.len = nulllen(stmp);
#445    tmp.stringv.stringv = nulldup(stmp);
#449    tmp.stringv.len = nulllen(stmp);
#450    tmp.stringv.stringv = nulldup(stmp);
#454    tmp.stringv.len = nulllen(stmp);
#455    tmp.stringv.stringv = nulldup(stmp);
#459    tmp.stringv.len = nulllen(stmp);
#460    tmp.stringv.stringv = nulldup(stmp);
#464    tmp.stringv.len = nulllen(stmp);
#465    tmp.stringv.stringv = nulldup(stmp);
#469    tmp.stringv.len = nulllen(stmp);
#470    tmp.stringv.stringv = nulldup(stmp);
#474    tmp.stringv.len = nulllen(stmp);
#475    tmp.stringv.stringv = nulldup(stmp);
#479    tmp.stringv.len = nulllen(stmp);
#480    tmp.stringv.stringv = nulldup(stmp);
#484    tmp.stringv.len = nulllen(stmp);
#485    tmp.stringv.stringv = nulldup(stmp);
#489    tmp.stringv.len = nulllen(stmp);
#490    tmp.stringv.stringv = nulldup(stmp);
#494    tmp.stringv.len = nulllen(stmp);
#495    tmp.stringv.stringv = nulldup(stmp);
#500    tmp.charv = *(char*)bytes;
#504    tmp.uint8v = *(unsigned char*)bytes;
#508    tmp.uint8v = *(unsigned char*)bytes;
#512    tmp.uint16v = *(unsigned short*)bytes;
#516    tmp.uint32v = *(unsigned int*)bytes;
#520    tmp.uint64v  = *(unsigned long long*)bytes;
#524    tmp.int16v = *(short*)bytes;
#528    tmp.int32v = *(int*)bytes;
#532    tmp.int64v  = *(long long*)bytes;
#536    tmp.floatv = *(float*)bytes;
#540    tmp.doublev = *(double*)bytes;
#543    tmp.opaquev.stringv = (char*)malloc(src->value.opaquev.len+1);
#544    memcpy(tmp.opaquev.stringv,src->value.opaquev.stringv,src->value.opaquev.len);
#545    tmp.opaquev.len = src->value.opaquev.len;
#546    tmp.opaquev.stringv[tmp.opaquev.len] = '\0';
#551    tmp.stringv.len = 0;
#552    tmp.stringv.stringv = NULL;
#567    dst->value = tmp;
dapalign.c#82    struct {char f1TYPE x;} tmp; \
#84    DST.alignment = (size_t)((char*)(&(tmp.x)) - (char*)(&tmp));}
#182    struct {TYPE1 f1TYPE x;} tmp; \
#184    DST.alignment = (size_t)((char*)(&(tmp.x)) - (char*)(&tmp));}
#187    struct {TYPE1 f1TYPE2 f2TYPE x;} tmp;   \
#189    DST.alignment = (size_t)((char*)(&(tmp.x)) - (char*)(&tmp));}
#192    struct {TYPE1 cTYPE2 x;} tmp; \
#193    DST = sizeof(tmp); }
dapcvt.c#213 char tmp[128];
dapdump.c#202    char* tmp;
#205    tmp = dcelisttostring(projections,",");
#207    return tmp;
#213    char* tmp;
#216    tmp = dcetostring((DCEnode*)proj);
#218    return tmp;
#236    char* tmp;
#239    tmp = dcetostring((DCEnode*)con);
#241    return tmp;
#357     char tmp[64];
#363     snprintf(tmp,sizeof(tmp),"%lu",(unsigned long)dim->dim.declsize);
#364     ncbytescat(buf,tmp);
#402    char tmp[1024];
#428    snprintf(tmp,sizeof(tmp),"%s %s {\n",
#430    ncbytescat(buf,tmp);
#431    snprintf(tmp,sizeof(tmp),"ocnode=%lx\n",(unsigned long)node->ocnode);
#432    ncbytescat(buf,tmp);
#433    snprintf(tmp,sizeof(tmp),"container=%s\n",
#435    ncbytescat(buf,tmp);
#436    snprintf(tmp,sizeof(tmp),"root=%s\n",
#438    ncbytescat(buf,tmp);
#439    snprintf(tmp,sizeof(tmp),"ncbasename=%s\n",node->ncbasename);
#440    ncbytescat(buf,tmp);
#441    snprintf(tmp,sizeof(tmp),"ncfullname=%s\n",node->ncfullname);
#442    ncbytescat(buf,tmp);
#443    snprintf(tmp,sizeof(tmp),"|subnodes|=%ld\n",nclistlength(node->subnodes));
#444    ncbytescat(buf,tmp);
#445    snprintf(tmp,sizeof(tmp),"externaltype=%d\n",node->externaltype);
#446    ncbytescat(buf,tmp);
#447    snprintf(tmp,sizeof(tmp),"ncid=%d\n",node->ncid);
#448    ncbytescat(buf,tmp);
#449    snprintf(tmp,sizeof(tmp),"maxstringlength=%ld\n",node->maxstringlength);
#450    ncbytescat(buf,tmp);
#451    snprintf(tmp,sizeof(tmp),"sequencelimit=%ld\n",node->sequencelimit);
#452    ncbytescat(buf,tmp);
#453    snprintf(tmp,sizeof(tmp),"usesequence=%d\n",node->usesequence);
#454    ncbytescat(buf,tmp);
#455    snprintf(tmp,sizeof(tmp),"elided=%d\n",node->elided);
#456    ncbytescat(buf,tmp);
#457    snprintf(tmp,sizeof(tmp),"invisible=%d\n",node->invisible);
#458    ncbytescat(buf,tmp);
#459    snprintf(tmp,sizeof(tmp),"attachment=%s\n",
#461    ncbytescat(buf,tmp);
#462    snprintf(tmp,sizeof(tmp),"rank=%lu\n",nclistlength(node->array.dimset0));
#463    ncbytescat(buf,tmp);
#466        snprintf(tmp,sizeof(tmp),"dims[%d]={\n",i);
#467        ncbytescat(buf,tmp);
#468 snprintf(tmp,sizeof(tmp),"    ocname=%s\n",dim->ocname);
#469        ncbytescat(buf,tmp);
#470 snprintf(tmp,sizeof(tmp),"    ncbasename=%s\n",dim->ncbasename);
#471        ncbytescat(buf,tmp);
#472 snprintf(tmp,sizeof(tmp),"    dimflags=%u\n",
#474        ncbytescat(buf,tmp);
#475 snprintf(tmp,sizeof(tmp),"    declsize=%lu\n",
#477        ncbytescat(buf,tmp);
#478        snprintf(tmp,sizeof(tmp),"    }\n");
#479        ncbytescat(buf,tmp);
#491    char tmp[1024];
#495        snprintf(tmp,sizeof(tmp),"NCalignment{size=%lu alignment=%lu offset=%lu}",
#497        result = nulldup(tmp);
#506    char tmp[8192];
#513    snprintf(tmp,sizeof(tmp),"cachenode%s(%lx){size=%lu; constraint=%s; vars=",
#518    ncbytescat(buf,tmp);
#536    char tmp[8192];
#542    snprintf(tmp,sizeof(tmp),"cache{limit=%lu; size=%lu;\n",
#545    ncbytescat(buf,tmp);
#570    char tmp[8192];
#575        snprintf(tmp,sizeof(tmp),"[%lu]",
#578        snprintf(tmp,sizeof(tmp),"[%lu:%lu]",
#582       snprintf(tmp,sizeof(tmp),"[%lu:%lu:%lu]",
#587    strcat(buf,tmp);
#588    return strdup(tmp);
daplex.c#118    char* tmp;
#221     tmp = ocbytescontents(lexstate->yytext);
#222     if(strcmp(tmp,"Data")==0 && *p == ':') {
#239     if(strcasecmp(keywords[i],tmp)==0) {
dapodom.c#79    char tmp[64];
#84 sprintf(tmp,"[%lu/%lu:%lu:%lu]",
#89 strcat(line,tmp);
#135 size_t tmp;
#136 tmp = odom->index[i];
#137 tmp = tmp - odom->start[i];
#138 tmp = tmp / odom->stride[i];
#139 tmp = tmp * steps[i];
#140 offset += tmp;
dapparse.c#362flatten(char* s, char* tmp, size_t tlen)
#366    strncpy(tmp,s,tlen);
#367    tmp[tlen] = '\0';
#368    p = (q = tmp);
#378    return tmp;
#448    char* tmp = NULL;
#455    tmp = (char*)ocmalloc(len+1);
#456    flatten(state->lexstate->input,tmp,prefixlen);
#457    (void) fprintf(stderr,"context: %s",tmp);
#458    flatten(state->lexstate->next,tmp,suffixlen);
#459    (void) fprintf(stderr,"^%s\n",tmp);
#461    ocfree(tmp);
data.c#525    char tmp[128];
#555                snprintf(tmp,sizeof(tmp),"%hhu",
#558                snprintf(tmp,sizeof(tmp),"%hu",
#561                snprintf(tmp,sizeof(tmp),"%llu",
#564                snprintf(tmp,sizeof(tmp),"%lu",
#567                snprintf(tmp,sizeof(tmp),"%u",
#570 bbCat(buf,tmp);
#574                snprintf(tmp,sizeof(tmp),"%hhd",
#577                snprintf(tmp,sizeof(tmp),"%hd",
#580                snprintf(tmp,sizeof(tmp),"%lld",
#583                snprintf(tmp,sizeof(tmp),"%ld",
#586                snprintf(tmp,sizeof(tmp),"%d",
#589 bbCat(buf,tmp);
#593                snprintf(tmp,sizeof(tmp),"((double)%.16g)",
#596                snprintf(tmp,sizeof(tmp),"((float)%.8g)",
#599 bbCat(buf,tmp);
dceconstraints.c#605    char tmp[1024];
#616                snprintf(tmp,sizeof(tmp),"[%lu%s]",
#619                snprintf(tmp,sizeof(tmp),"[%lu:%lu%s]",
#624         snprintf(tmp,sizeof(tmp),"[%lu:%lu:%lu%s]",
#630            ncbytescat(buf,tmp);
#670            snprintf(tmp,sizeof(tmp),"%lld",value->intvalue);
#671            ncbytescat(buf,tmp);
#674            snprintf(tmp,sizeof(tmp),"%g",value->floatvalue);
#675            ncbytescat(buf,tmp);
#1047    char tmp[1024];
#1059     snprintf(tmp,sizeof(tmp),
#1067            ncbytescat(buf,tmp);
#1076        snprintf(tmp,sizeof(tmp)," rank=%lu",(unsigned long)rank);
#1077 ncbytescat(buf,tmp);
#1117            snprintf(tmp,sizeof(tmp),"%lld",value->intvalue);
#1118            ncbytescat(buf,tmp);
#1121            snprintf(tmp,sizeof(tmp),"%g",value->floatvalue);
#1122            ncbytescat(buf,tmp);
dump.c#81           char tmp[64];
#82         sprintf(tmp,"?%d? ",dp->nctype);
#83            bbCat(buf,tmp);
#93    char tmp[64];
#98 escapifychar(ci->value.charv,tmp,'\'');
#99 bbCat(buf,tmp);
#103 sprintf(tmp,"%hhd",ci->value.int8v);
#104 bbCat(buf,tmp);
#107 sprintf(tmp,"%hd",ci->value.int16v);
#108 bbCat(buf,tmp);
#111 sprintf(tmp,"%d",ci->value.int32v);
#112 bbCat(buf,tmp);
#115 sprintf(tmp,"%g",ci->value.floatv);
#116 bbCat(buf,tmp);
#119 sprintf(tmp,"%lg",ci->value.doublev);
#120 bbCat(buf,tmp);
#123 sprintf(tmp,"%hhu",ci->value.int8v);
#124 bbCat(buf,tmp);
#127 sprintf(tmp,"%hu",ci->value.uint16v);
#128 bbCat(buf,tmp);
#131 sprintf(tmp,"%u",ci->value.uint32v);
#132 bbCat(buf,tmp);
#135 sprintf(tmp,"%lld",ci->value.int64v);
#136 bbCat(buf,tmp);
#139 sprintf(tmp,"%llu",ci->value.uint64v);
#140 bbCat(buf,tmp);
#143 sprintf(tmp,"%s",ci->value.enumv->fqn);
#144 bbCat(buf,tmp);
dumplib.c#208    void *tmp;
#219    tmp = emalloc(m + sizeof(int));
#220    memcpy(tmpsb->bufsb->len);
#223    sb->buf = tmp;
escapes.c#118 char tmp[8];
#119 escapifychar((unsigned int)s0[i],tmp,quote);
#120        strcat(result,tmp);
#276 char tmp[16];
#277 snprintf(tmp,sizeof(tmp),"DIGIT_%c_", *cp);
#278 bbCat(newname,tmp);
#486 char tmp[32];
#487 nprintf(tmp,sizeof(tmp),"//char(%u)",c);
#488 strcat(s,tmp);
#489 s += strlen(tmp);
#516 char tmp[32];
#524 f77escapifychar(c,tmp);
#526            bbCat(databuf,tmp+2);
#528            bbCat(databuf,tmp);
f77data.c#33    char tmp[64];
#39     sprintf(tmp,"'\\''");
#41     sprintf(tmp,"'%c'",ci->value.charv);
#44 sprintf(tmp,"%hhd",ci->value.int8v);
#47 sprintf(tmp,"%hd",ci->value.int16v);
#50 sprintf(tmp,"%d",ci->value.int32v);
#53 sprintf(tmp,"%.8g",ci->value.floatv);
#56 char* p = tmp;
#58 sprintf(tmp,"%.16g",ci->value.doublev);
#77 bbCat(codebuf,tmp);
genc.c#96            Bytebuffertmp = bbNew();
#103                bbClear(tmp);
#105                    bbprintf(tmp,"%s%ld",
#111                codedump(tmp);
#114     bbFree(tmp);
#751     char tmp[64];
#755     snprintf(tmp,sizeof(tmp),"%u",
#757     bbCat(dimbuf,tmp);
#861 char tmp[256];
#864 snprintf(tmp,sizeof(tmp),"%u",(unsigned int)e->dim.declsize);
#866 bbCat(stmt,tmp);
#873     char tmp[1024];
#876     snprintf(tmp,sizeof(tmp),"%lu",efield->typ.offset);
#878     snprintf(tmp,sizeof(tmp),"NC_COMPOUND_OFFSET(%s,%s)",
#887     tmp,
#897     tmp,
genf77.c#152             char tmp[32];
#154             nprintf(tmp,sizeof(tmp)," %lu",
#156             bbCat(dimstring,tmp);
#787            char tmp[32];
#788            nprintf(tmp,sizeof(tmp),"%s%lu",
#791            bbCat(stmt,tmp);
genj.c#463     char tmp[32];
#464     nprintf(tmp,sizeof(tmp),"%lu",dsym->dim.declsize);
#466     bbCat(dimbuf,tmp);
getvara.c#733    if(t1 > t2) {int tmp = t1t1 = t2t2 = tmp;}
nc3internal.c#354     long long tmp=0;
#355     status = ncx_get_int64(&xp, &tmp);
#356     new_nrecs = tmp;
nc4type.c#730   nc_vlen_t *tmp = (nc_vlen_t*)vlen_element;
#731   tmp->len = len;
#732   tmp->p = (void *)data;
#741   const nc_vlen_t *tmp = (nc_vlen_t*)vlen_element;
#744   *len = tmp->len;
#745   memcpy(datatmp->ptmp->len * type_size);
ncaux.c#205    struct {char f1TYPE x;} tmp; \
#207    DST.alignment = (size_t)((char*)(&(tmp.x)) - (char*)(&tmp));}
ncd2dispatch.c#1026    char tmp[NC_MAX_NAME*2];
#1137            snprintf(tmp,sizeof(tmp),"%s_%d",
#1140            dim->ncbasename = cdflegalname(tmp);
#1572 char tmp[32];
#1574 snprintf(tmp,sizeof(tmp),"%lu",(unsigned long)dim->dim.declsize);
#1575 ncbytescat(projection,tmp);
#1829 char tmp[64];
#1830 snprintf(tmp,sizeof(tmp),"[0:%lu]",
#1832 ncbytescat(seqcountconstraints,tmp);
ncgeny.c#278Listtmp;
#3000    tmp = listnew();
ncx.c#1740 unsigned tmp = mantissa >> 20;
#1741 if(tmp >= 4) {
#1743 } else if (tmp >= 2) {
#1749 tmp = mantissa - (1 << (20 + vsp->exp ));
#1750 tmp <<= 3 - vsp->exp;
#1751 vsp->mantissa2 = tmp;
#1752 vsp->mantissa1 = (tmp >> 16);
#5212  short tmp[LOOPCNT];        /* in case input is misaligned */
#5225      memcpy(tmp, *xppni*SIZEOF_SHORT);
#5226      xp = tmp;
#5278  short tmp[LOOPCNT];        /* in case input is misaligned */
#5291      memcpy(tmp, *xppni*SIZEOF_SHORT);
#5292      xp = tmp;
#5343  short tmp[LOOPCNT];        /* in case input is misaligned */
#5356      memcpy(tmp, *xppni*SIZEOF_SHORT);
#5357      xp = tmp;
#5408  short tmp[LOOPCNT];        /* in case input is misaligned */
#5421      memcpy(tmp, *xppni*SIZEOF_SHORT);
#5422      xp = tmp;
#5473  short tmp[LOOPCNT];        /* in case input is misaligned */
#5486      memcpy(tmp, *xppni*SIZEOF_SHORT);
#5487      xp = tmp;
#5538  short tmp[LOOPCNT];        /* in case input is misaligned */
#5551      memcpy(tmp, *xppni*SIZEOF_SHORT);
#5552      xp = tmp;
#5603  short tmp[LOOPCNT];        /* in case input is misaligned */
#5616      memcpy(tmp, *xppni*SIZEOF_SHORT);
#5617      xp = tmp;
#5668  short tmp[LOOPCNT];        /* in case input is misaligned */
#5681      memcpy(tmp, *xppni*SIZEOF_SHORT);
#5682      xp = tmp;
#5733  short tmp[LOOPCNT];        /* in case input is misaligned */
#5746      memcpy(tmp, *xppni*SIZEOF_SHORT);
#5747      xp = tmp;
#5798  short tmp[LOOPCNT];        /* in case input is misaligned */
#5811      memcpy(tmp, *xppni*SIZEOF_SHORT);
#5812      xp = tmp;
#6089  short tmp[LOOPCNT];        /* in case input is misaligned */
#6102      xp = tmp;
#6119      memcpy(*xpptmpni*X_SIZEOF_SHORT);
#6160  short tmp[LOOPCNT];        /* in case input is misaligned */
#6173      xp = tmp;
#6190      memcpy(*xpptmpni*X_SIZEOF_SHORT);
#6230  short tmp[LOOPCNT];        /* in case input is misaligned */
#6243      xp = tmp;
#6260      memcpy(*xpptmpni*X_SIZEOF_SHORT);
#6300  short tmp[LOOPCNT];        /* in case input is misaligned */
#6313      xp = tmp;
#6330      memcpy(*xpptmpni*X_SIZEOF_SHORT);
#6370  short tmp[LOOPCNT];        /* in case input is misaligned */
#6383      xp = tmp;
#6400      memcpy(*xpptmpni*X_SIZEOF_SHORT);
#6440  short tmp[LOOPCNT];        /* in case input is misaligned */
#6453      xp = tmp;
#6470      memcpy(*xpptmpni*X_SIZEOF_SHORT);
#6510  short tmp[LOOPCNT];        /* in case input is misaligned */
#6523      xp = tmp;
#6540      memcpy(*xpptmpni*X_SIZEOF_SHORT);
#6580  short tmp[LOOPCNT];        /* in case input is misaligned */
#6593      xp = tmp;
#6610      memcpy(*xpptmpni*X_SIZEOF_SHORT);
#6650  short tmp[LOOPCNT];        /* in case input is misaligned */
#6663      xp = tmp;
#6680      memcpy(*xpptmpni*X_SIZEOF_SHORT);
#6720  short tmp[LOOPCNT];        /* in case input is misaligned */
#6733      xp = tmp;
#6750      memcpy(*xpptmpni*X_SIZEOF_SHORT);
#7059  ushort tmp[LOOPCNT];        /* in case input is misaligned */
#7072      memcpy(tmp, *xppni*SIZEOF_USHORT);
#7073      xp = tmp;
#7125  ushort tmp[LOOPCNT];        /* in case input is misaligned */
#7138      memcpy(tmp, *xppni*SIZEOF_USHORT);
#7139      xp = tmp;
#7190  ushort tmp[LOOPCNT];        /* in case input is misaligned */
#7203      memcpy(tmp, *xppni*SIZEOF_USHORT);
#7204      xp = tmp;
#7255  ushort tmp[LOOPCNT];        /* in case input is misaligned */
#7268      memcpy(tmp, *xppni*SIZEOF_USHORT);
#7269      xp = tmp;
#7320  ushort tmp[LOOPCNT];        /* in case input is misaligned */
#7333      memcpy(tmp, *xppni*SIZEOF_USHORT);
#7334      xp = tmp;
#7385  ushort tmp[LOOPCNT];        /* in case input is misaligned */
#7398      memcpy(tmp, *xppni*SIZEOF_USHORT);
#7399      xp = tmp;
#7450  ushort tmp[LOOPCNT];        /* in case input is misaligned */
#7463      memcpy(tmp, *xppni*SIZEOF_USHORT);
#7464      xp = tmp;
#7515  ushort tmp[LOOPCNT];        /* in case input is misaligned */
#7528      memcpy(tmp, *xppni*SIZEOF_USHORT);
#7529      xp = tmp;
#7580  ushort tmp[LOOPCNT];        /* in case input is misaligned */
#7593      memcpy(tmp, *xppni*SIZEOF_USHORT);
#7594      xp = tmp;
#7645  ushort tmp[LOOPCNT];        /* in case input is misaligned */
#7658      memcpy(tmp, *xppni*SIZEOF_USHORT);
#7659      xp = tmp;
#7936  ushort tmp[LOOPCNT];        /* in case input is misaligned */
#7949      xp = tmp;
#7966      memcpy(*xpptmpni*X_SIZEOF_USHORT);
#8007  ushort tmp[LOOPCNT];        /* in case input is misaligned */
#8020      xp = tmp;
#8037      memcpy(*xpptmpni*X_SIZEOF_USHORT);
#8077  ushort tmp[LOOPCNT];        /* in case input is misaligned */
#8090      xp = tmp;
#8107      memcpy(*xpptmpni*X_SIZEOF_USHORT);
#8147  ushort tmp[LOOPCNT];        /* in case input is misaligned */
#8160      xp = tmp;
#8177      memcpy(*xpptmpni*X_SIZEOF_USHORT);
#8217  ushort tmp[LOOPCNT];        /* in case input is misaligned */
#8230      xp = tmp;
#8247      memcpy(*xpptmpni*X_SIZEOF_USHORT);
#8287  ushort tmp[LOOPCNT];        /* in case input is misaligned */
#8300      xp = tmp;
#8317      memcpy(*xpptmpni*X_SIZEOF_USHORT);
#8357  ushort tmp[LOOPCNT];        /* in case input is misaligned */
#8370      xp = tmp;
#8387      memcpy(*xpptmpni*X_SIZEOF_USHORT);
#8427  ushort tmp[LOOPCNT];        /* in case input is misaligned */
#8440      xp = tmp;
#8457      memcpy(*xpptmpni*X_SIZEOF_USHORT);
#8497  ushort tmp[LOOPCNT];        /* in case input is misaligned */
#8510      xp = tmp;
#8527      memcpy(*xpptmpni*X_SIZEOF_USHORT);
#8567  ushort tmp[LOOPCNT];        /* in case input is misaligned */
#8580      xp = tmp;
#8597      memcpy(*xpptmpni*X_SIZEOF_USHORT);
#8906  int tmp[LOOPCNT];        /* in case input is misaligned */
#8919      memcpy(tmp, *xppni*SIZEOF_INT);
#8920      xp = tmp;
#8972  int tmp[LOOPCNT];        /* in case input is misaligned */
#8985      memcpy(tmp, *xppni*SIZEOF_INT);
#8986      xp = tmp;
#9037  int tmp[LOOPCNT];        /* in case input is misaligned */
#9050      memcpy(tmp, *xppni*SIZEOF_INT);
#9051      xp = tmp;
#9102  int tmp[LOOPCNT];        /* in case input is misaligned */
#9115      memcpy(tmp, *xppni*SIZEOF_INT);
#9116      xp = tmp;
#9167  int tmp[LOOPCNT];        /* in case input is misaligned */
#9180      memcpy(tmp, *xppni*SIZEOF_INT);
#9181      xp = tmp;
#9232  int tmp[LOOPCNT];        /* in case input is misaligned */
#9245      memcpy(tmp, *xppni*SIZEOF_INT);
#9246      xp = tmp;
#9297  int tmp[LOOPCNT];        /* in case input is misaligned */
#9310      memcpy(tmp, *xppni*SIZEOF_INT);
#9311      xp = tmp;
#9362  int tmp[LOOPCNT];        /* in case input is misaligned */
#9375      memcpy(tmp, *xppni*SIZEOF_INT);
#9376      xp = tmp;
#9427  int tmp[LOOPCNT];        /* in case input is misaligned */
#9440      memcpy(tmp, *xppni*SIZEOF_INT);
#9441      xp = tmp;
#9492  int tmp[LOOPCNT];        /* in case input is misaligned */
#9505      memcpy(tmp, *xppni*SIZEOF_INT);
#9506      xp = tmp;
#9572  int tmp[LOOPCNT];        /* in case input is misaligned */
#9585      xp = tmp;
#9602      memcpy(*xpptmpni*X_SIZEOF_INT);
#9643  int tmp[LOOPCNT];        /* in case input is misaligned */
#9656      xp = tmp;
#9673      memcpy(*xpptmpni*X_SIZEOF_INT);
#9713  int tmp[LOOPCNT];        /* in case input is misaligned */
#9726      xp = tmp;
#9743      memcpy(*xpptmpni*X_SIZEOF_INT);
#9783  int tmp[LOOPCNT];        /* in case input is misaligned */
#9797      xp = tmp;
#9812      memcpy(*xpptmpni*X_SIZEOF_INT);
#9852  int tmp[LOOPCNT];        /* in case input is misaligned */
#9865      xp = tmp;
#9882      memcpy(*xpptmpni*X_SIZEOF_INT);
#9922  int tmp[LOOPCNT];        /* in case input is misaligned */
#9935      xp = tmp;
#9952      memcpy(*xpptmpni*X_SIZEOF_INT);
#9992  int tmp[LOOPCNT];        /* in case input is misaligned */
#10005      xp = tmp;
#10022      memcpy(*xpptmpni*X_SIZEOF_INT);
#10062  int tmp[LOOPCNT];        /* in case input is misaligned */
#10075      xp = tmp;
#10092      memcpy(*xpptmpni*X_SIZEOF_INT);
#10132  int tmp[LOOPCNT];        /* in case input is misaligned */
#10145      xp = tmp;
#10162      memcpy(*xpptmpni*X_SIZEOF_INT);
#10202  int tmp[LOOPCNT];        /* in case input is misaligned */
#10215      xp = tmp;
#10232      memcpy(*xpptmpni*X_SIZEOF_INT);
#10289  uint tmp[LOOPCNT];        /* in case input is misaligned */
#10302      memcpy(tmp, *xppni*SIZEOF_UINT);
#10303      xp = tmp;
#10355  uint tmp[LOOPCNT];        /* in case input is misaligned */
#10368      memcpy(tmp, *xppni*SIZEOF_UINT);
#10369      xp = tmp;
#10420  uint tmp[LOOPCNT];        /* in case input is misaligned */
#10433      memcpy(tmp, *xppni*SIZEOF_UINT);
#10434      xp = tmp;
#10485  uint tmp[LOOPCNT];        /* in case input is misaligned */
#10498      memcpy(tmp, *xppni*SIZEOF_UINT);
#10499      xp = tmp;
#10550  uint tmp[LOOPCNT];        /* in case input is misaligned */
#10563      memcpy(tmp, *xppni*SIZEOF_UINT);
#10564      xp = tmp;
#10615  uint tmp[LOOPCNT];        /* in case input is misaligned */
#10628      memcpy(tmp, *xppni*SIZEOF_UINT);
#10629      xp = tmp;
#10680  uint tmp[LOOPCNT];        /* in case input is misaligned */
#10693      memcpy(tmp, *xppni*SIZEOF_UINT);
#10694      xp = tmp;
#10745  uint tmp[LOOPCNT];        /* in case input is misaligned */
#10758      memcpy(tmp, *xppni*SIZEOF_UINT);
#10759      xp = tmp;
#10810  uint tmp[LOOPCNT];        /* in case input is misaligned */
#10823      memcpy(tmp, *xppni*SIZEOF_UINT);
#10824      xp = tmp;
#10875  uint tmp[LOOPCNT];        /* in case input is misaligned */
#10888      memcpy(tmp, *xppni*SIZEOF_UINT);
#10889      xp = tmp;
#10955  uint tmp[LOOPCNT];        /* in case input is misaligned */
#10968      xp = tmp;
#10985      memcpy(*xpptmpni*X_SIZEOF_UINT);
#11026  uint tmp[LOOPCNT];        /* in case input is misaligned */
#11039      xp = tmp;
#11056      memcpy(*xpptmpni*X_SIZEOF_UINT);
#11096  uint tmp[LOOPCNT];        /* in case input is misaligned */
#11109      xp = tmp;
#11126      memcpy(*xpptmpni*X_SIZEOF_UINT);
#11166  uint tmp[LOOPCNT];        /* in case input is misaligned */
#11179      xp = tmp;
#11196      memcpy(*xpptmpni*X_SIZEOF_UINT);
#11236  uint tmp[LOOPCNT];        /* in case input is misaligned */
#11249      xp = tmp;
#11266      memcpy(*xpptmpni*X_SIZEOF_UINT);
#11306  uint tmp[LOOPCNT];        /* in case input is misaligned */
#11319      xp = tmp;
#11336      memcpy(*xpptmpni*X_SIZEOF_UINT);
#11376  uint tmp[LOOPCNT];        /* in case input is misaligned */
#11389      xp = tmp;
#11406      memcpy(*xpptmpni*X_SIZEOF_UINT);
#11446  uint tmp[LOOPCNT];        /* in case input is misaligned */
#11459      xp = tmp;
#11476      memcpy(*xpptmpni*X_SIZEOF_UINT);
#11516  uint tmp[LOOPCNT];        /* in case input is misaligned */
#11529      xp = tmp;
#11546      memcpy(*xpptmpni*X_SIZEOF_UINT);
#11586  uint tmp[LOOPCNT];        /* in case input is misaligned */
#11599      xp = tmp;
#11616      memcpy(*xpptmpni*X_SIZEOF_UINT);
#11687 unsigned tmp = mantissa >> 20;
#11688 if(tmp >= 4) {
#11690 } else if (tmp >= 2) {
#11696 tmp = mantissa - (1 << (20 + vsp->exp ));
#11697 tmp <<= 3 - vsp->exp;
#11698 vsp->mantissa2 = tmp;
#11699 vsp->mantissa1 = (tmp >> 16);
#11752  float tmp[LOOPCNT];        /* in case input is misaligned */
#11765      memcpy(tmp, *xppni*SIZEOF_FLOAT);
#11766      xp = tmp;
#11817  float tmp[LOOPCNT];        /* in case input is misaligned */
#11830      memcpy(tmp, *xppni*SIZEOF_FLOAT);
#11831      xp = tmp;
#11882  float tmp[LOOPCNT];        /* in case input is misaligned */
#11895      memcpy(tmp, *xppni*SIZEOF_FLOAT);
#11896      xp = tmp;
#11947  float tmp[LOOPCNT];        /* in case input is misaligned */
#11960      memcpy(tmp, *xppni*SIZEOF_FLOAT);
#11961      xp = tmp;
#12012  float tmp[LOOPCNT];        /* in case input is misaligned */
#12025      memcpy(tmp, *xppni*SIZEOF_FLOAT);
#12026      xp = tmp;
#12077  float tmp[LOOPCNT];        /* in case input is misaligned */
#12090      memcpy(tmp, *xppni*SIZEOF_FLOAT);
#12091      xp = tmp;
#12142  float tmp[LOOPCNT];        /* in case input is misaligned */
#12155      memcpy(tmp, *xppni*SIZEOF_FLOAT);
#12156      xp = tmp;
#12207  float tmp[LOOPCNT];        /* in case input is misaligned */
#12220      memcpy(tmp, *xppni*SIZEOF_FLOAT);
#12221      xp = tmp;
#12272  float tmp[LOOPCNT];        /* in case input is misaligned */
#12285      memcpy(tmp, *xppni*SIZEOF_FLOAT);
#12286      xp = tmp;
#12428  float tmp[LOOPCNT];        /* in case input is misaligned */
#12441      xp = tmp;
#12458      memcpy(*xpptmpni*X_SIZEOF_FLOAT);
#12498  float tmp[LOOPCNT];        /* in case input is misaligned */
#12511      xp = tmp;
#12528      memcpy(*xpptmpni*X_SIZEOF_FLOAT);
#12568  float tmp[LOOPCNT];        /* in case input is misaligned */
#12581      xp = tmp;
#12598      memcpy(*xpptmpni*X_SIZEOF_FLOAT);
#12638  float tmp[LOOPCNT];        /* in case input is misaligned */
#12651      xp = tmp;
#12668      memcpy(*xpptmpni*X_SIZEOF_FLOAT);
#12708  float tmp[LOOPCNT];        /* in case input is misaligned */
#12721      xp = tmp;
#12738      memcpy(*xpptmpni*X_SIZEOF_FLOAT);
#12778  float tmp[LOOPCNT];        /* in case input is misaligned */
#12791      xp = tmp;
#12808      memcpy(*xpptmpni*X_SIZEOF_FLOAT);
#12848  float tmp[LOOPCNT];        /* in case input is misaligned */
#12861      xp = tmp;
#12878      memcpy(*xpptmpni*X_SIZEOF_FLOAT);
#12918  float tmp[LOOPCNT];        /* in case input is misaligned */
#12931      xp = tmp;
#12948      memcpy(*xpptmpni*X_SIZEOF_FLOAT);
#12988  float tmp[LOOPCNT];        /* in case input is misaligned */
#13001      xp = tmp;
#13018      memcpy(*xpptmpni*X_SIZEOF_FLOAT);
#13148  double tmp[LOOPCNT];        /* in case input is misaligned */
#13161      memcpy(tmp, *xppni*SIZEOF_DOUBLE);
#13162      xp = tmp;
#13213  double tmp[LOOPCNT];        /* in case input is misaligned */
#13226      memcpy(tmp, *xppni*SIZEOF_DOUBLE);
#13227      xp = tmp;
#13278  double tmp[LOOPCNT];        /* in case input is misaligned */
#13291      memcpy(tmp, *xppni*SIZEOF_DOUBLE);
#13292      xp = tmp;
#13343  double tmp[LOOPCNT];        /* in case input is misaligned */
#13356      memcpy(tmp, *xppni*SIZEOF_DOUBLE);
#13357      xp = tmp;
#13408  double tmp[LOOPCNT];        /* in case input is misaligned */
#13421      memcpy(tmp, *xppni*SIZEOF_DOUBLE);
#13422      xp = tmp;
#13473  double tmp[LOOPCNT];        /* in case input is misaligned */
#13486      memcpy(tmp, *xppni*SIZEOF_DOUBLE);
#13487      xp = tmp;
#13538  double tmp[LOOPCNT];        /* in case input is misaligned */
#13551      memcpy(tmp, *xppni*SIZEOF_DOUBLE);
#13552      xp = tmp;
#13603  double tmp[LOOPCNT];        /* in case input is misaligned */
#13616      memcpy(tmp, *xppni*SIZEOF_DOUBLE);
#13617      xp = tmp;
#13668  double tmp[LOOPCNT];        /* in case input is misaligned */
#13681      memcpy(tmp, *xppni*SIZEOF_DOUBLE);
#13682      xp = tmp;
#13839  double tmp[LOOPCNT];        /* in case input is misaligned */
#13852      xp = tmp;
#13869      memcpy(*xpptmpni*X_SIZEOF_DOUBLE);
#13909  double tmp[LOOPCNT];        /* in case input is misaligned */
#13922      xp = tmp;
#13939      memcpy(*xpptmpni*X_SIZEOF_DOUBLE);
#13979  double tmp[LOOPCNT];        /* in case input is misaligned */
#13992      xp = tmp;
#14009      memcpy(*xpptmpni*X_SIZEOF_DOUBLE);
#14049  double tmp[LOOPCNT];        /* in case input is misaligned */
#14062      xp = tmp;
#14079      memcpy(*xpptmpni*X_SIZEOF_DOUBLE);
#14119  double tmp[LOOPCNT];        /* in case input is misaligned */
#14132      xp = tmp;
#14149      memcpy(*xpptmpni*X_SIZEOF_DOUBLE);
#14189  double tmp[LOOPCNT];        /* in case input is misaligned */
#14202      xp = tmp;
#14219      memcpy(*xpptmpni*X_SIZEOF_DOUBLE);
#14259  double tmp[LOOPCNT];        /* in case input is misaligned */
#14272      xp = tmp;
#14289      memcpy(*xpptmpni*X_SIZEOF_DOUBLE);
#14329  double tmp[LOOPCNT];        /* in case input is misaligned */
#14342      xp = tmp;
#14359      memcpy(*xpptmpni*X_SIZEOF_DOUBLE);
#14399  double tmp[LOOPCNT];        /* in case input is misaligned */
#14412      xp = tmp;
#14429      memcpy(*xpptmpni*X_SIZEOF_DOUBLE);
#14487  longlong tmp[LOOPCNT];        /* in case input is misaligned */
#14500      memcpy(tmp, *xppni*SIZEOF_LONGLONG);
#14501      xp = tmp;
#14553  longlong tmp[LOOPCNT];        /* in case input is misaligned */
#14566      memcpy(tmp, *xppni*SIZEOF_LONGLONG);
#14567      xp = tmp;
#14618  longlong tmp[LOOPCNT];        /* in case input is misaligned */
#14631      memcpy(tmp, *xppni*SIZEOF_LONGLONG);
#14632      xp = tmp;
#14683  longlong tmp[LOOPCNT];        /* in case input is misaligned */
#14696      memcpy(tmp, *xppni*SIZEOF_LONGLONG);
#14697      xp = tmp;
#14748  longlong tmp[LOOPCNT];        /* in case input is misaligned */
#14761      memcpy(tmp, *xppni*SIZEOF_LONGLONG);
#14762      xp = tmp;
#14813  longlong tmp[LOOPCNT];        /* in case input is misaligned */
#14826      memcpy(tmp, *xppni*SIZEOF_LONGLONG);
#14827      xp = tmp;
#14878  longlong tmp[LOOPCNT];        /* in case input is misaligned */
#14891      memcpy(tmp, *xppni*SIZEOF_LONGLONG);
#14892      xp = tmp;
#14943  longlong tmp[LOOPCNT];        /* in case input is misaligned */
#14956      memcpy(tmp, *xppni*SIZEOF_LONGLONG);
#14957      xp = tmp;
#15008  longlong tmp[LOOPCNT];        /* in case input is misaligned */
#15021      memcpy(tmp, *xppni*SIZEOF_LONGLONG);
#15022      xp = tmp;
#15073  longlong tmp[LOOPCNT];        /* in case input is misaligned */
#15086      memcpy(tmp, *xppni*SIZEOF_LONGLONG);
#15087      xp = tmp;
#15153  longlong tmp[LOOPCNT];        /* in case input is misaligned */
#15166      xp = tmp;
#15183      memcpy(*xpptmpni*X_SIZEOF_LONGLONG);
#15224  longlong tmp[LOOPCNT];        /* in case input is misaligned */
#15237      xp = tmp;
#15254      memcpy(*xpptmpni*X_SIZEOF_LONGLONG);
#15294  longlong tmp[LOOPCNT];        /* in case input is misaligned */
#15307      xp = tmp;
#15324      memcpy(*xpptmpni*X_SIZEOF_LONGLONG);
#15364  longlong tmp[LOOPCNT];        /* in case input is misaligned */
#15377      xp = tmp;
#15394      memcpy(*xpptmpni*X_SIZEOF_LONGLONG);
#15434  longlong tmp[LOOPCNT];        /* in case input is misaligned */
#15447      xp = tmp;
#15464      memcpy(*xpptmpni*X_SIZEOF_LONGLONG);
#15504  longlong tmp[LOOPCNT];        /* in case input is misaligned */
#15517      xp = tmp;
#15534      memcpy(*xpptmpni*X_SIZEOF_LONGLONG);
#15574  longlong tmp[LOOPCNT];        /* in case input is misaligned */
#15587      xp = tmp;
#15604      memcpy(*xpptmpni*X_SIZEOF_LONGLONG);
#15644  longlong tmp[LOOPCNT];        /* in case input is misaligned */
#15657      xp = tmp;
#15674      memcpy(*xpptmpni*X_SIZEOF_LONGLONG);
#15714  longlong tmp[LOOPCNT];        /* in case input is misaligned */
#15727      xp = tmp;
#15744      memcpy(*xpptmpni*X_SIZEOF_LONGLONG);
#15784  longlong tmp[LOOPCNT];        /* in case input is misaligned */
#15797      xp = tmp;
#15814      memcpy(*xpptmpni*X_SIZEOF_LONGLONG);
#15871  ulonglong tmp[LOOPCNT];        /* in case input is misaligned */
#15884      memcpy(tmp, *xppni*SIZEOF_ULONGLONG);
#15885      xp = tmp;
#15937  ulonglong tmp[LOOPCNT];        /* in case input is misaligned */
#15950      memcpy(tmp, *xppni*SIZEOF_ULONGLONG);
#15951      xp = tmp;
#16002  ulonglong tmp[LOOPCNT];        /* in case input is misaligned */
#16015      memcpy(tmp, *xppni*SIZEOF_ULONGLONG);
#16016      xp = tmp;
#16067  ulonglong tmp[LOOPCNT];        /* in case input is misaligned */
#16080      memcpy(tmp, *xppni*SIZEOF_ULONGLONG);
#16081      xp = tmp;
#16132  ulonglong tmp[LOOPCNT];        /* in case input is misaligned */
#16145      memcpy(tmp, *xppni*SIZEOF_ULONGLONG);
#16146      xp = tmp;
#16197  ulonglong tmp[LOOPCNT];        /* in case input is misaligned */
#16210      memcpy(tmp, *xppni*SIZEOF_ULONGLONG);
#16211      xp = tmp;
#16262  ulonglong tmp[LOOPCNT];        /* in case input is misaligned */
#16275      memcpy(tmp, *xppni*SIZEOF_ULONGLONG);
#16276      xp = tmp;
#16327  ulonglong tmp[LOOPCNT];        /* in case input is misaligned */
#16340      memcpy(tmp, *xppni*SIZEOF_ULONGLONG);
#16341      xp = tmp;
#16392  ulonglong tmp[LOOPCNT];        /* in case input is misaligned */
#16405      memcpy(tmp, *xppni*SIZEOF_ULONGLONG);
#16406      xp = tmp;
#16457  ulonglong tmp[LOOPCNT];        /* in case input is misaligned */
#16470      memcpy(tmp, *xppni*SIZEOF_ULONGLONG);
#16471      xp = tmp;
#16537  ulonglong tmp[LOOPCNT];        /* in case input is misaligned */
#16550      xp = tmp;
#16567      memcpy(*xpptmpni*X_SIZEOF_ULONGLONG);
#16608  ulonglong tmp[LOOPCNT];        /* in case input is misaligned */
#16621      xp = tmp;
#16638      memcpy(*xpptmpni*X_SIZEOF_ULONGLONG);
#16678  ulonglong tmp[LOOPCNT];        /* in case input is misaligned */
#16691      xp = tmp;
#16708      memcpy(*xpptmpni*X_SIZEOF_ULONGLONG);
#16748  ulonglong tmp[LOOPCNT];        /* in case input is misaligned */
#16761      xp = tmp;
#16778      memcpy(*xpptmpni*X_SIZEOF_ULONGLONG);
#16818  ulonglong tmp[LOOPCNT];        /* in case input is misaligned */
#16831      xp = tmp;
#16848      memcpy(*xpptmpni*X_SIZEOF_ULONGLONG);
#16888  ulonglong tmp[LOOPCNT];        /* in case input is misaligned */
#16901      xp = tmp;
#16918      memcpy(*xpptmpni*X_SIZEOF_ULONGLONG);
#16958  ulonglong tmp[LOOPCNT];        /* in case input is misaligned */
#16971      xp = tmp;
#16988      memcpy(*xpptmpni*X_SIZEOF_ULONGLONG);
#17028  ulonglong tmp[LOOPCNT];        /* in case input is misaligned */
#17041      xp = tmp;
#17058      memcpy(*xpptmpni*X_SIZEOF_ULONGLONG);
#17098  ulonglong tmp[LOOPCNT];        /* in case input is misaligned */
#17111      xp = tmp;
#17128      memcpy(*xpptmpni*X_SIZEOF_ULONGLONG);
#17168  ulonglong tmp[LOOPCNT];        /* in case input is misaligned */
#17181      xp = tmp;
#17198      memcpy(*xpptmpni*X_SIZEOF_ULONGLONG);
occompile.c#145            char tmp[sizeof(unsigned int)];
#147     if(!xxdr_opaque(xxdrs,tmp,(off_t)sizeof(tmp)))
#149            if(tmp[0] == StartOfSequence) {
#159            } else if(tmp[0] == EndOfSequence) {
ocdata.c#367         unsigned int tmp;
#368 if(!xxdr_getbytes(xdrs,(char*)&tmp,(off_t)XDRUNIT))
#372     swapinline32(&tmp);
#374 *sp = (unsigned short)tmp;
ocdump.c#258    char tmp[32];
#275    sprintf(tmp,"%6zd",index);
#276    addfield(tmp,line,5);
#281    sprintf(tmp,"%08x",form.uv);
#282    addfield(tmp,line,8);
#287    sprintf(tmp,"%12u",form.uv);
#288    addfield(tmp,line,12);
#291    sprintf(tmp,"%12d",form.sv);
#292    addfield(tmp,line,12);
#295    sprintf(tmp,"%#g",form.fv);
#296    addfield(tmp,line,12);
#302 tmp[0] = '\0';
#310     if(!occoncat(tmp,sizeof(tmp),1,stmp))
#315    addfield(tmp,line,16);
#320    sprintf(tmp,"%#g",dform.d);
#321    addfield(tmp,line,12);
#372    char tmp[32];
#395        sprintf(tmp,"%6d",i);
#396        addfield(tmp,line,6);
#397        sprintf(tmp,"%08x",vx);
#398        addfield(tmp,line,9);
#399        sprintf(tmp,"%08x",v);
#400        addfield(tmp,line,10);
#507    char tmp[1024];
#509    snprintf(tmp,sizeof(tmp),"%lx:",(unsigned long)data);
#510    ocbytescat(buffer,tmp);
#515    snprintf(tmp,sizeof(tmp)," xdroffset=%ld",(unsigned long)data->xdroffset);
#516    ocbytescat(buffer,tmp);
#518        snprintf(tmp,sizeof(tmp)," xdrsize=%ld",(unsigned long)data->xdrsize);
#519        ocbytescat(buffer,tmp);
#522        snprintf(tmp,sizeof(tmp)," ninstances=%d",(int)data->ninstances);
#523        ocbytescat(buffer,tmp);
#525        snprintf(tmp,sizeof(tmp)," nstrings=%d",(int)data->nstrings);
#526        ocbytescat(buffer,tmp);
#529    snprintf(tmp,sizeof(tmp),"%lx",(unsigned long)data->container);
#530    ocbytescat(buffer,tmp);
#550    char tmp[1024];
#569    snprintf(tmp,sizeof(tmp),"[%03d]",depth);
#570    ocbytescat(buffer,tmp);
#574    snprintf(tmp,sizeof(tmp),"%08lu",(unsigned long)data->xdroffset);
#575    ocbytescat(buffer,tmp);
#583        snprintf(tmp,sizeof(tmp),"%04lu ",(unsigned long)data->index);
#584        ocbytescat(buffer,tmp);
#597        snprintf(tmp,sizeof(tmp),"%04lu",(unsigned long)data->ninstances);
#599        snprintf(tmp,sizeof(tmp),"%04lu",(unsigned long)data->xdrsize);
#601    ocbytescat(buffer,tmp);
#614    if(!occopycat(tmp,sizeof(tmp),1,pattern->name))
#616    ocbytescat(buffer,tmp);
#619 snprintf(tmp,sizeof(tmp),"[%lu]",(unsigned long)crossproduct);
#620 ocbytescat(buffer,tmp);
#636    char tmp[1024];
#659 snprintf(tmp,sizeof(tmp),".%lu",(unsigned long)next->index);
#660         ocbytescat(buffer,tmp);
#666         snprintf(tmp,sizeof(tmp),"[0..%lu]",(unsigned long)xproduct-1);
#667         ocbytescat(buffer,tmp);
#689    snprintf(tmp,sizeof(tmp),"->0x%0lx",(unsigned long)pathdata);
#690    ocbytescat(buffer,tmp);
ochttp.c#247 char tmp[8];
#251 tmp[0] = '0'; tmp[1] = 'x';
#252 tmp[2] = hexchars[hex2]; tmp[3] = hexchars[hex1];
#253 tmp[4] = '\0';
#254 ocbytescat(buf,tmp);
ocinternal.c#617 char tmp[OCPATHMAX+1];
#620 snprintf(tmp,sizeof(tmp)-1,"%s/%s.%ld/",ocglobalstate.tempdir,OCDIR,(long)pid);
#622 stat = mkdir(tmp);
#624 stat = mkdir(tmp,S_IRUSR | S_IWUSR | S_IXUSR);
#632 stat = ocmktmp(tmp,&state->curlflags.cookiejar);
ocnode.c#59    char* tmp;
#68    tmp = pathtostring(path,PATHSEPARATOR);
#69    if(tmp == NULL) {
#72        fullname = tmp;
odom.c#67    char tmp[64];
#73 sprintf(tmp,"[%lu/%lu..%lu:%lu]",
#79 strcat(line,tmp);
offsets.c#91    struct {char f1TYPE x;} tmp; \
#93    DST.alignment = (size_t)((char*)(&(tmp.x)) - (char*)(&tmp));}
#180    struct {TYPE1 f1TYPE x;} tmp; \
#182    DST.alignment = (size_t)((char*)(&(tmp.x)) - (char*)(&tmp));}
#188    struct {TYPE1 f1TYPE2 f2TYPE x;} tmp;   \
#190    DST.alignment = (size_t)((char*)(&(tmp.x)) - (char*)(&tmp));}
#196    struct {TYPE1 cTYPE2 x;} tmp; \
#197    DST = sizeof(tmp); }
util.c#699 size_t tmp[MAX_RANK];
#716 assert(toMixedBase (jjrankmax_dim_lentmp) == 0);
#718 (void) toMixedBase (jjrankmax_dim_lentmp);
#723 var_dimid[vn][dn] = (int)tmp[dn];
v1hpg.c#173 long long tmp=0;
#174 status = ncx_get_int64((const void **)(&gsp->pos), &tmp);
#175 *sp = (size_t)tmp;
#1489 long long tmp = 0;
#1490 status = ncx_get_int64((const void **)(&gs.pos), &tmp);
#1491 nrecs = (size_t)tmp;
vardef.c#126    static struct cdfvar tmp = /* variable for testing bad types, etc. */
#163    tmp.dims = (int *) emalloc(sizeof(int) * MAX_VAR_DIMS);
#164    tmp.name = (char *) emalloc(MAX_NC_NAME);
#186 if (ncvarinq(cdfidva_id[iv], tmp.name, &tmp.type,
#187       &tmp.ndimstmp.dims, &tmp.natts) == -1) {
#192 if (strcmp(tmp.nameva[iv].name) != 0 ||
#193     tmp.type != va[iv].type ||
#194     tmp.ndims != va[iv].ndims ||
#195     tmp.natts != va[iv].natts) {
#200     errvar(&test,&tmp);
#203     if (tmp.dims[id] != va[iv].dims[id]) {
#208     errvar(&test,&tmp);
#341    free (tmp.dims);
#342    free (tmp.name);
varget.c#57 long tmp;
#68 tmp = hc.cor[id];
#74 hc.cor[id] = tmp;
#75 tmp = hc.edg[id];
#81 hc.edg[id] = tmp;
#87 tmp = hc.cor[mqv];
#93 hc.cor[mqv] = tmp;
#94 tmp = hc.edg[mqv];
#100 hc.edg[mqv] = tmp;
vargetg.c#56 long tmp;
#74 tmp = hc.cor[id];
#80 hc.cor[id] = tmp;
#81 tmp = hc.edg[id];
#87 hc.edg[id] = tmp;
#88 tmp = hc.cor[id];
#94 hc.cor[id] = tmp;
#95 tmp = hc.edg[id];
#101 hc.edg[id] = tmp;
#102 tmp = strides[id];
#108 strides[id] = tmp;
varput.c#40    long tmp;
#73 tmp = hc.cor[id];
#79 hc.cor[id] = tmp;
#80 tmp = hc.edg[id];
#86 hc.edg[id] = tmp;
#91 tmp = hc.cor[mqv];
#97 hc.cor[mqv] = tmp;
#99 tmp = hc.edg[mqv];
#105 hc.edg[mqv] = tmp;
varputg.c#40    long tmp;
#77 tmp = hc.cor[id];
#83 hc.cor[id] = tmp;
#84 tmp = hc.edg[id];
#90 hc.edg[id] = tmp;
#91 tmp = hc.cor[id];
#97 hc.cor[id] = tmp;
#98 tmp = hc.edg[id];
#104 hc.edg[id] = tmp;
#105 tmp = strides[id];
#111 strides[id] = tmp;
vputget.c#48    } hc[3], tmp; /* test hypercubes */
#81     tmp.vals = emalloc(nel[ie]*nctypelen(test.vars[iv].type) + 8);
#105     if(ncvarget (cdfidivhc[ie].corhc[ie].edgtmp.vals)
#113     hc[ie].valstmp.vals) != 0) {
#122     free (tmp.vals);
vputgetg.c#51    } hc[3], tmp; /* test hypercubes */
#115     tmp.vals = emalloc(nelms);
#157       (char*)tmp.vals+hc[ie].offset)
#165 hc[ie].valstmp.vals) != 0) {
#175     free (tmp.vals);
xxdr.c#496 unsigned int tmp;
#501 tmp = ii[0];
#503 ii[1] = tmp;


HyperKWIC - Version 7.20DA executed at 11:37 on 27 Oct 2017 | Polyhedron Solutions - INTERNAL USE | COMMERCIAL (Any O/S) SN 4AKIed