ConvertUTF.c#64    ConversionResult result = conversionOK;
#70     result = targetExhausted; break;
#78     result = sourceIllegal;
#88 result = sourceIllegal;
#96 result = targetExhausted; break;
#105    return result;
#113    ConversionResult result = conversionOK;
#132     result = sourceIllegal;
#137 result = sourceExhausted;
#144 result = sourceIllegal;
#150     result = targetExhausted; break;
#157if (result == sourceIllegal) {
#162    return result;
#217    ConversionResult result = conversionOK;
#239     result = sourceIllegal;
#244 result = sourceExhausted;
#251 result = sourceIllegal;
#267     target -= bytesToWriteresult = targetExhausted; break;
#279    return result;
#339    ConversionResult result = conversionOK;
#346     result = sourceExhausted; break;
#350     result = sourceIllegal;
#368     result = targetExhausted; break;
#375     result = sourceIllegal;
#385 result = sourceIllegal;
#395 result = targetExhausted; break;
#404    return result;
#412    ConversionResult result = conversionOK;
#425 result = sourceIllegal;
#439     result = sourceIllegal;
#445     target -= bytesToWriteresult = targetExhausted; break;
#457    return result;
#465    ConversionResult result = conversionOK;
#472     result = sourceExhausted; break;
#476     result = sourceIllegal;
#494     result = targetExhausted; break;
#504     result = sourceIllegal;
#513     result = sourceIllegal;
#519    return result;
bytebuffer.c#253    char* result = (char*)emalloc(bb->length+1);
#254    memcpy((void*)result,(const void*)bb->content,bb->length);
#255    result[bb->length] = '\0'; /* just in case it is a string*/
#256    return result;
cdf.c#729    NClistresult = NULL;
#734        if(result == NULL)
#735           result = nclistnew();
#738        nclistpush(result,(void*)clonedim(nccomm,dim,var));
#740    return result;
constraints.c#758    DCEprojectionresult = NULL;
#768    for(result=null,i=0;i<nclistlength(projections);i++) {
#772     result = p1;
#776    if(result == NULL) {
#777 result = (DCEprojection*)dceclone((DCEnode*)var); /* use only the var projection */
#780    result = (DCEprojection*)dceclone((DCEnode*)result); /* so we can modify */
#784 dumpprojection(result),dumpprojection(var));
#789    ncstat = dcemergeprojections(result,var); /* result will be modified */
#792    if(resultp) *resultp = result;
#795 dumpprojection(result));
dapdump.c#255    char* result;
#265    result = ncbytesdup(buf);
#268    return result;
#375    char* result;
#377    result = ncbytesdup(buf);
#379    return result;
#386    char* result;
#388    result = ncbytesdup(buf);
#390    return result;
#398    char* result;
#482    result = ncbytesdup(buf);
#484    return result;
#490    char* result;
#493 result = nulldup("NCalignment{size=-- alignment=-- offset=--}");
#497        result = nulldup(tmp);
#499    return result;
#505    char* result = NULL;
#512    result = dcebuildconstraintstring(node->constraint);
#517         result);
#527    result = ncbytesdup(buf);
#529    return result;
#535    char* result = NULL;
#560    result = ncbytesdup(buf);
#562    return result;
#596    char* result = NULL;
#606    result = ncbytesdup(buf);
#608    return result;
daputil.c#374    char* result;
#405    result = ncbytesextract(pathname);
#408    return result;
#416    char* result;
#441    result = ncbytesextract(pathname);
#443    return result;
#475    char* result;
#483    result = (char*)malloc(len);
#484    result[0] = '\0';
#487 if(i > 0) strcat(result,separator);
#488 strcat(result,segment);
#490    return result;
dceconstraints.c#195dceslicecompose(DCEslices1DCEslices2DCEsliceresult)
#215    *result = sr;
#217slicedump("compose: result",result);
#336    char* result = NULL;
#338    result = ncbytesdup(buf);
#340    return result;
#346    DCEnoderesult = NULL;
#348    result = (DCEnode*)dcecreate(node->sort);
#349    if(result == NULL) goto done;
#354 DCEsliceclone = (DCEslice*)result;
#360 DCEsegmentclone = (DCEsegment*)result;
#369 DCEvarclone = (DCEvar*)result;
#376 DCEfcnclone = (DCEfcn*)result;
#384 DCEconstantclone = (DCEconstant*)result;
#392 DCEvalueclone = (DCEvalue*)result;
#407 DCEprojectionclone = (DCEprojection*)result;
#420 DCEselectionclone = (DCEselection*)result;
#428 DCEconstraintclone = (DCEconstraint*)result;
#440    return result;
dumplib.c#1913    bool_t result; /* 0 if fixed, 1 if unlimited size */
#1922    result = is_unlim[dimid]; /* 0 if fixed, 1 if unlimited size */
#1929    result = (dimid == unlimdimid) ;
#1931    return result;
dutf8proc.c#532  ssize_t result;
#534  result = utf8proc_decompose(strslenNULL, 0, options);
#535  if (result < 0) return result;
#536  buffer = (int32_t*)malloc(((size_t)result) * sizeof(int32_t) + 1);
#538  result = utf8proc_decompose(strslenbufferresultoptions);
#539  if (result < 0) {
#541    return result;
#543  result = utf8proc_reencode(bufferresultoptions);
#544  if (result < 0) {
#546    return result;
#550    newptr = realloc(bufferresult+1);
#554  return result;
#586  ssize_t result;
#587  result = utf8proc_decompose(str, 0, NULL, 0,
#589  return result;
escapes.c#114    char* result;
#115    result = poolalloc(1+4*len); /* overkill to support maximal expansion*/
#116    result[0] = '\0';
#120        strcat(result,tmp);
#122    return result;
#350    char* result;
#355    result = pooldup(bbContents(escaped));
#357    return result;
#426    char* result;
#448    result = pooldup(bbContents(escaped));
#450    return result;
genf77.c#582    char* result;
#595    result = poolalloc(slen);
#596    result[0] = '\0';
#601        strcat(result,sym->name); /* append "<prefix[i]/>"*/
#602 strcat(result,separator);
#604    strcat(result,suffix); /* append "<suffix>"*/
#605    return result;
genlib.c#201    char* result;
#214    result = poolalloc(slen);
#215    result[0] = '\0';
#220        strcat(result,sym->name); /* append "<prefix[i]/>"*/
#221 strcat(result,separator);
#223    strcat(result,suffix); /* append "<suffix>"*/
#224    return result;
list.c#149    void** result = (void**)malloc(sizeof(void*)*(l->length+1));
#150    memcpy((void*)result,(void*)l->content,sizeof(void*)*l->length);
#151    result[l->length] = (void*)0;
#152    return result;
ncbytes.c#166    char* result = (char*)malloc(bb->length+1);
#167    memcpy((void*)result,(const void*)bb->content,bb->length);
#168    result[bb->length] = '\0'; /* just in case it is a string*/
#169    return result;
#175    char* result = bb->content;
#179    return result;
ncgenl.c#1421#define YY_INPUT(buf,result,max_size) \
#1433 result = n; \
#1438 while ( (result = fread(buf, 1, max_sizencgin))==0 && ferror(ncgin)) \
#3210    int result = 0;
ncgeny.c#3517    NCConstant result = nullconstant;
#3520    result.lineno = fcn->lineno;
#3525        result.nctype = NC_DOUBLE;
#3526        result.value.doublev = 0;
#3564     Cdh2e(&cdtime,&result.value.doublev);
#3575    return result;
ncgenyy.c#1008#define YY_INPUT(buf,result,max_size) \
#1020 result = n; \
#1025 while ( (result = fread(buf, 1, max_sizencgin))==0 && ferror(ncgin)) \
nclist.c#149    void** result = (void**)malloc(sizeof(void*)*(l->length+1));
#150    memcpy((void*)result,(void*)l->content,sizeof(void*)*l->length);
#151    result[l->length] = (void*)0;
#152    return result;
nctime.c#439 double result;
#443 result = cdDiffJulian(cacb);
#446 result = cdDiffGregorian(caZB) + cdDiffJulian(ZAcb);
#451 result = cdDiffJulian(caZA) + cdDiffGregorian(ZBcb);
#454 result = cdDiffGregorian(cacb);
#457 return result;
#546 double result;
#550 result = value * 3600.0;
#553 result = value * 60.0;
#556 result = value;
#559 result = value/24.0;
#562 result = value/168.0;
#570 result = 0;
#573 return result;
#890cdCompAdd(cdCompTime comptime, double valuecdCalenType calendarcdCompTime *result){
#896 cdRel2Comp(calendar, "hours", reltimeresult);
#903cdCompAddMixed(cdCompTime ct, double valuecdCompTime *result){
#912 cdCompAdd(ctvaluecdJulianresult);
#915 cdCompAdd(ZBvalue-xjcdStandardresult);
#921 cdCompAdd(ctvaluecdStandardresult);
#924 cdCompAdd(ZAvalue-xgcdJulianresult);
#934 double result = 0;
#938 result = value/3600.0;
#941 result = value/60.0;
#944 result = value;
#947 result = 24.0 * value;
#950 result = 168.0 * value;
#957 return result;
ncuri.h#53extern int ncurilookup(NCURI*, const char* param, const char** result);
ocbytes.c#163    char* result = (char*)malloc(bb->length+1);
#164    memcpy((void*)result,(const void*)bb->content,bb->length);
#165    result[bb->length] = '\0'; /* just in case it is a string*/
#166    return result;
#172    char* result = bb->content;
#176    return result;
oclist.c#149    void** result = (void**)malloc(sizeof(void*)*(l->length+1));
#150    if(result != NULL) {
#152            memcpy((void*)result,(void*)l->content,sizeof(void*)*l->length);
#153        result[l->length] = (void*)0;
#155    return result;
ocuri.h#53extern int ocurilookup(OCURI*, const char* param, const char** result);
ocutil.c#553    static char result[1+(NMODES*(MAXMODENAME+1))]; /* hack to avoid malloc */
#555    char* p = result;
#556    result[0] = '\0';
#559 else if(!occoncat(result,sizeof(result),1,"NONE"))
#565     if(!occoncat(result,sizeof(result),1,","))
#569     else if(!occoncat(result,sizeof(result),1,ms))
#575 while((p-result) < NMODES) *p++ = ' ';
#578    return result;
semantics.c#813    nc_type result = NC_NAT;
#886    result = NC_NAT;
#889 result = infertype(result,con->nctype,hasneg);
#890 if(result == NC_NAT) break; /* something wrong */
#892    return result;
test_partvar.c#174    float* result = (float*)target;
#179 int eq = floateq(result[offset],expected[offset]);
#182 (unsigned long)offset,result[offset],(unsigned long)offset,expected[offset]);
test_vara.c#132    float* result = (float*)threeD;
#137 if(floateq(result[offset],expected[offset])) {
#139 (long unsigned)offset,result[offset],(long unsigned)offset,expected[offset]);
tests.h#524    size_t result[]);      /* dimensioned [length] */
#532int nc2dbl ( const nc_type datatype, const void *p, double *result);
tst_ar4_4d.c#150timeval_subtract (resultxy)
#151   struct timeval *result, *x, *y;
#167   result->tv_sec = x->tv_sec - y->tv_sec;
#168   result->tv_usec = x->tv_usec - y->tv_usec;
tst_utils.c#13nc4_timeval_subtract (resultxy)
#14   struct timeval *result, *x, *y;
#30   result->tv_sec = x->tv_sec - y->tv_sec;
#31   result->tv_usec = x->tv_usec - y->tv_usec;
util.c#16    char* result = (char*)emalloc(len+1);
#17    result[0] = '\0';
#18    if(s1) strcat(result,s1);
#19    if(s2) strcat(result,s2);
#20    return result;
#365    char* result;
#372        result = poolalloc(slen);
#373        result[0] = '\0';
#381        result = poolalloc(slen);
#382        result[0] = '\0';
#385            strcat(result,separator);
#386     strcat(result,sym->name); /* append "/<prefix[i]>"*/
#389    return result;
#399    char* result;
#403    result = poolcat(s1,sym->name);
#404    return result;
util.c#214    size_t result[])      /* dimensioned [length] */
#222     result[i] = number % base[i];
#225        result[0] = number;
#247    size_t result = 0;
#250        result += number[i-1];
#251        result *= base[i];
#254        result += number[i-1];
#255    return result;
#260int nc2dbl ( const nc_type datatype, const void *p, double *result)
#263    if ( ! result ) return 3;
#265        case NC_BYTE: *result = *((signed char *) p); break;
#266        case NC_CHAR: *result = *((signed char *) p); break;
#267        case NC_SHORT: *result = *((short *) p); break;
#270 *result = *((int *) p); break;
#272 *result = *((long *) p); break;
#274        case NC_FLOAT: *result = *((float *) p); break;
#275        case NC_DOUBLE: *result = *((double *) p); break;
#276        case NC_UBYTE:  *result = *((unsigned char *)  p); break;
#277        case NC_USHORT: *result = *((unsigned short *) p); break;
#280            *result = *((unsigned int *) p); break;
#282            *result = *((unsigned long *) p); break;
#284        case NC_INT64:  *result = *((long long *)          p); break;
#285        case NC_UINT64: *result = *((unsigned long long *) p); break;
#380    double result;
#468 result = rank < 0 ? base * 7 : base * (rank + 1);
#470     result = base * (result + index[d]);
#472    return result;
#485    double result;
#573 result = rank < 0 ? base * 7 : base * (rank + 1);
#575     result = base * (result + index[d]);
#577    return result;
#588    double result;
#590    result = hashtyperankindex );
#591    if (itype == NCT_UCHAR && type == NC_BYTE && result >= -128 && result < 0)
#592 result += 256;
#593    return result;
#646 size_t result = 1;
#648 result *= *sp++;
#649 return result;


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