def test_with_cpp(self):
     ast = parse_file('c_files/memmgr.c', use_cpp=True,
         cpp_path=CPPPATH,
         cpp_args=r'-I../utils/fake_libc_include')
     self.failUnless(isinstance(ast, c_ast.FileAST))
 
     ast2 = parse_file('c_files/year.c', use_cpp=True,
         cpp_path=CPPPATH, 
         cpp_args=r'-I../utils/fake_libc_include')
 
     self.failUnless(isinstance(ast2, c_ast.FileAST))

 def test_with_cpp(self):
     c_files_path = os.path.join('tests', 'c_files')
     ast = parse_file(self._find_file('memmgr.c'), use_cpp=True,
         cpp_path=CPPPATH,
         cpp_args='-I%s' % c_files_path)
     self.failUnless(isinstance(ast, c_ast.FileAST))
 
     ast2 = parse_file(self._find_file('year.c'), use_cpp=True,
         cpp_path=CPPPATH, 
         cpp_args=r'-Iutils/fake_libc_include')
 
     self.failUnless(isinstance(ast2, c_ast.FileAST))

def get_func_decls(filename, args):
    cpp_args = s_cpp_args(args)
    if args.cpp.lower() == "none":
        ast = parse_file(filename)
    else:
        ast = parse_file(filename,
                use_cpp=True,
                cpp_path=os.path.join(os.path.dirname(__file__), "fake_cpp"),
                cpp_args=cpp_args)
    v = FuncDeclVisitor()
    for idx, node in ast.children():
        v.visit(node)
    return v._ret

    def test_with_cpp(self):
        memmgr_path = self._find_file('memmgr.c')
        c_files_path = os.path.dirname(memmgr_path)
        ast = parse_file(memmgr_path, use_cpp=True,
            cpp_path=CPPPATH,
            cpp_args='-I%s' % c_files_path)
        self.assertTrue(isinstance(ast, c_ast.FileAST))

        fake_libc = os.path.join(c_files_path, '..', '..',
                                 'utils', 'fake_libc_include')
        ast2 = parse_file(self._find_file('year.c'), use_cpp=True,
            cpp_path=CPPPATH,
            cpp_args=[r'-I%s' % fake_libc])

        self.assertTrue(isinstance(ast2, c_ast.FileAST))

def translate_to_c(filename):
    """ Simply use the c_generator module to emit a parsed AST.
    """
    ast = parse_file(filename, use_cpp=True)
    generator = c_generator.CGenerator()
    ast.show()
    print(generator.visit(ast))

def create_test_case(ppcg_input_file, ppcg_output_files):   
    assert len(ppcg_output_files) == 1, "Currently support OpenCL only for VOBLA"     
    # Remove PENCIL qualifiers from C code otherwise it will not parse
    remove_pencil_qualifiers_from_file(ppcg_input_file)                      
    # Pre-process and parse the file               
    ast = pycparser.parse_file(ppcg_input_file, use_cpp=True)
    gen = c_generator.CGenerator()
    gen.visit(ast)
    # Find PENCIL function declarations
    pencil_info = FuncDeclVisitor()
    pencil_info.visit(ast)
    # Find struct definitions
    struct_info = StructDefintionVisitor()
    struct_info.visit(ast)
    # We need the struct and function prototypes to dump in the test file
    ast_new_file = copy_ast_declarations(pencil_info, struct_info)
    # Analyse the types of parameters in each PENCIL function
    for function_name in pencil_info.functions.keys():
        for formal_param in pencil_info.get_formal_params(function_name):            
            decorate_formal_params(formal_param, struct_info)
    # Create a main function that will call the PENCIL functions
    main_func = create_main(pencil_info)
    ast_new_file.ext.append(main_func)
    # Write the program to a file
    test_file = write_to_file(ast_new_file, ppcg_input_file)
    # Compile the code
    binary = compile_test_case(test_file, ppcg_output_files[0])
    return binary
    

def translate(filename, args, portion=None):
    try:
        ast = pycparser.parse_file(filename, use_cpp=True)

        et_obj = EnumTranslator(ast, args.enum, args.output_class)
        translate_params = {
            'import_line': args.importline,
            'header': args.header,
            'comment': args.comment,
            'hash_type': 'SHA-1',
            'hash_value': sha1sum(args.header),
            'portion': portion
        }

        et_obj.translate(translate_params, args.stop)
    except pycparser.plyparser.ParseError as exc:
        eprint('Translation error, try to use -p option with proper '
               'boundaries')
        eprint(exc)
        return
    except TypeError:
        eprint('Translation error, try to use -s option with a stop '
               'enumerator parameter')
        return

    if args.output:
        with open(args.output, 'w') as ftw:
            et_obj.write(ftw)
    else:
        et_obj.write()

