C / C ++। कमांड लाइन पार्सिंग विधि

बहुत पहले नहीं, काम पर, मुझे C ++ बिल्डर वातावरण में एक कार्यक्रम लिखने के कार्य का सामना करना पड़ा, और इसमें एक क्षण था जब आपको कमांड लाइन को पार्स करने की आवश्यकता थी। जादू भी कार्य से जुड़ा था: “आप सभी स्रोतों का उपयोग कर सकते हैं जो हैं। वे यहाँ झूठ बोलते हैं: ... "। सबसे पहले, मैं, निश्चित रूप से, पते पर चढ़ गया ... और वहां एक बहुत ही शाखायुक्त कोड संरचना मिली, जिसे मैंने जानने की कोशिश की और फैसला किया कि इसे अपने लिए अनुकूलित करना नरक था। इसलिए, यह मुझे संकेतों और स्लॉट्स के क्यूटी-आधारित प्रणाली के समान कुछ लिखने के लिए हुआ, केवल सी ++ बिल्डर और कमांड तर्क के लिए।
तो चलिए शुरू करते हैं। विचार यह है: कमांड लाइन विश्लेषण यह जांचने के लिए नीचे आता है कि क्या तर्क में एक विशेष चरित्र है (मेरे मामले में यह "-" - मैंने लिनक्स मानक लिया था)। इसके आधार पर, तर्क को पैरामीटर या उसके मूल्य के नाम के रूप में पढ़ा जाता है। प्रसंस्करण कार्यों को कॉल करने के लिए एक साहचर्य सरणी का उपयोग किया जाता है, अर्थात। एक सरणी जिसमें चाबियाँ उपलब्ध मापदंडों के नाम होंगे, और मान किसी विशेष पैरामीटर के प्रसंस्करण कार्यों के पते हैं। यह, सामान्य तौर पर, सभी है। चलो कार्यान्वयन के लिए नीचे उतरें?

आगे बढ़ो। चलो उपकरणों के अध्ययन के साथ शुरू करते हैं। C ++ बिल्डर साहचर्य सरणियों को संसाधित करने के लिए मानचित्र प्रकार (map.h में घोषित) का उपयोग करता है।

#include <map.h>

आगे की मदद अपने प्रकार की घोषणा करें:

typedef map <AnsiString, int*> TFuncTable;

और कक्षा में एक प्रकार की आवृत्ति:

TFuncTable funcTable;

यहां, AnsiString को कुंजी के रूप में उपयोग किया जाता है (मुझे माफ़ करें std :: string), और मान int * हैं (वैसे, यह 64-बिट सिस्टम के लिए काम नहीं कर सकता है)। अब, देखते हैं कि इस हैश में कैसे डालें। यह पता चला कि यह इतना आसान नहीं था और इसे मारने में लगभग 2 घंटे का समय लगा। लेकिन इसे इस तरह किया गया:

int *addr = (int*)&myFunction;
funcTable.insert(TFuncTable::value_type(AnsiString("-myParam"), addr));

यह TFuncTable पर ध्यान देने योग्य है :: value_type () - क्यों, मुझे ईमानदारी से समझ में नहीं आया, लेकिन, जाहिर है, यह कुछ प्रकार का मिलान है जिसके बिना कार्यक्रम भी संकलन नहीं होगा।
तो, सरणी को इनिशियलाइज़ किया - बढ़िया। वह कैसा दिखेगा? हां, कुछ इस तरह:

funcTable[“-myParam”] == 0xABCDEF // -

धीरे-धीरे लेकिन निश्चित रूप से, हम इस पूरी अर्थव्यवस्था का उपयोग कर रहे हैं। इस तरह के एल्गोरिथ्म का एक माइनस तुरंत उल्लेख के लायक है: प्रसंस्करण कार्य एक ही तरह के होने चाहिए, अर्थात हम एक कार्यात्मक प्रकार की घोषणा करते हैं:

typedef void (*TFunc)(AnsiString param);

और हमारे हैंडलर्स को लिखने के लिए उसमें चिपके रहें। ऐसे हैंडलर का एक उदाहरण:

void myFunction(AnsiString name)
{
MainForm->setTestName(name);
}

लेकिन यह एक साधारण हैंडलर है। जब पैरामीटर जैसा कुछ आता है तो शायद यह अधिक कठिन होगा:

"param1,param2,param3"

वास्तविक उदाहरण के लिए, आप / etc / fstab - Linux फ़ाइल को देख सकते हैं।
खैर, यह बताने का समय है कि पैरामीटर के नाम से हैश से फ़ंक्शन कैसे शुरू करें। हां, लेकिन इससे पहले, मुझे लगता है कि यह पूरी आरंभिक प्रक्रिया को ढेर में रखने लायक है:

1. नक्शा शामिल है
2. घोषित प्रकार हैश, इस प्रकार का उदाहरण घोषित किया।
3. उन्होंने इस प्रकार का पालन करते हुए एक कार्यात्मक प्रकार घोषित किया और पैरामीटर हैंडलर फ़ंक्शन लिखे।
4. हश भरा।

अब आप कमांड लाइन के प्रोसेसिंग फंक्शन को स्वयं शुरू कर सकते हैं। गणना एल्गोरिथम यह देखता है कि क्या तर्क पैरामीटर या उसके मूल्य का नाम है:

bool TMainForm::parseParams()
{
int argc;
TFunc srvFunc;
LPWSTR *cmdLine = CommandLineToArgvW(GetCommandLineW(), &argc);
int iter = 1;

for(int i = 1; i < argc; i += iter)
{
AnsiString param = "";
AnsiString paramName = cmdLine[i];
if(i < argc - 1)
{
if(AnsiString(cmdLine[i + 1])[1] == '-')
iter = 1;
else
{
param = cmdLine[i + 1];
iter = 2;
}
}

if(funcTable.find(paramName) == funcTable.end())
{
Out(" " + paramName);
return false;
}
srvFunc = (TFunc)funcTable[paramName];
srvFunc(param);
}
return true;
}


क्या है:
LPWSTR * cmdLine = CommandLineToArgvW (GetCommandLineW (), & argc); - इसके साथ बोरलैंड मदद में भी, सब कुछ काफी मैला है, लेकिन यह सब इस तथ्य से उबलता है कि इस तरह के परिवर्तनों से मानक argc और argv का उत्पादन होता है, इसलिए चलो आगे बढ़ते हैं।
आउट () एक विशेष इनपुट / आउटपुट फ़ंक्शन है। दिए गए विषय के लिए कोई दिलचस्पी नहीं है।
मुझे स्ट्रिंग तर्क में "-" प्रतीक के लिए खोज की प्रक्रिया बताने की आवश्यकता नहीं है - यह सामान्य है। सबसे दिलचस्प यहाँ:

srvFunc = (TFunc)funcTable[paramName];
srvFunc(param);

इसलिए फंक्शन हैंडलर लॉन्च किया जाता है। सरल, सही? और 1000 वीं घुटने तक कोई जंगली शाखाएं नहीं।

तो हमारे पास क्या है? मैं राज्य में काम करता हूं। कार्यालय, और इसलिए मैं वहां नहीं जा रहा हूँ यही है, जो कर्मचारी मेरे बाद आया है वह आसानी से अपने हैंडलर लिख देगा, पते को हैश में चलाएगा, और उसे कमांड लाइन विश्लेषक के बारे में नहीं सोचना होगा। यहाँ ऐसा अंकगणित है।