การส่งผ่านข้อโต้แย้งเพื่อ“ ทำการ”

ฉันใช้ Makefiles

ฉันมีเป้าหมายที่เรียกว่าเรียกใช้เป้าหมายrunการสร้าง ง่ายขึ้นดูเหมือนว่าต่อไปนี้:

prog: ....
  ...

run: prog
  ./prog

มีวิธีใดบ้างในการส่งผ่านข้อโต้แย้ง? ดังนั้น

make run asdf --> ./prog asdf
make run the dog kicked the cat --> ./prog the dog kicked the cat

ขอบคุณ!

ฉันไม่รู้วิธีที่จะทำสิ่งที่คุณต้องการอย่างแน่นอน แต่วิธีแก้ปัญหาอาจเป็น:

run: ./prog
    ./prog $(ARGS)

แล้ว:

make ARGS="asdf" run
# or
make run ARGS="asdf"

คำถามนี้เกือบสามปีแล้ว แต่ ...

หากคุณใช้ GNU ทำสิ่งนี้จะทำได้ง่าย ปัญหาเดียวคือว่าmakeจะตีความข้อโต้แย้งที่ไม่ใช่ตัวเลือกในบรรทัดคำสั่งเป็นเป้าหมาย วิธีแก้ปัญหาคือเปลี่ยนให้เป็นเป้าหมายที่ไม่ทำอะไรเลยดังนั้นmakeอย่าบ่นเลย:

# If the first argument is "run"...
ifeq (run,$(firstword $(MAKECMDGOALS)))
  # use the rest as arguments for "run"
  RUN_ARGS := $(wordlist 2,$(words $(MAKECMDGOALS)),$(MAKECMDGOALS))
  # ...and turn them into do-nothing targets
  $(eval $(RUN_ARGS):;@:)
endif

prog: # ...
    # ...

.PHONY: run
run : prog
    @echo prog $(RUN_ARGS)

ใช้สิ่งนี้ให้:

$ make run foo bar baz
prog foo bar baz

สำหรับมาตรฐานทำให้คุณสามารถส่งผ่านข้อโต้แย้งโดยกำหนดมาโครเช่นนี้

make run arg1=asdf

จากนั้นใช้พวกเขาเช่นนี้

run: ./prog $(arg1)
   etc

การอ้างอิงเพื่อสร้างNMake ของ Microsoft

คุณสามารถส่งตัวแปรไปยัง Makefile ได้ดังนี้:

run:
    @echo ./prog $$FOO

การใช้งาน:

$ make run FOO="the dog kicked the cat"
./prog the dog kicked the cat

หรือ:

$ FOO="the dog kicked the cat" make run
./prog the dog kicked the cat

หรือใช้วิธีการแก้ปัญหาที่ให้บริการโดยเบต้า :

run:
    @echo ./prog $(filter-out $@,$(MAKECMDGOALS))
%:
    @:

%:- กฎที่ตรงกับชื่องานใด ๆ @:- สูตรว่าง = ไม่ทำอะไรเลย

การใช้งาน:

$ make run the dog kicked the cat
./prog the dog kicked the cat

TL; DR อย่าพยายามทำสิ่งนี้

$ make run arg

สร้างสคริปต์แทน:

#! /bin/sh
# rebuild prog if necessary
make prog
# run prog with some arguments
./prog "$@"

และทำสิ่งนี้:

$ ./buildandrunprog.sh arg

ตอบคำถามที่ระบุไว้:

คุณสามารถใช้ตัวแปรในสูตร

run: prog
    ./prog $(var)

จากนั้นส่งการกำหนดตัวแปรให้เป็นอาร์กิวเมนต์เพื่อสร้าง

$ make run var=arg

./prog argนี้จะดำเนินการ

แต่ระวังข้อผิดพลาด ฉันจะทำอย่างละเอียดเกี่ยวกับข้อผิดพลาดของวิธีนี้และวิธีการอื่น ๆ ต่อไป

ตอบความตั้งใจที่อยู่เบื้องหลังคำถาม:

ข้อสันนิษฐาน: คุณต้องการเรียกใช้progด้วยอาร์กิวเมนต์บางตัว แต่ให้สร้างใหม่ก่อนที่จะทำงานหากจำเป็น

คำตอบ: สร้างสคริปต์ที่สร้างใหม่ถ้าจำเป็นแล้วเรียกใช้ prog ด้วย args

