ไวยากรณ์ของ X# นั้นตรงไปตรงมาแต่เข้มงวดกว่าเมื่อเทียบกับภาษาC

X# รองรับเฉพาะคอมเมนต์บรรทัดเดียวในรูปแบบ C++ โดยเริ่มต้นด้วย - //.

X# อนุญาตให้กำหนดค่าคงที่ที่มีชื่อซึ่งประกาศไว้นอกฟังก์ชัน ค่าคงที่ตัวเลขถูกกำหนดในลักษณะเดียวกับC++ตัวอย่างเช่น:

const i = 0

การอ้างอิงถึงสิ่งเหล่านี้ในที่อื่นต้องมีเครื่องหมาย * #นำหน้าชื่อ เช่น - "#i".

• ค่าคงที่ สตริงใช้เครื่องหมายอัญประกาศเดี่ยว ( '') หากต้องการใส่เครื่องหมายอัญประกาศเดี่ยวในค่าคงที่สตริง ให้ใช้เครื่องหมายแบ็กสแลช (เช่น'I\'m so happy') สตริง X# จะสิ้นสุดด้วยค่าว่าง
• ค่าคงที่เลขฐานสิบหกจะมีเครื่องหมายดอลลาร์ ( $) นำหน้า ตามด้วยค่าคงที่ ( $B8000)
• ค่าคงที่ทศนิยมไม่มีคำนำหน้า แต่ไม่สามารถขึ้นต้นด้วย0. ได้
• ค่าคงที่แบบไบนารีและฐานแปดยังไม่รองรับในขณะนี้

ป้ายกำกับใน X# ทำงานคล้ายกับป้ายกำกับในภาษาแอสเซมบลีอื่นๆ โดยgotoใช้ตัวย่อ (mnemonic) เพื่อกระโดดไปยังป้ายกำกับ แทนที่จะใช้ตัวย่อjumpแบบ ทั่วไปjmp

CodeLabel1 : goto CodeLabel2 :

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

namespace FIRST // ชื่อตัวแปรหรือค่าคงที่ทุกอย่างจะขึ้นต้นด้วย FIRST และเครื่องหมายขีดล่าง ดังนั้นชื่อเต็มที่แท้จริงของตัวแปรด้านล่าง// คือ FIRST_aVar var aVarnamespace SECOND // การตั้งชื่อตัวแปรอีกตัวว่า aVar ไม่ใช่ปัญหา ชื่อจริงของมันคือ SECOND_aVar var aVarnamespace FIRST // โค้ดส่วนนี้จะกลับไปอยู่ใน namespace FIRST จนกว่าไฟล์จะสิ้นสุด

โค้ดส่วนการทำงานทั้งหมดของ X# ควรอยู่ในฟังก์ชันที่กำหนดโดยคีย์เวิร์ด 'function' ต่างจากภาษา C X# ไม่รองรับการประกาศพารามิเตอร์อย่างเป็นทางการในส่วนหัวของฟังก์ชัน ดังนั้นจึงละเว้นวงเล็บหลังชื่อฟังก์ชันตามธรรมเนียม เนื่องจากรูปแบบคงที่ของบรรทัดถูกกำหนดไว้ในไวยากรณ์ที่ใช้ในตัวแยกวิเคราะห์โค้ด วงเล็บปีกกาเปิดจึงไม่สามารถอยู่บนบรรทัดถัดไปได้ ต่างจากภาษาอื่นๆ ที่มีรูปแบบคล้าย C

