gcc -MM auf Cygwin: manchmal Unix-Stil Pfade

Question

Ich habe ein (Legacy) Bash-Skript, das eine Liste von Verzeichnissen für Quelldateien analysiert und sie in ein Makefile echost makerules mit gcc -MM erstellen. Das Skript funktioniert gut, das Problem ist, dass make auf dem generierten Makefile inkonsistente Pfadformat in Makerules führt - während die meisten Makerules gemischte Stil Pfade (was in Ordnung ist), einige haben cygwin Stil Pfade (nicht ok). Dies geschah nicht auf einer sehr alten Version von Cygwin (~ 2002). Hier

ist das Skript:

#!/bin/bash 

fn_source=SourceFileList 
fn_depmake=depMakefile 
fn_orgMake=Makefile 
fn_depIncl=Depend.incl 
fn_optIncl=OptimizationCflags.incl 

# 
# create a Makefile to determine the dependencies 
echo -n create dep-makefile ...\ 
# 
# generate include for Optimization-File 
# 
echo > $fn_depIncl 
echo include $fn_optIncl >> $fn_depIncl 
echo >> $fn_depIncl 
# 
touch $fn_optIncl 
# 
echo > $fn_depmake 

# CFLAGS options from Makefile 
grep "^CFLAGS[ =]" $fn_orgMake | grep $BUILD_SPEC >> $fn_depmake 
grep "^CFLAGS_AS[ =]" $fn_orgMake | grep $BUILD_SPEC >> $fn_depmake 
grep "^CFLAGS_GCC[ =]" $fn_orgMake | grep $BUILD_SPEC >> $fn_depmake 

echo -n generate depMakefile ... 

echo >> $fn_depmake 

# the default rule 
echo all: >> $fn_depmake 

FileList=`cat $fn_source` 
incPath="" 
rawIncPath="" 
for fn in $FileList; do 
    incPath=$incPath" -I"${fn%/*} 
    rawIncPath=$rawIncPath" "${fn%/*} 
done 

# filter out redundant paths 
echo $incPath | \ 
sed -n -e 's/ /\ 
/gp' | \ 
sort -u > _tmp 
incPath=`cat _tmp` 

# filter out redundant paths 
echo $rawIncPath | \ 
sed -n -e 's/ /\ 
/gp' | \ 
sort -u > _tmp 
rawIncPath=`cat _tmp` 

# 
# create file with include paths 
# 
echo LibIncludes=$incPath > LibIncludes 

# 
# put all source files with the same path in one gcc command 
# 
for path in $rawIncPath; do 
    sourceFiles=`grep $path/ $fn_source` 
    echo " "echo do $path >> $fn_depmake 
    echo " "gcc -MM '$(CFLAGS_GCC)' -I$path $sourceFiles \>\> _tmp >> $fn_depmake 
done 

# start the Makefile 
echo start Makefile ... 
rm _tmp; touch _tmp 
make -s -f $fn_depmake 
# add ./obj/xxxxx*.o to the make-rules 
sed -e 's/\(^[a-zA-Z]\)/.\/obj\/\1/' <_tmp> _tmp1 
# add command to the make-rules 
sed -e '/\\/!a\ 
    $(CC) $($(*F)CFLAGS) -I$(<D) $(CFLAGS) -c $< -o $@' <_tmp1>> $fn_depIncl 
# workaround for gcc generating cygdrive paths for some paths only 
sed -i 's#/cygdrive/d#d:#' $fn_depIncl 
rm _tmp _tmp1 
rm $fn_depmake 
echo done. 

Wie Sie sehen können, bin ich zur Zeit eine Abhilfe verwenden diese Pfade zu misch gestylt diejenigen zu konvertieren sed, aber ich würde gerne wissen, warum dies im ersten Fall Ort?

Beispiel einer Regel gegangen „falsch“:

some.o: d:/some/path/A/some.cpp \ 
d:/some/path/A/some.h \ 
/cygdrive/d/some/path/B/subpathA/anotherheader.h \ 
/cygdrive/d/some/path/B/subpathA/yetanotherheader.h \ 
D:/some/path/B/subpathB/header.h 

Das Hauptproblem dabei ist, dass die resultierende Make-Datei zu einer Windows-nativen make.exe zugeführt wird, der keine Ahnung hat, was /cygdrive/d/path sein sollte .

Ich habe die Pfade nach jedem Schritt untersucht, und sie sind alle im gemischten Stil bismake -s -f $fn_depmake ausgeführt wird. Das heißt, die gelegentliche Konvertierung in Pfade im Cygwin-Stil erfolgt über den Befehl gcc -MM im generierten Makefile.

Es ist immer die gleiche Liste von Verzeichnissen, die in /cygdrive/d/pathA/somefile.cpp Pfadstil konvertiert werden. Es gibt nichts ungewöhnliches an dem Pfad, keine Leerzeichen, nur a-z/A-Z im Namen, die Länge des Pfades ist kurz, der längste Pfad ist 76 Zeichen einschließlich des Dateinamens, der Basispfad ist 34 Zeichen lang.

Wie kann ich gcc zwingen, gemischte Stilpfade zu erzeugen?

Answer 1

Ich kann das gleiche Problem auf meinem Projekt sehen. Ich verwende gmake.exe von Cygwin unter Windows.

Ein Aufruf von gcc -MM gibt sowohl Windows-Pfade (C:/project/file.h) als auch Cygwin-Pfade (/cygdrive/c/project/file.h) aus.

Ich weiß nicht, wie das noch zu beheben ist, aber ich fand, was die Änderung zu Cygwin-Pfaden auslöst. Dies geschieht, wenn ein Include einen relativen Pfad verwendet. Wenn also eine Datei #include "../file.h" enthält, enthält die Ausgabe von gcc -MM den absoluten Pfad von file.h mit einem Cygwin-ähnlichen Pfad.