Sistema operacional detectando makefile

Rotineiramente, trabalho em vários computadores e sistemas operacionais diferentes, que são Mac OS X, Linux ou Solaris. Para o projeto em que estou trabalhando, retiro meu código de um repositório git remoto.

Eu gosto de poder trabalhar em meus projetos, independentemente do terminal em que estou. Até agora, encontrei maneiras de contornar as alterações no sistema operacional alterando o makefile toda vez que troco de computador. No entanto, isso é tedioso e causa um monte de dores de cabeça.

Como posso modificar meu makefile para detectar qual SO estou usando e modificar a sintaxe de acordo?

Aqui está o makefile:

cc = gcc -g
CC = g++ -g
yacc=$(YACC)
lex=$(FLEX)

all: assembler

assembler: y.tab.o lex.yy.o
        $(CC) -o assembler y.tab.o lex.yy.o -ll -l y

assembler.o: assembler.c
        $(cc) -o assembler.o assembler.c

y.tab.o: assem.y
        $(yacc) -d assem.y
        $(CC) -c y.tab.c

lex.yy.o: assem.l
        $(lex) assem.l
        $(cc) -c lex.yy.c

clean:
        rm -f lex.yy.c y.tab.c y.tab.h assembler *.o *.tmp *.debug *.acts

Já existem muitas boas respostas aqui, mas eu queria compartilhar um exemplo mais completo de que ambos:

• não assume que unameexiste no Windows
• também detecta o processador

Os CCFLAGS definidos aqui não são necessariamente recomendados ou ideais; eles são exatamente o que o projeto ao qual eu estava adicionando a detecção automática de SO / CPU estava usando.

ifeq ($(OS),Windows_NT)
    CCFLAGS += -D WIN32
    ifeq ($(PROCESSOR_ARCHITEW6432),AMD64)
        CCFLAGS += -D AMD64
    else
        ifeq ($(PROCESSOR_ARCHITECTURE),AMD64)
            CCFLAGS += -D AMD64
        endif
        ifeq ($(PROCESSOR_ARCHITECTURE),x86)
            CCFLAGS += -D IA32
        endif
    endif
else
    UNAME_S := $(shell uname -s)
    ifeq ($(UNAME_S),Linux)
        CCFLAGS += -D LINUX
    endif
    ifeq ($(UNAME_S),Darwin)
        CCFLAGS += -D OSX
    endif
    UNAME_P := $(shell uname -p)
    ifeq ($(UNAME_P),x86_64)
        CCFLAGS += -D AMD64
    endif
    ifneq ($(filter %86,$(UNAME_P)),)
        CCFLAGS += -D IA32
    endif
    ifneq ($(filter arm%,$(UNAME_P)),)
        CCFLAGS += -D ARM
    endif
endif

