//if CPU is of big endian, return 0, if little endian,
//  return 1
int checkCPU(){
    union w{
        int  a;
        char b;
    } c;
    c.a = 1;
    return c.b == 1;
}

#define swap32Endian(x)    (((x)&(0x0000ffff)) << 32 | ((x)&(0xffff0000) >> 32)
#define swap64Endian(x)    (((x)&(0x00000000ffffffff)) >> 64 | ((x)&(0xffffffff00000000) >>64)

char *do_strcat(char *dst, const char *src){
    if(!src || !*src){
        return dst;
    }
    char *ret = dst;
    while(*dst){dst++;}; //move to the end
    while(*dst++ = *src++); //copy util reach '\0'
    return ret;
}

void reverseString(char* s, int sSize){
    if(!s || sSize <= 1){
        return;
    }
    
    char *pbeg = s, *pend = s + sSize - 1;
    char tmp;
    while(pbeg < pend){
        tmp = *pbeg;
        *pbeg = *pend;
        *pend = tmp;
        pbeg++;
        pend--;
    }
    
    return;
}

int max(int a, int b){
    return a >= b ? a : b;
}

char * addStrings(char * num1, char * num2){
    int res_len = max(strlen(num1), strlen(num2)) + 2;
    char *res = (char *)calloc(sizeof(char), res_len);
    char *cur = res;
    int carry = 0, n1, n2, n3 = 0;
    reverseString(num1, strlen(num1));
    reverseString(num2, strlen(num2));
    while(*num1 || *num2){
        n1 = *num1 ? *num1 - '0' : 0;
        n2 = *num2 ? *num2 - '0' : 0;
        *cur = (n1 + n2 + carry)%10 + '0';
        carry = (n1 + n2 + carry)/10;
        if(*num1){num1++;}
        if(*num2){num2++;}
        cur++;
    }
    if(carry > 0){
        *cur = carry + '0';
        cur++;
    }
    reverseString(res, strlen(res));
    return res;
}

int do_strcmp(const char *src, const char *dst){
    int ret = 0;
    while(!(ret = *src - *dst) && *dst && *src){
        src++;
        dst++;
    }
    if(ret < 0){
        ret = -1;
    }else if(ret > 0){
        ret = 1;
    }else{
        if(!*dst && !*src){
        }else if(!*src){
            ret = 1; //src is longer, thus greater
        }else{
            ret = -1;
        }
    }
    
    return ret;
}

bool isPalindrome(char * s){
    const char *beg = s, *end = s;
    while(*end != '\0'){
        end++;
    }
    end--; //move to the last character
    
    while(beg < end){
        //skip no alp or num char
        while(*beg != '\0' && !isalnum(*beg)){beg++;}
        while(end > beg && !isalnum(*end)){end--;}
        if(end <= beg){
            break;
        }
        //check if ok
        if(*beg - *end == 0 || 
          (isalpha(*beg) && isalpha(*end) && abs(*beg - *end) == 'a' - 'A' )){      
        }else{return false;}
        beg++;
        end--;
    }
    
    return true;
}

char * reverseWords(char * s){
    if(!s){
        return NULL;
    }
    
    char *beg = s, *end = s, *cur = s;
    char tmp;
    while(*cur++){
        if(isspace(*cur) || !*cur){
            end = cur - 1;
            //reverse each word
            while(beg < end){
                tmp = *beg;
                *beg = *end;
                *end = tmp;
                beg++;
                end--;
            }
            beg = end = cur + 1;
        }
    }
    
    beg = s;
    end = cur - 2;
    //reverse the whole sentence
    while(beg < end){
        tmp = *beg;
        *beg = *end;
        *end = tmp;
        beg++;
        end--;        
    }

    return s;
}

int get_strlen(const char *src){
    if(!src){
        return 0;
    }

    const char *tail = src;
    while(*tail++ != '\0'); //指向‘\0’之后一个位置
    return tail - src - 1; //不包括'\0'
}

int strStr(char * haystack, char * needle){
    if(!haystack || !needle){
        return 0; //null str
    }
    if(!*haystack && !*needle){
        return 0; //empty str
    }
    const char *ph = haystack, *pn = needle, *start = NULL;
    while(*ph){
        start = ph; //记录主串开始扫描的位置
        pn = needle;
        do{
            if(!*pn){ //子串扫描完成，找到答案
                return start - haystack;
            }
        }while(*pn++ == *ph++); //比较，推进子串和主串
        ph = start+1;
    }
    
    return -1;

char * do_strcpy(char * dst, const char *src){
    if(!dst || !src){
        return NULL;
    }

    char *dst_cp = dst;
    //先复制，后移动指针，复制完‘\0’后退出循环
    while((*dst++ = *src++) != '\0'){}
    return dst_cp;
}

void *do_memcpy(void *to, void *from, size_t n){
    if(!to || !from){
        return NULL;
    }

    char *to_cp = (char*)to;
    char *from_cp = (char*)from; //指针运算前先转成char*
    while(n--){
        *to_cp++ = *from_cp++;
    }
    return to;
}

    //char *str[] = {"Welcom", "to", "Fortemedia", "Nanjing"};
    //A, B, C, D
    const char *str[] = {"Welcom", "to", "Fortemedia", "Nanjing"};
    const char **p = str + 1; //p : address of "to", B
    str[0] = (*p++)+2; //NULL, p: C, 
    str[1] = *(p+1); //"Nanjing", D
    str[2] = p[1] + 3; //"jing", D[3]
    str[3] = p[0] + (str[2] - str[1]); // "g", p[0] + 3

    printf("str[0]: %s, str[1]: %s, str[2]: %s, str[3]: %s \n",
        str[0], str[1], str[2], str[3]);

    float score[] = {10, 20, 30 ,40};
    int (*p)(int, int);
    float *q = ret_ele_at(score+1, 1); //30.0 //指针函数
    p = ret_max;
    int a = (*p)(1, 2); //2 //函数指针
    printf("a: %d, *q: %f\n", a, *q);