funcalc - ออนไลน์ในคลาวด์

โครงการ:

ชื่อ

funcalc - เครื่องคิดเลข Funtools (สำหรับตารางไบนารี)

เรื่องย่อ

ฟังแคล [-n] [-a argstr] [-e expr] [-f file] [-l ลิงค์] [-p prog] [โอนาเมะ [คอลัมน์]]

OPTIONS

-a argstr # อาร์กิวเมนต์ผู้ใช้เพื่อส่งผ่านไปยังโปรแกรมที่คอมไพล์
-e expr # นิพจน์ funcalc
-f ไฟล์ # ไฟล์ที่มีนิพจน์ funcalc
-l libs # libs เพื่อเพิ่มคำสั่งลิงก์
-n # เอาต์พุตสร้างรหัสแทนการรวบรวมและดำเนินการ
-p prog # สร้างโปรแกรมที่มีชื่อไม่มีการเรียกใช้
-u # die หากไม่มีการประกาศตัวแปรใดๆ (ไม่ประกาศอัตโนมัติ)

DESCRIPTION

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

ฟังแคล นิพจน์สามารถระบุได้สามวิธี: บนบรรทัดคำสั่งโดยใช้ -e
[การแสดงออก] สลับในไฟล์โดยใช้ -f [ไฟล์] เปลี่ยนหรือจาก stdin (ถ้าไม่ใช่ -e
ไม่ -f ระบุไว้) แน่นอนไฟล์ที่มี ฟังแคล นิพจน์สามารถอ่านได้จาก
มาตรฐาน

คำขอแต่ละครั้งของ ฟังแคล ต้องการอินพุตไฟล์ตาราง Funtools เพื่อระบุเป็น
อาร์กิวเมนต์บรรทัดคำสั่งแรก ไฟล์ตาราง Funtools เอาต์พุตเป็นตัวเลือกที่สอง
การโต้แย้ง. จำเป็นเฉพาะเมื่อมีการสร้างไฟล์เอาต์พุต FITS (เช่น ในกรณีที่
ฟังแคล expression พิมพ์เฉพาะค่า ไม่จำเป็นต้องมีไฟล์เอาต์พุต) ถ้าอินพุตและเอาต์พุต
ระบุไฟล์ทั้งคู่ อาร์กิวเมนต์ทางเลือกที่สามสามารถระบุรายการของคอลัมน์ไปยัง
เปิดใช้งาน (โดยใช้ FunColumnActivate()). สังเกตว่า ฟังแคล กำหนดหรือไม่ที่จะ
สร้างรหัสสำหรับเขียนไฟล์เอาท์พุตตามการมีอยู่หรือไม่มีของเอาต์พุต
อาร์กิวเมนต์ไฟล์

A ฟังแคล นิพจน์ดำเนินการในแต่ละแถวของตารางและประกอบด้วย C . หนึ่งรายการขึ้นไป
คำสั่งที่ทำงานในคอลัมน์ของแถวนั้น (อาจใช้ตัวแปรชั่วคราว)
ภายในนิพจน์ การอ้างอิงถึงคอลัมน์ของ ปัจจุบัน แถวโดยใช้โครงสร้าง C
วากยสัมพันธ์ เคิร์-[colname]> เช่น cur->x, cur->pha เป็นต้น สามารถกำหนดตัวแปรสเกลาร์ในพื้นที่ได้
ใช้การประกาศ C ที่จุดเริ่มต้นของนิพจน์ มิฉะนั้น พวกเขาสามารถกำหนดได้
โดยอัตโนมัติโดย ฟังแคล (เป็นแบบคู่) ตัวอย่างเช่น การสลับคอลัมน์ x
และ y ในตารางสามารถทำได้โดยใช้ค่าเทียบเท่าต่อไปนี้ ฟังแคล
นิพจน์:

อุณหภูมิสองเท่า;
อุณหภูมิ = cur->x;
cur->x = cur->y;
cur->y = อุณหภูมิ;

หรือ:

อุณหภูมิ = cur->x;
cur->x = cur->y;
cur->y = อุณหภูมิ;

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

