###########################################################################
#                            TextMate Snippets                            #
###########################################################################
snippet def "#ifndef … #define … #endif"
#ifndef ${1/([A-Za-z0-9_]+).*/$1/}
#define ${1:SYMBOL} ${2:value}
#endif
endsnippet

snippet Inc "#include local header (inc)"
#include "${1:`!p snip.rv = snip.basename + '.h'`}"
endsnippet
#include "${1:`Filename("$1.h")`}"${2}

snippet inc "#include <> (Inc)"
#include <${1}>${2}
endsnippet

snippet mark "#pragma mark (mark)"
#if 0
${1:#pragma mark -
}#pragma mark $2
#endif

$0
endsnippet

snippet main "main() (main)"
int main(int argc, const char *argv[])
{
	$0
}
endsnippet

snippet for "for int loop (fori)"
for (${4:size_t} ${2:i} = 0; $2 < ${1:count}; ${3:++$2})
{
	${0:/* code */}
}
endsnippet

snippet enum "Enumeration"
enum ${1:name} { $0 };
endsnippet

snippet once "Include header once only guard"
#ifndef ${1:`!p
if not snip.c:
	import random, string
	name = re.sub(r'[^A-Za-z0-9]+','_', snip.fn).upper()
	rand = ''.join(random.sample(string.ascii_letters+string.digits, 8))
	snip.rv = ('%s_%s' % (name,rand)).upper()
else:
    snip.rv = snip.c`}
#define $1

${0}

#endif /* end of include guard: $1 */

endsnippet

snippet td "Typedef"
typedef ${1:int} ${2:MyCustomType};
endsnippet

snippet do "do...while loop (do)"
do {
	${0:/* code */}
} while(${1:/* condition */});
endsnippet

snippet fprintf "fprintf …"
fprintf(${1:stderr}, "${2:%s}\n"${2/([^%]|%%)*(%.)?.*/(?2:, :\);)/}$3${2/([^%]|%%)*(%.)?.*/(?2:\);)/}
endsnippet

snippet if "if .. (if)"
if (${1:/* condition */})
{
	${0:/* code */}
}
endsnippet

snippet ife "if .. else"
if (${1:/* condition */})
{
	${2:/* code */}
}
else
{
	${0:/* code */}
}
endsnippet

snippet printf "printf .. (printf)"
printf("${1:%s}\n"${1/([^%]|%%)*(%.)?.*/(?2:, :\);)/}$2${1/([^%]|%%)*(%.)?.*/(?2:\);)/}
endsnippet

snippet st "struct"
struct ${1:`!p snip.rv = (snip.basename or "name") + "_t"`}
{
	${0:/* data */}
};
endsnippet

# #ifndef ... #define ... #endif
snippet Def
#ifndef $1
#define ${1:SYMBOL} ${2:value}
#endif${3}
endsnippet

snippet def
#define
endsnippet

snippet ifdef
#ifdef ${1:FOO}
	${2:#define }
#endif
endsnippet

snippet #if
#if ${1:FOO}
	${2}
#endif
endsnippet

# Header Include-Guard
# (the randomizer code is taken directly from TextMate; it could probably be
# cleaner, I don't know how to do it in vim script)
snippet once
#ifndef ${1:`'__'.toupper(Filename('', 'UNTITLED').'_'.system("/usr/bin/ruby -e 'print (rand * 2821109907455).round.to_s(36)'"))`}

#define $1

${2}

#endif /* end of include guard: $1 */
endsnippet

#snippet guard
##ifndef ${1:`'__VWD_'.toupper(Filename('', 'UNTITLED').'_H_')`}
##define $1
#${2}
##endif // $1
#endsnippet

snippet guard
#ifndef ${1:`!p
if not snip.c:
	import string
	name = re.sub(r'[^A-Za-z0-9]+','_', snip.fn)
	snip.rv = ('__VWD_%s_' % name).upper()
else:
    snip.rv = snip.c`}
#define $1
${0}
#endif // $1
endsnippet


snippet else
else
{
	${1}
}
endsnippet

snippet el
else
{
	${1}
}
endsnippet

# Tertiary conditional
#snippet t
#	${1:/* condition */} ? ${2:a} : ${3:b}
# Do While Loop
snippet do
do
{
	${2:/* code */}
} while(${1:/* condition */});
endsnippet

# While Loop
snippet while
while(${1:/* condition */})
{
	${2:/* code */}
}
endsnippet

# Function
snippet fun
${1:void} ${2:function_name}(${3})
{
	${4:/* code */}
}
endsnippet

# Function Declaration
snippet fund
${1:void} ${2:function_name}(${3});${4}
endsnippet

# Struct
snippet struct
struct ${1:`!p snip.rv = (snip.basename or "name") + "_t"`}
{
	${2:/* data */}
};${4}
endsnippet

# Typedef struct
snippet tds
typedef struct ${2:_$1 }{
	${3:/* data */}
} ${1:`Filename('$1_t', 'name')`};
endsnippet

# Typdef enum
snippet tde
typedef enum {
	${1:/* data */}
} ${2:foo};
endsnippet

# printf
# unfortunately version this isn't as nice as TextMates's, given the lack of a
# dynamic `...`
snippet pr
printf("${1:%s}\n"${2});${3}
endsnippet

# fprintf (again, this isn't as nice as TextMate's version, but it works)
snippet fpr
fprintf(${1:stderr}, "${2:%s}\n"${3});${4}
endsnippet

snippet vim
// vim: tabstop=4 shiftwidth=4 noexpandtab
endsnippet

snippet cdump
printf("${1} = %${2}\n", $1);
endsnippet

snippet INFO
INFO("${1} = %${2}\n", $1);
endsnippet


snippet oldsymbol
asm (".symver ${1}, $1@GLIBC_2.2.5");
extern "C" int $1();

extern "C" int __wrap_$1()
{
	return $1();
}
endsnippet
# vim: tabstop=4 shiftwidth=4 noexpandtab