/* Create parser definition structure */
extern parserDefinition* HtmlParser (void)
{
static const char *const extensions [] = { "htm", "html", NULL };
parserDefinition *const def = parserNew ("HTML");
def->extensions = extensions;
def->tagRegexTable = htmlTagRegexTable;
def->tagRegexCount = ARRAY_SIZE (htmlTagRegexTable);
def->method = METHOD_NOT_CRAFTED|METHOD_REGEX;
return def;
}
extern parserDefinition* AwkParser (void)
{
static const char *const extensions [] = { "awk", "gawk", "mawk", NULL };
parserDefinition* def = parserNew ("Awk");
def->kinds = AwkKinds;
def->kindCount = ARRAY_SIZE (AwkKinds);
def->extensions = extensions;
def->parser = findAwkTags;
return def;
}
parserDefinition *FreeBasicParser (void)
{
static char const *extensions[] = { "bas", "bi", "bb", "pb", NULL };
parserDefinition *def = parserNew ("FreeBasic");
def->kinds = BasicKinds;
def->kindCount = ARRAY_SIZE (BasicKinds);
def->extensions = extensions;
def->parser = findBasicTags;
return def;
}
extern parserDefinition* VimParser (void)
{
static const char *const extensions [] = { "vim", NULL };
parserDefinition* def = parserNew ("Vim");
def->kinds = VimKinds;
def->kindCount = KIND_COUNT (VimKinds);
def->extensions = extensions;
def->parser = findVimTags;
return def;
}
extern parserDefinition *MyrddinParser (void)
{
static const char *const extensions [] = { "myr", NULL };
parserDefinition* const def = parserNew ("Myrddin");
def->extensions = extensions;
def->tagRegexTable = myrddinTagRegexTable;
def->tagRegexCount = ARRAY_SIZE (myrddinTagRegexTable);
def->method = METHOD_NOT_CRAFTED|METHOD_REGEX;
return def;
}
extern parserDefinition* PhpParser (void)
{
static const char *const extensions [] = { "php", "php3", "phtml", NULL };
parserDefinition* def = parserNew ("PHP");
def->kinds = PhpKinds;
def->kindCount = KIND_COUNT (PhpKinds);
def->extensions = extensions;
def->parser = findPhpTags;
return def;
}
extern parserDefinition* RubyParser (void)
{
static const char *const extensions [] = { "rb", "ruby", NULL };
parserDefinition* def = parserNew ("Ruby");
def->kinds = RubyKinds;
def->kindCount = KIND_COUNT (RubyKinds);
def->extensions = extensions;
def->parser = findRubyTags;
return def;
}
extern parserDefinition* AspParser (void)
{
static const char *const extensions [] = { "asp", "asa", NULL };
parserDefinition* def = parserNew ("Asp");
def->kinds = AspKinds;
def->kindCount = KIND_COUNT (AspKinds);
def->extensions = extensions;
def->parser = findAspTags;
return def;
}
extern parserDefinition* YaccParser (void)
{
static const char *const extensions [] = { "y", NULL };
parserDefinition* const def = parserNew ("YACC");
def->extensions = extensions;
def->method = METHOD_NOT_CRAFTED|METHOD_REGEX;
def->tagRegexTable = yaccTagRegexTable;
def->tagRegexCount = ARRAY_SIZE (yaccTagRegexTable);
return def;
}
extern parserDefinition* AbaqusParser (void)
{
static const char *const extensions [] = { "inp", NULL };
parserDefinition * def = parserNew ("Abaqus");
def->kinds = AbaqusKinds;
def->kindCount = ARRAY_SIZE (AbaqusKinds);
def->extensions = extensions;
def->parser = findAbaqusTags;
return def;
}
extern parserDefinition* LuaParser (void)
{
static const char* const extensions [] = { "lua", NULL };
parserDefinition* def = parserNew ("Lua");
def->kinds = LuaKinds;
def->kindCount = KIND_COUNT (LuaKinds);
def->extensions = extensions;
def->parser = findLuaTags;
return def;
}
/* parser definition */
extern parserDefinition* CssParser (void)
{
static const char *const extensions [] = { "css", NULL };
parserDefinition* def = parserNew ("CSS");
def->kinds = CssKinds;
def->kindCount = ARRAY_SIZE (CssKinds);
def->extensions = extensions;
def->parser = findCssTags;
return def;
}
extern parserDefinition* PowerShellParser (void)
{
static const char *const extensions [] = { "ps1", "psm1", NULL };
parserDefinition* def = parserNew ("PowerShell");
def->kinds = PowerShellKinds;
def->kindCount = ARRAY_SIZE (PowerShellKinds);
def->extensions = extensions;
def->parser = findPowerShellTags;
return def;
}
/* parser definition */
extern parserDefinition* WindResParser(void)
{
static const char *const extensions [] = { "rc", NULL };
parserDefinition* def = parserNew("WindRes");
def->kinds = ResKinds;
def->kindCount = ARRAY_SIZE(ResKinds);
def->extensions = extensions;
def->parser = findResTags;
return def;
}
extern parserDefinition *ElixirParser (void)
{
static const char *const extensions[] = { "ex", "exs", NULL };
parserDefinition *def = parserNew ("Elixir");
def->kinds = ElixirKinds;
def->kindCount = KIND_COUNT (ElixirKinds);
def->extensions = extensions;
def->parser = findElixirTags;
return def;
}
/*
* Parser definition structure
*/
extern parserDefinition* FalconParser (void)
{
static const char *const extensions [] = { "fal", "ftd", NULL };
parserDefinition *def = parserNew ("Falcon");
def->kinds = FalconKinds;
def->kindCount = ARRAY_SIZE (FalconKinds);
def->extensions = extensions;
def->parser = findFalconTags;
return def;
}
extern parserDefinition* BetaParser (void)
{
static const char *const extensions [] = { "bet", NULL };
parserDefinition* def = parserNew ("BETA");
def->kinds = BetaKinds;
def->kindCount = ARRAY_SIZE (BetaKinds);
def->extensions = extensions;
def->parser = findBetaTags;
return def;
}
extern parserDefinition* EfilogParser (void)
{
static const char *const extensions [] = { "efilog", "EFILOG", NULL };
parserDefinition* def = parserNew ("efilog");
def->kinds = efilogKinds;
def->kindCount = KIND_COUNT (efilogKinds);
def->extensions = extensions;
def->parser = findEfilogTags;
return def;
}
extern parserDefinition* PerlParser (void)
{
static const char *const extensions [] = { "pl", "pm", "plx", "perl", NULL };
parserDefinition* def = parserNew ("Perl");
def->kinds = PerlKinds;
def->kindCount = ARRAY_SIZE (PerlKinds);
def->extensions = extensions;
def->parser = findPerlTags;
return def;
}
extern parserDefinition* SlangParser (void)
{
static const char *const extensions [] = { "sl", NULL };
parserDefinition* const def = parserNew ("SLang");
def->extensions = extensions;
def->tagRegexTable = slangTagRegexTable;
def->tagRegexCount = ARRAY_SIZE (slangTagRegexTable);
def->method = METHOD_NOT_CRAFTED|METHOD_REGEX;
return def;
}
extern parserDefinition *SmlParser (void)
{
static const char *const extensions[] = { "sml", "sig", NULL };
parserDefinition *def = parserNew ("SML");
def->kinds = SmlKinds;
def->kindCount = KIND_COUNT (SmlKinds);
def->extensions = extensions;
def->parser = findSmlTags;
return def;
}
extern parserDefinition* CobolParser ()
{
static const char *const extensions [] = {
"cbl", "cob", "CBL", "COB", NULL };
parserDefinition* def = parserNew ("Cobol");
def->extensions = extensions;
def->initialize = installCobolRegex;
def->regex = TRUE;
return def;
}
extern parserDefinition *ErlangParser (void)
{
static const char *const extensions[] = { "erl", "ERL", "hrl", "HRL", NULL };
parserDefinition *def = parserNew ("Erlang");
def->kinds = ErlangKinds;
def->kindCount = COUNT_ARRAY (ErlangKinds);
def->extensions = extensions;
def->parser = findErlangTags;
return def;
}
extern parserDefinition* TclParser (void)
{
static const char *const extensions [] = { "tcl", "tk", "wish", "itcl", NULL };
parserDefinition* def = parserNew ("Tcl");
def->kinds = TclKinds;
def->kindCount = ARRAY_SIZE (TclKinds);
def->extensions = extensions;
def->parser = findTclTags;
return def;
}
extern parserDefinition* DocBookParser (void)
{
static const char *const extensions [] = { "sgml", "docbook", NULL };
parserDefinition* def = parserNew ("Docbook");
def->extensions = extensions;
def->kinds = DocBookKinds;
def->kindCount = ARRAY_SIZE (DocBookKinds);
def->parser = findDocBookTags;
return def;
}
extern parserDefinition *ValaParse(void) {
g_type_init();
static const char *const extensions [] = { "vala", "vapi", NULL };
parserDefinition* def = parserNew ("Vala");
def->kinds = ValaKinds;
def->kindCount = KIND_COUNT (ValaKinds);
def->extensions = extensions;
def->parser = findValaTags;
return def;
}
extern parserDefinition* PascalParser (void)
{
static const char *const extensions [] = { "p", "pas", NULL };
parserDefinition* def = parserNew ("Pascal");
def->extensions = extensions;
def->kinds = PascalKinds;
def->kindCount = KIND_COUNT (PascalKinds);
def->parser = findPascalTags;
return def;
}
extern parserDefinition* DiffParser (void)
{
static const char *const extensions [] = { "diff", "patch", NULL };
parserDefinition* const def = parserNew ("Diff");
def->kinds = DiffKinds;
def->kindCount = COUNT_ARRAY (DiffKinds);
def->extensions = extensions;
def->parser = findDiffTags;
def->useCork = TRUE;
return def;
}
extern parserDefinition* VerilogParser (void)
{
static const char *const extensions [] = { "v", NULL };
parserDefinition* def = parserNew ("Verilog");
def->kinds = VerilogKinds;
def->kindCount = ARRAY_SIZE (VerilogKinds);
def->extensions = extensions;
def->parser = findVerilogTags;
def->initialize = initialize;
return def;
}
extern parserDefinition* RstParser (void)
{
static const char *const extensions [] = { "rest", "reST", "rst", NULL };
parserDefinition* const def = parserNew ("reStructuredText");
def->kinds = RstKinds;
def->kindCount = ARRAY_SIZE (RstKinds);
def->extensions = extensions;
def->parser = findRstTags;
return def;
}
