Debian package version of polhemus's g4display
Janis Streib
30.03.22 69b66ffc68dca173cf5f014f797e02ca69c7db83
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
#! /bin/sh
# Wrapper for compilers which do not understand '-c -o'.
 
scriptversion=2018-03-07.03; # UTC
 
# Copyright (C) 1999-2021 Free Software Foundation, Inc.
# Written by Tom Tromey <tromey@cygnus.com>.
#
# 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, see <https://www.gnu.org/licenses/>.
 
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that program.
 
# This file is maintained in Automake, please report
# bugs to <bug-automake@gnu.org> or send patches to
# <automake-patches@gnu.org>.
 
nl='
'
 
# We need space, tab and new line, in precisely that order.  Quoting is
# there to prevent tools from complaining about whitespace usage.
IFS=" ""    $nl"
 
file_conv=
 
# func_file_conv build_file lazy
# Convert a $build file to $host form and store it in $file
# Currently only supports Windows hosts. If the determined conversion
# type is listed in (the comma separated) LAZY, no conversion will
# take place.
func_file_conv ()
{
  file=$1
  case $file in
    / | /[!/]*) # absolute file, and not a UNC file
      if test -z "$file_conv"; then
    # lazily determine how to convert abs files
    case `uname -s` in
      MINGW*)
        file_conv=mingw
        ;;
      CYGWIN* | MSYS*)
        file_conv=cygwin
        ;;
      *)
        file_conv=wine
        ;;
    esac
      fi
      case $file_conv/,$2, in
    *,$file_conv,*)
      ;;
    mingw/*)
      file=`cmd //C echo "$file " | sed -e 's/"\(.*\) " *$/\1/'`
      ;;
    cygwin/* | msys/*)
      file=`cygpath -m "$file" || echo "$file"`
      ;;
    wine/*)
      file=`winepath -w "$file" || echo "$file"`
      ;;
      esac
      ;;
  esac
}
 
# func_cl_dashL linkdir
# Make cl look for libraries in LINKDIR
func_cl_dashL ()
{
  func_file_conv "$1"
  if test -z "$lib_path"; then
    lib_path=$file
  else
    lib_path="$lib_path;$file"
  fi
  linker_opts="$linker_opts -LIBPATH:$file"
}
 
# func_cl_dashl library
# Do a library search-path lookup for cl
func_cl_dashl ()
{
  lib=$1
  found=no
  save_IFS=$IFS
  IFS=';'
  for dir in $lib_path $LIB
  do
    IFS=$save_IFS
    if $shared && test -f "$dir/$lib.dll.lib"; then
      found=yes
      lib=$dir/$lib.dll.lib
      break
    fi
    if test -f "$dir/$lib.lib"; then
      found=yes
      lib=$dir/$lib.lib
      break
    fi
    if test -f "$dir/lib$lib.a"; then
      found=yes
      lib=$dir/lib$lib.a
      break
    fi
  done
  IFS=$save_IFS
 
  if test "$found" != yes; then
    lib=$lib.lib
  fi
}
 
# func_cl_wrapper cl arg...
# Adjust compile command to suit cl
func_cl_wrapper ()
{
  # Assume a capable shell
  lib_path=
  shared=:
  linker_opts=
  for arg
  do
    if test -n "$eat"; then
      eat=
    else
      case $1 in
    -o)
      # configure might choose to run compile as 'compile cc -o foo foo.c'.
      eat=1
      case $2 in
        *.o | *.[oO][bB][jJ])
          func_file_conv "$2"
          set x "$@" -Fo"$file"
          shift
          ;;
        *)
          func_file_conv "$2"
          set x "$@" -Fe"$file"
          shift
          ;;
      esac
      ;;
    -I)
      eat=1
      func_file_conv "$2" mingw
      set x "$@" -I"$file"
      shift
      ;;
    -I*)
      func_file_conv "${1#-I}" mingw
      set x "$@" -I"$file"
      shift
      ;;
    -l)
      eat=1
      func_cl_dashl "$2"
      set x "$@" "$lib"
      shift
      ;;
    -l*)
      func_cl_dashl "${1#-l}"
      set x "$@" "$lib"
      shift
      ;;
    -L)
      eat=1
      func_cl_dashL "$2"
      ;;
    -L*)
      func_cl_dashL "${1#-L}"
      ;;
    -static)
      shared=false
      ;;
    -Wl,*)
      arg=${1#-Wl,}
      save_ifs="$IFS"; IFS=','
      for flag in $arg; do
        IFS="$save_ifs"
        linker_opts="$linker_opts $flag"
      done
      IFS="$save_ifs"
      ;;
    -Xlinker)
      eat=1
      linker_opts="$linker_opts $2"
      ;;
    -*)
      set x "$@" "$1"
      shift
      ;;
    *.cc | *.CC | *.cxx | *.CXX | *.[cC]++)
      func_file_conv "$1"
      set x "$@" -Tp"$file"
      shift
      ;;
    *.c | *.cpp | *.CPP | *.lib | *.LIB | *.Lib | *.OBJ | *.obj | *.[oO])
      func_file_conv "$1" mingw
      set x "$@" "$file"
      shift
      ;;
    *)
      set x "$@" "$1"
      shift
      ;;
      esac
    fi
    shift
  done
  if test -n "$linker_opts"; then
    linker_opts="-link$linker_opts"
  fi
  exec "$@" $linker_opts
  exit 1
}
 
eat=
 
case $1 in
  '')
     echo "$0: No command.  Try '$0 --help' for more information." 1>&2
     exit 1;
     ;;
  -h | --h*)
    cat <<\EOF
Usage: compile [--help] [--version] PROGRAM [ARGS]
 
Wrapper for compilers which do not understand '-c -o'.
Remove '-o dest.o' from ARGS, run PROGRAM with the remaining
arguments, and rename the output as expected.
 
If you are trying to build a whole package this is not the
right script to run: please start by reading the file 'INSTALL'.
 
Report bugs to <bug-automake@gnu.org>.
EOF
    exit $?
    ;;
  -v | --v*)
    echo "compile $scriptversion"
    exit $?
    ;;
  cl | *[/\\]cl | cl.exe | *[/\\]cl.exe | \
  icl | *[/\\]icl | icl.exe | *[/\\]icl.exe )
    func_cl_wrapper "$@"      # Doesn't return...
    ;;
esac
 
ofile=
cfile=
 
for arg
do
  if test -n "$eat"; then
    eat=
  else
    case $1 in
      -o)
    # configure might choose to run compile as 'compile cc -o foo foo.c'.
    # So we strip '-o arg' only if arg is an object.
    eat=1
    case $2 in
      *.o | *.obj)
        ofile=$2
        ;;
      *)
        set x "$@" -o "$2"
        shift
        ;;
    esac
    ;;
      *.c)
    cfile=$1
    set x "$@" "$1"
    shift
    ;;
      *)
    set x "$@" "$1"
    shift
    ;;
    esac
  fi
  shift
done
 
if test -z "$ofile" || test -z "$cfile"; then
  # If no '-o' option was seen then we might have been invoked from a
  # pattern rule where we don't need one.  That is ok -- this is a
  # normal compilation that the losing compiler can handle.  If no
  # '.c' file was seen then we are probably linking.  That is also
  # ok.
  exec "$@"
fi
 
# Name of file we expect compiler to create.
cofile=`echo "$cfile" | sed 's|^.*[\\/]||; s|^[a-zA-Z]:||; s/\.c$/.o/'`
 
# Create the lock directory.
# Note: use '[/\\:.-]' here to ensure that we don't use the same name
# that we are using for the .o file.  Also, base the name on the expected
# object file name, since that is what matters with a parallel build.
lockdir=`echo "$cofile" | sed -e 's|[/\\:.-]|_|g'`.d
while true; do
  if mkdir "$lockdir" >/dev/null 2>&1; then
    break
  fi
  sleep 1
done
# FIXME: race condition here if user kills between mkdir and trap.
trap "rmdir '$lockdir'; exit 1" 1 2 15
 
# Run the compile.
"$@"
ret=$?
 
if test -f "$cofile"; then
  test "$cofile" = "$ofile" || mv "$cofile" "$ofile"
elif test -f "${cofile}bj"; then
  test "${cofile}bj" = "$ofile" || mv "${cofile}bj" "$ofile"
fi
 
rmdir "$lockdir"
exit $ret
 
# Local Variables:
# mode: shell-script
# sh-indentation: 2
# eval: (add-hook 'before-save-hook 'time-stamp)
# time-stamp-start: "scriptversion="
# time-stamp-format: "%:y-%02m-%02d.%02H"
# time-stamp-time-zone: "UTC0"
# time-stamp-end: "; # UTC"
# End: