SC2Mapster

#! /bin/env python3
##    GPL license:
##    This program is free software: you can redistribute it and/or modify
##    it under the terms of the GNU General Public License as published by
##    the Free Software Foundation, either version 3 of the License, or
##    (at your option) any later version.
##
##    This program is distributed in the hope that it will be useful,
##    but WITHOUT ANY WARRANTY; without even the implied warranty of
##    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
##    GNU General Public License for more details.
##
##    You should have received a copy of the GNU General Public License
##    along with this program.  If not, see <http://www.gnu.org/licenses/&gt;.

# import libs
from xml.sax import ContentHandler
from xml.sax import make_parser
from xml.sax.handler import feature_namespaces
import sys,os,string,re

try:
    import SC2MapsterEdit
    bot = True
except:
    bot = False
#########important files############
native_lib = open(os.path.join('Base.SC2Data','TriggerLibs','NativeLib.SC2Lib'),'rb')
native_galaxy= open(os.path.join('Base.SC2Data','TriggerLibs','natives.galaxy'),'r')
string_list = open(os.path.join('enGB.SC2Data','LocalizedData','TriggerStrings.txt'),'r')
#output_file = open(os.path.join('output.txt'),'w')
output_file = sys.stdout

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

##empty dictionary for all kind of data
##they need to be copied else the reference will point to same adress
#trigger is not important now
empty_trigger={'Label':""}
#idenfifier of category will be ignored
empty_category = {'SubCategory':[],'Label':'','FunctionDef':[],'Preset':[],'Variable':[],'Trigger':[],'Comment':[],'Root':False}
#no EventResponse no Variable no functioncall
empty_function_def={'Identifier':"",'Label':"",'Flag':{},'ReturnType':'','TypeElement':'','Parameter':[]}
#too complicated to parse
empty_function_call={'FunctionDef':[]}
#too complicated to parse,only important for default values for parameters
empty_param={'ParameterDef':'','Value':'','ValueType':'','ValueTypeInfo':'','Preset':'','PresetValue':'','FunctionCall':'','Variable':'','Array':''}
#
empty_param_def={'Identifier':'','Value':'','Type':'','TypeElement':'','VariableType':"",'GameType':'','Default':False,'Preset':'','Limits':""}
#
empty_preset={'Identifier':'','Label':'','BaseType':'','PresetValue':[],'Flag':[]}
#
empty_preset_value ={'Identifier':'','Value':'','DefinesDefault':False}

#remove double space
space_filter = re.compile("  +")
def white_space_filter(s):
    return re.sub(space_filter," ",s)
#transform name to lowercase and replace space with -
def name_to_url(s):
	return white_space_filter(s.strip().lower().replace(" ","-").replace("("," ").replace(")"," ").strip())
#copy a 2 dimention dict without pointer reference
def new_dict(old_dict):
    res = old_dict.copy()
    for a in old_dict.keys():
        if type(res[a]) == type([]):
            res[a] = list()
        elif type(res[a]) == type({}):
            res[a] = dict()
    return res

#cmp wrapper
def cmp_to_key(mycmp):
    'Convert a cmp= function into a key= function'
    class K(object):
        def __init__(self, obj, *args):
            self.obj = obj
        def __lt__(self, other):
            return mycmp(self.obj, other.obj) 
        def __gt__(self, other):
            return mycmp(self.obj, other.obj) 
        def __eq__(self, other):
            return mycmp(self.obj, other.obj) 
        def __le__(self, other):
            return mycmp(self.obj, other.obj) 
        def __ge__(self, other):
            return mycmp(self.obj, other.obj) 
        def __ne__(self, other):
            return mycmp(self.obj, other.obj) 
    return K
