您遇到过的最糟糕的真实世界宏/预处理器滥用情况是什么？

Question

您遇到过的最糟糕的真实世界宏/预处理器滥用情况是什么？

Tre*_*ith 176 c c++ macros preprocessor

您遇到的最糟糕的 现实世界宏/预处理器滥用是什么(请不要设想IOCCC答案*哈哈*)？

如果它真的很有趣,请添加一个简短的片段或故事.目标是教一些东西,而不是总是告诉人们"永远不要使用宏".

ps:之前我曾经使用过宏...但是当我有一个"真正的"解决方案时,我最终会摆脱它们(即使真正的解决方案是内联的,它也会变得类似于宏).

额外:举一个例子,宏实际上比非宏解决方案更好.

相关问题: C++宏什么时候有用？

Answer 1

小智 410

从内存来看,它看起来像这样:

#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)

Run Code Online (Sandbox Code Playgroud)

是的,没有关闭任何功能的括号.语法高亮是一团糟,所以他用vi编辑(不是vim,它有语法着色!)

他是一名俄罗斯程序员,主要从事汇编语言工作.他很想保存尽可能多的字节,因为他之前曾在内存非常有限的系统上工作过."它用于卫星.只有非常少的字节,因此我们将每个字节用于许多事情." (比特摆弄,重复使用机器指令字节的数值)当我试图找出什么样的卫星时,我只能得到"轨道卫星.用于制造轨道."

他还有另外两个怪癖:一个凸面镜子安装在他的显示器上方"为了知道谁在看",偶尔突然从椅子上退出,快速做十次俯卧撑.他将最后一个解释为"编译器在代码中发现错误.这是惩罚".

在苏联俄罗斯,程序编译你! (227认同)
我认为如果我们在每次编译器在代码中发现错误时都进行了10次俯卧撑,那么程序员(包括我自己)会更合适.这也可能通过编译减少测试的发生. (124认同)
"编译器在代码中发现错误.这是惩罚".!公司发现你......对同事的惩罚! (87认同)
当我读到编译器错误"惩罚"时,我想到的第一件事是"多比必须熨烫他的手". (53认同)
每次我看这段代码,我都认为它是Python (34认同)
那家伙听起来很棒.但是,我没有看到这应该如何改善代码大小. (5认同)
ROFL - 需要记住镜像技巧:) (4认同)
任何机会都是他的名字皮尔？ (4认同)
我可以向你保证,那个人不是典型的俄罗斯程序员.我们*REAL*俄罗斯程序员倾向于用壶铃练习和(偶尔)用马蹄弯曲来惩罚自己(虽然它被认为更像是建筑师的东西):)) (4认同)
你在扩展中错过了关键字'return'吗？我想我希望这个恐怖是'#define RETURN(x)return(x);}'. (3认同)
@MikeyB,我同意健身,但与此同时,我只是*喜欢*"通过汇编测试." 为什么我们应该做什么机器可以做得更好？ (3认同)
我的眼睛!护目镜什么都不做! (3认同)
@mlvljr:Whimp!任何人都可以弯曲马蹄,我们爱尔兰程序员STRAIGHTEN马蹄铁! (3认同)
Bu- Wai-谁 - .那是正面的. (2认同)
真棒.我遇到过那样的俄罗斯程序员. (2认同)

Answer 2

i_a*_*orf 274

我最坏的:

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

Run Code Online (Sandbox Code Playgroud)

我花了两天时间追踪一些多线程COM引用计数问题,因为有些白痴把它放在头文件中.我不会提到我当时工作的公司.

这个故事的寓意？如果您不了解某些内容,请阅读文档并了解相关信息.不要只是让它消失.

@Joshua:如果你在多线程环境中运行这段代码,你可能会无意中这样做 (146认同)
问题是InterlockedIncrement*通常是*Windows API中定义的原子函数.因此,当人们调用InterlockedIncrement时,他们希望调用一个保证以原子方式执行的函数.相反,有人定义了一个具有相同名称的宏,该宏的计算结果为普通的非原子增量 (38认同)
"如果你不理解某些东西,请阅读文档并了解它.不要只是让它消失." - AMEN! (11认同)
请原谅我作为非C++程序员:这里的主要问题是线程安全函数是否被转换为非线程安全函数？或者InterlockedIncrement需要一个指针,所以现在你会增加指针而不是它指向的指针？或两者？ (5认同)
@ 1800信息:我认为你只会失去选票,这就是为什么我不能给你一个; p (2认同)

