Do you like my strlcpy strlcat etc?

Discussion in 'C Programming' started by RoSsIaCrIiLoIA, Feb 4, 2005.

  1. Do you like my strlcpy strlcat etc?
    Thank you
    /*---------------------------------------*/
    .....
    int main(void)
    {
    /*-------------------------------------{}*/
    srand((unsigned)time(0));
    test3(200000, 100, 100, strlcat, strlcat_m);
    test1(3000000, 100, revstring, revstring_m );
    return 0;
    } /* main, endswith */
    /* 25 + 25 + 10 = 60 0..59 */

    char lettere(unsigned j)
    {char *u="abcdefghijklmnopqrstuvwyz"
    "ABCDEFGHIJKLMNOPQRSTUVWYZ"
    "0123456789";
    return u[j%60];
    }


    void rand_phrase(char* a, size_t le)
    {unsigned i=0;
    /*------------------------------*/
    assert(a!=0);
    if(le==0) goto l0;
    la: a=lettere((unsigned)rand()); if(++i<le)goto la;
    l0:
    a=0;
    }


    /* does searchme end with the phrase phrase? */
    /* By RoSsIaCrIiLoIA */
    int endswith_m(const char* phrase, const char* searchme)
    {const char *p1, *p2;
    int r=0;
    /*------------------------------*/
    assert(phrase!=0 && searchme!=0);
    p1= phrase +strlen(phrase ); /**p1=*p2=0 */
    p2= searchme+strlen(searchme); /*ok caso *p1=0 o *p2=0 */
    goto l1;
    l0: --p1; --p2;
    l1: if(*p1!=*p2) goto le;
    if(p2==searchme)
    {r=1; goto le;}
    if(p1!=phrase) goto l0;
    le:
    return r;
    }



    /* reverse string in place. Return length */
    size_t revstring_m(char *string)
    {char *last, temp;
    size_t lgh;
    /*-------------------------------------*/
    if( (lgh=strlen(string))>1 )
    {
    last= string+lgh-1;
    l0:
    temp=*string, *string=*last, *last=temp;
    --last; ++string;
    if(last>string) goto l0;
    }
    return lgh;
    } /* revstring */


    size_t
    strlcpy_m(char* dst, const char* src, size_t sz)
    {size_t z=sz;
    /*----------------------------*/
    if( sz )
    {if( src )
    {while( --sz && (*dst++ = *src++) );
    --z;
    if( sz )
    {return z-sz;}
    else {l0: *dst=0;
    l1: z+=strlen(src);
    }
    }
    else if(dst) goto l0;
    }
    else if(src) goto l1;
    return z-sz;
    } /* strlcpy */


    size_t
    strlcat_m(char* dst, const char* src, size_t sz)
    {size_t z;
    /*--------------------*/
    if( (z=strlen(dst)) + 1 <= sz )
    return z + strlcpy_m(dst+z, src, sz-z);
    else {if(sz) dst[sz-1]=0; /* se dest=NULL could write it */
    return z + (src ? strlen(src): 0);
    }
    } /* strlcat */

    int test1(cicli, len_s0, f0, f1)
    unsigned cicli, len_s0;
    size_t (*f0)(char*), (*f1)(char*);
    {char *s0, *s1, *s2;
    size_t i, k0, k1, h0, h1, h3, len_s1=len_s0;
    time_t t0, t1;
    /*-------------------------------------{}*/
    if(cicli==0||len_s0==0||f0==0||f1==0)
    return 0;
    if(len_s0>100000)
    return 0;
    s0=malloc(len_s0);
    if(s0==0) return 0;
    if((s1=malloc(len_s1))==0)
    {free(s0); return 0;}
    if((s2=malloc(len_s0))==0)
    {free(s0);free(s1); return 0;}
    i=0;
    l0:
    h0=rand()%len_s0;
    rand_phrase(s0, h0);
    strcpy(s1, s0);
    if( (k0=f0(s0))!=(k1=f1(s1)) )
    {l1:
    printf("test failure:"
    "s1=%s# s0=%s# s2=%s# k0=%u# k1=%u# len(s0)=%u h0=%u h1=%u
    giri=%u\n",
    s1, s0, s2, (unsigned)k0,
    (unsigned)k1,(unsigned)strlen(s0),(unsigned)h0,(unsigned)h1,
    (unsigned)i);
    free(s0); free(s1); free(s2);
    return 0;
    }
    if(strcmp(s0, s1)!=0)goto l1;
    if(++i<cicli/50)goto l0;
    i=0;
    l34:
    h1=rand()%len_s1; rand_phrase(s1, h1);
    if(h1==0) goto l34;
    t0=time(0);
    l2:
    *s1=++*s1;
    if(f0(s1)==1234567) ++i;
    if(++i<cicli)goto l2;
    t1=time(0);
    printf("d_0=%f\n", difftime(t1,t0));
    i=0;
    t0=time(0);
    l3:
    *s1=++*s1;
    if(f1(s1)==1234567) ++i;
    if(++i<cicli)goto l3;
    t1=time(0);
    printf("d_1=%f\n", difftime(t1,t0));
    free(s0); free(s1); free(s2);
    printf("Test success\n");
    return 1;
    }

    /*************************************/
    #define G goto
    #define U unsigned
    #define R return
    #define W while
    #define F for
    #define P printf
    #define B break

    /* 25 + 25 + 10 = 60 0..59 */
    char lettere(U j)
    {char *u="abcdefghijklmnopqrstuvwyz"
    "ABCDEFGHIJKLMNOPQRSTUVWYZ"
    "0123456789";
    R u[j%60];
    }

    void rand_phrase(char* a, size_t le)
    {U i=0;
    /*------------------------------*/
    assert(a!=0);
    if(le==0) G l0;
    la: a=lettere((U)rand()); if(++i<le)G la;
    l0:
    a=0;
    }

    /* does searchme end with the phrase phrase? */
    /* By RoSsIaCrIiLoIA */
    int endswith_m(const char* phrase, const char* searchme)
    {const char *p1, *p2;
    int r=0;
    /*------------------------------*/
    assert(phrase!=0 && searchme!=0);
    p1= phrase +strlen(phrase ); /**p1=*p2=0 */
    p2= searchme+strlen(searchme); /*ok caso *p1=0 o *p2=0 */
    G l1;
    l0: --p1; --p2;
    l1: if(*p1!=*p2) G le;
    if(p2==searchme)
    {r=1; G le;}
    if(p1!=phrase) G l0;
    le:
    R r;
    }


    /* reverse string in place. Return length */
    size_t revstring_m(char *string)
    {char *last, temp;
    size_t lgh;
    /*-------------------------------------*/
    if( (lgh=strlen(string))>1 )
    {
    last= string+lgh-1;
    l0:
    temp=*string, *string=*last, *last=temp;
    --last; ++string;
    if(last>string) G l0;
    }
    return lgh;
    } /* revstring */


    size_t
    strlcpy_m(char* dst, const char* src, size_t sz)
    {size_t z=sz;
    /*----------------------------*/
    if( sz )
    {if( src )
    {W( --sz && (*dst++ = *src++) );
    --z;
    if( sz )
    {R z-sz;}
    else {l0: *dst=0;
    l1: z+=strlen(src);
    }
    }
    else if(dst) G l0;
    }
    else if(src) G l1;
    R z-sz;
    } /* strlcpy */


    size_t
    strlcat_m(char* dst, const char* src, size_t sz)
    {size_t z;
    /*--------------------*/
    if( (z=strlen(dst)) + 1 <= sz )
    R z + strlcpy_m(dst+z, src, sz-z);
    else {if(sz) dst[sz-1]=0; /* se dest=NULL could write it */
    R z + (src ? strlen(src): 0);
    }
    } /* strlcat */


    int test3(cicli, len_s0, len_s1, f0, f1)
    U cicli, len_s0, len_s1;
    size_t (*f0)(char*, const char*, size_t),
    (*f1)(char*, const char*, size_t);
    {char *s2, *s0, *s1, *s3;
    size_t i, k0, k1, h0, h1, h3;
    time_t t0, t1;
    /*-------------------------------------{}*/
    if(cicli==0||len_s0==0||len_s1==0||f0==0||f1==0)
    R 0;
    if(len_s0>100000||len_s1>100000)
    R 0;
    s0=malloc(len_s0);
    if(s0==0) R 0;
    if((s1=malloc(len_s1))==0)
    {free(s0); R 0;}
    if((s2=malloc(len_s0))==0)
    {free(s0);free(s1); R 0;}
    if((s3=malloc(len_s0))==0)
    {free(s0);free(s1); free(s2); R 0;}
    i=0;
    l0:
    h0=rand()%len_s0; h1=rand()%len_s1;
    h3=h0+1+rand()%(len_s0-h0);
    rand_phrase(s0, h0); rand_phrase(s1, h1);

    strcpy(s3, s0); strcpy(s2, s0);
    if( (k0=f0(s0, s1, h3 )) !=
    (k1=f1(s2, s1, h3 )) )
    {l1:
    P("test failure:"
    "s3=%s# s1=%s# s0=%s# s2=%s# k0=%u# k1=%u# len(s0)=%u h0=%u h1=%u
    giri=%u\n",
    s3, s1, s0, s2, (U)k0, (U)k1,(U)strlen(s0),(U)h0,(U)h1,
    (U)i);
    free(s0); free(s1); free(s2); free(s3);
    R 0;
    }
    if(strcmp(s0, s2)!=0)G l1;
    if(++i<cicli)G l0;
    i=0;
    //l34:
    // h1=rand()%len_s1; rand_phrase(s1, h1);
    // if(h1==0) G l34;
    t0=time(0);
    l2:
    h0=rand()%len_s0; rand_phrase(s0, h3);
    h1=rand()%len_s1; rand_phrase(s1, h1);
    h3=(h0+h1+1)%(len_s0);
    // *s1=++*s1;
    if(f0(s0, s1, h3)==1234567) ++i;
    if(++i<cicli)G l2;
    t1=time(0);
    P("d_0=%f\n", difftime(t1,t0));
    i=0;
    t0=time(0);
    l3:
    h0=rand()%len_s0; rand_phrase(s0, h0);
    h1=rand()%len_s1; rand_phrase(s1, h1);
    h3=(h0+h1+1)%(len_s0);
    // *s1=++*s1;
    if(f1(s0, s1, h3)==1234567) ++i;
    if(++i<cicli)G l3;
    t1=time(0);
    P("d_1=%f\n", difftime(t1,t0));
    free(s0); free(s1); free(s2); free(s3);
    P("Test success\n");
    R 1;
    }
    RoSsIaCrIiLoIA, Feb 4, 2005
    #1
    1. Advertising

  2. RoSsIaCrIiLoIA

    Big K Guest

    Skimming through the whole thing in 2 sec., I must say it looks rather
    sexy.

    Have any specific questions?


    RoSsIaCrIiLoIA wrote:
    > Do you like my strlcpy strlcat etc?
    > Thank you
    > /*---------------------------------------*/
    > ....
    > int main(void)
    > {
    > /*-------------------------------------{}*/
    > srand((unsigned)time(0));
    > test3(200000, 100, 100, strlcat, strlcat_m);
    > test1(3000000, 100, revstring, revstring_m );
    > return 0;
    > } /* main, endswith */
    > /* 25 + 25 + 10 = 60 0..59 */
    >
    > char lettere(unsigned j)
    > {char *u="abcdefghijklmnopqrstuvwyz"
    > "ABCDEFGHIJKLMNOPQRSTUVWYZ"
    > "0123456789";
    > return u[j%60];
    > }
    >
    >
    > void rand_phrase(char* a, size_t le)
    > {unsigned i=0;
    > /*------------------------------*/
    > assert(a!=0);
    > if(le==0) goto l0;
    > la: a=lettere((unsigned)rand()); if(++i<le)goto la;
    > l0:
    > a=0;
    > }
    >
    >
    > /* does searchme end with the phrase phrase? */
    > /* By RoSsIaCrIiLoIA */
    > int endswith_m(const char* phrase, const char* searchme)
    > {const char *p1, *p2;
    > int r=0;
    > /*------------------------------*/
    > assert(phrase!=0 && searchme!=0);
    > p1= phrase +strlen(phrase ); /**p1=*p2=0 */
    > p2= searchme+strlen(searchme); /*ok caso *p1=0 o *p2=0 */
    > goto l1;
    > l0: --p1; --p2;
    > l1: if(*p1!=*p2) goto le;
    > if(p2==searchme)
    > {r=1; goto le;}
    > if(p1!=phrase) goto l0;
    > le:
    > return r;
    > }
    >
    >
    >
    > /* reverse string in place. Return length */
    > size_t revstring_m(char *string)
    > {char *last, temp;
    > size_t lgh;
    > /*-------------------------------------*/
    > if( (lgh=strlen(string))>1 )
    > {
    > last= string+lgh-1;
    > l0:
    > temp=*string, *string=*last, *last=temp;
    > --last; ++string;
    > if(last>string) goto l0;
    > }
    > return lgh;
    > } /* revstring */
    >
    >
    > size_t
    > strlcpy_m(char* dst, const char* src, size_t sz)
    > {size_t z=sz;
    > /*----------------------------*/
    > if( sz )
    > {if( src )
    > {while( --sz && (*dst++ = *src++) );
    > --z;
    > if( sz )
    > {return z-sz;}
    > else {l0: *dst=0;
    > l1: z+=strlen(src);
    > }
    > }
    > else if(dst) goto l0;
    > }
    > else if(src) goto l1;
    > return z-sz;
    > } /* strlcpy */
    >
    >
    > size_t
    > strlcat_m(char* dst, const char* src, size_t sz)
    > {size_t z;
    > /*--------------------*/
    > if( (z=strlen(dst)) + 1 <= sz )
    > return z + strlcpy_m(dst+z, src, sz-z);
    > else {if(sz) dst[sz-1]=0; /* se dest=NULL could write it */
    > return z + (src ? strlen(src): 0);
    > }
    > } /* strlcat */
    >
    > int test1(cicli, len_s0, f0, f1)
    > unsigned cicli, len_s0;
    > size_t (*f0)(char*), (*f1)(char*);
    > {char *s0, *s1, *s2;
    > size_t i, k0, k1, h0, h1, h3, len_s1=len_s0;
    > time_t t0, t1;
    > /*-------------------------------------{}*/
    > if(cicli==0||len_s0==0||f0==0||f1==0)
    > return 0;
    > if(len_s0>100000)
    > return 0;
    > s0=malloc(len_s0);
    > if(s0==0) return 0;
    > if((s1=malloc(len_s1))==0)
    > {free(s0); return 0;}
    > if((s2=malloc(len_s0))==0)
    > {free(s0);free(s1); return 0;}
    > i=0;
    > l0:
    > h0=rand()%len_s0;
    > rand_phrase(s0, h0);
    > strcpy(s1, s0);
    > if( (k0=f0(s0))!=(k1=f1(s1)) )
    > {l1:
    > printf("test failure:"
    > "s1=%s# s0=%s# s2=%s# k0=%u# k1=%u# len(s0)=%u h0=%u h1=%u
    > giri=%u\n",
    > s1, s0, s2, (unsigned)k0,
    > (unsigned)k1,(unsigned)strlen(s0),(unsigned)h0,(unsigned)h1,
    > (unsigned)i);
    > free(s0); free(s1); free(s2);
    > return 0;
    > }
    > if(strcmp(s0, s1)!=0)goto l1;
    > if(++i<cicli/50)goto l0;
    > i=0;
    > l34:
    > h1=rand()%len_s1; rand_phrase(s1, h1);
    > if(h1==0) goto l34;
    > t0=time(0);
    > l2:
    > *s1=++*s1;
    > if(f0(s1)==1234567) ++i;
    > if(++i<cicli)goto l2;
    > t1=time(0);
    > printf("d_0=%f\n", difftime(t1,t0));
    > i=0;
    > t0=time(0);
    > l3:
    > *s1=++*s1;
    > if(f1(s1)==1234567) ++i;
    > if(++i<cicli)goto l3;
    > t1=time(0);
    > printf("d_1=%f\n", difftime(t1,t0));
    > free(s0); free(s1); free(s2);
    > printf("Test success\n");
    > return 1;
    > }
    >
    > /*************************************/
    > #define G goto
    > #define U unsigned
    > #define R return
    > #define W while
    > #define F for
    > #define P printf
    > #define B break
    >
    > /* 25 + 25 + 10 = 60 0..59 */
    > char lettere(U j)
    > {char *u="abcdefghijklmnopqrstuvwyz"
    > "ABCDEFGHIJKLMNOPQRSTUVWYZ"
    > "0123456789";
    > R u[j%60];
    > }
    >
    > void rand_phrase(char* a, size_t le)
    > {U i=0;
    > /*------------------------------*/
    > assert(a!=0);
    > if(le==0) G l0;
    > la: a=lettere((U)rand()); if(++i<le)G la;
    > l0:
    > a=0;
    > }
    >
    > /* does searchme end with the phrase phrase? */
    > /* By RoSsIaCrIiLoIA */
    > int endswith_m(const char* phrase, const char* searchme)
    > {const char *p1, *p2;
    > int r=0;
    > /*------------------------------*/
    > assert(phrase!=0 && searchme!=0);
    > p1= phrase +strlen(phrase ); /**p1=*p2=0 */
    > p2= searchme+strlen(searchme); /*ok caso *p1=0 o *p2=0 */
    > G l1;
    > l0: --p1; --p2;
    > l1: if(*p1!=*p2) G le;
    > if(p2==searchme)
    > {r=1; G le;}
    > if(p1!=phrase) G l0;
    > le:
    > R r;
    > }
    >
    >
    > /* reverse string in place. Return length */
    > size_t revstring_m(char *string)
    > {char *last, temp;
    > size_t lgh;
    > /*-------------------------------------*/
    > if( (lgh=strlen(string))>1 )
    > {
    > last= string+lgh-1;
    > l0:
    > temp=*string, *string=*last, *last=temp;
    > --last; ++string;
    > if(last>string) G l0;
    > }
    > return lgh;
    > } /* revstring */
    >
    >
    > size_t
    > strlcpy_m(char* dst, const char* src, size_t sz)
    > {size_t z=sz;
    > /*----------------------------*/
    > if( sz )
    > {if( src )
    > {W( --sz && (*dst++ = *src++) );
    > --z;
    > if( sz )
    > {R z-sz;}
    > else {l0: *dst=0;
    > l1: z+=strlen(src);
    > }
    > }
    > else if(dst) G l0;
    > }
    > else if(src) G l1;
    > R z-sz;
    > } /* strlcpy */
    >
    >
    > size_t
    > strlcat_m(char* dst, const char* src, size_t sz)
    > {size_t z;
    > /*--------------------*/
    > if( (z=strlen(dst)) + 1 <= sz )
    > R z + strlcpy_m(dst+z, src, sz-z);
    > else {if(sz) dst[sz-1]=0; /* se dest=NULL could write it */
    > R z + (src ? strlen(src): 0);
    > }
    > } /* strlcat */
    >
    >
    > int test3(cicli, len_s0, len_s1, f0, f1)
    > U cicli, len_s0, len_s1;
    > size_t (*f0)(char*, const char*, size_t),
    > (*f1)(char*, const char*, size_t);
    > {char *s2, *s0, *s1, *s3;
    > size_t i, k0, k1, h0, h1, h3;
    > time_t t0, t1;
    > /*-------------------------------------{}*/
    > if(cicli==0||len_s0==0||len_s1==0||f0==0||f1==0)
    > R 0;
    > if(len_s0>100000||len_s1>100000)
    > R 0;
    > s0=malloc(len_s0);
    > if(s0==0) R 0;
    > if((s1=malloc(len_s1))==0)
    > {free(s0); R 0;}
    > if((s2=malloc(len_s0))==0)
    > {free(s0);free(s1); R 0;}
    > if((s3=malloc(len_s0))==0)
    > {free(s0);free(s1); free(s2); R 0;}
    > i=0;
    > l0:
    > h0=rand()%len_s0; h1=rand()%len_s1;
    > h3=h0+1+rand()%(len_s0-h0);
    > rand_phrase(s0, h0); rand_phrase(s1, h1);
    >
    > strcpy(s3, s0); strcpy(s2, s0);
    > if( (k0=f0(s0, s1, h3 )) !=
    > (k1=f1(s2, s1, h3 )) )
    > {l1:
    > P("test failure:"
    > "s3=%s# s1=%s# s0=%s# s2=%s# k0=%u# k1=%u# len(s0)=%u h0=%u h1=%u
    > giri=%u\n",
    > s3, s1, s0, s2, (U)k0, (U)k1,(U)strlen(s0),(U)h0,(U)h1,
    > (U)i);
    > free(s0); free(s1); free(s2); free(s3);
    > R 0;
    > }
    > if(strcmp(s0, s2)!=0)G l1;
    > if(++i<cicli)G l0;
    > i=0;
    > //l34:
    > // h1=rand()%len_s1; rand_phrase(s1, h1);
    > // if(h1==0) G l34;
    > t0=time(0);
    > l2:
    > h0=rand()%len_s0; rand_phrase(s0, h3);
    > h1=rand()%len_s1; rand_phrase(s1, h1);
    > h3=(h0+h1+1)%(len_s0);
    > // *s1=++*s1;
    > if(f0(s0, s1, h3)==1234567) ++i;
    > if(++i<cicli)G l2;
    > t1=time(0);
    > P("d_0=%f\n", difftime(t1,t0));
    > i=0;
    > t0=time(0);
    > l3:
    > h0=rand()%len_s0; rand_phrase(s0, h0);
    > h1=rand()%len_s1; rand_phrase(s1, h1);
    > h3=(h0+h1+1)%(len_s0);
    > // *s1=++*s1;
    > if(f1(s0, s1, h3)==1234567) ++i;
    > if(++i<cicli)G l3;
    > t1=time(0);
    > P("d_1=%f\n", difftime(t1,t0));
    > free(s0); free(s1); free(s2); free(s3);
    > P("Test success\n");
    > R 1;
    > }
    Big K, Feb 4, 2005
    #2
    1. Advertising

  3. RoSsIaCrIiLoIA

    Big K Guest

    Big K wrote:
    > Skimming through the whole thing in 2 sec., I must say it looks

    rather
    > sexy.
    >
    > Have any specific questions?
    >


    Mr. Big K, do not top-post please.

    >
    > RoSsIaCrIiLoIA wrote:
    > > Do you like my strlcpy strlcat etc?
    > > Thank you
    > > /*---------------------------------------*/
    > > ....
    > > int main(void)
    > > {
    > > /*-------------------------------------{}*/
    > > srand((unsigned)time(0));
    > > test3(200000, 100, 100, strlcat, strlcat_m);
    > > test1(3000000, 100, revstring, revstring_m );
    > > return 0;
    > > } /* main, endswith */
    > > /* 25 + 25 + 10 = 60 0..59 */
    > >
    > > char lettere(unsigned j)
    > > {char *u="abcdefghijklmnopqrstuvwyz"
    > > "ABCDEFGHIJKLMNOPQRSTUVWYZ"
    > > "0123456789";
    > > return u[j%60];
    > > }
    > >
    > >
    > > void rand_phrase(char* a, size_t le)
    > > {unsigned i=0;
    > > /*------------------------------*/
    > > assert(a!=0);
    > > if(le==0) goto l0;
    > > la: a=lettere((unsigned)rand()); if(++i<le)goto la;
    > > l0:
    > > a=0;
    > > }
    > >
    > >
    > > /* does searchme end with the phrase phrase? */
    > > /* By RoSsIaCrIiLoIA */
    > > int endswith_m(const char* phrase, const char* searchme)
    > > {const char *p1, *p2;
    > > int r=0;
    > > /*------------------------------*/
    > > assert(phrase!=0 && searchme!=0);
    > > p1= phrase +strlen(phrase ); /**p1=*p2=0 */
    > > p2= searchme+strlen(searchme); /*ok caso *p1=0 o *p2=0 */
    > > goto l1;
    > > l0: --p1; --p2;
    > > l1: if(*p1!=*p2) goto le;
    > > if(p2==searchme)
    > > {r=1; goto le;}
    > > if(p1!=phrase) goto l0;
    > > le:
    > > return r;
    > > }
    > >
    > >
    > >
    > > /* reverse string in place. Return length */
    > > size_t revstring_m(char *string)
    > > {char *last, temp;
    > > size_t lgh;
    > > /*-------------------------------------*/
    > > if( (lgh=strlen(string))>1 )
    > > {
    > > last= string+lgh-1;
    > > l0:
    > > temp=*string, *string=*last, *last=temp;
    > > --last; ++string;
    > > if(last>string) goto l0;
    > > }
    > > return lgh;
    > > } /* revstring */
    > >
    > >
    > > size_t
    > > strlcpy_m(char* dst, const char* src, size_t sz)
    > > {size_t z=sz;
    > > /*----------------------------*/
    > > if( sz )
    > > {if( src )
    > > {while( --sz && (*dst++ = *src++) );
    > > --z;
    > > if( sz )
    > > {return z-sz;}
    > > else {l0: *dst=0;
    > > l1: z+=strlen(src);
    > > }
    > > }
    > > else if(dst) goto l0;
    > > }
    > > else if(src) goto l1;
    > > return z-sz;
    > > } /* strlcpy */
    > >
    > >
    > > size_t
    > > strlcat_m(char* dst, const char* src, size_t sz)
    > > {size_t z;
    > > /*--------------------*/
    > > if( (z=strlen(dst)) + 1 <= sz )
    > > return z + strlcpy_m(dst+z, src, sz-z);
    > > else {if(sz) dst[sz-1]=0; /* se dest=NULL could write it */
    > > return z + (src ? strlen(src): 0);
    > > }
    > > } /* strlcat */
    > >
    > > int test1(cicli, len_s0, f0, f1)
    > > unsigned cicli, len_s0;
    > > size_t (*f0)(char*), (*f1)(char*);
    > > {char *s0, *s1, *s2;
    > > size_t i, k0, k1, h0, h1, h3, len_s1=len_s0;
    > > time_t t0, t1;
    > > /*-------------------------------------{}*/
    > > if(cicli==0||len_s0==0||f0==0||f1==0)
    > > return 0;
    > > if(len_s0>100000)
    > > return 0;
    > > s0=malloc(len_s0);
    > > if(s0==0) return 0;
    > > if((s1=malloc(len_s1))==0)
    > > {free(s0); return 0;}
    > > if((s2=malloc(len_s0))==0)
    > > {free(s0);free(s1); return 0;}
    > > i=0;
    > > l0:
    > > h0=rand()%len_s0;
    > > rand_phrase(s0, h0);
    > > strcpy(s1, s0);
    > > if( (k0=f0(s0))!=(k1=f1(s1)) )
    > > {l1:
    > > printf("test failure:"
    > > "s1=%s# s0=%s# s2=%s# k0=%u# k1=%u# len(s0)=%u h0=%u h1=%u
    > > giri=%u\n",
    > > s1, s0, s2, (unsigned)k0,
    > > (unsigned)k1,(unsigned)strlen(s0),(unsigned)h0,(unsigned)h1,
    > > (unsigned)i);
    > > free(s0); free(s1); free(s2);
    > > return 0;
    > > }
    > > if(strcmp(s0, s1)!=0)goto l1;
    > > if(++i<cicli/50)goto l0;
    > > i=0;
    > > l34:
    > > h1=rand()%len_s1; rand_phrase(s1, h1);
    > > if(h1==0) goto l34;
    > > t0=time(0);
    > > l2:
    > > *s1=++*s1;
    > > if(f0(s1)==1234567) ++i;
    > > if(++i<cicli)goto l2;
    > > t1=time(0);
    > > printf("d_0=%f\n", difftime(t1,t0));
    > > i=0;
    > > t0=time(0);
    > > l3:
    > > *s1=++*s1;
    > > if(f1(s1)==1234567) ++i;
    > > if(++i<cicli)goto l3;
    > > t1=time(0);
    > > printf("d_1=%f\n", difftime(t1,t0));
    > > free(s0); free(s1); free(s2);
    > > printf("Test success\n");
    > > return 1;
    > > }
    > >
    > > /*************************************/
    > > #define G goto
    > > #define U unsigned
    > > #define R return
    > > #define W while
    > > #define F for
    > > #define P printf
    > > #define B break
    > >
    > > /* 25 + 25 + 10 = 60 0..59 */
    > > char lettere(U j)
    > > {char *u="abcdefghijklmnopqrstuvwyz"
    > > "ABCDEFGHIJKLMNOPQRSTUVWYZ"
    > > "0123456789";
    > > R u[j%60];
    > > }
    > >
    > > void rand_phrase(char* a, size_t le)
    > > {U i=0;
    > > /*------------------------------*/
    > > assert(a!=0);
    > > if(le==0) G l0;
    > > la: a=lettere((U)rand()); if(++i<le)G la;
    > > l0:
    > > a=0;
    > > }
    > >
    > > /* does searchme end with the phrase phrase? */
    > > /* By RoSsIaCrIiLoIA */
    > > int endswith_m(const char* phrase, const char* searchme)
    > > {const char *p1, *p2;
    > > int r=0;
    > > /*------------------------------*/
    > > assert(phrase!=0 && searchme!=0);
    > > p1= phrase +strlen(phrase ); /**p1=*p2=0 */
    > > p2= searchme+strlen(searchme); /*ok caso *p1=0 o *p2=0 */
    > > G l1;
    > > l0: --p1; --p2;
    > > l1: if(*p1!=*p2) G le;
    > > if(p2==searchme)
    > > {r=1; G le;}
    > > if(p1!=phrase) G l0;
    > > le:
    > > R r;
    > > }
    > >
    > >
    > > /* reverse string in place. Return length */
    > > size_t revstring_m(char *string)
    > > {char *last, temp;
    > > size_t lgh;
    > > /*-------------------------------------*/
    > > if( (lgh=strlen(string))>1 )
    > > {
    > > last= string+lgh-1;
    > > l0:
    > > temp=*string, *string=*last, *last=temp;
    > > --last; ++string;
    > > if(last>string) G l0;
    > > }
    > > return lgh;
    > > } /* revstring */
    > >
    > >
    > > size_t
    > > strlcpy_m(char* dst, const char* src, size_t sz)
    > > {size_t z=sz;
    > > /*----------------------------*/
    > > if( sz )
    > > {if( src )
    > > {W( --sz && (*dst++ = *src++) );
    > > --z;
    > > if( sz )
    > > {R z-sz;}
    > > else {l0: *dst=0;
    > > l1: z+=strlen(src);
    > > }
    > > }
    > > else if(dst) G l0;
    > > }
    > > else if(src) G l1;
    > > R z-sz;
    > > } /* strlcpy */
    > >
    > >
    > > size_t
    > > strlcat_m(char* dst, const char* src, size_t sz)
    > > {size_t z;
    > > /*--------------------*/
    > > if( (z=strlen(dst)) + 1 <= sz )
    > > R z + strlcpy_m(dst+z, src, sz-z);
    > > else {if(sz) dst[sz-1]=0; /* se dest=NULL could write it */
    > > R z + (src ? strlen(src): 0);
    > > }
    > > } /* strlcat */
    > >
    > >
    > > int test3(cicli, len_s0, len_s1, f0, f1)
    > > U cicli, len_s0, len_s1;
    > > size_t (*f0)(char*, const char*, size_t),
    > > (*f1)(char*, const char*, size_t);
    > > {char *s2, *s0, *s1, *s3;
    > > size_t i, k0, k1, h0, h1, h3;
    > > time_t t0, t1;
    > > /*-------------------------------------{}*/
    > > if(cicli==0||len_s0==0||len_s1==0||f0==0||f1==0)
    > > R 0;
    > > if(len_s0>100000||len_s1>100000)
    > > R 0;
    > > s0=malloc(len_s0);
    > > if(s0==0) R 0;
    > > if((s1=malloc(len_s1))==0)
    > > {free(s0); R 0;}
    > > if((s2=malloc(len_s0))==0)
    > > {free(s0);free(s1); R 0;}
    > > if((s3=malloc(len_s0))==0)
    > > {free(s0);free(s1); free(s2); R 0;}
    > > i=0;
    > > l0:
    > > h0=rand()%len_s0; h1=rand()%len_s1;
    > > h3=h0+1+rand()%(len_s0-h0);
    > > rand_phrase(s0, h0); rand_phrase(s1, h1);
    > >
    > > strcpy(s3, s0); strcpy(s2, s0);
    > > if( (k0=f0(s0, s1, h3 )) !=
    > > (k1=f1(s2, s1, h3 )) )
    > > {l1:
    > > P("test failure:"
    > > "s3=%s# s1=%s# s0=%s# s2=%s# k0=%u# k1=%u# len(s0)=%u h0=%u h1=%u
    > > giri=%u\n",
    > > s3, s1, s0, s2, (U)k0, (U)k1,(U)strlen(s0),(U)h0,(U)h1,
    > > (U)i);
    > > free(s0); free(s1); free(s2); free(s3);
    > > R 0;
    > > }
    > > if(strcmp(s0, s2)!=0)G l1;
    > > if(++i<cicli)G l0;
    > > i=0;
    > > //l34:
    > > // h1=rand()%len_s1; rand_phrase(s1, h1);
    > > // if(h1==0) G l34;
    > > t0=time(0);
    > > l2:
    > > h0=rand()%len_s0; rand_phrase(s0, h3);
    > > h1=rand()%len_s1; rand_phrase(s1, h1);
    > > h3=(h0+h1+1)%(len_s0);
    > > // *s1=++*s1;
    > > if(f0(s0, s1, h3)==1234567) ++i;
    > > if(++i<cicli)G l2;
    > > t1=time(0);
    > > P("d_0=%f\n", difftime(t1,t0));
    > > i=0;
    > > t0=time(0);
    > > l3:
    > > h0=rand()%len_s0; rand_phrase(s0, h0);
    > > h1=rand()%len_s1; rand_phrase(s1, h1);
    > > h3=(h0+h1+1)%(len_s0);
    > > // *s1=++*s1;
    > > if(f1(s0, s1, h3)==1234567) ++i;
    > > if(++i<cicli)G l3;
    > > t1=time(0);
    > > P("d_1=%f\n", difftime(t1,t0));
    > > free(s0); free(s1); free(s2); free(s3);
    > > P("Test success\n");
    > > R 1;
    > > }


    My bad.
    Big K, Feb 4, 2005
    #3
  4. RoSsIaCrIiLoIA <> writes:
    > Do you like my strlcpy strlcat etc?

    [snip]
    > #define G goto
    > #define U unsigned
    > #define R return
    > #define W while
    > #define F for
    > #define P printf
    > #define B break

    [snip]

    No.

    --
    Keith Thompson (The_Other_Keith) <http://www.ghoti.net/~kst>
    San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
    We must do something. This is something. Therefore, we must do this.
    Keith Thompson, Feb 4, 2005
    #4
  5. "Big K" <> writes:
    > Big K wrote:
    >> Skimming through the whole thing in 2 sec., I must say it looks

    > rather
    >> sexy.
    >>
    >> Have any specific questions?
    >>

    >
    > Mr. Big K, do not top-post please.
    >
    >>
    >> RoSsIaCrIiLoIA wrote:

    [huge snip]
    > My bad.


    Unnecessarily quoting hundreds of lines that aren't relevant to your
    followup is even worse than top-posting.

    --
    Keith Thompson (The_Other_Keith) <http://www.ghoti.net/~kst>
    San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
    We must do something. This is something. Therefore, we must do this.
    Keith Thompson, Feb 4, 2005
    #5
  6. On 4 Feb 2005 13:48:37 -0800, "Big K" <> wrote:

    >Skimming through the whole thing in 2 sec., I must say it looks rather
    >sexy.
    >
    >Have any specific questions?


    Why CBFalconer's ones are more fast?

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <time.h>
    #include <assert.h>

    /* Yes, I know strlcat and strlcpy are in the implementors
    namespace. Change them if you must.
    See <http://cbfalconer.home.att.net/download/strlcpy.zip>
    for documentation and rationale.

    The objective is to detect whether a given string terminates
    another string. This is a fairly tortuous way of doing
    "endswith", but is fairly clear.

    By C.B.Falconer. Released to public domain
    */

    /* ---------------------- */
    static int endswith_m(const char* , const char* );
    static size_t revstring_m(char* string);
    void rand_phrase(char* a, size_t le);
    size_t strlcpy_m(char* dst, const char* src, size_t sz);

    size_t strlcat_m(char* dst, const char* src, size_t sz);

    int test3(unsigned cicli,unsigned len_s0,unsigned len_s1,
    size_t (*f0)(char*, const char*, size_t),
    size_t (*f1)(char*, const char*, size_t) );

    int test1(unsigned cicli, unsigned len_s0,
    size_t (*f0)(char*), size_t (*f1)(char*) );

    /* reverse string in place. Return length */
    static size_t revstring(char *string)
    {
    char *last, temp;
    size_t lgh;

    if ((lgh = strlen(string)) > 1) {
    last = string + lgh; /* points to '\0' */
    while (last-- > string) {
    temp = *string; *string++ = *last; *last = temp;
    }
    }
    return lgh;
    } /* revstring */

    /* ---------------------- */

    static size_t strlcpy(char *dst, const char *src, size_t sz)
    {
    const char *start = src;

    if (src && sz--) {
    while ((*dst++ = *src))
    if (sz--) src++;
    else {
    *(--dst) = '\0';
    break;
    }
    }
    if (src) {
    while (*src++) continue;
    return src - start - 1;
    }
    else if (sz) *dst = '\0';
    return 0;
    } /* strlcpy */

    /* ---------------------- */

    static size_t strlcat(char *dst, const char *src, size_t sz)
    {
    char *start = dst;

    while (*dst++) /* assumes sz >= strlen(dst) */
    if (sz) sz--; /* i.e. well formed string */
    dst--;
    return dst - start + strlcpy(dst, src, sz);
    } /* strlcat */

    /* ---------------------- */

    /* does searchme end with the phrase phrase? */
    /* illustrates the power of reversing things */
    /* (if not the efficacy) */
    static int endswith(char *phrase, char *searchme)
    {
    int result, lgh, i;

    lgh = revstring(phrase); revstring(searchme);
    result = 1;
    for (i = 0; i < lgh; i++) /* strncmp if we had it */
    if (phrase != searchme) {
    result = 0; break;
    }
    revstring_m(phrase); revstring_m(searchme);
    return result;
    } /* endswith */

    /*End of By C.B.Falconer's ones */
    /* Start mine */
    #define G goto
    #define U unsigned
    #define R return
    #define W while
    #define F for
    #define P printf
    #define B break

    int main(void)
    {srand((U)time(0));
    test3(40000000, 100, 100, strlcpy, strlcpy_m);
    test1(3000000, 100, revstring, revstring_m );
    return 0;
    } /* main, endswith */


    /* 25 + 25 + 10 = 60 0..59 */
    char lettere(U j)
    {char *u="abcdefghijklmnopqrstuvwyz"
    "ABCDEFGHIJKLMNOPQRSTUVWYZ"
    "0123456789";
    R u[j%60];
    }

    void rand_phrase(char* a, size_t le)
    {U i=0;
    /*------------------------------*/
    assert(a!=0);
    if(le==0) G l0;
    la: a=lettere((U)rand()); if(++i<le)G la;
    l0:
    a=0;
    }

    /* does searchme end with the phrase phrase? */
    /* By RoSsIaCrIiLoIA */
    int endswith_m(const char* phrase, const char* searchme)
    {const char *p1, *p2;
    int r=0;
    /*------------------------------*/
    assert(phrase!=0 && searchme!=0);
    p1= phrase +strlen(phrase ); /**p1=*p2=0 */
    p2= searchme+strlen(searchme); /*ok caso *p1=0 o *p2=0 */
    G l1;
    l0: --p1; --p2;
    l1: if(*p1!=*p2) G le;
    if(p2==searchme)G l2;
    if(p1!=phrase) G l0;
    G le;
    l2: r=1;
    le:
    R r;
    }


    /* reverse string in place. Return length */
    size_t revstring_m(char *string)
    {char *last, temp;
    size_t lgh;
    /*-------------------------------------*/
    if( (lgh=strlen(string))>1 )
    {
    last= string+lgh-1;
    l0:
    temp=*string, *string=*last, *last=temp;
    --last; ++string;
    if(last>string) G l0;
    }
    return lgh;
    } /* revstring */


    size_t
    strlcpy_m(char* dst, const char* src, size_t sz)
    {size_t z=sz;
    char a;
    /*----------------------------*/
    if( sz )
    {if( src )
    {//W( --sz && (*dst++ = *src++) );
    l1: --sz;
    if(sz==0) G l2;
    a=*src; *dst=a;
    ++src; ++dst;
    if(a) G l1;
    l2:
    --z;
    if( sz )
    {R z-sz;}
    else { *dst=0;
    l0: z+=strlen(src);
    }
    }
    else if(dst) *dst=0;
    }
    else if(src) G l0;
    R z-sz;
    } /* strlcpy */


    size_t
    strlcat_m(char* dst, const char* src, size_t sz)
    {size_t z;
    /*--------------------*/
    if( (z=strlen(dst)) + 1 <= sz )
    R z + strlcpy_m(dst+z, src, sz-z);
    else {if(sz) dst[sz-1]=0; /* se dest=NULL could write it */
    R z + (src ? strlen(src): 0);
    }
    } /* strlcat */

    int test3(cicli, len_s0, len_s1, f0, f1)
    U cicli, len_s0, len_s1;
    size_t (*f0)(char*, const char*, size_t),
    (*f1)(char*, const char*, size_t);
    {char *s2, *s0, *s1, *s3;
    size_t i, k0, k1, h0, h1, h3;
    time_t t0, t1;
    /*-------------------------------------{}*/
    if(cicli==0||len_s0==0||len_s1==0||f0==0||f1==0)
    R 0;
    if(len_s0>100000||len_s1>100000)
    R 0;
    s0=malloc(len_s0);
    if(s0==0) R 0;
    if((s1=malloc(len_s1))==0)
    {free(s0); R 0;}
    if((s2=malloc(len_s0))==0)
    {free(s0);free(s1); R 0;}
    if((s3=malloc(len_s0))==0)
    {free(s0);free(s1); free(s2); R 0;}
    i=0;
    l0:
    h0=rand()%len_s0; h1=rand()%len_s1;
    h3=h0+1+rand()%(len_s0-h0);
    rand_phrase(s0, h0); rand_phrase(s1, h1);

    strcpy(s3, s0); strcpy(s2, s0);
    if( (k0=f0(s0, s1, h3 )) !=
    (k1=f1(s2, s1, h3 )) )
    {l1:
    P("test failure:"
    "s3=%s# s1=%s# s0=%s# s2=%s# k0=%u# k1=%u# len(s0)=%u h0=%u h1=%u
    giri=%u\n",
    s3, s1, s0, s2, (U)k0, (U)k1,(U)strlen(s0),(U)h0,(U)h1,
    (U)i);
    free(s0); free(s1); free(s2); free(s3);
    R 0;
    }
    if(strcmp(s0, s2)!=0)G l1;
    if(++i<cicli/50)G l0;
    i=0;
    l34:
    h1=rand()%len_s1; rand_phrase(s1, h1);
    if(h1==0) G l34;
    t0=time(0);
    l2:
    // h0=rand()%len_s0; rand_phrase(s0, h3);
    // h1=rand()%len_s1; rand_phrase(s1, h1);
    // h3=(h0+h1+1)%(len_s0);
    *s1=++*s1;
    if(f0(s0, s1, h1+1)==1234567) ++i;
    if(++i<cicli)G l2;
    t1=time(0);
    P("d_0=%f\n", difftime(t1,t0));
    i=0;
    t0=time(0);
    l3:
    // h0=rand()%len_s0; rand_phrase(s0, h0);
    // h1=rand()%len_s1; rand_phrase(s1, h1);
    // h3=(h0+h1+1)%(len_s0);
    *s1=++*s1;
    if(f1(s0, s1, h1+1)==1234567) ++i;
    if(++i<cicli)G l3;
    t1=time(0);
    P("d_1=%f\n", difftime(t1,t0));
    free(s0); free(s1); free(s2); free(s3);
    P("Test success\n");
    R 1;
    }


    int test1(cicli, len_s0, f0, f1)
    U cicli, len_s0;
    size_t (*f0)(char*), (*f1)(char*);
    {char *s0, *s1, *s2;
    size_t i, k0, k1, h0, h1, h3, len_s1=len_s0;
    time_t t0, t1;
    /*-------------------------------------{}*/
    if(cicli==0||len_s0==0||f0==0||f1==0)
    R 0;
    if(len_s0>100000)
    R 0;
    s0=malloc(len_s0);
    if(s0==0) R 0;
    if((s1=malloc(len_s1))==0)
    {free(s0); R 0;}
    if((s2=malloc(len_s0))==0)
    {free(s0);free(s1); R 0;}
    i=0;
    l0:
    h0=rand()%len_s0;
    rand_phrase(s0, h0);
    strcpy(s1, s0);
    if( (k0=f0(s0))!=(k1=f1(s1)) )
    {l1:
    P("test failure:"
    "s1=%s# s0=%s# s2=%s# k0=%u# k1=%u# len(s0)=%u h0=%u h1=%u
    giri=%u\n",
    s1, s0, s2, (U)k0, (U)k1,(U)strlen(s0),(U)h0,(U)h1, (U)i);
    free(s0); free(s1); free(s2);
    R 0;
    }
    if(strcmp(s0, s1)!=0)G l1;
    if(++i<cicli/50)G l0;
    i=0;
    l34:
    h1=rand()%len_s1; rand_phrase(s1, h1);
    if(h1==0) G l34;
    t0=time(0);
    l2:
    *s1=++*s1;
    if(f0(s1)==1234567) ++i;
    if(++i<cicli)G l2;
    t1=time(0);
    P("d_0=%f\n", difftime(t1,t0));
    i=0;
    t0=time(0);
    l3:
    *s1=++*s1;
    if(f1(s1)==1234567) ++i;
    if(++i<cicli)G l3;
    t1=time(0);
    P("d_1=%f\n", difftime(t1,t0));
    free(s0); free(s1); free(s2);
    P("Test success\n");
    R 1;
    }
    RoSsIaCrIiLoIA, Feb 5, 2005
    #6
  7. Keith Thompson wrote on 04/02/05 :
    > RoSsIaCrIiLoIA <> writes:
    >> Do you like my strlcpy strlcat etc? [snip]
    >> #define G goto
    >> #define U unsigned
    >> #define R return
    >> #define W while
    >> #define F for
    >> #define P printf
    >> #define B break

    > [snip]
    >
    > No.


    #define ooo goto
    #define ooO unsigned
    #define oOo return
    #define oOO while
    #define Ooo for
    #define OoO printf
    #define OOo break

    is more fun ...

    --
    Emmanuel
    The C-FAQ: http://www.eskimo.com/~scs/C-faq/faq.html
    The C-library: http://www.dinkumware.com/refxc.html

    "C is a sharp tool"
    Emmanuel Delahaye, Feb 5, 2005
    #7
  8. Emmanuel Delahaye <> scribbled the following:
    > #define ooo goto
    > #define ooO unsigned
    > #define oOo return
    > #define oOO while
    > #define Ooo for
    > #define OoO printf
    > #define OOo break


    > is more fun ...


    #define lll goto
    #define llI unsigned
    #define lIl return
    #define lII while
    #define Ill for
    #define IlI printf
    #define IIl break

    is even more fun, particularly when read in a sans-serif, preferably
    proportional, font.

    --
    /-- Joona Palaste () ------------- Finland --------\
    \-------------------------------------------------------- rules! --------/
    "I am lying."
    - Anon
    Joona I Palaste, Feb 5, 2005
    #8
  9. RoSsIaCrIiLoIA wrote:
    > Do you like my strlcpy strlcat etc?
    > Thank you
    > /*---------------------------------------*/
    > ....


    I think it could use some improvements:
    #define M main
    #define V void
    #define I int
    #define C char
    #define R return
    #define U unsigned
    #define G goto
    #define W while
    #define F for
    #define P printf
    #define B break
    #define SL strlen
    #define CC const char


    /************************************
    * You should be consistent throughout your program.
    * Consistency will help it run faster.
    ************************************/
    i M (v)
    {
    srand((U)time(0));
    test3(200000, 100, 100, strlcat, strlcat_m);
    test1(3000000, 100, revstring, revstring_m );
    R 0;
    } /* main, endswith */
    /* 25 + 25 + 10 = 60 0..59 */

    C lettere(U j)
    {C *u="abcdefghijklmnopqrstuvwyz"
    "ABCDEFGHIJKLMNOPQRSTUVWYZ"
    "0123456789";
    R u[j%60];
    }


    V rand_phrase(char* a, size_t le)
    {
    U i=0;
    /*------------------------------*/
    assert(a!=0);
    if(le==0) G l0;
    la: a=lettere((U)rand()); if(++i<le)G la;
    l0:
    a=0;
    }


    /* does searchme end with the phrase phrase? */
    /* By RoSsIaCrIiLoIA */
    I endswith_m(CC* phrase, CC* searchme)
    {CC *p1, *p2;
    I r=0;
    /*------------------------------*/
    assert(phrase!=0 && searchme!=0);
    p1= phrase +SL(phrase ); /**p1=*p2=0 */
    p2= searchme+SL(searchme); /*ok caso *p1=0 o *p2=0 */
    G l1;
    l0: --p1; --p2;
    l1: if(*p1!=*p2) G le;
    if(p2==searchme)
    {r=1;G le;}
    if(p1!=phrase)G l0;
    le:
    return r;
    }
    [snip]

    Since you don't want your programs easily readable
    by others, here are some tips to make it compile
    faster and to save time typing:
    1. Get rid of all unnecessary spaces.
    Spaces slow down the compilation phase.

    2. Be consistent with abbreviations.
    If you are going to use 'G' for 'goto', use
    it for all 'gotos'. This will help your produce
    programs faster since you don't have to type all
    those unnecessary letters.

    3. Get rid of all unnecessary line endings.
    Line-ends are considered "white-space" and the
    compiler must ignore them, wasting valuable
    compilation time. The more expressions and
    statements you can fit on a line, the better.

    4. Reduce length of variables and function names.
    This goes towards consistency and speed of
    compilation. More letters occupy more space in a
    compiler's symbol table. Also, more letters take
    more time to process.

    5. Comments slow down production.
    They slow down the compiler and slow down your
    typing. Produce more by typing less. After it
    works, you won't have to deal with it anyway.

    6. Use files sparingly.
    Each #include file requires time to open, parse, and
    close. Reduce the number in the source file.

    Also, place as many functions or code into fewer files.
    Again, the more files you have, the more time for
    compilation and linking. One file, one compilation,
    one linking, one program. Simple.

    If you want people to assist you with your program,
    you may have to make it readable and employ good coding
    styles, which may violate some of the above rules.
    You'll just have to decide which is more important.
    We can't do that for you.

    --
    Thomas Matthews

    C++ newsgroup welcome message:
    http://www.slack.net/~shiva/welcome.txt
    C++ Faq: http://www.parashift.com/c -faq-lite
    C Faq: http://www.eskimo.com/~scs/c-faq/top.html
    alt.comp.lang.learn.c-c++ faq:
    http://www.comeaucomputing.com/learn/faq/
    Other sites:
    http://www.josuttis.com -- C++ STL Library book
    http://www.sgi.com/tech/stl -- Standard Template Library
    Thomas Matthews, Feb 5, 2005
    #9
  10. Emmanuel Delahaye <> writes:
    > Keith Thompson wrote on 04/02/05 :
    >> RoSsIaCrIiLoIA <> writes:
    >>> Do you like my strlcpy strlcat etc? [snip]
    >>> #define G goto
    >>> #define U unsigned
    >>> #define R return
    >>> #define W while
    >>> #define F for
    >>> #define P printf
    >>> #define B break

    >> [snip]
    >>
    >> No.

    >
    > #define ooo goto
    > #define ooO unsigned
    > #define oOo return
    > #define oOO while
    > #define Ooo for
    > #define OoO printf
    > #define OOo break
    >
    > is more fun ...


    I prefer:

    #define O000 goto
    #define O00O unsigned
    #define O0O0 return
    #define O0OO while
    #define OO00 for
    #define OO0O printf
    #define OOO0 break

    --
    Keith Thompson (The_Other_Keith) <http://www.ghoti.net/~kst>
    San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
    We must do something. This is something. Therefore, we must do this.
    Keith Thompson, Feb 5, 2005
    #10
  11. RoSsIaCrIiLoIA

    CBFalconer Guest

    Emmanuel Delahaye wrote:
    > Keith Thompson wrote on 04/02/05 :
    > > RoSsIaCrIiLoIA <> writes:

    >
    > >> Do you like my strlcpy strlcat etc? [snip]
    > >> #define G goto
    > >> #define U unsigned
    > >> #define R return
    > >> #define W while
    > >> #define F for
    > >> #define P printf
    > >> #define B break

    > > [snip]
    > >
    > > No.

    >
    > #define ooo goto
    > #define ooO unsigned
    > #define oOo return
    > #define oOO while
    > #define Ooo for
    > #define OoO printf
    > #define OOo break
    >
    > is more fun ...


    Better yet, play with this:

    #define O00
    #define O0O
    #define O0o
    #define OO0
    #define OOO
    #define OOo
    #define Oo0
    #define OoO
    #define Ooo
    #define o00
    #define o0O
    #define o0o
    #define oO0
    #define oOO
    #define oOo
    #define oo0
    #define ooO
    #define ooo

    (yes, they are all distinct (18) and legal identifiers) They are
    in sorted order for ASCII.

    --
    "If you want to post a followup via groups.google.com, don't use
    the broken "Reply" link at the bottom of the article. Click on
    "show options" at the top of the article, then click on the
    "Reply" at the bottom of the article headers." - Keith Thompson
    CBFalconer, Feb 5, 2005
    #11
  12. RoSsIaCrIiLoIA

    CBFalconer Guest

    CBFalconer wrote:
    >
    > Emmanuel Delahaye wrote:
    > > Keith Thompson wrote on 04/02/05 :
    > > > RoSsIaCrIiLoIA <> writes:

    > >
    > > >> Do you like my strlcpy strlcat etc? [snip]
    > > >> #define G goto
    > > >> #define U unsigned
    > > >> #define R return
    > > >> #define W while
    > > >> #define F for
    > > >> #define P printf
    > > >> #define B break
    > > > [snip]
    > > >
    > > > No.

    > >
    > > #define ooo goto
    > > #define ooO unsigned
    > > #define oOo return
    > > #define oOO while
    > > #define Ooo for
    > > #define OoO printf
    > > #define OOo break
    > >
    > > is more fun ...

    >
    > Better yet, play with this:
    >
    > #define O00
    > #define O0O
    > #define O0o
    > #define OO0
    > #define OOO
    > #define OOo
    > #define Oo0
    > #define OoO
    > #define Ooo
    > #define o00
    > #define o0O
    > #define o0o
    > #define oO0
    > #define oOO
    > #define oOo
    > #define oo0
    > #define ooO
    > #define ooo
    >
    > (yes, they are all distinct (18) and legal identifiers) They are
    > in sorted order for ASCII.


    and here's another set of 120:

    O000 O001
    O00O O00l O010 O011 O01O O01l O0O0 O0O1
    O0OO O0Ol O0l0 O0l1 O0lO O0ll O100 O101
    O10O O10l O110 O111 O11O O11l O1O0 O1O1
    O1OO O1Ol O1l0 O1l1 O1lO O1ll OO00 OO01
    OO0O OO0l OO10 OO11 OO1O OO1l OOO0 OOO1
    OOOO OOOl OOl0 OOl1 OOlO OOll Ol00 Ol01
    Ol0O Ol0l Ol10 Ol11 Ol1O Ol1l OlO0 OlO1
    OlOO OlOl Oll0 Oll1 OllO Olll l000 l001
    l00O l00l l010 l011 l01O l01l l0O0 l0O1
    l0OO l0Ol l0l0 l0l1 l0lO l0ll l100 l101
    l10O l10l l110 l111 l11O l11l l1O0 l1O1
    l1OO l1Ol l1l0 l1l1 l1lO l1ll lO00 lO01
    lO0O lO0l lO10 lO11 lO1O lO1l lOO0 lOO1
    lOOO lOOl lOl0 lOl1 lOlO lOll ll00 ll01
    ll0O ll0l ll10 ll11 ll1O ll1l llO0 llO1
    llOO llOl lll0 lll1 lllO llll

    --
    "If you want to post a followup via groups.google.com, don't use
    the broken "Reply" link at the bottom of the article. Click on
    "show options" at the top of the article, then click on the
    "Reply" at the bottom of the article headers." - Keith Thompson
    CBFalconer, Feb 6, 2005
    #12
  13. "Johan" <> writes:
    > No,
    >
    > Real programmers do not use goto statements
    >
    > john


    Not true. Real programmers (at least good ones) do not use goto
    statements inappropriately. They actually do have legitimate uses.
    The real problem with goto statements is that misuse can create
    spaghetti code. (Personally, I think a goto statement is often a sign
    that the language is missing a feature that would make it unnecessary,
    such as multi-level break or exception handling.)

    Of course if you want to avoid them altogether yourself, that's fine.

    But there are other reasons to dislike RoSsIaCrIiLoIA's code, which
    we've discussed here before.

    BTW, please don't top-post, and please don't quote hundreds of lines
    of a previous article just to make a single comment.

    --
    Keith Thompson (The_Other_Keith) <http://www.ghoti.net/~kst>
    San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
    We must do something. This is something. Therefore, we must do this.
    Keith Thompson, Feb 6, 2005
    #13
  14. RoSsIaCrIiLoIA

    CBFalconer Guest

    Johan wrote:
    >
    > No,
    >
    > Real programmers do not use goto statements


    To spout this incorrect homily you had to quote over 300 lines of
    nonsense? and top-post into the bargain! Well done, oh foul and
    feckless critter.

    --
    "If you want to post a followup via groups.google.com, don't use
    the broken "Reply" link at the bottom of the article. Click on
    "show options" at the top of the article, then click on the
    "Reply" at the bottom of the article headers." - Keith Thompson
    CBFalconer, Feb 6, 2005
    #14
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Aleksandar Milivojevic

    return value of strlcat

    Aleksandar Milivojevic, May 4, 2004, in forum: C Programming
    Replies:
    5
    Views:
    557
    Aleksandar Milivojevic
    May 5, 2004
  2. Patrick Kowalzick
    Replies:
    5
    Views:
    461
    Patrick Kowalzick
    Mar 14, 2006
  3. strlcpy and strlcat

    , Dec 6, 2007, in forum: C Programming
    Replies:
    15
    Views:
    1,521
    CBFalconer
    Dec 11, 2007
  4. Kevin Walzer

    Re: PIL (etc etc etc) on OS X

    Kevin Walzer, Aug 1, 2008, in forum: Python
    Replies:
    4
    Views:
    374
    Fredrik Lundh
    Aug 13, 2008
  5. Amy Lee

    Help: undefined symbol: strlcpy

    Amy Lee, Jan 17, 2008, in forum: Perl Misc
    Replies:
    2
    Views:
    241
    Ben Morrow
    Jan 17, 2008
Loading...

Share This Page