View difference between Paste ID: XPtTgMj8 and RurmzEu5

 # py_to_cpp.py
 
 #script to read python code in to an AST, parse and replace nodes with corresponding
 #c++ code
 
 #make relevant imports
 import ast
 import numpy as np
 
 #parser class for function definitions
 class FunctionParser(ast.NodeVisitor):
     def visit_FunctionDef(self, node): #visit the function definition node
         #define relevant globals that require access
         global converted_lines, function_body, arg_vars, list_types, class_args
         arg_vars = [] #list of arguments
         args_string = '' #argument string for conversion
         init_arg = [] #store a list of arguments to initialise, done for use in any class definitions
 
         for i in range(0,len(node.args.args)): #iterate over the node arguments
             arg_val = node.args.args[i].arg #for each arg get the arg name
             init_arg.append(arg_val) #append the arg name to the list of args to initialise
 
         #class arguments usually start with self, self is not required for c++
         #a type won't have been defined in the function call for self, therefore if different number of list types to arguments
         #and first argument is self, remove the argument so the list of types and arguments matches up again
         if((len(init_arg) != len(list_types[0])) and init_arg[0] == 'self'):
             init_arg.pop(0)
         else:
             pass
 
         #iterate over the arguments to initialise
         for i in range(0,len(init_arg)):
             arg_type = list_types[0][i] #get the types of the first function's arguments
             full_arg = arg_type + ' ' + init_arg[i] #define a full argument string as the type and name
             arg_vars.append(full_arg) #add the full arg definition to list
             args_string += full_arg + ', ' #add the full arag definition to the arg string
         args_string = args_string[:-2] #remove extra ', ' at the end of the line
         list_types.pop(0) #remove the arg types for the arguments that have just been processed
 
         #if the name of the function is a class initialilser run a special case
         if(node.name == '__init__'):
             class_initialiser = [] #block for class initialisation function
             class_initialiser.append('public:') #mark following class variables as public for initalising the object
             class_args = init_arg #set the class args as a copy of the initialiser args
             for i in node.body: #iterate over the body of the initialiser function
                 line = general_access_node(i) #classify and convert the line of the function
                 splitup = line.split(' ') #split the converted line by space to inspect elements
                 #the following is a messy way to initialise class variables, if it is an initialisation the line will be in the
                 #style std::string name = "name"; which is incorrect formatting due to how these statements are processed elsewhere
                 try:
                     #check if the first argument of splitup (name) is equal to the final element of splitup inside quotations
                     #and without the ; ("name";).
                     if(splitup[1] == ("%s" % splitup[3][:-1]).replace('"','')):
                         #if it is then its a variable declaration, take the converted arg_vars declaration and add a semicolon
                         #it will now be in the form std::string name; (or other appropriate type of variable)
                         string_val = arg_vars[0]+';'
                         class_initialiser.append(string_val) #append the new string to the block
                         arg_vars.pop(0) #remove the arg_var as it has been declared in block
                     else: #if it doesn't match just append the line
                         class_initialiser.append(line)
                 except: #if splitup element access fails just append the line as the above condition will not occur
                     class_initialiser.append(line)
             return class_initialiser #return the initialised class function
         else:
             pass
 
         function_body = [] #define list for the main body of the function
         for i in node.body: #iterte over the nodes in the body of the function
             if(type(i) == ast.Return): #check if the line is a return function
                 line = ReturnParser().visit_Return(i) #visit the return parser function
                 if(line == None): #if return is a void return
                     function_body.append('return') #add a void return to the body
                 else: #if return has arguments
                     return_types = [] #make a list of the types of values being returned
                     for j in range(0,len(line)):  #iterate over the return values listed
                         for i in reversed(range(0,len(function_body))): #iterate backwards over the body of the function (find the latest definitions of the variables)
                             declaration_check = ' %s = ' % line[j] #check for a definition of the variable
                             if(declaration_check not in function_body[i]): #if there is not a definition of the variable on this line of the function body skip it
                                 pass
                             else: #if a definition is found isolate they type by taking the first word and add it to the return types list
                                 return_types.append(function_body[i].split(' ')[0])
                     #if there is only one return value a normal return can be used
                     if(len(return_types) == 1):
                         #add the return and the value to the function body
                         function_body.append('return %s;' % line)
                     else: #if multiple values are required generate a structure to return
                         struct_string = 'struct result {' #initialise structure string
                         for i in range(0,len(line)): #iterate over the number of arguments
                             #add (value_type dummy_return_[number];) to the structure string
                             struct_string += return_types[i] + ' dummy_return_%s; ' % str(i)
                         #remove the extra space, close the struct bracket and end statement for struct definition
                         struct_string = struct_string[:-1] + '};'
                         function_body.append(struct_string) #add the struct definition to the function body
                         return_string = 'return result {' #create string for function returns using the structure just defined
                         for i in range(0,len(line)): #iterate over the return arguments
                             return_string += line[i] + ', ' #add the arguments to the return string
                         return_string = return_string[:-2] + '};' #remove the extra ', ' and close bracket and end return statement
                         function_body.append(return_string) #add the return string to the function body
             else: #if the node is not a return determine the type and convert it then add to function body
                 function_body.append(general_access_node(i))
         if('return' in function_body[-1]): #check if the function was ended with a return
             pass
         else: #if no return add one
             function_body.append('return;')
         if(node.name == 'main'): #add a catch to prevent duplicate main functions within the converted script
             raise NameError('A function named "main" cannot be used within a C++ script as it is the default insertion point for the code, please rename this function in your script, this script will fill in a C++ main function automatically')
         else:
             pass
 
         function = [] #block for whole function
         #define the c++ function definition with the function name and the arguments string
         function_def = 'auto %s (%s) {' % (node.name, args_string)
         function.append(function_def) #add the function definition line
         function.append(function_body) #add the function body
         function.append('}') #close the open function brace
         arg_vars = [] #reset arg_vars as it is global
         function_body = [] #reset function body as it is global
         return function #return whole function
 
 #define parser for class definitions
 class ClassDefParser(ast.NodeVisitor):
     def visit_ClassDef(self,node): #visit class definition node
         global class_args #access to relevant globals
         class_block = [] #block of lines of converted class
         class_name = node.name #get the name of the class
         class_dec = 'class %s {' % class_name #make a converted class statement
         class_block.append(class_dec) #append the class stement to the block
 
         class_body = [] #make list of body of class statement
         for i in node.body: #iterate over the nodes in the body
             line = general_access_node(i) #convert the line of nodes and return
             class_body.append(line) #append the converted line to the body
 
         class_block.append(class_body) #append the body to the block
         class_block.append('};') #close off the class definition
 
         #@todo these properties
         #print(node.bases)
         #print(node.keywords)
         #print(node.decorator_list)
         return class_block #return the class block
 
 #input classifying and converting function
 def input_convert(name,data,type_var): #pass args of the variable, input arg data and the type of variable (pre-determined)
     val_assign = data #set val assign as data
     name_assign = name #set name assign as name
     converted_input = [] #list of converted input lines
     args = val_assign[1] #store the args of the input string
     outstring = args[0] #argument of the input string (line to output to prompt an input)
     outstring = string_or_var(outstring) #check if the outstring is a variable or string question
     outline = 'std::cout << ' + outstring + ';' #output the outstring
     converted_input.append(outline) #store the output line
     var = name_assign #store name of variable under var
     set_var = type_var + ' ' + var +';' #declare the input variable using the previously found type
     converted_input.append(set_var) #append the declaration to the input lines
     if(type_var=='std::string'): #if the type of input is a string
         input_string = 'std::getline (std::cin, %s);' % var #format a getline command to avoid whitespace breaks as this is probably unintended
         converted_input.append(input_string) #append the getline command to the input lines
     else: #if some other var type like float or int
         input_string = 'std::cin >> %s;' % var #use a standard cin command
         converted_input.append(input_string) #append the input command
         clear_in_buffer = 'std::cin.get();' #add a line to clear the input buffer to remove trailing \n for future input
         converted_input.append(clear_in_buffer) #append the clear buffer command
     end_line = 'std::cout << std::endl;' #append command to end line after inputs so next line isn't printed on the same line
     converted_input.append(end_line) #append the end line command to the input conversion
     return converted_input #return the input conversion
 
 #parser class for assign statements, anything with an =
 class AssignParser(ast.NodeVisitor):
     def visit_Assign(self,node): #function to visit the assign node
         global converted_lines, arg_vars, class_vars_for_call, called_objs, list_spiel #access to required globals
         for name in node.targets: #iterate over the node targets
             name_assign = general_access_node(name) #get the name, this is the variable the value is assigned to
         if(type(node.value) == ast.BinOp): #check for binary operators in the statement
             val_assign = BinOpParser().visit_BinOp(node.value) #send the node value to the binary operator parser, this will return the arguments swapping out ast operators for c++ operators
             flatten = [] #list for converting any sublists to one 1D array
             for i in val_assign: #iterate over the values
                 if isinstance(i,list): #if one of the values is a list
                     for j in i: #iterate the values in that list and append to the flattened array
                         flatten.append(j)
                 else: #if not a list just append the values directly
                     flatten.append(i)
             if(flatten!=[]): #if anything was added to the flatten list set the list as the value for the assign
                 val_assign = flatten
             else:
                 pass
             val_assign = ['BinOp',val_assign] #specify that this was a BinOp assignment
         else: #if it wasn't a bin op find the type of node and convert the value to appropriate formatting
             val_assign = general_access_node(node.value)
 
         try:
             if(name_assign==("%s" % val_assign)): #if name_assign assign and val assign are the same
                 class_vars_for_call.append(val_assign) #store the val in a list of class variables
             else:
                 pass
         except:
             pass
 
         type_check = type(val_assign) #find the type data the value assign is
         if(type_check == tuple and val_assign[0] == 'open'): #this condition will be met if the user attempts to open a file
             #val_assign will be in format (open,[filename,r/w/a])
             file_conversion = [] #make a list for file operation conversion
             args = val_assign[1] #args of the
             file_name = args[0] #get the file name as first arg
             open_type = args[1] #get the type of file operation as second arg
             file_declare = 'std::fstream %s;' % name_assign #make declaration of file stream
             file_conversion.append(file_declare) #appedn declaration to file conversion
             #convert appropriate operation type to c++ equivalent
             if('r' in open_type):
                 open_type = 'std::ios::in'
             elif('w' in open_type):
                 open_type = 'std::ios::out'
             elif(open_type == 'a'):
                 open_type = 'std::ios::app'
 
             file_name = file_name.replace('\\',"/") #replace backslash with forward to prevent issues in file name
             open_line = '%s.open("%s",%s);' % (name_assign,file_name,open_type) #declare line to open file with appropriate type
             file_conversion.append(open_line) #append file opening statement to file conversion block
             return file_conversion #return file conversion block
         #this condition will be met if someone declares an empty list
         elif(val_assign == []):
             if(list_spiel == True): #print this spiel of information if it is the first time this warning has come up
                 print('\nAn empty list was detected in your python script, this is a problem for the conversion.')
                 print('The C++ equivalent of python lists need to have the data type being entered declared in advance.')
                 list_spiel = False
             else:
                 pass
 
             appropriate_answer = False #inform user how to classify and enter their list types
             print('\nEmpty list detected called "%s", please enter a data type for the list. Accepted data types are: integer, float, string' % name_assign)
             print('If list will contain more lists please enter: list(type_of_data_in_sublist) and so on if sub_list type is another list, see "help" for an example.')
             while(appropriate_answer==False): #keep getting an input until an appropriate one is entered
                 data_type = input('Please enter a type listed above or "help" for more information: ')
 
                 if(data_type.lower() == 'help'): #if user asking for help print examples of each type
                     print('For an integer list type, the list could look like: [1,2,3,4,5]')
                     print('For a float list type, the list could look like [1.1,2.2,3.3,4.4,5.5]')
                     print('For a string list type, the list could look like ["Apples","Oranges","Bananas","Pears"]')
                     print('For a list of lists, the list could look like [ [[1,1,1],[2,2,2]] , [[3,3,3],[4,4,4]] ]. In this case you would need to enter: list(list(integer)).')
                     print('This is because you enter list one less time than the nest level (nest_level = consecutive "[" at the start) and the lowest level data is of type integer')
                 elif(data_type.lower() == 'integer'): #format list of integers
                     type_check = 'std::vector<int>'
                     val_assign = '{}'
                     appropriate_answer = True
                 elif(data_type.lower() == 'float'): #format list of floats
                     type_check = 'std::vector<float>'
                     val_assign = '{}'
                     appropriate_answer = True
                 elif(data_type.lower() == 'string'): #format list of strings
                     type_check = 'std::vector<std::string>'
                     val_assign = '{}'
                     appropriate_answer = True
                 elif('list' in data_type.lower()): #format list of lists
                     converted_string_lists = data_type.replace('list','std::vector').replace('(','<').replace(')','>')
                     converted_string_lists = converted_string_lists.replace('integer','int').replace('string','std::string')
                     type_check = 'std::vector<%s>' % converted_string_lists
                     val_assign = str(val_assign).replace('[','{').replace(']','}')
                     if('int' in converted_string_lists or 'float' in converted_string_lists or 'std::string' in converted_string_lists):
                         appropriate_answer = True
                     else:
                         print('Invalid input, please try again')
                 else:
                     print('Invalid input, please try again')
         #this condition will be met if line is assigning an input to a variable
         elif(type_check == tuple and val_assign[0] == 'input'):
             converted = input_convert(name_assign,val_assign,'std::string') #convert the input using the function above passing type as string as input was not formatted with int(input()) or float(input())
             return converted #return the conversion
         #this condition met if input wrapped in a type command of int or float or just a standard int/float command
         elif(type_check == tuple and (val_assign[0] == 'int' or val_assign[0] == 'float')):
             if(val_assign[1][0][0] == 'input'): #if an input command wrapped by the function
                 converted = input_convert(name_assign,val_assign[1][0],val_assign[0]) #convert input command using var type of the wrapping function
                 return converted #return the converted input
             else: #if it's not an input raise a TypeError as it is not handled yet
                 #@todo normal int() float() list() str() commands
                 raise TypeError('Conversion of arg type not handled %s' % val_assign)
         #if the val_assign is a call to create an object this condition will be met, this method is a bit messy and could potentially do with reworking
         elif(type_check == tuple and any(('class %s {' % val_assign[0]) in x for x in converted_lines)):
             #print(val_assign[0], name_assign, val_assign[1])
             #val_assign will have format (Class_Name,[init_arg,init_arg,...])
             obj_declaration = [] #make list for object declaration
             secondary_class_store = [] #secondary list of class
             assign_obj = '%s %s;' % (val_assign[0],name_assign) #definition of creating object conversion
             obj_declaration.append(assign_obj) #add object declaration to body
             args_obj = val_assign[1] #isolate arguments of the object declaration
             count = 0 #iterator for removing used object args
             recall = False #flag for if this is the second time an object of the same type is being created
             for i in range(0,len(called_objs)): #iterate over list of previously called classes
                 if(val_assign[0] == called_objs[i][0]): #check if this object is same type as existing
                     recall = True #mark that this is a recall
                     break #stop iterating
                 else:
                     pass
             if(recall==False): #if this is the first time this class has been called
                 secondary_class_store.append(val_assign[0]) #append the type to secondary list tracking classes called
                 for i in range(0,len(args_obj)): #iterate over the object args
                     if(type(args_obj[i]) == str): #if type of arg is a string
                         args_obj[i] = string_or_var(args_obj[i]) #check if was a string or variable, replace it with variable if variable
                     else:
                         pass
                     secondary_class_store.append(class_vars_for_call[i]) #store the class variable name
                     converted_line = '%s.%s = %s;' % (name_assign,class_vars_for_call[i],args_obj[i]) #initialise class parameters with values
                     count+=1 #increase count of variables from class_vars_for_call used
                     obj_declaration.append(converted_line) #append the converted line to the declaration block of the object
                 called_objs.append(secondary_class_store) #append previously called objects with the secondary list of class info
                 class_vars_for_call = class_vars_for_call[count:] #omit the used up variables from the class_vars_for_call list
             else: #if the class has been called before
                 for j in range(0,len(called_objs)): #iterate over the previously called objects list
                     if(called_objs[j][0] == val_assign[0]): #find the match case for this call
                         for k in range(1,len(called_objs[j])): #iterate over the arguments in that match call
                             #args_obj will take values one less than the corresponding stored argument as the first argument in a called_objs element will be the name of the class
                             #therefore called_objs[j] = ['Class_name',arg1,arg2,...], so for each k the corresponding arg to use is k-1
                             if(type(args_obj[k-1]) == str): #if type of arg is a string
                                 args_obj[k-1] = string_or_var(args_obj[k-1]) #check if was a string or variable, replace it with variable if variable
                             else:
                                 pass
                             converted_line = '%s.%s = %s;' % (name_assign,called_objs[j][k],args_obj[k-1]) #initialise class parameters with values
                             obj_declaration.append(converted_line) #append the converted line to the object declaration
                         break #break loop as relevant match found
                     else:
                         pass
             return obj_declaration #return the object declaration
         #if the val_assign is a return from the subscript parser this condition will be met
         elif(type_check == tuple and val_assign[0] == 'subscript'):
             #val_assign here will be ('subscript',['index',list_name,index_value])
             args = val_assign[1] #arguments of the assign statement stored
             list_name = args[1] #the name of the list is the argument 1
             type_script = args[0] #the type of subscripting (index/slice) stored
             if(type_script == 'index'): #if it is index subscripting
                 subscript = list_name + '[%s]' % args[2] #the subscript formtating is list_name[index_value]
             elif(type_script == 'slice'): #if it is slice subscripting
                 subscript = list_name + '[%s:%s]' % (args[2],args[3]) #the subscript formatting is list_name[lower_index:upper_index]
             else: #raise type error as other types are not handled yet
                 raise TypeError('Subscript type not yet handled: %s' % type_script)
 
             found = False #flag for if a declaration of list has been found
             #multiple iterating methods will follow this to check different places for declaration of the list
             #check the converted lines so far in reverse order to get the most recent declaration of the list
             for i in reversed(range(0,len(converted_lines))):
                 find_def = '%s = ' %  list_name #check for declaration of the list
                 if(find_def in converted_lines[i]): #check if the definition is on the current converted line
                     type_check = converted_lines[i].split(' ')[0] #if declaration match found isolate the type of the list
                     found = True #flag a declaration has been found
                 else:
                     pass
             #comparison to be made for if the list was declared in a function definition where the function has not yet been added to converted lines
             function_var = ' %s' % list_name
             if(arg_vars != [] and found == False): #if the list of arguments for active function is not empty and a match was not yet found
                 for i in range(0,len(arg_vars)): #iteratae over the arguments in the function definition
                     if(function_var not in arg_vars[i]):  #if no match for current argument pass
                         pass
                     else: #if match found isolate the type from the argument as the type for the subscript
                         type_check = arg_vars[i].split(' ')[0]
                         found = True #flag a match was found
             else:
                 pass
             #comparison to be made for if the list was declared in the body of the function currently being converted as it has not yet been added to converted lines
             if(function_body != [] and found == False):
                 #iterate backwards over the lines in the function body to get most recent declaration
                 for i in reversed(range(0,len(function_body))):
                     declaration_check = '%s = ' % list_name #expected declaration style of the list
                     #if not match in the line do nothing
                     if(declaration_check not in converted_lines[i]):
                         pass
                     else: #if there is a match isolate the type from the declaration
                         type_check = converted_lines[i].split(' ')[0]
                         found = True #flag as found
             #default to an auto type if no match is found
             if(found == False):
                 type_check = 'auto'
             else:
                 #list type will return something like vector<float>, the value from the subscript will therefore be a float
                 #need to isolate what is inside the first level of angle brackets
                 inner_level = type_check.split('std::vector<',1)[1] #remove the first lot of vector definition
                 mirrored = inner_level[::-1].replace('>','',1) #remove the final angle bracket to completely isolate the inner level
                 isolated_inner = mirrored[::-1] #re-mirror to get back original value
                 type_check = isolated_inner #type is now this isolted inner value
 
             val_assign = subscript #value is the formatted subscript
 
         #check if the name is a tuple, this conidition is met when attempting to set a list subscript to a certain value i.e. list[index] = 3
         elif(type(name_assign) == tuple):
             #name_assign will have the style ('subscript',['index',list_name,index_val])
             args = name_assign[1] #store arguments as the first element
             list_name = args[1] #name of the list is first argument element
             type_script = args[0] #store the type of subscripting
             if(type_script == 'index'): #if index type of subscripting format subscript as list_name[index_value]
                 subscript = list_name + '[%s]' % args[2]
             elif(type_script == 'slice'): #if slice type of subscripting format subscript as list_name[lower_index:upper_index]
                 subscript = list_name + '[%s:%s]' % (args[2],args[3])
             else: #if not one of these two raise a type error as it's not handled yet
                 raise TypeError('Subscript type not yet handled: %s' % type_script)
             #make converted line in the style list_name[index] = val;
             converted_line = subscript + ' = ' + str(val_assign) +';'
             return converted_line #return converted line as it's in different style to other assigns
         #if the type check is a tuple this is a function call return stored to a variable
         elif(type_check == tuple):
             #val assign will be equal to ('func_name',[func_args])
             func_name = val_assign[0] #store the name of the function
             val_assign = val_assign[1] #store the args of the function
             type_check = 'auto' #default to auto type returning
             args = val_assign #set args as the stored values
             for j in range(0,len(args)): #iterate over the args checking if string or variable
                 args[j] = string_or_var(args[j]) #stays same if variable overwrites to be in "" if string
 
             out_args = '' #set arguments string
             for i in range(0,len(args)): #iterate over the arguments
                 out_args += args[i] + ', ' #add the argument and ', ' to make comma separated string
             out_args = out_args[:-2] #remove the extra ', '
             #call formatted as func_name(func_args)
             val_assign = func_name + '(' + out_args + ')'
 
         #if val_assign is a list and a return of a binary operator string
         elif(type_check == list and val_assign[0] == 'BinOp'):
             #val_assign will be equal to ('BinOp',[list of values and operators])
             op_string = val_assign[1] #store list of arguments
             eq_string = '' #define the string of the equation
             for i in op_string: #iterate over the arguments
                 eq_string += str(i) + ' ' #add the argument to the existing string
             eq_string = eq_string[:-1] #remove the extra space at the end of the argument string
             val_assign = eq_string #set val_assign to this formatted string
 
             #a BinOp string could be for a concatenation of a string instead of maths
             #so attempt to determine the type of the first variable in the equation
             found = False #flag for no match
             #iterate backwards over converted lines for most recent definition
             for i in reversed(range(0,len(converted_lines))):
                 find_def = ' %s = ' %  op_string[0] #define the string to search for
                 if(find_def in converted_lines[i]): #if a match on this line
                     type_check = converted_lines[i].split(' ')[0] #isolate the type from the first word of the line
                     found = True #flag that a matach has been found
                 else:
                     pass
             function_var = ' %s' % op_string[0] #string to search for match in function arguments
             #only do this search if the line is in the body of a function that has not yet been completed
             if(arg_vars != [] and found == False):
                 for i in range(0,len(arg_vars)): #iterate over the arguments of the function
                     if(function_var not in arg_vars[i]): #if there is no match for this argument pass
                         pass
                     else: #if there is a match isolate the type from the first word of the argument declaration
                         type_check = arg_vars[i].split(' ')[0]
                         found = True #flag that a match has been found
             else:
                 pass
             #if a function body is currently in conversion and not yet appended to converted lines iterate over it to find match
             if(function_body != [] and found == False):
                 #iterate backwards through body to get most recent declaration
                 for i in reversed(range(0,len(function_body))):
                     declaration_check = '%s = ' % op_string[0] #string to check for in function body
                     if(declaration_check not in converted_lines[i]): #if no match this line do nothing
                         pass
                     else: #if match was found isolate the type as first word of line
                         type_check = converted_lines[i].split(' ')[0]
                         found = True #flag as found
             else:
                 pass
 
             if(found == False): #if no match was found default to an auto type
                 type_check = 'auto'
             else: #if match don't overwrite
                 pass
         #if the type of val_assign is a list then it is a list declaration
         elif(type_check == list):
             #val_assign could be 1D list such as [2,3,4] etc or could be list of lists
             inside_level = val_assign[0] #get the first element of the list to test if it is also a list for declaration purposes
             nest_level = 1 #indicate the level of nesting of the lists (this assumes there is one more list inside at leas, nest level is reduced by one at the end of this block to compensate for overcounting)
             while(type(inside_level) == list): #if the inside level is another list
                 inside_level = inside_level[0] #take another inside level
                 nest_level+=1 #increase the nesting count of the list
             nest_level-=1 #remove one to compensate for overcounting the nesting level
             #for as many lists are nested repeat std::vector<, for example the list [[2,3,4],[5,6,7]]
             #here would get a type check of std::vector<std::vector<int>>
             type_check = 'std::vector<'*(nest_level+1)+str(type(inside_level))+'>'*(nest_level+1)
             val_assign = str(val_assign).replace('[','{').replace(']','}') #convert list formatting to vector formatting
         #if val_assign is a string
         elif(type_check == str):
             #check to ensure it is not a bool value
             if(val_assign == 'true' or val_assign == 'false'):
                 type_check = 'bool' #set type as bool
             else:
                 #val_assign could be equal to 'Hello' for example
                 val_assign = '"%s"' % val_assign #add speech marks around the value to allow string formatting
                 type_check = 'std::string' #specify the type to declare as std::string
         #for any other standard type, for example val_assign = 3.3, type_check = <class 'float'>
         else:
             pass
         #define the converted declaration as the type check (if a standard one then remove the <class ' and '> from the string of the type)
         #then the variable name and the value assigned to it, e.g. float test = 7.9
         converted_line = str(type_check).replace("<class '",'').replace("'>","") + ' %s = %s;' % (name_assign,val_assign)
 
         return converted_line #return the converted line
 
 #define a parser for number nodes
 class NumParser(ast.NodeVisitor):
     def visit_Num(self,node): #define function to visit the number node
         return node.n #return the number from the node
 
 #define a parser for a unary operator node
 class UnaryOpParser(ast.NodeVisitor):
     def visit_UnaryOp(self,node): #visit the unary operator node
         if(type(node.op) == ast.USub): #if the operator is a '-' to make a negative number
             num = NumParser().visit_Num(node.operand) #get the number (this will be the number without - operator)
             num_with_operator = -1*num #make the number negative
             return num_with_operator #return the negative number
         elif(type(node.op) == ast.UAdd): #if the operator is a '+' to make a positive number
             num = NumParser().visit_Num(node.operand) #get the number
             num_with_operator = np.abs(num) #take the absolute of it to make it positive
             return num_with_operator #return the number
 
 #define a parser for string nodes
 class StrParser(ast.NodeVisitor):
     def visit_Str(self,node): #visit the string node
         return node.s #return the string value
 
 #define a parser for list nodes
 class ListParser(ast.NodeVisitor):
     def visit_List(self,node): #visit the list node
         list_vals = [] #define list of the values
         for i in node.elts: #for each argument of the list
             #find the type and make any necessary conversions then append to the list values
             #if there is a nested list then the type will revisit this parser, e.g. list_Vals = [] to start
             #then a sub list vals is generated and values appended to it then return that sub list to
             #append to the original list_vals, e.g. [[2,3,4]]
             list_vals.append(general_access_node(i))
 
         return list_vals #return the completed list of values
 
 #define a parser for subscript nodes (taking indices or slices of lists)
 class SubscriptParser(ast.NodeVisitor):
     def visit_Subscript(self,node): #visit the subscript node
         list_slice = [] #list of parameters of the subscript to format
         name = node.value.id #the variable name the list has
         if(type(node.slice) == ast.Index): #if the type of subscripting is taking an index from the list
             index = general_access_node(node.slice.value) #get the value of the index, could be number or letter if in a loop process
             list_slice.append('index') #mark this was an index process for later conversion
             list_slice.append(name) #add the name to the parameters
             list_slice.append(index) #add the index value to the parameters
 
         elif(type(node.slice) == ast.Slice): #if type of subscripting is a slice
             lower_index = general_access_node(node.slice.lower) #get the value of the lower index of the list
             upper_index = general_access_node(node.slice.upper) #get the value of the upper index of the list
             list_slice.append('slice') #mark this was a slice for ater conversion
             list_slice.append(name) #add the name to the parameters
             list_slice.append(lower_index) #add the lower index to the parameters
             list_slice.append(upper_index) #add the upper index to the parameters
 
         else: #need to do extslice type here later
             pass #@todo ExtSlice
 
         return 'subscript',list_slice #return a marking that this is a subscript node and the values
 
 #parser for binary operator nodes
 class BinOpParser(ast.NodeVisitor):
     def visit_BinOp(self,node): #visit the binary operator node
         vals = [] #list for values either side of binary operator
         left_val = general_access_node(node.left) #determine the type and get the value of arguments left of the operator
         right_val = general_access_node(node.right) #determine the type and get the value of arguments right of the operator
 
         ast_ops = [ast.Add,ast.Sub,ast.Div,ast.Mult] #list of types of ast operators
         #@todo handle more operators
         c_ops = ['+','-','/','*'] #corresponding list  of C++ operators
         operator = node.op #get operator between the left and right vals
         try: #attempt to find the operator type from the ast operator list
             op_index = ast_ops.index(type(operator))
             operator = c_ops[op_index] #get the corresponding C++ operator
         except: #if no index found then raise a type error to flag that it needs handling
             raise TypeError('Binary operator type not handled yet: %s' % operator)
         vals.append(left_val) #append the left value
         vals.append(operator) #append the new C++ operator
         vals.append(right_val) #append the right value
         return vals #return the list of values
 
 #define a parser for expression nodes
 class ExprParser(ast.NodeVisitor):
     def visit_Expr(self,node): #visit the expression node
         global converted_lines, function_body, arg_vars #allow access to relevant globals
         line = general_access_node(node.value) #determine type and do any conversions for the argument of the expression
         #example line = ('print',[a,b,c])
         function = line[0] #the function of the expression
         #handle different inbuilt functions to convert to C++ versions
         #@todo more of these inbuilts
         if(function == 'print'): #if the expression is a print statement
             function = 'std::cout << ' #replace the function with the std::cout function which will have at least one argument
             args = line[1] #store the arguments of the function
             #iterate over the function arguments, this is to check if the argument is a variable or a string
             for j in range(0,len(args)):
                 #print(args)
                 args[j] = string_or_var(args[j])
 
             out_args = '' #string of output arguments
             for i in range(0,len(args)): #iterate over the number of arguments
                 out_args += args[i] + ' << ' #add the argument and ' << ' to the output string
             out_args += 'std::endl' #add an endline to the end of the string
 
             converted_line = function + out_args + ';' #make the converted line std::cout << arg1 << arg2 ... << std::endl;
 
         elif('.' in function): #check if the function is an attribute
             #this means it is an attribute that should have already been resolved
             #an example could be line = ('g.append(',[args_list])
             args = line[1] #store the args as the first element
             for j in range(0,len(args)): #iterate over the arguments
                 if(type(args[j]) == str):
                     args[j] = string_or_var(args[j])
 
                 elif(type(args[j]) == list): #if the argument type is a list
                     args[j] = str(args[j]).replace('[','{').replace(']','}') #convert argument to vector notation
                 else:
                     pass
             args_string = '' #define a blank string to make string of arguments
             for i in range(0,len(args)): #iterate over the arguments
                 args_string += str(args[i]) + ', ' #add the argument and ', ' to the arguments string
             args_string = args_string[:-2] #remoev the extra ', ' from the end
             converted_line = '%s%s);' % (function,args_string) #complete the converted line to gie e.g. g.push_back(9.9)
         else:
             #if made it this far the expression is treated as a function call
             #example line = ('function_name',[function_args])
             args = line[1] #store the arugments of the function call
             for j in range(0,len(args)): #iterate over the arguments
                 args[j] = string_or_var(args[j])
 
             out_args = '' #as before format final arguments string as comma separated
             for i in range(0,len(args)):
                 out_args += args[i] + ', '
             out_args = out_args[:-2]
             #define the converted line as function_name(funtion_args);
             converted_line = function + '(' + out_args + ')' + ';'
 
         return converted_line #return the converted line
 
 #define parser to handle function call nodes
 class CallParser2(ast.NodeVisitor):
     def visit_Call(self,node): #visit function call node
         func_type = general_access_node(node.func) #call to get the value of the name of the function being called
         args_list = [] #list for arguments of tbhe function
         for i in range(0,len(node.args)): #iterate over the arguments of the function
             #print(node.args[i])
             args_list.append(general_access_node(node.args[i])) #classify and extract the value of the arguments of the function
         if(func_type == 'len'): #special case for the len function as this is an attribute of .size() in C++, other special conditions can be coded in here
             converted_func = args_list[0] + '.size()' #e.g. if it was len(a) change to a.size()
             return converted_func #return the converted function
         else:
             pass
         return func_type, args_list #if special cases not met return the type of function and arguments list
 
 #define parser to handle return nodes
 class ReturnParser(ast.NodeVisitor):
     def visit_Return(self,node): #visit return node
         if(type(node.value) == None): #if it is a void return with no values return None
             return node.value
         else: #if it has values get the types and values it is meant to returning and return them
             args_list = general_access_node(node.value)
             return args_list
 
 #define parser to handle tuple nodes
 class TupleParser(ast.NodeVisitor):
     def visit_Tuple(self,node): #visit tuple node
         args_list = [] #define list of arguments
         for i in range(0,len(node.elts)): #iterate over the values in the tuple
             args_list.append(general_access_node(node.elts[i])) #get the type and subsequant value of each argument in the tuple
         return args_list #return a list of arguments
 
 #define parser to handle if statement nodes
 class IfParser(ast.NodeVisitor):
     def visit_If(self,node): #visit if statement node
         global converted_lines, top_level_if #have access to relevant globals
 
         if_block = [] #make a list of the if block
         condition = general_access_node(node.test) #convert the condition of the if statement analysing the node
         condition_string = '' #make a string of the condition statement
         for i in range(0,len(condition)): #iterate over the arguments of the condition, each should have already been converted to an appropriate format
             condition_string += str(condition[i]) + ' ' #add the condition arguments space separated
         condition_string = condition_string[:-1] #remove the extra space at the end
         if(top_level_if): #if this is the first if statement
             statement = 'if (%s) {' % condition_string #format it as opening if with the condition
             top_level_if = False #next if statement is not top level, i.e. there is an elif statement
         else: #if an elif statement is already present
             statement = 'else if (%s) {' % condition_string #format with else if instead
         if_block.append(statement) #append the statement to the if block
 
         for i in node.body: #iterate over the nodes in the body of the if block
             #there could potentially be more if statements nested inside the main if statement
             #the first nested ifs would need to be if and not elif , hence reset the flag to be top level
             top_level_if = True
             line = general_access_node(i) #convert the node to an appropriate format
             if_block.append(line) #append the line to the if_block
             top_level_if = False #flag top level back to false as nesting has finished
 
         if_block.append('}') #close the if statement block
 
         #check if the else block contains another if block (this occurs if an elif statement is used)
         if(node.orelse == [] or type(node.orelse[0]) != ast.If): #if no elif statement in if block
             if_block.append('else {') #append an else statement
         else:
             pass
 
         #@todo fix where an else if appears for the first if inside an else block
         #example problem:
         #else {
         #   else if (...) {
         #
         #   }
         #   else {
         #
         #   }
         #}
         for i in node.orelse: #iterate over the nodes in the else statement
             try: #if its an elif statement i.test will work else will run except
                 i.test
                 line = general_access_node(i) #convert line
                 if_block.append(line) #add line to if block
             except: #if fails deafult to top level if statement for any statement inside
                 top_level_if = True #mark top level
                 line = general_access_node(i) #get the type of line and convert
                 if_block.append(line) #append the line to the if block
                 top_level_if = False #reset top level to false
 
         #@todo figure out a better way to ensure correct number of closing braces
         if(if_block[-1][-1] == '}'): #check if all if statements got closed off
             pass
         else: #if not close off the final one
             if_block.append('}')
 
         top_level_if = True #reset top level back to true
 
         return if_block #return the converted if block
 
 #define parser for compare statement nodes, inside if blocks
 class CompareParser(ast.NodeVisitor):
     def visit_Compare(self,node): #visit the compare node
         left_arg = general_access_node(node.left) #store the left value of the argument
         #define the types of ast operators
         ast_ops = [ast.Eq,ast.NotEq,ast.Lt,ast.LtE,ast.Gt,ast.GtE,ast.Is,ast.IsNot,ast.In,ast.NotIn,ast.And,ast.Or]
         #define the corresponding c++ operators
         c_ops = ['==','!=','<','<=','>','>=','TODO','TODO','TODO','TODO','&&','||']
 
         #@todo handle the is and in operators for c++
         full_args = [] #list of full arguments from the compare statement
         full_args.append(left_arg) #append the left value argument to full arguments
         for i in range(0,len(node.ops)): #iterate over the number of operators for long chains of comparisons
             index = ast_ops.index(type(node.ops[i])) #get the index of match of the ast_ops
             c_op = c_ops[index] #get the corresponding c_op
             full_args.append(c_op) #append the c operator to the args
             value = general_access_node(node.comparators[i]) #get the value being compared to type and value
             if(type(value) == str): #if it is a string
                 value = string_or_var(value) #run check to see if it is string or variable
             else:
                 pass
             full_args.append(value) #append the value to the full args
 
         return full_args #return the full args
 
 #define parser for name nodes
 class NameParser(ast.NodeVisitor):
     def visit_Name(self,node): #visit name node
         name = node.id #get the name id
         return name #return the name
 
 #define parser for for loop nodes
 class ForParser(ast.NodeVisitor):
     def visit_For(self,node): #visit the for node
         global converted_lines
         iterator = general_access_node(node.target) #get the iterator of the loop
         condition = general_access_node(node.iter) #get the condition of the loop
         try: #check for a special condition of iterating over lines in an open file
             file = False #flag for whether this loop is accessing a file
             file_check = 'std::fstream %s;' % condition #check for declaration of file
             if(type(condition) != tuple): #will only be a file declaration if condition is not a tuple
                 for line in converted_lines: #iterate over converted lines to look for file declaration
                     if(type(line) == list):
                         for i in line:
                             if(i==file_check):
                                 file = True #if file declaration found flag as such
                                 break
                             else:
                                 pass
                     else:
                         if(line==file_check):
                             file = True #if file declaration found flag as such
                             break
                         else:
                             pass
             #this condition should be true for an iterative loop of type "for line in file:"
             if(type(condition) != tuple and file==True):
                 for_condition = [] #make a block for this type of for loop
                 declare_iterator = 'std::string %s;' % iterator #make iterator declaration
                 new_condition = "while (!%s.eof()) {" % condition #conver to a while loop to iterate over file
                 getline_string = "std::getline(%s,%s,'\\n');"% (condition,iterator) #get the line of the file
                 #append relevant statements to condition block
                 for_condition.append(declare_iterator)
                 for_condition.append(new_condition)
                 for_condition.append(getline_string)
                 for i in node.body: #for each node in the body
                     line = general_access_node(i) #classify and convert the line
                     if('std::cout << ' in line): #check if attempting to print something
                         splitup = line.split(' << ') #split on the args separator
                         for i in range(0,len(splitup)): #iterate over the split args
                             if(splitup[i] == ('"%s"' % iterator)): #check if the arg is the iterator which has falsely been converted in to a string
                                 splitup[i] = iterator #if false conversion made switch out for iterator
                                 line = ' << '.join(splitup) #rejoin the line
                             else: #if no false string pass
                                 pass
                     elif('push_back' in line): #check if attempting to append something to a list
                         if(('push_back("%s")' % iterator) in line): #if iterator being pushed back after false conversion to a string replace the string with the iterator
                             line = line.replace(('push_back("%s")' % iterator), ('push_back(%s)' % iterator))
                         else:
                             pass
                     for_condition.append(line) #convert the node and append it to the block
                 for_condition.append('}') #close the for brace
                 return for_condition #return this special case loop
             else:
                 pass
         except: #if fails condition is not true anyway
             pass
         #e.g. of condition = ('range'[0,list_name.size()]) or number equivalent
         if(condition[0] == 'range'):
             lower_limit = condition[1][0] #lower limit of range
             upper_limit = condition[1][1] #upper limit of range
             #write the condition of the for loop incrementing in the range
             if(upper_limit==0): #if the upper limit is 0, e.g. range(10,0)
                 #make the for condition iterate backwards from the "lower" limit (with higher value) to "upper" limit (value 0)
                 for_condition = 'for (int %s = %s; %s > %s; %s--) {' % (iterator,lower_limit,iterator,upper_limit,iterator)
             elif(isinstance(upper_limit,int) and isinstance(lower_limit,int) and upper_limit<lower_limit): #if both limits are numbers (not a len function) and upper has lower value than lower
                 #make the for condition iterate backwards from the "lower" limit (with higher value) to "upper" limit (lower value)
                 for_condition = 'for (int %s = %s; %s > %s; %s--) {' % (iterator,lower_limit,iterator,upper_limit,iterator)
             else: #otherwise assume forwards iteration
                 for_condition = 'for (int %s = %s; %s < %s; %s++) {' % (iterator,lower_limit,iterator,upper_limit,iterator)
         elif(condition[0] == 'reversed'):
             #condition will be in format ('reversed',[('range',[0,5])])
             #take limits opposite way round as they are in a reversed function
             upper_limit = condition[1][0][1][0]
             lower_limit = condition[1][0][1][1]
             if(upper_limit==0): #conditions are as above but reversed
                 for_condition = 'for (int %s = %s; %s > %s; %s--) {' % (iterator,lower_limit,iterator,upper_limit,iterator)
             elif(isinstance(upper_limit,int) and isinstance(lower_limit,int) and lower_limit>upper_limit):
                 for_condition = 'for (int %s = %s; %s > %s; %s--) {' % (iterator,lower_limit,iterator,upper_limit,iterator)
             else:
                 for_condition = 'for (int %s = %s; %s < %s; %s++) {' % (iterator,lower_limit,iterator,upper_limit,iterator)
         else: #if line was for x in list_name, the condition will be (list_name)
             vector = condition
             #format for condition
             for_condition = 'for (auto %s: %s) {' % (iterator,vector)
 
         body_block = [] #define body of for loop
         body_block.append(for_condition) #append the for condition to the body
         for i in node.body: #for each node in the body
             line = general_access_node(i) #classify and convert the line
             if('std::cout << ' in line): #check if attempting to print something
                 splitup = line.split(' << ') #split on the args separator
                 for i in range(0,len(splitup)): #iterate over the split args
                     if(splitup[i] == ('"%s"' % iterator)): #check if the arg is the iterator which has falsely been converted in to a string
                         splitup[i] = iterator #if false conversion made switch out for iterator
                         line = ' << '.join(splitup) #rejoin the line
                     else: #if no false string pass
                         pass
             elif('push_back' in line):
                 if(('push_back("%s")' % iterator) in line):
                     line = line.replace(('push_back("%s")' % iterator), ('push_back(%s)' % iterator))
                 else:
                     pass
             body_block.append(line) #convert the node and append it to the block
         body_block.append('}') #close the for brace
         return body_block #return the body
 
 #define parser for attribute nodes
 class AttributeParser(ast.NodeVisitor):
     def visit_Attribute(self,node): #visit the attribute node
         attribute = node.attr #gives the function being applied, e.g for a.append, returns append
         value = general_access_node(node.value) #classify and convert the object being appended
         #print(attribute,value)
         if(attribute=='append'): #if the atrribute is append
             attribute = 'push_back' #replace with vector push_back method
         elif(value=='self'): #if not raise a type error to flag this attribute is not yet handled
             #converted_line = '%s.%s' % (value,attribute)
             return attribute
             #return None
             #raise TypeError('Attribute type not handled yet: %s,%s' % (attribute,value))
         else:
             pass
 
         converted_line = '%s.%s(' % (value,attribute) #define the converted line
         return converted_line #return the converted line
 
 #define parser for while nodes
 class WhileParser(ast.NodeVisitor):
     def visit_While(self,node): #visit while node
         while_body = [] #define while block
         condition = general_access_node(node.test) #convert the while condition
         condition_string = '' #define string for the condition
         for i in condition: #iterate over the elements in the condition list
             condition_string+=str(i)+' ' #add the condition element and a space
         condition_string = condition_string[:-1] #remove the extra space
         condition_line = 'while (%s) {' % condition_string #define the while statement
         while_body.append(condition_line) #append the while statement to the block
         for i in node.body: #iterate over nodes in the body of the while loop
             line = general_access_node(i) #classify and convert the node
             while_body.append(line) #append the converted line to the block
         while_body.append('}') #close the while loop
         #@todo handle the orelse node
         return while_body #return the while block
 
 #define parser for AugAssign nodes
 class AugAssignParser(ast.NodeVisitor):
     def visit_AugAssign(self,node): #visit AugAssign nodes
         var = general_access_node(node.target) #get the variable value is assigned to
         ast_operators = [ast.Add,ast.Sub,ast.Div,ast.Mult] #define list of ast operators
         c_ops = ['+=','-=','/=','*='] #define corresponding list of c++ operators
         index = ast_operators.index(type(node.op)) #get the index matching the operator
         operator = c_ops[index] #get the correspoding c++ operator to the matched operator
         value = general_access_node(node.value) #classify and convert the value node
         converted_line = '%s %s %s;' % (var,operator,value) #format the aug assign string
         return converted_line #return the converted line
 
 #define parser for name constant nodes
 class NameConstantParser(ast.NodeVisitor):
     def visit_NameConstant(self,node): #visit name constant node
         #node.value should be True False or None
         if(node.value == True): #if True return C++ bool true
             return 'true'
         elif(node.value == False): #if false return C++ bool false
             return 'false'
         else: #if none flag not handled yet
             raise TypeError('NameConstant not true or false and not handled : %s' % node.value)
 
 #define function to check if a value is a string or a variable as they are classified the same by the AST
 def string_or_var(value):
     global converted_lines, arg_vars, function_body, class_args #have access to relevant globals
     found = False #flag no match found
     #iterate backwards over converted lines looking for a match, backwards to get most recent definition
     for i in reversed(range(0,len(converted_lines))):
         declaration_check = '%s = ' % value #look for declaration of variable
         if(declaration_check not in converted_lines[i]): #if not match pass
             pass
         else: #if match flag a match found
             found = True
             break
     #if there is a function under conversion not yet appended and no match found
     if(arg_vars != [] and found == False):
         for i in range(0,len(arg_vars)): #iterate over the function arguments
             if(value not in arg_vars[i]): #if no match pass
                 pass
             else: #if match flag a match was found
                 found = True
                 break
     else:
         pass
     #if there is a function under conversion not yet appended and no match found
     if(function_body != [] and found == False):
         for i in reversed(range(0,len(function_body))): #iterate backwards over function body to get most recent definition
             declaration_check = '%s = ' % value #look for declaration of variable
             if((converted_lines==[]) or declaration_check not in converted_lines[i]): #if no match pass
                 pass
             else: #if match flag that a match was found
                 found = True
                 break
 
     #if there is an active class check for a match in its declarated arguments
     if(class_args != [] and found == False):
         for i in range(0,len(class_args)): #iterate over class args to check for match
             declaration_check = '%s' % value #look for declaration of variable
             if((class_args==[]) or declaration_check not in class_args[i]): #if no match pass
                 pass
             else: #if match flag that a match was found
                 found = True
                 break
 
 
     if(found==False):
         #print(converted_lines)
         second_declare = ' %s;' % value
         for i in reversed(range(0,len(converted_lines))):
             for j in range(0,len(converted_lines[i])):
                 if(second_declare not in converted_lines[i][j]): #if not match pass
                     pass
                 else: #if match flag a match found
                     found = True
                     break
 
     if(found == False and value != 'true' and value != 'false'): #if no match default to string
         value = '"%s"' % value
     else:
         pass
     #if match will return the same value therefore a variable, if no match it will put speech marks around for c++ string definition
     return value
 
 #this functions purpose is to receive any node and determine it's type
 #once determined the node will be passed to an appropriate parsing function or directly
 #handle the node for some simple cases then return the value of the node after it has
 #been parsed and converted by the parser it sent it to
 def general_access_node(node):
     #check the type of the node and compare to currently handled type
     if(type(node) == ast.FunctionDef):
         #store the value of the return from the parsed node after sending it to be decoded
         parsed_node = FunctionParser().visit_FunctionDef(node)
     elif(type(node) == ast.Assign):
         parsed_node = AssignParser().visit_Assign(node)
     elif(type(node) == ast.Expr):
         parsed_node = ExprParser().visit_Expr(node)
     elif(type(node) == ast.If):
         parsed_node = IfParser().visit_If(node)
     elif(type(node) == ast.For):
         parsed_node = ForParser().visit_For(node)
     elif(type(node) == ast.Num):
         parsed_node = NumParser().visit_Num(node)
     elif(type(node) == ast.Str):
         parsed_node = StrParser().visit_Str(node)
     elif(type(node) == ast.UnaryOp):
         parsed_node = UnaryOpParser().visit_UnaryOp(node)
     elif(type(node) == ast.Subscript):
         parsed_node = SubscriptParser().visit_Subscript(node)
     elif(type(node) == ast.Call):
         parsed_node = CallParser2().visit_Call(node)
     elif(type(node) == ast.Return):
         parsed_node = ReturnParser().visit_Return(node)
     elif(type(node) == ast.Tuple):
         parsed_node = TupleParser().visit_Tuple(node)
     elif(type(node) == ast.List):
         parsed_node = ListParser().visit_List(node)
     elif(type(node) == ast.Compare):
         parsed_node = CompareParser().visit_Compare(node)
     elif(type(node) == ast.Name):
         parsed_node = NameParser().visit_Name(node)
     elif(type(node) == ast.Pass):
         parsed_node = '\n'
     elif(type(node) == ast.Attribute):
         parsed_node = AttributeParser().visit_Attribute(node)
     elif(type(node) == str):
         parsed_node = node
     elif(type(node) == ast.While):
         parsed_node = WhileParser().visit_While(node)
     elif(type(node) == ast.AugAssign):
         parsed_node = AugAssignParser().visit_AugAssign(node)
     elif(type(node) == ast.NameConstant):
         parsed_node = NameConstantParser().visit_NameConstant(node)
     elif(type(node) == ast.ClassDef):
         parsed_node = ClassDefParser().visit_ClassDef(node)
     elif(type(node) == ast.Break):
         parsed_node = 'break;'
     else: #if the type of node does not yet have a parser raise a type error which diesplays the type to know what parser needs to be made next
         raise TypeError('Parser not found for type: %s' % type(node))
 
     return parsed_node #return the parsed/converted node value
 
 #define the main function for parsing and converting a script,takes arguments of the name of a python script and the name of a script with example function calls
 def main(script_to_parse,script_of_function_calls=None):
     global converted_lines, list_types #make globals of the converted lines and function argument types
     list_types = [] #define list of function types from script of function calls
     converted_lines = [] #define list of converted C++ lines
     #if a script of cuntion calls has been provided analyse it for types, if not then no functions are defined in the python script
     if(script_of_function_calls!=None):
         file2 = open(script_of_function_calls,'r').read() #open and read the script of function calls specified
         call_parse = ast.parse(file2) #parse the script to make an AST of nodes
         for node in call_parse.body: #iterate over the nodes in the body of the tree
             funcs_args = [] #define list of the arguments of current function in the tree
             for arg in node.value.args: #iterate over the arguments in the function currently active
                 arg_val = general_access_node(arg) #get the value of the argument
                 #run through a series of checks to determine the type of the argument provided
                 #once a match is found append the appropriate type to the current function's arguments type list
                 if isinstance(arg_val,int):
                     funcs_args.append('int')
                 elif isinstance(arg_val,float):
                     funcs_args.append('float')
                 elif isinstance(arg_val,str):
                     funcs_args.append('std::string')
                 elif isinstance(arg_val,list): #if the argument is a list it needs special handling
                     inside_level = arg_val[0] #get the first element of the list to check if it contains more lists
                     nest_level = 1 #increase the nest level by one
                     if isinstance(inside_level,list): #if the first element is a list
                         inside_level = inside_level[0] #take the first element of the sub list
                         nest_level+=1 #increase the nest level by one
                         while(isinstance(inside_level,list)): #if still a sub list then repeat this process until the first non list element is found
                             inside_level = inside_level[0]
                             nest_level+=1
                         type_check = type(inside_level) #get the type of the first non list element
 
                     else: #if not a list of lists get the type of the first element
                         type_check = type(inside_level)
                     #define the type of list, nest level is used to determine the number of vector commands to nest
                     #for example the list [[2,3,4],[5,6,7]] would have nest_level = 2 and type_check = <class 'int'>
                     #so the below code would format type_list = <std::vector<std::vector<int>>
                     type_list = ('std::vector<'*nest_level)+str(type_check).replace("<class '",'').replace("'>",'') + ('>'*nest_level)
                     funcs_args.append(type_list) #append this vector definition to the function's arguments
             list_types.append(funcs_args) #append the completed funtion arguments type list to the list of type lists
     else: #if no function calls skip this process
         pass
 
     file = open(script_to_parse,'r').read() #open the python file to convert and read it
     tree = ast.parse(file) #make an AST of the nodes within the file
     main = False #flag that a main function has not yet been added to the converted script
     for node in tree.body: #iterate over the nodes in the body of the AST
         line_test = general_access_node(node) #run function to determine the type of the node and convert it accordingly
         #if the line had a function definition it has already been added to converted lines so this condition is added to stop duplicate addition, these are the conditions that will be met if that is true
         #print(line_test[0])
         if(('auto' in line_test[0] and '{' in line_test[0]) or ('class' in line_test[0] and '{' in line_test[0])):
             pass
         else: #if it is not a function definition
             if(main==False): #check if a main has been added yet
                 converted_lines.append('int main () {') #if no main start the main function here as function definitions have finished
                 main=True #flag that a main has been added
             else: #if main has been added do not add it again
                 pass
         #check to see if the returned value has already been added to the converted lines and the return was not a void one
         #if it is not a NoneType return and has not yet been added to converted lines then add it
         #modified to check if the line was just appended to the converted lines list, may cause issue if you write the same line twice in a row, untested
         #if(line_test != converted_lines[len(converted_lines)-1] and line_test != None):
         converted_lines.append(line_test)
         #else: #if it has been addded or is NoneType do nothing
          #   pass
     converted_lines.append('return 0;') #add a return for the c++ main function
     converted_lines.append('}') #close the main function
     #below are checks to see what include statements are needed for the c++ code
     #each one will chec for an instance of a function and if a match is found the appropriate
     #include statement will be inserted in to the top of the converted lines list
     if(('std::cout' in line for line in converted_lines) or ('std::cin' in line for line in converted_lines)):
         converted_lines.insert(0,'#include <iostream>')
     else:
         pass
     if('std::string' in line for line in converted_lines):
         converted_lines.insert(0,'#include <string>')
     else:
         pass
     if('std::vector' in line for line in converted_lines):
         converted_lines.insert(0,'#include <vector>')
     else:
         pass
     if('std::fstream' in line for line in converted_lines):
         converted_lines.insert(0,'#include <fstream>')
     else:
         pass
     return converted_lines #return the list of converted c++ lines
 
 #function to check if line is list or list of lists and convert in to flattened data
 def walk(e):
     if(type(e) == list): #if the line is a list
         for v2 in e: #iterate over list elements
             for v3 in walk(v2): #iterate over sub list elements (which will iterate further if another sublist)
                 yield v3 #yield the non list element
     else: #if line not a list
         yield e #return the line
 
 #function to write the parsed data to an output .cpp file
 def write_file(data,name_of_output='Output.cpp'):
     file = open(name_of_output,'w+') #open an output file to the specified path for writing/creation
     indentation_level=0 #default indentation level is 0
     public_open = False
     flatten = [] #create a list of flattened line data
     for line in walk(data): #call walk function on converted data
         flatten.append(line) #append the flattened line to the flattened data
 
     for line in flatten: #iterate over the lines in the flattened data
         #print(line,indentation_level)
         if(public_open==True and ('auto' in line or '};' in line)):
             indentation_level-=1
             public_open=False
         else:
             pass
         open_brace_count = line.count('{') #count number of open brackets on the line
         close_brace_count = line.count('}') #count number of closing brackets on the line
         if(open_brace_count>close_brace_count):
             #if more open brackets than close, the code following (not including) this line
             #will require indentation, as such write this line and the increase the indentation level for subsequent lines
             file.write(('\t'*indentation_level)+line+'\n')
             indentation_level+=1
         elif(open_brace_count<close_brace_count):
             #if more close brackets than open brackets, the code following is outside of the
             #function block, as such will need indentation level reduced by one, this includes the closing brace this time
             #hence the reverse order to the condition above
             indentation_level-=1
             file.write(('\t'*indentation_level)+line+'\n')
         elif('public:' in line):
             file.write(('\t'*indentation_level)+line+'\n')
             indentation_level+=1
             public_open = True
         else: #if number of braces equal then do not change indentation level
             file.write(('\t'*indentation_level)+line+'\n')
 
     file.close() #writing completed so close the file
 
 if __name__ == '__main__':
     top_level_if = True #flag for if statments, method needs revision
     list_spiel = True #flag for displaying extra information about empty lists
     class_vars_for_call = []
     called_objs = []
     print('Beginning Parsing') #inform user parsing has began, precaution incase a large file takes a long time parsing
     converted_data = main('Test.py','CallTest.py') #parse Test.py file, function call examples are listed in CallTest.py, if no function calls do not pass second argument
     print('Parsing Completed') #inform user parsing has finished
     print('Writing File') #inform user output to file has started
     write_file(converted_data,'Test.cpp') #write a file called Test.cpp with the output data, if no name specified will default to Output.cpp
     print('Writing Completed') #inform user writeout completed