O comando uname ( http://developer.apple.com/documentation/Darwin/Reference/ManPages/man1/uname.1.html ) sem parâmetros deve informar o nome do sistema operacional. Eu usaria isso, então faria condicionais com base no valor de retorno.

Exemplo

UNAME := $(shell uname)

ifeq ($(UNAME), Linux)
# do something Linux-y
endif
ifeq ($(UNAME), Solaris)
# do something Solaris-y
endif

Detecte o sistema operacional usando dois truques simples:

• Primeiro a variável de ambiente OS
• Então o unamecomando

ifeq ($(OS),Windows_NT)     # is Windows_NT on XP, 2000, 7, Vista, 10...
    detected_OS := Windows
else
    detected_OS := $(shell uname)  # same as "uname -s"
endif

Ou uma maneira mais segura, se não estiver no Windows e unameindisponível:

ifeq ($(OS),Windows_NT) 
    detected_OS := Windows
else
    detected_OS := $(shell sh -c 'uname 2>/dev/null || echo Unknown')
endif

Ken Jackson propõe uma alternativa interessante se você deseja distinguir Cygwin / MinGW / MSYS / Windows. Veja a resposta dele assim:

ifeq '$(findstring ;,$(PATH))' ';'
    detected_OS := Windows
else
    detected_OS := $(shell uname 2>/dev/null || echo Unknown)
    detected_OS := $(patsubst CYGWIN%,Cygwin,$(detected_OS))
    detected_OS := $(patsubst MSYS%,MSYS,$(detected_OS))
    detected_OS := $(patsubst MINGW%,MSYS,$(detected_OS))
endif

Depois, você pode selecionar o material relevante, dependendo de detected_OS:

ifeq ($(detected_OS),Windows)
    CFLAGS += -D WIN32
endif
ifeq ($(detected_OS),Darwin)        # Mac OS X
    CFLAGS += -D OSX
endif
ifeq ($(detected_OS),Linux)
    CFLAGS   +=   -D LINUX
endif
ifeq ($(detected_OS),GNU)           # Debian GNU Hurd
    CFLAGS   +=   -D GNU_HURD
endif
ifeq ($(detected_OS),GNU/kFreeBSD)  # Debian kFreeBSD
    CFLAGS   +=   -D GNU_kFreeBSD
endif
ifeq ($(detected_OS),FreeBSD)
    CFLAGS   +=   -D FreeBSD
endif
ifeq ($(detected_OS),NetBSD)
    CFLAGS   +=   -D NetBSD
endif
ifeq ($(detected_OS),DragonFly)
    CFLAGS   +=   -D DragonFly
endif
ifeq ($(detected_OS),Haiku)
    CFLAGS   +=   -D Haiku
endif

Notas:

• O comando unameé o mesmo que uname -sopção -s( --kernel-name) é o padrão. Veja por que uname -sé melhor queuname -o .

• O uso de OS(em vez de uname) simplifica o algoritmo de identificação. Você ainda pode usar apenas uname, mas precisa lidar com os if/elseblocos para verificar todas as variações do MinGW, Cygwin etc.

• A variável de ambiente OSé sempre definida como "Windows_NT"em diferentes versões do Windows (consulte %OS%variável de ambiente na Wikipedia ).

• Uma alternativa de OSé a variável de ambiente MSVC(verifica a presença do MS Visual Studio , veja o exemplo usando o Visual C ++ ).

Abaixo, forneço um exemplo completo usando makee gccpara criar uma biblioteca compartilhada: *.soou *.dlldependendo da plataforma. O exemplo é o mais simples possível para ser mais compreensível.

Para instalar makee gccno Windows, consulte Cygwin ou MinGW .

Meu exemplo é baseado em cinco arquivos

 ├── lib
 │   └── Makefile
 │   └── hello.h
 │   └── hello.c
 └── app
     └── Makefile
     └── main.c

Lembrete: Makefile é recuado usando tabulação . Cuidado ao copiar e colar abaixo dos arquivos de amostra.

Os dois Makefilearquivos

1 lib/Makefile

ifeq ($(OS),Windows_NT)
    uname_S := Windows
else
    uname_S := $(shell uname -s)
endif

ifeq ($(uname_S), Windows)
    target = hello.dll
endif
ifeq ($(uname_S), Linux)
    target = libhello.so
endif
#ifeq ($(uname_S), .....) #See https://stackoverflow.com/a/27776822/938111
#    target = .....
#endif

%.o: %.c
    gcc  -c $<  -fPIC  -o $@
    # -c $<  => $< is first file after ':' => Compile hello.c
    # -fPIC  => Position-Independent Code (required for shared lib)
    # -o $@  => $@ is the target => Output file (-o) is hello.o

$(target): hello.o
    gcc  $^  -shared  -o $@
    # $^      => $^ expand to all prerequisites (after ':') => hello.o
    # -shared => Generate shared library
    # -o $@   => Output file (-o) is $@ (libhello.so or hello.dll)

2) app/Makefile

ifeq ($(OS),Windows_NT)
    uname_S := Windows
else
    uname_S := $(shell uname -s)
endif

ifeq ($(uname_S), Windows)
    target = app.exe
endif
ifeq ($(uname_S), Linux)
    target = app
