c.snippets

## Main

# main

snippet main
int main(int argc, const char *argv[])
{
	${0}
	return 0;
}
endsnippet
# main(void)

snippet mainn
int main(void)
{
	${0}
	return 0;
}
endsnippet
##

## Preprocessor

# #include <...>

snippet inc
#include <${1:stdio}.h>
endsnippet
# #include "..."

snippet Inc
#include "${1:`vim_snippets#Filename("$1.h")`}"
endsnippet
# ifndef...define...endif

snippet ndef
#ifndef $1
#define ${1:SYMBOL} ${2:value}
#endif /* ifndef $1 */
endsnippet
# define

snippet def
#define
endsnippet
# ifdef...endif

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

snippet #if
#if ${1:FOO}
	${0:${VISUAL}}
#endif
endsnippet
# header include guard

snippet once
#ifndef ${1:`toupper(vim_snippets#Filename('$1_H', 'UNTITLED_H'))`}

#define $1

	${0}

#endif /* end of include guard: $1 */
endsnippet
# Disable C++ name mangling in C headers

snippet nocxx
#ifdef __cplusplus

extern "C" {

#endif

	${0}

#ifdef __cplusplus

} /* extern "C" */
#endif
endsnippet
##

## Control Statements

# if

snippet if
if(${1:true}){
	${0:${VISUAL}}
}
endsnippet

snippet ife
if (${1:true}) {
	${2:${VISUAL}}
} else {
	${0}
}
endsnippet
# else

snippet el
	else {

		${0:${VISUAL}}

	}
endsnippet
# else if

snippet elif

	else if (${1:true}) {

		${0:${VISUAL}}

	}
endsnippet
# ifi

snippet ifi
if (${1:true}) ${0};
endsnippet
# ternary

snippet t
${1:/* condition */} ? ${2:a} : ${3:b}
endsnippet
# switch

snippet switch

switch (${1:/* variable */}) {
	case ${2:/* variable case */}:
			${3}
			${4:break;}${5}
	default:
			${6}
}
endsnippet
# switch without default

snippet switchndef

switch (${1:/* variable */}) {
	case ${2:/* variable case */}:
			${3}
			${4:break;}${5}
}
endsnippet
# case

snippet case
	case ${1:/* variable case */}:
		${2}
		${3:break;}
endsnippet
snippet ret
return ${0};
endsnippet
##

## Loops

# for

snippet for
for (int ${2:i} = 0; $2 < ${1:count}; $2${3:++}) {
	${4}
}
endsnippet
# for (custom)

snippet forr
for (int ${1:i} = ${2:0}; ${3:$1 < 10}; $1${4:++}) {
	${5}
}
endsnippet
# while

snippet wh

while (${1:/* condition */}) {
	${0:${VISUAL}}
}
endsnippet
# do... while

snippet do
do {
	${0:${VISUAL}}
} while (${1:/* condition */});
endsnippet
##

## Functions

# function definition

snippet fun

${1:void} ${2:function_name}(${3})
{
	${4}
}
endsnippet
# function definition with zero parameters

snippet fun0

${1:void} ${2:function_name}()
{
	${3}
}
endsnippet
# function definition with Doxygen documentation

snippet dfun0

/*! \brief ${1:Brief function description here}
 *
 *  ${2:Detailed description of the function}
 *
 * \return ${3:Return parameter description}
 */

${4:void} ${5:function_name}()
{
	${6}
}
endsnippet
# function definition with one parameter

snippet fun1

${1:void} ${2:function_name}(${3:Type} ${4:Parameter})
{
	${5}
}
endsnippet
# function definition with one parameter with  Doxygen documentation

snippet dfun1

/*! \brief ${1:Brief function description here}
 *
 *  ${2:Detailed description of the function}
 *
 * \param $3 ${4:Parameter description}
 * \return ${5:Return parameter description}
 */

${6:void} ${7:function_name}(${8:Type} ${3:Parameter})
{
	${9}
}
endsnippet
# function definition with two parameters

snippet fun2

${1:void} ${2:function_name}(${3:Type} ${4:Parameter}, ${5:Type} ${6:Parameter})
{
	${7}
}
endsnippet
# function definition with two parameters with  Doxygen documentation