def generate_xml(filename):
    ast = parse_file(filename, use_cpp=True)
    visitor = FuncDeclVisitor()
    print '<?xml version="1.0" encoding="UTF-8"?>'
    print "<blas_functions>"
    visitor.visit(ast)
    print "</blas_functions>"

def show_decl_file(filename):
    ast = parse_file(filename, use_cpp=True)
    v = FuncDefVisitor()
    v.visit(ast)
    v = TypeDeclVisitor()
    v.visit(ast)
    printTypes()

def generate_test_app():
    c_file = os.path.join(test_app_dir, 'pycparser_main.c')
    ast = parse_file(c_file,
                     use_cpp=True,
                     cpp_path=os.path.join(os.environ.get('XMOS_TOOL_PATH'),
                                           'bin', 'xcc'),
                     cpp_args=['-E',
                               '{}{}'.format('-I',
                                             os.path.join('..','lib_xcore_c','api')),
                               '{}{}'.format('-I',
                                             os.path.join('..','lib_xcore_c','src')),
                               '{}{}'.format('-I',
                                             os.path.join('..','..','lib_trycatch','lib_trycatch','api')),
                               '{}{}'.format('-I',
                                             os.path.join('..','..','lib_trycatch','lib_trycatch','src')),
                               '{}{}'.format('-I',
                                             os.path.join('..','..','lib_xassert','lib_xassert','api'))
                              ]
                    )

    functions = LibraryFunctionExtractor()
    function_call_blocks = functions.get_function_call_blocks(ast)

    with open(os.path.join(test_app_dir, 'test.c'), "w") as test_c_file:
        test_c_file.writelines(file_top)
        test_c_file.writelines(function_call_blocks)
        test_c_file.writelines(file_bottom)

def show_func_defs(filename):
    # Note that cpp is used. Provide a path to your own cpp or
    # make sure one exists in PATH.
    ast = parse_file(filename, use_cpp=True)

    v = FuncDefVisitor()
    v.visit(ast)

def translate_to_go(filename):

    firstname = filename 
    if "." in filename:
      firstname = filename.rsplit(".", 1)[0]

    clearlog()

    f = open(filename)
    data = f.read()
    f.close()

    data = cleanup(data)
   
    #filename = tempfile.mkstemp()[1]
    filename2 = "/tmp/jeje"

    f = open(filename2, "w")
    f.write(data)
    f.close()

    try:
        ast = parse_file(filename2, use_cpp=True)
    except plyparser.ParseError as e:
        print("Could not parse %s:" % (filename))
        print("line " + "".join(str(e).split(":", 1)[1:]))
        return
    generator = GoGenerator()
    s = generator.visit(ast)
    s = generator.fix_int_to_bool(s)
    s = generator.last_minute_replacements(s, firstname)
    s = generator.make_header() + s

    print(s)

def parse_header(filename):
    return parse_file(filename,
                      use_cpp=True,
                      cpp_args=[
                        r'-I{}'.format(os.path.dirname(filename)),
                        r'-I{}'.format(FAKE_LIBC_INCLUDE_DIR),
                        r'-D_DOXYGEN_ONLY_'])

def show_func_defs(filename):
    # Note that cpp is used. Provide a path to your own cpp or
    # make sure one exists in PATH.
    ast = parse_file(filename, use_cpp=True, cpp_args=r"-Iutils/fake_libc_include")

    v = FuncDefVisitor()
    v.visit(ast)

def translate(filename):
    ast = parse_file(filename,
        use_cpp=True,
        cpp_path='gcc',
        cpp_args=[
            "-E",
            "-D__FBSDID(x)=", # FreeBSD identifier
            "-D__attribute__(x)=", # attribute extension
            "-D__builtin_va_list=void*", # include/x86/_types.h:154 typedef __builtin_va_list   __va_list; 
            "-D__inline=",
            "-D__asm(x)=",

            "-D_RUNETYPE_H_=1", # skip include/runtype.h
            "-D_RuneLocale=void*", # but it defines this type

            "-D_Noreturn=",

            "-U__BLOCKS__", # no (^) syntax: include/stdlib.h: int  atexit_b(void (^)(void));
            "-U__nonnull", # avoid __nonnull redefinition

            "-nostdinc",
            "-Ipycparser/utils/fake_libc_include",
            "-Iinclude", # copy from /usr/include
            ])
    generator = js_generator.JavaScriptGenerator()
    print(generator.visit(ast))

def create_func_defs(filename):
    ast = parse_file(filename, use_cpp=True)

    v = FuncDeclVisitor()
    v.visit(ast)

    return v.buffer