endif
#ifeq ($(uname_S), .....) #See https://stackoverflow.com/a/27776822/938111
#    target = .....
#endif

%.o: %.c
    gcc  -c $< -I ../lib  -o $@
    # -c $<     => compile (-c) $< (first file after :) = main.c
    # -I ../lib => search headers (*.h) in directory ../lib
    # -o $@     => output file (-o) is $@ (target) = main.o

$(target): main.o
    gcc  $^  -L../lib  -lhello  -o $@
    # $^       => $^ (all files after the :) = main.o (here only one file)
    # -L../lib => look for libraries in directory ../lib
    # -lhello  => use shared library hello (libhello.so or hello.dll)
    # -o $@    => output file (-o) is $@ (target) = "app.exe" or "app"

Para saber mais, leia a documentação de Variáveis ​​automáticas , conforme indicado pelo cfi .

O código fonte

- lib/hello.h

#ifndef HELLO_H_
#define HELLO_H_

const char* hello();

#endif

- lib/hello.c

#include "hello.h"

const char* hello()
{
    return "hello";
}

- app/main.c

#include "hello.h" //hello()
#include <stdio.h> //puts()

int main()
{
    const char* str = hello();
    puts(str);
}

A compilação

Corrija a copiar-colar de Makefile(substitua os espaços à esquerda por uma tabulação).

> sed  's/^  */\t/'  -i  */Makefile

O makecomando é o mesmo nas duas plataformas. A saída fornecida é em sistemas operacionais semelhantes ao Unix:

> make -C lib
make: Entering directory '/tmp/lib'
gcc  -c hello.c  -fPIC  -o hello.o
# -c hello.c  => hello.c is first file after ':' => Compile hello.c
# -fPIC       => Position-Independent Code (required for shared lib)
# -o hello.o  => hello.o is the target => Output file (-o) is hello.o
gcc  hello.o  -shared  -o libhello.so
# hello.o        => hello.o is the first after ':' => Link hello.o
# -shared        => Generate shared library
# -o libhello.so => Output file (-o) is libhello.so (libhello.so or hello.dll)
make: Leaving directory '/tmp/lib'

> make -C app
make: Entering directory '/tmp/app'
gcc  -c main.c -I ../lib  -o main.o
# -c main.c => compile (-c) main.c (first file after :) = main.cpp
# -I ../lib => search headers (*.h) in directory ../lib
# -o main.o => output file (-o) is main.o (target) = main.o
gcc  main.o  -L../lib  -lhello  -o app
# main.o   => main.o (all files after the :) = main.o (here only one file)
# -L../lib => look for libraries in directory ../lib
# -lhello  => use shared library hello (libhello.so or hello.dll)
# -o app   => output file (-o) is app.exe (target) = "app.exe" or "app"
make: Leaving directory '/tmp/app'

A corrida

O aplicativo requer saber onde está a biblioteca compartilhada.

No Windows, uma solução simples é copiar a biblioteca onde o aplicativo está:

> cp -v lib/hello.dll app
`lib/hello.dll' -> `app/hello.dll'

Em sistemas operacionais semelhantes ao Unix, você pode usar a LD_LIBRARY_PATHvariável de ambiente:

> export LD_LIBRARY_PATH=lib

Execute o comando no Windows:

> app/app.exe
hello

Execute o comando em sistemas operacionais semelhantes ao Unix:

> app/app
hello

Eu estava experimentando recentemente para responder a essa pergunta que estava me perguntando. Aqui estão as minhas conclusões:

Como no Windows, você não pode ter certeza de que o unamecomando está disponível, você pode usá-lo gcc -dumpmachine. Isso exibirá o destino do compilador.

Também pode haver um problema ao usar unamese você deseja fazer alguma compilação cruzada.

Aqui está uma lista de exemplo de saída possível de gcc -dumpmachine:

• mingw32
• i686-pc-cygwin
• x86_64-redhat-linux

Você pode verificar o resultado no makefile assim:

SYS := $(shell gcc -dumpmachine)
ifneq (, $(findstring linux, $(SYS)))
 # Do Linux things
