WebSVN – Kolibri OS – Diff – /kernel/trunk/asmxygen.py


import re
import os
import argparse
import sys
 
""" TODO:
    - Optimize name and var_type checking
"""
 
# Parameters
# Path to doxygen folder to make doxygen files in: -o 
doxygen_src_path = 'docs/doxygen'
# Remove generated doxygen files: --clean
clean_generated_stuff = False
# Dump all defined symbols: --dump
dump_symbols = False
# Print symbol stats: --stats
print_stats = False
# Do not write warnings file: --nowarn
enable_warnings = True
 
# Constants
link_root = "http://websvn.kolibrios.org/filedetails.php?repname=Kolibri+OS&path=/kernel/trunk"
 
# fasm keywords
keywords = [
	# Generic keywords
	"align",
	"equ",
	"org",
	"while",
	"load",
	"store",
	"times",
	"repeat",
	"virtual",
	"display",
	"err",
	"assert",
	"if",
	# Instructions
	"aaa",
	"aad",
	"aam",
	"aas",
	"adc",
	"adcx",
	"add",
	"addpd",
	"addps",
	"addsd",
	"addss",
	"addsubpd",
	"addsubps",
	"adox",
	"aesdec",
	"aesdeclast",
	"aesenc",
	"aesenclast",
	"aesimc",
	"aeskeygenassist",
	"and",
	"andn",
	"andnpd",
	"andnps",
	"andpd",
	"andps",
	"arpl",
	"bextr",
	"blendpd",
	"blendps",
	"blendvpd",
	"blendvps",
	"blsi",
	"blsmsk",
	"blsr",
	"bndcl",
	"bndcn",
	"bndcu",
	"bndldx",
	"bndmk",
	"bndmov",
	"bndstx",
	"bound",
	"bsf",
	"bsr",
	"bswap",
	"bt",
	"btc",
	"btr",
	"bts",
	"bzhi",
	"call",
	"cbw",
	"cdq",
	"cdqe",
	"clac",
	"clc",
	"cld",
	"cldemote",
	"clflush",
	"clflushopt",
	"cli",
	"clts",
	"clwb",
	"cmc",
	"cmova",
	"cmovae",
	"cmovb",
	"cmovbe",
	"cmovc",
	"cmove",
	"cmovg",
	"cmovge",
	"cmovl",
	"cmovle",
	"cmovna",
	"cmovnae",
	"cmovnb",
	"cmovnbe",
	"cmovnc",
	"cmovne",
	"cmovng",
	"cmovnge",
	"cmovnl",
	"cmovnle",
	"cmovno",
	"cmovnp",
	"cmovns",
	"cmovnz",
	"cmovo",
	"cmovp",
	"cmovpe",
	"cmovpo",
	"cmovs",
	"cmovz",
	"cmp",
	"cmppd",
	"cmpps",
	"cmps",
	"cmpsb",
	"cmpsd",
	"cmpsd",
	"cmpsq",
	"cmpss",
	"cmpsw",
	"cmpxchg",
	"cmpxchg16b",
	"cmpxchg8b",
	"comisd",
	"comiss",
	"cpuid",
	"cqo",
	"crc32",
	"cvtdq2pd",
	"cvtdq2ps",
	"cvtpd2dq",
	"cvtpd2pi",
	"cvtpd2ps",
	"cvtpi2pd",
	"cvtpi2ps",
	"cvtps2dq",
	"cvtps2pd",
	"cvtps2pi",
	"cvtsd2si",
	"cvtsd2ss",
	"cvtsi2sd",
	"cvtsi2ss",
	"cvtss2sd",
	"cvtss2si",
	"cvttpd2dq",
	"cvttpd2pi",
	"cvttps2dq",
	"cvttps2pi",
	"cvttsd2si",
	"cvttss2si",
	"cwd",
	"cwde",
	"daa",
	"das",
	"dec",
	"div",
	"divpd",
	"divps",
	"divsd",
	"divss",
	"dppd",
	"dpps",
	"emms",
	"enter",
	"extractps",
	"f2xm1",
	"fabs",
	"fadd",
	"faddp",
	"fbld",
	"fbstp",
	"fchs",
	"fclex",
	"fcmova",
	"fcmovae",
	"fcmovb",
	"fcmovbe",
	"fcmovc",
	"fcmove",
	"fcmovg",
	"fcmovge",
	"fcmovl",
	"fcmovle",
	"fcmovna",
	"fcmovnae",
	"fcmovnb",
	"fcmovnbe",
	"fcmovnc",
	"fcmovne",
	"fcmovng",
	"fcmovnge",
	"fcmovnl",
	"fcmovnle",
	"fcmovno",
	"fcmovnp",
	"fcmovns",
	"fcmovnz",
	"fcmovo",
	"fcmovp",
	"fcmovpe",
	"fcmovpo",
	"fcmovs",
	"fcmovz",
	"fcom",
	"fcomi",
	"fcomip",
	"fcomp",
	"fcompp",
	"fcos",
	"fdecstp",
	"fdiv",
	"fdivp",
	"fdivr",
	"fdivrp",
	"ffree",
	"fiadd",
	"ficom",
	"ficomp",
	"fidiv",
	"fidivr",
	"fild",
	"fimul",
	"fincstp",
	"finit",
	"fist",
	"fistp",
	"fisttp",
	"fisub",
	"fisubr",
	"fld",
	"fld1",
	"fldcw",
	"fldenv",
	"fldl2e",
	"fldl2t",
	"fldlg2",
	"fldln2",
	"fldpi",
	"fldz",
	"fmul",
	"fmulp",
	"fnclex",
	"fninit",
	"fnop",
	"fnsave",
	"fnstcw",
	"fnstenv",
	"fnstsw",
	"fpatan",
	"fprem",
	"fprem1",
	"fptan",
	"frndint",
	"frstor",
	"fsave",
	"fscale",
	"fsin",
	"fsincos",
	"fsqrt",
	"fst",
	"fstcw",
	"fstenv",
	"fstp",
	"fstsw",
	"fsub",
	"fsubp",
	"fsubr",
	"fsubrp",
	"ftst",
	"fucom",
	"fucomi",
	"fucomip",
	"fucomp",
	"fucompp",
	"fwait",
	"fxam",
	"fxch",
	"fxrstor",
	"fxsave",
	"fxtract",
	"fyl2x",
	"fyl2xp1",
	"gf2p8affineinvqb",
	"gf2p8affineqb",
	"gf2p8mulb",
	"haddpd",
	"haddps",
	"hlt",
	"hsubpd",
	"hsubps",
	"idiv",
	"imul",
	"in",
	"inc",
	"ins",
	"insb",
	"insd",
	"insertps",
	"insw",
	"int",
	"int1",
	"int3",
	"into",
	"invd",
	"invlpg",
	"invpcid",
	"iret",
	"iretd",
	"jmp",
	"ja",
	"jae",
	"jb",
	"jbe",
	"jc",
	"jcxz",
	"jecxz",
	"je",
	"jg",
	"jge",
	"jl",
	"jle",
	"jna",
	"jnae",
	"jnb",
	"jnbe",
	"jnc",
	"jne",
	"jng",
	"jnge",
	"jnl",
	"jnle",
	"jno",
	"jnp",
	"jns",
	"jnz",
	"jo",
	"jp",
	"jpe",
	"jpo",
	"js",
	"jz",
	"kaddb",
	"kaddd",
	"kaddq",
	"kaddw",
	"kandb",
	"kandd",
	"kandnb",
	"kandnd",
	"kandnq",
	"kandnw",
	"kandq",
	"kandw",
	"kmovb",
	"kmovd",
	"kmovq",
	"kmovw",
	"knotb",
	"knotd",
	"knotq",
	"knotw",
	"korb",
	"kord",
	"korq",
	"kortestb",
	"kortestd",
	"kortestq",
	"kortestw",
	"korw",
	"kshiftlb",
	"kshiftld",
	"kshiftlq",
	"kshiftlw",
	"kshiftrb",
	"kshiftrd",
	"kshiftrq",
	"kshiftrw",
	"ktestb",
	"ktestd",
	"ktestq",
	"ktestw",
	"kunpckbw",
	"kunpckdq",
	"kunpckwd",
	"kxnorb",
	"kxnord",
	"kxnorq",
	"kxnorw",
	"kxorb",
	"kxord",
	"kxorq",
	"kxorw",
	"lahf",
	"lar",
	"lddqu",
	"ldmxcsr",
	"lds",
	"lea",
	"leave",
	"les",
	"lfence",
	"lfs",
	"lgdt",
	"lgs",
	"lidt",
	"lldt",
	"lmsw",
	"lock",
	"lods",
	"lodsb",
	"lodsd",
	"lodsq",
	"lodsw",
	"loop",
	"loopa",
	"loopae",
	"loopb",
	"loopbe",
	"loopc",
	"loope",
	"loopg",
	"loopge",
	"loopl",
	"loople",
	"loopna",
	"loopnae",
	"loopnb",
	"loopnbe",
	"loopnc",
	"loopne",
	"loopng",
	"loopnge",
	"loopnl",
	"loopnle",
	"loopno",
	"loopnp",
	"loopns",
	"loopnz",
	"loopo",
	"loopp",
	"looppe",
	"looppo",
	"loops",
	"loopz",
	"lsl",
	"lss",
	"ltr",
	"lzcnt",
	"maskmovdqu",
	"maskmovq",
	"maxpd",
	"maxps",
	"maxsd",
	"maxss",
	"mfence",
	"minpd",
	"minps",
	"minsd",
	"minss",
	"monitor",
	"mov",
	"movapd",
	"movaps",
	"movbe",
	"movd",
	"movddup",
	"movdir64b",
	"movdiri",
	"movdq2q",
	"movdqa",
	"movdqu",
	"movhlps",
	"movhpd",
	"movhps",
	"movlhps",
	"movlpd",
	"movlps",
	"movmskpd",
	"movmskps",
	"movntdq",
	"movntdqa",
	"movnti",
	"movntpd",
	"movntps",
	"movntq",
	"movq",
	"movq",
	"movq2dq",
	"movs",
	"movsb",
	"movsd",
	"movsd",
	"movshdup",
	"movsldup",
	"movsq",
	"movss",
	"movsw",
	"movsx",
	"movsxd",
	"movupd",
	"movups",
	"movzx",
	"mpsadbw",
	"mul",
	"mulpd",
	"mulps",
	"mulsd",
	"mulss",
	"mulx",
	"mwait",
	"neg",
	"nop",
	"not",
	"or",
	"orpd",
	"orps",
	"out",
	"outs",
	"outsb",
	"outsd",
	"outsw",
	"pabsb",
	"pabsd",
	"pabsq",
	"pabsw",
	"packssdw",
	"packsswb",
	"packusdw",
	"packuswb",
	"paddb",
	"paddd",
	"paddq",
	"paddsb",
	"paddsw",
	"paddusb",
	"paddusw",
	"paddw",
	"palignr",
	"pand",
	"pandn",
	"pause",
	"pavgb",
	"pavgw",
	"pblendvb",
	"pblendw",
	"pclmulqdq",
	"pcmpeqb",
	"pcmpeqd",
	"pcmpeqq",
	"pcmpeqw",
	"pcmpestri",
	"pcmpestrm",
	"pcmpgtb",
	"pcmpgtd",
	"pcmpgtq",
	"pcmpgtw",
	"pcmpistri",
	"pcmpistrm",
	"pdep",
	"pext",
	"pextrb",
	"pextrd",
	"pextrq",
	"pextrw",
	"phaddd",
	"phaddsw",
	"phaddw",
	"phminposuw",
	"phsubd",
	"phsubsw",
	"phsubw",
	"pinsrb",
	"pinsrd",
	"pinsrq",
	"pinsrw",
	"pmaddubsw",
	"pmaddwd",
	"pmaxsb",
	"pmaxsd",
	"pmaxsq",
	"pmaxsw",
	"pmaxub",
	"pmaxud",
	"pmaxuq",
	"pmaxuw",
	"pminsb",
	"pminsd",
	"pminsq",
	"pminsw",
	"pminub",
	"pminud",
	"pminuq",
	"pminuw",
	"pmovmskb",
	"pmovsx",
	"pmovzx",
	"pmuldq",
	"pmulhrsw",
	"pmulhuw",
	"pmulhw",
	"pmulld",
	"pmullq",
	"pmullw",
	"pmuludq",
	"pop",
	"popa",
	"popad",
	"popcnt",
	"popf",
	"popfd",
	"popfq",
	"por",
	"prefetchw",
	"prefetchh",
	"psadbw",
	"pshufb",
	"pshufd",
	"pshufhw",
	"pshuflw",
	"pshufw",
	"psignb",
	"psignd",
	"psignw",
	"pslld",
	"pslldq",
	"psllq",
	"psllw",
	"psrad",
	"psraq",
	"psraw",
	"psrld",
	"psrldq",
	"psrlq",
	"psrlw",
	"psubb",
	"psubd",
	"psubq",
	"psubsb",
	"psubsw",
	"psubusb",
	"psubusw",
	"psubw",
	"ptest",
	"ptwrite",
	"punpckhbw",
	"punpckhdq",
	"punpckhqdq",
	"punpckhwd",
	"punpcklbw",
	"punpckldq",
	"punpcklqdq",
	"punpcklwd",
	"push",
	"pushw",
	"pushd",
	"pusha",
	"pushad",
	"pushf",
	"pushfd",
	"pushfq",
	"pxor",
	"rcl",
	"rcpps",
	"rcpss",
	"rcr",
	"rdfsbase",
	"rdgsbase",
	"rdmsr",
	"rdpid",
	"rdpkru",
	"rdpmc",
	"rdrand",
	"rdseed",
	"rdtsc",
	"rdtscp",
	"rep",
	"repe",
	"repne",
	"repnz",
	"repz",
	"ret",
	"rol",
	"ror",
	"rorx",
	"roundpd",
	"roundps",
	"roundsd",
	"roundss",
	"rsm",
	"rsqrtps",
	"rsqrtss",
	"sahf",
	"sal",
	"sar",
	"sarx",
	"sbb",
	"scas",
	"scasb",
	"scasd",
	"scasw",
	"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",
	"sfence",
	"sgdt",
	"sha1msg1",
	"sha1msg2",
	"sha1nexte",
	"sha1rnds4",
	"sha256msg1",
	"sha256msg2",
	"sha256rnds2",
	"shl",
	"shld",
	"shlx",
	"shr",
	"shrd",
	"shrx",
	"shufpd",
	"shufps",
	"sidt",
	"sldt",
	"smsw",
	"sqrtpd",
	"sqrtps",
	"sqrtsd",
	"sqrtss",
	"stac",
	"stc",
	"std",
	"sti",
	"stmxcsr",
	"stos",
	"stosb",
	"stosd",
	"stosq",
	"stosw",
	"str",
	"sub",
	"subpd",
	"subps",
	"subsd",
	"subss",
	"swapgs",
	"syscall",
	"sysenter",
	"sysexit",
	"sysret",
	"test",
	"tpause",
	"tzcnt",
	"ucomisd",
	"ucomiss",
	"ud",
	"umonitor",
	"umwait",
	"unpckhpd",
	"unpckhps",
	"unpcklpd",
	"unpcklps",
	"valignd",
	"valignq",
	"vblendmpd",
	"vblendmps",
	"vbroadcast",
	"vcompresspd",
	"vcompressps",
	"vcvtpd2qq",
	"vcvtpd2udq",
	"vcvtpd2uqq",
	"vcvtph2ps",
	"vcvtps2ph",
	"vcvtps2qq",
	"vcvtps2udq",
	"vcvtps2uqq",
	"vcvtqq2pd",
	"vcvtqq2ps",
	"vcvtsd2usi",
	"vcvtss2usi",
	"vcvttpd2qq",
	"vcvttpd2udq",
	"vcvttpd2uqq",
	"vcvttps2qq",
	"vcvttps2udq",
	"vcvttps2uqq",
	"vcvttsd2usi",
	"vcvttss2usi",
	"vcvtudq2pd",
	"vcvtudq2ps",
	"vcvtuqq2pd",
	"vcvtuqq2ps",
	"vcvtusi2sd",
	"vcvtusi2ss",
	"vdbpsadbw",
	"verr",
	"verw",
	"vexpandpd",
	"vexpandps",
	"vextractf128",
	"vextractf32x4",
	"vextractf32x8",
	"vextractf64x2",
	"vextractf64x4",
	"vextracti128",
	"vextracti32x4",
	"vextracti32x8",
	"vextracti64x2",
	"vextracti64x4",
	"vfixupimmpd",
	"vfixupimmps",
	"vfixupimmsd",
	"vfixupimmss",
	"vfmadd132pd",
	"vfmadd132ps",
	"vfmadd132sd",
	"vfmadd132ss",
	"vfmadd213pd",
	"vfmadd213ps",
	"vfmadd213sd",
	"vfmadd213ss",
	"vfmadd231pd",
	"vfmadd231ps",
	"vfmadd231sd",
	"vfmadd231ss",
	"vfmaddsub132pd",
	"vfmaddsub132ps",
	"vfmaddsub213pd",
	"vfmaddsub213ps",
	"vfmaddsub231pd",
	"vfmaddsub231ps",
	"vfmsub132pd",
	"vfmsub132ps",
	"vfmsub132sd",
	"vfmsub132ss",
	"vfmsub213pd",
	"vfmsub213ps",
	"vfmsub213sd",
	"vfmsub213ss",
	"vfmsub231pd",
	"vfmsub231ps",
	"vfmsub231sd",
	"vfmsub231ss",
	"vfmsubadd132pd",
	"vfmsubadd132ps",
	"vfmsubadd213pd",
	"vfmsubadd213ps",
	"vfmsubadd231pd",
	"vfmsubadd231ps",
	"vfnmadd132pd",
	"vfnmadd132ps",
	"vfnmadd132sd",
	"vfnmadd132ss",
	"vfnmadd213pd",
	"vfnmadd213ps",
	"vfnmadd213sd",
	"vfnmadd213ss",
	"vfnmadd231pd",
	"vfnmadd231ps",
	"vfnmadd231sd",
	"vfnmadd231ss",
	"vfnmsub132pd",
	"vfnmsub132ps",
	"vfnmsub132sd",
	"vfnmsub132ss",
	"vfnmsub213pd",
	"vfnmsub213ps",
	"vfnmsub213sd",
	"vfnmsub213ss",
	"vfnmsub231pd",
	"vfnmsub231ps",
	"vfnmsub231sd",
	"vfnmsub231ss",
	"vfpclasspd",
	"vfpclassps",
	"vfpclasssd",
	"vfpclassss",
	"vgatherdpd",
	"vgatherdpd",
	"vgatherdps",
	"vgatherdps",
	"vgatherqpd",
	"vgatherqpd",
	"vgatherqps",
	"vgatherqps",
	"vgetexppd",
	"vgetexpps",
	"vgetexpsd",
	"vgetexpss",
	"vgetmantpd",
	"vgetmantps",
	"vgetmantsd",
	"vgetmantss",
	"vinsertf128",
	"vinsertf32x4",
	"vinsertf32x8",
	"vinsertf64x2",
	"vinsertf64x4",
	"vinserti128",
	"vinserti32x4",
	"vinserti32x8",
	"vinserti64x2",
	"vinserti64x4",
	"vmaskmov",
	"vmovdqa32",
	"vmovdqa64",
	"vmovdqu16",
	"vmovdqu32",
	"vmovdqu64",
	"vmovdqu8",
	"vpblendd",
	"vpblendmb",
	"vpblendmd",
	"vpblendmq",
	"vpblendmw",
	"vpbroadcast",
	"vpbroadcastb",
	"vpbroadcastd",
	"vpbroadcastm",
	"vpbroadcastq",
	"vpbroadcastw",
	"vpcmpb",
	"vpcmpd",
	"vpcmpq",
	"vpcmpub",
	"vpcmpud",
	"vpcmpuq",
	"vpcmpuw",
	"vpcmpw",
	"vpcompressd",
	"vpcompressq",
	"vpconflictd",
	"vpconflictq",
	"vperm2f128",
	"vperm2i128",
	"vpermb",
	"vpermd",
	"vpermi2b",
	"vpermi2d",
	"vpermi2pd",
	"vpermi2ps",
	"vpermi2q",
	"vpermi2w",
	"vpermilpd",
	"vpermilps",
	"vpermpd",
	"vpermps",
	"vpermq",
	"vpermt2b",
	"vpermt2d",
	"vpermt2pd",
	"vpermt2ps",
	"vpermt2q",
	"vpermt2w",
	"vpermw",
	"vpexpandd",
	"vpexpandq",
	"vpgatherdd",
	"vpgatherdd",
	"vpgatherdq",
	"vpgatherdq",
	"vpgatherqd",
	"vpgatherqd",
	"vpgatherqq",
	"vpgatherqq",
	"vplzcntd",
	"vplzcntq",
	"vpmadd52huq",
	"vpmadd52luq",
	"vpmaskmov",
	"vpmovb2m",
	"vpmovd2m",
	"vpmovdb",
	"vpmovdw",
	"vpmovm2b",
	"vpmovm2d",
	"vpmovm2q",
	"vpmovm2w",
	"vpmovq2m",
	"vpmovqb",
	"vpmovqd",
	"vpmovqw",
	"vpmovsdb",
	"vpmovsdw",
	"vpmovsqb",
	"vpmovsqd",
	"vpmovsqw",
	"vpmovswb",
	"vpmovusdb",
	"vpmovusdw",
	"vpmovusqb",
	"vpmovusqd",
	"vpmovusqw",
	"vpmovuswb",
	"vpmovw2m",
	"vpmovwb",
	"vpmultishiftqb",
	"vprold",
	"vprolq",
	"vprolvd",
	"vprolvq",
	"vprord",
	"vprorq",
	"vprorvd",
	"vprorvq",
	"vpscatterdd",
	"vpscatterdq",
	"vpscatterqd",
	"vpscatterqq",
	"vpsllvd",
	"vpsllvq",
	"vpsllvw",
	"vpsravd",
	"vpsravq",
	"vpsravw",
	"vpsrlvd",
	"vpsrlvq",
	"vpsrlvw",
	"vpternlogd",
	"vpternlogq",
	"vptestmb",
	"vptestmd",
	"vptestmq",
	"vptestmw",
	"vptestnmb",
	"vptestnmd",
	"vptestnmq",
	"vptestnmw",
	"vrangepd",
	"vrangeps",
	"vrangesd",
	"vrangess",
	"vrcp14pd",
	"vrcp14ps",
	"vrcp14sd",
	"vrcp14ss",
	"vreducepd",
	"vreduceps",
	"vreducesd",
	"vreducess",
	"vrndscalepd",
	"vrndscaleps",
	"vrndscalesd",
	"vrndscaless",
	"vrsqrt14pd",
	"vrsqrt14ps",
	"vrsqrt14sd",
	"vrsqrt14ss",
	"vscalefpd",
	"vscalefps",
	"vscalefsd",
	"vscalefss",
	"vscatterdpd",
	"vscatterdps",
	"vscatterqpd",
	"vscatterqps",
	"vshuff32x4",
	"vshuff64x2",
	"vshufi32x4",
	"vshufi64x2",
	"vtestpd",
	"vtestps",
	"vzeroall",
	"vzeroupper",
	"wait",
	"wbinvd",
	"wrfsbase",
	"wrgsbase",
	"wrmsr",
	"wrpkru",
	"xabort",
	"xacquire",
	"xadd",
	"xbegin",
	"xchg",
	"xend",
	"xgetbv",
	"xlat",
	"xlatb",
	"xor",
	"xorpd",
	"xorps",
	"xrelease",
	"xrstor",
	"xrstors",
	"xsave",
	"xsavec",
	"xsaveopt",
	"xsaves",
	"xsetbv",
	"xtest"
]
 