funcalc -f swap.expr itest.ev otest.ev

ไฟล์ผลลัพธ์จะมีค่าของคอลัมน์ x และ y ที่สลับกัน

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

อุณหภูมิ = cur->x:D;
cur->x = cur->y:D;
cur->y = อุณหภูมิ;

ตัวระบุชนิดข้อมูลเป็นไปตามไวยากรณ์ตาราง FITS มาตรฐานสำหรับการกำหนดคอลัมน์โดยใช้ TFORM:

· A: อักขระ ASCII

· B: ถ่าน 8 บิตที่ไม่ได้ลงชื่อ

· I: ลงนาม int 16 บิต

· U: int 16 บิตที่ไม่ได้ลงนาม (ไม่ใช่ FITS มาตรฐาน)

· J: ลงนาม int แบบ 32 บิต

· V: int 32 บิตที่ไม่ได้ลงชื่อ (ไม่ใช่ FITS มาตรฐาน)

· E: ทุ่นลอย 32 บิต

· D: ทุ่น 64 บิต

· X: บิต (ถือว่าเป็นอาร์เรย์ของตัวอักษร)

โปรดทราบว่าเฉพาะการอ้างอิงคอลัมน์แรกเท่านั้นที่ควรมีประเภทข้อมูลที่ชัดเจน
ตัวระบุ

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

dx = (cur->x - cur->y)/(cur->x + cur->y);

โดยปกติจะต้องดำเนินการโดยใช้เลขทศนิยม ในกรณีที่ x และ y
คอลัมน์เป็นจำนวนเต็ม ซึ่งสามารถทำได้โดยการอ่านคอลัมน์เป็นสองเท่าโดยใช้ข้อความที่ชัดเจน
ข้อกำหนดประเภท:

dx = (cur->x:D - cur->y:D)/(cur->x + cur->y);

หรือสามารถทำได้โดยใช้การหล่อแบบ C ในนิพจน์:

dx = ((ดับเบิ้ล)cur->x - (ดับเบิ้ล)cur->y)/((ดับเบิ้ล)cur->x + (ดับเบิ้ล)cur->y);

นอกจากการเข้าถึงคอลัมน์ในแถวปัจจุบันแล้ว ยังสามารถอ้างอิงถึง
ก่อน แถวที่ใช้ ก่อนหน้า-[colname]> และถึง ถัดไป แถวที่ใช้ ต่อไป-[ชื่อคอล]>. สังเกตว่า
if ก่อนหน้า-[colname]> ถูกระบุใน ฟังแคล นิพจน์ แถวแรกสุดไม่ใช่
ประมวลผล ถ้า ต่อไป-[colname]> ถูกระบุใน ฟังแคล นิพจน์แถวสุดท้าย
ไม่ได้รับการประมวลผล ทางนี้, prev และ ถัดไป รับประกันว่าจะชี้ไปที่แถวที่ถูกต้องเสมอ
ตัวอย่างเช่น ในการพิมพ์ค่าของคอลัมน์ x ปัจจุบันและคอลัมน์ y ก่อนหน้า
ใช้ฟังก์ชัน C fprintf ใน a ฟังแคล การแสดงออก:

fprintf(stdout, "%d %d\n", cur->x, ก่อนหน้า->y);

คอลัมน์ใหม่สามารถระบุได้โดยใช้ตัวเดียวกัน เคิร์-[colname]> ไวยากรณ์โดยต่อท้ายคอลัมน์
type (และตัวระบุ tlmin/tlmax/binsiz ทางเลือก) คั่นด้วยเครื่องหมายทวิภาค ตัวอย่างเช่น,
cur->avg:D จะกำหนดคอลัมน์ใหม่ของประเภท double ตัวระบุประเภทเหมือนกันเหล่านั้น
ใช้ด้านบนเพื่อระบุประเภทข้อมูลใหม่สำหรับคอลัมน์ที่มีอยู่