else ifneq(, $(findstring mingw, $(SYS)))
 # Do MinGW things
else ifneq(, $(findstring cygwin, $(SYS)))
 # Do Cygwin things
else
 # Do things for others
endif

Funcionou bem para mim, mas não tenho certeza de que seja uma maneira confiável de obter o tipo de sistema. Pelo menos, é confiável sobre o MinGW e é tudo o que preciso, pois não requer o unamecomando ou o pacote MSYS no Windows.

Para resumir, unamefornece o sistema no qual você está compilando e gcc -dumpmachineo sistema para o qual você está compilando.

O makefile do git contém vários exemplos de como gerenciar sem o autoconf / automake, mas ainda funciona em várias plataformas unixy.

Atualização: Agora considero esta resposta obsoleta. Postei uma nova solução perfeita mais abaixo.

Se o seu makefile pode estar em execução no Windows não Cygwin, unamepode não estar disponível. Isso é estranho, mas essa é uma solução potencial. Você deve verificar primeiro o Cygwin para descartá-lo, porque ele também possui o WINDOWS em sua PATHvariável de ambiente.

ifneq (,$(findstring /cygdrive/,$(PATH)))
    UNAME := Cygwin
else
ifneq (,$(findstring WINDOWS,$(PATH)))
    UNAME := Windows
else
    UNAME := $(shell uname -s)
endif
endif

Esse é o trabalho que o automake / autoconf do GNU foi projetado para resolver. Você pode querer investigá-los.

Como alternativa, você pode definir variáveis ​​de ambiente em suas diferentes plataformas e tornar o Makefile condicional em relação a elas.

Finalmente encontrei a solução perfeita que resolve esse problema para mim.

ifeq '$(findstring ;,$(PATH))' ';'
    UNAME := Windows
else
    UNAME := $(shell uname 2>/dev/null || echo Unknown)
    UNAME := $(patsubst CYGWIN%,Cygwin,$(UNAME))
    UNAME := $(patsubst MSYS%,MSYS,$(UNAME))
    UNAME := $(patsubst MINGW%,MSYS,$(UNAME))
endif

A variável UNAME está configurada para Linux, Cygwin, MSYS, Windows, FreeBSD, NetBSD (ou presumivelmente Solaris, Darwin, OpenBSD, AIX, HP-UX) ou Desconhecido. Em seguida, ele pode ser comparado em todo o restante do Makefile para separar quaisquer variáveis ​​e comandos sensíveis ao SO.

A chave é que o Windows usa ponto e vírgula para separar os caminhos na variável PATH, enquanto todos os outros usam dois pontos. (É possível criar um diretório Linux com um ';' no nome e adicioná-lo ao PATH, o que quebraria isso, mas quem faria isso?) Esse parece ser o método menos arriscado para detectar o Windows nativo porque ele não precisa de uma chamada de shell. Os Cygwin e Msys uso PATH dois pontos assim uname é chamado por eles.

Observe que a variável de ambiente do sistema operacional pode ser usada para detectar o Windows, mas não para distinguir entre o Cygwin e o Windows nativo. Testar o eco de aspas funciona, mas requer uma chamada de shell.

Infelizmente, Cygwin adiciona algumas informações de versão à saída de uname , então adicionei as chamadas 'patsubst' para alterá-las para apenas 'Cygwin'. Além disso, uname para MSYS na verdade tem três saídas possíveis começando com MSYS ou MINGW, mas eu também uso o patsubst para transformar tudo em apenas 'MSYS'.

Se é importante distinguir entre sistemas Windows nativos com e sem o uname.exe no caminho, essa linha pode ser usada em vez da atribuição simples:

UNAME := $(shell uname 2>NUL || echo Windows)

É claro que em todos os casos é necessário o GNU make , ou outro make que suporte as funções usadas.

Encontrei esse problema hoje e precisava dele no Solaris, então aqui está uma maneira padrão do POSIX de fazer (algo muito próximo disso) isso.

#Detect OS
UNAME = `uname`

# Build based on OS name
DetectOS:
    -@make $(UNAME)


