ITT we write a lisp compiler

#define cdr(sym , ... ) __VA_ARGS__

#define car(sym , ...) sym
#define cons(...) __VA_ARGS__

#define funcall(f,...) f(__VA_ARGS__)

#define list(...) (__VA_ARGS__)

#define append(list1,list2) cons list1,cons list2

#define quote(...) cons list(__VA_ARGS__)

#define cond1(list1) car list1 ?cdr list1:0
#define cond2(list1,list2) car list1 ?cdr list1:(car list2?cdr list2:0)
#define cond3(list1,list2,list3) car list1?cdr list1:(car list2?cdr list2 :(car list3?cdr list3 :0))

#define mapcar1(f,arg) f(arg)
#define mapcar2(f,arg,arg2) f(arg),mapcar1(f,arg2)
#define mapcar3(f,arg,...) f(arg),mapcar2(f,__VA_ARGS__)
#define mapcar4(f,arg,...) f(arg),mapcar3(f,__VA_ARGS__)
#define mapcar5(f,arg,...) f(arg),mapcar4(f,__VA_ARGS__)
#define mapcar6(f,arg,...) f(arg),mapcar5(f,__VA_ARGS__)
#define mapcar7(f,arg,...) f(arg),mapcar6(f,__VA_ARGS__)
#define mapcar8(f,arg,...) f(arg),mapcar7(f,__VA_ARGS__)
#define mapcar9(f,arg,...) f(arg),mapcar8(f,__VA_ARGS__)
#define mapcar10(f,arg,...) f(arg),mapcar9(f,__VA_ARGS__)
#define mapcar11(f,arg,...) f(arg),mapcar10(f,__VA_ARGS__)
#define mapcar12(f,arg,...) f(arg),mapcar11(f,__VA_ARGS__)
#define mapcar13(f,arg,...) f(arg),mapcar12(f,__VA_ARGS__)
#define mapcar14(f,arg,...) f(arg),mapcar13(f,__VA_ARGS__)
#define mapcar15(f,arg,...) f(arg),mapcar14(f,__VA_ARGS__)
#define mapcar16(f,arg,...) f(arg),mapcar15(f,__VA_ARGS__)
#define mapcar17(f,arg,...) f(arg),mapcar16(f,__VA_ARGS__)
#define mapcar18(f,arg,...) f(arg),mapcar17(f,__VA_ARGS__)
#define mapcar19(f,arg,...) f(arg),mapcar18(f,__VA_ARGS__)
#define mapcar20(f,arg,...) f(arg),mapcar19(f,__VA_ARGS__)
#define mapcar21(f,arg,...) f(arg),mapcar20(f,__VA_ARGS__)
#define mapcar22(f,arg,...) f(arg),mapcar21(f,__VA_ARGS__)
#define mapcar23(f,arg,...) f(arg),mapcar22(f,__VA_ARGS__)
#define mapcar24(f,arg,...) f(arg),mapcar23(f,__VA_ARGS__)
#define mapcar25(f,arg,...) f(arg),mapcar24(f,__VA_ARGS__)
#define mapcar26(f,arg,...) f(arg),mapcar25(f,__VA_ARGS__)
#define mapcar27(f,arg,...) f(arg),mapcar26(f,__VA_ARGS__)
#define mapcar28(f,arg,...) f(arg),mapcar27(f,__VA_ARGS__)
#define mapcar29(f,arg,...) f(arg),mapcar28(f,__VA_ARGS__)

#define mapcar30(f,arg,...) f(arg),mapcar29(f,__VA_ARGS__)
#define mapcar31(f,arg,...) f(arg),mapcar30(f,__VA_ARGS__)
#define mapcar32(f,arg,...) f(arg),mapcar31(f,__VA_ARGS__)
#define mapcar33(f,arg,...) f(arg),mapcar32(f,__VA_ARGS__)
#define mapcar34(f,arg,...) f(arg),mapcar33(f,__VA_ARGS__)
#define mapcar35(f,arg,...) f(arg),mapcar34(f,__VA_ARGS__)
#define mapcar36(f,arg,...) f(arg),mapcar35(f,__VA_ARGS__)
#define mapcar37(f,arg,...) f(arg),mapcar36(f,__VA_ARGS__)
#define mapcar38(f,arg,...) f(arg),mapcar37(f,__VA_ARGS__)
#define mapcar39(f,arg,...) f(arg),mapcar38(f,__VA_ARGS__)