#our main class
class FunctionWriter(ContentHandler):
    def __init__(self,stringFile,nativesFile):
        self.setting = ""
        self.root_category = {}
        self.category = {}
        self.label = {}
        self.icon = {}
        self.comment = {}
        self.temp_id=""
        self.temp_name=""
        self.function_def={}
        self.trigger={}
        self.function_call={}
        self.param={}
        self.param_def={}
        self.preset={}
        self.preset_value={}
        self.subfunc_type={}
        self.variable={}
	#we need the file saved as list
	#filestream is not very fast
        self.string_file = stringFile.readlines()
        self.natives_file = nativesFile.readlines()
    def sort_cat_func(self):
        pass
    #how we collect attrs data
    #important is self.setting, which defines how the next child tag will be processed
    
    def startElement(self, name, attrs):
        self.temp_name=name
        if name == "Root":
            self.setting = "Root"
        elif name == "Item":
            if self.setting  == "Root":
                if attrs["Type"] == "Label":
                    self.label[attrs['Id']]={}
                elif attrs["Type"] == "Category":
                    self.category[attrs['Id']]=new_dict(empty_category)
                    self.category[attrs['Id']]["Root"]=True
                    self.root_category[attrs['Id']]=attrs['Id']
            elif self.setting  == "Category":
                if attrs['Type']=="Category":
                    try:
                        self.category[self.temp_id]['SubCategory'].append(attrs["Id"])
                    except KeyError:
                        self.category[self.temp_id]=new_dict(empty_category)
                        self.category[self.temp_id]['SubCategory'].append(attrs["Id"])
                elif  attrs['Type']=="FunctionDef":
                    try:
                        self.category[self.temp_id]['FunctionDef'].append(attrs["Id"])
                    except KeyError:
                        self.category[self.temp_id]=new_dict(empty_category)
                        self.category[self.temp_id]['FunctionDef'].append(attrs["Id"])
                elif  attrs['Type']=="Preset":
                    try:
                        self.category[self.temp_id]['Preset'].append(attrs["Id"])
                    except KeyError:
                        self.category[self.temp_id]=new_dict(empty_category)
                        self.category[self.temp_id]['Preset'].append(attrs["Id"])    
                elif  attrs['Type']=="Variable":
                    try:
                        self.category[self.temp_id]['Variable'].append(attrs["Id"])
                    except KeyError:
                        self.category[self.temp_id]=new_dict(empty_category)
                        self.category[self.temp_id]['Variable'].append(attrs["Id"])
                elif  attrs['Type']=="Trigger":
                    try:
                        self.category[self.temp_id]['Trigger'].append(attrs["Id"])
                    except KeyError:
                        self.category[self.temp_id]=new_dict(empty_category)
                        self.category[self.temp_id]['Trigger'].append(attrs["Id"])
                elif  attrs['Type']=="Comment":
                    try:
                        self.category[self.temp_id]['Comment'].append(attrs["Id"])
                    except KeyError:
                        self.category[self.temp_id]=new_dict(empty_category)
                        self.category[self.temp_id]['Comment'].append(attrs["Id"])
            elif self.setting  == "Preset" and attrs["Type"]=="PresetValue":
                try:
                    self.preset[self.temp_id]['PresetValue'].append(attrs["Id"])
                except KeyError:
                    self.preset[self.temp_id]=new_dict(empty_preset)
                    self.preset[self.temp_id]['PresetValue'].append(attrs["Id"])
                
        elif name == "Element":
            if attrs["Type"] == "Label":
                self.setting="Label"
                self.temp_id =attrs["Id"]
            elif attrs["Type"] == "Comment":
                self.setting="Comment"
                self.temp_id =attrs["Id"]
            elif attrs["Type"] == "Category":
                self.setting="Category"
                self.temp_id =attrs["Id"]
                try:
                    test = type(self.category[self.temp_id])
                except:
                    self.category[self.temp_id]=new_dict(empty_category)
            elif attrs["Type"] == "Trigger":
                self.setting="Trigger"
                self.temp_id =attrs["Id"]
            elif attrs["Type"] == "FunctionDef":
                self.setting="FunctionDef"
                self.temp_id =attrs["Id"]
            elif attrs["Type"] == "FunctionCall":
                self.setting="FunctionCall"
                self.temp_id =attrs["Id"]
            elif attrs["Type"] == "Param":
                self.setting="Param"
                self.temp_id =attrs["Id"]
            elif attrs["Type"] == "ParamDef":
                self.setting="ParamDef"
                self.temp_id =attrs["Id"]
            elif attrs["Type"] == "Preset":
                self.setting="Preset"
                self.temp_id =attrs["Id"]
            elif attrs["Type"] == "PresetValue":
                self.setting="PresetValue"
                self.temp_id =attrs["Id"]
                try:
                    test = type(self.preset_value[self.temp_id])
                except:
                    self.preset_value[self.temp_id]=new_dict(empty_preset_value)
            elif attrs["Type"] == "SubFuncType":
                self.setting="SubFuncType"
                self.temp_id =attrs["Id"]
            elif attrs["Type"] == "Variable":
                self.setting="Variable"
                self.temp_id =attrs["Id"]
            
        elif name =="Label":
            if  self.setting=="Category":
                try:
                    self.category[attrs['Id']]['Label']=attrs['Id']
                except KeyError:
                    self.category[attrs['Id']]=new_dict(empty_category)
                    self.category[attrs['Id']]['Label']=attrs['Id']
            elif  self.setting=="Trigger":
                try:
                    self.trigger[attrs['Id']]['Label']=attrs['Id']
                except KeyError:
                    self.trigger[attrs['Id']]=new_dict(empty_trigger)
                    self.trigger[attrs['Id']]['Label']=attrs['Id']
            elif self.setting == "FunctionDef":
                    try:
                        self.function_def[self.temp_id]["Label"]=attrs['Id']
                    except KeyError:
                        self.function_def[self.temp_id] = new_dict(empty_function_def)
                        self.function_def[self.temp_id]["Label"]=attrs['Id']
            elif self.setting == "Preset":
                    try:
                        self.preset[self.temp_id]["Label"]=attrs['Id']
                    except KeyError:
                        self.preset[self.temp_id] = new_dict(empty_preset)
                        self.preset[self.temp_id]["Label"]=attrs['Id']
						
        elif name[:4]=="Flag":
            if self.setting == "FunctionDef":
                try:
                    self.function_def[self.temp_id]["Flag"][name]=name
                except KeyError:
                    self.function_def[self.temp_id] = new_dict(empty_function_def)
                    self.function_def[self.temp_id]["Flag"][name]=name

        elif name=="Parameter":
            if self.setting == "FunctionDef":
                try:
                    self.function_def[self.temp_id]["Parameter"].append(attrs['Id'])
                except KeyError:
                    self.function_def[self.temp_id] = new_dict(empty_function_def)
                    self.function_def[self.temp_id]["Parameter"].append(attrs['Id'])
					
        elif name=="Type":
            if self.setting == "FunctionDef":
                try:
                    self.function_def[self.temp_id]["ReturnType"]=attrs['Value']
                except KeyError:
                    self.function_def[self.temp_id] = new_dict(empty_function_def)
                    self.function_def[self.temp_id]["ReturnType"]=attrs['Value']
            elif self.setting == "ParamDef":
                try:
                    self.param_def[self.temp_id]["Type"]=attrs['Value']
                except KeyError:
                    self.param_def[self.temp_id] = new_dict(empty_param_def)
                    self.param_def[self.temp_id]["Type"]=attrs['Value']
					
        elif name=="TypeElement":
            if self.setting == "FunctionDef":
                try:
                    self.function_def[self.temp_id]["TypeElement"]=attrs['Id']
                except KeyError:
                    self.function_def[self.temp_id] = new_dict(empty_function_def)
                    self.function_def[self.temp_id]["TypeElement"]=attrs['Id']
            elif self.setting == "ParamDef":
                try:
                    self.param_def[self.temp_id]["TypeElement"]=attrs['Id']
                except KeyError:
                    self.param_def[self.temp_id] = new_dict(empty_function_def)
                    self.param_def[self.temp_id]["TypeElement"]=attrs['Id']
					
        elif name=="GameType":
            if self.setting == "ParamDef":
                try:
                    self.param_def[self.temp_id]["GameType"]=attrs['Value']
                except KeyError:
                    self.param_def[self.temp_id] = new_dict(empty_param_def)
                    self.param_def[self.temp_id]["GameType"]=attrs['Value']
					
        elif name=="Limits":
            if self.setting == "ParamDef":
                try:
                    self.param_def[self.temp_id]["Limits"]=attrs['Value']
                except KeyError:
                    self.param_def[self.temp_id] = new_dict(empty_param_def)
                    self.param_def[self.temp_id]["Limits"]=attrs['Value']
					
        elif name=="BaseType":
            if self.setting == "Preset":
                try:
                    self.preset[self.temp_id]["BaseType"]=attrs['Value']
                except KeyError:
                    self.preset[self.temp_id] = new_dict(empty_preset)
                    self.preset[self.temp_id]["BaseType"]=attrs['Value']
					
        elif name[:5]=="Preset":
            if self.setting == "Preset":
                try:
                    self.preset[self.temp_id]["Flag"].append(name)
                except KeyError:
                    self.preset[self.temp_id] = new_dict(empty_preset)
                    self.preset[self.temp_id]["Flag"].append(name)
					
        elif name=="DefinesDefault":
            if self.setting == "PresetValue":
                try:
                    self.preset_value[self.temp_id]["DefinesDefault"]=True
                except KeyError:
                    self.preset_value[self.temp_id] = new_dict(empty_preset_value)
                    self.preset_value[self.temp_id]["DefinesDefault"]=True
	#reset settings				
    def endElement(self, name):
        if name == "Root" or name == "Element":
            self.setting = ""

    # we need to parse the data between <x> and </x> this is the function    
    def characters(self, content):
        s = content.strip()
        if s != "":
            if self.setting == "Label":
                if self.temp_name == "Icon":
                    try:
                        self.icon[self.temp_id]['Texture'] = s
                    except KeyError:
                        self.icon[self.temp_id] ={'Texture': "",'Color':"" }
                        self.icon[self.temp_id]['Texture'] = s
                elif self.temp_name == "Color":
                    try:
                        self.icon[str(self.temp_id)]['Color'] = s
                    except KeyError:
                        self.icon[self.temp_id] ={'Texture': "",'Color':"" }
                        self.icon[self.temp_id]['Color'] = s
            elif self.setting == "Comment":
                if self.temp_name == "Comment":
                    try:
                        self.comment[self.temp_id]['Text'] = s
                    except KeyError:
                        self.comment[self.temp_id]={'Text':"",'SubFuncType':""}
                        self.comment[self.temp_id]['Text'] = s
            elif self.setting == "FunctionDef":
                if self.temp_name == "Identifier":
                    try:
                        self.function_def[self.temp_id]["Identifier"]=s
                    except KeyError:
                        self.function_def[self.temp_id] = new_dict(empty_function_def)
                        self.function_def[self.temp_id]["Identifier"]=s
            elif self.setting == "ParamDef":
                if self.temp_name == "Identifier":
                    try:
                        self.param_def[self.temp_id]["Identifier"]=s
                    except KeyError:
                        self.param_def[self.temp_id] = new_dict(empty_param_def)
                        self.param_def[self.temp_id]["Identifier"]=s
            elif self.setting == "Preset":
                if self.temp_name == "Identifier":
                    try:
                        self.preset[self.temp_id]["Identifier"]=s
                    except KeyError:
                        self.preset[self.temp_id] = new_dict(empty_preset)
                        self.preset[self.temp_id]["Identifier"]=s
            elif self.setting == "PresetValue":
                if self.temp_name == "Identifier":
                    try:
                        self.preset_value[self.temp_id]["Identifier"]=s
                    except KeyError:
                        self.preset_value[self.temp_id] = new_dict(empty_preset_value)
                        self.preset_value[self.temp_id]["Identifier"]=s
                elif self.temp_name == "Value":
                    try:
                        self.preset_value[self.temp_id]["Value"]=s
                    except KeyError:
                        self.preset_value[self.temp_id] = new_dict(empty_preset_value)
                        self.preset_value[self.temp_id]["Value"]=s
						
    #generate event functions in wikicreale
    def generate_sub_event(self,a,b):
        res=0
        self.category[b]['FunctionDef'].sort(key=cmp_to_key(lambda x,y: self.function_def[x]["Identifier"]<self.function_def[y]["Identifier"]))
        for c in self.category[b]['FunctionDef']:
                        if 'FlagEvent' in self.function_def[c]['Flag'].keys():
                            res=1
                            print("={}-{}".format(self.get_string("root",a),self.get_string("SubCategory",b)),file=output_file)
                            # if there is a trigger in category we want to show category