fasm_types = [
	"db", "rb",
	"dw", "rw",
	"dd", "rd",
	"dp", "rp",
	"df", "rf",
	"dq", "rq",
	"dt", "rt",
	"du",
]
 
# Warning list
warnings = ""
 
# Parse arguments
parser = argparse.ArgumentParser()
parser.add_argument("-o", help="Doxygen output folder")
parser.add_argument("--clean", help="Remove generated files", action="store_true")
parser.add_argument("--dump", help="Dump all defined symbols", action="store_true")
parser.add_argument("--stats", help="Print symbol stats", action="store_true")
parser.add_argument("--nowarn", help="Do not write warnings file", action="store_true")
args = parser.parse_args()
doxygen_src_path = args.o if args.o else 'docs/doxygen'
clean_generated_stuff = args.clean
dump_symbols = args.dump
print_stats = args.stats
enable_warnings = not args.nowarn
 
# Variables, functions, labels, macros, structure types
elements = []
# Names of macroses
macro_names = []
# Names of structs
struct_names = []
# Equated constant names (name = value)
equated_constant_names = []
# Literally equated constant names (name equ value)
equ_names = []
 
class LegacyAsmReader:
	def __init__(self, file):
		self.file = file
		self.lines = open(file, "r", encoding="utf-8").readlines()
		self.line_idx = 0
		self.i = 0
 
	def curr(self):
		try: return self.lines[self.line_idx][self.i]
		except: return ''
 
	def step(self):
		c = self.curr()
		self.i += 1
		# Wrap the line if '\\' followed by whitespaces and/or comment
		while self.curr() == '\\':
			i_of_backslash = self.i
			self.i += 1
			while self.curr().isspace():
				self.i += 1
			if self.curr() == ';' or self.curr() == '':
				self.line_idx += 1
				self.i = 0
			else:
				# There's something other than a comment after the backslash
				# So don't interpret the backslash as a line wrap
				self.i = i_of_backslash
				break
		return c
 
	def nextline(self):
		c = self.curr()
		while c != '':
			c = self.step()
		self.line_idx += 1
		self.i = 0
 
	def no_lines(self):
		if self.line_idx >= len(self.lines):
			return True
		return False
 
	def location(self):	
		return f"{self.file}:{self.line_idx + 1}"
 
	def skip_spaces(self):
		while self.curr().isspace():
			self.step()
 