Answer 3

Joe*_*sky 166

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

Run Code Online (Sandbox Code Playgroud)

我更喜欢<#define forever for(;;)>所以你可以写<forever {...}> (52认同)
Pax的建议不是直接来自K&R吗？我还是说,不值得努力. (6认同)
它很聪明(tm)但我真的很喜欢它的读法. (2认同)

Answer 4

小智 145

#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!");
}

Run Code Online (Sandbox Code Playgroud)

挑战:任何人都可以用更少的定义和结构来做到这一点吗？;-)

那要么是美丽的,要么美丽可怕. (40认同)
@Mark - 它声明`public`和`static as nothing,`void`为`int`,`main(x)`为`main()`,所以`public static void main(String [] args)`turn进入`int main()`.然后`System`变成's s; s`,所以`System.out.println("Hello World!");`变成`S s; s.out.println("Hello World!");`在`S`结构中调用`F`结构中的`println`函数. (38认同)
报道称"冒犯".(我小孩!) (25认同)
你刚刚写了一个java-to-c转换器!horray! (19认同)
看看这个:http://www.mailcom.com/ioccc/chia/chia.c(下载并编译) (2认同)

Answer 5

And*_*ite 130

#define private public

Run Code Online (Sandbox Code Playgroud)

虽然对象设计的鬼魂会在晚上困扰你,但是对于单元测试来说这甚至可能是有用的. (30认同)
嗯,未定义的行为,容易违反单一定义规则,潜在的布局差异.是的,这是一个胜利者. (12认同)
所以,我可以访问私有和公共的东西,但不能访问受保护的东西,我无法访问`class`关键字和第一个访问修饰符之间的东西. (10认同)
@Ken:`#define class struct #define protected public` (3认同)

Answer 6

Mic*_*rty 107

#define if while

Run Code Online (Sandbox Code Playgroud)

这是对某人玩的笑话,受到影响的人并没有发现有趣

我总是喜欢#define sizeof(x)rand() (32认同)
#define而if会更加阴险. (22认同)
这是一个很好的恶作剧,但如果有任何"else"语句,它将无法编译.我发现#define if(x)if(true)是最有效的. (15认同)
我们应该澄清你的陈述.受影响的人*没有发现有趣*.:-) (7认同)
当我做家庭作业时,我经常故意做这种事情,只是为了惹恼我的老师. (6认同)

Answer 7

pax*_*blo 106

可怕的:

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

Run Code Online (Sandbox Code Playgroud)

说真的,如果你想在Pascal中编码,买一个Pascal编译器,不要破坏漂亮的C语言.

C不漂亮.这很难看. (47认同)
现在你让我想知道我能用聪明的头文件模拟哪些语言. (45认同)
它的美丽在于它的简洁.据说它具有汇编语言的所有速度与汇编语言的可读性相结合:-)我更喜欢它而不是膨胀的C++(尽管我在日常工作中更喜欢Java,因为它的库很大). (27认同)
不完全是.查找Bourne的bourne shell原始源代码.他这样做是为了得到某种像ALGOL一样混蛋的混蛋. (9认同)
#define DO for(int _i = 0; _i <= 1; ++ _ i){if(_i == 1)//// LINE BREAK //// #define IF(cond); if(!(cond))休息; } //// LINE BREAK //// DO printf("a")IF(1 == 2); (3认同)

Answer 8

dcw*_*dcw 93

一个'建筑师',非常谦虚的家伙,你知道这种类型,有以下几点:

#define retrun return

Run Code Online (Sandbox Code Playgroud)

因为他喜欢快速打字.这位大脑外科医生曾经喜欢对比他聪明的人(这几乎是每个人)大声喊叫,并威胁要在他们身上使用黑带.

而是教你的编辑自动重新回归.我至少对我的IRC客户端做过这样的hackeries (4认同)
你不能只是打开一个新终端(或切换到另一个vt)并做`killall rn`？ (2认同)