#! /bin/sh
# rebuild prog if necessary
make prog
# run prog with some arguments
./prog "$@"

สคริปต์นี้ทำให้ความตั้งใจชัดเจนมาก มันใช้ make เพื่อทำสิ่งที่มันดีสำหรับ: building มันใช้เชลล์สคริปต์เพื่อทำสิ่งที่ดีสำหรับ: การประมวลผลแบบแบตช์

รวมทั้งคุณสามารถทำสิ่งอื่นที่คุณอาจต้องการด้วยความยืดหยุ่นและการแสดงออกของเชลล์สคริปต์อย่างเต็มที่โดยไม่มีคำเตือนทั้งหมดของ makefile

ไวยากรณ์การโทรก็เหมือนกันในทางปฏิบัติแล้ว:

$ ./buildandrunprog.sh foo "bar baz"

เปรียบเทียบกับ:

$ ./prog foo "bar baz"

ตรงกันข้ามกับ

$ make run var="foo bar\ baz"

พื้นหลัง:

make ไม่ได้ถูกออกแบบมาเพื่อส่งอาร์กิวเมนต์ไปยังเป้าหมาย อาร์กิวเมนต์ทั้งหมดในบรรทัดคำสั่งถูกตีความว่าเป็นเป้าหมาย (aka เป้าหมาย) เป็นตัวเลือกหรือเป็นการกำหนดตัวแปร

ดังนั้นถ้าคุณเรียกใช้สิ่งนี้:

$ make run foo --wat var=arg

ทำให้จะตีความrunและfooเป็นเป้าหมาย (เป้าหมาย) เพื่ออัปเดตตามสูตรของพวกเขา --watเป็นตัวเลือกสำหรับการทำ และvar=argเป็นการกำหนดตัวแปร

สำหรับรายละเอียดเพิ่มเติมดูได้ที่: https://www.gnu.org/software/make/manual/html_node/Goals.html#Goals

สำหรับคำศัพท์โปรดดูที่: https://www.gnu.org/software/make/manual/html_node/Rule-Introduction.html#Rule-Introduction

เกี่ยวกับวิธีการกำหนดตัวแปรและทำไมฉันถึงแนะนำมัน

$ make run var=arg

และตัวแปรในสูตร

run: prog
    ./prog $(var)

นี่เป็นวิธีที่ "ถูกต้อง" และตรงไปตรงมาที่สุดในการส่งผ่านข้อโต้แย้งไปยังสูตร แต่ในขณะที่มันสามารถใช้เพื่อเรียกใช้โปรแกรมที่มีข้อโต้แย้งมันไม่ได้ถูกออกแบบมาให้ใช้อย่างนั้น ดูhttps://www.gnu.org/software/make/manual/html_node/Overriding.html#Overriding

ในความคิดของฉันนี้มีข้อเสียอย่างหนึ่งใหญ่: สิ่งที่คุณต้องการจะทำคือการทำงานที่มีการโต้แย้งprog argแต่แทนที่จะเขียน:

$ ./prog arg

คุณกำลังเขียน:

$ make run var=arg

สิ่งนี้จะได้รับที่น่าอึดอัดใจมากขึ้นเมื่อพยายามที่จะผ่านข้อโต้แย้งหรือข้อโต้แย้งที่มีช่องว่าง:

$ make run var="foo bar\ baz"
./prog foo bar\ baz
argcount: 2
arg: foo
arg: bar baz

เปรียบเทียบกับ:

$ ./prog foo "bar baz"
argcount: 2
arg: foo
arg: bar baz

สำหรับบันทึกนี่คือสิ่งที่ฉันprogดูเหมือน:

#! /bin/sh
echo "argcount: $#"
for arg in "$@"; do
  echo "arg: $arg"
done

โปรดทราบว่าคุณไม่ควรใส่$(var)เครื่องหมายคำพูดใน makefile:

run: prog
    ./prog "$(var)"

เพราะprogจะได้รับเพียงหนึ่งอาร์กิวเมนต์:

$ make run var="foo bar\ baz"
./prog "foo bar\ baz"
argcount: 1
arg: foo bar\ baz

ทั้งหมดนี้เป็นเหตุผลที่ฉันแนะนำให้กับเส้นทางนี้