class AsmReaderRecognizingStrings(LegacyAsmReader):
	def __init__(self, file):
		super().__init__(file)
		self.in_string = None
		self.should_recognize_strings = True
 
	def step(self):
		c = super().step()
		if self.should_recognize_strings and (c == '"' or c == "'"):
			# If just now we was at the double or single quotation mark
			# and we aren't in a string yet
			# then say "we are in a string openned with this quotation mark now"
			if self.in_string == None:
				self.in_string = c
			# If just now we was at the double or single quotation mark
			# and we are in the string entered with the same quotation mark
			# then say "we aren't in a string anymore"
			elif self.in_string == c:
				self.in_string = None
		return c
 
class AsmReaderReadingComments(AsmReaderRecognizingStrings):
	def __init__(self, file):
		super().__init__(file)
		self.status = dict()
		self.status_reset()
		self.comment = ''
 
	def status_reset(self):
		# If the line has non-comment code
		self.status_has_code = False
		# If the line has a comment at the end
		self.status_has_comment = False
		# Let it recognize strings further, we are definitely out of a comment
		self.should_recognize_strings = True
 
	def status_set_has_comment(self):
		self.status_has_comment = True
		# Don't let it recognize strings cause we are in a comment now
		self.should_recognize_strings = False
 
	def status_set_has_code(self):
		self.status_has_code = True
 
	def update_status(self):
		# If we aren't in a comment and we aren't in a string - say we are now in a comment if ';' met
		if not self.status_has_comment and not self.in_string and self.curr() == ';':
			self.status_set_has_comment()
		# Else if we are in a comment - collect the comment
		elif self.status_has_comment:
			self.comment += self.curr()
		# Else if there's some non-whitespace character out of a comment
		# then the line has code
		elif not self.status_has_comment and not self.curr().isspace():
			self.status_set_has_code()
 
	def step(self):
		# Get to the next character
		c = super().step()
		# Update status of the line according to the next character
		self.update_status()
		return c
 
	def nextline(self):
		super().nextline()
		# If the line we leave was not a comment-only line
		# then forget the collected comment
		# Otherwise the collected comment should be complemented by comment from next line in step()
		if self.status_has_code:
			self.comment = ''
		# Reset the line status (now it's the status of the new line)
		self.status_reset()
		# Set new status for this line according to the first character in the line
		self.update_status()
 