##                            flag_root+=1
##                            flag_category+=1
##                            if flag_root == 1:
##                                print("=="+self.get_string("root",a),file=output_file)
##                            if flag_category == 1 and self.get_string("SubCategory",b).strip() !="":
##                                print ("==="+self.get_string("SubCategory",b),file=output_file)
                            # get the grammar hint name as a list
                            grammar_hint_name = self.get_string("GrammarHintName",c)
                            #print("<<apifunction>>",file=output_file)
                            print("=="+grammar_hint_name[2],file=output_file)
                            print("===GUI",file=output_file)
                            grammar_split =white_space_filter(grammar_hint_name[0].strip()).split()
                            grammer_var = []
                            for i in range(len(grammar_split)):
                                if grammar_split[i][-1]=="~" or grammar_split[i][0]=="~":
                                    grammer_var.append(i)
                                    grammar_split[i] = grammar_split[i].replace("~","")
                                                                                            
                            #parse the galaxy script function
                            #
                            galaxy_code= ""
                            for line in self.natives_file:
                                if line.find(self.function_def[c]['Identifier'])>-1:
                                    galaxy_code = line.strip()
                                    break
                            #makeup for parameter
                            galaxy_code=white_space_filter(galaxy_code.replace("native ","").replace (";",""))
                            galaxy_code2=galaxy_code[galaxy_code.find("("):]
                            galaxy_code2=galaxy_code2.replace("(","").replace(")","")
                            galaxy_code2=galaxy_code2.split(",")
                            for i in range(len(galaxy_code2)):
                                galaxy_code2[i]=tuple(galaxy_code2[i].split())
                            galaxy_code=galaxy_code[:galaxy_code.find("(")]+"("
                            for i in range(len(galaxy_code2)):
                                if i>0:
                                    grammar_split[grammer_var[i-1]]="[[galaxy/triggers/types/{}|{}]]".format(galaxy_code2[i][0],grammar_split[grammer_var[i-1]])
                                galaxy_code+="[[galaxy/triggers/types/{}|{}]] ".format(galaxy_code2[i][0],galaxy_code2[i][0])+galaxy_code2[i][1]+","
                            galaxy_code=galaxy_code[:-1]+")"
                            #makeup for the return type
                            i = galaxy_code.find(" ")
                            galaxy_code2=galaxy_code[:i]
                            galaxy_code2="[[galaxy/triggers/types/{}|{}]] ".format(galaxy_code2,galaxy_code2)
                            galaxy_code=galaxy_code2+galaxy_code[i:]
                            grammar_hint_name[0]=""
                            for i in grammar_split:
                                grammar_hint_name[0]+=i+" "
                            print(self.get_string("root",a)+" - "+grammar_hint_name[0],file=output_file)
                            print("===Galaxy Code",file=output_file)
                            print (galaxy_code,file=output_file)
                            print("===Description",file=output_file)
                            print(grammar_hint_name[1],file=output_file) 	
                            print("===Parameters",file=output_file)
                            print ("*[[galaxy/triggers/types/trigger|trigger]]  t\n",file=output_file)
                            for parameter in self.function_def[c]['Parameter']:
                                k = self.get_string("ParamDef",parameter)
                                print ("*"+k[2],file=output_file)
                                for i in range(3,len(k)):
                                    print ("**"+k[i],file=output_file)
                            print ("\n\n",file=output_file)
                                
        return res                    
    def generate_event(self,k="",g=""):
        if k=="" and g=="":
            print("=EVENT",file=output_file)
            key_list = sorted(self.root_category.keys(),key=cmp_to_key(lambda x,y: self.get_string("root",x)<self.get_string("root",y)))
            for a in key_list:       
                self.category[a]['SubCategory'].sort(key=cmp_to_key(lambda x,y: self.get_string("SubCategory",x)<self.get_string("SubCategory",y)))
                for b in self.category[a]['SubCategory']:
                    if self.category[b]['SubCategory'] ==[]:
                        
                        self.generate_sub_event(a,b)
                    else:
                        self.generate_event(a,b)
        else:

                if self.category[g]['SubCategory'] ==[]:
                    self.generate_sub_event(k,g)
                else:
                    self.generate_sub_event(k,g)
                    self.category[g]['SubCategory'].sort(key=cmp_to_key(lambda x,y: self.get_string("SubCategory",x)<self.get_string("SubCategory",y)))
                    for c in self.category[g]['SubCategory']:
                        self.generate_event(k,c)

                
    #generate event functions in wikicreale
    def generate_event_index(self,k=""):
        if k == "":
            print("=EVENT INDEX",file=output_file)
            key_list = sorted(self.root_category.keys(),key=cmp_to_key(lambda x,y: self.get_string("root",x)<self.get_string("root",y)))                                                                          
            for a in key_list:   
                self.category[a]['SubCategory'].sort(key=cmp_to_key(lambda x,y: self.get_string("SubCategory",x)<self.get_string("SubCategory",y)))
                print("==[[galaxy/triggers/category-{}|{}]]".format(name_to_url(self.get_string("root",a)),self.get_string("root",a).strip()),file=output_file)
                for b in self.category[a]['SubCategory']:
                    if self.category[b]['SubCategory'] ==[]:
                        self.category[b]['FunctionDef'].sort(key=cmp_to_key(lambda x,y: self.function_def[x]["Identifier"]<self.function_def[y]["Identifier"]))
                        result=self.generate_sub_event_index(b)
                        if result!="":
                            print ("==="+self.get_string("SubCategory",b),file=output_file)
                            print (result,file=output_file)
                    else:
                        self.generate_event_index(b)
        else:

                        if self.category[k]['SubCategory'] ==[]:
                            self.category[k]['FunctionDef'].sort(key=cmp_to_key(lambda x,y: self.function_def[x]["Identifier"]<self.function_def[y]["Identifier"]))
                            result=self.generate_sub_event_index(k)
                            if result!="":
                                #print("==[[galaxy/triggers/category-{}|{}]]".format(name_to_url(self.get_string("root",a)),self.get_string("root",k).strip()),file=output_file)
                                print ("==="+self.get_string("SubCategory",k),file=output_file)
                                print (result,file=output_file)
                        else:
                            self.category[k]['FunctionDef'].sort(key=cmp_to_key(lambda x,y: self.function_def[x]["Identifier"]<self.function_def[y]["Identifier"]))
                            result=self.generate_sub_event_index(k)
                            if result!="":
                                print ("==="+self.get_string("SubCategory",k),file=output_file)
                                print (result,file=output_file)
                            self.category[k]['SubCategory'].sort(key=cmp_to_key(lambda x,y: self.get_string("SubCategory",x)<self.get_string("SubCategory",y)))
                            for c in self.category[k]['SubCategory']:
                                self.generate_event_index(c)

    def generate_sub_event_index(self,b):                   
        res=""
        self.category[b]['FunctionDef'].sort(key=cmp_to_key(lambda x,y: self.function_def[x]["Identifier"]<self.function_def[y]["Identifier"]))
        for c in self.category[b]['FunctionDef']:  
            if 'FlagEvent' in self.function_def[c]['Flag'].keys():
                # get the grammar hint name as a list
                grammar_hint_name = self.get_string("GrammarHintName",c)
                res+="====[[galaxy/triggers/{}|{}]]".format(name_to_url(grammar_hint_name[2]),grammar_hint_name[2].strip())+"\n"
                res+="*"+grammar_hint_name[1]+"\n"	
                        
        return res
	#generate action or functions in wikicreale
    def generate_function(self):
        pass
	#generate preset + preset values in wikicreale
    def generate_preset(self):
        res=""
        for a in self.preset.keys():
            res=""
            res +="=="+self.preset[a]['Identifier']+"\n"
            res +="*"+self.preset[a]['Label']+"\n"
            res +="*BaseType: "+self.preset[a]['BaseType']+"\n"
