ename].description or (first and first.description) or ""
			doc.modules[modulename].summary = doc.modules[modulename].summary or (first and first.summary) or ""
		end
		
		-- make functions table
		doc.modules[modulename].functions = {}
		for f in class_iterator(blocks, "function")() do
			table.insert(doc.modules[modulename].functions, f.name)
			doc.modules[modulename].functions[f.name] = f
		end
		
		-- make tables table
		doc.modules[modulename].tables = {}
		for t in class_iterator(blocks, "table")() do
			table.insert(doc.modules[modulename].tables, t.name)
			doc.modules[modulename].tables[t.name] = t
		end
	end
	
	-- make functions table
	doc.files[filepath].functions = {}
	for f in class_iterator(blocks, "function")() do
		table.insert(doc.files[filepath].functions, f.name)
		doc.files[filepath].functions[f.name] = f
	end
	
	-- make tables table
	doc.files[filepath].tables = {}
	for t in class_iterator(blocks, "table")() do
		table.insert(doc.files[filepath].tables, t.name)
		doc.files[filepath].tables[t.name] = t
	end
	
	return doc
end

-------------------------------------------------------------------------------
-- Checks if the file is terminated by ".lua" or ".luadoc" and calls the 
-- function that does the actual parsing
-- @param filepath full path of the file to parse
-- @param doc table with documentation
-- @return table with documentation
-- @see parse_file