# OS is Linux, use GCC
Linux: program.c
    @SHELL_VARIABLE="-D_LINUX_STUFF_HERE_"
    rm -f program
    gcc $(SHELL_VARIABLE) -o program program.c

# OS is Solaris, use c99
SunOS: program.c
    @SHELL_VARIABLE="-D_SOLARIS_STUFF_HERE_"
    rm -f program
    c99 $(SHELL_VARIABLE) -o program program.c

Aqui está uma solução simples que verifica se você está em um ambiente Windows ou posix (Linux / Unix / Cygwin / Mac):

ifeq ($(shell echo "check_quotes"),"check_quotes")
   WINDOWS := yes
else
   WINDOWS := no
endif

Ele aproveita o fato de que o eco existe nos ambientes do tipo posix e do Windows, e que no Windows o shell não filtra as aspas.

Observe que os Makefiles são extremamente sensíveis ao espaçamento. Aqui está um exemplo de um Makefile que executa um comando extra no OS X e que funciona no OS X e Linux. No geral, porém, autoconf / automake é o caminho a percorrer para qualquer coisa que não seja trivial.

UNAME: = $ (shell uname -s)
CPP = g ++
CPPFLAGS = -pthread -ansi -Wall -Werror -pedantic -O0 -g3 -I / nexopia / include
LDFLAGS = -pthread -L / nexopia / lib -lboost_system

HEADERS = data_structures.h http_client.h load.h lock.h search.h server.h thread.h utility.h
OBJECTS = http_client.o carga.o bloqueio.oa pesquisa.o servidor.o thread.o utilidade.o vor.o

tudo: vor

limpar \ limpo:
    rm -f $ (OBJETOS) por

vor: $ (OBJETOS)
    $ (CPP) $ (LDFLAGS) -o ou para $ (OBJETOS)
ifeq ($ (UNAME), Darwin)
    # Defina o local da biblioteca do Boost
    install_name_tool -change libboost_system.dylib /nexopia/lib/libboost_system.dylib vor
fim se

% .o:% .cpp $ (HEADERS) Makefile
    $ (CPP) $ (CPPFLAGS) -c $

Outra maneira de fazer isso é usando um script "configure". Se você já está usando um com seu makefile, pode usar uma combinação de uname e sed para fazer com que as coisas funcionem. Primeiro, no seu script, faça:

UNAME=uname

Então, para colocar isso no seu Makefile, comece com Makefile.in, que deve ter algo como

UNAME=@@UNAME@@

iniciar.

Use o seguinte comando sed no seu script de configuração após o UNAME=unamebit.

sed -e "s|@@UNAME@@|$UNAME|" < Makefile.in > Makefile

Agora seu makefile deveria ter UNAMEdefinido como desejado. Se as instruções / elif / else são tudo o que resta!

Eu tive um caso em que tive que detectar a diferença entre duas versões do Fedora, para ajustar as opções de linha de comando do inkscape:
- no Fedora 31, o inkscape padrão é 1.0beta que usa --export-file
- no Fedora <31, o inkscape padrão é 0,92 que usa--export-pdf

Meu Makefile contém o seguinte

# set VERSION_ID from /etc/os-release

$(eval $(shell grep VERSION_ID /etc/os-release))

# select the inkscape export syntax

ifeq ($(VERSION_ID),31)
EXPORT = export-file
else
EXPORT = export-pdf
endif

# rule to convert inkscape SVG (drawing) to PDF

%.pdf : %.svg
    inkscape --export-area-drawing $< --$(EXPORT)=$@

Isso funciona porque /etc/os-releasecontém uma linha

VERSION_ID=<value>

para que o comando shell no Makefile retorne a string VERSION_ID=<value>, o comando eval atua sobre isso para definir a variável Makefile VERSION_ID. Obviamente, isso pode ser ajustado para outros sistemas operacionais, dependendo de como os metadados são armazenados. Note que no Fedora não existe uma variável de ambiente padrão que dê a versão do sistema operacional, caso contrário eu teria usado isso!