Answer 9

xto*_*ofl 69

真实世界？MSVC在minmax.h中有宏,称为max和min,每次打算使用标准std::numeric_limits<T>::max()函数时都会导致编译器错误.

将NOMINMAX添加到C/C++ - >预处理器 - >预处理器定义下的项目属性中. (36认同)
这些宏存在于MS头中,长度超过min和max已经存在于C++标准库中. (18认同)
更糟糕的是,当你的其他四个外部依赖关系也定义了自己的最小值/最大值时,它们具有不同程度的可能性,从糟糕的括号内的宏到编写良好的模板,其中一个必须使其无法被定义或者以其他方式跳过这些...在我的书中,语言是50%的责任. (4认同)
解决了(std :: numeric_limits <T> :: max)()但是,非常讨厌. (3认同)
啊,是的,这就是为什么我有一个特殊的标题,恢复#undef后的MS特定标题... (2认同)

Answer 10

mou*_*iel 58

Pascal语法和法语关键字之间的混合:

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

Run Code Online (Sandbox Code Playgroud)

#define zut_alors退出(-1) (36认同)
这太棒了,它让我大笑起来.那么,这基本上是用C语言实现的Basic的本地化法语版本？ (4认同)

Answer 11

180*_*ION 56

Raymond Chen 对使用流控制宏有很好的帮助.他最好的例子是直接来自最初的Bourne shell源代码:

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
}

Run Code Online (Sandbox Code Playgroud)

两点:一,这个粘贴弄乱了原来的缩进.第二,代码看起来很好:20世纪70年代的Unix C是一个狂热的Algol-68粉丝.如果为什么幸运的僵硬可以用古怪的风格表达自己,为什么史蒂夫伯恩不能？当然,有人谴责维护不了解Algol 68的人可能不会理解这种扩大自己口味的机会. (2认同)
我以前见过`if` ...`else` ...`elif` ...`fi`和`case` ...`esac`(用Bourne为sh发明的语言),但是` loop` ...`pool`是一个真正的宝石. (2认同)

Answer 12

And*_*w Y 54

我想为比赛提交一个名为chaos-pp的gem ,它通过预处理器宏实现一种函数式语言.

其中一个例子是完全由预处理器计算第500个斐波那契数:

预处理器之前的原始代码如下所示:

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

Run Code Online (Sandbox Code Playgroud)

预处理文件我们得到以下结果(经过相当长的等待):

$ 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;
}

Run Code Online (Sandbox Code Playgroud)

我想看看宏 (3认同)

Answer 13

Dav*_*eas 52

直接来自Qt:

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

Run Code Online (Sandbox Code Playgroud)

真的很高兴与其他libs作为boost :: signals进行交互......举个例子,Qt中还有许多其他人可以创建有趣的代码,例如:

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

Run Code Online (Sandbox Code Playgroud)

这就是C++ ......但突然间:

boost::signals::trackable

Run Code Online (Sandbox Code Playgroud)

不再是有效的C++.

Qt非常具有领土性,会恶意攻击试图占据其命名空间的其他库:) (38认同)
遗憾的是,Qt使用宏攻击其命名空间之外的库 (21认同)
如果您害怕这种互动,请使用Q_SIGNALS和Q_SLOTS. (9认同)
幸运的是boost :: signals2修复了这个问题;) (7认同)
:)所以它是一个宏,打破其他库什么都没有.这甚至比我预期的要好:) (5认同)
由于Qt是一个非常大的框架,因此没有理由使用其他库,特别是boost :: signals.这些宏在使用Qt的代码中非常有意义.如果您不想要它们,只需禁用它们并使用Q_WHATEVER.根本不是问题. (2认同)

Answer 14

MrV*_*dez 50

Windows.h有很多滥用宏的函数.

MrValdez对Windows.h中的GetObject宏感到恼火

GetObject宏将GetObject()函数更改为GetObjectA()或GetObjectW()(取决于构建是否分别以非unicode和unicode编译)

MrValdez讨厌在GetObject功能行之前做的事情

#undef GetObject

Object *GetObject()

Run Code Online (Sandbox Code Playgroud)

另一种方法是将函数名称更改为GetGameObject()之类的其他名称