// get number of arguments with __NARG__
#define __NARG__(...) __NARG_I_(__VA_ARGS__,__RSEQ_N())
#define __NARG_I_(...) __ARG_N(__VA_ARGS__)
#define __ARG_N( \
_1, _2, _3, _4, _5, _6, _7, _8, _9,_10, \
_11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
_21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \
_31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
_41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \
_51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
_61,_62,_63,N,...) N
#define __RSEQ_N() \
63,62,61,60, \
59,58,57,56,55,54,53,52,51,50, \
49,48,47,46,45,44,43,42,41,40, \
39,38,37,36,35,34,33,32,31,30, \
29,28,27,26,25,24,23,22,21,20, \
19,18,17,16,15,14,13,12,11,10, \
9,8,7,6,5,4,3,2,1,0

// general definition for any function name
#define _VFUNC_(name, n) name##n
#define _VFUNC(name, n) _VFUNC_(name, n)
#define VFUNC(func, ...) _VFUNC(func, __NARG__(__VA_ARGS__)) (__VA_ARGS__)

#define mapcar(f,...) VFUNC(f,__VA_ARGS__)

#define lambda(return_type,arguments,function_body) \
({ \
return_type __fn__ arguments {cons function_body;} \
__fn__; \
})
/*
#include <stdio.h>
int main()
{

printf("%d\n",lambda(int,(int arg),(int a,b,c=0;b=arg,a=arg/2;if((b-5)<a){return 1;}else{return 2;} ))(5) );

}
*/

#define loop for(;;)
#define setq(x,...) __auto_type x=(__VA_ARGS__)

#define eq(a,b) (a)==(b)

#define VOID void

#define stringify2(n...) #n
#define stringify(n...) stringify2(n)
#define show(x...) _Pragma(stringify(message stringify(x)) )

show(Compile time, messages, with, unlimited length,123)

#include <void.h>

#define begin {
#define end }

>>12
That was Microsoft quality!

>>15
more like

#define ( {
#define ) }


>>17
Invalid

#define LOCAL static
#define PROC extern
#define TYPE typedef
#define STRUCT TYPE struct
#define UNION TYPE union
#define REG register

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

#define BEGIN {
#define END }
#define SWITCH switch(
#define IN ){
#define ENDSW }
#define FOR for(
#define WHILE while(
#define DO ){
#define OD ;}
#define REP do{
#define PER }while(
#define DONE );
#define LOOP for(;;){
#define POOL }


#define SKIP ;
#define DIV /
#define REM %
#define NEQ ^
#define ANDF &&
#define ORF ||

#define TRUE (-1)
#define FALSE 0
#define LOBYTE 0377
#define STRIP 0177
#define QUOTE 0200

#define EOF 0
#define NL '\n'
#define SP ' '
#define LQ '`'
#define RQ '\''
#define MINUS '-'
#define COLON ':'

#define MAX(a,b) ((a)>(b)?(a):(b))

This doesn't look like a compiler

>>20
Of course. Lisp is meant to be interpreted.
#define eval(...) ({__VA_ARG__;})
eval((printf("Hello world")));

http://codepad.org/VUURK7Ne It works

http://codepad.org/7rZScXHa

>>21
Awful

This looks like void.h

#define defun(funcname,args,body) funcname args {body;}

http://codepad.org/aEkZJT1X

>>25
void.h has already been included >>14

Please stop raping the C language with your bullshit.

>>15
>>19
And these happen to be the worst.
If you want Pascal syntax, then program in fucking Pascal.

#include "void.h"

>>29
What if you want Pascal syntax, pointer arithmetic, and portability?

>>29
Optimize your quotes, 「下さい」。

>>29
actually, that's algol

#include "https://www.reddit.com/r/frozenvoid/wiki/void2/lambda_h"

>>34
I doubt FrozenAnus knows what is lambda at all.

#include "https://www.reddit.com/r/frozenvoid/wiki/void2/vapply_h"

>>31
then use FreePascal/Lazarus

#define offsetof(st, m) ((size_t)(&((st *)0)->m))

>>34,36
The scary thing is, I can actually see URLs for include paths get put into the standard at some point in the future.

>>39
You mean like Go?

>>40
Well, not exactly.
If you're talking about import, it's used for fetching and compiling git repos.

>>41
It's also local.
But still, it's not quite as bad as #include "https://www.reddit.com/r/frozenvoid/wiki/void2/vapply_h"