bc - คู่มืออ้างอิง ตัวเลือก ตัวอย่างคำสั่ง

---

ชื่อ

bc - ภาษาเครื่องคิดเลขที่มีความแม่นยำตามอำเภอใจ

ซินแท็กซ์

bc [ -hlwsqv ] [ตัวเลือกแบบยาว] [ ไฟล์ ... ]

คำอธิบาย

bc เป็นภาษาที่สนับสนุนตัวเลขที่มีความแม่นยำตามอำเภอใจพร้อมการดำเนินการคำสั่งแบบโต้ตอบ มีความคล้ายคลึงกันบางประการในไวยากรณ์ของโปรแกรมภาษาซี ไลบรารีคณิตศาสตร์มาตรฐานพร้อมใช้งานโดยตัวเลือกบรรทัดคำสั่ง หากมีการร้องขอ จะมีการกำหนดไลบรารีคณิตศาสตร์ก่อนที่จะประมวลผลไฟล์ใดๆ bc เริ่มต้นโดยการประมวลผลโค้ดจากไฟล์ทั้งหมดที่อยู่ในบรรทัดคำสั่งตามลำดับที่แสดง หลังจากประมวลผลไฟล์ทั้งหมดแล้ว bc จะอ่านจากอินพุตมาตรฐาน รหัสทั้งหมดจะถูกดำเนินการตามที่อ่าน (หากไฟล์มีคำสั่งหยุดโปรเซสเซอร์ bc จะไม่อ่านจากอินพุตมาตรฐาน)

bc รุ่นนี้มีส่วนขยายหลายรายการนอกเหนือจากการใช้งาน bc แบบดั้งเดิมและมาตรฐานร่าง POSIX ตัวเลือกบรรทัดคำสั่งอาจทำให้ส่วนขยายเหล่านี้พิมพ์คำเตือนหรือถูกปฏิเสธ เอกสารนี้อธิบายถึงภาษาที่โปรเซสเซอร์นี้ยอมรับ ส่วนขยายจะถูกระบุเช่นนั้น

ตัวเลือก

-h, --help

พิมพ์การใช้งานและออก

-i, --interactive

บังคับโหมดโต้ตอบ

-l, --mathlib

กำหนดไลบรารีคณิตศาสตร์มาตรฐาน

-w, --warn

แจ้งเตือนส่วนขยาย POSIX bc

-s, --standard

ประมวลผลภาษา POSIX bc ทุกประการ

-q, --quiet

อย่าพิมพ์การต้อนรับ GNU bc ปกติ

-v, --version

พิมพ์หมายเลขเวอร์ชันและลิขสิทธิ์แล้วออก

ตัวเลข

องค์ประกอบพื้นฐานที่สุดใน bc คือตัวเลข ตัวเลขเป็นตัวเลขที่มีความแม่นยำตามอำเภอใจ ความแม่นยำนี้มีทั้งในส่วนที่เป็นจำนวนเต็มและส่วนที่เป็นเศษส่วน ตัวเลขทั้งหมดจะแสดงภายในเป็นทศนิยม และการคำนวณทั้งหมดจะทำเป็นทศนิยม (เวอร์ชันนี้ตัดทอนผลลัพธ์จากการหารและการคูณ) มีสองคุณลักษณะของตัวเลข ความยาว และมาตราส่วน ความยาวคือจำนวนทศนิยมทั้งหมดที่ใช้โดย bc เพื่อแสดงตัวเลข และมาตราส่วนคือจำนวนรวมของหลักทศนิยมหลังจุดทศนิยม ตัวอย่างเช่น:

 .000001 has a length of 6 and scale of 6.
 1935.000 has a length of 7 and a scale of 3.

ตัวแปร

ตัวเลขถูกจัดเก็บไว้ในตัวแปร 2 ประเภท คือ ตัวแปรอย่างง่ายและอาร์เรย์ ตั้งชื่อทั้งตัวแปรอย่างง่ายและตัวแปรอาร์เรย์ ชื่อขึ้นต้นด้วยตัวอักษรตามด้วยตัวอักษร ตัวเลข และขีดล่างจำนวนเท่าใดก็ได้ ตัวอักษรทั้งหมดจะต้องเป็นตัวพิมพ์เล็ก (ชื่อที่เป็นตัวอักษรและตัวเลขเต็มเป็นส่วนขยาย ใน POSIX bc ชื่อทั้งหมดเป็นอักษรตัวพิมพ์เล็กตัวเดียว) บริบทจะระบุประเภทของตัวแปรได้ เนื่องจากชื่อตัวแปรอาร์เรย์ทั้งหมดจะตามด้วยวงเล็บเหลี่ยม ( []).

มีตัวแปรพิเศษสี่ตัว ได้แก่ สเกล ibase โอเบส และ สุดท้าย มาตราส่วน กำหนดวิธีที่การดำเนินการบางอย่างใช้ตัวเลขหลังจุดทศนิยม ค่าเริ่มต้นของ มาตราส่วน คือ 0 ibase และ obase กำหนดฐานการแปลงสำหรับตัวเลขอินพุตและเอาต์พุต ค่าเริ่มต้นสำหรับทั้งอินพุตและเอาต์พุตคือฐาน 10 last (ส่วนขยาย) คือตัวแปรที่มีค่าของตัวเลขที่พิมพ์ล่าสุด ซึ่งจะกล่าวถึงในรายละเอียดเพิ่มเติมตามความเหมาะสม ตัวแปรทั้งหมดเหล่านี้อาจมีการกำหนดค่าให้กับตัวแปรเหล่านี้เช่นเดียวกับที่ใช้ในนิพจน์

ความคิดเห็น

ความคิดเห็นใน bc เริ่มต้นด้วยอักขระ /* และลงท้ายด้วยอักขระ */ ความคิดเห็นอาจเริ่มต้นที่ใดก็ได้และปรากฏเป็นช่องว่างเดียวในอินพุต (ซึ่งทำให้ความคิดเห็นเป็นตัวคั่นรายการอินพุตอื่นๆ ตัวอย่างเช่น ไม่พบความคิดเห็นตรงกลางชื่อตัวแปร) ข้อคิดเห็นรวมถึงการขึ้นบรรทัดใหม่ (จุดสิ้นสุดของบรรทัด) ระหว่างจุดเริ่มต้นและจุดสิ้นสุดของความคิดเห็น

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

การแสดงออก

ตัวเลขถูกจัดการโดยนิพจน์และคำสั่ง เนื่องจากภาษาได้รับการออกแบบมาให้โต้ตอบได้ ข้อความและนิพจน์จะถูกดำเนินการโดยเร็วที่สุด ไม่มีโปรแกรม "หลัก" รหัสจะถูกดำเนินการแทนเมื่อพบ (ฟังก์ชั่นที่จะกล่าวถึงในรายละเอียดในภายหลังจะถูกกำหนดเมื่อพบ)