##            res +="*Flag:\n"
##            for b in self.preset[a]['Flag']:
##                res +="** "+b+"\n"
            res += "===PresetValue\n"
            for b in self.preset[a]['PresetValue']:
                value = self.get_string("PresetValue",b)
                res +="* {}:{}".format(value[0],value[1])
                if value[2]:
                    res += "Default \n"
                else:
                    res += "\n"
            print (res)
        pass
    #get pure data in simple string no mackup except link tag
    def get_string(self,its_category="",its_id=""):
        res=""
        temp_tag=""
        
        if its_category=="root":
            temp_tag = "Category/Name/lib_Ntve_"+its_id+"="
            for line in self.string_file:
                if line.find(temp_tag)==0:
                    res+=line[len(temp_tag):]
                    res=res.strip()
                    break
        elif its_category=="SubCategory":
            temp_tag = "Category/Name/lib_Ntve_"+its_id+"="
            for line in self.string_file:
                if line.find(temp_tag)==0:
                    res+=line[len(temp_tag):]
                    res=res.strip()
                    break
        elif its_category=="GrammarHintName":
            temp_tag=['FunctionDef/Grammar/lib_Ntve_'+its_id+"="]
            temp_tag.append('FunctionDef/Hint/lib_Ntve_'+its_id+"=")
            temp_tag.append('FunctionDef/Name/lib_Ntve_'+its_id+"=")
            a = 0
            #temp_prefix=["===GUI","===Description ","=="]
            res=[]
            for line in self.string_file:
                if line.find(temp_tag[a])!=-1:
                    res.append(line[len(temp_tag[a]):])
                    a+=1
                if a>=3:
                    break
        elif its_category=="ParamDef":
            res=[]
            res.append(self.param_def[its_id]['Type'])
            res.append(self.param_def[its_id]['Identifier'])
            res.append("[[galaxy/triggers/types/{}|{}]] ".format(self.param_def[its_id]['Type'],self.param_def[its_id]['Type']) + self.param_def[its_id]['Identifier'])
            if self.param_def[its_id]['Type']!="preset":
                #get rest info like limit
                for key in self.param_def[its_id]:
                    if key!="Type" and key!="Identifier" and self.param_def[its_id][key]!="" and self.param_def[its_id][key]!=False:
                        res.append(key + ": " + str(self.param_def[its_id][key]))
            else:
                preset_name=""
                temp_tag = "Preset/Name/lib_Ntve_"+self.param_def[its_id]["TypeElement"]+"="
                for line in self.string_file:
                    if line.find(temp_tag)>=0:
                        preset_name+=line[len(temp_tag):]
                        break
                
                res.append("Preset: [[galaxy/triggers/presets/{}|{}]]".format(name_to_url(preset_name),preset_name.strip()))
                #get rest info like limit
                for key in self.param_def[its_id]:
                    if key!="Type" and key!="Identifier" and key!="TypeElement" and self.param_def[its_id][key]!="" and self.param_def[its_id][key]!=False:
                        res.append(key + ": " + str(self.param_def[its_id][key]))
        elif its_category=="PresetValue":
            res=[]
            res.append(self.preset_value[its_id]["Identifier"])
            res.append(self.preset_value[its_id]["Value"])
            res.append("Default: {}".format(str(self.preset_value[its_id]["DefinesDefault"]))) 
        return res
    #we want to save the output or print the data here.   
    def endDocument(self):
        self.generate_preset()

def clean_lines(file):
    data = file.readlines()
    title=0
    k= len(data)
    i=0
    while i < k:
        if len(data[i])>=3 and data[i][:2]=="==" and data[i][2]!="=":
            title+=1
        if title==2:
            data.pop(i-1)
            k-=1
            title-=1
            i-=1
        i+=1
    return data
#main function, which will be called if u use this file as a exec not as lib
if __name__ == '__main__':
    # Create a parser
    parser = make_parser()

    # Tell the parser we are not interested in XML namespaces
    parser.setFeature(feature_namespaces, 0)

    # Create the handler
    dh = FunctionWriter(string_list,native_galaxy)

    # Tell the parser to use our handler
    parser.setContentHandler(dh)

    # Parse the input
    parser.parse(native_lib)
    output_file.close()
    data = clean_lines(open(os.path.join('output.txt'),'r'))
    output_file = open(os.path.join('output.txt'),'w')
    for line in data:
        if line.strip()!="":
            print(line.strip(),file=output_file)
    output_file.close()