सबसे खराब वास्तविक दुनिया मैक्रो / प्री-प्रोसेसर दुरुपयोग है जो आपने कभी देखा है?

Question

क्या है सबसे खराब वास्तविक दुनिया मैक्रो / पूर्व प्रोसेसर दुरुपयोग क्या तुमने कभी का सामना करना पड़ा (कृपया कोई IOCCC जवाब * haha * काल्पनिक)?

कृपया एक छोटा सा स्निपेट या कहानी जोड़ें यदि यह वास्तव में मनोरंजक है। लक्ष्य हमेशा "मैक्रों का उपयोग न करें" लोगों को बताने के बजाय कुछ सिखाना है।

---

ps: मैंने पहले मैक्रोज़ का उपयोग किया है ... लेकिन आमतौर पर मैं उनसे छुटकारा पाता हूं जब मेरे पास "वास्तविक" समाधान होता है (भले ही वास्तविक समाधान इनबिल्ड हो तो यह मैक्रो के समान हो जाता है)।

---

बोनस: एक उदाहरण दें जहां मैक्रो वास्तव में एक मैक्रो समाधान से बेहतर था।

संबंधित प्रश्न: सी ++ मैक्रो कब फायदेमंद हैं?

Comments

+1 मैक्रों के हाथों हुए दुर्व्यवहार के दुरुपयोग की ओर ध्यान दिलाने के लिए।

— i_am_jorf

#

— डेफिन

सामुदायिक विकी का अर्थ है कि इस प्रश्न या उसके उत्तर पर किसी को भी वोट नहीं मिलेगा। कई लोग इस तरह के सवालों को प्रतिष्ठा हासिल करने के सस्ते और आसान तरीकों के रूप में देखते हैं, इसलिए यदि आप इसे सामुदायिक विकि के रूप में चिह्नित करते हैं, तो लोगों को सभी तुला आकार से बाहर निकलने और इसे बंद करने की संभावना कम है।

— ग्रीम पेरो

"लोगों को आकार से बाहर निकलने और इसे बंद करने की संभावना है": क्या आप यह अनुमान लगा रहे हैं कि आप स्टैक ओवरफ्लो पर कोई हास्यप्रद / मज़ेदार सामग्री नहीं चाहते हैं?

— ट्रेवर बॉयड स्मिथ

बस एक त्वरित बिंदु, पूर्व-प्रोसेसर भाषा का हिस्सा है और इसलिए किसी भी चीज़ की तरह, इसका उपयोग करने के लिए बुराई / गलत नहीं है।

— मिस्टर बॉय

Answer 1

स्मृति से, यह कुछ इस तरह से देखा:

#define RETURN(result) return (result);}

