anjuta-extras 3.26.0-3 / usr / share / anjuta / properties / styles.properties

###############################################################################
#
# Created by update-properties.pl from all SciTE properties files
#
# This file is divided in 2 parts:
#   * The first part concatenate all SciTE *.properties file containing style
#     definition but without these definitions. 
#   * The second part group all style definitions. The style definition should
#     be modified to use anjuta style properties. If the output file already
#     exists the second part is read before overwriting it, so you can keep
#     any change done here.



###############################################################################
# From abaqus.properties
# Define SciTE settings for ABAQUS files.

file.patterns.abaqus=*.inp;*.dat;*.msg
filter.abaqus=ABAQUS input (inp)|$(file.patterns.abaqus)|

*filter.abaqus=$(filter.abaqus)

#lexer.$(file.patterns.abaqus)=abaqus
lexer.$(file.patterns.abaqus)=abaqus

# keywords and input/output specifiers
keywords=*amplitude *assembly \
*beam *boundary *buckle *bulk \
*cload *conditions *conductivity *contact \
*damping *density *dload *dsflux *dsload *dynamic \
*el *elastic *element *element output *elgen *elset *encastre *end step \
*expansion *explicit *equation *embedded element \
*field *freq *frequency *friction \
*generate \
*heading *heat transfer *history \
*imperfectio *import *include *initial *initial conditions *instance *interactio \
*internal *interval \
*marks *material *monitor *mpc \
*ncopy *nfill *ngen *nlgeom *node *node output *node print *nset *number \
*output \
*pair *parameter *part *physical constants *plastic *print *preprint \
*radiate *restart \
*shell *shell section *solid section *specific heat *sradiate *static *step \
*surface \
*temperature *time *type \
*variable *viscosity

arguments=elset engineering inc input line material name nset pin tie type write generate field variable history \
stefan boltzmann absolute zero zero frequency steady state new old set change number shift \
model position newset oldset host

keywords.$(file.patterns.abaqus)=
keywords2.$(file.patterns.abaqus)=$(keywords)
keywords3.$(file.patterns.abaqus)=
keywords4.$(file.patterns.abaqus)=
keywords5.$(file.patterns.abaqus)=$(arguments)
keywords6.$(file.patterns.abaqus)=

comment.block.abaqus=**

# ABAQUS styles

command.compile.*.inp=
command.build.*.inp=abaqus job=$(FileName) cpus=4
command.go.*.inp=

autocomplete.abaqus.ignorecase=1
calltip.abaqus.ignorecase=1



###############################################################################
# From ada.properties
# Define SciTE settings for Ada files.

filter.ada=Ada (ads adb)|*.ads;*.adb|

*filter.ada=$(filter.ada)

file.patterns.ada=*.ads;*.adb

*source.patterns.ada=$(file.patterns.ada);

lexer.$(file.patterns.ada)=ada

*language.ada=Ada|ads||

#indent.size.$(file.patterns.ada)=3
#use.tabs.$(file.patterns.ada)=0

# Keyword except of operator keywords
keywordclass.ada.main=abort abstract accept access aliased all array at begin body \
case constant declare delay delta digits do else elsif end entry exception exit for \
function generic goto if in is limited loop new null of others out package pragma \
private procedure protected raise range record renames requeue return reverse \
select separate subtype tagged task terminate then type until use when while with
# Keywords for operators
keywordclass.ada.operators=abs and mod not or rem xor

keywordclass.ada=$(keywordclass.ada.main) $(keywordclass.ada.operators)

keywords.$(file.patterns.ada)=$(keywordclass.ada)

# Ada styles

# Comments
comment.block.ada=--~

braces.ada.style=4

statement.indent.$(file.patterns.ada)=1 begin declare else elsif exception for if is loop while
statement.lookback.$(file.patterns.ada)=20
block.start.$(file.patterns.ada)=10 then is
block.end.$(file.patterns.ada)=10 end

calltip.ada.word.characters=._$(chars.alpha)

adagcc=gcc -c $(FileNameExt)

command.compile.*.ads=$(adagcc)
command.build.*.ads=gnatmake
command.go.*.ads=$(FileName)

command.compile.*.adb=$(adagcc)
command.build.*.adb=gnatmake
command.go.*.adb=$(FileName)



###############################################################################
# From asm.properties
# Define SciTE settings for Assembler files (NASM)
# Originally by Black Horus blackhorus@gmx.net 2002
# Updated by Kein-Hong Man mkh@pl.jaring.my 2003-10
# Updated by Marat Dukhan (mdukhan3.at.gatech.dot.edu) 10/4/2011

# Nasm files
file.patterns.asm=*.asm
#file.patterns.as=*.s

*source.patterns.asm=$(file.patterns.asm);

filter.asm=Assembler x86/x64 (asm)|$(file.patterns.asm)|
filter.as=Assembler x86/x64 (as)|$(file.patterns.as)|

*filter.asm=$(filter.asm)

lexer.$(file.patterns.asm)=asm
lexer.$(file.patterns.as)=as

*language.assembler=Assembler|asm||

bcd_instruction=aaa aad aam aas daa das
flow_instruction=ja jae jb jbe jc jcxz je jg jge jl jle jmp jna \
	jnae jnb jnbe jnc jne jng jnge jnl jnle jno jnp jns jnz \
	jo jp jpe jpo js jz \
	jcxz jecxz jrcxz \
	loop loope loopne loopz loopnz \
	call ret

alu_instruction=add sub adc sbb neg cmp inc dec \
	and or xor not test \
	shl shr sal sar shld shrd rol ror rcl rcr \
	cbw cwd cwde cdq cdqe cqo \
	bsf bsr bt btc btr bts \
	idiv imul div mul bswap \
	nop

mem_instruction=lea \
	mov movsx movsxd movzx \
	xlatb bound \
	xchg xadd cmpxchg cmpxchg8b cmpxchg16b

stack_instruction=push pop pushad popad pushf popf pushfd popfd pushfq popfq

pred_instruction=seta setae setb setbe setc sete setg setge setl \
	setle setna setnae setnb setnbe setnc setne setng setnge \
	setnl setnle setno setnp setns setnz seto setp setpe setpo \
	sets setz \
	salc

flag_instruction=clc cld stc std cmc lahf sahf

cmov_instruction=cmovo cmovno cmovb cmovc cmovnae cmovae cmovnb \
	cmovnc cmove cmovz cmovne cmovnz cmovbe cmovna cmova \
	cmovnbe cmovs cmovns cmovp cmovpe cmovnp cmovpo cmovl \
	cmovnge cmovge cmovnl cmovle cmovng cmovg cmovnle

prefix_instruction=lock rep repe repz repne repnz

string_instruction=cmpsb cmpsw cmpsq \
	movsb movsw movsq \
	scasb scasw scasd scasq \
	stosb stosw stosd stosq

info_instruction=cpuid rdtsc rdtscp rdpmc xgetbv

lwp_instruction=llwpcb slwpcb lwpval lwpins

ext_instruction=crc32 popcnt lzcnt tzcnt movbe pclmulqdq rdrand

bmi1_instruction=andn bextr blsi blsmk blsr

bmi2_instruction=bzhi mulx pdep pext rorx sarx shlx shrx

tbm_instruction=blcfill blci blcic blcmsk blcs blsfill blsic t1mskc tzmsk

fpu_instruction=f2xm1 fabs fadd faddp fbld fbstp fchs fclex fcom fcomp fcompp fdecstp \
	fdisi fdiv fdivp fdivr fdivrp feni ffree fiadd ficom ficomp fidiv \
	fidivr fild fimul fincstp finit fist fistp fisub fisubr fld fld1 \
	fldcw fldenv fldenvw fldl2e fldl2t fldlg2 fldln2 fldpi fldz fmul \
	fmulp fnclex fndisi fneni fninit fnop fnsave fnsavew fnstcw fnstenv \
	fnstenvw fnstsw fpatan fprem fptan frndint frstor frstorw fsave \
	fsavew fscale fsqrt fst fstcw fstenv fstenvw fstp fstsw fsub fsubp \
	fsubr fsubrp ftst fwait fxam fxch fxtract fyl2x fyl2xp1 \
	fsetpm fcos fldenvd fnsaved fnstenvd fprem1 frstord fsaved fsin fsincos \
	fstenvd fucom fucomp fucompp fcomi fcomip fucomi fucomip ffreep \
	fcmovb fcmove fcmovbe fcmovu fcmovnb fcmovne fcmovnbe fcmovnu

mmx_instruction=movd movq \
	paddb paddw paddd paddsb paddsw paddusb paddusw \
	psubb psubw psubd psubsb psubsw psubusb psubusw \
	pand pandn por pxor \
	pcmpeqb pcmpeqd pcmpeqw pcmpgtb pcmpgtd pcmpgtw \
	pmaddwd pmulhw pmullw \
	psllw pslld psllq psrlw psrld psrlq psraw psrad \
	packuswb packsswb packssdw \
	punpcklbw punpcklwd punpckldq punpckhbw punpckhwd punpckhdq \
	emms

mmx2_instruction=pavgb pavgw \
	pextrw pinsrw pmovmskb \
	pmaxsw pmaxub pminsw pminub \
	pmulhuw psadbw pshufw \
	prefetchnta prefetcht0 prefetcht1 prefetcht2 \
	maskmovq movntq sfence

emmx_instruction=paddsiw psubsiw \
	pmulhrw pmachriw pmulhriw \
	pmagw pdistib paveb \
	pmvzb pmvnzb pmvlzb pmvgezb

k3d_instruction=pfacc pfadd pfsub pfsubr pfmul \
	pfcmpeq pfcmpge pfcmpgt \
	pfmax pfmin \
	pfrcp pfrcpit1 pfrcpit2 pfrsqit1 pfrsqrt \
	pi2fd pf2id \
	pavgusb pmulhrw \
	femms

k3d2_instruction=pfnacc pfpnacc pi2fw pf2iw pswapd

k3dgeode_instruction=pfrsqrtv pfrcpv

k3dprefetch_instruction=prefetch prefetchw

sse_instruction=addss addps subss subps \
	mulss mulps divss divps sqrtss sqrtps \
	rcpss rcpps rsqrtss rsqrtps \
	maxss maxps minss minps \
	cmpss comiss ucomiss cmpps \
	cmpeqss cmpltss cmpless cmpunordss cmpneqss cmpnltss cmpnless cmpordss \
	cmpeqps cmpltps cmpleps cmpunordps cmpneqps cmpnltps cmpnleps cmpordps \
	andnps andps orps xorps \
	cvtsi2ss cvtss2si cvttss2si \
	cvtpi2ps cvtps2pi cvttps2pi \
	movss movlps movhps movlhps movhlps movaps movups movntps movmskps \
	shufps unpckhps unpcklps \
	ldmxcsr stmxcsr

sse2_instruction=addpd addsd subpd subsd \
	mulsd mulpd divsd divpd sqrtsd sqrtpd \
	maxsd maxpd minsd minpd \
	cmpsd comisd ucomisd cmppd \
	cmpeqsd cmpltsd cmplesd cmpunordsd cmpneqsd cmpnltsd cmpnlesd cmpordsd \
	cmpeqpd cmpltpd cmplepd cmpunordpd cmpneqpd cmpnltpd cmpnlepd cmpordpd \
	andnpd andpd orpd xorpd \
	cvtsd2ss cvtpd2ps cvtss2sd cvtps2pd \
	cvtdq2ps cvtps2dq cvttps2dq \
	cvtdq2pd cvtpd2dq cvttpd2dq \
	cvtsi2sd cvtsd2si cvttsd2si \
	cvtpi2pd cvtpd2pi cvttpd2pi \
	movsd movlpd movhpd movapd movupd movntpd movmskpd \
	shufpd unpckhpd unpcklpd \
	movnti movdqa movdqu movntdq maskmovdqu \
	movdq2q movq2dq \
	paddq psubq pmuludq \
	pslldq psrldq \
	punpcklqdq punpckhqdq \
	pshufhw pshuflw pshufd \
	lfence mfence

sse3_instruction=addsubps addsubpd \
	haddps haddpd hsubps hsubpd \
	movsldup movshdup movddup \
	lddqu \
	fisttp

ssse3_instruction=psignb psignw psignd \
	pabsb pabsw pabsd \
	palignr pshufb \
	pmulhrsw pmaddubsw \
	phaddw phaddd phaddsw \
	phsubw phsubd phsubsw

sse4a_instruction=extrq insertq \
	movntsd movntss

sse41_instruction=mpsadbw phminposuw \
	pmuldq pmulld \
	dpps dppd \
	blendps blendpd blendvps blendvpd pblendvb pblendw \
	pmaxsb pmaxuw pmaxsd pmaxud pminsb pminuw pminsd pminud \
	roundps roundss roundpd roundsd \
	insertps pinsrb pinsrd pinsrq \
	extractps pextrb pextrd pextrq \
	pmovsxbw pmovsxbd pmovsxbq pmovsxwd pmovsxwq pmovsxdq \
	pmovzxbw pmovzxbd pmovzxbq pmovzxwd pmovzxwq pmovzxdq \
	ptest \
	pcmpeqq \
	packusdw \
	movntdqa

sse42_instruction=pcmpgtq \
	pcmpestri pcmpestrm pcmpistri pcmpistrm

aes_instruction=aesenc aesenclast aesdec aesdeclast aeskeygenassist aesimc

padlock_instruction=xcryptcbc xcryptcfb xcryptctr xcryptecb xcryptofb \
	xsha1 xsha256 montmul xstore


avx_instruction=vaddss vaddps vaddsd vaddpd vsubss vsubps vsubsd vsubpd \
	vaddsubps vaddsubpd \
	vhaddps vhaddpd vhsubps vhsubpd \
	vmulss vmulps vmulsd vmulpd \
	vmaxss vmaxps vmaxsd vmaxpd vminss vminps vminsd vminpd \
	vandps vandpd vandnps vandnpd vorps vorpd vxorps vxorpd \
	vblendps vblendpd vblendvps vblendvpd \
	vcmpss vcomiss vucomiss vcmpsd vcomisd vucomisd vcmpps vcmppd \
	vcmpeqss vcmpltss vcmpless vcmpunordss vcmpneqss vcmpnltss vcmpnless vcmpordss \
	vcmpeq_uqss vcmpngess vcmpngtss vcmpfalsess vcmpneq_oqss vcmpgess vcmpgtss vcmptruess \
	vcmpeq_osss vcmplt_oqss vcmple_oqss vcmpunord_sss vcmpneq_usss vcmpnlt_uqss vcmpnle_uqss vcmpord_sss \
	vcmpeq_usss vcmpnge_uqss vcmpngt_uqss vcmpfalse_osss vcmpneq_osss vcmpge_oqss vcmpgt_oqss vcmptrue_usss \
	vcmpeqps vcmpltps vcmpleps vcmpunordps vcmpneqps vcmpnltps vcmpnleps vcmpordps \
	vcmpeq_uqps vcmpngeps vcmpngtps vcmpfalseps vcmpneq_oqps vcmpgeps vcmpgtps vcmptrueps \
	vcmpeq_osps vcmplt_oqps vcmple_oqps vcmpunord_sps vcmpneq_usps vcmpnlt_uqps vcmpnle_uqps vcmpord_sps \
	vcmpeq_usps vcmpnge_uqps vcmpngt_uqps vcmpfalse_osps vcmpneq_osps vcmpge_oqps vcmpgt_oqps vcmptrue_usps \
	vcmpeqsd vcmpltsd vcmplesd vcmpunordsd vcmpneqsd vcmpnltsd vcmpnlesd vcmpordsd \
	vcmpeq_uqsd vcmpngesd vcmpngtsd vcmpfalsesd vcmpneq_oqsd vcmpgesd vcmpgtsd vcmptruesd \
	vcmpeq_ossd vcmplt_oqsd vcmple_oqsd vcmpunord_ssd vcmpneq_ussd vcmpnlt_uqsd vcmpnle_uqsd vcmpord_ssd \
	vcmpeq_ussd vcmpnge_uqsd vcmpngt_uqsd vcmpfalse_ossd vcmpneq_ossd vcmpge_oqsd vcmpgt_oqsd vcmptrue_ussd \
	vcmpeqpd vcmpltpd vcmplepd vcmpunordpd vcmpneqpd vcmpnltpd vcmpnlepd vcmpordpd \
	vcmpeq_uqpd vcmpngepd vcmpngtpd vcmpfalsepd vcmpneq_oqpd vcmpgepd vcmpgtpd vcmptruepd \
	vcmpeq_ospd vcmplt_oqpd vcmple_oqpd vcmpunord_spd vcmpneq_uspd vcmpnlt_uqpd vcmpnle_uqpd vcmpord_spd \
	vcmpeq_uspd vcmpnge_uqpd vcmpngt_uqpd vcmpfalse_ospd vcmpneq_ospd vcmpge_oqpd vcmpgt_oqpd vcmptrue_uspd \
	vcvtsd2ss vcvtpd2ps vcvtss2sd vcvtps2pd \
	vcvtsi2ss vcvtss2si vcvttss2si \
	vcvtpi2ps vcvtps2pi vcvttps2pi \
	vcvtdq2ps vcvtps2dq vcvttps2dq \
	vcvtdq2pd vcvtpd2dq vcvttpd2dq \
	vcvtsi2sd vcvtsd2si vcvttsd2si \
	vcvtpi2pd vcvtpd2pi vcvttpd2pi \
	vdivss vdivps vdivsd vdivpd vsqrtss vsqrtps vsqrtsd vsqrtpd \
	vdpps vdppd \
	vmaskmovps vmaskmovpd \
	vmovss vmovsd vmovaps vmovapd vmovups vmovupd vmovntps vmovntpd \
	vmovhlps vmovlhps vmovlps vmovlpd vmovhps vmovhpd \
	vmovsldup vmovshdup vmovddup \
	vmovmskps vmovmskpd \
	vroundss vroundps vroundsd vroundpd \
	vrcpss vrcpps vrsqrtss vrsqrtps \
	vunpcklps vunpckhps vunpcklpd vunpckhpd \
	vbroadcastss vbroadcastsd vbroadcastf128 \
	vextractps vinsertps vextractf128 vinsertf128 \
	vshufps vshufpd vpermilps vpermilpd vperm2f128 \
	vtestps vtestpd \
	vpaddb vpaddusb vpaddsb vpaddw vpaddusw vpaddsw vpaddd vpaddq \
	vpsubb vpsubusb vpsubsb vpsubw vpsubusw vpsubsw vpsubd vpsubq \
	vphaddw vphaddsw vphaddd vphsubw vphsubsw vphsubd \
	vpsllw vpslld vpsllq vpsrlw vpsrld vpsrlq vpsraw vpsrad \
	vpand vpandn vpor vpxor \
	vpblendwb vpblendw \
	vpsignb vpsignw vpsignd \
	vpavgb vpavgw \
	vpabsb vpabsw vpabsd \
	vmovd vmovq vmovdqa vmovdqu vlddqu vmovntdq vmovntdqa vmaskmovdqu \
	vpmovsxbw vpmovsxbd vpmovsxbq vpmovsxwd vpmovsxwq vpmovsxdq \
	vpmovzxbw vpmovzxbd vpmovzxbq vpmovzxwd vpmovzxwq vpmovzxdq \
	vpackuswb vpacksswb vpackusdw vpackssdw \
	vpcmpeqb vpcmpeqw vpcmpeqd vpcmpeqq vpcmpgtb vpcmpgtw vpcmpgtd vpcmpgtq \
	vpmaddubsw vpmaddwd \
	vpmullw vpmulhuw vpmulhw vpmulhrsw vpmulld vpmuludq vpmuldq \
	vpmaxub vpmaxsb vpmaxuw vpmaxsw vpmaxud vpmaxsd \
	vpminub vpminsb vpminuw vpminsw vpminud vpminsd \
	vpmovmskb vptest \
	vpunpcklbw vpunpcklwd vpunpckldq vpunpcklqdq \
	vpunpckhbw vpunpckhwd vpunpckhdq vpunpckhqdq \
	vpslldq vpsrldq vpalignr \
	vpshufb vpshuflw vpshufhw vpshufd \
	vpextrb vpextrw vpextrd vpextrq vpinsrb vpinsrw vpinsrd vpinsrq \
	vpsadbw vmpsadbw vphminposuw \
	vpcmpestri vpcmpestrm vpcmpistri vpcmpistrm \
	vpclmulqdq vaesenc vaesenclast vaesdec vaesdeclast vaeskeygenassist vaesimc \
	vldmxcsr vstmxcsr vzeroall vzeroupper

avx2_instruction=vbroadcasti128 vpbroadcastb vpbroadcastw vpbroadcastd vpbroadcastq \
	vpblendd \
	vpermd vpermq vperm2i128 \
	vextracti128 vinserti128 \
	vpmaskmovd vpmaskmovq \
	vpsllvd vpsllvq vpsravd vpsrlvd vpsrldq \
	vpgatherdd vpgatherqd vgatherdq vgatherqq \
	vpermps vpermpd \
	vgatherdpd vgatherqpd vgatherdps vgatherqps

xop_instruction=vfrczss vfrczps vfrczsd vfrczpd \
	vpermil2ps vperlil2pd \
	vtestps vtestpd \
	vpcomub vpcomb vpcomuw vpcomw vpcomud vpcomd vpcomuq vpcomq \
	vphaddubw vphaddbw vphaddubd vphaddbd vphaddubq vphaddbq \
	vphadduwd vphaddwd vphadduwq vphaddwq vphaddudq vphadddq \
	vphsubbw vphsubwd vphsubdq \
	vpmacsdd vpmacssdd vpmacsdql vpmacssdql vpmacsdqh vpmacssdqh \
	vpmacsww vpmacssww vpmacswd vpmacsswd \
	vpmadcswd vpmadcsswd \
	vpcmov vpperm \
	vprotb vprotw vprotd vprotq \
	vpshab vpshaw vpshad vpshaq \
	vpshlb vpshlw vpshld vpshlq

cvt16_instruction=vcvtph2ps vcvtps2ph

fma4_instruction=vfmaddss vfmaddps vfmaddsd vfmaddpd \
	vfmsubss vfmsubps vfmsubsd vfmsubpd \
	vnfmaddss vnfmaddps vnfmaddsd vnfmaddpd \
	vnfmsubss vnfmsubps vnfmsubsd vnfmsubpd \
	vfmaddsubps vfmaddsubpd vfmsubaddps vfmsubaddpd

fma3_instruction=vfmadd132ss vfmadd213ss vfmadd231ss \
	vfmadd132ps vfmadd213ps vfmadd231ps \
	vfmadd132sd vfmadd213sd vfmadd231sd \
	vfmadd132pd vfmadd213pd vfmadd231pd \
	vfmaddsub132ps vfmaddsub213ps vfmaddsub231ps \
	vfmaddsub132pd vfmaddsub213pd vfmaddsub231pd \
	vfmsubadd132ps vfmsubadd213ps vfmsubadd231ps \
	vfmsubadd132pd vfmsubadd213pd vfmsubadd231pd \
	vfmsub132ss vfmsub213ss vfmsub231ss \
	vfmsub132ps vfmsub213ps vfmsub231ps \
	vfmsub132sd vfmsub213sd vfmsub231sd \
	vfmsub132pd vfmsub213pd vfmsub231pd \
	vfnmadd132ss vfnmadd213ss vfnmadd231ss \
	vfnmadd132ps vfnmadd213ps vfnmadd231ps \
	vfnmadd132sd vfnmadd213sd vfnmadd231sd \
	vfnmadd132pd vfnmadd213pd vfnmadd231pd \
	vfnmsub132ss vfnmsub213ss vfnmsub231ss \
	vfnmsub132ps vfnmsub213ps vfnmsub231ps \
	vfnmsub132sd vfnmsub213sd vfnmsub231sd \
	vfnmsub132pd vfnmsub213pd vfnmsub231pd

register=al ah bl bh cl ch dl dh \
	ax bx cx dx si di bp \
	eax ebx ecx edx esi edi ebx esp \
	st0 st1 st2 st3 st4 st5 st6 st7 \
	mm0 mm1 mm2 mm3 mm4 mm5 mm6 mm7 \
	xmm0 xmm1 xmm2 xmm3 xmm4 xmm5 xmm6 xmm7 \
	ymm0 ymm1 ymm2 ymm3 ymm4 ymm5 ymm6 ymm7 \
	fs

register_64=sil dil bpl \
	r8b r9b r10b r11b r12b r13b r14b r15b \
	r8w r9w r10w r11w r12w r13w r14w r15w \
	rax rcx rdx rbx rsp rbp rsi rdi \
	r8 r9 r10 r11 r12 r13 r14 r15 \
	xmm8 xmm9 xmm10 xmm11 xmm12 xmm13 xmm14 xmm15 \
	ymm8 ymm9 ymm10 ymm11 ymm12 ymm13 ymm14 ymm15 \
	gs

directive_nasm=db dw dd dq dt do dy \
	resb resw resd resq rest reso resy incbin equ times safeseh \
	__utf16__ __utf32__ %+ \
	default cpu float start imagebase osabi \
	..start ..imagebase ..gotpc ..gotoff ..gottpoff ..got ..plt ..sym ..tlsie \
	section segment __sect__ group absolute \
	.bss .comment .data .lbss .ldata .lrodata .rdata .rodata .tbss .tdata .text \
	alloc bss code exec data noalloc nobits noexec nowrite progbits rdata tls write \
	private public common stack overlay class \
	extern global common import export \
	%define %idefine %xdefine %ixdefine %assign %undef %? %?? \
	%defstr %idefstr %deftok %ideftok \
	%strcat %strlen %substr \
	%macro %imacro %rmacro %exitmacro %endmacro %unmacro \
	%if %ifn %elif %elifn %else %endif \
	%ifdef %ifndef %elifdef %elifndef \
	%ifmacro %ifnmacro %elifmacro %elifnmacro \
	%ifctx %ifnctx %elifctx %elifnctx \
	%ifidn %ifnidn %elifidn %elifnidn \
	%ifidni %ifnidni %elifidni %elifnidni \
	%ifid %ifnid %elifid %elifnid \
	%ifnum %ifnnum %elifnum %elifnnum \
	%ifstr %ifnstr %elifstr %elifnstr \
	%iftoken %ifntoken %eliftoken %elifntoken \
	%ifempty %elifempty %ifnempty %elifnempty \
	%ifenv %ifnenv %elifenv %elifnenv \
	%rep %exitrep %endrep \
	%while %exitwhile %endwhile \
	%include %pathsearch %depend %use \
	%push %pop %repl %arg %local %stacksize flat flat64 large small \
	%error %warning %fatal \
	%00 .nolist %rotate %line %! %final %clear \
	struc endstruc istruc at iend \
	align alignb sectalign \
	bits use16 use32 use64 \
	__nasm_major__ __nasm_minor__ __nasm_subminor__ ___nasm_patchlevel__ \
	__nasm_version_id__ __nasm_ver__ \
	__file__ __line__ __pass__ __bits__ __output_format__ \
	__date__ __time__ __date_num__ __time_num__ __posix_time__ \
	__utc_date__ __utc_time__ __utc_date_num__ __utc_time_num__ \
	__float_daz__ __float_round__ __float__ \
	__use_altreg__ altreg \
	__use_smartalign__ smartalign __alignmode__ \
	__use_fp__ __infinity__ __nan__ __qnan__ __snan__ \
	__float8__ __float16__ __float32__ __float64__ __float80m__ __float80e__ __float128l__ __float128h__

directive_operand_nasm=a16 a32 a64 o16 o32 o64 strict \
	byte word dword qword tword oword yword nosplit \
	%0 %1 %2 %3 %4 %5 %6 %7 %8 %9 \
	abs rel \
	$ $$ \
	seg wrt

keywords.$(file.patterns.asm)=$(bcd_instruction) $(flow_instruction) $(alu_instruction) $(mem_instruction) $(stack_instruction) $(pred_instruction) $(flag_instruction) $(cmov_instruction) $(prefix_instruction) $(string_instruction) $(info_instruction) $(lwp_instruction) $(ext_instruction) $(bmi1_instruction) $(bmi2_instruction)
keywords2.$(file.patterns.asm)=$(fpu_instruction)
keywords3.$(file.patterns.asm)=$(register) $(register_64)
keywords4.$(file.patterns.asm)=$(directive_nasm)
keywords5.$(file.patterns.asm)=$(directive_operand_nasm)
keywords6.$(file.patterns.asm)=$(mmx_instruction) $(mmx2_instruction) $(emmx_instruction) $(k3d_instruction) $(k3d2_instruction) $(k3dgeode_instruction) $(k3dprefetch_instruction) $(sse_instruction) $(sse2_instruction) $(sse3_instruction) $(ssse3_instruction) $(sse4a_instruction) $(sse41_instruction) $(sse42_instruction) $(aes_instruction) $(padlock_instruction) $(avx_instruction) $(avx2_instruction) $(xop_instruction) $(cvt16_instruction) $(fma4_instruction) $(fma3_instruction)

keywords.$(file.patterns.as)=$(bcd_instruction) $(flow_instruction) $(alu_instruction) $(mem_instruction) $(stack_instruction) $(pred_instruction) $(flag_instruction) $(cmov_instruction) $(prefix_instruction) $(string_instruction) $(info_instruction) $(lwp_instruction) $(ext_instruction) $(bmi1_instruction) $(bmi2_instruction)
keywords2.$(file.patterns.as)=$(fpu_instruction)
keywords3.$(file.patterns.as)=$(register) $(register_64)
keywords4.$(file.patterns.as)=$(directive_nasm)
keywords5.$(file.patterns.as)=$(directive_operand_nasm)
keywords6.$(file.patterns.as)=$(mmx_instruction) $(mmx2_instruction) $(emmx_instruction) $(k3d_instruction) $(k3d2_instruction) $(k3dgeode_instruction) $(k3dprefetch_instruction) $(sse_instruction) $(sse2_instruction) $(sse3_instruction) $(ssse3_instruction) $(sse4a_instruction) $(sse41_instruction) $(sse42_instruction) $(aes_instruction) $(padlock_instruction) $(avx_instruction) $(avx2_instruction) $(xop_instruction) $(cvt16_instruction) $(fma4_instruction) $(fma3_instruction)

comment.block.asm=;
comment.block.as=#


# Assembler Styles
#$(colour.code.comment.line),font:Comic Sans MS,size:8
#fore:#0000ff


command.compile.$(file.patterns.asm)=nasm $(FileNameExt)

command.name.0.*.asm=Link
command.0.*.asm=link $(FileName)


statement.indent.$(file.patterns.asm)=9 .if
statement.indent.$(file.patterns.as)=9 .if



###############################################################################
# From asn1.properties
# Define SciTE settings for ASN.1 MIB definition files.

filter.asn1=ASN.1 (asn1)|*.mib|

*filter.asn1=$(filter.asn1)

file.patterns.asn1=*.mib

lexer.$(file.patterns.asn1)=asn1

*language.asn=ASN.1|mib||

# ASN.1 styles

# Keywords
keywords.$(file.patterns.asn1)=\
ACCESS AGENT AUGMENTS \
BEGIN BITS \
CAPABILITIES CHOICE COMPLIANCE CONTACT CONVENTION \
DEFINITIONS DEFVAL DESCRIPTION DISPLAY \
END ENTERPRISE EXPORTS \
FALSE FROM \
GROUP GROUPS \
HINT \
IDENTITY IMPLIED IMPORTS INCLUDES INDEX INFO \
LAST \
MANDATORY MAX MIN MODULE \
NOTATION NOTIFICATION NULL \
OBJECTS OBJECT-TYPE OF ORGANIZATION \
PRODUCT \
RELEASE REFERENCE REQUIRES REVISION \
SEQUENCE SIZE STATUS SUPPORTS SYNTAX \
TEXTUAL TRAP TYPE TRAP-TYPE \
UPDATED \
VALUE VARIABLES VARIATION \
WRITE

# Attributes
keywords2.$(file.patterns.asn1)=\
accessible \
create current \
deprecated \
for \
mandatory \
not notify not-accessible \
obsolete only optional \
read read-only read-write \
write

# Descriptors
keywords3.$(file.patterns.asn1)=\
ABSENT ANY APPLICATION \
BIT BOOLEAN BY \
COMPONENT COMPONENTS \
DEFAULT DEFINED \
ENUMERATED EXPLICIT EXTERNAL \
IMPLICIT INIFINITY \
MAX MIN MINUS \
OPTIONAL \
PRESENT PRIVATE \
REAL \
SET \
TAGS TRUE

# Types
keywords4.$(file.patterns.asn1)=\
Counter Counter32 Counter64 \
DisplayString \
Gauge Gauge32 \
IDENTIFIER INTEGER Integer32 IpAddress \
NetworkAddress NsapAddress \
OBJECT OCTET Opaque \
PhysAddress \
STRING \
TimeTicks \
UInteger32 UNITS Unsigned32




###############################################################################
# From au3.properties
# Define SciTE settings for AutoIt files.
#
# SciTE settings for AutoIt 3.3.14.2

# File filters, patterns, language, lexer and source
file.patterns.au3=*.au3
filter.au3=AutoIt (au3)|$(file.patterns.au3)|
lexer.$(file.patterns.au3)=au3

*filter.au3=$(filter.au3)
*language.au3=AutoIt|au3||
*source.patterns.au3=$(file.patterns.au3);

# Autocomplete and CallTip
autocomplete.au3.ignorecase=1
autocomplete.au3.start.characters=$(chars.alpha)$(chars.numeric)_@#$
calltip.au3.end.definition=)
calltip.au3.ignorecase=1
calltip.au3.use.escapes=1
calltip.au3.word.characters=$(chars.alpha)$(chars.numeric)_.
word.characters.$(file.patterns.au3)=$(chars.alpha)$(chars.numeric)$(chars.accented)_@#$.

# Indentation
indent.size.$(file.patterns.au3)=4
tab.size.$(file.patterns.au3)=4
use.tabs.$(file.patterns.au3)=1

block.start.$(file.patterns.au3)=5\
 case if do for func else elseif while select switch with\
 Case If Do For Func Else ElseIf While Select Switch With\
 CASE IF DO FOR FUNC ELSE ELSEIF WHILE SELECT SWITCH WITH

block.end.$(file.patterns.au3)=5\
 case else endif elseif endfunc endselect endswitch next until wend endwith\
 Case Else EndIf ElseIf EndFunc EndSelect EndSwitch Next Until WEnd EndWith Wend\
 CASE ELSE ENDIF ELSEIF ENDFUNC ENDSELECT ENDSWITCH NEXT UNTIL WEND ENDWITH

# Comment Block, Box and Stream
comment.block.au3=;~
comment.block.at.line.start.au3=1
comment.box.start.au3=#cs
comment.box.middle.au3=;
comment.box.end.au3=#ce
comment.stream.start.au3=#cs
comment.stream.end.au3=#ce

# Au3 keywords
# Imported Scite4AutoIt3 files may resolve i.e. $(au3.variables.used) as keyword values

# Keyword
keywords.$(file.patterns.au3)=and byref case const continuecase continueloop default dim\
 do else elseif endfunc endif endselect endswitch endwith enum exit exitloop false\
 for func global if in local next not null or redim return select static step switch\
 then to true until volatile wend while with

# Function
keywords2.$(file.patterns.au3)=abs acos adlibregister adlibunregister asc ascw asin assign\
 atan autoitsetoption autoitwingettitle autoitwinsettitle beep binary binarylen binarymid\
 binarytostring bitand bitnot bitor bitrotate bitshift bitxor blockinput break call\
 cdtray ceiling chr chrw clipget clipput consoleread consolewrite consolewriteerror\
 controlclick controlcommand controldisable controlenable controlfocus controlgetfocus\
 controlgethandle controlgetpos controlgettext controlhide controllistview controlmove\
 controlsend controlsettext controlshow controltreeview cos dec dircopy dircreate\
 dirgetsize dirmove dirremove dllcall dllcalladdress dllcallbackfree dllcallbackgetptr\
 dllcallbackregister dllclose dllopen dllstructcreate dllstructgetdata dllstructgetptr\
 dllstructgetsize dllstructsetdata drivegetdrive drivegetfilesystem drivegetlabel\
 drivegetserial drivegettype drivemapadd drivemapdel drivemapget drivesetlabel drivespacefree\
 drivespacetotal drivestatus envget envset envupdate eval execute exp filechangedir\
 fileclose filecopy filecreatentfslink filecreateshortcut filedelete fileexists filefindfirstfile\
 filefindnextfile fileflush filegetattrib filegetencoding filegetlongname filegetpos\
 filegetshortcut filegetshortname filegetsize filegettime filegetversion fileinstall\
 filemove fileopen fileopendialog fileread filereadline filereadtoarray filerecycle\
 filerecycleempty filesavedialog fileselectfolder filesetattrib filesetend filesetpos\
 filesettime filewrite filewriteline floor ftpsetproxy funcname guicreate guictrlcreateavi\
 guictrlcreatebutton guictrlcreatecheckbox guictrlcreatecombo guictrlcreatecontextmenu\
 guictrlcreatedate guictrlcreatedummy guictrlcreateedit guictrlcreategraphic guictrlcreategroup\
 guictrlcreateicon guictrlcreateinput guictrlcreatelabel guictrlcreatelist guictrlcreatelistview\
 guictrlcreatelistviewitem guictrlcreatemenu guictrlcreatemenuitem guictrlcreatemonthcal\
 guictrlcreateobj guictrlcreatepic guictrlcreateprogress guictrlcreateradio guictrlcreateslider\
 guictrlcreatetab guictrlcreatetabitem guictrlcreatetreeview guictrlcreatetreeviewitem\
 guictrlcreateupdown guictrldelete guictrlgethandle guictrlgetstate guictrlread guictrlrecvmsg\
 guictrlregisterlistviewsort guictrlsendmsg guictrlsendtodummy guictrlsetbkcolor guictrlsetcolor\
 guictrlsetcursor guictrlsetdata guictrlsetdefbkcolor guictrlsetdefcolor guictrlsetfont\
 guictrlsetgraphic guictrlsetimage guictrlsetlimit guictrlsetonevent guictrlsetpos\
 guictrlsetresizing guictrlsetstate guictrlsetstyle guictrlsettip guidelete guigetcursorinfo\
 guigetmsg guigetstyle guiregistermsg guisetaccelerators guisetbkcolor guisetcoord\
 guisetcursor guisetfont guisethelp guiseticon guisetonevent guisetstate guisetstyle\
 guistartgroup guiswitch hex hotkeyset httpsetproxy httpsetuseragent hwnd inetclose\
 inetget inetgetinfo inetgetsize inetread inidelete iniread inireadsection inireadsectionnames\
 inirenamesection iniwrite iniwritesection inputbox int isadmin isarray isbinary isbool\
 isdeclared isdllstruct isfloat isfunc ishwnd isint iskeyword isnumber isobj isptr\
 isstring log memgetstats mod mouseclick mouseclickdrag mousedown mousegetcursor mousegetpos\
 mousemove mouseup mousewheel msgbox number objcreate objcreateinterface objevent\
 objevent objget objname onautoitexitregister onautoitexitunregister opt ping pixelchecksum\
 pixelgetcolor pixelsearch processclose processexists processgetstats processlist\
 processsetpriority processwait processwaitclose progressoff progresson progressset\
 ptr random regdelete regenumkey regenumval regread regwrite round run runas runaswait\
 runwait send sendkeepactive seterror setextended shellexecute shellexecutewait shutdown\
 sin sleep soundplay soundsetwavevolume splashimageon splashoff splashtexton sqrt\
 srandom statusbargettext stderrread stdinwrite stdioclose stdoutread string stringaddcr\
 stringcompare stringformat stringfromasciiarray stringinstr stringisalnum stringisalpha\
 stringisascii stringisdigit stringisfloat stringisint stringislower stringisspace\
 stringisupper stringisxdigit stringleft stringlen stringlower stringmid stringregexp\
 stringregexpreplace stringreplace stringreverse stringright stringsplit stringstripcr\
 stringstripws stringtoasciiarray stringtobinary stringtrimleft stringtrimright stringupper\
 tan tcpaccept tcpclosesocket tcpconnect tcplisten tcpnametoip tcprecv tcpsend tcpshutdown\
 tcpstartup timerdiff timerinit tooltip traycreateitem traycreatemenu traygetmsg trayitemdelete\
 trayitemgethandle trayitemgetstate trayitemgettext trayitemsetonevent trayitemsetstate\
 trayitemsettext traysetclick trayseticon traysetonevent traysetpauseicon traysetstate\
 traysettooltip traytip ubound udpbind udpclosesocket udpopen udprecv udpsend udpshutdown\
 udpstartup vargettype winactivate winactive winclose winexists winflash wingetcaretpos\
 wingetclasslist wingetclientsize wingethandle wingetpos wingetprocess wingetstate\
 wingettext wingettitle winkill winlist winmenuselectitem winminimizeall winminimizeallundo\
 winmove winsetontop winsetstate winsettitle winsettrans winwait winwaitactive winwaitclose\
 winwaitnotactive

# Macro
keywords3.$(file.patterns.au3)=@appdatacommondir @appdatadir @autoitexe @autoitpid @autoitversion\
 @autoitx64 @com_eventobj @commonfilesdir @compiled @computername @comspec @cpuarch\
 @cr @crlf @desktopcommondir @desktopdepth @desktopdir @desktopheight @desktoprefresh\
 @desktopwidth @documentscommondir @error @exitcode @exitmethod @extended @favoritescommondir\
 @favoritesdir @gui_ctrlhandle @gui_ctrlid @gui_dragfile @gui_dragid @gui_dropid @gui_winhandle\
 @homedrive @homepath @homeshare @hotkeypressed @hour @ipaddress1 @ipaddress2 @ipaddress3\
 @ipaddress4 @kblayout @lf @localappdatadir @logondnsdomain @logondomain @logonserver\
 @mday @min @mon @msec @muilang @mydocumentsdir @numparams @osarch @osbuild @oslang\
 @osservicepack @ostype @osversion @programfilesdir @programscommondir @programsdir\
 @scriptdir @scriptfullpath @scriptlinenumber @scriptname @sec @startmenucommondir\
 @startmenudir @startupcommondir @startupdir @sw_disable @sw_enable @sw_hide @sw_lock\
 @sw_maximize @sw_minimize @sw_restore @sw_show @sw_showdefault @sw_showmaximized\
 @sw_showminimized @sw_showminnoactive @sw_showna @sw_shownoactivate @sw_shownormal\
 @sw_unlock @systemdir @tab @tempdir @tray_id @trayiconflashing @trayiconvisible @username\
 @userprofiledir @wday @windowsdir @workingdir @yday @year

# Send key
keywords4.$(file.patterns.au3)={!} {#} {^} {{} {}} {+} {alt} {altdown} {altup} {appskey}\
 {asc} {backspace} {break} {browser_back} {browser_favorites} {browser_forward} {browser_home}\
 {browser_refresh} {browser_search} {browser_stop} {bs} {capslock} {ctrldown} {ctrlup}\
 {del} {delete} {down} {end} {enter} {esc} {escape} {f1} {f10} {f11} {f12} {f2} {f3}\
 {f4} {f5} {f6} {f7} {f8} {f9} {home} {ins} {insert} {lalt} {launch_app1} {launch_app2}\
 {launch_mail} {launch_media} {lctrl} {left} {lshift} {lwin} {lwindown} {lwinup} {media_next}\
 {media_play_pause} {media_prev} {media_stop} {numlock} {numpad0} {numpad1} {numpad2}\
 {numpad3} {numpad4} {numpad5} {numpad6} {numpad7} {numpad8} {numpad9} {numpadadd}\
 {numpaddiv} {numpaddot} {numpadenter} {numpadmult} {numpadsub} {oem_102} {pause}\
 {pgdn} {pgup} {printscreen} {ralt} {rctrl} {right} {rshift} {rwin} {rwindown} {rwinup}\
 {scrolllock} {shiftdown} {shiftup} {sleep} {space} {tab} {up} {volume_down} {volume_mute}\
 {volume_up}

# Pre-Processor
keywords5.$(file.patterns.au3)=#ce #comments-end #comments-start #cs #include #include-once\
#notrayicon #onautoitstartregister #requireadmin

# Special
keywords6.$(file.patterns.au3)=#endregion #forcedef #forceref #ignorefunc #pragma #region\
 $(autoit3wrapper.keywords.special)

# Abbrev-Expand
keywords7.$(file.patterns.au3)=$(au3.keywords.abbrev) $(au3.keywords.userabbrev)

# Standard UDF
keywords8.$(file.patterns.au3)=$(au3.keywords.udfs)

# Au3 styles


# Properties using paths

# Directory containing AutoIt program files
autoit3dir=$(SciteDefaultHome)\..

# API path
api.$(file.patterns.au3)=$(SciteDefaultHome)\api\au3.api;$(SciteDefaultHome)\api\au3.autoit3wrapper.api;$(SciteUserHome)\au3.user.calltips.api

# Commands for F1 Help
command.help.$(file.patterns.au3)=$(CurrentWord)!$(autoit3dir)\AutoIt.chm
command.help.subsystem.$(file.patterns.au3)=4

# Commands to Compile, Build and Go
command.compile.$(file.patterns.au3)="$(autoit3dir)\Aut2Exe\Aut2exe.exe" /in "$(FilePath)"
command.build.$(file.patterns.au3)="$(autoit3dir)\Aut2Exe\Aut2exe.exe" /in "$(FilePath)" /x64
command.go.$(file.patterns.au3)="$(autoit3dir)\AutoIt3.exe" /ErrorStdOut "$(FilePath)" $(1) $(2) $(3) $(4)

# Au3Check
command.0.$(file.patterns.au3)="$(autoit3dir)\Au3Check.exe" -q "$(FilePath)"
command.name.0.$(file.patterns.au3)=Syntax Check
command.shortcut.0.$(file.patterns.au3)=Ctrl+F5
command.save.before.0.$(file.patterns.au3)=1



###############################################################################
# From ave.properties
# Define SciTE settings for Avenue files.

filter.ave=AVE (ave)|*.ave|

*filter.ave=$(filter.ave)

file.patterns.ave=*.ave

lexer.*.ave=ave
lexer.$(file.patterns.ave)=ave

*language.avenue=Avenue|ave||

####################################################
# import classes and requests
# files ave.classes &  ave.funcs is to large
#import ave.classes
#import ave.funcs

keywords.$(file.patterns.ave)=nil true false else for if while then elseif end av self in exit
#keywords2.$(file.patterns.ave)=$(keywordclass.ave)
#keywords3.$(file.patterns.ave)=$(keywordfunc.ave)
word.chars.ave=$(chars.alpha)$(chars.numeric)_#
word.characters.$(file.patterns.ave)=$(word.chars.ave)

statement.indent.$(file.patterns.ave)=1 else for if while then
statement.lookback.$(file.patterns.ave)=1 end

#Avenue string not support tab symbol, if You use tabs in script all tabs automatic translated to space.
#use.tabs=0

####################################################
#Load user-defined api for current project.
#api.$(file.patterns.ave)=ave.api
####################################################

comment.block.ave='--

comment.box.start.ave='--
comment.box.middle.ave='--
comment.box.end.ave='--
#Avenue is not case-sensitive lang.
autocomplete.ave.ignorecase=1
calltip.ave.ignorecase=1
autocomplete.ave.start.characters=.
calltip.ave.word.characters=.$(word.chars.ave)

# AVE styles
############################################################
# Braces are only matched in operator style
braces.ave.style=10
############################################################


avenue=ave "$(FilePath)"
avenueGo=avego "$(FilePath)"
avenueBuild=avebuild "$(FilePath)"

################################################################
#use winhlp32 system
#if ArcView installed in other directory please correct path <C:\ESRI\AV_GIS30\ARCVIEW\HELP\ARCVIEW>
#command.help.$(file.patterns.ave)=$(CurrentWord)!C:\ESRI\AV_GIS30\ARCVIEW\HELP\ARCVIEW
#command.help.subsystem.$(file.patterns.ave)=5


#~ # compile
#~ command.compile.$(file.patterns.ave)=$(avenue)
#~ command.go.$(file.patterns.ave)=$(avenueGo)
#~ #send to arcview
#~ command.name.0.*.ave=Insert into project
#~ command.0.*.ave=$(avenueBuild)
#~ command.subsystem.0.*.ave=1

#~ command.name.1.*.ave=Variables Report
#~ command.1.*.ave=VarsReport.exe  "$(FilePath)"



###############################################################################
# From avs.properties
# Define SciTE settings for AviSynth scripts.

file.patterns.avs=*.avs;*.avsi

filter.avs=AviSynth (avs avsi)|$(file.patterns.avs)|

lexer.$(file.patterns.avs)=avs

word.chars.avs=$(chars.alpha)$(chars.numeric)_#
word.characters.$(file.patterns.avs)=$(word.chars.avs)

autocomplete.avs.ignorecase=1
autocomplete.avs.fillups=(
calltip.avs_quote.ignorecase=1
calltip.avs.word.characters=$(word.chars.avs)

comment.block.at.line.start.avs=1
comment.block.avs=#~
comment.stream.start.avs=/*
comment.stream.end.avs=*/
comment.box.start.avs=/*
comment.box.middle.avs= *
comment.box.end.avs= */

# Keywords
keywords.$(file.patterns.avs)=true false return global

# Filters
keywords2.$(file.patterns.avs)=addborders alignedsplice amplify amplifydb animate applyrange assumebff \
assumefieldbased assumefps assumeframebased assumesamplerate assumescaledfps assumetff audiodub audiodubex \
avifilesource avisource bicubicresize bilinearresize blackmanresize blackness blankclip blur bob cache \
changefps colorbars colorkeymask coloryuv compare complementparity conditionalfilter conditionalreader \
convertaudio convertaudioto16bit convertaudioto24bit convertaudioto32bit convertaudioto8bit convertaudiotofloat \
convertbacktoyuy2 convertfps converttobackyuy2 converttomono converttorgb converttorgb24 converttorgb32 \
converttoy8 converttoyv16 converttoyv24 converttoyv411 converttoyuy2 converttoyv12 crop cropbottom delayaudio \
deleteframe dissolve distributor doubleweave duplicateframe ensurevbrmp3sync fadein fadein0 fadein2 fadeio fadeio0 \
fadeio2 fadeout fadeout0 fadeout2 fixbrokenchromaupsampling fixluminance fliphorizontal flipvertical frameevaluate \
freezeframe gaussresize generalconvolution getchannel getchannels getmtmode getparity grayscale greyscale histogram \
horizontalreduceby2 imagereader imagesource imagewriter info interleave internalcache internalcachemt invert killaudio \
killvideo lanczos4resize lanczosresize layer letterbox levels limiter loop mask maskhs max merge mergeargb mergechannels \
mergechroma mergeluma mergergb messageclip min mixaudio monotostereo normalize null opendmlsource overlay peculiarblend \
pointresize pulldown reduceby2 resampleaudio resetmask reverse rgbadjust scriptclip segmentedavisource segmenteddirectshowsource \
selecteven selectevery selectodd selectrangeevery separatefields setmtmode sharpen showalpha showblue showfiveversions \
showframenumber showgreen showred showsmpte showtime sincresize skewrows spatialsoften spline16resize spline36resize \
spline64resize ssrc stackhorizontal stackvertical subtitle subtract supereq swapfields swapuv temporalsoften timestretch \
tone trim turn180 turnleft turnright tweak unalignedsplice utoy utoy8 version verticalreduceby2 vtoy vtoy8 wavsource \
weave writefile writefileend writefileif writefilestart ytouv

# Plugins
keywords3.$(file.patterns.avs)=addgrain addgrainc agc_hdragc analyzelogo animeivtc asharp audiograph autocrop \
autoyuy2 avsrecursion awarpsharp bassaudiosource bicublinresize bifrost binarize blendfields blindpp blockbuster \
bordercontrol cfielddiff cframediff chromashift cnr2 colormatrix combmask contra convolution3d convolution3dyv12 \
dctfilter ddcc deblendlogo deblock deblock_qed decimate decomb dedup deen deflate degrainmedian depan depanestimate \
depaninterleave depanscenes depanstabilize descratch despot dfttest dgbob dgsource directshowsource distancefunction \
dss2 dup dupmc edeen edgemask ediupsizer eedi2 eedi3 eedi3_rpow2 expand faerydust fastbicubicresize fastbilinearresize \
fastediupsizer dedgemask fdecimate ffaudiosource ffdshow ffindex ffmpegsource ffmpegsource2 fft3dfilter fft3dgpu \
ffvideosource fielddeinterlace fielddiff fillmargins fity2uv fity2u fity2v fitu2y fitv2y fluxsmooth fluxsmoothst fluxsmootht \
framediff framenumber frfun3b frfun7 gicocu golddust gradfun2db grapesmoother greedyhma grid guavacomb hqdn3d hybridfupp \
hysteresymask ibob improvesceneswitch inflate inpand inpaintlogo interframe interlacedresize interlacedwarpedresize \
interleaved2planar iscombed iscombedt iscombedtivtc kerneldeint leakkernelbob leakkerneldeint limitedsharpen limitedsharpenfaster \
logic lsfmod lumafilter lumayv12 manalyse maskeddeinterlace maskedmerge maskedmix mblockfps mcompensate mctemporaldenoise \
mctemporaldenoisepp mdegrain1 mdegrain2 mdegrain3 mdepan medianblur mergehints mflow mflowblur mflowfps mflowinter minblur mipsmooth \
mmask moderatesharpen monitorfilter motionmask mpasource mpeg2source mrecalculate mscdetection msharpen mshow msmooth msu_fieldshiftfixer \
msu_frc msuper mt mt_adddiff mt_average mt_binarize mt_circle mt_clamp mt_convolution mt_deflate mt_diamond mt_edge mt_ellipse \
mt_expand mt_freeellipse mt_freelosange mt_freerectangle mt_hysteresis mt_infix mt_inflate mt_inpand mt_invert mt_logic mt_losange \
mt_lut mt_lutf mt_luts mt_lutspa mt_lutsx mt_lutxy mt_lutxyz mt_makediff mt_mappedblur mt_merge mt_motion mt_polish mt_rectangle \
mt_square mti mtsource multidecimate mvanalyse mvblockfps mvchangecompensate mvcompensate mvdegrain1 mvdegrain2 mvdegrain3 mvdenoise \
mvdepan mvflow mvflowblur mvflowfps mvflowfps2 mvflowinter mvincrease mvmask mvrecalculate mvscdetection mvshow nicac3source nicdtssource \
niclpcmsource nicmpasource nicmpg123source nnedi nnedi2 nnedi2_rpow2 nnedi3 nnedi3_rpow2 nomosmooth overlaymask peachsmoother pixiedust \
planar2interleaved qtgmc qtinput rawavsource rawsource reduceflicker reinterpolate411 removedirt removedust removegrain removegrainhd \
removetemporalgrain repair requestlinear reversefielddominance rgb3dlut rgdeinterlace rgsdeinterlace rgblut rotate sangnom seesaw sharpen2 \
showchannels showcombedtivtc smartdecimate smartdeinterlace smdegrain smoothdeinterlace smoothuv soothess soxfilter spacedust sshiq ssim \
ssiq stmedianfilter t3dlut tanisotropic tbilateral tcanny tcomb tcombmask tcpserver tcpsource tdecimate tdeint tedgemask telecide \
temporalcleaner temporalrepair temporalsmoother tfieldblank tfm tisophote tivtc tmaskblank tmaskedmerge tmaskedmerge3 tmm tmonitor tnlmeans \
tomsmocomp toon textsub ttempsmooth ttempsmoothf tunsharp unblock uncomb undot unfilter unsharpmask vaguedenoiser variableblur verticalcleaner \
videoscope vinverse vobsub vqmcalc warpedresize warpsharp xsharpen yadif yadifmod yuy2lut yv12convolution yv12interlacedreduceby2 \
yv12interlacedselecttopfields yv12layer yv12lut yv12lutxy yv12substract yv12torgb24 yv12toyuy2

# Functions
keywords4.$(file.patterns.avs)=abs apply assert bool ceil chr clip continueddenominator continuednumerator cos default defined \
eval averagechromau averagechromav averageluma chromaudifference chromavdifference lumadifference exist exp findstr float floor \
frac hexvalue import int isbool isclip isfloat isint isstring lcase leftstr load_stdcall_plugin loadcplugin loadplugin loadvfapiplugin \
loadvirtualdubplugin log midstr muldiv nop opt_allowfloataudio opt_avipadscanlines opt_dwchannelmask opt_usewaveextensible \
opt_vdubplanarhack pi pow rand revstr rightstr round scriptdir scriptfile scriptname select setmemorymax setplanarlegacyalignment \
rgbdifference rgbdifferencefromprevious rgbdifferencetonext udifferencefromprevious udifferencetonext setworkingdir sign sin spline \
sqrt string strlen time ucase undefined value versionnumber versionstring uplanemax uplanemedian uplanemin uplaneminmaxdifference \
vdifferencefromprevious vdifferencetonext vplanemax vplanemedian vplanemin vplaneminmaxdifference ydifferencefromprevious \
ydifferencetonext yplanemax yplanemedian yplanemin yplaneminmaxdifference

# Clip properties
keywords5.$(file.patterns.avs)=audiobits audiochannels audiolength audiolengthf audiorate framecount framerate frameratedenominator \
frameratenumerator getleftchannel getrightchannel hasaudio hasvideo height isaudiofloat isaudioint isfieldbased isframebased \
isinterleaved isplanar isrgb isrgb24 isrgb32 isyuv isyuy2 isyv12 width

# User defined
keywords6.$(file.patterns.avs)=

# AviSynth Styles

# Braces are only matched in operator style
braces.avs.style=5



###############################################################################
# From baan.properties
# Define SciTE settings for Baan files.
#set Below as per Preference.
font.baan.monospace=font:Consolas,size:10

fold.baan.keywords.based=1
fold.baan.syntax.based=0
fold.baan.sections=1
fold.baan.inner.level=0
lexer.baan.styling.within.preprocessor=1

#uncomment below, set the full path of API files. If more than one, seperate it with ';'.
#api.$(file.patterns.baan)=

#Uncomment below two properties, set the full path of CHM files.
#command.help.$(file.patterns.baan)=$(CurrentWord)!D:\
#command.help.subsystem.$(file.patterns.baan)=4

#Not much to change.  Check Baan Styles for preference.
file.patterns.baan=*.bc;*.cln

filter.baan=Baan (baan)|$(file.patterns.baan)|

*filter.baan=$(filter.baan)

lexer.$(file.patterns.baan)=baan

*language.baan=Baan|bc||

word.characters.$(file.patterns.baan)=$(chars.alpha)$(chars.numeric)_#.$
calltip.baan.word.characters=$(chars.alpha)$(chars.numeric)_#.$
autocomplete.baan.ignorecase=1
calltip.baan.ignorecase=1
autocomplete.baan.start.characters="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_."

preprocessor.symbol.$(file.patterns.baan)=#
preprocessor.start.$(file.patterns.baan)=if ifdef ifndef
preprocessor.middle.$(file.patterns.baan)=else elif
preprocessor.end.$(file.patterns.baan)=endif

# Comment blocks for Baan
comment.block.baan=|
comment.block.at.line.start.baan=1

block.start.$(file.patterns.baan)=4 case  else for  if repeat selectdo selectempty selecteos selecterror
block.end.$(file.patterns.baan)=4 else endcase  endfor  endif endselect endwhile selectempty selecteos selecterror
statement.lookback.$(file.patterns.baan)=0

# Baan styles. Change colours based on preference.
# Gray
colour.baan.whitespace=fore:#808080
#Olive
colour.baan.preproc=fore:#808000
#Magenta
colour.baan.string=fore:#FF00FF
#Teal
colour.baan.comment.doc=fore:#008080
#green
colour.baan.comment.line=fore:#008000
#Red
colour.baan.numbers=fore:#FF0000
#Maroon
colour.baan.keyword=fore:#800000
#Blue
colour.baan.keyword2=fore:#0000FF
colour.baan.keyword3=fore:#0000FF
#Orange Red
colour.baan.keyword4=fore:#FF4500 
#Purple
colour.baan.keyword5=fore:#800080
colour.baan.keyword6=fore:#FF00FF,back:#4EE2EC
colour.baan.keyword7=fore:#FF0000,back:#90EE90
colour.baan.keyword8=fore:#CC00CC,back:#FFFF99
colour.baan.keyword9=fore:#00FFFF
#DarkOrchid
colour.baan.tabledef=fore:#9932CC 
#BlueViolet
colour.baan.tablesql=fore:#8A2BE2
#Navy
colour.baan.functions=fore:#000080
#DarkGoldenrod
colour.baan.domaindef=fore:#B8860B
# FireBrick
colour.baan.funcdefs=fore:#B22222
# OrangeRed
colour.baan.objdefs=fore:#FF4500
#Dark Olive Green
colour.baan.definedefs=fore:#556B2F

colour.baan.braces.highlight=fore:#0000FF
colour.baan.braces.incomplete=fore:#FF0000
colour.baan.eol.string.not.closed=fore:#000000,back:#E0C0E0
colour.baan.operator=fore:#007F00	


# Braces are only matched in operator style
braces.baan.style=7

#Indent properties
statement.indent.$(file.patterns.baan)=12 after.choice: after.delete: after.display: after.field: after.form.read: after.form: \
after.group: after.input: after.layout: after.program: after.receive.data: after.rewrite: after.skip.delete: after.skip.rewrite: \
after.skip.write: after.update.db.commit: after.write: after.zoom: before.checks: before.choice: before.delete: before.display.object: \
before.display: before.field: before.form: before.group: before.input: before.layout: before.new.object: before.print: before.program: \
before.read: before.rewrite: before.write: before.zoom: check.input: declaration: domain.error: init.field: init.form: init.group: on.choice: \
on.display.total.line: on.entry: on.error: on.exit: on.input: read.view: ref.display: ref.input: selection.filter: when.field.changes:

#keywords Reserved Keywords (Do not Change)
keywords.$(file.patterns.baan)=alike all and array as asc at avg base based between boolean both break bset buffer by call case cast chart clear \
clearunref common const continue count cross current_date current_timestamp date date.num date.to.num debug default delete deleteempty \
deleteerror desc dim distinct dll dllusage domain double else empty end endcase enddelete enddllusage endfor endfunctionusage endif endselect \
endupdate endwhile enum_description eq escape exists extern false fatal fetching field first fixed for from full function functionusage ge global goto \
group gt having hint hints if in include index inner input inrange integer is join label last le leading left like long lt max mb menu message min multibyte \
ne no nodebug not notransactions nowarnings null on or order ordered outer path pi prepared print prompt question raw real ref reference refers repeat \
retry return right row rows select selectbind selectdo selectempty selecteos selecterror session set setunref size skip static step sticky stop strict_boolean \
string subhint sum table text_content then timestamp to trailing trim true union unref until update updateempty updateerror use used void warning warnings \
when where wherebind whereused while with

#Keywords2 Functions (Set your Functions based on Baan version & TIV level.)
keywords2.$(file.patterns.baan)=abort abort.io  \
db.after.delete db.after.insert db.after.update \
xmlSetData \
zoom.to$

#Keywords3 Functions InListAbridged (Set Functions, based on Baan Version & TIV Level.) ~.is.mandatory will work for <any.field>.is.mandatory() DAL function.
keywords3.$(file.patterns.baan)=~.is.mandatory 

#Keywords4 Sub Sections (Sub Sections should always come before main sections, because after.~: in main section would overtake after.choice: and so on). (Do Not Change)
keywords4.$(file.patterns.baan)=after.choice: after.delete: after.display: after.field: after.form: after.group: after.input: after.layout: after.read: after.rewrite: \
after.skip.delete: after.skip.rewrite: after.skip.write: after.write: after.zoom: before.checks:  before.choice: before.delete: before.display: before.field: before.form: \
before.group: before.input: before.layout: before.print: before.read: before.rewrite: before.write: before.zoom: check.input: domain.error: init.field: init.form: \
init.group: on.choice: on.entry: on.exit: on.input: read.view: ref.display: ref.input: selection.filter: when.field.changes:

#Keyword5 Main Sections InListAbridged (Do Not Change)
keywords5.$(file.patterns.baan)=after.~: before.~: choice.abort.program: choice.abort.work: choice.add.set: choice.ask.helpinfo: choice.attachments: \
choice.bms: choice.calculator: choice.calender: choice.cancel.work: choice.change.frm: choice.change.order: choice.cmd.about.baan: choice.cmd.copy: \
choice.cmd.cut: choice.cmd.options: choice.cmd.paste: choice.cont.process: choice.create.job: choice.current.work: choice.cust.grid: choice.def.find: \
choice.display.set: choice.dupl.occur: choice.end.program: choice.field.browse: choice.field.help: choice.find.data: choice.first.frm: choice.first.set: \
choice.first.view: choice.freeze.columns: choice.get.defaults: choice.global.copy: choice.global.delete: choice.glossary: choice.help.index: choice.hide.fields: \
choice.interrupt: choice.last.frm: choice.last.set: choice.last.view: choice.mark.delete: choice.mark.occur: choice.modify.set: choice.next.frm: choice.next.set: \
choice.next.view: choice.next.work: choice.prev.frm: choice.prev.set: choice.prev.view: choice.print.data: choice.processes: choice.recover.set: choice.reference: \
choice.resize.frm: choice.rotate.curr: choice.run.job: choice.save.defaults: choice.select.all: choice.send.data: choice.sendto.desktop: choice.sendto.editor: \
choice.sendto.mail: choice.sendto.tasklst: choice.start.chart: choice.start.query: choice.start.set: choice.suspend.work: choice.switch.windows: choice.synchronize: \
choice.text.manager: choice.to.clipboard: choice.unfreeze.colum: choice.update.db: choice.user.0: choice.user.1: choice.user.2: choice.user.3: choice.user.4: choice.user.5: \
choice.user.6: choice.user.7: choice.user.8: choice.user.9: choice.using.help: choice.zoom:  declaration: detail.~: field.~: footer.~: form.~: functions: group.~: \
header.~:  main.table.io: on.display.total.line: on.error: zoom.from.~:

#Keyword6 PreDefined Variables (Set these predefined variables based on your Baan Version).
keywords6.$(file.patterns.baan)=actual.occ \
zoomreturn$

#keywords7 Attributes PreDefined ( Below list needs to be typed in UPPER case in scripts, but keep it in lower here). (Set these predefined Attributes based on your Baan Version).
keywords7.$(file.patterns.baan)=__file__ \
z.session

#keywords8 Enumerate domains. Enter domain domain names starting with '^' and ending with '.'. All the enumerates would be listed. (Based on your Baan Version).
keywords8.$(file.patterns.baan)=^tcyesno. ^tdsls.corg.

#Keywords9 MACROS from standard based on your Baan Version. Write in CAPS inside the scripts, but in lower here.
keywords9.$(file.patterns.baan)=dalnew dalupdate




###############################################################################
# From blitzbasic.properties
# Define SciTE settings for BlitzBasic files.

file.patterns.blitzbasic=*.bb

filter.blitzbasic=BlitzBasic (bb)|$(file.patterns.blitzbasic)|

*filter.blitzbasic=$(filter.blitzbasic)

lexer.$(file.patterns.blitzbasic)=blitzbasic

# keywords must be all lowercase

keywordclass.blitzbasic=abs accepttcpstream acos after and apptitle asc asin atan atan2 \
automidhandle autosuspend availvidmem backbuffer banksize before bin calldll \
case ceil changedir channelpan channelpitch channelplaying channelvolume chr \
closedir closefile closemovie closetcpserver closetcpstream closeudpstream cls \
clscolor color colorblue colorgreen colorred commandline const copybank copyfile \
copyimage copypixel copypixelfast copyrect copystream cos countgfxdrivers \
countgfxmodes counthostips createbank createdir createimage createnetplayer \
createprocess createtcpserver createtimer createudpstream currentdate currentdir \
currenttime data debuglog default delay delete deletedir deletefile \
deletenetplayer desktopbuffer dim dottedip drawblock drawblockrect drawimage \
drawimagerect drawmovie each else else if elseif end end function end if end \
select end type endgraphics endif eof execfile exit exp false field filepos \
filesize filetype first flip float floor flushjoy flushkeys flushmouse \
fontheight fontname fontsize fontstyle fontwidth for forever freebank freefont \
freeimage freesound freetimer frontbuffer function gammablue gammagreen gammared \
getcolor getenv getkey getmouse gfxdrivername gfxmodedepth gfxmodeexists \
gfxmodeformat gfxmodeheight gfxmodewidth global gosub goto grabimage graphics \
graphicsbuffer graphicsdepth graphicsformat graphicsheight graphicswidth \
handleimage hex hidepointer hostip hostnetgame if imagebuffer imageheight \
imagerectcollide imagerectoverlap imagescollide imagesoverlap imagewidth \
imagexhandle imageyhandle include input insert instr int joinnetgame joydown \
joyhat joyhit joypitch joyroll joytype joyu joyudir joyv joyvdir joyx joyxdir \
joyy joyyaw joyydir joyz joyzdir keydown keyhit keywait last left len line \
loadanimimage loadbuffer loadfont loadimage loadsound local lockbuffer \
lockedformat lockedpitch lockedpixels log log10 loopsound lower lset maskimage \
mid midhandle millisecs mod morefiles mousedown mousehit mousex mousexspeed \
mousey mouseyspeed mousez mousezspeed movemouse movieheight movieplaying \
moviewidth netmsgdata netmsgfrom netmsgto netmsgtype netplayerlocal \
netplayername new next nextfile not null openfile openmovie opentcpstream or \
origin oval pausechannel pausetimer peekbyte peekfloat peekint peekshort pi \
playcdtrack playmusic playsound plot pokebyte pokefloat pokeint pokeshort print \
queryobject rand read readavail readbyte readbytes readdir readfile readfloat \
readint readline readpixel readpixelfast readshort readstring rect rectsoverlap \
recvnetmsg recvudpmsg repeat replace resettimer resizebank resizeimage restore \
resumechannel resumetimer return right rnd rndseed rotateimage rset runtimeerror \
sar savebuffer saveimage scaleimage scanline seedrnd seekfile select sendnetmsg \
sendudpmsg setbuffer setenv setfont setgamma setgfxdriver sgn shl showpointer \
shr sin soundpan soundpitch soundvolume sqr startnetgame step stop stopchannel \
stopnetgame str string stringheight stringwidth systemproperty tan tcpstreamip \
tcpstreamport tcptimeouts text tformfilter tformimage then tileblock tileimage \
timerticks to totalvidmem trim true type udpmsgip udpmsgport udpstreamip \
udpstreamport udptimeouts unlockbuffer until updategamma upper viewport vwait \
waitkey waitmouse waittimer wend while write writebyte writebytes writefile \
writefloat writeint writeline writepixel writepixelfast writeshort writestring \
xor

keywords.$(file.patterns.blitzbasic)=$(keywordclass.blitzbasic)

# BB styles
# Preprocessor
# Date
# StringEOL
# Constant
# Asm




###############################################################################
# From bullant.properties
# Define SciTE settings for Bullant files.

filter.bullant=Bullant (.ant)|*.ant|

*filter.bullant=$(filter.bullant)

file.patterns.bullant=*.ant

lexer.$(file.patterns.bullant)=bullant

*language.bullant=Bullant|ant||

keywordclass.bullant=abstract all ancestor and application \
assert attributes author \
begin \
callback class concrete config constants construct continue \
depends description downcast driver \
elif else ensures error exception exposure extension \
false fatal final function \
generics glyph \
help hidden host \
immutable in inherits is \
kernel \
label leave library locals \
mutable \
none not null \
obsolete options or other \
parameters peer private public \
raise reason restricted retry return \
returns rollback route \
security self settings severity step \
task test transaction true \
unknown \
varying \
warning when \
method end if until while trap case debug for foreach lock \
boolean \
character character$ \
date date$ datetime datetime$ \
float \
hex$ \
identifier identifier$ integer interval interval$ \
money money$ \
raw raw$ \
string \
tick tick$ time time$ \
version version$


keywords.$(file.patterns.bullant)=$(keywordclass.bullant)

# Bullant styles



# compile
command.compile.*.ant=

# normal execute
command.go.*.ant=
command.go.subsystem.*.ant=

#build=compile ...
command.build.*.ant=
command.build.subsystem.*.ant=




###############################################################################
# From caml.properties
#	Define SciTE settings for Objective Caml, Standard ML 97 files
#
#	To use with Standard ML source in .ml files, select Standard ML
#	from the SciTE Language menu (or adjust the properties below).
#
# To fully enable this Scintilla lexer, make sure the following entries
#	are present and uncommented in your SciTE properties:
#
#		$(filter.caml)\
#		$(filter.sml)\
#
#		Objective Caml|ml||\
#		Standard ML|sml||\
#
#		import caml

# OCaml/SML implementation and interface files
file.patterns.caml=*.ml;*.mli
file.patterns.sml=*.sml

*filter.objectivecaml=$(filter.caml)

filter.caml=Objective Caml (ml mli)|$(file.patterns.caml)|
filter.sml=Standard ML 97 (sml ml)|$(file.patterns.sml)|

lexer.*.caml=caml
lexer.$(file.patterns.caml)=caml
lexer.$(file.patterns.sml)=caml

#*language.objectivecaml=Objective Caml|ml||

# the line below is ONLY used as part of "external" lexer support
#lexerpath.$(file.patterns.caml)=LexCaml.dll
#lexerpath.$(file.patterns.sml)=LexCaml.dll

# the standard Objective Caml 3.09/3.10/3.11 language "textual" keywords
keywordstandard.caml= \
and as assert asr begin class \
constraint do done downto else end \
exception external false for fun function \
functor if in include inherit initializer \
land lazy let lor lsl lsr \
lxor match method mod module mutable \
new object of open or private \
rec sig struct then to true \
try type val virtual when while \
with
keywords.$(file.patterns.caml)=$(keywordstandard.caml)

# the standard Standard ML '97 language "textual" keywords
keywordstandard.sml= \
abstype andalso and as case datatype div do \
else end eqtype exception \
false fn fun functor handle if infixr infix include in let local \
mod nonfix not of open op orelse raise rec \
sharing signature sig structure struct then true type use \
val while withtype with
keywords.$(file.patterns.sml)=$(keywordstandard.sml)

# "optional" Objective Caml / library keywords; some suggested entries are here,
# more could come from, say, Pervasives ('parser' is from Camlp4)
keywordoptional1.caml= \
option Some None ignore ref lnot succ pred parser
keywords2.$(file.patterns.caml)=$(keywordoptional1.caml)

# "optional" Standard ML '97 / library keywords; some suggested entries are here,
# more could come from, say, Standard Basis Library
keywordoptional1.sml= \
option SOME NONE ignore ref \
chr explode implode ord size
keywords2.$(file.patterns.sml)=$(keywordoptional1.sml)

# "optional" Objective Caml / library keywords; some suggested entries are here,
# more could come from, say, user-defined types
keywordoptional2.caml= \
array bool char float int list string unit
keywords3.$(file.patterns.caml)=$(keywordoptional2.caml)

# "optional" Standard ML '97 / library keywords; some suggested entries are here,
# more could come from, say, user-defined types
keywordoptional2.sml= \
array bool char int list nil real string unit vector word
keywords3.$(file.patterns.sml)=$(keywordoptional2.sml)

word.characters.$(file.patterns.caml)=$(chars.alpha)$(chars.numeric)_'`
word.characters.$(file.patterns.sml)=$(chars.alpha)$(chars.numeric)_'

comment.stream.start.caml=(*
comment.stream.end.caml=*)
comment.box.start.caml=(*
comment.box.middle.caml= *
comment.box.end.caml= *)

# "folding" support not currently implemented

# "Out-of-the-box" syntax colors are defined here - I like having
# my literals (number, char, and string), tag-names, and "optional"
# keywords stand out - you might not, so adjust accordingly!
# Tag-names
# Keywords2 (season to taste - use for option, Some, None, etc)
# Keywords3 (season to taste - use for bool, char, float, etc)
# Embedded whitespace (SML character/string constant)

# Braces are only matched in operator style
braces.caml.style=7

# The below command(s) can and should be adjusted to reflect your environment;
# in addition, per-directory overrides are possible, so that project-specific "build"
# commands may be used for more complex cases - see the SciTE documentation.
command.compile.$(file.patterns.caml)=ocamlc -c $(FileNameExt)



###############################################################################
# From cmake.properties
# Define SciTE settings for CMake.
# contributed by Cristian Adam <cristian dot adam at gmx dot net>

filter.cmake=CMake (CMakeLists.txt cmake ctest)|CMakeLists.txt;*.cmake;*.cmake.in;*.ctest;*.ctest.in|
*filter.cmake=$(filter.cmake)
file.patterns.cmake=CMakeLists.txt;*.cmake;*.cmake.in;*.ctest;*.ctest.in
lexer.$(file.patterns.cmake)=cmake
*language.cmake=CMake|cmake||

# Commands:
keywords.$(file.patterns.cmake)= add_custom_command \
add_custom_target \
add_definitions \
add_dependencies \
add_executable \
add_library \
add_subdirectory \
add_test \
aux_source_directory \
build_command \
build_name \
cmake_minimum_required \
configure_file \
create_test_sourcelist \
else \
elseif \
enable_language \
enable_testing \
endforeach \
endif \
endmacro \
endwhile \
exec_program \
execute_process \
export_library_dependencies \
file \
find_file \
find_library \
find_package \
find_path \
find_program \
fltk_wrap_ui \
foreach \
get_cmake_property \
get_directory_property \
get_filename_component \
get_source_file_property \
get_target_property \
get_test_property \
if \
include \
include_directories \
include_external_msproject \
include_regular_expression \
install \
install_files \
install_programs \
install_targets \
link_directories \
link_libraries \
list \
load_cache \
load_command \
macro \
make_directory \
mark_as_advanced \
math \
message \
option \
output_required_files \
project \
qt_wrap_cpp \
qt_wrap_ui \
remove \
remove_definitions \
separate_arguments \
set \
set_directory_properties \
set_source_files_properties \
set_target_properties \
set_tests_properties \
site_name \
source_group \
string \
subdir_depends \
subdirs \
target_link_libraries \
try_compile \
try_run \
use_mangled_mesa \
utility_source \
variable_requires \
vtk_make_instantiator \
vtk_wrap_java \
vtk_wrap_python \
vtk_wrap_tcl \
while \
write_file

# Variables:
keywords2.$(file.patterns.cmake)= ABSOLUTE \
ABSTRACT \
ADDITIONAL_MAKE_CLEAN_FILES \
ALL \
AND \
APPEND \
ARGS \
ASCII \
BEFORE \
CACHE \
CACHE_VARIABLES \
CLEAR \
COMMAND \
COMMANDS \
COMMAND_NAME \
COMMENT \
COMPARE \
COMPILE_FLAGS \
COPYONLY \
DEFINED \
DEFINE_SYMBOL \
DEPENDS \
DOC \
EQUAL \
ESCAPE_QUOTES \
EXCLUDE \
EXCLUDE_FROM_ALL \
EXISTS \
EXPORT_MACRO \
EXT \
EXTRA_INCLUDE \
FATAL_ERROR \
FILE \
FILES \
FORCE \
FUNCTION \
GENERATED \
GLOB \
GLOB_RECURSE \
GREATER \
GROUP_SIZE \
HEADER_FILE_ONLY \
HEADER_LOCATION \
IMMEDIATE \
INCLUDES \
INCLUDE_DIRECTORIES \
INCLUDE_INTERNALS \
INCLUDE_REGULAR_EXPRESSION \
LESS \
LINK_DIRECTORIES \
LINK_FLAGS \
LOCATION \
MACOSX_BUNDLE \
MACROS \
MAIN_DEPENDENCY \
MAKE_DIRECTORY \
MATCH \
MATCHALL \
MATCHES \
MODULE \
NAME \
NAME_WE \
NOT \
NOTEQUAL \
NO_SYSTEM_PATH \
OBJECT_DEPENDS \
OPTIONAL \
OR \
OUTPUT \
OUTPUT_VARIABLE \
PATH \
PATHS \
POST_BUILD \
POST_INSTALL_SCRIPT \
PREFIX \
PREORDER \
PRE_BUILD \
PRE_INSTALL_SCRIPT \
PRE_LINK \
PROGRAM \
PROGRAM_ARGS \
PROPERTIES \
QUIET \
RANGE \
READ \
REGEX \
REGULAR_EXPRESSION \
REPLACE \
REQUIRED \
RETURN_VALUE \
RUNTIME_DIRECTORY \
SEND_ERROR \
SHARED \
SOURCES \
STATIC \
STATUS \
STREQUAL \
STRGREATER \
STRLESS \
SUFFIX \
TARGET \
TOLOWER \
TOUPPER \
VAR \
VARIABLES \
VERSION \
WIN32 \
WRAP_EXCLUDE \
WRITE \
APPLE  \
MINGW \
MSYS \
CYGWIN  \
BORLAND \
WATCOM \
MSVC MSVC_IDE MSVC60 MSVC70 MSVC71 MSVC80 CMAKE_COMPILER_2005 \
OFF ON \

#User defined:
#keywords3.$(file.patterns.cmake)=MyFunction MySomethingElse

# Block and indenting
statement.indent.$(file.patterns.cmake)=5 if while foreach macro
comment.block.cmake=#~
comment.block.at.line.start.cmake=1
calltip.cmake.ignorecase=1
calltip.cmake.parameters.start=(
calltip.cmake.parameters.separators=,
calltip.cmake.parameters.end=)




###############################################################################
# From cobol.properties
# Define SciTE settings for COBOL files.

file.patterns.COBOL=*.cob;*.cbl;*.cpy
filter.cobol=COBOL (cob cbl cpy)|$(file.patterns.COBOL)|
*filter.cobol=$(filter.cobol)

lexer.$(file.patterns.COBOL)=COBOL

*language.cobol=COBOL|cob||

word.characters.$(file.patterns.COBOL)=$(chars.alpha)$(chars.numeric)$(chars.accented)_-

# These keywords are case insensitive
keywords.$(file.patterns.COBOL)=configuration data declaratives division environment environment-division file file-control function i-o i-o-control identification input input-output linkage local-storage output procedure program program-id receive-control section special-names working-storage
keywords2.$(file.patterns.COBOL)=accept add alter apply assign call chain close compute continue control convert copy count delete display divide draw drop eject else enable end-accept end-add end-call end-chain end-compute end-delete end-display end-divide end-evaluate end-if end-invoke end-multiply end-perform end-read end-receive end-return end-rewrite end-search end-start end-string end-subtract end-unstring end-write erase evaluate examine exec execute exit go goback generate if ignore initialize initiate insert inspect invoke leave merge move multiply open otherwise perform print read receive release reload replace report reread rerun reserve reset return rewind rewrite rollback run search seek select send set sort start stop store string subtract sum suppress terminate then transform unlock unstring update use wait when wrap write
keywords3.$(file.patterns.COBOL)=access acquire actual address advancing after all allowing alphabet alphabetic alphabetic-lower alphabetic-upper alphanumeric alphanumeric-edited also alternate and any are area areas as ascending at attribute author auto auto-hyphen-skip auto-skip automatic autoterminate background-color background-colour backward basis beep before beginning bell binary blank blink blinking block bold bottom box boxed by c01 c02 c03 c04 c05 c06 c07 c08 c09 c10 c11 c12 cancel cbl cd centered cf ch chaining changed character characters chart class clock-units cobol code code-set col collating color colour column com-reg comma command-line commit commitment common communication comp comp-0 comp-1 comp-2 comp-3 comp-4 comp-5 comp-6 comp-x compression computational computational-1 computational-2 computational-3 computational-4 computational-5 computational-6 computational-x computational console contains content control-area controls conversion converting core-index corr corresponding crt crt-under csp currency current-date cursor cycle cyl-index cyl-overflow date date-compiled date-written day day-of-week dbcs de debug debug-contents debug-item debug-line debug-name debug-sub-1 debug-sub-2 debug-sub-3 debugging decimal-point default delimited delimiter depending descending destination detail disable disk disp display-1 display-st down duplicates dynamic echo egcs egi emi empty-check encryption end end-of-page ending enter entry eol eop eos equal equals error escape esi every exceeds exception excess-3 exclusive exhibit extend extended-search external externally-described-key factory false fd fh--fcd fh--keydef file-id file-limit file-limits file-prefix filler final first fixed footing for foreground-color foreground-colour footing format from full giving global greater grid group heading high high-value high-values highlight id in index indexed indic indicate indicator indicators inheriting initial installation into invalid invoked is japanese just justified kanji kept key keyboard label last leading left left-justify leftline length length-check less limit limits lin linage linage-counter line line-counter lines lock lock-holding locking low low-value low-values lower lowlight manual mass-update master-index memory message method mode modified modules more-labels multiple name named national national-edited native nchar negative next no no-echo nominal not note nstd-reels null nulls number numeric numeric-edited numeric-fill o-fill object object-computer object-storage occurs of off omitted on oostackptr optional or order organization other others overflow overline packed-decimal padding page page-counter packed-decimal paragraph password pf ph pic picture plus pointer pop-up pos position positioning positive previous print-control print-switch printer printer-1 printing prior private procedure-pointer procedures proceed process processing prompt protected public purge queue quote quotes random range rd readers ready record record-overflow recording records redefines reel reference references relative remainder remarks removal renames reorg-criteria repeated replacing reporting reports required resident return-code returning reverse reverse-video reversed rf rh right right-justify rolling rounded s01 s02 s03 s04 s05 same screen scroll sd secure security segment segment-limit selective self selfclass sentence separate sequence sequential service setshadow shift-in shift-out sign size skip1 skip2 skip3 sort-control sort-core-size sort-file-size sort-merge sort-message sort-mode-size sort-option sort-return source source-computer space spaces space-fill spaces standard standard-1 standard-2 starting status sub-queue-1 sub-queue-2 sub-queue-3 subfile super symbolic sync synchronized sysin sysipt syslst sysout syspch syspunch system-info tab tallying tape terminal terminal-info test text than through thru time time-of-day time-out timeout times title to top totaled totaling trace track-area track-limit tracks trailing trailing-sign transaction true type typedef underline underlined unequal unit until up updaters upon upper upsi-0 upsi-1 upsi-2 upsi-3 upsi-4 upsi-5 upsi-6 upsi-7 usage user using value values variable varying when-compiled window with words write-only write-verify writerszero zero zero-fill zeros zeroes

# COBOL styles
# 2,Line Comment|3,Doc Comment|4,Number|5,Keyword (A)|6,String|7,Character|8,Extended keyword|9,Preprocessor|10,Operator
# 11,Identifier|16,Keyword (B)








###############################################################################
# From coffeescript.properties
# Define SciTE settings for CoffeeScript files.

filter.coffeescript=CoffeeScript (coffee)|*.coffee|

file.patterns.coffeescript=*.coffee

lexer.$(file.patterns.coffeescript)=coffeescript




###############################################################################
# From conf.properties
# Define SciTE settings for Apache Configuration files.
# contributed by Ahmad Zawawi <zeus_go64@hotmail.com>

file.patterns.conf=*.conf;.htaccess
*source.patterns.conf=$(file.patterns.conf);
filter.conf=Apache Conf (conf)|$(file.patterns.conf)|
*filter.apacheconfig=$(filter.conf)
lexer.$(file.patterns.conf)=conf
#*language.apacheconfig=Apache Confi&g|conf||
# for future implemention...
#api.$(file.patterns.conf)=conf.api

# Keywords for Apache's Runtime directives
keywords.$(file.patterns.conf)=\
acceptmutex acceptpathinfo accessconfig accessfilename \
action addalt addaltbyencoding addaltbytype addcharset \
adddefaultcharset adddescription addencoding \
addhandler addicon addiconbyencoding addiconbytype \
addinputfilter addlanguage addmodule addmoduleinfo \
addoutputfilter addoutputfilterbytype addtype agentlog \
alias aliasmatch all allow allowconnect \
allowencodedslashes allowoverride anonymous \
anonymous_authoritative anonymous_logemail \
anonymous_mustgiveemail anonymous_nouserid \
anonymous_verifyemail assignuserid authauthoritative \
authdbauthoritative authdbgroupfile \
authdbmauthoritative authdbmgroupfile authdbmtype \
authdbmuserfile authdbuserfile authdigestalgorithm \
authdigestdomain authdigestfile authdigestgroupfile \
authdigestnccheck authdigestnonceformat \
authdigestnoncelifetime authdigestqop \
authdigestshmemsize authgroupfile \
authldapauthoritative authldapbinddn \
authldapbindpassword authldapcharsetconfig \
authldapcomparednonserver authldapdereferencealiases \
authldapenabled authldapfrontpagehack \
authldapgroupattribute authldapgroupattributeisdn \
authldapremoteuserisdn authldapurl authname authtype \
authuserfile bindaddress browsermatch \
browsermatchnocase bs2000account bufferedlogs \
cachedefaultexpire cachedirlength cachedirlevels \
cachedisable cacheenable cacheexpirycheck cachefile \
cacheforcecompletion cachegcclean cachegcdaily \
cachegcinterval cachegcmemusage cachegcunused \
cacheignorecachecontrol cacheignoreheaders \
cacheignorenolastmod cachelastmodifiedfactor \
cachemaxexpire cachemaxfilesize cacheminfilesize \
cachenegotiateddocs cacheroot cachesize \
cachetimemargin cgimapextension charsetdefault \
charsetoptions charsetsourceenc checkspelling \
childperuserid clearmodulelist contentdigest \
cookiedomain cookieexpires cookielog cookiename \
cookiestyle cookietracking coredumpdirectory customlog \
dav davdepthinfinity davlockdb davmintimeout \
defaulticon defaultlanguage defaulttype define \
deflatebuffersize deflatecompressionlevel \
deflatefilternote deflatememlevel deflatewindowsize \
deny directory directoryindex directorymatch \
directoryslash documentroot dumpioinput dumpiooutput \
enableexceptionhook enablemmap enablesendfile \
errordocument errorlog example expiresactive \
expiresbytype expiresdefault extendedstatus \
extfilterdefine extfilteroptions fancyindexing \
fileetag files filesmatch forcelanguagepriority \
forcetype forensiclog from group header headername \
hostnamelookups identitycheck ifdefine ifmodule \
imapbase imapdefault imapmenu include indexignore \
indexoptions indexorderdefault isapiappendlogtoerrors \
isapiappendlogtoquery isapicachefile isapifakeasync \
isapilognotsupported isapireadaheadbuffer keepalive \
keepalivetimeout languagepriority ldapcacheentries \
ldapcachettl ldapconnectiontimeout ldapopcacheentries \
ldapopcachettl ldapsharedcachefile ldapsharedcachesize \
ldaptrustedca ldaptrustedcatype limit limitexcept \
limitinternalrecursion limitrequestbody \
limitrequestfields limitrequestfieldsize \
limitrequestline limitxmlrequestbody listen \
listenbacklog loadfile loadmodule location \
locationmatch lockfile logformat loglevel maxclients \
maxkeepaliverequests maxmemfree maxrequestsperchild \
maxrequestsperthread maxspareservers maxsparethreads \
maxthreads maxthreadsperchild mcachemaxobjectcount \
mcachemaxobjectsize mcachemaxstreamingbuffer \
mcacheminobjectsize mcacheremovalalgorithm mcachesize \
metadir metafiles metasuffix mimemagicfile \
minspareservers minsparethreads mmapfile \
modmimeusepathinfo multiviewsmatch namevirtualhost \
nocache noproxy numservers nwssltrustedcerts \
nwsslupgradeable options order passenv pidfile port \
protocolecho proxy proxybadheader proxyblock \
proxydomain proxyerroroverride proxyiobuffersize \
proxymatch proxymaxforwards proxypass proxypassreverse \
proxypreservehost proxyreceivebuffersize proxyremote \
proxyremotematch proxyrequests proxytimeout proxyvia \
qsc readmename redirect redirectmatch \
redirectpermanent redirecttemp refererignore \
refererlog removecharset removeencoding removehandler \
removeinputfilter removelanguage removeoutputfilter \
removetype requestheader require resourceconfig \
rewritebase rewritecond rewriteengine rewritelock \
rewritelog rewriteloglevel rewritemap rewriteoptions \
rewriterule rlimitcpu rlimitmem rlimitnproc satisfy \
scoreboardfile script scriptalias scriptaliasmatch \
scriptinterpretersource scriptlog scriptlogbuffer \
scriptloglength scriptsock securelisten sendbuffersize \
serveradmin serveralias serverlimit servername \
serverpath serverroot serversignature servertokens \
servertype setenv setenvif setenvifnocase sethandler \
setinputfilter setoutputfilter singlelisten ssiendtag \
ssierrormsg ssistarttag ssitimeformat ssiundefinedecho \
sslcacertificatefile sslcacertificatepath \
sslcarevocationfile sslcarevocationpath \
sslcertificatechainfile sslcertificatefile \
sslcertificatekeyfile sslciphersuite sslengine \
sslmutex ssloptions sslpassphrasedialog sslprotocol \
sslproxycacertificatefile sslproxycacertificatepath \
sslproxycarevocationfile sslproxycarevocationpath \
sslproxyciphersuite sslproxyengine \
sslproxymachinecertificatefile \
sslproxymachinecertificatepath sslproxyprotocol \
sslproxyverify sslproxyverifydepth sslrandomseed \
sslrequire sslrequiressl sslsessioncache \
sslsessioncachetimeout sslusername sslverifyclient \
sslverifydepth startservers startthreads \
suexecusergroup threadlimit threadsperchild \
threadstacksize timeout transferlog typesconfig \
unsetenv usecanonicalname user userdir \
virtualdocumentroot virtualdocumentrootip virtualhost \
virtualscriptalias virtualscriptaliasip \
win32disableacceptex xbithack

#common parameters for Apache runtime configuration
keywords2.$(file.patterns.conf)=\
on off standalone inetd \
force-response-1.0 downgrade-1.0 nokeepalive \
indexes includes followsymlinks none \
x-compress x-gzip


# compiling/building simply checks for the correct symantics....
command.compile.$(file.patterns.conf)=httpd -t -f $(FilePath)
command.build.$(file.patterns.conf)=httpd -t -f $(FilePath)



###############################################################################
# From cpp.properties
# Define SciTE settings for C++, C, C#, Ch, Java, IDL, JavaScript, Flash (ActionScript 2) files.

# sma files are Small script (C-like)
file.patterns.cpp=*.c;*.cc;*.cpp;*.cxx;*.h;*.hh;*.hpp;*.hxx;*.ipp;*.m;*.mm;*.sma
file.patterns.cplusplus=*.cc;*.cpp;*.cxx
# jad = decompiled class files; pde = Processing.org sketch files
file.patterns.java=*.java;*.jad;*.pde
# pln, inc and t are SilkTest (4Test) files.
file.patterns.test=*.pln;*.inc;*.t
# es = JS dialect of Abobe for SVG
file.patterns.js=*.js;*.es;*.ts
file.patterns.cs=*.cs
file.patterns.rc=*.rc;*.rc2;*.dlg
file.patterns.idl=*.idl;*.odl
file.patterns.flash=*.as;*.asc;*.jsfl
file.patterns.ch=*.ch;*.chf;*.chs
file.patterns.vala=*.vala
file.patterns.go=*.go
file.patterns.pike=*.pike
file.patterns.swift=*.swift
file.patterns.c.like=$(file.patterns.cpp);$(file.patterns.cs);$(file.patterns.idl);$(file.patterns.java);$(file.patterns.js);$(file.patterns.flash);$(file.patterns.ch);$(file.patterns.vala);$(file.patterns.pike)

*source.patterns.cpp=$(file.patterns.c.like);
*source.patterns.resource=$(file.patterns.rc);*.def;

shbang.tcc=cpp
shbang.tinycc=cpp

filter.cpp=C/C++ (c cc cpp cxx cs vala h hh hxx hpp ipp dlg rc rc2 mak)|\
$(file.patterns.cpp);$(file.patterns.cs);$(file.patterns.rc);$(file.patterns.vala);*.mak;make*|
filter.java=Java (java)|*.java|
filter.js=JavaScript (js es ts)|$(file.patterns.js)|
filter.idl=IDL (idl odl)|$(file.patterns.idl)|
filter.test=SilkTest (pln inc t)|$(file.patterns.test)|
filter.flash=Flash (as asc jsfl)|$(file.patterns.flash)|
filter.ch=Ch (ch chf chs)|$(file.patterns.ch)|
filter.go=Go (go)|$(file.patterns.go)|
filter.pike=Pike (pike)|$(file.patterns.pike)|
filter.swift=Swift (swift)|$(file.patterns.swift)|

*filter.cpp=$(filter.cpp)
*filter.java=$(filter.java)
*filter.javascript=$(filter.js)
*filter.idl=$(filter.idl)

lexer.$(file.patterns.java)=cpp
lexer.$(file.patterns.cpp)=cpp
lexer.$(file.patterns.rc)=cpp
lexer.$(file.patterns.idl)=cpp
lexer.$(file.patterns.cs)=cpp
lexer.$(file.patterns.js)=cpp
lexer.$(file.patterns.test)=cpp
lexer.$(file.patterns.flash)=cpp
lexer.$(file.patterns.ch)=cpp
lexer.$(file.patterns.vala)=cpp
lexer.$(file.patterns.go)=cpp
lexer.$(file.patterns.pike)=cpp
lexer.$(file.patterns.swift)=cpp

*language.c=&C / C++|c||
*language.csharp=C&#|cs||
*language.java=&Java|java||
*language.javascript=Java&Script|js||
#*language.resource=Reso&urce|rc||

keywordclass.cpp=alignas alignof and and_eq asm auto bitand bitor bool break \
case catch char char16_t char32_t class compl const constexpr const_cast continue \
decltype default delete do double dynamic_cast else enum explicit export extern false final float for \
friend goto if inline int long mutable namespace new noexcept not not_eq nullptr \
operator or or_eq override private protected public \
register reinterpret_cast return short signed sizeof static static_assert static_cast struct switch \
template this thread_local throw true try typedef typeid typename union unsigned using \
virtual void volatile wchar_t while xor xor_eq

directives.objective.c=\
@class @defs @protocol @required @optional @end \
@interface @public @package @protected @private @property \
@implementation @synthesize @dynamic \
@throw @try @catch @finally \
@synchronized @autoreleasepool \
@selector @encode \
@compatibility_alias

# Since Objective C and C++ share the .h extension, allow Objective C directives as keywords
# For stricter display of pure C++, specify keywords.$(file.patterns.cpp)=$(keywordclass.cpp)
keywords.$(file.patterns.cpp)=$(keywordclass.cpp) $(directives.objective.c)

# keywords2 is for highlighting user defined keywords or function calls or similar
#keywords2.$(file.patterns.cpp)=file

# keywords3 is for doc comment keywords, highlighted in style 17
#CPP doxygen
file.patterns.doxygen.langs=$(file.patterns.cpp);$(file.patterns.java)
keywordclass.doxygen=a addindex addtogroup anchor arg attention \
author b brief bug c class code date def defgroup deprecated dontinclude \
e em endcode endhtmlonly endif endlatexonly endlink endverbatim enum example exception \
f$ f[ f] file fn hideinitializer htmlinclude htmlonly \
if image include ingroup internal invariant interface latexonly li line link \
mainpage name namespace nosubgrouping note overload \
p page par param param[in] param[out] \
post pre ref relates remarks return retval \
sa section see showinitializer since skip skipline struct subsection \
test throw throws todo typedef union until \
var verbatim verbinclude version warning weakgroup $ @ \ & < > # { }
keywords3.$(file.patterns.doxygen.langs)=$(keywordclass.doxygen)

# keywords5 is for preprocessor definitions and will cause inactive code
# to be greyed out. This setting is a space separated list of definitions
# where a definition may be of the form NAME=VALUE or simply NAME.
#keywords5.$(file.patterns.cpp)=_MSC_VER SCI_NAMESPACE GTK_MAJOR_VERSION=2

word.chars.cxx=$(chars.alpha)$(chars.numeric)_#
word.characters.$(file.patterns.cpp)=$(word.chars.cxx)
calltip.cpp.word.characters=$(chars.alpha)$(chars.numeric)_
comment.block.cpp=//~
#comment.block.at.line.start.cpp=1
comment.stream.start.cpp=/*
comment.stream.end.cpp=*/
comment.box.start.cpp=/*
comment.box.middle.cpp= *
comment.box.end.cpp= */

# Folding
#fold.cpp.syntax.based=0
#fold.comment=0
#fold.cpp.comment.multiline=0
#fold.cpp.comment.explicit=0
#defaults for fold.cpp.explicit.start=//{ and fold.cpp.explicit.end=//}
#  can be replaced by defining custom strings, e.g. //[ and //]
#fold.cpp.explicit.start=//[
#fold.cpp.explicit.end=//]
#if fold strings are set to something like /*{{{ and /*}}} (Origami/WinF style fold strings), enable
#  fold.cpp.explicit.anywhere, allowing explicit fold points being anywhere, not just in line comments
#fold.cpp.explicit.anywhere=1
#fold.preprocessor=1
#fold.compact=1
#fold.at.else=1

file.patterns.c.except.cpp=$(file.patterns.cs);$(file.patterns.idl);*.java;$(file.patterns.flash);$(file.patterns.ch)
statement.indent.$(file.patterns.c.except.cpp)=5 case default do else for if while
statement.indent.$(file.patterns.cpp)=5 case default do else for if private protected public while
statement.end.$(file.patterns.c.like)=10 ;
statement.lookback.$(file.patterns.c.like)=20
block.start.$(file.patterns.c.like)=10 {
block.end.$(file.patterns.c.like)=10 }

#autocomplete.cpp.fillups=(

#styling.within.preprocessor=1
preprocessor.symbol.$(file.patterns.cpp)=#
preprocessor.start.$(file.patterns.cpp)=if ifdef ifndef
preprocessor.middle.$(file.patterns.cpp)=else elif
preprocessor.end.$(file.patterns.cpp)=endif

preprocessor.symbol.$(file.patterns.cs)=#
preprocessor.start.$(file.patterns.cs)=if region
preprocessor.middle.$(file.patterns.cs)=else elif
preprocessor.end.$(file.patterns.cs)=endif endregion

keywordclass.ch=\
auto array bool break case char class complex ComplexInf ComplexNaN \
const continue default delete \
do double else enum export extern float for foreach goto if Inf inline int \
long namespace NaN new NULL private public register restrict return short \
signed sizeof static string_t struct switch this typedef union unsigned \
using void volatile wchar_t while __declspec
keywords.$(file.patterns.ch)=$(keywordclass.ch)
word.chars.ch=$(chars.alpha)$(chars.numeric)_#
word.characters.$(file.patterns.ch)=$(word.chars.cxx)
comment.block.ch=//~
#comment.block.at.line.start.ch=1
comment.stream.start.ch=/*
comment.stream.end.ch=*/
comment.box.start.ch=/*
comment.box.middle.ch= *
comment.box.end.ch= */
preprocessor.symbol.$(file.patterns.ch)=#
preprocessor.start.$(file.patterns.ch)=if ifdef ifndef
preprocessor.middle.$(file.patterns.ch)=else elif
preprocessor.end.$(file.patterns.ch)=endif

keywordclass.cs=abstract as ascending base bool break by byte case catch char checked \
class const continue decimal default delegate descending do double else enum \
equals event explicit extern false finally fixed float for foreach from goto group if \
implicit in int interface internal into is join lock let long namespace new null \
object on operator orderby out override params private protected public \
readonly ref return sbyte sealed select short sizeof stackalloc static \
string struct switch this throw true try typeof uint ulong \
unchecked unsafe ushort using var virtual void volatile where while
keywords.$(file.patterns.cs)=$(keywordclass.cs)
word.characters.$(file.patterns.cs)=$(word.chars.cxx)

keywordclass.go=\
bool byte break case chan complex64 complex128 const continue defer default  \
else  for func go goto fallthrough false float32 float64 if import int interface int8 int16 int32 int64 \
len map nil package range return select string struct switch true type \
uint uintptr uint8 uint16 uint32 uint64  var
keywords.$(file.patterns.go)=$(keywordclass.go)

keywordclass.rc=\
ACCELERATORS ALT AUTO3STATE AUTOCHECKBOX AUTORADIOBUTTON \
BEGIN BITMAP BLOCK BUTTON CAPTION CHARACTERISTICS CHECKBOX CLASS \
COMBOBOX CONTROL CTEXT CURSOR DEFPUSHBUTTON DIALOG DIALOGEX DISCARDABLE \
EDITTEXT END EXSTYLE FONT GROUPBOX ICON LANGUAGE LISTBOX LTEXT \
MENU MENUEX MENUITEM MESSAGETABLE POPUP \
PUSHBUTTON RADIOBUTTON RCDATA RTEXT SCROLLBAR SEPARATOR SHIFT STATE3 \
STRINGTABLE STYLE TEXTINCLUDE VALUE VERSION VERSIONINFO VIRTKEY
keywords.$(file.patterns.rc)=$(keywordclass.rc)

keywordclass.idl=\
aggregatable allocate appobject arrays async async_uuid \
auto_handle \
bindable boolean broadcast byte byte_count \
call_as callback char coclass code comm_status \
const context_handle context_handle_noserialize \
context_handle_serialize control cpp_quote custom \
decode default defaultbind defaultcollelem \
defaultvalue defaultvtable dispinterface displaybind dllname \
double dual \
enable_allocate encode endpoint entry enum error_status_t \
explicit_handle \
fault_status first_is float \
handle_t heap helpcontext helpfile helpstring \
helpstringcontext helpstringdll hidden hyper \
id idempotent ignore iid_as iid_is immediatebind implicit_handle \
import importlib in include in_line int __int64 __int3264 interface \
last_is lcid length_is library licensed local long \
max_is maybe message methods midl_pragma \
midl_user_allocate midl_user_free min_is module ms_union \
ncacn_at_dsp ncacn_dnet_nsp ncacn_http ncacn_ip_tcp \
ncacn_nb_ipx ncacn_nb_nb ncacn_nb_tcp ncacn_np \
ncacn_spx ncacn_vns_spp ncadg_ip_udp ncadg_ipx ncadg_mq \
ncalrpc nocode nonbrowsable noncreatable nonextensible notify \
object odl oleautomation optimize optional out out_of_line \
pipe pointer_default pragma properties propget propput propputref \
ptr public \
range readonly ref represent_as requestedit restricted retval \
shape short signed size_is small source strict_context_handle \
string struct switch switch_is switch_type \
transmit_as typedef \
uidefault union unique unsigned user_marshal usesgetlasterror uuid \
v1_enum vararg version void wchar_t wire_marshal

keywordclass.msidl=handle
keywordclass.xpidl=attribute native noscript scriptable shared wstring inout
keywords.$(file.patterns.idl)=$(keywordclass.idl) $(keywordclass.xpidl)

# http://java.sun.com/docs/books/tutorial/java/nutsandbolts/_keywords.html
keywordclass.java=abstract assert boolean break byte case catch char class \
const continue default do double else enum extends final finally float for \
goto if implements import instanceof int interface long \
native new package private protected public \
return short static strictfp super switch synchronized this throw throws \
transient try var void volatile while
keywords.$(file.patterns.java)=$(keywordclass.java)

keywordclass.javascript=abstract boolean break byte case catch char class \
const continue debugger default delete do double else enum export extends \
final finally float for function goto if implements import in instanceof \
int interface long native new package private protected public \
return short static super switch synchronized this throw throws \
transient try typeof var void volatile while with
keywords.$(file.patterns.js)=$(keywordclass.javascript)

keywordclass.flash=add and break case catch class continue default delete do \
dynamic else eq extends false finally for function ge get gt if implements import in \
instanceof interface intrinsic le lt ne new not null or private public return \
set static super switch this throw true try typeof undefined var void while with

keywordclass2.flash=Array Arguments Accessibility Boolean Button Camera Color \
ContextMenu ContextMenuItem Date Error Function Key LoadVars LocalConnection Math \
Microphone Mouse MovieClip MovieClipLoader NetConnection NetStream Number Object \
PrintJob Selection SharedObject Sound Stage String StyleSheet System TextField \
TextFormat TextSnapshot Video Void XML XMLNode XMLSocket \
_accProps _focusrect _global _highquality _parent _quality _root _soundbuftime \
arguments asfunction call capabilities chr clearInterval duplicateMovieClip \
escape eval fscommand getProperty getTimer getURL getVersion gotoAndPlay gotoAndStop \
ifFrameLoaded Infinity -Infinity int isFinite isNaN length loadMovie loadMovieNum \
loadVariables loadVariablesNum maxscroll mbchr mblength mbord mbsubstring MMExecute \
NaN newline nextFrame nextScene on onClipEvent onUpdate ord parseFloat parseInt play \
prevFrame prevScene print printAsBitmap printAsBitmapNum printNum random removeMovieClip \
scroll set setInterval setProperty startDrag stop stopAllSounds stopDrag substring \
targetPath tellTarget toggleHighQuality trace unescape unloadMovie unLoadMovieNum updateAfterEvent

keywords.$(file.patterns.flash)=$(keywordclass.flash)
keywords2.$(file.patterns.flash)=$(keywordclass2.flash)

keywordclass.vala=if else switch case default break continue return yield for foreach in \
do while try catch finally throw

keywordclass2.vala=namespace interface class struct enum delegate signal errordomain \
construct get set value base const static var dynamic weak unowned virtual abstract \
override public protected private extern throws requires ensures yields out ref lock \
using true false null delete generic new this typeof sizeof as owned int string char bool

keywords.$(file.patterns.vala)=$(keywordclass.vala)
keywords2.$(file.patterns.vala)=$(keywordclass2.vala)

keywordclass.pike=constant enum if do for while else foreach case switch break continue \
return typeof catch class lambda import inherit static void int string float mixed object \
function program array mapping multiset
keywords.$(file.patterns.pike)=$(keywordclass.pike)

keywordclass.swift.declarations=class deinit enum extension func import init \
internal let operator private protocol public static struct subscript typealias var
keywordclass.swift.statements=break case continue default do else fallthrough \
for if in return switch where while
keywordclass.swift.expressions=as dynamicType false is nil self Self super \
true __COLUMN__ __FILE__ __FUNCTION__ __LINE__
# The contextual keywords are only keywords in particular contexts
keywordclass.swift.contextual=associativity convenience dynamic didSet final get \
infix inout lazy left mutating none nonmutating optional override postfix \
precedence prefix Protocol required right set Type unowned weak willSet

keywords.$(file.patterns.swift)=$(keywordclass.swift.declarations) \
$(keywordclass.swift.statements) $(keywordclass.swift.expressions) \
$(keywordclass.swift.contextual)

# Substyles can be used for extra lists of highlighted identifiers and doc comment keywords
# Identifiers
#substyles.cpp.11=2
#substylewords.11.1.$(file.patterns.cpp)=std map string vector
#style.cpp.11.1=fore:#EE00AA
#style.cpp.75.1=$(style.cpp.75),fore:#BB6666
# Doc comment keywords
#substyles.cpp.17=1
#style.cpp.17.1=$(style.cpp.17),fore:#00AAEE
#style.cpp.81.1=$(style.cpp.81),fore:#6699AA
#substylewords.17.1.$(file.patterns.cpp)=check

# Markers
# keywords6.$(file.patterns.c.like)=FIXME TODO XXX HACK UnresolvedMergeConflict UNDONE

#styling.within.preprocessor=1
#lexer.cpp.allow.dollars=1
#lexer.cpp.track.preprocessor=1
#lexer.cpp.update.preprocessor=1
# For C# leave lexer.cpp.verbatim.strings.allow.escapes as 0 but change to 1 for Objective C
#lexer.cpp.verbatim.strings.allow.escapes=1
#lexer.cpp.triplequoted.strings=1
#lexer.cpp.hashquoted.strings=1
#lexer.cpp.backquoted.strings=1
#lexer.cpp.escape.sequence=1

#lexer.cpp.escape.sequence=1

# C++ styles


# Inactive states are 64 greater than their active counterparts


# Braces are only matched in operator style
braces.cpp.style=10

ccopts=-pedantic -Os
cc=g++ $(ccopts) -c $(FileNameExt) -o $(FileName).o
ccc=gcc $(ccopts) -c $(FileNameExt) -o $(FileName).o

make.command=make
command.compile.*.c=$(ccc) -std=c99
command.build.*.c=$(make.command)
command.build.*.h=$(make.command)
command.clean.*.c=$(make.command) clean
command.clean.*.h=$(make.command) clean
command.go.*.c=./$(FileName)
# To make the Go command both compile (if needed) and execute, use this setting:
#command.go.needs.*.c=gcc $(ccopts) -std=c99 $(FileNameExt) -o $(FileName)

command.compile.$(file.patterns.cplusplus)=$(cc)
command.build.$(file.patterns.cplusplus)=$(make.command)
command.clean.$(file.patterns.cplusplus)=$(make.command) clean
command.go.$(file.patterns.cplusplus)=./$(FileName)
command.go.needs.$(file.patterns.cplusplus)=g++ $(ccopts) $(FileNameExt) -o $(FileName)

command.name.0.$(file.patterns.cpp)=Indent
command.0.$(file.patterns.cpp)=astyle --style=attach --indent=force-tab=8 --keep-one-line-blocks --pad-header --unpad-paren --pad-comma --indent-cases --align-pointer=name $(FileNameExt)
command.is.filter.0.$(file.patterns.cpp)=1

command.name.1.$(file.patterns.cplusplus)=Lint
command.1.$(file.patterns.cplusplus)=g++ -W -Wall -Wshadow -Wwrite-strings -Wold-style-cast \
	-Woverloaded-virtual -pedantic -Os -fno-exceptions -c $(FileNameExt)

if PLAT_WIN
	command.compile.*.rc=windres $(FileNameExt) $(FileName).o
	command.build.*.rc=$(make.command)
	command.help.$(file.patterns.cpp)=$(CurrentWord)!G:\Program Files\Microsoft Visual Studio\MSDN98\98VSa\1033\MSDNVS6A.COL
	command.help.subsystem.$(file.patterns.cpp)=4
	command.go.*.js=cscript /nologo $(FileNameExt)
# When maintaining old Win16 programs...
#	command.help.$(file.patterns.cpp)=$(CurrentWord)!I:\msvc\help\win31wh.hlp
#	command.help.subsystem.$(file.patterns.cpp)=5

if PLAT_GTK
	command.help.$(file.patterns.cpp)=man $(CurrentWord) | col -b

if PLAT_WIN
	command.build.*.cs=csc /t:winexe $(FileNameExt) /r:system.dll,system.drawing.dll
	command.go.*.cs=$(FileName)
	command.go.subsystem.*.cs=0
if PLAT_GTK
	command.build.*.cs=mcs /t:winexe $(FileNameExt) /r:System,System.Drawing
	command.go.*.cs=mono $(FileName).exe
	command.go.subsystem.*.cs=1

command.compile.*.java=javac $(FileNameExt)
command.build.*.java=javac *.java
command.go.*.java=java -cp . $(FileName)

if PLAT_WIN
	command.help.*.java=http://java.sun.com/javase/6/docs/api/java/util/$(CurrentWord).html
	command.help.subsystem.*.java=2

command.compile.*.ch=ch -n $(FileNameExt)
command.build.*.ch=ch -n  $(FileNameExt)
command.go.*.ch=ch -u $(FileNameExt)

command.compile.*.as=mtasc -strict $(FileNameExt)
command.build.*.as=mtasc -strict *.as

command.build.$(file.patterns.vala)=valac $(FileNameExt)
command.go.*.vala=./$(FileName)

# can also be 6g for 64-bit systems!
command.compile.*.go=8g $(FileNameExt)
command.build.*.go=$(make.command)
command.go.*.go=./$(FileName)

command.compile.*.ts=tsc $(FileNameExt)



###############################################################################
# From csound.properties
# SciTE settings for Csound files (orchestra and score)
# Author:  Georg Ritter <ritterfuture A T gmail D O T com>
# Created: Mai 2005

# Csound files
file.patterns.csound=*.orc;*.sco;*.csd
filter.csound=Csound (orc sco csd)|$(file.patterns.csound)|
*filter.csound=$(filter.csound)

lexer.$(file.patterns.csound)=csound

*language.csound=Csound|orc||

# Csound opcodes

# This list was extracted from Csound_opcodes.vim which can be found here:
# http://csounds.com/istvan/archive/misc/Csound_vim_syntax-4.24.1.tar.gz

csound_opcodes=\
	a i db in or zr Add Dec Div Inc Mul Sub abs and cos dam dec div exp \
	fin fof fog inh ino inq ins int inx inz lfo log mac mod mul not out \
	pan pow rms rnd shl sin sqr sub sum tab tan tb0 tb1 tb2 tb3 tb4 tb5 \
	tb6 tb7 tb8 tb9 urd vco xin xor zar zaw zir ziw zkr zkw adsr babo \
	buzz cent clip comb cosh diff divz fini fink fmb3 fof2 fold fout \
	frac ftsr gain goto in32 inch init line maca moog mute nrpn outc \
	outh outo outq outs outx outz peak port pset pvoc rand seed sinh \
	sqrt stix tabw tanh tb10 tb11 tb12 tb13 tb14 tb15 tone vadd vco2 \
	vdiv vexp vibr vmap vmul vpow wrap xout xyin zacl zarg zawm ziwm \
	zkcl zkwm FLbox FLjoy FLrun adsyn ampdb atone birnd bqrez butbp \
	butbr buthp butlp clear ctrl7 dbamp dconv delay dumpk endin endop \
	event expon fouti foutk ftgen ftlen gauss gbuzz grain guiro igoto \
	ihold instr integ kgoto limit linen log10 loopg loopl lpf18 madsr \
	max_k metro noise nsamp oscil out32 outch outic outkc outq1 outq2 \
	outq3 outq4 outs1 outs2 pareq pitch pluck portk print pvadd randh \
	randi rbjeq readk reson rezzy rnd31 scans scanu sense space tab_i \
	table tbvcf tempo timek times tival tonek tonex vaddv vbap4 vbap8 \
	vbapz vcomb vcopy vdecr vdivv veloc vexpv vibes vincr vmult voice \
	vport vpowv vpvoc vsubv vwrap wgbow xadsr zamod zkmod FLhide FLkeyb \
	FLknob FLpack FLshow FLtabs FLtext active adsynt alpass areson \
	atonek atonex bamboo bbcutm bbcuts biquad cabasa cauchy cggoto \
	cigoto ckgoto clfilt cngoto convle cosinv cpsoct cpspch cpstun \
	cpuprc cross2 crunch ctrl14 ctrl21 delay1 delayk delayr delayw \
	deltap denorm diskin dumpk2 dumpk3 dumpk4 envlpx expseg filesr \
	fiopen fmbell follow foscil foutir ftlen2 ftload ftmorf ftsave \
	grain2 grain3 harmon hrtfer initc7 interp jitter linenr lineto \
	linseg locsig loopge loople lorenz loscil lowres lpread lpslot \
	mandel mandol mclock mdelay midic7 midiin midion mirror moscil \
	mpulse mrtmsg mxadsr nlfilt noteon notnum ntrpol octave octcps \
	octpch opcode oscbnk oscil1 oscil3 oscili osciln oscils oscilx \
	outiat outipb outipc outkat outkpb outkpc pchoct phasor planet \
	poscil printk prints pvread pvsftr pvsftw random readk2 readk3 \
	readk4 reinit resonk resonr resonx resony resonz reverb rigoto \
	s16b14 s32b14 sekere sfload sfplay shaker sininv spat3d spdist \
	spsend strset table3 tablei tablew tabw_i taninv tigoto timout \
	turnon upsamp vbap16 vcella vco2ft vdel_k vdelay vlimit vmultv \
	vrandh vrandi wgclar xscans xscanu FLcolor FLcount FLgroup FLlabel \
	FLpanel FLvalue aftouch ampdbfs ampmidi aresonk balance bexprnd \
	biquada changed clockon cps2pch cpsmidi cpstmid cpstuni cpsxpch \
	dbfsamp dcblock deltap3 deltapi deltapn deltapx dispfft display \
	envlpxr exprand expsega expsegr filelen filter2 flanger fmmetal \
	fmrhode fmvoice follow2 foscili fprints ftchnls ftloadk ftlptim \
	ftsavek gogobel granule hilbert initc14 initc21 invalue jitter2 \
	jspline linrand linsegr locsend logbtwo loopseg loscil3 lowresx \
	lphasor lposcil lpreson lpshold marimba massign midic14 midic21 \
	midichn midion2 midiout moogvcf noteoff nreverb nstrnum octmidi \
	oscil1i outic14 outipat outkc14 outkpat pcauchy pchbend pchmidi \
	phaser1 phaser2 pinkish poisson polyaft poscil3 printk2 printks \
	product pvcross pvsanal pvsinfo pvsynth randomh randomi release \
	repluck reverb2 rspline rtclock seqtime sfilist sfinstr sfplay3 \
	sfplaym sfplist slider8 sndwarp soundin spat3di spat3dt specsum \
	streson tableiw tablekt tableng tablera tablewa taninv2 tempest \
	tlineto transeg trigger trigseq trirand turnoff unirand valpass \
	vco2ift vdelay3 vdelayk vdelayx vexpseg vibrato vlinseg vlowres \
	vmirror waveset weibull wgbrass wgflute wgpluck wguide1 wguide2 \
	xtratim zakinit FLbutton FLcolor2 FLprintk FLroller FLscroll \
	FLsetBox FLsetVal FLslider FLupdate betarand butterbp butterbr \
	butterhp butterlp chanctrl clockoff convolve cpsmidib ctrlinit \
	cuserrnd deltapxw distort1 downsamp duserrnd filepeak fmpercfl \
	fmwurlie fprintks hsboscil lowpass2 lpfreson lpinterp lposcil3 \
	maxalloc midictrl multitap nestedap octmidib oscilikt outvalue \
	pchmidib powoftwo prealloc pvinterp pvsadsyn pvscross pvsfread \
	pvsmaska rireturn samphold schedule semitone sensekey setksmps \
	sfinstr3 sfinstrm sfplay3m sfpreset slider16 slider32 slider64 \
	slider8f soundout specaddm specdiff specdisp specfilt spechist \
	specptrk specscal spectrum sprintks subinstr svfilter tablegpw \
	tableikt tablemix tableseg tablewkt tablexkt tb0_init tb1_init \
	tb2_init tb3_init tb4_init tb5_init tb6_init tb7_init tb8_init \
	tb9_init tempoval vco2init vdelayxq vdelayxs vdelayxw vecdelay \
	wgpluck2 wterrain xscanmap zfilter2 FLbutBank FLgetsnap FLpackEnd \
	FLprintk2 FLsetFont FLsetSize FLsetText FLsetsnap FLslidBnk \
	FLtabsEnd dripwater eventname ktableseg noteondur osciliktp \
	oscilikts pgmassign phasorbnk pitchamdf pvbufread readclock \
	sandpaper scantable schedwhen sfinstr3m sfpassign slider16f \
	slider32f slider64f sndwarpst soundoutc soundouts tablecopy \
	tableigpw tableimix tablexseg tb10_init tb11_init tb12_init \
	tb13_init tb14_init tb15_init timeinstk timeinsts vbap4move \
	vbap8move vbapzmove vdelayxwq vdelayxws xscansmap FLgroupEnd \
	FLloadsnap FLpack_end FLpanelEnd FLsavesnap FLsetAlign FLsetColor \
	FLsetVal_i FLtabs_end filenchnls noteondur2 scanhammer schedkwhen \
	tableicopy tambourine vbap16move vbaplsinit wgbowedbar FLgroup_end \
	FLpanel_end FLscrollEnd FLsetColor2 mididefault midinoteoff \
	sleighbells FLscroll_end subinstrinit FLsetPosition FLsetTextSize \
	FLsetTextType midinoteoncps midinoteonkey midinoteonoct \
	midinoteonpch midipitchbend schedwhenname FLsetTextColor \
	schedkwhenname midicontrolchange midiprogramchange \
	midipolyaftertouch midichannelaftertouch

# Header statements
csound_header_stmts=sr kr ar ksmps nchnls

# Other keywords
csound_other_keywords=

keywords.$(file.patterns.csound)=$(csound_opcodes)
keywords2.$(file.patterns.csound)=$(csound_header_stmts)
keywords3.$(file.patterns.csound)=$(csound_other_keywords)

comment.block.csound=;

# Styles ...




###############################################################################
# From css.properties
# Define SciTE settings for CSS files
# Jakub Vr�na - jakub@vrana.cz
# Updated Andy Holder - Jan 2011

filter.css=CSS (css)|*.css|
*filter.css=$(filter.css)
lexer.*.css=css
*language.css=CSS|css||

indent.size.*.css=4
tab.size.*.css=4
use.tabs.*.css=1

keywordclass.css1=\
color background-color background-image background-repeat background-attachment background-position background \
font-family font-style font-variant font-weight font-size font \
word-spacing letter-spacing text-decoration vertical-align text-transform text-align text-indent line-height \
margin-top margin-right margin-bottom margin-left margin \
padding-top padding-right padding-bottom padding-left padding \
border-top-width border-right-width border-bottom-width border-left-width border-width \
border-top border-right border-bottom border-left border \
border-color border-style width height float clear \
display white-space list-style-type list-style-image list-style-position list-style

keywordclass.values=\
auto none normal italic oblique small-caps bold bolder lighter \
xx-small x-small small medium large x-large xx-large larger smaller \
transparent repeat repeat-x repeat-y no-repeat scroll fixed \
top bottom left center right justify both \
underline overline line-through blink \
baseline sub super text-top middle text-bottom \
capitalize uppercase lowercase thin medium thick \
dotted dashed solid double groove ridge inset outset \
block inline list-item pre no-wrap inside outside \
disc circle square decimal lower-roman upper-roman lower-alpha upper-alpha \
aqua black blue fuchsia gray green lime maroon navy olive purple red silver teal white yellow

# rgb(i1, i2, i3) rgb(p1, p2, p3) #xxx #xxxxxx url(path)
# path: in optional single or double quotes. If quotes, inside quotes must be backslashed.
# length: [+-][0-9]+<unit>
# unit: % pt mm cm pc in px em ex

# at-rule: import

# CSS2

keywordclass.css2=\
border-top-color border-right-color border-bottom-color border-left-color border-color \
border-top-style border-right-style border-bottom-style border-left-style border-style \
top right bottom left position z-index direction unicode-bidi \
min-width max-width min-height max-height overflow clip visibility content quotes \
counter-reset counter-increment marker-offset \
size marks page-break-before page-break-after page-break-inside page orphans widows \
font-stretch font-size-adjust unicode-range units-per-em src \
panose-1 stemv stemh slope cap-height x-height ascent descent widths bbox definition-src \
baseline centerline mathline topline text-shadow \
caption-side table-layout border-collapse border-spacing empty-cells speak-header \
cursor outline outline-width outline-style outline-color \
volume speak pause-before pause-after pause cue-before cue-after cue \
play-during azimuth elevation speech-rate voice-family pitch pitch-range stress richness \
speak-punctuation speak-numeral

keywordclass.values2=\
inherit \
run-in compact marker table inline-table table-row-group table-header-group table-footer-group \
table-row table-column-group table-column table-cell table-caption \
static relative absolute fixed ltr rtl embed bidi-override \
visible hidden scroll collapse open-quote close-quote no-open-quote no-close-quote \
decimal-leading-zero lower-greek lower-latin upper-latin hebrew armenian georgian \
cjk-ideographic hiragana katakana hiragana-iroha katakana-iroha \
landscape portrait crop cross always avoid \
wider narrower ultra-condensed extra-condensed condensed semi-condensed \
semi-expanded expanded extra-expanded ultra-expanded \
caption icon menu message-box small-caption status-bar \
separate show hide once crosshair default pointer move text wait help \
e-resize ne-resize nw-resize n-resize se-resize sw-resize s-resize w-resize \
ActiveBorder ActiveCaption AppWorkspace Background ButtonFace ButtonHighlight ButtonShadow \
InactiveCaptionText ButtonText CaptionText GrayText Highlight HighlightText InactiveBorder \
InactiveCaption InfoBackground InfoText Menu MenuText Scrollbar ThreeDDarkShadow \
ThreeDFace ThreeDHighlight ThreeDLightShadow ThreeDShadow Window WindowFrame WindowText \
silent x-soft soft medium loud x-loud spell-out mix \
left-side far-left center-left center-right far-right right-side behind leftwards rightwards \
below level above higher lower x-slow slow medium fast x-fast faster slower \
male female child x-low low high x-high code digits continuous

# properties and pseudos starting with -moz- etc.
keywordclass.vendor.prefixes=^-moz- ^-webkit- ^-o- ^-ms-

# CSS3 is a set of standards that are currently still begin worked on,
# so this list is certainly incomplete.
# This list is CSS3 as recognised by firefox 4 as of start of 2011
keywordclass.css3=background-size \
border-radius border-top-right-radius border-bottom-right-radius border-bottom-left-radius border-top-left-radius \
box-shadow \
columns column-width column-count column-rule column-gap column-rule-color column-rule-style column-rule-width \
resize opacity word-wrap

# Pseudo Classes
keywordclass.pseudoclass.css1=link active visited
keywordclass.pseudoclass.css2=first-child focus hover lang left right first
keywordclass.pseudoclass.css3=empty enabled disabled checked not root target \
only-child last-child nth-child nth-last-child \
first-of-type last-of-type nth-of-type nth-last-of-type only-of-type \
valid invalid required optional
keywordclass.pseudoclass.other=indeterminate default

# Pseudo Elements
keywordclass.pseudoelement.css=first-letter first-line before after
# ::selection WAS in the css3 standard and is supported in many browsers.
# your choice:
keywordclass.pseudoelement.css3=selection
#keywordclass.pseudoelement.other=selection


# counter(id) counter(id, style) attr(X) local("name)" format("string")
# angle: [+-][0-9]+<unit>
# angle unit: deg grad rad
# time: [0-9]+<unit>
# time unit: ms s
# frequency: [0-9]+<unit>
# frequency unit: Hz kHz
# Unicode range: U+x??-yyy

# at-rule: media, values: all aural braille embossed handheld print projection screen tty tv
# at-rule: page font-face charset

#####
# CSS1 properties
keywords.*.css=$(keywordclass.css1)
# Pseudo classes or more precisely single colon ':' selectors
keywords2.*.css=$(keywordclass.pseudoclass.css1) $(keywordclass.pseudoclass.css2) \
    $(keywordclass.pseudoclass.css3) $(keywordclass.pseudoelement.css)
# CSS2 properties
keywords3.*.css=$(keywordclass.css2)
# CSS3 properties
keywords4.*.css=$(keywordclass.css3)
# Pseudo elements or more precisely double colon '::' selectors
keywords5.*.css=$(keywordclass.pseudoelement.css) $(keywordclass.pseudoelement.css3)
# Extra CSS Properties
# Any CSS starting with the common vendor prefixes and microsoft's filter.
keywords6.*.css=$(keywordclass.vendor.prefixes) filter
# Extra pseudo classes
keywords7.*.css=$(keywordclass.pseudoclass.other) $(keywordclass.vendor.prefixes)
# Extra pseudo elements
keywords8.*.css=$(keywordclass.pseudoelement.other) $(keywordclass.vendor.prefixes)

word.characters.*.css=$(chars.alpha)$(chars.numeric)-
comment.stream.start.css=/*
comment.stream.end.css=*/


block.start.*.css=5 {
block.end.*.css=5 }



###############################################################################
# From d.properties
# Define SciTE settings for D

file.patterns.d=*.d
filter.d=D (d)|$(file.patterns.d)|
*filter.d=$(filter.d)
lexer.$(file.patterns.d)=d
*language.d=D|d||

word.chars.d=$(chars.alpha)$(chars.numeric)_#
word.characters.$(file.patterns.d)=$(word.chars.d)
#~ word.characters.$(file.patterns.cs)=$(word.chars.d)
calltip.d.word.characters=$(chars.alpha)$(chars.numeric)_


#comment.block.at.line.start.d=1
comment.block.d=//~
comment.stream.start.d=/+
comment.stream.end.d=+/
comment.box.start.d=/*
comment.box.middle.d= *
comment.box.end.d= */
#lexer.d.fold.at.else=1

statement.indent.$(file.patterns.d)=6 case catch class debug default do else \
finally for foreach foreach_reverse if private protected public scope struct \
try union while with
statement.end.$(file.patterns.d)=13 ;
statement.lookback.$(file.patterns.d)=20
block.start.$(file.patterns.d)=13 {
block.end.$(file.patterns.d)=13 }

# D keywords
keywords.$(file.patterns.d)=abstract alias align asm assert auto \
 body bool break byte \
 case cast catch cdouble cent cfloat char class const continue creal \
 dchar debug default delegate delete deprecated do double \
 else enum export extern \
 false final finally float for foreach foreach_reverse function \
 goto \
 idouble if ifloat import in inout int interface invariant ireal is \
 lazy long \
 mixin module \
 new null \
 out override \
 package pragma private protected public \
 real return \
 scope short static struct super switch synchronized \
 template this throw true try typedef typeid typeof \
 ubyte ucent uint ulong union unittest ushort \
 version void volatile \
 wchar while with

# keywords2 are intended for embedded ASM

# keywords3 are intended for doxygen
keywords3.$(file.patterns.d)=a addindex addtogroup anchor arg attention \
author b brief bug c class code date def defgroup deprecated dontinclude \
e em endcode endhtmlonly endif endlatexonly endlink endverbatim enum example exception \
f$ f[ f] file fn hideinitializer htmlinclude htmlonly \
if image include ingroup internal invariant interface latexonly li line link \
mainpage name namespace nosubgrouping note overload \
p page par param post pre ref relates remarks return retval \
sa section see showinitializer since skip skipline struct subsection \
test throw todo typedef union until \
var verbatim verbinclude version warning weakgroup $ @ \ & < > # { }

# keywords4 are intended for syntax driven or custom highlighting


# Styles

# 0 - whitespace
# 1, 2, 3, 4 - comments:  /* */,  //,  /** */ or /*! */,  /+ +/
# 5 - number
# 6, 7, 8, 9 - keywords: standard, secondary, doc keywords, typedefs and aliases
# 10 - string
# 11 - string not closed
# 12 - char
# 13 - operator
# 14 - identifier
# 15, 16, 17 - Doc comments: line doc /// or //!, doc keyword, doc keyword err
# 18, 19 stringb, stringr
# breaces must be operator style to allow matching
braces.d.style=13


command.compile.*.d=dmd -O $(FileNameExt)
command.build.*.d=$(make.command)
command.go.*.d=$(FileName)




###############################################################################
# From ecl.properties
file.patterns.ecl=*.ecl;*.eclattr;*.hql
filter.ecl=ECL (ecl eclattr hql)|$(file.patterns.ecl)|
*filter.ecl=$(filter.ecl)
lexer.$(file.patterns.ecl)=ecl

word.chars.ecl=$(chars.alpha)$(chars.numeric)_#
word.characters.$(file.patterns.ecl)=$(word.chars.ecl)
calltip.ecl.word.characters=$(chars.alpha)$(chars.numeric)_

#comment.block.at.line.start.ecl=1
comment.block.ecl=//
comment.stream.start.ecl=/+
comment.stream.end.ecl=+/
comment.box.start.ecl=/*
comment.box.middle.ecl= *
comment.box.end.ecl= */
#lexer.ecl.fold.at.else=1

statement.indent.$(file.patterns.ecl)=record module
statement.end.$(file.patterns.ecl)=13 ;
statement.lookback.$(file.patterns.ecl)=20
block.start.$(file.patterns.ecl)=13 {
block.end.$(file.patterns.ecl)=13 }


keywords.$(file.patterns.ecl)=abs acos ascii asin asstring atan atan2 ave case choose choosen choosesets clustersize cos cosh count cron dataset dedup denormalize distribute distributed distribution ebcdic enth error evaluate event exists exp fetch fromunicode getisvalid global group hash hash32 hash64 hashcrc hashmd5 if index intformat isvalid iterate join keyunicode length limit ln log map matched matchlength matchposition matchtext matchunicode max merge min normalize parse pipe power preload project pull random rank ranked realformat recordof regexfind regexreplace rejected rollup round roundup row rowdiff sample set sin sinh sizeof soapcall sort sorted sqrt sum table tan tanh topn tounicode transfer trim truncate typeof ungroup unicodeorder which workunit xmldecode xmlencode xmltext xmlunicode
keywords2.$(file.patterns.ecl)=apply build buildindex evaluate fail keydiff keypatch loadxml notify output parallel sequential soapcall
keywords3.$(file.patterns.ecl)=__compressed__ all and any as atmost before beginc++ best between case const counter csv descend encrypt end endc++ endmacro except exclusive expire export extend false few first flat full function group header heading hole ifblock import in joined keep keyed last left limit load local locale lookup macro many maxcount maxlength min skew module named nocase( noroot noscan nosort not of only opt or outer overwrite packed partition penalty physicallength pipe quote record relationship repeat return right scan self separator service shared skew skip sql store terminator thor threshold token transform trim true type unicodeorder unsorted validate virtual whole wild within xml xpath
keywords4.$(file.patterns.ecl)=ascii big_endian boolean data decimal ebcdic integer pattern qstring real record rule set of string token udecimal unicode unsigned varstring varunicode
keywords5.$(file.patterns.ecl)=checkpoint deprecated failcode failmessage failure global independent onwarning persist priority recovery stored success wait when
keywords6.$(file.patterns.ecl)=#append #break #declare #demangle #end #for #getdatatype #if #inmodule #loop #mangle #onwarning #option #set #stored #uniquename #workunit integer symbol value text symbol value

#command.build.$(file.patterns.ecl)=eclcc.exe -I"$(HPCCBIN)\ecllibrary" -I"$(HPCCBIN)\ecllibrary" -I"$(HPCCBIN)\plugins" "$(FileNameExt)"



###############################################################################
# From eiffel.properties
# Define SciTE settings for Eiffel files.

filter.eiffel=Eiffel (e)|*.e|

*filter.eiffel=$(filter.eiffel)

file.patterns.eiffel=*.e

*source.patterns.eiffel=$(file.patterns.eiffel);

# Main Eiffel lexer dows indentation based folding
lexer.$(file.patterns.eiffel)=eiffel
# Alternative key word based folding has trouble with redefine and rename clauses
#lexer.$(file.patterns.eiffel)=eiffelkw

*language.eiffel=&Eiffel|e||

# These keywords are case insensitive although Eiffel has conventions for
# keywords, predefined names and predefined classes: alias, Current, BOOLEAN
# Could differentiate between these
keywordclass.eiffel=\
alias all and any as bit boolean \
check class character clone create creation current \
debug deferred div do double \
else elseif end ensure equal expanded export external \
false feature forget from frozen general \
if implies indexing infix inherit inspect integer invariant is \
language like local loop mod name nochange none not \
obsolete old once or platform pointer prefix precursor \
real redefine rename require rescue result retry \
select separate string strip then true undefine unique until \
variant void when xor

keywords.$(file.patterns.eiffel)=$(keywordclass.eiffel)

# Eiffel styles
# Braces are only matched in operator style
braces.eiffel.style=6
braces.eiffelkw.style=$(braces.eiffel.style)

statement.indent.$(file.patterns.eiffel)=3 do else elsif rescue if is loop
statement.end.$(file.patterns.eiffel)=10 ;
statement.lookback.$(file.patterns.eiffel)=20
block.start.$(file.patterns.eiffel)=10 check debug deferred do from if inspect once
block.end.$(file.patterns.eiffel)=10 end

command.compile.*.e=compile $(FileName)


###############################################################################
# From erlang.properties
# Define SciTE settings for Erlang files.

# M: Erlang M-Files
file.patterns.erlang=*.erl;*.hrl

# M: Erlang M-Files
filter.erlang=Erlang (erl hrl)|$(file.patterns.erlang)|

*filter.erlang=$(filter.erlang)

lexer.$(file.patterns.erlang)=erlang

#*language.erlang=Erlang|erl||

# Reserved Erlang words
keywords.$(file.patterns.erlang)=after and andalso band begin bnot bor bsl bsr bxor case catch cond div end fun if let not of or orelse query receive rem try when xor
# Erlang built-in functions (BIFs)
keywords2.$(file.patterns.erlang)=erlang: abs adler32 adler32_combine erlang:append_element apply atom_to_binary atom_to_list binary_to_atom binary_to_existing_atom binary_to_list bitstring_to_list binary_to_term bit_size erlang:bump_reductions byte_size erlang:cancel_timer check_process_code concat_binary crc32 crc32_combine date decode_packet delete_module erlang:demonitor disconnect_node erlang:display element erase erlang:error exit float float_to_list erlang:fun_info erlang:fun_to_list erlang:function_exported garbage_collect get erlang:get_cookie get_keys erlang:get_stacktrace group_leader halt erlang:hash hd erlang:hibernate integer_to_list erlang:integer_to_list iolist_to_binary iolist_size is_alive is_atom is_binary is_bitstring is_boolean erlang:is_builtin is_float is_function is_integer is_list is_number is_pid is_port is_process_alive is_record is_reference is_tuple length link list_to_atom list_to_binary list_to_bitstring list_to_existing_atom list_to_float list_to_integer erlang:list_to_integer list_to_pid list_to_tuple load_module erlang:load_nif erlang:loaded erlang:localtime erlang:localtime_to_universaltime make_ref erlang:make_tuple erlang:max erlang:md5 erlang:md5_final erlang:md5_init erlang:md5_update erlang:memory erlang:min module_loaded erlang:monitor monitor_node node nodes now open_port erlang:phash erlang:phash2 pid_to_list port_close port_command erlang:port_command port_connect port_control erlang:port_call erlang:port_info erlang:port_to_list erlang:ports pre_loaded erlang:process_display process_flag process_info processes purge_module put erlang:raise erlang:read_timer erlang:ref_to_list register registered erlang:resume_process round self erlang:send erlang:send_after erlang:send_nosuspend erlang:set_cookie setelement size spawn spawn_link spawn_monitor spawn_opt split_binary erlang:start_timer statistics erlang:suspend_process erlang:system_flag erlang:system_info erlang:system_monitor erlang:system_profile term_to_binary throw time tl erlang:trace erlang:trace_delivered erlang:trace_info erlang:trace_pattern trunc tuple_size tuple_to_list erlang:universaltime erlang:universaltime_to_localtime unlink unregister whereis erlang:yield
# Erlang preprocessor instructions
keywords3.$(file.patterns.erlang)=-define -else -endif -ifdef -ifndef -include -include_lib -undef
# Erlang module attributes
keywords4.$(file.patterns.erlang)=-behavior -behaviour -compile -created -created_by -export -file -import -module -modified -modified_by -record -revision -spec -type -vsn
# Erlang documentation helpers
keywords5.$(file.patterns.erlang)=@author @clear @copyright @deprecated @doc @docfile @end @equiv @headerfile @hidden @private @reference @see @since @spec @throws @title @todo @TODO @type @version
# Erlang documentation macros
keywords6.$(file.patterns.erlang)=@date @docRoot @link @module @package @section @time @type @version

# Comment start
comment.block.erlang=%~

# Erlang styles
# foreground;background;bold;italic


# Comments
#---------------------------

# Types
#---------------------------

# Special
#---------------------------



###############################################################################
# From escript.properties
# the directory of the ecompile.exe
ECOMPILEHOME=C:\Daten\Code\CVS Workspace\etheria-pol095\scripts

#
# Define SciTE settings for ESCRIPT files.
#
filter.escript=E-Script (src em)|$(file.patterns.escript)|
#filter.escript=E-Script (src inc cfg em)|$(file.patterns.escript)|
*filter.escript=$(filter.escript)

file.patterns.escript=*.src;*.em
#file.patterns.escript=*.src;*.inc;*.cfg;*.em

lexer.$(file.patterns.escript)=escript
escript.case.sensitive=0


command.compile.*.src="$(ECOMPILEHOME)\ecompile.exe" $(FileNameExt)

#~ Braces are only matched in brace style
#braces.escript.style=9



keywords.$(file.patterns.escript)=\
basic basicio boats \
cfgfile \
file \
http \
npc \
os \
uo util \
accessible \
addmenuitem \
appendconfigfileelem \
applyconstraint \
applydamage \
applyrawdamage \
assignrecttoweatherregion \
append \
baseskilltorawskill \
boatfromitem \
broadcast \
ban \
cdbl \
cint \
cstr \
checklineofsight \
checklosat \
checkskill \
consumemana \
consumereagents \
consumesubstance \
createaccount \
createitematlocation \
createiteminbackpack \
createitemininventory \
createitemincontainer \
createmenu \
createmultiatlocation \
createnpcfromtemplate \
createrootiteminstoragearea \
createstoragearea \
clear_script_profile_counters \
close \
damage \
destroyitem \
destroymulti \
destroyrootiteminstoragearea \
detach \
disableevents \
disconnectclient \
distance \
disable \
enableevents \
enumerateitemsincontainer \
enumerateonlinecharacters \
equipfromtemplate \
equipitem \
eraseglobalproperty \
eraseobjproperty \
enable \
enabled \
erase \
events_waiting \
exists \
findconfigelem \
findobjtypeincontainer \
findrootiteminstoragearea \
findstoragearea \
fclose \
find \
fopen \
fread \
fseek \
ftell \
fwrite \
gamestat \
getamount \
getcommandhelp \
getconfigint \
getconfigintkeys \
getconfigmaxintkey \
getconfigreal \
getconfigstring \
getconfigstringkeys \
getconfigstringarray \
getelemproperty \
getequipmentbylayer \
getglobalproperty \
getharvestdifficulty \
getmapinfo \
getmenuobjtypes \
getobjproperty \
getobjtype \
getobjtypebyname \
getproperty \
getrawskill \
getregionstring \
getskill \
getspelldifficulty \
getstandingheight \
getworldheight \
grantprivilege \
harvestresource \
healdamage \
hex \
islegalmove \
insert \
keys \
listequippeditems \
listghostsnearlocation \
listhostiles \
listitemsatlocation \
listitemsnearlocation \
listitemsnearlocationoftype \
listmobilesinlineofsight \
listmobilesnearlocation \
listmobilesnearlocationex \
listobjectsinbox \
loadtusscpfile \
left \
len \
log_profile \
lower \
makeboundingbox \
move \
moveboat \
moveboatrelative \
movecharactertolocation \
moveitemtocontainer \
moveitemtolocation \
move_offline_mobiles \
openpaperdoll \
open \
pack \
performaction \
playlightningbolteffect \
playmovingeffect \
playmovingeffectxyz \
playobjectcenteredeffect \
playsoundeffect \
playsoundeffectprivate \
playstationaryeffect \
printtextabove \
printtextaboveprivate \
packages \
polcore \
position \
print \
queryparam \
randomdiceroll \
randomint \
rawskilltobaseskill \
readconfigfile \
readgameclock \
releaseitem \
registerforspeechevents \
registeritemwithboat \
requestinput \
reserveitem \
restartscript \
resurrect \
revokeprivilege \
runawayfrom \
runawayfromlocation \
runtoward \
runtowardlocation \
reverse \
run_script_to_completion \
saveworldstate \
selectmenuitem2 \
self \
sendbuywindow \
senddialoggump \
sendevent \
sendopenspecialcontainer \
sendpacket \
sendsellwindow \
sendskillwindow \
sendstringastipwindow \
sendsysmessage \
sendtextentrygump \
setanchor \
setglobalproperty \
setname \
setobjproperty \
setopponent \
setproperty \
setrawskill \
setregionlightlevel \
setregionweatherlevel \
setscriptcontroller \
setwarmode \
shutdown \
speakpowerwords \
splitwords \
startspelleffect \
subtractamount \
systemfindboatbyserial \
systemfindobjectbyserial \
say \
set_critical \
set_debug \
set_priority \
set_priority_divide \
set_script_option \
setcmdlevel \
setdex \
setint \
setlightlevel \
setmaster \
setname \
setpassword \
setstr \
shrink \
size \
sleep \
sleepms \
sort \
spendgold \
squelch \
start_script \
syslog \
system_rpm \
target \
targetcoordinates \
targetmultiplacement \
turnawayfrom \
turnawayfromlocation \
turnboat \
turntoward \
turntowardlocation \
toggle \
unloadconfigfile \
unpack \
unban \
unload_scripts \
upper \
walkawayfrom \
walkawayfromlocation \
walktoward \
walktowardlocation \
wander \
writehtml \
writehtmlraw \
wait_for_event \
movechar_forcelocation \
moveitem_forcelocation \
moveitem_normal \
scriptopt_debug \
scriptopt_no_interrupt \
scriptopt_no_runaway \
te_cancel_disable \
te_cancel_enable \
te_style_disable \
te_style_normal \
te_style_numerical \
tgtopt_check_los \
tgtopt_harmful \
tgtopt_helpful \
tgtopt_neutral \
tgtopt_nocheck_los \
setprop \
getprop


keywords2.$(file.patterns.escript)=\
array \
const \
dictionary \
global \
local \
var \
and \
default \
in \
next not \
or \
return \
to \
include \
use \
enum


keywords3.$(file.patterns.escript)=\
while \
for \
endfor \
function \
program \
endprogram endfunction \
foreach \
case \
else elseif \
if endcase endenum endforeach endif endwhile





###############################################################################
# From flagship.properties
# Define SciTE settings for Harbour and FlagShip files.
# (Syntactically compatible to other XBase dialects, like dBase, Clipper, Fox etc.)
# Based on Version .02 by Randy Butler.

# FlagShip Source code file
file.patterns.flagship=*.prg

lexer.$(file.patterns.flagship)=flagship

*language.flagship=FlagShip|prg||

# FlagShip 6 Commands
keywordclass.fs6commands=\
? @ accept access all alternate announce ansi any append as assign autolock average \
begin bell bitmap blank box \
call cancel case century charset checkbox clear close cls color combobox commit \
confirm console constant continue copy count create cursor \
date dbread dbwrite decimals declare default delete deleted delimiters device dir \
directory display do draw \
edit else elseif eject end endcase enddo endif endtext epoch erase error escape eval eventmask \
exact exclusive extended external extra \
field file filter find fixed font for form format from \
get gets global global_extern go goto gotop guialign guicolor guicursor guitransl \
html htmltext \
if image index input intensity \
join \
key keyboard keytransl \
label lines list listbox local locate \
margin memory memvar menu message method multibyte multilocks \
next nfs nfslock nfs_force note \
on openerror order outmode \
pack parameters path pixel pop printer private prompt public push pushbutton \
quit \
radiobutton radiogroup read recall refresh reindex relation release rename replace report request restore \
richtext rowadapt rowalign run \
save say scoreboard scrcompress screen seek select sequence set setenhanced setstandard setunselected \
skip softseek sort source static store struct structure sum \
tag tbrowse text to total type typeahead \
unique unlock update use \
wait while with wrap \
xml zap zerobyteout

# FlagShip 6 Std Library Functions
keywordclass.fs6libfunc=\
_displarr _displarrerr _displarrstd _displobj _displobjerr _displobjstd \
aadd abs achoice aclone acopy adel adir aelemtype aeval afields afill ains alert alias alltrim altd ansi2oem \
appiomode appmdimode appobject array asc ascan asize asort at atail atanychar autoxlock \
between bin2i bin2l bin2w binand binlshift binor binrshift binxor bof break browse \
cdow chr chr2screen cmonth col col2pixel color2rgb colorselect colvisible consoleopen consolesize crc32 ctod curdir \
date datevalid day dbappend dbclearfilter dbclearindex dbclearrelation dbcloseall dbclosearea dbcommit dbcommitall \
dbcreate dbcreateindex dbdelete dbedit dbeval dbf dbfilter dbfinfo dbflock dbfused dbgetlocate dbgobottom dbgoto \
dbgotop dbobject dbrecall dbreindex dbrelation dbrlock dbrlocklist dbrselect dbrunlock dbseek dbselectarea \
dbsetdriver dbsetfilter dbsetindex dbsetlocate dbsetorder dbsetrelation dbskip dbstruct dbunlock dbunlockall \
dbusearea default deleted descend devout devoutpict devpos directory diskspace dispbegin dispbox dispcount \
dispend dispout doserror doserror2str dow drawline dtoc dtos \
empty eof errorblock errorlevel eval execname execpidnum exp \
fattrib fclose fcount fcreate ferase ferror ferror2str fieldblock fielddeci fieldget fieldgetarr fieldlen fieldname \
fieldpos fieldput fieldputarr fieldtype fieldwblock file findexefile fklabel fkmax flagship_dir flock flockf fopen \
found fread freadstdin freadstr freadtxt frename fs_set fseek fwrite \
getactive getalign getapplykey getdosetkey getenv getenvarr getfunction getpostvalid getprevalid getreader guidrawline \
hardcr header hex2num \
i2bin iif indexcheck indexcount indexdbf indexext indexkey indexnames indexord infobox inkey inkey2read inkey2str inkeytrap \
instdchar instdstring int int2num isalpha isbegseq iscolor isdbexcl isdbflock isdbmultip isdbmultiple isdbmultipleopen \
isdbrlock isdigit isfunction isguimode islower isobjclass isobjequiv isobjproperty isprinter isupper \
l2bin lastkey lastrec left len listbox lock log lower ltrim lupdate \
macroeval macrosubst max max_col max_row maxcol maxrow mcol mdblck mdiclose mdiopen mdiselect memocode memodecode \
memoedit memoencode memoline memoread memory memotran memowrit memvarblock mhide min minmax mlcount mlctopos mleftdown \
mlpos mod month mpostolc mpresent mreststate mrightdown mrow msavestate msetcursor msetpos mshow mstate \
neterr netname nextkey num2hex num2int \
objclone oem2ansi onkey ordbagext ordbagname ordcond ordcondset ordcreate orddescend orddestroy ordfor ordisinique \
ordkey ordkeyadd ordkeycount ordkeydel ordkeygoto ordkeyno ordkeyval ordlistadd ordlistclear ordlistrebui ordname \
ordnumber ordscope ordsetfocu ordsetrelat ordskipunique os outerr outstd \
padc padl padr param parameters pcalls pcol pcount pixel2col pixel2row printstatus procfile procline procname procstack proper prow \
qout qout2 qqout qqout2 \
rat rddlist rddname rddsetdefault readexit readinsert readkey readkill readmodal readsave readupdated readvar reccount recno recsize \
replicate restscreen right rlock rlockverify round row row2pixel rowadapt rowvisible rtrim \
savescreen scrdos2unix screen2chr scroll scrunix2dos seconds secondscpu select serial set setansi setblink setcancel setcol2get \
setcolor setcolorba setcursor setevent setguicursor setkey setmode setpos setprc setvarempty sleep sleepms soundex space \
sqrt statbarmsg statusmessage stod str strlen strlen2col strlen2pix strlen2space strpeek strpoke strtran strzero stuff substr \
tbcolumnnew tbmouse tbrowsearr tbrowsedb tbrowsenew tempfilename time tone transform trim truepath type \
updated upper used usersactive usersdbf usersmax \
val valtype version \
webdate weberrorhandler webgetenvir webgetformdata webhtmlbegin webhtmlend weblogerr webmaildomain weboutdata websendmail word \
year

# FlagShip 6 function and procedure
keywordclass.fs6funcproc=\
function procedure return exit

# FlagShip 6 Class (OOP)
keywordclass.fs6class=\
class instance export hidden protect prototype

# Doxygen keywords
keywordclass.fs6doxygen=a addindex addtogroup anchor arg attention \
author b brief bug c class code date def defgroup deprecated dontinclude \
e em endcode endhtmlonly endif endlatexonly endlink endverbatim enum example exception \
f$ f[ f] file fn hideinitializer htmlinclude htmlonly \
if image include ingroup internal invariant interface latexonly li line link \
mainpage name namespace nosubgrouping note overload \
p page par param param[in] param[out] \
post pre ref relates remarks return retval \
sa section see showinitializer since skip skipline struct subsection \
test throw throws todo typedef union until \
var verbatim verbinclude version warning weakgroup $ @ \ & < > # { }

keywords.$(file.patterns.flagship)=$(keywordclass.fs6commands)
keywords2.$(file.patterns.flagship)=$(keywordclass.fs6libfunc)
keywords3.$(file.patterns.flagship)=$(keywordclass.fs6funcproc)
keywords4.$(file.patterns.flagship)=$(keywordclass.fs6class)
keywords5.$(file.patterns.flagship)=$(keywordclass.fs6doxygen)

#FlagShip Comments
#comment.block.flagship='/
comment.block.flagship=//~
comment.stream.start.flagship=/*
comment.stream.end.flagship=*/
comment.box.start.flagship=/*
comment.box.middle.flagship= *
comment.box.end.flagship= */

#lexer.flagship.styling.within.preprocessor=0

# FlagShip styles




#FlagShip Compiler Option
fsOptObj=-c -q -w1 -w2 -w3
fsOptExe=-q -w1 -w2 -w3

#Command for obj file
fsObj=FlagShip $(fsOptObj) $(FileNameExt) -o $(FileName).o

#Command for exe file
fsExe=FlagShip $(fsOptExe) $(FileNameExt) -o $(FileName)

# Use flagship without make file
command.compile.*.prg=$(fsObj)
command.build.*.prg=$(fsExe)
command.go.*.prg=$(FileName)

# Use flagship with a make file
#make.command=make
#command.compile.*.prg=$(make.command)
#command.build.*.prg=$(make.command)
#command.go.*.prg=$(FileName)
#command.build.*.ch=$(make.command)
#command.build.*.fh=$(make.command)

# help from fsman
command.help.$(file.patterns.flagship)=fsman



###############################################################################
# From forth.properties
# Define SciTE settings for Forth files

# These patterns conflict with fortran.properties and nncrontab.properties
# so disable these other properties files if you want to use forth.
#file.patterns.forth=*.f;*.spf
file.patterns.forth=*.forth

# add '*.tab;*.spf;' to 'source.files' variable in 'SciTEGlobal.properties'
# if you want to include these file patterns into default source file list

lexer.$(file.patterns.forth)=forth

*language.forth=Forth|forth||

filter.forth=Forth files (f spf)|$(file.patterns.forth)|

*filter.forth=$(filter.forth)

word.characters.$(file.patterns.forth)=$(chars.alpha)$(chars.numeric)%-

comment.block.forth=\
#comment.block.at.line.start.forth=0
comment.stream.start.forth=(
comment.stream.end.forth=)
comment.box.start.forth=\
comment.box.middle.forth=\
comment.box.end.forth=\

# Forth styles

# control keywords Forth
keywords.$(file.patterns.forth)=\
AGAIN BEGIN CASE DO ELSE ENDCASE ENDOF IF LOOP OF REPEAT THEN UNTIL  WHILE \
[IF] [ELSE] [THEN] ?DO

# Keywords
keywords2.$(file.patterns.forth)=\
DUP DROP ROT SWAP OVER @ ! 2@ 2! 2DUP 2DROP 2SWAP 2OVER NIP R@ >R R> 2R@ 2>R 2R> \
0= 0< SP@ SP! W@ W! C@ C! < > = <> 0<>\
SPACE SPACES KEY? KEY THROW CATCH ABORT */ 2* /MOD CELL+ CELLS CHAR+ \
CHARS MOVE ERASE DABS TITLE HEX DECIMAL HOLD <# # #S #> SIGN \
D. . U. DUMP (.") >NUMBER ' IMMEDIATE EXIT RECURSE UNLOOP LEAVE HERE ALLOT , \
C, W, COMPILE, BRANCH, RET, LIT, DLIT, ?BRANCH, ", >MARK >RESOLVE1 <MARK >RESOLVE \
ALIGN ALIGNED USER-ALLOT USER-HERE HEADER DOES> SMUDGE HIDE :NONAME LAST-WORD \
?ERROR ERROR2 FIND1 SFIND SET-CURRENT GET-CURRENT DEFINITIONS GET-ORDER FORTH \
ONLY SET-ORDER ALSO PREVIOUS VOC-NAME. ORDER LATEST LITERAL 2LITERAL SLITERAL \
CLITERAL ?LITERAL1 ?SLITERAL1 HEX-LITERAL HEX-SLITERAL ?LITERAL2 ?SLITERAL2 SOURCE \
EndOfChunk CharAddr PeekChar IsDelimiter GetChar OnDelimiter SkipDelimiters OnNotDelimiter \
SkipWord SkipUpTo ParseWord NextWord PARSE SKIP CONSOLE-HANDLES REFILL DEPTH ?STACK \
?COMP WORD INTERPRET BYE QUIT MAIN1 EVALUATE INCLUDE-FILE INCLUDED >BODY +WORD \
WORDLIST CLASS! CLASS@ PAR! PAR@ ID. ?IMMEDIATE ?VOC IMMEDIATE VOC WordByAddrWl \
WordByAddr NLIST WORDS SAVE OPTIONS /notransl ANSI>OEM ACCEPT EMIT CR TYPE EKEY? \
EKEY EKEY>CHAR EXTERNTASK ERASE-IMPORTS ModuleName ModuleDirName ENVIRONMENT? \
DROP-EXC-HANDLER SET-EXC-HANDLER HALT ERR CLOSE-FILE CREATE-FILE CREATE-FILE-SHARED \
OPEN-FILE-SHARED DELETE-FILE FILE-POSITION FILE-SIZE OPEN-FILE READ-FILE REPOSITION-FILE \
DOS-LINES UNIX-LINES READ-LINE WRITE-FILE RESIZE-FILE WRITE-LINE ALLOCATE FREE RESIZE \
START SUSPEND RESUME STOP PAUSE MIN MAX TRUE FALSE ASCIIZ> \
R/O W/O ;CLASS ENDWITH OR AND /STRING SEARCH COMPARE EXPORT ;MODULE SPACE

# defwords
keywords3.$(file.patterns.forth)=\
VARIABLE CREATE : VALUE CONSTANT VM: M: var dvar chars OBJ \
CONSTR: DESTR: CLASS: OBJECT: POINTER \
USER USER-CREATE USER-VALUE VECT \
WNDPROC: VOCABULARY -- TASK: CEZ: MODULE:

# prewords1
keywords4.$(file.patterns.forth)=\
CHAR [CHAR] POSTPONE WITH ['] TO [COMPILE] CHAR ASCII \'

# prewords2
keywords5.$(file.patterns.forth)=\
REQUIRE WINAPI:

# string words
keywords6.$(file.patterns.forth)=\
S" ABORT" Z" " ." C"


#command.compile.*.f=spf.cmd $(FileNameExt)



###############################################################################
# From fortran.properties
# Define SciTE settings for Fortran files.

filter.fortran=Fortran (f for f90 f95 f2k)|*.f;*.for;*.f90;*.f95;*.f2k|

*filter.fortran=$(filter.fortran)

file.patterns.f95=*.f90;*.f95;*.f2k
file.patterns.f77=*.f;*.for
file.patterns.fortran=$(file.patterns.f95);$(file.patterns.f77)

lexer.$(file.patterns.f95)=fortran
lexer.$(file.patterns.f77)=f77

*language.fortran=&Fortran|f90||

# keywords and input/output specifiers
keywordclass.fortran=access action advance allocatable allocate \
apostrophe assign assignment associate asynchronous backspace \
bind blank blockdata call case character class close common \
complex contains continue critical cycle data deallocate decimal delim \
default dimension direct do dowhile double doubleprecision else \
elseif elsewhere encoding end endassociate endblockdata enddo \
endfile endforall endfunction endif endinterface endmodule endprogram \
endselect endsubroutine endtype endwhere entry eor equivalence \
err errmsg exist exit external file flush fmt forall form format \
formatted function go goto id if implicit in include inout \
integer inquire intent interface intrinsic iomsg iolength \
iostat is kind len logical module name named namelist nextrec nml \
none nullify number only open opened operator optional out pad \
parameter pass pause pending pointer pos position precision \
print private procedure program protected public quote read readwrite \
real rec recl recursive result return rewind save select \
selectcase selecttype sequential sign size stat status stop stream \
subroutine target then to type unformatted unit use value \
volatile wait where while write

keywords.$(file.patterns.f95)=$(keywordclass.fortran)
keywords.$(file.patterns.f77)=$(keywordclass.fortran)

# keywords2 is for highlighting intrinsic and extended functions
keywords2.$(file.patterns.fortran)=abs achar acos acosd adjustl adjustr \
aimag aimax0 aimin0 aint ajmax0 ajmin0 akmax0 akmin0 all allocated alog \
alog10 amax0 amax1 amin0 amin1 amod anint any asin asind associated \
atan atan2 atan2d atand bitest bitl bitlr bitrl bjtest bit_size bktest break \
btest cabs ccos cdabs cdcos cdexp cdlog cdsin cdsqrt ceiling cexp char \
clog cmplx conjg cos cosd cosh count cpu_time cshift csin csqrt dabs \
dacos dacosd dasin dasind datan datan2 datan2d datand date \
date_and_time dble dcmplx dconjg dcos dcosd dcosh dcotan ddim dexp \
dfloat dflotk dfloti dflotj digits dim dimag dint dlog dlog10 dmax1 dmin1 \
dmod dnint dot_product dprod dreal dsign dsin dsind dsinh dsqrt dtan dtand \
dtanh eoshift epsilon errsns exp exponent float floati floatj floatk floor fraction \
free huge iabs iachar iand ibclr ibits ibset ichar idate idim idint idnint ieor ifix \
iiabs iiand iibclr iibits iibset iidim iidint iidnnt iieor iifix iint iior iiqint iiqnnt iishft \
iishftc iisign ilen imax0 imax1 imin0 imin1 imod index inint inot int int1 int2 int4 \
int8 iqint iqnint ior ishft ishftc isign isnan izext jiand jibclr jibits jibset jidim jidint \
jidnnt jieor jifix jint jior jiqint jiqnnt jishft jishftc jisign jmax0 jmax1 jmin0 jmin1 \
jmod jnint jnot jzext kiabs kiand kibclr kibits kibset kidim kidint kidnnt kieor kifix \
kind kint kior kishft kishftc kisign kmax0 kmax1 kmin0 kmin1 kmod knint knot kzext \
lbound leadz len len_trim lenlge lge lgt lle llt log log10 logical lshift malloc matmul \
max max0 max1 maxexponent maxloc maxval merge min min0 min1 minexponent minloc \
minval mod modulo mvbits nearest nint not nworkers number_of_processors pack popcnt \
poppar precision present product radix random random_number random_seed range real \
repeat reshape rrspacing rshift scale scan secnds selected_int_kind \
selected_real_kind set_exponent shape sign sin sind sinh size sizeof sngl snglq spacing \
spread sqrt sum system_clock tan tand tanh tiny transfer transpose trim ubound unpack verify

# keywords3 are nonstardard, extended and user defined functions
keywords3.$(file.patterns.fortran)=cdabs cdcos cdexp cdlog cdsin cdsqrt cotan cotand \
dcmplx dconjg dcotan dcotand decode dimag dll_export dll_import doublecomplex dreal \
dvchk encode find flen flush getarg getcharqq getcl getdat getenv gettim hfix ibchng \
identifier imag int1 int2 int4 intc intrup invalop iostat_msg isha ishc ishl jfix \
lacfar locking locnear map nargs nbreak ndperr ndpexc offset ovefl peekcharqq precfill \
prompt qabs qacos qacosd qasin qasind qatan qatand qatan2 qcmplx qconjg qcos qcosd \
qcosh qdim qexp qext qextd qfloat qimag qlog qlog10 qmax1 qmin1 qmod qreal qsign qsin \
qsind qsinh qsqrt qtan qtand qtanh ran rand randu rewrite segment setdat settim system \
timer undfl unlock union val virtual volatile zabs zcos zexp zlog zsin zsqrt

#fold.comment.fortran=1
#fold.quotes.fortran=1

comment.block.fortran=!~

# These setting do not work very well for FORTRAN, uncoment to use it
# statement.indent.$(file.patterns.fortran)=8 associate block blockdata case do enum \
# 	function interface module program subroutine then type where

# Fortran styles
# Braces are matched in all cases
braces.fortran.style=0

if PLAT_WIN
	fc77=lf95 $(FileNameExt) -c -fix
	fc90=lf95 $(FileNameExt) -c
if PLAT_GTK
	fc77=f77 -c -o $(FileName).o $(FileNameExt)
	fc90=f90 -c -o $(FileName).o $(FileNameExt)

command.compile.*.f=$(fc77)
command.build.*.f=make
command.go.*.f=$(FileName)

command.compile.*.for=$(fc77)
command.build.*.for=make
command.go.*.for=$(FileName)

command.compile.*.f90=$(fc90)
command.build.*.f90=make
command.go.*.f90=$(FileName)

command.compile.*.f95=$(fc90)
command.build.*.f95=make
command.go.*.f95=$(FileName)

if PLAT_WIN
    api.$(file.patterns.fortran)=$(SciteDefaultHome)\fortran.api

autocomplete.fortran.ignorecase=1
autocomplete.f77.ignorecase=1
calltip.fortran.ignorecase=1
calltip.f77.ignorecase=1



###############################################################################
# From freebasic.properties
# Define SciTE settings for FreeBasic files.

file.patterns.freebasic=*.bas;*.bi

filter.freebasic=FreeBasic (bb bi)|$(file.patterns.freebasic)|

*filter.freebasic=$(filter.freebasic)

lexer.$(file.patterns.freebasic)=freebasic

*language.freebasic=FreeBasic|bas||

# keywords must be all lowercase

keywordclass.freebasic=\
append as asc asin asm atan2 atn beep bin binary bit bitreset bitset bload \
bsave byref byte byval call callocate case cbyte cdbl cdecl chain chdir chr \
cint circle clear clng clngint close cls color command common cons const \
continue cos cshort csign csng csrlin cubyte cuint culngint cunsg curdir \
cushort custom cvd cvi cvl cvlongint cvs cvshort data date deallocate declare \
defbyte defdbl defined defint deflng deflngint defshort defsng defstr defubyte \
defuint defulngint defushort dim dir do double draw dylibload dylibsymbol else \
elseif end enum environ environ$ eof eqv erase err error exec exepath exit exp \
export extern field fix flip for fre freefile function get getjoystick getkey \
getmouse gosub goto hex hibyte hiword if iif imagecreate imagedestroy imp \
inkey inp input instr int integer is kill lbound lcase left len let lib line \
lobyte loc local locate lock lof log long longint loop loword lset ltrim \
mid mkd mkdir mki mkl mklongint mks mkshort mod multikey mutexcreate \
mutexdestroy mutexlock mutexunlock name next not oct on once open option or out \
output overload paint palette pascal pcopy peek peeki peeks pipe pmap point \
pointer poke pokei pokes pos preserve preset print private procptr pset ptr \
public put random randomize read reallocate redim rem reset restore resume \
resume next return rgb rgba right rmdir rnd rset rtrim run sadd screen \
screencopy screeninfo screenlock screenptr screenres screenset screensync \
screenunlock seek statement seek function selectcase setdate setenviron \
setmouse settime sgn shared shell shl short shr sin single sizeof sleep space \
spc sqr static stdcall step stop str string string strptr sub swap system tab \
tan then threadcreate threadwait time time timer to trans trim type ubound \
ubyte ucase uinteger ulongint union unlock unsigned until ushort using va_arg \
va_first va_next val val64 valint varptr view viewprint wait wend while width \
window windowtitle with write xor zstring

keywordclass.preprocessor=\
#define #dynamic #else #endif #error #if #ifdef #ifndef #inclib #include \
#print #static #undef

keywords.$(file.patterns.freebasic)=$(keywordclass.freebasic)
keywords2.$(file.patterns.freebasic)=$(keywordclass.preprocessor)

# FB styles
# Date
# StringEOL
# Constant
# Asm




###############################################################################
# From gap.properties
# Define SciTE settings for GAP files.

file.patterns.gap=*.g;*.gd;*.gi

# GAP files
filter.gap=Gap (g gi gd)|$(file.patterns.gap)|

*filter.gap=$(filter.gap)

lexer.$(file.patterns.gap)=gap

*language.gap=Gap|g||

keywords.$(file.patterns.gap)=and break continue do elif else end fi for function \
if in local mod not od or quit rec repeat return then until while QUIT

keywords2.$(file.patterns.gap)=false true IsBound Unbind TryNextMethod \
Info Assert SaveWorkspace fail

#keywords3.$(file.patterns.gap)

comment.block.gap=#~

# GAP styles

# Braces are only matched in operator style
braces.gap.style=8


###############################################################################
# From haskell.properties
# Define SciTE settings for Haskell.

lexer.*.hs=haskell
filter.hs=Haskell (hs)|*.hs|

*filter.hs=$(filter.hs)

*language.haskell=Haskell|hs||


# Available in literatehaskell lexer:

# keywords for Haskell 98
keywordclass.haskell98=case class data default deriving do else hiding if \
import in infix infixl infixr instance let module \
newtype of then type where forall foreign

# keywords for FFI
keywordclass.ffi=export label dynamic safe threadsafe \
unsafe stdcall ccall prim

keywords.*.hs=$(keywordclass.haskell98)

keywords2.*.hs=$(keywordclass.ffi)



###############################################################################
# From hex.properties
# Define SciTE settings for Motorola S-Record and Intel HEX files.

file.patterns.srec=*.mot;*.srec
file.patterns.ihex=*.hex
file.patterns.tehex=*.tek

filter.srec=S-Record (mot)|$(file.patterns.srec)|
filter.ihex=Intel HEX (hex)|$(file.patterns.ihex)|
filter.tehex=Tektronix extended HEX (tek)|$(file.patterns.tehex)|

*filter.srec=$(filter.srec)
*filter.ihex=$(filter.ihex)
*filter.tehex=$(filter.tehex)

lexer.$(file.patterns.srec)=srec
lexer.$(file.patterns.ihex)=ihex
lexer.$(file.patterns.tehex)=tehex

*language.srecord=S-Record|mot||
*language.intelhex=Intel HEX|hex||
*language.tektronixhex=Tektronix extended HEX|tek||

# .11 N/A

# .8 N/A

# .14 N/A



###############################################################################
# From html.properties
# Define SciTE settings for HTML files.

# vxml added by lseredi

file.patterns.web=*.html;*.htm;*.asp;*.shtml;*.htd;*.jsp;*.xhtml
file.patterns.php=*.php3;*.phtml;*.php
file.patterns.html=$(file.patterns.web);$(file.patterns.php);*.htt;*.cfm;*.tpl;*.dtd;*.hta
file.patterns.vxml=*.vxml
file.patterns.xml=*.xml;*.xsl;*.svg;*.xul;*.xsd;*.dtd;*.xslt;*.axl;*.xrc;*.rdf
file.patterns.docbook=*.docbook
file.patterns.mako=*.mak;*.mako

*source.patterns.cgi=*.cgi;
*source.patterns.html=$(file.patterns.web);
*source.patterns.xml=$(file.patterns.xml);

lexer.$(file.patterns.html)=hypertext
lexer.$(file.patterns.vxml)=hypertext
lexer.$(file.patterns.xml)=xml
lexer.$(file.patterns.docbook)=hypertext
lexer.$(file.patterns.mako)=hypertext

filter.web=Web (html htm asp shtml css xml docbook jsp)|$(file.patterns.web);*.css;*.xml;*.docbook|
filter.php=PHP (php php3 phtml)|$(file.patterns.php)|

*filter.web=$(filter.web)
*filter.php=$(filter.php)

*language.html=H&ypertext|html|$(keyHTML)|
*language.php=P&HP|php||
*language.xml=&XML|xml|$(keyXML)|

fold.html=1
#fold.html.preprocessor=0
#fold.hypertext.comment=1
#fold.hypertext.heredoc=1

#Default Language=1 for JS, 2 for VBS.
#asp.default.language=2
#html.tags.case.sensitive=1

#lexer.html.django=1
#lexer.html.mako=1

#xml.auto.close.tags=1
#lexer.xml.allow.scripts=0

# All hypertext elements and attributes must be listed in lower case
hypertext.elements=\
a abbr acronym address applet area b base basefont \
bdo big blockquote body br button caption center \
cite code col colgroup dd del dfn dir div dl dt em \
fieldset font form frame frameset h1 h2 h3 h4 h5 h6 \
head hr html i iframe img input ins isindex kbd label \
legend li link map menu meta noframes noscript \
object ol optgroup option p param pre q s samp \
script select small span strike strong style sub sup \
table tbody td textarea tfoot th thead title tr tt u ul \
var xml xmlns

hypertext.attributes=\
abbr accept-charset accept accesskey action align alink \
alt archive axis background bgcolor border \
cellpadding cellspacing char charoff charset checked cite \
class classid clear codebase codetype color cols colspan \
compact content coords \
data datafld dataformatas datapagesize datasrc datetime \
declare defer dir disabled enctype event \
face for frame frameborder \
headers height href hreflang hspace http-equiv \
id ismap label lang language leftmargin link longdesc \
marginwidth marginheight maxlength media method multiple \
name nohref noresize noshade nowrap \
object onblur onchange onclick ondblclick onfocus \
onkeydown onkeypress onkeyup onload onmousedown \
onmousemove onmouseover onmouseout onmouseup \
onreset onselect onsubmit onunload \
profile prompt readonly rel rev rows rowspan rules \
scheme scope selected shape size span src standby start style \
summary tabindex target text title topmargin type usemap \
valign value valuetype version vlink vspace width \
text password checkbox radio submit reset \
file hidden image \
^data-

# As defined in "HTML5 differences from HTML4" Working Draft
# http://www.w3.org/TR/html5-diff/
html5.elements=\
address article aside audio base canvas command details datalist embed \
figure figcaption footer header hgroup keygen mark menu meter nav output \
progress ruby rt rp section source time video wbr

html5.attributes=\
async autocomplete autofocus contenteditable contextmenu draggable \
form formaction formenctype formmethod formnovalidate formtarget \
list manifest max min novalidate pattern placeholder \
required reversed role sandbox scoped seamless sizes spellcheck srcdoc step

keywordclass.hypertext=\
$(hypertext.elements) $(hypertext.attributes) $(html5.elements) $(html5.attributes) public !doctype

vxml.elements=\
assign audio block break catch choice clear disconnect else elseif \
emphasis enumerate error exit field filled form goto grammar help \
if initial link log menu meta noinput nomatch object option p paragraph \
param phoneme prompt property prosody record reprompt return s say-as \
script sentence subdialog submit throw transfer value var voice vxml

vxml.attributes=\
accept age alphabet anchor application base beep bridge category charset \
classid cond connecttimeout content contour count dest destexpr dtmf dtmfterm \
duration enctype event eventexpr expr expritem fetchtimeout finalsilence \
gender http-equiv id level maxage maxstale maxtime message messageexpr \
method mime modal mode name namelist next nextitem ph pitch range rate \
scope size sizeexpr skiplist slot src srcexpr sub time timeexpr timeout \
transferaudio type value variant version volume xml:lang

keywordclass.vxml=\
$(vxml.elements) $(vxml.attributes) public !doctype

# List from http://www.php.net/manual/en/reserved.php (updated for PHP 5)
# For a list with functions http://groups.google.com/group/scite-interest/web/extras
# All words should be lower case to ensure case insensitivity when comparing
keywordclass.php=\
and array as bool boolean break case cfunction class const continue declare \
default die directory do double echo else elseif empty enddeclare endfor \
endforeach endif endswitch endwhile eval exit extends false float for \
foreach function global goto if include include_once int integer isset list namespace \
new null object old_function or parent print real require require_once resource \
return static stdclass string switch true unset use var while xor \
abstract catch clone exception final implements interface php_user_filter \
private protected public this throw try \
__class__ __dir__ __file__ __function__ __line__ __method__ \
__namespace__ __sleep __wakeup

# Override keywordclass.php with another file if present
import phpfunctions

keywords.$(file.patterns.html)=$(keywordclass.hypertext)
# JavaScript keywords are possible inside embedded Javascript
keywords2.$(file.patterns.html)=$(keywordclass.javascript)
# VBScript keywords are possible inside embedded VBScript
keywords3.$(file.patterns.html)=$(keywordclass.vb)
# Python keywords are possible inside embedded Python
keywords4.$(file.patterns.html)=$(keywordclass.python)
# PHP keywords are possible inside embedded PHP
keywords5.$(file.patterns.html)=$(keywordclass.php)
# SGML / DTD keywords
keywords6.$(file.patterns.html)=ELEMENT DOCTYPE ATTLIST ENTITY NOTATION

# START DocBook
docbook.elements42=\
abbrev abstract accel ackno acronym action address affiliation alt anchor \
answer appendix appendixinfo application area areaset areaspec arg article \
articleinfo artpagenums attribution audiodata audioobject author authorblurb \
authorgroup authorinitials beginpage bibliocoverage bibliodiv biblioentry \
bibliography bibliographyinfo biblioid bibliomisc bibliomixed bibliomset \
bibliorelation biblioset bibliosource blockinfo blockquote book bookinfo \
bridgehead callout calloutlist caption caution chapter chapterinfo citation \
citebiblioid citerefentry citetitle city classname classsynopsis classsynopsisinfo \
cmdsynopsis co collab collabname colophon colspec command computeroutput \
confdates confgroup confnum confsponsor conftitle constant constraint \
constraintdef constructorsynopsis contractnum contractsponsor contrib \
copyright coref corpauthor corpname country database date dedication \
destructorsynopsis edition editor email emphasis entry entrytbl envar \
epigraph equation errorcode errorname errortext errortype example \
exceptionname fax fieldsynopsis figure filename firstname firstterm \
footnote footnoteref foreignphrase formalpara funcdef funcparams \
funcprototype funcsynopsis funcsynopsisinfo function glossary glossaryinfo \
glossdef glossdiv glossentry glosslist glosssee glossseealso glossterm \
graphic graphicco group guibutton guiicon guilabel guimenu guimenuitem \
guisubmenu hardware highlights holder honorific htm imagedata imageobject \
imageobjectco important index indexdiv indexentry indexinfo indexterm \
informalequation informalexample informalfigure informaltable initializer \
inlineequation inlinegraphic inlinemediaobject interface interfacename \
invpartnumber isbn issn issuenum itemizedlist itermset jobtitle keycap \
keycode keycombo keysym keyword keywordset label legalnotice lhs lineage \
lineannotation link listitem iteral literallayout lot lotentry manvolnum \
markup medialabel mediaobject mediaobjectco member menuchoice methodname \
methodparam methodsynopsis mm modespec modifier ousebutton msg msgaud \
msgentry msgexplan msginfo msglevel msgmain msgorig msgrel msgset msgsub \
msgtext nonterminal note objectinfo olink ooclass ooexception oointerface \
option optional orderedlist orgdiv orgname otheraddr othercredit othername \
pagenums para paramdef parameter part partinfo partintro personblurb \
personname phone phrase pob postcode preface prefaceinfo primary primaryie \
printhistory procedure production productionrecap productionset productname \
productnumber programlisting programlistingco prompt property pubdate publisher \
publishername pubsnumber qandadiv qandaentry qandaset question quote refclass \
refdescriptor refentry refentryinfo refentrytitle reference referenceinfo \
refmeta refmiscinfo refname refnamediv refpurpose refsect1 refsect1info refsect2 \
refsect2info refsect3 refsect3info refsection refsectioninfo refsynopsisdiv \
refsynopsisdivinfo releaseinfo remark replaceable returnvalue revdescription \
revhistory revision revnumber revremark rhs row sbr screen screenco screeninfo \
screenshot secondary secondaryie sect1 sect1info sect2 sect2info sect3 sect3info \
sect4 sect4info sect5 sect5info section sectioninfo see seealso seealsoie \
seeie seg seglistitem segmentedlist segtitle seriesvolnums set setindex \
setindexinfo setinfo sgmltag shortaffil shortcut sidebar sidebarinfo simpara \
simplelist simplemsgentry simplesect spanspec state step street structfield \
structname subject subjectset subjectterm subscript substeps subtitle \
superscript surname sv symbol synopfragment synopfragmentref synopsis \
systemitem table tbody term tertiary tertiaryie textdata textobject tfoot \
tgroup thead tip title titleabbrev toc tocback tocchap tocentry tocfront \
toclevel1 toclevel2 toclevel3 toclevel4 toclevel5 tocpart token trademark \
type ulink userinput varargs variablelist varlistentry varname videodata \
videoobject void volumenum warning wordasword xref year

docbook.attributes=\
arch condition conformance id lang os remap role revision revisionflag security \
userlevel vendor xreflabel \
status label endterm linkend space width

keywordclass.docbook=\
$(docbook.elements42) $(docbook.attributes)

keywordclass.mako=$(keywordclass.hypertext)
keywords.$(file.patterns.mako)=$(keywordclass.hypertext)
# JavaScript keywords are possible inside embedded Javascript
keywords2.$(file.patterns.mako)=$(keywordclass.javascript)
# VBScript keywords are possible inside embedded VBScript
keywords3.$(file.patterns.mako)=$(keywordclass.vb)
# Python keywords are possible inside embedded Python
keywords4.$(file.patterns.mako)=$(keywordclass.python) include namespace inherit \
call doc text page endclass endexcept endfinally endfor endif endtry endwhile block
# PHP keywords are possible inside embedded PHP
keywords5.$(file.patterns.mako)=$(keywordclass.php)
# SGML / DTD keywords
keywords6.$(file.patterns.mako)=ELEMENT DOCTYPE ATTLIST ENTITY NOTATION

# For Django's template language. Since Django seems to use the same .html extension
# as plain HTML, it is up to the user to integrate these keywords if desired.
keywordclass.django= not in autoescape with \
csrf_token cycle empty block endblock filter endfilter for endfor firstof \
if endif ifchanged endifchanged ifequal endifequal include load now regroup spaceless \
endspaceless ssi url widthratio add addslashes capfirst center cut date \
default default_if_none dictsort dictsortreversed divisibleby escape escapejs \
filesizeformat first fix_ampersands float_format force_escape get_digit \
iriencode join last length length_is linebreaks linebreaksbr linenumbers ljust \
lower make_list phone2numeric pluralize pprint random removetags rjust safe \
safeseq slice slugify stringformat striptags time timesince timeuntil title \
truncatewords truncatewords_html unordered_list upper urlencode urlize \
urlizetrunc wordcount wordwrap yesno apnumber intcomma intword ordinal \
naturalday lorem

keywords.$(file.patterns.docbook)=$(keywordclass.docbook)
keywords6.$(file.patterns.docbook)=ELEMENT DOCTYPE ATTLIST ENTITY NOTATION
# END DocBook

word.characters.$(file.patterns.html)=$(chars.alpha)$(chars.numeric)$(chars.accented)_-$
comment.stream.start.hypertext=<!--
comment.stream.end.hypertext=-->
comment.block.hypertext=//~
comment.block.at.line.start.hypertext=1

comment.box.start.xml=
comment.stream.start.xml=

# No keyword for xml, as it accepts any keyword
keywords.$(file.patterns.xml)=
# SGML / DTD keywords
keywords6.$(file.patterns.xml)=ELEMENT DOCTYPE ATTLIST ENTITY NOTATION

word.characters.$(file.patterns.xml)=$(chars.alpha)$(chars.numeric)_-

keywords.$(file.patterns.vxml)=$(keywordclass.vxml)
keywords2.$(file.patterns.vxml)=$(keywordclass.javascript)



word.characters.$(file.patterns.vxml)=$(chars.alpha)$(chars.numeric)_-

# Define the background colours for SGML and each scripting language
colour.hypertext.sgml.back=back:#EFEFFF
colour.hypertext.server.javascript.back=back:#DFDF7F
colour.hypertext.client.vbs.back=back:#EFEFFF
colour.hypertext.server.vbs.back=back:#CFCFEF
colour.hypertext.client.python.back=back:#EFFFEF
colour.hypertext.server.python.back=back:#CFEFCF
colour.hypertext.server.php.back=back:#FFF8F8

# HTML and XML share lexing code so use the same style numbers
# Hypertext Markup Language

# Some reasonable background colours found in the default Windows palette
# Off White #FFFBF0    Light green #C0DCC0    Light Blue #A6CAF0

# Embedded Javascript
fontcolour.js=$(colour.embedded.js),$(font.js)

# ASP Javascript

# Embedded VBS

# ASP VBS




# PHP

# XML: eXtensible Markup Language
# For XML, there is no list of known tags or attributes so all are coloured known

# No brace matching in XML
braces.xml.style=31

if PLAT_WIN
	command.go.$(file.patterns.web)="file://$(FilePath)"
	command.go.subsystem.$(file.patterns.web)=2
if PLAT_GTK
	command.go.$(file.patterns.web)=firefox "file://$(FilePath)"
if PLAT_MAC
	command.go.$(file.patterns.web)=open "file://$(FilePath)"
	command.go.subsystem.$(file.patterns.web)=2

command.go.$(file.patterns.php)=php -f "$(FileNameExt)"
command.compile.$(file.patterns.php)=php -l "$(FileNameExt)"



###############################################################################
# From inno.properties
# Define SciTE settings for Inno Setup script files.

file.patterns.inno=*.iss;*.isl

filter.inno=Inno Setup (iss isl)|$(file.patterns.inno)|

*filter.inno=$(filter.inno)

lexer.$(file.patterns.inno)=inno

*language.innosetup=&InnoSetup|iss||

comment.block.inno=;~

# Sections
keywords.$(file.patterns.inno)=\
 code components custommessages dirs files icons ini installdelete \
 langoptions languages messages registry run setup types tasks \
 uninstalldelete uninstallrun _istool

# Keywords
keywords2.$(file.patterns.inno)=\
 allowcancelduringinstall allownoicons allowrootdirectory allowuncpath \
 alwaysrestart alwaysshowcomponentslist alwaysshowdironreadypage \
 alwaysshowgrouponreadypage alwaysusepersonalgroup appcomments appcontact \
 appcopyright appid appmodifypath appmutex appname apppublisher \
 apppublisherurl appreadmefile appsupportphone appsupporturl appupdatesurl \
 appvername appversion appenddefaultdirname appenddefaultgroupname \
 architecturesallowed architecturesinstallin64bitmode backcolor backcolor2 \
 backcolordirection backsolid changesassociations changesenvironment \
 compression compressionthreads copyrightfontname copyrightfontsize \
 createappdir createuninstallregkey defaultdirname defaultgroupname \
 defaultuserinfoname defaultuserinfoorg defaultuserinfoserial dialogfontname \
 dialogfontsize dialogfontstandardheight direxistswarning disabledirpage \
 disablefinishedpage disableprogramgrouppage disablereadymemo \
 disablereadypage disablestartupprompt diskclustersize diskslicesize \
 diskspanning dontmergeduplicatefiles enabledirdoesntexistwarning encryption \
 extradiskspacerequired flatcomponentslist infoafterfile infobeforefile \
 internalcompresslevel languagecodepage languagedetectionmethod languageid \
 languagename licensefile mergeduplicatefiles messagesfile minversion \
 onlybelowversion outputbasefilename outputdir outputmanifestfile password \
 privilegesrequired reservebytes restartifneededbyrun righttoleft \
 setupiconfile setuplogging showcomponentsizes showlanguagedialog \
 showtaskstreelines showundisplayablelanguages signtool signeduninstaller \
 signeduninstallerdir slicesperdisk solidcompression sourcedir \
 terminalservicesaware timestamprounding timestampsinutc titlefontname \
 titlefontsize touchdate touchtime uninstalldisplayicon uninstalldisplayname \
 uninstallfilesdir uninstalliconfile uninstalllogmode \
 uninstallrestartcomputer uninstallstyle uninstallable \
 updateuninstalllogappname usepreviousappdir usepreviousgroup \
 useprevioussetuptype useprevioustasks useprevioususerinfo usesetupldr \
 userinfopage versioninfocompany versioninfocopyright versioninfodescription \
 versioninfoproductname versioninfoproductversion versioninfotextversion \
 versioninfoversion welcomefontname welcomefontsize windowresizable \
 windowshowcaption windowstartmaximized windowvisible wizardimagebackcolor \
 wizardimagefile wizardimagestretch wizardsmallimagebackcolor \
 wizardsmallimagefile wizardstyle

# Parameters
keywords3.$(file.patterns.inno)=\
 afterinstall attribs beforeinstall check comment components copymode \
 description destdir destname excludes externalsize extradiskspacerequired \
 filename flags fontinstall groupdescription hotkey iconfilename iconindex \
 key languages minversion name onlybelowversion parameters permissions root \
 runonceid section source statusmsg string subkey tasks type types valuedata \
 valuename valuetype verb workingdir

# Preprocessor directives
keywords4.$(file.patterns.inno)=\
 append define dim elif else emit endif endsub error expr file for if ifdef \
 ifexist ifndef ifnexist include insert pragma sub undef

# Pascal keywords
keywords5.$(file.patterns.inno)=\
 begin break case const continue do downto else end except finally for \
 function if of procedure repeat then to try until uses var while with

# User defined keywords
keywords6.$(file.patterns.inno)=

# Properties styles


#if PLAT_WIN
#	# Replace PATH_TO_INNOSETUP by the path to your InnoSetup installation
#	command.compile.$(file.patterns.inno)="PATH_TO_INNOSETUP\iscc.exe" $(FileNameExt)
#	command.go.$(file.patterns.inno)="PATH_TO_INNOSETUP\Compil32.exe" $(FileNameExt)



###############################################################################
# From json.properties
# Define SciTE settings for JSON files.

file.patterns.json=*.json;*.eslintrc;*.jshintrc;*.jsonld
*source.patterns.json=$(file.patterns.json);

filter.json=JSON (json eshintrc jshintrc)|$(file.patterns.json)|
*filter.json=$(filter.json)

lexer.$(file.patterns.json)=json

*language.json=JSON|json||

lexer.json.allow.comments=1
lexer.json.escape.sequence=1

# JSON keywords
keywords.$(file.patterns.json)=false true null

# JSON-LD keywords
keywords2.$(file.patterns.json)=@id @context @type @value @language @container \
@list @set @reverse @index @base @vocab @graph




###############################################################################
# From kix.properties
# Define SciTE settings for Assembler files
# Black Horus blackhorus@gmx.net

# Masm files
file.patterns.kix=*.kix
filter.kix=Kix-Script (kix)|$(file.patterns.kix)|

*filter.kix=$(filter.kix)

#lexer.$(file.patterns.kix)=asm
lexer.$(file.patterns.kix)=kix

*language.kix=&Kix|kix||

# These keywords are commands
keywords.$(file.patterns.kix)=? and beep big break call cd cls color cookie1 copy \
	debug del dim display do until exit flushkb for each next function endfunction \
	get gets global go gosub goto if else endif md or password play quit \
	rd redim return run select case endselect set setl setm settime \
	shell sleep small use while loop

# This keywords are functions
keywords2.$(file.patterns.kix)=abs addkey addprinterconnection addprogramgroup \
	addprogramitem asc ascan at backupeventlog box cdbl chr cint cleareventlog \
	close comparefiletimes createobject cstr dectohex delkey delprinterconnection \
	delprogramgroup delprogramitem deltree delvalue dir enumgroup enumipinfo enumkey \
	enumlocalgroup enumvalue execute exist existkey expandenvironmentvars fix \
	formatnumber freefilehandle getdiskspace getfileattr getfilesize getfiletime \
	getfileversion getobject iif ingroup instr instrrev int isdeclared join \
	kbhit keyexist lcase left len loadhive loadkey logevent logoff ltrim \
	memorysize messagebox open readline readprofilestring readtype readvalue \
	redirectoutput right rnd round rtrim savekey sendkeys sendmessage setascii \
	setconsole setdefaultprinter setfileattr setfocus setoption setsystemstate \
	settitle setwallpaper showprogramgroup shutdown sidtoname split srnd substr \
	trim ubound ucase unloadhive val vartype vartypename writeline \
	writeprofilestring writevalue

# This keywords are macros if preceded by @
keywords3.$(file.patterns.kix)=address build color comment cpu crlf csd curdir \
	date day domain dos error fullname homedir homedrive homeshr hostname \
	inwin ipaddress0 ipaddress1 ipaddress2 ipaddress3 kix lanroot ldomain \
	ldrive lm logonmode longhomedir lserver maxpwage mdayno mhz monthno \
	month msecs pid primarygroup priv productsuite producttype pwage ras \
	result rserver scriptdir scriptexe scriptname serror sid site startdir \
	syslang ticks time userid userlang wdayno wksta wuserid ydayno year

# Comments
comment.block.kix=;
comment.block.at.line.start.kix=1

# Kix Styles

# Commands
command.go.*.kix=kix32 $(FileName)

# Indenting
tab.size.$(file.patterns.kix)=6
indent.size.$(file.patterns.kix)=3
use.tabs.$(file.patterns.kix)=1

statement.indent.$(file.patterns.kix)=7 if else for do while function case



###############################################################################
# From latex.properties
# Define SciTE settings for LaTeX files.

file.patterns.latex=*.tex;*.sty

filter.latex=LaTeX (tex sty)|$(file.patterns.latex)|

*filter.latex=$(filter.latex)

lexer.$(file.patterns.latex)=latex

# LaTeX styles

command.compile.*.tex=latex $(FileNameExt)
command.build.*.tex=dvips -f $(FileName).dvi > $(FileName).ps
command.go.*.tex=dvips $(FileName).dvi

command.name.0.*.tex=View
command.0.*.tex=xdvi $(FileName).dvi
command.name.1.*.tex=View PS
command.1.*.tex=gv $(FileName).ps



###############################################################################
# From lisp.properties
# Define SciTE settings for lisp and Scheme files.

file.patterns.lisp=*.lsp;*.lisp

filter.lisp=LISP (lsp lisp)|$(file.patterns.lisp)|

file.patterns.scheme=*.scm;*.smd;*.ss
filter.scheme=Scheme (scm smd)|$(file.patterns.scheme)|

#*filter.lisp=$(filter.lisp)
#*filter.scheme=$(filter.scheme)

lexer.$(file.patterns.lisp)=lisp
lexer.$(file.patterns.scheme)=lisp

*language.lisp=Lisp|lisp||

# lisp build in functions, xlisp dialect
keywords.$(file.patterns.lisp)= not defun + - * / = < > <= >= princ \
eval apply funcall quote identity function complement backquote lambda set setq setf \
defun defmacro gensym make symbol intern symbol name symbol value symbol plist get \
getf putprop remprop hash make array aref car cdr caar cadr cdar cddr caaar caadr cadar \
caddr cdaar cdadr cddar cdddr caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr \
cdaaar cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr cons list append reverse last nth \
nthcdr member assoc subst sublis nsubst  nsublis remove length list length \
mapc mapcar mapl maplist mapcan mapcon rplaca rplacd nconc delete atom symbolp numberp \
boundp null listp consp minusp zerop plusp evenp oddp eq eql equal cond case and or let l if prog \
prog1 prog2 progn go return do dolist dotimes catch throw error cerror break \
continue errset baktrace evalhook truncate float rem min max abs sin cos tan expt exp sqrt \
random logand logior logxor lognot bignums logeqv lognand lognor \
logorc2 logtest logbitp logcount integer length nil

word.chars.lisp=$(chars.alpha)$(chars.numeric)_-<>.#+@$%^&=*!?
word.characters.$(file.patterns.lisp)=$(word.chars.lisp)

# Scheme functions, R5RS
keywords.$(file.patterns.scheme)= + - * / = < > <= >= => \
abs acos and angle append apply asin assoc assoc assq assv atan \
begin boolean? \
caar cadr call-with-current-continuation call/cc \
call-with-input-file call-with-output-file call-with-values \
car cdr \
caar cadr cdar cddr \
caaar caadr cadar caddr cdaar cdadr cddar cdddr \
caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr \
cdaaar cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr \
case ceiling char->integer \
char-alphabetic? char-ci<=? char-ci<? char-ci=? char-ci>=? char-ci>? \
char-downcase char-lower-case? char-numeric? char-ready? \
char-upcase char-upper-case? char-whitespace? \
char<=? char<? char=? char>=? char>? char? \
close-input-port close-output-port complex? cond cons cos \
current-input-port current-output-port \
define define-syntax delay denominator display do dynamic-wind \
else eof-object? eq? equal? eqv? eval even? exact->inexact exact? \
exp expt \
floor for-each force \
gcd \
if imag-part inexact->exact inexact? input-port? integer->char integer? interaction-environment \
lambda lcm length let let* let-syntax letrec letrec-syntax \
list list->string list->vector list-ref list-tail list? load log \
magnitude make-polar make-rectangular make-string make-vector \
map max member memq memv min modulo \
negative? newline not null-environment null? number->string number? numerator \
odd? open-input-file open-output-file or output-port? \
pair? peek-char input-port? output-port? positive? procedure? \
quasiquote quote quotient \
rational? rationalize read read-char real-part real? remainder reverse round \
scheme-report-environment set! set-car! set-cdr! sin sqrt string \
string->list string->number string->symbol string-append \
string-ci<=? string-ci<? string-ci=? string-ci>=? string-ci>? \
string-copy string-fill! string-length string-ref string-set! \
string<=? string<? string=? string>=? string>? string? \
substring symbol->string symbol? syntax-rules \
transcript-off transcript-on truncate \
unquote unquote-splicing \
values vector vector->list vector-fill! vector-length vector-ref vector-set! vector? \
with-input-from-file with-output-to-file write write-char \
zero?

word.chars.scheme=$(chars.alpha)$(chars.numeric)!$%&*/:<=>?^_~+-.@
word.characters.$(file.patterns.scheme)=$(word.chars.scheme)


comment.block.lisp=;
comment.box.start.lisp=;;
comment.box.middle.lisp=;;
comment.box.end.lisp=;;


# LISP styles

# Braces are only matched in operator style
braces.lisp.style=10

#command.go.$(file.patterns.scheme)=c:\tools\pscheme\pscheme.exe /r $(FilePath)
command.go.$(file.patterns.scheme)=c:\tools\gambit\gsi.exe -f $(FilePath)
#command.go.$(file.patterns.scheme)=c:\tools\plt\mzscheme.exe -r $(FilePath)
command.go.subsystem.$(file.patterns.scheme)=0



###############################################################################
# From lot.properties
# Define SciTE settings for lot files.
file.patterns.lot=*.lot

filter.lot=Lot (lot)|$(file.patterns.lot)|

*filter.lot=$(filter.lot)

lexer.$(file.patterns.lot)=lot

*language.lot=Lot|lot||

word.characters.$(file.patterns.lot)=$(chars.alpha)$(chars.numeric)

# LOT FileStyles



###############################################################################
# From lout.properties
# Define SciTE settings for Basser Lout files.
# Based on Lout 3.35 [April 2007]
# * to update keywords, see or diff externs.h

file.patterns.lout=*.lt

filter.lout=Lout (lt)|*.lt|

*filter.lout=$(filter.lout)

lexer.$(file.patterns.lout)=lout

*language.lout=Lout|lt||

# @-prefixed keywords
keywords.$(file.patterns.lout)= \
@OptGall @FontDef @Family @Face @Name @Metrics @ExtraMetrics \
@Mapping @Recode @Filter @FilterIn @FilterOut @FilterErr \
@Common @Rump @Meld @Insert @OneOf @Next @Plus @Minus @Wide \
@High @HShift @VShift @BeginHeaderComponent @EndHeaderComponent \
@SetHeaderComponent @ClearHeaderComponent @OneCol @OneRow \
@HMirror @VMirror @HScale @VScale @HCover @VCover @Scale \
@KernShrink @HContract @VContract @HLimited @VLimited @HExpand \
@VExpand @StartHVSpan @StartHSpan @StartVSpan @HSpan @VSpan \
@PAdjust @HAdjust @VAdjust @Rotate @Background @IncludeGraphic \
@SysIncludeGraphic @Graphic @LinkSource @LinkDest @URLLink \
@PlainGraphic @Verbatim @RawVerbatim @Case @Yield @BackEnd \
@Char @Font @Space @YUnit @ZUnit @Break @Underline @SetColour \
@SetColor @SetUnderlineColour @SetUnderlineColor @SetTexture \
@Outline @Language @CurrLang @CurrFamily @CurrFace @CurrYUnit \
@CurrZUnit @LEnv @@A @@B @@C @@D @@E @LClos @@V @LUse @LEO \
@Open @Use @NotRevealed @Tagged @Database @SysDatabase \
@Include @SysInclude @IncludeGraphicRepeated \
@SysIncludeGraphicRepeated @PrependGraphic @SysPrependGraphic \
@Target @Null @PageLabel @Galley @ForceGalley @LInput @Split \
@Tag @Key @Optimize @Merge @Enclose @Begin @End @Moment \
@Second @Minute @Hour @Day @Month @Year @Century @WeekDay \
@YearDay @DaylightSaving @SetContext @GetContext

# symbols that are keywords (excluding braces)
keywords2.$(file.patterns.lout)= &&& && & ^// ^/ ^|| ^| ^& // / || |

# non-@-prefixed keywords
keywords3.$(file.patterns.lout)= def langdef force horizontally into \
extend import export precedence associativity left right body macro \
named compulsory following preceding foll_or_prec now

comment.block.lout=#~

indent.maintain.$(file.patterns.lout)=1

# Lout styles

# Braces are only matched in operator style
braces.lout.style=8

command.compile.$(file.patterns.lout)=lout "$(FileNameExt)" > "$(FileName).ps"
command.build.$(file.patterns.lout)=make

if PLAT_WIN
	command.go.$(file.patterns.lout)=gview "$(FileName).ps"

if PLAT_GTK
	command.go.$(file.patterns.lout)=gview32 "$(FileName).ps"




###############################################################################
# From lua.properties
# Define SciTE settings for Lua files.
# Lua 5.x highlighting is enabled by default. For other choices,
# including Lua 4 highlighting, see below.

file.patterns.lua=*.lua

*source.patterns.lua=$(file.patterns.lua);

shbang.lua=lua

filter.lua=Lua (lua)|$(file.patterns.lua)|

*filter.lua=$(filter.lua)

lexer.$(file.patterns.lua)=lua

*language.lua=Lu&a|lua||

word.chars.lua=$(chars.alpha)$(chars.numeric)$(chars.accented)_%
word.characters.$(file.patterns.lua)=$(word.chars.lua)

#### Lua 4.0.1

# Keywords
keywordclass.lua4=\
and break do else elseif \
end for function if in \
local nil not or repeat \
return then until while

# Basic Functions
keywordclass2.lua4=\
_ALERT assert call collectgarbage copytagmethods \
dofile dostring error foreach foreachi \
gcinfo getglobal getn gettagmethod globals \
newtag next print rawget rawset \
setglobal settag settagmethod sort tag \
tonumber tostring tinsert tremove type \
_VERSION _ERRORMESSAGE

# String Manipulation & Mathematical Functions
keywordclass3.lua4=\
strbyte strchar strfind strlen strlower \
strrep strsub strupper format gsub \
abs acos asin atan atan2 \
ceil cos deg exp floor \
log log10 max min mod \
rad sin sqrt tan frexp \
ldexp random randomseed PI

# Input and Output Facilities & System Facilities
keywordclass4.lua4=\
openfile closefile readfrom writeto appendto \
remove rename flush seek tmpname read write \
clock date execute exit getenv setlocale \
_INPUT _OUTPUT _STDIN _STDOUT _STDERR -- file descriptors

# Debug (not enabled by default)
keywordclass5.lua4=\
getinfo getlocal setlocal setcallhook setlinehook

#### Lua 5.0.3

# Keywords
keywordclass.lua50=$(keywordclass.lua4) false true

# Basic Functions
keywordclass2.lua5=\
assert collectgarbage dofile error _G \
getmetatable ipairs loadfile next pairs \
pcall print rawequal rawget rawset \
setmetatable tonumber tostring type _VERSION \
xpcall string table math coroutine io os debug

keywordclass2.lua50=$(keywordclass2.lua5) \
getfenv gcinfo loadlib loadstring require \
setfenv unpack _LOADED LUA_PATH _REQUIREDNAME

# String, Table , Mathematical, Bitwise
keywordclass3.lua5=\
string.byte string.char string.dump string.find string.format \
string.gsub string.len string.lower string.rep string.sub string.upper \
table.concat table.insert table.remove table.sort \
math.abs math.acos math.asin math.atan math.atan2 \
math.ceil math.cos math.deg math.exp math.floor \
math.frexp math.ldexp math.log math.max math.min \
math.pi math.pow math.rad math.random math.randomseed \
math.sin math.sqrt math.tan

keywordclass3.lua50=$(keywordclass3.lua5) \
string.gfind \
table.foreach table.foreachi table.getn table.setn \
math.mod math.log10

# Coroutine, Input/Output, System, Package
keywordclass4.lua50=\
coroutine.create coroutine.resume coroutine.status coroutine.wrap coroutine.yield \
io.close io.flush io.input io.lines io.open \
io.output io.read io.tmpfile io.type io.write \
io.stdin io.stdout io.stderr \
os.clock os.date os.difftime os.execute os.exit \
os.getenv os.remove os.rename os.setlocale os.time \
os.tmpname

# Debug (not enabled by default)
keywordclass5.lua50=\
debug.debug debug.gethook debug.getinfo debug.getlocal debug.getupvalue \
debug.setlocal debug.setupvalue debug.sethook debug.traceback

#### Lua 5.1.4

# Keywords
keywordclass.lua51=$(keywordclass.lua50)

# Basic Functions
keywordclass2.lua51=$(keywordclass2.lua5) \
getfenv load loadstring select \
setfenv unpack package

# String, Table , Mathematical, Bitwise
keywordclass3.lua51=$(keywordclass3.lua5) \
string.gmatch string.match string.reverse \
table.maxn \
math.cosh math.fmod math.huge math.log10 math.modf \
math.sinh math.tanh

# Coroutine, Input/Output, System, Package
keywordclass4.package=\
require package.cpath package.loaded \
package.loadlib package.path package.preload

keywordclass4.lua51=$(keywordclass4.lua50) \
coroutine.running io.popen \
module package.loaders package.seeall \
$(keywordclass4.package)

# Debug (not enabled by default)
keywordclass5.lua51=$(keywordclass5.lua50) \
debug.getfenv debug.getmetatable debug.getregistry debug.setfenv debug.setmetatable

#### Lua 5.2.0

# Keywords
keywordclass.lua52=$(keywordclass.lua50) goto

# Basic Functions
keywordclass2.lua52=$(keywordclass2.lua5) \
load rawlen select package bit32 _ENV

# String, Table , Mathematical, Bitwise
keywordclass3.bit32=\
bit32.arshift bit32.band bit32.bnot bit32.bor bit32.btest \
bit32.bxor bit32.extract bit32.replace bit32.lrotate bit32.lshift \
bit32.rrotate bit32.rshift

keywordclass3.lua52=$(keywordclass3.lua5) \
string.gmatch string.match string.reverse \
table.pack table.unpack \
math.cosh math.fmod math.huge math.modf math.sinh math.tanh \
$(keywordclass3.bit32)

# Coroutine, Input/Output, System, Package
keywordclass4.lua52=$(keywordclass4.lua50) \
coroutine.running io.popen \
package.config package.searchers package.searchpath \
$(keywordclass4.package)

# Debug (not enabled by default)
keywordclass5.lua52=$(keywordclass5.lua50) \
debug.getmetatable debug.getregistry debug.setmetatable \
debug.getuservalue debug.setuservalue debug.upvalueid debug.upvaluejoin

#### Lua 5.3.0

# Keywords
keywordclass.lua53=$(keywordclass.lua50) goto

# Basic Functions
keywordclass2.lua53=$(keywordclass2.lua5) \
load rawlen select package utf8 _ENV

# String, UTF8, Table , Mathematical
keywordclass3.utf8=\
utf8.char utf8.charpattern utf8.codes \
utf8.codepoint utf8.len utf8.offset

keywordclass3.lua53=\
string.byte string.char string.dump string.find string.format \
string.gmatch string.gsub string.len string.lower string.match \
string.pack string.packsize string.rep \
string.reverse string.sub string.unpack string.upper \
table.concat table.insert table.move table.pack \
table.remove table.sort table.unpack \
math.abs math.acos math.asin math.atan \
math.ceil math.cos math.deg math.exp \
math.floor math.fmod math.huge \
math.log math.max math.maxinteger math.min math.mininteger \
math.modf math.pi math.rad \
math.random math.randomseed math.sin \
math.sqrt math.tan \
math.tointeger math.type math.ult \
$(keywordclass3.utf8)

# Coroutine, Input/Output, System, Package
keywordclass4.lua53=$(keywordclass4.lua50) \
coroutine.isyieldable coroutine.running io.popen \
package.config package.searchers package.searchpath \
$(keywordclass4.package)

# Debug (not enabled by default)
keywordclass5.lua53=$(keywordclass5.lua52)

#### Lua 5.x

# Keywords
keywordclass.lua5x=$(keywordclass.lua53)

# Basic Functions
keywordclass2.lua5x=$(keywordclass2.lua5) \
getfenv gcinfo load loadlib loadstring \
require select setfenv unpack \
_LOADED LUA_PATH _REQUIREDNAME \
package rawlen package bit32 utf8 _ENV

# String, Table , Mathematical, Bitwise
keywordclass3.lua5x=$(keywordclass3.lua5) \
string.gfind string.gmatch string.match string.reverse \
string.pack string.packsize string.unpack \
table.foreach table.foreachi table.getn table.setn \
table.maxn table.pack table.unpack table.move \
math.cosh math.fmod math.huge math.log10 math.modf \
math.mod math.sinh math.tanh math.maxinteger math.mininteger \
math.tointeger math.type math.ult \
$(keywordclass3.bit32) \
$(keywordclass3.utf8)

# Coroutine, Input/Output, System, Package
keywordclass4.lua5x=$(keywordclass4.lua50) \
coroutine.isyieldable coroutine.running io.popen \
module package.loaders package.seeall \
package.config package.searchers package.searchpath \
$(keywordclass4.package)

# Debug (not enabled by default)
keywordclass5.lua5x=$(keywordclass5.lua50) \
debug.getfenv debug.getmetatable debug.getregistry debug.setfenv debug.setmetatable \
debug.getuservalue debug.setuservalue debug.upvalueid debug.upvaluejoin

# Keyword highlighting selection
# Options: lua4, lua50, lua51, lua52, lua53, lua5x (default)
# or enable everything like this: $(keywordclass.lua4)$(keywordclass.lua5x)
keywords.$(file.patterns.lua)=$(keywordclass.lua5x)
keywords2.$(file.patterns.lua)=$(keywordclass2.lua5x)
keywords3.$(file.patterns.lua)=$(keywordclass3.lua5x)
keywords4.$(file.patterns.lua)=$(keywordclass4.lua5x)

# Add keywords5, 6, 7 & 8 for user-defined libraries
#keywords5.$(file.patterns.lua)=
#keywords6.$(file.patterns.lua)=
#keywords7.$(file.patterns.lua)=
#keywords8.$(file.patterns.lua)=

#~ statement.indent.$(file.patterns.lua)=5 do else function then
#~ statement.lookback.$(file.patterns.lua)=20
indent.maintain.$(file.patterns.lua)=1

comment.block.lua=--~
comment.block.at.line.start.lua=1

# Lua styles

# Braces are only matched in operator style
braces.lua.style=10

# compatible with LuaBinaries for Lua 5.1; will work on both platforms.
command.compile.*.lua=luac5.1 -o "$(FileName).luc" "$(FileNameExt)"
# Lua 5.1
command.go.*.lua=lua5.1 "$(FileNameExt)"
# Lua 4.0
#command.go.*.lua=Lua-4.0.exe -c -f "$(FileNameExt)"



###############################################################################
# From matlab.properties
# Define SciTE settings for Octave and Matlab (see below) files.

# set the default lexer for .m files
DEFAULT_M_LEXER_OCTAVE=1
DEFAULT_M_LEXER_MATLAB=0

#-----------------------------------------------------------------------
# Octave
#-----------------------------------------------------------------------

# M: Octave M-Files (we nee .m.octave for distinguishing it from matlab)
file.patterns.octave=*.m.octave
#~ if DEFAULT_M_LEXER_OCTAVE
#~ file.patterns.octave=*.m;$(file.patterns.octave)
file.patterns.matlab=*.m;*.m.octave

# M: Octave M-Files
filter.octave=Octave (m)|$(file.patterns.octave)|

lexer.$(file.patterns.octave)=octave

#*language.octave=Octave|m.octave||

keywordclass.octave=\
__FILE__ \
__LINE__ \
break \
case \
catch \
classdef \
continue \
do \
else \
elseif \
end \
end_try_catch \
end_unwind_protect \
endclassdef \
endenumeration \
endevents \
endfor \
endif \
endmethods \
endparfor \
endproperties \
endswitch \
endwhile \
enumeration \
events \
for \
function endfunction \
get \
global \
if \
methods \
otherwise \
parfor \
persistent \
properties \
return \
set \
static \
switch \
try \
until \
unwind_protect \
unwind_protect_cleanup \
while

keywords.$(file.patterns.octave)=$(keywordclass.octave)

comment.block.octave=#

# Octave styles

#-----------------------------------------------------------------------
# Matlab
#-----------------------------------------------------------------------

# M: Matlab M-Files (we need .m.matlab to distinguish it from octave)
file.patterns.matlab=*.m.matlab
#~ if DEFAULT_M_LEXER_MATLAB
#~ file.patterns.matlab=*.m;$(file.patterns.matlab)
# M: Matlab M-Files
filter.matlab=Matlab (m)|$(file.patterns.matlab)|

*filter.matlab=$(filter.matlab)

lexer.$(file.patterns.matlab)=matlab

*language.matlab=Matlab|m.matlab||

keywordclass.matlab=break case catch continue else elseif end for function \
global if otherwise persistent return switch try while

keywords.$(file.patterns.matlab)=$(keywordclass.matlab)

comment.block.matlab=%~

# Matlab styles




###############################################################################
# From metapost.properties
# file    : metapost.properties
# version : 18 august 2003
# author  : Hans Hagen / PRAGMA ADE / www.pragma-ade.com

# Metapost: patterns

file.patterns.metapost=*.mp;*.mpx
file.patterns.metafun=*.mp;*.mpx;*.mpy

filter.metapost=MetaPost (mp mpx)|$(file.patterns.metapost)|
filter.metafun=MetaFun (mp mpx mpy)|$(file.patterns.metafun)|

*filter.metapost=$(filter.metapost)

lexer.$(file.patterns.metapost)=metapost
lexer.$(file.patterns.metafun)=metapost

*language.metapost=MetaPost|mp||

# Metapost: commands (check process view)

command.compile.$(file.patterns.metapost)=
command.build.$(file.patterns.metapost)=mpost $(FileNameExt)
command.go.$(file.patterns.metapost)=gv $(FileName).1

command.compile.$(file.patterns.metafun)=
command.build.$(file.patterns.metafun)=texexec --mptex $(FileNameExt)
command.go.$(file.patterns.metafun)=gv $(FileName).1

command.0.$(file.patterns.metapost)=
command.1.$(file.patterns.metapost)=
command.2.$(file.patterns.metapost)=
command.3.$(file.patterns.metapost)=
command.4.$(file.patterns.metapost)=
command.5.$(file.patterns.metapost)=
command.6.$(file.patterns.metapost)=
command.7.$(file.patterns.metapost)=
command.8.$(file.patterns.metapost)=
command.9.$(file.patterns.metapost)=

command.0.$(file.patterns.metafun)=
command.1.$(file.patterns.metafun)=
command.2.$(file.patterns.metafun)=
command.3.$(file.patterns.metafun)=
command.4.$(file.patterns.metafun)=
command.5.$(file.patterns.metafun)=
command.6.$(file.patterns.metafun)=
command.7.$(file.patterns.metafun)=
command.8.$(file.patterns.metafun)=
command.9.$(file.patterns.metafun)=

# Metapost: highlighting



# Metapost: comments

comment.block.metapost=%
comment.block.at.line.start.metapost=1

# Metapost: lexer.metapost.interface.default
#
# 0 not used
# 1 metapost primitives and commands
# 2 metafun macros
#
# first lines of a metapost file are interpreted as follows:
#
# % interface=none|metapost|mp|metafun

lexer.metapost.interface.default=1

# Metapost: lexer.metapost.comment.process
#
# 0 don't interpret comment
# 1 color comment like source code

lexer.metapost.comment.process=0

# Metapost: keywords

keywordclass.metapost.tex=\
    btex verbatimtex etex

keywordclass.metapost.primitives=\
    charcode day linecap linejoin miterlimit month pausing \
    prologues showstopping time tracingcapsules tracingchoices \
    tracingcommands tracingequations tracinglostchars \
    tracingmacros tracingonline tracingoutput tracingrestores \
    tracingspecs tracingstats tracingtitles truecorners \
    warningcheck year \
    false nullpicture pencircle true \
    and angle arclength arctime ASCII bluepart boolean bot \
    char color cosd cycle decimal directiontime floor fontsize \
    greenpart hex infont intersectiontimes known length llcorner \
    lrcorner makepath makepen mexp mlog normaldeviate not \
    numeric oct odd or path pair pen penoffset picture point \
    postcontrol precontrol redpart reverse rotated scaled \
    shifted sind slanted sqrt str string subpath substring \
    transform transformed ulcorner uniformdeviate unknown \
    urcorner xpart xscaled xxpart xypart ypart yscaled yxpart \
    yypart zscaled \
    addto clip input interim let newinternal save setbounds \
    shipout show showdependencies showtoken showvariable \
    special \
    begingroup endgroup of curl tension and controls \
    reflectedabout rotatedaround interpath on off beginfig \
    endfig def vardef enddef epxr suffix text primary secondary \
    tertiary primarydef secondarydef tertiarydef top bottom \
    ulft urt llft lrt randomseed also contour doublepath \
    withcolor withpen dashed if else elseif fi for endfor forever exitif \
    forsuffixes downto upto step until \
    charlist extensible fontdimen headerbyte kern ligtable \
    boundarychar chardp charext charht charic charwd designsize \
    fontmaking charexists \
    cullit currenttransform gfcorners grayfont hround \
    imagerules lowres_fix nodisplays notransforms openit \
    displaying currentwindow screen_rows screen_cols \
    pixels_per_inch cull display openwindow numspecial \
    totalweight autorounding fillin proofing tracingpens \
    xoffset chardx granularity smoothing turningcheck yoffset \
    chardy hppp tracingedges vppp \
    extra_beginfig extra_endfig mpxbreak \
    end

keywordclass.metapost.plain=\
    ahangle ahlength bboxmargin defaultpen defaultscale \
    labeloffset background currentpen currentpicture cuttings \
    defaultfont extra_beginfig extra_endfig \
    beveled black blue bp butt cc cm dd ditto down epsilon \
    evenly fullcircle green halfcircle identity in infinity left \
    mitered mm origin pensquare pt quartercircle red right \
    rounded squared unitsquare up white withdots \
    abs bbox ceiling center cutafter cutbefore dir \
    directionpoint div dotprod intersectionpoint inverse mod lft \
    round rt unitvector whatever \
    cutdraw draw drawarrow drawdblarrow fill filldraw drawdot \
    loggingall pickup tracingall tracingnone undraw unfill \
    unfilldraw \
    buildcycle dashpattern decr dotlabel dotlabels drawoptions \
    incr label labels max min thelabel z \
    beginchar blacker capsule_end change_width \
    define_blacker_pixels define_corrected_pixels \
    define_good_x_pixels define_good_y_pixels \
    define_horizontal_corrected_pixels define_pixels \
    define_whole_blacker_pixels define_whole_pixels \
    define_whole_vertical_blacker_pixels \
    define_whole_vertical_pixels endchar extra_beginchar \
    extra_endchar extra_setup font_coding_scheme\
    font_extra_space

keywordclass.metapost.all=\
    $(keywordclass.metapost.tex) \
    $(keywordclass.metapost.primitives) \
    $(keywordclass.metapost.plain)

keywordclass.metafun.all=

keywords.$(file.patterns.metapost)=$(keywordclass.metapost.all)

keywords.$(file.patterns.metafun)=$(keywordclass.metapost.all)
keywords2.$(file.patterns.metafun)=$(keywordclass.metafun.all)

##  Metapost fold points
## keywords4  = fold beginning; keywords5 = fold ending.
keywords4.$(file.patterns.metapost)=beginfig for verbatimtex def begingroup \
    if btex forsuffixes vardef primarydef
keywords5.$(file.patterns.metapost)=etex fi endfig endgroup end endfor endif \
    enddef

import metafun-scite.properties

# Metapost: end of file



###############################################################################
# From mmixal.properties

# Define SciTE settings for MMIXAL files.

file.patterns.mmixal=*.mms
filter.mmixal=MMIXAL (mms)|$(file.patterns.mmixal)|
*filter.mmixal=$(filter.mmixal)

lexer.$(file.patterns.mmixal)=mmixal

*language.mmixal=MMIXAL|mms||

opcodes=2ADDU 4ADDU 8ADDU 16ADDU ADD ADDU AND ANDNH ANDNL ANDNMH ANDNML \
	BDIF BEV BN BNN BNP BNZ BOD BP BSPEC BYTE BZ CMP CMPU CSEV CSN CSNN CSNP CSNZ CSOD CSP CSWAP CSZ \
	DIV DIVU ESPEC EXPR FADD FCMP FCMPE FDIV FEQL FEQLE FIX FIXU FLOT FLOTU FMUL FREM FSQRT FSUB FUN FUNE \
	GET GETA GO GREG I_BIT INCH INCL INCMH INCML IS JMP LDA LDB LDBU LDHT LDO LDOU LDSF LDT LDTU LDUNC LDVTS LDW LDWU LOC LOCAL \
	MOR MUL MULU MUX MXOR NAND NEG NEGU NNIX NOR NXOR O_BIT OCTA ODIF OR ORH ORL ORMH ORML ORN \
	PBEV PBN PBNN PBNP PBNZ PBOD PBP PBZ POP PREFIX PREGO PRELD PREST PUSHGO PUSHJ PUT \
	RESUME SAVE SET SETH SETL SETMH SETML SFLOT SFLOTU SL SLU SR SRU \
	STB STBU STCO STHT STO STOU STSF STT STTU STUNC STW STWU SUB SUBU SWYM SYNC SYNCD TDIF TETRA TRAP TRIP UNSAVE \
	WDIF WYDEXOR ZSEV ZSN ZSNN ZSNP ZSNZ ZSOD ZSP ZSZ

special_register=rA rB rC rD rE rF rG rH rI rJ rK rL rM rN rO rP rQ rR rS rT rU rV rW rX rY rZ rBB rTT rWW rXX rYY rZZ

predef_symbols=@ Text_Segment Data_Segment Pool_Segment Stack_Segment \
	StdErr StdIn StdOut \
	Fopen Fclose Fread Fwrite Fgets Fputs Fgetws Fputws Ftell Fseek \
	TextRead TextWrite BinaryRead BinaryWrite BinaryReadWrite

keywords.$(file.patterns.mmixal)=$(opcodes)
keywords2.$(file.patterns.mmixal)=$(special_register)
keywords3.$(file.patterns.mmixal)=$(predef_symbols)

# Include for those who use the preprocessor mmixali written by R. Loos.
# Comment otherwise.

comment.block.mmixal=%

tab.size.$(file.patterns.mmixal)=16
indent.size.$(file.patterns.mmixal)=16

command.compile.$(file.patterns.mmixal)=mmixal -l $(FileName).map -b 200 $(FilePath)
command.go.$(file.patterns.mmixal)=mmix $(1) $(FileName).mmo
#~ mmotype
command.name.2.$(file.patterns.mmixal)=mmotype
command.2.$(file.patterns.mmixal)=mmotype $(FileName).mmo $(FileName).out



###############################################################################
# From modula3.properties
#
#	-*- coding: utf-8 -*-
#	File	:	modula3.properties
#	Author	:	Dariusz Knociński
#	Date	:	2010/11/07 - 2010/12/11
#	Notes	:	Define SciTE settings for Modula-3.
#

file.patterns.m3=*.m3;*.mg;*.i3;*.ig

filter.modula3=Modula-3 (m3 i3 mg ig)|$(file.patterns.m3)|
*filter.modula3=$(filter.modula3)
lexer.$(file.patterns.m3)=modula
*language.modula3=Modula-3|m3||

#	Keywords
#
keywords.$(file.patterns.m3)=AND ANY ARRAY AS BEGIN BITS BRANDED BY CASE CONST\
	DIV DO ELSE ELSIF END EVAL EXCEPT EXCEPTION EXIT EXPORTS FINALLY FOR FROM\
	GENERIC IF IMPORT IN INTERFACE LOCK LOOP METHODS MOD MODULE NOT OBJECT OF\
	OR OVERRIDES PROCEDURE RAISE RAISES READONLY RECORD REF REPEAT RETURN\
	REVEAL ROOT SET THEN TO TRY TYPE TYPECASE UNSAFE UNTIL UNTRACED VALUE VAR\
	WHILE WITH

#	Reserved identifiers
#
keywords2.$(file.patterns.m3)=ABS ADDRESS ADR ADRSIZE BITSIZE BOOLEAN BYTESIZE\
	CARDINAL CEILING CHAR DEC DISPOSE EXTENDED FALSE FIRST FLOAT FLOOR INC\
	INTEGER ISTYPE LAST LONGINT LONGREAL LOOPHOLE MAX MIN MUTEX NARROW NEW NIL\
	NULL NUMBER ORD REAL REFANY ROUND SUBARRAY TEXT TRUE TRUNC TYPECODE VAL\
	WIDECHAR

#	Operators
#
keywords3.$(file.patterns.m3)= + < # = ; .. : - > { } | := <: * <= ( ) ^ , =>\
	/ >= [ ] . &

#	Pragmas keywords
#
keywords4.$(file.patterns.m3)= EXTERNAL INLINE ASSERT TRACE FATAL UNUSED\
	OBSOLETE NOWARN LINE PRAGMA

#	Escape sequences
#
keywords5.$(file.patterns.m3)= f n r t \ " '

#	Doxygene keywords
#
keywords6.$(file.patterns.m3)= author authors file brief date proc param result

# Default fonts
#
font.module.base=$(font.base)
font.modula.code=font:$(font.module.base),size:10
font.modula.comment=font:$(font.module.base),size:10,italics
font.modula.doxykey=font:$(font.module.base),size:10,bold,italics
font.modula.keywords=font:$(font.module.base),size:10,bold
font.modula.reserved=font:$(font.module.base),size:10
font.modula.strings=font:$(font.module.base),size:10,italics
font.modula.strspec=font:$(font.module.base),size:10,bold,italics
font.modula.char=font:$(font.module.base),size:10,italics
font.modula.charspec=font:$(font.module.base),size:10,bold,italics
font.modula.badstr=font:$(font.module.base),size:10,bold

# Default
#

# Comments
#

# Doxygen comments
#

# Doxygene keywords
#

# Keywords
#

# Reserved words
#

# Numbers
#

# Based numbers / #{#}_#{#} base 2-16
#

# Float numbers / #{#}.#{#}Exp
#

# Strings
#

# Strings special (escape sequences)
#

# Char
#

# Char special (escape sequences and octal numbers)
#

# Procedures
#

# Pragmas
#

# Pragmas keywords
#

# Operators
#

# Bad strings
#

#
#	EOF
#



###############################################################################
# From nimrod.properties
# Define SciTE settings for Nimrod files.

file.patterns.nimrod=*.nim

shbang.nimrod=nim

filter.nimrod=Nimrod (nim)|$(file.patterns.nimrod)|

*filter.nimrod=$(filter.nimrod)

lexer.$(file.patterns.nimrod)=nimrod

keywordclass.nimrod=addr and as asm \
block break \
case cast const continue converter \
discard div \
elif else end enum except exception \
finally for from generic \
if implies import in include is isnot iterator \
lambda \
macro method mod \
nil not notin \
object of or out \
proc ptr \
raise ref return \
shl shr \
template try tuple type \
var \
when where while with without \
xor \
yield

keywords.$(file.patterns.nimrod)=$(keywordclass.nimrod)

#~ statement.indent.$(file.patterns.nimrod)=10 :
statement.indent.$(file.patterns.nimrod)=5 elif else except finally of \
for if try while

statement.lookback.$(file.patterns.nimrod)=0
block.start.$(file.patterns.nimrod)=
block.end.$(file.patterns.nimrod)=

view.indentation.examine.*.nim=2

#fold.quotes.nimrod=1

comment.block.nimrod=#~

# nimrod styles
# Braces are only matched in operator style
braces.nimrod.style=10

if PLAT_WIN
	command.go.*.nim=nimrod c -r "$(FileNameExt)"
	command.go.subsystem.*.nim=1

if PLAT_GTK
	command.go.*.nim=nimrod c -r "$(FileNameExt)"

command.name.1.*.nim=Syntax Check
command.1.*.nim=nimrod check "$(FilePath)"

# compile
command.compile.*.nim=nimrod c "$(FilePath)"

# build
command.build.*.nim=nimrod --forcebuild "$(FilePath)"
command.build.subsystem.*.nim=1





###############################################################################
# From nncrontab.properties
# Define SciTE settings for extended crontab files used by a powerful
# Windows scheduler/event monitor/automation manager nnCron.
# (http://nemtsev.eserv.ru/)

file.patterns.nncron=*.tab;*.spf
# add '*.tab;*.spf;' to 'source.files' variable in 'SciTEGlobal.properties'
# if you want to include these file patterns into default source file list

lexer.$(file.patterns.nncron)=nncrontab

*language.nnCron=&nnCron crontab|tab||

filter.nncrontab=nnCron files (tab spf)|$(file.patterns.nncron)|

*filter.nncrontab=$(filter.nncrontab)

word.characters.$(file.patterns.nncron)=$(chars.alpha)$(chars.numeric)%-

comment.block.nncrontab=\ 

# nnCrontab styles

# Section keywords and Forth words for nnCrontab
keywords.$(file.patterns.nncron)=\
AGAIN ALLOT AND Action BEGIN CASE COMPARE CONSTANT CREATE DO Days ELSE \
ENDCASE ENDOF EVAL-SUBST EVALUATE FALSE Hours I IF LEAVE LOOP Minutes \
Months NOT OF OFF ON OR PAD REPEAT Rule SET THEN TRUE Time UNTIL VALUE \
VARIABLE WHILE WeekDays Years

# Keywords for nnCrontab
keywords2.$(file.patterns.nncron)=\
</JScript> </SCRIPT> </VBScript> <JScript> <VBScript> ACCESS-DATE BEEP \
CALL_DIAL CALL_HANGUP CHAR CLIPBOARD CONSOLE CREATION-DATE CUR-DATE DATE- \
DATE-INTERVAL DELAY DIAL DIR-CREATE DIR-DELETE DIR-EMPTY DIR-SIZE Day@ \
Domain ERR-MSG EXIST FILE-ACCESS-DATE FILE-APPEND FILE-COPY FILE-CREATE \
FILE-CREATION-DATE FILE-CROP FILE-DATE FILE-DELETE FILE-EMPTY FILE-EXIST \
FILE-MOVE FILE-RENAME FILE-SIZE FILE-WRITE FILE-WRITE-DATE FOR-CHILD-WINDOWS \
FOR-FILES FOR-WINDOWS FREE-SPACE GET-CUR-TIME GET-REG GET-VER GetTickCount \
HANGUP HIDE-ICON HINT HINT-OFF HINT-POS HINT-SIZE HINTW HOST-EXIST Hour@ \
IDLE INTERVAL IS-ARCHIVE IS-DIR IS-HIDDEN IS-READONLY IS-SYSTEM KILL LAUNCH \
LOG LOGGEDON LOGOFF LogonBatch LogonInteractive LogonNetwork MOUSE-LBCLK \
MOUSE-LBDCLK MOUSE-LBDN MOUSE-LBUP MOUSE-MOVE MOUSE-MOVER MOUSE-MOVEW \
MOUSE-RBCLK MOUSE-RBDCLK MOUSE-RBDN MOUSE-RBUP MSG Min@ Mon@ \
MonitorResponseTime NHOST-EXIST No ONLINE PAUSE PLAY-SOUND PLAY-SOUNDW \
POP3-CHECK POWEROFF PROC-EXIST PROC-TIME PURGE-OLD PURGE-OLDA PURGE-OLDW \
Password QSTART-APP QSTART-APPW QUERY QUIT RASDomain RASError RASPassword \
RASPhone RASSecPassword RASUser RE-ALL RE-MATCH REBOOT REG-DELETE-KEY \
REG-DELETE-VALUE REG-DWORD REG-SZ REMINDER RUN SEND-KEYS SEND-KEYS-DELAY \
SHOW-ICON SHUTDOWN START-APP START-APPW START-QUIT START-TIME Sec@ \
SecPassword THINT THINTW TimeSec@ TMSG TQUERY User WDay@ WIN-ACTIVATE \
WIN-ACTIVE WIN-CLICK WIN-CLOSE WIN-EXIST WIN-HIDE WIN-HWND WIN-MAXIMIZE \
WIN-MINIMIZE WIN-MOVE WIN-MOVER WIN-RESTORE WIN-SEND-KEYS WIN-SHOW \
WIN-TERMINATE WIN-TOPMOST WIN-VER WIN-WAIT WINAPI WRITE-DATE WatchClipboard \
WatchConnect WatchDir WatchDisconnect WatchDriveInsert WatchDriveRemove \
WatchFile WatchProc WatchProcStop WatchWinActivate WatchWinCreate \
WatchWinDestroy WatchWindow WinNT Year@ Yes

# Modifiers for nnCrontab
keywords3.$(file.patterns.nncron)=\
ALL AboveNormalPriority AsService BelowNormalPriority FILESONLY \
HighPriority IdlePriority LoadProfile NoActive NoDel NoLog NoRunAs \
NormalPriority OnceADay OnceAHour OnceAMonth OnceAWeek RECURSIVE \
RealtimePriority RunOnce SWHide ShowMaximized ShowMinimized ShowNoActivate \
ShowNormal StartIn StartPos StartSize TODEPTH WATCH-CHANGE-ATTRIBUTES \
WATCH-CHANGE-DIR-NAME WATCH-CHANGE-FILE-NAME WATCH-CHANGE-LAST-WRITE \
WATCH-CHANGE-SECURITY WATCH-CHANGE-SIZE WaitFor WatchSubtree WithoutProfile




###############################################################################
# From nsis.properties
# Define SciTE settings for NSIS.
# contributed by Angelo Mandato <angelo at spaceblue dot com>
# Updated for NSIS v.2.02 / 2004-10-25 by flizebogen <flizebogen at gmx dot de>
# Updated /2004-28-2 by Robert Roessler <robertr at rftp dot com>
# Updated for NSIS v.2.05 and latest lexer / 2005-3-10 by Angelo Mandato <angelo at spaceblue dot com>

filter.nsis=NSIS (nsi nsh)|*.nsi;*.nsh|
*filter.nsis=$(filter.nsis)
file.patterns.nsis=*.nsi;*.nsh
lexer.$(file.patterns.nsis)=nsis
*language.nsis=NSIS|nsis||

# Advanced settings
nsis.uservars=1
#nsis.ignorecase=1
# Note: keywords below must all be lowercase in order for ignorecase=1 to function correctly

# Functions:
keywords.$(file.patterns.nsis)=!addincludedir !addplugindir MakeNSIS Portions \
Contributors: Abort AddBrandingImage AddSize AutoCloseWindow BGFont \
BGGradient BrandingText BringToFront Call CallInstDLL Caption ChangeUI \
ClearErrors ComponentText GetDLLVersion GetDLLVersionLocal GetFileTime \
GetFileTimeLocal CopyFiles CRCCheck CreateDirectory CreateFont CreateShortCut \
SetDatablockOptimize DeleteINISec DeleteINIStr DeleteRegKey DeleteRegValue \
Delete DetailPrint DirText DirShow DirVar DirVerify GetInstDirError AllowRootDirInstall \
CheckBitmap EnableWindow EnumRegKey EnumRegValue Exch Exec ExecWait \
ExecShell ExpandEnvStrings FindWindow FindClose FindFirst FindNext File FileBufSize \
FlushINI ReserveFile FileClose FileErrorText FileOpen FileRead FileWrite FileReadByte \
FileWriteByte FileSeek Function FunctionEnd GetDlgItem GetFullPathName \
GetTempFileName HideWindow Icon IfAbort IfErrors IfFileExists IfRebootFlag IfSilent \
InstallDirRegKey InstallColors InstallDir InstProgressFlags InstType IntOp IntCmp \
IntCmpU IntFmt IsWindow Goto LangString LangStringUP LicenseData \
LicenseForceSelection LicenseLangString LicenseText LicenseBkColor \
LoadLanguageFile LogSet LogText MessageBox Nop Name OutFile Page \
PageCallbacks PageEx PageExEnd Pop Push Quit ReadINIStr ReadRegDWORD \
ReadRegStr ReadEnvStr Reboot RegDLL Rename Return RMDir Section SectionEnd \
SectionIn SubSection SectionGroup SubSectionEnd SectionGroupEnd SearchPath \
SectionSetFlags SectionGetFlags SectionSetInstTypes SectionGetInstTypes \
SectionGetText SectionSetText SectionGetSize SectionSetSize GetCurInstType \
SetCurInstType InstTypeSetText InstTypeGetText SendMessage SetAutoClose \
SetCtlColors SetBrandingImage SetCompress SetCompressor SetCompressorDictSize \
SetCompressionLevel SetDateSave SetDetailsView SetDetailsPrint SetErrors \
SetErrorLevel GetErrorLevel SetFileAttributes SetFont SetOutPath SetOverwrite \
SetPluginUnload SetRebootFlag SetShellVarContext SetSilent ShowInstDetails \
ShowUninstDetails ShowWindow SilentInstall SilentUnInstall Sleep StrCmp StrCpy \
StrLen SubCaption UninstallExeName UninstallCaption UninstallIcon UninstPage \
UninstallText UninstallSubCaption UnRegDLL WindowIcon WriteINIStr WriteRegBin \
WriteRegDWORD WriteRegStr WriteRegExpandStr WriteUninstaller XPStyle !packhdr \
!system !execute !AddIncludeDir !include !cd !ifdef !ifndef !endif !define !undef !else !echo !warning \
!error !verbose !macro !macroend !insertmacro !ifmacrodef !ifmacrondef MiscButtonText \
DetailsButtonText UninstallButtonText InstallButtonText SpaceTexts \
CompletedText GetFunctionAddress GetLabelAddress GetCurrentAddress \
!AddPluginDir InitPluginsDir AllowSkipFiles Var VIAddVersionKey VIProductVersion LockWindow


# Variables:
keywords2.$(file.patterns.nsis)=$0 $1 $2 $3 $4 $5 $6 $7 $8 $9 \
$R0 $R1 $R2 $R3 $R4 $R5 $R6 $R7 $R8 $R9 $\t $\" $\' $\` \
$VARNAME $0, $INSTDIR $OUTDIR $CMDLINE $LANGUAGE $PROGRAMFILES \
$COMMONFILES $DESKTOP $EXEDIR ${NSISDIR} $WINDIR $SYSDIR $TEMP \
$STARTMENU $SMPROGRAMS $SMSTARTUP $QUICKLAUNCH $DOCUMENTS \
$SENDTO $RECENT $FAVORITES $MUSIC $PICTURES $VIDEOS $NETHOOD \
$FONTS $TEMPLATES $APPDATA $PRINTHOOD $INTERNET_CACHE $COOKIES \
$HISTORY $PROFILE $ADMINTOOLS $RESOURCES $RESOURCES_LOCALIZED \
$CDBURN_AREA $HWNDPARENT $PLUGINSDIR $$ $\r $\n

# Labels:
keywords3.$(file.patterns.nsis)=ARCHIVE FILE_ATTRIBUTE_ARCHIVE FILE_ATTRIBUTE_HIDDEN \
FILE_ATTRIBUTE_NORMAL FILE_ATTRIBUTE_OFFLINE FILE_ATTRIBUTE_READONLY \
FILE_ATTRIBUTE_SYSTEM FILE_ATTRIBUTE_TEMPORARY HIDDEN HKCC HKCR HKCU \
HKDD HKEY_CLASSES_ROOT HKEY_CURRENT_CONFIG HKEY_CURRENT_USER HKEY_DYN_DATA \
HKEY_LOCAL_MACHINE HKEY_PERFORMANCE_DATA HKEY_USERS HKLM HKPD HKU IDABORT \
IDCANCEL IDIGNORE IDNO IDOK IDRETRY IDYES MB_ABORTRETRYIGNORE MB_DEFBUTTON1 \
MB_DEFBUTTON2 MB_DEFBUTTON3 MB_DEFBUTTON4 MB_ICONEXCLAMATION \
MB_ICONINFORMATION MB_ICONQUESTION MB_ICONSTOP MB_OK MB_OKCANCEL \
MB_RETRYCANCEL MB_RIGHT MB_SETFOREGROUND MB_TOPMOST MB_YESNO \
MB_YESNOCANCEL NORMAL OFFLINE READONLY SW_SHOWMAXIMIZED SW_SHOWMINIMIZED \
SW_SHOWNORMAL SYSTEM TEMPORARY auto colored false force hide ifnewer nevershow \
normal off on show silent silentlog smooth true try lzma zlib bzip2 none listonly textonly \
both top left bottom right license components directory instfiles uninstConfirm custom \
all leave current ifdiff lastused LEFT RIGHT CENTER dlg_id ALT CONTROL EXT SHIFT \
open print manual alwaysoff

#User defined:
#keywords4.$(file.patterns.nsis)=MyFunction MySomethingElse



# compiling/building simply checks for the correct symantics....
command.compile.$(file.patterns.nsis)=c:/program files/nsis/makensis.exe "$(FilePath)"
command.build.$(file.patterns.nsis)=c:/program files/nsis/makensis.exe "$(FilePath)"

command.go.$(file.patterns.nsis)=$(FileName).exe

command.help.$(file.patterns.nsis)=$(CurrentWord)!C:\Program files\NSIS\NSIS.chm
command.help.subsystem.$(file.patterns.nsis)=4

comment.block.nsis=;
comment.block.at.line.start.nsis=1
comment.stream.start.nsis=/*
comment.stream.end.nsis=*/
comment.box.start.nsis=/*
comment.box.middle.nsis=;
comment.box.end.nsis=*/



###############################################################################
# From opal.properties
# Define SciTE settings for Opal files.

filter.opal=OPAL (impl sign)|*.impl;*.sign|

*filter.opal=$(filter.opal)

file.patterns.opal=*.impl;*.sign
lexer.$(file.patterns.opal)=opal
*language.opal=Opal|impl||

keywordclass.opal_keywords=ALL AND ANDIF ANY AS ASSERT AXM COMPLETELY DATA DEF DERIVE \
DFD DISCRIMINATORS ELSE EX EXTERNAL FI FIX FUN IF IMPLEMENTATION IMPLIES IMPORT \
IN INHERIT INJECTIONS INTERFACE INTERNAL LAW LAZY LEFTASSOC LET MODULE NOT ONLY \
OR ORIF OTHERWISE POST PRE PRED PRIORITY PROPERTIES REALIZES REQUIRE RIGHTASSOC \
SELECTORS SIGNATURE SORT SPC SPEC SPECIFICATION STRUCTURE THE THEN THEORY THM \
TYPE UNIQ WHERE

keywordclass.opal_sorts=aEntry agent align anchor ans arg arg1 arg2 array \
arrowWhere bag bitmap bool bstree byte callback canvasEditor capStyle channel \
char childstat codom codomFrom codomTo color colorModel com composeOp config \
configCom cursor dArray data data1 data11 data2 data21 data3 data31 data4 \
data41 dataFrom dataTo defaultPrio denotation device dist distOut dom domFrom \
domTo drawing dyn emitter env event eventInfo file filemode filestat filetype \
first first1 first2 first3 fission fmt font from from1 from2 funct group groupid \
heap iconfig image in inData index inode input int inter interdom interpreter \
iseq items joinStyle justifyHow long manager managerRequest map mapEntry mark \
mid modifier nat natMap OBJECT option orient out outData output packOp pair \
parser permission point positionRequest process procstat quad range real \
regulator rel relief res res1 res2 result role sap script scroller scrollView \
scrollWindow searchOpt second seekMode selector semaphor seq seqEntry set \
setEntry short sigaction sighandler sigmask signal size sizeRequest some \
sreal state stateId stateRequest string subrel tag textEditor time to tree \
triple union user userid version view void wconfig wconfigCom wday widget \
window wrapStyle

keywords.$(file.patterns.opal)=$(keywordclass.opal_keywords)
keywords2.$(file.patterns.opal)=$(keywordclass.opal_sorts)


# Opal styles




###############################################################################
# From oscript.properties
# Defines SciTE settings for OScript sources; osx files and/or OSpace dumps.
# OScript is a programming language used to develop applications for the
# Livelink server platform.

##############################################################################
# Specify file extension and lexer class.

file.patterns.oscript=*.osx
filter.oscript=OScript (osx)|$(file.patterns.oscript)|
*filter.oscript=$(filter.oscript)
lexer.$(file.patterns.oscript)=oscript

##############################################################################
# Specify various editor parameters.

word.chars.oscript=$(chars.alpha)$(chars.numeric)_$
word.characters.$(file.patterns.oscript)=$(word.chars.oscript)

#comment.block.at.line.start.oscript=1
comment.block.oscript=//~
#~ comment.stream.start.oscript=#ifdef DOC
#~ comment.stream.end.oscript=#endif
comment.stream.start.oscript=/*
comment.stream.end.oscript=*/
comment.box.start.oscript=/*
comment.box.middle.oscript= *
comment.box.end.oscript= */

statement.indent.$(file.patterns.oscript)=6 case default else for if \
repeat switch while
statement.lookback.$(file.patterns.oscript)=20
statement.end.$(file.patterns.oscript)=10 ;
block.start.$(file.patterns.oscript)=10 if
block.end.$(file.patterns.oscript)=10 end
indent.maintain.$(file.patterns.oscript)=1
indent.size.$(file.patterns.oscript)=4
use.tabs.$(file.patterns.oscript)=1
tab.size.$(file.patterns.oscript)=4

preprocessor.symbol.$(file.patterns.oscript)=#
preprocessor.start.$(file.patterns.oscript)=ifdef ifndef
preprocessor.middle.$(file.patterns.oscript)=else
preprocessor.end.$(file.patterns.oscript)=endif

##############################################################################
# Specify API autocompletion and calltip help.

api.$(file.patterns.oscript)=$(SciteDefaultHome)\api\oscript.api
autocomplete.oscript.ignorecase=1
calltip.oscript.ignorecase=1
calltip.oscript.use.escapes=1
calltip.oscript.word.characters=_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$.

##############################################################################
# Define keyword classes separately according to the language semantics
# before grouping them to keywords for styling. OScript is not case-sensitive;
# all keywords configured here must be entered in lower-case.

# Language native value and reference types.
keywordclass.type=\
assoc boolean bytes date dynamic error extern file integer list long object \
point real recarray record script string

# Word-like (literal) operators (boolean).
keywordclass.operator=\
and eq ge gt le lt ne not or xor

# Code-flow control statements.
keywordclass.oscript.control=\
break breakif by case continue continueif default downto else elseif end for \
goto if in repeat switch to until while

# Keywords to declare functions.
keywordclass.function=\
function return void

# Various language native keywords and reserved words.
keywordclass.miscellaneous=\
dll inbyref inout linked nodebug super this xcmd xfcn

# Constants with values and defaults for primitive types.
keywordclass.constant=\
false true undefined

# Language native constants (type classification integers).
keywordclass.coreconstant=\
booleantype bytestype datatype dynamictype errortype externtype integertype \
listtype longtype objecttype objreftype pointtype realtype scripttype \
stringtype undefinedtype voidtype

# Language native functions not bound to any object (global).
keywordclass.corefunction=\
datatypename echo echodebug echoerror echoinfo echostamp echowarn \
getfeatures isdefined iserror isfeature isinvokable isnoterror isnotset \
isobject isset isundefined length nparameters parameters pointh pointv type

# Object types available in Livelink kernel and core modules.
keywordclass.builtintype=\
cachetree capiconnect capierr capilog capilogin compiler dapisession \
dapinode dapiversion dapistream filecopy fileprefs frame javaobject \
mailmessage pop3session smtpsession ssloptions patfind patchange regex \
socket sqlconnection sqlcursor uapisession uapiuser wapisession wapimap \
wapimaptask wapiwork wapisubwork domattr domcdatasection domcharacterdata \
domcomment domdocument domdocumentfragment domdocumenttype domelement \
domentity domentityreference domimplementation domnamednodemap domnode \
domnodelist domnotation domparser domprocessinginstruction domtext saxparser \
xslprocessor

# Singletons available in Livelink kernel and core modules; they offer only
# static methods to call.
keywordclass.builtinobject=\
capi dapi env global language logging math memcached otds pattern security \
sql str system uapi vis wapi web zip

# Keywords usable in WebLingo sources (HTML templates including OScript).
keywordclass.weblingo=\
call html oscript

##############################################################################
# Define keyword groups that are recognized by the lexer and can be assigned
# different styles.

# Language native keywords: SCE_OSCRIPT_KEYWORD state.
keywords.$(file.patterns.oscript)=$(keywordclass.oscript.control) \
$(keywordclass.function) $(keywordclass.miscellaneous)

# Constants: SCE_OSCRIPT_CONSTANT state.
keywords2.$(file.patterns.oscript)=$(keywordclass.constant) \
$(keywordclass.coreconstant)

# Word-like (literal) operators: SCE_OSCRIPT_OPERATOR state.
keywords3.$(file.patterns.oscript)=$(keywordclass.operator)

# Value and reference (object) types: SCE_OSCRIPT_TYPE state.
keywords4.$(file.patterns.oscript)=$(keywordclass.type) \
$(keywordclass.builtintype)

# Language native (global) functions: SCE_OSCRIPT_FUNCTION state.
keywords5.$(file.patterns.oscript)=$(keywordclass.corefunction)

# Core static objects: SCE_OSCRIPT_OBJECT state.
keywords6.$(file.patterns.oscript)=$(keywordclass.builtinobject)

##############################################################################
# Define Style definitions supported by the lexical states. There are multiple
# states for language keyword groups although they all are reserved words; to
# be able ot assign them different styles.

# Documentation comment; a text delimited by preprocessor directives
# Type available in the language, in kernel or code modules.
# Global function in the language, in kernel or code modules.

braces.oscript.style=12

##############################################################################
# Specify help.

if PLAT_WIN
	command.help.$(file.patterns.oscript)=$(CurrentWord)!C:\LL971\builder\documentation.chm
	command.help.subsystem.$(file.patterns.oscript)=4



###############################################################################
# From others.properties
# Define SciTE settings for other simple files.

file.patterns.props=*.properties;*.session;*.ini;*.inf;*.url;*.cfg;*.cnf;*.aut
file.patterns.text=*.txt;*.log;*.lst;*.doc;*.diz;*.nfo
file.patterns.batch=*.bat;*.cmd;*.nt
file.patterns.diff=*.diff;*.patch
file.patterns.make=makefile;Makefile;*.mak;configure
file.patterns.indent=*.indent

*source.patterns.props=$(file.patterns.props);
*source.patterns.batch=$(file.patterns.batch);
*source.patterns.diff=$(file.patterns.diff);
*source.patterns.make=$(file.patterns.make);*.iface;

filter.properties=Properties (ini inf reg url cfg cnf)|$(file.patterns.props)|
filter.text=Text (txt log lst doc diz nfo)|$(file.patterns.text);make*|
filter.batch=Batch (bat cmd nt)|$(file.patterns.batch)|
filter.diff=Difference (diff patch)|$(file.patterns.diff)|

*filter.properties=$(filter.properties)
*filter.text=$(filter.text)

lexer.$(file.patterns.props)=props
lexer.$(file.patterns.batch)=batch
lexer.*.err=errorlist
lexer.$(file.patterns.make)=makefile
lexer.*.iface=makefile
lexer.$(file.patterns.diff)=diff
lexer.$(file.patterns.indent)=indent

*language.batch=&Batch|bat||
*language.difference=&Difference|diff||
*language.errorlist=&Errorlist|err||
*language.properties=&Properties|properties||
*language.makefile=&Makefile|mak|$(keyMake)|
*language._text=Text|txt|$(keyText)|
*language.indent=Indent|indent|$(keyIndent)|

word.characters.$(file.patterns.text)=$(chars.alpha)$(chars.numeric)$(chars.accented)-'

colour.other.operator=fore:#B06000

# Properties styles

comment.block.props=#~
preprocessor.symbol.$(file.patterns.make)=!
preprocessor.start.$(file.patterns.make)=IF IFDEF IFNDEF
preprocessor.middle.$(file.patterns.make)=ELSE ELSEIF ELSEIFDEF ELSEIFNDEF
preprocessor.end.$(file.patterns.make)=ENDIF

# Batch styles

# List from http://www.easydos.com/dosindex.html and https://sourceforge.net/p/scintilla/bugs/1686/
# I limit here the commands to those built in command.com, ie. I don't list external Dos commands
# if [no] (test) (command) -- test is EXIST (filename) | (string1)==(string2) | ERRORLEVEL (number)
# for %%(variable) IN (set) DO (command) -- variable is [a-zA-Z] -- eg for %%X in (*.txt) do type %%X
# Also includes device names.
keywordclass.batch=\
assoc aux break call cd chcp chdir choice cls cmdextversion \
color com1 com2 com3 com4 con copy ctty date defined \
del dir do dpath echo else endlocal erase errorlevel exist \
exit for ftype goto if in lpt1 lpt2 lpt3 lpt4 md mkdir move \
not nul path pause popd prompt prn pushd rd rem ren \
rename rmdir set setlocal shift start time title type ver \
verify vol
keywords.$(file.patterns.batch)=$(keywordclass.batch)

# Optional list of external commands to highlight in style 5.
# If not set all commands are highlighted in style 5.
#keywords2.$(file.patterns.batch)=append attrib chkdsk comp diskcomp


comment.block.batch=REM ~

# Makefile styles


comment.block.makefile=#~


error.background=back:#FFF7E7,eolfilled

lexer.errorlist.value.separate=1
#lexer.errorlist.escape.sequences=1

# Difference styles


command.build.makefile=make
command.build.*.mak=make

command.help.*.properties="file://$(SciteDefaultHome)/SciTEDoc.html#property-$(CurrentSelection)"
command.help.subsystem.*.properties=2

if PLAT_WIN
	command.go.*.bat="$(FileNameExt)"
	command.name.0.*.bat=Execute Selection
	command.0.*.bat=$(CurrentSelection)
	command.name.1.*.mak=nmake
	command.1.*.mak=nmake -f $(FileNameExt)



###############################################################################
# From pascal.properties
# Define SciTE settings for Pascal files.
# Changed by Fernando Lozano <fsl@centroin.com.br> for Free Pascal
# Changed by Mathias Rauen <scite@madshi.net> for Delphi
# Changed by Marko Njezic <sf@maxempire.com> to match new LexPascal lexer and updated for Delphi XE4

filter.pascal=Pascal (dpr dpk pas dfm inc pp)|*.dpr;*.dpk;*.pas;*.dfm;*.inc;*.pp|

*filter.pascal=$(filter.pascal)

file.patterns.pascal=*.dpr;*.pas;*.dfm;*.inc;*.pp
file.patterns.pascal.package=*.dpk
file.patterns.pascal.all=$(file.patterns.pascal);$(file.patterns.pascal.package)
lexer.$(file.patterns.pascal.all)=pascal
*language.pascal=Pascal|pas||

keywordclass.pascal=absolute abstract and array as asm assembler automated begin case \
cdecl class const constructor delayed deprecated destructor dispid dispinterface \
div do downto dynamic else end except experimental export exports external far \
file final finalization finally for forward function goto helper if \
implementation in inherited initialization inline interface is label library \
message mod near nil not object of on operator or out overload override packed \
pascal platform private procedure program property protected public published \
raise record reference register reintroduce repeat resourcestring safecall \
sealed set shl shr static stdcall strict string then threadvar to try type unit \
unsafe until uses var varargs virtual while winapi with xor

keywordclass.pascal.smart=add default implements index name nodefault read readonly \
remove stored write writeonly

keywordclass.pascal.package=package contains requires

keywords.$(file.patterns.pascal)=$(keywordclass.pascal) $(keywordclass.pascal.smart)
keywords.$(file.patterns.pascal.package)=$(keywordclass.pascal) $(keywordclass.pascal.smart) $(keywordclass.pascal.package)

# If enabled some keywords will only be highlightend in appropriate context.
# As implemented those are keywords related to property and DLL exports declarations
lexer.pascal.smart.highlighting=1

# Pascal styles


# Braces are only matched in operator style
braces.pascal.style=13

comment.block.pascal=//~
comment.stream.start.pascal={
comment.stream.end.pascal=}
comment.box.start.pascal=(*
comment.box.middle.pascal= *
comment.box.end.pascal= *)

statement.indent.$(file.patterns.pascal)=9 case class do else for then \
private protected public published repeat try while type
statement.end.$(file.patterns.pascal)=13 ;
statement.lookback.$(file.patterns.pascal)=20
block.start.$(file.patterns.pascal)=9 begin
block.end.$(file.patterns.pascal)=9 end

#using virtual pascal
#pc=C:\Vp21\Bin.w32\Vpc.exe -VC:\Vp21\Bin.w32\Vp.vpo "$(FilePath)"

#using free pascal

# compile
command.compile.*.pas=fpc "$(FilePath)"

# normal execute
if PLAT_WIN
	command.go.*.pas="$(FileName).exe"
	command.go.subsystem.*.pas=2
if PLAT_GTK
	command.go.*.pas="kvt -e $(FileName)"

# build
command.build.*.pas=fpc -B "$(FilePath)"
command.build.subsystem.*.pas=1

command.name.0.*.pas=Debug Compile
command.0.*.pas=fpc -g "$(FilePath)"
command.name.1.*.pas=Debug Build
command.1.*.pas=fpc -g -B "$(FilePath)"
command.name.2.*.pas=GDB
if PLAT_WIN
	command.2.*.pas=gdbpasw "$(FileName)"
if PLAT_GTK
	command.2.*.pas=gdb "$(FileName)"
	command.name.3.*.pas=DDD
	command.3.*.pas=ddd "$(FileName)"




###############################################################################
# From perl.properties
# Define SciTE settings for Perl, Bash, and AWK files.

file.patterns.perl=*.pl;*.pm;*.pod
file.patterns.bash=*.sh;*.bsh;configure;*.ksh
file.patterns.awk=*.awk

*source.patterns.perl=$(file.patterns.perl);
*source.patterns.bash=$(file.patterns.bash);

shbang.perl=pl
shbang.sh=sh
shbang.bash=sh

shbang.gawk=awk
shbang.nawk=awk
shbang.mawk=awk

filter.perl=Perl (pl pm)|$(file.patterns.perl)|
filter.bash=Bash (sh bsh)|$(file.patterns.bash)|
filter.awk=GAWK  (awk)|$(file.patterns.awk)|

*filter.perl=$(filter.perl)
*filter.bash=$(filter.bash)

*language.perl=Pe&rl|pl||
*language.shell=Shell|sh||

lexer.$(file.patterns.perl)=perl
lexer.$(file.patterns.bash)=bash
lexer.$(file.patterns.awk)=perl

keywords.$(file.patterns.perl)=\
NULL __FILE__ __LINE__ __PACKAGE__ __DATA__ __END__ AUTOLOAD \
BEGIN CORE DESTROY END EQ GE GT INIT LE LT NE CHECK abs accept \
alarm and atan2 bind binmode bless caller chdir chmod chomp chop \
chown chr chroot close closedir cmp connect continue cos crypt \
dbmclose dbmopen defined delete die do dump each else elsif endgrent \
endhostent endnetent endprotoent endpwent endservent eof eq eval \
exec exists exit exp fcntl fileno flock for foreach fork format \
formline ge getc getgrent getgrgid getgrnam gethostbyaddr gethostbyname \
gethostent getlogin getnetbyaddr getnetbyname getnetent getpeername \
getpgrp getppid getpriority getprotobyname getprotobynumber getprotoent \
getpwent getpwnam getpwuid getservbyname getservbyport getservent \
getsockname getsockopt glob gmtime goto grep gt hex if index \
int ioctl join keys kill last lc lcfirst le length link listen \
local localtime lock log lstat lt map mkdir msgctl msgget msgrcv \
msgsnd my ne next no not oct open opendir or ord our pack package \
pipe pop pos print printf prototype push quotemeta qu \
rand read readdir readline readlink readpipe recv redo \
ref rename require reset return reverse rewinddir rindex rmdir \
scalar seek seekdir select semctl semget semop send setgrent \
sethostent setnetent setpgrp setpriority setprotoent setpwent \
setservent setsockopt shift shmctl shmget shmread shmwrite shutdown \
sin sleep socket socketpair sort splice split sprintf sqrt srand \
stat study sub substr symlink syscall sysopen sysread sysseek \
system syswrite tell telldir tie tied time times truncate \
uc ucfirst umask undef unless unlink unpack unshift untie until \
use utime values vec wait waitpid wantarray warn while write \
xor \
given when default break say state UNITCHECK __SUB__ fc

keywords.$(file.patterns.awk)=\
BEGIN END \
if else while do for in break continue delete exit function return \
print printf sprintf \
system close getline next nextfile fflush \
atan2 cos exp int log rand sin sqrt srand \
asort asorti gensub sub gsub index length match split \
strtonum substr tolower toupper \
mktime strftime systime \
and compl lshift or rshift xor \
bindtextdomain dcgettext dcngettext \
ARGC ARGIND ARGV BINMODE CONVFMT ENVIRON ERRNO FIELDWIDTHS \
FILENAME FNR FS IGNORECASE LINT NF NR OFMT OFS ORS PROCINFO \
RS RT RSTART RLENGTH SUBSEP TEXTDOMAIN


comment.block.awk=#~
block.start.$(file.patterns.awk)=10 {
block.end.$(file.patterns.awk)=10 }


word.characters.$(file.patterns.perl)=$(chars.alpha)$(chars.numeric)_$@%&

comment.block.perl=#~
block.start.$(file.patterns.perl)=10 {
block.end.$(file.patterns.perl)=10 }

colour.perl.heredoc=$(colour.embedded.comment)

#fold.perl.package=1
#fold.perl.pod=1

# generic keywords
bash_keywords1=alias \
ar asa awk banner basename bash bc bdiff break \
bunzip2 bzip2 cal calendar case cat cc cd chmod cksum \
clear cmp col comm compress continue cp cpio crypt \
csplit ctags cut date dc dd declare deroff dev df diff diff3 \
dircmp dirname do done du echo ed egrep elif else env \
esac eval ex exec exit expand export expr false fc \
fgrep fi file find fmt fold for function functions \
getconf getopt getopts grep gres hash head help \
history iconv id if in integer jobs join kill local lc \
let line ln logname look ls m4 mail mailx make \
man mkdir more mt mv newgrp nl nm nohup ntps od \
pack paste patch pathchk pax pcat perl pg pr print \
printf ps pwd read readonly red return rev rm rmdir \
sed select set sh shift size sleep sort spell \
split start stop strings strip stty sum suspend \
sync tail tar tee test then time times touch tr \
trap true tsort tty type typeset ulimit umask unalias \
uname uncompress unexpand uniq unpack unset until \
uudecode uuencode vi vim vpax wait wc whence which \
while who wpaste wstart xargs zcat

# additional keywords from coreutils
bash_keywords2=chgrp chown chroot dir dircolors \
factor groups hostid install link md5sum mkfifo \
mknod nice pinky printenv ptx readlink seq \
sha1sum shred stat su tac unlink users vdir whoami yes

keywords.$(file.patterns.bash)=$(bash_keywords1) $(bash_keywords2)

word.characters.$(file.patterns.bash)=$(chars.alpha)$(chars.numeric)_$@%&

comment.block.bash=#~

colour.bash.heredoc=$(colour.embedded.comment)

# Perl styles
# The perl styles are set to lots of different foreground and background colours as an


# Braces are only matched in operator style
braces.perl.style=10

# Bash styles
# The bash styles are set to lots of different foreground and background colours as an
# Braces are only matched in operator style
braces.bash.style=7

command.go.$(file.patterns.awk)=gawk -f $(FileNameExt)

command.go.$(file.patterns.perl)=perl -w $(FileNameExt)

command.compile.$(file.patterns.perl)=perl -c -w $(FileNameExt)
command.name.0.$(file.patterns.perl)=Lint
command.0.$(file.patterns.perl)=perl -MO=Lint,all $(FileNameExt)

command.name.1.$(file.patterns.perl)=Check Syntax
command.1.$(file.patterns.perl)=perl -cw $(FileNameExt)

command.name.2.$(file.patterns.perl)=Code Profiler
command.2.$(file.patterns.perl)=perl -d:DProf $(FileNameExt)

command.name.3.$(file.patterns.perl)=Profiler Parser
command.3.$(file.patterns.perl)=C:\Perl\bin\dprofpp.bat $(FileDir)\tmon.out

command.go.$(file.patterns.bash)=bash $(FileNameExt)



###############################################################################
# From pov.properties
# Define SciTE settings for POV-Ray SDL files.

file.patterns.pov=*.pov;*.inc

filter.pov=POV-Ray SDL (pov)|$(file.patterns.pov)|

*filter.pov=$(filter.pov)

indent.size.*.pov=2
tab.size.*.pov=2
use.tabs.*.pov=0
indent.size.*.inc=2
tab.size.*.inc=2
use.tabs.*.inc=0

lexer.$(file.patterns.pov)=pov

*language.povray=P&OV-Ray SDL|pov||

word.chars.pov=$(chars.alpha)$(chars.numeric)_#
word.characters.$(file.patterns.pov)=$(word.chars.pov)

api.*.pov=POV-Ray_SDL.api
#autocomplete.pov.ignorecase=1
autocomplete.pov.start.characters=.
#autocomplete.pov.fillups=(
#calltip.pov_quote.ignorecase=1
calltip.pov.word.characters=.$(word.chars.pov)

comment.block.at.line.start.pov=1
comment.block.pov=//~
#~ comment.stream.start.pov=#ifdef BOOFOO
#~ comment.stream.end.pov=#endif
comment.stream.start.pov=/*
comment.stream.end.pov=*/
comment.box.start.pov=/*
comment.box.middle.pov= *
comment.box.end.pov= */

#~ statement.indent.$(file.patterns.pov)=5 case catch class default do else for if \
#~ private protected public struct try union while
#~ statement.lookback.$(file.patterns.pov)=20
#~ block.start.$(file.patterns.pov)=10 {
#~ block.end.$(file.patterns.pov)=10 }
#indent.maintain.$(file.patterns.pov)=1
#indent.size.$(file.patterns.pov)=4
#tab.size.$(file.patterns.pov)=4
#use.tabs.$(file.patterns.pov)=1

# Actually, these are SDL directives, but SciTE is seeking for the preprocessor.* properties
preprocessor.symbol.$(file.patterns.pov)=#
preprocessor.start.$(file.patterns.pov)=if ifdef ifndef switch while macro
preprocessor.middle.$(file.patterns.pov)=else
preprocessor.end.$(file.patterns.pov)=end

# keywords(1) is for Language directives (#xxx)
keywordclass.pov=declare local include undef fopen fclose read write default version \
case range break debug error warning \
if ifdef ifndef switch while macro else end

keywords.$(file.patterns.pov)=$(keywordclass.pov)

# keywords2 is for Objects & CSG & Appearance (xxx {})
keywords2.$(file.patterns.pov)=camera light_source light_group \
object blob sphere cylinder box cone height_field julia_fractal \
lathe prism sphere_sweep superellipsoid sor text torus \
bicubic_patch disc mesh mesh2 polygon triangle smooth_triangle \
plane poly cubic quartic quadric isosurface parametric \
union intersection difference merge function array spline \
vertex_vectors normal_vectors uv_vectors face_indices normal_indices uv_indices \
texture texture_list interior_texture \
texture_map material_map image_map color_map colour_map pigment_map \
normal_map slope_map bump_map density_map \
pigment normal material interior finish reflection irid slope pigment_pattern image_pattern \
warp media scattering density background fog sky_sphere rainbow \
global_settings radiosity photons pattern \
transform looks_like projected_through contained_by clipped_by bounded_by

# keywords3 is for Types & Modifiers & Items
keywords3.$(file.patterns.pov)=linear_spline quadratic_spline cubic_spline natural_spline bezier_spline b_spline \
read write append inverse open \
perspective orthographic fisheye ultra_wide_angle omnimax panoramic \
spherical spotlight jitter circular orient \
media_attenuation media_interaction shadowless parallel \
refraction collect pass_through global_lights hierarchy sturm smooth \
gif tga iff pot png pgm ppm jpeg tiff sys ttf \
quaternion hypercomplex linear_sweep conic_sweep \
type all_intersections split_union cutaway_textures \
no_shadow no_image no_reflection double_illuminate hollow \
uv_mapping all use_index use_color use_colour no_bump_scale \
conserve_energy fresnel \
average agate boxed bozo bumps cells crackle cylindrical density_file dents \
facets granite leopard marble onion planar quilted radial ripples spotted waves wood wrinkles \
solid use_alpha interpolate magnet noise_generator toroidal \
ramp_wave triangle_wave sine_wave scallop_wave cubic_wave poly_wave \
once map_type method fog_type hf_gray_16 charset ascii utf8 \
rotate scale translate matrix location right up direction sky \
angle look_at aperture blur_samples focal_point confidence variance \
radius falloff tightness point_at area_light adaptive fade_distance fade_power \
threshold strength water_level tolerance max_iteration precision slice \
u_steps v_steps flatness inside_vector \
accuracy max_gradient evaluate max_trace precompute \
target ior dispersion dispersion_samples caustics \
color colour rgb rgbf rgbt rgbft red green blue filter transmit gray hf \
fade_color fade_colour quick_color quick_colour \
brick checker hexagon brick_size mortar bump_size \
ambient diffuse brilliance crand phong phong_size metallic specular \
roughness reflection_exponent exponent thickness \
gradient spiral1 spiral2 agate_turb form metric \
offset df3 coords size mandel exterior julia \
control0 control1 altitude turbulence octaves omega lambda \
repeat flip black-hole orientation dist_exp major_radius \
frequency phase intervals samples ratio absorption emission aa_threshold aa_level \
eccentricity extinction distance turb_depth fog_offset fog_alt width arc_angle falloff_angle \
adc_bailout ambient_light assumed_gamma irid_wavelength number_of_waves \
always_sample brigthness count error_bound gray_threshold load_file \
low_error_factor max_sample minimum_reuse nearest_count \
pretrace_end pretrace_start recursion_limit save_file \
spacing gather max_trace_level autostop expand_thresholds

# keywords4 is for Predefined Identifiers
keywords4.$(file.patterns.pov)=x y z t u v \
yes no true false on off \
clock clock_delta clock_on final_clock final_frame frame_number \
image_height image_width initial_clock initial_frame pi version

# keywords5 is for Predefined Functions
keywords5.$(file.patterns.pov)=abs acos acosh asc asin asinh atan atanh atan2 \
ceil cos cosh defined degrees dimensions dimension_size div exp file_exists floor \
inside int ln log max min mod pow prod radians rand seed select sin sinh sqrt strcmp \
strlen sum tan tanh val vdot vlength min_extent max_extent trace vaxis_rotate \
vcross vrotate vnormalize vturbulence chr concat str strlwr strupr substr vstr \
sqr cube reciprocal pwr

# keywords6 is for User defined keywords 1
keywords6.$(file.patterns.pov)=

# keywords7 is for User defined keywords 2
keywords7.$(file.patterns.pov)=

# keywords8 is for User defined keywords 3
keywords8.$(file.patterns.pov)=

# POV-Ray SDL styles

# Keywords (bozo test colors :-)
# Braces are only matched in operator style
braces.pov.style=4

command.compile.*.pov=pvengine.exe $(FileName)
command.build.*.pov=
command.go.*.pov=pvengine.exe $(FileName)

if PLAT_WIN
	command.help.$(file.patterns.pov)=$(CurrentWord)!D:\Programmes\UImages\POV-Ray 3.5\help\povray35.chm
	command.help.subsystem.$(file.patterns.pov)=4



###############################################################################
# From powerpro.properties
# Define SciTE settings for powerpro files.
file.patterns.powerpro=*.powerpro

filter.powerpro=PowerPro (powerpro)|$(file.patterns.powerpro)|
*filter.powerpro=$(filter.powerpro)
lexer.$(file.patterns.powerpro)=powerpro
*language.powerpro=PowerPro|powerpro||

keywordclass.control=\
break do else elseif endfor endif for function global gt if ifelse \
ifx jump local lt quit static

keywords.$(file.patterns.powerpro)=$(keywordclass.control)

keywordclass.plugins=\
win.debug win.debugshow win.exists win.getdisplayrect win.getfocus win.gethandle win.getrect \
win.getsystemmetrics win.gettext win.maximize win.minimize win.move win.sendkeys win.setdebug \
win.setfocus win.setrect win.settext win.show

keywordclass.functions=\
bar case clip env exec fill flag floattostring format formattime ftos \
index input inputcancel inputdefault inputdialog join length messagebox mouse \
not note readline remove replace replacechars replaceg revindex select \
stof validpath visiblewindow wait wait.activity wait.for wait.forinterval wait.message \
wait.quit wait.ready wait.sleep wait.until wallpaper window window word

keywords2.$(file.patterns.powerpro)=$(keywordclass.plugins)|$(keywordclass.functions)

calltip.powerpro.word.characters=$(chars.alpha)$(chars.numeric)_
comment.block.powerpro=//~
comment.stream.start.powerpro=/*
comment.stream.end.powerpro=*/
comment.box.start.powerpro=/*
comment.box.middle.powerpro= *
comment.box.end.powerpro= */

# Autocomplete and call tip settings
#api.*.powerpro=$(SciteDefaultHome)\api\powerpro.api
word.characters.*.powerpro=$(chars.alpha)$(chars.numeric)@$_

# Braces are only matched in operator style
braces.powerpro.style=11


command.go.$(file.patterns.powerpro)="$(FilePath)"
command.go.subsystem.$(file.patterns.powerpro)=2

command.help.$(file.patterns.powerpro)=$(CurrentWord)!C:\Program Files\PowerPro\powerpro.chm
command.help.subsystem.$(file.patterns.powerpro)=4



###############################################################################
# From powershell.properties
# Define SciTE settings for PowerShell files

file.patterns.powershell=*.ps1

filter.powershell=PowerShell (ps1)|$(file.patterns.powershell)|

*filter.powershell=$(filter.powershell)

lexer.$(file.patterns.powershell)=powershell

*language.powershell=PowerShell|ps1||

word.characters.$(file.patterns.powershell)=$(chars.alpha)$(chars.numeric)_-$

# Keywords
keywords.$(file.patterns.powershell)=\
begin break catch continue data do dynamicparam else elseif end exit filter \
finally for foreach from function if in local param private process return \
switch throw trap try until where while

# Cmdlets
keywords2.$(file.patterns.powershell)=\
add-computer add-content add-history add-member add-pssnapin add-type \
checkpoint-computer clear-content clear-eventlog clear-history clear-item \
clear-itemproperty clear-variable compare-object complete-transaction \
connect-wsman convert-path convertfrom-csv convertfrom-securestring \
convertfrom-stringdata convertto-csv convertto-html convertto-securestring \
convertto-xml copy-item copy-itemproperty debug-process disable-computerrestore \
disable-psbreakpoint disable-pssessionconfiguration disable-wsmancredssp \
disconnect-wsman enable-computerrestore enable-psbreakpoint enable-psremoting \
enable-pssessionconfiguration enable-wsmancredssp enter-pssession exit-pssession \
export-alias export-clixml export-console export-counter export-csv \
export-formatdata export-modulemember export-pssession foreach-object \
format-custom format-list format-table format-wide get-acl get-alias \
get-authenticodesignature get-childitem get-command get-computerrestorepoint \
get-content get-counter get-credential get-culture get-date get-event \
get-eventlog get-eventsubscriber get-executionpolicy get-formatdata get-help \
get-history get-host get-hotfix get-item get-itemproperty get-job get-location \
get-member get-module get-psbreakpoint get-pscallstack get-psdrive \
get-psprovider get-pssession get-pssessionconfiguration get-pssnapin \
get-pfxcertificate get-process get-random get-service get-tracesource \
get-transaction get-uiculture get-unique get-variable get-wsmancredssp \
get-wsmaninstance get-winevent get-wmiobject group-object import-alias \
import-clixml import-counter import-csv import-localizeddata import-module \
import-pssession invoke-command invoke-expression invoke-history invoke-item \
invoke-wsmanaction invoke-wmimethod join-path limit-eventlog measure-command \
measure-object move-item move-itemproperty new-alias new-event new-eventlog \
new-item new-itemproperty new-module new-modulemanifest new-object new-psdrive \
new-pssession new-pssessionoption new-service new-timespan new-variable \
new-wsmaninstance new-wsmansessionoption new-webserviceproxy out-default \
out-file out-gridview out-host out-null out-printer out-string pop-location \
push-location read-host receive-job register-engineevent register-objectevent \
register-pssessionconfiguration register-wmievent remove-computer remove-event \
remove-eventlog remove-item remove-itemproperty remove-job remove-module \
remove-psbreakpoint remove-psdrive remove-pssession remove-pssnapin \
remove-variable remove-wsmaninstance remove-wmiobject rename-item \
rename-itemproperty reset-computermachinepassword resolve-path restart-computer \
restart-service restore-computer resume-service select-object select-string \
select-xml send-mailmessage set-acl set-alias set-authenticodesignature \
set-content set-date set-executionpolicy set-item set-itemproperty set-location \
set-psbreakpoint set-psdebug set-pssessionconfiguration set-service \
set-strictmode set-tracesource set-variable set-wsmaninstance \
set-wsmanquickconfig set-wmiinstance show-eventlog sort-object split-path \
start-job start-process start-service start-sleep start-transaction \
start-transcript stop-computer stop-job stop-process stop-service \
stop-transcript suspend-service tee-object test-computersecurechannel \
test-connection test-modulemanifest test-path test-wsman trace-command \
undo-transaction unregister-event unregister-pssessionconfiguration \
update-formatdata update-list update-typedata use-transaction wait-event \
wait-job wait-process where-object write-debug write-error write-eventlog \
write-host write-output write-progress write-verbose write-warning

# Aliases
keywords3.$(file.patterns.powershell)=\
ac asnp cat cd chdir clc clear clhy cli clp cls clv compare copy cp cpi cpp cvpa \
dbp del diff dir ebp echo epal epcsv epsn erase etsn exsn fc fl foreach ft fw \
gal gbp gc gci gcm gcs gdr ghy gi gjb gl gm gmo gp gps group gsn gsnp gsv gu gv \
gwmi h history icm iex ihy ii ipal ipcsv ipmo ipsn ise iwmi kill lp ls man md \
measure mi mount move mp mv nal ndr ni nmo nsn nv ogv oh popd ps pushd pwd r rbp \
rcjb rd rdr ren ri rjb rm rmdir rmo rni rnp rp rsn rsnp rv rvpa rwmi sajb sal \
saps sasv sbp sc select set si sl sleep sort sp spjb spps spsv start sv swmi tee \
type where wjb write

# Functions
keywords4.$(file.patterns.powershell)=\
clear-host disable-psremoting enable-psremoting get-verb help importsystemmodules \
mkdir more prompt psedit tabexpansion

# User-defined keywords
#keywords5.$(file.patterns.powershell)=

# Comments
comment.block.powershell=#~
comment.block.at.line.start.powershell=1

# PowerShell Styles



###############################################################################
# From ps.properties
# Define SciTE settings for PostScript files.

file.patterns.ps=*.ps

filter.ps=PostScript (ps)|$(file.patterns.ps)|

*filter.ps=$(filter.ps)

lexer.$(file.patterns.ps)=ps

*language.postscript=P&ostScript|ps||

ps.tokenize=0
ps.level=3

comment.block.ps=%~

# Postscript level 1 operators
keywords.$(file.patterns.ps)=\
$error = == FontDirectory StandardEncoding UserObjects abs add aload \
anchorsearch and arc arcn arcto array ashow astore atan awidthshow begin bind \
bitshift bytesavailable cachestatus ceiling charpath clear cleardictstack \
cleartomark clip clippath closefile closepath concat concatmatrix copy copypage \
cos count countdictstack countexecstack counttomark currentcmykcolor \
currentcolorspace currentdash currentdict currentfile currentflat currentfont \
currentgray currenthsbcolor currentlinecap currentlinejoin currentlinewidth \
currentmatrix currentmiterlimit currentpagedevice currentpoint currentrgbcolor \
currentscreen currenttransfer cvi cvlit cvn cvr cvrs cvs cvx def defaultmatrix \
definefont dict dictstack div dtransform dup echo end eoclip eofill eq \
erasepage errordict exch exec execstack executeonly executive exit exp false \
file fill findfont flattenpath floor flush flushfile for forall ge get \
getinterval grestore grestoreall gsave gt idetmatrix idiv idtransform if ifelse \
image imagemask index initclip initgraphics initmatrix inustroke invertmatrix \
itransform known kshow le length lineto ln load log loop lt makefont mark \
matrix maxlength mod moveto mul ne neg newpath noaccess nor not null nulldevice \
or pathbbox pathforall pop print prompt pstack put putinterval quit rand rcheck \
rcurveto read readhexstring readline readonly readstring rectstroke repeat \
resetfile restore reversepath rlineto rmoveto roll rotate round rrand run save \
scale scalefont search setblackgeneration setcachedevice setcachelimit \
setcharwidth setcolorscreen setcolortransfer setdash setflat setfont setgray \
sethsbcolor setlinecap setlinejoin setlinewidth setmatrix setmiterlimit \
setpagedevice setrgbcolor setscreen settransfer setvmthreshold show showpage \
sin sqrt srand stack start status statusdict stop stopped store string \
stringwidth stroke strokepath sub systemdict token token transform translate \
true truncate type ueofill undefineresource userdict usertime version vmstatus \
wcheck where widthshow write writehexstring writestring xcheck xor

# Postscript level 2 operators
keywords2.$(file.patterns.ps)=\
GlobalFontDirectory ISOLatin1Encoding SharedFontDirectory UserObject arct \
colorimage cshow currentblackgeneration currentcacheparams currentcmykcolor \
currentcolor currentcolorrendering currentcolorscreen currentcolorspace \
currentcolortransfer currentdevparams currentglobal currentgstate \
currenthalftone currentobjectformat currentoverprint currentpacking \
currentpagedevice currentshared currentstrokeadjust currentsystemparams \
currentundercolorremoval currentuserparams defineresource defineuserobject \
deletefile execform execuserobject filenameforall fileposition filter \
findencoding findresource gcheck globaldict glyphshow gstate ineofill infill \
instroke inueofill inufill inustroke languagelevel makepattern packedarray \
printobject product realtime rectclip rectfill rectstroke renamefile \
resourceforall resourcestatus revision rootfont scheck selectfont serialnumber \
setbbox setblackgeneration setcachedevice2 setcacheparams setcmykcolor setcolor \
setcolorrendering setcolorscreen setcolorspace setcolortranfer setdevparams \
setfileposition setglobal setgstate sethalftone setobjectformat setoverprint \
setpacking setpagedevice setpattern setshared setstrokeadjust setsystemparams \
setucacheparams setundercolorremoval setuserparams setvmthreshold shareddict \
startjob uappend ucache ucachestatus ueofill ufill undef undefinefont \
undefineresource undefineuserobject upath ustroke ustrokepath vmreclaim \
writeobject xshow xyshow yshow

# Postscript level 3 operators
keywords3.$(file.patterns.ps)=\
cliprestore clipsave composefont currentsmoothness findcolorrendering \
setsmoothness shfill

# RIP-specific operators (Ghostscript)
keywords4.$(file.patterns.ps)=\
.begintransparencygroup .begintransparencymask .bytestring .charboxpath \
.currentaccuratecurves .currentblendmode .currentcurvejoin .currentdashadapt \
.currentdotlength .currentfilladjust2 .currentlimitclamp .currentopacityalpha \
.currentoverprintmode .currentrasterop .currentshapealpha \
.currentsourcetransparent .currenttextknockout .currenttexturetransparent \
.dashpath .dicttomark .discardtransparencygroup .discardtransparencymask \
.endtransparencygroup .endtransparencymask .execn .filename .filename \
.fileposition .forceput .forceundef .forgetsave .getbitsrect .getdevice \
.inittransparencymask .knownget .locksafe .makeoperator .namestring .oserrno \
.oserrorstring .peekstring .rectappend .runandhide .setaccuratecurves \
.setblendmode .setcurvejoin .setdashadapt .setdebug .setdefaultmatrix \
.setdotlength .setfilladjust2 .setlimitclamp .setmaxlength .setopacityalpha \
.setoverprintmode .setrasterop .setsafe .setshapealpha .setsourcetransparent \
.settextknockout .settexturetransparent .stringbreak .stringmatch .tempfile \
.type1decrypt .type1encrypt .type1execchar .unread arccos arcsin copydevice \
copyscanlines currentdevice finddevice findlibfile findprotodevice flushpage \
getdeviceprops getenv makeimagedevice makewordimagedevice max min \
putdeviceprops setdevice

# PostScript styles

# Braces are only matched in procedure parenthesis style
braces.ps.style=11

if PLAT_WIN
    command.go.*.ps=gswin32c "$(FileNameExt)"

if PLAT_GTK
    command.go.*.ps=gs "$(FileNameExt)"




###############################################################################
# From purebasic.properties
# Define SciTE settings for PureBasic files.

file.patterns.purebasic=*.pb

filter.purebasic=PureBasic (pb)|$(file.patterns.purebasic)|

*filter.purebasic=$(filter.purebasic)

lexer.$(file.patterns.purebasic)=purebasic

# keywords must be all lowercase

#Language
keywords.$(file.patterns.purebasic)=and break case continue data \
datasection declare declarecdll declaredll default deftype dim else \
elseif end enddatasection endenumeration endif endinterface endprocedure \
endselect endstructure endstructureunion enumeration extends fakereturn \
for foreach forever global gosub goto if includebinary includefile \
includepath interface newlist next or procedure procedurecdll \
proceduredll procedurereturn protected read repeat restore return select \
shared static step structure structureunion to until wend while xincludefile

#preprocessor
keywords2.$(file.patterns.purebasic)=compilercase compilerdefault \
compilerelse compilerendif compilerendselect compilerif compilerselect

# PB styles
# Preprocessor
# Date
# StringEOL
# Asm




###############################################################################
# From python.properties
# Define SciTE settings for Python files.

file.patterns.py=*.py;*.pyw;*.pyx;*.pxd;*.pxi
file.patterns.scons=SConstruct;SConscript

*source.patterns.python=$(file.patterns.py);

shbang.python=py

filter.python=Python (py pyw)|$(file.patterns.py)|

*filter.python=$(filter.python)

lexer.$(file.patterns.py)=python
lexer.$(file.patterns.scons)=python

*language.python=Pytho&n|py||

keywordclass.python2=and as assert break class continue def del elif \
else except exec finally for from global if import in is lambda not \
or pass print raise return try while with yield

keywordclass.python3=False None True and as assert break class continue \
def del elif else except finally for from global if import in is lambda \
nonlocal not or pass raise return try while with yield

keywordclass.python=$(keywordclass.python2)

# Extra keywords for cython
keywordclass.cython=cdef cimport cpdef

keywords.$(file.patterns.py)=$(keywordclass.python) $(keywordclass.cython)
keywords.$(file.patterns.scons)=$(keywordclass.python)

# If you uncomment the 3 lines below,
# and put some words after "keywordclass2.python=",
# those words will be styled by style.python.14

#keywordclass2.python=
#keywords2.$(file.patterns.py)=$(keywordclass2.python)
#keywords2.$(file.patterns.scons)=$(keywordclass2.python)

# Use 2 sets of substyles to highlight standard library modules and
# imports from the future.
# Additional identifier sets can be added by incrementing the  next
# line's value and adding extra definitions similar to below.
substyles.python.11=2

substylewords.11.1.$(file.patterns.py)=\
__main__ _dummy_thread _thread abc aifc argparse \
array ast asynchat asyncio asyncore atexit audioop \
base64 bdb binascii binhex bisect builtins bz2 \
calendar cgi cgitb chunk cmath cmd code codecs \
codeop collections colorsys compileall concurrent \
configparser contextlib copy copyreg crypt csv \
ctypes curses datetime dbm decimal difflib dis \
distutils dummy_threading email ensurepip enum \
errno faulthandler fcntl filecmp fileinput fnmatch \
formatter fpectl fractions ftplib functools gc getopt \
getpass gettext glob grp gzip hashlib heapq hmac \
html http http imaplib imghdr importlib inspect io \
ipaddress itertools json keyword linecache locale \
logging lzma macpath mailbox mailcap marshal math \
mimetypes mmap modulefinder msilib msvcrt \
multiprocessing netrc nis nntplib numbers operator \
os os ossaudiodev parser pathlib pdb pickle \
pickletools pipes pkgutil platform plistlib poplib posix \
pprint pty pwd py_compile pyclbr queue quopri \
random re readline reprlib resource rlcompleter runpy \
sched select selectors shelve shlex shutil signal site \
smtpd smtplib sndhdr socket socketserver spwd \
sqlite3 ssl stat statistics string stringprep struct \
subprocess sunau symbol symtable sys sysconfig \
syslog tabnanny tarfile telnetlib tempfile termios \
textwrap threading time timeit tkinter token \
tokenize trace traceback tracemalloc tty turtle \
types unicodedata unittest urllib uu uuid venv warnings \
wave weakref webbrowser winreg winsound wsgiref \
xdrlib xml xmlrpc zipfile zipimport zlib
style.python.11.1=fore:#DD9900

substylewords.11.2.$(file.patterns.py)=__future__ \
with_statement unicode_literals print_function
style.python.11.2=fore:#EE00AA,italics

#~ statement.indent.$(file.patterns.py)=10 :
statement.indent.$(file.patterns.py)=5 class def elif else except finally \
for if try while with

statement.lookback.$(file.patterns.py)=0
block.start.$(file.patterns.py)=
block.end.$(file.patterns.py)=

view.indentation.examine.*.py=2

tab.timmy.whinge.level=1

#fold.quotes.python=1

comment.block.python=#~

indent.python.colon=1

# Python styles
# Braces are only matched in operator style
braces.python.style=10

if PLAT_WIN
	command.go.*.py=pythonw -u "$(FileNameExt)"
	command.go.subsystem.*.py=1
	command.go.*.pyw=pythonw -u "$(FileNameExt)"
	command.go.subsystem.*.pyw=1
	command.build.SConscript=scons.bat --up .
	command.build.SConstruct=scons.bat .

if PLAT_GTK
	command.go.*.py=python -u "$(FileNameExt)"
	command.build.SConscript=scons --up .
	command.build.SConstruct=scons .

if PLAT_MAC
	command.go.*.py=python -u "$(FileNameExt)"
	command.build.SConscript=scons --up .
	command.build.SConstruct=scons .

command.name.1.$(file.patterns.py)=Syntax Check
command.1.$(file.patterns.py)=python -c "import py_compile; py_compile.compile(r'$(FilePath)')"



###############################################################################
# From r.properties
# Define SciTE settings for R and S source files

file.patterns.r=*.R;*.rsource;*.S;
file.patterns.r.like=$(file.patterns.r)

filter.r=R and S+ (R S rsouce)|$(file.patterns.r)|

*filter.r=$(filter.r)

lexer.$(file.patterns.r)=r

*language.r=R|R||

keywordclass.r=if else repeat while function for in next break TRUE FALSE NULL NA Inf NaN

keywords.$(file.patterns.r)=$(keywordclass.r)

keywords2.$(file.patterns.r)=abbreviate abline abs acf acos acosh addmargins aggregate agrep alarm alias alist all anova any aov aperm append apply approx approxfun apropos ar args arima array arrows asin asinh assign assocplot atan atanh attach attr attributes autoload autoloader ave axis backsolve barplot basename beta bindtextdomain binomial biplot bitmap bmp body box boxplot bquote break browser builtins bxp by bzfile c call cancor capabilities casefold cat category cbind ccf ceiling character charmatch chartr chol choose chull citation class close cm cmdscale codes coef coefficients col colnames colors colorspaces colours comment complex confint conflicts contour contrasts contributors convolve cophenetic coplot cor cos cosh cov covratio cpgram crossprod cummax cummin cumprod cumsum curve cut cutree cycle data dataentry date dbeta dbinom dcauchy dchisq de debug debugger decompose delay deltat demo dendrapply density deparse deriv det detach determinant deviance dexp df dfbeta dfbetas dffits dgamma dgeom dget dhyper diag diff diffinv difftime digamma dim dimnames dir dirname dist dlnorm dlogis dmultinom dnbinom dnorm dotchart double dpois dput drop dsignrank dt dump dunif duplicated dweibull dwilcox eapply ecdf edit effects eigen emacs embed end environment eval evalq example exists exp expression factanal factor factorial family fft fifo file filter find fitted fivenum fix floor flush for force formals format formula forwardsolve fourfoldplot frame frequency ftable function gamma gaussian gc gcinfo gctorture get getenv geterrmessage gettext gettextf getwd gl glm globalenv gray grep grey grid gsub gzcon gzfile hat hatvalues hcl hclust head heatmap help hist history hsv httpclient iconv iconvlist identical identify if ifelse image influence inherits integer integrate interaction interactive intersect invisible isoreg jitter jpeg julian kappa kernapply kernel kmeans knots kronecker ksmooth labels lag lapply layout lbeta lchoose lcm legend length letters levels lfactorial lgamma library licence license line lines list lm load loadhistory loadings local locator loess log logb logical loglin lowess ls lsfit machine mad mahalanobis makepredictcall manova mapply match matlines matplot matpoints matrix max mean median medpolish menu merge message methods mget min missing mode monthplot months mosaicplot mtext mvfft names napredict naprint naresid nargs nchar ncol next nextn ngettext nlevels nlm nls noquote nrow numeric objects offset open optim optimise optimize options order ordered outer pacf page pairlist pairs palette par parse paste pbeta pbinom pbirthday pcauchy pchisq pdf pentagamma person persp pexp pf pgamma pgeom phyper pi pico pictex pie piechart pipe plclust plnorm plogis plot pmatch pmax pmin pnbinom png pnorm points poisson poly polygon polym polyroot postscript power ppoints ppois ppr prcomp predict preplot pretty princomp print prmatrix prod profile profiler proj promax prompt provide psigamma psignrank pt ptukey punif pweibull pwilcox q qbeta qbinom qbirthday qcauchy qchisq qexp qf qgamma qgeom qhyper qlnorm qlogis qnbinom qnorm qpois qqline qqnorm qqplot qr qsignrank qt qtukey quantile quarters quasi quasibinomial quasipoisson quit qunif quote qweibull qwilcox rainbow range rank raw rbeta rbind rbinom rcauchy rchisq readline real recover rect reformulate regexpr relevel remove reorder rep repeat replace replicate replications require reshape resid residuals restart return rev rexp rf rgamma rgb rgeom rhyper rle rlnorm rlogis rm rmultinom rnbinom rnorm round row rownames rowsum rpois rsignrank rstandard rstudent rt rug runif runmed rweibull rwilcox sample sapply save savehistory scale scan screen screeplot sd search searchpaths seek segments seq sequence serialize setdiff setequal setwd shell sign signif sin single sinh sink smooth solve sort source spectrum spline splinefun split sprintf sqrt stack stars start stderr stdin stdout stem step stepfun stl stop stopifnot str strftime strheight stripchart strptime strsplit strtrim structure strwidth strwrap sub subset substitute substr substring sum summary sunflowerplot supsmu svd sweep switch symbols symnum system t table tabulate tail tan tanh tapply tempdir tempfile termplot terms tetragamma text time title toeplitz tolower topenv toupper trace traceback transform trigamma trunc truncate try ts tsdiag tsp typeof unclass undebug union unique uniroot unix unlink unlist unname unserialize unsplit unstack untrace unz update upgrade url var varimax vcov vector version vi vignette warning warnings weekdays weights which while window windows with write wsbrowser xedit xemacs xfig xinch xor xtabs xyinch yinch zapsmall

keywords3.$(file.patterns.r)=acme aids aircondit amis aml banking barchart barley beaver bigcity boot brambles breslow bs bwplot calcium cane capability cav censboot channing city claridge cloth cloud coal condense contourplot control corr darwin densityplot dogs dotplot ducks empinf envelope environmental ethanol fir frets gpar grav gravity grob hirose histogram islay knn larrows levelplot llines logit lpoints lsegments lset ltext lvqinit lvqtest manaus melanoma melanoma motor multiedit neuro nitrofen nodal ns nuclear oneway parallel paulsen poisons polar qq qqmath remission rfs saddle salinity shingle simplex singer somgrid splom stripplot survival tau tmd tsboot tuna unit urine viewport wireframe wool xyplot


word.chars.r=$(chars.alpha)$(chars.numeric)_.#
word.characters.$(file.patterns.r)=$(word.chars.r)
comment.block.r=#~

statement.indent.$(file.patterns.r.like)=5 for if
statement.end.$(file.patterns.r.like)=10 ;
statement.lookback.$(file.patterns.r.like)=20
block.start.$(file.patterns.r.like)=10 {
block.end.$(file.patterns.r.like)=10 }

# R styles


# Braces are only matched in operator style
braces.r.style=8



###############################################################################
# From rebol.properties
# Define SciTE settings for REBOL files.

file.patterns.rebol=*.r;*.reb

filter.rebol=REBOL (r)|$(file.patterns.rebol)|

*filter.rebol=$(filter.rebol)

lexer.$(file.patterns.rebol)=rebol

# keywords. Found at http://www.rebol.com/docs/dictionary.html
keywords.$(file.patterns.rebol)=about abs absolute add \
alert alias all alter and \
any any-block? any-function? any-string? any-type? \
any-word? append arccosine arcsine arctangent \
array as-pair ask at attempt \
back binary? bind bitset? block? \
break brightness? browse build-tag caret-to-offset \
catch center-face change change-dir char? \
charset checksum choose clean-path clear \
clear-fields close comment complement component? \
compose compress confirm connected? construct \
context copy cosine datatype? date? \
debase decimal? decode-cgi decompress dehex \
delete detab difference dir? dirize \
disarm dispatch divide do do-events \
does dump-face dump-obj echo either \
else email? empty? enbase entab \
equal? error? even? event? exclude \
exists? exit exp extract fifth \
file? find first flash focus \
for forall foreach forever form \
forskip found? fourth free func \
function function? get get-modes get-word? \
greater-or-equal? greater? halt has hash? \
head head? help hide hide-popup \
if image? import-email in in-window? \
index? info? inform input input? \
insert integer? intersect issue? join \
last launch layout length? lesser-or-equal? \
lesser? library? license link? list-dir \
list? lit-path? lit-word? load load-image \
log-10 log-2 log-e logic? loop \
lowercase make make-dir make-face max \
maximum maximum-of min minimum minimum-of \
modified? mold money? multiply native? \
negate negative? next none? not \
not-equal? now number? object? odd? \
offset-to-caret offset? op? open or \
pair? paren? parse parse-xml path? \
pick poke port? positive? power \
prin print probe protect protect-system \
query quit random read read-io \
recycle reduce refinement? reform rejoin \
remainder remold remove remove-each rename \
repeat repend replace request request-color \
request-date request-download request-file request-list request-pass \
request-text resend return reverse routine? \
same? save script? second secure \
select send series? set set-modes \
set-net set-path? set-word? show show-popup \
sign? sine size-text size? skip \
sort source span? split-path square-root \
strict-equal? strict-not-equal? string? struct? stylize \
subtract suffix? switch tag? tail \
tail? tangent third throw time? \
to to-binary to-bitset to-block to-char \
to-date to-decimal to-email to-file to-get-word \
to-hash to-hex to-idate to-image to-integer \
to-issue to-list to-lit-path to-lit-word to-local-file \
to-logic to-money to-pair to-paren to-path \
to-rebol-file to-refinement to-set-path to-set-word to-string \
to-tag to-time to-tuple to-url to-word \
trace trim try tuple? type? \
unfocus union unique unprotect unset \
unset? until unview update upgrade \
uppercase url? usage use value? \
view viewed? wait what what-dir \
while within? word? write write-io xor zero?

# test functions
keywords2.$(file.patterns.rebol)=action? any-block? any-function? any-string? \
any-type? any-word? binary? bitset? block? char? component? connected? \
datatype? date? decimal? dir? email? empty? equal? error? even? event? exists? \
file? found? function? get-word? greater-or-equal greater? hash? head? image? \
index? info? input? integer? issue? length? lesser-or-equal? lesser? library? \
link-app? link? list? lit-path? lit-word? logic? modified? money? native? negative? \
none? not-equal? number? object? odd? offset? op? pair? paren? path? port? \
positive? rebol-command? rebol-encap? rebol-link? rebol-pro? rebol-view? \
refinement? routine? same? script? series? set-path? set-word? sign? size? \
strict-equal? strict-not-equal string? struct? suffix? tag? tail? time? tuple? type? \
unset? url? value? view? word? zero?

# types
keywords3.$(file.patterns.rebol)=action! any-block! any-function! any-string! any-type! \
 any-word! binary! bitset! block! char! datatype! date! decimal! email! error! \
 event! file! function! get-word! hash! image! integer! issue! library! list! lit-path! \
 lit-word! logic! money! native! none! number! object! op! pair! paren! path! \
 port! refinement! routine! series! set-path! set-word! string! struct! symbol! tag! \
 time! tuple! unset! url! word!

word.chars.rebol=$(chars.alpha)$(chars.numeric)?!.�+-*&|=_~
word.characters.$(file.patterns.rebol)=$(word.chars.rebol)

comment.block.rebol=;
comment.box.start.rebol=;;
comment.box.middle.rebol=;;
comment.box.end.rebol=;;

# REBOL styles



# Braces are only matched in default style
braces.rebol.style=0

command.go.$(file.patterns.rebol)=E:\tools\lang\rebol\core\rebol.exe $(FilePath)




###############################################################################
# From registry.properties
# Define SciTE settings for registry files.

file.patterns.registry=*.reg
filter.registry=Registration files (reg)|$(file.patterns.registry)|
lexer.$(file.patterns.registry)=registry

comment.block.registry=;;

[Styles]




###############################################################################
# From ruby.properties
# Define SciTE settings for Ruby files.

file.patterns.rb=*.rb;*.rbw;*.rake;*.rjs;Rakefile

*source.patterns.ruby=$(file.patterns.rb);

shbang.ruby=rb

filter.ruby=Ruby (rb rbw)|$(file.patterns.rb)|

*filter.ruby=$(filter.ruby)

lexer.$(file.patterns.rb)=ruby

*language.ruby=Ruby|rb||

keywordclass.ruby=__FILE__ and def end in or self unless __LINE__ begin \
defined? ensure module redo super until BEGIN break do false next rescue \
then when END case else for nil retry true while alias class elsif if \
not return undef yield
keywords.$(file.patterns.rb)=$(keywordclass.ruby)

statement.indent.$(file.patterns.rb)=5 def class if do elsif else case while for

block.start.$(file.patterns.rb)=5 do
block.end.$(file.patterns.rb)=5 end

indent.opening.$(file.patterns.rb)=1
indent.closing.$(file.patterns.rb)=1

comment.block.ruby=#~

# ruby styles

# Braces are only matched in operator style
braces.ruby.style=10

if PLAT_WIN
	command.go.*.rb=ruby $(FileNameExt)
	command.go.subsystem.*.rb=1
	command.go.*.rbw=rubyw $(FileNameExt)
	command.go.subsystem.*.rbw=1
	command.help.*.rb=$(CurrentWord)!c:\apps\ruby\ProgrammingRuby.chm
	command.help.subsystem.*.rb=4

if PLAT_GTK
	command.go.*.rb=ruby $(FileNameExt)

	command.name.1.*.rb=Check Syntax
	command.1.*.rb=ruby -cw $(FileNameExt)

	command.name.2.*.rb=Code Profiler
	command.2.*.rb=ruby -r profile $(FileNameExt)

if PLAT_MAC
	command.go.*.rb=ruby $(FileNameExt)
	command.name.1.*.rb=Check Syntax
	command.1.*.rb=ruby -cw $(FileNameExt)
	command.name.2.*.rb=Code Profiler
	command.2.*.rb=ruby -r profile $(FileNameExt)



###############################################################################
# From rust.properties
# Define SciTE settings for Rust

file.patterns.rust=*.rs
filter.rust=Rust (rs)|$(file.patterns.rust)|
*filter.rust=$(filter.rust)
lexer.$(file.patterns.rust)=rust
*language.rust=Rust|rs||

word.chars.rust=$(chars.alpha)$(chars.numeric)_#
word.characters.$(file.patterns.rust)=$(word.chars.rust)
calltip.rust.word.characters=$(chars.alpha)$(chars.numeric)_

comment.block.at.line.start.rust=1
comment.block.rust=//~
comment.stream.start.rust=/*
comment.stream.end.rust=*/
comment.box.start.rust=/*
comment.box.middle.rust= *
comment.box.end.rust= */

statement.indent.$(file.patterns.rust)=6
statement.end.$(file.patterns.rust)=16 ;
statement.lookback.$(file.patterns.rust)=20
block.start.$(file.patterns.rust)=16 {
block.end.$(file.patterns.rust)=16 }
braces.rust.style=16

# Rust keywords
keywords.$(file.patterns.rust)=alignof as be box break const continue crate do else enum extern false fn for if impl in let loop match mod mut offsetof once priv proc pub pure ref return self sizeof static struct super trait true type typeof unsafe unsized use virtual while yield

# Built-in types
keywords2.$(file.patterns.rust)=bool char f32 f64 i16 i32 i64 i8 int str u16 u32 u64 u8 uint

# The Self parameter
keywords3.$(file.patterns.rust)=Self


command.compile.*.rs=rustc $(FileNameExt)
command.build.*.rs=$(make.command)
command.go.*.rs=./$(FileName)




###############################################################################
# From scriptol.properties
# Define SciTE settings for scriptol files.

filter.scriptol=Scriptol (sol)|*.sol|

*filter.scriptol=$(filter.scriptol)

lexer.*.sol=scriptol

file.patterns.sol=*.sol

keywordclass.scriptol= act action alias always and array as \
bool boolean break by byte \
class case catch const constant continue \
dyn def define dict do double \
echo else elsif end enum error false file for float forever function \
globak gtk \
in if ifdef import include int integer java javax \
let long match mod nil not natural null number \
or print protected public real return redo \
scan script scriptol sol short super static step until using \
var text then this true try \
void volatile while when \
undef zero
keywords.$(file.patterns.sol)=$(keywordclass.scriptol)

statement.indent.*.sol=
statement.lookback.*.sol=1
block.start.*.sol=10

comment.block.scriptol=`~

# scriptol styles


if PLAT_WIN
        command.help.$(file.patterns.sol)="file://$(SciteDefaultHome)\manual.html"
        command.help.subsystem.$(file.patterns.sol)=2

if PLAT_GTK
        command.help.$(file.patterns.sol)=man $(CurrentWord) | col -b

command.compile.*.sol=solc -c $(FileNameExt)
command.build.*.sol=solc -be $(FileNameExt)
command.go.*.sol=$(FileName)
command.go.subsystem.*.sol=1

command.name.0.*.sol=XSolP
command.0.*.sol =xsolp -be $(FileNameExt)
command.is.filter.0.*.sol=1

command.name.1.*.sol=XSolC
command.1.*.sol =xsolc -be $(FileNameExt)
command.is.filter.1.*.sol=1

command.name.2.*.sol=Compile to Php
command.2.*.sol=solp -b $(FileNameExt)
command.is.filter.2.*.sol=1

command.name.3.*.sol=Compile Web page
command.3.*.sol=solp -b -w $(FileNameExt)
command.is.filter.3.*.sol=1

command.name.4.*.sol=Interpret
command.4.*.sol=solp $(FileNameExt)
command.is.filter.4.*.sol=1




###############################################################################
# From smalltalk.properties
# Define SciTE settings for Smalltalk files.

file.patterns.smalltalk=*.st

filter.smalltalk=Smalltalk (st)|$(file.patterns.smalltalk)|

*filter.smalltalk=$(filter.smalltalk)

lexer.$(file.patterns.smalltalk)=smalltalk

keywords.$(file.patterns.smalltalk)=\
    ifTrue: ifFalse: whileTrue: whileFalse: ifNil: ifNotNil: whileTrue whileFalse repeat isNil notNil

# Styles




###############################################################################
# From sorcins.properties
# Define SciTE settings for SORCUS Installation Files
# Originally by Christoph Baumann cb@sorcus.com

# SORCUS Installation files end with .ins
file.patterns.sorcins=*.ins
filter.sorcins=SORCUS Installation File (ins)|$(file.patterns.sorcins)|

*filter.sorcins=$(filter.sorcins)

lexer.$(file.patterns.sorcins)=sorcins

commands=ARGUSCONNECTCHANNELS \
    M2DEVICE M2INST M2PAR M2PROC M2FUNC M2CMD M2LOADMODUL \
    M6DEVICE M6INST M6PAR M6PROC M6FUNC M6CMD M6LOADMODUL \
    M7DEVICE M7INST M7PAR M7PROC M7FUNC M7CMD M7LOADMODUL \
    M8DEVICE M8INST M8PAR M8PROC M8FUNC M8CMD M8LOADMODUL \
    MAXRESET MAXCONNECTCPU MAXLOADOSX MAXINST MAXPROC \
    MAXFUNC MAXPAR MAXLOADMDD MAXFLASHFILE

parameter=board slot layer osx file no usage task tasktype level irq flags \
    datasize func para start progno name count index TIMEOUT RESET

constants=MAX_NI_TASK MAX_TI_TASK MAX_II_TASK MAX_DI_TASK

keywords.$(file.patterns.sorcins)=$(commands)
keywords2.$(file.patterns.sorcins)=$(parameter)
keywords3.$(file.patterns.sorcins)=$(constants)

comment.block.sorcins=;




###############################################################################
# From specman.properties
# Define SciTE settings for Specman E language files.

# specman files
file.patterns.specman=*.e

filter.specman=Specman (e)|\
$(file.patterns.specman)|

*filter.specman=$(filter.specman)

lexer.$(file.patterns.specman)=specman

*language.specman=Specman|e||

keywords.$(file.patterns.specman)= \
struct unit \
integer real bool int long uint nibble byte bits bytes bit time string \
var instance event \
verilog vhdl \
on compute start expect check that routine \
specman is also first only with like \
list of all radix hex dec bin ignore illegal \
traceable untraceable \
cover using count_only trace_only at_least transition item ranges \
cross text call task within \
packing low high \
locker address \
body code vec chars \
byte_array external_pointer \
choose matches \
if then else when try \
case casex casez default \
and or not xor \
until repeat while for from to step each do break continue \
before next always -kind network \
index it me in new return result select \
cycle sample events forever \
wait  change  negedge rise fall delay sync sim true detach eventually emit \
gen keep keeping soft before \
define as computed type extend \
variable global sys \
import \
untyped symtab ECHO DOECHO \
initialize non_terminal testgroup delayed exit finish \
out append print outf appendf \
post_generate pre_generate setup_test finalize_test extract_test \
init run copy as_a a set_config dut_error add clear lock quit \
lock unlock release swap quit to_string value stop_run \
crc_8 crc_32 crc_32_flip get_config add0 all_indices and_all \
apply average count delete exists first_index get_indices \
has insert is_a_permutation is_empty key key_exists key_index \
last last_index max max_index max_value min min_index \
min_value or_all pop pop0 push push0 product resize reverse \
sort split sum top top0 unique clear is_all_iterations \
get_enclosing_unit hdl_path exec deep_compare deep_compare_physical \
pack unpack warning error fatal \
size \
files load module ntv source_ref script read write \
initial idle others posedge clock cycles \
statement action command member exp block num file

# keywords2 is for highlighting secondary keywords
keywords2.$(file.patterns.specman)= \
TRUE FALSE \
MAX_INT MIN_INT NULL UNDEF \

# keywords3 is for sequence and eRM keywords and functions
keywords3.$(file.patterns.specman)= \
any_sequence_item sequence any_sequence_driver driver \
created_driver  parent_sequence \
bfm_interaction_mode PULL_MODE PUSH_MODE MAIN SIMPLE RANDOM \
max_random_count max_random_depth num_of_last_items \
NORMAL NONE FULL LOW HIGH MEDIUM logger message \
get_tags show_units show_actions show_message ignore_tags \
set_style set_screen set_file set_flush_frequency \
set_format set_units set_actions at_message_verbosity \
short_name short_name_path short_name_style \
\
private protected package rerun any_env \
unqualified_clk clk reset_start reset_end \
message_logger verbosity tags to_file \
\
body pre_body post_body get_next_item send_to_bfm \
get_depth get_driver nice_string get_index grab \
is_blocked is_relevant ungrab mid_do post_do post_trace \
pre_do current_grabber get_current_item get_num_items_sent \
get_sequence_trace_list get_trace_list is_grabbed \
try_next_item check_is_relevant delay_clock \
get_sub_drivers regenerate_data wait_for_sequences \
stop

# keywords4 is for highlighting user defined keywords or function calls, highlighted in style 19
keywords4.$(file.patterns.specman)=

word.chars.specman=$(chars.alpha)$(chars.numeric)_#
word.characters.$(file.patterns.specman)=$(word.chars.specman)
comment.block.specman=//~
comment.block.at.line.start.specman=1
comment.stream.start.specman=
comment.stream.end.specman=
comment.box.start.specman=
comment.box.middle.specman=
comment.box.end.specman=

#~ statement.indent.$(file.patterns.specman)=5  if else try \
#~ case casex casez default \
#~ until repeat while for do \
#~ struct unit extend when
#~ statement.lookback.$(file.patterns.specman)=20
#~ block.start.$(file.patterns.specman)=10 {
#~ block.end.$(file.patterns.specman)=10 }

indent.maintain.$(file.patterns.specman)=1;

#autocomplete.specman.fillups=(

preprocessor.symbol.$(file.patterns.specman)=#
preprocessor.start.$(file.patterns.specman)=ifdef ifndef
preprocessor.middle.$(file.patterns.specman)=else
preprocessor.end.$(file.patterns.specman)=}


# Specman E styles


# Braces are only matched in operator style
braces.specman.style=10




###############################################################################
# From spice.properties
# Define SciTE settings for spice files.

file.patterns.spice=*.scp;*.out
filter.spice=Spice (out scp)|$(file.patterns.spice)|
*filter.spice=$(filter.spice)
lexer.$(file.patterns.spice)=spice

#indent.size.$(file.patterns.spice)=3
#use.tabs.$(file.patterns.spice)=0

# Keyword for script commands
keywordclass.spice.command=\
ac  alias  alter  alterparam append askvalues assertvalid autoscale \
break compose copy copytodoc dc  delete  destroy  destroyvec diff  display \
disto  dowhile  echo  else  end  errorstop  fftinit filter foreach  fourier \
freqtotime function  functionundef goto  homecursors if isdisplayed label \
let  linearize listing  load  loadaccumulator makelabel movelabel makesmithplot \
movecursorleft movecursorright  msgbox nameplot  newplot nextparam noise \
nopoints  op plot plotf plotref poly print  printcursors  printevent printname \
printplot printstatus printtext printtol printunits printval printvector \
pwl  pz  quit  removesmithplot rename repeat  resume  rotate  runs rusage \
save sendplot sendscript sens  set  setcursor setdoc setlabel setlabeltype \
setmargins setnthtrigger  setunits setvec setparam setplot  setquery \
setscaletype settracecolor settracestyle setsource settrigger  setvec \
setxlimits setylimits show  showmod  sort status  step  stop  switch \
tf  timetofreq  timetowave tran  unalias  unlet  unset  unalterparam \
update version view   wavefilter  wavetotime where  while  write
# Keywords for script functions
keywordclass.spice.functions=\
abs askvalue atan average ceil cos db differentiate differentiatex \
exp finalvalue floor getcursorx getcursory getcursory0 getcursory1 \
getparam im ln initialvalue integrate integratex interpolate isdef \
isdisplayed j log length mag, max maxscale mean meanpts min minscale \
nextplot  nextvector  norm operatingpoint ph phase phaseextend pk_pk \
pos pulse re rms rmspts rnd sameplot  sin sqrt stddev stddevpts tan \
tfall tolerance trise unitvec vector
# Keywords for spice parameters
keywordclass.spice.params=param nodeset include options dcconv subckt ends model


keywordclass.spice=$(keywordclass.spice.command) $(keywordclass.spice.functions) $(keywordclass.spice.params)

keywords.$(file.patterns.spice)=$(keywordclass.spice.command)
keywords2.$(file.patterns.spice)=$(keywordclass.spice.functions)
keywords3.$(file.patterns.spice)=$(keywordclass.spice.params)

# spice styles

# Comments
comment.block.spice=*~

braces.spice.style=4

statement.indent.$(file.patterns.spice)=5 begin declare else elsif exception for if is loop while
statement.lookback.$(file.patterns.spice)=20
block.start.$(file.patterns.spice)=10 then is
block.end.$(file.patterns.spice)=10 end

calltip.spice.word.characters=._$(chars.alpha)



###############################################################################
# From sql.properties
# Define SciTE settings for SQL and PL/SQL files.

filter.sql=SQL (sql)|*.sql|

*filter.sql=$(filter.sql)

file.patterns.sql=*.sql
file.patterns.plsql=*.spec;*.body;*.sps;*.spb;*.sf;*.sp

lexer.$(file.patterns.sql)=sql
lexer.$(file.patterns.plsql)=sql

*language.sql=S&QL|sql||

#*language.plsql=P&LSQL|spec||

# SQL styles
# Not used
# not used
# style.sql.14=

# Braces are only matched in operator style
braces.sql.style=10
# Enables backslash as an escape character
#sql.backslash.escapes=1

# Activate '#' based comments for MySQL with 1 or disable for Oracle with 0:
#lexer.sql.numbersign.comment=0

# Set to 1 to colourise recognized words with dots
# (recommended for Oracle PL/SQL objects)
#lexer.sql.allow.dotted.word=1

#lexer.sql.backticks.identifier=1

keywords.$(file.patterns.sql)=\
absolute action add admin after aggregate \
alias all allocate alter and any are array as asc \
assertion at authorization \
before begin binary bit blob body boolean both breadth by \
call cascade cascaded case cast catalog char character \
check class clob close collate collation column commit \
completion connect connection constraint constraints \
constructor continue corresponding create cross cube current \
current_date current_path current_role current_time current_timestamp \
current_user cursor cycle \
data date day deallocate dec decimal declare default \
deferrable deferred delete depth deref desc describe descriptor \
destroy destructor deterministic dictionary diagnostics disconnect \
distinct domain double drop dynamic \
each else end end-exec equals escape every except \
exception exec execute exists exit external \
false fetch first float for foreign found from free full \
function \
general get global go goto grant group grouping \
having host hour \
identity if ignore immediate in indicator initialize initially \
inner inout input insert int integer intersect interval \
into is isolation iterate \
join \
key \
language large last lateral leading left less level like \
limit local localtime localtimestamp locator \
map match merge minute modifies modify module month \
names national natural nchar nclob new next no none \
not null numeric \
object of off old on only open operation option \
or order ordinality out outer output \
package pad parameter parameters partial path postfix precision prefix \
preorder prepare preserve primary \
prior privileges procedure public \
read reads real recursive ref references referencing relative \
restrict result return returns revoke right \
role rollback rollup routine row rows \
savepoint schema scroll scope search second section select \
sequence session session_user set sets size smallint some| space \
specific specifictype sql sqlexception sqlstate sqlwarning start \
state statement static structure system_user \
table temporary terminate than then time timestamp \
timezone_hour timezone_minute to trailing transaction translation \
treat trigger true \
under union unique unknown \
unnest update usage user using \
value values varchar variable varying view \
when whenever where with without work write \
year \
zone

keywords.$(file.patterns.plsql)=\
all alter and any array as asc at authid avg begin between \
binary_integer \
body boolean bulk by char char_base check close cluster collect \
comment commit compress connect constant create current currval \
cursor date day declare decimal default delete desc distinct \
do drop else elsif end exception exclusive execute exists exit \
extends false fetch float for forall from function goto group \
having heap hour if immediate in index indicator insert integer \
interface intersect interval into is isolation java level like \
limited lock long loop max min minus minute mlslabel mod mode \
month natural naturaln new nextval nocopy not nowait null number \
number_base ocirowid of on opaque open operator option or order \
organization others out package partition pctfree pls_integer \
positive positiven pragma prior private procedure public raise \
range raw real record ref release return reverse rollback row \
rowid rownum rowtype savepoint second select separate set share \
smallint space sql sqlcode sqlerrm start stddev subtype successful \
sum synonym sysdate table then time timestamp to trigger true \
type uid union unique update use user validate values varchar \
varchar2 variance view when whenever where while with work write \
year zone

# Keywords for PlDoc comments
keywords3.$(file.patterns.sql)=\
param author since return see deprecated todo

# Keywords for SQL*Plus
keywords4.$(file.patterns.sql)=\
acc~ept a~ppend archive log attribute \
bre~ak bti~tle \
c~hange cl~ear col~umn comp~ute conn~ect copy \
def~ine del desc~ribe disc~onnect \
e~dit exec~ute exit \
get \
help ho~st \
i~nput \
l~ist \
passw~ord pau~se pri~nt pro~mpt \
quit \
recover rem~ark repf~ooter reph~eader r~un \
sav~e set sho~w shutdown spo~ol sta~rt startup store \
timi~ng tti~tle \
undef~ine \
var~iable \
whenever oserror whenever sqlerror \

# User keywords 1
# Keywords for Standard packages
keywords5.$(file.patterns.sql)=\
dbms_output.disable dbms_output.enable dbms_output.get_line \
dbms_output.get_lines dbms_output.new_line dbms_output.put \
dbms_output.put_line \



###############################################################################
# From tacl.properties
# Define SciTE settings for TACL files.

file.patterns.TACL=*.tacl
filter.tacl=TACL (TACL)|$(file.patterns.TACL)|
*filter.tacl=$(filter.tacl)

lexer.$(file.patterns.TACL)=TACL

# These keywords are case insensitive
keywords.$(file.patterns.TACL)=activate add adddsttransition adduser alter altpri assign attachseg backupcpu break builtins buscmd clear columnize comment compute copy dump copyvar create createseg debug debugnow default delete deluser detachseg env exit fileinfo filenames files filetovar help history home info initterm inlecho inleof inlout inlprefix inlto join keep keys lights load loaded files logoff logon o obey outvar param password pause pmsearch pmsg pop ppd purge push rcvdump receivedump reload remotepassword rename reset rpasswrd run rund seginfo set setprompt settime show sink status stop suspend switch system systimes time timestamp_to_text useusers variables varinfo vartofile vchange vcopy vdelete vfind vinsert vlist vmove volume vtree wakeup who xbusdown xbusup ybusdown ybusup _comparev _contime_to_text _contime_to_text_date _contime_to_text_time _debugger _execute _longest _month3

comment.block.TACL===

# TACL styles
# 1,Comment|2,Line Comment|3,Doc Comment|4,Number|5,Builtin|6,String|7,Character|8,Command|9,Preprocessor|10,Operator






###############################################################################
# From tal.properties
# Define SciTE settings for TAL files.
file.patterns.TAL=*.TAL
filter.tal=TAL (TAL)|$(file.patterns.TAL)|
*filter.tal=$(filter.tal)

lexer.$(file.patterns.TAL)=TAL

# These keywords are case insensitive
keywords.$(file.patterns.TAL)=and assert baddr begin by call callable case cbaddr code cwaddr define do downto drop else end entry external fixed for forward goto if int interrupt label land literal lor main not of or otherwise priv proc procaddr real resident return rscan scan sgbaddr sgwaddr sgxbaddr sgxwaddr stack store string struct subproc then to unsigned until use variable waddr while xor
keywords2.$(file.patterns.TAL)=at below bit_filler block bytes c cobol elements ext extensible filler fortran language name pascal private unspecified words

comment.block.TAL=--

# TAL styles
# 1,Comment|2,Line Comment|3,Doc Comment|4,Number|5,Keyword|6,String|7,Character|8,Unreserved keyword|9,Preprocessor|10,Operator







###############################################################################
# From tcl.properties
# Define SciTE settings for tcl and itcl files.

file.patterns.tcl=*.tcl;*.exp
file.patterns.itcl=*.itcl
file.patterns.tcl.like=$(file.patterns.tcl);$(file.patterns.itcl);

filter.tcl=Tcl (tcl)|$(file.patterns.tcl)|
filter.itcl=itcl (itcl)|$(file.patterns.itcl)|

*filter.tcl=$(filter.tcl)

lexer.$(file.patterns.tcl)=tcl
lexer.$(file.patterns.itcl)=tcl

*language.tcl=&TCL|tcl||

keywordclass.tcl=after append array auto_execok \
auto_import auto_load auto_load_index auto_qualify \
beep bgerror binary break case catch cd clock \
close concat continue dde default echo else elseif \
encoding eof error eval exec exit expr fblocked \
fconfigure fcopy file fileevent flush for foreach format \
gets glob global history http if incr info \
interp join lappend lindex linsert list llength load \
loadTk lrange lreplace lsearch lset lsort memory msgcat \
namespace open package pid pkg::create pkg_mkIndex Platform-specific proc \
puts pwd re_syntax read regexp registry regsub rename \
resource return scan seek set socket source split \
string subst switch tclLog tclMacPkgSearch tclPkgSetup tclPkgUnknown tell \
time trace unknown unset update uplevel upvar variable \
vwait while

keywordclass.tk=bell bind bindtags bitmap button canvas checkbutton clipboard \
colors console cursors destroy entry event focus font \
frame grab grid image Inter-client keysyms label labelframe \
listbox lower menu menubutton message option options pack \
panedwindow photo place radiobutton raise scale scrollbar selection \
send spinbox text tk tk_chooseColor tk_chooseDirectory tk_dialog tk_focusNext \
tk_getOpenFile tk_messageBox tk_optionMenu tk_popup tk_setPalette tkerror tkvars tkwait \
toplevel winfo wish wm

keywordclass.itcl=@scope body class code common component configbody \
constructor define destructor hull import inherit itcl itk itk_component \
itk_initialize itk_interior itk_option iwidgets keep method \
private protected public

keywordclass.TkCommands=tk_bisque tk_chooseColor tk_dialog tk_focusFollowsMouse tk_focusNext \
tk_focusPrev tk_getOpenFile tk_getSaveFile tk_messageBox tk_optionMenu \
tk_popup tk_setPalette tk_textCopy tk_textCut tk_textPaste \
tkButtonAutoInvoke tkButtonDown tkButtonEnter tkButtonInvoke tkButtonLeave \
tkButtonUp tkCancelRepeat tkCheckRadioDown tkCheckRadioEnter tkCheckRadioInvoke \
tkColorDialog tkColorDialog_BuildDialog tkColorDialog_CancelCmd tkColorDialog_Config tkColorDialog_CreateSelector \
tkColorDialog_DrawColorScale tkColorDialog_EnterColorBar tkColorDialog_HandleRGBEntry tkColorDialog_HandleSelEntry tkColorDialog_InitValues \
tkColorDialog_LeaveColorBar tkColorDialog_MoveSelector tkColorDialog_OkCmd tkColorDialog_RedrawColorBars tkColorDialog_RedrawFinalColor \
tkColorDialog_ReleaseMouse tkColorDialog_ResizeColorBars tkColorDialog_RgbToX tkColorDialog_SetRGBValue tkColorDialog_StartMove \
tkColorDialog_XToRgb tkConsoleAbout tkConsoleBind tkConsoleExit tkConsoleHistory \
tkConsoleInit tkConsoleInsert tkConsoleInvoke tkConsoleOutput tkConsolePrompt \
tkConsoleSource tkDarken tkEntryAutoScan tkEntryBackspace tkEntryButton1 \
tkEntryClosestGap tkEntryGetSelection tkEntryInsert tkEntryKeySelect tkEntryMouseSelect \
tkEntryNextWord tkEntryPaste tkEntryPreviousWord tkEntrySeeInsert tkEntrySetCursor \
tkEntryTranspose tkEventMotifBindings tkFDGetFileTypes tkFirstMenu tkFocusGroup_BindIn \
tkFocusGroup_BindOut tkFocusGroup_Create tkFocusGroup_Destroy tkFocusGroup_In tkFocusGroup_Out \
tkFocusOK tkGenerateMenuSelect tkIconList tkIconList_Add tkIconList_Arrange \
tkIconList_AutoScan tkIconList_Btn1 tkIconList_Config tkIconList_Create tkIconList_CtrlBtn1 \
tkIconList_Curselection tkIconList_DeleteAll tkIconList_Double1 tkIconList_DrawSelection tkIconList_FocusIn \
tkIconList_FocusOut tkIconList_Get tkIconList_Goto tkIconList_Index tkIconList_Invoke \
tkIconList_KeyPress tkIconList_Leave1 tkIconList_LeftRight tkIconList_Motion1 tkIconList_Reset \
tkIconList_ReturnKey tkIconList_See tkIconList_Select tkIconList_Selection tkIconList_ShiftBtn1 \
tkIconList_UpDown tkListbox tkListboxAutoScan tkListboxBeginExtend tkListboxBeginSelect \
tkListboxBeginToggle tkListboxCancel tkListboxDataExtend tkListboxExtendUpDown tkListboxKeyAccel_Goto \
tkListboxKeyAccel_Key tkListboxKeyAccel_Reset tkListboxKeyAccel_Set tkListboxKeyAccel_Unset tkListboxMotion \
tkListboxSelectAll tkListboxUpDown tkMbButtonUp tkMbEnter tkMbLeave \
tkMbMotion tkMbPost tkMenuButtonDown tkMenuDownArrow tkMenuDup \
tkMenuEscape tkMenuFind tkMenuFindName tkMenuFirstEntry tkMenuInvoke \
tkMenuLeave tkMenuLeftArrow tkMenuMotion tkMenuNextEntry tkMenuNextMenu \
tkMenuRightArrow tkMenuUnpost tkMenuUpArrow tkMessageBox tkMotifFDialog \
tkMotifFDialog_ActivateDList tkMotifFDialog_ActivateFEnt tkMotifFDialog_ActivateFList tkMotifFDialog_ActivateSEnt tkMotifFDialog_BrowseDList \
tkMotifFDialog_BrowseFList tkMotifFDialog_BuildUI tkMotifFDialog_CancelCmd tkMotifFDialog_Config tkMotifFDialog_Create \
tkMotifFDialog_FileTypes tkMotifFDialog_FilterCmd tkMotifFDialog_InterpFilter tkMotifFDialog_LoadFiles tkMotifFDialog_MakeSList \
tkMotifFDialog_OkCmd tkMotifFDialog_SetFilter tkMotifFDialog_SetListMode tkMotifFDialog_Update tkPostOverPoint \
tkRecolorTree tkRestoreOldGrab tkSaveGrabInfo tkScaleActivate tkScaleButton2Down \
tkScaleButtonDown tkScaleControlPress tkScaleDrag tkScaleEndDrag tkScaleIncrement \
tkScreenChanged tkScrollButton2Down tkScrollButtonDown tkScrollButtonDrag tkScrollButtonUp \
tkScrollByPages tkScrollByUnits tkScrollDrag tkScrollEndDrag tkScrollSelect \
tkScrollStartDrag tkScrollTopBottom tkScrollToPos tkTabToWindow tkTearOffMenu \
tkTextAutoScan tkTextButton1 tkTextClosestGap tkTextInsert tkTextKeyExtend \
tkTextKeySelect tkTextNextPara tkTextNextPos tkTextNextWord tkTextPaste \
tkTextPrevPara tkTextPrevPos tkTextPrevWord tkTextResetAnchor tkTextScrollPages \
tkTextSelectTo tkTextSetCursor tkTextTranspose tkTextUpDownLine tkTraverseToMenu \
tkTraverseWithinMenu

keywords.$(file.patterns.tcl.like)=$(keywordclass.tcl)
keywords2.$(file.patterns.tcl.like)=$(keywordclass.tk)
keywords3.$(file.patterns.tcl.like)= $(keywordclass.TkCommands)
keywords4.$(file.patterns.itcl)=$(keywordclass.itcl)
keywords5.$(file.patterns.tcl.like)=expand

comment.block.tcl=#~
# also suported is #- for start/end of box, box.middle # can be in column 1
comment.box.start.tcl=##
comment.box.middle.tcl= #
comment.box.end.tcl= ##

# tcl styles
# Other keywords (bozo test colors :-)


# Braces are only matched in operator style
braces.tcl.style=6



###############################################################################
# From tex.properties
# file    : tex.properties
# version : 18 august 2003
# author  : Hans Hagen / PRAGMA ADE / www.pragma-ade.com

# TeX users may want to use the Latin Modern Typewriter font:
#
#   font.monospace=font:LMTypewriter10,size:16.5
#   font.errorfont=font:LMTypewriter10,size:11.5
#
# These and more presets are done in context.properties.

# TeX: patterns

file.patterns.tex=*.tex;*.sty
file.patterns.latex=*.tex;*.sty;*.aux;*.toc;*.idx
file.patterns.context=*.tex;*.tui;*.tuo;*.sty

# filter to be checked/tested:

filter.tex=TeX (tex sty)|$(file.patterns.tex)|
filter.latex=LaTeX (tex sty aux toc idx)|$(file.patterns.latex)|
filter.context=ConTeXt (tex tui tuo sty)|$(file.patterns.context)|

lexer.$(file.patterns.tex)=tex
lexer.$(file.patterns.latex)=tex
lexer.$(file.patterns.context)=tex

*language.tex=TeX|tex||

# TeX: commands (check process view)

command.compile.$(file.patterns.tex)=
command.build.$(file.patterns.tex)=tex $(FileNameExt)
command.go.$(file.patterns.tex)=gv $(FileName).pdf

command.compile.$(file.patterns.latex)=
command.build.$(file.patterns.latex)=pdflatex $(FileNameExt)
command.go.$(file.patterns.latex)=gv $(FileName).pdf

command.compile.$(file.patterns.context)=
command.build.$(file.patterns.context)=texexec --pdf $(FileNameExt)
command.go.$(file.patterns.context)=gv $(FileName).pdf

command.0.$(file.patterns.tex)=
command.1.$(file.patterns.tex)=
command.2.$(file.patterns.tex)=
command.3.$(file.patterns.tex)=
command.4.$(file.patterns.tex)=
command.5.$(file.patterns.tex)=
command.6.$(file.patterns.tex)=
command.7.$(file.patterns.tex)=
command.8.$(file.patterns.tex)=
command.9.$(file.patterns.tex)=

command.0.$(file.patterns.latex)=
command.1.$(file.patterns.latex)=
command.2.$(file.patterns.latex)=
command.3.$(file.patterns.latex)=
command.4.$(file.patterns.latex)=
command.5.$(file.patterns.latex)=
command.6.$(file.patterns.latex)=
command.7.$(file.patterns.latex)=
command.8.$(file.patterns.latex)=
command.9.$(file.patterns.latex)=

command.0.$(file.patterns.context)=
command.1.$(file.patterns.context)=
command.2.$(file.patterns.context)=
command.3.$(file.patterns.context)=
command.4.$(file.patterns.context)=
command.5.$(file.patterns.context)=
command.6.$(file.patterns.context)=
command.7.$(file.patterns.context)=
command.8.$(file.patterns.context)=
command.9.$(file.patterns.context)=

# BibTeX command
command.name.2.$(file.patterns.tex)=BibTeX
command.name.2.$(file.patterns.latex)=BibTeX
command.name.2.$(file.patterns.context)=BibTeX
command.2.$(file.patterns.tex)=bibtex $(FileName)
command.2.$(file.patterns.latex)=bibtex $(FileName)
command.2.$(file.patterns.context)=bibtex $(FileName)

# TeX: highlighting



# TeX: comments

comment.block.tex=%
comment.block.at.line.start.tex=1

# TeX: lexer.tex.interface.default
#
# 0 all \commands
# 1 tex etex pdftex omega primitives
# 2 context nl (when context.properties is loaded)
# 3 context en (when context.properties is loaded)
# 4 context de (when context.properties is loaded)
# 5 context cz (when context.properties is loaded)
# 6 context it (when context.properties is loaded)
# 7 context ro (when context.properties is loaded)
# 8 latex (no keywords yet; will move up)
#
# first lines of a tex file are interpreted as follows
#
# % interface=all|nl|en|de|cz|it|ro|latex

lexer.tex.interface.default=0

# TeX: lexer.tex.use.keywords
#
# 0 don't use keyword lists
# 1 use keyword lists

lexer.tex.use.keywords=1

# TeX: lexer.tex.comment.process
#
# 0 don't interpret comment
# 1 color comment like source code

lexer.tex.comment.process=0

# TeX: lexer.tex.auto.if
#
# 0 don't handle \if<unknown>
# 1 treat \if<unknown> as command

lexer.tex.auto.if=1

# TeX: keywords (incomplete, just for testing and as example)

keywordclass.primitives.tex=\
    above abovedisplayshortskip abovedisplayskip \
    abovewithdelims accent adjdemerits advance afterassignment \
    aftergroup atop atopwithdelims \
    badness baselineskip batchmode begingroup \
    belowdisplayshortskip belowdisplayskip binoppenalty botmark \
    box boxmaxdepth brokenpenalty \
    catcode char chardef cleaders closein closeout clubpenalty \
    copy count countdef cr crcr csname \
    day deadcycles def defaulthyphenchar defaultskewchar \
    delcode delimiter delimiterfactor delimeters \
    delimitershortfall delimeters dimen dimendef discretionary \
    displayindent displaylimits displaystyle \
    displaywidowpenalty displaywidth divide \
    doublehyphendemerits dp dump \
    edef else emergencystretch end endcsname endgroup endinput \
    endlinechar eqno errhelp errmessage errorcontextlines \
    errorstopmode escapechar everycr everydisplay everyhbox \
    everyjob everymath everypar everyvbox exhyphenpenalty \
    expandafter  \
    fam fi finalhyphendemerits firstmark floatingpenalty font \
    fontdimen fontname futurelet \
    gdef global group globaldefs \
    halign hangafter hangindent hbadness hbox hfil horizontal \
    hfill horizontal hfilneg hfuzz hoffset holdinginserts hrule \
    hsize hskip hss horizontal ht hyphenation hyphenchar \
    hyphenpenalty hyphen \
    if ifcase ifcat ifdim ifeof iffalse ifhbox ifhmode ifinner \
    ifmmode ifnum ifodd iftrue ifvbox ifvmode ifvoid ifx \
    ignorespaces immediate indent input inputlineno input \
    insert insertpenalties interlinepenalty \
    jobname \
    kern \
    language lastbox lastkern lastpenalty lastskip lccode \
    leaders left lefthyphenmin leftskip leqno let limits \
    linepenalty line lineskip lineskiplimit long looseness \
    lower lowercase \
    mag mark mathaccent mathbin mathchar mathchardef mathchoice \
    mathclose mathcode mathinner mathop mathopen mathord \
    mathpunct mathrel mathsurround maxdeadcycles maxdepth \
    meaning medmuskip message mkern month moveleft moveright \
    mskip multiply muskip muskipdef \
    newlinechar noalign noboundary noexpand noindent nolimits \
    nonscript scriptscript nonstopmode nulldelimiterspace \
    nullfont number \
    omit openin openout or outer output outputpenalty over \
    overfullrule overline overwithdelims \
    pagedepth pagefilllstretch pagefillstretch pagefilstretch \
    pagegoal pageshrink pagestretch pagetotal par parfillskip \
    parindent parshape parskip patterns pausing penalty \
    postdisplaypenalty predisplaypenalty predisplaysize \
    pretolerance prevdepth prevgraf \
    radical raise read relax relpenalty right righthyphenmin \
    rightskip romannumeral \
    scriptfont scriptscriptfont scriptscriptstyle scriptspace \
    scriptstyle scrollmode setbox setlanguage sfcode shipout \
    show showbox showboxbreadth showboxdepth showlists showthe \
    skewchar skip skipdef spacefactor spaceskip span special \
    splitbotmark splitfirstmark splitmaxdepth splittopskip \
    string \
    tabskip textfont textstyle the thickmuskip thinmuskip time \
    toks toksdef tolerance topmark topskip tracingcommands \
    tracinglostchars tracingmacros tracingonline tracingoutput \
    tracingpages tracingparagraphs tracingrestores tracingstats \
    uccode uchyph underline unhbox unhcopy unkern unpenalty \
    unskip unvbox unvcopy uppercase \
    vadjust valign vbadness vbox vcenter vfil vfill vfilneg \
    vfuzz voffset vrule vsize vskip vsplit vss vtop \
    wd widowpenalty write \
    xdef xleaders xspaceskip \
    year

keywordclass.primitives.etex=\
    beginL beginR botmarks \
    clubpenalties currentgrouplevel currentgrouptype \
    currentifbranch currentiflevel currentiftype \
    detokenize dimexpr displaywidowpenalties \
    endL endR eTeXrevision eTeXversion everyeof \
    firstmarks fontchardp fontcharht fontcharic fontcharwd \
    glueexpr glueshrink glueshrinkorder gluestretch \
    gluestretchorder gluetomu \
    ifcsname ifdefined iffontchar interactionmode \
    interactionmode interlinepenalties \
    lastlinefit lastnodetype \
    marks topmarks middle muexpr mutoglue \
    numexpr \
    pagediscards parshapedimen parshapeindent parshapelength \
    predisplaydirection \
    savinghyphcodes savingvdiscards scantokens showgroups \
    showifs showtokens splitdiscards splitfirstmarks \
    TeXXeTstate tracingassigns tracinggroups tracingifs \
    tracingnesting tracingscantokens \
    unexpanded unless \
    widowpenalties

keywordclass.primitives.pdftex=\
    pdfadjustspacing pdfannot pdfavoidoverfull \
    pdfcatalog pdfcompresslevel \
    pdfdecimaldigits pdfdest pdfdestmargin \
    pdfendlink pdfendthread \
    pdffontattr pdffontexpand pdffontname pdffontobjnum pdffontsize \
    pdfhorigin \
    pdfimageresolution pdfincludechars pdfinfo \
    pdflastannot pdflastdemerits pdflastobj \
    pdflastvbreakpenalty pdflastxform pdflastximage \
    pdflastximagepages pdflastxpos pdflastypos \
    pdflinesnapx pdflinesnapy pdflinkmargin pdfliteral \
    pdfmapfile pdfmaxpenalty pdfminpenalty pdfmovechars \
    pdfnames \
    pdfobj pdfoptionpdfminorversion pdfoutline pdfoutput \
    pdfpageattr pdfpageheight pdfpageresources pdfpagesattr \
    pdfpagewidth pdfpkresolution pdfprotrudechars \
    pdfrefobj pdfrefxform pdfrefximage \
    pdfsavepos pdfsnaprefpoint pdfsnapx pdfsnapy pdfstartlink \
    pdfstartthread \
    pdftexrevision pdftexversion pdfthread pdfthreadmargin \
    pdfuniqueresname \
    pdfvorigin \
    pdfxform pdfximage

keywordclass.primitives.omega=\
    odelimiter omathaccent omathchar oradical omathchardef omathcode odelcode \
    leftghost rightghost \
    charwd charht chardp charit \
    localleftbox localrightbox \
    localinterlinepenalty localbrokenpenalty \
    pagedir bodydir pardir textdir mathdir \
    boxdir nextfakemath \
    pagewidth pageheight pagerightoffset pagebottomoffset \
    nullocp nullocplist ocp externalocp ocplist pushocplist popocplist clearocplists ocptracelevel \
    addbeforeocplist addafterocplist removebeforeocplist removeafterocplist \
    OmegaVersion \
    InputTranslation OutputTranslation DefaultInputTranslation DefaultOutputTranslation \
    noInputTranslation noOutputTranslation \
    InputMode OutputMode DefaultInputMode DefaultOutputMode \
    noInputMode noOutputMode noDefaultInputMode noDefaultOutputMode

# only the macros that make sense:

keywordclass.macros.plain.partial=\
    TeX \
    bgroup egroup endgraf space empty null \
    newcount newdimen newskip newmuskip newbox newtoks newhelp newread newwrite newfam newlanguage newinsert newif \
    maxdimen magstephalf magstep \
    frenchspacing nonfrenchspacing normalbaselines obeylines obeyspaces raggedright ttraggedright \
    thinspace negthinspace enspace enskip quad qquad \
    smallskip medskip bigskip removelastskip topglue vglue hglue \
    break nobreak allowbreak filbreak goodbreak smallbreak medbreak bigbreak \
    line leftline rightline centerline rlap llap underbar strutbox strut \
    cases matrix pmatrix bordermatrix eqalign displaylines eqalignno leqalignno \
    pageno folio tracingall showhyphens fmtname fmtversion \
    hphantom vphantom phantom smash

keywordclass.macros.eplain.partial=\
    eTeX \
    newmarks grouptype interactionmode nodetype iftype \
    tracingall loggingall tracingnone

# for fun

keywordclass.primitives.pdftex.experimental=

keywordclass.primitives.all=\
    $(keywordclass.primitives.tex) \
    $(keywordclass.primitives.etex) \
    $(keywordclass.primitives.pdftex) \
    $(keywordclass.primitives.pdftex.experimental) \
    $(keywordclass.primitives.omega)

# hooks for context

keywordclass.macros.context.undocumented.en=
keywordclass.macros.context.undocumented.nl=
keywordclass.macros.context.undocumented.de=
keywordclass.macros.context.undocumented.cz=
keywordclass.macros.context.undocumented.it=
keywordclass.macros.context.undocumented.ro=

keywordclass.macros.context.extras=

keywordclass.macros.context.nl=
keywordclass.macros.context.en=
keywordclass.macros.context.de=
keywordclass.macros.context.cz=
keywordclass.macros.context.it=
keywordclass.macros.context.ro=

import cont-en-scite
import cont-nl-scite
import cont-de-scite
import cont-cz-scite
import cont-it-scite
import cont-ro-scite

import cont-xx-scite

# hooks for latex (file should define keywordclass.macros.latex.all)

keywordclass.macros.latex.all=

import latex-scite

# collections

keywordclass.tex.all=\
    $(keywordclass.primitives.tex) \
    $(keywordclass.macros.plain.partial)

keywordclass.etex.all=\
    $(keywordclass.primitives.tex) \
    $(keywordclass.primitives.etex) \
    $(keywordclass.macros.plain.partial) \
    $(keywordclass.macros.eplain.partial)

keywordclass.latex.all=\
    $(keywordclass.primitives.tex) \
    $(keywordclass.primitives.etex) \
    $(keywordclass.macros.latex.all)

keywordclass.pdflatex.all=\
    $(keywordclass.primitives.tex) \
    $(keywordclass.primitives.etex) \
    $(keywordclass.primitives.pdftex) \
    $(keywordclass.macros.latex.all)

# we can't use $(keywordclass.primitives.all) here due to some kind of
# limitation in nesting

keywordclass.context.base=\
    $(keywordclass.primitives.tex) \
    $(keywordclass.primitives.etex) \
    $(keywordclass.primitives.pdftex) \
    $(keywordclass.primitives.pdftex.experimental) \
    $(keywordclass.primitives.omega) \
    $(keywordclass.macros.plain.partial) \
    $(keywordclass.macros.eplain.partial)

keywordclass.context.all=\
    $(keywordclass.context.base) \
    $(keywordclass.macros.context.en) \
    $(keywordclass.macros.context.extras) \
    $(keywordclass.macros.context.undocumented.en)

keywordclass.context.all.nl=\
    $(keywordclass.context.base) \
    $(keywordclass.macros.context.nl) \
    $(keywordclass.macros.context.extras) \
    $(keywordclass.macros.context.undocumented.nl)

keywordclass.context.all.en=\
    $(keywordclass.context.base) \
    $(keywordclass.macros.context.en) \
    $(keywordclass.macros.context.extras) \
    $(keywordclass.macros.context.undocumented.en)

keywordclass.context.all.de=\
    $(keywordclass.context.base) \
    $(keywordclass.macros.context.de) \
    $(keywordclass.macros.context.extras) \
    $(keywordclass.macros.context.undocumented.de)

keywordclass.context.all.cz=\
    $(keywordclass.context.base) \
    $(keywordclass.macros.context.cz) \
    $(keywordclass.macros.context.extras) \
    $(keywordclass.macros.context.undocumented.cz)

keywordclass.context.all.it=\
    $(keywordclass.context.base) \
    $(keywordclass.macros.context.it) \
    $(keywordclass.macros.context.extras) \
    $(keywordclass.macros.context.undocumented.it)

keywordclass.context.all.ro=\
    $(keywordclass.context.base) \
    $(keywordclass.macros.context.ro) \
    $(keywordclass.macros.context.extras) \
    $(keywordclass.macros.context.undocumented.ro)

# hm

keywords.$(file.patterns.tex)=$(keywordclass.tex.all)
keywords.$(file.patterns.latex)=$(keywordclass.latex.all)
keywords.$(file.patterns.context)=$(keywordclass.context.all)

# keywords1 is not used since scintilla takes it from 'keywords'

keywords.$(file.patterns.context)=$(keywordclass.context.base)

keywords2.$(file.patterns.context)=$(keywordclass.context.all.nl)
keywords3.$(file.patterns.context)=$(keywordclass.context.all.en)
keywords4.$(file.patterns.context)=$(keywordclass.context.all.de)
keywords5.$(file.patterns.context)=$(keywordclass.context.all.cz)
keywords6.$(file.patterns.context)=$(keywordclass.context.all.it)
keywords7.$(file.patterns.context)=$(keywordclass.context.all.ro)

# keywords71.$(file.patterns.context)=$(keywordclass.tex.all)
# keywords72.$(file.patterns.context)=$(keywordclass.etex.all)
# keywords73.$(file.patterns.context)=$(keywordclass.pdftex.all)
# keywords74.$(file.patterns.context)=$(keywordclass.pdfetex.all)
#
# keywords91.$(file.patterns.context)=$(keywordclass.latex.all)

# for the moment LaTeX gets slot 8, but we will move it up as soon as
# more keyword lists can be defined

keywords8.$(file.patterns.context)=$(keywordclass.pdflatex.all)

# TeX: words

word.characters.$(file.patterns.tex)=$(chars.alpha)$(chars.numeric)$(chars.accented)\@
word.characters.$(file.patterns.latex)=$(chars.alpha)$(chars.numeric)$(chars.accented)\@
word.characters.$(file.patterns.context)=$(chars.alpha)$(chars.numeric)$(chars.accented)\@!?

# TeX: end of file



###############################################################################
# From txt2tags.properties
# Define SciTE settings for txt2tags.

file.patterns.txt2tags=*.t2t

shbang.txt2tags=txt2tags

filter.txt2tags=Txt2tags (t2t)|$(file.patterns.txt2tags)|

*filter.txt2tags=$(filter.txt2tags)

lexer.$(file.patterns.txt2tags)=txt2tags

*language.txt2tags=&txt2tags|t2t||
































###############################################################################
# From vb.properties
# Define SciTE settings for VB files.

# BAS: Module, FRM: Form, CLS: Class Module, CTL: User Control
# PAG: Property Page, DSR: Data Report, DOB: User Document
file.patterns.vb=*.vb;*.bas;*.frm;*.cls;*.ctl;*.pag;*.dsr;*.dob
# VBS: VBScript, DSM: Visual[ex. Dev] Studio macro
file.patterns.wscript=*.vbs;*.dsm

*source.patterns.vb=$(file.patterns.vb);$(file.patterns.wscript);

# VBP: VB Project, VBG: VB Project Group (ActiveX), MAK: old (VB3) project file, VBW: VB Workspace
filter.vb=VB (vb vbp vbs bas frm cls ctl pag dsr dob)|$(file.patterns.vb);$(file.patterns.wscript);*.vbp;*.vbg;*.mak;*.vbw|

*filter.vb=$(filter.vb)

lexer.$(file.patterns.vb)=vb
lexer.$(file.patterns.wscript)=vbscript

*language.vb=&VB|vb||
#*language.vbscript=VBScr&ipt|vbs||

# Keywords, operators, statements, data types and some words in .frm files
keywordclass.vb6=\
addressof alias and as attribute base begin binary boolean byref byte byval call case cdbl \
cint clng compare const csng cstr currency date decimal declare defbool defbyte defcur \
defdate defdbl defdec defint deflng defobj defsng defstr defvar dim do double each else \
elseif empty end enum eqv erase error event exit explicit false for friend function get \
global gosub goto if imp implements in input integer is len let lib like load lock long \
loop lset me mid midb mod new next not nothing null object on option optional or paramarray \
preserve print private property public raiseevent randomize redim rem resume return rset \
seek select set single static step stop string sub text then time to true type typeof \
unload until variant wend while with withevents xor

# html.properties picks up VB keywords from keywordclass.vb
keywordclass.vb=$(keywordclass.vb6)

# Mostly system statements (files, registry, I/O...) that
# I am not sure to include with the regular statements.
keywordclass.vbotherstatements=\
appactivate beep chdir chdrive close filecopy get input kill line unlock mkdir name \
open print put reset rmdir savepicture savesetting seek sendkeys setattr width write

# VBNet specific keywords
keywordclass.vbnet=\
addhandler andalso ansi assembly auto catch cbool cbyte cchar cdate cdec char class \
cobj continue csbyte cshort ctype cuint culng cushort custom default delegate directcast \
endif externalsource finally gettype handles imports inherits interface isfalse isnot \
istrue module mustinherit mustoverride my mybase myclass namespace narrowing notinheritable \
notoverridable of off operator orelse overloads overridable overrides partial protected \
readonly region removehandler sbyte shadows shared short strict structure synclock \
throw try trycast uinteger ulong unicode ushort using when widening writeonly

keywords.$(file.patterns.vb)=$(keywordclass.vb6) $(keywordclass.vbnet)
keywords.$(file.patterns.wscript)=$(keywordclass.vb6)

keywords2.$(file.patterns.vb)=$(keywordclass.vbotherstatements)

comment.block.vb='~
comment.block.vbscript='~
# VB styles



# wscript
# normal execute
command.go.$(file.patterns.wscript)="$(FilePath)"
command.go.subsystem.$(file.patterns.wscript)=2

# note we have no real "build"; rather "execute and capture
# compiletime and runtime errors"
command.build.$(file.patterns.wscript)=cscript "$(FilePath)"
command.build.subsystem.$(file.patterns.wscript)=1

command.help.$(file.patterns.wscript)=$(CurrentWord)!C:\Program Files\Microsoft Visual Studio\MSDN\2001OCT\1033\MSDN130.COL
command.help.subsystem.$(file.patterns.wscript)=4
command.help.$(file.patterns.vb)=$(CurrentWord)!C:\Program Files\Microsoft Visual Studio\MSDN\2001OCT\1033\MSDN130.COL
command.help.subsystem.$(file.patterns.vb)=4



###############################################################################
# From verilog.properties
# Define SciTE settings for Verilog files.

# Verilog files
file.patterns.verilog=*.v;*.vh
filter.verilog=Verilog (verilog)|$(file.patterns.verilog)|

*filter.verilog=$(filter.verilog)

lexer.$(file.patterns.verilog)=verilog

*language.verilog=Verilog|v||

word.chars.verilog=$(chars.alpha)$(chars.numeric)_`$#
word.characters.$(file.patterns.verilog)=$(word.chars.verilog)

calltip.verilog.word.characters=$(chars.alpha)$(chars.numeric)_$

comment.block.verilog=//~
#comment.block.at.line.start.verilog=1
comment.stream.start.verilog=/*
comment.stream.end.verilog=*/
comment.box.start.verilog=/*
comment.box.middle.verilog= *
comment.box.end.verilog= */

fold.verilog.flags=0

statement.lookback.$(file.patterns.verilog)=20
statement.end.$(file.patterns.verilog)=10 ;
block.start.$(file.patterns.verilog)=5 begin case casex casez
block.end.$(file.patterns.verilog)=5 begin end endcase
statement.indent.$(file.patterns.verilog)=5 always else for if while

indent.maintain.$(file.patterns.verilog)=0

preprocessor.symbol.$(file.patterns.verilog)=`
preprocessor.start.$(file.patterns.verilog)=ifdef ifndef
preprocessor.middle.$(file.patterns.verilog)=else
preprocessor.end.$(file.patterns.verilog)=endif

keywordclass.verilog= \
always and assign automatic \
begin buf bufif0 bufif1 \
case casex casez cell cmos config \
deassign default defparam design disable \
edge else end endcase endconfig endfunction endgenerate endmodule endprimitive endspecify endtable endtask event \
for force forever fork function \
generate genvar \
highz0 highz1 \
if ifnone incdir include initial inout input instance integer \
join \
large liblist library localparam \
macromodule medium module \
nand negedge nmos nor noshowcancelled not notif0 notif1 \
or output \
parameter pmos posedge primitive pull0 pull1 pulldown pullup pulsestyle_ondetect pulsestyle_onevent \
rcmos real realtime reg release repeat rnmos rpmos rtran rtranif0 rtranif1 \
scalared showcancelled signed small specify specparam strong0 strong1 supply0 supply1 \
table task time tran tranif0 tranif1 tri tri0 tri1 triand trior trireg \
unsigned use uwire \
vectored \
wait wand weak0 weak1 while wire wor \
xnor xor

keywords.$(file.patterns.verilog)=$(keywordclass.verilog)

# Secondary keywords and identifiers
keywords2.$(file.patterns.verilog)=
keywords3.$(file.patterns.verilog)= \
$async$and$array $async$and$plane $async$nand$array $async$nand$plane $async$nor$array $async$nor$plane $async$or$array $async$or$plane \
$bitstoreal \
$countdrivers \
$display $displayb $displayh $displayo \
$dist_chi_square $dist_erlang $dist_exponential $dist_normal $dist_poisson $dist_t $dist_uniform \
$dumpall $dumpfile $dumpflush $dumplimit $dumpoff $dumpon $dumpportsall $dumpportsflush $dumpportslimit $dumpportsoff $dumpportson $dumpvars \
$fclose $fdisplayh $fdisplay $fdisplayf $fdisplayb $feof $ferror $fflush $fgetc $fgets $finish $fmonitorb $fmonitor $fmonitorf $fmonitorh $fopen $fread $fscanf $fseek $fsscanf $fstrobe $fstrobebb $fstrobef $fstrobeh $ftel $fullskew $fwriteb $fwritef $fwriteh $fwrite \
$getpattern \
$history $hold \
$incsave $input $itor \
$key \
$list $log \
$monitorb $monitorh $monitoroff $monitoron $monitor $monitoro \
$nochange $nokey $nolog \
$period $printtimescale \
$q_add $q_exam $q_full $q_initialize $q_remove \
$random $readmemb $readmemh $readmemh $realtime $realtobits $recovery $recrem $removal $reset_count $reset $reset_value $restart $rewind $rtoi \
$save $scale $scope $sdf_annotate $setup $setuphold $sformat $showscopes $showvariables $showvars $signed $skew $sreadmemb $sreadmemh $stime $stop $strobeb $strobe $strobeh $strobeo $swriteb $swriteh $swriteo $swrite $sync$and$array $sync$and$plane $sync$nand$array $sync$nand$plane $sync$nor$array $sync$nor$plane $sync$or$array $sync$or$plane \
$test$plusargs $time $timeformat $timeskew \
$ungetc $unsigned \
$value$plusargs \
$width $writeb $writeh $write $writeo
# User defined tasks and identifiers
keywords4.$(file.patterns.verilog)=
# comment keyword
keywords5.$(file.patterns.verilog)= synopsys parallel_case infer_mux TODO


# Define SciTE settings for SystemVerilog files.

# systemverilog files
file.patterns.systemverilog=*.sv;*.svh
filter.systemverilog=systemverilog (systemverilog)|$(file.patterns.systemverilog)|
lexer.$(file.patterns.systemverilog)=verilog

word.chars.systemverilog=$(chars.alpha)$(chars.numeric)_`$#
word.characters.$(file.patterns.systemverilog)=$(word.chars.systemverilog)

statement.lookback.$(file.patterns.systemverilog)=20
statement.end.$(file.patterns.systemverilog)=10 ;
block.start.$(file.patterns.systemverilog)=5 begin case casex casez
block.end.$(file.patterns.systemverilog)=5 begin end endcase
statement.indent.$(file.patterns.systemverilog)=5 always else for if while

indent.maintain.$(file.patterns.systemverilog)= 0

preprocessor.symbol.$(file.patterns.systemverilog)=`
preprocessor.start.$(file.patterns.systemverilog)=ifdef ifndef
preprocessor.middle.$(file.patterns.systemverilog)=else
preprocessor.end.$(file.patterns.systemverilog)=endif

# Taken from the SystemVerilog IEEE Std 1800-2005 Annex B
keywords.$(file.patterns.systemverilog)=\
alias always always_comb always_ff always_latch and assert assign assume \
automatic before begin bind bins binsof bit break buf bufif0 bufif1 byte case \
casex casez cell chandle class clocking cmos config const constraint context \
continue cover covergroup coverpoint cross deassign default defparam design \
disable dist do edge else end endcase endclass endclocking endconfig \
endfunction endgenerate endgroup endinterface endmodule endpackage \
endprimitive endprogram endproperty endspecify endsequence endtable endtask \
enum event expect export extends extern final first_match for force foreach \
forever fork forkjoin function generate genvar highz0 highz1 if iff ifnone \
ignore_bins illegal_bins import incdir include initial inout input inside \
instance int integer interface intersect join join_any join_none large liblist \
library local localparam logic longint macromodule matches medium modport \
module nand negedge new nmos nor noshowcancelled not notif0 notif1 null or \
output package packed parameter pmos posedge primitive priority program \
property protected pull0 pull1 pulldown pullup pulsestyle_onevent \
pulsestyle_ondetect pure rand randc randcase randsequence rcmos real realtime \
ref reg release repeat return rnmos rpmos rtran rtranif0 rtranif1 scalared \
sequence shortint shortreal showcancelled signed small solve specify specparam \
static string strong0 strong1 struct super supply0 supply1 table tagged task \
this throughout time timeprecision timeunit tran tranif0 tranif1 tri tri0 tri1 \
triand trior trireg type typedef union unique unsigned use uwire var vectored \
virtual void wait wait_order wand weak0 weak1 while wildcard wire with within \
wor xnor xor

# Secondary keywords and identifiers
keywords2.$(file.patterns.systemverilog)=

# System Tasks
keywords3.$(file.patterns.systemverilog)=\
$acos $acosh $asin $asinh $assertfailoff $assertfailon $assertkill \
$assertnonvacuouson $assertoff $asserton $assertpassoff $assertpasson \
$assertvacuousoff $async$and$array $async$and$plane $async$nand$array \
$async$nand$plane $async$nor$array $async$nor$plane $async$or$array \
$async$or$plane $atan $atan2 $atanh $bits $bitstoreal $bitstoshortreal $cast \
$ceil $changed $changed_gclk $changing_gclk $clog2 $cos $cosh $countdrivers \
$countones $coverage_control $coverage_get $coverage_get_max $coverage_merge \
$coverage_save $dimensions $display $displayb $displayh $displayo \
$dist_chi_square $dist_erlang $dist_exponential $dist_normal $dist_poisson \
$dist_t $dist_uniform $dumpall $dumpfile $dumpflush $dumplimit $dumpoff \
$dumpon $dumpports $dumpportsall $dumpportsflush $dumpportslimit $dumpportsoff \
$dumpportson $dumpvars $error $exit $exp $falling_gclk $fatal $fclose \
$fdisplay $fdisplayb $fdisplayf $fdisplayh $fdisplayo $fell $fell_gclk $feof \
$ferror $fflush $fgetc $fgets $finish $floor $fmonitor $fmonitorb $fmonitorf \
$fmonitorh $fmonitoro $fopen $fread $fscanf $fseek $fsscanf $fstrobe $fstrobeb \
$fstrobebb $fstrobef $fstrobeh $fstrobeo $ftel $ftell $fullskew $future_gclk \
$fwrite $fwriteb $fwritef $fwriteh $fwriteo $get_coverage $getpattern $high \
$history $hold $hypot $increment $incsave $info $input $isunbounded $isunknown \
$itor $key $left $list $ln $load_coverage_db $log $log10 $low $monitor \
$monitorb $monitorh $monitoro $monitoroff $monitoron $nochange $nokey $nolog \
$onehot $onehot0 $past $past_gclk $period $pow $printtimescale $q_add $q_exam \
$q_full $q_initialize $q_remove $random $readmemb $readmemh $realtime \
$realtobits $recovery $recrem $removal $reset $reset_count $reset_value \
$restart $rewind $right $rising_gclk $root $rose $rose_gclk $rtoi $sampled \
$save $scale $scope $sdf_annotate $set_coverage_db_name $setup $setuphold \
$sformat $sformatf $shortrealtobits $showscopes $showvariables $showvars \
$signed $sin $sinh $size $skew $sqrt $sreadmemb $sreadmemh $sscanf $stable \
$stable_gclk $steady_gclk $stime $stop $strobe $strobeb $strobeh $strobeo \
$swrite $swriteb $swriteh $swriteo $sync$and$array $sync$and$plane \
$sync$nand$array $sync$nand$plane $sync$nor$array $sync$nor$plane \
$sync$or$array $sync$or$plane $system $tan $tanh $test$plusargs $time \
$timeformat $timeskew $typename $ungetc $unit $unpacked_dimensions $unsigned \
$urandom $urandom_range $value$plusargs $warning $width $write $writeb $writeh \
$writememb $writememh $writeo

# User defined tasks and identifiers
keywords4.$(file.patterns.systemverilog)=
# comment keyword
keywords5.$(file.patterns.systemverilog)= synopsys parallel_case infer_mux TODO


# Verilog styles


# Turn on port styling features
lexer.verilog.portstyling=1
# Turn on treatment of all uppercase identifiers as user-defined keywords
lexer.verilog.allupperkeywords=1

# Support for colorizing inactive code due to preprocessor directives
lexer.verilog.track.preprocessor=1
lexer.verilog.update.preprocessor=1

# Inactive states are 64 greater than their active counterparts


# Braces are only matched in operator style
braces.verilog.style=10




###############################################################################
# From vhdl.properties
# Define SciTE settings for vhdl files.

# VHDL files
file.patterns.vhdl=*.vhd;*.vhdl
filter.vhdl=VHDL (vhd vhdl)|$(file.patterns.vhdl)|

*filter.vhdl=$(filter.vhdl)

lexer.$(file.patterns.vhdl)=vhdl

*language.vhdl=VHDL|vhd||

word.chars.vhdl=$(chars.alpha)$(chars.numeric)_
word.characters.$(file.patterns.vhdl)=$(word.chars.vhdl)

#calltip.vhdl.word.characters=$(chars.alpha)$(chars.numeric)_

comment.block.vhdl=--
#comment.block.at.line.start.vhdl=1
#comment.stream.start.vhdl=/*
#comment.stream.end.vhdl=*/
#comment.box.start.vhdl=/*
#comment.box.middle.vhdl= *
#comment.box.end.vhdl= */

#~ fold.at.Begin=1
#~ fold.at.Parenthese=1

#statement.lookback.$(file.patterns.vhdl)=20
#block.start.$(file.patterns.vhdl)=5 begin
#block.end.$(file.patterns.vhdl)=5 end
#statement.indent.$(file.patterns.vhdl)=5 always case casex casez else for if while \
#module function task

indent.maintain.$(file.patterns.vhdl)=1;


keywords.$(file.patterns.vhdl)=access after alias all architecture array assert attribute begin block \
body buffer bus case component configuration constant disconnect downto else elsif end entity exit file \
for function generate generic group guarded if impure in inertial inout is label library linkage literal \
loop map new next null of on open others out package port postponed procedure process pure range record \
register reject report return select severity shared signal subtype then to transport type unaffected \
units until use variable wait when while with

keywords2.$(file.patterns.vhdl)=                                                                            \
 abs and mod nand nor not or rem rol ror sla sll sra srl xnor xor

keywords3.$(file.patterns.vhdl)=                                                                            \
 left right low high ascending image value pos val succ pred leftof rightof base range reverse_range        \
 length delayed stable quiet transaction event active last_event last_active last_value driving             \
 driving_value simple_name path_name instance_name

keywords4.$(file.patterns.vhdl)=                                                                            \
 now readline read writeline write endfile resolved to_bit to_bitvector to_stdulogic to_stdlogicvector      \
 to_stdulogicvector to_x01 to_x01z to_UX01 rising_edge falling_edge is_x shift_left shift_right rotate_left \
 rotate_right resize to_integer to_unsigned to_signed std_match to_01

keywords5.$(file.patterns.vhdl)=                                                                            \
 std ieee work standard textio std_logic_1164 std_logic_arith std_logic_misc std_logic_signed               \
 std_logic_textio std_logic_unsigned numeric_bit numeric_std math_complex math_real vital_primitives        \
 vital_timing

keywords6.$(file.patterns.vhdl)=                                                                            \
 boolean bit character severity_level integer real time delay_length natural positive string bit_vector     \
 file_open_kind file_open_status line text side width std_ulogic std_ulogic_vector std_logic                \
 std_logic_vector X01 X01Z UX01 UX01Z unsigned signed

# vhdl styles

# Braces are only matched in operator style
braces.vhdl.style=5



###############################################################################
# From yaml.properties
# Define SciTE settings for YAML files.

# associate YAML file patter with the YAML lexer
file.patterns.yaml=*.yaml;*.yml
filter.yaml=YAML (yaml)|$(file.patterns.yaml)|
*filter.yaml=$(filter.yaml)
lexer.$(file.patterns.yaml)=yaml
*language.yaml=YAML|yaml||

# YAML requires spaces for tabs
tabsize.$(file.patterns.yaml)=2
indent.size.$(file.patterns.yaml)=2
use.tabs.$(file.patterns.yaml)=0

# YAML comment character
comment.block.yaml=#~

# YAML convertible values
keywords.$(file.patterns.yaml)=true false yes no

# YAML font styles





###############################################################################
# Style for COBOL from file cobol.properties

# Note: all non-comment fonts are forced to monospace
	style.COBOL.0=$(style.anjuta.normal)
# Line comment
	style.COBOL.2=$(style.anjuta.comment)
# Doc comment
	style.COBOL.3=$(style.anjuta.comment)
# Number
	style.COBOL.4=$(style.anjuta.number)
# Keyword (A)
	style.COBOL.5=$(style.anjuta.keyword)
# String
	style.COBOL.6=$(style.anjuta.string)
# Character
	style.COBOL.7=$(style.anjuta.char)
# Extended keyword
	style.COBOL.8=$(style.anjuta.localkeyword)
# Preprocessor
	style.COBOL.9=$(style.anjuta.preprocessor)
# Operators
	style.COBOL.10=$(style.anjuta.operator)
# Identifier
	style.COBOL.11=$(style.anjuta.identifier)
# Keyword (B)
	style.COBOL.16=$(style.anjuta.function)



###############################################################################
# Style for TACL from file tacl.properties

# 11,Identifier|16,Label|
	style.TACL.0=$(style.anjuta.normal)
# Comment
	style.TACL.1=$(style.anjuta.comment)
# Line comment
	style.TACL.2=$(style.anjuta.comment)
# Doc comment
	style.TACL.3=$(style.anjuta.comment)
# Number
	style.TACL.4=$(style.anjuta.number)
# Builtin
	style.TACL.5=$(style.anjuta.keyword)
# String
	style.TACL.6=$(style.anjuta.string)
# Character
	style.TACL.7=$(style.anjuta.char)
# Command
	style.TACL.8=$(style.anjuta.localkeyword)
# Preprocessor
	style.TACL.9=$(style.anjuta.preprocessor)
# Operators
	style.TACL.10=$(style.anjuta.operator)
# Identifier
	style.TACL.11=$(style.anjuta.identifier)
# Label
	style.TACL.16=$(style.anjuta.function)



###############################################################################
# Style for TAL from file tal.properties

# 11,Identifier
	style.TAL.0=$(style.anjuta.normal)
# Comment
	style.TAL.1=$(style.anjuta.comment)
# Line comment
	style.TAL.2=$(style.anjuta.comment)
# Doc comment
	style.TAL.3=$(style.anjuta.comment)
# Number
	style.TAL.4=$(style.anjuta.number)
# Keyword
	style.TAL.5=$(style.anjuta.keyword)
# String
	style.TAL.6=$(style.anjuta.string)
# Character
	style.TAL.7=$(style.anjuta.char)
# Unreserved keyword
	style.TAL.8=$(style.anjuta.localkeyword)
# Preprocessor
	style.TAL.9=$(style.anjuta.preprocessor)
# Operators
	style.TAL.10=$(style.anjuta.operator)
# Identifier
	style.TAL.11=$(style.anjuta.identifier)



###############################################################################
# Style for abaqus from file abaqus.properties

# Default
	style.abaqus.0=$(style.anjuta.normal)
# Comment
	style.abaqus.1=$(style.anjuta.comment)
# Comment-blocks
	style.abaqus.2=$(style.anjuta.comment)
# Number
	style.abaqus.3=$(style.anjuta.number)
# Quoted string
	style.abaqus.4=$(style.anjuta.char)
# Ansys operator
	style.abaqus.5=$(style.anjuta.operator)
# Ansys word
	style.abaqus.6=$(style.anjuta.keyword)
# Ansys processor
	style.abaqus.7=$(style.anjuta.preprocessor)
# Ansys command
	style.abaqus.8=$(style.anjuta.localkeyword)
# Ansys slashcommand
	style.abaqus.9=$(style.anjuta.syskeyword)
# Ansys starcommand
	style.abaqus.10=$(style.anjuta.syskeyword)
# Ansys argument
	style.abaqus.11=$(style.anjuta.identifier)
# Ansys function
	style.abaqus.12=$(style.anjuta.function)



###############################################################################
# Style for ada from file ada.properties

# Default
	style.ada.0=$(style.anjuta.whitespace)
# Keyword
	style.ada.1=$(style.anjuta.keyword)
# Number
	style.ada.3=$(style.anjuta.number)
# Operators (delimiters)
	style.ada.4=$(style.anjuta.operator)
# Character
	style.ada.5=$(style.anjuta.char)
# End of line where character is not closed
	style.ada.6=$(style.anjuta.unclosed)
# String
	style.ada.7=$(style.anjuta.string)
# End of line where string is not closed
	style.ada.8=$(style.anjuta.unclosed)
# Label
	style.ada.9=$(style.anjuta.function)
# Comment
	style.ada.10=$(style.anjuta.comment)
# Illegal token
	style.ada.11=$(style.anjuta.error)



###############################################################################
# Style for as from file asm.properties

#
	style.as.1=$(style.anjuta.comment)
#
	style.as.2=$(style.anjuta.number)
#
	style.as.3=$(style.anjuta.string)
#
	style.as.4=$(style.anjuta.operator)
#
	style.as.5=$(style.anjuta.identifier)
#
	style.as.6=$(style.anjuta.keyword)
#
	style.as.7=$(style.anjuta.localkeyword)
#
	style.as.8=$(style.anjuta.identifier)
#
	style.as.9=$(style.anjuta.preprocessor)
#
	style.as.10=$(style.anjuta.preprocessor)
#
	style.as.11=$(style.anjuta.comment)
#
	style.as.12=$(style.anjuta.char)
#
	style.as.13=$(style.anjuta.unclosed)
#
	style.as.14=$(style.anjuta.syskeyword)
#
	style.as.15=$(style.anjuta.preprocessor)



###############################################################################
# Style for asm from file asm.properties

#
	style.asm.0=$(style.anjuta.normal)
# Comment
	style.asm.1=$(style.anjuta.comment)
# Number
	style.asm.2=$(style.anjuta.number)
# String
	style.asm.3=$(style.anjuta.string)
# Operator
	style.asm.4=$(style.anjuta.operator)
# CPU instruction
	style.asm.6=$(style.anjuta.keyword)
# FPU instruction
	style.asm.7=$(style.anjuta.localkeyword)
# Register
	style.asm.8=$(style.anjuta.identifier)
# assembler Directive
	style.asm.9=$(style.anjuta.preprocessor)
# assembler Directive Operand
	style.asm.10=$(style.anjuta.preprocessor)
# Comment block (GNU as /*...*/ syntax, unimplemented)
	style.asm.11=$(style.anjuta.comment)
# Character/String (single quote) (also character prefix in GNU as)
	style.asm.12=$(style.anjuta.char)
# End of line where string is not closed
	style.asm.13=$(style.anjuta.unclosed)
# Extended instructions
	style.asm.14=$(style.anjuta.syskeyword)
# Comment directive
	style.asm.15=$(style.anjuta.preprocessor)



###############################################################################
# Style for asn1 from file asn1.properties

# Default
	style.asn1.0=$(style.anjuta.normal)
# Comment
	style.asn1.1=$(style.anjuta.comment)
# Identifiers
	style.asn1.2=$(style.anjuta.identifier)
# Double quoted string
	style.asn1.3=$(style.anjuta.string)
# Numeric OID definition
	style.asn1.4=$(style.anjuta.definition)
# Non OID numbers
	style.asn1.5=$(style.anjuta.number)
# Keywords
	style.asn1.6=$(style.anjuta.keyword)
# Attributes
	style.asn1.7=$(style.anjuta.attribute)
# Descriptors
	style.asn1.8=$(style.anjuta.localkeyword)
# Types
	style.asn1.9=$(style.anjuta.syskeyword)
# Operators
	style.asn1.10=$(style.anjuta.operator)



###############################################################################
# Style for au3 from file au3.properties

# White space
	style.au3.0=$(style.anjuta.whitespace)
# Comment block
	style.au3.1=$(style.anjuta.comment)
# Comment stream
	style.au3.2=$(style.anjuta.comment)
# Number
	style.au3.3=$(style.anjuta.number)
# Function
	style.au3.4=$(style.anjuta.function)
# Keyword
	style.au3.5=$(style.anjuta.keyword)
# Macro
	style.au3.6=$(style.anjuta.localkeyword)
# String
	style.au3.7=$(style.anjuta.string)
# Operator
	style.au3.8=$(style.anjuta.operator)
# Variable
	style.au3.9=$(style.anjuta.identifier)
# Send key
	style.au3.10=$(style.anjuta.char)
# Pre-Processor
	style.au3.11=$(style.anjuta.preprocessor)
# Special
	style.au3.12=$(style.anjuta.attribute)
# Abbrev-Expand
	style.au3.13=$(style.anjuta.regex)
# COM Object
	style.au3.14=$(style.anjuta.attribute)
# Standard UDF
	style.au3.15=$(style.anjuta.syskeyword)



###############################################################################
# Style for ave from file ave.properties

# White space: Visible only in View Whitespace mode (or if it has a back colour)
	style.ave.0=$(style.anjuta.whitespace)
# Comment
	style.ave.1=$(style.anjuta.comment)
# Number
	style.ave.2=$(style.anjuta.number)
# Keyword
	style.ave.3=$(style.anjuta.keyword)
# String
	style.ave.6=$(style.anjuta.string)
# Enumeration
	style.ave.7=$(style.anjuta.definition)
# End of line where string is not closed
	style.ave.8=$(style.anjuta.unclosed)
# Identifier (everything else...)
	style.ave.9=$(style.anjuta.identifier)
# Operators
	style.ave.10=$(style.anjuta.operator)
# SCE_AVE_WORD1 allocated but unused
	style.ave.11=$(style.anjuta.preprocessor)
# Other keywords (bozo test colors :-)
	style.ave.12=$(style.anjuta.localkeyword)
#
	style.ave.13=$(style.anjuta.syskeyword)
#
	style.ave.14=$(style.anjuta.keyword)
#
	style.ave.15=$(style.anjuta.keyword)
#
	style.ave.16=$(style.anjuta.keyword)



###############################################################################
# Style for avs from file avs.properties

# White space: Visible only in View Whitespace mode (or if it has a back colour)
	style.avs.0=$(style.anjuta.whitespace)
# Comment: /* */. Use fixed font to keep boxed comments as boxes
	style.avs.1=$(style.anjuta.comment)
# Comment: [* *]. Use fixed font to keep boxed comments as boxes
	style.avs.2=$(style.anjuta.comment)
# Line Comment: #. Proportionnal font is generally OK here
	style.avs.3=$(style.anjuta.comment)
# Number
	style.avs.4=$(style.anjuta.number)
# Operators
	style.avs.5=$(style.anjuta.operator)
# Double quoted string
	style.avs.7=$(style.anjuta.string)
# String with three double quotes
	style.avs.8=$(style.anjuta.regex)
# Keyword
	style.avs.9=$(style.anjuta.keyword)
# Filter
	style.avs.10=$(style.anjuta.localkeyword)
# Plugin
	style.avs.11=$(style.anjuta.syskeyword)
# Function
	style.avs.12=$(style.anjuta.function)
# Clip properties
	style.avs.13=$(style.anjuta.attribute)
# User defined
	style.avs.14=$(style.anjuta.extrakeyword)



###############################################################################
# Style for baan from file baan.properties

# White space
	style.baan.0=$(style.anjuta.whitespace)
# Comment
	style.baan.1=$(style.anjuta.comment)
# Doc comment
	style.baan.2=$(style.anjuta.comment)
# Number
	style.baan.3=$(style.anjuta.number)
# Keyword ~ Reserved Words
	style.baan.4=$(style.anjuta.keyword)
# Double quoted string
	style.baan.5=$(style.anjuta.string)
# Preprocessor
	style.baan.6=$(style.anjuta.preprocessor)
# Operators
	style.baan.7=$(style.anjuta.operator)
# Identifiers
	style.baan.8=$(style.anjuta.identifier)
# End of line where string is not closed
	style.baan.9=$(style.anjuta.unclosed)
# Keywords2 ~ Functions
	style.baan.10=$(style.anjuta.localkeyword)
# Keywords3 ~ Functions Abridged
	style.baan.11=$(style.anjuta.localkeyword)
# Keywords4 ~ Sections
	style.baan.12=$(style.anjuta.definition)
# Keywords5 ~ Predefined Variables
	style.baan.13=$(style.anjuta.char)
# Keywords6 ~ Attributes Predefined
	style.baan.14=$(style.anjuta.attribute)
# Keywords7
	style.baan.15=$(style.anjuta.extrakeyword)
# Keywords8
	style.baan.16=$(style.anjuta.extrakeyword)
# Keywords9
	style.baan.17=$(style.anjuta.extrakeyword)
# TableDef
	style.baan.18=$(style.anjuta.definition)
# TableSQL
	style.baan.19=$(style.anjuta.definition)
# Functions
	style.baan.20=$(style.anjuta.function)
# DomainDef
	style.baan.21=$(style.anjuta.function)
# FunctionDef
	style.baan.22=$(style.anjuta.function)
# ObjectDef used in #include and #pragma used dll
	style.baan.23=$(style.anjuta.preprocessor)
# DefineDef used in #define 
	style.baan.24=$(style.anjuta.preprocessor)



###############################################################################
# Style for bash from file perl.properties

# White space
	style.bash.0=$(style.anjuta.whitespace)
# Error
	style.bash.1=$(style.anjuta.error)
# Comment
	style.bash.2=$(style.anjuta.comment)
# Number
	style.bash.3=$(style.anjuta.number)
# Keyword
	style.bash.4=$(style.anjuta.keyword)
# Double quoted string
	style.bash.5=$(style.anjuta.string)
# Single quoted string
	style.bash.6=$(style.anjuta.char)
# Operators
	style.bash.7=$(style.anjuta.operator)
# Identifiers (functions, etc.)
	style.bash.8=$(style.anjuta.function)
# Scalars: $var
	style.bash.9=$(style.anjuta.identifier)
# Parameter expansion: ${var}
	style.bash.10=$(style.anjuta.identifier)
# Back Ticks
	style.bash.11=$(style.anjuta.raw)
# Here-doc (delimiter)
	style.bash.12=$(style.anjuta.comment)
# Here-doc (single quoted, q)
	style.bash.13=$(style.anjuta.comment)



###############################################################################
# Style for batch from file others.properties

# Default
	style.batch.0=$(style.anjuta.normal)
# Comment (rem or ::)
	style.batch.1=$(style.anjuta.comment)
# Keywords
	style.batch.2=$(style.anjuta.keyword)
# Label (line beginning with ':')
	style.batch.3=$(style.anjuta.function)
# Hide command character ('@')
	style.batch.4=$(style.anjuta.preprocessor)
# External commands
	style.batch.5=$(style.anjuta.localkeyword)
# Variable: %%x (x is almost whatever, except space and %), %n (n in [0-9]), %EnvironmentVar%
	style.batch.6=$(style.anjuta.identifier)
# Operator: * ? < > |
	style.batch.7=$(style.anjuta.operator)



###############################################################################
# Style for blitzbasic from file blitzbasic.properties

# Default
	style.blitzbasic.0=$(style.anjuta.normal)
# Comment
	style.blitzbasic.1=$(style.anjuta.comment)
# Number
	style.blitzbasic.2=$(style.anjuta.number)
# Keyword1
	style.blitzbasic.3=$(style.anjuta.keyword)
# String
	style.blitzbasic.4=$(style.anjuta.string)
# Operator
	style.blitzbasic.6=$(style.anjuta.operator)
# Identifier
	style.blitzbasic.7=$(style.anjuta.identifier)
# Keyword2
	style.blitzbasic.10=$(style.anjuta.localkeyword)
# Keyword3
	style.blitzbasic.11=$(style.anjuta.syskeyword)
# Keyword4
	style.blitzbasic.12=$(style.anjuta.extrakeyword)
# Label
	style.blitzbasic.15=$(style.anjuta.function)
# Error
	style.blitzbasic.16=$(style.anjuta.error)
# HexNumber
	style.blitzbasic.17=$(style.anjuta.number)
# BinNumber
	style.blitzbasic.18=$(style.anjuta.number)



###############################################################################
# Style for bullant from file bullant.properties

# White space
	style.bullant.0=$(style.anjuta.whitespace)
# Comment
	style.bullant.1=$(style.anjuta.comment)
# Line Comment
	style.bullant.2=$(style.anjuta.comment)
# Doc comment
	style.bullant.3=$(style.anjuta.comment)
# Number
	style.bullant.4=$(style.anjuta.number)
# Keyword
	style.bullant.5=$(style.anjuta.keyword)
# Double quoted string
	style.bullant.6=$(style.anjuta.string)
# Single quoted string
	style.bullant.7=$(style.anjuta.char)
# Symbols
	style.bullant.8=$(style.anjuta.operator)
# Preprocessor
	style.bullant.9=$(style.anjuta.preprocessor)



###############################################################################
# Style for caml from file caml.properties

# White space
	style.caml.0=$(style.anjuta.whitespace)
#style.caml.2=
	style.caml.2=$(style.anjuta.definition)
# Keywords (builtin language-defined keywords)
	style.caml.3=$(style.anjuta.keyword)
#style.caml.4=
	style.caml.4=$(style.anjuta.localkeyword)
#style.caml.5=
	style.caml.5=$(style.anjuta.syskeyword)
# Linenum directive
	style.caml.6=$(style.anjuta.preprocessor)
# Operators
	style.caml.7=$(style.anjuta.operator)
# Number
	style.caml.8=$(style.anjuta.number)
# Single quoted string (character constant)
	style.caml.9=$(style.anjuta.char)
#style.caml.10=
	style.caml.10=$(style.anjuta.regex)
# Double quoted string (string constant)
	style.caml.11=$(style.anjuta.string)
# Comment (NOT nested)
	style.caml.12=$(style.anjuta.comment)
# Comment (SINGLY nested)
	style.caml.13=$(style.anjuta.comment)
# Comment (DOUBLY nested)
	style.caml.14=$(style.anjuta.comment)
# Comment (TRIPLY nested)
	style.caml.15=$(style.anjuta.comment)



###############################################################################
# Style for cmake from file cmake.properties

# Whitespace (SCE_CMAKE_DEFAULT)
	style.cmake.0=$(style.anjuta.whitespace)
# Comment (SCE_CMAKE_COMMENT)
	style.cmake.1=$(style.anjuta.comment)
# String double quote (SCE_CMAKE_STRINGDQ)
	style.cmake.2=$(style.anjuta.string)
# String left quote (SCE_CMAKE_STRINGLQ)
	style.cmake.3=$(style.anjuta.char)
# String right quote (SCE_CMAKE_STRINGRQ)
	style.cmake.4=$(style.anjuta.char)
# Function (SCE_CMAKE_COMMANDS)
	style.cmake.5=$(style.anjuta.function)
# Variable (SCE_CMAKE_ARGUMENTS)
	style.cmake.6=$(style.anjuta.identifier)
# Label (SCE_CMAKE_VARIABLE)
	style.cmake.7=$(style.anjuta.definition)
# User Defined (SCE_CMAKE_USERDEFINED)
	style.cmake.8=$(style.anjuta.extrakeyword)
# Section (SCE_CMAKE_WHILEDEF)
	style.cmake.9=$(style.anjuta.keyword)
# Sub section (SCE_CMAKE_FOREACHDEF)
	style.cmake.10=$(style.anjuta.localkeyword)
# If def (SCE_CMAKE_IFDEFINEDEF)
	style.cmake.11=$(style.anjuta.preprocessor)
# Macro def (SCE_CMAKE_MACRODEF)
	style.cmake.12=$(style.anjuta.preprocessor)
# Variable within string (SCE_CMAKE_STRINGVAR)
	style.cmake.13=$(style.anjuta.identifier)
# Numbers (SCE_CMAKE_NUMBER)
	style.cmake.14=$(style.anjuta.number)



###############################################################################
# Style for coffeescript from file coffeescript.properties

# White space
	style.coffeescript.0=$(style.anjuta.whitespace)
# SCE_COFFEESCRIPT_COMMENT allocated but unused
	style.coffeescript.1=$(style.anjuta.comment)
# Line Comment
	style.coffeescript.2=$(style.anjuta.comment)
# SCE_COFFEESCRIPT_COMMENTDOC allocated but unused
	style.coffeescript.3=$(style.anjuta.comment)
# Number
	style.coffeescript.4=$(style.anjuta.number)
# Keyword
	style.coffeescript.5=$(style.anjuta.keyword)
# Double quoted string
	style.coffeescript.6=$(style.anjuta.string)
# Single quoted string
	style.coffeescript.7=$(style.anjuta.char)
# SCE_COFFEESCRIPT_UUID allocated but unused
	style.coffeescript.8=$(style.anjuta.attribute)
# SCE_COFFEESCRIPT_PREPROCESSOR allocated but unused
	style.coffeescript.9=$(style.anjuta.preprocessor)
# Operators
	style.coffeescript.10=$(style.anjuta.operator)
# SCE_COFFEESCRIPT_STRINGEOL allocated but unused
	style.coffeescript.12=$(style.anjuta.string)
# SCE_COFFEESCRIPT_VERBATIM allocated but unused
	style.coffeescript.13=$(style.anjuta.string)
# Regular expressions
	style.coffeescript.14=$(style.anjuta.regex)
# SCE_COFFEESCRIPT_COMMENTLINEDOC allocated but unused
	style.coffeescript.15=$(style.anjuta.comment)
# Keywords2
	style.coffeescript.16=$(style.anjuta.localkeyword)
# SCE_COFFEESCRIPT_COMMENTDOCKEYWORD allocated but unused
	style.coffeescript.17=$(style.anjuta.comment)
# SCE_COFFEESCRIPT_COMMENTDOCKEYWORDERROR allocated but unused
	style.coffeescript.18=$(style.anjuta.comment)
# Global class
	style.coffeescript.19=$(style.anjuta.definition)
# SCE_COFFEESCRIPT_STRINGRAW allocated but unused
	style.coffeescript.20=$(style.anjuta.string)
# SCE_COFFEESCRIPT_TRIPLEVERBATIM allocated but unused
	style.coffeescript.21=$(style.anjuta.string)
# Comment block ###
	style.coffeescript.22=$(style.anjuta.comment)
# Verbose REGEX
	style.coffeescript.23=$(style.anjuta.regex)
# Verbose REGEX comment
	style.coffeescript.24=$(style.anjuta.comment)
# Iinstance property
	style.coffeescript.25=$(style.anjuta.attribute)



###############################################################################
# Style for conf from file conf.properties

# whitespace (SCE_CONF_DEFAULT)
	style.conf.0=$(style.anjuta.whitespace)
# Comment (SCE_CONF_COMMENT)
	style.conf.1=$(style.anjuta.comment)
# Number (SCE_CONF_NUMBER)
	style.conf.2=$(style.anjuta.number)
# Apache Runtime Directive (SCE_CONF_DIRECTIVE)
	style.conf.3=$(style.anjuta.preprocessor)
# extensions (like .gz, .tgz, .html) (SCE_CONF_EXTENSION)
	style.conf.4=$(style.anjuta.keyword)
# parameters for Apache Runtime directives (SCE_CONF_PARAMETER)
	style.conf.5=$(style.anjuta.localkeyword)
# Double quoted string (SCE_CONF_STRING)
	style.conf.6=$(style.anjuta.string)
# Operators (SCE_CONF_OPERATOR)
	style.conf.7=$(style.anjuta.operator)
# IP address (SCE_CONF_IP)
	style.conf.8=$(style.anjuta.number)
# identifier (SCE_CONF_IDENTIFIER)
	style.conf.9=$(style.anjuta.identifier)



###############################################################################
# Style for cpp from file cpp.properties

# White space
	style.cpp.0=$(style.anjuta.whitespace)
# Comment: /* */.
	style.cpp.1=$(style.anjuta.comment)
# Line Comment: //.
	style.cpp.2=$(style.anjuta.comment)
# Doc comment: block comments beginning with /** or /*!
	style.cpp.3=$(style.anjuta.comment)
# Number
	style.cpp.4=$(style.anjuta.number)
# Keyword
	style.cpp.5=$(style.anjuta.keyword)
# Double quoted string
	style.cpp.6=$(style.anjuta.string)
# Single quoted string
	style.cpp.7=$(style.anjuta.char)
# UUIDs (only in IDL)
	style.cpp.8=$(style.anjuta.identifier)
# Preprocessor
	style.cpp.9=$(style.anjuta.preprocessor)
# Operators
	style.cpp.10=$(style.anjuta.operator)
# End of line where string is not closed
	style.cpp.12=$(style.anjuta.unclosed)
# Verbatim strings for C#
	style.cpp.13=$(style.anjuta.raw)
# Regular expressions for JavaScript
	style.cpp.14=$(style.anjuta.regex)
# Doc Comment Line: line comments beginning with /// or //!.
	style.cpp.15=$(style.anjuta.comment)
# Keywords2
	style.cpp.16=$(style.anjuta.localkeyword)
# Comment keyword
	style.cpp.17=$(style.anjuta.comment)
# Comment keyword error
	style.cpp.18=$(style.anjuta.comment)
# Global class
	style.cpp.19=$(style.anjuta.syskeyword)
# Raw strings for C++0x
	style.cpp.20=$(style.anjuta.string)
# Triple-quoted strings for Vala
	style.cpp.21=$(style.anjuta.string)
# Hash-quoted strings for Pike
	style.cpp.22=$(style.anjuta.string)
# Preprocessor stream comment
	style.cpp.23=$(style.anjuta.preprocessor)
# Preprocessor stream doc comment
	style.cpp.24=$(style.anjuta.preprocessor)
# User defined literals
	style.cpp.25=$(style.anjuta.number)
# Task Marker
	style.cpp.26=$(style.anjuta.attribute)
# Escape sequence
	style.cpp.27=$(style.anjuta.string)
# White space
	style.cpp.64=$(style.anjuta.whitespace)
# Comment: /* */.
	style.cpp.65=$(style.anjuta.comment)
# Line Comment: //.
	style.cpp.66=$(style.anjuta.comment)
# Doc comment: block comments beginning with /** or /*!
	style.cpp.67=$(style.anjuta.comment)
# Number
	style.cpp.68=$(style.anjuta.number)
# Keyword
	style.cpp.69=$(style.anjuta.keyword)
# Double quoted string
	style.cpp.70=$(style.anjuta.string)
# Single quoted string
	style.cpp.71=$(style.anjuta.char)
# UUIDs (only in IDL)
	style.cpp.72=$(style.anjuta.identifier)
# Preprocessor
	style.cpp.73=$(style.anjuta.preprocessor)
# Operators
	style.cpp.74=$(style.anjuta.operator)
# Identifiers
	style.cpp.75=$(style.anjuta.identifier)
# End of line where string is not closed
	style.cpp.76=$(style.anjuta.unclosed)
# Verbatim strings for C#
	style.cpp.77=$(style.anjuta.string)
# Regular expressions for JavaScript
	style.cpp.78=$(style.anjuta.regex)
# Doc Comment Line: line comments beginning with /// or //!.
	style.cpp.79=$(style.anjuta.comment)
# Keywords2
	style.cpp.80=$(style.anjuta.keyword)
# Comment keyword
	style.cpp.81=$(style.anjuta.comment)
# Comment keyword error
	style.cpp.82=$(style.anjuta.comment)
# Raw strings for C++0x
	style.cpp.84=$(style.anjuta.string)
# Triple-quoted strings for Vala
	style.cpp.85=$(style.anjuta.string)
# Hash-quoted strings for Pike
	style.cpp.86=$(style.anjuta.string)
# Preprocessor stream comment
	style.cpp.87=$(style.anjuta.preprocessor)
# Preprocessor stream doc comment
	style.cpp.88=$(style.anjuta.preprocessor)
# User defined literals
	style.cpp.89=$(style.anjuta.number)
# Task Marker
	style.cpp.90=$(style.anjuta.attribute)



###############################################################################
# Style for csound from file csound.properties

# Default
	style.csound.0=$(style.anjuta.normal)
# Comment
	style.csound.1=$(style.anjuta.comment)
# Number
	style.csound.2=$(style.anjuta.number)
# Operator
	style.csound.3=$(style.anjuta.operator)
# Instr
	style.csound.4=$(style.anjuta.keyword)
# Opcode
	style.csound.6=$(style.anjuta.localkeyword)
# Header statement
	style.csound.7=$(style.anjuta.syskeyword)
# User keywords
	style.csound.8=$(style.anjuta.extrakeyword)
# comment block
	style.csound.9=$(style.anjuta.comment)
# Parameter
	style.csound.10=$(style.anjuta.attribute)
# A-Rate variable
	style.csound.11=$(style.anjuta.identifier)
# K-Rate variable
	style.csound.12=$(style.anjuta.identifier)
# I-Rate variable
	style.csound.13=$(style.anjuta.identifier)
# Global variable
	style.csound.14=$(style.anjuta.identifier)
# End of line where string is not closed
	style.csound.15=$(style.anjuta.identifier)



###############################################################################
# Style for css from file css.properties

# White space: Visible only in View Whitespace mode (or if it has a back colour)
	style.css.0=$(style.anjuta.whitespace)
# Selector (HTML tag)
	style.css.1=$(style.anjuta.keyword)
# Pseudo class (HtmlTag:pseudoClass) see "keywords2" above
	style.css.3=$(style.anjuta.localkeyword)
# Unknown Pseudo class
	style.css.4=$(style.anjuta.syskeyword)
# Operator
	style.css.5=$(style.anjuta.operator)
# CSS1 Property, see keywords
	style.css.6=$(style.anjuta.attribute)
# Unknown Property
	style.css.7=$(style.anjuta.attribute)
# Value
	style.css.8=$(style.anjuta.string)
# Comment
	style.css.9=$(style.anjuta.comment)
# ID selector (#IdSel)
	style.css.10=$(style.anjuta.number)
# "!important"
	style.css.11=$(style.anjuta.error)
# At-rule (@) except @media
	style.css.12=$(style.anjuta.definition)
# Double quoted strings
	style.css.13=$(style.anjuta.string)
# Single quoted strings
	style.css.14=$(style.anjuta.char)
# CSS2 Property, see keywords3
	style.css.15=$(style.anjuta.attribute)
# Attribute selection ([att='val'])
	style.css.16=$(style.anjuta.attribute)
# CSS3 Property, see keywords4
	style.css.17=$(style.anjuta.syskeyword)
# Pseudo elements, see keywords5
	style.css.18=$(style.anjuta.syskeyword)
# Other CSS Property, see keywords6
	style.css.19=$(style.anjuta.syskeyword)
# Other Pseudoclass, see keywords7
	style.css.20=$(style.anjuta.localkeyword)
# Other Pseudoelement, see keywords8
	style.css.21=$(style.anjuta.localkeyword)
# "@media"
	style.css.22=$(style.anjuta.identifier)
# Variable in SCSS, LESS, or HSS
	style.css.23=$(style.anjuta.identifier)



###############################################################################
# Style for d from file d.properties

# 20, 21, 22 keywords 5, 6, and 7
	style.d.0=$(style.anjuta.whitespace)
#
	style.d.1=$(style.anjuta.comment)
#
	style.d.2=$(style.anjuta.comment)
#
	style.d.3=$(style.anjuta.comment)
#
	style.d.4=$(style.anjuta.comment)
#
	style.d.5=$(style.anjuta.number)
#
	style.d.6=$(style.anjuta.keyword)
#
	style.d.7=$(style.anjuta.localkeyword)
#
	style.d.8=$(style.anjuta.syskeyword)
#
	style.d.9=$(style.anjuta.extrakeyword)
#
	style.d.10=$(style.anjuta.string)
#
	style.d.11=$(style.anjuta.unclosed)
#
	style.d.12=$(style.anjuta.char)
#
	style.d.13=$(style.anjuta.operator)
#
	style.d.15=$(style.anjuta.comment)
#
	style.d.16=$(style.anjuta.comment)
#
	style.d.17=$(style.anjuta.comment)
#
	style.d.18=$(style.anjuta.string)
#
	style.d.19=$(style.anjuta.string)
#
	style.d.20=$(style.anjuta.keyword)
#
	style.d.21=$(style.anjuta.keyword)
#
	style.d.22=$(style.anjuta.keyword)



###############################################################################
# Style for diff from file others.properties

# Default
	style.diff.0=$(style.anjuta.normal)
# Comment (part before "diff ..." or "--- ..." and , Only in ..., Binary file...)
	style.diff.1=$(style.anjuta.comment)
# Command (diff ...)
	style.diff.2=$(style.anjuta.keyword)
# Source file (--- ...) and Destination file (+++ ...)
	style.diff.3=$(style.anjuta.raw)
# Position setting (@@ ...)
	style.diff.4=$(style.anjuta.number)
# Line removal (-...)
	style.diff.5=$(style.anjuta.localkeyword)
# Line addition (+...)
	style.diff.6=$(style.anjuta.syskeyword)
# Line change (!...)
	style.diff.7=$(style.anjuta.extrakeyword)



###############################################################################
# Style for ecl from file ecl.properties

#
	style.ecl.0=$(style.anjuta.normal)
#
	style.ecl.1=$(style.anjuta.comment)
#
	style.ecl.2=$(style.anjuta.comment)
#
	style.ecl.3=$(style.anjuta.number)
#
	style.ecl.4=$(style.anjuta.string)
#
	style.ecl.5=$(style.anjuta.definition)
#
	style.ecl.6=$(style.anjuta.operator)
#
	style.ecl.7=$(style.anjuta.char)
#
	style.ecl.8=$(style.anjuta.attribute)
#
	style.ecl.9=$(style.anjuta.preprocessor)
#
	style.ecl.10=$(style.anjuta.error)
#
	style.ecl.11=$(style.anjuta.identifier)
#
	style.ecl.12=$(style.anjuta.unclosed)
#
	style.ecl.13=$(style.anjuta.string)
#
	style.ecl.14=$(style.anjuta.regex)
#
	style.ecl.15=$(style.anjuta.comment)
#
	style.ecl.16=$(style.anjuta.keyword)
#
	style.ecl.17=$(style.anjuta.comment)
#
	style.ecl.18=$(style.anjuta.comment)
#
	style.ecl.19=$(style.anjuta.localkeyword)
#
	style.ecl.20=$(style.anjuta.syskeyword)
#
	style.ecl.21=$(style.anjuta.extrakeyword)
#
	style.ecl.22=$(style.anjuta.function)
#
	style.ecl.23=$(style.anjuta.comment)
#
	style.ecl.24=$(style.anjuta.attribute)
#
	style.ecl.25=$(style.anjuta.attribute)
#
	style.ecl.26=$(style.anjuta.attribute)
#
	style.ecl.27=$(style.anjuta.attribute)



###############################################################################
# Style for eiffel from file eiffel.properties

# Default
	style.eiffel.0=$(style.anjuta.whitespace)
# Line comment
	style.eiffel.1=$(style.anjuta.comment)
# Number
	style.eiffel.2=$(style.anjuta.number)
# Keyword
	style.eiffel.3=$(style.anjuta.keyword)
# String
	style.eiffel.4=$(style.anjuta.string)
# Character
	style.eiffel.5=$(style.anjuta.char)
# Operators
	style.eiffel.6=$(style.anjuta.operator)
# End of line where string is not closed
	style.eiffel.8=$(style.anjuta.unclosed)



###############################################################################
# Style for eiffelkw from file eiffel.properties

#
	style.eiffelkw.0=$(style.anjuta.whitespace)
#
	style.eiffelkw.1=$(style.anjuta.comment)
#
	style.eiffelkw.2=$(style.anjuta.number)
#
	style.eiffelkw.3=$(style.anjuta.keyword)
#
	style.eiffelkw.4=$(style.anjuta.string)
#
	style.eiffelkw.5=$(style.anjuta.char)
#
	style.eiffelkw.6=$(style.anjuta.operator)
#
	style.eiffelkw.7=$(style.anjuta.identifier)
#
	style.eiffelkw.8=$(style.anjuta.unclosed)



###############################################################################
# Style for erlang from file erlang.properties

# Default style
	style.erlang.0=$(style.anjuta.whitespace)
# Default comment
	style.erlang.1=$(style.anjuta.comment)
# Variable
	style.erlang.2=$(style.anjuta.identifier)
# Number
	style.erlang.3=$(style.anjuta.number)
# Reserved words
	style.erlang.4=$(style.anjuta.keyword)
# String
	style.erlang.5=$(style.anjuta.string)
# Operators
	style.erlang.6=$(style.anjuta.operator)
# Atom
	style.erlang.7=$(style.anjuta.attribute)
# Function name
	style.erlang.8=$(style.anjuta.function)
# Character
	style.erlang.9=$(style.anjuta.char)
# Macro
	style.erlang.10=$(style.anjuta.preprocessor)
# Record
	style.erlang.11=$(style.anjuta.definition)
# Preprocessor
	style.erlang.12=$(style.anjuta.operator)
# Node name
	style.erlang.13=$(style.anjuta.identifier)
# Function comment
	style.erlang.14=$(style.anjuta.comment)
# Module comment
	style.erlang.15=$(style.anjuta.comment)
# Documentation helper in comment
	style.erlang.16=$(style.anjuta.comment)
# Documentation macro in comment
	style.erlang.17=$(style.anjuta.comment)
# Atom quoted
	style.erlang.18=$(style.anjuta.attribute)
# Macro quoted
	style.erlang.19=$(style.anjuta.preprocessor)
# Record quoted
	style.erlang.20=$(style.anjuta.definition)
# Node name quoted
	style.erlang.21=$(style.anjuta.identifier)
# Built-in functions
	style.erlang.22=$(style.anjuta.syskeyword)
# Module name
	style.erlang.23=$(style.anjuta.definition)
# Module attributes
	style.erlang.24=$(style.anjuta.definition)
# Unknown: error
	style.erlang.31=$(style.anjuta.error)



###############################################################################
# Style for errorlist from file others.properties

# Default
	style.errorlist.0=$(style.anjuta.error)
# python Error
	style.errorlist.1=$(style.anjuta.error)
# gcc Error
	style.errorlist.2=$(style.anjuta.error)
# Microsoft Error
	style.errorlist.3=$(style.anjuta.error)
# command or return status
	style.errorlist.4=$(style.anjuta.number)
# Borland error and warning messages
	style.errorlist.5=$(style.anjuta.error)
# perl error and warning messages
	style.errorlist.6=$(style.anjuta.error)
# .NET tracebacks
	style.errorlist.7=$(style.anjuta.error)
# Lua error and warning messages
	style.errorlist.8=$(style.anjuta.error)
# ctags
	style.errorlist.9=$(style.anjuta.error)
# diff changed !
	style.errorlist.10=$(style.anjuta.extrakeyword)
# diff addition +
	style.errorlist.11=$(style.anjuta.syskeyword)
# diff deletion -
	style.errorlist.12=$(style.anjuta.localkeyword)
# diff message ---
	style.errorlist.13=$(style.anjuta.raw)
# PHP error
	style.errorlist.14=$(style.anjuta.error)
# Essential Lahey Fortran 90 error
	style.errorlist.15=$(style.anjuta.error)
# Intel Fortran Compiler error
	style.errorlist.16=$(style.anjuta.error)
# Intel Fortran Compiler v8.0 error/warning
	style.errorlist.17=$(style.anjuta.error)
# Absoft Pro Fortran 90/95 v8.2 error or warning
	style.errorlist.18=$(style.anjuta.error)
# HTML Tidy
	style.errorlist.19=$(style.anjuta.error)
# Java runtime stack trace
	style.errorlist.20=$(style.anjuta.error)
# Text matched with find in files and message part of GCC errors
	style.errorlist.21=$(style.anjuta.normal)
# GCC showing include path to following error
	style.errorlist.22=$(style.anjuta.error)
# Escape sequence
	style.errorlist.23=$(style.anjuta.string)
# Escape sequence unknown
	style.errorlist.24=$(style.anjuta.string)
# Basic colours
	style.errorlist.40=fore:#000000,$(error.background)
#
	style.errorlist.41=fore:#800000,$(error.background)
#
	style.errorlist.42=fore:#008000,$(error.background)
#
	style.errorlist.43=fore:#808000,$(error.background)
#
	style.errorlist.44=fore:#000080,$(error.background)
#
	style.errorlist.45=fore:#800080,$(error.background)
#
	style.errorlist.46=fore:#008080,$(error.background)
#
	style.errorlist.47=fore:#A0A0A0,$(error.background)
# Intense colours
	style.errorlist.48=fore:#000000,bold,$(error.background)
#
	style.errorlist.49=fore:#800000,bold,$(error.background)
#
	style.errorlist.50=fore:#008000,bold,$(error.background)
#
	style.errorlist.51=fore:#808000,bold,$(error.background)
#
	style.errorlist.52=fore:#000080,bold,$(error.background)
#
	style.errorlist.53=fore:#800080,bold,$(error.background)
#
	style.errorlist.54=fore:#008080,bold,$(error.background)
#
	style.errorlist.55=fore:#A0A0A0,bold,$(error.background)



###############################################################################
# Style for escript from file escript.properties

# Default
	style.escript.0=$(style.anjuta.normal)
# Comment
	style.escript.1=$(style.anjuta.comment)
# Line Comment
	style.escript.2=$(style.anjuta.comment)
# Doc comment
	style.escript.3=$(style.anjuta.comment)
# Number
	style.escript.4=$(style.anjuta.number)
# Keyword
	style.escript.5=$(style.anjuta.keyword)
# Double quoted string
	style.escript.6=$(style.anjuta.string)
# Operators
	style.escript.7=$(style.anjuta.operator)
# Braces
	style.escript.9=$(style.anjuta.operator)
# Keywords2
	style.escript.10=$(style.anjuta.localkeyword)
# Keywords3
	style.escript.11=$(style.anjuta.syskeyword)



###############################################################################
# Style for f77 from file fortran.properties

#
	style.f77.0=$(style.anjuta.whitespace)
#
	style.f77.1=$(style.anjuta.comment)
#
	style.f77.2=$(style.anjuta.number)
#
	style.f77.3=$(style.anjuta.char)
#
	style.f77.4=$(style.anjuta.string)
#
	style.f77.5=$(style.anjuta.unclosed)
#
	style.f77.6=$(style.anjuta.operator)
#
	style.f77.8=$(style.anjuta.keyword)
#
	style.f77.9=$(style.anjuta.localkeyword)
#
	style.f77.10=$(style.anjuta.syskeyword)
#
	style.f77.11=$(style.anjuta.preprocessor)
#
	style.f77.12=$(style.anjuta.operator)
#
	style.f77.13=$(style.anjuta.definition)
#
	style.f77.14=$(style.anjuta.regex)



###############################################################################
# Style for flagship from file flagship.properties

# Comment * ...
	style.flagship.1=$(style.anjuta.comment)
# Comment Line && ...
	style.flagship.2=$(style.anjuta.comment)
# Comment Doc /* ... */
	style.flagship.3=$(style.anjuta.comment)
# Comment Line Doc // ...
	style.flagship.4=$(style.anjuta.comment)
# Comment keyword
	style.flagship.5=$(style.anjuta.comment)
# Comment keyword error
	style.flagship.6=$(style.anjuta.comment)
# Keyword - Commands
	style.flagship.7=$(style.anjuta.keyword)
# keywords 2 - Std Library Functions
	style.flagship.8=$(style.anjuta.localkeyword)
# keywords 3 - function, procedure, return, exit
	style.flagship.9=$(style.anjuta.syskeyword)
# keywords 4 - Class (oop)
	style.flagship.10=$(style.anjuta.extrakeyword)
# Number
	style.flagship.11=$(style.anjuta.number)
# String
	style.flagship.12=$(style.anjuta.string)
# Preprocessor (directives)
	style.flagship.13=$(style.anjuta.preprocessor)
# Operator
	style.flagship.14=$(style.anjuta.operator)
# Date
	style.flagship.16=$(style.anjuta.number)
# STRINGEOL - End of line where string is not closed
	style.flagship.17=$(style.anjuta.unclosed)
# Constant nil .t. .f.
	style.flagship.18=$(style.anjuta.number)
# Word operator .and. .or. .not.
	style.flagship.19=$(style.anjuta.operator)
# Comment Doc C
	style.flagship.22=$(style.anjuta.comment)
# Comment Line Doc C
	style.flagship.23=$(style.anjuta.comment)
# Keyword C
	style.flagship.24=$(style.anjuta.keyword)
# Std Library Functions C
	style.flagship.25=$(style.anjuta.syskeyword)
# Number C
	style.flagship.26=$(style.anjuta.number)
# String C
	style.flagship.27=$(style.anjuta.string)
# Preprocessor C
	style.flagship.28=$(style.anjuta.preprocessor)
# Operator C
	style.flagship.29=$(style.anjuta.operator)
# STRINGEOL C
	style.flagship.31=$(style.anjuta.unclosed)



###############################################################################
# Style for forth from file forth.properties

# whitespace (SCE_FORTH_DEFAULT)
	style.forth.0=$(style.anjuta.normal)
# Comment (SCE_FORTH_COMMENT)
	style.forth.1=$(style.anjuta.comment)
# ML comment (SCE_FORTH_COMMENT_ML)
	style.forth.2=$(style.anjuta.comment)
# ML comment (SCE_FORTH_IDENTIFIER)
	style.forth.3=$(style.anjuta.comment)
# control (SCE_FORTH_CONTROL)
	style.forth.4=$(style.anjuta.preprocessor)
# Keywords (SCE_FORTH_KEYWORD)
	style.forth.5=$(style.anjuta.keyword)
# defwords (SCE_FORTH_DEFWORD)
	style.forth.6=$(style.anjuta.localkeyword)
# preword1 (SCE_FORTH_PREWORD1)
	style.forth.7=$(style.anjuta.syskeyword)
# preword2 (SCE_FORTH_PREWORD2)
	style.forth.8=$(style.anjuta.extrakeyword)
# number (SCE_FORTH_NUMBER)
	style.forth.9=$(style.anjuta.number)
# Double quoted string (SCE_FORTH_STRING)
	style.forth.10=$(style.anjuta.string)
# locale
	style.forth.11=$(style.anjuta.char)



###############################################################################
# Style for fortran from file fortran.properties

# Default
	style.fortran.0=$(style.anjuta.whitespace)
# Comment
	style.fortran.1=$(style.anjuta.comment)
# Number
	style.fortran.2=$(style.anjuta.number)
# Single quoted string
	style.fortran.3=$(style.anjuta.char)
# Double quoted string
	style.fortran.4=$(style.anjuta.string)
# End of line where string is not closed
	style.fortran.5=$(style.anjuta.unclosed)
# Operators
	style.fortran.6=$(style.anjuta.operator)
# Keywords
	style.fortran.8=$(style.anjuta.keyword)
# Keywords2
	style.fortran.9=$(style.anjuta.localkeyword)
# Keywords3
	style.fortran.10=$(style.anjuta.syskeyword)
# Preprocessor
	style.fortran.11=$(style.anjuta.preprocessor)
# Operators in .NAME. format
	style.fortran.12=$(style.anjuta.operator)
# Labels
	style.fortran.13=$(style.anjuta.definition)
# Continuation
	style.fortran.14=$(style.anjuta.regex)



###############################################################################
# Style for freebasic from file freebasic.properties

# Default
	style.freebasic.0=$(style.anjuta.normal)
# Comment
	style.freebasic.1=$(style.anjuta.comment)
# Number
	style.freebasic.2=$(style.anjuta.number)
# Keyword1
	style.freebasic.3=$(style.anjuta.keyword)
# String
	style.freebasic.4=$(style.anjuta.string)
# Preprocessor
	style.freebasic.5=$(style.anjuta.preprocessor)
# Operator
	style.freebasic.6=$(style.anjuta.operator)
# Identifier
	style.freebasic.7=$(style.anjuta.identifier)
# Keyword2
	style.freebasic.10=$(style.anjuta.localkeyword)
# Keyword3
	style.freebasic.11=$(style.anjuta.syskeyword)
# Keyword4
	style.freebasic.12=$(style.anjuta.extrakeyword)
# Label
	style.freebasic.15=$(style.anjuta.function)
# Error
	style.freebasic.16=$(style.anjuta.error)
# HexNumber
	style.freebasic.17=$(style.anjuta.number)
# BinNumber
	style.freebasic.18=$(style.anjuta.number)



###############################################################################
# Style for gap from file gap.properties

# White space
	style.gap.0=$(style.anjuta.whitespace)
# Keywords
	style.gap.2=$(style.anjuta.keyword)
# Keywords 2
	style.gap.3=$(style.anjuta.localkeyword)
# Keywords 3
	style.gap.4=$(style.anjuta.syskeyword)
# Keywords 4
	style.gap.5=$(style.anjuta.extrakeyword)
# Strings
	style.gap.6=$(style.anjuta.string)
# Characters
	style.gap.7=$(style.anjuta.char)
# Operators
	style.gap.8=$(style.anjuta.operator)
# Comment
	style.gap.9=$(style.anjuta.comment)
# Numbers
	style.gap.10=$(style.anjuta.number)
# End of line where string is not closed
	style.gap.11=$(style.anjuta.unclosed)



###############################################################################
# Style for haskell from file haskell.properties

# white space
	style.haskell.0=$(style.anjuta.whitespace)
# keyword
	style.haskell.2=$(style.anjuta.keyword)
# numbers
	style.haskell.3=$(style.anjuta.number)
# string
	style.haskell.4=$(style.anjuta.string)
# character
	style.haskell.5=$(style.anjuta.char)
# class: error not implemented
	style.haskell.6=$(style.anjuta.error)
# data: error not implemented
	style.haskell.9=$(style.anjuta.error)
# import: error not implemented
	style.haskell.10=$(style.anjuta.error)
# operator
	style.haskell.11=$(style.anjuta.operator)
# instance: error not implemented
	style.haskell.12=$(style.anjuta.error)
# line comment
	style.haskell.13=$(style.anjuta.comment)
# block comment
	style.haskell.14=$(style.anjuta.comment)
# block comment 2
	style.haskell.15=$(style.anjuta.comment)
# block comment 3
	style.haskell.16=$(style.anjuta.comment)
# pragma
	style.haskell.17=$(style.anjuta.preprocessor)
# preprocessor
	style.haskell.18=$(style.anjuta.preprocessor)
# End of line where string is not closed
	style.haskell.19=$(style.anjuta.error)
# Reserved operator
	style.haskell.20=$(style.anjuta.operator)
# Literate comment
	style.haskell.21=$(style.anjuta.comment)
# Literate delimiter
	style.haskell.22=$(style.anjuta.number)



###############################################################################
# Style for hypertext from file html.properties

# Text
	style.hypertext.0=$(style.anjuta.normal)
# Tags
	style.hypertext.1=$(style.anjuta.keyword)
# Unknown Tags
	style.hypertext.2=$(style.anjuta.localkeyword)
# Attributes
	style.hypertext.3=$(style.anjuta.attribute)
# Unknown Attributes
	style.hypertext.4=$(style.anjuta.identifier)
# Numbers
	style.hypertext.5=$(style.anjuta.number)
# Double quoted strings
	style.hypertext.6=$(style.anjuta.string)
# Single quoted strings
	style.hypertext.7=$(style.anjuta.char)
# Other inside tag
	style.hypertext.8=$(style.anjuta.regex)
# Comment
	style.hypertext.9=$(style.anjuta.comment)
# Entities
	style.hypertext.10=$(style.anjuta.attribute)
# XML style tag ends '/>'
	style.hypertext.11=$(style.anjuta.keyword)
# XML identifier start '<?'
	style.hypertext.12=$(style.anjuta.keyword)
# XML identifier end '?>'
	style.hypertext.13=$(style.anjuta.keyword)
#  SCRIPT
	style.hypertext.14=$(style.anjuta.normal)
# ASP <% ... %>
	style.hypertext.15=$(style.anjuta.keyword)
# ASP <% ... %>
	style.hypertext.16=$(style.anjuta.keyword)
# CDATA
	style.hypertext.17=$(style.anjuta.raw)
# PHP
	style.hypertext.18=$(style.anjuta.preprocessor)
# Unquoted values
	style.hypertext.19=$(style.anjuta.identifier)
# JSP Comment <%-- ... --%>
	style.hypertext.20=$(style.anjuta.comment)
# SGML tags <! ... >
	style.hypertext.21=$(style.anjuta.keyword)
# SGML command
	style.hypertext.22=$(style.anjuta.keyword)
# SGML 1st param
	style.hypertext.23=$(style.anjuta.attribute)
# SGML double string
	style.hypertext.24=$(style.anjuta.string)
# SGML single string
	style.hypertext.25=$(style.anjuta.char)
# SGML error
	style.hypertext.26=$(style.anjuta.error)
# SGML special (#xxxx type)
	style.hypertext.27=$(style.anjuta.attribute)
# SGML entity
	style.hypertext.28=$(style.anjuta.attribute)
# SGML comment
	style.hypertext.29=$(style.anjuta.comment)
# SGML first parameter - lexer internal. It is an error if any text is in this style.
	style.hypertext.30=$(style.anjuta.preprocessor)
# SGML block
	style.hypertext.31=$(style.anjuta.preprocessor)
# JS Start - allows eol filled background to not start on same line as SCRIPT tag
	style.hypertext.40=$(style.anjuta.function)
# JS Default
	style.hypertext.41=$(style.anjuta.normal)
# JS Comment
	style.hypertext.42=$(style.anjuta.comment)
# JS Line Comment
	style.hypertext.43=$(style.anjuta.comment)
# JS Doc comment
	style.hypertext.44=$(style.anjuta.comment)
# JS Number
	style.hypertext.45=$(style.anjuta.number)
# JS Word
	style.hypertext.46=$(style.anjuta.identifier)
# JS Keyword
	style.hypertext.47=$(style.anjuta.keyword)
# JS Double quoted string
	style.hypertext.48=$(style.anjuta.string)
# JS Single quoted string
	style.hypertext.49=$(style.anjuta.char)
# JS Symbols
	style.hypertext.50=$(style.anjuta.operator)
# JavaScript EOL
	style.hypertext.51=$(style.anjuta.function)
# JavaScript RegEx
	style.hypertext.52=$(style.anjuta.regex)
# JS Start - allows eol filled background to not start on same line as SCRIPT tag
	style.hypertext.55=$(style.anjuta.function)
# JS Default
	style.hypertext.56=$(style.anjuta.normal)
# JS Comment
	style.hypertext.57=$(style.anjuta.comment)
# JS Line Comment
	style.hypertext.58=$(style.anjuta.comment)
# JS Doc comment
	style.hypertext.59=$(style.anjuta.comment)
# JS Number
	style.hypertext.60=$(style.anjuta.number)
# JS Word
	style.hypertext.61=$(style.anjuta.identifier)
# JS Keyword
	style.hypertext.62=$(style.anjuta.keyword)
# JS Double quoted string
	style.hypertext.63=$(style.anjuta.string)
# JS Single quoted string
	style.hypertext.64=$(style.anjuta.char)
# JS Symbols
	style.hypertext.65=$(style.anjuta.operator)
# JavaScript EOL
	style.hypertext.66=$(style.anjuta.function)
# JavaScript RegEx
	style.hypertext.67=$(style.anjuta.regex)
# Default
	style.hypertext.71=$(style.anjuta.normal)
# Comment
	style.hypertext.72=$(style.anjuta.comment)
# Number
	style.hypertext.73=$(style.anjuta.number)
# KeyWord
	style.hypertext.74=$(style.anjuta.keyword)
# String
	style.hypertext.75=$(style.anjuta.string)
# Identifier
	style.hypertext.76=$(style.anjuta.identifier)
# Unterminated string
	style.hypertext.77=$(style.anjuta.unclosed)
# Default
	style.hypertext.81=$(style.anjuta.normal)
# Comment
	style.hypertext.82=$(style.anjuta.comment)
# Number
	style.hypertext.83=$(style.anjuta.number)
# KeyWord
	style.hypertext.84=$(style.anjuta.keyword)
# String
	style.hypertext.85=$(style.anjuta.string)
# Identifier
	style.hypertext.86=$(style.anjuta.identifier)
# Unterminated string
	style.hypertext.87=$(style.anjuta.unclosed)
# Embedded Python
	style.hypertext.90=$(style.anjuta.whitespace)
#
	style.hypertext.91=$(style.anjuta.normal)
# Comment
	style.hypertext.92=$(style.anjuta.comment)
# Number
	style.hypertext.93=$(style.anjuta.number)
# String
	style.hypertext.94=$(style.anjuta.string)
# Single quoted string
	style.hypertext.95=$(style.anjuta.char)
# Keyword
	style.hypertext.96=$(style.anjuta.keyword)
# Triple quotes
	style.hypertext.97=$(style.anjuta.char)
# Triple double quotes
	style.hypertext.98=$(style.anjuta.string)
# Class name definition
	style.hypertext.99=$(style.anjuta.definition)
# Function or method name definition
	style.hypertext.100=$(style.anjuta.function)
# Operators
	style.hypertext.101=$(style.anjuta.operator)
# Identifiers
	style.hypertext.102=$(style.anjuta.identifier)
# PHP complex variable
	style.hypertext.104=$(style.anjuta.identifier)
# ASP Python
	style.hypertext.105=$(style.anjuta.whitespace)
#
	style.hypertext.106=$(style.anjuta.normal)
# Comment
	style.hypertext.107=$(style.anjuta.comment)
# Number
	style.hypertext.108=$(style.anjuta.number)
# String
	style.hypertext.109=$(style.anjuta.string)
# Single quoted string
	style.hypertext.110=$(style.anjuta.char)
# Keyword
	style.hypertext.111=$(style.anjuta.keyword)
# Triple quotes
	style.hypertext.112=$(style.anjuta.char)
# Triple double quotes
	style.hypertext.113=$(style.anjuta.string)
# Class name definition
	style.hypertext.114=$(style.anjuta.definition)
# Function or method name definition
	style.hypertext.115=$(style.anjuta.function)
# Operators
	style.hypertext.116=$(style.anjuta.operator)
# Identifiers
	style.hypertext.117=$(style.anjuta.identifier)
# Default
	style.hypertext.118=$(style.anjuta.normal)
# Double quoted String
	style.hypertext.119=$(style.anjuta.string)
# Single quoted string
	style.hypertext.120=$(style.anjuta.char)
# Keyword
	style.hypertext.121=$(style.anjuta.keyword)
# Number
	style.hypertext.122=$(style.anjuta.number)
# Variable
	style.hypertext.123=$(style.anjuta.identifier)
# Comment
	style.hypertext.124=$(style.anjuta.comment)
# One line comment
	style.hypertext.125=$(style.anjuta.comment)
# PHP variable in double quoted string
	style.hypertext.126=$(style.anjuta.identifier)
# PHP operator
	style.hypertext.127=$(style.anjuta.operator)



###############################################################################
# Style for ihex from file hex.properties

# Same color scheme as above, comments when differing
	style.ihex.0=$(style.anjuta.normal)
# Record start ':'
	style.ihex.1=$(style.anjuta.attribute)
#
	style.ihex.2=$(style.anjuta.attribute)
#
	style.ihex.3=$(style.anjuta.attribute)
#
	style.ihex.4=$(style.anjuta.attribute)
#
	style.ihex.5=$(style.anjuta.attribute)
#
	style.ihex.6=$(style.anjuta.attribute)
#
	style.ihex.7=$(style.anjuta.attribute)
# Data field: Start address
	style.ihex.9=$(style.anjuta.number)
# Address field: Type unknown (4 digits as usual)
	style.ihex.10=$(style.anjuta.error)
# Data field: Extended address
	style.ihex.11=$(style.anjuta.number)
#
	style.ihex.12=$(style.anjuta.number)
#
	style.ihex.13=$(style.anjuta.number)
# Data field: Type unknown
	style.ihex.14=$(style.anjuta.char)
#
	style.ihex.15=$(style.anjuta.char)
#
	style.ihex.16=$(style.anjuta.char)
#
	style.ihex.17=$(style.anjuta.char)
#
	style.ihex.18=$(style.anjuta.char)



###############################################################################
# Style for inno from file inno.properties

# Comment
	style.inno.1=$(style.anjuta.comment)
# Keyword
	style.inno.2=$(style.anjuta.keyword)
# Parameter
	style.inno.3=$(style.anjuta.attribute)
# Section
	style.inno.4=$(style.anjuta.function)
# Preprocessor
	style.inno.5=$(style.anjuta.preprocessor)
# Preprocessor (inline)
	style.inno.6=$(style.anjuta.preprocessor)
# Pascal comment
	style.inno.7=$(style.anjuta.comment)
# Pascal keyword
	style.inno.8=$(style.anjuta.keyword)
# User defined keyword
	style.inno.9=$(style.anjuta.localkeyword)
# Double quoted string
	style.inno.10=$(style.anjuta.string)
# Single quoted string
	style.inno.11=$(style.anjuta.char)
# Identifier - lexer internal. It is an error if any text is in this style.
	style.inno.12=$(style.anjuta.error)



###############################################################################
# Style for json from file json.properties

# Default
	style.json.0=$(style.anjuta.normal)
# Number
	style.json.1=$(style.anjuta.number)
# String
	style.json.2=$(style.anjuta.string)
# Unclosed string
	style.json.3=$(style.anjuta.error)
# Property name
	style.json.4=$(style.anjuta.attribute)
# Escape sequence
	style.json.5=$(style.anjuta.string)
# Line comment
	style.json.6=$(style.anjuta.comment)
# Block comment
	style.json.7=$(style.anjuta.comment)
# Operator
	style.json.8=$(style.anjuta.operator)
# URL/IRI
	style.json.9=$(style.anjuta.syskeyword)
# JSON-LD compact IRI
	style.json.10=$(style.anjuta.keyword)
# JSON keyword
	style.json.11=$(style.anjuta.keyword)
# JSON-LD keyword
	style.json.12=$(style.anjuta.keyword)
# Parsing error
	style.json.13=$(style.anjuta.error)



###############################################################################
# Style for kix from file kix.properties

# White space
	style.kix.0=$(style.anjuta.whitespace)
# Comment
	style.kix.1=$(style.anjuta.comment)
# String
	style.kix.2=$(style.anjuta.string)
#
	style.kix.3=$(style.anjuta.char)
# Number
	style.kix.4=$(style.anjuta.number)
# Variables
	style.kix.5=$(style.anjuta.identifier)
# Macro
	style.kix.6=$(style.anjuta.preprocessor)
# Keyword
	style.kix.7=$(style.anjuta.keyword)
# Function
	style.kix.8=$(style.anjuta.function)
# Operator
	style.kix.9=$(style.anjuta.operator)
# Stream comment
	style.kix.10=$(style.anjuta.comment)



###############################################################################
# Style for latex from file latex.properties

# White space
	style.latex.0=$(style.anjuta.whitespace)
# Command
	style.latex.1=$(style.anjuta.keyword)
# Tag Opening
	style.latex.2=$(style.anjuta.attribute)
# Math Inline
	style.latex.3=$(style.anjuta.function)
# Comment
	style.latex.4=$(style.anjuta.comment)
# Tag Closing
	style.latex.5=$(style.anjuta.string)
# Math Block
	style.latex.6=$(style.anjuta.regex)
# Comment Block
	style.latex.7=$(style.anjuta.comment)
# Verbatim Segment
	style.latex.8=$(style.anjuta.raw)
# Short Command
	style.latex.9=$(style.anjuta.preprocessor)
# Special Char
	style.latex.10=$(style.anjuta.char)
# Command optional argument
	style.latex.11=$(style.anjuta.extrakeyword)
# Syntax error
	style.latex.12=$(style.anjuta.error)



###############################################################################
# Style for lisp from file lisp.properties

# White space
	style.lisp.0=$(style.anjuta.whitespace)
# Line Comment
	style.lisp.1=$(style.anjuta.comment)
# Number
	style.lisp.2=$(style.anjuta.number)
# Keyword
	style.lisp.3=$(style.anjuta.keyword)
# Keyword 2
	style.lisp.4=$(style.anjuta.syskeyword)
# Symbol
	style.lisp.5=$(style.anjuta.localkeyword)
# String
	style.lisp.6=$(style.anjuta.string)
# End of line where string is not closed
	style.lisp.8=$(style.anjuta.unclosed)
# Operators
	style.lisp.10=$(style.anjuta.operator)
# Special
	style.lisp.11=$(style.anjuta.extrakeyword)
# Multi-line comment
	style.lisp.12=$(style.anjuta.comment)



###############################################################################
# Style for lot from file lot.properties

# Default
	style.lot.0=$(style.anjuta.normal)
# header
	style.lot.1=$(style.anjuta.keyword)
# break
	style.lot.2=$(style.anjuta.localkeyword)
# set
	style.lot.3=$(style.anjuta.unclosed)
# pass
	style.lot.4=$(style.anjuta.definition)
# fail
	style.lot.5=$(style.anjuta.error)
# abort
	style.lot.6=$(style.anjuta.error)



###############################################################################
# Style for lout from file lout.properties

# White space
	style.lout.0=$(style.anjuta.whitespace)
# Comment
	style.lout.1=$(style.anjuta.comment)
# Number
	style.lout.2=$(style.anjuta.number)
# Keyword (@-prefixed keywords)
	style.lout.3=$(style.anjuta.keyword)
# Keyword2 (symbol keywords)
	style.lout.4=$(style.anjuta.localkeyword)
# Keyword3 (non-@ keywords)
	style.lout.5=$(style.anjuta.syskeyword)
# Keyword4 (user or library symbols)
	style.lout.6=$(style.anjuta.extrakeyword)
# Double quoted string
	style.lout.7=$(style.anjuta.string)
# Operators
	style.lout.8=$(style.anjuta.operator)
# End of line where string is not closed
	style.lout.10=$(style.anjuta.unclosed)



###############################################################################
# Style for lua from file lua.properties

# White space: Visible only in View Whitespace mode (or if it has a back colour)
	style.lua.0=$(style.anjuta.whitespace)
# Block comment (Lua 5.0)
	style.lua.1=$(style.anjuta.comment)
# Line comment
	style.lua.2=$(style.anjuta.comment)
# Doc comment -- Not used in Lua (yet?)
	style.lua.3=$(style.anjuta.comment)
# Number
	style.lua.4=$(style.anjuta.number)
# Keyword
	style.lua.5=$(style.anjuta.keyword)
# (Double quoted) String
	style.lua.6=$(style.anjuta.string)
# Character (Single quoted string)
	style.lua.7=$(style.anjuta.char)
# Literal string
	style.lua.8=$(style.anjuta.raw)
# Preprocessor (obsolete in Lua 4.0 and up)
	style.lua.9=$(style.anjuta.preprocessor)
# Operators
	style.lua.10=$(style.anjuta.operator)
# End of line where string is not closed
	style.lua.12=$(style.anjuta.unclosed)
# Other keywords (bozo test colors, but toned down ;)
	style.lua.13=$(style.anjuta.localkeyword)
#
	style.lua.14=$(style.anjuta.syskeyword)
#
	style.lua.15=$(style.anjuta.extrakeyword)
#
	style.lua.16=$(style.anjuta.keyword)
#
	style.lua.17=$(style.anjuta.localkeyword)
#
	style.lua.18=$(style.anjuta.syskeyword)
#
	style.lua.19=$(style.anjuta.extrakeyword)
# Labels
	style.lua.20=$(style.anjuta.extrakeyword)



###############################################################################
# Style for makefile from file others.properties

# Default
	style.makefile.0=$(style.anjuta.normal)
# Comment: #
	style.makefile.1=$(style.anjuta.comment)
# Pre-processor or other comment: !
	style.makefile.2=$(style.anjuta.preprocessor)
# Variable: $(x)
	style.makefile.3=$(style.anjuta.identifier)
# Operator
	style.makefile.4=$(style.anjuta.operator)
# Target
	style.makefile.5=$(style.anjuta.keyword)
# Error
	style.makefile.9=$(style.anjuta.error)



###############################################################################
# Style for matlab from file matlab.properties

# White space
	style.matlab.0=$(style.anjuta.whitespace)
# Comment
	style.matlab.1=$(style.anjuta.comment)
# Command
	style.matlab.2=$(style.anjuta.function)
# Number
	style.matlab.3=$(style.anjuta.number)
# Keyword
	style.matlab.4=$(style.anjuta.keyword)
# String (5=single quoted, 8=double quoted)
	style.matlab.5=$(style.anjuta.char)
# Operator
	style.matlab.6=$(style.anjuta.operator)
#
	style.matlab.8=$(style.anjuta.string)



###############################################################################
# Style for metapost from file metapost.properties

# Default
	style.metapost.0=$(style.anjuta.whitespace)
# Special
	style.metapost.1=$(style.anjuta.extrakeyword)
# Group
	style.metapost.2=$(style.anjuta.function)
# Symbol
	style.metapost.3=$(style.anjuta.operator)
# Command
	style.metapost.4=$(style.anjuta.keyword)
# Text
	style.metapost.5=$(style.anjuta.string)
# Extra
	style.metapost.6=$(style.anjuta.extrakeyword)



###############################################################################
# Style for mmixal from file mmixal.properties

# Comment
	style.mmixal.1=$(style.anjuta.comment)
# Label
	style.mmixal.2=$(style.anjuta.function)
# Valid Opcode (as defined in opcodes above)
	style.mmixal.5=$(style.anjuta.localkeyword)
# Unknown Opcode
	style.mmixal.6=$(style.anjuta.syskeyword)
# Number
	style.mmixal.9=$(style.anjuta.number)
# Reference (to a Label)
	style.mmixal.10=$(style.anjuta.function)
# Char
	style.mmixal.11=$(style.anjuta.char)
# String
	style.mmixal.12=$(style.anjuta.string)
# Register (also special_register as defined above)
	style.mmixal.13=$(style.anjuta.identifier)
# Hexadecimal Number
	style.mmixal.14=$(style.anjuta.number)
# Operator
	style.mmixal.15=$(style.anjuta.operator)
# Symbol (as defined in predef_symbols above)
	style.mmixal.16=$(style.anjuta.attribute)
#~ style.mmixal.17=$(colour.preproc)
	style.mmixal.17=$(style.anjuta.preprocessor)



###############################################################################
# Style for modula from file modula3.properties

#
	style.modula.0=$(style.anjuta.normal)
#
	style.modula.1=$(style.anjuta.comment)
#
	style.modula.2=$(style.anjuta.comment)
#
	style.modula.3=$(style.anjuta.comment)
#
	style.modula.4=$(style.anjuta.keyword)
#
	style.modula.5=$(style.anjuta.localkeyword)
#
	style.modula.6=$(style.anjuta.number)
#
	style.modula.7=$(style.anjuta.number)
#
	style.modula.8=$(style.anjuta.number)
#
	style.modula.9=$(style.anjuta.string)
#
	style.modula.10=$(style.anjuta.string)
#
	style.modula.11=$(style.anjuta.char)
#
	style.modula.12=$(style.anjuta.char)
#
	style.modula.13=$(style.anjuta.definition)
#
	style.modula.14=$(style.anjuta.preprocessor)
#
	style.modula.15=$(style.anjuta.preprocessor)
#
	style.modula.16=$(style.anjuta.operator)
#
	style.modula.17=$(style.anjuta.unclosed)



###############################################################################
# Style for nimrod from file nimrod.properties

# White space
	style.nimrod.0=$(style.anjuta.whitespace)
# Comment
	style.nimrod.1=$(style.anjuta.comment)
# Number
	style.nimrod.2=$(style.anjuta.number)
# String
	style.nimrod.3=$(style.anjuta.string)
# Single quoted string
	style.nimrod.4=$(style.anjuta.char)
# Keyword
	style.nimrod.5=$(style.anjuta.keyword)
# Triple quotes
	style.nimrod.6=$(style.anjuta.regex)
# Triple double quotes
	style.nimrod.7=$(style.anjuta.string)
# Class name definition
	style.nimrod.8=$(style.anjuta.definition)
# Function or method name definition
	style.nimrod.9=$(style.anjuta.function)
# Operators
	style.nimrod.10=$(style.anjuta.operator)
# Comment-blocks
	style.nimrod.12=$(style.anjuta.comment)
# End of line where string is not closed
	style.nimrod.13=$(style.anjuta.error)
# Highlighted identifiers
	style.nimrod.14=$(style.anjuta.identifier)
# Decorators
	style.nimrod.15=$(style.anjuta.attribute)



###############################################################################
# Style for nncrontab from file nncrontab.properties

# Comment (SCE_NNCRONTAB_COMMENT)
	style.nncrontab.1=$(style.anjuta.comment)
# Task start/end (SCE_NNCRONTAB_TASK)
	style.nncrontab.2=$(style.anjuta.definition)
# Section keywords (SCE_NNCRONTAB_SECTION)
	style.nncrontab.3=$(style.anjuta.function)
# Keywords (SCE_NNCRONTAB_KEYWORD)
	style.nncrontab.4=$(style.anjuta.keyword)
# Modificators (SCE_NNCRONTAB_MODIFIER)
	style.nncrontab.5=$(style.anjuta.attribute)
# Asterisk (SCE_NNCRONTAB_ASTERISK)
	style.nncrontab.6=$(style.anjuta.operator)
# Number (SCE_NNCRONTAB_NUMBER)
	style.nncrontab.7=$(style.anjuta.number)
# Double quoted string (SCE_NNCRONTAB_STRING)
	style.nncrontab.8=$(style.anjuta.string)
# Environment variable (SCE_NNCRONTAB_ENVIRONMENT)
	style.nncrontab.9=$(style.anjuta.identifier)
# Identifier (SCE_NNCRONTAB_IDENTIFIER) - lexer internal. It is an error if any text is in this style.
	style.nncrontab.10=$(style.anjuta.error)



###############################################################################
# Style for nsis from file nsis.properties

# Whitespace (SCE_NSIS_DEFAULT)
	style.nsis.0=$(style.anjuta.whitespace)
# Comment (SCE_NSIS_COMMENT)
	style.nsis.1=$(style.anjuta.comment)
# String double quote (SCE_NSIS_STRINGDQ)
	style.nsis.2=$(style.anjuta.string)
# String left quote (SCE_NSIS_STRINGLQ)
	style.nsis.3=$(style.anjuta.char)
# String right quote (SCE_NSIS_STRINGRQ)
	style.nsis.4=$(style.anjuta.char)
# Function (SCE_NSIS_FUNCTION)
	style.nsis.5=$(style.anjuta.function)
# Variable (SCE_NSIS_VARIABLE)
	style.nsis.6=$(style.anjuta.identifier)
# Label (SCE_NSIS_LABEL)
	style.nsis.7=$(style.anjuta.function)
# User Defined (SCE_NSIS_USERDEFINED)
	style.nsis.8=$(style.anjuta.extrakeyword)
# Section (SCE_NSIS_SECTIONDEF)
	style.nsis.9=$(style.anjuta.preprocessor)
# Sub section (SCE_NSIS_SUBSECTIONDEF)
	style.nsis.10=$(style.anjuta.preprocessor)
# If def (SCE_NSIS_IFDEFINEDEF)
	style.nsis.11=$(style.anjuta.preprocessor)
# Macro def (SCE_NSIS_MACRODEF)
	style.nsis.12=$(style.anjuta.preprocessor)
# Variable within string (SCE_NSIS_STRINGVAR)
	style.nsis.13=$(style.anjuta.identifier)
# Numbers (SCE_NSIS_NUMBER)
	style.nsis.14=$(style.anjuta.number)
# Section Group SCE_NSIS_SECTIONGROUP)
	style.nsis.15=$(style.anjuta.preprocessor)
# Page Ex SCE_NSIS_PAGEEX)
	style.nsis.16=$(style.anjuta.preprocessor)
# Function Definition SCE_NSIS_FUNCTIONDEF)
	style.nsis.17=$(style.anjuta.preprocessor)
# Comment Box SCE_NSIS_COMMENTBOX)
	style.nsis.18=$(style.anjuta.comment)



###############################################################################
# Style for octave from file matlab.properties

# White space
	style.octave.0=$(style.anjuta.whitespace)
# Comment
	style.octave.1=$(style.anjuta.comment)
# Command
	style.octave.2=$(style.anjuta.function)
# Number
	style.octave.3=$(style.anjuta.number)
# Keyword
	style.octave.4=$(style.anjuta.keyword)
# String (5: single quoted, 8: double quoted)
	style.octave.5=$(style.anjuta.char)
# Operator
	style.octave.6=$(style.anjuta.operator)
#
	style.octave.8=$(style.anjuta.string)



###############################################################################
# Style for opal from file opal.properties

# White space
	style.opal.0=$(style.anjuta.whitespace)
# Comment block
	style.opal.1=$(style.anjuta.comment)
# Comment line
	style.opal.2=$(style.anjuta.comment)
# Integer
	style.opal.3=$(style.anjuta.number)
# Keyword
	style.opal.4=$(style.anjuta.keyword)
# Sort
	style.opal.5=$(style.anjuta.char)
# Double quoted string
	style.opal.6=$(style.anjuta.string)
# Brace normal
	style.opal.7=$(style.anjuta.operator)
# Bool const
	style.opal.8=$(style.anjuta.identifier)



###############################################################################
# Style for oscript from file oscript.properties

# Single-line comment.
	style.oscript.1=$(style.anjuta.comment)
# Multi-line comment.
	style.oscript.2=$(style.anjuta.comment)
# #ifdef DOC and #endif; the value of DOC is supposed to be never defined.
	style.oscript.3=$(style.anjuta.comment)
# Preprocessor directive.
	style.oscript.4=$(style.anjuta.preprocessor)
# Number.
	style.oscript.5=$(style.anjuta.number)
# String enclosed in single quotes (apostrophes).
	style.oscript.6=$(style.anjuta.char)
# String enclosed in double quotes (quotation marks).
	style.oscript.7=$(style.anjuta.string)
# Constant literal. See the property keywords2 above.
	style.oscript.8=$(style.anjuta.localkeyword)
# Server-global variable (prefixed by $).
	style.oscript.10=$(style.anjuta.definition)
# Language native keyword or reserved word. See the property keywords above.
	style.oscript.11=$(style.anjuta.keyword)
# Operator; either symbolic or literal. See the property keywords3 above.
	style.oscript.12=$(style.anjuta.operator)
# Label to jump to with the GoTo statement.
	style.oscript.13=$(style.anjuta.identifier)
# See the property keywords4 above.
	style.oscript.14=$(style.anjuta.syskeyword)
# See the property keywords5 above.
	style.oscript.15=$(style.anjuta.extrakeyword)
# Static built-in object. See the property keywords6 above.
	style.oscript.16=$(style.anjuta.function)



###############################################################################
# Style for pascal from file pascal.properties

# White space
	style.pascal.0=$(style.anjuta.whitespace)
# Comment: { ... }
	style.pascal.2=$(style.anjuta.comment)
# Comment: (* ... *)
	style.pascal.3=$(style.anjuta.comment)
# Line Comment: // ...
	style.pascal.4=$(style.anjuta.number)
# Preprocessor: {$ ... }
	style.pascal.5=$(style.anjuta.keyword)
# Preprocessor: (*$ ... *)
	style.pascal.6=$(style.anjuta.string)
# Number
	style.pascal.7=$(style.anjuta.char)
# Hex Number
	style.pascal.8=$(style.anjuta.operator)
# Keyword
	style.pascal.9=$(style.anjuta.preprocessor)
# String
	style.pascal.10=$(style.anjuta.operator)
# End of line where string is not closed
	style.pascal.11=$(style.anjuta.error)
# Character
	style.pascal.12=$(style.anjuta.char)
# Operators
	style.pascal.13=$(style.anjuta.operator)
# Inline Asm
	style.pascal.14=$(style.anjuta.localkeyword)



###############################################################################
# Style for perl from file perl.properties

# White space
	style.perl.0=$(style.anjuta.whitespace)
# Error
	style.perl.1=$(style.anjuta.comment)
# Comment
	style.perl.2=$(style.anjuta.comment)
# POD: = at beginning of line
	style.perl.3=$(style.anjuta.comment)
# Number
	style.perl.4=$(style.anjuta.number)
# Keyword
	style.perl.5=$(style.anjuta.keyword)
# Double quoted string
	style.perl.6=$(style.anjuta.string)
# Single quoted string
	style.perl.7=$(style.anjuta.char)
# Symbols / Punctuation. Currently not used by LexPerl.
	style.perl.8=$(style.anjuta.operator)
# Preprocessor. Currently not used by LexPerl.
	style.perl.9=$(style.anjuta.preprocessor)
# Operators
	style.perl.10=$(style.anjuta.operator)
# Identifiers (functions, etc.)
	style.perl.11=$(style.anjuta.identifier)
# Scalars: $var
	style.perl.12=$(style.anjuta.identifier)
# Array: @var
	style.perl.13=$(style.anjuta.identifier)
# Hash: %var
	style.perl.14=$(style.anjuta.identifier)
# Symbol table: *var
	style.perl.15=$(style.anjuta.identifier)
# SCE_PL_VARIABLE_INDEXER allocated but unused
	style.perl.16=$(style.anjuta.error)
# Regex: /re/ or m{re}
	style.perl.17=$(style.anjuta.regex)
# Substitution: s/re/ore/
	style.perl.18=$(style.anjuta.regex)
# Long Quote (qq, qr, qw, qx) -- obsolete: replaced by qq, qx, qr, qw
	style.perl.19=$(style.anjuta.string)
# Back Ticks
	style.perl.20=$(style.anjuta.char)
# Data Section: __DATA__ or __END__ at beginning of line
	style.perl.21=$(style.anjuta.function)
# Here-doc (delimiter)
	style.perl.22=$(style.anjuta.comment)
# Here-doc (single quoted, q)
	style.perl.23=$(style.anjuta.comment)
# Here-doc (double quoted, qq)
	style.perl.24=$(style.anjuta.comment)
# Here-doc (back ticks, qx)
	style.perl.25=$(style.anjuta.comment)
# Single quoted string, generic
	style.perl.26=$(style.anjuta.char)
# qq = Double quoted string
	style.perl.27=$(style.anjuta.string)
# qx = Back ticks
	style.perl.28=$(style.anjuta.char)
# qr = Regex
	style.perl.29=$(style.anjuta.regex)
# qw = Array
	style.perl.30=$(style.anjuta.identifier)
# POD: verbatim paragraphs
	style.perl.31=$(style.anjuta.comment)
# subroutine prototype
	style.perl.40=$(style.anjuta.attribute)
# format identifier
	style.perl.41=$(style.anjuta.raw)
# format body
	style.perl.42=$(style.anjuta.raw)
# Double quoted string (interpolated variable)
	style.perl.43=$(style.anjuta.string)
# translation: tr{}{} y{}{}
	style.perl.44=$(style.anjuta.regex)
# Regex: /re/ or m{re} (interpolated variable)
	style.perl.54=$(style.anjuta.regex)
# Substitution: s/re/ore/ (interpolated variable)
	style.perl.55=$(style.anjuta.regex)
# Back Ticks (interpolated variable)
	style.perl.57=$(style.anjuta.char)
# Here-doc (double quoted, qq) (interpolated variable)
	style.perl.61=$(style.anjuta.comment)
# Here-doc (back ticks, qx) (interpolated variable)
	style.perl.62=$(style.anjuta.comment)
# qq = Double quoted string (interpolated variable)
	style.perl.64=$(style.anjuta.string)
# qx = Back ticks (interpolated variable)
	style.perl.65=$(style.anjuta.char)
# qr = Regex (interpolated variable)
	style.perl.66=$(style.anjuta.regex)



###############################################################################
# Style for pov from file pov.properties

# White space: Visible only in View Whitespace mode (or if it has a back colour)
	style.pov.0=$(style.anjuta.whitespace)
# Comment: /* */. Use fixed font to keep boxed comments as boxes
	style.pov.1=$(style.anjuta.comment)
# Line Comment: //. Proportionnal font is generally OK here
	style.pov.2=$(style.anjuta.comment)
# Number
	style.pov.3=$(style.anjuta.number)
# Operators
	style.pov.4=$(style.anjuta.operator)
# Double quoted string
	style.pov.6=$(style.anjuta.string)
# End of line where string is not closed
	style.pov.7=$(style.anjuta.unclosed)
# Directive: #keyword
	style.pov.8=$(style.anjuta.preprocessor)
# Directive keyword error
	style.pov.9=$(style.anjuta.error)
# Keyword 2: Objects & CSG & Appearance (xxx {})
	style.pov.10=$(style.anjuta.keyword)
# Keyword 3: Types & Modifiers & Items
	style.pov.11=$(style.anjuta.attribute)
# Keyword 4: Predefined Identifiers
	style.pov.12=$(style.anjuta.identifier)
# Keyword 5: Predefined Functions
	style.pov.13=$(style.anjuta.function)
# Keyword 6
	style.pov.14=$(style.anjuta.localkeyword)
# Keyword 7
	style.pov.15=$(style.anjuta.syskeyword)
# Keyword 8
	style.pov.16=$(style.anjuta.extrakeyword)



###############################################################################
# Style for powerpro from file powerpro.properties

# Default text color
	style.powerpro.0=$(style.anjuta.normal)
# Comment: /* */
	style.powerpro.1=$(style.anjuta.comment)
# Line Comment: // ;; ;
	style.powerpro.2=$(style.anjuta.comment)
# Number
	style.powerpro.3=$(style.anjuta.number)
# Keywords1
	style.powerpro.4=$(style.anjuta.keyword)
# Keywords2
	style.powerpro.5=$(style.anjuta.localkeyword)
# Keywords3
	style.powerpro.6=$(style.anjuta.syskeyword)
# Keywords4
	style.powerpro.7=$(style.anjuta.extrakeyword)
# Double quoted string
	style.powerpro.8=$(style.anjuta.string)
# Single quoted string
	style.powerpro.9=$(style.anjuta.char)
# Line continuation
	style.powerpro.10=$(style.anjuta.preprocessor)
# Operators
	style.powerpro.11=$(style.anjuta.operator)
# Identifiers
	style.powerpro.12=$(style.anjuta.identifier)
# End of line where string is not closed
	style.powerpro.13=$(style.anjuta.error)
# Verbatim strings
	style.powerpro.14=$(style.anjuta.regex)
#alternate quote style (#)
	style.powerpro.15=$(style.anjuta.string)
#function style
	style.powerpro.16=$(style.anjuta.function)



###############################################################################
# Style for powershell from file powershell.properties

# Default
	style.powershell.0=$(style.anjuta.whitespace)
# Comment
	style.powershell.1=$(style.anjuta.comment)
# String
	style.powershell.2=$(style.anjuta.string)
# Character
	style.powershell.3=$(style.anjuta.char)
# Number
	style.powershell.4=$(style.anjuta.number)
# Variable
	style.powershell.5=$(style.anjuta.identifier)
# Operator
	style.powershell.6=$(style.anjuta.operator)
# Identifier
	style.powershell.7=$(style.anjuta.identifier)
# Keyword
	style.powershell.8=$(style.anjuta.keyword)
# Cmdlet
	style.powershell.9=$(style.anjuta.localkeyword)
# Alias
	style.powershell.10=$(style.anjuta.attribute)
# Function
	style.powershell.11=$(style.anjuta.function)
# Comment (multi-line)
	style.powershell.13=$(style.anjuta.comment)
# Here-string
	style.powershell.14=$(style.anjuta.string)
# Here-string single quote
	style.powershell.15=$(style.anjuta.char)
# Comment keyword
	style.powershell.16=$(style.anjuta.comment)



###############################################################################
# Style for props from file others.properties

# Comment
	style.props.1=$(style.anjuta.comment)
# Section
	style.props.2=$(style.anjuta.function)
# Assignment operator
	style.props.3=$(style.anjuta.operator)
# Default value (@)
	style.props.4=$(style.anjuta.attribute)



###############################################################################
# Style for ps from file ps.properties

#Default
	style.ps.0=$(style.anjuta.normal)
# Comment
	style.ps.1=$(style.anjuta.comment)
# DSC comment
	style.ps.2=$(style.anjuta.comment)
# DSC comment value
	style.ps.3=$(style.anjuta.comment)
# Number
	style.ps.4=$(style.anjuta.number)
# Name
	style.ps.5=$(style.anjuta.identifier)
# Keyword
	style.ps.6=$(style.anjuta.keyword)
# Literal
	style.ps.7=$(style.anjuta.string)
# Immediately evaluated literal
	style.ps.8=$(style.anjuta.char)
# Array parenthesis
	style.ps.9=$(style.anjuta.operator)
# Dictionary parenthesis
	style.ps.10=$(style.anjuta.operator)
# Procedure parenthesis
	style.ps.11=$(style.anjuta.operator)
# Text
	style.ps.12=$(style.anjuta.raw)
# Hex string
	style.ps.13=$(style.anjuta.number)
# Base85 string
	style.ps.14=$(style.anjuta.regex)
# Bad string character
	style.ps.15=$(style.anjuta.error)



###############################################################################
# Style for purebasic from file purebasic.properties

# Default
	style.purebasic.0=$(style.anjuta.normal)
# Comment
	style.purebasic.1=$(style.anjuta.comment)
# Number
	style.purebasic.2=$(style.anjuta.number)
# Keyword1
	style.purebasic.3=$(style.anjuta.keyword)
# String
	style.purebasic.4=$(style.anjuta.string)
# Operator
	style.purebasic.6=$(style.anjuta.operator)
# Identifier
	style.purebasic.7=$(style.anjuta.identifier)
# Keyword2
	style.purebasic.10=$(style.anjuta.preprocessor)
# Keyword3
	style.purebasic.11=$(style.anjuta.localkeyword)
# Keyword4
	style.purebasic.12=$(style.anjuta.syskeyword)
# Constant
	style.purebasic.13=$(style.anjuta.number)
# Label
	style.purebasic.15=$(style.anjuta.definition)
# Error
	style.purebasic.16=$(style.anjuta.error)
# HexNumber
	style.purebasic.17=$(style.anjuta.number)
# BinNumber
	style.purebasic.18=$(style.anjuta.number)



###############################################################################
# Style for python from file python.properties

# White space
	style.python.0=$(style.anjuta.whitespace)
# Comment
	style.python.1=$(style.anjuta.comment)
# Number
	style.python.2=$(style.anjuta.number)
# String
	style.python.3=$(style.anjuta.string)
# Single quoted string
	style.python.4=$(style.anjuta.char)
# Keyword
	style.python.5=$(style.anjuta.keyword)
# Triple quotes
	style.python.6=$(style.anjuta.string)
# Triple double quotes
	style.python.7=$(style.anjuta.string)
# Class name definition
	style.python.8=$(style.anjuta.definition)
# Function or method name definition
	style.python.9=$(style.anjuta.function)
# Operators
	style.python.10=$(style.anjuta.operator)
# Comment-blocks
	style.python.12=$(style.anjuta.comment)
# End of line where string is not closed
	style.python.13=$(style.anjuta.unclosed)
# Highlighted identifiers
	style.python.14=$(style.anjuta.identifier)
# Decorators
	style.python.15=$(style.anjuta.attribute)
# F-String
	style.python.16=$(style.anjuta.string)
# Single quoted f-string
	style.python.17=$(style.anjuta.char)
# Triple quoted f-string
	style.python.18=$(style.anjuta.string)
# Triple double quoted f-string
	style.python.19=$(style.anjuta.string)



###############################################################################
# Style for r from file r.properties

# White space
	style.r.0=$(style.anjuta.whitespace)
# Comment
	style.r.1=$(style.anjuta.comment)
#Keyword
	style.r.2=$(style.anjuta.keyword)
# Base Package Function
	style.r.3=$(style.anjuta.localkeyword)
# Other Package Function
	style.r.4=$(style.anjuta.syskeyword)
# Number
	style.r.5=$(style.anjuta.number)
# " Delimited String
	style.r.6=$(style.anjuta.string)
# ' Delimited String
	style.r.7=$(style.anjuta.char)
# Operator
	style.r.8=$(style.anjuta.operator)
# Identifier
	style.r.9=$(style.anjuta.identifier)
# INFIX highlight
	style.r.10=$(style.anjuta.extrakeyword)
# INFIX End of Line error
	style.r.11=$(style.anjuta.error)



###############################################################################
# Style for rebol from file rebol.properties

# Any other text
	style.rebol.0=$(style.anjuta.normal)
# Line Comment
	style.rebol.1=$(style.anjuta.comment)
# Block Comment ( comment {the text} )
	style.rebol.2=$(style.anjuta.comment)
# Preface (text before the REBOL header)
	style.rebol.3=$(style.anjuta.comment)
# Operators
	style.rebol.4=$(style.anjuta.operator)
# Characters ( #"a" )
	style.rebol.5=$(style.anjuta.string)
# String with quotes
	style.rebol.6=$(style.anjuta.char)
# String with braces
	style.rebol.7=$(style.anjuta.raw)
# Number
	style.rebol.8=$(style.anjuta.number)
# Pair ( 800x600 )
	style.rebol.9=$(style.anjuta.number)
# Tuple ( 127.0.0.1 )
	style.rebol.10=$(style.anjuta.number)
# Binary ( 16#{1A803F59} )
	style.rebol.11=$(style.anjuta.number)
# Money
	style.rebol.12=$(style.anjuta.number)
# Issue { #123-CD-456 }
	style.rebol.13=$(style.anjuta.definition)
# Tag { <TITLE height=100> }
	style.rebol.14=$(style.anjuta.definition)
# File { %/C/Winnt/some.dll }
	style.rebol.15=$(style.anjuta.attribute)
# Email { joe@mail.dom }
	style.rebol.16=$(style.anjuta.attribute)
# URL { ftp://there.dom }
	style.rebol.17=$(style.anjuta.attribute)
# Date { 17-Feb-2004 1/3/99 }
	style.rebol.18=$(style.anjuta.number)
# Time { 12:30 11:22:59 01:59:59.123 }
	style.rebol.19=$(style.anjuta.number)
# Keyword (all)
	style.rebol.21=$(style.anjuta.keyword)
# Keyword (test functions)
	style.rebol.22=$(style.anjuta.localkeyword)
# Keyword (datatypes)
	style.rebol.23=$(style.anjuta.syskeyword)
# Keyword 4
	style.rebol.24=$(style.anjuta.extrakeyword)
# Keyword 5
	style.rebol.25=$(style.anjuta.extrakeyword)
# Keyword 6
	style.rebol.26=$(style.anjuta.extrakeyword)
# Keyword 7
	style.rebol.27=$(style.anjuta.extrakeyword)
# Keyword 8
	style.rebol.28=$(style.anjuta.extrakeyword)



###############################################################################
# Style for registry from file registry.properties

# Default
	style.registry.0=$(style.anjuta.normal)
# Comment: ;;
	style.registry.1=$(style.anjuta.comment)
# Value name: "Icon"="cmd.exe,-1"
	style.registry.2=$(style.anjuta.number)
# String
	style.registry.3=$(style.anjuta.string)
# Hex digit
	style.registry.4=$(style.anjuta.regex)
# Value type: dword, hex(2), hex(7)
	style.registry.5=$(style.anjuta.definition)
# Added key, [HKLM\*\shell\notepad]
	style.registry.6=$(style.anjuta.keyword)
# Removed key, [-HKLM\*\shell\notepad]
	style.registry.7=$(style.anjuta.syskeyword)
# Escaped characters in strings
	style.registry.8=$(style.anjuta.string)
# GUID in key path, [HKCU\{C4ACBD3E-6114-4618-904C-B206ABA9DEB0}]
	style.registry.9=$(style.anjuta.number)
# GUID in string, @="{C4ACBD3E-6114-4618-904C-B206ABA9DEB0}"
	style.registry.10=$(style.anjuta.number)
# Parameter: "notepad.exe %1 %*"
	style.registry.11=$(style.anjuta.attribute)
# Operators
	style.registry.12=$(style.anjuta.operator)



###############################################################################
# Style for ruby from file ruby.properties

# White space
	style.ruby.0=$(style.anjuta.whitespace)
# Error
	style.ruby.1=$(style.anjuta.error)
# Comment line
	style.ruby.2=$(style.anjuta.comment)
# POD
	style.ruby.3=$(style.anjuta.comment)
# Number
	style.ruby.4=$(style.anjuta.number)
# Word
	style.ruby.5=$(style.anjuta.keyword)
# String
	style.ruby.6=$(style.anjuta.string)
# Character
	style.ruby.7=$(style.anjuta.char)
# Class name
	style.ruby.8=$(style.anjuta.localkeyword)
# Def name
	style.ruby.9=$(style.anjuta.syskeyword)
# Operator
	style.ruby.10=$(style.anjuta.operator)
# Regex
	style.ruby.12=$(style.anjuta.regex)
# Global
	style.ruby.13=$(style.anjuta.unclosed)
# Symbol
	style.ruby.14=$(style.anjuta.operator)
# MODULE_NAME
	style.ruby.15=$(style.anjuta.extrakeyword)
# INSTANCE_VAR
	style.ruby.16=$(style.anjuta.identifier)
# CLASS_VAR
	style.ruby.17=$(style.anjuta.identifier)
# BACKTICKS
	style.ruby.18=$(style.anjuta.raw)
# DATASECTION
	style.ruby.19=$(style.anjuta.function)
# HERE_DELIM
	style.ruby.20=$(style.anjuta.raw)
# HERE_Q
	style.ruby.21=$(style.anjuta.raw)
# HERE_QQ
	style.ruby.22=$(style.anjuta.raw)
# HERE_QX
	style.ruby.23=$(style.anjuta.raw)
# STRING_Q
	style.ruby.24=$(style.anjuta.string)
# STRING_QQ
	style.ruby.25=$(style.anjuta.string)
# STRING_QX
	style.ruby.26=$(style.anjuta.string)
# STRING_QR
	style.ruby.27=$(style.anjuta.string)
# STRING_QW
	style.ruby.28=$(style.anjuta.string)
# Demoted Keyword
	style.ruby.29=$(style.anjuta.keyword)
# STDIN
	style.ruby.30=$(style.anjuta.definition)
# STDOUT
	style.ruby.31=$(style.anjuta.definition)
# STDERR
	style.ruby.40=$(style.anjuta.definition)
# SCE_RB_UPPER_BOUND allocated but unused
	style.ruby.41=$(style.anjuta.error)



###############################################################################
# Style for rust from file rust.properties

# Whitespace
	style.rust.0=$(style.anjuta.whitespace)
# Block comment
	style.rust.1=$(style.anjuta.comment)
# Line comment
	style.rust.2=$(style.anjuta.comment)
# Block doc comment
	style.rust.3=$(style.anjuta.comment)
# Line doc comment
	style.rust.4=$(style.anjuta.comment)
# Number
	style.rust.5=$(style.anjuta.number)
# Keywords 1-7
	style.rust.6=$(style.anjuta.keyword)
#
	style.rust.7=$(style.anjuta.kewyord)
#
	style.rust.8=$(style.anjuta.syskeyword)
#
	style.rust.9=$(style.anjuta.localkeyword)
#
	style.rust.10=$(style.anjuta.localkeyword)
#
	style.rust.11=$(style.anjuta.localkeyword)
#
	style.rust.12=$(style.anjuta.localkeyword)
# Regular string
	style.rust.13=$(style.anjuta.regex)
# Raw string
	style.rust.14=$(style.anjuta.string)
# Character
	style.rust.15=$(style.anjuta.char)
# Operator
	style.rust.16=$(style.anjuta.operator)
# Lifetime
	style.rust.18=$(style.anjuta.attribute)
# Macro
	style.rust.19=$(style.anjuta.preprocessor)
# Lexical error
	style.rust.20=$(style.anjuta.error)
# Byte string
	style.rust.21=$(style.anjuta.string)
# Raw byte string
	style.rust.22=$(style.anjuta.string)
# Byte character
	style.rust.23=$(style.anjuta.char)



###############################################################################
# Style for scriptol from file scriptol.properties

# Default
	style.scriptol.0=$(style.anjuta.normal)
# White space
	style.scriptol.1=$(style.anjuta.whitespace)
# Scriptol style comment line
	style.scriptol.2=$(style.anjuta.comment)
# Persistent comment line
	style.scriptol.3=$(style.anjuta.comment)
# C style comment line
	style.scriptol.4=$(style.anjuta.comment)
# Comment-blocks
	style.scriptol.5=$(style.anjuta.comment)
# Number
	style.scriptol.6=$(style.anjuta.number)
# String
	style.scriptol.7=$(style.anjuta.string)
# Character/Single quoted string
	style.scriptol.8=$(style.anjuta.char)
# End of line where string is not closed
	style.scriptol.9=$(style.anjuta.error)
# Keyword
	style.scriptol.10=$(style.anjuta.keyword)
# Operators
	style.scriptol.11=$(style.anjuta.operator)
# Identifiers
	style.scriptol.12=$(style.anjuta.identifier)
# Class name definition
	style.scriptol.14=$(style.anjuta.definition)



###############################################################################
# Style for smalltalk from file smalltalk.properties

# String
	style.smalltalk.1=$(style.anjuta.string)
# Number
	style.smalltalk.2=$(style.anjuta.number)
# Comment
	style.smalltalk.3=$(style.anjuta.comment)
# Symbol
	style.smalltalk.4=$(style.anjuta.identifier)
# Binary
	style.smalltalk.5=$(style.anjuta.number)
# Boolean
	style.smalltalk.6=$(style.anjuta.keyword)
# self
	style.smalltalk.7=$(style.anjuta.keyword)
# super
	style.smalltalk.8=$(style.anjuta.keyword)
# nil
	style.smalltalk.9=$(style.anjuta.keyword)
# Global
	style.smalltalk.10=$(style.anjuta.definition)
# Return
	style.smalltalk.11=$(style.anjuta.syskeyword)
# Special
	style.smalltalk.12=$(style.anjuta.extrakeyword)
# KwSend
	style.smalltalk.13=$(style.anjuta.keyword)
# Assignment
	style.smalltalk.14=$(style.anjuta.operator)
# Character
	style.smalltalk.15=$(style.anjuta.char)
# Special selector
	style.smalltalk.16=$(style.anjuta.regex)



###############################################################################
# Style for sorcins from file sorcins.properties

# Command
	style.sorcins.1=$(style.anjuta.keyword)
# Parameter
	style.sorcins.2=$(style.anjuta.attribute)
# Comment line
	style.sorcins.3=$(style.anjuta.comment)
# String
	style.sorcins.4=$(style.anjuta.string)
# Constant
	style.sorcins.9=$(style.anjuta.number)



###############################################################################
# Style for specman from file specman.properties

# White space
	style.specman.0=$(style.anjuta.whitespace)
# Code
	style.specman.1=$(style.anjuta.keyword)
# Line Comment
	style.specman.2=$(style.anjuta.comment)
# Line Bang Comment
	style.specman.3=$(style.anjuta.comment)
# Number
	style.specman.4=$(style.anjuta.number)
# Keyword
	style.specman.5=$(style.anjuta.keyword)
# Double quoted string
	style.specman.6=$(style.anjuta.string)
# Keyword 2
	style.specman.7=$(style.anjuta.extrakeyword)
# Keyword 3
	style.specman.8=$(style.anjuta.syskeyword)
# Preprocessor
	style.specman.9=$(style.anjuta.preprocessor)
# Operators
	style.specman.10=$(style.anjuta.operator)
# End of line where string is not closed
	style.specman.12=$(style.anjuta.error)
# Regexp tag
	style.specman.13=$(style.anjuta.regex)
# HDL Signal
	style.specman.14=$(style.anjuta.attribute)
# User defined
	style.specman.19=$(style.anjuta.localkeyword)



###############################################################################
# Style for spice from file spice.properties

# Default
	style.spice.0=$(style.anjuta.whitespace)
# Keyword
	style.spice.2=$(style.anjuta.keyword)
# Keyword2
	style.spice.3=$(style.anjuta.localkeyword)
# Keyword3
	style.spice.4=$(style.anjuta.syskeyword)
# Number
	style.spice.5=$(style.anjuta.number)
# Operators (delimiters)
	style.spice.6=$(style.anjuta.operator)
# Value
	style.spice.7=$(style.anjuta.char)
# Comment
	style.spice.8=$(style.anjuta.comment)



###############################################################################
# Style for sql from file sql.properties

# White space
	style.sql.0=$(style.anjuta.whitespace)
# Comment
	style.sql.1=$(style.anjuta.comment)
# Line Comment
	style.sql.2=$(style.anjuta.comment)
# Doc comment
	style.sql.3=$(style.anjuta.comment)
# Number
	style.sql.4=$(style.anjuta.number)
# Keyword
	style.sql.5=$(style.anjuta.keyword)
# Double quoted string
	style.sql.6=$(style.anjuta.string)
# Single quoted string
	style.sql.7=$(style.anjuta.char)
# SQL*Plus
	style.sql.8=$(style.anjuta.preprocessor)
# SQL*Plus PROMPT
	style.sql.9=$(style.anjuta.preprocessor)
# Operators
	style.sql.10=$(style.anjuta.operator)
# SQL*Plus Comment
	style.sql.13=$(style.anjuta.comment)
# Hash Line Comment
	style.sql.15=$(style.anjuta.comment)
# Keywords2: Database objects
	style.sql.16=$(style.anjuta.localkeyword)
# Comment Doc Keyword
	style.sql.17=$(style.anjuta.comment)
# Comment Doc Keyword Error
	style.sql.18=$(style.anjuta.comment)
# Keywords5: User Keywords 1
	style.sql.19=$(style.anjuta.syskeyword)
# Keywords6: User Keywords 2
	style.sql.20=$(style.anjuta.extrakeyword)
# Keywords7: User Keywords 3
	style.sql.21=$(style.anjuta.syskeyword)
# Keywords8: User Keywords 4
	style.sql.22=$(style.anjuta.extrakeyword)
# Quoted identifier
	style.sql.23=$(style.anjuta.identifier)
# Q operator
	style.sql.24=$(style.anjuta.operator)



###############################################################################
# Style for srec from file hex.properties

# Record start 'S'
	style.srec.1=$(style.anjuta.preprocessor)
# Record type
	style.srec.2=$(style.anjuta.attribute)
# Record type unknown
	style.srec.3=$(style.anjuta.extrakeyword)
# Byte count field: Correct byte count
	style.srec.4=$(style.anjuta.number)
# Byte count field: Wrong byte count
	style.srec.5=$(style.anjuta.error)
# Address field: No address
	style.srec.6=$(style.anjuta.whitespace)
# Address field: Data address
	style.srec.7=$(style.anjuta.number)
# Address field: Record count
	style.srec.8=$(style.anjuta.number)
# Address field: Start address
	style.srec.9=$(style.anjuta.attribute)
# Address field: Type unknown (this state does not contain any characters)
	style.srec.10=$(style.anjuta.error)
# Data odd
	style.srec.12=$(style.anjuta.string)
# Data field: Position unknown
	style.srec.14=$(style.anjuta.string)
# Checksum field: Correct checksum
	style.srec.16=$(style.anjuta.attribute)
# Checksum field: Wrong checksum
	style.srec.17=$(style.anjuta.error)
# Garbage data after the record
	style.srec.18=$(style.anjuta.comment)



###############################################################################
# Style for tcl from file tcl.properties

# White space
	style.tcl.0=$(style.anjuta.whitespace)
# Comment:.....; #comment
	style.tcl.1=$(style.anjuta.comment)
# Line Comment:  #comment
	style.tcl.2=$(style.anjuta.comment)
# Number and hex number (syntax #[0-f]+)
	style.tcl.3=$(style.anjuta.number)
# Keyword in quote
	style.tcl.4=$(style.anjuta.string)
# In quote
	style.tcl.5=$(style.anjuta.string)
# operator
	style.tcl.6=$(style.anjuta.operator)
# Identifiers
	style.tcl.7=$(style.anjuta.keyword)
# Substitution
	style.tcl.8=$(style.anjuta.preprocessor)
# Substitution starts with a brace ${woow}
	style.tcl.9=$(style.anjuta.preprocessor)
# Modifier -xxx
	style.tcl.10=$(style.anjuta.char)
# Expand (what and odd syntax)
	style.tcl.11=$(style.anjuta.keyword)
# Keywords
	style.tcl.12=$(style.anjuta.localkeyword)
# Keywords 2
	style.tcl.13=$(style.anjuta.syskeyword)
# Keywords 3
	style.tcl.14=$(style.anjuta.extrakeyword)
# Keywords 4
	style.tcl.15=$(style.anjuta.localkeyword)
# Keywords 5
	style.tcl.16=$(style.anjuta.syskeyword)
# Keywords 6
	style.tcl.17=$(style.anjuta.extrakeyword)
# Keywords 7
	style.tcl.18=$(style.anjuta.localkeyword)
# Keywords 8
	style.tcl.19=$(style.anjuta.syskeyword)
#comment box
	style.tcl.20=$(style.anjuta.comment)
#comment block
	style.tcl.21=$(style.anjuta.comment)



###############################################################################
# Style for tehex from file hex.properties

# Same color scheme as above, comments when differing
	style.tehex.0=$(style.anjuta.normal)
# Record start '%'
	style.tehex.1=$(style.anjuta.number)
#
	style.tehex.2=$(style.anjuta.number)
#
	style.tehex.3=$(style.anjuta.number)
#
	style.tehex.4=$(style.anjuta.number)
#
	style.tehex.5=$(style.anjuta.number)
# .6 N/A
	style.tehex.7=$(style.anjuta.error)
# .8 N/A
	style.tehex.9=$(style.anjuta.error)
# Address field: Type unknown (9 digits as usual)
	style.tehex.10=$(style.anjuta.keyword)
# .11 N/A
	style.tehex.12=$(style.anjuta.error)
#
	style.tehex.13=$(style.anjuta.error)
# .15 N/A
	style.tehex.16=$(style.anjuta.error)
#
	style.tehex.17=$(style.anjuta.error)
#
	style.tehex.18=$(style.anjuta.error)



###############################################################################
# Style for tex from file tex.properties

# Default
	style.tex.0=$(style.anjuta.whitespace)
# Special
	style.tex.1=$(style.anjuta.keyword)
# Group
	style.tex.2=$(style.anjuta.identifier)
# Symbol
	style.tex.3=$(style.anjuta.operator)
# Command
	style.tex.4=$(style.anjuta.preprocessor)



###############################################################################
# Style for txt2tags from file txt2tags.properties

# Default
	style.txt2tags.0=$(style.anjuta.normal)
# Special
	style.txt2tags.1=$(style.anjuta.keyword)
# STRONG
	style.txt2tags.2=$(style.anjuta.definition)
# STRONG 2 (not used)
	style.txt2tags.3=$(style.anjuta.function)
# EM1 (italic)
	style.txt2tags.4=$(style.anjuta.attribute)
# EM2 (underline)
	style.txt2tags.5=$(style.anjuta.function)
# H1
	style.txt2tags.6=$(style.anjuta.keyword)
# H2
	style.txt2tags.7=$(style.anjuta.keyword)
# H3
	style.txt2tags.8=$(style.anjuta.keyword)
# H4
	style.txt2tags.9=$(style.anjuta.keyword)
# H5
	style.txt2tags.10=$(style.anjuta.keyword)
# H6
	style.txt2tags.11=$(style.anjuta.keyword)
# prechar (not used)
	style.txt2tags.12=$(style.anjuta.char)
# list
	style.txt2tags.13=$(style.anjuta.operator)
# list
	style.txt2tags.14=$(style.anjuta.operator)
# BLOCKQUOTE
	style.txt2tags.15=$(style.anjuta.string)
# STRIKEOUT
	style.txt2tags.16=$(style.anjuta.unclosed)
# HRULE
	style.txt2tags.17=$(style.anjuta.attribute)
# LINK
	style.txt2tags.18=$(style.anjuta.extrakeyword)
# CODE
	style.txt2tags.19=$(style.anjuta.syskeyword)
# CODE2
	style.txt2tags.20=$(style.anjuta.syskeyword)
# CODEBLOCK
	style.txt2tags.21=$(style.anjuta.syskeyword)
# COMMENT
	style.txt2tags.22=$(style.anjuta.comment)
# OPTION
	style.txt2tags.23=$(style.anjuta.attribute)
# PREPROC
	style.txt2tags.24=$(style.anjuta.preprocessor)
# POSTPROC
	style.txt2tags.25=$(style.anjuta.preprocessor)



###############################################################################
# Style for vb from file vb.properties

# Comment
	style.vb.1=$(style.anjuta.comment)
# Number
	style.vb.2=$(style.anjuta.number)
# Keyword
	style.vb.3=$(style.anjuta.keyword)
# String
	style.vb.4=$(style.anjuta.string)
# Preprocessor (directives)
	style.vb.5=$(style.anjuta.preprocessor)
# Operator
	style.vb.6=$(style.anjuta.operator)
# Date
	style.vb.8=$(style.anjuta.number)
# End of line where string is not closed
	style.vb.9=$(style.anjuta.unclosed)
# Other keywords (bozo test colors :-)
	style.vb.10=$(style.anjuta.localkeyword)
#
	style.vb.11=$(style.anjuta.syskeyword)
#
	style.vb.12=$(style.anjuta.extrakeyword)



###############################################################################
# Style for vbscript from file vb.properties

# VBScript styles same as VB styles
	style.vbscript.0=$(style.anjuta.normal)
#
	style.vbscript.1=$(style.anjuta.comment)
#
	style.vbscript.2=$(style.anjuta.number)
#
	style.vbscript.3=$(style.anjuta.keyword)
#
	style.vbscript.4=$(style.anjuta.string)
#
	style.vbscript.5=$(style.anjuta.preprocessor)
#
	style.vbscript.6=$(style.anjuta.operator)
#
	style.vbscript.7=$(style.anjuta.identifier)
#
	style.vbscript.8=$(style.anjuta.number)
#
	style.vbscript.9=$(style.anjuta.unclosed)
#
	style.vbscript.10=$(style.anjuta.localkeyword)
#
	style.vbscript.11=$(style.anjuta.syskeyword)
#
	style.vbscript.12=$(style.anjuta.extrakeyword)



###############################################################################
# Style for verilog from file verilog.properties

# White space
	style.verilog.0=$(style.anjuta.whitespace)
# Comment
	style.verilog.1=$(style.anjuta.comment)
# Line Comment
	style.verilog.2=$(style.anjuta.comment)
# Bang comment
	style.verilog.3=$(style.anjuta.comment)
# Number
	style.verilog.4=$(style.anjuta.number)
# Keyword
	style.verilog.5=$(style.anjuta.keyword)
# Double quoted string
	style.verilog.6=$(style.anjuta.string)
# Keyword2, Secondary keywords and identifiers
	style.verilog.7=$(style.anjuta.localkeyword)
# keywords3, System tasks
	style.verilog.8=$(style.anjuta.syskeyword)
# Preprocessor
	style.verilog.9=$(style.anjuta.preprocessor)
# Operators
	style.verilog.10=$(style.anjuta.operator)
# End of line where string is not closed
	style.verilog.12=$(style.anjuta.error)
# keywords4, User defined identifiers and tasks
	style.verilog.19=$(style.anjuta.extrakeyword)
# comment keyword
	style.verilog.20=$(style.anjuta.comment)
# port declare (input output ioput)
	style.verilog.21=$(style.anjuta.definition)
#
	style.verilog.22=$(style.anjuta.definition)
#
	style.verilog.23=$(style.anjuta.definition)
# port connection
	style.verilog.24=$(style.anjuta.attribute)
# White space
	style.verilog.64=$(style.anjuta.whitespace)
#
	style.verilog.65=$(style.anjuta.whitespace)
#
	style.verilog.66=$(style.anjuta.whitespace)
#
	style.verilog.67=$(style.anjuta.whitespace)
#
	style.verilog.68=$(style.anjuta.whitespace)
#
	style.verilog.69=$(style.anjuta.whitespace)
#
	style.verilog.70=$(style.anjuta.whitespace)
#
	style.verilog.71=$(style.anjuta.whitespace)
#
	style.verilog.72=$(style.anjuta.whitespace)
#
	style.verilog.73=$(style.anjuta.whitespace)
#
	style.verilog.74=$(style.anjuta.whitespace)
#
	style.verilog.75=$(style.anjuta.whitespace)
#
	style.verilog.76=$(style.anjuta.whitespace)
#
	style.verilog.83=$(style.anjuta.whitespace)
#
	style.verilog.84=$(style.anjuta.whitespace)
#
	style.verilog.85=$(style.anjuta.whitespace)
#
	style.verilog.86=$(style.anjuta.whitespace)
#
	style.verilog.87=$(style.anjuta.whitespace)
#
	style.verilog.88=$(style.anjuta.whitespace)



###############################################################################
# Style for vhdl from file vhdl.properties

# White space
	style.vhdl.0=$(style.anjuta.whitespace)
# Comment
	style.vhdl.1=$(style.anjuta.comment)
# Bang comment
	style.vhdl.2=$(style.anjuta.comment)
# Number
	style.vhdl.3=$(style.anjuta.number)
# Double quoted string
	style.vhdl.4=$(style.anjuta.string)
# End of line where string is not closed
	style.vhdl.7=$(style.anjuta.error)
# Keyword
	style.vhdl.8=$(style.anjuta.keyword)
# Std operator
	style.vhdl.9=$(style.anjuta.operator)
# Attribute
	style.vhdl.10=$(style.anjuta.function)
# Std Function
	style.vhdl.11=$(style.anjuta.syskeyword)
# Std Package
	style.vhdl.12=$(style.anjuta.localkeyword)
# Std Type
	style.vhdl.13=$(style.anjuta.syskeyword)
# User defined identifiers and tasks
	style.vhdl.14=$(style.anjuta.extrakeyword)
# Block comment
	style.vhdl.15=$(style.anjuta.comment)



###############################################################################
# Style for xml from file html.properties

# Default
	style.xml.0=$(style.anjuta.normal)
# Tags
	style.xml.1=$(style.anjuta.keyword)
# Unknown Tags
	style.xml.2=$(style.anjuta.localkeyword)
# Attributes
	style.xml.3=$(style.anjuta.attribute)
# Unknown Attributes
	style.xml.4=$(style.anjuta.syskeyword)
# Numbers
	style.xml.5=$(style.anjuta.number)
# Double quoted strings
	style.xml.6=$(style.anjuta.string)
# Single quoted strings
	style.xml.7=$(style.anjuta.char)
# Other inside tag
	style.xml.8=$(style.anjuta.identifier)
# Comment
	style.xml.9=$(style.anjuta.comment)
# Entities
	style.xml.10=$(style.anjuta.attribute)
# XML style tag ends '/>'
	style.xml.11=$(style.anjuta.keyword)
# XML identifier start '<?'
	style.xml.12=$(style.anjuta.keyword)
# XML identifier end '?>'
	style.xml.13=$(style.anjuta.keyword)
# CDATA
	style.xml.17=$(style.anjuta.raw)
# Question
	style.xml.18=$(style.anjuta.operator)
# Unquoted Value
	style.xml.19=$(style.anjuta.raw)
# SGML tags <! ... >
	style.xml.21=$(style.anjuta.localkeyword)
# SGML command
	style.xml.22=$(style.anjuta.keyword)
# SGML 1st param
	style.xml.23=$(style.anjuta.attribute)
# SGML double string
	style.xml.24=$(style.anjuta.string)
# SGML single string
	style.xml.25=$(style.anjuta.char)
# SGML error
	style.xml.26=$(style.anjuta.error)
# SGML special (#xxxx type)
	style.xml.27=$(style.anjuta.attribute)
# SGML entity
	style.xml.28=$(style.anjuta.attribute)
# SGML comment
	style.xml.29=$(style.anjuta.comment)
# SGML block
	style.xml.31=$(style.anjuta.preprocessor)



###############################################################################
# Style for yaml from file yaml.properties

# default
	style.yaml.0=$(style.anjuta.normal)
# comment line
	style.yaml.1=$(style.anjuta.comment)
# value identifier
	style.yaml.2=$(style.anjuta.identifier)
# keyword value
	style.yaml.3=$(style.anjuta.keyword)
# numerical value
	style.yaml.4=$(style.anjuta.number)
# reference/repeating value
	style.yaml.5=$(style.anjuta.localkeyword)
# document delimiting line
	style.yaml.6=$(style.anjuta.comment)
# text block marker
	style.yaml.7=$(style.anjuta.syskeyword)
# syntax error marker
	style.yaml.8=$(style.anjuta.error)
# operator
	style.yaml.9=$(style.anjuta.operator)