评论中的jdkoftinoff已经指出:问题是所有的Windows API函数都是宏.

Adam Rosenfield提到可以通过在包含windows.h来删除问题之前定义NOGDI,WIN32_LEAN_AND_MEAN,NOMINMAX等来解决问题.

我想我们有一个胜利者.这是现实世界,这是一个非常糟糕的主意,它影响了大量无辜的程序员.谁应该对微软的这个宝石负责谁应该被认为是一个战争罪犯...最好的部分是微软没有考虑使用像GetObject,SendMessage或CreateWindow这样惊人的常见名称. (12认同)
问题是所有的Windows API函数都是宏.咬我的是GetTickCount().由于我在windows之外编写了大部分编程,因此我在windows头文件中找到了所有的定义,然后创建了我自己的include文件,它们都预先确定了兼容性. (6认同)
你可以在包含windows.h之前对#nine'ing NOGDI进行抑制,但前提是你不需要使用任何各种GDI函数.还有许多其他宏,如WIN32_LEAN_AND_MEAN,NOMINMAX等,可以抑制其他内容的定义或包含. (3认同)

Answer 15

vav*_*ava 45

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

Run Code Online (Sandbox Code Playgroud)

这真是太邪恶了.它是随机的,这意味着它会一直在不同的地方触发,它会改变return语句,它通常会有一些代码可能会自动失败,它会改变无辜的关键字,你不会对它产生怀疑并使用它来自标准空间的异常,因此您不会尝试搜索您的来源以找到它的来源.太棒了

我怀疑制作它的人会把它带到代码审查. (4认同)
刚测试了这个,至少它默认不编译,因为随机丢失了包含,然后它是红色的.但是,如果你有意外包含,事情会变得更糟 - VC++ 2010将它标记为关键字并且不显示宏扩展工具提示,因此IDE没有帮助找到它: - / (4认同)

Answer 16

Gra*_*erg 36

一位同事和我在我们的一些代码流中发现了这两个宝石.这些宏在每个执行流式传输的SINGLE类文件中实例化.这个可怕的代码不仅遍布我们的代码库,当我们找到关于它的原始作者时,他在我们的内部维基上写了一篇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> )

Run Code Online (Sandbox Code Playgroud)

更新(2009年12月17日):

关于这个可怕的宏观作者的更多好消息.截至8月,负责这种怪物的员工被解雇了.

他显然从来没有听说过:"调试的难度是首先编写代码的两倍.因此,如果你尽可能巧妙地编写代码,那么根据定义,你不够聪明,无法调试它." -Brian W. Kernighan (3认同)

Answer 17

Tho*_*thy 33

I did the following myself, and I think I learned something from it.

In 1992 or so I wrote a small Lisp interpreter. It wasn't implemented in normal C, but in an interpreted C-like language. This C-like language used the standard C pre-processor, though.

The Lisp interpreter of course contained the functions car, which is used in Lisp to return the first element in a list, and cdr, which returns the rest of the list. They were implemented like this:

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 */

Run Code Online (Sandbox Code Playgroud)

(Data were stored in arrays, since there were no structs. CONS_OFFSET is the constant 1000.)

car and cdr are used frequently in Lisp, and are short, and since function calls weren't very fast in the implementation language, I optimized my code by implementing those two Lisp functions as macros:

#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])

Run Code Online (Sandbox Code Playgroud)

CHECK_CONS checks that its argument actually is a list, and since that one is also used frequently in the interpreter, and is short, I wrote that one too as a macro:

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

Run Code Online (Sandbox Code Playgroud)

IS_CONS and LISP_ERROR were also used frequently, so I made them into macros too:

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

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

Run Code Online (Sandbox Code Playgroud)

Seems reasonable?

But then, why did the entire system crash on this line:

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

Run Code Online (Sandbox Code Playgroud)

我花了很长时间才找到问题,直到我最终检查了预处理器扩展到的那条短线.它被扩展为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))

Run Code Online (Sandbox Code Playgroud)

