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

nl::อาร์การ์ด

สรุป

การแจกแจง

OptionArgumentType enum
กําหนดข้อกําหนดอาร์กิวเมนต์สําหรับตัวเลือกบรรทัดคําสั่ง

ประเภทคําจํากัดความ

NonOptionArgHandlerFunct)(const char *progName, int argc, char *argv[]) Typedef
bool(*
ฟังก์ชันที่สามารถเรียกใช้เพื่อจัดการอาร์กิวเมนต์บรรทัดคําสั่งที่ไม่ใช่ตัวเลือกที่เหลืออยู่
OptionHandlerFunct)(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg) Typedef
bool(*
ฟังก์ชันที่เรียกใช้เพื่อจัดการชุดตัวเลือกบรรทัดคําสั่งได้

ตัวแปร

PrintArgError = DefaultPrintArgError)(const char *msg,...)
void(*
ตัวชี้ไปยังฟังก์ชันที่ใช้ในการพิมพ์ข้อผิดพลาดที่เกิดขึ้นระหว่างการแยกวิเคราะห์อาร์กิวเมนต์
gActiveOptionSets = NULL
รายการ OptionSets ที่ส่งผ่านไปยังการเรียกใช้ ParseArgs() ที่ใช้งานอยู่ในปัจจุบัน

ฟังก์ชัน

CountAllOptions(OptionSet *optSets[])
size_t
CountAllOptions(OptionSet **optSets)
size_t
CountOptionSets(OptionSet *optSets[])
size_t
CountOptionSets(OptionSet **optSets)
size_t
DefaultPrintArgError(const char *msg, ...)
void
พิมพ์ข้อความแสดงข้อผิดพลาดที่เชื่อมโยงกับการแยกวิเคราะห์อาร์กิวเมนต์
FindOptionById(OptionSet **optSets, int optId, OptionSet *& optSet, OptionDef *& optDef)
void
FindOptionByIndex(OptionSet **optSets, int optIndex, OptionSet *& optSet, OptionDef *& optDef)
void
GetNextArg(char *& parsePoint)
bool
IsShortOptionChar(int ch)
bool
MakeLongOptions(OptionSet **optSets)
struct option *
MakeShortOptions(OptionSet **optSets)
char *
MakeUniqueHelpGroupNamesList(OptionSet *optSets[])
const char **
ParseArgs(const char *progName, int argc, char *argv[], OptionSet *optSets[], NonOptionArgHandlerFunct nonOptArgHandler, bool ignoreUnknown)
bool
แยกวิเคราะห์ชุดอาร์กิวเมนต์สไตล์บรรทัดคําสั่ง ฟังก์ชันการจัดการสายเรียกเข้าเพื่อประมวลผลแต่ละตัวเลือกและอาร์กิวเมนต์ที่ไม่ใช่ตัวเลือก
ParseArgs(const char *progName, int argc, char *argv[], OptionSet *optSets[], NonOptionArgHandlerFunct nonOptArgHandler)
bool
ParseArgs(const char *progName, int argc, char *argv[], OptionSet *optSets[])
bool
ParseArgsFromEnvVar(const char *progName, const char *varName, OptionSet *optSets[], NonOptionArgHandlerFunct nonOptArgHandler, bool ignoreUnknown)
bool
แยกวิเคราะห์ชุดอาร์กิวเมนต์จากตัวแปรสภาพแวดล้อมที่มีชื่อ
ParseArgsFromEnvVar(const char *progName, const char *varName, OptionSet *optSets[])
bool
ParseArgsFromEnvVar(const char *progName, const char *varName, OptionSet *optSets[], NonOptionArgHandlerFunct nonOptArgHandler)
bool
ParseArgsFromString(const char *progName, const char *argStr, OptionSet *optSets[], NonOptionArgHandlerFunct nonOptArgHandler, bool ignoreUnknown)
bool
แยกวิเคราะห์ชุดอาร์กิวเมนต์จากสตริงที่ระบุ
ParseArgsFromString(const char *progName, const char *argStr, OptionSet *optSets[], NonOptionArgHandlerFunct nonOptArgHandler)
bool
ParseArgsFromString(const char *progName, const char *argStr, OptionSet *optSets[])
bool
ParseBoolean(const char *str, bool & output)
bool
แยกวิเคราะห์สตริงเป็นค่าบูลีน
ParseFabricId(const char *str, uint64_t & fabricId, bool allowReserved)
bool
แยกวิเคราะห์รหัสผ้า Weave ในรูปแบบข้อความ
ParseHexString(const char *hexStr, uint32_t strLen, uint8_t *outBuf, uint32_t outBufSize, uint32_t & outDataLen)
bool
แยกวิเคราะห์สตริงไบต์ที่ระบุในรูปแบบเลขฐานสิบหก
ParseIPAddress(const char *str, IPAddress & output)
bool
โดยเริ่มจากแยกวิเคราะห์ที่อยู่ IP ในรูปแบบข้อความ
ParseInt(const char *str, uint64_t & output, int base)
bool
แยกวิเคราะห์และพยายามแปลงสตริงเป็นจํานวนเต็ม 64 บิตแบบไม่มีเครื่องหมาย โดยใช้การตีความที่เหมาะสมตามพารามิเตอร์พื้นฐาน
ParseInt(const char *str, uint32_t & output, int base)
bool
แยกวิเคราะห์และพยายามแปลงสตริงเป็นจํานวนเต็ม 32 บิตที่ไม่มีเครื่องหมาย ซึ่งใช้การตีความที่เหมาะสมตามพารามิเตอร์พื้นฐาน
ParseInt(const char *str, int32_t & output, int base)
bool
แยกวิเคราะห์และพยายามแปลงสตริงเป็นจํานวนเต็มที่มีเครื่องหมาย 32 บิต โดยใช้การตีความที่เหมาะสมตามพารามิเตอร์พื้นฐาน
ParseInt(const char *str, uint64_t & output)
bool
แยกวิเคราะห์และพยายามแปลงสตริงที่ตีความเป็นค่าทศนิยมเป็นจํานวนเต็มที่ไม่มีเครื่องหมาย 64 บิต โดยใช้การตีความที่เหมาะสมตามพารามิเตอร์พื้นฐาน
ParseInt(const char *str, uint32_t & output)
bool
แยกวิเคราะห์และพยายามแปลงสตริงที่ตีความเป็นค่าทศนิยมเป็นจํานวนเต็มที่ไม่มีเครื่องหมาย 32 บิต โดยใช้การตีความที่เหมาะสมตามพารามิเตอร์พื้นฐาน
ParseInt(const char *str, int32_t & output)
bool
แยกวิเคราะห์และพยายามแปลงสตริงที่ตีความเป็นค่าทศนิยมเป็นจํานวนเต็มแบบ 32 บิต ซึ่งใช้การตีความที่เหมาะสมตามพารามิเตอร์พื้นฐาน
ParseInt(const char *str, uint16_t & output)
bool
แยกวิเคราะห์และพยายามแปลงสตริงที่ตีความเป็นค่าทศนิยมเป็นจํานวนเต็มที่ไม่มีเครื่องหมาย 16 บิต โดยใช้การตีความที่เหมาะสมตามพารามิเตอร์พื้นฐาน
ParseInt(const char *str, int16_t & output)
bool
แยกวิเคราะห์และพยายามแปลงสตริงที่ตีความเป็นค่าทศนิยมเป็นจํานวนเต็มแบบ 16 บิต ซึ่งใช้การตีความที่เหมาะสมตามพารามิเตอร์ฐาน
ParseInt(const char *str, uint8_t & output)
bool
แยกวิเคราะห์และพยายามแปลงสตริงที่ตีความเป็นค่าทศนิยมเป็นจํานวนเต็มที่ไม่มีเครื่องหมาย 8 บิต โดยใช้การตีความที่เหมาะสมตามพารามิเตอร์พื้นฐาน
ParseNodeId(const char *str, uint64_t & nodeId)
bool
เริ่มด้วยการแยกวิเคราะห์รหัสโหนด Weave ในรูปแบบข้อความ
ParseSubnetId(const char *str, uint16_t & subnetId)
bool
แยกวิเคราะห์และพยายามแปลงสตริงเป็นรหัสซับเน็ตที่ไม่มีลายเซ็น 16 บิต โดยตีความสตริงว่าเป็นเลขฐาน 16
PrintOptionHelp(OptionSet *optSets[], FILE *s)
void
พิมพ์ข้อความความช่วยเหลือสําหรับรายการตัวเลือกที่ระบุไปยังสตรีม
PutStringWithBlankLine(FILE *s, const char *str)
void
PutStringWithNewLine(FILE *s, const char *str)
void
SplitArgs(char *argStr, char **& argList, char *initialArg)
int32_t

ชั้นเรียน

nl::ArgParser::ตัวเลือกความช่วยเหลือ

OptionSet ทั่วไปสําหรับการจัดการตัวเลือกการให้ข้อมูล (ความช่วยเหลือ เวอร์ชัน)

nl::ArgParser::OptionSetBase

OptionSet ที่เครื่องจัดการเป็นฟังก์ชันเสมือนจริง

โครงสร้าง

nl::ArgParser::OptionDef

กําหนดตัวเลือกบรรทัดคําสั่ง

nl::ArgParser::OptionSet

กําหนดกลุ่มตัวเลือกบรรทัดคําสั่งที่เกี่ยวข้องเชิงตรรกะและนํามาใช้ใหม่ได้

การแจกแจง

OptionArgumentType

 OptionArgumentType

กําหนดข้อกําหนดอาร์กิวเมนต์สําหรับตัวเลือกบรรทัดคําสั่ง

ประเภทคําจํากัดความ

ไม่ใช่เครื่องจัดการrrFunct

bool(* NonOptionArgHandlerFunct)(const char *progName, int argc, char *argv[])

ฟังก์ชันที่สามารถเรียกใช้เพื่อจัดการอาร์กิวเมนต์บรรทัดคําสั่งที่ไม่ใช่ตัวเลือกที่เหลืออยู่

OptionHandlerFunct

bool(* OptionHandlerFunct)(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg)

ฟังก์ชันที่เรียกใช้เพื่อจัดการชุดตัวเลือกบรรทัดคําสั่งได้

ตัวแปร

ข้อผิดพลาด PrintArg

void(* PrintArgError)(const char *msg,...) = DefaultPrintArgError

ตัวชี้ไปยังฟังก์ชันที่ใช้ในการพิมพ์ข้อผิดพลาดที่เกิดขึ้นระหว่างการแยกวิเคราะห์อาร์กิวเมนต์

แอปพลิเคชันควรเรียกใช้ PrintArgError() เพื่อรายงานข้อผิดพลาดในตัวเลือกและฟังก์ชันการจัดการอาร์กิวเมนต์ที่ไม่ใช่ตัวเลือก แทนที่จะพิมพ์ไปยัง stdout/stderr โดยตรง

ค่าเริ่มต้นจะเป็นตัวชี้ไปยังฟังก์ชัน DefaultPrintArgError()

ชุด gActiveOption

OptionSet ** gActiveOptionSets = NULL

รายการ OptionSets ที่ส่งผ่านไปยังการเรียกใช้ ParseArgs() ที่ใช้งานอยู่ในปัจจุบัน

ค่านี้จะเป็น NULL เมื่อไม่มีการเรียกไปยัง ParseArgs() อยู่ระหว่างดําเนินการ

ฟังก์ชัน

ตัวเลือกทั้งหมด

size_t CountAllOptions(
  OptionSet *optSets[]
)

ตัวเลือกทั้งหมด

size_t CountAllOptions(
  OptionSet **optSets
)

ชุดตัวเลือกการนับ

size_t CountOptionSets(
  OptionSet *optSets[]
)

ชุดตัวเลือกการนับ

size_t CountOptionSets(
  OptionSet **optSets
)

ข้อผิดพลาด DefaultPrintArg

void DefaultPrintArgError(
  const char *msg,
  ...
)

พิมพ์ข้อความแสดงข้อผิดพลาดที่เชื่อมโยงกับการแยกวิเคราะห์อาร์กิวเมนต์

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

รายละเอียด
พารามิเตอร์
[in] msg
ข้อความที่จะพิมพ์

แอปพลิเคชันควรเรียกผ่านตัวชี้ฟังก์ชัน PrintArgError แทนที่จะเรียกใช้ฟังก์ชันนี้โดยตรง

รหัสตัวเลือกการค้นหา

void FindOptionById(
  OptionSet **optSets,
  int optId,
  OptionSet *& optSet,
  OptionDef *& optDef
)

FindOptionByIndex

void FindOptionByIndex(
  OptionSet **optSets,
  int optIndex,
  OptionSet *& optSet,
  OptionDef *& optDef
)

รับ NextArg

bool GetNextArg(
  char *& parsePoint
)

IsShortOptionChar

bool IsShortOptionChar(
  int ch
)

ตัวเลือกแบบยาว

struct option * MakeLongOptions(
  OptionSet **optSets
)

ตัวเลือกสั้น

char * MakeShortOptions(
  OptionSet **optSets
)

ตั้งชื่อกลุ่มที่ไม่ซ้ํา

const char ** MakeUniqueHelpGroupNamesList(
  OptionSet *optSets[]
)

พาร์ซอาร์ก

bool ParseArgs(
  const char *progName,
  int argc,
  char *argv[],
  OptionSet *optSets[],
  NonOptionArgHandlerFunct nonOptArgHandler,
  bool ignoreUnknown
)

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

ParseArgs() ใช้รายการอาร์กิวเมนต์ (argv) และแยกวิเคราะห์ตามชุดคําจํากัดความของตัวเลือกที่มีให้ ฟังก์ชันนี้รองรับตัวเลือกทั้งแบบยาว (เพิ่มประสิทธิภาพ) และแบบสั้น (-o) และใช้ไวยากรณ์ตัวเลือกเดียวกันกับฟังก์ชัน GNU getopt_long(3)

รายละเอียด
พารามิเตอร์
[in] progName
ชื่อโปรแกรมหรือบริบทที่จะแยกวิเคราะห์อาร์กิวเมนต์ ระบบจะใช้สตริงนี้นําหน้าข้อความแสดงข้อผิดพลาดและคําเตือน
[in] argc
จํานวนอาร์กิวเมนต์ที่จะแยกวิเคราะห์ บวกกับ 1
[in] argv
อาร์เรย์ของสตริงอาร์กิวเมนต์ที่จะแยกวิเคราะห์ ความยาวของอาร์เรย์ต้องมากกว่าค่าที่ระบุสําหรับ argc และต้องกําหนด argv[argc] เป็น NULL 1 รายการ การแยกวิเคราะห์อาร์กิวเมนต์เริ่มต้นด้วยองค์ประกอบอาร์เรย์ วินาที (argv[1]) ระบบจะไม่สนใจองค์ประกอบ 0
[in] optSets
รายการตัวชี้ไปยังโครงสร้าง OptionSet ที่กําหนดตัวเลือกทางกฎหมาย รายการที่มีให้ต้องลงท้ายด้วย NULL
[in] nonOptArgHandler
ตัวชี้ไปยังฟังก์ชันที่จะเรียกใช้เมื่อการแยกวิเคราะห์ตัวเลือกเสร็จสมบูรณ์ด้วยอาร์กิวเมนต์ที่ไม่ใช่ตัวเลือกที่เหลืออยู่ ระบบจะเรียกใช้ฟังก์ชันดังกล่าวไม่ว่าจะมีอาร์กิวเมนต์หรือไม่ก็ตาม หากเป็น NULL จะ ParseArgs() จะรายงานข้อผิดพลาดหากมีอาร์กิวเมนต์ที่ไม่ใช่ตัวเลือก
[in] ignoreUnknown
หากเป็น "จริง" ระบบจะไม่สนใจตัวเลือกที่ไม่รู้จัก
การคืนสินค้า
true หากแยกวิเคราะห์ตัวเลือกและอาร์กิวเมนต์ที่ไม่ใช่ตัวเลือกสําเร็จแล้ว false หากไม่รู้จักตัวเลือกหรือไม่มีฟังก์ชันเครื่องจัดการรายการใดรายการหนึ่ง (เช่น แสดงผลเท็จ)

ระบบจะส่งคําจํากัดความของตัวเลือกไปยัง ParseArgs() เป็นอาร์เรย์ของโครงสร้าง OptionSet (optSets) OptionSet แต่ละรายการมีคําจํากัดความของตัวเลือกและฟังก์ชันเครื่องจัดการ ParseArgs() ประมวลผลอาร์กิวเมนต์ตัวเลือกตามลําดับที่กําหนด โดยเรียกใช้ฟังก์ชันเครื่องจัดการที่เกี่ยวข้องสําหรับตัวเลือกแต่ละรายการที่รู้จัก หลังจากแยกวิเคราะห์ตัวเลือกทั้งหมดแล้ว ระบบจะเรียกใช้ฟังก์ชันเครื่องจัดการที่ไม่ใช่ตัวเลือก (nonOptArgHandler) แยกต่างหากเพียงครั้งเดียวเพื่อประมวลผลอาร์กิวเมนต์ที่เหลือ

ชุดตัวเลือก

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

การกําหนดรูปแบบ SetSetsone จะมี 2 รูปแบบที่จะเริ่มใช้อินสแตนซ์ของโครงสร้าง OptionSet เอง เช่น เป็นค่าคงที่แบบคงที่ หรือคลาสย่อย OptionSetBase และระบุเครื่องมือสร้าง การทํางานหลังจะใช้ฟังก์ชัน HandleOption() เสมือนอย่างเดียวเพื่อมอบสิทธิ์การจัดการตัวเลือกไปยังคลาสย่อย

ระบบจะส่งรายการของ OptionSet ไปยังฟังก์ชัน ParseArgs() เป็นอาร์เรย์ของ NULL ที่สิ้นสุด เช่น

static OptionSet gToolOptions =
{
    HandleOption,        // handler function
    gToolOptionDefs,  // array of option definitions
    "GENERAL OPTIONS",   // help group
    gToolOptionHelp   // option help text
};

static OptionSet *gOptionSets[] =
{
    &gToolOptions,
    &gNetworkOptions,
    &gTestingOptions,
    &gHelpOptions,
    NULL
};

int main(int argc, char *argv[])
{
    if (!ParseArgs("test-app", argc, argv, gOptionSets))
    {
        ...
    }
}

คําจํากัดความตัวเลือก

ตัวเลือกจะกําหนดโดยใช้โครงสร้าง OptionDef คําจํากัดความของตัวเลือกจะจัดเป็นอาร์เรย์ขององค์ประกอบ OptionDef โดยที่องค์ประกอบแต่ละรายการจะมีชื่อตัวเลือก รหัสจํานวนเต็มที่ใช้ระบุตัวเลือก และระบุว่าตัวเลือกคาดหวัง/อนุญาตอาร์กิวเมนต์หรือไม่ จุดสิ้นสุดของอาร์เรย์ตัวเลือกจะระบุโดยช่องชื่อ NULL เช่น

enum
{
    kOpt_Listen = 1000,
    kOpt_Length,
    kOpt_Count,
};

static OptionDef gToolOptionDefs[] =
{
    // NAME         REQUIRES/ALLOWS ARG?  ID/SHORT OPTION CHAR
    // ============================================================
    {  "listen",    kNoArgument,          kOpt_Listen     },
    {  "length",    kArgumentRequired,    kOpt_Length     },
    {  "count",     kArgumentRequired,    kOpt_Count      },
    {  "num",       kArgumentRequired,    kOpt_Count      }, // alias for --count
    {  "debug",     kArgumentOptional,    'd'             },
    {  "help",      kNoArgument,          'h'             },
    {  NULL }
};

รหัสตัวเลือก

รหัสตัวเลือกจะระบุตัวเลือกสําหรับโค้ดที่จัดการ (ฟังก์ชัน OptionHandler) รหัสตัวเลือกจะสัมพันธ์กับ OptionSet ที่ปรากฏ ดังนั้นจึงใช้ซ้ําได้ใน OptionSet ต่างๆ (แต่ดูตัวเลือกวิดีโอสั้นด้านล่าง) รูปแบบทั่วไปคือการเริ่มใช้รหัสตัวเลือกหมายเลข 1000 แต่จะใช้ตัวเลขใดก็ได้ (gt และ 128 ได้) ตัวเลือกชื่อแทนสามารถสร้างขึ้นได้โดยใช้รหัสตัวเลือกเดียวกับชื่อตัวเลือกที่แตกต่างกัน

ตัวเลือกวิดีโอสั้น

ParseArgs() ต่างจากสตริง getopt_long(3) ตรงที่ไม่มีการใช้สตริงแยกต่างหากที่ระบุรายการตัวเลือกตัวเลือกสั้นๆ ตัวเลือกใดก็ตามที่มีค่ารหัสอยู่ในช่วงของอักขระ ASCII ที่เป็นกราฟิก จะช่วยให้ระบบใช้อักขระนั้นเป็นตัวเลือกแบบสั้นได้

ParseArgs() กําหนดให้อักขระตัวเลือกแบบสั้นต้องไม่ซ้ํากันในตัวเลือก all OptionSet ด้วยเหตุนี้ จึงไม่แนะนําให้ใช้ตัวเลือกสั้นๆ กับ OptionSet ใดๆ ที่มีการแชร์ระหว่างโปรแกรมต่างๆ เนื่องจากโอกาสสําคัญสําหรับการชน อักขระตัวเลือกแบบสั้นอาจมีการใช้งานซ้ําภายใน OptionSet เดียวเพื่อให้สร้างชื่อตัวเลือกแบบยาวของชื่อแทนได้

ความช่วยเหลือเกี่ยวกับตัวเลือก

OptionSet แต่ละรายการจะมีสตริง OptionHelp ที่อธิบายวัตถุประสงค์และไวยากรณ์ของตัวเลือกที่เชื่อมโยง ฟังก์ชัน PrintOptionHelp() จะใช้สตริงเหล่านี้เพื่อสร้างข้อมูลการใช้งานตัวเลือก

ตามปกติแล้ว สตริงความช่วยเหลือเกี่ยวกับตัวเลือกจะประกอบด้วยตัวอย่างไวยากรณ์ตามด้วยคําอธิบายข้อความของตัวเลือก หากตัวเลือกมีเวอร์ชันแบบสั้นหรือชื่อแทน ระบบจะระบุไว้ก่อนชื่อยาวๆ หลัก เพื่อความสอดคล้องกัน ที่มีการเยื้องไวยากรณ์ไวยากรณ์ด้วยช่องว่าง 2 บรรทัด ขณะที่บรรทัดรายละเอียดมีการเยื้องด้วย 7 วรรค บรรทัดว่างบรรทัดเดียวจะทําตามคําอธิบายตัวเลือกแต่ละรายการ รวมถึงบรรทัดสุดท้าย

เช่น

static const char *const gToolOptionHelp =
    "  --listen\n"
    "       Listen and respond to requests sent from another node.\n"
    "\n"
    "  --length \n"
    "       Send requests with the specified number of bytes in the payload.\n"
    "\n"
    "  --num, --count \n"
    "       Send the specified number of requests and exit.\n"
    "\n"
    "  -d, --debug []\n"
    "       Set debug logging to the given level. (Default: 1)\n"
    "\n"
    "  -h, --help\n"
    "       Print help information.\n"
    "\n";

กลุ่มช่วยเหลือเกี่ยวกับตัวเลือก

OptionSet คือสตริง HelpGroupName ที่ใช้เพื่อจัดกลุ่มตัวเลือกเข้าด้วยกันในเอาต์พุตความช่วยเหลือ ฟังก์ชัน PrintOptionHelp() จะใช้ HelpGroupName เป็นชื่อส่วนในเอาต์พุตการใช้งานที่สร้างขึ้น หาก OptionSet หลายรายการมี HelpGroupName เดียวกัน PrintPrintHelp() จะพิมพ์ความช่วยเหลือสําหรับตัวเลือกของ OptionSet ต่างๆ ร่วมกันภายใต้ชื่อส่วนทั่วไป

พาร์ซอาร์ก

bool ParseArgs(
  const char *progName,
  int argc,
  char *argv[],
  OptionSet *optSets[],
  NonOptionArgHandlerFunct nonOptArgHandler
)

พาร์ซอาร์ก

bool ParseArgs(
  const char *progName,
  int argc,
  char *argv[],
  OptionSet *optSets[]
)

พาร์ซอาร์กส์จากเอฟวาร์

bool ParseArgsFromEnvVar(
  const char *progName,
  const char *varName,
  OptionSet *optSets[],
  NonOptionArgHandlerFunct nonOptArgHandler,
  bool ignoreUnknown
)

แยกวิเคราะห์ชุดอาร์กิวเมนต์จากตัวแปรสภาพแวดล้อมที่มีชื่อ

ParseArgsFromEnvVar() อ่านตัวแปรสภาพแวดล้อมที่มีชื่อและส่งค่าไปยัง ParseArgsFromString() เพื่อแยกวิเคราะห์ หากไม่ได้กําหนดตัวแปรสภาพแวดล้อม ฟังก์ชันจะไม่ดําเนินการใดๆ

รายละเอียด
พารามิเตอร์
[in] progName
ชื่อโปรแกรมหรือบริบทที่จะแยกวิเคราะห์อาร์กิวเมนต์ ระบบจะใช้สตริงนี้นําหน้าข้อความแสดงข้อผิดพลาดและคําเตือน
[in] varName
ชื่อของตัวแปรสภาพแวดล้อม
[in] optSets
รายการตัวชี้ไปยังโครงสร้าง OptionSet ที่กําหนดตัวเลือกทางกฎหมาย รายการที่มีให้ต้องลงท้ายด้วย NULL
[in] nonOptArgHandler
ตัวชี้ไปยังฟังก์ชันที่จะเรียกใช้เมื่อการแยกวิเคราะห์ตัวเลือกเสร็จสมบูรณ์ด้วยอาร์กิวเมนต์ที่ไม่ใช่ตัวเลือกที่เหลืออยู่ ระบบจะเรียกใช้ฟังก์ชันดังกล่าวไม่ว่าจะมีอาร์กิวเมนต์หรือไม่ก็ตาม หากเป็น NULL จะ ParseArgs() จะรายงานข้อผิดพลาดหากมีอาร์กิวเมนต์ที่ไม่ใช่ตัวเลือก
[in] ignoreUnknown
หากเป็น "จริง" ระบบจะไม่สนใจตัวเลือกที่ไม่รู้จัก
การคืนสินค้า
true หากแยกวิเคราะห์ตัวเลือกและอาร์กิวเมนต์ที่ไม่ใช่ตัวเลือกสําเร็จแล้ว หรือหากไม่ได้ตั้งค่าตัวแปรสภาพแวดล้อมที่ระบุ false หากระบบไม่รู้จักตัวเลือก หากมีฟังก์ชันเครื่องจัดการที่ไม่ถูกต้อง (เช่น แสดงผลเท็จ) หรือหากเกิดข้อผิดพลาดภายใน

พาร์ซอาร์กส์จากเอฟวาร์

bool ParseArgsFromEnvVar(
  const char *progName,
  const char *varName,
  OptionSet *optSets[]
)

พาร์ซอาร์กส์จากเอฟวาร์

bool ParseArgsFromEnvVar(
  const char *progName,
  const char *varName,
  OptionSet *optSets[],
  NonOptionArgHandlerFunct nonOptArgHandler
)

สตริงการแยกวิเคราะห์จากสตริง

bool ParseArgsFromString(
  const char *progName,
  const char *argStr,
  OptionSet *optSets[],
  NonOptionArgHandlerFunct nonOptArgHandler,
  bool ignoreUnknown
)

แยกวิเคราะห์ชุดอาร์กิวเมนต์จากสตริงที่ระบุ

ParseArgsFromString() แบ่งสตริงที่ระบุ (argStr) เป็นชุดอาร์กิวเมนต์และแยกวิเคราะห์อาร์กิวเมนต์โดยใช้ฟังก์ชัน ParseArgs()

รายละเอียด
พารามิเตอร์
[in] progName
ชื่อโปรแกรมหรือบริบทที่จะแยกวิเคราะห์อาร์กิวเมนต์ ระบบจะใช้สตริงนี้นําหน้าข้อความแสดงข้อผิดพลาดและคําเตือน
[in] argStr
สตริงที่มีตัวเลือกและอาร์กิวเมนต์ที่จะแยกวิเคราะห์
[in] optSets
รายการตัวชี้ไปยังโครงสร้าง OptionSet ที่กําหนดตัวเลือกทางกฎหมาย รายการที่มีให้ต้องลงท้ายด้วย NULL
[in] nonOptArgHandler
ตัวชี้ไปยังฟังก์ชันที่จะเรียกใช้เมื่อการแยกวิเคราะห์ตัวเลือกเสร็จสมบูรณ์ด้วยอาร์กิวเมนต์ที่ไม่ใช่ตัวเลือกที่เหลืออยู่ ระบบจะเรียกใช้ฟังก์ชันดังกล่าวไม่ว่าจะมีอาร์กิวเมนต์หรือไม่ก็ตาม หากเป็น NULL จะ ParseArgs() จะรายงานข้อผิดพลาดหากมีอาร์กิวเมนต์ที่ไม่ใช่ตัวเลือก
[in] ignoreUnknown
หากเป็น "จริง" ระบบจะไม่สนใจตัวเลือกที่ไม่รู้จัก
การคืนสินค้า
true หากมีการแยกวิเคราะห์ตัวเลือกและอาร์กิวเมนต์ที่ไม่ใช่ตัวเลือกสําเร็จแล้ว false หากไม่ทราบตัวเลือก เมื่อเครื่องจัดการรายใดรายหนึ่งทํางานไม่สําเร็จ (กล่าวคือ แสดงข้อมูลเท็จ) หรือหากเกิดข้อผิดพลาดภายใน

ไวยากรณ์ของสตริงอินพุตนั้นคล้ายกับไวยากรณ์คําสั่ง Shell ของ Unix แต่มีรูปแบบการเสนอราคาที่เรียบง่าย กล่าวอย่างเจาะจงคือ

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

เช่น

--listen --count 10 --sw-version '1.0 (DEVELOPMENT)' "--hostname=nest.com"

สตริงการแยกวิเคราะห์จากสตริง

bool ParseArgsFromString(
  const char *progName,
  const char *argStr,
  OptionSet *optSets[],
  NonOptionArgHandlerFunct nonOptArgHandler
)

สตริงการแยกวิเคราะห์จากสตริง

bool ParseArgsFromString(
  const char *progName,
  const char *argStr,
  OptionSet *optSets[]
)

พาร์สบูลีน

bool ParseBoolean(
  const char *str,
  bool & output
)

แยกวิเคราะห์สตริงเป็นค่าบูลีน

ฟังก์ชันนี้จะยอมรับค่าอินพุตต่อไปนี้ (ไม่คํานึงถึงตัวพิมพ์เล็กหรือใหญ่) "true", "yes", "t", "y";"1"; "false";"noquoquo;f"tquo;"t)

รายละเอียด
พารามิเตอร์
[in] str
ตัวชี้ไปยังสตริง C ที่สิ้นสุดโดย NULL ซึ่งแสดงค่าที่จะแยกวิเคราะห์
[out] output
การอ้างอิงพื้นที่เก็บข้อมูลสําหรับบูลีนสําหรับเก็บค่าที่แยกวิเคราะห์สําเร็จ
การคืนสินค้า
เป็นจริงเสมอ มิเช่นนั้น จะเป็นเท็จเมื่อล้มเหลว

รหัส ParseFabricId

bool ParseFabricId(
  const char *str,
  uint64_t & fabricId,
  bool allowReserved
)

แยกวิเคราะห์รหัสผ้า Weave ในรูปแบบข้อความ

ฟังก์ชัน ParseFabricId() ยอมรับรหัสผ้า 64 บิตที่ระบุในรูปแบบเลขฐานสิบหกโดยมีหรือไม่มี '0x' นําหน้า

รายละเอียด
พารามิเตอร์
[in] str
ตัวชี้ไปยังสตริง C ที่สิ้นสุดโดย NULL ที่มีรหัสผ้าที่จะแยกวิเคราะห์
[out] output
การอ้างอิงค่า uint64_t ที่จัดเก็บค่าที่แยกวิเคราะห์สําเร็จ
[in] allowReserved
หากเป็น "จริง" ให้แยกวิเคราะห์รหัสผ้าในช่วงที่สงวนไว้
การคืนสินค้า
เป็น "true" หากแยกวิเคราะห์ค่าเป็น "เท็จ" หากไม่ใช่

สตริง ParexHexString

bool ParseHexString(
  const char *hexStr,
  uint32_t strLen,
  uint8_t *outBuf,
  uint32_t outBufSize,
  uint32_t & outDataLen
)

แยกวิเคราะห์สตริงไบต์ที่ระบุในรูปแบบเลขฐานสิบหก

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

รายละเอียด
พารามิเตอร์
[in] hexStr
ตัวชี้ไปยังสตริงที่จะแยกวิเคราะห์
[in] strLen
จํานวนอักขระในเลขฐานสิบหกเพื่อแยกวิเคราะห์
[in] outBuf
ตัวชี้ไปยังบัฟเฟอร์ที่จัดเก็บไบต์ในการแยกวิเคราะห์
[in] outBufSize
ขนาดของบัฟเฟอร์ที่ outBuf
[out] outDataLen
การอ้างอิงเป็นจํานวนเต็มที่จะรับจํานวนไบต์ทั้งหมดที่แยกวิเคราะห์ หากเหตุการณ์ OutBuf ใหญ่ไม่พอที่จะเก็บจํานวนไบต์ที่ระบุ outDataLen จะตั้งค่าเป็น UINT32_MAX
การคืนสินค้า
เป็นจริงหากแยกวิเคราะห์ค่าสําเร็จ เป็นเท็จหากข้อมูลอินพุตมีรูปแบบไม่ถูกต้อง หรือหาก outBuf เล็กเกินไป

ที่อยู่ IP

bool ParseIPAddress(
  const char *str,
  IPAddress & output
)

โดยเริ่มจากแยกวิเคราะห์ที่อยู่ IP ในรูปแบบข้อความ

รายละเอียด
พารามิเตอร์
[in] str
ตัวชี้ไปยังสตริง C ที่สิ้นสุด NULL ที่มีที่อยู่ที่จะแยกวิเคราะห์
[out] output
การอ้างอิงถึงออบเจ็กต์ IPAddress ที่จัดเก็บค่าที่แยกวิเคราะห์สําเร็จ
การคืนสินค้า
เป็น "true" หากแยกวิเคราะห์ค่าเป็น "เท็จ" หากไม่ใช่

พาร์เซ็ท

bool ParseInt(
  const char *str,
  uint64_t & output,
  int base
)

แยกวิเคราะห์และพยายามแปลงสตริงเป็นจํานวนเต็ม 64 บิตแบบไม่มีเครื่องหมาย โดยใช้การตีความที่เหมาะสมตามพารามิเตอร์พื้นฐาน

รายละเอียด
พารามิเตอร์
[in] str
ตัวชี้ไปยังสตริง C ที่สิ้นสุดโดย NULL ซึ่งแสดงจํานวนเต็มที่จะแยกวิเคราะห์
[out] output
การอ้างอิงพื้นที่เก็บข้อมูลสําหรับจํานวนเต็มที่ไม่มีเครื่องหมาย 64 บิต ที่เก็บค่าการแยกวิเคราะห์สําเร็จ
[in] base
ฐานตามที่ควรตีความและแยกวิเคราะห์สตริง หากเป็น 0 หรือ 16 สตริงอาจเป็นเลขฐานสิบหกและขึ้นต้นด้วย "0x" มิเช่นนั้น 0 จะแสดงโดยนัยเป็น 10 จนกว่าจะพบ 0 นําหน้า โดยที่ 8 โดยนัย
การคืนสินค้า
เป็นจริงเสมอ มิเช่นนั้น จะเป็นเท็จเมื่อล้มเหลว

พาร์เซ็ท

bool ParseInt(
  const char *str,
  uint32_t & output,
  int base
)

แยกวิเคราะห์และพยายามแปลงสตริงเป็นจํานวนเต็ม 32 บิตที่ไม่มีเครื่องหมาย ซึ่งใช้การตีความที่เหมาะสมตามพารามิเตอร์พื้นฐาน

รายละเอียด
พารามิเตอร์
[in] str
ตัวชี้ไปยังสตริง C ที่สิ้นสุดโดย NULL ซึ่งแสดงจํานวนเต็มที่จะแยกวิเคราะห์
[out] output
การอ้างอิงพื้นที่เก็บข้อมูลสําหรับจํานวนเต็มที่ไม่มีการเข้ารหัส 32 บิต ซึ่งจะเก็บค่าที่แยกวิเคราะห์สําเร็จ
[in] base
ฐานตามที่ควรตีความและแยกวิเคราะห์สตริง หากเป็น 0 หรือ 16 สตริงอาจเป็นเลขฐานสิบหกและขึ้นต้นด้วย "0x" มิเช่นนั้น 0 จะแสดงโดยนัยเป็น 10 จนกว่าจะพบ 0 นําหน้า โดยที่ 8 โดยนัย
การคืนสินค้า
เป็นจริงเสมอ มิเช่นนั้น จะเป็นเท็จเมื่อล้มเหลว

พาร์เซ็ท

bool ParseInt(
  const char *str,
  int32_t & output,
  int base
)

แยกวิเคราะห์และพยายามแปลงสตริงเป็นจํานวนเต็มที่มีเครื่องหมาย 32 บิต โดยใช้การตีความที่เหมาะสมตามพารามิเตอร์พื้นฐาน

รายละเอียด
พารามิเตอร์
[in] str
ตัวชี้ไปยังสตริง C ที่สิ้นสุดโดย NULL ซึ่งแสดงจํานวนเต็มที่จะแยกวิเคราะห์
[out] output
การอ้างอิงพื้นที่เก็บข้อมูลสําหรับจํานวนเต็มที่มีเครื่องหมาย 32 บิต ซึ่งจะเก็บค่าที่แยกวิเคราะห์สําเร็จ
[in] base
ฐานตามที่ควรตีความและแยกวิเคราะห์สตริง หากเป็น 0 หรือ 16 สตริงอาจเป็นเลขฐานสิบหกและขึ้นต้นด้วย "0x" มิเช่นนั้น 0 จะแสดงโดยนัยเป็น 10 จนกว่าจะพบ 0 นําหน้า โดยที่ 8 โดยนัย
การคืนสินค้า
เป็นจริงเสมอ มิเช่นนั้น จะเป็นเท็จเมื่อล้มเหลว

พาร์เซ็ท

bool ParseInt(
  const char *str,
  uint64_t & output
)

แยกวิเคราะห์และพยายามแปลงสตริงที่ตีความเป็นค่าทศนิยมเป็นจํานวนเต็มที่ไม่มีเครื่องหมาย 64 บิต โดยใช้การตีความที่เหมาะสมตามพารามิเตอร์พื้นฐาน

รายละเอียด
พารามิเตอร์
[in] str
ตัวชี้ไปยังสตริง C ที่สิ้นสุดโดย NULL ซึ่งแสดงจํานวนเต็มที่จะแยกวิเคราะห์
[out] output
การอ้างอิงพื้นที่เก็บข้อมูลสําหรับจํานวนเต็มที่ไม่มีเครื่องหมาย 64 บิต ที่เก็บค่าการแยกวิเคราะห์สําเร็จ
การคืนสินค้า
เป็นจริงเสมอ มิเช่นนั้น จะเป็นเท็จเมื่อล้มเหลว

พาร์เซ็ท

bool ParseInt(
  const char *str,
  uint32_t & output
)

แยกวิเคราะห์และพยายามแปลงสตริงที่ตีความเป็นค่าทศนิยมเป็นจํานวนเต็มที่ไม่มีเครื่องหมาย 32 บิต โดยใช้การตีความที่เหมาะสมตามพารามิเตอร์พื้นฐาน

รายละเอียด
พารามิเตอร์
[in] str
ตัวชี้ไปยังสตริง C ที่สิ้นสุดโดย NULL ซึ่งแสดงจํานวนเต็มที่จะแยกวิเคราะห์
[out] output
การอ้างอิงพื้นที่เก็บข้อมูลสําหรับจํานวนเต็มที่ไม่มีการเข้ารหัส 32 บิต ซึ่งจะเก็บค่าที่แยกวิเคราะห์สําเร็จ
การคืนสินค้า
เป็นจริงเสมอ มิเช่นนั้น จะเป็นเท็จเมื่อล้มเหลว

พาร์เซ็ท

bool ParseInt(
  const char *str,
  int32_t & output
)

แยกวิเคราะห์และพยายามแปลงสตริงที่ตีความเป็นค่าทศนิยมเป็นจํานวนเต็มแบบ 32 บิต ซึ่งใช้การตีความที่เหมาะสมตามพารามิเตอร์พื้นฐาน

รายละเอียด
พารามิเตอร์
[in] str
ตัวชี้ไปยังสตริง C ที่สิ้นสุดโดย NULL ซึ่งแสดงจํานวนเต็มที่จะแยกวิเคราะห์
[out] output
การอ้างอิงพื้นที่เก็บข้อมูลสําหรับจํานวนเต็มที่มีเครื่องหมาย 32 บิต ซึ่งจะเก็บค่าที่แยกวิเคราะห์สําเร็จ
การคืนสินค้า
เป็นจริงเสมอ มิเช่นนั้น จะเป็นเท็จเมื่อล้มเหลว

พาร์เซ็ท

bool ParseInt(
  const char *str,
  uint16_t & output
)

แยกวิเคราะห์และพยายามแปลงสตริงที่ตีความเป็นค่าทศนิยมเป็นจํานวนเต็มที่ไม่มีเครื่องหมาย 16 บิต โดยใช้การตีความที่เหมาะสมตามพารามิเตอร์พื้นฐาน

รายละเอียด
พารามิเตอร์
[in] str
ตัวชี้ไปยังสตริง C ที่สิ้นสุดโดย NULL ซึ่งแสดงจํานวนเต็มที่จะแยกวิเคราะห์
[out] output
การอ้างอิงพื้นที่เก็บข้อมูลสําหรับจํานวนเต็มที่ไม่มีเครื่องหมาย 16 บิต ซึ่งจะเก็บค่าที่แยกวิเคราะห์สําเร็จ
การคืนสินค้า
เป็นจริงเสมอ มิเช่นนั้น จะเป็นเท็จเมื่อล้มเหลว

พาร์เซ็ท

bool ParseInt(
  const char *str,
  int16_t & output
)

แยกวิเคราะห์และพยายามแปลงสตริงที่ตีความเป็นค่าทศนิยมเป็นจํานวนเต็มแบบ 16 บิต ซึ่งใช้การตีความที่เหมาะสมตามพารามิเตอร์ฐาน

รายละเอียด
พารามิเตอร์
[in] str
ตัวชี้ไปยังสตริง C ที่สิ้นสุดโดย NULL ซึ่งแสดงจํานวนเต็มที่จะแยกวิเคราะห์
[out] output
การอ้างอิงพื้นที่เก็บข้อมูลสําหรับจํานวนเต็มที่มีเครื่องหมาย 16 บิต ซึ่งระบบจะจัดเก็บค่าที่แยกวิเคราะห์สําเร็จ
การคืนสินค้า
เป็นจริงเสมอ มิเช่นนั้น จะเป็นเท็จเมื่อล้มเหลว

พาร์เซ็ท

bool ParseInt(
  const char *str,
  uint8_t & output
)

แยกวิเคราะห์และพยายามแปลงสตริงที่ตีความเป็นค่าทศนิยมเป็นจํานวนเต็มที่ไม่มีเครื่องหมาย 8 บิต โดยใช้การตีความที่เหมาะสมตามพารามิเตอร์พื้นฐาน

รายละเอียด
พารามิเตอร์
[in] str
ตัวชี้ไปยังสตริง C ที่สิ้นสุดโดย NULL ซึ่งแสดงจํานวนเต็มที่จะแยกวิเคราะห์
[out] output
การอ้างอิงพื้นที่เก็บข้อมูลสําหรับจํานวนเต็มที่ไม่มีเครื่องหมาย 8 บิต ซึ่งเก็บค่าที่แยกวิเคราะห์สําเร็จ
การคืนสินค้า
เป็นจริงเสมอ มิเช่นนั้น จะเป็นเท็จเมื่อล้มเหลว

รหัสพาร์เซ่

bool ParseNodeId(
  const char *str,
  uint64_t & nodeId
)

เริ่มด้วยการแยกวิเคราะห์รหัสโหนด Weave ในรูปแบบข้อความ

ฟังก์ชัน ParseNodeId() จะยอมรับรหัสโหนด 64 บิตที่ระบุในรูปแบบเลขฐานสิบหก (โดยมีหรือไม่มี '0x') หรือมีคําว่า 'any' หรือ 'all&#39 ซึ่งมีการตีความว่ารหัสโหนดใดก็ได้ (0xFFFFFFFFFFFFFFFF)

รายละเอียด
พารามิเตอร์
[in] str
ตัวชี้ไปยังสตริง C ที่สิ้นสุดโดย NULL ที่มีรหัสโหนดที่จะแยกวิเคราะห์
[out] output
การอ้างอิงค่า uint64_t ที่จัดเก็บค่าที่แยกวิเคราะห์สําเร็จ
การคืนสินค้า
เป็น "true" หากแยกวิเคราะห์ค่าเป็น "เท็จ" หากไม่ใช่

รหัสซับเน็ตย่อย

bool ParseSubnetId(
  const char *str,
  uint16_t & subnetId
)

แยกวิเคราะห์และพยายามแปลงสตริงเป็นรหัสซับเน็ตที่ไม่มีลายเซ็น 16 บิต โดยตีความสตริงว่าเป็นเลขฐาน 16

รายละเอียด
พารามิเตอร์
[in] str
ตัวชี้ไปยังสตริง C ที่สิ้นสุดโดย NULL ซึ่งแสดงรหัสซับเน็ต ซึ่งมีรูปแบบเป็นเลขฐานสิบหกเพื่อแยกวิเคราะห์
[in,out] subnetId
การอ้างอิงพื้นที่เก็บข้อมูลสําหรับจํานวนเต็มที่ไม่มีเครื่องหมาย 16 บิต ซึ่งจะเก็บค่ารหัสซับเน็ตที่แยกวิเคราะห์สําเร็จ
การคืนสินค้า
เป็นจริงเสมอ มิเช่นนั้น จะเป็นเท็จเมื่อล้มเหลว

ความช่วยเหลือของ PrintOption

void PrintOptionHelp(
  OptionSet *optSets[],
  FILE *s
)

พิมพ์ข้อความความช่วยเหลือสําหรับรายการตัวเลือกที่ระบุไปยังสตรีม

รายละเอียด
พารามิเตอร์
[in] optSets
รายการตัวชี้ไปยังโครงสร้าง OptionSet ที่มีข้อความช่วยเหลือสําหรับการพิมพ์
[in] s
สตรีม FILE ที่ควรพิมพ์ข้อความช่วยเหลือ

PutStringWithblankLine

void PutStringWithBlankLine(
  FILE *s,
  const char *str
)

PutStringWithNewLine

void PutStringWithNewLine(
  FILE *s,
  const char *str
)

SplitArgs

int32_t SplitArgs(
  char *argStr,
  char **& argList,
  char *initialArg
)