class AsmReaderFetchingIdentifiers(AsmReaderReadingComments):
	def __init__(self, file):
		super().__init__(file)
 
	def fetch_identifier(self):
		self.skip_spaces()
		result = ''
		while is_id(self.curr()):
			result += self.step()
		return result
 
class AsmReader(AsmReaderFetchingIdentifiers):
	def __init__(self, file):
		super().__init__(file)
 
created_files = []
 
class AsmElement:
	def __init__(self, location, name, comment):
		self.location = location
		self.file = self.location.split(':')[0].replace('\\', '/')
		self.line = self.location.split(':')[1]
		self.name = name
		self.comment = comment
 
	def dump(self):
		print(f"{self.comment}")
		print(f"{self.location}: {self.name}")
 
	def emit(self, dest, doxycomment = '', declaration = ''):
		global warnings
		# Redefine default declaration
		if declaration == '':
			declaration = f'#define {self.name}'
		# Check doxycomment
		if not doxycomment.endswith('\n'):
			doxycomment += '\n'
		if doxycomment.split('@brief ')[1][0].islower():
			warnings += f"{self.location}: Brief comment starting from lowercase\n"
		# Build contents to emit
		contents = ''
		contents += '/**\n'
		contents += doxycomment
		contents += (f"@par Source\n" +
		             f"{self.file}:{self.line}\n")
		contents += '*/\n'
		contents += declaration
		contents += '\n\n'
		# Get path to file to emit this
		full_path = dest + '/' + self.file
		# Remove the file on first access if it was created by previous generation
		if full_path not in created_files:
			if os.path.isfile(full_path):
				os.remove(full_path)
			created_files.append(full_path)
		# Create directories need for the file
		os.makedirs(os.path.dirname(full_path), exist_ok=True)
		f = open(full_path, "a")
		contents = ''.join([i if ord(i) < 128 else '?' for i in contents])
		f.write(contents)
		f.close()
 
class AsmVariable(AsmElement):
	def __init__(self, location, name, comment, type, init):
		super().__init__(location, name, comment)
		self.type = type
		self.init = init
 
	def dump(self):
		super().dump()
		print(f"Variable")
 
	def emit(self, dest):
		# Build doxycomment specific for the variable
		doxycomment = ''
		doxycomment += self.comment
		if '@brief' not in doxycomment:
			doxycomment = '@brief ' + doxycomment
		doxycomment += (f"@par Initial value\n" +
		                f"{self.init}\n")
		# Build the declaration
		name = self.name.replace(".", "_")
		var_type = self.type.replace(".", "_")
		declaration = f"{var_type} {name};"
		# Emit this
		super().emit(dest, doxycomment, declaration)
 
class AsmFunction(AsmElement):
	def __init__(self, location, name, comment, calling_convention, args, used_regs):
		super().__init__(location, name, comment)
		self.calling_convention = calling_convention
		self.args = args
		self.used_regs = used_regs
 
	def dump(self):
		super().dump()
		print(f"Function")
 
	def emit(self, dest):
		# Build doxycomment specific for the variable
		doxycomment = ''
		doxycomment += self.comment
		if '@brief' not in doxycomment:
			doxycomment = '@brief ' + doxycomment
		# Build the arg list for declaration
		arg_list = '('
		if len(self.args) > 0:
			argc = 0
			for arg in self.args:
				if argc != 0:
					arg_list += ", "
				arg_list += f"{arg[1]} {arg[0]}"
				argc += 1
		arg_list += ')'
		# Build the declaration
		name = self.name.replace(".", "_")
		declaration = f"void {name}{arg_list};"
		# Emit this
		super().emit(dest, doxycomment, declaration)
 
class AsmLabel(AsmElement):
	def __init__(self, location, name, comment):
		super().__init__(location, name, comment)
 
	def dump(self):
		super().dump()
		print(f"Label")
 
	def emit(self, dest):
		# Build doxycomment specific for the variable
		doxycomment = ''
		doxycomment += self.comment
		if '@brief' not in doxycomment:
			doxycomment = '@brief ' + doxycomment
		# Build the declaration
		name = self.name.replace(".", "_")
		declaration = f"label {name};"
		# Emit this
		super().emit(dest, doxycomment, declaration)
 
class AsmMacro(AsmElement):
	def __init__(self, location, name, comment, args):
		super().__init__(location, name, comment)
		self.args = args
 
	def dump(self):
		super().dump()
		print(f"Macro")
		print(f"Parameters: {self.args}")
 
	def emit(self, dest):
		# Construct arg list without '['s, ']'s and '*'s
		args = [arg for arg in self.args if arg not in "[]*"]
		# Construct C-like arg list
		arg_list = ""
		if len(args) > 0:
			arg_list += '('
			argc = 0
			for arg in args:
				if argc != 0:
					arg_list += ", "
				arg_list += arg
				argc += 1
			arg_list += ')'
		# Build doxycomment
		doxycomment = ''
		doxycomment += self.comment
		if '@brief' not in doxycomment:
			doxycomment = '@brief ' + doxycomment
		# Build declaration
		declaration = f"#define {self.name}{arg_list}"
		# Emit this
		super().emit(dest, doxycomment, declaration)
 
class AsmStruct(AsmElement):
	def __init__(self, location, name, comment, members):
		super().__init__(location, name, comment)
		self.members = members
 
	def dump(self):
		super().dump()
		print(f"Struct")
 
	def emit(self, dest):
		# Build doxycomment
		doxycomment = ''
		doxycomment += self.comment
		if '@brief' not in doxycomment:
			doxycomment = '@brief ' + doxycomment
		doxycomment += '\n'
		# Build declaration
		declaration = f"struct {self.name}" + " {\n"
		for member in self.members:
			if type(member) == AsmVariable:
				declaration += f'\t{member.type} {member.name}; /**< {member.comment} */\n'
		declaration += '};'
		# Emit this
		super().emit(dest, doxycomment, declaration)
 
class AsmUnion(AsmElement):
	def __init__(self, location, name, comment, members):
		super().__init__(location, name, comment)
		self.members = members
 
	def dump(self):
		super().dump()
		print(f"Union")
 
	def emit(self, dest):
		# Build doxycomment
		doxycomment = ''
		doxycomment += self.comment
		if '@brief' not in doxycomment:
			doxycomment = '@brief ' + doxycomment
		# Build declaration
		declaration = f"union {self.name}" + " {};"
		# Emit this
		super().emit(dest, doxycomment, declaration)
 