นิพจน์ธรรมดาเป็นเพียงค่าคงที่ bc แปลงค่าคงที่เป็นเลขทศนิยมภายในโดยใช้ฐานอินพุตปัจจุบัน ซึ่งระบุโดยตัวแปร ibase (มีข้อยกเว้นในฟังก์ชัน) ค่าทางกฎหมายของ ibase คือ 2 ถึง 36 (ฐานที่มากกว่า 16 เป็นส่วนขยาย) การกำหนดค่าที่อยู่นอกช่วงนี้ให้กับ ibase จะได้ค่าเป็น 2 หรือ 36 ตัวเลขที่ป้อนอาจมีอักขระ 0-9 และ A-Z (หมายเหตุ: ต้องเป็นตัวพิมพ์ใหญ่ ตัวอักษรตัวพิมพ์เล็กคือชื่อตัวแปร) ตัวเลขหลักเดียวจะมีค่าของหลักเสมอโดยไม่คำนึงถึงค่าของ ibase (เช่น A=10) สำหรับตัวเลขหลายหลัก bc จะเปลี่ยนหลักอินพุตทั้งหมดที่มากกว่าหรือเท่ากับ ibase เป็นค่า ibase-1 ทำให้ตัวเลข ZZZ เป็นตัวเลข 3 หลักที่ใหญ่ที่สุดของฐานอินพุตเสมอ

นิพจน์ทั้งหมดคล้ายกับภาษาระดับสูงอื่น ๆ เนื่องจากมีตัวเลขเพียงประเภทเดียว จึงไม่มีกฎสำหรับการผสมประเภท แต่มีกฎเกี่ยวกับมาตราส่วนของนิพจน์แทน ทุกนิพจน์มีมาตราส่วน ซึ่งได้มาจากมาตราส่วนของตัวเลขดั้งเดิม การดำเนินการที่ทำ และในหลายกรณี ค่าของตัวแปรมาตราส่วน ค่าทางกฎหมายของตัวแปร มาตราส่วน คือ 0 ถึงจำนวนสูงสุดที่แทนด้วยจำนวนเต็ม C

ในคำอธิบายนิพจน์ทางกฎหมายต่อไปนี้ "expr" หมายถึงนิพจน์ที่สมบูรณ์ และ "var" หมายถึงตัวแปรแบบธรรมดาหรือแบบอาร์เรย์ ตัวแปรอย่างง่ายคือ a

name

และระบุตัวแปรอาร์เรย์เป็น

name[expr]

เว้นแต่จะกล่าวถึงเป็นพิเศษ ขนาดของผลลัพธ์คือขนาดสูงสุดของนิพจน์ที่เกี่ยวข้อง

- expr

ผลลัพธ์คือการปฏิเสธของนิพจน์

++ var

ตัวแปรจะเพิ่มขึ้นหนึ่งค่าและค่าใหม่คือผลลัพธ์ของนิพจน์

-- var

ตัวแปรจะลดลงหนึ่งค่าและค่าใหม่คือผลลัพธ์ของนิพจน์

var ++

ผลลัพธ์ของนิพจน์คือค่าของตัวแปร จากนั้นตัวแปรจะเพิ่มขึ้นทีละหนึ่ง

var --

ผลลัพธ์ของนิพจน์คือค่าของตัวแปร จากนั้นตัวแปรจะลดลงหนึ่ง

expr + expr

ผลลัพธ์ของนิพจน์คือผลรวมของนิพจน์ทั้งสอง

expr - expr

ผลลัพธ์ของนิพจน์คือความแตกต่างของนิพจน์ทั้งสอง

expr * expr

ผลลัพธ์ของนิพจน์คือผลคูณของนิพจน์ทั้งสอง

expr / expr

ผลลัพธ์ของนิพจน์คือผลหารของนิพจน์ทั้งสอง สเกลของผลลัพธ์คือค่าของตัวแปร สเกล

expr % expr

ผลลัพธ์ของนิพจน์คือ "ส่วนที่เหลือ" และคำนวณด้วยวิธีต่อไปนี้ ในการคำนวณ a%b a/b ตัวแรกจะคำนวณเป็นมาตราส่วนหลัก ผลลัพธ์นั้นใช้ในการคำนวณ a-(a/b)*b เป็นสเกลสูงสุดของ สเกล+สเกล(b) และสเกล(a) หากตั้งค่า มาตราส่วน เป็นศูนย์ และนิพจน์ทั้งสองเป็นจำนวนเต็ม นิพจน์นี้จะเป็นฟังก์ชันเศษจำนวนเต็ม

expr ^ expr

ผลลัพธ์ของนิพจน์คือค่าของค่าแรกยกกำลังสอง นิพจน์ที่สองต้องเป็นจำนวนเต็ม (หากนิพจน์ที่สองไม่ใช่จำนวนเต็ม จะมีการสร้างคำเตือนและนิพจน์ถูกตัดทอนเพื่อให้ได้ค่าจำนวนเต็ม) สเกลของผลลัพธ์คือ สเกล ถ้าเลขยกกำลังเป็นค่าลบ หากเลขยกกำลังเป็นบวก ขนาดของผลลัพธ์จะเป็นค่าต่ำสุดของมาตราส่วนในนิพจน์แรกคูณด้วยค่าของเลขชี้กำลังและค่าสูงสุดของมาตราส่วนและมาตราส่วนของนิพจน์แรก (เช่น scale(a^b)=min(scale(a)*b, max( scale, scale(a))).) โปรดทราบว่า expr^0 จะส่งกลับค่าเสมอ จาก 1.

( expr )

สิ่งนี้จะเปลี่ยนลำดับความสำคัญมาตรฐานเพื่อบังคับการประเมินนิพจน์

var = expr

ตัวแปรถูกกำหนดค่าของนิพจน์

var <op>= expr

ซึ่งเทียบเท่ากับ "var=var expr" ยกเว้นว่าส่วน "var" ได้รับการประเมินเพียงครั้งเดียว สิ่งนี้สามารถสร้างความแตกต่างได้หาก "var" เป็นอาร์เรย์

นิพจน์เชิงสัมพันธ์เป็นนิพจน์ชนิดพิเศษที่ประเมินเป็น 0 หรือ 1 เสมอ 0 ถ้าความสัมพันธ์เป็นเท็จ และ 1 ถ้าความสัมพันธ์นั้นเป็นจริง สิ่งเหล่านี้อาจปรากฏในสำนวนทางกฎหมายใดๆ (POSIX bc กำหนดให้ใช้นิพจน์เชิงสัมพันธ์เฉพาะใน if, while และ for statement และการทดสอบเชิงสัมพันธ์เดียวเท่านั้นที่ทำได้) ตัวดำเนินการเชิงสัมพันธ์คือ

