python_mini_C_Parser

import sys
from operator import itemgetter, attrgetter
from xml.etree.ElementTree import ElementTree

# parsing config
CONFIG_FILE = "cparser.xml"

tr = ElementTree()
m=tr.parse(CONFIG_FILE)
path = m.find("includeDir").text
startXML = ""
sXML = m.find("startXML")
oXML = m.find("outputXML").text
if sXML.attrib["active"].lower() == "true":
    startXML = sXML.text
# parsing config


arr = []
defineID = 2
funcID = 1

def trim(l):
    nl = []
    for i in l:
        if len(i) > 0:
            nl.append(i)
    return nl

def stripList(l):
    for i in range(0,len(l)):
        l[i] = l[i].strip()
    return l

def contains(lst, srch):
    for x in lst:
        if x == srch:return True
    return False

def filter_existant(ar):
    tmp = []
    apTmp = []
    for x in range(0,len(ar)):
        if not contains(tmp, ar[x][1]):
            apTmp.append(ar[x])
            tmp.append(ar[x][1])
    return apTmp




tree = ElementTree()
try:
    if len(startXML) != 0:
        m=tree.parse(startXML)
        m=m.find("NotepadPlus")
        l=list(m.iter("KeyWord"))
        for x in l:
            name = x.attrib["name"]
            func = funcID if x.attrib.__contains__("func") else defineID
            retval = ""
            parm = []
            if func:
                ov = x.find("Overload")
                if ov is not None:
                    retval = ov.attrib["retVal"]
                    p = list(ov.iter("Param"))
                    for i in p:
                        parm.append(i.attrib["name"])
            arr.append((func, name, retval, parm))
except:
    pass

def parseDefine(s):
    global arr, defineID, funcID
    ls = trim(s.split(" "))
    arr.append((defineID, ls[1], '' if len(ls)<3 else ls[2], []))
def parseFunc(s):
    global arr, defineID, funcID
    l = s.split("(")
    ps = l[1].split(")")
    ps = ')'.join(ps[:len(ps)-1]).split(",")
    stripList(ps)
    l[0] = l[0].replace(chr(0x9), ' ')
    tl = trim(l[0].split(" "))
    try:
        arr.append( (funcID, tl[len(tl)-1], ' '.join(tl[0:len(tl)-1]), ps) )
    except:
        if len(s) == 2:
            arr.append( (funcID, tl[len(tl)-1], ' ', []) )

def parseC(file):
    global arr
    nav = False
    ncom = 0
    stInd = 0
    ndef = False
    nusl = 0
    s = ""
    zag = 0
    bTyp = False
    nZag2 = 0
    bInc = False

    try:
        fl = open(file, "r")
        print("parsing file: "+file)
    except:
        return
    f = fl.read()
    fl.close()

    for i in range(0,len(f)):

        if f[i:i+2] == "/*":
            ncom = 1
            i+=1
            continue

        if f[i:i+2] == "*/":
            ncom = 0
            i+=1
            stInd = i+1
            continue

        if ncom == 1:
            continue

        if f[i]=="{" and f[stInd:i].find("extern")==-1:
            nZag2 += 1
        if f[i]=="}":
            nZag2 -= 1

        if nZag2 > 0:
            continue

        if f[i]!="\"" and nav:
            continue

        if f[i:i+7] == "#define":
            stInd = i
            ndef = True

        if f[i:i+8] == "#include":
            bInc = True
            stInd = i

        if f[i]=="#":
            nusl = 1

        if f[i]==";":
            if zag and not bTyp:
                s = f[stInd:i]
                parseFunc(s)
                zag = False
            else:
                bTyp = False
            stInd = i+2

        if f[i]==")" and zag>0 and not ndef and not nusl and not bTyp:
            zag -= 1
            if zag == 0:
                s = f[stInd:i+1]
                parseFunc(s)
                zag = False
                stInd = i+1

        if f[i]=="\"":
            nav^=True

        if (f[i]=="\r" or f[i]=="\n"):
            nusl = 0
            if bInc:
                s = f[stInd:i]
                s1 = s.split("<")
                if len(s1) > 1:
                    parseC(path+s1[1].split(">")[0].strip())
                else:
                    spl = s.split("\"")
                    if len(spl) == 3:
                        parseC(spl[1])
            if ndef:
                ndef = False
                s = f[stInd:i]
                try:
                    parseDefine(s)
                except:
                    pass
                s = ""
                continue
            stInd = i+1


        if f[i] == "(" and not ndef and not nusl:
            zag += 1

        if f[i:i+7] == "typedef" and not nusl and not ndef:
            stInd = i
            bTyp = True

parseC(sys.argv[1])

arr = filter_existant(arr)
arr = sorted(arr, key=lambda x: x[1].upper())

# export
fl = open(oXML, "w")
fl.write("<?xml version=\"1.0\" encoding=\"Windows-1252\" ?>\n")
fl.write("<NotepadPlus>\n")
fl.write("\t<AutoComplete language=\"C\">\n")
fl.write("\t\t<Environment ignoreCase=\"yes\" startFunc=\"(\" stopFunc=\")\" paramSeparator=\",\" terminal=\";\" />\n")
for i in arr:
    if(i[0] == defineID):
        fl.write("\t\t\t<KeyWord name=\""+i[1]+"\"/>\n")
    if(i[0] == funcID):
        fl.write("\t\t\t<KeyWord name=\""+i[1]+"\" func=\"yes\">\n")
        fl.write("\t\t\t\t<Overload retVal=\""+i[2].replace('\n', ' ')+"\">\n")
        for j in i[3]:
            fl.write("\t\t\t\t\t<Param name=\""+j.strip()+"\"/>\n")

        fl.write("\t\t\t\t</Overload>\n")
        fl.write("\t\t\t</KeyWord>\n")

fl.write("\t</AutoComplete>\n")
fl.write("</NotepadPlus>\n")
fl.close()