class VariableNameIsMacroName:
	def __init__(self, name):
		self.name = name
 
def is_id(c):
	return c.isprintable() and c not in "+-/*=<>()[]{};:,|&~#`'\" \n\r\t\v"
 
def is_starts_as_id(s):
	return not s[0].isdigit()
 
def parse_after_macro(r):
	location = r.location()
 
	# Skip spaces after the "macro" keyword
	r.skip_spaces()
	# Read macro name
	name = ""
	while is_id(r.curr()) or r.curr() == '#':
		name += r.step()
	# Skip spaces after macro name
	r.skip_spaces()
	# Find all arguments
	args = []
	arg = ''
	while r.curr() and r.curr() != ';' and r.curr() != '{':
		# Collect identifier
		if is_id(r.curr()):
			arg += r.step()
		# Save the collected identifier
		elif r.curr() == ',':
			args.append(arg)
			arg = ''
			r.step()
		# Just push the '['
		elif r.curr() == '[':
			args.append(r.step())
		# Just push the identifier and get ']' ready to be pushed on next comma
		elif r.curr() == ']':
			args.append(arg)
			arg = r.step()
		# Just push the identifier and get '*' ready to be pushed on next comma
		elif r.curr() == '*':
			args.append(arg)
			arg = r.step()
		# Just skip whitespaces
		elif r.curr().isspace():
			r.step()
		# Something unexpected
		else:
			raise Exception(f"Unexpected symbol '{r.curr()}' at index #{r.i} " + 
			                f"in the macro declaration at {location} " +
			                f"(line: {r.lines[r.line_idx]})\n''")
	# Append the last argument
	if arg != '':
		args.append(arg)
	# Skip t spaces after the argument list
	r.skip_spaces()
	# Get a comment if it is: read till the end of the line and get the comment from the reader
	while r.curr() != '':
		r.step()
	comment = r.comment
	# Find end of the macro
	prev = ''
	while True:
		if r.curr() == '}' and prev != '\\':
			break
		elif r.curr() == '':
			prev = ''
			r.nextline()
			continue
		prev = r.step()
	# Build the output
	return AsmMacro(location, name, comment, args)
 
def parse_variable(r, first_word = None):
	global warnings
	location = r.location()
 
	# Skip spaces before variable name
	r.skip_spaces()
	# Get variable name
	name = ""
	# Read it if it was not supplied
	if first_word == None:
		while is_id(r.curr()):
			name += r.step()
	# Or use the supplied one instead
	else:
		name = first_word
	# Check the name
	# If it's 0 len, that means threr's something else than an identifier at the beginning
	if len(name) == 0:
		return None
	# If it starts from digit or othervice illegally it's illegal
	if not is_starts_as_id(name):
		return None
	# If it's a keyword, that's not a variable declaration
	if name in keywords:
		return None
	# If it's a macro name, that's not a variable declaration
	if name in macro_names:
		return VariableNameIsMacroName(name)
	# If it's a datatype or a structure name that's not a variable declaration: that's just a data
	# don't document just a data for now
	if name in struct_names or name in fasm_types:
		return None
	# Skip spaces before type name
	r.skip_spaces()
	# Read type name
	var_type = ""
	while is_id(r.curr()):
		var_type += r.step()
	# Check the type name
	if len(var_type) == 0:
		# If there's no type identifier after the name
		# maybe the name is something meaningful for the next parser
		# return it
		return name
	# If it starts from digit or othervice illegally it's illegal
	if not is_starts_as_id(var_type):
		return None
	# If it's a keyword, that's not a variable declaration
	# return the two words of the lexical structure
	if var_type in keywords:
		return (name, var_type)
	# Skip spaces before the value
	r.skip_spaces()
	# Read the value until the comment or end of the line
	value = ""
	while r.curr() != ';' and r.curr() != '' and r.curr() != '\n':
		value += r.step()
	# Skip spaces after the value
	r.skip_spaces()
	# Read till end of the line to get a comment from the reader
	while r.curr() != '':
		r.step()
	# Build the result
	return AsmVariable(location, name, r.comment, var_type, value)
 
def parse_after_struct(r, as_union = True):
	global warnings
	location = r.location()
 
	# Skip spaces after "struct" keyword
	r.skip_spaces()
	# Read struct name
	name = ""
	while is_id(r.curr()):
		name += r.step()
	# Read till end of the line and get the comment from the reader
	while r.curr() != '':
		r.step()
	comment = r.comment
	# Get to the next line to parse struct members
	r.nextline()
	# Parse struct members
	members = []
	while True:
		r.skip_spaces()
		var = parse_variable(r)
		if type(var) == AsmVariable:
			members.append(var)
		elif type(var) == str:
			if var == 'union':
				# Parse the union as a struct
				union = parse_after_struct(r, as_union = True)
				members.append(union)
				# Skip the ends of the union
				r.nextline()
			elif r.curr() == ':':
				warnings += f"{r.location()}: Skept the label in the struct\n"
			else:
				raise Exception(f"Garbage in struct member at {location} (got '{var}' identifier)")
		elif type(var) == VariableNameIsMacroName:
			if var.name == 'ends':
				break
		r.nextline()
	# Return the result
	if as_union:
		return AsmStruct(location, name, comment, members)
	else:
		return AsmUnion(location, name, comment, members)
 
def parse_after_proc(r):
	# Get proc name
	name = r.fetch_identifier()
	# Next identifier after the proc name
	identifier = r.fetch_identifier()
	# Check if the id is 'stdcall' or 'c' (calling convention specifier)
	# and if so - save the convention and lookup the next identifier
	calling_convention = ''
	if identifier == 'stdcall' or identifier == 'c':
		calling_convention = identifier
		# If next is a comma, just skip it
		if r.curr() == ',':
			r.step()
		# Read the next identifier
		identifier = r.fetch_identifier()
	# Check if the id is 'uses' (used register list specifier)
	# and if so save the used register list
	used_regs = []
	if identifier == 'uses':
		# Read the registers
		while True:
			reg_name = r.fetch_identifier()
			if reg_name != '':
				used_regs.append(reg_name)
			else:
				break
		# If next is a comma, just skip it
		if r.curr() == ',':
			r.step()
		# Read the next identifier
		identifier = r.fetch_identifier()
	# Check if there are argument identifiers
	args = []
	while identifier != '':
		arg_name = identifier
		arg_type = 'arg_t'
		# Skip spaces after argument name
		r.skip_spaces()
		# If there's a ':' after the name - the next identifier is type
		if r.curr() == ':':
			r.step()
			arg_type = r.fetch_identifier()
		# If there's a comma - there's one more argument
		# else no arguments anymore
		if r.curr() == ',':
			r.step()
			identifier = r.fetch_identifier()
		else:
			identifier = ''
		args.append((arg_name, arg_type))
	# Get to the end of the line and get a comment from the reader
	while r.curr() != '':
		r.step()
	comment = r.comment
	# Build the element
	return AsmFunction(r.location(), name, comment, calling_convention, args, used_regs)
 
def get_declarations(asm_file_contents, asm_file_name):
	r = AsmReader(asm_file_name)
 
	while not r.no_lines():
		# Skip leading spaces
		r.skip_spaces()
		# Skip the line if it's starting with a comment
		if r.curr() == ';':
			r.nextline()
			continue
		# Get first word
		first_word = ""
		while is_id(r.curr()):
			first_word += r.step()
		# Match macro declaration
		if first_word == "macro":
			macro = parse_after_macro(r)
			elements.append(macro)
			macro_names.append(macro.name)
		# Match structure declaration
		elif first_word == "struct":
			struct = parse_after_struct(r)
			elements.append(struct)
			struct_names.append(struct.name)
		# Match function definition
		elif first_word == "proc":
			proc = parse_after_proc(r)
			elements.append(proc)
		elif first_word == 'format':
			# Skip the format directive
			pass
		elif first_word == 'include':
			# Skip the include directive
			pass
		elif first_word == 'if':
			# Skip the conditional directive
			pass
		elif first_word == 'repeat':
			# Skip the repeat directive
			pass
		elif first_word == 'purge':
			while True:
				# Skip spaces after the 'purge' keyword or after the comma what separated the previous macro name
				r.skip_spaces()
				# Get the purged macro name
				name = ''
				while is_id(r.curr()):
					name += r.step()
				# Remove the purged macro from the macro names list
				try:
					macro_names.remove(name)
				except:
					pass
				# Skip spaces after the name
				r.skip_spaces()
				# If it's comma (',') after then that's not the last purged macro, continue purging
				if r.curr() == ',':
					r.step()
					continue
				# Here we purged all the macros should be purged
				break
		# Match label or a variable
		elif len(first_word) != 0:
			# Skip spaces after the identifier
			r.skip_spaces()
			# Match a variable
			var = parse_variable(r, first_word)
			if type(var) == AsmVariable:
				elements.append(var)
			# If it wasn't a variable but there was an identifier
			# Maybe that's a label and the identifier is the label name
			# The parse_variable returns the first found or supplied identifier
			# In this case it returns the first_word which is supplied
			# If it didn't match a type identifier after the word
			elif type(var) == str:
				name = var
				# Match label beginning (':' after name)
				if r.curr() == ':':
					# Get to the end of the line and get the coment from the reader
					while r.curr() != '':
						r.step()
					comment = r.comment
					# Only handle non-local labels
					if name[0] != '.' and name != "@@" and name != "$Revision":
						elements.append(AsmLabel(r.location(), name, comment))
				elif r.curr() == '=':
					# Add the equated constant (name = value) to equated constants list
					equated_constant_names.append(first_word)
			elif type(var) == tuple:
				(word_one, word_two) = var
				if word_two == 'equ':
					# Add the name to equ names list
					equ_names.append(word_one)
		r.nextline()
 