expr1 < expr2

ผลลัพธ์คือ 1 ถ้า expr1 น้อยกว่า expr2 อย่างเคร่งครัด

expr1 <= expr2

ผลลัพธ์คือ 1 ถ้า expr1 น้อยกว่าหรือเท่ากับ expr2

expr1 > expr2

ผลลัพธ์คือ 1 ถ้า expr1 มากกว่า expr2 อย่างเคร่งครัด

expr1 >= expr2

ผลลัพธ์คือ 1 ถ้า expr1 มากกว่าหรือเท่ากับ expr2

expr1 == expr2

ผลลัพธ์คือ 1 ถ้า expr1 เท่ากับ expr2

expr1 != expr2

ผลลัพธ์คือ 1 ถ้า expr1 ไม่เท่ากับ expr2

การดำเนินการบูลีนยังถูกกฎหมายอีกด้วย (POSIX bc ไม่มีการดำเนินการบูลีน) ผลลัพธ์ของการดำเนินการบูลีนทั้งหมดคือ 0 และ 1 (สำหรับเท็จและจริง) เช่นเดียวกับนิพจน์เชิงสัมพันธ์ ตัวดำเนินการบูลีนคือ:

!expr

ผลลัพธ์คือ 1 ถ้า expr เป็น 0

expr && expr

ผลลัพธ์คือ 1 ถ้านิพจน์ทั้งสองไม่เป็นศูนย์

expr || expr

ผลลัพธ์คือ 1 ถ้านิพจน์ใดไม่ใช่ศูนย์

ลำดับความสำคัญของนิพจน์มีดังนี้: (ต่ำสุดไปสูงสุด)

|| operator, left associative
&& operator, left associative
! operator, nonassociative
Relational operators, left associative
Assignment operator, right associative
+ and - operators, left associative
*, / and % operators, left associative
^ operator, right associative
unary - operator, nonassociative
++ and -- operators, nonassociative

ลำดับความสำคัญนี้ถูกเลือกเพื่อให้โปรแกรม bc ที่สอดคล้องกับ POSIX ทำงานได้อย่างถูกต้อง สิ่งนี้จะทำให้การใช้ตัวดำเนินการเชิงสัมพันธ์และเชิงตรรกะมีลักษณะการทำงานที่ผิดปกติเมื่อใช้กับนิพจน์การกำหนด พิจารณานิพจน์:

a = 3 < 5

โปรแกรมเมอร์ C ส่วนใหญ่จะถือว่าสิ่งนี้จะกำหนดผลลัพธ์ของ "3 < 5" (ค่า 1) ให้กับตัวแปร "a" สิ่งนี้ทำใน bc คือกำหนดค่า 3 ให้กับตัวแปร "a" แล้วเปรียบเทียบ 3 กับ 5 ทางที่ดีควรใช้วงเล็บเมื่อใช้ตัวดำเนินการเชิงสัมพันธ์และเชิงตรรกะกับตัวดำเนินการกำหนด

มีนิพจน์พิเศษอีกสองสามรายการที่มีให้ใน bc สิ่งเหล่านี้เกี่ยวข้องกับฟังก์ชันที่ผู้ใช้กำหนดและฟังก์ชันมาตรฐาน ทั้งหมดจะปรากฏเป็น "ชื่อ(พารามิเตอร์)" ดูหัวข้อเกี่ยวกับฟังก์ชันสำหรับฟังก์ชันที่กำหนดโดยผู้ใช้ ฟังก์ชันมาตรฐานคือ:

length ( expression )

ค่าของฟังก์ชันความยาวคือจำนวนหลักที่มีนัยสำคัญในนิพจน์

read ( )

ฟังก์ชันอ่าน (ส่วนขยาย) จะอ่านตัวเลขจากอินพุตมาตรฐาน โดยไม่คำนึงว่าฟังก์ชันนั้นจะเกิดขึ้นที่ใด ระวัง นี่อาจทำให้เกิดปัญหากับการผสมข้อมูลและโปรแกรมในอินพุตมาตรฐาน การใช้งานที่ดีที่สุดสำหรับฟังก์ชันนี้คือในโปรแกรมที่เขียนขึ้นก่อนหน้านี้ซึ่งต้องการอินพุตจากผู้ใช้ แต่ไม่อนุญาตให้ป้อนรหัสโปรแกรมจากผู้ใช้ ค่าของฟังก์ชันการอ่านคือตัวเลขที่อ่านจากอินพุตมาตรฐานโดยใช้ค่าปัจจุบันของตัวแปร ibase สำหรับฐานการแปลง

scale ( expression )

ค่าของฟังก์ชันสเกลคือจำนวนหลักหลังจุดทศนิยมในนิพจน์

sqrt ( expression )

ค่าของฟังก์ชัน sqrt คือรากที่สองของนิพจน์ ถ้านิพจน์เป็นค่าลบ ข้อผิดพลาดรันไทม์จะถูกสร้างขึ้น

งบ

ข้อความ (เช่นเดียวกับภาษาเกี่ยวกับพีชคณิตส่วนใหญ่) จัดเตรียมลำดับของการประเมินนิพจน์ ในคำสั่ง bc จะดำเนินการ "โดยเร็วที่สุด" การดำเนินการเกิดขึ้นเมื่อพบการขึ้นบรรทัดใหม่และมีคำสั่งที่สมบูรณ์ตั้งแต่หนึ่งคำสั่งขึ้นไป เนื่องจากการดำเนินการทันที การขึ้นบรรทัดใหม่จึงมีความสำคัญมากใน bc อันที่จริงแล้ว ทั้งเครื่องหมายอัฒภาคและการขึ้นบรรทัดใหม่จะใช้เป็นตัวคั่นคำสั่ง บรรทัดใหม่ที่วางไม่ถูกต้องจะทำให้เกิดข้อผิดพลาดทางไวยากรณ์ เนื่องจากการขึ้นบรรทัดใหม่เป็นตัวคั่นคำสั่ง จึงเป็นไปได้ที่จะซ่อนการขึ้นบรรทัดใหม่โดยใช้อักขระแบ็กสแลช ลำดับ "\" โดยที่ เป็นการขึ้นบรรทัดใหม่จะปรากฏเป็น bc เป็นการเว้นวรรคแทนการขึ้นบรรทัดใหม่ รายการคำสั่งคือชุดของคำสั่งที่คั่นด้วยเครื่องหมายอัฒภาคและบรรทัดใหม่ ต่อไปนี้เป็นรายการของคำสั่ง bc และสิ่งที่พวกเขาทำ: (สิ่งที่อยู่ในวงเล็บเหลี่ยม ([]) เป็นส่วนเสริมของคำสั่ง)

expression

