haiku.git

/*
 * Copyright (c) 2003 Matthijs Hollemans
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a 
 * copy of this software and associated documentation files (the "Software"), 
 * to deal in the Software without restriction, including without limitation 
 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 
 * and/or sell copies of the Software, and to permit persons to whom the 
 * Software is furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in 
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
 * DEALINGS IN THE SOFTWARE.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "rdef.h"
#include "private.h"

ptr_list_t include_dirs;
ptr_list_t input_files;

uint32 flags = 0;

status_t rdef_err;
int32 rdef_err_line;
char rdef_err_file[B_PATH_NAME_LENGTH];
char rdef_err_msg[1024];


void
free_ptr_list(ptr_list_t &list)
{
	for (ptr_iter_t i = list.begin(); i != list.end(); ++i) {
		free(*i);
	}

	list.clear();
}


int32
rdef_get_version()
{
	return 2;
}


status_t
rdef_add_include_dir(const char *dir, bool toEndOfList)
{
	clear_error();

	char *path = (char *)malloc(strlen(dir) + 2);
	if (path == NULL) {
		rdef_err = B_NO_MEMORY;
		return B_NO_MEMORY;
	}

	strcpy(path, dir);
	strcat(path, "/");

	if (toEndOfList)
		include_dirs.push_back(path);
	else
		include_dirs.push_front(path);

	return B_OK;
}


status_t
rdef_remove_include_dir(const char *dir)
{
	size_t length = strlen(dir);
	bool noSlash = false;
	if (dir[length - 1] != '/')
		noSlash = true;

	for (ptr_iter_t i = include_dirs.begin(); i != include_dirs.end(); ++i) {
		char *path = (char *)*i;

		if (!strncmp(dir, path, length)
			&& path[length + (noSlash ? 1 : 0)] == '\0') {
			// we found the entry in the list, let's remove it
			include_dirs.erase(i);
			free(path);
			return B_OK;
		}
	}

	return B_ENTRY_NOT_FOUND;
}


void
rdef_free_include_dirs()
{
	free_ptr_list(include_dirs);
}


status_t
rdef_add_input_file(const char *file)
{
	clear_error();

	char *temp = strdup(file);
	if (temp == NULL) {
		rdef_err = B_NO_MEMORY;
		return B_NO_MEMORY;
	}

	input_files.push_back(temp);
	return B_OK;
}


void
rdef_free_input_files()
{
	free_ptr_list(input_files);
}


void
rdef_set_flags(uint32 flags_)
{
	flags = flags_;
}


void
rdef_clear_flags()
{
	flags = 0;
}


void 
clear_error()
{
	rdef_err = B_OK;
	rdef_err_line = 0;
	rdef_err_file[0] = '\0';
	rdef_err_msg[0] = '\0';
}


bool
open_file_from_include_dir(const char *filename, char *outname)
{
	for (ptr_iter_t i = include_dirs.begin(); i != include_dirs.end(); ++i) {
		char tmpname[B_PATH_NAME_LENGTH];
		strcpy(tmpname, (char *)*i);
		strcat(tmpname, filename);

		if (access(tmpname, R_OK) == 0) {
			strcpy(outname, tmpname);
			return true;
		}
	}

	return false;
}