int myfunction1(args) {
    int x = 0;
    // do something
    RETURN(x)

int myfunction2(args) {
    int y = 0;
    // do something
    RETURN(y)

int myfunction3(args) {
    int z = 0;
    // do something
    RETURN(z)

हां यह सही है, किसी भी फ़ंक्शन में कोई समापन ब्रेसिज़ नहीं है। सिंटैक्स हाइलाइटिंग एक गड़बड़ थी, इसलिए उन्होंने vi का उपयोग संपादित करने के लिए किया (विम नहीं, इसका सिंटैक्स रंग है!)।

वह एक रूसी प्रोग्रामर थे, जिन्होंने ज्यादातर असेंबली लैंग्वेज में काम किया था। वह जितनी संभव हो उतने बाइट्स बचाने के बारे में कट्टर था क्योंकि उसने पहले बहुत सीमित मेमोरी वाले सिस्टम पर काम किया था। "यह उपग्रह के लिए था। केवल बहुत कम बाइट, इसलिए हम प्रत्येक बाइट का उपयोग कई चीजों के लिए करते हैं।" (बिट फ़िडलिंग, उनके संख्यात्मक मानों के लिए मशीन अनुदेश बाइट्स का पुन: उपयोग करना) जब मैंने यह पता लगाने की कोशिश की कि किस प्रकार के उपग्रह हैं, तो मैं केवल "परिक्रमा उपग्रह" प्राप्त करने में सक्षम था।

उनके पास दो अन्य क्विरक्स थे: एक उत्तल दर्पण उनके मॉनिटर के ऊपर चढ़ा हुआ था "यह जानने के लिए कि कौन देख रहा है", और एक त्वरित दस पुशअप्स करने के लिए अपनी कुर्सी से कभी-कभी अचानक निकल जाते हैं। उन्होंने इसे अंतिम रूप में समझाया "कोड में संकलक त्रुटि मिली। यह सजा है"।

Comments

"कंपाइलर को कोड में त्रुटि मिली। यह सजा है"। !! कंपनी आपको मिली ... साथी कर्मचारियों को सजा!

— लर्निंग

सोवियत रूस में, कार्यक्रम आपको संकलित करता है!

— क्रेशवर्क्स

जब मैंने संकलक त्रुटि "सजा" के बारे में पढ़ा, तो सबसे पहले मैंने सोचा कि "डॉबी को अपने हाथों से लोहा लेना था"।

— ग्रीम पेरो

मुझे लगता है कि प्रोग्रामर (खुद को शामिल किया गया) बहुत अधिक फिट होगा यदि हम सभी ने हर बार 10 पुशअप्स किए तो एक कंपाइलर को हमारे कोड में कोई त्रुटि मिली। यह संकलन द्वारा परीक्षण की घटना को भी कम कर सकता है।

— मिकीबी

वह आदमी कमाल का लगता है। लेकिन हाँ, मैं यह नहीं देखता कि यह कोड आकार में सुधार कैसे माना जाता है।

— जलफ

Answer 2

मेरा सबसे बुरा:

#define InterlockedIncrement(x) (x)++
#define InterlockedDecrement(x) (x)--

मैंने अपने जीवन के दो दिन कुछ मल्टी-थ्रेडेड COM रेफ-काउंटिंग मुद्दे पर नज़र रखने में बिताए क्योंकि कुछ बेवकूफों ने इसे हेडर फ़ाइल में डाल दिया। मैं उस कंपनी का उल्लेख नहीं करूँगा, जिसके लिए मैंने उस समय काम किया था।

इस कहानी से क्या शिक्षा मिलती है? यदि आपको कुछ समझ में नहीं आता है, तो दस्तावेज़ीकरण पढ़ें और इसके बारे में जानें। बस इसे दूर मत जाओ।

Comments

@ जोशुआ: यदि आप इस कोड को एक बहुआयामी वातावरण में चलाते हैं, तो आप अनजाने में ऐसा कर सकते हैं

— 1800 सूचना

"अगर आपको कुछ समझ में नहीं आता है, तो दस्तावेज़ीकरण पढ़ें और इसके बारे में जानें। बस इसे दूर न करें।" - तथास्तु!

— पॉल अलेक्जेंडर

@ 1800 जानकारी: मुझे लगता है कि आप सिर्फ वोट खो देंगे, यही वजह है कि मैं आपको एक नहीं दे सकता हूं? P

— wkf

मुझे गैर-सी ++ प्रोग्रामर के रूप में क्षमा करें: क्या यहां मुख्य समस्या यह है कि थ्रेडसेफ़ फ़ंक्शन को नॉन-थ्रेडसेफ़ में बदल दिया जाता है? या कि InterlockedIncrement एक पॉइंटर की उम्मीद करता है, तो अब आप पॉइंटर को बढ़ाएंगे बजाय इसके कि यह किस ओर इशारा कर रहा है? अथवा दोनों?

— टिम पीटरज़ेकर

समस्या यह है कि InterlockedIncrement आम तौर पर विंडोज एपीआई में परिभाषित एक परमाणु कार्य है। इसलिए जब लोग InterlockedIncrement को कॉल करते हैं, तो वे एक ऐसे फ़ंक्शन में कॉल करने की अपेक्षा करते हैं जो परमाणु रूप से निष्पादित होने की गारंटी है। इसके बजाय, किसी ने एक मैक्रो को उसी नाम से परिभाषित किया, जो एक सादे, गैर-परमाणु वृद्धि का मूल्यांकन करता है

— jalf

Answer 3

#define ever (;;)
for ever { 
   ...
}

Comments

मैं पसंद करता हूं <#define हमेशा के लिए (;;)> ताकि आप लिख सकें <हमेशा के लिए {...}>

— paxdiablo

किसी ने मुझे EVER चीज के लिए खोए हुए अंकों के साथ स्कूल में

— भेजा

क्या P & का सुझाव K & R से सीधा नहीं है? फिर भी, प्रयास के लायक नहीं, मैं कहूंगा।

— जॉनसन

यह वास्तव में बिल्कुल भी बुरा नहीं है। मैं for (;;)मुहावरे का उपयोग नहीं कर रहा हूं , अन्यथा मैं तुरंत इस मैक्रो को अपने कोड में जोड़ देता।

— एनटी

@ यायालसी: एमएसीएस लिस्प (और कुछ सामान्य लिस्प कार्यान्वयन) में आप (defmacro ever ())और फिर(require 'cl (ever))

— जो डी

Answer 4

#include <iostream>
#define System S s;s
#define public
#define static
#define void int
#define main(x) main()
struct F{void println(char* s){std::cout << s << std::endl;}};
struct S{F out;};

public static void main(String[] args) {
  System.out.println("Hello World!");
}

चुनौती: क्या कोई इसे कम परिभाषित और संरचना के साथ कर सकता है? ;-)

Comments

आपने अभी एक जावा-टू-सी कनवर्टर लिखा है! horray!

— एंड्रियास पीटरसन

"आक्रामक" के रूप में रिपोर्ट किया गया। (मैं बच्चा!)

— अन्निका बैकस्ट्रोम

वह या तो छिपकर सुंदर है या खूबसूरती से छिपा हुआ है।

— क्रिस लुत्ज

@ मर्क - यह घोषित करता है publicऔर static as nothing, void` के रूप में int, और के main(x)रूप में main(), इसलिए में public static void main(String[] args)बदल जाता है int main()। फिर में Systemबदल जाता है S s;s, इसलिए System.out.println("Hello World!");यह बदल जाता है कि संरचना में किस फ़ंक्शन को S s; s.out.println("Hello World!");कॉल किया जाता है । printlnFS

— क्रिस लुत्ज

इस पर एक नज़र डालें: mailcom.com/ioccc/chia/chia.c (डाउनलोड करें और इसे संकलित करें)

— रॉबर्टो बोनालेट

Answer 5

#define private public

Comments

मैंने पहले भी ऐसा किया है। कभी-कभी आपको केवल एक सदस्य चर को संशोधित करने या कुछ तृतीय-पक्ष कोड में एक फ़ंक्शन को ओवरराइड करने की आवश्यकता होती है जिसे आप बदल नहीं सकते हैं - और उन्होंने आपके लिए एक सहायक प्रदान नहीं किया।

— माइकल क्रिस्टोफिक

वाह यूनिट के परीक्षण के लिए यह उपयोगी भी हो सकता है, भले ही ऑब्जेक्ट डिज़ाइन के भूत आपको रात में परेशान करेंगे।

— इपगा

हम्म, अपरिभाषित व्यवहार, एक-परिभाषा नियम का आसान उल्लंघन, संभावित लेआउट अंतर। हाँ, यह एक विजेता है।

— डेविड थॉर्नले

तो इसके साथ, मैं निजी और सार्वजनिक सामानों तक पहुंच बना सकता हूं, लेकिन संरक्षित सामान नहीं, और मैं classकीवर्ड और पहली पहुंच संशोधक के बीच सामान तक नहीं पहुंच सकता ।

— केन ब्लूम

@Ken:#define class struct #define protected public

— याकॉव

Answer 6

#define if while

यह किसी पर मजाक किया गया था, यह प्रभावित लोगों द्वारा मनोरंजक नहीं पाया गया था

Comments

# डेफिन जबकि अगर और भी अधिक कपटी होगी।

— स्टारबेल

हमें आपके कथन को स्पष्ट करना चाहिए। यह प्रभावित लोगों द्वारा मनोरंजक नहीं पाया गया था । :-)

— एंड्रयू शेफर्ड

जब मैंने होमवर्क असाइनमेंट किया, तो मैंने अक्सर इस तरह के काम किए, बस अपने शिक्षकों को परेशान करने के लिए।

— पियोन

यह एक अच्छा शरारत है, लेकिन यह संकलित नहीं करेगा यदि कोई "और" बयान हो। मैंने पाया है कि #define if (x) if (true) सबसे प्रभावी है।

— ग्राफिक्स नोब ऑक्ट

मैंने हमेशा #define sizeof (x) रैंड ()

— जॉन

Answer 7

गूढ़:

#define begin {
#define end }
/* and so on */

गंभीरता से, यदि आप पास्कल में कोड करना चाहते हैं, तो पास्कल संकलक खरीदें, सुंदर सी भाषा को नष्ट न करें।

Comments

अब आप मुझे सोच रहे हैं कि मैं किन भाषाओं को एक चालाक पर्याप्त हेडर फाइल के साथ जोड़ सकता हूं।

— छिपकली

सी सुंदर नहीं है। यह बदसूरत है।

— rlbond

इसकी सुंदरता इसकी सादगी में निहित है। यह कहा गया है कि इसमें असेंबली लैंग्वेज की सारी गति है ... असेंबली लैंग्वेज की पठनीयता :-) मैं इसे फूला हुआ सी ++ से अधिक पसंद करता हूं (हालांकि मैं अपनी विशाल लाइब्रेरी के कारण अपने दिन की नौकरी में जावा को प्राथमिकता देता हूं)।

— पैक्सिडाब्लो

सच में नहीं। बॉर्न शेल के लिए बॉर्न का मूल स्रोत खोजें। उसने ऐसा कुछ प्रकार के कमीने ALGOL जैसी गड़बड़ी को प्राप्त करने के लिए किया।

— RBerteig

#define DO (int _i = 0; _i <= 1; ++ _ i) {if (_i == 1) //// LINE BREAK //// #define IF (cond); if ((cond)) ब्रेक; } //// लाइन BREAK //// DO प्रिंटफ ("ए") IF (1 == 2);

— एड्रियन पनासीक

Answer 8

एक 'वास्तुकार', बहुत विनम्र आदमी है, आप जानते हैं कि प्रकार था, निम्नलिखित था:

#define retrun return

क्योंकि वह तेजी से टाइप करना पसंद करता था। ब्रेन-सर्जन उन लोगों पर चिल्लाना पसंद करते थे जो उनसे ज्यादा स्मार्ट थे (जो कि हर किसी को बहुत पसंद था), और उन पर अपनी ब्लैक-बेल्ट का इस्तेमाल करने की धमकी देते थे।

Comments

मैं उस टाइपो को इतना अधिक बनाता हूं कि मैं वास्तव में इस पर विचार करता हूं।

— जोशुआ

बल्कि अपने संपादक को वापसी में ऑटोरप्लेस के बारे में सिखाएं। Ive ने मेरे IRC- क्लाइंट को ऐसे हैकरीज किए, कम से कम

— Tetha

अरे, मुझे लगता है कि मैं उस 'वास्तुकार' के साथ भी काम करता था। आखिरकार जब उन्हें अपने अहंकार के बारे में जानने की आवश्यकता पड़ी, तो उन्हें वरिष्ठ-वास्तुकार का पुनर्पाठ मिला।

— BIBD

मैंने 'rn' को bash में 'rm' के लिए फिर से परिभाषित किया, क्योंकि मैं टाइप नहीं कर सकता था और 'rn' न्यूज़रीडर को स्टार्टअप और सर्वर से कनेक्ट होने में 5 मिनट लगते थे।

— मार्टिन बेकेट

आप बस एक नया टर्मिनल नहीं खोल सकते (या दूसरे वीटी पर स्विच करें) और करें killall rn?

— जो डी

Answer 9

असली दुनिया? MSVC के पास minmax.h में मैक्रोज़ हैं, कहा जाता है maxऔर min, जो मानक std::numeric_limits<T>::max()फ़ंक्शन का उपयोग करने के लिए हर बार एक संकलक त्रुटि का कारण बनता है ।

Comments

आह, हाँ, यही कारण है कि मेरे पास एक विशेष हेडर था जिसमें एमएस-विशिष्ट लोगों के बाद #

— undef के संन्यास को

के साथ हल किया गया (std :: num_limits <T> :: max) () लेकिन हाँ, बहुत कष्टप्रद।

— आरएलबोंड

C / C ++ -> प्रीप्रोसेसर -> प्रीप्रोसेसर परिभाषाओं के तहत अपने प्रोजेक्ट गुणों में NOMINMAX जोड़ें।

— मैट्न्यूपोर्ट

ये मैक्रोज़ न्यूनतम से अधिक एमएस हेडर में मौजूद हैं और अधिकतम C ++ स्टैंडर्ड लाइब्रेरी में हैं।

— रिचर्ड

यह तब और भी बुरा होता है जब आपकी चार अन्य बाहरी निर्भरताएँ भी अपने आप में न्यूनतम / अधिकतम को परिभाषित करती हैं, अलग-अलग प्रकार की सक्रीयता की, ख़राब-विघटित मैक्रोज़ से लेकर अच्छी तरह से लिखे गए टेम्प्लेट तक की, और उनमें से सिर्फ एक को असम्बद्ध होना असंभव बना देता है या अन्यथा इन्हें छोड़ें ... मेरी पुस्तक में यद्यपि दोष के लिए भाषा 50% है।

— रोमन स्टार्कोव

Answer 10

पास्कल सिंटैक्स और फ्रेंच कीवर्ड के बीच एक मिश्रण:

#define debut {
#define fin }
#define si if(
#define alors ){
#define sinon }else{
#define finsi }

Comments

#define zut_alors से बाहर निकलना (-1)

— मिकीबी

यह कमाल है और इसने मुझे जोर से हंसाया। तो, यह मूल रूप से सी में लागू बेसिक का एक स्थानीयकृत फ्रांसीसी संस्करण है?

— बॉबी

Answer 11

रेमंड चेन प्रवाह नियंत्रण मैक्रोज़ का उपयोग करने के खिलाफ एक बहुत अच्छा शेख़ी है । उसका सर्वश्रेष्ठ उदाहरण मूल बॉर्न शेल स्रोत कोड से सीधे है:

ADDRESS alloc(nbytes)
    POS     nbytes;
{
    REG POS rbytes = round(nbytes+BYTESPERWORD,BYTESPERWORD);

    LOOP    INT     c=0;
    REG BLKPTR  p = blokp;
    REG BLKPTR  q;
    REP IF !busy(p)
        THEN    WHILE !busy(q = p->word) DO p->word = q->word OD
        IF ADR(q)-ADR(p) >= rbytes
        THEN    blokp = BLK(ADR(p)+rbytes);
            IF q > blokp
            THEN    blokp->word = p->word;
            FI
            p->word=BLK(Rcheat(blokp)|BUSY);
            return(ADR(p+1));
        FI
        FI
        q = p; p = BLK(Rcheat(p->word)&~BUSY);
    PER p>q ORF (c++)==0 DONE
    addblok(rbytes);
    POOL
}

Comments

दो बिंदु: एक, इस पेस्ट ने मूल इंडेंटेशन को गड़बड़ कर दिया। और दो, यह जो है, उसके लिए कोड ठीक दिखता है: 1970 के दशक में एक उग्र अल्गोल -68 प्रशंसक द्वारा यूनिक्स सी। अगर _ भाग्यशाली भाग्यशाली खुद को एक विचित्र शैली में व्यक्त कर सकता है, तो स्टीव बॉर्न क्यों नहीं कर सकते? बेशक, किसी ने इसे बनाए रखने के लिए निंदा की, जो अल्गोल 68 को नहीं जानता, अपने स्वयं के स्वाद को व्यापक बनाने के लिए इस अवसर की सराहना नहीं कर सकता है।

— डेरियस बेकन

मुझे लगता है कि यह स्टीव बॉर्न द्वारा एक सुझाए गए प्रोग्रामिंग शैली के बजाय एक मजाक के रूप में किया जा सकता है

— मार्टिन बेकेट

मैंने देखा है if... else... elif... fiऔर case... esacसे पहले (बहुत भाषा कि बॉर्न श के लिए आविष्कार में), लेकिन loop... poolएक असली मणि है।

— हॉब

Answer 12

मैं प्रतियोगिता के लिए अराजकता-पीपी नामक एक मणि प्रस्तुत करना चाहूंगा , जो प्रीप्रोसेसर मैक्रोज़ के माध्यम से एक कार्यात्मक भाषा को लागू करता है।

उदाहरणों में से एक पूरी तरह से प्रीप्रोसेसर द्वारा 500 वें रिट्रेसमेंट नंबर की गणना कर रहा है:

प्रीप्रोसेसर से पहले मूल कोड इस प्रकार दिखता है:

int main(void) {
   printf
     ("The 500th Fibonacci number is "
      ORDER_PP(8stringize(8to_lit(8fib(8nat(5,0,0)))))
      ".\n");
   return 0;
}

फ़ाइल प्राप्त करने के बाद हमें निम्न परिणाम मिलते हैं (एक लंबे इंतजार के बाद):

$ cpp -I../inc fibonacci.c 2>/dev/null | tail
  return fib_iter(n, 0, 1);
}
# 63 "fibonacci.c"
int main(void) {
   printf
     ("The 500th Fibonacci number is "
      "139423224561697880139724382870407283950070256587697307264108962948325571622863290691557658876222521294125"
      ".\n");
   return 0;
}

Comments

आप सीवीएस से कोड को पकड़ सकते हैं और देख सकते हैं। मैंने कुछ समय पहले अपने ब्लॉगपोस्ट में इसके बारे में कुछ और विवरण दिया था, जब मैंने इस पर ठोकर खाई: bnpcs.blogspot.com/2009/02/… यदि परिणामी कोड डिबगिंग के साथ समस्या के लिए नहीं है (यदि लंबी लाइनों के गले लगने की समस्या है तो वे इस तरह की "भाषा" से उत्पन्न होते हैं), यह सी के लिए एक व्यावहारिक कोड-जनरेटर के रूप में भी उपयोग करने योग्य हो सकता है

— एंड्रयू वाई

मैं सिर्फ कल्पना करने के लिए इसे हमेशा के लिए ले जाने की कल्पना कर सकता हूं

— पॉल फुल्ट्ज II

Answer 13

सीधे क्यूटी से:

#define slots   /* */
#define signals /* */

वास्तव में बढ़ावा देने के रूप में अन्य libs के साथ बातचीत करने के लिए अच्छा :: संकेत ... बस एक उदाहरण, Qt में कई अन्य हैं जो मज़ेदार दिखने वाले कोड बनाते हैं:

class X : public QObject {
   Q_OBJECT
private slots:
   //...
public signals:
   //...
};

और वह C ++ है ... लेकिन अचानक:

boost::signals::trackable

C ++ को मान्य नहीं है।

Comments

:) तो यह एक मैक्रो है जो अन्य पुस्तकालयों को कुछ नहीं के लिए तोड़ता है। यह मेरी अपेक्षा से भी बेहतर है :)

— डेविड रॉड्रिग्ज -

Qt बहुत प्रादेशिक है और

— शातिर रूप से

अफसोस की बात है कि

— मैक्रों

सौभाग्य से बढ़ावा :: संकेतों 2 ने इस मुद्दे को ठीक कर दिया है;)

— बोडलान

यदि आप इस सहभागिता से डरते हैं, तो Q_SIGNALS और Q_SLOTS का उपयोग करें।

— तदेउस्ज़ ए। कदलोबोस्की

Answer 14

Windows.h में बहुत सारे कार्य हैं जो मैक्रोज़ को गाली देते हैं।

---

MrValdez Windows.h में पाए जाने वाले GetObject मैक्रो से नाराज है

GetObject मैक्रो GetObjectA () फ़ंक्शन को GetObjectA () या GetObjectW () में परिवर्तित करता है (यदि निर्माण गैर-यूनिकोड और यूनिकोड में संकलित है, क्रमशः)

MrOaldez GetObject फ़ंक्शन लाइन से पहले करने से नफरत करता है

#undef GetObject

Object *GetObject()

वैकल्पिक कार्य GetGameObject () जैसे फ़ंक्शन का नाम कुछ और में बदलना है

---

टिप्पणियों में jdkoftinoff ने इसे nailed किया है: समस्या यह है कि सभी विंडोज़ एपीआई फ़ंक्शन मैक्रोज़ हैं।

एडम रोसेनफील्ड ने उल्लेख किया कि मुद्दों को हटाने के लिए windows.h सहित NOGDI, WIN32_LEAN_AND_MEAN, NOMINMAX, आदि को परिभाषित करके मुद्दों को ठीक किया जा सकता है।

Comments

आप windows.h को शामिल करने से पहले इसे # डिफाइन 'NOGDI' से दबा सकते हैं, बशर्ते कि आपको GDI के किसी भी फ़ंक्शंस का उपयोग करने की आवश्यकता न हो। अन्य मैक्रोज़ का एक गुच्छा है जैसे कि Win32_LEAN_AND_MEAN, NOMINMAX, आदि जो अन्य चीजों को परिभाषित या शामिल किए जाने से दबाते हैं।

— एडम रोसेनफील्ड

GetObject एक सुंदर जेनेरिक फ़ंक्शन नाम है। शायद आप टकराव से बचने के लिए संदर्भ को देखते हुए अधिक वर्णनात्मक नाम का उपयोग कर सकते थे। हालाँकि, यह एक बहुत बुरा मैक्रो मामला है।

— स्ट्रैजर

यह काफी कष्टप्रद है कि win32 में एपीआई नामों को फूआ और फूओ में परिवर्तित करने के लिए सभी मैक्रोज़ हैं। हमें SendMessage की समस्या है।

— i_am_jorf

समस्या यह है कि सभी विंडोज़ एपीआई फ़ंक्शन मैक्रोज़ हैं। एक वह बिट मुझे GetTickCount () था। चूंकि मैं अपनी अधिकांश प्रोग्रामिंग विंडोज़ के बाहर करता हूं, इसलिए मैंने विंडोज़ हेडर में सभी डिफाइन को पाया और फिर अपनी खुद की फाइल शामिल की, जिसने संगतता को पहले से सत्यापित करने के लिए उन सभी को परिभाषित किया।

— jdkoftinoff

मुझे लगता है कि हमारे पास एक विजेता है। यह वास्तविक दुनिया है, यह एक हास्यास्पद बुरा विचार है, और यह बड़ी संख्या में निर्दोष प्रोग्रामर को प्रभावित करता है। जो कोई भी Microsoft में इस रत्न के लिए ज़िम्मेदार है उसे युद्ध अपराधी माना जाना चाहिए ... सबसे अच्छी बात यह है कि Microsoft ने GetObject, SendMessage या CreateWindow जैसे आश्चर्यजनक रूप से सामान्य नामों का उपयोग करने के बारे में दो बार नहीं सोचा।

— जलफ

Answer 15

#define return if (std::random(1000) < 2) throw std::exception(); else return

यह सिर्फ इतनी बुराई है। यह यादृच्छिक है, जिसका अर्थ है कि यह हर समय अलग-अलग स्थानों में आग लगाता है, यह रिटर्न स्टेटमेंट में बदलाव करता है, जो आमतौर पर इस पर कुछ कोड होता है जो सभी के द्वारा विफल हो सकता है, यह निर्दोष दिखने वाले कीवर्ड को बदल देता है जिसे आपको कभी भी संदेह नहीं होगा और इसका उपयोग करता है एसटीडी स्पेस से अपवाद तो आप अपने स्रोतों के माध्यम से खोजने की कोशिश नहीं करेंगे कि यह स्रोत है बस शानदार।

Comments

बस इस एक का परीक्षण किया है, कम से कम यह एक यादृच्छिक के लिए एक लापता शामिल की वजह से डिफ़ॉल्ट रूप से संकलित नहीं करता है, और फिर यह लाल-स्क्विगल्ड है। यदि आपके पास दुर्घटना में शामिल है, हालांकि, चीजें खराब हो जाती हैं - VC ++ 2010 यह अभी भी एक कीवर्ड के रूप में चिह्नित करता है और मैक्रो विस्तार टूलटिप नहीं दिखाता है, इसलिए इसे खोजने के लिए IDE की कोई मदद नहीं: - /

— ओरेगॉन्ग

मुझे यह पसंद है! प्रतिभाशाली। कल्पना कीजिए कि जब आप "डिबग" कर सकते हैं तो यह कितना अच्छा लग सकता है जब यह एप्लिकेशन किसी और ने प्रबंधित नहीं किया हो।

— ब्राईस

Answer 16

एक सहकर्मी और मुझे ऑब्जेक्ट स्ट्रीमिंग के लिए हमारे कुछ कोड में ये दो रत्न मिले। इन मैक्रोज़ को कभी-कभी स्ट्रीमिंग करने वाले हर व्यक्ति वर्ग फ़ाइल में त्वरित किया गया था। इतना ही नहीं हमारे कोड बेस पर यह सब छिपा हुआ है, जब हमने इसके बारे में मूल लेखक से संपर्क किया, तो उन्होंने हमारे आंतरिक विकि पर एक 7 पेज का लेख लिखा, जो इसे यहाँ करने का प्रयास कर रहा था।

कहने की जरूरत नहीं है, यह तब से हटा दिया गया है और अब हमारे कोड आधार में उपयोग नहीं किया जाता है।

हाइलाइट किए गए कीवर्ड द्वारा फेंके नहीं जाएं। यह सभी एक मैक्रो है

#define DECLARE_MODIFICATION_REQUEST_PACKET( T )                                                \
namespace NameSpace                                                                     \
{                                                                                       \
                                                                                        \
class T##ElementModificationRequestPacket;                                                          \
}                                                                                       \
                                                                                        \
DECLARE_STREAMING_TEMPLATES( IMPEXP_COMMON_TEMPLATE_DECLARE, NameSpace::ElementModificationRequestPacket<T>, OtherNameSpace::NetPacketBase )    \
DLLIMPEXP_COMMON_TEMPLATE_DECLARE( NameSpace::ElementModificationRequestPacket<T> )     \
DECLARE_AUTOGENERATION_TEMPLATES( DLLIMPEXP_COMMON_TEMPLATE_DECLARE, NameSpace::T##ModificationRequestPacket, NameSpace::ElementModificationRequestPacket<T> )      \
                                                                                        \
namespace NameSpace {                                                                   \
class DLLIMPEXP_COMMON T##ModificationRequestPacket : public ElementModificationRequestPacket<T>\
{                                                                                       \
public:                                                                                 \
    T##ModificationRequestPacket( NetBase * pParent )                                   \
    : ElementModificationRequestPacket<T>( pParent ), m_Gen() {}                            \
                                                                                        \
    T##ModificationRequestPacket( NetBase * pParent,                                    \
                            Action          eAction,                                    \
                            const T &   rT )                                            \
    : ElementModificationRequestPacket<T>( pParent, eAction, rT ), m_Gen() {}               \
                                                                                        \
    T##ModificationRequestPacket( const T##ModificationRequestPacket & rhs )                        \
    : ElementModificationRequestPacket<T>( rhs ), m_Gen() {}                                \
                                                                                        \
    virtual                     ~T##ModificationRequestPacket( void ) {}                        \
                                                                                        \
    virtual Uint32          GetPacketTypeID( void ) const                           \
    {                                                                                   \
        return Net::T##_Modification_REQUEST_PACKET;                                        \
    }                                                                                   \
                                                                                        \
    virtual OtherNameSpace::ClassID GetClassID ( void ) const                           \
    {                                                                                   \
        return OtherNameSpace::NetBase::GenerateHeader( OtherNameSpace::ID__LICENSING,  \
                                                         Net::T##_Modification_REQUEST_PACKET );    \
    }                                                                                   \
                                                                                        \
    virtual T##ModificationRequestPacket * Create( void ) const                             \
    { return new T##ModificationRequestPacket( m_pParent ); }                                   \
                                                                                        \
    T##ModificationRequestPacket() {}                                                           \
                                                                                        \
protected:                                                                              \
    OtherNameSpace::ObjectAutogeneration<T##ModificationRequestPacket> m_Gen;                       \
                                                                                        \
    friend class OtherNameSpace::StreamingBase::StreamingClassInfoT<T##ModificationRequestPacket >;                     \
    OtherNameSpace::StreamingBase::Streaming<T##ModificationRequestPacket, ElementModificationRequestPacket<T> >    m_Stream;   \
                                                                                        \
};                                                                                      \
}                                                                                       \
DLLIMPEXP_COMMON_TEMPLATE_DECLARE( ThirdNameSpace::ListenerBase<const NameSpace::T##ModificationRequestPacket> )            \
DLLIMPEXP_COMMON_TEMPLATE_DECLARE( ThirdNameSpace::BroadcasterT<const NameSpace::T##ModificationRequestPacket> )            \
typedef  ThirdNameSpace::BroadcasterT<const T##ModificationRequestPacket>  T##ModifiedBroadcaster;



#define IMPLEMENT_MODIFICATION_REQUEST_PACKET( T )                                                                  \
DLLIMPEXP_COMMON_TEMPLATE_INSTANTIATE( NameSpace::ElementModificationRequestPacket<T> )                         \
DLLIMPEXP_COMMON_TEMPLATE_INSTANTIATE( ThirdNameSpace::ListenerBase<const NameSpace::T##ModificationRequestPacket> )        \
DLLIMPEXP_COMMON_TEMPLATE_INSTANTIATE( ThirdNameSpace::BroadcasterT<const NameSpace::T##ModificationRequestPacket> )        \
INSTANTIATE_STREAMING_TEMPLATES( DLLIMPEXP_COMMON_TEMPLATE_INSTANTIATE, NameSpace::ElementModificationRequestPacket<T>, OtherNameSpace::NetPacketBase ) \
INSTANTIATE_AUTOGENERATION_TEMPLATES( DLLIMPEXP_COMMON_TEMPLATE_INSTANTIATE, NameSpace::T##ModificationRequestPacket, NameSpace::ElementModificationRequestPacket<T> )

---

अपडेट (17 दिसंबर, 2009):

इस घृणित मैक्रो लेखक के बारे में अधिक अच्छी खबर। अगस्त तक, इस राक्षसी के लिए जिम्मेदार कर्मचारी को बर्खास्त कर दिया गया था।

Comments

उन्होंने स्पष्ट रूप से कभी नहीं सुना: "डिबगिंग पहली जगह में कोड लिखने के रूप में दोगुना कठिन है। इसलिए, यदि आप कोड को यथासंभव चतुराई से लिखते हैं, तो आप परिभाषा के अनुसार हैं, इसे डिबग करने के लिए पर्याप्त स्मार्ट नहीं हैं।" -ब्रायन डब्ल्यू कर्निघन

— ट्रेवर बॉयड स्मिथ

Answer 17

मैंने स्वयं निम्नलिखित कार्य किया, और मुझे लगता है कि मैंने इससे कुछ सीखा।

1992 या इसके बाद मैंने एक छोटा लिस्प दुभाषिया लिखा। इसे सामान्य सी में लागू नहीं किया गया था, लेकिन सी-लाइक भाषा में व्याख्या की गई थी। इस सी-लाइक लैंग्वेज में हालांकि स्टैंडर्ड C प्री-प्रोसेसर का इस्तेमाल किया गया था।

लिस्प दुभाषिया में फ़ंक्शंस कार शामिल थी , जिसका उपयोग लिस्प में लिस्ट में पहले तत्व को वापस करने के लिए किया जाता है, और सीडीआर , जो बाकी की सूची में वापस आ जाता है। उन्हें इस तरह लागू किया गया था:

LISPID car(LISPID id) {
    CHECK_CONS("car", 1, id);
    return cons_cars[id - CONS_OFFSET];
} /* car */

LISPID cdr(LISPID id) {
    CHECK_CONS("cdr", 1, id);
    return cons_cdrs[id - CONS_OFFSET];
} /* cdr */

(डेटा सरणियों में संग्रहीत किया गया था, क्योंकि कोई संरचना नहीं थी। CONS_OFFSET निरंतर 1000 है।)

कार और cdr का उपयोग लिस्प में अक्सर किया जाता है, और ये कम होते हैं, और चूंकि फ़ंक्शन कॉल कार्यान्वयन भाषा में बहुत तेज़ नहीं थे, इसलिए मैंने मैक्रोज़ के रूप में उन दो लिस्प कार्यों को लागू करके अपने कोड को अनुकूलित किया:

#define car(id) (CHECK_CONS("car", 1, (id)), cons_cars[(id) - CONS_OFFSET])
#define cdr(id) (CHECK_CONS("car", 1, (id)), cons_cdrs[(id) - CONS_OFFSET])

CHECK_CONS यह जाँचता है कि इसका तर्क वास्तव में एक सूची है, और चूँकि एक का उपयोग दुभाषिया में अक्सर किया जाता है, और संक्षिप्त रूप से, मैंने लिखा है कि एक भी एक स्थूल के रूप में:

#define CHECK_CONS(fun, pos, arg)   \
    (!IS_CONS(arg) ?        \
        LISP_ERROR("Arg " + pos + " to " + fun +    \
                   " must be a list: " + lispid2string(arg)) : 0)

IS_CONS और LISP_ERROR भी अक्सर उपयोग किए जाते थे, इसलिए मैंने उन्हें मैक्रोज़ में भी बनाया:

#define IS_CONS(id) \
    (   intp(id) && (id) >= CONS_OFFSET     \
     && ((id) - CONS_OFFSET) < sizeof(cons_cars))

#define LISP_ERROR(str)     (throw((str) + "\n"))

उचित लगता है?

लेकिन फिर, पूरी प्रणाली इस लाइन पर दुर्घटनाग्रस्त क्यों हुई:

id2 = car(car(car(car((id1))));

मैंने समस्या को खोजने के लिए एक लंबा समय काम किया, जब तक कि मैंने अंत में यह नहीं जांचा कि प्री-प्रोसेसर द्वारा उस छोटी लाइन का विस्तार क्या था। इसे 31370-वर्ण रेखा तक विस्तारित किया गया था, जिसे मैंने यहाँ स्पष्टता के लिए लाइनों (उनमें से 502) में विभाजित किया है:

id2 = ((!(intp( (((!(intp( (((!(intp( (((!(intp( (id1)) && (
(id1)) >= 1000 && (( (id1)) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (id1))) + "\n")) : 0), cons_cars[(id1) - 1000])))
&& ( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) >= 1000 && (( (((!(intp( (id1)) && (
(id1)) >= 1000 && (( (id1)) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (id1))) + "\n")) : 0), cons_cars[(id1) - 1000]))) -
1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" +
" must be a list: " + lispid2string( (((!(intp( (id1)) && ( (id1))
>= 1000 && (( (id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg "
+ 1 + " to " + "car" + " must be a list: " + lispid2string(
(id1))) + "\n")) : 0), cons_cars[(id1) - 1000])))) + "\n")) : 0),
cons_cars[(((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1)) -
1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" +
" must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])) - 1000]))) && ( (((!(intp( (((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) && ( (((!(intp( (id1)) && ( (id1)) >=
1000 && (( (id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg " +
1 + " to " + "car" + " must be a list: " + lispid2string( (id1)))
+ "\n")) : 0), cons_cars[(id1) - 1000]))) >= 1000 && (( (((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1))
- 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car"
+ " must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])))) + "\n")) : 0), cons_cars[(((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])) - 1000]))) >= 1000 && (( (((!(intp(
(((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) && ( (((!(intp( (id1)) && ( (id1)) >=
1000 && (( (id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg " +
1 + " to " + "car" + " must be a list: " + lispid2string( (id1)))
+ "\n")) : 0), cons_cars[(id1) - 1000]))) >= 1000 && (( (((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1))
- 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car"
+ " must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])))) + "\n")) : 0), cons_cars[(((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])) - 1000]))) - 1000) < sizeof(cons_cars))
? (throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (((!(intp( (((!(intp( (id1)) && ( (id1)) >= 1000 &&
(( (id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to
" + "car" + " must be a list: " + lispid2string( (id1))) + "\n"))
: 0), cons_cars[(id1) - 1000]))) && ( (((!(intp( (id1)) && (
(id1)) >= 1000 && (( (id1)) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (id1))) + "\n")) : 0), cons_cars[(id1) - 1000])))
>= 1000 && (( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1)) -
1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" +
" must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1))
- 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car"
+ " must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])))) + "\n")) : 0), cons_cars[(((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])) - 1000])))) + "\n")) : 0),
cons_cars[(((!(intp( (((!(intp( (id1)) && ( (id1)) >= 1000 && ((
(id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to "
+ "car" + " must be a list: " + lispid2string( (id1))) + "\n")) :
0), cons_cars[(id1) - 1000]))) && ( (((!(intp( (id1)) && ( (id1))
>= 1000 && (( (id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg "
+ 1 + " to " + "car" + " must be a list: " + lispid2string(
(id1))) + "\n")) : 0), cons_cars[(id1) - 1000]))) >= 1000 && ((
(((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1))
- 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car"
+ " must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])))) + "\n")) : 0), cons_cars[(((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])) - 1000])) - 1000]))) && ( (((!(intp(
(((!(intp( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1)) -
1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" +
" must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) && ( (((!(intp( (id1)) && ( (id1)) >=
1000 && (( (id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg " +
1 + " to " + "car" + " must be a list: " + lispid2string( (id1)))
+ "\n")) : 0), cons_cars[(id1) - 1000]))) >= 1000 && (( (((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1))
- 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car"
+ " must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])))) + "\n")) : 0), cons_cars[(((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])) - 1000]))) && ( (((!(intp( (((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) && ( (((!(intp( (id1)) && ( (id1)) >=
1000 && (( (id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg " +
1 + " to " + "car" + " must be a list: " + lispid2string( (id1)))
+ "\n")) : 0), cons_cars[(id1) - 1000]))) >= 1000 && (( (((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1))
- 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car"
+ " must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])))) + "\n")) : 0), cons_cars[(((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])) - 1000]))) >= 1000 && (( (((!(intp(
(((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) && ( (((!(intp( (id1)) && ( (id1)) >=
1000 && (( (id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg " +
1 + " to " + "car" + " must be a list: " + lispid2string( (id1)))
+ "\n")) : 0), cons_cars[(id1) - 1000]))) >= 1000 && (( (((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1))
- 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car"
+ " must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])))) + "\n")) : 0), cons_cars[(((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])) - 1000]))) - 1000) < sizeof(cons_cars))
? (throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (((!(intp( (((!(intp( (id1)) && ( (id1)) >= 1000 &&
(( (id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to
" + "car" + " must be a list: " + lispid2string( (id1))) + "\n"))
: 0), cons_cars[(id1) - 1000]))) && ( (((!(intp( (id1)) && (
(id1)) >= 1000 && (( (id1)) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (id1))) + "\n")) : 0), cons_cars[(id1) - 1000])))
>= 1000 && (( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1)) -
1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" +
" must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1))
- 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car"
+ " must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])))) + "\n")) : 0), cons_cars[(((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])) - 1000])))) + "\n")) : 0),
cons_cars[(((!(intp( (((!(intp( (id1)) && ( (id1)) >= 1000 && ((
(id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to "
+ "car" + " must be a list: " + lispid2string( (id1))) + "\n")) :
0), cons_cars[(id1) - 1000]))) && ( (((!(intp( (id1)) && ( (id1))
>= 1000 && (( (id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg "
+ 1 + " to " + "car" + " must be a list: " + lispid2string(
(id1))) + "\n")) : 0), cons_cars[(id1) - 1000]))) >= 1000 && ((
(((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1))
- 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car"
+ " must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])))) + "\n")) : 0), cons_cars[(((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])) - 1000])) - 1000]))) >= 1000 && ((
(((!(intp( (((!(intp( (((!(intp( (id1)) && ( (id1)) >= 1000 && ((
(id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to "
+ "car" + " must be a list: " + lispid2string( (id1))) + "\n")) :
0), cons_cars[(id1) - 1000]))) && ( (((!(intp( (id1)) && ( (id1))
>= 1000 && (( (id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg "
+ 1 + " to " + "car" + " must be a list: " + lispid2string(
(id1))) + "\n")) : 0), cons_cars[(id1) - 1000]))) >= 1000 && ((
(((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1))
- 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car"
+ " must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])))) + "\n")) : 0), cons_cars[(((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])) - 1000]))) && ( (((!(intp( (((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) && ( (((!(intp( (id1)) && ( (id1)) >=
1000 && (( (id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg " +
1 + " to " + "car" + " must be a list: " + lispid2string( (id1)))
+ "\n")) : 0), cons_cars[(id1) - 1000]))) >= 1000 && (( (((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1))
- 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car"
+ " must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])))) + "\n")) : 0), cons_cars[(((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])) - 1000]))) >= 1000 && (( (((!(intp(
(((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) && ( (((!(intp( (id1)) && ( (id1)) >=
1000 && (( (id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg " +
1 + " to " + "car" + " must be a list: " + lispid2string( (id1)))
+ "\n")) : 0), cons_cars[(id1) - 1000]))) >= 1000 && (( (((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1))
- 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car"
+ " must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])))) + "\n")) : 0), cons_cars[(((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])) - 1000]))) - 1000) < sizeof(cons_cars))
? (throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (((!(intp( (((!(intp( (id1)) && ( (id1)) >= 1000 &&
(( (id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to
" + "car" + " must be a list: " + lispid2string( (id1))) + "\n"))
: 0), cons_cars[(id1) - 1000]))) && ( (((!(intp( (id1)) && (
(id1)) >= 1000 && (( (id1)) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (id1))) + "\n")) : 0), cons_cars[(id1) - 1000])))
>= 1000 && (( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1)) -
1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" +
" must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1))
- 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car"
+ " must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])))) + "\n")) : 0), cons_cars[(((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])) - 1000])))) + "\n")) : 0),
cons_cars[(((!(intp( (((!(intp( (id1)) && ( (id1)) >= 1000 && ((
(id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to "
+ "car" + " must be a list: " + lispid2string( (id1))) + "\n")) :
0), cons_cars[(id1) - 1000]))) && ( (((!(intp( (id1)) && ( (id1))
>= 1000 && (( (id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg "
+ 1 + " to " + "car" + " must be a list: " + lispid2string(
(id1))) + "\n")) : 0), cons_cars[(id1) - 1000]))) >= 1000 && ((
(((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1))
- 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car"
+ " must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])))) + "\n")) : 0), cons_cars[(((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])) - 1000])) - 1000]))) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (((!(intp( (((!(intp( (((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) && ( (((!(intp( (id1)) && ( (id1)) >=
1000 && (( (id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg " +
1 + " to " + "car" + " must be a list: " + lispid2string( (id1)))
+ "\n")) : 0), cons_cars[(id1) - 1000]))) >= 1000 && (( (((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1))
- 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car"
+ " must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])))) + "\n")) : 0), cons_cars[(((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])) - 1000]))) && ( (((!(intp( (((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) && ( (((!(intp( (id1)) && ( (id1)) >=
1000 && (( (id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg " +
1 + " to " + "car" + " must be a list: " + lispid2string( (id1)))
+ "\n")) : 0), cons_cars[(id1) - 1000]))) >= 1000 && (( (((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1))
- 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car"
+ " must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])))) + "\n")) : 0), cons_cars[(((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])) - 1000]))) >= 1000 && (( (((!(intp(
(((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) && ( (((!(intp( (id1)) && ( (id1)) >=
1000 && (( (id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg " +
1 + " to " + "car" + " must be a list: " + lispid2string( (id1)))
+ "\n")) : 0), cons_cars[(id1) - 1000]))) >= 1000 && (( (((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1))
- 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car"
+ " must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])))) + "\n")) : 0), cons_cars[(((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])) - 1000]))) - 1000) < sizeof(cons_cars))
? (throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (((!(intp( (((!(intp( (id1)) && ( (id1)) >= 1000 &&
(( (id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to
" + "car" + " must be a list: " + lispid2string( (id1))) + "\n"))
: 0), cons_cars[(id1) - 1000]))) && ( (((!(intp( (id1)) && (
(id1)) >= 1000 && (( (id1)) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (id1))) + "\n")) : 0), cons_cars[(id1) - 1000])))
>= 1000 && (( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1)) -
1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" +
" must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1))
- 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car"
+ " must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])))) + "\n")) : 0), cons_cars[(((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])) - 1000])))) + "\n")) : 0),
cons_cars[(((!(intp( (((!(intp( (id1)) && ( (id1)) >= 1000 && ((
(id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to "
+ "car" + " must be a list: " + lispid2string( (id1))) + "\n")) :
0), cons_cars[(id1) - 1000]))) && ( (((!(intp( (id1)) && ( (id1))
>= 1000 && (( (id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg "
+ 1 + " to " + "car" + " must be a list: " + lispid2string(
(id1))) + "\n")) : 0), cons_cars[(id1) - 1000]))) >= 1000 && ((
(((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1))
- 1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car"
+ " must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])))) + "\n")) : 0), cons_cars[(((!(intp(
(id1)) && ( (id1)) >= 1000 && (( (id1)) - 1000) <
sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" + " must
be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000])) - 1000])) - 1000])))) + "\n")) : 0),
cons_cars[(((!(intp( (((!(intp( (((!(intp( (id1)) && ( (id1)) >=
1000 && (( (id1)) - 1000) < sizeof(cons_cars)) ? (throw(("Arg " +
1 + " to " + "car" + " must be a list: " + lispid2string( (id1)))
+ "\n")) : 0), cons_cars[(id1) - 1000]))) && ( (((!(intp( (id1))
&& ( (id1)) >= 1000 && (( (id1)) - 1000) < sizeof(cons_cars)) ?
(throw(("Arg " + 1 + " to " + "car" + " must be a list: " +
lispid2string( (id1))) + "\n")) : 0), cons_cars[(id1) - 1000])))
>= 1000 && (( (((!(intp( (id1)) && ( (id1)) >= 1000 && (( (id1)) -
1000) < sizeof(cons_cars)) ? (throw(("Arg " + 1 + " to " + "car" +
" must be a list: " + lispid2string( (id1))) + "\n")) : 0),
cons_cars[(id1) - 1000]))) - 1000) < sizeof(cons_cars))

Comments

I optimized my code by implementing those [..] functions as macros- प्रसिद्ध अंतिम शब्द ...

— ब्लूराजा - डैनी पफ्लुगुएट

मैंने अपनी पोस्टस्क्रिप्ट दुभाषिया के शुरुआती संस्करणों में इसी तरह की गालियां दीं। पुश और पॉप ऐसे कार्य थे जो इतने महत्वपूर्ण थे कि उन्हें मैक्रोज़ होना चाहिए । लेकिन इनमें से एक से अधिक शामिल अभिव्यक्ति की रचना करने से अपरिभाषित व्यवहार होता है। अनिर्धारित व्यवहार केवल -O3 को संकलित करते समय पकड़ा जाता है। और -O3 में फंक्शन वर्जन वैसे भी इनलेटेड होते।

— लूज़र ने

Answer 18

मुझे एक बार एक एप्लिकेशन को यूनिक्स से खिड़कियों तक पोर्ट करना पड़ा था, जिसकी विशिष्ट प्रकृति दोषियों की रक्षा के लिए अनाम रहेगी। जिस व्यक्ति ने इसे लिखा था, वह उत्पादन कोड लिखने के लिए बेहिचक एक प्रोफेसर था, और स्पष्ट रूप से सी से किसी अन्य भाषा में आया था। ऐसा भी होता है कि अंग्रेजी उनकी पहली भाषा नहीं थी, हालांकि वह जिस देश से आते हैं, वहां के लोग इसे काफी अच्छी तरह से बोलते हैं।

उनके आवेदन ने सी भाषा को एक प्रारूप में मोड़ने के लिए प्रीप्रोसेसर का भारी उपयोग किया जिसे वह बेहतर समझ सकता था। लेकिन जिस मैक्रो का उन्होंने सबसे ज्यादा इस्तेमाल किया, उसे 'थिंग.एच' (गंभीरता से) नाम की हेडर फाइल में परिभाषित किया गया, जिसमें निम्नलिखित शामिल थे:

#define I  Any void_me
#define thou  Any void_thee
#define iam(klas)  klas me = (klas) void_me
#define thouart(klas)  klas thee = (klas) void_thee
#define my  me ->
#define thy  thee ->
#define his  him ->
#define our  my methods ->
#define your  thy methods ->

... जो वह तब निम्न की तरह मठ लिखते थे:

void Thing_setName (I, const char *name) {
iam (Thing);
if (name != my name) {
    Melder_free (my name);
    my name = Melder_wcsdup (name);
    }
    our nameChanged (me);
}

void Thing_overrideClass (I, void *klas) {
iam (Thing);
my methods = (Thing_Table)klas;
if (! ((Thing_Table) klas) -> destroy)
    ((Thing_Table) klas) -> _initialize (klas);
}

पूरी परियोजना (~ 60,000 एलओसी) एक समान शैली में लिखी गई थी - मार्को नरक, अजीब नाम, ओल्डे-इंग्लिश शब्दजाल, आदि। सौभाग्य से हम एक ओएसएस पुस्तकालय पाए जाने के बाद से कोड को फेंकने में सक्षम थे जो समान एल्गोरिथ्म दर्जनों का प्रदर्शन करते थे। समय की तेजी से।

(मैंने इस उत्तर को कॉपी और एडिट किया है जो मैंने मूल रूप से इस प्रश्न पर बनाया है )।

Comments

मैं बल्कि सभी के पास अंग्रेजी और पुरातन अंग्रेजी से मंत्रमुग्ध हूं, बेशक मैं सहमत हूं कि कोड भयानक लगता है।

— डेरियस बेकन

Answer 19

मेरे द्वारा कभी भी सबसे खराब स्थिति में एक उत्पाद में निष्पादन योग्य का एक सूट था जिसमें नामित तकनीकी नेता ने पुस्तकालयों का पता नहीं लगाया था।

इसके बजाय, उसके पास कई विजुअल सोर्स सेफ फोल्डरों में साझा की गई फाइलों के सेट थे। तब उन्हें एहसास हुआ कि उन्हें प्रत्येक एप्लिकेशन के लिए थोड़ा अलग व्यवहार करने की आवश्यकता है।

आपके द्वारा यहां लागू किए जा सकने वाले कई रिफ्लैक्टिंग चरण हैं

इसके बजाय, उन्होंने #ifdefs का उपयोग किया

   void DisplayLoadError()
   {
   #if defined __TIMETABLE_EDITOR
   MessageBox("Timetable Editor failed to load the correct timetable", MB_ERROR);
   #else if defined __SCHEDULESET_EDITOR
   MessageBox("Schedule Set Editor faied to load the correct Schedule Set", MB_ERROR);
   #else if defined __ROSTER_EDITOR
   MessageBox("Roster Editor failed to load the correct Roster", MB_ERROR);
   #endif
   }

Answer 20

नेटवर्क पर पारित संदेशों के लिए विशिष्ट आईडी बनाने के लिए LINE प्रीप्रोसेसर का उपयोग:

NetworkMessages.h

#define MSG_LOGIN  __LINE__
#define MSG_LOGOUT __LINE__
#define MSG_CHAT   __LINE__

यह एक उदाहरण है जहां मैक्रो वास्तव में एक गैर-मैक्रो समाधान से बेहतर था:

एक गैर-मैक्रो समाधान कक्षाओं में, संदेश किस आईडी का ट्रैक रखता है, इसके लिए फ़ंक्शंस और वेरिएबल्स का निर्माण करना होता है। डेवलपर संदेश आईडी ट्रैकिंग को जटिल बना सकता है या नहीं कर सकता है जबकि यह पढ़ना और डीबग करना अधिक आसान है।

इसके अलावा, नए संदेश को केवल स्रोत में संदेश जोड़कर जोड़ना आसान है।

इस स्थिति का नुकसान यह है कि फ़ाइल को उन सभी कोड में शामिल करना होगा जो संदेशों का उपयोग करते हैं। जब भी कोई संदेश संपादित किया जाता है तो संकलन समय बढ़ जाता है।

Comments

और संस्करण एक दूसरे के साथ असंगत हो सकते हैं (अच्छा नहीं!)। कैसे एक एनम पर्याप्त नहीं आया?

— स्ट्रैजर

यह और एनम दोनों की असंगति की एक ही समस्या है।

— MrValdez

अब मैं साथ आता हूं और #defines को सॉर्ट करता हूं ... और प्रोटोकॉल बदलता है। या मुझे Doxygen धर्म मिलता है और सभी संदेश कोडों को दस्तावेज़ित करता है, और प्रोटोकॉल बदलता है। कम से कम एक एनुम बाद के बदलाव के तहत स्थिर है।

— RBerteig

@MrValdez, फाइल शुरू करने के लिए उसी तर्ज पर परिभाषित रखने की अपेक्षा, आदेशों के एक ब्लॉक को रखना कम प्रतिबंधात्मक है।

— पीटरचेन

मुझे पता है कि यह एक पुराना पोस्ट है, लेकिन क्या यह भी काम करता है? मेरा मतलब है कि #define केवल लाइन में संदेश स्थिरांक को बदल देगा और उसके बाद ही लाइन को लाइन नंबर तक विस्तारित किया जाएगा, इसलिए हर बार जब हम विभिन्न लाइनों पर एक ही निरंतर का उपयोग करते हैं - तो यह बदल जाएगा (वर्तमान लाइन संख्या में)?

— XzKto

Answer 21

एक काफी बुरा उदाहरण:

#ifdef __cplusplus
#define class _vclass
#endif

यह एक C संरचना की अनुमति देता है जिसमें एक सदस्य चर होता है जिसे classC ++ कंपाइलर द्वारा नियंत्रित किया जाता है। इसमें निर्माण के साथ दो हेडर हैं; उनमें से एक में अंत में '#undef क्लास' भी है और दूसरा नहीं है।

Comments

यही कारण है कि @classइसके बजाय Objective-C का उपयोग होता है class।

Answer 22

इंटरनेशनल ओब्सेस्केटेड सी कोडिंग प्रतियोगिता के एक वर्ष में, एक प्रविष्टि थी जहाँ पूरा कार्यक्रम था:

P

अनंतिम के साथ जिसे आप परिभाषित कर सकते हैं P मेकफाइल में जो भी कार्यक्रम चाहिए था।

जैसा कि मुझे याद है, यह श्रेणियों में से एक में जीता था, और अगले साल एक नियम ने प्रवेश की उस शैली को अस्वीकार कर दिया था।

(संपादित करें: छह महीने बाद या कुछ और ... मुझे यकीन है कि "No IOCCC" चीज मुख्य प्रश्न में नहीं थी जब मैंने इसे लिखा था ...)

Answer 23

मैं एक दिन ऊब गया था और उद्देश्य-सी में ब्लॉक के साथ खेल रहा था ...

#define Lambda(var, body) [^ id(id (var)) { return (body);} copy]
#define Call(f, arg) ((id(^)(id))(f))(arg)
#define Int(num) [NSNumber numberWithInteger:(num)]
#define Mult(a, b) Int([(a) integerValue] * [(b) integerValue])
#define Add(a, b) Int([(a) integerValue] + [(b) integerValue])
#define Sub1(n) Int([(n) integerValue] - 1)
#define Add1(n) Int([(n) integerValue] + 1)
#define If(cond, thenblock, elseblock) ([(cond) integerValue] ? (thenblock) : (elseblock))
#define Cons(car, cdr_) [[ConsType alloc] initWithCar:(car) cdr:(cdr_)]
#define Car(list) [(list) car]
#define Cdr(list) [(list) cdr]
#define Define(var, value) id var = (value)
#define Nullq(value) Int(value == nil)

"दिलचस्प" चीजों की अनुमति देना:

Define(Y, Lambda(f, Call(Lambda(x, Call(x, x)),
                         Lambda(x, Call(f, Lambda(y, Call(Call(x, x), y)))))));
Define(AlmostTotal, Lambda(f, Lambda(list, If(Nullq(list), Int(0),
                                              Add(Car(list), Call(f, Cdr(list)))))));
Define(Total, Call(Y, AlmostTotal));
Print(Call(Total, Cons(Int(4), Cons(Int(5), Cons(Int(8), nil)))));

(कुछ फ़ंक्शन और वर्ग परिभाषाएँ संक्षिप्तता के लिए नहीं दिखाई गई हैं)

Comments

"मैं एक दिन बोर हो गया था" प्रसिद्ध डेवलपर अंतिम शब्द :)

— रिचर्ड जे। रॉस III

Answer 24

मैंने जो सबसे बुरा देखा वो था गैर-उपयोग :-)

किसी ने एक strcpy लिखा (मुझे लगता है कि यह था ... अब से 10 साल पहले) एक विधि के अंदर कार्य करता है (क्योंकि वे strcpy कॉल करने के ओवरहेड नहीं चाहते थे ... आह)।

उन्होंने कहा कि यह जापानी पात्रों के लिए काम नहीं करेगा, इसलिए उन्होंने ASCII या यूनिकोड करने के लिए शुरुआत में "अगर" जोड़ा। उस बिंदु पर कोड एक स्क्रीन के बारे में था ... संभवतः कैश सुसंगतता को मारना और कोड की इनलाइनिंग के लिए उसकी कथित बचत को मिटा देना।

कोड समान प्रकारों के लिए सहेजा गया था (इसलिए मैक्रो का उपयोग करना चाहिए था)।

बेशक, उन्होंने जो लिखा था, वह बहुत ज्यादा धीमा था जो कि ट्यून्डेड असेंबलर से एक था जो मानक पुस्तकालय में था ...

बेशक अगर वे सिर्फ एक मैक्रो के रूप में यह सब किया था यह एक कॉल के साथ बदला जा सकता था strcpy ...

निश्चित रूप से मैंने कंपनी छोड़ दी (इसके कारण सीधे नहीं ...)

Comments

The code was identical save for the types (so should have used a macro).नहीं, उसे एक टेम्पलेट का उपयोग करना चाहिए था।

— ब्लूराजा - डैनी पफ्लुगुएफ्ट

उसे स्ट्रैची में निर्मित का उपयोग करना चाहिए था! (और यह C कोड था C ++ नहीं तो कोई टेम्पलेट नहीं) :-P

— TofuBeer

समयपूर्व अनुकूलन सभी बुराई की जड़ है।

— ह्यूबर्ट करियो

Answer 25

अनिवार्य

#define FOR  for

तथा

#define ONE  1
#define TWO  2
...

किसे पता था?

Comments

CODE में लेकिन-लेकिन-लेकिन नहीं साहित्यकारों! ;)

— बर्नार्ड

वे अभी भी शाब्दिक हैं, उन्हें उद्देश्य से नाम देना चाहिए / इरादा वैकल्पिक प्रतीक नहीं। COBOL कोड के बारे में मैंने सुना है कि उन्होंने चर 5 = 5 बनाया था, बाद में कोड ने कहा कि 5 = 10 सेट करें ... वास्तविक लोग जहां वे + 5 करते थे और var + 10. मिला

— ग्रेग डोमजान

COBOL के बारे में कभी नहीं सुना, केवल FORTRAN के साथ। बेशक, शून्य, ZEROS, और शून्य आरक्षित शब्दों के रूप में है, उन सभी का अर्थ ठीक वैसा ही है जैसा कि 0.

— डेविड थोरले

"# वनफाइन वन 0" से बहुत बेहतर। यदि आप एक विशाल चाहते हैं, तो उसके लिए वेब पर खोज करें और गैर-शून्य संख्या हिट से आश्चर्यचकित हो जाएं।

— रूबेन

Answer 26

#define TRUE 0 // dumbass

ऐसा करने वाले व्यक्ति ने कुछ साल बाद खुद को समझाया - सबसे (यदि सभी नहीं) सी लाइब्रेरी फ़ंक्शन 0 को एक संकेत के रूप में वापस करते हैं कि सब कुछ ठीक हो गया। इसलिए, वह इस तरह कोड लिखना चाहता था:

if (memcpy(buffer, packet, BUFFER_SIZE) == TRUE) {
; // rape that packet
}

कहने की जरूरत नहीं है, हमारी टीम (परीक्षक या डेवलपर) में से किसी ने कभी भी उसके कोड को देखने की हिम्मत नहीं की।

Comments

मैं 0 "सब कुछ ठीक है" बनाने के लिए सी लाइब्रेरी के कार्यों को दोष देता हूं: पी

— आरसीआईएक्स

कुछ घोषित क्यों नहीं किया #define FLAG_SUCCESS 0?

— पियोन

Answer 27

मैं मैक्रों में कोड्स को बनाए रखता हूं। तो एक फ़ंक्शन के अंत में एक लेबल होगा लेकिन फ़ंक्शन कोड में कोई दृश्यमान गोटो नहीं होगा। मामले को बदतर बनाने के लिए मैक्रो अन्य बयानों के अंत में आम तौर पर स्क्रीन से दूर होता है जब तक कि आप क्षैतिज रूप से स्क्रॉल न करें।

#define CHECK_ERROR if (!SomeCondition) goto Cleanup

void SomeFunction() 
{ 
    SomeLongFunctionName(ParamOne, ParamTwo, ParamThree, ParamFour); CHECK_ERROR  
    //SomeOtherCode  
    Cleanup:    
   //Cleanup code  
}

Comments

क्या बुरा है जब मैक्रोज़ दोनों gotoबयानों के साथ-साथ लक्ष्य लेबल की परिभाषा भी छिपाते हैं। पूरी तरह से जादू।

— रूबेन

मैं उस से पीड़ित है - लेकिन मैक्रो फ़ंक्शन कॉल की तरह लग रहा था।

— जोनाथन लेफ़लर

Answer 28

#include <iostream>
#define public_static_void_main(x) int main()
#define System_out_println(x) std::cout << x << std::endl

public_static_void_main(String[] args) {
  System_out_println("Hello World!");
}

Comments

और आप एक रनटाइम लिखना चाहते थे। देखो मैंने कितना समय बचाया!

— बर्नार्ड

@ ट्रेवर: हाँ ... स्मार्ट वाले अभी भी जावा के बजाय कर रहे हैं। कवर के लिए चलाता है

— माइकल मायर्स

यदि आप पहले के बजाय args के बाद [] डालते हैं, और "#define स्ट्रिंग int argc, char *", तो यह (दुख की बात) संकलित करेगा।

— एडम रोसेनफील्ड

मुझे दूसरे अच्छे लगते हैं। यह कुछ जावा को कुछ मैक्रोज़ के साथ लिखे जाने के करीब दिखाता है। अन्य एक सटीक जावा दिखाता है जो स्नीकी मैक्रोज़ के ढेरों के साथ लिखा जा रहा है और फ़ंक्शन सदस्यों के साथ संरचना करता है। पहला एक सस्ता मजाक था, जबकि दूसरा एक विस्तृत और अच्छा-बुरा मजाक था।

— क्रिस लुत्ज़

Answer 29

एक सहपाठी द्वारा जो जादू की संख्या के बारे में नियमों को समझने में विफल रहा:
#define TWO_HUNDRED_AND_EIGHTY_THREE_POINT_ONE 283.1

Answer 30

एएसए - http://www.ingber.com/#ASA

आपको वास्तव में इसकी सराहना करने के लिए इसे डाउनलोड करना होगा। संपूर्ण कार्य प्रवाह मैक्रोज़ द्वारा निर्धारित किया जाता है। यह पूरी तरह से अपठनीय है। उदहारण के लिए -

 if (asa_open == FALSE) {
asa_open = TRUE;
++number_asa_open;
#if ASA_PRINT
if (number_asa_open == 1) {
  /* open the output file */
#if USER_ASA_OUT
  if (!strcmp (OPTIONS->Asa_Out_File, "STDOUT")) {
#if INCL_STDOUT
    ptr_asa_out = stdout;
#endif /* INCL_STDOUT */
  } else {
#if ASA_SAVE
    ptr_asa_out = fopen (OPTIONS->Asa_Out_File, "a");
#else
    ptr_asa_out = fopen (OPTIONS->Asa_Out_File, "w");
#endif
  }
#else /* USER_ASA_OUT */
  if (!strcmp (ASA_OUT, "STDOUT")) {
#if INCL_STDOUT
    ptr_asa_out = stdout;
#endif /* INCL_STDOUT */
  } else {
#if ASA_SAVE
    ptr_asa_out = fopen (ASA_OUT, "a");
#else
    ptr_asa_out = fopen (ASA_OUT, "w");
#endif
  }
#endif /* USER_ASA_OUT */
} else {
#if USER_ASA_OUT
  if (!strcmp (OPTIONS->Asa_Out_File, "STDOUT")) {
#if INCL_STDOUT
    ptr_asa_out = stdout;
#endif /* INCL_STDOUT */
  } else {
    ptr_asa_out = fopen (OPTIONS->Asa_Out_File, "a");
  }
#else
  if (!strcmp (ASA_OUT, "STDOUT")) {
#if INCL_STDOUT
    ptr_asa_out = stdout;
#endif /* INCL_STDOUT */
  } else {
    ptr_asa_out = fopen (ASA_OUT, "a");
  }
#endif
  fprintf (ptr_asa_out, "\n\n\t\t number_asa_open = %d\n",
           number_asa_open);
}
#endif /* ASA_PRINT */
} else {
++recursive_asa_open;
#if ASA_PRINT
if (recursive_asa_open == 1) {
  /* open the output file */
#if ASA_SAVE
#if USER_ASA_OUT
  if (!strcmp (OPTIONS->Asa_Out_File, "STDOUT")) {
#if INCL_STDOUT
    ptr_asa_out = stdout;
#endif /* INCL_STDOUT */
  } else {
    ptr_asa_out = fopen (OPTIONS->Asa_Out_File, "a");
  }
#else
  if (!strcmp (ASA_OUT, "STDOUT")) {
#if INCL_STDOUT
    ptr_asa_out = stdout;
#endif /* INCL_STDOUT */
  } else {
    ptr_asa_out = fopen (ASA_OUT, "a");
  }
#endif
#else /* ASA_SAVE */
#if USER_ASA_OUT
  if (!strcmp (OPTIONS->Asa_Out_File, "STDOUT")) {
#if INCL_STDOUT
    ptr_asa_out = stdout;
#endif /* INCL_STDOUT */
  } else {

आदि आदि।

और वह सिर्फ विकल्प स्थापित कर रहा है। पूरा कार्यक्रम ऐसा है।

Comments

हे भगवान ... मुझे लगता है कि मुझे चक्कर आ रहा है।

— माइकल फौकरकिस