`我通过将那些[..]函数实现为宏来优化我的代码` - 着名的最后一句话...... (18认同)
我在Postscript翻译的早期版本中犯了类似的滥用行为.推送和弹出是非常重要的功能,它们应该是宏*.但是编写涉及多个这些表达式的表达式会导致未定义的行为.仅在-O3处编译时才会捕获未定义的行为.而在-O3,函数版本无论如何都会被内联. (3认同)

Answer 18

Nik*_*man 29

我曾经不得不将一个C应用程序从unix移植到windows,其特定性质仍未命名以保护有罪.写这篇文章的人是一位不习惯编写生产代码的教授,而且很明显从其他语言来到C语言.英语不是他的第一语言,尽管他来自大多数人的国家说得很好.

他的应用程序大量使用预处理器将C语言扭曲成他可以更好理解的格式.但他最常用的宏是在名为'Thing.h'的头文件中定义的(严重),其中包括以下内容:

#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 ->

Run Code Online (Sandbox Code Playgroud)

...然后他用来写下如下的怪物:

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);
}

Run Code Online (Sandbox Code Playgroud)

整个项目(约60,000 LOC)是用类似的风格写的 - 马克地狱,奇怪的名字,Olde-English行话等等.幸运的是我们能够抛出代码,因为我找到了一个执行相同算法的OSS库几十个时间更快.

(我复制并编辑了我最初在这个问题上做出的答案).

我很喜欢占有欲和古老的英语,因为我当然认为代码看起来很糟糕. (3认同)

Answer 19

And*_*erd 27

我遇到的最糟糕的事情是在一个包含一套可执行文件的产品中,指定的技术负责人没有找到库.

相反,他有几组Visual Source Safe文件夹中共享的文件.然后他意识到他们需要对每个应用程序的行为略有不同.

您可以在此处应用许多重构步骤.

相反,他使用#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
   }

Run Code Online (Sandbox Code Playgroud)

Answer 20

MrV*_*dez 17

使用LINE预处理器为通过网络传递的消息生成唯一ID:

NetworkMessages.h

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

Run Code Online (Sandbox Code Playgroud)

这是宏实际上比非宏解决方案更好的示例:

在非宏解决方案类中,必须构建函数和变量以跟踪消息的ID.开发人员可能会或可能不会使消息ID跟踪变得复杂,而这更容易阅读和调试.

此外,只需将消息添加到源中,就可以更轻松地添加新消息.

这种情况的缺点是文件必须包含在使用消息的所有代码中.编辑消息时,编译时间会增加.

现在我来对#defines进行排序......并且协议发生了变化.或者我获得Doxygen宗教并记录所有消息代码,并且协议发生变化.在后一种变化下,至少一个枚举是稳定的. (17认同)
版本可能彼此不兼容(不好!).怎么一个枚举还不够？ (8认同)
@MrValdez,保持枚举块顺序的限制性要小于保持相对于文件启动的相同行的定义. (3认同)

Answer 21

Jon*_*ler 16

一个相当糟糕的例子:

#ifdef __cplusplus
#define class _vclass
#endif

Run Code Online (Sandbox Code Playgroud)

这允许包含被调用的成员变量的C结构class由C++编译器处理.这个构造有两个标题; 其中一个最后还包含'#undef class',另一个则没有.

Answer 22

Kaz*_*gon 14

在国际混淆C编码竞赛的一年中,有一个条目,整个程序是:

P

条件是你可以P在makefile中定义你想要的任何程序.

我记得,它赢得了其中一个类别,并且在接下来的一年中出现了违反这种进入方式的规则.

(编辑:六个月后或者其他什么......我确信当我写这篇文章时,"没有IOCCC"的事情不在主要问题中......)

Answer 23

cob*_*bal 12

有一天我很无聊,在Objective-C中玩着块...

#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)

Run Code Online (Sandbox Code Playgroud)

允许"有趣"的事情,如:

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)))));

Run Code Online (Sandbox Code Playgroud)

(为简洁起见,未显示某些功能和类定义)

Answer 24

Tof*_*eer 11

我看到的最糟糕的是不使用:-)

有人在一个方法中写了一个strcpy(我认为就是10多年前的那个)函数(因为他们不想要调用strcpy ...... sigh的开销).