def generate(filename, origin_path, gen_path):
	ast = parse_file(os.path.join(origin_path, filename), use_cpp=True, 
		cpp_path='gcc', 
		cpp_args=['-E', r'-D' + CSMITH_MINIMAL_MACRO, r'-I' + CSMITH_RUNTIME, r'-I' + FAKE_SYS_LIB])
	# parser = c_parser.CParser()
	# ast = parser.parse(code)

	# construct an error label
	checkpoint = c_ast.FuncCall(c_ast.ID('__VERIFIER_error'), None)
	error_label = c_ast.Label("ERROR", checkpoint)

	num_ext_children = len(ast.ext)
	print("## num of ext children: " + str(num_ext_children))
	funcs = findAllFuncDef(ast)

	for picked in funcs:
		# picked = random.randint(0, len(funcs)-1)
		seed_fun = funcs.index(picked)
		print("## Function picked: " + str(seed_fun))
		seed = ast.ext.index(picked)
		print("## Seed: " + str(seed))

		numInsert = algo.countAllInsertion(ast.ext[seed].body, 0)
		print("$$$$$ numInsert is " + str(numInsert))
		for i in range(1, numInsert+1):
			ast_new = copy.deepcopy(ast)
			ast_new.ext[seed].body = checkpoint_insert_if(ast_new.ext[seed].body, i, error_label)
			code = c_generator.CGenerator().visit(ast_new)
			code_new = removeNonSupport(code)
			basename = filename
			basename_gen, file_extension = os.path.splitext(basename)
			filename_gen = gen_path + basename_gen + postfix + str(seed_fun) + '-' + str(i) + file_extension
			# print "hhhhhhhhhhhhhhhhh" + basename_gen 
			dumpToFile(filename_gen, code_new)
			print("## Generate: " + filename_gen)

def _get_imp_funcs(c_fpath):
    """Gets the functions that can be imported from a C file."""

    # gets the path of the fake system headers
    fsh_path = os.path.join(__path__[0], 'pycparser', 'fake_libc_include')

    # TODO: USE THE cpp.py MODULE TO PREPROCESS THE FILE

    # gets the AST
    ast = pycparser.parse_file(c_fpath, use_cpp=c_fpath, cpp_args=['-I', fsh_path])
    
    # function definition info collector class
    class FuncDefVisitor(pycparser.c_ast.NodeVisitor):
        def __init__(self):
            pycparser.c_ast.NodeVisitor.__init__(self)
            self.func_names = []
        def visit_FuncDef(self, node):
            self.func_names.append(node.decl.name)

    # gets the function definition info
    v = FuncDefVisitor()
    v.visit(ast)

    # returns the function definition info
    return v.func_names

def process_file(filename, incpath):
	cppargs = ["-Iutils/fake_libc_include", "-I%s" % incpath,
			"-DDECLSPEC=",
			"-D_SDL_platform_h=1",
			"-D_SDL_endian_h=1",
			"-DSDL_FORCE_INLINE=", "-D__attribute__(x)=",
	];
	ast = parse_file(filename, use_cpp=True, cpp_args=cppargs);
	v = visitor();
	v.visit(ast);

	del ast;

	cppargs.append("-dM");
	defines_text = preprocess_file(filename, cpp_args=cppargs);
	for s in defines_text.split("\n"):
		if s[:8] == "#define ":
			s = s[8:];
			m = re.search("(SDL_[A-Za-z0-9_]+)", s);
			if m != None:
				d = m.group(0);
				if isinstance(d, str) and len(d) > 4 and d == d.upper():
					v.defines.append(d);

	generate_output("sdl2.vim", v);

def parse_jamaica_output(filename, includepath = None):
	"""
	Use pycparser to parse a Jamaica output file.
	Because Jamaica's output is pretty complex, cpp is required, and even still 
	some features have to be removed because it uses GCC extensions unsupported by pycparser.
	Returns a pycparser.c_ast or throws ParseError
	
	If includepath is None then the project include files are used for parsing. Else, an absolute
	path to alternate includes can be provided.
	"""
	if '*' in filename:
		filename = deglob_file(filename)
	
	cppargs = ['-E', 
			   '-DNDEBUG', #Disable Jamaica debug support 
			   '-U__GNUC__', #Prevents use of __attribute__, will cause an "unsupported compiler" #warning
			   #'-W#warnings', #And this hides that warning
			   '-DJAMAICA_NATIVE_TIME_GET_HIGH_RESOLUTION_TIMESTAMP', #These use volatile asm() which is not supported by pycparser
			   '-DJAMAICA_NATIVE_THREAD_COMPARE_AND_SWAP',
			   '-D__CAICOS__', #So we can tell if we are being parsed by caicos
			   r'-I' + project_path("stdlibheaders"), #Override stdlib headers with blank versions (Jamaica builder doesn't use them, but includes them)
			   ]
	
	if includepath == None: 
		cppargs.append(r'-I' + project_path("projectfiles", "include"))
	else: 
		cppargs.append(r'-I' + str(includepath))
	
	return pycparser.parse_file(filename, use_cpp=True, cpp_path="gcc", cpp_args=cppargs)