windows下的getopt/getoptlong函數

getopt/getopt_long函數是GNU C中的函數，在linux編程中很常用到。這里就不介紹了。

windows下沒有找到類似的函數，自己寫一個又浪費時間，於是乎從glibc中找出來。

這里放出兩個版本的下載地址

http://files.cnblogs.com/files/oloroso/getopt--from-glibc-2.15.tar.gz

http://files.cnblogs.com/files/oloroso/getopt-win-from-glibc-2.2.5.tar.gz

下載GLibC源碼

首先需要下載glibC的源代碼文件，這個文件比較大，但是我們只需要其中的幾個文件而已。

如果是后面給出的鏈接下載的glibc源碼包，只需要兩個文件。如果是比較新版本的glibc，可能需要四個文件(getopt.h/getopt_int.h/getopt.c/getopt_init.c)

這個只需要圖中所示的兩個文件即可。下載之后找到這兩個文件解壓出來即可。

下載地址  http://ftp.ntu.edu.tw/gnu/libc/#glibc-2.2.5.tar.gz

這是glibc-2.2.5的壓縮包中間提取的文件

下面是glibc-2.15中需要提取的文件

修改getopt.c

gettext.h頭文件不存在問題（glibc-2.15）

首先需要修改的是沒有“gettext.h”這個頭文件的問題。這里直接將其注釋掉，然后修改后面的宏定義。

這個修改僅是glibc-2.15版本中，如果是glibc-2.2.5版本的，是沒有這個問題的。

將下面的代碼（大概在70行）

#ifdef _LIBC
# include <libintl.h>
#else
# include "gettext.h"
# define _(msgid) gettext (msgid)
#endif

修改為

#ifdef _LIBC
# include <libintl.h>
#else
//# include "gettext.h"
# define _(msgid)  (msgid)
#endif

修改后

 

alloca的問題(無法解析的外部符號 _alloca)(glibc-2.15)

關於alloca這個函數，從百度百科中摘抄下來一點。

alloca內存分配函數,與malloc,calloc,realloc類似。但是注意一個重要的區別,_alloca是在棧(stack)上申請空間,用完馬上就釋放.

包含在頭文件malloc.h中.在某些系統中會宏定義成_alloca使用。

在glibc-2.2.5版本是沒有這個問題的，這個問題存在於glibc-2.15版本中。

編譯生成的時候會報錯

1>  getopt.c
1>e:\getopt-win\getopt.c(571): warning C4013: “alloca”未定義；假設外部返回 int
1>e:\getopt-win\getopt.c(571): warning C4047: “初始化”:“option_list *”與“int”的間接級別不同
1>getopt.obj : error LNK2019: 無法解析的外部符號 _alloca，該符號在函數 __getopt_internal_r 中被引用

這里保存的原因是alloca這個函數沒有定義，那么我們使用已經定義好的版本就是了。修改成如下圖所示即可

 

strings.h頭文件不存在問題（glibc-2.2.5）

這個修改和前面的gettext.h文件的修改類似，但是區別是這個問題在glibc-2.15中不存在。

這里的修改很簡單，添加一個 HAVE_STRING_H 的宏定義即可。

修改前                                                                      修改后

 

添加getopt_long/getopt_long_only的定義

這兩個函數在getopt.h文件中聲明了，但是其定義在getopt1.c中，可以直接將getopt1.c文件也拿過來用。因為這個文件中的內容不多，為了減少文件的數量，直接將其中有用的部分拷貝到getopt.c文件中是個不錯的主意。

glibc-2.2.5版本中，要拷貝的內容如下

int
getopt_long (argc, argv, options, long_options, opt_index)
     int argc;
     char *const *argv;
     const char *options;
     const struct option *long_options;
     int *opt_index;
{
  return _getopt_internal (argc, argv, options, long_options, opt_index, 0);
}

/* Like getopt_long, but '-' as well as '--' can indicate a long option.
   If an option that starts with '-' (not '--') doesn't match a long option,
   but does match a short option, it is parsed as a short option
   instead.  */

int
getopt_long_only (argc, argv, options, long_options, opt_index)
     int argc;
     char *const *argv;
     const char *options;
     const struct option *long_options;
     int *opt_index;
{
  return _getopt_internal (argc, argv, options, long_options, opt_index, 1);
}

 

如果是glibc-2.15版本的，除了這兩個函數之外，還有兩個可重入版本的可以添加進去

