Merge pull request #112 from groleo/master (2a9ddad1) · Commits · Elphel / doxverilog

addon/doxypysql/search.py

+267 −62

Original line number	Original line	Diff line number	Diff line
	@@ -12,8 +12,8 @@
	import sqlite3		import sqlite3
	import sys		import sys
	import os		import os
	import re
	import getopt		import getopt
			import json

	class MemberType:		class MemberType:
	Define="0"		Define="0"
	@@ -29,82 +29,210 @@ class MemberType:
	Property="10"		Property="10"
	Event="11"		Event="11"

			class RequestType:
			References="9901"
			Struct="9902"
			Includers="9903"
			Includees="9904"
			Members="9905"
			BaseClasses="9906"
			SubClasses="9907"

			g_conn=None
	###############################################################################		###############################################################################

	def escapeLike(val):		def escapeLike(val):
	return 'LIKE "%' + val.replace("\\", "\\\\").replace("_", "\\_") \		return 'LIKE "%' + val.replace("\\", "\\\\").replace("_", "\\_") \
	.replace("%", "\\%") + '%" ESCAPE "\\"'		.replace("%", "\\%") + '%" ESCAPE "\\"'

			def matchName(name):
			if type(name) is str:
			return "name "+escapeLike(name)
			else:
			return 'id=%d' %name

			def fileName(id_file):
			if g_conn.execute("SELECT COUNT(*) FROM files WHERE id=?",[id_file]).fetchone()[0] > 1:
			print "non-uniq fileid"

			for r in g_conn.execute("SELECT * FROM files WHERE id=?",[id_file]).fetchall():
			return r['name']

			return ""

			def fileId(name):
			if g_conn.execute("SELECT COUNT(*) FROM files WHERE name=?",[name]).fetchone()[0] > 1:
			print "non-uniq file name"

			for r in g_conn.execute("SELECT * FROM files WHERE name=?",[name]).fetchall():
			return r['id']

	def getLine(id_file,line,column):		return -1
	rv=""
	for r in g_conn.execute('SELECT * FROM files WHERE id=%d;' % id_file).fetchall():
	rv += "found in file %s:%d:%d" % (r['name'],line,column)
	return rv

	###############################################################################		###############################################################################

	def processCallers(caller, path=None, fid=None):		def findReferences(name):
			o=[]

	cur = g_conn.cursor()		cur = g_conn.cursor()
	if fid is None:		cur.execute("SELECT refid FROM memberdef WHERE name=?",[name])
	cur.execute("SELECT refid FROM memberdef WHERE name='%s'" % caller)
	refids = cur.fetchall()		refids = cur.fetchall()

	if len(refids) == 0:		if len(refids) == 0:
	print 'No results found'		return o
	return
	refid = refids[0]['refid']		refid = refids[0]['refid']
	print "%s" % refid
	cur = g_conn.cursor()		cur = g_conn.cursor()
	for info in cur.execute("SELECT * FROM xrefs WHERE dst LIKE '%"+refid+"%'"):		for info in cur.execute("SELECT * FROM xrefs WHERE dst LIKE '%"+refid+"%'"):
			item={}
	cur = g_conn.cursor()		cur = g_conn.cursor()
	for i2 in cur.execute("SELECT * FROM memberdef WHERE refid='%s'" % info['src']):		for i2 in cur.execute("SELECT * FROM memberdef WHERE refid=?",[info['src']]):
	print "caller:%s" % i2['name']		item['name']=i2['name']
	for i2 in cur.execute("SELECT * FROM files WHERE id='%s'" % info['id_file']):		item['src']=info['src']
	print "file : %s:%d" % (i2['name'],info['line'])		item['file']=fileName(info['id_file'])
			item['line']=info['line']

			o.append(item)
			return o

	def processFunction(name):
	for r in g_conn.execute('SELECT * FROM memberdef WHERE name LIKE "%'
	+name+'%" AND kind='+MemberType.Function+';').fetchall():
	print '==> %s %s %s' % (r['type'],r['name'],r['argsstring'])
	print getLine(r['id_file'],r['line'],r['column'])

			def findFunction(name):
			o=[]
			for r in g_conn.execute('SELECT * FROM memberdef WHERE '+matchName(name)+' AND kind=?',[MemberType.Function]).fetchall():
			item={}
			item['name'] = r['name']
			item['definition'] = r['definition']
			item['argsstring'] = r['argsstring']
			item['file'] = fileName(r['id_file'])
			item['line'] = r['line']
			item['detaileddescription'] = r['detaileddescription']
			o.append(item)
			return o

	def processMacro(name):
	for r in g_conn.execute('SELECT * FROM memberdef WHERE name LIKE "%'		def findMacro(name):
	+name+'%" AND kind='+MemberType.Define+';').fetchall():		o=[]
	mname = r['name']		for r in g_conn.execute('SELECT * FROM memberdef WHERE '+matchName(name)+' AND kind=?',[MemberType.Define]).fetchall():
			item={}
			item['name'] = r['name']
	if r['argsstring']:		if r['argsstring']:
	mname += r['argsstring']		item['argsstring'] = r['argsstring']
	print '%s' % (mname)		item['definition'] = r['initializer']
	print getLine(r['id_file'],r['line'],r['column'])		item['file'] = fileName(r['id_file'])
			item['line'] = r['line']
			o.append(item)
			return o


			def findTypedef(name):
			o=[]
			for r in g_conn.execute('SELECT * FROM memberdef WHERE '+matchName(name)+' AND kind=?',[MemberType.Typedef]).fetchall():
			item={}
			item['name'] = r['name']
			item['definition'] = r['definition']
			item['file'] = fileName(r['id_file'])
			item['line'] = r['line']
			o.append(item)
			return o


			def findVariable(name):
			o=[]
			for r in g_conn.execute('SELECT * FROM memberdef WHERE '+matchName(name)+' AND kind=?',[MemberType.Variable]).fetchall():
			item={}
			item['name'] = r['name']
			item['definition'] = r['definition']
			item['file'] = fileName(r['id_file'])
			item['line'] = r['line']
			o.append(item)
			return o

			def findParams(name):
			o=[]
			for r in g_conn.execute('SELECT id FROM memberdef WHERE '+matchName(name)).fetchall():
			#a=("SELECT * FROM params where id=(SELECT id_param FROM memberdef_params where id_memberdef=?",[id_memberdef])
			item={}
			item['id'] = r['id']
			o.append(item)
			return o


			def findStruct(name):
			o=[]
			for r in g_conn.execute('SELECT * FROM compounddef WHERE '+matchName(name)).fetchall():
			item={}
			item['name'] = r['name']
			o.append(item)
			return o

			def findIncluders(name):
			o=[]
			fid = fileId(name)
			for r in g_conn.execute('SELECT * FROM includes WHERE id_dst=?',[fid]).fetchall():
			item={}
			item['name'] = fileName(r['id_src'])
			o.append(item)
			return o

			def findIncludees(name):
			o=[]
			fid = fileId(name)
			for r in g_conn.execute('SELECT * FROM includes WHERE id_src=?',[fid]).fetchall():
			item={}
			item['name'] = r['dst']
			o.append(item)
			return o


			def findMembers(name):
			o=[]
			for r in g_conn.execute('SELECT * FROM memberdef WHERE scope LIKE "%'+name+'%";').fetchall():
			item={}
			item['name'] = r['name']
			item['definition'] = r['definition']
			item['argsstring'] = r['argsstring']
			item['file'] = fileName(r['id_file'])
			item['line'] = r['line']
			item['documentation'] = r['documentation']
			o.append(item)
			return o


			def findBaseClasses(name):
			o=[]
			for r in g_conn.execute('SELECT base FROM basecompoundref WHERE derived=?',[name]).fetchall():
			item={}
			item['name'] = r['base']
			o.append(item)
			return o

	def processType(name, path=None):
	for r in g_conn.execute('SELECT * FROM memberdef WHERE name LIKE "%'
	+name+'%" AND kind='+MemberType.Typedef+';').fetchall():
	print '%s' % (r['name'])
	print getLine(r['id_file'],r['line'],r['column'])

			def findSubClasses(name):
			o=[]
			for r in g_conn.execute('SELECT derived FROM basecompoundref WHERE base=?',[name]).fetchall():
			item={}
			item['name'] = r['derived']
			o.append(item)
			return o

	def processVariable(name):
	for r in g_conn.execute('SELECT * FROM memberdef WHERE name LIKE "%'+
	name + '%" AND kind='+MemberType.Variable+';').fetchall():
	print '> %s' % (r['name'])
	print getLine(r['id_file'],r['line'],r['column'])

	###############################################################################		###############################################################################

	def usage():		def usage():
	print """Usage: search.py [options]		print """Usage: search.py [Options]
	Options:		Options:
	-h, --help		-h, --help
	-d <D> Use database <D> for queries		-d <D> Use database <D> for queries
	-c <F> Search for callers of <F>		-r <F> Search for references to <F>
	-f <F> Search for function <F>		-f <F> Search for definition of function <F>
	-m <M> Search for macro <M>		-m <M> Search for definition of macro <M>
	-t <T> Search for type <T>		-t <T> Search for definition of type <T>
	-v <V> Search for variable <V>		-v <V> Search for definition of variable <V>
			-I <I> Get the includers of <I>
			-i <I> Get the includees of <I>
			-M <C> Get all members of class <C>
			-B <C> Get the base classes of class <C>
			-S <C> Get the sub classes of class <C>
	"""		"""

	def openDb(dbname):		def openDb(dbname):
	@@ -121,17 +249,72 @@ def openDb(dbname):
	g_conn.row_factory = sqlite3.Row		g_conn.row_factory = sqlite3.Row

	###############################################################################		###############################################################################
			def process(kind,o):
			request_processors = {
			MemberType.Function: findFunction,
			MemberType.Define: findMacro,
			MemberType.Variable: findVariable,
			MemberType.Typedef: findTypedef,
			RequestType.References: findReferences,
			RequestType.Struct: findStruct,
			RequestType.Includers: findIncluders,
			RequestType.Includees: findIncludees,
			RequestType.Members: findMembers,
			RequestType.BaseClasses: findBaseClasses,
			RequestType.SubClasses: findSubClasses
			}
			return request_processors[kind](o)


	def main(argv):		def processHref(ref):
			j={}

			# is it in memberdef ?
			table="memberdef"
			if ( g_conn.execute("SELECT count(*) from %s WHERE refid='%s'" % (table,ref) ).fetchone()[0] > 0 ):
			for r in g_conn.execute("SELECT kind,id FROM %s WHERE refid='%s'" % (table,ref) ).fetchall():
			j=process(str(r['kind']),int(r['id']))

			# is it in compounddef ?
			table="compounddef"
			if ( g_conn.execute("SELECT count(*) from %s WHERE refid='%s'" % (table,ref)).fetchone()[0] > 0 ):
			for r in g_conn.execute("SELECT id FROM %s WHERE refid='%s'" % (table,ref) ).fetchall():
			j=process(RequestType.Struct,int(r['id']))

			return j


			def serveCgi():
			import cgi

			print 'Content-Type: application/json\n'

			fieldStorage = cgi.FieldStorage()
			form = dict((key, fieldStorage.getvalue(key)) for key in fieldStorage.keys())

			if 'href' in form:
			ref = form['href']
			else:
			print '{"result": null, "error": "no refid given"}'
			sys.exit(0)

			openDb('doxygen_sqlite3.db')

			j = processHref(ref)

			print json.dumps({"result":j,"error":None})


			def serveCli(argv):
	try:		try:
	opts, args = getopt.getopt(argv, "hc:d:f:m:t:v:",["help"])		opts, args = getopt.getopt(argv, "hr:I:i:d:f:m:t:v:H:M:B:S:",["help"])
	except getopt.GetoptError:		except getopt.GetoptError:
	usage()		usage()
	sys.exit(1)		sys.exit(1)

			ref=None
	dbname=None		dbname=None
			j={}

	for a, o in opts:		for a, o in opts:
	if a in ('-h', '--help'):		if a in ('-h', '--help'):
	@@ -139,21 +322,43 @@ def main(argv):
	sys.exit(0)		sys.exit(0)
	elif a in ('-d'):		elif a in ('-d'):
	dbname=o		dbname=o
	elif a in ('-c'):		continue
	openDb(dbname)		elif a in ('-r'):
	processCallers(o)		kind=RequestType.References
			elif a in ('-I'):
			kind=RequestType.Includers
			elif a in ('-i'):
			kind=RequestType.Includees
			elif a in ('-M'):
			kind=RequestType.Members
			elif a in ('-B'):
			kind=RequestType.BaseClasses
			elif a in ('-S'):
			kind=RequestType.SubClasses
	elif a in ('-f'):		elif a in ('-f'):
	openDb(dbname)		kind=MemberType.Function
	processFunction(o)
	elif a in ('-m'):		elif a in ('-m'):
	openDb(dbname)		kind=MemberType.Define
	processMacro(o)
	elif a in ('-t'):		elif a in ('-t'):
	openDb(dbname)		kind=MemberType.Typedef
	processType(o)
	elif a in ('-v'):		elif a in ('-v'):
			kind=MemberType.Variable
			elif a in ('-H'):
			ref = o

	openDb(dbname)		openDb(dbname)
	processVariable(o)		if ref != None:
			j=processHref(ref)
			else:
			j=process(kind,o)
			print json.dumps(j)


			def main(argv):
			if 'REQUEST_METHOD' in os.environ:
			serveCgi()
			else:
			serveCli(argv)

	if __name__ == '__main__':		if __name__ == '__main__':
	main(sys.argv[1:])		main(sys.argv[1:])

Admin message