def it_neds_to_be_parsed(source_file):
	dest = doxygen_src_path + '/' + source_file
	# If there's no the doxygen file it should be compiled to
	# then yes, we should compile it to doxygen
	if not os.path.isfile(dest):
		return True
	source_change_time = os.path.getmtime(source_file)
	dest_change_file = os.path.getmtime(dest)
	# If the source is newer than the doxygen it was compiled to
	# then the source should be recompiled (existing doxygen is old)
	if source_change_time > dest_change_file:
		return True
	return False
 
def handle_file(handled_files, asm_file_name, subdir = "."):
	# Canonicalize the file path and get it relative to cwd
	cwd = os.path.abspath(os.path.dirname(sys.argv[0]))
	asm_file_name = os.path.realpath(asm_file_name)
	asm_file_name = asm_file_name[len(cwd) + 1:]
	# If it's lang.inc - skip it
	if asm_file_name == 'lang.inc':
		return
	# If the file was handled in this execution before - skip it
	if asm_file_name in handled_files:
		return
	# Say that the file was handled in this execution
	handled_files.append(asm_file_name)
	# Check if the file should be parsed (if it was modified or wasn't parsed yet)
	should_get_declarations = True
	if not it_neds_to_be_parsed(asm_file_name):
		print(f"Skipping {asm_file_name} (already newest)")
		should_get_declarations = False
	else:
		print(f"Handling {asm_file_name}")
	# Read the source
	asm_file_contents = open(asm_file_name, "r", encoding="utf-8").read()
	# Find includes, fix their paths and handle em recoursively
	includes = re.findall(r'^include (["\'])(.*)\1', asm_file_contents, flags=re.MULTILINE)
	for include in includes:
		include = include[1].replace('\\', '/');
		full_path = subdir + '/' + include;
		# If the path isn't valid, maybe that's not relative path
		if not os.path.isfile(full_path):
			full_path = include
		new_subdir = full_path.rsplit('/', 1)[0]
		handle_file(handled_files, full_path, new_subdir)
	# Only collect declarations from the file if it wasn't parsed before
	if should_get_declarations and not clean_generated_stuff:
		get_declarations(asm_file_contents, asm_file_name)
 
kernel_files = []
 
handle_file(kernel_files, "./kernel.asm");
 
if dump_symbols:
	for asm_element in elements:
		asm_element.dump()
 
if print_stats:
	print("--stats is not nimplmented")
 
if clean_generated_stuff:
	kernel_files_set = set(kernel_files)
	for file in kernel_files:
		doxygen_file = f"{doxygen_src_path}/{file}"
		if (os.path.isfile(doxygen_file)):
			print(f"Removing {file}... ", end = '')
			os.remove(doxygen_file)
			print("Done.")
else:
	print(f"Writing doumented sources to {doxygen_src_path}")
 
	i = 0
	for element in elements:
		print(f"[{i + 1}/{len(elements)}] Emitting {element.name} from {element.location}")
		element.emit(doxygen_src_path)
		i += 1
 
if enable_warnings:
	open('asmxygen.txt', "w", encoding = "utf-8").write(warnings)