ข้อความนี้ทำหนึ่งในสองสิ่ง ถ้านิพจน์ขึ้นต้นด้วย " ..." จะถือเป็นคำสั่งการมอบหมาย หากนิพจน์ไม่ใช่คำสั่งการกำหนด นิพจน์จะถูกประเมินและพิมพ์ไปยังเอาต์พุต หลังจากพิมพ์หมายเลขแล้ว บรรทัดใหม่จะถูกพิมพ์ ตัวอย่างเช่น "a=1" คือคำสั่งการมอบหมาย และ "(a=1)" คือนิพจน์ที่มีการมอบหมายแบบฝัง ตัวเลขทั้งหมดที่พิมพ์จะพิมพ์ในฐานที่ระบุโดยตัวแปร obase ค่าทางกฎหมายสำหรับ obase คือ 2 ถึง BC_BASE_MAX (ดูหัวข้อขีดจำกัด) สำหรับฐาน 2 ถึง 16 จะใช้วิธีการเขียนตัวเลขตามปกติ สำหรับฐานที่มากกว่า 16 bc ใช้วิธีพิมพ์ตัวเลขแบบหลายอักขระ โดยพิมพ์ฐานที่สูงกว่าแต่ละหลักเป็นเลขฐาน 10 ตัวเลขหลายตัวถูกคั่นด้วยช่องว่าง แต่ละหลักประกอบด้วยจำนวนอักขระที่จำเป็นในการแสดงค่าฐานสิบของ "obase-1" เนื่องจากตัวเลขมีความแม่นยำตามอำเภอใจ ตัวเลขบางตัวอาจไม่สามารถพิมพ์บนบรรทัดเอาต์พุตเดียวได้ ตัวเลขยาวเหล่านี้จะถูกแบ่งตามบรรทัดโดยใช้ "\" เป็นอักขระตัวสุดท้ายในบรรทัด จำนวนอักขระสูงสุดที่พิมพ์ต่อบรรทัดคือ 70 เนื่องจากลักษณะการโต้ตอบของ bc การพิมพ์ตัวเลขทำให้เกิดผลข้างเคียงในการกำหนดค่าที่พิมพ์ให้กับตัวแปรพิเศษ last . ซึ่งช่วยให้ผู้ใช้สามารถกู้คืนค่าสุดท้ายที่พิมพ์ได้โดยไม่ต้องพิมพ์นิพจน์ที่พิมพ์ตัวเลขซ้ำ การกำหนดให้กับ last นั้นถูกต้องตามกฎหมาย และจะเขียนทับค่าที่พิมพ์ล่าสุดด้วยค่าที่กำหนด ค่าที่กำหนดใหม่จะยังคงอยู่จนกว่าจะพิมพ์ตัวเลขถัดไปหรือกำหนดค่าอื่นเป็น สุดท้าย (การติดตั้งบางอย่างอาจอนุญาตให้ใช้จุดเดียว (.) ซึ่งไม่ใช่ส่วนหนึ่งของตัวเลขในรูปแบบเครื่องหมายเข็มสั้นสำหรับ สุดท้าย)

string

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

print list

คำสั่งพิมพ์ (ส่วนขยาย) จัดเตรียมวิธีการส่งออกอื่น "รายการ" คือรายการของสตริงและนิพจน์ที่คั่นด้วยเครื่องหมายจุลภาค สตริงหรือนิพจน์แต่ละรายการจะถูกพิมพ์ตามลำดับของรายการ ไม่มีการพิมพ์บรรทัดใหม่ที่ยุติ นิพจน์จะได้รับการประเมินและพิมพ์ค่าและกำหนดให้กับตัวแปร สุดท้าย สตริงในคำสั่งการพิมพ์จะถูกพิมพ์ไปยังเอาต์พุตและอาจมีอักขระพิเศษ อักขระพิเศษเริ่มต้นด้วยอักขระเครื่องหมายทับขวา (\) อักขระพิเศษที่ bc รู้จักคือ "a" (การแจ้งเตือนหรือกระดิ่ง), "b" (backspace), "f" (การป้อนแบบฟอร์ม), "n" (การขึ้นบรรทัดใหม่), "r" (การขึ้นบรรทัดใหม่ กลับ), "q" (อัญประกาศคู่), "t" (แท็บ) และ "\" (แบ็กสแลช) อักขระอื่นๆ ที่ตามหลังแบ็กสแลชจะถูกละเว้น

{ statement_list }

นี่คือคำสั่งผสม อนุญาตให้จัดกลุ่มคำสั่งหลายรายการเข้าด้วยกันเพื่อดำเนินการ

if ( expression ) statement1 [else statement2]

คำสั่ง if จะประเมินนิพจน์และดำเนินการคำสั่ง 1 หรือคำสั่ง 2 ขึ้นอยู่กับค่าของนิพจน์ ถ้านิพจน์ไม่เป็นศูนย์ คำสั่ง 1 จะถูกดำเนินการ ถ้า statement2 มีอยู่และค่าของ expression เป็น 0 ดังนั้น statement2 จะถูกดำเนินการ (ส่วนคำสั่งอื่นเป็นส่วนเสริม)

while ( expression ) statement

คำสั่ง while จะดำเนินการคำสั่งในขณะที่นิพจน์ไม่เป็นศูนย์ จะประเมินนิพจน์ก่อนดำเนินการคำสั่งแต่ละครั้ง การสิ้นสุดของลูปเกิดจากค่านิพจน์เป็นศูนย์หรือการดำเนินการของคำสั่งพัก

for ( [expression1] ; [expression2] ; [expression3] ) statement

สำหรับคำสั่งควบคุมการดำเนินการซ้ำของคำสั่ง Expression1 ได้รับการประเมินก่อนการวนซ้ำ Expression2 ได้รับการประเมินก่อนดำเนินการคำสั่งแต่ละครั้ง ถ้าไม่ใช่ศูนย์ ข้อความนั้นจะถูกประเมิน หากเป็นศูนย์ แสดงว่าการวนซ้ำสิ้นสุดลง หลังจากดำเนินการคำสั่งแต่ละครั้ง expression3 จะถูกประเมินก่อนที่จะประเมินค่า expression2 ใหม่ หากไม่มี expression1 หรือ expression3 ก็จะไม่มีการประเมิน ณ จุดที่พวกเขาจะถูกประเมิน หากไม่มีนิพจน์ 2 จะเหมือนกับการแทนค่า 1 สำหรับนิพจน์ 2 (นิพจน์ทางเลือกเป็นส่วนขยาย POSIX bc ต้องการทั้งสามนิพจน์) ต่อไปนี้คือโค้ดเทียบเท่าสำหรับคำสั่ง for:

expression1;
while (expression2) {
   statement;
   expression3;
}

break

คำสั่งนี้ทำให้เกิดการออกจากการปิดล้อมคำสั่ง while ล่าสุดหรือคำสั่ง for

continue

