From 238c37388ba3ce1b32db2410724319a4049d6a55 Mon Sep 17 00:00:00 2001 From: CentOS Sources Date: Nov 03 2021 00:19:09 +0000 Subject: import fribidi-1.0.10-6.el9 --- diff --git a/.fribidi.metadata b/.fribidi.metadata new file mode 100644 index 0000000..291cda6 --- /dev/null +++ b/.fribidi.metadata @@ -0,0 +1 @@ +e22d6cf070966d2735b8e1a6d961a87f1e828a99 SOURCES/fribidi-1.0.10.tar.xz diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..50a3946 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +SOURCES/fribidi-1.0.10.tar.xz diff --git a/SOURCES/fribidi-drop-bundled-gnulib.patch b/SOURCES/fribidi-drop-bundled-gnulib.patch new file mode 100644 index 0000000..7857369 --- /dev/null +++ b/SOURCES/fribidi-drop-bundled-gnulib.patch @@ -0,0 +1,1870 @@ +diff -pruN fribidi-1.0.10.orig/bin/Makefile.am fribidi-1.0.10/bin/Makefile.am +--- fribidi-1.0.10.orig/bin/Makefile.am 2020-07-06 04:17:23.000000000 +0900 ++++ fribidi-1.0.10/bin/Makefile.am 2020-07-07 21:09:49.076237457 +0900 +@@ -2,11 +2,9 @@ bin_PROGRAMS = fribidi + + noinst_PROGRAMS = fribidi-benchmark fribidi-bidi-types fribidi-caprtl2utf8 + +-getopt_SOURCES = getopt.c getopt1.c getopt_int.h getopt.h gettext.h ++fribidi_SOURCES = fribidi-main.c + +-fribidi_SOURCES = fribidi-main.c $(getopt_SOURCES) +- +-fribidi_benchmark_SOURCES = fribidi-benchmark.c $(getopt_SOURCES) ++fribidi_benchmark_SOURCES = fribidi-benchmark.c + + AM_CPPFLAGS = \ + @FRIBIDI_CPPFLAGS@ \ +diff -pruN fribidi-1.0.10.orig/bin/getopt.c fribidi-1.0.10/bin/getopt.c +--- fribidi-1.0.10.orig/bin/getopt.c 2015-08-05 03:49:07.000000000 +0900 ++++ fribidi-1.0.10/bin/getopt.c 1970-01-01 09:00:00.000000000 +0900 +@@ -1,1268 +0,0 @@ +-/* Getopt for GNU. +- NOTE: getopt is now part of the C library, so if you don't know what +- "Keep this file name-space clean" means, talk to drepper@gnu.org +- before changing it! +- Copyright (C) 1987,88,89,90,91,92,93,94,95,96,98,99,2000,2001,2002,2003,2004 +- Free Software Foundation, Inc. +- This file is part of the GNU C Library. +- +- This program is free software; you can redistribute it and/or modify +- it under the terms of the GNU General Public License as published by +- the Free Software Foundation; either version 2, or (at your option) +- any later version. +- +- This program is distributed in the hope that it will be useful, +- but WITHOUT ANY WARRANTY; without even the implied warranty of +- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +- GNU General Public License for more details. +- +- You should have received a copy of the GNU General Public License along +- with this program; if not, write to the Free Software Foundation, +- Inc., 59 Temple Place - Suite 330, Boston, MA 02110-1301, USA. */ +- +-/* This tells Alpha OSF/1 not to define a getopt prototype in . +- Ditto for AIX 3.2 and . */ +-#ifndef _NO_PROTO +-# define _NO_PROTO +-#endif +- +-#ifdef HAVE_CONFIG_H +-# include +-#endif +- +-#include +- +-/* Comment out all this code if we are using the GNU C Library, and are not +- actually compiling the library itself. This code is part of the GNU C +- Library, but also included in many other GNU distributions. Compiling +- and linking in this code is a waste when using the GNU C library +- (especially if it is a shared library). Rather than having every GNU +- program understand `configure --with-gnu-libc' and omit the object files, +- it is simpler to just do this in the source for each such file. */ +- +-#define GETOPT_INTERFACE_VERSION 2 +-#if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2 +-# include +-# if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION +-# define ELIDE_CODE +-# endif +-#endif +- +-#ifndef ELIDE_CODE +- +- +-/* This needs to come after some library #include +- to get __GNU_LIBRARY__ defined. */ +-#ifdef __GNU_LIBRARY__ +-/* Don't include stdlib.h for non-GNU C libraries because some of them +- contain conflicting prototypes for getopt. */ +-# include +-# include +-#endif /* GNU C library. */ +- +-#include +- +-#ifdef VMS +-# include +-#endif +- +-#ifdef _LIBC +-# include +-#else +-# include "gettext.h" +-# define _(msgid) gettext (msgid) +-#endif +- +-#if defined _LIBC && defined USE_IN_LIBIO +-# include +-#endif +- +-#ifndef attribute_hidden +-# define attribute_hidden +-#endif +- +-/* This version of `getopt' appears to the caller like standard Unix `getopt' +- but it behaves differently for the user, since it allows the user +- to intersperse the options with the other arguments. +- +- As `getopt' works, it permutes the elements of ARGV so that, +- when it is done, all the options precede everything else. Thus +- all application programs are extended to handle flexible argument order. +- +- Setting the environment variable POSIXLY_CORRECT disables permutation. +- Then the behavior is completely standard. +- +- GNU application programs can use a third alternative mode in which +- they can distinguish the relative order of options and other arguments. */ +- +-#include "getopt.h" +-#include "getopt_int.h" +- +-/* For communication from `getopt' to the caller. +- When `getopt' finds an option that takes an argument, +- the argument value is returned here. +- Also, when `ordering' is RETURN_IN_ORDER, +- each non-option ARGV-element is returned here. */ +- +-char *optarg; +- +-/* Index in ARGV of the next element to be scanned. +- This is used for communication to and from the caller +- and for communication between successive calls to `getopt'. +- +- On entry to `getopt', zero means this is the first call; initialize. +- +- When `getopt' returns -1, this is the index of the first of the +- non-option elements that the caller should itself scan. +- +- Otherwise, `optind' communicates from one call to the next +- how much of ARGV has been scanned so far. */ +- +-/* 1003.2 says this must be 1 before any call. */ +-int optind = 1; +- +-/* Callers store zero here to inhibit the error message +- for unrecognized options. */ +- +-int opterr = 1; +- +-/* Set to an option character which was unrecognized. +- This must be initialized on some systems to avoid linking in the +- system's own getopt implementation. */ +- +-int optopt = '?'; +- +-/* Keep a global copy of all internal members of getopt_data. */ +- +-static struct _getopt_data getopt_data; +- +- +-#ifndef __GNU_LIBRARY__ +- +-/* Avoid depending on library functions or files +- whose names are inconsistent. */ +- +-#ifndef getenv +-extern char *getenv ( +-); +-#endif +- +-#endif /* not __GNU_LIBRARY__ */ +- +-#ifdef _LIBC +-/* Stored original parameters. +- XXX This is no good solution. We should rather copy the args so +- that we can compare them later. But we must not use malloc(3). */ +-extern int __libc_argc; +-extern char **__libc_argv; +- +-/* Bash 2.0 gives us an environment variable containing flags +- indicating ARGV elements that should not be considered arguments. */ +- +-# ifdef USE_NONOPTION_FLAGS +-/* Defined in getopt_init.c */ +-extern char *__getopt_nonoption_flags; +-# endif +- +-# ifdef USE_NONOPTION_FLAGS +-# define SWAP_FLAGS(ch1, ch2) \ +- if (d->__nonoption_flags_len > 0) \ +- { \ +- char __tmp = __getopt_nonoption_flags[ch1]; \ +- __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2]; \ +- __getopt_nonoption_flags[ch2] = __tmp; \ +- } +-# else +-# define SWAP_FLAGS(ch1, ch2) +-# endif +-#else /* !_LIBC */ +-# define SWAP_FLAGS(ch1, ch2) +-#endif /* _LIBC */ +- +-/* Exchange two adjacent subsequences of ARGV. +- One subsequence is elements [first_nonopt,last_nonopt) +- which contains all the non-options that have been skipped so far. +- The other is elements [last_nonopt,optind), which contains all +- the options processed since those non-options were skipped. +- +- `first_nonopt' and `last_nonopt' are relocated so that they describe +- the new indices of the non-options in ARGV after they are moved. */ +- +-static void +-exchange ( +- char **argv, +- struct _getopt_data *d +-) +-{ +- int bottom = d->__first_nonopt; +- int middle = d->__last_nonopt; +- int top = d->optind; +- char *tem; +- +- /* Exchange the shorter segment with the far end of the longer segment. +- That puts the shorter segment into the right place. +- It leaves the longer segment in the right place overall, +- but it consists of two parts that need to be swapped next. */ +- +-#if defined _LIBC && defined USE_NONOPTION_FLAGS +- /* First make sure the handling of the `__getopt_nonoption_flags' +- string can work normally. Our top argument must be in the range +- of the string. */ +- if (d->__nonoption_flags_len > 0 && top >= d->__nonoption_flags_max_len) +- { +- /* We must extend the array. The user plays games with us and +- presents new arguments. */ +- char *new_str = malloc (top + 1); +- if (new_str == NULL) +- d->__nonoption_flags_len = d->__nonoption_flags_max_len = 0; +- else +- { +- memset (__mempcpy (new_str, __getopt_nonoption_flags, +- d->__nonoption_flags_max_len), +- '\0', top + 1 - d->__nonoption_flags_max_len); +- d->__nonoption_flags_max_len = top + 1; +- __getopt_nonoption_flags = new_str; +- } +- } +-#endif +- +- while (top > middle && middle > bottom) +- { +- if (top - middle > middle - bottom) +- { +- /* Bottom segment is the short one. */ +- int len = middle - bottom; +- register int i; +- +- /* Swap it with the top part of the top segment. */ +- for (i = 0; i < len; i++) +- { +- tem = argv[bottom + i]; +- argv[bottom + i] = argv[top - (middle - bottom) + i]; +- argv[top - (middle - bottom) + i] = tem; +- SWAP_FLAGS (bottom + i, top - (middle - bottom) + i); +- } +- /* Exclude the moved bottom segment from further swapping. */ +- top -= len; +- } +- else +- { +- /* Top segment is the short one. */ +- int len = top - middle; +- register int i; +- +- /* Swap it with the bottom part of the bottom segment. */ +- for (i = 0; i < len; i++) +- { +- tem = argv[bottom + i]; +- argv[bottom + i] = argv[middle + i]; +- argv[middle + i] = tem; +- SWAP_FLAGS (bottom + i, middle + i); +- } +- /* Exclude the moved top segment from further swapping. */ +- bottom += len; +- } +- } +- +- /* Update records for the slots the non-options now occupy. */ +- +- d->__first_nonopt += (d->optind - d->__last_nonopt); +- d->__last_nonopt = d->optind; +-} +- +-/* Initialize the internal data when the first call is made. */ +- +-static const char * +-_getopt_initialize ( +- int argc, +- char *const *argv, +- const char *optstring, +- struct _getopt_data *d +-) +-{ +- /* Start processing options with ARGV-element 1 (since ARGV-element 0 +- is the program name); the sequence of previously skipped +- non-option ARGV-elements is empty. */ +- +- d->__first_nonopt = d->__last_nonopt = d->optind; +- +- d->__nextchar = NULL; +- +- d->__posixly_correct = !!getenv ("POSIXLY_CORRECT"); +- +- /* Determine how to handle the ordering of options and nonoptions. */ +- +- if (optstring[0] == '-') +- { +- d->__ordering = RETURN_IN_ORDER; +- ++optstring; +- } +- else if (optstring[0] == '+') +- { +- d->__ordering = REQUIRE_ORDER; +- ++optstring; +- } +- else if (d->__posixly_correct) +- d->__ordering = REQUIRE_ORDER; +- else +- d->__ordering = PERMUTE; +- +-#if defined _LIBC && defined USE_NONOPTION_FLAGS +- if (!d->__posixly_correct && argc == __libc_argc && argv == __libc_argv) +- { +- if (d->__nonoption_flags_max_len == 0) +- { +- if (__getopt_nonoption_flags == NULL +- || __getopt_nonoption_flags[0] == '\0') +- d->__nonoption_flags_max_len = -1; +- else +- { +- const char *orig_str = __getopt_nonoption_flags; +- int len = d->__nonoption_flags_max_len = strlen (orig_str); +- if (d->__nonoption_flags_max_len < argc) +- d->__nonoption_flags_max_len = argc; +- __getopt_nonoption_flags = +- (char *) malloc (d->__nonoption_flags_max_len); +- if (__getopt_nonoption_flags == NULL) +- d->__nonoption_flags_max_len = -1; +- else +- memset (__mempcpy (__getopt_nonoption_flags, orig_str, len), +- '\0', d->__nonoption_flags_max_len - len); +- } +- } +- d->__nonoption_flags_len = d->__nonoption_flags_max_len; +- } +- else +- d->__nonoption_flags_len = 0; +-#endif +- +- return optstring; +-} +- +-/* Scan elements of ARGV (whose length is ARGC) for option characters +- given in OPTSTRING. +- +- If an element of ARGV starts with '-', and is not exactly "-" or "--", +- then it is an option element. The characters of this element +- (aside from the initial '-') are option characters. If `getopt' +- is called repeatedly, it returns successively each of the option characters +- from each of the option elements. +- +- If `getopt' finds another option character, it returns that character, +- updating `optind' and `nextchar' so that the next call to `getopt' can +- resume the scan with the following option character or ARGV-element. +- +- If there are no more option characters, `getopt' returns -1. +- Then `optind' is the index in ARGV of the first ARGV-element +- that is not an option. (The ARGV-elements have been permuted +- so that those that are not options now come last.) +- +- OPTSTRING is a string containing the legitimate option characters. +- If an option character is seen that is not listed in OPTSTRING, +- return '?' after printing an error message. If you set `opterr' to +- zero, the error message is suppressed but we still return '?'. +- +- If a char in OPTSTRING is followed by a colon, that means it wants an arg, +- so the following text in the same ARGV-element, or the text of the following +- ARGV-element, is returned in `optarg'. Two colons mean an option that +- wants an optional arg; if there is text in the current ARGV-element, +- it is returned in `optarg', otherwise `optarg' is set to zero. +- +- If OPTSTRING starts with `-' or `+', it requests different methods of +- handling the non-option ARGV-elements. +- See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above. +- +- Long-named options begin with `--' instead of `-'. +- Their names may be abbreviated as long as the abbreviation is unique +- or is an exact match for some defined option. If they have an +- argument, it follows the option name in the same ARGV-element, separated +- from the option name by a `=', or else the in next ARGV-element. +- When `getopt' finds a long-named option, it returns 0 if that option's +- `flag' field is nonzero, the value of the option's `val' field +- if the `flag' field is zero. +- +- The elements of ARGV aren't really const, because we permute them. +- But we pretend they're const in the prototype to be compatible +- with other systems. +- +- LONGOPTS is a vector of `struct option' terminated by an +- element containing a name which is zero. +- +- LONGIND returns the index in LONGOPT of the long-named option found. +- It is only valid when a long-named option has been found by the most +- recent call. +- +- If LONG_ONLY is nonzero, '-' as well as '--' can introduce +- long-named options. */ +- +-int +-_getopt_internal_r ( +- int argc, +- char *const *argv, +- const char *optstring, +- const struct option *longopts, +- int *longind, +- int long_only, +- struct _getopt_data *d +-) +-{ +- int print_errors = d->opterr; +- if (optstring[0] == ':') +- print_errors = 0; +- +- if (argc < 1) +- return -1; +- +- d->optarg = NULL; +- +- if (d->optind == 0 || !d->__initialized) +- { +- if (d->optind == 0) +- d->optind = 1; /* Don't scan ARGV[0], the program name. */ +- optstring = _getopt_initialize (argc, argv, optstring, d); +- d->__initialized = 1; +- } +- +- /* Test whether ARGV[optind] points to a non-option argument. +- Either it does not have option syntax, or there is an environment flag +- from the shell indicating it is not an option. The later information +- is only used when the used in the GNU libc. */ +-#if defined _LIBC && defined USE_NONOPTION_FLAGS +-# define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0' \ +- || (d->optind < d->__nonoption_flags_len \ +- && __getopt_nonoption_flags[d->optind] == '1')) +-#else +-# define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0') +-#endif +- +- if (d->__nextchar == NULL || *d->__nextchar == '\0') +- { +- /* Advance to the next ARGV-element. */ +- +- /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been +- moved back by the user (who may also have changed the arguments). */ +- if (d->__last_nonopt > d->optind) +- d->__last_nonopt = d->optind; +- if (d->__first_nonopt > d->optind) +- d->__first_nonopt = d->optind; +- +- if (d->__ordering == PERMUTE) +- { +- /* If we have just processed some options following some non-options, +- exchange them so that the options come first. */ +- +- if (d->__first_nonopt != d->__last_nonopt +- && d->__last_nonopt != d->optind) +- exchange ((char **) argv, d); +- else if (d->__last_nonopt != d->optind) +- d->__first_nonopt = d->optind; +- +- /* Skip any additional non-options +- and extend the range of non-options previously skipped. */ +- +- while (d->optind < argc && NONOPTION_P) +- d->optind++; +- d->__last_nonopt = d->optind; +- } +- +- /* The special ARGV-element `--' means premature end of options. +- Skip it like a null option, +- then exchange with previous non-options as if it were an option, +- then skip everything else like a non-option. */ +- +- if (d->optind != argc && !strcmp (argv[d->optind], "--")) +- { +- d->optind++; +- +- if (d->__first_nonopt != d->__last_nonopt +- && d->__last_nonopt != d->optind) +- exchange ((char **) argv, d); +- else if (d->__first_nonopt == d->__last_nonopt) +- d->__first_nonopt = d->optind; +- d->__last_nonopt = argc; +- +- d->optind = argc; +- } +- +- /* If we have done all the ARGV-elements, stop the scan +- and back over any non-options that we skipped and permuted. */ +- +- if (d->optind == argc) +- { +- /* Set the next-arg-index to point at the non-options +- that we previously skipped, so the caller will digest them. */ +- if (d->__first_nonopt != d->__last_nonopt) +- d->optind = d->__first_nonopt; +- return -1; +- } +- +- /* If we have come to a non-option and did not permute it, +- either stop the scan or describe it to the caller and pass it by. */ +- +- if (NONOPTION_P) +- { +- if (d->__ordering == REQUIRE_ORDER) +- return -1; +- d->optarg = argv[d->optind++]; +- return 1; +- } +- +- /* We have found another option-ARGV-element. +- Skip the initial punctuation. */ +- +- d->__nextchar = (argv[d->optind] + 1 +- + (longopts != NULL && argv[d->optind][1] == '-')); +- } +- +- /* Decode the current option-ARGV-element. */ +- +- /* Check whether the ARGV-element is a long option. +- +- If long_only and the ARGV-element has the form "-f", where f is +- a valid short option, don't consider it an abbreviated form of +- a long option that starts with f. Otherwise there would be no +- way to give the -f short option. +- +- On the other hand, if there's a long option "fubar" and +- the ARGV-element is "-fu", do consider that an abbreviation of +- the long option, just like "--fu", and not "-f" with arg "u". +- +- This distinction seems to be the most useful approach. */ +- +- if (longopts != NULL +- && (argv[d->optind][1] == '-' +- || (long_only && (argv[d->optind][2] +- || !strchr (optstring, argv[d->optind][1]))))) +- { +- char *nameend; +- const struct option *p; +- const struct option *pfound = NULL; +- int exact = 0; +- int ambig = 0; +- int indfound = -1; +- int option_index; +- +- for (nameend = d->__nextchar; *nameend && *nameend != '='; nameend++) +- /* Do nothing. */ ; +- +- /* Test all long options for either exact match +- or abbreviated matches. */ +- for (p = longopts, option_index = 0; p->name; p++, option_index++) +- if (!strncmp (p->name, d->__nextchar, nameend - d->__nextchar)) +- { +- if ((unsigned int) (nameend - d->__nextchar) +- == (unsigned int) strlen (p->name)) +- { +- /* Exact match found. */ +- pfound = p; +- indfound = option_index; +- exact = 1; +- break; +- } +- else if (pfound == NULL) +- { +- /* First nonexact match found. */ +- pfound = p; +- indfound = option_index; +- } +- else if (long_only +- || pfound->has_arg != p->has_arg +- || pfound->flag != p->flag || pfound->val != p->val) +- /* Second or later nonexact match found. */ +- ambig = 1; +- } +- +- if (ambig && !exact) +- { +- if (print_errors) +- { +-#if defined _LIBC && defined USE_IN_LIBIO +- char *buf; +- +- if (__asprintf (&buf, _("%s: option `%s' is ambiguous\n"), +- argv[0], argv[d->optind]) >= 0) +- { +- _IO_flockfile (stderr); +- +- int old_flags2 = ((_IO_FILE *) stderr)->_flags2; +- ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL; +- +- if (_IO_fwide (stderr, 0) > 0) +- __fwprintf (stderr, L"%s", buf); +- else +- fputs (buf, stderr); +- +- ((_IO_FILE *) stderr)->_flags2 = old_flags2; +- _IO_funlockfile (stderr); +- +- free (buf); +- } +-#else +- fprintf (stderr, _("%s: option `%s' is ambiguous\n"), +- argv[0], argv[d->optind]); +-#endif +- } +- d->__nextchar += strlen (d->__nextchar); +- d->optind++; +- d->optopt = 0; +- return '?'; +- } +- +- if (pfound != NULL) +- { +- option_index = indfound; +- d->optind++; +- if (*nameend) +- { +- /* Don't test has_arg with >, because some C compilers don't +- allow it to be used on enums. */ +- if (pfound->has_arg) +- d->optarg = nameend + 1; +- else +- { +- if (print_errors) +- { +-#if defined _LIBC && defined USE_IN_LIBIO +- char *buf; +- int n; +-#endif +- +- if (argv[d->optind - 1][1] == '-') +- { +- /* --option */ +-#if defined _LIBC && defined USE_IN_LIBIO +- n = __asprintf (&buf, _("\ +-%s: option `--%s' doesn't allow an argument\n"), argv[0], pfound->name); +-#else +- fprintf (stderr, _("\ +-%s: option `--%s' doesn't allow an argument\n"), argv[0], pfound->name); +-#endif +- } +- else +- { +- /* +option or -option */ +-#if defined _LIBC && defined USE_IN_LIBIO +- n = __asprintf (&buf, _("\ +-%s: option `%c%s' doesn't allow an argument\n"), argv[0], argv[d->optind - 1][0], pfound->name); +-#else +- fprintf (stderr, _("\ +-%s: option `%c%s' doesn't allow an argument\n"), argv[0], argv[d->optind - 1][0], pfound->name); +-#endif +- } +- +-#if defined _LIBC && defined USE_IN_LIBIO +- if (n >= 0) +- { +- _IO_flockfile (stderr); +- +- int old_flags2 = ((_IO_FILE *) stderr)->_flags2; +- ((_IO_FILE *) stderr)->_flags2 +- |= _IO_FLAGS2_NOTCANCEL; +- +- if (_IO_fwide (stderr, 0) > 0) +- __fwprintf (stderr, L"%s", buf); +- else +- fputs (buf, stderr); +- +- ((_IO_FILE *) stderr)->_flags2 = old_flags2; +- _IO_funlockfile (stderr); +- +- free (buf); +- } +-#endif +- } +- +- d->__nextchar += strlen (d->__nextchar); +- +- d->optopt = pfound->val; +- return '?'; +- } +- } +- else if (pfound->has_arg == 1) +- { +- if (d->optind < argc) +- d->optarg = argv[d->optind++]; +- else +- { +- if (print_errors) +- { +-#if defined _LIBC && defined USE_IN_LIBIO +- char *buf; +- +- if (__asprintf (&buf, _("\ +-%s: option `%s' requires an argument\n"), argv[0], argv[d->optind - 1]) >= 0) +- { +- _IO_flockfile (stderr); +- +- int old_flags2 = ((_IO_FILE *) stderr)->_flags2; +- ((_IO_FILE *) stderr)->_flags2 +- |= _IO_FLAGS2_NOTCANCEL; +- +- if (_IO_fwide (stderr, 0) > 0) +- __fwprintf (stderr, L"%s", buf); +- else +- fputs (buf, stderr); +- +- ((_IO_FILE *) stderr)->_flags2 = old_flags2; +- _IO_funlockfile (stderr); +- +- free (buf); +- } +-#else +- fprintf (stderr, +- _("%s: option `%s' requires an argument\n"), +- argv[0], argv[d->optind - 1]); +-#endif +- } +- d->__nextchar += strlen (d->__nextchar); +- d->optopt = pfound->val; +- return optstring[0] == ':' ? ':' : '?'; +- } +- } +- d->__nextchar += strlen (d->__nextchar); +- if (longind != NULL) +- *longind = option_index; +- if (pfound->flag) +- { +- *(pfound->flag) = pfound->val; +- return 0; +- } +- return pfound->val; +- } +- +- /* Can't find it as a long option. If this is not getopt_long_only, +- or the option starts with '--' or is not a valid short +- option, then it's an error. +- Otherwise interpret it as a short option. */ +- if (!long_only || argv[d->optind][1] == '-' +- || strchr (optstring, *d->__nextchar) == NULL) +- { +- if (print_errors) +- { +-#if defined _LIBC && defined USE_IN_LIBIO +- char *buf; +- int n; +-#endif +- +- if (argv[d->optind][1] == '-') +- { +- /* --option */ +-#if defined _LIBC && defined USE_IN_LIBIO +- n = __asprintf (&buf, _("%s: unrecognized option `--%s'\n"), +- argv[0], d->__nextchar); +-#else +- fprintf (stderr, _("%s: unrecognized option `--%s'\n"), +- argv[0], d->__nextchar); +-#endif +- } +- else +- { +- /* +option or -option */ +-#if defined _LIBC && defined USE_IN_LIBIO +- n = __asprintf (&buf, _("%s: unrecognized option `%c%s'\n"), +- argv[0], argv[d->optind][0], d->__nextchar); +-#else +- fprintf (stderr, _("%s: unrecognized option `%c%s'\n"), +- argv[0], argv[d->optind][0], d->__nextchar); +-#endif +- } +- +-#if defined _LIBC && defined USE_IN_LIBIO +- if (n >= 0) +- { +- _IO_flockfile (stderr); +- +- int old_flags2 = ((_IO_FILE *) stderr)->_flags2; +- ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL; +- +- if (_IO_fwide (stderr, 0) > 0) +- __fwprintf (stderr, L"%s", buf); +- else +- fputs (buf, stderr); +- +- ((_IO_FILE *) stderr)->_flags2 = old_flags2; +- _IO_funlockfile (stderr); +- +- free (buf); +- } +-#endif +- } +- d->__nextchar = (char *) ""; +- d->optind++; +- d->optopt = 0; +- return '?'; +- } +- } +- +- /* Look at and handle the next short option-character. */ +- +- { +- char c = *d->__nextchar++; +- char *temp = strchr (optstring, c); +- +- /* Increment `optind' when we start to process its last character. */ +- if (*d->__nextchar == '\0') +- ++d->optind; +- +- if (temp == NULL || c == ':') +- { +- if (print_errors) +- { +-#if defined _LIBC && defined USE_IN_LIBIO +- char *buf; +- int n; +-#endif +- +- if (d->__posixly_correct) +- { +- /* 1003.2 specifies the format of this message. */ +-#if defined _LIBC && defined USE_IN_LIBIO +- n = __asprintf (&buf, _("%s: illegal option -- %c\n"), +- argv[0], c); +-#else +- fprintf (stderr, _("%s: illegal option -- %c\n"), argv[0], c); +-#endif +- } +- else +- { +-#if defined _LIBC && defined USE_IN_LIBIO +- n = __asprintf (&buf, _("%s: invalid option -- %c\n"), +- argv[0], c); +-#else +- fprintf (stderr, _("%s: invalid option -- %c\n"), argv[0], c); +-#endif +- } +- +-#if defined _LIBC && defined USE_IN_LIBIO +- if (n >= 0) +- { +- _IO_flockfile (stderr); +- +- int old_flags2 = ((_IO_FILE *) stderr)->_flags2; +- ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL; +- +- if (_IO_fwide (stderr, 0) > 0) +- __fwprintf (stderr, L"%s", buf); +- else +- fputs (buf, stderr); +- +- ((_IO_FILE *) stderr)->_flags2 = old_flags2; +- _IO_funlockfile (stderr); +- +- free (buf); +- } +-#endif +- } +- d->optopt = c; +- return '?'; +- } +- /* Convenience. Treat POSIX -W foo same as long option --foo */ +- if (temp[0] == 'W' && temp[1] == ';') +- { +- char *nameend; +- const struct option *p; +- const struct option *pfound = NULL; +- int exact = 0; +- int ambig = 0; +- int indfound = 0; +- int option_index; +- +- /* This is an option that requires an argument. */ +- if (*d->__nextchar != '\0') +- { +- d->optarg = d->__nextchar; +- /* If we end this ARGV-element by taking the rest as an arg, +- we must advance to the next element now. */ +- d->optind++; +- } +- else if (d->optind == argc) +- { +- if (print_errors) +- { +- /* 1003.2 specifies the format of this message. */ +-#if defined _LIBC && defined USE_IN_LIBIO +- char *buf; +- +- if (__asprintf (&buf, +- _("%s: option requires an argument -- %c\n"), +- argv[0], c) >= 0) +- { +- _IO_flockfile (stderr); +- +- int old_flags2 = ((_IO_FILE *) stderr)->_flags2; +- ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL; +- +- if (_IO_fwide (stderr, 0) > 0) +- __fwprintf (stderr, L"%s", buf); +- else +- fputs (buf, stderr); +- +- ((_IO_FILE *) stderr)->_flags2 = old_flags2; +- _IO_funlockfile (stderr); +- +- free (buf); +- } +-#else +- fprintf (stderr, _("%s: option requires an argument -- %c\n"), +- argv[0], c); +-#endif +- } +- d->optopt = c; +- if (optstring[0] == ':') +- c = ':'; +- else +- c = '?'; +- return c; +- } +- else +- /* We already incremented `d->optind' once; +- increment it again when taking next ARGV-elt as argument. */ +- d->optarg = argv[d->optind++]; +- +- /* optarg is now the argument, see if it's in the +- table of longopts. */ +- +- for (d->__nextchar = nameend = d->optarg; *nameend && *nameend != '='; +- nameend++) +- /* Do nothing. */ ; +- +- /* Test all long options for either exact match +- or abbreviated matches. */ +- for (p = longopts, option_index = 0; p->name; p++, option_index++) +- if (!strncmp (p->name, d->__nextchar, nameend - d->__nextchar)) +- { +- if ((unsigned int) (nameend - d->__nextchar) == +- strlen (p->name)) +- { +- /* Exact match found. */ +- pfound = p; +- indfound = option_index; +- exact = 1; +- break; +- } +- else if (pfound == NULL) +- { +- /* First nonexact match found. */ +- pfound = p; +- indfound = option_index; +- } +- else +- /* Second or later nonexact match found. */ +- ambig = 1; +- } +- if (ambig && !exact) +- { +- if (print_errors) +- { +-#if defined _LIBC && defined USE_IN_LIBIO +- char *buf; +- +- if (__asprintf (&buf, _("%s: option `-W %s' is ambiguous\n"), +- argv[0], argv[d->optind]) >= 0) +- { +- _IO_flockfile (stderr); +- +- int old_flags2 = ((_IO_FILE *) stderr)->_flags2; +- ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL; +- +- if (_IO_fwide (stderr, 0) > 0) +- __fwprintf (stderr, L"%s", buf); +- else +- fputs (buf, stderr); +- +- ((_IO_FILE *) stderr)->_flags2 = old_flags2; +- _IO_funlockfile (stderr); +- +- free (buf); +- } +-#else +- fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"), +- argv[0], argv[d->optind]); +-#endif +- } +- d->__nextchar += strlen (d->__nextchar); +- d->optind++; +- return '?'; +- } +- if (pfound != NULL) +- { +- option_index = indfound; +- if (*nameend) +- { +- /* Don't test has_arg with >, because some C compilers don't +- allow it to be used on enums. */ +- if (pfound->has_arg) +- d->optarg = nameend + 1; +- else +- { +- if (print_errors) +- { +-#if defined _LIBC && defined USE_IN_LIBIO +- char *buf; +- +- if (__asprintf (&buf, _("\ +-%s: option `-W %s' doesn't allow an argument\n"), argv[0], pfound->name) >= 0) +- { +- _IO_flockfile (stderr); +- +- int old_flags2 = ((_IO_FILE *) stderr)->_flags2; +- ((_IO_FILE *) stderr)->_flags2 +- |= _IO_FLAGS2_NOTCANCEL; +- +- if (_IO_fwide (stderr, 0) > 0) +- __fwprintf (stderr, L"%s", buf); +- else +- fputs (buf, stderr); +- +- ((_IO_FILE *) stderr)->_flags2 = old_flags2; +- _IO_funlockfile (stderr); +- +- free (buf); +- } +-#else +- fprintf (stderr, _("\ +-%s: option `-W %s' doesn't allow an argument\n"), argv[0], pfound->name); +-#endif +- } +- +- d->__nextchar += strlen (d->__nextchar); +- return '?'; +- } +- } +- else if (pfound->has_arg == 1) +- { +- if (d->optind < argc) +- d->optarg = argv[d->optind++]; +- else +- { +- if (print_errors) +- { +-#if defined _LIBC && defined USE_IN_LIBIO +- char *buf; +- +- if (__asprintf (&buf, _("\ +-%s: option `%s' requires an argument\n"), argv[0], argv[d->optind - 1]) >= 0) +- { +- _IO_flockfile (stderr); +- +- int old_flags2 = ((_IO_FILE *) stderr)->_flags2; +- ((_IO_FILE *) stderr)->_flags2 +- |= _IO_FLAGS2_NOTCANCEL; +- +- if (_IO_fwide (stderr, 0) > 0) +- __fwprintf (stderr, L"%s", buf); +- else +- fputs (buf, stderr); +- +- ((_IO_FILE *) stderr)->_flags2 = old_flags2; +- _IO_funlockfile (stderr); +- +- free (buf); +- } +-#else +- fprintf (stderr, +- _("%s: option `%s' requires an argument\n"), +- argv[0], argv[d->optind - 1]); +-#endif +- } +- d->__nextchar += strlen (d->__nextchar); +- return optstring[0] == ':' ? ':' : '?'; +- } +- } +- d->__nextchar += strlen (d->__nextchar); +- if (longind != NULL) +- *longind = option_index; +- if (pfound->flag) +- { +- *(pfound->flag) = pfound->val; +- return 0; +- } +- return pfound->val; +- } +- d->__nextchar = NULL; +- return 'W'; /* Let the application handle it. */ +- } +- if (temp[1] == ':') +- { +- if (temp[2] == ':') +- { +- /* This is an option that accepts an argument optionally. */ +- if (*d->__nextchar != '\0') +- { +- d->optarg = d->__nextchar; +- d->optind++; +- } +- else +- d->optarg = NULL; +- d->__nextchar = NULL; +- } +- else +- { +- /* This is an option that requires an argument. */ +- if (*d->__nextchar != '\0') +- { +- d->optarg = d->__nextchar; +- /* If we end this ARGV-element by taking the rest as an arg, +- we must advance to the next element now. */ +- d->optind++; +- } +- else if (d->optind == argc) +- { +- if (print_errors) +- { +- /* 1003.2 specifies the format of this message. */ +-#if defined _LIBC && defined USE_IN_LIBIO +- char *buf; +- +- if (__asprintf (&buf, _("\ +-%s: option requires an argument -- %c\n"), argv[0], c) >= 0) +- { +- _IO_flockfile (stderr); +- +- int old_flags2 = ((_IO_FILE *) stderr)->_flags2; +- ((_IO_FILE *) stderr)->_flags2 |= +- _IO_FLAGS2_NOTCANCEL; +- +- if (_IO_fwide (stderr, 0) > 0) +- __fwprintf (stderr, L"%s", buf); +- else +- fputs (buf, stderr); +- +- ((_IO_FILE *) stderr)->_flags2 = old_flags2; +- _IO_funlockfile (stderr); +- +- free (buf); +- } +-#else +- fprintf (stderr, +- _("%s: option requires an argument -- %c\n"), +- argv[0], c); +-#endif +- } +- d->optopt = c; +- if (optstring[0] == ':') +- c = ':'; +- else +- c = '?'; +- } +- else +- /* We already incremented `optind' once; +- increment it again when taking next ARGV-elt as argument. */ +- d->optarg = argv[d->optind++]; +- d->__nextchar = NULL; +- } +- } +- return c; +- } +-} +- +-int +-_getopt_internal ( +- int argc, +- char *const *argv, +- const char *optstring, +- const struct option *longopts, +- int *longind, +- int long_only +-) +-{ +- int result; +- +- getopt_data.optind = optind; +- getopt_data.opterr = opterr; +- +- result = _getopt_internal_r (argc, argv, optstring, longopts, +- longind, long_only, &getopt_data); +- +- optind = getopt_data.optind; +- optarg = getopt_data.optarg; +- optopt = getopt_data.optopt; +- +- return result; +-} +- +-int +-getopt ( +- int argc, +- char *const *argv, +- const char *optstring +-) +-{ +- return _getopt_internal (argc, argv, optstring, +- (const struct option *) 0, (int *) 0, 0); +-} +- +-#endif /* Not ELIDE_CODE. */ +- +-#ifdef TEST +- +-/* Compile with -DTEST to make an executable for use in testing +- the above definition of `getopt'. */ +- +-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); +-} +- +-#endif /* TEST */ +diff -pruN fribidi-1.0.10.orig/bin/getopt.h fribidi-1.0.10/bin/getopt.h +--- fribidi-1.0.10.orig/bin/getopt.h 2015-08-05 03:49:07.000000000 +0900 ++++ fribidi-1.0.10/bin/getopt.h 1970-01-01 09:00:00.000000000 +0900 +@@ -1,187 +0,0 @@ +-/* Declarations for getopt. +- Copyright (C) 1989-1994,1996-1999,2001,2003,2004 +- Free Software Foundation, Inc. +- This file is part of the GNU C Library. +- +- This program is free software; you can redistribute it and/or modify +- it under the terms of the GNU General Public License as published by +- the Free Software Foundation; either version 2, or (at your option) +- any later version. +- +- This program is distributed in the hope that it will be useful, +- but WITHOUT ANY WARRANTY; without even the implied warranty of +- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +- GNU General Public License for more details. +- +- You should have received a copy of the GNU General Public License along +- with this program; if not, write to the Free Software Foundation, +- Inc., 59 Temple Place - Suite 330, Boston, MA 02110-1301, USA. */ +- +-#ifndef _GETOPT_H +- +-#ifndef __need_getopt +-# define _GETOPT_H 1 +-#endif +- +-/* If __GNU_LIBRARY__ is not already defined, either we are being used +- standalone, or this is the first header included in the source file. +- If we are being used with glibc, we need to include , but +- that does not exist if we are standalone. So: if __GNU_LIBRARY__ is +- not defined, include , which will pull in for us +- if it's from glibc. (Why ctype.h? It's guaranteed to exist and it +- doesn't flood the namespace with stuff the way some other headers do.) */ +-#if !defined __GNU_LIBRARY__ +-# include +-#endif +- +-#ifndef __THROW +-# ifndef __GNUC_PREREQ +-# define __GNUC_PREREQ(maj, min) (0) +-# endif +-# if defined __cplusplus && __GNUC_PREREQ (2,8) +-# define __THROW throw () +-# else +-# define __THROW +-# endif +-#endif +- +-#ifdef __cplusplus +-extern "C" +-{ +-#endif +- +-/* For communication from `getopt' to the caller. +- When `getopt' finds an option that takes an argument, +- the argument value is returned here. +- Also, when `ordering' is RETURN_IN_ORDER, +- each non-option ARGV-element is returned here. */ +- +- extern char *optarg; +- +-/* Index in ARGV of the next element to be scanned. +- This is used for communication to and from the caller +- and for communication between successive calls to `getopt'. +- +- On entry to `getopt', zero means this is the first call; initialize. +- +- When `getopt' returns -1, this is the index of the first of the +- non-option elements that the caller should itself scan. +- +- Otherwise, `optind' communicates from one call to the next +- how much of ARGV has been scanned so far. */ +- +- extern int optind; +- +-/* Callers store zero here to inhibit the error message `getopt' prints +- for unrecognized options. */ +- +- extern int opterr; +- +-/* Set to an option character which was unrecognized. */ +- +- extern int optopt; +- +-#ifndef __need_getopt +-/* Describe the long-named options requested by the application. +- The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector +- of `struct option' terminated by an element containing a name which is +- zero. +- +- The field `has_arg' is: +- no_argument (or 0) if the option does not take an argument, +- required_argument (or 1) if the option requires an argument, +- optional_argument (or 2) if the option takes an optional argument. +- +- If the field `flag' is not NULL, it points to a variable that is set +- to the value given in the field `val' when the option is found, but +- left unchanged if the option is not found. +- +- To have a long-named option do something other than set an `int' to +- a compiled-in constant, such as set a value from `optarg', set the +- option's `flag' field to zero and its `val' field to a nonzero +- value (the equivalent single-letter option character, if there is +- one). For long options that have a zero `flag' field, `getopt' +- returns the contents of the `val' field. */ +- +- struct option +- { +- const char *name; +- /* has_arg can't be an enum because some compilers complain about +- type mismatches in all the code that assumes it is an int. */ +- int has_arg; +- int *flag; +- int val; +- }; +- +-/* Names for the values of the `has_arg' field of `struct option'. */ +- +-# define no_argument 0 +-# define required_argument 1 +-# define optional_argument 2 +-#endif /* need getopt */ +- +- +-/* Get definitions and prototypes for functions to process the +- arguments in ARGV (ARGC of them, minus the program name) for +- options given in OPTS. +- +- Return the option character from OPTS just read. Return -1 when +- there are no more options. For unrecognized options, or options +- missing arguments, `optopt' is set to the option letter, and '?' is +- returned. +- +- The OPTS string is a list of characters which are recognized option +- letters, optionally followed by colons, specifying that that letter +- takes an argument, to be placed in `optarg'. +- +- If a letter in OPTS is followed by two colons, its argument is +- optional. This behavior is specific to the GNU `getopt'. +- +- The argument `--' causes premature termination of argument +- scanning, explicitly telling `getopt' that there are no more +- options. +- +- If OPTS begins with `--', then non-option arguments are treated as +- arguments to the option '\0'. This behavior is specific to the GNU +- `getopt'. */ +- +-#ifdef __GNU_LIBRARY__ +-/* Many other libraries have conflicting prototypes for getopt, with +- differences in the consts, in stdlib.h. To avoid compilation +- errors, only prototype getopt for the GNU C library. */ +- extern int getopt ( +- int ___argc, +- char *const *___argv, +- const char *__shortopts +- ) __THROW; +-#else /* not __GNU_LIBRARY__ */ +- extern int getopt ( +- ); +-#endif /* __GNU_LIBRARY__ */ +- +-#ifndef __need_getopt +- extern int getopt_long ( +- int ___argc, +- char *const *___argv, +- const char *__shortopts, +- const struct option *__longopts, +- int *__longind +- ) __THROW; +- extern int getopt_long_only ( +- int ___argc, +- char *const *___argv, +- const char *__shortopts, +- const struct option *__longopts, +- int *__longind +- ) __THROW; +- +-#endif +- +-#ifdef __cplusplus +-} +-#endif +- +-/* Make sure we later can get all the definitions and declarations. */ +-#undef __need_getopt +- +-#endif /* getopt.h */ +diff -pruN fribidi-1.0.10.orig/bin/getopt1.c fribidi-1.0.10/bin/getopt1.c +--- fribidi-1.0.10.orig/bin/getopt1.c 2015-08-05 03:49:07.000000000 +0900 ++++ fribidi-1.0.10/bin/getopt1.c 1970-01-01 09:00:00.000000000 +0900 +@@ -1,213 +0,0 @@ +-/* getopt_long and getopt_long_only entry points for GNU getopt. +- Copyright (C) 1987,88,89,90,91,92,93,94,96,97,98,2004 +- Free Software Foundation, Inc. +- This file is part of the GNU C Library. +- +- This program is free software; you can redistribute it and/or modify +- it under the terms of the GNU General Public License as published by +- the Free Software Foundation; either version 2, or (at your option) +- any later version. +- +- This program is distributed in the hope that it will be useful, +- but WITHOUT ANY WARRANTY; without even the implied warranty of +- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +- GNU General Public License for more details. +- +- You should have received a copy of the GNU General Public License along +- with this program; if not, write to the Free Software Foundation, +- Inc., 59 Temple Place - Suite 330, Boston, MA 02110-1301, USA. */ +- +-#ifdef HAVE_CONFIG_H +-#include +-#endif +- +-#ifdef _LIBC +-# include +-#else +-# include "getopt.h" +-#endif +-#include "getopt_int.h" +- +-#include +- +-/* Comment out all this code if we are using the GNU C Library, and are not +- actually compiling the library itself. This code is part of the GNU C +- Library, but also included in many other GNU distributions. Compiling +- and linking in this code is a waste when using the GNU C library +- (especially if it is a shared library). Rather than having every GNU +- program understand `configure --with-gnu-libc' and omit the object files, +- it is simpler to just do this in the source for each such file. */ +- +-#define GETOPT_INTERFACE_VERSION 2 +-#if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2 +-#include +-#if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION +-#define ELIDE_CODE +-#endif +-#endif +- +-#ifndef ELIDE_CODE +- +- +-/* This needs to come after some library #include +- to get __GNU_LIBRARY__ defined. */ +-#ifdef __GNU_LIBRARY__ +-#include +-#endif +- +-#ifndef NULL +-#define NULL 0 +-#endif +- +-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); +-} +- +-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); +-} +- +-/* 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); +-} +- +-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); +-} +- +-#endif /* Not ELIDE_CODE. */ +- +-#ifdef TEST +- +-#include +- +-int +-main ( +- int argc, +- 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); +-} +- +-#endif /* TEST */ +diff -pruN fribidi-1.0.10.orig/bin/getopt_int.h fribidi-1.0.10/bin/getopt_int.h +--- fribidi-1.0.10.orig/bin/getopt_int.h 2015-08-05 03:49:07.000000000 +0900 ++++ fribidi-1.0.10/bin/getopt_int.h 1970-01-01 09:00:00.000000000 +0900 +@@ -1,145 +0,0 @@ +-/* Internal declarations for getopt. +- Copyright (C) 1989-1994,1996-1999,2001,2003,2004 +- Free Software Foundation, Inc. +- This file is part of the GNU C Library. +- +- This program is free software; you can redistribute it and/or modify +- it under the terms of the GNU General Public License as published by +- the Free Software Foundation; either version 2, or (at your option) +- any later version. +- +- This program is distributed in the hope that it will be useful, +- but WITHOUT ANY WARRANTY; without even the implied warranty of +- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +- GNU General Public License for more details. +- +- You should have received a copy of the GNU General Public License along +- with this program; if not, write to the Free Software Foundation, +- Inc., 59 Temple Place - Suite 330, Boston, MA 02110-1301, USA. */ +- +-#ifndef _GETOPT_INT_H +-#define _GETOPT_INT_H 1 +- +-extern int _getopt_internal ( +- int ___argc, +- char *const *___argv, +- const char *__shortopts, +- const struct option *__longopts, +- int *__longind, +- int __long_only +-); +- +- +-/* Reentrant versions which can handle parsing multiple argument +- vectors at the same time. */ +- +-/* Data type for reentrant functions. */ +-struct _getopt_data +-{ +- /* These have exactly the same meaning as the corresponding global +- variables, except that they are used for the reentrant +- versions of getopt. */ +- int optind; +- int opterr; +- int optopt; +- char *optarg; +- +- /* Internal members. */ +- +- /* True if the internal members have been initialized. */ +- int __initialized; +- +- /* The next char to be scanned in the option-element +- in which the last option character we returned was found. +- This allows us to pick up the scan where we left off. +- +- If this is zero, or a null string, it means resume the scan +- by advancing to the next ARGV-element. */ +- char *__nextchar; +- +- /* Describe how to deal with options that follow non-option ARGV-elements. +- +- If the caller did not specify anything, +- the default is REQUIRE_ORDER if the environment variable +- POSIXLY_CORRECT is defined, PERMUTE otherwise. +- +- REQUIRE_ORDER means don't recognize them as options; +- stop option processing when the first non-option is seen. +- This is what Unix does. +- This mode of operation is selected by either setting the environment +- variable POSIXLY_CORRECT, or using `+' as the first character +- of the list of option characters. +- +- PERMUTE is the default. We permute the contents of ARGV as we +- scan, so that eventually all the non-options are at the end. +- This allows options to be given in any order, even with programs +- that were not written to expect this. +- +- RETURN_IN_ORDER is an option available to programs that were +- written to expect options and other ARGV-elements in any order +- and that care about the ordering of the two. We describe each +- non-option ARGV-element as if it were the argument of an option +- with character code 1. Using `-' as the first character of the +- list of option characters selects this mode of operation. +- +- The special argument `--' forces an end of option-scanning regardless +- of the value of `ordering'. In the case of RETURN_IN_ORDER, only +- `--' can cause `getopt' to return -1 with `optind' != ARGC. */ +- +- enum +- { +- REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER +- } __ordering; +- +- /* If the POSIXLY_CORRECT environment variable is set. */ +- int __posixly_correct; +- +- +- /* Handle permutation of arguments. */ +- +- /* Describe the part of ARGV that contains non-options that have +- been skipped. `first_nonopt' is the index in ARGV of the first +- of them; `last_nonopt' is the index after the last of them. */ +- +- int __first_nonopt; +- int __last_nonopt; +- +-#if defined _LIBC && defined USE_NONOPTION_FLAGS +- int __nonoption_flags_max_len; +- int __nonoption_flags_len; +-# endif +-}; +- +-/* The initializer is necessary to set OPTIND and OPTERR to their +- default values and to clear the initialization flag. */ +-#define _GETOPT_DATA_INITIALIZER { 1, 1 } +- +-extern int _getopt_internal_r ( +- int ___argc, +- char *const *___argv, +- const char *__shortopts, +- const struct option *__longopts, +- int *__longind, +- int __long_only, +- struct _getopt_data *__data +-); +- +-extern int _getopt_long_r ( +- int ___argc, +- char *const *___argv, +- const char *__shortopts, +- const struct option *__longopts, +- int *__longind, +- struct _getopt_data *__data +-); +- +-extern int _getopt_long_only_r ( +- int ___argc, +- char *const *___argv, +- const char *__shortopts, +- const struct option *__longopts, +- int *__longind, +- struct _getopt_data *__data +-); +- +-#endif /* getopt_int.h */ +diff -pruN fribidi-1.0.10.orig/bin/gettext.h fribidi-1.0.10/bin/gettext.h +--- fribidi-1.0.10.orig/bin/gettext.h 2015-08-05 03:49:07.000000000 +0900 ++++ fribidi-1.0.10/bin/gettext.h 1970-01-01 09:00:00.000000000 +0900 +@@ -1,2 +0,0 @@ +-#undef gettext +-#define gettext +diff -pruN fribidi-1.0.10.orig/bin/meson.build fribidi-1.0.10/bin/meson.build +--- fribidi-1.0.10.orig/bin/meson.build 2020-07-06 04:17:23.000000000 +0900 ++++ fribidi-1.0.10/bin/meson.build 2020-07-07 21:10:30.931408884 +0900 +@@ -1,12 +1,12 @@ + fribidi = executable('fribidi', +- 'fribidi-main.c', 'getopt.c', 'getopt1.c', fribidi_unicode_version_h, ++ 'fribidi-main.c', fribidi_unicode_version_h, + c_args: ['-DHAVE_CONFIG_H'] + fribidi_static_cargs + visibility_args, + include_directories: incs, + link_with: libfribidi, + install: true) + + executable('fribidi-benchmark', +- 'fribidi-benchmark.c', 'getopt.c', 'getopt1.c', fribidi_unicode_version_h, ++ 'fribidi-benchmark.c', fribidi_unicode_version_h, + c_args: ['-DHAVE_CONFIG_H'] + fribidi_static_cargs + visibility_args, + include_directories: incs, + link_with: libfribidi, diff --git a/SPECS/fribidi.spec b/SPECS/fribidi.spec new file mode 100644 index 0000000..57a0049 --- /dev/null +++ b/SPECS/fribidi.spec @@ -0,0 +1,331 @@ +Summary: Library implementing the Unicode Bidirectional Algorithm +Name: fribidi +Version: 1.0.10 +Release: 6%{?dist} +URL: https://github.com/fribidi/fribidi/ +Source: https://github.com/%{name}/%{name}/releases/download/v%{version}/%{name}-%{version}.tar.xz +License: LGPLv2+ and UCD +BuildRequires: gcc +%if 0%{?rhel} && 0%{?rhel} <= 8 +BuildRequires: automake autoconf libtool +%else +BuildRequires: meson +%endif +BuildRequires: make +Patch0: fribidi-drop-bundled-gnulib.patch + +%description +A library to handle bidirectional scripts (for example Hebrew, Arabic), +so that the display is done in the proper way; while the text data itself +is always written in logical order. + +%package devel +Summary: Libraries and include files for FriBidi +Requires: %{name}%{?_isa} = %{version}-%{release} + +%description devel +Include files and libraries needed for developing applications which use +FriBidi. + +%prep +%autosetup -p1 +%if 0%{?rhel} && 0%{?rhel} <= 8 +autoreconf -i +%endif + +%build +%if 0%{?rhel} && 0%{?rhel} <= 8 +%if 0%{?el5} +# FORTIFY_SOURCE=2 breaks EL-5 build +export CFLAGS=`echo $RPM_OPT_FLAGS | sed -e 's|FORTIFY_SOURCE=2|FORTIFY_SOURCE=1|'` +%ifarch ppc ppc64 x86_64 +export CFLAGS="$CFLAGS -DPAGE_SIZE=4096" +%endif +%else +# outside of EL-5, only ppc* needs modification +%ifarch ppc ppc64 +export CFLAGS="$RPM_OPT_FLAGS -DPAGE_SIZE=4096" +%endif +%endif +%configure --disable-static --disable-docs +make %{?_smp_mflags} V=1 +%else +%meson -Ddocs=false +%meson_build +%endif + +%check +%if 0%{?rhel} && 0%{?rhel} <= 8 +make check +%else +%meson_test +%endif + +%install +%if 0%{?rhel} && 0%{?rhel} <= 8 +make DESTDIR=$RPM_BUILD_ROOT install INSTALL="install -p" +%else +%meson_install +%endif +rm -f $RPM_BUILD_ROOT%{_libdir}/*.la + +%ldconfig_scriptlets + +%files +%doc README AUTHORS ChangeLog THANKS NEWS TODO +%license COPYING +%{_bindir}/fribidi +%{_libdir}/libfribidi.so.0* + +%files devel +%{_includedir}/fribidi +%{_libdir}/libfribidi.so +%{_libdir}/pkgconfig/*.pc +#%%{_mandir}/man3/*.gz + +%changelog +* Mon Aug 09 2021 Mohan Boddu - 1.0.10-6 +- Rebuilt for IMA sigs, glibc 2.34, aarch64 flags + Related: rhbz#1991688 + +* Thu Apr 15 2021 Mohan Boddu - 1.0.10-5 +- Rebuilt for RHEL 9 BETA on Apr 15th 2021. Related: rhbz#1947937 + +* Tue Jan 26 2021 Fedora Release Engineering - 1.0.10-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_34_Mass_Rebuild + +* Mon Jul 27 2020 Fedora Release Engineering - 1.0.10-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_33_Mass_Rebuild + +* Tue Jul 7 2020 Akira TAGOH - 1.0.10-2 +- Update the patch to drop bundled gnulib. + +* Mon Jul 6 2020 Akira TAGOH - 1.0.10-1 +- New upstream release. + Resolves: rhbz#1853939 + +* Thu Mar 05 2020 Akira TAGOH - 1.0.9-1 +- New upstream release. + Resolves: rhbz#1809478 + +* Tue Jan 28 2020 Fedora Release Engineering - 1.0.8-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_32_Mass_Rebuild + +* Wed Jan 15 2020 Akira TAGOH - 1.0.8-2 +- Restore the deprecated API that was accidentally removed in the previous release. + Resolves: rhbz#1787293 + +* Fri Dec 13 2019 Akira TAGOH - 1.0.8-1 +- New upstream release. + Resolves: rhbz#1783205 + +* Wed Dec 11 2019 Akira TAGOH - 1.0.7-2 +- Fix CVE-2019-18397 + Resolves: rhbz#1781218 + +* Mon Sep 30 2019 Akira TAGOH - 1.0.7-1 +- New upstream release. + Resolves: rhbz#1756434 + +* Fri Sep 27 2019 Akira TAGOH - 1.0.6-1 +- New upstream release. + Resolves: rhbz#1756212 +- Use meson to build. + +* Thu Jul 25 2019 Fedora Release Engineering - 1.0.5-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_31_Mass_Rebuild + +* Tue Jul 23 2019 Akira TAGOH - 1.0.5-3 +- Backport upstream patch to remove HAVE_CONFIG_H from public API. + Fixes rhbz#1730516 + +* Thu Jan 31 2019 Fedora Release Engineering - 1.0.5-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_30_Mass_Rebuild + +* Mon Aug 06 2018 Akira TAGOH - 1.0.5-1 +- New upstream release. (#1609080) + +* Thu Jul 26 2018 Akira TAGOH - 1.0.4-6 +- Drop bundled gnulib code. + +* Tue Jul 17 2018 Akira TAGOH - 1.0.4-5 +- Add BR: gcc. + +* Fri Jul 13 2018 Fedora Release Engineering - 1.0.4-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_29_Mass_Rebuild + +* Thu Jul 12 2018 Akira TAGOH - 1.0.4-3 +- Modernize spec file. + +* Fri Jun 29 2018 Akira TAGOH - 1.0.4-2 +- Use ldconfig rpm macro. + +* Fri Jun 08 2018 Akira TAGOH - 1.0.4-1 +- New upstream release. (#1587985) + +* Thu May 31 2018 Akira TAGOH - 1.0.3-1 +- New upstream release. (#1584541) + +* Fri May 04 2018 Caolán McNamara - 1.0.2-1 +- Resolves: rhbz#1574858 latest version, --disable-docs because there's no c2man + +* Wed Feb 28 2018 Caolán McNamara - 1.0.1-1 +- Resolves: rhbz#1549934 latest version + +* Wed Feb 07 2018 Fedora Release Engineering - 0.19.7-7 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_28_Mass_Rebuild + +* Mon Oct 16 2017 Caolán McNamara - 0.19.7-6 +- Resolves: rhbz#1502675 enable make check + +* Wed Aug 02 2017 Fedora Release Engineering - 0.19.7-5 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Binutils_Mass_Rebuild + +* Wed Jul 26 2017 Fedora Release Engineering - 0.19.7-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Mass_Rebuild + +* Fri Feb 10 2017 Fedora Release Engineering - 0.19.7-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_26_Mass_Rebuild + +* Wed Feb 03 2016 Fedora Release Engineering - 0.19.7-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_24_Mass_Rebuild + +* Tue Aug 11 2015 Caolán McNamara - 0.19.7-1 +- Resolves: rhbz#1250755 latest fribidi + +* Wed Jun 17 2015 Fedora Release Engineering - 0.19.6-5 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_23_Mass_Rebuild + +* Sat Feb 21 2015 Till Maas - 0.19.6-4 +- Rebuilt for Fedora 23 Change + https://fedoraproject.org/wiki/Changes/Harden_all_packages_with_position-independent_code + +* Sat Aug 16 2014 Fedora Release Engineering - 0.19.6-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_21_22_Mass_Rebuild + +* Sat Jun 07 2014 Fedora Release Engineering - 0.19.6-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_21_Mass_Rebuild + +* Mon Jan 13 2014 Caolán McNamara - 0.19.6-1 +- Resolves: rhbz#1052148 latest fribidi +- drop integrated signedwarning.patch +- drop integrated fribidi-aarch64.patch + +* Sat Aug 03 2013 Fedora Release Engineering - 0.19.4-5 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_20_Mass_Rebuild + +* Wed Apr 03 2013 Caolán McNamara - 0.19.4-4 +- Resolves: rhbz#925368 support aarch64 + +* Mon Feb 18 2013 Caolán McNamara - 0.19.4-3 +- Resolves: rhbz#884000 remove empty man pages + +* Mon Dec 10 2012 Caolán McNamara - 0.19.4-2 +- Resolves: rhbz#884000 signed warning (thanks mfabian) + +* Tue Nov 27 2012 Caolán McNamara - 0.19.4-1 +- Resolves: rhbz#880490 bump to latest version + +* Tue Oct 16 2012 Parag Nemade - 0.19.2-6 +- spec cleanup for changed packaging guidelines + +* Thu Jul 19 2012 Fedora Release Engineering - 0.19.2-5 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_18_Mass_Rebuild + +* Fri Jan 13 2012 Fedora Release Engineering - 0.19.2-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_17_Mass_Rebuild + +* Tue Feb 08 2011 Fedora Release Engineering - 0.19.2-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_15_Mass_Rebuild + +* Fri Jul 24 2009 Fedora Release Engineering - 0.19.2-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_12_Mass_Rebuild + +* Thu Mar 26 2009 Behdad Esfahbod 0.19.2-1 +- Update to 0.19.2 + +* Tue Feb 24 2009 Fedora Release Engineering - 0.19.1-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_11_Mass_Rebuild + +* Mon Jan 12 2009 Caolán McNamara - 0.19.1-3 +- rebuild to get provides pkgconfig(fribidi) + +* Mon Feb 18 2008 Fedora Release Engineering - 0.19.1-2 +- Autorebuild for GCC 4.3 + +* Wed Jan 16 2008 Caolan McNamara 0.19.1-1 +- next version +- workaround PAGE_SIZE requirement + +* Wed Aug 29 2007 Caolan McNamara 0.10.9-2 +- rebuild + +* Fri Aug 10 2007 Caolan McNamara 0.10.9-1 +- next version + +* Thu Aug 02 2007 Caolan McNamara 0.10.8-2 +- clarify license + +* Thu May 31 2007 Caolan McNamara 0.10.8-1 +- next version + +* Mon Feb 05 2007 Caolan McNamara 0.10.7-6 +- Resolves: rhbz#225771 spec cleanups + +* Wed Jul 12 2006 Jesse Keating - 0.10.7-5.1 +- rebuild + +* Thu Jun 29 2006 Caolan McNamara 0.10.7-5 +- rh#197223# devel Require pkg-config + +* Wed Jun 7 2006 Jeremy Katz - 0.10.7-4 +- put devel .so symlink in the right subpackage + +* Tue May 23 2006 Caolan McNamara 0.10.7-3 +- rh#192669# clearly I didn't actually get around to basing fribidi-config + of pkg-config output + +* Tue May 02 2006 Caolan McNamara 0.10.7-2 +- base fribidi-config on pkg-config output +- allow fribidi_config.h to be the same on 32 and 64 bit + +* Mon Mar 27 2006 Caolan McNamara 0.10.7-1 +- latest version + +* Fri Feb 10 2006 Jesse Keating - 0.10.4-8.2.1 +- bump again for double-long bug on ppc(64) + +* Tue Feb 07 2006 Jesse Keating - 0.10.4-8.2 +- rebuilt for new gcc4.1 snapshot and glibc changes + +* Fri Dec 09 2005 Jesse Keating +- rebuilt + +* Wed Mar 2 2005 Caolan McNamara 0.10.4-8 +- rebuild with gcc4 + +* Wed Feb 09 2005 Caolan McNamara 0.10.4-7 +- rebuilt + +* Tue Jun 15 2004 Elliot Lee +- rebuilt + +* Tue Mar 02 2004 Elliot Lee +- rebuilt + +* Fri Feb 13 2004 Elliot Lee +- rebuilt + +* Wed Sep 24 2003 Jeremy Katz 0.10.4-4 +- update description +- include docs (#104964) + +* Wed Jun 04 2003 Elliot Lee +- rebuilt + +* Sat May 24 2003 Florian La Roche +- add ldconfig to post/postun + +* Fri May 16 2003 Jeremy Katz 0.10.4-2 +- Initial build in Red Hat Linux +