int
getopt_long(int argc, char *const *argv, const char *options,
const struct option *long_options, int *opt_index)
{
    return _getopt_internal(argc, argv, options, long_options, opt_index, 0, 0);
}

int
_getopt_long_r(int argc, char *const *argv, const char *options,
const struct option *long_options, int *opt_index,
struct _getopt_data *d)
{
    return _getopt_internal_r(argc, argv, options, long_options, opt_index,
        0, d, 0);
}

/* Like getopt_long, but '-' as well as '--' can indicate a long option.
If an option that starts with '-' (not '--') doesn't match a long option,
but does match a short option, it is parsed as a short option
instead.  */

int
getopt_long_only (int argc, char *const *argv, const char *options,
const struct option *long_options, int *opt_index)
{
    return _getopt_internal (argc, argv, options, long_options, opt_index, 1, 0);
}

int
_getopt_long_only_r(int argc, char *const *argv, const char *options,
const struct option *long_options, int *opt_index,
struct _getopt_data *d)
{
    return _getopt_internal_r(argc, argv, options, long_options, opt_index,
        1, d, 0);
}

 

測試一下

經過上面的修改，可以進行一點簡單的測試了。

測試用例不用自己寫了，在getopt.c和getopt1.c文件中都有，直接拿過來用了。

這里測試的時候沒有區分是glibc-2.2.5還是glibc-2.15版本的getopt/getopt_long，因為兩個測試的結果是一樣的。

getopt()函數的測試

測試代碼

#include "getopt.h"
#include <stdlib.h>
#include <stdio.h>

int
main(int argc, char **argv)
{
    int c;
    int digit_optind = 0;

    while (1)
    {
        int this_option_optind = optind ? optind : 1;

        c = getopt(argc, argv, "abc:d:0123456789");
        if (c == -1)
            break;

        switch (c)
        {
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                if (digit_optind != 0 && digit_optind != this_option_optind)
                    printf("digits occur in two different argv-elements.\n");
                digit_optind = this_option_optind;
                printf("option %c\n", c);
                break;
            case 'a':
                printf("option a\n");
                break;
            case 'b':
                printf("option b\n");
                break;
            case 'c':
                printf("option c with value '%s'\n", optarg);
                break;
            case '?':
                break;
            default:
                printf("?? getopt returned character code 0%o ??\n", c);
        }
    }

    if (optind < argc)
    {
        printf("non-option ARGV-elements: ");
        while (optind < argc)
            printf("%s ", argv[optind++]);
        printf("\n");
    }

    exit(0);
}

測試結果

getopt_long的測試

#include "getopt.h"
#include <stdlib.h>
#include <stdio.h>
int
main(argc, argv)
    int argc;        //這是早期的C語言函數參數的寫法
    char **argv;    //現在不提倡這么寫
{
    int c;
    int digit_optind = 0;

    while (1)
    {
        int this_option_optind = optind ? optind : 1;
        int option_index = 0;
        static struct option long_options[] =
        {
            { "add", 1, 0, 0 },
            { "append", 0, 0, 0 },
            { "delete", 1, 0, 0 },
            { "verbose", 0, 0, 0 },
            { "create", 0, 0, 0 },
            { "file", 1, 0, 0 },
            { 0, 0, 0, 0 }
        };

        c = getopt_long(argc, argv, "abc:d:0123456789",
            long_options, &option_index);
        if (c == -1)
            break;

        switch (c)
        {
            case 0:
                printf("option %s", long_options[option_index].name);
                if (optarg)
                    printf(" with arg %s", optarg);
                printf("\n");
                break;

            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                if (digit_optind != 0 && digit_optind != this_option_optind)
                    printf("digits occur in two different argv-elements.\n");
                digit_optind = this_option_optind;
                printf("option %c\n", c);
                break;
            case 'a':
                printf("option a\n");
                break;
            case 'b':
                printf("option b\n");
                break;
            case 'c':
                printf("option c with value `%s'\n", optarg);
                break;
            case 'd':
                printf("option d with value `%s'\n", optarg);
                break;
            case '?':
                break;
            default:
                printf("?? getopt returned character code 0%o ??\n", c);
        }
    }

    if (optind < argc)
    {
        printf("non-option ARGV-elements: ");
        while (optind < argc)
            printf("%s ", argv[optind++]);
        printf("\n");
    }

    exit(0);
}

 測試結果