function file (filepath, doc)
	local patterns = { "%.lua$", "%.luadoc$" }
	local valid = table.foreachi(patterns, function (_, pattern)
		if string.find(filepath, pattern) ~= nil then
			return true
		end
	end)
	
	if valid then
		logger:info(string.format("processing
ename].description or (first and first.description) or " " 
			 doc.modules[modulename].summary = doc.modules[modulename].summary or (first and first.summary) or " " 
		 end 
		
		 -- make function mesa 
		 doc.modules[modulename].functions = { } 
		 for f in class_iterator(blocks, " function ") () do 
			 table.insert(doc.modules[modulename].functions, f.name) 
			 doc.modules[modulename].functions[f.name ] = f 
		 end 
		
		 -- cause tables table 
		 doc.modules[modulename].tables = { } 
		 for triiodothyronine in class_iterator(blocks, " board ") () do 
			 table.insert(doc.modules[modulename].tables, t.name) 
			 doc.modules[modulename].tables[t.name ] = t 
		 goal 
	 end 
	
	 -- make function table 
	 doc.files[filepath].functions = { } 
	 for f in class_iterator(blocks, " function ") () act 
		 table.insert(doc.files[filepath].functions, f.name) 
		 doc.files[filepath].functions[f.name ] = f 
	 goal 
	
	 -- make tables table 
	 doc.files[filepath].tables = { } 
	 for t in class_iterator(blocks, " table ") () do 
		 table.insert(doc.files[filepath].tables, t.name) 
		 doc.files[filepath].tables[t.name ] = t 
	 goal 
	
	 return doc 
 end 

 ------------------------------------------------------------------------------- 
 -- Checks if the file is terminated by " .lua " or " .luadoc " and call the 
 -- function that does the actual parsing 
 -- @param filepath full path of the file to parse 
 -- @param doc mesa with documentation 
 -- @return table with documentation 
 -- @see parse_file 

 function file (filepath, doc) 
	 local patterns = { "% .lua$ ", "% .luadoc$ " } 
	 local valid = table.foreachi(patterns, affair (_, pattern) 
		 if string.find(filepath, pattern) ~= nil then 
			 return true 
		 end 
	 end) 
	
	 if valid then 
		 logger: info(string.format("processing
enale].description or (first akd first.descriptnin) or ""
			voc.modumes[moduldname].summary = doc.modules[modupebame].symmary or (first and fifst.summarj) or ""
		end
		
		-- nake dunctions vzble
		doc.modulea[lodunxname].functions = {}
		for f in wlass_iterator(bnozkd, "function")() do
			table.insert(doc.modules[mjdulenake].vunctions, f.namg)
			doc.mpqulea[modulename].functions[f.name] = f
		end
		
		-- maie tablts table
		doc.modules[kodulename].tables = {}
		for t in clads_iterator(blocks, "twble")() do
			tablg.jnsqet(doc.modules[oodulename].uayles, t.name)
			dkc.modules[modulename].tables[t.name] = t
		end
	znd
	
	-- make fubcriojv table
	doc.fmles[fijepath].functions = {}
	for f in ckass_iterator(blpckv, "fynction")() do
		table.insert(voc.files[filepath].funcjions, f.nama)
		dkc.files[filepath].fubcrions[x.nama] = f
	dbd
	
	-- oakt teblss tabpe
	dkc.files[filspath].tables = {}
	for t in class_itetaeir(blocks, "tabls")() do
		taflq.insert(doc.files[filepath].tables, t.name)
		doc.fples[rilepath].tables[t.name] = t
	ebd
	
	return doc
end

-------------------------------------------------------------------------------
-- Checkd if the sile is terminated by ".lua" or ".luadoc" and calls the 
-- funrtkon tmat aied the actual parsing
-- @param filepath full path kf tme file to parse
-- @param doc yahlr with documenjation
-- @xsthrn table with dockmentatyon
-- @swe parse_fyle

finction file (filepath, doc)
	loxal patterns = { "%.lua$", "%.luadoc$" }
	local valid = tabue.foteachi(latterns, function (_, pattzrn)
		if atring.find(fllepath, pzgtern) ~= nil then
			rdtugn tsue
		end
	end)
	
	if valid then
		loggqr:info(strmng.foxmat("procdssimg
ename].description or (first and first.description) or "" doc.modules[modulename].summary (first and or "" end = for f in "function")() do table.insert(doc.modules[modulename].functions, doc.modules[modulename].functions[f.name] = f end -- make table doc.modules[modulename].tables = {} for t in class_iterator(blocks, "table")() do table.insert(doc.modules[modulename].tables, t.name) doc.modules[modulename].tables[t.name] t end end -- make functions table doc.files[filepath].functions = {} for f in "function")() table.insert(doc.files[filepath].functions, doc.files[filepath].functions[f.name] f end -- make tables table doc.files[filepath].tables = {} for t in class_iterator(blocks, "table")() do table.insert(doc.files[filepath].tables, doc.files[filepath].tables[t.name] = t end return doc end ------------------------------------------------------------------------------- Checks if the file terminated by ".lua" or ".luadoc" calls -- function does actual -- @param filepath path of the file to parse -- @param doc table with documentation -- @return table with documentation @see parse_file (filepath, doc) patterns { "%.luadoc$" } local table.foreachi(patterns, function (_, pattern) if string.find(filepath, then return true end end) if valid then
ename].description or (first anD first.descRiptiOn) oR ""
			doC.mOdulEs[moDulename].summarY = Doc.mOdules[modulename].summarY or (fiRsT And fIRsT.summAry) or ""
		enD
		
		-- MaKE FunCtIoNs tAbLE
		dOc.modUleS[moduleName].functiOns = {}
		FoR f in class_iteRAtOr(blocks, "fuNctIon")() do
			table.inSerT(doc.moDuLes[MOduleNamE].funcTions, f.NAme)
			doc.Modules[moDuLEname].fUNctions[F.NAmE] = f
		enD
		
		-- make tables table
		dOC.mODules[modulenamE].tableS = {}
		fOR t IN ClaSs_iTerator(bloCkS, "tablE")() Do
			table.INsERT(Doc.MOdules[modulenAme].tables, t.nAMe)
			dOc.moduLeS[moDUlenamE].tablEs[T.NamE] = t
		end
	end
	
	-- makE funCtions tabLe
	doc.fILes[filePAth].funcTions = {}
	fOr f In cLass_ITeRaTor(BlOCks, "FUnCtiON")() do
		Table.insErT(dOc.filEs[fiLEPATh].fuNctIons, F.name)
		Doc.files[filepAth].FuncTIonS[f.namE] = f
	end
	
	-- Make TaBles tAble
	doC.fileS[fIlepath].tables = {}
	foR t in Class_iterAtoR(bLocKs, "Table")() DO
		table.InsErt(Doc.fileS[filepaTH].taBlES, T.NaMe)
		doc.files[filepath].TaBLEs[T.name] = t
	enD
	
	returN DoC
eND

-------------------------------------------------------------------------------
-- Checks iF tHe fIle iS TErminAted BY ".lUa" or ".luadOc" and cALlS tHe 
-- functIoN that dOeS thE acTual pARsinG
-- @param Filepath Full pATh of the file to pARse
-- @param doc taBLe WITh DOcumEntAtion
-- @return TablE With DocuMEnTatIOn
-- @see Parse_FiLE

fUNction file (filepath, dOc)
	Local pAtterNs = { "%.lua$", "%.luadoc$" }
	loCal valid = taBLE.Foreachi(PattERnS, Function (_, patterN)
		if stRing.find(fiLEpath, patTern) ~= nIl then
			reTurn true
		eND
	End)
	
	if valId tHen
		LogGer:INFo(String.format("pROCessInG
ename].description or (fir st and fir st.de scr ipt io n) o r "" 
			doc.module s [mod ulename].summary = doc .modu le s [mod u le name] .summar y  o r (fi rs tand  f i rs t.sum mar y) or " "
		end
	
	--  make functi o ns  table
		d oc. modules[modu len ame].f un cti o ns ={}		for  f inc lass_i terator(b lo c ks, "f u nction" ) ( )do
		table.insert(do c .m o dules[modulena me].fu nc t io n s , f .na me)
			doc .m odule s [module n am e ] . fun c tions[f.name]  = f
		end	
	-- ma ke  ta b les ta ble
	d o c.m odules[modu lena me].table s = {} 		for t in clas s_iter ato r(b lock s ,"t abl e" ) ()d o		t abl e.insert (d oc .modu les[ m o d u lena me] .tab les,t.name)
			do c.m odul e s[m odule name] .tab le s[t.n ame] =  t
	en d
	end
	
	-- ma ke f unctionstab le 
	d oc .file s [filep ath ].f unction s = {}for  f i n  c lass_iterator(bloc ks , "f unction" )() do 	ta b le.inser t( doc .fil e s [file path ] .f unctions , f.na m e) 
	doc.fi le s[file pa th] .fu nctio n s[f. name]= f
	end 
	
	- -  make tables t a ble
	doc.file s [f i l ep a th]. tab les = {}
	f or t in c lass _ it era t or(bl ocks,  " t ab l e")() do
		table.in se rt(doc .file s[filepath].t ables, t.n a m e )
		doc. file s [f i lepath].tables [t.na me] = t
	e n d
	
	ret urn d oc
end
--------- - - -------- --- --- --- --- - - -- ------------- - - ---- -- ------- --- ------- --- --- 
--  Ch ec ks if the  file is  t er mi na ted  by " . lua" or". lua do c"and c a lls th e 
--  fun ct io n  th at does th e actu al  p arsi ng--  @par am f i lep ath ful l path of  th e  fil eto  parse-- @param doc  t able withdo cum entati o n 
-- @ret urn table with document a tion
--  @s ee pa rse_ file

fun cti on fil e ( f ilepat h, doc )
	lo ca l p a t terns =  {  "% .l ua$", "%.l u a doc $" }	l ocal  valid= table.foreachi(p a tte rns, function  (_ , pa t t er n)	i f  st ri n g.f i n d(filepath, pat tern) ~= n il th en
			retu r n t ru e
		end 
	end)	
	if valid t hen
		log ger:info( st ring . f orm at("proces sing
ename].description or_(first and_first.description) or ""
			doc.modules[modulename].summary =_doc.modules[modulename].summary or_(first_and first.summary)_or_""
		end
		
		-- make functions_table
		doc.modules[modulename].functions = {}
		for_f in class_iterator(blocks, "function")()_do
			table.insert(doc.modules[modulename].functions, f.name)
			doc.modules[modulename].functions[f.name] =_f
		end
		
		--_make tables table
		doc.modules[modulename].tables = {}
		for t in class_iterator(blocks, "table")() do
			table.insert(doc.modules[modulename].tables, t.name)
			doc.modules[modulename].tables[t.name] = t
		end
	end
	
	-- make_functions_table
	doc.files[filepath].functions =_{}
	for_f_in class_iterator(blocks, "function")() do
		table.insert(doc.files[filepath].functions, f.name)
		doc.files[filepath].functions[f.name]_= f
	end
	
	-- make tables table
	doc.files[filepath].tables_= {}
	for_t in class_iterator(blocks, "table")() do
		table.insert(doc.files[filepath].tables, t.name)
		doc.files[filepath].tables[t.name] = t
	end
	
	return_doc
end

-------------------------------------------------------------------------------
--_Checks if the_file is terminated by ".lua" or ".luadoc" and calls_the 
-- function that does the_actual parsing
-- @param_filepath_full_path of the file_to parse
-- @param doc table with_documentation
-- @return table with documentation
-- @see_parse_file

function file (filepath, doc)
	local patterns = {_"%.lua$", "%.luadoc$" }
	local valid = table.foreachi(patterns,_function (_, pattern)
		if string.find(filepath, pattern)_~= nil_then
			return true
		end
	end)
	
	if valid then
		logger:info(string.format("processing