snippet dfun2

/*! \brief ${1:Brief function description here}
 *
 *  ${2:Detailed description of the function}
 *
 * \param $3 ${4:Parameter description}
 * \param $5 ${6:Parameter description}
 * \return ${7:Return parameter description}
 */

${8:void} ${9:function_name}(${10:Type} ${3:Parameter}, ${11:Type} ${5:Parameter})
{
	${12}
}
endsnippet
# function definition with three parameters

snippet fun3

${1:void} ${2:function_name}(${3:Type} ${4:Parameter}, ${5:Type} ${6:Parameter}, ${7:Type} ${8:Parameter})
{
	${9}
}
endsnippet
# function definition with three parameters with  Doxygen documentation

snippet dfun3

/*! \brief ${1:Brief function description here}
 *
 *  ${2:Detailed description of the function}
 *
 * \param $3 ${4:Parameter description}
 * \param $5 ${6:Parameter description}
 * \param $7 ${8:Parameter description}
 * \return ${9:Return parameter description}
 */

${10:void} ${11:function_name}(${12:Type} ${3:Parameter}, ${13:Type} ${5:Parameter}, ${14:Type} ${7:Parameter})
{
	${15}
}
endsnippet
# function declaration

snippet fund

${1:void} ${2:function_name}(${3});
endsnippet
##

## Types

# typedef

snippet td
typedef ${1:int} ${2:MyCustomType};
endsnippet
# struct

snippet st
/*! \struct $1
 *  \brief ${3:Brief struct description}
 *
 *  ${4:Detailed description}
 */

struct ${1:`vim_snippets#Filename('$1_t', 'name')`} {
	${2:Data} /*!< ${4:Description} */
}${5: /* optional variable list */};
endsnippet
# typedef struct

snippet tds
/*! \struct $2
 *  \brief ${5:Brief struct description}
 *
 *  ${6:Detailed description}
 */
typedef struct ${2:_$1 }{
	m_${3:Data} /*!< ${4:Description} */
} ${1:`vim_snippets#Filename('$1_t', 'name')`};

endsnippet

snippet enum
/*! \enum $1
 *
 *  ${2:Detailed description}
 */
enum ${1:name} { ${0} };
endsnippet
# typedef enum

snippet tde

/*! \enum $2
 *
 *  ${4:Detailed description}
 */

typedef enum {
	${1:Data} /*!< ${3:Description} */
} ${2:foo};
endsnippet
##

## Input/Output

# printf

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

snippet fpr
fprintf(${1:stderr}, "${2:%s}\n"${3});
endsnippet

snippet prd

printf("${1:} = %d\n", $1);
endsnippet

snippet prf
printf("${1:} = %f\n", $1);
endsnippet

snippet prx
printf("${1:} = %${2}\n", $1);
endsnippet
# getopt

snippet getopt

int choice;
while (1){
	static struct option long_options[] =
	{
		/* Use flags like so:
		   {"verbose",	no_argument,	&verbose_flag, 'V'}*/
		/* Argument styles: no_argument, required_argument, optional_argument */
		{"version", no_argument,	0,	'v'},
		{"help",	no_argument,	0,	'h'},
		${1}
		{0,0,0,0}
		};
	int option_index = 0;
	/* Argument parameters:
    no_argument: " "
    required_argument: ":"
    optional_argument: "::" */
	choice = getopt_long( argc, argv, "vh",
			long_options, &option_index);
	if (choice == -1)
		break;

	switch( choice ){
			case 'v':
				${2}
				break;

			case 'h':
				${3}
				break;

			case '?':
				/* getopt_long will have already printed an error */
				break;

			default:
				/* Not sure how to get here... */
				return EXIT_FAILURE;
	}

}



/* Deal with non-option arguments here */
if ( optind < argc ){
	while ( optind < argc ){
		${0}
	}
}
endsnippet
##

# TODO section

snippet todo

/*! TODO: ${1:Todo description here}
 *  \todo $1
 */
endsnippet
## Miscellaneous

# This is kind of convenient

snippet .
[${1}]
endsnippet

snippet b "bracket" i
(${1:${VISUAL}})${2}
endsnippet

snippet g "square" i
[${1}]${2}
endsnippet