他们发现它不适用于日文字符,所以他们在开始时添加了一个"if"来做ASCII或Unicode.在那时,代码大约是一个屏幕长...可能会杀死缓存一致性并删除他所谓的代码内联的节省.

除了类型之外,代码是相同的(所以应该使用宏).

当然,他们编写的strcpy比标准库中的手动调制汇编程序慢得多......

当然,如果他们刚刚将它作为一个宏完成,它可以被替换为strcpy的调用......

当然我退出了公司(不是直接因为......)

Answer 25

dcw*_*dcw 11

必须的

#define FOR  for

Run Code Online (Sandbox Code Playgroud)

和

#define ONE  1
#define TWO  2
...

Run Code Online (Sandbox Code Playgroud)

谁知道？

但是 - 但是在代码中没有任何立场!;) (5认同)

Answer 26

小智 11

我维护在宏中有代码的代码.因此,函数最后会有一个标签,但在函数代码中没有可见的goto.更糟糕的是,除非您水平滚动,否则宏通常在屏幕外的其他语句的末尾.

#define CHECK_ERROR if (!SomeCondition) goto Cleanup

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

Run Code Online (Sandbox Code Playgroud)

Answer 27

Mic*_*kis 11

#define TRUE 0 // dumbass

Run Code Online (Sandbox Code Playgroud)

这样做的人在几年后解释了自己 - 大多数(如果不是全部)C库函数返回0表示一切顺利.所以,他希望能够编写如下代码:

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

Run Code Online (Sandbox Code Playgroud)

毋庸置疑,我们团队中的任何人(测试人员或开发人员)都不敢再次浏览他的代码.

为什么不声明像`#define FLAG_SUCCESS 0`这样的东西？ (6认同)

Answer 28

Fra*_*ank 10

#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!");
}

Run Code Online (Sandbox Code Playgroud)

我更喜欢另一个.这个显示了一些接近Java的东西,用几个宏编写.另一个显示精确的Java是用大量的偷偷摸摸的宏和结构与函数成员编写的.第一个是一个廉价的笑话,而第二个是一个精心制作而且很好的笑话. (16认同)
@Trevor:是的......聪明的人仍然在做Java.*为封面* (4认同)
你想写一个运行时.看看我节省了多少时间! (3认同)

Answer 29

Rub*_*bys 10

由一位未能理解魔法数字规则的同学:
#define TWO_HUNDRED_AND_EIGHTY_THREE_POINT_ONE 283.1

Answer 30

Ste*_*eve 9

ASA - 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 {

Run Code Online (Sandbox Code Playgroud)

等等

这就是设置选项.整个计划就是这样.

我的天啊......我想我晕了. (2认同)

Answer 31

rco*_*der 9

曾经是编码员的"技术经理"将以下精彩的宏引入我们的C++项目,因为他认为NULL在DOM解析例程中检查值太多了:

TRYSEGV
CATCHSEGV

Run Code Online (Sandbox Code Playgroud)

在封面下,这些使用了setjmp,longjmp和一个信号处理程序,SIGSEGV以模拟"捕获"段错误的能力.

当然,一旦代码退出原始TRYSEGV宏调用的范围,代码中的任何内容都不会重置跳转指针,因此代码中的任何段错误都将返回到(现在无效)jump_env指针.

代码会立即死在那里,但在破坏程序堆栈和渲染调试之前或多或少没有意义.

Answer 32

MrV*_*dez 8

AI Game Programming Wisdom有一章,其中宏用于为有限状态机创建脚本语言.

由于书籍和代码是受版权保护的材料,因此这里是指向详细说明宏的页面的Google书籍链接(最终的脚本语言可以在第324页找到.)

@MrValdez:你的虐待是别人的杰作.:) (9认同)
为什么这么邪恶？宏在某种程度上简化了代码.良好的编程语言允许您创建镜像问题域的迷你语言.C为您提供预处理器作为主要选项,除非您想拼出便携式汇编程序...... (3认同)

Answer 33

Jim*_*ans 7

在Lucent,我曾经看过Steve Bourne原始Unix shell的源代码,并发现他使用C预处理器使C看起来像~~Pascal或~~ Algol.处理if语句的部分如下所示:

#define IF   if (
#define THEN ) {
#define ELSE } else {
#define ELIF } else if (
#define FI   ; }