เพื่อความสมบูรณ์ที่นี่มีวิธีการอื่น ๆ "ผ่านการขัดแย้งเพื่อให้ทำงาน"

วิธีที่ 1:

run: prog
    ./prog $(filter-out $@, $(MAKECMDGOALS))

%:
    @true

คำอธิบายสั้น ๆ : กรองเป้าหมายปัจจุบันออกจากรายการเป้าหมาย สร้าง catch all all ( %) ซึ่งไม่ทำอะไรเลยที่จะเพิกเฉยต่อเป้าหมายอื่น ๆ

วิธีที่ 2:

ifeq (run, $(firstword $(MAKECMDGOALS)))
  runargs := $(wordlist 2, $(words $(MAKECMDGOALS)), $(MAKECMDGOALS))
  $(eval $(runargs):;@true)
endif

run:
    ./prog $(runargs)

คำอธิบายสั้นสุดถ้าเป้าหมายคือแล้วเอาประตูแรกและสร้างเป้าหมายอะไรทำเพื่อเป้าหมายที่เหลืออยู่โดยใช้runeval

ทั้งสองจะอนุญาตให้คุณเขียนบางสิ่งเช่นนี้

$ make run arg1 arg2

สำหรับคำอธิบายที่ละเอียดยิ่งขึ้นศึกษาคู่มือการทำ: https://www.gnu.org/software/make/manual/html_node/index.html

ปัญหาของวิธีที่ 1:

• อาร์กิวเมนต์ที่ขึ้นต้นด้วยเส้นประจะถูกตีความโดย make และไม่ผ่านเป็นเป้าหมาย

  $ make run --foo --bar
  

  วิธีแก้ปัญหา

  $ make run -- --foo --bar
  

• อาร์กิวเมนต์ที่มีเครื่องหมายเท่ากับจะถูกตีความโดย make และไม่ผ่าน

  $ make run foo=bar
  

  ไม่มีวิธีแก้ไข

• ขัดแย้งกับช่องว่างเป็นที่น่าอึดอัดใจ

  $ make run foo "bar\ baz"
  

  ไม่มีวิธีแก้ไข

• หากมีข้อโต้แย้งเกิดขึ้นrun(เท่ากับเป้าหมาย) ก็จะถูกลบออก

  $ make run foo bar run
  

  จะทำงาน./prog foo barแทน./prog foo bar run

  วิธีแก้ปัญหาที่เป็นไปได้ด้วยวิธีที่ 2

• หากการโต้เถียงเป็นเป้าหมายที่ถูกกฎหมายมันก็จะถูกเรียกใช้

  $ make run foo bar clean
  

  จะทำงาน./prog foo bar cleanแต่ยังมีสูตรสำหรับเป้าหมายclean(สมมติว่ามีอยู่)

  วิธีแก้ปัญหาที่เป็นไปได้ด้วยวิธีที่ 2

• เมื่อคุณพิมพ์ผิดเป้าหมายที่ถูกต้องมันจะถูกเพิกเฉยอย่างเงียบ ๆ เพราะจับเป้าหมายทั้งหมด

  $ make celan
  

  จะเพิกเฉยอย่างเงียบ ๆ celanก็จะเงียบไม่สนใจ

  วิธีแก้ปัญหาคือการทำให้ทุกอย่างละเอียด ดังนั้นคุณจะเห็นสิ่งที่เกิดขึ้น แต่นั่นสร้างเสียงรบกวนมากสำหรับเอาต์พุตที่ถูกต้อง

ปัญหาของวิธีที่ 2:

• หากอาร์กิวเมนต์มีชื่อเดียวกันกับเป้าหมายที่มีอยู่แล้ว make จะพิมพ์คำเตือนว่ามันถูกเขียนทับ

  ไม่มีวิธีแก้ปัญหาที่ฉันรู้

• อาร์กิวเมนต์ที่มีเครื่องหมายเท่ากับจะยังคงถูกตีความโดย make และไม่ผ่าน

  ไม่มีวิธีแก้ไข

• การขัดแย้งกับช่องว่างยังคงน่าอึดอัดใจ

  ไม่มีวิธีแก้ไข

• การโต้เถียงกับการแบ่งช่องว่างevalพยายามที่จะสร้างไม่ทำอะไรเลยเป้าหมาย

  วิธีแก้ปัญหา: สร้างการจับทั่วโลกทุกเป้าหมายโดยไม่ทำอะไรเลย ด้วยปัญหาดังกล่าวข้างต้นว่าจะไม่สนใจเป้าหมายที่ชอบด้วยกฎหมายที่ผิดพลาดอีกต่อไป