ตัวอย่างเช่น เพื่อสร้างและแสดงผลคอลัมน์ใหม่ที่เป็นค่าเฉลี่ยของ x และ y
คอลัมน์ คอลัมน์ "เฉลี่ย" ใหม่สามารถกำหนดได้:

cur->avg:D = (cur->x + cur->y)/2.0

โปรดทราบว่าสุดท้าย ';' ไม่จำเป็นสำหรับนิพจน์บรรทัดเดียว

เช่นเดียวกับข้อกำหนดประเภทข้อมูล FITS TFORM ตัวระบุประเภทข้อมูลคอลัมน์สามารถอยู่ข้างหน้าได้
โดยการนับตัวเลขเพื่อกำหนดอาร์เรย์ เช่น "10I" หมายถึงเวกเตอร์ 10 int สั้น "2E"
หมายถึงการลอยตัวที่แม่นยำสองอัน ฯลฯ คอลัมน์ใหม่จำเป็นต้องกำหนดเพียงครั้งเดียวในa
ฟังแคล นิพจน์ หลังจากนั้นก็สามารถใช้ได้โดยไม่ต้องระบุประเภทซ้ำ นี้
รวมการอ้างอิงถึงองค์ประกอบของอาร์เรย์คอลัมน์:

cur->avg[0]:2D = (cur->x + cur->y)/2.0;
cur->avg[1] = (cur->x - cur->y)/2.0;

ชนิดข้อมูล 'X' (บิต) ถือเป็นอาร์เรย์ของมิติข้อมูล (numeric_count/8) เช่น
16X ถูกประมวลผลเป็นอาร์เรย์ถ่านขนาด 2 ไบต์ องค์ประกอบอาร์เรย์ 8 บิตแต่ละรายการมีการเข้าถึงแยกกัน:

cur->stat[0]:16X = 1;
cur->stat[1] = 2;

ที่นี่สร้างคอลัมน์ 16 บิตโดยตั้งค่า MSB เป็น 1 และตั้งค่า LSB เป็น 2

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

cur->avg[0]:2D = (cur->x + cur->y)/2.0;
cur->avg[1] = (cur->x - cur->y)/2.0;
if(cur->avg[0] == cur->x )
ดำเนินการต่อ;

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

fpv = (cur->av3:D-cur->av1:D)/(cur->av1+cur->av2:D+cur->av3);
fbv = cur->av2/(cur->av1+cur->av2+cur->av3);
fpu = ((double)cur->au3-cur->au1)/((double)cur->au1+cur->au2+cur->au3);
fbu = cur->au2/(สองเท่า)(cur->au1+cur->au2+cur->au3);
fprintf(stdout, "%f\t%f\t%f\t%f\n", fpv, fbv, fpu, fbu);

ในตัวอย่างข้างต้น เราใช้ทั้งข้อมูลจำเพาะประเภทที่ชัดเจน (สำหรับคอลัมน์ "av") และ type
การแคสต์ (สำหรับคอลัมน์ "au") เพื่อให้แน่ใจว่าการดำเนินการทั้งหมดจะดำเนินการใน double
ความแม่นยำ

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

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

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

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

[ชื่อคำสั่ง]
... รหัสไปที่นี่ ...
ปลาย

คำสั่งคือ:

· ทั่วโลก เพิ่มรหัสและการประกาศในพื้นที่ส่วนกลาง ก่อนรูทีนหลัก

· ในประเทศ เพิ่มการประกาศ (และรหัส) หลังการประกาศในเครื่อง main

· ก่อน เพิ่มรหัสก่อนเข้าสู่ลูปการประมวลผลแถวหลัก

· หลังจาก เพิ่มรหัสหลังจากออกจากลูปการประมวลผลแถวหลัก

ดังนั้น ต่อไปนี้ ฟังแคล นิพจน์จะประกาศตัวแปรโกลบอลและสร้างรูทีนย่อย
โทรก่อนและหลังลูปการประมวลผลหลัก:

ทั่วโลก
คู่ v1, v2;
init สองครั้ง (เป็นโมฆะ);
เสร็จสิ้นสองครั้ง(วีสองครั้ง);
ปลาย
ก่อน
v1 = เริ่มต้น ();
ปลาย
... ประมวลผลแถวด้วยการคำนวณโดยใช้ v1 ...
หลังจาก
v2 = เสร็จสิ้น (v1);
ถ้า (v2 < 0.0){
fprintf(stderr, "การประมวลผลล้มเหลว %g -> %g\n", v1, v2);
ทางออก(1);
}
ปลาย

กิจวัตรเช่น ในนั้น() และ เสร็จสิ้น() ด้านบนจะถูกส่งไปยังโปรแกรมที่สร้างขึ้นสำหรับการเชื่อมโยง
โดยใช้โปรแกรม -l [ลิงค์ สั่ง ... ] สวิตซ์. สตริงที่ระบุโดยสวิตช์นี้จะเป็น
เพิ่มไปยังลิงค์ไลน์ที่ใช้สร้างโปรแกรม (ก่อนถึงไลบรารี funtools) สำหรับ
ตัวอย่าง สมมติว่า ในนั้น() และ เสร็จสิ้น() อยู่ในห้องสมุด libmysubs.a ใน
/opt/special/lib ไดเร็กทอรี ใช้:

funcalc -l "-L/opt/special/lib -lmysubs" ...

อาร์กิวเมนต์ของผู้ใช้สามารถส่งผ่านไปยังโปรแกรม funcalc ที่คอมไพล์แล้วโดยใช้อาร์กิวเมนต์สตริงไปที่
สวิตช์ "-a" สตริงควรมีอาร์กิวเมนต์ของผู้ใช้ทั้งหมด เช่น ผ่าน
จำนวนเต็ม 1 และ 2 ใช้:

funcalc -a "1 2" ...

อาร์กิวเมนต์ถูกเก็บไว้ในอาร์เรย์ภายในและเข้าถึงได้เป็นสตริงผ่าน ARGV(n)
มาโคร ตัวอย่างเช่น พิจารณานิพจน์ต่อไปนี้:

ในประเทศ
int pmin, พีแม็กซ์;
ปลาย

ก่อน
พีมิน=อาตอย(อาร์จีวี(0));
pmax=อาต๋อย(อาร์จีวี(1));
ปลาย

if( (cur->pha >= pmin) && (cur->pha <= pmax) )
fprintf(stderr, "%d %d %d\n", cur->x, cur->y, cur->pha);

นิพจน์นี้จะพิมพ์ค่า x, y และ pha สำหรับทุกแถวที่มีค่า pha เป็น
ระหว่างสองค่าที่ผู้ใช้ป้อน:

funcalc -a '1 12' -f foo snr.ev'[cir 512 512 .1]'
512 512 6
512 512 8
512 512 5
512 512 5
512 512 8

funcalc -a '5 6' -f foo snr.ev'[cir 512 512 .1]'
512 512 6
512 512 5
512 512 5

โปรดทราบว่าเป็นความรับผิดชอบของผู้ใช้เพื่อให้แน่ใจว่าจำนวนอาร์กิวเมนต์ที่ถูกต้อง
จะผ่านไป มาโคร ARGV(n) คืนค่า NULL ถ้าอาร์กิวเมนต์ที่ร้องขออยู่นอกขีดจำกัด
ของจำนวนอาร์กิวเมนต์จริง ซึ่งมักจะส่งผลให้ SEGV หากประมวลผลแบบสุ่มสี่สุ่มห้า เพื่อตรวจสอบ
จำนวนอาร์กิวเมนต์ ใช้มาโคร ARGC:

ในประเทศ
เมล็ดยาว int=1;
ขีด จำกัด สองเท่า=0.8;
ปลาย

ก่อน
if( ARGC >= 1 ) เมล็ด = atol(อาร์จีวี(0));
ถ้า ( ARGC >= 2 ) จำกัด = atof(อาร์จีวี(1));
srand48(เมล็ด);
ปลาย

ถ้า ( drand48() > จำกัด ) ดำเนินการต่อ;

