mirror of
https://github.com/KolibriOS/kolibrios.git
synced 2025-01-07 14:12:00 +03:00
2047 lines
42 KiB
Python
2047 lines
42 KiB
Python
import re
|
|
import os
|
|
import argparse
|
|
import sys
|
|
import pickle
|
|
|
|
# Parameters
|
|
# Path to doxygen folder to make doxygen files in: -o <path>
|
|
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",
|
|
]
|
|
|
|
# Dict where an identifier is assicoated with a string
|
|
# The string contains characters specifying flags
|
|
# Available flags:
|
|
# k - Keyword
|
|
# m - Macro name
|
|
# t - fasm data Type name (db, rq, etc.)
|
|
# s - Struct type name
|
|
# e - equated constant (name equ value)
|
|
# = - set constants (name = value)
|
|
ID_KIND_KEYWORD = 'k'
|
|
ID_KIND_MACRO_NAME = 'm'
|
|
ID_KIND_FASM_TYPE = 't'
|
|
ID_KIND_STRUCT_NAME = 's'
|
|
ID_KIND_EQUATED_CONSTANT = 'e'
|
|
ID_KIND_SET_CONSTANT = '='
|
|
id2kind = {}
|
|
|
|
# Add kind flag to identifier in id2kind
|
|
def id_add_kind(identifier, kind):
|
|
if identifier not in id2kind:
|
|
id2kind[identifier] = ''
|
|
id2kind[identifier] += kind
|
|
|
|
# Remove kind flag of identifier in id2kind
|
|
def id_remove_kind(identifier, kind):
|
|
if identifier in id2kind:
|
|
if kind in id2kind[identifier]:
|
|
id2kind[identifier] = id2kind[identifier].replace(kind, '')
|
|
|
|
# Get kind of an identifier
|
|
def id_get_kind(identifier):
|
|
if identifier in id2kind:
|
|
return id2kind[identifier]
|
|
else:
|
|
return ''
|
|
|
|
for keyword in keywords:
|
|
id_add_kind(keyword, ID_KIND_KEYWORD)
|
|
|
|
for fasm_type in fasm_types:
|
|
id_add_kind(fasm_type, ID_KIND_FASM_TYPE)
|
|
|
|
# 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")
|
|
parser.add_argument("--noemit", help="Do not emit doxygen files (for testing)", 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
|
|
noemit = args.noemit
|
|
|
|
# Variables, functions, labels, macros, structure types
|
|
elements = []
|
|
|
|
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):
|
|
global warnings
|
|
|
|
# If the element was constructed during this execution then the element is new
|
|
self.new = True
|
|
self.location = location
|
|
self.file = self.location.split(':')[0].replace('\\', '/')
|
|
self.line = self.location.split(':')[1]
|
|
self.name = name
|
|
self.comment = comment
|
|
|
|
if self.comment == '':
|
|
warnings += f'{self.location}: Undocumented element\n'
|
|
|
|
def dump(self):
|
|
print(f"{self.comment}")
|
|
print(f"{self.location}: {self.name}")
|
|
|
|
def emit(self, dest, doxycomment = '', declaration = ''):
|
|
# Do not emit anything if the symbol is marked as hidden in its comment
|
|
if '@dont_give_a_doxygen' in self.comment:
|
|
return
|
|
|
|
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"<a href='{link_root}/{self.file}#line-{self.line}'>{self.file}:{self.line}</a>\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
|
|
# Get kind of the identifier from id2kind table
|
|
kind = id_get_kind(name)
|
|
# If it's a keyword, that's not a variable declaration
|
|
if ID_KIND_KEYWORD in kind:
|
|
return None
|
|
# If it's a macro name, that's not a variable declaration
|
|
if ID_KIND_MACRO_NAME in kind:
|
|
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 ID_KIND_STRUCT_NAME in kind or ID_KIND_FASM_TYPE in kind:
|
|
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
|
|
# Get kind of type identifier
|
|
type_kind = id_get_kind(var_type)
|
|
# If it's a keyword, that's not a variable declaration
|
|
# return the two words of the lexical structure
|
|
if ID_KIND_KEYWORD in type_kind:
|
|
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)
|
|
id_add_kind(macro.name, ID_KIND_MACRO_NAME)
|
|
# Match structure declaration
|
|
elif first_word == "struct":
|
|
struct = parse_after_struct(r)
|
|
elements.append(struct)
|
|
id_add_kind(struct.name, ID_KIND_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:
|
|
id_remove_kind(name, ID_KIND_MACRO_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":
|
|
if '@return' in comment or '@param' in comment:
|
|
element = AsmFunction(r.location(), name, comment, '', [], [])
|
|
else:
|
|
element = AsmLabel(r.location(), name, comment)
|
|
elements.append(element)
|
|
elif r.curr() == '=':
|
|
# Save the identifier as a set constant
|
|
id_add_kind(first_word, ID_KIND_SET_CONSTANT)
|
|
elif type(var) == tuple:
|
|
(word_one, word_two) = var
|
|
if word_two == 'equ':
|
|
# Save the identifier as an equated constant
|
|
id_add_kind(word_one, ID_KIND_EQUATED_CONSTANT)
|
|
r.nextline()
|
|
|
|
def it_neds_to_be_parsed(source_file):
|
|
# If there's no symbols file saved - parse it anyway
|
|
# cause we need to create the symbols file and use it
|
|
# if we gonna generate proper doxygen
|
|
if not os.path.isfile('asmxygen.elements.pickle'):
|
|
return True
|
|
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 = "."):
|
|
global elements
|
|
# 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}")
|
|
# Remove elements parsed from this file before if any
|
|
elements_to_remove = [x for x in elements if x.location.split(':')[0] == asm_file_name]
|
|
elements = [x for x in elements if x.location.split(':')[0] != asm_file_name]
|
|
# Forget types of identifiers of names of the removed elements
|
|
for element in elements_to_remove:
|
|
if type(element) == AsmStruct:
|
|
id_remove_kind(element.name, ID_KIND_STRUCT_NAME)
|
|
elif type(element) == AsmMacro:
|
|
id_remove_kind(element.name, ID_KIND_MACRO_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 = []
|
|
|
|
# Load remembered list of symbols
|
|
if os.path.isfile('asmxygen.elements.pickle'):
|
|
print('Reading existing dump of symbols')
|
|
(elements, id2kind) = pickle.load(open('asmxygen.elements.pickle', 'rb'))
|
|
|
|
handle_file(kernel_files, "./kernel.asm");
|
|
|
|
if dump_symbols:
|
|
for asm_element in elements:
|
|
asm_element.dump()
|
|
|
|
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.")
|
|
elif not noemit:
|
|
print(f"Writing doumented sources to {doxygen_src_path}")
|
|
|
|
i = 0
|
|
new_elements = [x for x in elements if x.new]
|
|
for element in new_elements:
|
|
print(f"[{i + 1}/{len(new_elements)}] Emitting {element.name} from {element.location}")
|
|
element.emit(doxygen_src_path)
|
|
i += 1
|
|
|
|
print(f"Writing dump of symbols to asmxygen.elements.pickle")
|
|
|
|
# Now when the new elements already was written, there's no new elements anymore
|
|
for element in elements:
|
|
element.new = False
|
|
pickle.dump((elements, id2kind), open('asmxygen.elements.pickle', 'wb'))
|
|
|
|
if print_stats:
|
|
var_count = 0
|
|
mac_count = 0
|
|
lab_count = 0
|
|
fun_count = 0
|
|
uni_count = 0
|
|
str_count = 0
|
|
for element in elements:
|
|
if type(element) == AsmVariable:
|
|
var_count += 1
|
|
elif type(element) == AsmMacro:
|
|
mac_count += 1
|
|
elif type(element) == AsmLabel:
|
|
lab_count += 1
|
|
elif type(element) == AsmFunction:
|
|
fun_count += 1
|
|
elif type(element) == AsmUnion:
|
|
uni_count += 1
|
|
elif type(element) == AsmStruct:
|
|
str_count += 1
|
|
print(f'Parsed variable count: {var_count}')
|
|
print(f'Parsed macro count: {mac_count}')
|
|
print(f'Parsed label count: {lab_count}')
|
|
print(f'Parsed function count: {fun_count}')
|
|
print(f'Parsed union type count: {uni_count}')
|
|
print(f'Parsed structure type count: {str_count}')
|
|
|
|
if enable_warnings:
|
|
open('asmxygen.txt', "w", encoding = "utf-8").write(warnings)
|