คำสั่งดำเนินการต่อ (ส่วนขยาย) ทำให้การปิดล้อมล่าสุดสำหรับคำสั่งเริ่มต้นการทำซ้ำครั้งต่อไป

halt

คำสั่งหยุด (ส่วนขยาย) เป็นคำสั่งดำเนินการที่ทำให้ตัวประมวลผล bc ปิดการทำงานเฉพาะเมื่อมีการดำเนินการเท่านั้น ตัวอย่างเช่น "ถ้า (0 == 1) หยุด" จะไม่ทำให้ bc ยุติลง เนื่องจากไม่ได้ดำเนินการหยุด

return

คืนค่า 0 จากฟังก์ชัน (ดูหัวข้อเกี่ยวกับฟังก์ชั่น)

return ( expression )

คืนค่านิพจน์จากฟังก์ชัน (ดูหัวข้อเกี่ยวกับฟังก์ชัน) ไม่จำเป็นต้องใส่วงเล็บ

งบปลอม

ข้อความเหล่านี้ไม่ใช่ข้อความตามความหมายดั้งเดิม พวกเขาไม่ได้ดำเนินการคำสั่ง ฟังก์ชั่นจะดำเนินการในเวลา "คอมไพล์"

limits

พิมพ์ขีดจำกัดในเครื่องที่บังคับใช้โดย bc เวอร์ชันในเครื่อง นี่คือส่วนขยาย

quit

เมื่ออ่านคำสั่ง exit ตัวประมวลผล bc จะถูกยกเลิก โดยไม่คำนึงว่าจะพบคำสั่ง exit อยู่ที่ใด ตัวอย่างเช่น "ถ้า (0 == 1) เลิก" จะทำให้ bc สิ้นสุด

warranty

พิมพ์ประกาศการรับประกันที่ยาวขึ้น นี่คือส่วนขยาย

ฟังก์ชั่น

ฟังก์ชันจัดเตรียมวิธีการกำหนดการคำนวณที่สามารถดำเนินการได้ในภายหลัง ฟังก์ชันใน bc จะคำนวณค่าและส่งกลับไปยังผู้เรียกเสมอ คำจำกัดความของฟังก์ชันเป็น "ไดนามิก" ในแง่ที่ว่าฟังก์ชันไม่ได้ถูกกำหนดจนกว่าจะพบคำจำกัดความในอินพุต คำจำกัดความนั้นจะถูกใช้จนกว่าจะพบฟังก์ชันคำจำกัดความอื่นสำหรับชื่อเดียวกัน คำจำกัดความใหม่จะแทนที่คำจำกัดความเก่า มีการกำหนดฟังก์ชันดังนี้:

define name ( parameters ) { newline
    auto_list   statement_list }

การเรียกใช้ฟังก์ชันเป็นเพียงการแสดงออกของรูปแบบ "ชื่อ(พารามิเตอร์)"

พารามิเตอร์คือตัวเลขหรืออาร์เรย์ (ส่วนขยาย) ในนิยามของฟังก์ชัน พารามิเตอร์ตั้งแต่ศูนย์ขึ้นไปถูกกำหนดโดยการแสดงชื่อโดยคั่นด้วยเครื่องหมายจุลภาค พารามิเตอร์ทั้งหมดถูกเรียกใช้โดยพารามิเตอร์ค่า อาร์เรย์ถูกระบุในการกำหนดพารามิเตอร์ด้วยสัญลักษณ์ "ชื่อ[]" ในการเรียกใช้ฟังก์ชัน พารามิเตอร์จริงคือนิพจน์แบบเต็มสำหรับพารามิเตอร์ตัวเลข สัญกรณ์เดียวกันนี้ใช้สำหรับการส่งผ่านอาร์เรย์เช่นเดียวกับการกำหนดพารามิเตอร์อาร์เรย์ อาร์เรย์ที่มีชื่อจะถูกส่งผ่านค่าไปยังฟังก์ชัน เนื่องจากนิยามของฟังก์ชันเป็นแบบไดนามิก หมายเลขพารามิเตอร์และประเภทจะถูกตรวจสอบเมื่อเรียกใช้ฟังก์ชัน จำนวนหรือประเภทของพารามิเตอร์ที่ไม่ตรงกันจะทำให้เกิดข้อผิดพลาดรันไทม์ ข้อผิดพลาดรันไทม์จะเกิดขึ้นสำหรับการเรียกไปยังฟังก์ชันที่ไม่ได้กำหนด

auto_list เป็นรายการทางเลือกของตัวแปรที่มีไว้สำหรับใช้ "ในเครื่อง" ไวยากรณ์ของรายการอัตโนมัติ (ถ้ามี) คือ "auto name, ... ;" (เครื่องหมายอัฒภาคเป็นตัวเลือก) แต่ละ ชื่อ คือชื่อของตัวแปรอัตโนมัติ อาจระบุอาร์เรย์โดยใช้สัญกรณ์เดียวกับที่ใช้ในพารามิเตอร์ ตัวแปรเหล่านี้มีค่าที่ส่งไปยังสแต็กเมื่อเริ่มต้นฟังก์ชัน จากนั้นตัวแปรจะเริ่มต้นเป็นศูนย์และใช้ตลอดการทำงานของฟังก์ชัน เมื่อออกจากฟังก์ชัน ตัวแปรเหล่านี้จะถูกป๊อปเพื่อให้ค่าดั้งเดิม (ในขณะที่เรียกใช้ฟังก์ชัน) ของตัวแปรเหล่านี้ถูกกู้คืน พารามิเตอร์เป็นตัวแปรอัตโนมัติจริงๆ ที่เริ่มต้นเป็นค่าที่ระบุในการเรียกใช้ฟังก์ชัน ตัวแปรอัตโนมัติแตกต่างจากตัวแปรโลคัลแบบดั้งเดิม เพราะหากฟังก์ชัน A เรียกใช้ฟังก์ชัน B แล้ว B อาจเข้าถึงตัวแปรอัตโนมัติของฟังก์ชัน A โดยใช้ชื่อเดียวกัน เว้นแต่ฟังก์ชัน B จะเรียกตัวแปรอัตโนมัติเหล่านั้น เนื่องจากตัวแปรอัตโนมัติและพารามิเตอร์ถูกพุชไปยังสแต็ก bc จึงสนับสนุนฟังก์ชันเรียกซ้ำ

เนื้อหาของฟังก์ชันเป็นรายการของคำสั่ง bc อีกครั้ง ข้อความจะถูกคั่นด้วยเครื่องหมายอัฒภาคหรือขึ้นบรรทัดใหม่ คำสั่งการส่งคืนทำให้เกิดการสิ้นสุดของฟังก์ชันและการส่งคืนค่า คำสั่ง return มีสองเวอร์ชัน รูปแบบแรก "return" จะส่งกลับค่า 0 ไปยังนิพจน์การโทร รูปแบบที่สอง "return ( expression )" คำนวณค่าของนิพจน์และส่งกลับค่านั้นไปยังนิพจน์การโทร มี "return (0)" โดยนัยที่ส่วนท้ายของทุกฟังก์ชัน สิ่งนี้ทำให้ฟังก์ชันสามารถยุติและส่งกลับ 0 โดยไม่มีคำสั่งส่งคืนที่ชัดเจน

