/****************************************************************
 * 処理系の変数値の有効範囲をチェックするプログラム             *
 * ANSI C 準拠の命令のみ使用(でないのが紛れていましたらm(_)m)   *
 * This Program Version 1.1                                     *
 *                                                              *
 * 制作環境…DJGPP Version 2.02                                 *
 * 制作者…やすっち                                             *
 *                                                              *
 * 使用する場合は拡張子txtを取り除いてください                  *
 *                                                              *
 * 注意事項…                                                   *
 * 仕様上処理系によりオーバーフローがらみの警告が出る           *
 * 可能性があります。                                           *
 * またどうしてもコンパイルが通らない時はコメントを             *
 * 全て消してみると動く場合もあります。                         *
 * また処理を速くする為の命令部を取り除いても                   *
 * 表示結果には特に影響はありませんが、 処理系により            *
 * 大幅に処理が遅くなってしまう場合があります。                 *
 *                                                              *
 * 参考情報…                                                   *
 * 無符号unsignedの有効範囲は、                                 *
 * 0 から 2^bit-1 まで。                                        *
 * 有符号signedの有効範囲は、                                   *
 * -(2^(bit-1)) から 2^(bit-1)-1 まで。                         *
 * byte(バイト) = 8bit(ビット)                                  *
 ***************************************************************/


/****************************
 *  インクルードファイル    *
 ***************************/

#include <stdio.h>


/****************************
 *  関数プロトタイプ        *
 ***************************/

void    UcharCheck(void);
void    ScharCheck(void);
void    UintCheck(void);
void    SintCheck(void);
void    UshortCheck(void);
void    SshortCheck(void);
void    UlongCheck(void);
void    SlongCheck(void);


/****************************
 *  メイン関数              *
 ***************************/

int     main(void)
{
    printf("処理系の変数値の有効範囲をチェックするプログラム\n");
    printf("Version1.1 やすっち\n\n");
    printf("このプログラムをコンパイルした処理系の有効範囲検査の結果\n");
    
    UcharCheck();
    ScharCheck();
    UintCheck();
    SintCheck();
    UshortCheck();
    SshortCheck();
    UlongCheck();
    SlongCheck();
    
    return 0;
}


/****************************
 *  マクロ関数群            *
 ***************************/

/* 無符号整数型汎用オーバーフローチェックマクロ関数 */
#define U_Check(data,save)                                              \
{                                                                       \
    data = 0;                                                           \
    save = 0;                                                           \
    /* 処理時間を速くする為に大まかな検索開始位置を決定する */          \
    while(1){                                                           \
        if(data < save){                                                \
            data = save;                                                \
            break;                                                      \
        } else {                                                        \
            save = data;                                                \
        }                                                               \
        data += 1000;                                                   \
    }                                                                   \
    /* 開始位置からオーバーフロー値を正確に調べる */                    \
    while(1){                                                           \
        data++;                                                         \
        if(data == 0){                                                  \
            break;                                                      \
        } else {                                                        \
            save = data;                                                \
        }                                                               \
    }                                                                   \
}

/* 有符号整数型汎用オーバーフローチェックマクロ関数 */
#define S_Check(data,save1,save2)                                       \
{                                                                       \
    data = 0;                                                           \
    save1 = 0;                                                          \
    /* 処理時間を速くする為に大まかな検索開始位置を決定する */          \
    while(1){                                                           \
        if(data > save1){                                               \
            data = save1;                                               \
            break;                                                      \
        } else {                                                        \
            save1 = data;                                               \
        }                                                               \
        data -= 1000;                                                   \
    }                                                                   \
    /* 開始位置からオーバーフロー値を正確に調べる */                    \
    while(1){                                                           \
        data--;                                                         \
        if(data > 0){                                                   \
            break;                                                      \
        } else {                                                        \
            save1 = data;                                               \
        }                                                               \
    }                                                                   \
                                                                        \
    data = 0;                                                           \
    save2 = 0;                                                          \
    /* 処理時間を速くする為に大まかな検索開始位置を決定する */          \
    while(1){                                                           \
        if(data < save2){                                               \
            data = save2;                                               \
            break;                                                      \
        } else {                                                        \
            save2 = data;                                               \
        }                                                               \
        data += 1000;                                                   \
    }                                                                   \
    /* 開始位置からオーバーフロー値を正確に調べる */                    \
    while(1){                                                           \
        data++;                                                         \
        if(data < 0){                                                   \
            break;                                                      \
        } else {                                                        \
            save2 = data;                                               \
        }                                                               \
    }                                                                   \
}


/****************************
 *  サブルーチン関数群      *
 ***************************/

/* unsigned char 型のオーバーフローチェック */
void    UcharCheck(void)
{
    unsigned char   data,save;
    
    U_Check(data,save);
    printf("unsigned char型の範囲は 0〜%u\n",save);
}

/* signed char 型のオーバーフローチェック */
void    ScharCheck(void)
{
    signed char     data,save1,save2;
    
    S_Check(data,save1,save2);
    printf("signed char型の範囲は %d〜%u\n",save1,save2);
}


/* unsigned int 型のオーバーフローチェック */
void    UintCheck(void)
{
    unsigned int    data,save;
    
    U_Check(data,save);
    printf("unsined int型の範囲は 0〜%u\n",save);
}

/* signed int 型のオーバーフローチェック */
void    SintCheck(void)
{
    signed int  data,save1,save2;
    
    S_Check(data,save1,save2);
    printf("signed int型の範囲は %d〜%u\n",save1,save2);
}


/* unsigned short int 型のオーバーフローチェック */
void    UshortCheck(void)
{
    unsigned short int  data,save;
    
    U_Check(data,save);
    printf("unsined short int型の範囲は 0〜%u\n",save);
}

/* signed short int 型のオーバーフローチェック */
void    SshortCheck(void)
{
    signed short int    data,save1,save2;
    
    S_Check(data,save1,save2);
    printf("signed short int型の範囲は %d〜%u\n",save1,save2);
}


/* unsigned long int 型のオーバーフローチェック */
void    UlongCheck(void)
{
    unsigned long int   data,save;
    
    U_Check(data,save);
    printf("unsined long int型の範囲は 0〜%u\n",save);
}

/* signed long int 型のオーバーフローチェック */
void    SlongCheck(void)
{
    signed long int     data,save1,save2;
    
    S_Check(data,save1,save2);
    printf("signed long int型の範囲は %d〜%u\n",save1,save2);
}