Rev 8974	Rev 8975
1	import re	1	import re
2	import os	2	import os
3	import argparse	3	import argparse
4	import sys	4	import sys
5		5
6	""" TODO:	6	""" TODO:
7	- Optimize name and var_type checking	7	- Optimize name and var_type checking
8	"""	8	"""
9		9
10	# Parameters	10	# Parameters
11	# Path to doxygen folder to make doxygen files in: -o	11	# Path to doxygen folder to make doxygen files in: -o
12	doxygen_src_path = 'docs/doxygen'	12	doxygen_src_path = 'docs/doxygen'
13	# Remove generated doxygen files: --clean	13	# Remove generated doxygen files: --clean
14	clean_generated_stuff = False	14	clean_generated_stuff = False
15	# Dump all defined symbols: --dump	15	# Dump all defined symbols: --dump
16	dump_symbols = False	16	dump_symbols = False
17	# Print symbol stats: --stats	17	# Print symbol stats: --stats
18	print_stats = False	18	print_stats = False
19	# Do not write warnings file: --nowarn	19	# Do not write warnings file: --nowarn
20	enable_warnings = True	20	enable_warnings = True
21		21
22	# Constants	22	# Constants
23	link_root = "http://websvn.kolibrios.org/filedetails.php?repname=Kolibri+OS&path=/kernel/trunk"	23	link_root = "http://websvn.kolibrios.org/filedetails.php?repname=Kolibri+OS&path=/kernel/trunk"
24		24
25	# fasm keywords	25	# fasm keywords
26	keywords = [	26	keywords = [
27	# Generic keywords	27	# Generic keywords
28	"align",	28	"align",
29	"equ",	29	"equ",
30	"org",	30	"org",
31	"while",	31	"while",
32	"load",	32	"load",
33	"store",	33	"store",
34	"times",	34	"times",
35	"repeat",	35	"repeat",
36	"virtual",	36	"virtual",
37	"display",	37	"display",
38	"err",	38	"err",
39	"assert",	39	"assert",
40	"if",	40	"if",
41	# Instructions	41	# Instructions
42	"aaa",	42	"aaa",
43	"aad",	43	"aad",
44	"aam",	44	"aam",
45	"aas",	45	"aas",
46	"adc",	46	"adc",
47	"adcx",	47	"adcx",
48	"add",	48	"add",
49	"addpd",	49	"addpd",
50	"addps",	50	"addps",
51	"addsd",	51	"addsd",
52	"addss",	52	"addss",
53	"addsubpd",	53	"addsubpd",
54	"addsubps",	54	"addsubps",
55	"adox",	55	"adox",
56	"aesdec",	56	"aesdec",
57	"aesdeclast",	57	"aesdeclast",
58	"aesenc",	58	"aesenc",
59	"aesenclast",	59	"aesenclast",
60	"aesimc",	60	"aesimc",
61	"aeskeygenassist",	61	"aeskeygenassist",
62	"and",	62	"and",
63	"andn",	63	"andn",
64	"andnpd",	64	"andnpd",
65	"andnps",	65	"andnps",
66	"andpd",	66	"andpd",
67	"andps",	67	"andps",
68	"arpl",	68	"arpl",
69	"bextr",	69	"bextr",
70	"blendpd",	70	"blendpd",
71	"blendps",	71	"blendps",
72	"blendvpd",	72	"blendvpd",
73	"blendvps",	73	"blendvps",
74	"blsi",	74	"blsi",
75	"blsmsk",	75	"blsmsk",
76	"blsr",	76	"blsr",
77	"bndcl",	77	"bndcl",
78	"bndcn",	78	"bndcn",
79	"bndcu",	79	"bndcu",
80	"bndldx",	80	"bndldx",
81	"bndmk",	81	"bndmk",
82	"bndmov",	82	"bndmov",
83	"bndstx",	83	"bndstx",
84	"bound",	84	"bound",
85	"bsf",	85	"bsf",
86	"bsr",	86	"bsr",
87	"bswap",	87	"bswap",
88	"bt",	88	"bt",
89	"btc",	89	"btc",
90	"btr",	90	"btr",
91	"bts",	91	"bts",
92	"bzhi",	92	"bzhi",
93	"call",	93	"call",
94	"cbw",	94	"cbw",
95	"cdq",	95	"cdq",
96	"cdqe",	96	"cdqe",
97	"clac",	97	"clac",
98	"clc",	98	"clc",
99	"cld",	99	"cld",
100	"cldemote",	100	"cldemote",
101	"clflush",	101	"clflush",
102	"clflushopt",	102	"clflushopt",
103	"cli",	103	"cli",
104	"clts",	104	"clts",
105	"clwb",	105	"clwb",
106	"cmc",	106	"cmc",
107	"cmova",	107	"cmova",
108	"cmovae",	108	"cmovae",
109	"cmovb",	109	"cmovb",
110	"cmovbe",	110	"cmovbe",
111	"cmovc",	111	"cmovc",
112	"cmove",	112	"cmove",
113	"cmovg",	113	"cmovg",
114	"cmovge",	114	"cmovge",
115	"cmovl",	115	"cmovl",
116	"cmovle",	116	"cmovle",
117	"cmovna",	117	"cmovna",
118	"cmovnae",	118	"cmovnae",
119	"cmovnb",	119	"cmovnb",
120	"cmovnbe",	120	"cmovnbe",
121	"cmovnc",	121	"cmovnc",
122	"cmovne",	122	"cmovne",
123	"cmovng",	123	"cmovng",
124	"cmovnge",	124	"cmovnge",
125	"cmovnl",	125	"cmovnl",
126	"cmovnle",	126	"cmovnle",
127	"cmovno",	127	"cmovno",
128	"cmovnp",	128	"cmovnp",
129	"cmovns",	129	"cmovns",
130	"cmovnz",	130	"cmovnz",
131	"cmovo",	131	"cmovo",
132	"cmovp",	132	"cmovp",
133	"cmovpe",	133	"cmovpe",
134	"cmovpo",	134	"cmovpo",
135	"cmovs",	135	"cmovs",
136	"cmovz",	136	"cmovz",
137	"cmp",	137	"cmp",
138	"cmppd",	138	"cmppd",
139	"cmpps",	139	"cmpps",
140	"cmps",	140	"cmps",
141	"cmpsb",	141	"cmpsb",
142	"cmpsd",	142	"cmpsd",
143	"cmpsd",	143	"cmpsd",
144	"cmpsq",	144	"cmpsq",
145	"cmpss",	145	"cmpss",
146	"cmpsw",	146	"cmpsw",
147	"cmpxchg",	147	"cmpxchg",
148	"cmpxchg16b",	148	"cmpxchg16b",
149	"cmpxchg8b",	149	"cmpxchg8b",
150	"comisd",	150	"comisd",
151	"comiss",	151	"comiss",
152	"cpuid",	152	"cpuid",
153	"cqo",	153	"cqo",
154	"crc32",	154	"crc32",
155	"cvtdq2pd",	155	"cvtdq2pd",
156	"cvtdq2ps",	156	"cvtdq2ps",
157	"cvtpd2dq",	157	"cvtpd2dq",
158	"cvtpd2pi",	158	"cvtpd2pi",
159	"cvtpd2ps",	159	"cvtpd2ps",
160	"cvtpi2pd",	160	"cvtpi2pd",
161	"cvtpi2ps",	161	"cvtpi2ps",
162	"cvtps2dq",	162	"cvtps2dq",
163	"cvtps2pd",	163	"cvtps2pd",
164	"cvtps2pi",	164	"cvtps2pi",
165	"cvtsd2si",	165	"cvtsd2si",
166	"cvtsd2ss",	166	"cvtsd2ss",
167	"cvtsi2sd",	167	"cvtsi2sd",
168	"cvtsi2ss",	168	"cvtsi2ss",
169	"cvtss2sd",	169	"cvtss2sd",
170	"cvtss2si",	170	"cvtss2si",
171	"cvttpd2dq",	171	"cvttpd2dq",
172	"cvttpd2pi",	172	"cvttpd2pi",
173	"cvttps2dq",	173	"cvttps2dq",
174	"cvttps2pi",	174	"cvttps2pi",
175	"cvttsd2si",	175	"cvttsd2si",
176	"cvttss2si",	176	"cvttss2si",
177	"cwd",	177	"cwd",
178	"cwde",	178	"cwde",
179	"daa",	179	"daa",
180	"das",	180	"das",
181	"dec",	181	"dec",
182	"div",	182	"div",
183	"divpd",	183	"divpd",
184	"divps",	184	"divps",
185	"divsd",	185	"divsd",
186	"divss",	186	"divss",
187	"dppd",	187	"dppd",
188	"dpps",	188	"dpps",
189	"emms",	189	"emms",
190	"enter",	190	"enter",
191	"extractps",	191	"extractps",
192	"f2xm1",	192	"f2xm1",
193	"fabs",	193	"fabs",
194	"fadd",	194	"fadd",
195	"faddp",	195	"faddp",
196	"fbld",	196	"fbld",
197	"fbstp",	197	"fbstp",
198	"fchs",	198	"fchs",
199	"fclex",	199	"fclex",
200	"fcmova",	200	"fcmova",
201	"fcmovae",	201	"fcmovae",
202	"fcmovb",	202	"fcmovb",
203	"fcmovbe",	203	"fcmovbe",
204	"fcmovc",	204	"fcmovc",
205	"fcmove",	205	"fcmove",
206	"fcmovg",	206	"fcmovg",
207	"fcmovge",	207	"fcmovge",
208	"fcmovl",	208	"fcmovl",
209	"fcmovle",	209	"fcmovle",
210	"fcmovna",	210	"fcmovna",
211	"fcmovnae",	211	"fcmovnae",
212	"fcmovnb",	212	"fcmovnb",
213	"fcmovnbe",	213	"fcmovnbe",
214	"fcmovnc",	214	"fcmovnc",
215	"fcmovne",	215	"fcmovne",
216	"fcmovng",	216	"fcmovng",
217	"fcmovnge",	217	"fcmovnge",
218	"fcmovnl",	218	"fcmovnl",
219	"fcmovnle",	219	"fcmovnle",
220	"fcmovno",	220	"fcmovno",
221	"fcmovnp",	221	"fcmovnp",
222	"fcmovns",	222	"fcmovns",
223	"fcmovnz",	223	"fcmovnz",
224	"fcmovo",	224	"fcmovo",
225	"fcmovp",	225	"fcmovp",
226	"fcmovpe",	226	"fcmovpe",
227	"fcmovpo",	227	"fcmovpo",
228	"fcmovs",	228	"fcmovs",
229	"fcmovz",	229	"fcmovz",
230	"fcom",	230	"fcom",
231	"fcomi",	231	"fcomi",
232	"fcomip",	232	"fcomip",
233	"fcomp",	233	"fcomp",
234	"fcompp",	234	"fcompp",
235	"fcos",	235	"fcos",
236	"fdecstp",	236	"fdecstp",
237	"fdiv",	237	"fdiv",
238	"fdivp",	238	"fdivp",
239	"fdivr",	239	"fdivr",
240	"fdivrp",	240	"fdivrp",
241	"ffree",	241	"ffree",
242	"fiadd",	242	"fiadd",
243	"ficom",	243	"ficom",
244	"ficomp",	244	"ficomp",
245	"fidiv",	245	"fidiv",
246	"fidivr",	246	"fidivr",
247	"fild",	247	"fild",
248	"fimul",	248	"fimul",
249	"fincstp",	249	"fincstp",
250	"finit",	250	"finit",
251	"fist",	251	"fist",
252	"fistp",	252	"fistp",
253	"fisttp",	253	"fisttp",
254	"fisub",	254	"fisub",
255	"fisubr",	255	"fisubr",
256	"fld",	256	"fld",
257	"fld1",	257	"fld1",
258	"fldcw",	258	"fldcw",
259	"fldenv",	259	"fldenv",
260	"fldl2e",	260	"fldl2e",
261	"fldl2t",	261	"fldl2t",
262	"fldlg2",	262	"fldlg2",
263	"fldln2",	263	"fldln2",
264	"fldpi",	264	"fldpi",
265	"fldz",	265	"fldz",
266	"fmul",	266	"fmul",
267	"fmulp",	267	"fmulp",
268	"fnclex",	268	"fnclex",
269	"fninit",	269	"fninit",
270	"fnop",	270	"fnop",
271	"fnsave",	271	"fnsave",
272	"fnstcw",	272	"fnstcw",
273	"fnstenv",	273	"fnstenv",
274	"fnstsw",	274	"fnstsw",
275	"fpatan",	275	"fpatan",
276	"fprem",	276	"fprem",
277	"fprem1",	277	"fprem1",
278	"fptan",	278	"fptan",
279	"frndint",	279	"frndint",
280	"frstor",	280	"frstor",
281	"fsave",	281	"fsave",
282	"fscale",	282	"fscale",
283	"fsin",	283	"fsin",
284	"fsincos",	284	"fsincos",
285	"fsqrt",	285	"fsqrt",
286	"fst",	286	"fst",
287	"fstcw",	287	"fstcw",
288	"fstenv",	288	"fstenv",
289	"fstp",	289	"fstp",
290	"fstsw",	290	"fstsw",
291	"fsub",	291	"fsub",
292	"fsubp",	292	"fsubp",
293	"fsubr",	293	"fsubr",
294	"fsubrp",	294	"fsubrp",
295	"ftst",	295	"ftst",
296	"fucom",	296	"fucom",
297	"fucomi",	297	"fucomi",
298	"fucomip",	298	"fucomip",
299	"fucomp",	299	"fucomp",
300	"fucompp",	300	"fucompp",
301	"fwait",	301	"fwait",
302	"fxam",	302	"fxam",
303	"fxch",	303	"fxch",
304	"fxrstor",	304	"fxrstor",
305	"fxsave",	305	"fxsave",
306	"fxtract",	306	"fxtract",
307	"fyl2x",	307	"fyl2x",
308	"fyl2xp1",	308	"fyl2xp1",
309	"gf2p8affineinvqb",	309	"gf2p8affineinvqb",
310	"gf2p8affineqb",	310	"gf2p8affineqb",
311	"gf2p8mulb",	311	"gf2p8mulb",
312	"haddpd",	312	"haddpd",
313	"haddps",	313	"haddps",
314	"hlt",	314	"hlt",
315	"hsubpd",	315	"hsubpd",
316	"hsubps",	316	"hsubps",
317	"idiv",	317	"idiv",
318	"imul",	318	"imul",
319	"in",	319	"in",
320	"inc",	320	"inc",
321	"ins",	321	"ins",
322	"insb",	322	"insb",
323	"insd",	323	"insd",
324	"insertps",	324	"insertps",
325	"insw",	325	"insw",
326	"int",	326	"int",
327	"int1",	327	"int1",
328	"int3",	328	"int3",
329	"into",	329	"into",
330	"invd",	330	"invd",
331	"invlpg",	331	"invlpg",
332	"invpcid",	332	"invpcid",
333	"iret",	333	"iret",
334	"iretd",	334	"iretd",
335	"jmp",	335	"jmp",
336	"ja",	336	"ja",
337	"jae",	337	"jae",
338	"jb",	338	"jb",
339	"jbe",	339	"jbe",
340	"jc",	340	"jc",
341	"jcxz",	341	"jcxz",
342	"jecxz",	342	"jecxz",
343	"je",	343	"je",
344	"jg",	344	"jg",
345	"jge",	345	"jge",
346	"jl",	346	"jl",
347	"jle",	347	"jle",
348	"jna",	348	"jna",
349	"jnae",	349	"jnae",
350	"jnb",	350	"jnb",
351	"jnbe",	351	"jnbe",
352	"jnc",	352	"jnc",
353	"jne",	353	"jne",
354	"jng",	354	"jng",
355	"jnge",	355	"jnge",
356	"jnl",	356	"jnl",
357	"jnle",	357	"jnle",
358	"jno",	358	"jno",
359	"jnp",	359	"jnp",
360	"jns",	360	"jns",
361	"jnz",	361	"jnz",
362	"jo",	362	"jo",
363	"jp",	363	"jp",
364	"jpe",	364	"jpe",
365	"jpo",	365	"jpo",
366	"js",	366	"js",
367	"jz",	367	"jz",
368	"kaddb",	368	"kaddb",
369	"kaddd",	369	"kaddd",
370	"kaddq",	370	"kaddq",
371	"kaddw",	371	"kaddw",
372	"kandb",	372	"kandb",
373	"kandd",	373	"kandd",
374	"kandnb",	374	"kandnb",
375	"kandnd",	375	"kandnd",
376	"kandnq",	376	"kandnq",
377	"kandnw",	377	"kandnw",
378	"kandq",	378	"kandq",
379	"kandw",	379	"kandw",
380	"kmovb",	380	"kmovb",
381	"kmovd",	381	"kmovd",
382	"kmovq",	382	"kmovq",
383	"kmovw",	383	"kmovw",
384	"knotb",	384	"knotb",
385	"knotd",	385	"knotd",
386	"knotq",	386	"knotq",
387	"knotw",	387	"knotw",
388	"korb",	388	"korb",
389	"kord",	389	"kord",
390	"korq",	390	"korq",
391	"kortestb",	391	"kortestb",
392	"kortestd",	392	"kortestd",
393	"kortestq",	393	"kortestq",
394	"kortestw",	394	"kortestw",
395	"korw",	395	"korw",
396	"kshiftlb",	396	"kshiftlb",
397	"kshiftld",	397	"kshiftld",
398	"kshiftlq",	398	"kshiftlq",
399	"kshiftlw",	399	"kshiftlw",
400	"kshiftrb",	400	"kshiftrb",
401	"kshiftrd",	401	"kshiftrd",
402	"kshiftrq",	402	"kshiftrq",
403	"kshiftrw",	403	"kshiftrw",
404	"ktestb",	404	"ktestb",
405	"ktestd",	405	"ktestd",
406	"ktestq",	406	"ktestq",
407	"ktestw",	407	"ktestw",
408	"kunpckbw",	408	"kunpckbw",
409	"kunpckdq",	409	"kunpckdq",
410	"kunpckwd",	410	"kunpckwd",
411	"kxnorb",	411	"kxnorb",
412	"kxnord",	412	"kxnord",
413	"kxnorq",	413	"kxnorq",
414	"kxnorw",	414	"kxnorw",
415	"kxorb",	415	"kxorb",
416	"kxord",	416	"kxord",
417	"kxorq",	417	"kxorq",
418	"kxorw",	418	"kxorw",
419	"lahf",	419	"lahf",
420	"lar",	420	"lar",
421	"lddqu",	421	"lddqu",
422	"ldmxcsr",	422	"ldmxcsr",
423	"lds",	423	"lds",
424	"lea",	424	"lea",
425	"leave",	425	"leave",
426	"les",	426	"les",
427	"lfence",	427	"lfence",
428	"lfs",	428	"lfs",
429	"lgdt",	429	"lgdt",
430	"lgs",	430	"lgs",
431	"lidt",	431	"lidt",
432	"lldt",	432	"lldt",
433	"lmsw",	433	"lmsw",
434	"lock",	434	"lock",
435	"lods",	435	"lods",
436	"lodsb",	436	"lodsb",
437	"lodsd",	437	"lodsd",
438	"lodsq",	438	"lodsq",
439	"lodsw",	439	"lodsw",
440	"loop",	440	"loop",
441	"loopa",	441	"loopa",
442	"loopae",	442	"loopae",
443	"loopb",	443	"loopb",
444	"loopbe",	444	"loopbe",
445	"loopc",	445	"loopc",
446	"loope",	446	"loope",
447	"loopg",	447	"loopg",
448	"loopge",	448	"loopge",
449	"loopl",	449	"loopl",
450	"loople",	450	"loople",
451	"loopna",	451	"loopna",
452	"loopnae",	452	"loopnae",
453	"loopnb",	453	"loopnb",
454	"loopnbe",	454	"loopnbe",
455	"loopnc",	455	"loopnc",
456	"loopne",	456	"loopne",
457	"loopng",	457	"loopng",
458	"loopnge",	458	"loopnge",
459	"loopnl",	459	"loopnl",
460	"loopnle",	460	"loopnle",
461	"loopno",	461	"loopno",
462	"loopnp",	462	"loopnp",
463	"loopns",	463	"loopns",
464	"loopnz",	464	"loopnz",
465	"loopo",	465	"loopo",
466	"loopp",	466	"loopp",
467	"looppe",	467	"looppe",
468	"looppo",	468	"looppo",
469	"loops",	469	"loops",
470	"loopz",	470	"loopz",
471	"lsl",	471	"lsl",
472	"lss",	472	"lss",
473	"ltr",	473	"ltr",
474	"lzcnt",	474	"lzcnt",
475	"maskmovdqu",	475	"maskmovdqu",
476	"maskmovq",	476	"maskmovq",
477	"maxpd",	477	"maxpd",
478	"maxps",	478	"maxps",
479	"maxsd",	479	"maxsd",
480	"maxss",	480	"maxss",
481	"mfence",	481	"mfence",
482	"minpd",	482	"minpd",
483	"minps",	483	"minps",
484	"minsd",	484	"minsd",
485	"minss",	485	"minss",
486	"monitor",	486	"monitor",
487	"mov",	487	"mov",
488	"movapd",	488	"movapd",
489	"movaps",	489	"movaps",
490	"movbe",	490	"movbe",
491	"movd",	491	"movd",
492	"movddup",	492	"movddup",
493	"movdir64b",	493	"movdir64b",
494	"movdiri",	494	"movdiri",
495	"movdq2q",	495	"movdq2q",
496	"movdqa",	496	"movdqa",
497	"movdqu",	497	"movdqu",
498	"movhlps",	498	"movhlps",
499	"movhpd",	499	"movhpd",
500	"movhps",	500	"movhps",

Subversion Repositories Kolibri OS

(root)/kernel/trunk/asmxygen.py – Rev 8974 → 8975