• มันใช้evalเพื่อแก้ไข makefile ที่รันไทม์ คุณจะไปได้ไกลแค่ไหนในแง่ของความสามารถในการอ่านและการดีบักและหลักการของความประหลาดใจอย่างน้อยที่สุดหลักการน้อยมหัศจรรย์

  วิธีแก้ปัญหา: ไม่ทำเช่นนี้ !! 1 progแทนเขียนสคริปต์เปลือกที่วิ่งให้แล้ววิ่ง

ฉันได้ทำการทดสอบโดยใช้ gnu make เท่านั้น สิ่งอื่น ๆ อาจมีพฤติกรรมที่แตกต่างกัน

TL; DR อย่าพยายามทำสิ่งนี้

$ make run arg

สร้างสคริปต์แทน:

#! /bin/sh
# rebuild prog if necessary
make prog
# run prog with some arguments
./prog "$@"

และทำสิ่งนี้:

$ ./buildandrunprog.sh arg

นี่คือวิธีแก้ไขปัญหาอื่นที่สามารถช่วยกรณีการใช้งานบางกรณี:

test-%:
    $(PYTHON) run-tests.py $@

กล่าวอีกนัยหนึ่งให้เลือกคำนำหน้า ( test-ในกรณีนี้) จากนั้นส่งชื่อเป้าหมายโดยตรงไปยังโปรแกรม / นักวิ่ง ฉันเดาว่านี่เป็นประโยชน์ส่วนใหญ่หากมีบางส่วนเกี่ยวข้องกับสคริปต์นักวิ่งที่สามารถแกะชื่อเป้าหมายเป็นสิ่งที่มีประโยชน์สำหรับโปรแกรมพื้นฐาน

ไม่ดูที่ไวยากรณ์จาก man page ของ GNU make

ทำ [-f makefile] [ตัวเลือก] ... [เป้าหมาย] ...

คุณสามารถระบุเป้าหมายได้หลายเป้าหมายดังนั้น 'ไม่' (อย่างน้อยไม่ในวิธีที่คุณระบุ)

คุณสามารถแยกอาร์กิวเมนต์ n-th แต่ละรายการอย่างชัดเจนในบรรทัดคำสั่ง ในการทำเช่นนี้คุณสามารถใช้ตัวแปร MAKECMDGOALS ซึ่งเก็บรายการอาร์กิวเมนต์บรรทัดคำสั่งที่กำหนดให้กับ 'make' ซึ่งตีความเป็นรายการของเป้าหมาย หากคุณต้องการแยกอาร์กิวเมนต์ n-th คุณสามารถใช้ตัวแปรนั้นรวมกับฟังก์ชั่น "word" ตัวอย่างเช่นถ้าคุณต้องการอาร์กิวเมนต์ที่สองคุณสามารถเก็บไว้ในตัวแปรดังนี้

second_argument := $(word 2, $(MAKECMDGOALS) )

อานนท์ , run: ./progลักษณะบิตแปลกเป็นส่วนหนึ่งที่เหมาะสมควรจะเป็นเป้าหมายเพื่อให้run: progดูดี

ฉันอยากจะแนะนำเพียง:

.PHONY: run

run:
        prog $(arg1)

และฉันต้องการเพิ่มข้อโต้แย้งนั้นสามารถถูกส่งผ่าน:

1. เป็นอาร์กิวเมนต์: make arg1="asdf" run
2. หรือถูกกำหนดเป็นสภาพแวดล้อม: arg1="asdf" make run

นี่คือตัวอย่างของฉัน โปรดทราบว่าฉันกำลังเขียนภายใต้ Windows 7 โดยใช้ mingw32-make.exe ที่มาพร้อมกับ Dev-Cpp (ฉันมี c: \ Windows \ System32 \ make.bat ดังนั้นคำสั่งยังคงเรียกว่า "make")

clean:
    $(RM) $(OBJ) $(BIN) 
    @echo off
    if "${backup}" NEQ "" ( mkdir ${backup} 2> nul && copy * ${backup} )

การใช้งานสำหรับการทำความสะอาดปกติ:

make clean