ฟังก์ชันยังเปลี่ยนการใช้ตัวแปร ibase อีกด้วย ค่าคงที่ทั้งหมดในตัวฟังก์ชันจะถูกแปลงโดยใช้ค่าของ ibase ณ เวลาที่เรียกใช้ฟังก์ชัน การเปลี่ยนแปลงของ ibase จะถูกละเว้นระหว่างการทำงานของฟังก์ชัน ยกเว้นฟังก์ชันมาตรฐาน read ซึ่งจะใช้ค่าปัจจุบันของ ibase เสมอสำหรับ การแปลงตัวเลข

มีการเพิ่มส่วนขยายหลายรายการในฟังก์ชัน ประการแรก รูปแบบของคำนิยามได้รับการผ่อนปรนเล็กน้อย มาตรฐานกำหนดให้เครื่องหมายปีกกาเปิดอยู่ในบรรทัดเดียวกับคำหลัก กำหนด และส่วนอื่นๆ ทั้งหมดต้องอยู่ในบรรทัดต่อไปนี้ bc รุ่นนี้จะอนุญาตการขึ้นบรรทัดใหม่จำนวนเท่าใดก็ได้ก่อนและหลังเครื่องหมายปีกกาเปิดของฟังก์ชัน ตัวอย่างเช่น คำจำกัดความต่อไปนี้เป็นกฎหมาย

define d (n) { return (2*n); }
define d (n)
  { return (2*n); }

ฟังก์ชันอาจกำหนดเป็น โมฆะ void funtion ไม่ส่งคืนค่า ดังนั้นจึงไม่สามารถใช้ในที่ใดๆ ที่ต้องการค่าได้ ฟังก์ชัน void ไม่สร้างเอาต์พุตใด ๆ เมื่อเรียกใช้โดยตัวมันเองบนบรรทัดอินพุต คำสำคัญ void จะอยู่ระหว่างคำสำคัญ define และชื่อฟังก์ชัน ตัวอย่างเช่น พิจารณาเซสชันต่อไปนี้

define py (y) { print "--->", y, "<---", "\n"; }
define void px (x) { print "--->", x, "<---", "\n"; }
py(1)
--->1<---
0
px(1)
--->1<---

เนื่องจาก py ไม่ใช่ฟังก์ชัน void การเรียกใช้ py(1) จึงพิมพ์ผลลัพธ์ที่ต้องการ จากนั้นพิมพ์บรรทัดที่สองที่เป็นค่าของฟังก์ชัน เนื่องจากค่าของฟังก์ชันที่ไม่ได้รับคำสั่ง return ที่ชัดเจนคือศูนย์ เลขศูนย์จึงถูกพิมพ์ออกมา สำหรับ px(1) จะไม่มีการพิมพ์ศูนย์เนื่องจากฟังก์ชันเป็นฟังก์ชันโมฆะ

นอกจากนี้ยังเพิ่มการเรียกตามตัวแปรสำหรับอาร์เรย์ หากต้องการประกาศการเรียกโดยอาร์เรย์ตัวแปร การประกาศพารามิเตอร์อาร์เรย์ในนิยามฟังก์ชันจะมีลักษณะดังนี้ "*ชื่อ[]" การเรียกใช้ฟังก์ชันยังคงเหมือนกับการเรียกตามอาร์เรย์ค่า

ห้องสมุดคณิตศาสตร์

ถ้า bc ถูกเรียกใช้ด้วยตัวเลือก -l ไลบรารีคณิตศาสตร์จะถูกโหลดไว้ล่วงหน้าและกำหนดมาตราส่วนเริ่มต้นเป็น 20 ฟังก์ชันคณิตศาสตร์จะคำนวณผลลัพธ์เป็นมาตราส่วนที่ตั้งไว้ที่ เวลาที่โทร ไลบรารีคณิตศาสตร์กำหนดฟังก์ชันต่อไปนี้:

s (x)

ไซน์ของ x, x มีหน่วยเป็นเรเดียน

c (x)

โคไซน์ของ x, x มีหน่วยเป็นเรเดียน

a (x)

อาร์กแทนเจนต์ของ x อาร์กแทนเจนต์จะคืนค่าเรเดียน

l (x)

ลอการิทึมธรรมชาติของ x

e (x)

ฟังก์ชันเอกซ์โพเนนเชียลของการเพิ่มค่า e เป็นค่า x

j (n,x)

ฟังก์ชันเบสเซลของลำดับจำนวนเต็ม n ของ x

ตัวอย่าง

ใน /bin/sh ต่อไปนี้จะกำหนดค่าของ "pi" ให้กับตัวแปรเชลล์ pi

pi=$(echo "scale=10; 4*a(1)" | bc -l)

ต่อไปนี้คือนิยามของฟังก์ชันเอกซ์โปเนนเชียลที่ใช้ในไลบรารีคณิตศาสตร์ ฟังก์ชันนี้เขียนด้วย POSIX bc

scale = 20

/* Uses the fact that e^x = (e^(x/2))^2
   When x is small enough, we use the series:
     e^x = 1 + x + x^2/2! + x^3/3! + ...
*/

define e(x) {
  auto  a, d, e, f, i, m, v, z

  /* Check the sign of x. */
  if (x<0) {
    m = 1
    x = -x
  } 

  /* Precondition x. */
  z = scale;
  scale = 4 + z + .44*x;
  while (x > 1) {
    f += 1;
    x /= 2;
  }

  /* Initialize the variables. */
  v = 1+x
  a = x
  d = 1

  for (i=2; 1; i++) {
    e = (a *= x) / (d *= i)
    if (e == 0) {
      if (f>0) while (f--)  v = v*v;
      scale = z
      if (m) return (1/v);
      return (v/1);
    }
    v += e
  }
}

ต่อไปนี้คือโค้ดที่ใช้คุณลักษณะเพิ่มเติมของ bc เพื่อใช้โปรแกรมอย่างง่ายสำหรับการคำนวณยอดคงเหลือในสมุดเช็ค โปรแกรมนี้ถูกเก็บไว้ในไฟล์อย่างดีที่สุดเพื่อให้สามารถใช้งานได้หลายครั้งโดยไม่ต้องพิมพ์ซ้ำทุกครั้งที่ใช้งาน

scale=2
print "\nCheck book program!\n"
print "  Remember, deposits are negative transactions.\n"
print "  Exit by a 0 transaction.\n\n"