ฟังก์ชันxSharpFunction { // โค้ดของฟังก์ชัน}

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

ฟังก์ชันxSharpFunction { EAX = $10 anotherFunction ( EAX ); return }ฟังก์ชันanotherFunction { //โค้ดของฟังก์ชัน}

คีย์เวิร์ด นี้returnจะส่งการทำงานกลับไปยังที่อยู่ EIP สำหรับส่งคืนที่บันทึกไว้ในสแต็ก

ภาษา X# สามารถทำงานกับโครงสร้างข้อมูลระดับต่ำสามแบบ ได้แก่รีจิสเตอร์สแต็กและหน่วยความจำบนพอร์ตที่แตกต่างกัน รีจิสเตอร์เป็นพื้นฐานของการดำเนินการปกติทั้งหมดในภาษา X# สามารถคัดลอกรีจิสเตอร์ไปยังอีกรีจิสเตอร์หนึ่งได้โดยการเขียนDST = SRCแทนที่จะใช้movคำสั่งโหลด/จัดเก็บ รีจิสเตอร์สามารถเพิ่มหรือลดค่าได้ง่ายเช่นกัน การดำเนินการทางคณิตศาสตร์ (บวก ลบ คูณ หาร) เขียนได้เป็น โดยdest op srcที่srcเป็นค่าคงที่ ตัวแปร หรือรีจิสเตอร์ และdestเป็นทั้งตัวถูกดำเนินการและตำแหน่งที่เก็บผลลัพธ์

ตัวอย่างของการกำหนดค่าและการดำเนินการทางคณิตศาสตร์แสดงไว้ด้านล่าง

ESI = 12345 // กำหนดค่า 12345 ให้กับ ESI EDX = #constantForEDX // กำหนดค่า #ConstantForEDX ให้กับ EDX EAX = EBX // ย้าย EBX ไปยัง EAX => mov eax, ebx EAX -- // ลดค่า EAX => dec eax EAX ++ // เพิ่มค่า EAX => inc eax EAX + 2 // เพิ่ม 2 ให้กับ eax => add eax, 2 EAX - $ 80 // ลบ 0x80 ออกจาก eax => sub eax, 0x80 BX * CX // คูณ BX ด้วย CX => mul cx -- การหาร การคูณ และการหารเอาเศษ ควรคงค่ารีจิสเตอร์ไว้CX / BX // หาร CX ด้วย BX => div bx CX mod BX // เศษเหลือของ CX/BX ไปยัง BX => div bx

การเลื่อนและการหมุนรีจิสเตอร์นั้นคล้ายคลึงกับภาษาซี

DX << 10 // เลื่อนไปทางซ้าย 10 บิตCX >> 8 // เลื่อนไปทางขวา 8 บิตEAX <~ 6 // หมุนไปทางซ้าย 6 บิตEAX ~> 4 // หมุนไปทางขวา 4 บิต

การดำเนินการบิตไวส์อื่นๆ นั้นคล้ายกับการดำเนินการทางคณิตศาสตร์

DL & $ 08 // ดำเนินการ AND แบบบิตกับ DL และ 0x08 แล้วเก็บผลลัพธ์ไว้ใน DL CX | 1 // ตั้งค่าบิตต่ำสุดของ CX เป็น 1 (ทำให้เป็นเลขคี่) EAX = ~ ECX // ดำเนินการ NOT แบบบิตกับ ECX แล้วเก็บผลลัพธ์ไว้ใน EAX EAX ^ EAX // ลบ EAX โดยการดำเนินการ XOR กับตัวเอง

การจัดการสแต็กใน X# ทำได้โดยใช้ คำสั่ง `push` +และ-`pop` โดย ` +push` จะผลักค่ารีจิสเตอร์ ค่าคงที่ หรือรีจิสเตอร์ทั้งหมดลงบนสแต็ก และ-`pop` จะดึงค่ากลับไปยังรีจิสเตอร์บางตัว ค่าคงที่ทั้งหมดจะถูกผลักลงบนสแต็กในรูปแบบดับเบิลเวิร์ด เว้นแต่จะระบุไว้เป็นอย่างอื่น (ไม่รองรับการผลักไบต์เดียว)

+ ESI // ผลัก esi - EDI // ป๊อปเข้า edi + All // บันทึกรีจิสเตอร์ทั้งหมด => pushad - All // โหลดรีจิสเตอร์ทั้งหมด => popad + $ 1 badboo2 // ผลัก 0x1badboo2 ลงบนสแต็ก+ $ cafe เป็นคำ// \/ + $ babe เป็นคำ// ผลัก 0xcafebabe + # VideoMemory // ผลักค่าคงที่ VideoMemory

ตัวแปรถูกกำหนดภายในเนมสเปซโดยใช้varคีย์เวิร์ด `variable` อาร์เรย์ถูกกำหนดโดยการระบุชนิดและขนาด ตัวแปรและอาร์เรย์จะมีค่าเริ่มต้นเป็นศูนย์ หากต้องการอ้างอิงถึงค่าของตัวแปร ให้ใช้จุด ('.') และหากต้องการอ้างอิงถึงที่อยู่ของตัวแปร ให้ใช้เครื่องหมายจุด ('.' @)

namespace XSharpVariables var zeroVar // ตัวแปรจะถูกกำหนดค่าเป็นศูนย์var myVar1 = $ f000beef // ตัวแปรจะถูกกำหนดค่าเป็น 0xf000beef var someString = ' Hello XSharp ! ' // ตัวแปรจะถูกกำหนดค่าเป็น 'Hello XSharp!\0', var buffer byte [ 1024 ] // ตัวแปรขนาด 1024 ไบต์ จะถูกกำหนดค่าเป็นศูนย์ 1024 ไบต์... EAX = . myVar1 // ย้ายค่าของ myVar1 (0xf000beef) ไปยัง EAX ESI = @ . someString // ย้ายที่อยู่ของ someString ไปยัง ESI CL = . someString // ย้ายอักขระตัวแรกของ someString ('H') ไปยัง CL . zeroVar = EAX // กำหนดค่า zeroVar ให้กับค่าของ EAX

X# สามารถเข้าถึงที่อยู่ที่มีค่าออฟเซ็ตที่ระบุโดยใช้วงเล็บเหลี่ยมได้:

var someString = ' Hello XSharp ! ' //ตัวแปรจะถูกกำหนดค่าเป็น 'Hello XSharp!\0' ... ESI = @ . someString // โหลดที่อยู่ของ someString ไปยัง ESI CL = 'B' // ตั้งค่า CL เป็น 'B' (เขียน 'H' ใหม่ไว้ที่จุดเริ่มต้น) CH = ESI [ 1 ] // ย้ายอักขระตัวที่สอง ('E') จากสตริงไปยัง CH ESI [ 4 ] = $ 00 // สิ้นสุดสตริง//ค่าของ someString จะเป็น 'Bell' (หรือ 'Bell\0 XSharp!\0')

ใน X# มีสองวิธีในการเปรียบเทียบค่า ได้แก่ การเปรียบเทียบแบบบริสุทธิ์ และการเปรียบเทียบแบบมีเงื่อนไข (if-comparison)

• การเปรียบเทียบแบบบริสุทธิ์จะเก็บผลลัพธ์ไว้ในตัวแปร FLAGS ซึ่งสามารถนำไปใช้ในภาษาแอสเซมบลีแบบดั้งเดิม หรือใช้กับifคีย์เวิร์ดโดยไม่ต้องระบุสมาชิกที่ใช้ในการเปรียบเทียบ
• หากการเปรียบเทียบเป็นการเปรียบเทียบสมาชิกสองคนโดยตรงหลังจากifคำหลัก

ต่อไปนี้เป็นสองวิธีในการเขียนฟังก์ชันหาความยาวสตริง X# (แบบช้าstrlen) :

// วิธีที่ 1: ใช้ฟังก์ชัน เปรียบเทียบแบบบริสุทธิ์ strlen { ESI = ESP [ 4 ] // รับพอยเตอร์ไปยังสตริงที่ส่งผ่านเป็นอาร์กิวเมนต์แรกECX ^ ECX // ล้าง ECX Loop : AL = ESI [ ECX ] // รับอักขระตัวถัดไปAL ?= 0 // เป็น 0 หรือไม่? บันทึกไปยัง FLAGS ถ้า= return // ถ้า ZF ถูกตั้งค่า ให้คืนค่า ECX ++ // มิฉะนั้น ให้เพิ่มค่า ECX ไปที่Loop // วนลูป...//วิธีที่ 2: ใช้ฟังก์ชัน if strlen { ESI = ESP [ 4 ] // รับพอยเตอร์ไปยังสตริงที่ส่งผ่านเป็นอาร์กิวเมนต์แรกECX ^ ECX // ล้าง ECX Loop : AL = ESI [ ECX ] if AL = 0 return // AL = 0? return ECX ++ goto Loop // วนลูป.... }

มีตัวดำเนินการเปรียบเทียบให้เลือกใช้ 6 แบบ: ตัวดำเนินการเหล่านี้สามารถใช้ได้ทั้งในการเปรียบเทียบและในลูป โปรดทราบว่ายังมี ตัวดำเนินการ AND ระดับบิตซึ่งใช้ทดสอบบิตด้วย:< > = <= >= !=

AL ?& $ 80 // ทดสอบ AL MSB ถ้า= ส่งคืน// ถ้า ZF เป็น 0 คำสั่งทดสอบให้ผลลัพธ์เป็น 0 และ MSB ไม่ได้ถูกตั้งค่า

Cosmos ช่วยให้ผู้ใช้สามารถบูตระบบปฏิบัติการในสภาพแวดล้อมจำลองโดยใช้เครื่องเสมือนこれによりนักพัฒนาสามารถทดสอบระบบบนคอมพิวเตอร์ของตนเองได้โดยไม่ต้องรีบูตเครื่อง ซึ่งมีข้อดีคือไม่จำเป็นต้องใช้ฮาร์ดแวร์เพิ่มเติม หรือไม่ต้องออกจากสภาพแวดล้อมการพัฒนาแบบบูรณาการ (IDE) VMware เป็นวิธีการจำลองเสมือนหลัก แต่ก็รองรับวิธีการอื่นๆ เช่นQEMUและ Hyper-V ด้วย

ตัวเลือกนี้จะเขียนระบบปฏิบัติการลงใน ไฟล์ อิมเมจดิสก์ ( ไฟล์ ISO ) ซึ่งสามารถโหลดลงในโปรแกรมจำลองบางตัว (เช่นBochs , QEMUหรือที่พบได้ทั่วไปคือ VMware ) หรือเขียนลงในแฟลชไดรฟ์ USBและบูตบนฮาร์ดแวร์จริงได้

ตัวเลือกนี้อนุญาตให้ระบบปฏิบัติการบูตบนฮาร์ดแวร์จริง ข้อมูลจะถูกส่งผ่านเครือข่ายท้องถิ่น (LAN) ไปยัง เครื่อง ไคลเอ็นต์ซึ่งต้องใช้คอมพิวเตอร์สองเครื่อง: เครื่องหนึ่งเป็นเครื่องไคลเอ็นต์ (ที่ใช้บูตระบบปฏิบัติการ) และอีกเครื่องหนึ่งเป็นเครื่องเซิร์ฟเวอร์ (โดยปกติจะเป็นเครื่องสำหรับพัฒนาซอฟต์แวร์) นอกจากนี้ยังต้องมีเครือข่ายเชื่อมต่อระหว่างคอมพิวเตอร์ทั้งสองเครื่อง เครื่องไคลเอ็นต์ที่มีการ์ดเครือข่ายและระบบอินพุต/เอาต์พุตพื้นฐาน ( BIOS ) ที่สามารถบูตด้วย PXE ได้ (ข้อมูลณ ปี 2022)การดีบักผ่านเครือข่ายไม่ได้รับการสนับสนุนอีกต่อไป