การใช้งานสำหรับการทำความสะอาดและสร้างการสำรองข้อมูลใน mydir /:

make clean backup=mydir

ไม่ภูมิใจกับสิ่งนี้มากเกินไป แต่ฉันไม่ต้องการผ่านตัวแปรสภาพแวดล้อมดังนั้นฉันจึงกลับวิธีเรียกใช้คำสั่งบรรจุกระป๋อง:

run:
    @echo command-you-want

สิ่งนี้จะพิมพ์คำสั่งที่คุณต้องการเรียกใช้ดังนั้นเพียงประเมินมันใน subshell:

$(make run) args to my command

ฉันพบวิธีรับอาร์กิวเมนต์ที่มีเครื่องหมายเท่ากับ (=)! คำตอบนี้เป็นส่วนเพิ่มเติมของคำตอบ @lesmana (เพราะสมบูรณ์ที่สุดและอธิบายได้ที่นี่) แต่มันใหญ่เกินไปที่จะเขียนเป็นความคิดเห็น อีกครั้งฉันทำซ้ำข้อความของเขา: TL; DR อย่าพยายามทำเช่นนี้!

ผมจำเป็นต้องมีวิธีการที่จะรักษาข้อโต้แย้งของฉัน--xyz-enabled=false(ตั้งแต่เริ่มต้นเป็นความจริง) $(MAKECMDGOALS)ซึ่งเราทุกคนรู้ว่าตอนนี้ที่ว่านี้ไม่ได้เป็นเป้าหมายของการแต่งหน้าจึงไม่เป็นส่วนหนึ่งของ

ในขณะที่ดูตัวแปรทั้งหมดของการทำโดยการสะท้อน$(.VARIABLES)ฉันได้ผลลัพธ์ที่น่าสนใจ:

[...] -*-command-variables-*- --xyz-enabled [...]

นี้จะช่วยให้เราไปสองวิธีทั้งได้รับการเริ่มต้นทั้งหมดด้วย--(ถ้าที่นำไปใช้กับกรณีของคุณ) หรือลักษณะเป็นGNU ให้เฉพาะเจาะจง (อาจจะไม่ได้มีไว้สำหรับเราที่จะใช้งาน)-*-command-variables-*-ตัวแปร ** ดูส่วนท้ายสำหรับตัวเลือกเพิ่มเติม ** ในกรณีของฉันตัวแปรนี้ถือ:

--xyz-enabled=false

ด้วยตัวแปรนี้เราสามารถรวมกับโซลูชันที่มีอยู่แล้วด้วย$(MAKECMDGOALS)และโดยการกำหนด:

# the other technique to invalidate other targets is still required, see linked post
run:
    @echo ./prog $(-*-command-variables-*-) $(filter-out $@,$(MAKECMDGOALS))`

และใช้งานด้วย (รวมลำดับของการขัดแย้งอย่างชัดเจน):

make run -- config --xyz-enabled=false over=9000 --foo=bar show  isit=alwaysreversed? --help

กลับมาว่า:

./prog isit=alwaysreversed? --foo=bar over=9000 --xyz-enabled=false config show --help

อย่างที่คุณเห็นเราปลดปล่อยออร์เดอร์ทั้งหมด ส่วนที่มี "การกำหนดค่า" - อัตราต่อรองดูเหมือนจะถูกย้อนกลับลำดับของ "เป้าหมาย" -args จะถูกเก็บไว้ ฉันวาง "มอบหมาย" - ค่าเริ่มต้นหวังว่าโปรแกรมของคุณจะไม่สนใจว่าข้อโต้แย้งนั้นถูกวางไว้ที่ใด

ปรับปรุง: ต่อไปนี้ทำให้ตัวแปรดูมีแนวโน้มเช่นกัน:

MAKEFLAGS =  -- isit=alwaysreverse? --foo=bar over=9000 --xyz-enabled=false
MAKEOVERRIDES = isit=alwaysreverse? --foo=bar over=9000 --xyz-enabled=false

อีกวิธีที่ฉันใช้คือ-nธงซึ่งบอกmakeให้ทำแห้ง ตัวอย่างเช่น,

$ make install -n 
# Outputs the string: helm install stable/airflow --name airflow -f values.yaml
$ eval $(make install -n) --dry-run --debug
# Runs: helm install stable/airflow --name airflow -f values.yaml --dry-run --debug