print "Initial balance? "; bal = read()
bal /= 1
print "\n"
while (1) {
  "current balance = "; bal
  "transaction? "; trans = read()
  if (trans == 0) break;
  bal -= trans
  bal /= 1
}
quit

ต่อไปนี้คือนิยามของฟังก์ชันแฟกทอเรียลแบบเรียกซ้ำ

define f (x) {
  if (x <= 1) return (1);
  return (f(x-1) * x);
}

อ่านบรรทัดและตัวเลือก LIBEDIT

สามารถคอมไพล์ GNU bc (ผ่านตัวเลือกการกำหนดค่า) เพื่อใช้ไลบรารีตัวแก้ไขอินพุต readline ของ GNU หรือไลบรารี libedit BSD ซึ่งช่วยให้ผู้ใช้สามารถแก้ไขบรรทัดก่อนที่จะส่งไปที่ bc นอกจากนี้ยังอนุญาตให้ใช้ประวัติของบรรทัดก่อนหน้าที่พิมพ์ เมื่อเลือกตัวเลือกนี้ bc จะมีตัวแปรพิเศษอีกหนึ่งตัว ตัวแปรพิเศษ ประวัติ คือจำนวนบรรทัดของประวัติที่เก็บไว้ สำหรับ readline ค่า -1 หมายความว่าจะเก็บบรรทัดประวัติได้ไม่จำกัดจำนวน การตั้งค่า ประวัติ เป็นจำนวนบวกจะจำกัดจำนวนบรรทัดประวัติไว้ตามจำนวนที่กำหนด ค่า 0 จะปิดใช้งานคุณสมบัติประวัติ ค่าเริ่มต้นคือ 100 สำหรับข้อมูลเพิ่มเติม โปรดอ่านคู่มือผู้ใช้สำหรับไลบรารี readline, history และ BSD libedit ไม่สามารถเปิดใช้งานทั้ง readline และ libedit พร้อมกันได้

ความแตกต่าง

bc เวอร์ชันนี้นำมาใช้จากแบบร่าง POSIX P1003.2/D11 และมีความแตกต่างและส่วนขยายหลายอย่างที่เกี่ยวข้องกับแบบร่างและการใช้งานแบบเดิม ไม่มีการนำไปใช้ในแบบดั้งเดิมโดยใช้ dc(1) รุ่นนี้เป็นกระบวนการเดียวที่แยกวิเคราะห์และเรียกใช้การแปลรหัสไบต์ของโปรแกรม มีตัวเลือก "ไม่มีเอกสาร" (-c) ที่ทำให้โปรแกรมส่งออกรหัสไบต์ไปยังเอาต์พุตมาตรฐานแทนที่จะเรียกใช้ ส่วนใหญ่จะใช้สำหรับการดีบักโปรแกรมแยกวิเคราะห์และเตรียมไลบรารีคณิตศาสตร์

แหล่งที่มาของความแตกต่างที่สำคัญคือส่วนขยาย ซึ่งฟีเจอร์ถูกขยายเพื่อเพิ่มฟังก์ชันการทำงานและส่วนเพิ่มเติม โดยเพิ่มฟีเจอร์ใหม่เข้าไป ต่อไปนี้คือรายการความแตกต่างและส่วนขยาย

LANG environment

เวอร์ชันนี้ไม่เป็นไปตามมาตรฐาน POSIX ในการประมวลผลตัวแปรสภาพแวดล้อม LANG และตัวแปรสภาพแวดล้อมทั้งหมดที่ขึ้นต้นด้วย LC_

names

ตัวดั้งเดิมและ POSIX bc มีชื่อตัวอักษรเดี่ยวสำหรับฟังก์ชัน ตัวแปร และอาร์เรย์ พวกเขาได้รับการขยายให้เป็นชื่อหลายอักขระที่ขึ้นต้นด้วยตัวอักษรและอาจมีตัวอักษร ตัวเลข และเครื่องหมายขีดล่าง

Strings

ไม่อนุญาตให้ใช้สตริงที่มีอักขระ NUL POSIX กล่าวว่าอักขระทั้งหมดต้องรวมอยู่ในสตริง

last

POSIX bc ไม่มีตัวแปร last การใช้งาน bc บางอย่างใช้เครื่องหมายมหัพภาค (.) ในทำนองเดียวกัน

comparisons

POSIX bc อนุญาตให้เปรียบเทียบเฉพาะในคำสั่ง if คำสั่ง while และนิพจน์ที่สองของคำสั่ง for นอกจากนี้ อนุญาตให้มีการดำเนินการเชิงสัมพันธ์เดียวเท่านั้นในแต่ละคำสั่งเหล่านั้น

if statement, else clause

POSIX bc ไม่มีส่วนคำสั่งอื่น

for statement

POSIX bc ต้องการให้นิพจน์ทั้งหมดอยู่ในคำสั่ง for

&&, ||, !

POSIX bc ไม่มีตัวดำเนินการเชิงตรรกะ

read function

POSIX bc ไม่มีฟังก์ชันการอ่าน

print statement

POSIX bc ไม่มีคำสั่งพิมพ์

continue statement

POSIX bc ไม่มีคำสั่งดำเนินการต่อ

return statement

POSIX bc ต้องใส่วงเล็บรอบนิพจน์ return

array parameters

POSIX bc ไม่ (ปัจจุบัน) รองรับพารามิเตอร์อาร์เรย์แบบเต็ม ไวยากรณ์ POSIX อนุญาตให้ใช้อาร์เรย์ในนิยามฟังก์ชัน แต่ไม่มีวิธีการระบุอาร์เรย์เป็นพารามิเตอร์จริง (ซึ่งเป็นไปได้มากว่าเป็นการมองข้ามไวยากรณ์) การใช้งานแบบดั้งเดิมของ bc จะมีการเรียกตามพารามิเตอร์อาร์เรย์ค่าเท่านั้น

function format

POSIX bc ต้องใช้เครื่องหมายปีกกาเปิดในบรรทัดเดียวกับคำสำคัญ define และคำสั่ง auto ในบรรทัดถัดไป

=+, =-, =*, =/, =%, =^

POSIX bc ไม่ต้องการตัวดำเนินการการกำหนด "แบบเก่า" เหล่านี้ เวอร์ชันนี้อาจอนุญาตการมอบหมายแบบ "แบบเก่า" เหล่านี้ ใช้คำสั่งจำกัดเพื่อดูว่าเวอร์ชันที่ติดตั้งรองรับหรือไม่ หากรองรับตัวดำเนินการกำหนด "แบบเก่า" คำสั่ง "a =- 1" จะลดลง a ทีละ 1 แทนที่จะตั้งค่า a เป็นค่า -1

spaces in numbers