Run Code Online (Sandbox Code Playgroud)

我的一个朋友告诉我,他在20世纪90年代中期对它进行了一些维护,但情况仍然如此.(这里有一个关于代码库固有保守性的教训.)

当然,史蒂夫在早期做过这个实验,如果他以后写的话,我肯定会有第二个想法.

更新:根据维基百科的Bourne Shell文章,这些宏给它带来了Algol 68的味道.并且,完整的宏集在这里!他们显然影响了国际混淆C代码竞赛的创始人.

因为'od'代表Octal Dump,这是Unix第七版中的实用工具. (3认同)
这更像是Algol而不是Pascal - Algol使用向后关键字(如'fi')来标记结构的结尾.一般来说,shell使用它.有趣的问题:为什么Bourne shell中循环的结束标有'`done`'而不是'`od`'？ (2认同)

Answer 34

Pet*_*rey 7

我喜欢这个例子,它使用宏来估计PI的值.圆越大,近似越精确.

#define _ -F<00||--F-OO--;
int F=00,OO=00;main(){F_OO();printf("%1.3f\n",4.*-F/OO/OO);}F_OO()
{
            _-_-_-_
       _-_-_-_-_-_-_-_-_
    _-_-_-_-_-_-_-_-_-_-_-_
  _-_-_-_-_-_-_-_-_-_-_-_-_-_
 _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
 _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
 _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
 _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
  _-_-_-_-_-_-_-_-_-_-_-_-_-_
    _-_-_-_-_-_-_-_-_-_-_-_
        _-_-_-_-_-_-_-_
            _-_-_-_
}

Run Code Online (Sandbox Code Playgroud)

另一个是该c计划

Run Code Online (Sandbox Code Playgroud)

要编译,您需要定义c为

-Dc="#include <stdio.h> int main() { char *t =\"Hello World\n\"; while(*t) putc(*t++, stdout); return 0; }"

Run Code Online (Sandbox Code Playgroud)

Answer 35

Obi*_*Obi 6

C.的Coroutines(AKA Stackless线程):)这是邪恶的诡计.

#define crBegin static int state=0; switch(state) { case 0:
#define crReturn(i,x) do { state=i; return x; case i:; } while (0)
#define crFinish }
int function(void) {
    static int i;
    crBegin;
    for (i = 0; i < 10; i++)
        crReturn(1, i);
    crFinish;
}

int decompressor(void) {
    static int c, len;
    crBegin;
    while (1) {
        c = getchar();
        if (c == EOF)
            break;
        if (c == 0xFF) {
            len = getchar();
            c = getchar();
            while (len--)
            crReturn(c);
        } else
        crReturn(c);
    }
    crReturn(EOF);
    crFinish;
}


void parser(int c) {
    crBegin;
    while (1) {
        /* first char already in c */
        if (c == EOF)
            break;
        if (isalpha(c)) {
            do {
                add_to_token(c);
        crReturn( );
            } while (isalpha(c));
            got_token(WORD);
        }
        add_to_token(c);
        got_token(PUNCT);
    crReturn( );
    }
    crFinish;
}

Run Code Online (Sandbox Code Playgroud)

Answer 36

Dol*_*hin 5

switch (device_id)
{
#ifndef PROD_1
#ifndef PROD_2
#ifdef PROD_3
  case ID_1:
#endif

#ifdef PROD_4

#ifdef PROD_5
  case ID_2:
  case ID_3:
  case ID_4:
#elif defined(PROD_4)
#ifndef PROD_6
  case ID_1:
#endif // PROD_6
  case ID_5:
#endif

  case ID_6:
#endif

#ifdef PROD_7
  #ifndef PROD_8
    case ID_7:
  #endif
#endif

Run Code Online (Sandbox Code Playgroud)

(名称改为保护不那么无辜)

请注意,我们还没有得到任何代码,这只是为了获得第一个实际的代码位.这实际上发生了(几乎,但不完全相同的方式)几个函数,每个函数最终只有4种可能的变化(也主要是复制/粘贴,有轻微的变化和#ifdefs自己的).

归档时间：	16 年，10 月前
查看次数：	110478 次
最近记录：	12 年，9 月前