แมโคร WRITE_ROW ขยายเป็น FunTableRowPut() การเรียกที่เขียนแถวปัจจุบัน มัน
สามารถใช้เขียนแถวได้มากกว่าหนึ่งครั้ง นอกจากนี้ มาโคร NROW ยังขยายเป็น
กำลังประมวลผลหมายเลขแถว การใช้มาโครทั้งสองนี้จะแสดงดังต่อไปนี้
ตัวอย่าง:

if(cur->pha:I == cur->pi:I ) ดำเนินการต่อ;
a = cur->pha;
cur->pha = cur->pi;
cur->pi = a;
cur->AVG:E = (cur->pha+cur->pi)/2.0;
cur->NR:ฉัน = NROW;
ถ้า ( NROW < 10 ) WRITE_ROW;

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

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

ดังกล่าวก่อนหน้า ฟังแคล จะประกาศตัวแปรสเกลาร์โดยอัตโนมัติ (เป็น a
double) หากมีการใช้ตัวแปรนั้นแต่ไม่ได้ประกาศ สิ่งอำนวยความสะดวกนี้ถูกนำไปใช้
ใช้สคริปต์ sed ชื่อ funcalc.sed ซึ่งประมวลผลเอาต์พุตของคอมไพเลอร์เพื่อรับรู้ an
ข้อผิดพลาดของตัวแปรที่ไม่ได้ประกาศ สคริปต์นี้ได้รับข้อผิดพลาดที่เหมาะสม
ข้อมูลสำหรับ gcc และสำหรับ cc บนแพลตฟอร์ม Solaris, DecAlpha และ SGI หากคุณพบว่า
การประกาศสเกลาร์อัตโนมัติไม่ทำงานบนแพลตฟอร์มของคุณ โปรดตรวจสอบสคริปต์ sed นี้
อาจจำเป็นต้องเพิ่มหรือแก้ไขข้อความแสดงข้อผิดพลาดบางอย่างที่รู้สึกได้

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

/* ความคิดเห็นนี้จะจบลงผิดที่ (เช่น วงใน) */
ดับเบิ้ลเอ; /* ผิดที่เหมือนกันครับ */
/* นี่จะอยู่ในตำแหน่งที่ถูกต้อง (วงใน) */
if(cur->x:D == cur->y:D ) ดำเนินการต่อ; /* อยู่ในตำแหน่งที่ถูกต้องเช่นกัน */
a = cur->x;
cur->x = cur->y;
cur->y = a;
cur->avg:E = (cur->x+cur->y)/2.0;

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

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

พร้อมกับความคิดเห็นของ C ฟังแคล นิพจน์สามารถมีความคิดเห็นภายในบรรทัดเดียวที่
ไม่ส่งต่อไปยังโปรแกรม C ที่สร้างขึ้น ความคิดเห็นภายในเหล่านี้เริ่มต้นด้วย #
ตัวอักษรและไปขึ้นบรรทัดใหม่:

ดับเบิ้ลเอ; # สิ่งนี้ไม่ผ่านไปยังไฟล์ C ที่สร้างขึ้น
#ก็ไม่ใช่
a = cur->x;
cur->x = cur->y;
cur->y = a;
/* ความคิดเห็นนี้ถูกส่งไปยังไฟล์ C */
cur->avg:E = (cur->x+cur->y)/2.0;

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

ชัดเจน pi pha

จะทำให้แน่ใจว่าคอลัมน์ pi และ pha ถูกอ่านสำหรับแต่ละแถว แม้ว่าจะไม่ได้อ่านก็ตาม
ประมวลผลในวงเหตุการณ์ภายใน NS ชัดเจน สามารถวางคำสั่งได้ทุกที่

สุดท้ายโปรดทราบว่า ฟังแคล ปัจจุบันทำงานกับนิพจน์ที่เกี่ยวข้องกับตารางไบนารี FITS และ
ไฟล์เหตุการณ์ดิบ เราจะพิจารณาเพิ่มการรองรับการแสดงภาพในภายหลัง
หากมีความต้องการการสนับสนุนจากชุมชน

ใช้ funcalc ออนไลน์โดยใช้บริการ onworks.net