การใช้งาน bc อื่นๆ อนุญาตให้มีการเว้นวรรคเป็นตัวเลข ตัวอย่างเช่น "x=1 3" จะกำหนดค่า 13 ให้กับตัวแปร x คำสั่งเดียวกันจะทำให้เกิดข้อผิดพลาดทางไวยากรณ์ใน bc เวอร์ชันนี้

errors and execution

การใช้งานนี้แตกต่างจากการใช้งานอื่นๆ ในแง่ของรหัสที่จะถูกดำเนินการเมื่อพบข้อผิดพลาดทางไวยากรณ์และอื่นๆ ในโปรแกรม หากพบข้อผิดพลาดทางไวยากรณ์ในข้อกำหนดของฟังก์ชัน การกู้คืนข้อผิดพลาดจะพยายามค้นหาจุดเริ่มต้นของคำสั่งและแยกวิเคราะห์ฟังก์ชันต่อไป เมื่อพบข้อผิดพลาดทางไวยากรณ์ในฟังก์ชัน ฟังก์ชันนั้นจะไม่สามารถเรียกใช้ได้และไม่ได้กำหนด ข้อผิดพลาดทางไวยากรณ์ในรหัสการดำเนินการแบบโต้ตอบจะทำให้บล็อกการดำเนินการปัจจุบันใช้ไม่ได้ บล็อกการดำเนินการจะสิ้นสุดโดยจุดสิ้นสุดของบรรทัดที่ปรากฏหลังจากคำสั่งที่สมบูรณ์ ตัวอย่างเช่น,

a = 1
b = 2

มีสองบล็อกการดำเนินการและ

{ a = 1
  b = 2 }

มีหนึ่งบล็อกการดำเนินการ ข้อผิดพลาดรันไทม์จะยุติการดำเนินการของบล็อกการดำเนินการปัจจุบัน คำเตือนรันไทม์จะไม่ยุติบล็อกการดำเนินการปัจจุบัน

Interrupts

ระหว่างเซสชันแบบโต้ตอบ สัญญาณ SIGINT (โดยปกติจะสร้างโดยอักขระ control-C จากเทอร์มินัล) จะทำให้การดำเนินการของบล็อกการดำเนินการปัจจุบันถูกขัดจังหวะ จะแสดงข้อผิดพลาด "รันไทม์" เพื่อระบุว่าฟังก์ชันใดถูกขัดจังหวะ หลังจากล้างโครงสร้างรันไทม์ทั้งหมดแล้ว จะมีการพิมพ์ข้อความเพื่อแจ้งให้ผู้ใช้ทราบว่า bc พร้อมสำหรับการป้อนข้อมูลเพิ่มเติม ฟังก์ชันที่กำหนดไว้ก่อนหน้านี้ทั้งหมดยังคงกำหนดไว้ และค่าของตัวแปรที่ไม่ใช่อัตโนมัติทั้งหมดคือค่า ณ จุดที่มีการขัดจังหวะ ตัวแปรอัตโนมัติและพารามิเตอร์ของฟังก์ชันทั้งหมดจะถูกลบออกในระหว่างกระบวนการล้างข้อมูล ระหว่างเซสชันที่ไม่มีการโต้ตอบ สัญญาณ SIGINT จะยุติการทำงานทั้งหมดของ bc

ขีดจำกัด

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

BC_BASE_MAX

ขณะนี้ฐานเอาต์พุตสูงสุดตั้งไว้ที่ 999 ฐานอินพุตสูงสุดคือ 16

BC_DIM_MAX

ขณะนี้เป็นขีดจำกัดโดยพลการที่ 65535 ตามที่เผยแพร่ การติดตั้งของคุณอาจแตกต่างออกไป

BC_SCALE_MAX

จำนวนหลักหลังจุดทศนิยมจำกัดไว้ที่ INT_MAX หลัก นอกจากนี้ จำนวนหลักก่อนจุดทศนิยมจะจำกัดไว้ที่ INT_MAX หลัก

BC_STRING_MAX

ขีดจำกัดของจำนวนอักขระในสตริงคือ INT_MAX อักขระ

exponent

ค่าของเลขยกกำลังในการดำเนินการเพิ่ม (^) ถูกจำกัดไว้ที่ LONG_MAX

variable names

ขีดจำกัดปัจจุบันของจำนวนชื่อเฉพาะคือ 32767 สำหรับตัวแปร อาร์เรย์ และฟังก์ชันอย่างง่ายแต่ละตัว

ตัวแปรสภาพแวดล้อม

ตัวแปรสภาพแวดล้อมต่อไปนี้ประมวลผลโดย bc:

POSIXLY_CORRECT

ซึ่งเหมือนกับตัวเลือก -s

BC_ENV_ARGS

นี่เป็นอีกกลไกในการรับข้อโต้แย้งไปยัง bc รูปแบบเหมือนกับอาร์กิวเมนต์บรรทัดคำสั่ง อาร์กิวเมนต์เหล่านี้จะได้รับการประมวลผลก่อน ดังนั้นไฟล์ใดๆ ที่แสดงอยู่ในอาร์กิวเมนต์สภาพแวดล้อมจะได้รับการประมวลผลก่อนไฟล์อาร์กิวเมนต์บรรทัดคำสั่งใดๆ ซึ่งช่วยให้ผู้ใช้สามารถตั้งค่าตัวเลือก "มาตรฐาน" และไฟล์ที่จะประมวลผลทุกครั้งที่เรียกใช้ bc ไฟล์ในตัวแปรสภาพแวดล้อมโดยทั่วไปจะมีคำจำกัดความของฟังก์ชันสำหรับฟังก์ชันที่ผู้ใช้ต้องการกำหนดไว้ทุกครั้งที่เรียกใช้ bc

BC_LINE_LENGTH

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

การวินิจฉัย

หากไม่สามารถเปิดไฟล์ใดๆ ในบรรทัดคำสั่งได้ bc จะแจ้งว่าไฟล์นั้นไม่พร้อมใช้งานและยุติการทำงาน นอกจากนี้ยังมีการวินิจฉัยคอมไพล์และรันไทม์ที่ควรอธิบายด้วยตนเอง

ข้อบกพร่อง

การกู้คืนข้อผิดพลาดยังไม่ดีนัก

ส่งอีเมลรายงานข้อบกพร่องไปที่ bug-bc@gnu.org อย่าลืมใส่คำว่า ``bc'' ที่ใดที่หนึ่งในฟิลด์ ``Subject:''

ผู้เขียน

Philip A. Nelson
philnelson@acm.org

กิตติกรรมประกาศ

ผู้เขียนขอขอบคุณ Steve Sommars (Steve.Sommars@att.com) สำหรับความช่วยเหลืออย่างกว้างขวางในการทดสอบการใช้งาน ได้รับข้อเสนอแนะที่ดีมากมาย นี่เป็นผลิตภัณฑ์ที่ดีกว่ามากเนื่องจากการมีส่วนร่วมของเขา